Rejig everything

bin/generate-params.hs

@@ -1,7 +1,7 @@
 #!/usr/bin/runhaskell
 
 -- This can be run with e.g.:
--- runhaskell generate-params.hs > ../src/Sound/Tidal/Params.hs
+-- runhaskell generate-params.hs > ../tidal-params-dirt/src/Sound/Tidal/Params/Dirt.hs
 
 import           Data.Function
 import           Data.List

bin/params-header.hs

@@ -1,12 +1,14 @@
-module Sound.Tidal.Params where
+module Sound.Tidal.Params.Dirt where
 
 -- Please note, this file is generated by bin/generate-params.hs
 -- Submit any pull requests against that file and/or params-header.hs
 -- in the same folder, thanks.
 
 {-
-    Params.hs - Provides the basic control patterns available to TidalCycles by default
-    Copyright (C) 2021, Alex McLean and contributors
+    Dirt.hs - Provides Tidal parameters for communicating with Dirt
+    and similar OSC endpoints.
+
+    Copyright (C) 2023, Alex McLean and contributors
 
     This library is free software: you can redistribute it and/or modify
     it under the terms of the GNU General Public License as published by
@@ -22,81 +24,7 @@ module Sound.Tidal.Params where
     along with this library.  If not, see <http://www.gnu.org/licenses/>.
 -}
 
-import qualified Data.Map.Strict            as Map
-
-import           Sound.Tidal.Pattern
-import           Sound.Tidal.Signal.Base
-import           Sound.Tidal.Signal.Compose ((#))
-import           Sound.Tidal.Types
-import           Sound.Tidal.Value
--- import Sound.Tidal.Core ((#))
-import           Data.Fixed                 (mod')
-import           Data.Maybe                 (fromMaybe)
-import           Data.Word                  (Word8)
-import           Sound.Tidal.Utils
-
--- | group multiple params into one
-grp :: Pattern p => [String -> ValueMap] -> p String -> p ValueMap
-grp [] _ = silence
-grp fs p = splitby <$> p
-  where splitby name = Map.unions $ map (\(v, f) -> f v) $ zip (split name) fs
-        split :: String -> [String]
-        split = wordsBy (==':')
-
-mF :: String -> String -> ValueMap
-mF name v = fromMaybe Map.empty $ do f <- readMaybe v
-                                     return $ Map.singleton name (VF f)
-
-mI :: String -> String -> ValueMap
-mI name v = fromMaybe Map.empty $ do i <- readMaybe v
-                                     return $ Map.singleton name (VI i)
-
-mS :: String -> String -> ValueMap
-mS name v = Map.singleton name (VS v)
-
--- | Param makers
-
-pF :: Pattern p => String -> p Double -> p ValueMap
-pF name = fmap (Map.singleton name . VF)
-
-pI :: Pattern p => String -> p Int -> p ValueMap
-pI name = fmap (Map.singleton name . VI)
-
-pB :: Pattern p => String -> p Bool -> p ValueMap
-pB name = fmap (Map.singleton name . VB)
-
-pR :: Pattern p => String -> p Time -> p ValueMap
-pR name = fmap (Map.singleton name . VR)
-
-pN :: Pattern p => String -> p Note -> p ValueMap
-pN name = fmap (Map.singleton name . VN)
-
-pS :: Pattern p => String -> p String -> p ValueMap
-pS name = fmap (Map.singleton name . VS)
-
-pX :: Pattern p => String -> p [Word8] -> p ValueMap
-pX name = fmap (Map.singleton name . VX)
-
-pStateF :: Pattern p => String -> String -> (Maybe Double -> Double) -> p ValueMap
-pStateF name sName update = pure $ Map.singleton name $ VState statef
-  where statef :: ValueMap -> (ValueMap, Value)
-        statef sMap = (Map.insert sName v sMap, v)
-          where v = VF $ update $ Map.lookup sName sMap >>= getF
-
-pStateList :: Pattern p => String -> String -> [Value] -> p ValueMap
-pStateList name sName xs = pure $ Map.singleton name $ VState statef
-  where statef :: ValueMap -> (ValueMap, Value)
-        statef sMap = (Map.insert sName (VList $ tail looped) sMap, head looped)
-          where xs' = fromMaybe xs (Map.lookup sName sMap >>= getList)
-                -- do this instead of a cycle, so it can get updated with the a list
-                looped | null xs' = xs
-                       | otherwise = xs'
-
-pStateListF :: Pattern p => String -> String -> [Double] -> p ValueMap
-pStateListF name sName = pStateList name sName . map VF
-
-pStateListS :: Pattern p => String -> String -> [String] -> p ValueMap
-pStateListS name sName = pStateList name sName . map VS
+import           Sound.Tidal.Params
 
 -- | Grouped params
 

cabal.project

@@ -1 +1 @@
-packages: ./ tidal-link
+packages: tidal-core, tidal-stream, tidal-link, tidal-params-dirt

old/Sound/Tidal/Alignment.hs

@@ -0,0 +1,19 @@
+module Sound.Tidal.Alignment where
+
+import           Sound.Tidal.Pattern
+import           Sound.Tidal.Types
+
+squeeze :: Pattern p => p a -> p a
+squeeze = setStrategy SqueezeIn
+
+squeezeIn :: Pattern p => p a -> p a
+squeezeIn = squeeze
+
+squeezeOut :: Pattern p => p a -> p a
+squeezeOut = setStrategy SqueezeOut
+
+expand :: Pattern p => p a -> p a
+expand = setStrategy Expand
+
+repeat :: Pattern p => p a -> p a
+repeat = setStrategy Repeat

src/Sound/Tidal/Compose.hs → old/Sound/Tidal/Compose.hs

@@ -8,7 +8,6 @@
 
 module Sound.Tidal.Compose where
 
-import           Control.Monad           (forM)
 import           Data.Bits
 import           Prelude                 hiding ((*>), (<*))
 
@@ -44,16 +43,16 @@ opOut :: Pattern p => (a -> b -> c) -> p a -> p b -> p c
 opOut f a b = f <$> a *> b
 
 opSqueeze :: (a -> b -> c) -> Signal a -> Signal b -> Signal c
-opSqueeze f a b = squeezeJoin $ fmap (\a -> fmap (\b -> f a b)  b) a
+opSqueeze f pata patb = squeezeJoin $ fmap (\a -> fmap (f a)  patb) pata
 
 opSqueezeOut :: (a -> b -> c) -> Signal a -> Signal b -> Signal c
-opSqueezeOut f pata patb = squeezeJoin $ fmap (\a -> fmap (\b -> f b a)  pata) patb
+opSqueezeOut f pata patb = squeezeJoin $ fmap (\a -> fmap (`f` a)  pata) patb
 
 opTrig :: (a -> b -> c) -> Signal a -> Signal b -> Signal c
-opTrig f a b = trigJoin $ fmap (\a -> fmap (\b -> f a b)  b) a
+opTrig f pata patb = trigJoin $ fmap (\a -> fmap (f a)  patb) pata
 
 opTrigzero :: (a -> b -> c) -> Signal a -> Signal b -> Signal c
-opTrigzero f a b = trigzeroJoin $ fmap (\a -> fmap (\b -> f a b)  b) a
+opTrigzero f pata patb = trigzeroJoin $ fmap (\a -> fmap (f a)  patb) pata
 
 -- ************************************************************ --
 
@@ -123,31 +122,31 @@ infixl 4 |=|, |=, =|, ||=, =||, !=, !!=
 -- keep
 
 keepMix, (|.|) :: (Pattern p, Unionable a) => p a -> p a -> p a
-keepMix pata patb = opMix (union) pata patb
+keepMix pata patb = opMix union pata patb
 (|.|) = keepMix
 
 keepIn, (|.) :: (Pattern p, Unionable a) => p a -> p a -> p a
-keepIn pata patb = opIn (union) pata patb
+keepIn pata patb = opIn union pata patb
 (|.) = keepIn
 
 keepOut, (.|) :: (Pattern p, Unionable a) => p a -> p a -> p a
-keepOut pata patb = opOut (union) pata patb
+keepOut pata patb = opOut union pata patb
 (.|) = keepOut
 
 keepSqueeze, (||.) :: (Unionable a) => Signal a -> Signal a -> Signal a
-keepSqueeze pata patb = opSqueeze (union) pata patb
+keepSqueeze pata patb = opSqueeze union pata patb
 (||.) = keepSqueeze
 
 keepSqueezeOut, (.||) :: (Unionable a) => Signal a -> Signal a -> Signal a
-keepSqueezeOut pata patb = opSqueezeOut (union) pata patb
+keepSqueezeOut pata patb = opSqueezeOut union pata patb
 (.||) = keepSqueezeOut
 
 keepTrig, (!.) :: (Unionable a) => Signal a -> Signal a -> Signal a
-keepTrig pata patb = opTrig (union) pata patb
+keepTrig pata patb = opTrig union pata patb
 (!.) = keepTrig
 
 keepTrigzero, (!!.) :: (Unionable a) => Signal a -> Signal a -> Signal a
-keepTrigzero pata patb = opTrigzero (union) pata patb
+keepTrigzero pata patb = opTrigzero union pata patb
 (!!.) = keepTrigzero
 
 infixl 4 |.|, |., .|, ||., .||, !., !!.
@@ -315,31 +314,31 @@ infixl 4 |/|, |/, /|, ||/, /||, !/, !!/
 -- mod
 
 modMix, (|%|) :: (Pattern p, Integral a) => p a -> p a -> p a
-modMix pata patb = opMix (mod) pata patb
+modMix pata patb = opMix mod pata patb
 (|%|) = modMix
 
 modIn, (|%) :: (Pattern p, Integral a) => p a -> p a -> p a
-modIn pata patb = opIn (mod) pata patb
+modIn pata patb = opIn mod pata patb
 (|%) = modIn
 
 modOut, (%|) :: (Pattern p, Integral a) => p a -> p a -> p a
-modOut pata patb = opOut (mod) pata patb
+modOut pata patb = opOut mod pata patb
 (%|) = modOut
 
 modSqueeze, (||%) :: (Integral a) => Signal a -> Signal a -> Signal a
-modSqueeze pata patb = opSqueeze (mod) pata patb
+modSqueeze pata patb = opSqueeze mod pata patb
 (||%) = modSqueeze
 
 modSqueezeOut, (%||) :: (Integral a) => Signal a -> Signal a -> Signal a
-modSqueezeOut pata patb = opSqueezeOut (mod) pata patb
+modSqueezeOut pata patb = opSqueezeOut mod pata patb
 (%||) = modSqueezeOut
 
 modTrig, (!%) :: (Integral a) => Signal a -> Signal a -> Signal a
-modTrig pata patb = opTrig (mod) pata patb
+modTrig pata patb = opTrig mod pata patb
 (!%) = modTrig
 
 modTrigzero, (!!%) :: (Integral a) => Signal a -> Signal a -> Signal a
-modTrigzero pata patb = opTrigzero (mod) pata patb
+modTrigzero pata patb = opTrigzero mod pata patb
 (!!%) = modTrigzero
 
 infixl 4 |%|, |%, %|, ||%, %||, !%, !!%
@@ -507,95 +506,95 @@ infixl 4 |.|.|, |.|., .|.|, ||.|., .|.||, !.|., !!.|.
 -- bxor
 
 bxorMix, (|.^.|) :: (Pattern p, Bits a) => p a -> p a -> p a
-bxorMix pata patb = opMix (xor) pata patb
+bxorMix pata patb = opMix xor pata patb
 (|.^.|) = bxorMix
 
 bxorIn, (|.^.) :: (Pattern p, Bits a) => p a -> p a -> p a
-bxorIn pata patb = opIn (xor) pata patb
+bxorIn pata patb = opIn xor pata patb
 (|.^.) = bxorIn
 
 bxorOut, (.^.|) :: (Pattern p, Bits a) => p a -> p a -> p a
-bxorOut pata patb = opOut (xor) pata patb
+bxorOut pata patb = opOut xor pata patb
 (.^.|) = bxorOut
 
 bxorSqueeze, (||.^.) :: (Bits a) => Signal a -> Signal a -> Signal a
-bxorSqueeze pata patb = opSqueeze (xor) pata patb
+bxorSqueeze pata patb = opSqueeze xor pata patb
 (||.^.) = bxorSqueeze
 
 bxorSqueezeOut, (.^.||) :: (Bits a) => Signal a -> Signal a -> Signal a
-bxorSqueezeOut pata patb = opSqueezeOut (xor) pata patb
+bxorSqueezeOut pata patb = opSqueezeOut xor pata patb
 (.^.||) = bxorSqueezeOut
 
 bxorTrig, (!.^.) :: (Bits a) => Signal a -> Signal a -> Signal a
-bxorTrig pata patb = opTrig (xor) pata patb
+bxorTrig pata patb = opTrig xor pata patb
 (!.^.) = bxorTrig
 
 bxorTrigzero, (!!.^.) :: (Bits a) => Signal a -> Signal a -> Signal a
-bxorTrigzero pata patb = opTrigzero (xor) pata patb
+bxorTrigzero pata patb = opTrigzero xor pata patb
 (!!.^.) = bxorTrigzero
 
 infixl 4 |.^.|, |.^., .^.|, ||.^., .^.||, !.^., !!.^.
 
 -- bshiftl
 
 bshiftlMix, (|.<<.|) :: (Pattern p, Bits a) => p a -> p Int -> p a
-bshiftlMix pata patb = opMix (shiftL) pata patb
+bshiftlMix pata patb = opMix shiftL pata patb
 (|.<<.|) = bshiftlMix
 
 bshiftlIn, (|.<<.) :: (Pattern p, Bits a) => p a -> p Int -> p a
-bshiftlIn pata patb = opIn (shiftL) pata patb
+bshiftlIn pata patb = opIn shiftL pata patb
 (|.<<.) = bshiftlIn
 
 bshiftlOut, (.<<.|) :: (Pattern p, Bits a) => p a -> p Int -> p a
-bshiftlOut pata patb = opOut (shiftL) pata patb
+bshiftlOut pata patb = opOut shiftL pata patb
 (.<<.|) = bshiftlOut
 
 bshiftlSqueeze, (||.<<.) :: (Bits a) => Signal a -> Signal Int -> Signal a
-bshiftlSqueeze pata patb = opSqueeze (shiftL) pata patb
+bshiftlSqueeze pata patb = opSqueeze shiftL pata patb
 (||.<<.) = bshiftlSqueeze
 
 bshiftlSqueezeOut, (.<<.||) :: (Bits a) => Signal a -> Signal Int -> Signal a
-bshiftlSqueezeOut pata patb = opSqueezeOut (shiftL) pata patb
+bshiftlSqueezeOut pata patb = opSqueezeOut shiftL pata patb
 (.<<.||) = bshiftlSqueezeOut
 
 bshiftlTrig, (!.<<.) :: (Bits a) => Signal a -> Signal Int -> Signal a
-bshiftlTrig pata patb = opTrig (shiftL) pata patb
+bshiftlTrig pata patb = opTrig shiftL pata patb
 (!.<<.) = bshiftlTrig
 
 bshiftlTrigzero, (!!.<<.) :: (Bits a) => Signal a -> Signal Int -> Signal a
-bshiftlTrigzero pata patb = opTrigzero (shiftL) pata patb
+bshiftlTrigzero pata patb = opTrigzero shiftL pata patb
 (!!.<<.) = bshiftlTrigzero
 
 infixl 4 |.<<.|, |.<<., .<<.|, ||.<<., .<<.||, !.<<., !!.<<.
 
 -- bshiftr
 
 bshiftrMix, (|.>>.|) :: (Pattern p, Bits a) => p a -> p Int -> p a
-bshiftrMix pata patb = opMix (shiftR) pata patb
+bshiftrMix pata patb = opMix shiftR pata patb
 (|.>>.|) = bshiftrMix
 
 bshiftrIn, (|.>>.) :: (Pattern p, Bits a) => p a -> p Int -> p a
-bshiftrIn pata patb = opIn (shiftR) pata patb
+bshiftrIn pata patb = opIn shiftR pata patb
 (|.>>.) = bshiftrIn
 
 bshiftrOut, (.>>.|) :: (Pattern p, Bits a) => p a -> p Int -> p a
-bshiftrOut pata patb = opOut (shiftR) pata patb
+bshiftrOut pata patb = opOut shiftR pata patb
 (.>>.|) = bshiftrOut
 
 bshiftrSqueeze, (||.>>.) :: (Bits a) => Signal a -> Signal Int -> Signal a
-bshiftrSqueeze pata patb = opSqueeze (shiftR) pata patb
+bshiftrSqueeze pata patb = opSqueeze shiftR pata patb
 (||.>>.) = bshiftrSqueeze
 
 bshiftrSqueezeOut, (.>>.||) :: (Bits a) => Signal a -> Signal Int -> Signal a
-bshiftrSqueezeOut pata patb = opSqueezeOut (shiftR) pata patb
+bshiftrSqueezeOut pata patb = opSqueezeOut shiftR pata patb
 (.>>.||) = bshiftrSqueezeOut
 
 bshiftrTrig, (!.>>.) :: (Bits a) => Signal a -> Signal Int -> Signal a
-bshiftrTrig pata patb = opTrig (shiftR) pata patb
+bshiftrTrig pata patb = opTrig shiftR pata patb
 (!.>>.) = bshiftrTrig
 
 bshiftrTrigzero, (!!.>>.) :: (Bits a) => Signal a -> Signal Int -> Signal a
-bshiftrTrigzero pata patb = opTrigzero (shiftR) pata patb
+bshiftrTrigzero pata patb = opTrigzero shiftR pata patb
 (!!.>>.) = bshiftrTrigzero
 
 infixl 4 |.>>.|, |.>>., .>>.|, ||.>>., .>>.||, !.>>., !!.>>.

src/Sound/Tidal/Context.hs → old/Sound/Tidal/Context.hs

@@ -42,5 +42,6 @@ import           Sound.Tidal.Signal.Waveform as C
 import           Sound.Tidal.Stream          as C
 -- import Sound.Tidal.Time as C
 -- import Sound.Tidal.Transition as C
+import           Sound.Tidal.Alignment       as C
 import           Sound.Tidal.Types           as C
 import           Sound.Tidal.Version         as C