Safe Haskell | None |
---|---|
Language | Haskell2010 |
Sound.Tidal.Boot
Synopsis
- class Tidally where
- type OscMap = [(Target, [OSC])]
- mkOscMap :: OscMap
- mkTidal :: IO Stream
- mkTidalWith :: OscMap -> Config -> IO Stream
- only :: Tidally => IO () -> IO ()
- p :: Tidally => ID -> ControlPattern -> IO ()
- _p :: Tidally => ID -> ControlPattern -> IO ()
- p_ :: Tidally => ID -> ControlPattern -> IO ()
- hush :: Tidally => IO ()
- panic :: Tidally => IO ()
- list :: Tidally => IO ()
- mute :: Tidally => ID -> IO ()
- unmute :: Tidally => ID -> IO ()
- unmuteAll :: Tidally => IO ()
- unsoloAll :: Tidally => IO ()
- solo :: Tidally => ID -> IO ()
- unsolo :: Tidally => ID -> IO ()
- once :: Tidally => ControlPattern -> IO ()
- asap :: Tidally => ControlPattern -> IO ()
- first :: Tidally => ControlPattern -> IO ()
- nudgeAll :: Tidally => Double -> IO ()
- all :: Tidally => (ControlPattern -> ControlPattern) -> IO ()
- resetCycles :: Tidally => IO ()
- setCycle :: Tidally => Time -> IO ()
- setcps :: Tidally => Pattern Double -> IO ()
- getcps :: Tidally => IO Time
- setbpm :: Tidally => Time -> IO ()
- getbpm :: Tidally => IO Time
- getnow :: Tidally => IO Time
- enableLink :: Tidally => IO ()
- disableLink :: Tidally => IO ()
- d1 :: Tidally => ControlPattern -> IO ()
- d2 :: Tidally => ControlPattern -> IO ()
- d3 :: Tidally => ControlPattern -> IO ()
- d4 :: Tidally => ControlPattern -> IO ()
- d5 :: Tidally => ControlPattern -> IO ()
- d6 :: Tidally => ControlPattern -> IO ()
- d7 :: Tidally => ControlPattern -> IO ()
- d8 :: Tidally => ControlPattern -> IO ()
- d9 :: Tidally => ControlPattern -> IO ()
- d10 :: Tidally => ControlPattern -> IO ()
- d11 :: Tidally => ControlPattern -> IO ()
- d12 :: Tidally => ControlPattern -> IO ()
- d13 :: Tidally => ControlPattern -> IO ()
- d14 :: Tidally => ControlPattern -> IO ()
- d15 :: Tidally => ControlPattern -> IO ()
- d16 :: Tidally => ControlPattern -> IO ()
- _d1 :: Tidally => ControlPattern -> IO ()
- _d2 :: Tidally => ControlPattern -> IO ()
- _d3 :: Tidally => ControlPattern -> IO ()
- _d4 :: Tidally => ControlPattern -> IO ()
- _d5 :: Tidally => ControlPattern -> IO ()
- _d6 :: Tidally => ControlPattern -> IO ()
- _d7 :: Tidally => ControlPattern -> IO ()
- _d8 :: Tidally => ControlPattern -> IO ()
- _d9 :: Tidally => ControlPattern -> IO ()
- _d10 :: Tidally => ControlPattern -> IO ()
- _d11 :: Tidally => ControlPattern -> IO ()
- _d12 :: Tidally => ControlPattern -> IO ()
- _d13 :: Tidally => ControlPattern -> IO ()
- _d14 :: Tidally => ControlPattern -> IO ()
- _d15 :: Tidally => ControlPattern -> IO ()
- _d16 :: Tidally => ControlPattern -> IO ()
- d1_ :: Tidally => ControlPattern -> IO ()
- d2_ :: Tidally => ControlPattern -> IO ()
- d3_ :: Tidally => ControlPattern -> IO ()
- d4_ :: Tidally => ControlPattern -> IO ()
- d5_ :: Tidally => ControlPattern -> IO ()
- d6_ :: Tidally => ControlPattern -> IO ()
- d7_ :: Tidally => ControlPattern -> IO ()
- d8_ :: Tidally => ControlPattern -> IO ()
- d9_ :: Tidally => ControlPattern -> IO ()
- d10_ :: Tidally => ControlPattern -> IO ()
- d11_ :: Tidally => ControlPattern -> IO ()
- d12_ :: Tidally => ControlPattern -> IO ()
- d13_ :: Tidally => ControlPattern -> IO ()
- d14_ :: Tidally => ControlPattern -> IO ()
- d15_ :: Tidally => ControlPattern -> IO ()
- d16_ :: Tidally => ControlPattern -> IO ()
- getState :: Tidally => String -> IO (Maybe Value)
- setI :: Tidally => String -> Pattern Int -> IO ()
- setF :: Tidally => String -> Pattern Double -> IO ()
- setS :: Tidally => String -> Pattern String -> IO ()
- setR :: Tidally => String -> Pattern Rational -> IO ()
- setB :: Tidally => String -> Pattern Bool -> IO ()
- xfade :: Tidally => ID -> ControlPattern -> IO ()
- xfadeIn :: Tidally => ID -> Time -> ControlPattern -> IO ()
- array :: Pattern [Word8] -> ControlPattern
- binary :: Pattern Int -> Pattern Bool
- freeze :: Pattern Double -> ControlPattern
- index :: Real b => b -> Pattern b -> Pattern c -> Pattern c
- range :: Num a => Pattern a -> Pattern a -> Pattern a -> Pattern a
- show :: Show a => a -> String
- type Rational = Ratio Integer
- mask :: Pattern Bool -> Pattern a -> Pattern a
- loop :: Pattern Double -> ControlPattern
- fromList :: [a] -> Pattern a
- (*>) :: Pattern (a -> b) -> Pattern a -> Pattern b
- data Ratio a
- empty :: Pattern a
- (<*) :: Pattern (a -> b) -> Pattern a -> Pattern b
- when :: (Int -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- (%) :: Integral a => a -> a -> Ratio a
- numerator :: Ratio a -> a
- denominator :: Ratio a -> a
- swap :: Eq a => [(a, b)] -> Pattern a -> Pattern b
- fix :: (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern
- reset :: Pattern Bool -> Pattern a -> Pattern a
- parens :: MyParser a -> MyParser a
- choose :: [a] -> Pattern a
- from :: Pattern Double -> ControlPattern
- to :: Pattern Double -> ControlPattern
- class Unionable a where
- union :: a -> a -> a
- type Event a = EventF (ArcF Time) a
- data EventF a b = Event {}
- data Stream = Stream {}
- ascii :: Pattern String -> Pattern Bool
- squeeze :: Pattern Int -> [Pattern a] -> Pattern a
- release :: Pattern Double -> ControlPattern
- left :: ControlPattern -> ControlPattern
- right :: ControlPattern -> ControlPattern
- approxRational :: RealFrac a => a -> a -> Rational
- (<|) :: Unionable a => Pattern a -> Pattern a -> Pattern a
- append :: Pattern a -> Pattern a -> Pattern a
- size :: Pattern Double -> ControlPattern
- skip :: ControlPattern -> ControlPattern
- chunk :: Pattern Int -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b
- sign :: MyParser Sign
- sec :: Fractional a => Pattern a -> Pattern a
- scale :: Fractional a => Pattern String -> Pattern Int -> Pattern a
- data State = State {}
- (|>) :: Unionable a => Pattern a -> Pattern a -> Pattern a
- data OSC
- type Time = Rational
- send :: Cx -> Double -> Double -> (Double, Bool, Message) -> IO ()
- float :: MyParser Double
- extend :: Pattern Rational -> Pattern a -> Pattern a
- select :: Pattern Double -> [Pattern a] -> Pattern a
- lower :: ControlPattern -> ControlPattern
- brackets :: MyParser a -> MyParser a
- angles :: MyParser a -> MyParser a
- braces :: MyParser a -> MyParser a
- symbol :: String -> MyParser String
- decimal :: MyParser Integer
- naturalOrFloat :: MyParser (Either Integer Double)
- integer :: MyParser Integer
- natural :: MyParser Integer
- cat :: [Pattern a] -> Pattern a
- run :: (Enum a, Num a, Real a) => Pattern a -> Pattern a
- streamList :: Stream -> IO ()
- iter :: Pattern Int -> Pattern c -> Pattern c
- echo :: Pattern Integer -> Pattern Rational -> Pattern Double -> ControlPattern -> ControlPattern
- type Arc = ArcF Time
- data ArcF a = Arc {}
- sam :: Time -> Time
- toTime :: Real a => a -> Rational
- fromTime :: Fractional a => Time -> a
- nextSam :: Time -> Time
- cyclePos :: Time -> Time
- hull :: Arc -> Arc -> Arc
- subArc :: Arc -> Arc -> Maybe Arc
- subMaybeArc :: Maybe Arc -> Maybe Arc -> Maybe (Maybe Arc)
- sect :: Arc -> Arc -> Arc
- timeToCycleArc :: Time -> Arc
- cycleArc :: Arc -> Arc
- cyclesInArc :: Integral a => Arc -> [a]
- cycleArcsInArc :: Arc -> [Arc]
- arcCycles :: Arc -> [Arc]
- arcCyclesZW :: Arc -> [Arc]
- mapCycle :: (Time -> Time) -> Arc -> Arc
- isIn :: Arc -> Time -> Bool
- lcmr :: Rational -> Rational -> Rational
- newtype Note = Note {}
- type ValueMap = Map String Value
- class Valuable a where
- data Value
- data Context = Context {
- contextPosition :: [((Int, Int), (Int, Int))]
- class Stringy a where
- deltaContext :: Int -> Int -> a -> a
- class Moddable a where
- gmod :: a -> a -> a
- type ControlPattern = Pattern ValueMap
- data Pattern a = Pattern {}
- pattern :: (State -> [Event a]) -> Pattern a
- setSteps :: Maybe Rational -> Pattern a -> Pattern a
- setStepsFrom :: Pattern b -> Pattern a -> Pattern a
- withSteps :: (Rational -> Rational) -> Pattern a -> Pattern a
- pace :: Rational -> Pattern a -> Pattern a
- keepMeta :: Pattern a -> Pattern a -> Pattern a
- keepSteps :: Pattern a -> Pattern b -> Pattern b
- (<<*) :: Pattern (a -> b) -> Pattern a -> Pattern b
- applyPatToPat :: (Maybe Arc -> Maybe Arc -> Maybe (Maybe Arc)) -> Pattern (a -> b) -> Pattern a -> Pattern b
- applyPatToPatBoth :: Pattern (a -> b) -> Pattern a -> Pattern b
- applyPatToPatLeft :: Pattern (a -> b) -> Pattern a -> Pattern b
- applyPatToPatRight :: Pattern (a -> b) -> Pattern a -> Pattern b
- applyPatToPatSqueeze :: Pattern (a -> b) -> Pattern a -> Pattern b
- unwrap :: Pattern (Pattern a) -> Pattern a
- innerJoin :: Pattern (Pattern b) -> Pattern b
- outerJoin :: Pattern (Pattern a) -> Pattern a
- squeezeJoin :: Pattern (Pattern a) -> Pattern a
- _trigJoin :: Bool -> Pattern (Pattern a) -> Pattern a
- trigJoin :: Pattern (Pattern a) -> Pattern a
- trigZeroJoin :: Pattern (Pattern a) -> Pattern a
- resetTo :: Pattern Rational -> Pattern a -> Pattern a
- restart :: Pattern Bool -> Pattern a -> Pattern a
- restartTo :: Pattern Rational -> Pattern a -> Pattern a
- noOv :: String -> a
- silence :: Pattern a
- nothing :: Pattern a
- queryArc :: Pattern a -> Arc -> [Event a]
- splitQueries :: Pattern a -> Pattern a
- withResultArc :: (Arc -> Arc) -> Pattern a -> Pattern a
- withResultTime :: (Time -> Time) -> Pattern a -> Pattern a
- withResultStart :: (Time -> Time) -> Pattern a -> Pattern a
- withQueryArc :: (Arc -> Arc) -> Pattern a -> Pattern a
- withQueryTime :: (Time -> Time) -> Pattern a -> Pattern a
- withQueryStart :: (Time -> Time) -> Pattern a -> Pattern a
- withQueryControls :: (ValueMap -> ValueMap) -> Pattern a -> Pattern a
- withEvent :: (Event a -> Event b) -> Pattern a -> Pattern b
- withValue :: (a -> b) -> Pattern a -> Pattern b
- withEvents :: ([Event a] -> [Event b]) -> Pattern a -> Pattern b
- withPart :: (Arc -> Arc) -> Pattern a -> Pattern a
- _extract :: (Value -> Maybe a) -> String -> ControlPattern -> Pattern a
- extractI :: String -> ControlPattern -> Pattern Int
- extractF :: String -> ControlPattern -> Pattern Double
- extractS :: String -> ControlPattern -> Pattern String
- extractB :: String -> ControlPattern -> Pattern Bool
- extractR :: String -> ControlPattern -> Pattern Rational
- extractN :: String -> ControlPattern -> Pattern Note
- compressArc :: Arc -> Pattern a -> Pattern a
- compressArcTo :: Arc -> Pattern a -> Pattern a
- focusArc :: Arc -> Pattern a -> Pattern a
- fast :: Pattern Time -> Pattern a -> Pattern a
- fastSqueeze :: Pattern Time -> Pattern a -> Pattern a
- density :: Pattern Time -> Pattern a -> Pattern a
- _fast :: Time -> Pattern a -> Pattern a
- slow :: Pattern Time -> Pattern a -> Pattern a
- _slow :: Time -> Pattern a -> Pattern a
- _fastGap :: Time -> Pattern a -> Pattern a
- rotL :: Time -> Pattern a -> Pattern a
- rotR :: Time -> Pattern a -> Pattern a
- rev :: Pattern a -> Pattern a
- matchManyToOne :: (b -> a -> Bool) -> Pattern a -> Pattern b -> Pattern (Bool, b)
- filterValues :: (a -> Bool) -> Pattern a -> Pattern a
- filterJust :: Pattern (Maybe a) -> Pattern a
- filterWhen :: (Time -> Bool) -> Pattern a -> Pattern a
- filterOnsets :: Pattern a -> Pattern a
- filterEvents :: (Event a -> Bool) -> Pattern a -> Pattern a
- filterDigital :: Pattern a -> Pattern a
- filterAnalog :: Pattern a -> Pattern a
- playFor :: Time -> Time -> Pattern a -> Pattern a
- separateCycles :: Int -> Pattern a -> [Pattern a]
- patternify :: (t1 -> t2 -> Pattern a) -> Pattern t1 -> t2 -> Pattern a
- patternify' :: (b -> Pattern c -> Pattern a) -> Pattern b -> Pattern c -> Pattern a
- patternify2 :: (a -> b -> c -> Pattern d) -> Pattern a -> Pattern b -> c -> Pattern d
- patternify2' :: (a -> b -> Pattern c -> Pattern d) -> Pattern a -> Pattern b -> Pattern c -> Pattern d
- patternify3 :: (a -> b -> c -> Pattern d -> Pattern e) -> Pattern a -> Pattern b -> Pattern c -> Pattern d -> Pattern e
- patternify3' :: (a -> b -> c -> Pattern d -> Pattern e) -> Pattern a -> Pattern b -> Pattern c -> Pattern d -> Pattern e
- patternifySqueeze :: (a -> Pattern b -> Pattern c) -> Pattern a -> Pattern b -> Pattern c
- combineContexts :: [Context] -> Context
- setContext :: Context -> Pattern a -> Pattern a
- withContext :: (Context -> Context) -> Pattern a -> Pattern a
- deltaMini :: String -> String
- isAnalog :: Event a -> Bool
- isDigital :: Event a -> Bool
- onsetIn :: Arc -> Event a -> Bool
- defragParts :: Eq a => [Event a] -> [Event a]
- isAdjacent :: Eq a => Event a -> Event a -> Bool
- wholeOrPart :: Event a -> Arc
- wholeStart :: Event a -> Time
- wholeStop :: Event a -> Time
- eventPartStart :: Event a -> Time
- eventPartStop :: Event a -> Time
- eventPart :: Event a -> Arc
- eventValue :: Event a -> a
- eventHasOnset :: Event a -> Bool
- toEvent :: (((Time, Time), (Time, Time)), a) -> Event a
- resolveState :: ValueMap -> [Event ValueMap] -> (ValueMap, [Event ValueMap])
- applyFIS :: (Double -> Double) -> (Int -> Int) -> (String -> String) -> Value -> Value
- fNum2 :: (Int -> Int -> Int) -> (Double -> Double -> Double) -> Value -> Value -> Value
- getI :: Value -> Maybe Int
- getF :: Value -> Maybe Double
- getN :: Value -> Maybe Note
- getS :: Value -> Maybe String
- getB :: Value -> Maybe Bool
- getR :: Value -> Maybe Rational
- getBlob :: Value -> Maybe [Word8]
- getList :: Value -> Maybe [Value]
- valueToPattern :: Value -> Pattern Value
- sameDur :: Event a -> Event a -> Bool
- groupEventsBy :: Eq a => (Event a -> Event a -> Bool) -> [Event a] -> [[Event a]]
- collectEvent :: [Event a] -> Maybe (Event [a])
- collectEventsBy :: Eq a => (Event a -> Event a -> Bool) -> [Event a] -> [Event [a]]
- collectBy :: Eq a => (Event a -> Event a -> Bool) -> Pattern a -> Pattern [a]
- collect :: Eq a => Pattern a -> Pattern [a]
- uncollectEvent :: Event [a] -> [Event a]
- uncollectEvents :: [Event [a]] -> [Event a]
- uncollect :: Pattern [a] -> Pattern a
- showStateful :: ControlPattern -> String
- showAll :: Show a => Arc -> Pattern a -> String
- stepcount :: Pattern a -> Int
- drawLine :: Pattern Char -> Render
- drawLineSz :: Int -> Pattern Char -> Render
- draw :: Pattern Char -> Render
- sig :: (Time -> a) -> Pattern a
- sine :: Fractional a => Pattern a
- sine2 :: Fractional a => Pattern a
- cosine :: Fractional a => Pattern a
- cosine2 :: Fractional a => Pattern a
- saw :: (Fractional a, Real a) => Pattern a
- saw2 :: (Fractional a, Real a) => Pattern a
- isaw :: (Fractional a, Real a) => Pattern a
- isaw2 :: (Fractional a, Real a) => Pattern a
- tri :: (Fractional a, Real a) => Pattern a
- tri2 :: (Fractional a, Real a) => Pattern a
- square :: Fractional a => Pattern a
- square2 :: Fractional a => Pattern a
- envL :: Pattern Double
- envLR :: Pattern Double
- envEq :: Pattern Double
- envEqR :: Pattern Double
- (|+|) :: (Applicative a, Num b) => a b -> a b -> a b
- (|+) :: Num a => Pattern a -> Pattern a -> Pattern a
- (+|) :: Num a => Pattern a -> Pattern a -> Pattern a
- (||+) :: Num a => Pattern a -> Pattern a -> Pattern a
- (|++|) :: Applicative a => a String -> a String -> a String
- (|++) :: Pattern String -> Pattern String -> Pattern String
- (++|) :: Pattern String -> Pattern String -> Pattern String
- (||++) :: Pattern String -> Pattern String -> Pattern String
- (|/|) :: (Applicative a, Fractional b) => a b -> a b -> a b
- (|/) :: Fractional a => Pattern a -> Pattern a -> Pattern a
- (/|) :: Fractional a => Pattern a -> Pattern a -> Pattern a
- (||/) :: Fractional a => Pattern a -> Pattern a -> Pattern a
- (|*|) :: (Applicative a, Num b) => a b -> a b -> a b
- (|*) :: Num a => Pattern a -> Pattern a -> Pattern a
- (*|) :: Num a => Pattern a -> Pattern a -> Pattern a
- (||*) :: Num a => Pattern a -> Pattern a -> Pattern a
- (|-|) :: (Applicative a, Num b) => a b -> a b -> a b
- (|-) :: Num a => Pattern a -> Pattern a -> Pattern a
- (-|) :: Num a => Pattern a -> Pattern a -> Pattern a
- (||-) :: Num a => Pattern a -> Pattern a -> Pattern a
- (|%|) :: (Applicative a, Moddable b) => a b -> a b -> a b
- (|%) :: Moddable a => Pattern a -> Pattern a -> Pattern a
- (%|) :: Moddable a => Pattern a -> Pattern a -> Pattern a
- (||%) :: Moddable a => Pattern a -> Pattern a -> Pattern a
- (|**|) :: (Applicative a, Floating b) => a b -> a b -> a b
- (|**) :: Floating a => Pattern a -> Pattern a -> Pattern a
- (**|) :: Floating a => Pattern a -> Pattern a -> Pattern a
- (||**) :: Floating a => Pattern a -> Pattern a -> Pattern a
- (|>|) :: (Applicative a, Unionable b) => a b -> a b -> a b
- (>|) :: Unionable a => Pattern a -> Pattern a -> Pattern a
- (||>) :: Unionable a => Pattern a -> Pattern a -> Pattern a
- (|<|) :: (Applicative a, Unionable b) => a b -> a b -> a b
- (|<) :: Unionable a => Pattern a -> Pattern a -> Pattern a
- (||<) :: Unionable a => Pattern a -> Pattern a -> Pattern a
- (#) :: Unionable b => Pattern b -> Pattern b -> Pattern b
- fastFromList :: [a] -> Pattern a
- listToPat :: [a] -> Pattern a
- fromMaybes :: [Maybe a] -> Pattern a
- _run :: (Enum a, Num a) => a -> Pattern a
- scan :: (Enum a, Num a) => Pattern a -> Pattern a
- _scan :: (Enum a, Num a) => a -> Pattern a
- slowCat :: [Pattern a] -> Pattern a
- slowcat :: [Pattern a] -> Pattern a
- slowAppend :: Pattern a -> Pattern a -> Pattern a
- slowappend :: Pattern a -> Pattern a -> Pattern a
- fastAppend :: Pattern a -> Pattern a -> Pattern a
- fastappend :: Pattern a -> Pattern a -> Pattern a
- fastCat :: [Pattern a] -> Pattern a
- fastcat :: [Pattern a] -> Pattern a
- timeCat :: [(Time, Pattern a)] -> Pattern a
- timecat :: [(Time, Pattern a)] -> Pattern a
- overlay :: Pattern a -> Pattern a -> Pattern a
- mono :: Pattern a -> Pattern a
- stack :: [Pattern a] -> Pattern a
- (<~) :: Pattern Time -> Pattern a -> Pattern a
- (~>) :: Pattern Time -> Pattern a -> Pattern a
- slowSqueeze :: Pattern Time -> Pattern a -> Pattern a
- sparsity :: Pattern Time -> Pattern a -> Pattern a
- zoom :: (Time, Time) -> Pattern a -> Pattern a
- zoompat :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a
- zoomArc :: Arc -> Pattern a -> Pattern a
- fastGap :: Pattern Time -> Pattern a -> Pattern a
- densityGap :: Pattern Time -> Pattern a -> Pattern a
- compress :: (Time, Time) -> Pattern a -> Pattern a
- compressTo :: (Time, Time) -> Pattern a -> Pattern a
- repeatCycles :: Pattern Int -> Pattern a -> Pattern a
- _repeatCycles :: Int -> Pattern a -> Pattern a
- fastRepeatCycles :: Int -> Pattern a -> Pattern a
- every :: Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- _every :: Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- every' :: Pattern Int -> Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- _every' :: Int -> Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- foldEvery :: [Int] -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- whenT :: (Time -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- _getP_ :: (Value -> Maybe a) -> Pattern Value -> Pattern a
- _getP :: a -> (Value -> Maybe a) -> Pattern Value -> Pattern a
- _cX :: a -> (Value -> Maybe a) -> String -> Pattern a
- _cX_ :: (Value -> Maybe a) -> String -> Pattern a
- cF :: Double -> String -> Pattern Double
- cF_ :: String -> Pattern Double
- cF0 :: String -> Pattern Double
- cN :: Note -> String -> Pattern Note
- cN_ :: String -> Pattern Note
- cN0 :: String -> Pattern Note
- cI :: Int -> String -> Pattern Int
- cI_ :: String -> Pattern Int
- cI0 :: String -> Pattern Int
- cB :: Bool -> String -> Pattern Bool
- cB_ :: String -> Pattern Bool
- cB0 :: String -> Pattern Bool
- cR :: Rational -> String -> Pattern Rational
- cR_ :: String -> Pattern Rational
- cR0 :: String -> Pattern Rational
- cT :: Time -> String -> Pattern Time
- cT0 :: String -> Pattern Time
- cT_ :: String -> Pattern Time
- cS :: String -> String -> Pattern String
- cS_ :: String -> Pattern String
- cS0 :: String -> Pattern String
- in0 :: Pattern Double
- in1 :: Pattern Double
- in2 :: Pattern Double
- in3 :: Pattern Double
- in4 :: Pattern Double
- in5 :: Pattern Double
- in6 :: Pattern Double
- in7 :: Pattern Double
- in8 :: Pattern Double
- in9 :: Pattern Double
- in10 :: Pattern Double
- in11 :: Pattern Double
- in12 :: Pattern Double
- in13 :: Pattern Double
- in14 :: Pattern Double
- in15 :: Pattern Double
- in16 :: Pattern Double
- in17 :: Pattern Double
- in18 :: Pattern Double
- in19 :: Pattern Double
- in20 :: Pattern Double
- in21 :: Pattern Double
- in22 :: Pattern Double
- in23 :: Pattern Double
- in24 :: Pattern Double
- in25 :: Pattern Double
- in26 :: Pattern Double
- in27 :: Pattern Double
- in28 :: Pattern Double
- in29 :: Pattern Double
- in30 :: Pattern Double
- in31 :: Pattern Double
- in32 :: Pattern Double
- in33 :: Pattern Double
- in34 :: Pattern Double
- in35 :: Pattern Double
- in36 :: Pattern Double
- in37 :: Pattern Double
- in38 :: Pattern Double
- in39 :: Pattern Double
- in40 :: Pattern Double
- in41 :: Pattern Double
- in42 :: Pattern Double
- in43 :: Pattern Double
- in44 :: Pattern Double
- in45 :: Pattern Double
- in46 :: Pattern Double
- in47 :: Pattern Double
- in48 :: Pattern Double
- in49 :: Pattern Double
- in50 :: Pattern Double
- in51 :: Pattern Double
- in52 :: Pattern Double
- in53 :: Pattern Double
- in54 :: Pattern Double
- in55 :: Pattern Double
- in56 :: Pattern Double
- in57 :: Pattern Double
- in58 :: Pattern Double
- in59 :: Pattern Double
- in60 :: Pattern Double
- in61 :: Pattern Double
- in62 :: Pattern Double
- in63 :: Pattern Double
- in64 :: Pattern Double
- in65 :: Pattern Double
- in66 :: Pattern Double
- in67 :: Pattern Double
- in68 :: Pattern Double
- in69 :: Pattern Double
- in70 :: Pattern Double
- in71 :: Pattern Double
- in72 :: Pattern Double
- in73 :: Pattern Double
- in74 :: Pattern Double
- in75 :: Pattern Double
- in76 :: Pattern Double
- in77 :: Pattern Double
- in78 :: Pattern Double
- in79 :: Pattern Double
- in80 :: Pattern Double
- in81 :: Pattern Double
- in82 :: Pattern Double
- in83 :: Pattern Double
- in84 :: Pattern Double
- in85 :: Pattern Double
- in86 :: Pattern Double
- in87 :: Pattern Double
- in88 :: Pattern Double
- in89 :: Pattern Double
- in90 :: Pattern Double
- in91 :: Pattern Double
- in92 :: Pattern Double
- in93 :: Pattern Double
- in94 :: Pattern Double
- in95 :: Pattern Double
- in96 :: Pattern Double
- in97 :: Pattern Double
- in98 :: Pattern Double
- in99 :: Pattern Double
- in100 :: Pattern Double
- in101 :: Pattern Double
- in102 :: Pattern Double
- in103 :: Pattern Double
- in104 :: Pattern Double
- in105 :: Pattern Double
- in106 :: Pattern Double
- in107 :: Pattern Double
- in108 :: Pattern Double
- in109 :: Pattern Double
- in110 :: Pattern Double
- in111 :: Pattern Double
- in112 :: Pattern Double
- in113 :: Pattern Double
- in114 :: Pattern Double
- in115 :: Pattern Double
- in116 :: Pattern Double
- in117 :: Pattern Double
- in118 :: Pattern Double
- in119 :: Pattern Double
- in120 :: Pattern Double
- in121 :: Pattern Double
- in122 :: Pattern Double
- in123 :: Pattern Double
- in124 :: Pattern Double
- in125 :: Pattern Double
- in126 :: Pattern Double
- in127 :: Pattern Double
- s_patternify :: (a -> Pattern b -> Pattern c) -> Pattern a -> Pattern b -> Pattern c
- s_patternify2 :: (a -> b -> c -> Pattern d) -> Pattern a -> Pattern b -> c -> Pattern d
- stepJoin :: Pattern (Pattern a) -> Pattern a
- stepcat :: [Pattern a] -> Pattern a
- _take :: Time -> Pattern a -> Pattern a
- steptake :: Pattern Time -> Pattern a -> Pattern a
- _stepdrop :: Time -> Pattern a -> Pattern a
- stepdrop :: Pattern Time -> Pattern a -> Pattern a
- _expand :: Rational -> Pattern a -> Pattern a
- _contract :: Rational -> Pattern a -> Pattern a
- expand :: Pattern Rational -> Pattern a -> Pattern a
- contract :: Pattern Rational -> Pattern a -> Pattern a
- _extend :: Rational -> Pattern a -> Pattern a
- stepalt :: [[Pattern a]] -> Pattern a
- getScale :: Fractional a => [(String, [a])] -> Pattern String -> Pattern Int -> Pattern a
- scaleWith :: (Eq a, Fractional a) => Pattern String -> ([a] -> [a]) -> Pattern Int -> Pattern a
- scaleWithList :: (Eq a, Fractional a) => Pattern String -> [[a] -> [a]] -> Pattern Int -> Pattern a
- raiseDegree :: Fractional a => Int -> [a] -> [a]
- lowerDegree :: Fractional a => Int -> [a] -> [a]
- raiseDegrees :: Fractional a => Int -> Int -> [a] -> [a]
- lowerDegrees :: Fractional a => Int -> Int -> [a] -> [a]
- scaleList :: String
- scaleTable :: Fractional a => [(String, [a])]
- grp :: [String -> ValueMap] -> Pattern String -> ControlPattern
- mF :: String -> String -> ValueMap
- mI :: String -> String -> ValueMap
- mS :: String -> String -> ValueMap
- pF :: String -> Pattern Double -> ControlPattern
- pI :: String -> Pattern Int -> ControlPattern
- pB :: String -> Pattern Bool -> ControlPattern
- pR :: String -> Pattern Rational -> ControlPattern
- pN :: String -> Pattern Note -> ControlPattern
- pS :: String -> Pattern String -> ControlPattern
- pX :: String -> Pattern [Word8] -> ControlPattern
- pStateF :: String -> String -> (Maybe Double -> Double) -> ControlPattern
- pStateList :: String -> String -> [Value] -> ControlPattern
- pStateListF :: String -> String -> [Double] -> ControlPattern
- pStateListS :: String -> String -> [String] -> ControlPattern
- sound :: Pattern String -> ControlPattern
- sTake :: String -> [String] -> ControlPattern
- cc :: Pattern String -> ControlPattern
- nrpn :: Pattern String -> ControlPattern
- nrpnn :: Pattern Int -> ControlPattern
- nrpnv :: Pattern Int -> ControlPattern
- grain' :: Pattern String -> ControlPattern
- midinote :: Pattern Note -> ControlPattern
- drum :: Pattern String -> ControlPattern
- drumN :: Num a => String -> a
- accelerate :: Pattern Double -> ControlPattern
- accelerateTake :: String -> [Double] -> ControlPattern
- accelerateCount :: String -> ControlPattern
- accelerateCountTo :: String -> Pattern Double -> Pattern ValueMap
- acceleratebus :: Pattern Int -> Pattern Double -> ControlPattern
- amp :: Pattern Double -> ControlPattern
- ampTake :: String -> [Double] -> ControlPattern
- ampCount :: String -> ControlPattern
- ampCountTo :: String -> Pattern Double -> Pattern ValueMap
- ampbus :: Pattern Int -> Pattern Double -> ControlPattern
- amprecv :: Pattern Int -> ControlPattern
- arrayTake :: String -> [Double] -> ControlPattern
- arraybus :: Pattern Int -> Pattern [Word8] -> ControlPattern
- attack :: Pattern Double -> ControlPattern
- attackTake :: String -> [Double] -> ControlPattern
- attackCount :: String -> ControlPattern
- attackCountTo :: String -> Pattern Double -> Pattern ValueMap
- attackbus :: Pattern Int -> Pattern Double -> ControlPattern
- attackrecv :: Pattern Int -> ControlPattern
- bandf :: Pattern Double -> ControlPattern
- bandfTake :: String -> [Double] -> ControlPattern
- bandfCount :: String -> ControlPattern
- bandfCountTo :: String -> Pattern Double -> Pattern ValueMap
- bandfbus :: Pattern Int -> Pattern Double -> ControlPattern
- bandfrecv :: Pattern Int -> ControlPattern
- bandq :: Pattern Double -> ControlPattern
- bandqTake :: String -> [Double] -> ControlPattern
- bandqCount :: String -> ControlPattern
- bandqCountTo :: String -> Pattern Double -> Pattern ValueMap
- bandqbus :: Pattern Int -> Pattern Double -> ControlPattern
- bandqrecv :: Pattern Int -> ControlPattern
- bank :: Pattern String -> ControlPattern
- begin :: Pattern Double -> ControlPattern
- beginTake :: String -> [Double] -> ControlPattern
- beginCount :: String -> ControlPattern
- beginCountTo :: String -> Pattern Double -> Pattern ValueMap
- beginbus :: Pattern Int -> Pattern Double -> ControlPattern
- binshift :: Pattern Double -> ControlPattern
- binshiftTake :: String -> [Double] -> ControlPattern
- binshiftCount :: String -> ControlPattern
- binshiftCountTo :: String -> Pattern Double -> Pattern ValueMap
- binshiftbus :: Pattern Int -> Pattern Double -> ControlPattern
- binshiftrecv :: Pattern Int -> ControlPattern
- button0 :: Pattern Double -> ControlPattern
- button0Take :: String -> [Double] -> ControlPattern
- button0Count :: String -> ControlPattern
- button0CountTo :: String -> Pattern Double -> Pattern ValueMap
- button0bus :: Pattern Int -> Pattern Double -> ControlPattern
- button0recv :: Pattern Int -> ControlPattern
- button1 :: Pattern Double -> ControlPattern
- button1Take :: String -> [Double] -> ControlPattern
- button1Count :: String -> ControlPattern
- button1CountTo :: String -> Pattern Double -> Pattern ValueMap
- button1bus :: Pattern Int -> Pattern Double -> ControlPattern
- button1recv :: Pattern Int -> ControlPattern
- button10 :: Pattern Double -> ControlPattern
- button10Take :: String -> [Double] -> ControlPattern
- button10Count :: String -> ControlPattern
- button10CountTo :: String -> Pattern Double -> Pattern ValueMap
- button10bus :: Pattern Int -> Pattern Double -> ControlPattern
- button10recv :: Pattern Int -> ControlPattern
- button11 :: Pattern Double -> ControlPattern
- button11Take :: String -> [Double] -> ControlPattern
- button11Count :: String -> ControlPattern
- button11CountTo :: String -> Pattern Double -> Pattern ValueMap
- button11bus :: Pattern Int -> Pattern Double -> ControlPattern
- button11recv :: Pattern Int -> ControlPattern
- button12 :: Pattern Double -> ControlPattern
- button12Take :: String -> [Double] -> ControlPattern
- button12Count :: String -> ControlPattern
- button12CountTo :: String -> Pattern Double -> Pattern ValueMap
- button12bus :: Pattern Int -> Pattern Double -> ControlPattern
- button12recv :: Pattern Int -> ControlPattern
- button13 :: Pattern Double -> ControlPattern
- button13Take :: String -> [Double] -> ControlPattern
- button13Count :: String -> ControlPattern
- button13CountTo :: String -> Pattern Double -> Pattern ValueMap
- button13bus :: Pattern Int -> Pattern Double -> ControlPattern
- button13recv :: Pattern Int -> ControlPattern
- button14 :: Pattern Double -> ControlPattern
- button14Take :: String -> [Double] -> ControlPattern
- button14Count :: String -> ControlPattern
- button14CountTo :: String -> Pattern Double -> Pattern ValueMap
- button14bus :: Pattern Int -> Pattern Double -> ControlPattern
- button14recv :: Pattern Int -> ControlPattern
- button15 :: Pattern Double -> ControlPattern
- button15Take :: String -> [Double] -> ControlPattern
- button15Count :: String -> ControlPattern
- button15CountTo :: String -> Pattern Double -> Pattern ValueMap
- button15bus :: Pattern Int -> Pattern Double -> ControlPattern
- button15recv :: Pattern Int -> ControlPattern
- button2 :: Pattern Double -> ControlPattern
- button2Take :: String -> [Double] -> ControlPattern
- button2Count :: String -> ControlPattern
- button2CountTo :: String -> Pattern Double -> Pattern ValueMap
- button2bus :: Pattern Int -> Pattern Double -> ControlPattern
- button2recv :: Pattern Int -> ControlPattern
- button3 :: Pattern Double -> ControlPattern
- button3Take :: String -> [Double] -> ControlPattern
- button3Count :: String -> ControlPattern
- button3CountTo :: String -> Pattern Double -> Pattern ValueMap
- button3bus :: Pattern Int -> Pattern Double -> ControlPattern
- button3recv :: Pattern Int -> ControlPattern
- button4 :: Pattern Double -> ControlPattern
- button4Take :: String -> [Double] -> ControlPattern
- button4Count :: String -> ControlPattern
- button4CountTo :: String -> Pattern Double -> Pattern ValueMap
- button4bus :: Pattern Int -> Pattern Double -> ControlPattern
- button4recv :: Pattern Int -> ControlPattern
- button5 :: Pattern Double -> ControlPattern
- button5Take :: String -> [Double] -> ControlPattern
- button5Count :: String -> ControlPattern
- button5CountTo :: String -> Pattern Double -> Pattern ValueMap
- button5bus :: Pattern Int -> Pattern Double -> ControlPattern
- button5recv :: Pattern Int -> ControlPattern
- button6 :: Pattern Double -> ControlPattern
- button6Take :: String -> [Double] -> ControlPattern
- button6Count :: String -> ControlPattern
- button6CountTo :: String -> Pattern Double -> Pattern ValueMap
- button6bus :: Pattern Int -> Pattern Double -> ControlPattern
- button6recv :: Pattern Int -> ControlPattern
- button7 :: Pattern Double -> ControlPattern
- button7Take :: String -> [Double] -> ControlPattern
- button7Count :: String -> ControlPattern
- button7CountTo :: String -> Pattern Double -> Pattern ValueMap
- button7bus :: Pattern Int -> Pattern Double -> ControlPattern
- button7recv :: Pattern Int -> ControlPattern
- button8 :: Pattern Double -> ControlPattern
- button8Take :: String -> [Double] -> ControlPattern
- button8Count :: String -> ControlPattern
- button8CountTo :: String -> Pattern Double -> Pattern ValueMap
- button8bus :: Pattern Int -> Pattern Double -> ControlPattern
- button8recv :: Pattern Int -> ControlPattern
- button9 :: Pattern Double -> ControlPattern
- button9Take :: String -> [Double] -> ControlPattern
- button9Count :: String -> ControlPattern
- button9CountTo :: String -> Pattern Double -> Pattern ValueMap
- button9bus :: Pattern Int -> Pattern Double -> ControlPattern
- button9recv :: Pattern Int -> ControlPattern
- ccn :: Pattern Double -> ControlPattern
- ccnTake :: String -> [Double] -> ControlPattern
- ccnCount :: String -> ControlPattern
- ccnCountTo :: String -> Pattern Double -> Pattern ValueMap
- ccnbus :: Pattern Int -> Pattern Double -> ControlPattern
- ccv :: Pattern Double -> ControlPattern
- ccvTake :: String -> [Double] -> ControlPattern
- ccvCount :: String -> ControlPattern
- ccvCountTo :: String -> Pattern Double -> Pattern ValueMap
- ccvbus :: Pattern Int -> Pattern Double -> ControlPattern
- channel :: Pattern Int -> ControlPattern
- channelTake :: String -> [Double] -> ControlPattern
- channelCount :: String -> ControlPattern
- channelCountTo :: String -> Pattern Double -> Pattern ValueMap
- channelbus :: Pattern Int -> Pattern Int -> ControlPattern
- clhatdecay :: Pattern Double -> ControlPattern
- clhatdecayTake :: String -> [Double] -> ControlPattern
- clhatdecayCount :: String -> ControlPattern
- clhatdecayCountTo :: String -> Pattern Double -> Pattern ValueMap
- clhatdecaybus :: Pattern Int -> Pattern Double -> ControlPattern
- clhatdecayrecv :: Pattern Int -> ControlPattern
- coarse :: Pattern Double -> ControlPattern
- coarseTake :: String -> [Double] -> ControlPattern
- coarseCount :: String -> ControlPattern
- coarseCountTo :: String -> Pattern Double -> Pattern ValueMap
- coarsebus :: Pattern Int -> Pattern Double -> ControlPattern
- coarserecv :: Pattern Int -> ControlPattern
- comb :: Pattern Double -> ControlPattern
- combTake :: String -> [Double] -> ControlPattern
- combCount :: String -> ControlPattern
- combCountTo :: String -> Pattern Double -> Pattern ValueMap
- combbus :: Pattern Int -> Pattern Double -> ControlPattern
- combrecv :: Pattern Int -> ControlPattern
- control :: Pattern Double -> ControlPattern
- controlTake :: String -> [Double] -> ControlPattern
- controlCount :: String -> ControlPattern
- controlCountTo :: String -> Pattern Double -> Pattern ValueMap
- controlbus :: Pattern Int -> Pattern Double -> ControlPattern
- cps :: Pattern Double -> ControlPattern
- cpsTake :: String -> [Double] -> ControlPattern
- cpsCount :: String -> ControlPattern
- cpsCountTo :: String -> Pattern Double -> Pattern ValueMap
- cpsbus :: Pattern Int -> Pattern Double -> ControlPattern
- cpsrecv :: Pattern Int -> ControlPattern
- crush :: Pattern Double -> ControlPattern
- crushTake :: String -> [Double] -> ControlPattern
- crushCount :: String -> ControlPattern
- crushCountTo :: String -> Pattern Double -> Pattern ValueMap
- crushbus :: Pattern Int -> Pattern Double -> ControlPattern
- crushrecv :: Pattern Int -> ControlPattern
- ctlNum :: Pattern Double -> ControlPattern
- ctlNumTake :: String -> [Double] -> ControlPattern
- ctlNumCount :: String -> ControlPattern
- ctlNumCountTo :: String -> Pattern Double -> Pattern ValueMap
- ctlNumbus :: Pattern Int -> Pattern Double -> ControlPattern
- ctranspose :: Pattern Double -> ControlPattern
- ctransposeTake :: String -> [Double] -> ControlPattern
- ctransposeCount :: String -> ControlPattern
- ctransposeCountTo :: String -> Pattern Double -> Pattern ValueMap
- ctransposebus :: Pattern Int -> Pattern Double -> ControlPattern
- ctransposerecv :: Pattern Int -> ControlPattern
- cut :: Pattern Int -> ControlPattern
- cutTake :: String -> [Double] -> ControlPattern
- cutCount :: String -> ControlPattern
- cutCountTo :: String -> Pattern Double -> Pattern ValueMap
- cutbus :: Pattern Int -> Pattern Int -> ControlPattern
- cutrecv :: Pattern Int -> ControlPattern
- cutoff :: Pattern Double -> ControlPattern
- cutoffTake :: String -> [Double] -> ControlPattern
- cutoffCount :: String -> ControlPattern
- cutoffCountTo :: String -> Pattern Double -> Pattern ValueMap
- cutoffbus :: Pattern Int -> Pattern Double -> ControlPattern
- cutoffrecv :: Pattern Int -> ControlPattern
- cutoffegint :: Pattern Double -> ControlPattern
- cutoffegintTake :: String -> [Double] -> ControlPattern
- cutoffegintCount :: String -> ControlPattern
- cutoffegintCountTo :: String -> Pattern Double -> Pattern ValueMap
- cutoffegintbus :: Pattern Int -> Pattern Double -> ControlPattern
- cutoffegintrecv :: Pattern Int -> ControlPattern
- decay :: Pattern Double -> ControlPattern
- decayTake :: String -> [Double] -> ControlPattern
- decayCount :: String -> ControlPattern
- decayCountTo :: String -> Pattern Double -> Pattern ValueMap
- decaybus :: Pattern Int -> Pattern Double -> ControlPattern
- decayrecv :: Pattern Int -> ControlPattern
- degree :: Pattern Double -> ControlPattern
- degreeTake :: String -> [Double] -> ControlPattern
- degreeCount :: String -> ControlPattern
- degreeCountTo :: String -> Pattern Double -> Pattern ValueMap
- degreebus :: Pattern Int -> Pattern Double -> ControlPattern
- degreerecv :: Pattern Int -> ControlPattern
- delay :: Pattern Double -> ControlPattern
- delayTake :: String -> [Double] -> ControlPattern
- delayCount :: String -> ControlPattern
- delayCountTo :: String -> Pattern Double -> Pattern ValueMap
- delaybus :: Pattern Int -> Pattern Double -> ControlPattern
- delayrecv :: Pattern Int -> ControlPattern
- delayfeedback :: Pattern Double -> ControlPattern
- delayfeedbackTake :: String -> [Double] -> ControlPattern
- delayfeedbackCount :: String -> ControlPattern
- delayfeedbackCountTo :: String -> Pattern Double -> Pattern ValueMap
- delayfeedbackbus :: Pattern Int -> Pattern Double -> ControlPattern
- delayfeedbackrecv :: Pattern Int -> ControlPattern
- delaytime :: Pattern Double -> ControlPattern
- delaytimeTake :: String -> [Double] -> ControlPattern
- delaytimeCount :: String -> ControlPattern
- delaytimeCountTo :: String -> Pattern Double -> Pattern ValueMap
- delaytimebus :: Pattern Int -> Pattern Double -> ControlPattern
- delaytimerecv :: Pattern Int -> ControlPattern
- detune :: Pattern Double -> ControlPattern
- detuneTake :: String -> [Double] -> ControlPattern
- detuneCount :: String -> ControlPattern
- detuneCountTo :: String -> Pattern Double -> Pattern ValueMap
- detunebus :: Pattern Int -> Pattern Double -> ControlPattern
- detunerecv :: Pattern Int -> ControlPattern
- distort :: Pattern Double -> ControlPattern
- distortTake :: String -> [Double] -> ControlPattern
- distortCount :: String -> ControlPattern
- distortCountTo :: String -> Pattern Double -> Pattern ValueMap
- distortbus :: Pattern Int -> Pattern Double -> ControlPattern
- distortrecv :: Pattern Int -> ControlPattern
- djf :: Pattern Double -> ControlPattern
- djfTake :: String -> [Double] -> ControlPattern
- djfCount :: String -> ControlPattern
- djfCountTo :: String -> Pattern Double -> Pattern ValueMap
- djfbus :: Pattern Int -> Pattern Double -> ControlPattern
- djfrecv :: Pattern Int -> ControlPattern
- dry :: Pattern Double -> ControlPattern
- dryTake :: String -> [Double] -> ControlPattern
- dryCount :: String -> ControlPattern
- dryCountTo :: String -> Pattern Double -> Pattern ValueMap
- drybus :: Pattern Int -> Pattern Double -> ControlPattern
- dryrecv :: Pattern Int -> ControlPattern
- dur :: Pattern Double -> ControlPattern
- durTake :: String -> [Double] -> ControlPattern
- durCount :: String -> ControlPattern
- durCountTo :: String -> Pattern Double -> Pattern ValueMap
- durbus :: Pattern Int -> Pattern Double -> ControlPattern
- durrecv :: Pattern Int -> ControlPattern
- end :: Pattern Double -> ControlPattern
- endTake :: String -> [Double] -> ControlPattern
- endCount :: String -> ControlPattern
- endCountTo :: String -> Pattern Double -> Pattern ValueMap
- endbus :: Pattern Int -> Pattern Double -> ControlPattern
- enhance :: Pattern Double -> ControlPattern
- enhanceTake :: String -> [Double] -> ControlPattern
- enhanceCount :: String -> ControlPattern
- enhanceCountTo :: String -> Pattern Double -> Pattern ValueMap
- enhancebus :: Pattern Int -> Pattern Double -> ControlPattern
- enhancerecv :: Pattern Int -> ControlPattern
- expression :: Pattern Double -> ControlPattern
- expressionTake :: String -> [Double] -> ControlPattern
- expressionCount :: String -> ControlPattern
- expressionCountTo :: String -> Pattern Double -> Pattern ValueMap
- expressionbus :: Pattern Int -> Pattern Double -> ControlPattern
- expressionrecv :: Pattern Int -> ControlPattern
- fadeInTime :: Pattern Double -> ControlPattern
- fadeInTimeTake :: String -> [Double] -> ControlPattern
- fadeInTimeCount :: String -> ControlPattern
- fadeInTimeCountTo :: String -> Pattern Double -> Pattern ValueMap
- fadeInTimebus :: Pattern Int -> Pattern Double -> ControlPattern
- fadeTime :: Pattern Double -> ControlPattern
- fadeTimeTake :: String -> [Double] -> ControlPattern
- fadeTimeCount :: String -> ControlPattern
- fadeTimeCountTo :: String -> Pattern Double -> Pattern ValueMap
- fadeTimebus :: Pattern Int -> Pattern Double -> ControlPattern
- frameRate :: Pattern Double -> ControlPattern
- frameRateTake :: String -> [Double] -> ControlPattern
- frameRateCount :: String -> ControlPattern
- frameRateCountTo :: String -> Pattern Double -> Pattern ValueMap
- frameRatebus :: Pattern Int -> Pattern Double -> ControlPattern
- frames :: Pattern Double -> ControlPattern
- framesTake :: String -> [Double] -> ControlPattern
- framesCount :: String -> ControlPattern
- framesCountTo :: String -> Pattern Double -> Pattern ValueMap
- framesbus :: Pattern Int -> Pattern Double -> ControlPattern
- freezeTake :: String -> [Double] -> ControlPattern
- freezeCount :: String -> ControlPattern
- freezeCountTo :: String -> Pattern Double -> Pattern ValueMap
- freezebus :: Pattern Int -> Pattern Double -> ControlPattern
- freezerecv :: Pattern Int -> ControlPattern
- freq :: Pattern Double -> ControlPattern
- freqTake :: String -> [Double] -> ControlPattern
- freqCount :: String -> ControlPattern
- freqCountTo :: String -> Pattern Double -> Pattern ValueMap
- freqbus :: Pattern Int -> Pattern Double -> ControlPattern
- freqrecv :: Pattern Int -> ControlPattern
- fromTake :: String -> [Double] -> ControlPattern
- fromCount :: String -> ControlPattern
- fromCountTo :: String -> Pattern Double -> Pattern ValueMap
- frombus :: Pattern Int -> Pattern Double -> ControlPattern
- fromrecv :: Pattern Int -> ControlPattern
- fshift :: Pattern Double -> ControlPattern
- fshiftTake :: String -> [Double] -> ControlPattern
- fshiftCount :: String -> ControlPattern
- fshiftCountTo :: String -> Pattern Double -> Pattern ValueMap
- fshiftbus :: Pattern Int -> Pattern Double -> ControlPattern
- fshiftrecv :: Pattern Int -> ControlPattern
- fshiftnote :: Pattern Double -> ControlPattern
- fshiftnoteTake :: String -> [Double] -> ControlPattern
- fshiftnoteCount :: String -> ControlPattern
- fshiftnoteCountTo :: String -> Pattern Double -> Pattern ValueMap
- fshiftnotebus :: Pattern Int -> Pattern Double -> ControlPattern
- fshiftnoterecv :: Pattern Int -> ControlPattern
- fshiftphase :: Pattern Double -> ControlPattern
- fshiftphaseTake :: String -> [Double] -> ControlPattern
- fshiftphaseCount :: String -> ControlPattern
- fshiftphaseCountTo :: String -> Pattern Double -> Pattern ValueMap
- fshiftphasebus :: Pattern Int -> Pattern Double -> ControlPattern
- fshiftphaserecv :: Pattern Int -> ControlPattern
- gain :: Pattern Double -> ControlPattern
- gainTake :: String -> [Double] -> ControlPattern
- gainCount :: String -> ControlPattern
- gainCountTo :: String -> Pattern Double -> Pattern ValueMap
- gainbus :: Pattern Int -> Pattern Double -> ControlPattern
- gate :: Pattern Double -> ControlPattern
- gateTake :: String -> [Double] -> ControlPattern
- gateCount :: String -> ControlPattern
- gateCountTo :: String -> Pattern Double -> Pattern ValueMap
- gatebus :: Pattern Int -> Pattern Double -> ControlPattern
- gaterecv :: Pattern Int -> ControlPattern
- harmonic :: Pattern Double -> ControlPattern
- harmonicTake :: String -> [Double] -> ControlPattern
- harmonicCount :: String -> ControlPattern
- harmonicCountTo :: String -> Pattern Double -> Pattern ValueMap
- harmonicbus :: Pattern Int -> Pattern Double -> ControlPattern
- harmonicrecv :: Pattern Int -> ControlPattern
- hatgrain :: Pattern Double -> ControlPattern
- hatgrainTake :: String -> [Double] -> ControlPattern
- hatgrainCount :: String -> ControlPattern
- hatgrainCountTo :: String -> Pattern Double -> Pattern ValueMap
- hatgrainbus :: Pattern Int -> Pattern Double -> ControlPattern
- hatgrainrecv :: Pattern Int -> ControlPattern
- hbrick :: Pattern Double -> ControlPattern
- hbrickTake :: String -> [Double] -> ControlPattern
- hbrickCount :: String -> ControlPattern
- hbrickCountTo :: String -> Pattern Double -> Pattern ValueMap
- hbrickbus :: Pattern Int -> Pattern Double -> ControlPattern
- hbrickrecv :: Pattern Int -> ControlPattern
- hcutoff :: Pattern Double -> ControlPattern
- hcutoffTake :: String -> [Double] -> ControlPattern
- hcutoffCount :: String -> ControlPattern
- hcutoffCountTo :: String -> Pattern Double -> Pattern ValueMap
- hcutoffbus :: Pattern Int -> Pattern Double -> ControlPattern
- hcutoffrecv :: Pattern Int -> ControlPattern
- hold :: Pattern Double -> ControlPattern
- holdTake :: String -> [Double] -> ControlPattern
- holdCount :: String -> ControlPattern
- holdCountTo :: String -> Pattern Double -> Pattern ValueMap
- holdbus :: Pattern Int -> Pattern Double -> ControlPattern
- holdrecv :: Pattern Int -> ControlPattern
- hours :: Pattern Double -> ControlPattern
- hoursTake :: String -> [Double] -> ControlPattern
- hoursCount :: String -> ControlPattern
- hoursCountTo :: String -> Pattern Double -> Pattern ValueMap
- hoursbus :: Pattern Int -> Pattern Double -> ControlPattern
- hresonance :: Pattern Double -> ControlPattern
- hresonanceTake :: String -> [Double] -> ControlPattern
- hresonanceCount :: String -> ControlPattern
- hresonanceCountTo :: String -> Pattern Double -> Pattern ValueMap
- hresonancebus :: Pattern Int -> Pattern Double -> ControlPattern
- hresonancerecv :: Pattern Int -> ControlPattern
- imag :: Pattern Double -> ControlPattern
- imagTake :: String -> [Double] -> ControlPattern
- imagCount :: String -> ControlPattern
- imagCountTo :: String -> Pattern Double -> Pattern ValueMap
- imagbus :: Pattern Int -> Pattern Double -> ControlPattern
- imagrecv :: Pattern Int -> ControlPattern
- kcutoff :: Pattern Double -> ControlPattern
- kcutoffTake :: String -> [Double] -> ControlPattern
- kcutoffCount :: String -> ControlPattern
- kcutoffCountTo :: String -> Pattern Double -> Pattern ValueMap
- kcutoffbus :: Pattern Int -> Pattern Double -> ControlPattern
- kcutoffrecv :: Pattern Int -> ControlPattern
- krush :: Pattern Double -> ControlPattern
- krushTake :: String -> [Double] -> ControlPattern
- krushCount :: String -> ControlPattern
- krushCountTo :: String -> Pattern Double -> Pattern ValueMap
- krushbus :: Pattern Int -> Pattern Double -> ControlPattern
- krushrecv :: Pattern Int -> ControlPattern
- lagogo :: Pattern Double -> ControlPattern
- lagogoTake :: String -> [Double] -> ControlPattern
- lagogoCount :: String -> ControlPattern
- lagogoCountTo :: String -> Pattern Double -> Pattern ValueMap
- lagogobus :: Pattern Int -> Pattern Double -> ControlPattern
- lagogorecv :: Pattern Int -> ControlPattern
- lbrick :: Pattern Double -> ControlPattern
- lbrickTake :: String -> [Double] -> ControlPattern
- lbrickCount :: String -> ControlPattern
- lbrickCountTo :: String -> Pattern Double -> Pattern ValueMap
- lbrickbus :: Pattern Int -> Pattern Double -> ControlPattern
- lbrickrecv :: Pattern Int -> ControlPattern
- lclap :: Pattern Double -> ControlPattern
- lclapTake :: String -> [Double] -> ControlPattern
- lclapCount :: String -> ControlPattern
- lclapCountTo :: String -> Pattern Double -> Pattern ValueMap
- lclapbus :: Pattern Int -> Pattern Double -> ControlPattern
- lclaprecv :: Pattern Int -> ControlPattern
- lclaves :: Pattern Double -> ControlPattern
- lclavesTake :: String -> [Double] -> ControlPattern
- lclavesCount :: String -> ControlPattern
- lclavesCountTo :: String -> Pattern Double -> Pattern ValueMap
- lclavesbus :: Pattern Int -> Pattern Double -> ControlPattern
- lclavesrecv :: Pattern Int -> ControlPattern
- lclhat :: Pattern Double -> ControlPattern
- lclhatTake :: String -> [Double] -> ControlPattern
- lclhatCount :: String -> ControlPattern
- lclhatCountTo :: String -> Pattern Double -> Pattern ValueMap
- lclhatbus :: Pattern Int -> Pattern Double -> ControlPattern
- lclhatrecv :: Pattern Int -> ControlPattern
- lcrash :: Pattern Double -> ControlPattern
- lcrashTake :: String -> [Double] -> ControlPattern
- lcrashCount :: String -> ControlPattern
- lcrashCountTo :: String -> Pattern Double -> Pattern ValueMap
- lcrashbus :: Pattern Int -> Pattern Double -> ControlPattern
- lcrashrecv :: Pattern Int -> ControlPattern
- legato :: Pattern Double -> ControlPattern
- legatoTake :: String -> [Double] -> ControlPattern
- legatoCount :: String -> ControlPattern
- legatoCountTo :: String -> Pattern Double -> Pattern ValueMap
- legatobus :: Pattern Int -> Pattern Double -> ControlPattern
- clip :: Pattern Double -> ControlPattern
- leslie :: Pattern Double -> ControlPattern
- leslieTake :: String -> [Double] -> ControlPattern
- leslieCount :: String -> ControlPattern
- leslieCountTo :: String -> Pattern Double -> Pattern ValueMap
- lesliebus :: Pattern Int -> Pattern Double -> ControlPattern
- leslierecv :: Pattern Int -> ControlPattern
- lfo :: Pattern Double -> ControlPattern
- lfoTake :: String -> [Double] -> ControlPattern
- lfoCount :: String -> ControlPattern
- lfoCountTo :: String -> Pattern Double -> Pattern ValueMap
- lfobus :: Pattern Int -> Pattern Double -> ControlPattern
- lforecv :: Pattern Int -> ControlPattern
- lfocutoffint :: Pattern Double -> ControlPattern
- lfocutoffintTake :: String -> [Double] -> ControlPattern
- lfocutoffintCount :: String -> ControlPattern
- lfocutoffintCountTo :: String -> Pattern Double -> Pattern ValueMap
- lfocutoffintbus :: Pattern Int -> Pattern Double -> ControlPattern
- lfocutoffintrecv :: Pattern Int -> ControlPattern
- lfodelay :: Pattern Double -> ControlPattern
- lfodelayTake :: String -> [Double] -> ControlPattern
- lfodelayCount :: String -> ControlPattern
- lfodelayCountTo :: String -> Pattern Double -> Pattern ValueMap
- lfodelaybus :: Pattern Int -> Pattern Double -> ControlPattern
- lfodelayrecv :: Pattern Int -> ControlPattern
- lfoint :: Pattern Double -> ControlPattern
- lfointTake :: String -> [Double] -> ControlPattern
- lfointCount :: String -> ControlPattern
- lfointCountTo :: String -> Pattern Double -> Pattern ValueMap
- lfointbus :: Pattern Int -> Pattern Double -> ControlPattern
- lfointrecv :: Pattern Int -> ControlPattern
- lfopitchint :: Pattern Double -> ControlPattern
- lfopitchintTake :: String -> [Double] -> ControlPattern
- lfopitchintCount :: String -> ControlPattern
- lfopitchintCountTo :: String -> Pattern Double -> Pattern ValueMap
- lfopitchintbus :: Pattern Int -> Pattern Double -> ControlPattern
- lfopitchintrecv :: Pattern Int -> ControlPattern
- lfoshape :: Pattern Double -> ControlPattern
- lfoshapeTake :: String -> [Double] -> ControlPattern
- lfoshapeCount :: String -> ControlPattern
- lfoshapeCountTo :: String -> Pattern Double -> Pattern ValueMap
- lfoshapebus :: Pattern Int -> Pattern Double -> ControlPattern
- lfoshaperecv :: Pattern Int -> ControlPattern
- lfosync :: Pattern Double -> ControlPattern
- lfosyncTake :: String -> [Double] -> ControlPattern
- lfosyncCount :: String -> ControlPattern
- lfosyncCountTo :: String -> Pattern Double -> Pattern ValueMap
- lfosyncbus :: Pattern Int -> Pattern Double -> ControlPattern
- lfosyncrecv :: Pattern Int -> ControlPattern
- lhitom :: Pattern Double -> ControlPattern
- lhitomTake :: String -> [Double] -> ControlPattern
- lhitomCount :: String -> ControlPattern
- lhitomCountTo :: String -> Pattern Double -> Pattern ValueMap
- lhitombus :: Pattern Int -> Pattern Double -> ControlPattern
- lhitomrecv :: Pattern Int -> ControlPattern
- lkick :: Pattern Double -> ControlPattern
- lkickTake :: String -> [Double] -> ControlPattern
- lkickCount :: String -> ControlPattern
- lkickCountTo :: String -> Pattern Double -> Pattern ValueMap
- lkickbus :: Pattern Int -> Pattern Double -> ControlPattern
- lkickrecv :: Pattern Int -> ControlPattern
- llotom :: Pattern Double -> ControlPattern
- llotomTake :: String -> [Double] -> ControlPattern
- llotomCount :: String -> ControlPattern
- llotomCountTo :: String -> Pattern Double -> Pattern ValueMap
- llotombus :: Pattern Int -> Pattern Double -> ControlPattern
- llotomrecv :: Pattern Int -> ControlPattern
- lock :: Pattern Double -> ControlPattern
- lockTake :: String -> [Double] -> ControlPattern
- lockCount :: String -> ControlPattern
- lockCountTo :: String -> Pattern Double -> Pattern ValueMap
- lockbus :: Pattern Int -> Pattern Double -> ControlPattern
- lockrecv :: Pattern Int -> ControlPattern
- loopTake :: String -> [Double] -> ControlPattern
- loopCount :: String -> ControlPattern
- loopCountTo :: String -> Pattern Double -> Pattern ValueMap
- loopbus :: Pattern Int -> Pattern Double -> ControlPattern
- lophat :: Pattern Double -> ControlPattern
- lophatTake :: String -> [Double] -> ControlPattern
- lophatCount :: String -> ControlPattern
- lophatCountTo :: String -> Pattern Double -> Pattern ValueMap
- lophatbus :: Pattern Int -> Pattern Double -> ControlPattern
- lophatrecv :: Pattern Int -> ControlPattern
- lrate :: Pattern Double -> ControlPattern
- lrateTake :: String -> [Double] -> ControlPattern
- lrateCount :: String -> ControlPattern
- lrateCountTo :: String -> Pattern Double -> Pattern ValueMap
- lratebus :: Pattern Int -> Pattern Double -> ControlPattern
- lraterecv :: Pattern Int -> ControlPattern
- lsize :: Pattern Double -> ControlPattern
- lsizeTake :: String -> [Double] -> ControlPattern
- lsizeCount :: String -> ControlPattern
- lsizeCountTo :: String -> Pattern Double -> Pattern ValueMap
- lsizebus :: Pattern Int -> Pattern Double -> ControlPattern
- lsizerecv :: Pattern Int -> ControlPattern
- lsnare :: Pattern Double -> ControlPattern
- lsnareTake :: String -> [Double] -> ControlPattern
- lsnareCount :: String -> ControlPattern
- lsnareCountTo :: String -> Pattern Double -> Pattern ValueMap
- lsnarebus :: Pattern Int -> Pattern Double -> ControlPattern
- lsnarerecv :: Pattern Int -> ControlPattern
- metatune :: Pattern Double -> ControlPattern
- metatuneTake :: String -> [Double] -> ControlPattern
- metatuneCount :: String -> ControlPattern
- metatuneCountTo :: String -> Pattern Double -> Pattern ValueMap
- metatunebus :: Pattern Int -> Pattern Double -> ControlPattern
- metatunerecv :: Pattern Int -> ControlPattern
- midibend :: Pattern Double -> ControlPattern
- midibendTake :: String -> [Double] -> ControlPattern
- midibendCount :: String -> ControlPattern
- midibendCountTo :: String -> Pattern Double -> Pattern ValueMap
- midibendbus :: Pattern Int -> Pattern Double -> ControlPattern
- midichan :: Pattern Double -> ControlPattern
- midichanTake :: String -> [Double] -> ControlPattern
- midichanCount :: String -> ControlPattern
- midichanCountTo :: String -> Pattern Double -> Pattern ValueMap
- midichanbus :: Pattern Int -> Pattern Double -> ControlPattern
- midicmd :: Pattern String -> ControlPattern
- midicmdTake :: String -> [Double] -> ControlPattern
- midicmdbus :: Pattern Int -> Pattern String -> ControlPattern
- miditouch :: Pattern Double -> ControlPattern
- miditouchTake :: String -> [Double] -> ControlPattern
- miditouchCount :: String -> ControlPattern
- miditouchCountTo :: String -> Pattern Double -> Pattern ValueMap
- miditouchbus :: Pattern Int -> Pattern Double -> ControlPattern
- minutes :: Pattern Double -> ControlPattern
- minutesTake :: String -> [Double] -> ControlPattern
- minutesCount :: String -> ControlPattern
- minutesCountTo :: String -> Pattern Double -> Pattern ValueMap
- minutesbus :: Pattern Int -> Pattern Double -> ControlPattern
- modwheel :: Pattern Double -> ControlPattern
- modwheelTake :: String -> [Double] -> ControlPattern
- modwheelCount :: String -> ControlPattern
- modwheelCountTo :: String -> Pattern Double -> Pattern ValueMap
- modwheelbus :: Pattern Int -> Pattern Double -> ControlPattern
- modwheelrecv :: Pattern Int -> ControlPattern
- mtranspose :: Pattern Double -> ControlPattern
- mtransposeTake :: String -> [Double] -> ControlPattern
- mtransposeCount :: String -> ControlPattern
- mtransposeCountTo :: String -> Pattern Double -> Pattern ValueMap
- mtransposebus :: Pattern Int -> Pattern Double -> ControlPattern
- mtransposerecv :: Pattern Int -> ControlPattern
- n :: Pattern Note -> ControlPattern
- nTake :: String -> [Double] -> ControlPattern
- nCount :: String -> ControlPattern
- nCountTo :: String -> Pattern Double -> Pattern ValueMap
- nbus :: Pattern Int -> Pattern Note -> ControlPattern
- note :: Pattern Note -> ControlPattern
- noteTake :: String -> [Double] -> ControlPattern
- noteCount :: String -> ControlPattern
- noteCountTo :: String -> Pattern Double -> Pattern ValueMap
- notebus :: Pattern Int -> Pattern Note -> ControlPattern
- nudge :: Pattern Double -> ControlPattern
- nudgeTake :: String -> [Double] -> ControlPattern
- nudgeCount :: String -> ControlPattern
- nudgeCountTo :: String -> Pattern Double -> Pattern ValueMap
- nudgebus :: Pattern Int -> Pattern Double -> ControlPattern
- nudgerecv :: Pattern Int -> ControlPattern
- octave :: Pattern Int -> ControlPattern
- octaveTake :: String -> [Double] -> ControlPattern
- octaveCount :: String -> ControlPattern
- octaveCountTo :: String -> Pattern Double -> Pattern ValueMap
- octavebus :: Pattern Int -> Pattern Int -> ControlPattern
- octaveR :: Pattern Double -> ControlPattern
- octaveRTake :: String -> [Double] -> ControlPattern
- octaveRCount :: String -> ControlPattern
- octaveRCountTo :: String -> Pattern Double -> Pattern ValueMap
- octaveRbus :: Pattern Int -> Pattern Double -> ControlPattern
- octaveRrecv :: Pattern Int -> ControlPattern
- octer :: Pattern Double -> ControlPattern
- octerTake :: String -> [Double] -> ControlPattern
- octerCount :: String -> ControlPattern
- octerCountTo :: String -> Pattern Double -> Pattern ValueMap
- octerbus :: Pattern Int -> Pattern Double -> ControlPattern
- octerrecv :: Pattern Int -> ControlPattern
- octersub :: Pattern Double -> ControlPattern
- octersubTake :: String -> [Double] -> ControlPattern
- octersubCount :: String -> ControlPattern
- octersubCountTo :: String -> Pattern Double -> Pattern ValueMap
- octersubbus :: Pattern Int -> Pattern Double -> ControlPattern
- octersubrecv :: Pattern Int -> ControlPattern
- octersubsub :: Pattern Double -> ControlPattern
- octersubsubTake :: String -> [Double] -> ControlPattern
- octersubsubCount :: String -> ControlPattern
- octersubsubCountTo :: String -> Pattern Double -> Pattern ValueMap
- octersubsubbus :: Pattern Int -> Pattern Double -> ControlPattern
- octersubsubrecv :: Pattern Int -> ControlPattern
- offset :: Pattern Double -> ControlPattern
- offsetTake :: String -> [Double] -> ControlPattern
- offsetCount :: String -> ControlPattern
- offsetCountTo :: String -> Pattern Double -> Pattern ValueMap
- offsetbus :: Pattern Int -> Pattern Double -> ControlPattern
- ophatdecay :: Pattern Double -> ControlPattern
- ophatdecayTake :: String -> [Double] -> ControlPattern
- ophatdecayCount :: String -> ControlPattern
- ophatdecayCountTo :: String -> Pattern Double -> Pattern ValueMap
- ophatdecaybus :: Pattern Int -> Pattern Double -> ControlPattern
- ophatdecayrecv :: Pattern Int -> ControlPattern
- orbit :: Pattern Int -> ControlPattern
- orbitTake :: String -> [Double] -> ControlPattern
- orbitCount :: String -> ControlPattern
- orbitCountTo :: String -> Pattern Double -> Pattern ValueMap
- orbitbus :: Pattern Int -> Pattern Int -> ControlPattern
- orbitrecv :: Pattern Int -> ControlPattern
- overgain :: Pattern Double -> ControlPattern
- overgainTake :: String -> [Double] -> ControlPattern
- overgainCount :: String -> ControlPattern
- overgainCountTo :: String -> Pattern Double -> Pattern ValueMap
- overgainbus :: Pattern Int -> Pattern Double -> ControlPattern
- overshape :: Pattern Double -> ControlPattern
- overshapeTake :: String -> [Double] -> ControlPattern
- overshapeCount :: String -> ControlPattern
- overshapeCountTo :: String -> Pattern Double -> Pattern ValueMap
- overshapebus :: Pattern Int -> Pattern Double -> ControlPattern
- overshaperecv :: Pattern Int -> ControlPattern
- pan :: Pattern Double -> ControlPattern
- panTake :: String -> [Double] -> ControlPattern
- panCount :: String -> ControlPattern
- panCountTo :: String -> Pattern Double -> Pattern ValueMap
- panbus :: Pattern Int -> Pattern Double -> ControlPattern
- panrecv :: Pattern Int -> ControlPattern
- panorient :: Pattern Double -> ControlPattern
- panorientTake :: String -> [Double] -> ControlPattern
- panorientCount :: String -> ControlPattern
- panorientCountTo :: String -> Pattern Double -> Pattern ValueMap
- panorientbus :: Pattern Int -> Pattern Double -> ControlPattern
- panorientrecv :: Pattern Int -> ControlPattern
- panspan :: Pattern Double -> ControlPattern
- panspanTake :: String -> [Double] -> ControlPattern
- panspanCount :: String -> ControlPattern
- panspanCountTo :: String -> Pattern Double -> Pattern ValueMap
- panspanbus :: Pattern Int -> Pattern Double -> ControlPattern
- panspanrecv :: Pattern Int -> ControlPattern
- pansplay :: Pattern Double -> ControlPattern
- pansplayTake :: String -> [Double] -> ControlPattern
- pansplayCount :: String -> ControlPattern
- pansplayCountTo :: String -> Pattern Double -> Pattern ValueMap
- pansplaybus :: Pattern Int -> Pattern Double -> ControlPattern
- pansplayrecv :: Pattern Int -> ControlPattern
- panwidth :: Pattern Double -> ControlPattern
- panwidthTake :: String -> [Double] -> ControlPattern
- panwidthCount :: String -> ControlPattern
- panwidthCountTo :: String -> Pattern Double -> Pattern ValueMap
- panwidthbus :: Pattern Int -> Pattern Double -> ControlPattern
- panwidthrecv :: Pattern Int -> ControlPattern
- partials :: Pattern Double -> ControlPattern
- partialsTake :: String -> [Double] -> ControlPattern
- partialsCount :: String -> ControlPattern
- partialsCountTo :: String -> Pattern Double -> Pattern ValueMap
- partialsbus :: Pattern Int -> Pattern Double -> ControlPattern
- partialsrecv :: Pattern Int -> ControlPattern
- phaserdepth :: Pattern Double -> ControlPattern
- phaserdepthTake :: String -> [Double] -> ControlPattern
- phaserdepthCount :: String -> ControlPattern
- phaserdepthCountTo :: String -> Pattern Double -> Pattern ValueMap
- phaserdepthbus :: Pattern Int -> Pattern Double -> ControlPattern
- phaserdepthrecv :: Pattern Int -> ControlPattern
- phaserrate :: Pattern Double -> ControlPattern
- phaserrateTake :: String -> [Double] -> ControlPattern
- phaserrateCount :: String -> ControlPattern
- phaserrateCountTo :: String -> Pattern Double -> Pattern ValueMap
- phaserratebus :: Pattern Int -> Pattern Double -> ControlPattern
- phaserraterecv :: Pattern Int -> ControlPattern
- pitch1 :: Pattern Double -> ControlPattern
- pitch1Take :: String -> [Double] -> ControlPattern
- pitch1Count :: String -> ControlPattern
- pitch1CountTo :: String -> Pattern Double -> Pattern ValueMap
- pitch1bus :: Pattern Int -> Pattern Double -> ControlPattern
- pitch1recv :: Pattern Int -> ControlPattern
- pitch2 :: Pattern Double -> ControlPattern
- pitch2Take :: String -> [Double] -> ControlPattern
- pitch2Count :: String -> ControlPattern
- pitch2CountTo :: String -> Pattern Double -> Pattern ValueMap
- pitch2bus :: Pattern Int -> Pattern Double -> ControlPattern
- pitch2recv :: Pattern Int -> ControlPattern
- pitch3 :: Pattern Double -> ControlPattern
- pitch3Take :: String -> [Double] -> ControlPattern
- pitch3Count :: String -> ControlPattern
- pitch3CountTo :: String -> Pattern Double -> Pattern ValueMap
- pitch3bus :: Pattern Int -> Pattern Double -> ControlPattern
- pitch3recv :: Pattern Int -> ControlPattern
- polyTouch :: Pattern Double -> ControlPattern
- polyTouchTake :: String -> [Double] -> ControlPattern
- polyTouchCount :: String -> ControlPattern
- polyTouchCountTo :: String -> Pattern Double -> Pattern ValueMap
- polyTouchbus :: Pattern Int -> Pattern Double -> ControlPattern
- portamento :: Pattern Double -> ControlPattern
- portamentoTake :: String -> [Double] -> ControlPattern
- portamentoCount :: String -> ControlPattern
- portamentoCountTo :: String -> Pattern Double -> Pattern ValueMap
- portamentobus :: Pattern Int -> Pattern Double -> ControlPattern
- portamentorecv :: Pattern Int -> ControlPattern
- progNum :: Pattern Double -> ControlPattern
- progNumTake :: String -> [Double] -> ControlPattern
- progNumCount :: String -> ControlPattern
- progNumCountTo :: String -> Pattern Double -> Pattern ValueMap
- progNumbus :: Pattern Int -> Pattern Double -> ControlPattern
- rate :: Pattern Double -> ControlPattern
- rateTake :: String -> [Double] -> ControlPattern
- rateCount :: String -> ControlPattern
- rateCountTo :: String -> Pattern Double -> Pattern ValueMap
- ratebus :: Pattern Int -> Pattern Double -> ControlPattern
- raterecv :: Pattern Int -> ControlPattern
- real :: Pattern Double -> ControlPattern
- realTake :: String -> [Double] -> ControlPattern
- realCount :: String -> ControlPattern
- realCountTo :: String -> Pattern Double -> Pattern ValueMap
- realbus :: Pattern Int -> Pattern Double -> ControlPattern
- realrecv :: Pattern Int -> ControlPattern
- releaseTake :: String -> [Double] -> ControlPattern
- releaseCount :: String -> ControlPattern
- releaseCountTo :: String -> Pattern Double -> Pattern ValueMap
- releasebus :: Pattern Int -> Pattern Double -> ControlPattern
- releaserecv :: Pattern Int -> ControlPattern
- resonance :: Pattern Double -> ControlPattern
- resonanceTake :: String -> [Double] -> ControlPattern
- resonanceCount :: String -> ControlPattern
- resonanceCountTo :: String -> Pattern Double -> Pattern ValueMap
- resonancebus :: Pattern Int -> Pattern Double -> ControlPattern
- resonancerecv :: Pattern Int -> ControlPattern
- ring :: Pattern Double -> ControlPattern
- ringTake :: String -> [Double] -> ControlPattern
- ringCount :: String -> ControlPattern
- ringCountTo :: String -> Pattern Double -> Pattern ValueMap
- ringbus :: Pattern Int -> Pattern Double -> ControlPattern
- ringrecv :: Pattern Int -> ControlPattern
- ringdf :: Pattern Double -> ControlPattern
- ringdfTake :: String -> [Double] -> ControlPattern
- ringdfCount :: String -> ControlPattern
- ringdfCountTo :: String -> Pattern Double -> Pattern ValueMap
- ringdfbus :: Pattern Int -> Pattern Double -> ControlPattern
- ringdfrecv :: Pattern Int -> ControlPattern
- ringf :: Pattern Double -> ControlPattern
- ringfTake :: String -> [Double] -> ControlPattern
- ringfCount :: String -> ControlPattern
- ringfCountTo :: String -> Pattern Double -> Pattern ValueMap
- ringfbus :: Pattern Int -> Pattern Double -> ControlPattern
- ringfrecv :: Pattern Int -> ControlPattern
- room :: Pattern Double -> ControlPattern
- roomTake :: String -> [Double] -> ControlPattern
- roomCount :: String -> ControlPattern
- roomCountTo :: String -> Pattern Double -> Pattern ValueMap
- roombus :: Pattern Int -> Pattern Double -> ControlPattern
- roomrecv :: Pattern Int -> ControlPattern
- sagogo :: Pattern Double -> ControlPattern
- sagogoTake :: String -> [Double] -> ControlPattern
- sagogoCount :: String -> ControlPattern
- sagogoCountTo :: String -> Pattern Double -> Pattern ValueMap
- sagogobus :: Pattern Int -> Pattern Double -> ControlPattern
- sagogorecv :: Pattern Int -> ControlPattern
- sclap :: Pattern Double -> ControlPattern
- sclapTake :: String -> [Double] -> ControlPattern
- sclapCount :: String -> ControlPattern
- sclapCountTo :: String -> Pattern Double -> Pattern ValueMap
- sclapbus :: Pattern Int -> Pattern Double -> ControlPattern
- sclaprecv :: Pattern Int -> ControlPattern
- sclaves :: Pattern Double -> ControlPattern
- sclavesTake :: String -> [Double] -> ControlPattern
- sclavesCount :: String -> ControlPattern
- sclavesCountTo :: String -> Pattern Double -> Pattern ValueMap
- sclavesbus :: Pattern Int -> Pattern Double -> ControlPattern
- sclavesrecv :: Pattern Int -> ControlPattern
- scram :: Pattern Double -> ControlPattern
- scramTake :: String -> [Double] -> ControlPattern
- scramCount :: String -> ControlPattern
- scramCountTo :: String -> Pattern Double -> Pattern ValueMap
- scrambus :: Pattern Int -> Pattern Double -> ControlPattern
- scramrecv :: Pattern Int -> ControlPattern
- scrash :: Pattern Double -> ControlPattern
- scrashTake :: String -> [Double] -> ControlPattern
- scrashCount :: String -> ControlPattern
- scrashCountTo :: String -> Pattern Double -> Pattern ValueMap
- scrashbus :: Pattern Int -> Pattern Double -> ControlPattern
- scrashrecv :: Pattern Int -> ControlPattern
- seconds :: Pattern Double -> ControlPattern
- secondsTake :: String -> [Double] -> ControlPattern
- secondsCount :: String -> ControlPattern
- secondsCountTo :: String -> Pattern Double -> Pattern ValueMap
- secondsbus :: Pattern Int -> Pattern Double -> ControlPattern
- semitone :: Pattern Double -> ControlPattern
- semitoneTake :: String -> [Double] -> ControlPattern
- semitoneCount :: String -> ControlPattern
- semitoneCountTo :: String -> Pattern Double -> Pattern ValueMap
- semitonebus :: Pattern Int -> Pattern Double -> ControlPattern
- semitonerecv :: Pattern Int -> ControlPattern
- shape :: Pattern Double -> ControlPattern
- shapeTake :: String -> [Double] -> ControlPattern
- shapeCount :: String -> ControlPattern
- shapeCountTo :: String -> Pattern Double -> Pattern ValueMap
- shapebus :: Pattern Int -> Pattern Double -> ControlPattern
- shaperecv :: Pattern Int -> ControlPattern
- sizeTake :: String -> [Double] -> ControlPattern
- sizeCount :: String -> ControlPattern
- sizeCountTo :: String -> Pattern Double -> Pattern ValueMap
- sizebus :: Pattern Int -> Pattern Double -> ControlPattern
- sizerecv :: Pattern Int -> ControlPattern
- slide :: Pattern Double -> ControlPattern
- slideTake :: String -> [Double] -> ControlPattern
- slideCount :: String -> ControlPattern
- slideCountTo :: String -> Pattern Double -> Pattern ValueMap
- slidebus :: Pattern Int -> Pattern Double -> ControlPattern
- sliderecv :: Pattern Int -> ControlPattern
- slider0 :: Pattern Double -> ControlPattern
- slider0Take :: String -> [Double] -> ControlPattern
- slider0Count :: String -> ControlPattern
- slider0CountTo :: String -> Pattern Double -> Pattern ValueMap
- slider0bus :: Pattern Int -> Pattern Double -> ControlPattern
- slider0recv :: Pattern Int -> ControlPattern
- slider1 :: Pattern Double -> ControlPattern
- slider1Take :: String -> [Double] -> ControlPattern
- slider1Count :: String -> ControlPattern
- slider1CountTo :: String -> Pattern Double -> Pattern ValueMap
- slider1bus :: Pattern Int -> Pattern Double -> ControlPattern
- slider1recv :: Pattern Int -> ControlPattern
- slider10 :: Pattern Double -> ControlPattern
- slider10Take :: String -> [Double] -> ControlPattern
- slider10Count :: String -> ControlPattern
- slider10CountTo :: String -> Pattern Double -> Pattern ValueMap
- slider10bus :: Pattern Int -> Pattern Double -> ControlPattern
- slider10recv :: Pattern Int -> ControlPattern
- slider11 :: Pattern Double -> ControlPattern
- slider11Take :: String -> [Double] -> ControlPattern
- slider11Count :: String -> ControlPattern
- slider11CountTo :: String -> Pattern Double -> Pattern ValueMap
- slider11bus :: Pattern Int -> Pattern Double -> ControlPattern
- slider11recv :: Pattern Int -> ControlPattern
- slider12 :: Pattern Double -> ControlPattern
- slider12Take :: String -> [Double] -> ControlPattern
- slider12Count :: String -> ControlPattern
- slider12CountTo :: String -> Pattern Double -> Pattern ValueMap
- slider12bus :: Pattern Int -> Pattern Double -> ControlPattern
- slider12recv :: Pattern Int -> ControlPattern
- slider13 :: Pattern Double -> ControlPattern
- slider13Take :: String -> [Double] -> ControlPattern
- slider13Count :: String -> ControlPattern
- slider13CountTo :: String -> Pattern Double -> Pattern ValueMap
- slider13bus :: Pattern Int -> Pattern Double -> ControlPattern
- slider13recv :: Pattern Int -> ControlPattern
- slider14 :: Pattern Double -> ControlPattern
- slider14Take :: String -> [Double] -> ControlPattern
- slider14Count :: String -> ControlPattern
- slider14CountTo :: String -> Pattern Double -> Pattern ValueMap
- slider14bus :: Pattern Int -> Pattern Double -> ControlPattern
- slider14recv :: Pattern Int -> ControlPattern
- slider15 :: Pattern Double -> ControlPattern
- slider15Take :: String -> [Double] -> ControlPattern
- slider15Count :: String -> ControlPattern
- slider15CountTo :: String -> Pattern Double -> Pattern ValueMap
- slider15bus :: Pattern Int -> Pattern Double -> ControlPattern
- slider15recv :: Pattern Int -> ControlPattern
- slider2 :: Pattern Double -> ControlPattern
- slider2Take :: String -> [Double] -> ControlPattern
- slider2Count :: String -> ControlPattern
- slider2CountTo :: String -> Pattern Double -> Pattern ValueMap
- slider2bus :: Pattern Int -> Pattern Double -> ControlPattern
- slider2recv :: Pattern Int -> ControlPattern
- slider3 :: Pattern Double -> ControlPattern
- slider3Take :: String -> [Double] -> ControlPattern
- slider3Count :: String -> ControlPattern
- slider3CountTo :: String -> Pattern Double -> Pattern ValueMap
- slider3bus :: Pattern Int -> Pattern Double -> ControlPattern
- slider3recv :: Pattern Int -> ControlPattern
- slider4 :: Pattern Double -> ControlPattern
- slider4Take :: String -> [Double] -> ControlPattern
- slider4Count :: String -> ControlPattern
- slider4CountTo :: String -> Pattern Double -> Pattern ValueMap
- slider4bus :: Pattern Int -> Pattern Double -> ControlPattern
- slider4recv :: Pattern Int -> ControlPattern
- slider5 :: Pattern Double -> ControlPattern
- slider5Take :: String -> [Double] -> ControlPattern
- slider5Count :: String -> ControlPattern
- slider5CountTo :: String -> Pattern Double -> Pattern ValueMap
- slider5bus :: Pattern Int -> Pattern Double -> ControlPattern
- slider5recv :: Pattern Int -> ControlPattern
- slider6 :: Pattern Double -> ControlPattern
- slider6Take :: String -> [Double] -> ControlPattern
- slider6Count :: String -> ControlPattern
- slider6CountTo :: String -> Pattern Double -> Pattern ValueMap
- slider6bus :: Pattern Int -> Pattern Double -> ControlPattern
- slider6recv :: Pattern Int -> ControlPattern
- slider7 :: Pattern Double -> ControlPattern
- slider7Take :: String -> [Double] -> ControlPattern
- slider7Count :: String -> ControlPattern
- slider7CountTo :: String -> Pattern Double -> Pattern ValueMap
- slider7bus :: Pattern Int -> Pattern Double -> ControlPattern
- slider7recv :: Pattern Int -> ControlPattern
- slider8 :: Pattern Double -> ControlPattern
- slider8Take :: String -> [Double] -> ControlPattern
- slider8Count :: String -> ControlPattern
- slider8CountTo :: String -> Pattern Double -> Pattern ValueMap
- slider8bus :: Pattern Int -> Pattern Double -> ControlPattern
- slider8recv :: Pattern Int -> ControlPattern
- slider9 :: Pattern Double -> ControlPattern
- slider9Take :: String -> [Double] -> ControlPattern
- slider9Count :: String -> ControlPattern
- slider9CountTo :: String -> Pattern Double -> Pattern ValueMap
- slider9bus :: Pattern Int -> Pattern Double -> ControlPattern
- slider9recv :: Pattern Int -> ControlPattern
- smear :: Pattern Double -> ControlPattern
- smearTake :: String -> [Double] -> ControlPattern
- smearCount :: String -> ControlPattern
- smearCountTo :: String -> Pattern Double -> Pattern ValueMap
- smearbus :: Pattern Int -> Pattern Double -> ControlPattern
- smearrecv :: Pattern Int -> ControlPattern
- songPtr :: Pattern Double -> ControlPattern
- songPtrTake :: String -> [Double] -> ControlPattern
- songPtrCount :: String -> ControlPattern
- songPtrCountTo :: String -> Pattern Double -> Pattern ValueMap
- songPtrbus :: Pattern Int -> Pattern Double -> ControlPattern
- speed :: Pattern Double -> ControlPattern
- speedTake :: String -> [Double] -> ControlPattern
- speedCount :: String -> ControlPattern
- speedCountTo :: String -> Pattern Double -> Pattern ValueMap
- speedbus :: Pattern Int -> Pattern Double -> ControlPattern
- squiz :: Pattern Double -> ControlPattern
- squizTake :: String -> [Double] -> ControlPattern
- squizCount :: String -> ControlPattern
- squizCountTo :: String -> Pattern Double -> Pattern ValueMap
- squizbus :: Pattern Int -> Pattern Double -> ControlPattern
- squizrecv :: Pattern Int -> ControlPattern
- stepsPerOctave :: Pattern Double -> ControlPattern
- stepsPerOctaveTake :: String -> [Double] -> ControlPattern
- stepsPerOctaveCount :: String -> ControlPattern
- stepsPerOctaveCountTo :: String -> Pattern Double -> Pattern ValueMap
- stepsPerOctavebus :: Pattern Int -> Pattern Double -> ControlPattern
- stepsPerOctaverecv :: Pattern Int -> ControlPattern
- stutterdepth :: Pattern Double -> ControlPattern
- stutterdepthTake :: String -> [Double] -> ControlPattern
- stutterdepthCount :: String -> ControlPattern
- stutterdepthCountTo :: String -> Pattern Double -> Pattern ValueMap
- stutterdepthbus :: Pattern Int -> Pattern Double -> ControlPattern
- stutterdepthrecv :: Pattern Int -> ControlPattern
- stuttertime :: Pattern Double -> ControlPattern
- stuttertimeTake :: String -> [Double] -> ControlPattern
- stuttertimeCount :: String -> ControlPattern
- stuttertimeCountTo :: String -> Pattern Double -> Pattern ValueMap
- stuttertimebus :: Pattern Int -> Pattern Double -> ControlPattern
- stuttertimerecv :: Pattern Int -> ControlPattern
- sustain :: Pattern Double -> ControlPattern
- sustainTake :: String -> [Double] -> ControlPattern
- sustainCount :: String -> ControlPattern
- sustainCountTo :: String -> Pattern Double -> Pattern ValueMap
- sustainbus :: Pattern Int -> Pattern Double -> ControlPattern
- sustainpedal :: Pattern Double -> ControlPattern
- sustainpedalTake :: String -> [Double] -> ControlPattern
- sustainpedalCount :: String -> ControlPattern
- sustainpedalCountTo :: String -> Pattern Double -> Pattern ValueMap
- sustainpedalbus :: Pattern Int -> Pattern Double -> ControlPattern
- sustainpedalrecv :: Pattern Int -> ControlPattern
- timescale :: Pattern Double -> ControlPattern
- timescaleTake :: String -> [Double] -> ControlPattern
- timescaleCount :: String -> ControlPattern
- timescaleCountTo :: String -> Pattern Double -> Pattern ValueMap
- timescalebus :: Pattern Int -> Pattern Double -> ControlPattern
- timescalewin :: Pattern Double -> ControlPattern
- timescalewinTake :: String -> [Double] -> ControlPattern
- timescalewinCount :: String -> ControlPattern
- timescalewinCountTo :: String -> Pattern Double -> Pattern ValueMap
- timescalewinbus :: Pattern Int -> Pattern Double -> ControlPattern
- toTake :: String -> [Double] -> ControlPattern
- toCount :: String -> ControlPattern
- toCountTo :: String -> Pattern Double -> Pattern ValueMap
- tobus :: Pattern Int -> Pattern Double -> ControlPattern
- torecv :: Pattern Int -> ControlPattern
- toArg :: Pattern String -> ControlPattern
- toArgTake :: String -> [Double] -> ControlPattern
- toArgbus :: Pattern Int -> Pattern String -> ControlPattern
- toArgrecv :: Pattern Int -> ControlPattern
- tomdecay :: Pattern Double -> ControlPattern
- tomdecayTake :: String -> [Double] -> ControlPattern
- tomdecayCount :: String -> ControlPattern
- tomdecayCountTo :: String -> Pattern Double -> Pattern ValueMap
- tomdecaybus :: Pattern Int -> Pattern Double -> ControlPattern
- tomdecayrecv :: Pattern Int -> ControlPattern
- tremolodepth :: Pattern Double -> ControlPattern
- tremolodepthTake :: String -> [Double] -> ControlPattern
- tremolodepthCount :: String -> ControlPattern
- tremolodepthCountTo :: String -> Pattern Double -> Pattern ValueMap
- tremolodepthbus :: Pattern Int -> Pattern Double -> ControlPattern
- tremolodepthrecv :: Pattern Int -> ControlPattern
- tremolorate :: Pattern Double -> ControlPattern
- tremolorateTake :: String -> [Double] -> ControlPattern
- tremolorateCount :: String -> ControlPattern
- tremolorateCountTo :: String -> Pattern Double -> Pattern ValueMap
- tremoloratebus :: Pattern Int -> Pattern Double -> ControlPattern
- tremoloraterecv :: Pattern Int -> ControlPattern
- triode :: Pattern Double -> ControlPattern
- triodeTake :: String -> [Double] -> ControlPattern
- triodeCount :: String -> ControlPattern
- triodeCountTo :: String -> Pattern Double -> Pattern ValueMap
- triodebus :: Pattern Int -> Pattern Double -> ControlPattern
- trioderecv :: Pattern Int -> ControlPattern
- tsdelay :: Pattern Double -> ControlPattern
- tsdelayTake :: String -> [Double] -> ControlPattern
- tsdelayCount :: String -> ControlPattern
- tsdelayCountTo :: String -> Pattern Double -> Pattern ValueMap
- tsdelaybus :: Pattern Int -> Pattern Double -> ControlPattern
- tsdelayrecv :: Pattern Int -> ControlPattern
- uid :: Pattern Double -> ControlPattern
- uidTake :: String -> [Double] -> ControlPattern
- uidCount :: String -> ControlPattern
- uidCountTo :: String -> Pattern Double -> Pattern ValueMap
- uidbus :: Pattern Int -> Pattern Double -> ControlPattern
- unit :: Pattern String -> ControlPattern
- unitTake :: String -> [Double] -> ControlPattern
- unitbus :: Pattern Int -> Pattern String -> ControlPattern
- val :: Pattern Double -> ControlPattern
- valTake :: String -> [Double] -> ControlPattern
- valCount :: String -> ControlPattern
- valCountTo :: String -> Pattern Double -> Pattern ValueMap
- valbus :: Pattern Int -> Pattern Double -> ControlPattern
- vcfegint :: Pattern Double -> ControlPattern
- vcfegintTake :: String -> [Double] -> ControlPattern
- vcfegintCount :: String -> ControlPattern
- vcfegintCountTo :: String -> Pattern Double -> Pattern ValueMap
- vcfegintbus :: Pattern Int -> Pattern Double -> ControlPattern
- vcfegintrecv :: Pattern Int -> ControlPattern
- vcoegint :: Pattern Double -> ControlPattern
- vcoegintTake :: String -> [Double] -> ControlPattern
- vcoegintCount :: String -> ControlPattern
- vcoegintCountTo :: String -> Pattern Double -> Pattern ValueMap
- vcoegintbus :: Pattern Int -> Pattern Double -> ControlPattern
- vcoegintrecv :: Pattern Int -> ControlPattern
- velocity :: Pattern Double -> ControlPattern
- velocityTake :: String -> [Double] -> ControlPattern
- velocityCount :: String -> ControlPattern
- velocityCountTo :: String -> Pattern Double -> Pattern ValueMap
- velocitybus :: Pattern Int -> Pattern Double -> ControlPattern
- velocityrecv :: Pattern Int -> ControlPattern
- voice :: Pattern Double -> ControlPattern
- voiceTake :: String -> [Double] -> ControlPattern
- voiceCount :: String -> ControlPattern
- voiceCountTo :: String -> Pattern Double -> Pattern ValueMap
- voicebus :: Pattern Int -> Pattern Double -> ControlPattern
- voicerecv :: Pattern Int -> ControlPattern
- vowel :: Pattern String -> ControlPattern
- vowelTake :: String -> [Double] -> ControlPattern
- vowelbus :: Pattern Int -> Pattern String -> ControlPattern
- vowelrecv :: Pattern Int -> ControlPattern
- waveloss :: Pattern Double -> ControlPattern
- wavelossTake :: String -> [Double] -> ControlPattern
- wavelossCount :: String -> ControlPattern
- wavelossCountTo :: String -> Pattern Double -> Pattern ValueMap
- wavelossbus :: Pattern Int -> Pattern Double -> ControlPattern
- wavelossrecv :: Pattern Int -> ControlPattern
- xsdelay :: Pattern Double -> ControlPattern
- xsdelayTake :: String -> [Double] -> ControlPattern
- xsdelayCount :: String -> ControlPattern
- xsdelayCountTo :: String -> Pattern Double -> Pattern ValueMap
- xsdelaybus :: Pattern Int -> Pattern Double -> ControlPattern
- xsdelayrecv :: Pattern Int -> ControlPattern
- voi :: Pattern Double -> ControlPattern
- voibus :: Pattern Int -> Pattern Double -> ControlPattern
- voirecv :: Pattern Int -> ControlPattern
- vco :: Pattern Double -> ControlPattern
- vcobus :: Pattern Int -> Pattern Double -> ControlPattern
- vcorecv :: Pattern Int -> ControlPattern
- vcf :: Pattern Double -> ControlPattern
- vcfbus :: Pattern Int -> Pattern Double -> ControlPattern
- vcfrecv :: Pattern Int -> ControlPattern
- up :: Pattern Note -> ControlPattern
- tremr :: Pattern Double -> ControlPattern
- tremrbus :: Pattern Int -> Pattern Double -> ControlPattern
- tremrrecv :: Pattern Int -> ControlPattern
- tremdp :: Pattern Double -> ControlPattern
- tremdpbus :: Pattern Int -> Pattern Double -> ControlPattern
- tremdprecv :: Pattern Int -> ControlPattern
- tdecay :: Pattern Double -> ControlPattern
- tdecaybus :: Pattern Int -> Pattern Double -> ControlPattern
- tdecayrecv :: Pattern Int -> ControlPattern
- sz :: Pattern Double -> ControlPattern
- szbus :: Pattern Int -> Pattern Double -> ControlPattern
- szrecv :: Pattern Int -> ControlPattern
- sus :: Pattern Double -> ControlPattern
- stt :: Pattern Double -> ControlPattern
- sttbus :: Pattern Int -> Pattern Double -> ControlPattern
- sttrecv :: Pattern Int -> ControlPattern
- std :: Pattern Double -> ControlPattern
- stdbus :: Pattern Int -> Pattern Double -> ControlPattern
- stdrecv :: Pattern Int -> ControlPattern
- sld :: Pattern Double -> ControlPattern
- sldbus :: Pattern Int -> Pattern Double -> ControlPattern
- sldrecv :: Pattern Int -> ControlPattern
- scr :: Pattern Double -> ControlPattern
- scrbus :: Pattern Int -> Pattern Double -> ControlPattern
- scrrecv :: Pattern Int -> ControlPattern
- scp :: Pattern Double -> ControlPattern
- scpbus :: Pattern Int -> Pattern Double -> ControlPattern
- scprecv :: Pattern Int -> ControlPattern
- scl :: Pattern Double -> ControlPattern
- sclbus :: Pattern Int -> Pattern Double -> ControlPattern
- sclrecv :: Pattern Int -> ControlPattern
- sag :: Pattern Double -> ControlPattern
- sagbus :: Pattern Int -> Pattern Double -> ControlPattern
- sagrecv :: Pattern Int -> ControlPattern
- s :: Pattern String -> ControlPattern
- rel :: Pattern Double -> ControlPattern
- relbus :: Pattern Int -> Pattern Double -> ControlPattern
- relrecv :: Pattern Int -> ControlPattern
- por :: Pattern Double -> ControlPattern
- porbus :: Pattern Int -> Pattern Double -> ControlPattern
- porrecv :: Pattern Int -> ControlPattern
- pit3 :: Pattern Double -> ControlPattern
- pit3bus :: Pattern Int -> Pattern Double -> ControlPattern
- pit3recv :: Pattern Int -> ControlPattern
- pit2 :: Pattern Double -> ControlPattern
- pit2bus :: Pattern Int -> Pattern Double -> ControlPattern
- pit2recv :: Pattern Int -> ControlPattern
- pit1 :: Pattern Double -> ControlPattern
- pit1bus :: Pattern Int -> Pattern Double -> ControlPattern
- pit1recv :: Pattern Int -> ControlPattern
- phasr :: Pattern Double -> ControlPattern
- phasrbus :: Pattern Int -> Pattern Double -> ControlPattern
- phasrrecv :: Pattern Int -> ControlPattern
- phasdp :: Pattern Double -> ControlPattern
- phasdpbus :: Pattern Int -> Pattern Double -> ControlPattern
- phasdprecv :: Pattern Int -> ControlPattern
- ohdecay :: Pattern Double -> ControlPattern
- ohdecaybus :: Pattern Int -> Pattern Double -> ControlPattern
- ohdecayrecv :: Pattern Int -> ControlPattern
- number :: Pattern Note -> ControlPattern
- lsn :: Pattern Double -> ControlPattern
- lsnbus :: Pattern Int -> Pattern Double -> ControlPattern
- lsnrecv :: Pattern Int -> ControlPattern
- lpq :: Pattern Double -> ControlPattern
- lpqbus :: Pattern Int -> Pattern Double -> ControlPattern
- lpqrecv :: Pattern Int -> ControlPattern
- lpf :: Pattern Double -> ControlPattern
- lpfbus :: Pattern Int -> Pattern Double -> ControlPattern
- lpfrecv :: Pattern Int -> ControlPattern
- loh :: Pattern Double -> ControlPattern
- lohbus :: Pattern Int -> Pattern Double -> ControlPattern
- lohrecv :: Pattern Int -> ControlPattern
- llt :: Pattern Double -> ControlPattern
- lltbus :: Pattern Int -> Pattern Double -> ControlPattern
- lltrecv :: Pattern Int -> ControlPattern
- lht :: Pattern Double -> ControlPattern
- lhtbus :: Pattern Int -> Pattern Double -> ControlPattern
- lhtrecv :: Pattern Int -> ControlPattern
- lfop :: Pattern Double -> ControlPattern
- lfopbus :: Pattern Int -> Pattern Double -> ControlPattern
- lfoprecv :: Pattern Int -> ControlPattern
- lfoi :: Pattern Double -> ControlPattern
- lfoibus :: Pattern Int -> Pattern Double -> ControlPattern
- lfoirecv :: Pattern Int -> ControlPattern
- lfoc :: Pattern Double -> ControlPattern
- lfocbus :: Pattern Int -> Pattern Double -> ControlPattern
- lfocrecv :: Pattern Int -> ControlPattern
- lcr :: Pattern Double -> ControlPattern
- lcrbus :: Pattern Int -> Pattern Double -> ControlPattern
- lcrrecv :: Pattern Int -> ControlPattern
- lcp :: Pattern Double -> ControlPattern
- lcpbus :: Pattern Int -> Pattern Double -> ControlPattern
- lcprecv :: Pattern Int -> ControlPattern
- lcl :: Pattern Double -> ControlPattern
- lclbus :: Pattern Int -> Pattern Double -> ControlPattern
- lclrecv :: Pattern Int -> ControlPattern
- lch :: Pattern Double -> ControlPattern
- lchbus :: Pattern Int -> Pattern Double -> ControlPattern
- lchrecv :: Pattern Int -> ControlPattern
- lbd :: Pattern Double -> ControlPattern
- lbdbus :: Pattern Int -> Pattern Double -> ControlPattern
- lbdrecv :: Pattern Int -> ControlPattern
- lag :: Pattern Double -> ControlPattern
- lagbus :: Pattern Int -> Pattern Double -> ControlPattern
- lagrecv :: Pattern Int -> ControlPattern
- hpq :: Pattern Double -> ControlPattern
- hpqbus :: Pattern Int -> Pattern Double -> ControlPattern
- hpqrecv :: Pattern Int -> ControlPattern
- hpf :: Pattern Double -> ControlPattern
- hpfbus :: Pattern Int -> Pattern Double -> ControlPattern
- hpfrecv :: Pattern Int -> ControlPattern
- hg :: Pattern Double -> ControlPattern
- hgbus :: Pattern Int -> Pattern Double -> ControlPattern
- hgrecv :: Pattern Int -> ControlPattern
- gat :: Pattern Double -> ControlPattern
- gatbus :: Pattern Int -> Pattern Double -> ControlPattern
- gatrecv :: Pattern Int -> ControlPattern
- fadeOutTime :: Pattern Double -> ControlPattern
- dt :: Pattern Double -> ControlPattern
- dtbus :: Pattern Int -> Pattern Double -> ControlPattern
- dtrecv :: Pattern Int -> ControlPattern
- dfb :: Pattern Double -> ControlPattern
- dfbbus :: Pattern Int -> Pattern Double -> ControlPattern
- dfbrecv :: Pattern Int -> ControlPattern
- det :: Pattern Double -> ControlPattern
- detbus :: Pattern Int -> Pattern Double -> ControlPattern
- detrecv :: Pattern Int -> ControlPattern
- delayt :: Pattern Double -> ControlPattern
- delaytbus :: Pattern Int -> Pattern Double -> ControlPattern
- delaytrecv :: Pattern Int -> ControlPattern
- delayfb :: Pattern Double -> ControlPattern
- delayfbbus :: Pattern Int -> Pattern Double -> ControlPattern
- delayfbrecv :: Pattern Int -> ControlPattern
- ctfg :: Pattern Double -> ControlPattern
- ctfgbus :: Pattern Int -> Pattern Double -> ControlPattern
- ctfgrecv :: Pattern Int -> ControlPattern
- ctf :: Pattern Double -> ControlPattern
- ctfbus :: Pattern Int -> Pattern Double -> ControlPattern
- ctfrecv :: Pattern Int -> ControlPattern
- chdecay :: Pattern Double -> ControlPattern
- chdecaybus :: Pattern Int -> Pattern Double -> ControlPattern
- chdecayrecv :: Pattern Int -> ControlPattern
- bpq :: Pattern Double -> ControlPattern
- bpqbus :: Pattern Int -> Pattern Double -> ControlPattern
- bpqrecv :: Pattern Int -> ControlPattern
- bpf :: Pattern Double -> ControlPattern
- bpfbus :: Pattern Int -> Pattern Double -> ControlPattern
- bpfrecv :: Pattern Int -> ControlPattern
- att :: Pattern Double -> ControlPattern
- attbus :: Pattern Int -> Pattern Double -> ControlPattern
- attrecv :: Pattern Int -> ControlPattern
- xorwise :: Int -> Int
- timeToIntSeed :: RealFrac a => a -> Int
- intSeedToRand :: Fractional a => Int -> a
- timeToRand :: (RealFrac a, Fractional b) => a -> b
- timeToRands :: (RealFrac a, Fractional b) => a -> Int -> [b]
- timeToRands' :: Fractional a => Int -> Int -> [a]
- rand :: Fractional a => Pattern a
- brand :: Pattern Bool
- brandBy :: Pattern Double -> Pattern Bool
- _brandBy :: Double -> Pattern Bool
- irand :: Num a => Pattern Int -> Pattern a
- _irand :: Num a => Int -> Pattern a
- perlinWith :: Fractional a => Pattern Double -> Pattern a
- perlin :: Fractional a => Pattern a
- perlin2With :: Pattern Double -> Pattern Double -> Pattern Double
- perlin2 :: Pattern Double -> Pattern Double
- normal :: (Floating a, Ord a) => Pattern a
- chooseBy :: Pattern Double -> [a] -> Pattern a
- wchoose :: [(a, Pattern Double)] -> Pattern a
- wchooseBy :: Pattern Double -> [(a, Pattern Double)] -> Pattern a
- randcat :: [Pattern a] -> Pattern a
- wrandcat :: [(Pattern a, Pattern Double)] -> Pattern a
- degrade :: Pattern a -> Pattern a
- degradeBy :: Pattern Double -> Pattern a -> Pattern a
- _degradeBy :: Double -> Pattern a -> Pattern a
- _degradeByUsing :: Pattern Double -> Double -> Pattern a -> Pattern a
- unDegradeBy :: Pattern Double -> Pattern a -> Pattern a
- _unDegradeBy :: Double -> Pattern a -> Pattern a
- degradeOverBy :: Int -> Pattern Double -> Pattern a -> Pattern a
- sometimesBy :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- sometimesBy' :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- sometimes :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- sometimes' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- often :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- often' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- rarely :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- rarely' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- almostNever :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- almostNever' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- almostAlways :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- almostAlways' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- never :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- always :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- someCyclesBy :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- _someCyclesBy :: Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- somecyclesBy :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- someCycles :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- somecycles :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- brak :: Pattern a -> Pattern a
- _iter :: Int -> Pattern a -> Pattern a
- iter' :: Pattern Int -> Pattern c -> Pattern c
- _iter' :: Int -> Pattern a -> Pattern a
- palindrome :: Pattern a -> Pattern a
- fadeOut :: Time -> Pattern a -> Pattern a
- fadeOutFrom :: Time -> Time -> Pattern a -> Pattern a
- fadeIn :: Time -> Pattern a -> Pattern a
- fadeInFrom :: Time -> Time -> Pattern a -> Pattern a
- spread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b
- slowspread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b
- fastspread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b
- spread' :: Monad m => (a -> b -> m c) -> m a -> b -> m c
- spreadChoose :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b
- spreadr :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b
- ifp :: (Int -> Bool) -> (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- wedge :: Pattern Time -> Pattern a -> Pattern a -> Pattern a
- _wedge :: Time -> Pattern a -> Pattern a -> Pattern a
- whenmod :: Pattern Time -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- _whenmod :: Time -> Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- superimpose :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- trunc :: Pattern Time -> Pattern a -> Pattern a
- _trunc :: Time -> Pattern a -> Pattern a
- linger :: Pattern Time -> Pattern a -> Pattern a
- _linger :: Time -> Pattern a -> Pattern a
- within :: (Time, Time) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- withinArc :: Arc -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- within' :: (Time, Time) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- revArc :: (Time, Time) -> Pattern a -> Pattern a
- euclid :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
- _euclid :: Int -> Int -> Pattern a -> Pattern a
- euclidFull :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a -> Pattern a
- _euclidBool :: Int -> Int -> Pattern Bool
- _euclid' :: Int -> Int -> Pattern a -> Pattern a
- euclidOff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
- eoff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
- _euclidOff :: Int -> Int -> Int -> Pattern a -> Pattern a
- euclidOffBool :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern Bool -> Pattern Bool
- _euclidOffBool :: Int -> Int -> Int -> Pattern Bool -> Pattern Bool
- distrib :: [Pattern Int] -> Pattern a -> Pattern a
- _distrib :: [Int] -> Pattern a -> Pattern a
- euclidInv :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
- _euclidInv :: Int -> Int -> Pattern a -> Pattern a
- rot :: Ord a => Pattern Int -> Pattern a -> Pattern a
- _rot :: Ord a => Int -> Pattern a -> Pattern a
- segment :: Pattern Time -> Pattern a -> Pattern a
- _segment :: Time -> Pattern a -> Pattern a
- discretise :: Pattern Time -> Pattern a -> Pattern a
- fit :: Pattern Int -> [a] -> Pattern Int -> Pattern a
- _fit :: Int -> [a] -> Pattern Int -> Pattern a
- permstep :: RealFrac b => Int -> [a] -> Pattern b -> Pattern a
- struct :: Pattern Bool -> Pattern a -> Pattern a
- substruct :: Pattern Bool -> Pattern b -> Pattern b
- randArcs :: Int -> Pattern [Arc]
- randStruct :: Int -> Pattern Int
- substruct' :: Pattern Int -> Pattern a -> Pattern a
- stripe :: Pattern Int -> Pattern a -> Pattern a
- _stripe :: Int -> Pattern a -> Pattern a
- slowstripe :: Pattern Int -> Pattern a -> Pattern a
- parseLMRule :: String -> [(String, String)]
- parseLMRule' :: String -> [(Char, String)]
- lindenmayer :: Int -> String -> String -> String
- lindenmayerI :: Num b => Int -> String -> String -> [b]
- runMarkov :: Int -> [[Double]] -> Int -> Time -> [Int]
- markovPat :: Pattern Int -> Pattern Int -> [[Double]] -> Pattern Int
- _markovPat :: Int -> Int -> [[Double]] -> Pattern Int
- beat :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a
- __beat :: (Pattern (Pattern a) -> Pattern a) -> Time -> Time -> Pattern a -> Pattern a
- enclosingArc :: [Arc] -> Arc
- stretch :: Pattern a -> Pattern a
- fit' :: Pattern Time -> Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
- _chunk :: Integral a => a -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b
- chunk' :: Integral a1 => Pattern a1 -> (Pattern a2 -> Pattern a2) -> Pattern a2 -> Pattern a2
- _chunk' :: Integral a => a -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b
- inside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a
- _inside :: Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a
- outside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a
- _outside :: Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a
- loopFirst :: Pattern a -> Pattern a
- timeLoop :: Pattern Time -> Pattern a -> Pattern a
- seqPLoop :: [(Time, Time, Pattern a)] -> Pattern a
- toScale :: Num a => [a] -> Pattern Int -> Pattern a
- toScale' :: Num a => Int -> [a] -> Pattern Int -> Pattern a
- swingBy :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a
- swing :: Pattern Time -> Pattern a -> Pattern a
- cycleChoose :: [a] -> Pattern a
- _rearrangeWith :: Pattern Int -> Int -> Pattern a -> Pattern a
- shuffle :: Pattern Int -> Pattern a -> Pattern a
- _shuffle :: Int -> Pattern a -> Pattern a
- scramble :: Pattern Int -> Pattern a -> Pattern a
- _scramble :: Int -> Pattern a -> Pattern a
- randrun :: Int -> Pattern Int
- seqP :: [(Time, Time, Pattern a)] -> Pattern a
- ur :: Time -> Pattern String -> [(String, Pattern a)] -> [(String, Pattern a -> Pattern a)] -> Pattern a
- inhabit :: [(String, Pattern a)] -> Pattern String -> Pattern a
- spaceOut :: [Time] -> Pattern a -> Pattern a
- flatpat :: Pattern [a] -> Pattern a
- layer :: [a -> Pattern b] -> a -> Pattern b
- arpeggiate :: Pattern a -> Pattern a
- arpg :: Pattern a -> Pattern a
- arpWith :: ([EventF (ArcF Time) a] -> [EventF (ArcF Time) b]) -> Pattern a -> Pattern b
- arp :: Pattern String -> Pattern a -> Pattern a
- _arp :: String -> Pattern a -> Pattern a
- rolled :: Pattern a -> Pattern a
- rolledBy :: Pattern (Ratio Integer) -> Pattern a -> Pattern a
- rolledWith :: Ratio Integer -> Pattern a -> Pattern a
- ply :: Pattern Rational -> Pattern a -> Pattern a
- _ply :: Rational -> Pattern a -> Pattern a
- plyWith :: (Ord t, Num t) => Pattern t -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- _plyWith :: (Ord t, Num t) => t -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- press :: Pattern a -> Pattern a
- pressBy :: Pattern Time -> Pattern a -> Pattern a
- _pressBy :: Time -> Pattern a -> Pattern a
- sew :: Pattern Bool -> Pattern a -> Pattern a -> Pattern a
- stitch :: Pattern Bool -> Pattern a -> Pattern a -> Pattern a
- while :: Pattern Bool -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- stutter :: Integral i => i -> Time -> Pattern a -> Pattern a
- jux :: (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap
- juxcut :: (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap
- juxcut' :: [t -> Pattern ValueMap] -> t -> Pattern ValueMap
- jux' :: [t -> Pattern ValueMap] -> t -> Pattern ValueMap
- jux4 :: (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap
- juxBy :: Pattern Double -> (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap
- pick :: String -> Int -> String
- samples :: Applicative f => f String -> f Int -> f String
- samples' :: Applicative f => f String -> f Int -> f String
- spreadf :: [a -> Pattern b] -> a -> Pattern b
- stackwith :: Unionable a => Pattern a -> [Pattern a] -> Pattern a
- _range :: (Functor f, Num b) => b -> b -> f b -> f b
- rangex :: (Functor f, Floating b) => b -> b -> f b -> f b
- off :: Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- _off :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- offadd :: Num a => Pattern Time -> Pattern a -> Pattern a -> Pattern a
- sseq :: String -> String -> Pattern String
- sseqs :: [(String, String)] -> Pattern String
- sseq' :: [String] -> String -> Pattern String
- ghost'' :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- ghostWith :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- ghost' :: Time -> Pattern ValueMap -> Pattern ValueMap
- ghost :: Pattern ValueMap -> Pattern ValueMap
- tabby :: Int -> Pattern a -> Pattern a -> Pattern a
- _select :: Double -> [Pattern a] -> Pattern a
- selectF :: Pattern Double -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a
- _selectF :: Double -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a
- pickF :: Pattern Int -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a
- _pickF :: Int -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a
- contrast :: (ControlPattern -> ControlPattern) -> (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern
- contrastBy :: (a -> Value -> Bool) -> (ControlPattern -> Pattern b) -> (ControlPattern -> Pattern b) -> Pattern (Map String a) -> Pattern (Map String Value) -> Pattern b
- contrastRange :: (ControlPattern -> Pattern a) -> (ControlPattern -> Pattern a) -> Pattern (Map String (Value, Value)) -> ControlPattern -> Pattern a
- unfix :: (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern
- fixRange :: (ControlPattern -> Pattern ValueMap) -> Pattern (Map String (Value, Value)) -> ControlPattern -> ControlPattern
- unfixRange :: (ControlPattern -> Pattern ValueMap) -> Pattern (Map String (Value, Value)) -> ControlPattern -> ControlPattern
- quantise :: (Functor f, RealFrac b) => b -> f b -> f b
- qfloor :: (Functor f, RealFrac b) => b -> f b -> f b
- qceiling :: (Functor f, RealFrac b) => b -> f b -> f b
- qround :: (Functor f, RealFrac b) => b -> f b -> f b
- inv :: Functor f => f Bool -> f Bool
- smooth :: Fractional a => Pattern a -> Pattern a
- snowball :: Int -> (Pattern a -> Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- soak :: Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- deconstruct :: Int -> Pattern String -> String
- bite :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
- _bite :: Int -> Pattern Int -> Pattern a -> Pattern a
- squeezeJoinUp :: Pattern ControlPattern -> ControlPattern
- _chew :: Int -> Pattern Int -> ControlPattern -> ControlPattern
- chew :: Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern
- __binary :: Bits b => Int -> b -> [Bool]
- _binary :: Bits b => Int -> b -> Pattern Bool
- _binaryN :: Int -> Pattern Int -> Pattern Bool
- binaryN :: Pattern Int -> Pattern Int -> Pattern Bool
- grain :: Pattern Double -> Pattern Double -> ControlPattern
- necklace :: Rational -> [Int] -> Pattern Bool
- chromaticiseBy :: (Num a, Enum a, Ord a) => Pattern a -> Pattern a -> Pattern a
- _chromaticiseBy :: (Num a, Enum a, Ord a) => a -> Pattern a -> Pattern a
- chromaticizeBy :: (Num a, Enum a, Ord a) => Pattern a -> Pattern a -> Pattern a
- _ribbon :: Time -> Time -> Pattern a -> Pattern a
- ribbon :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a
- rib :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a
- unjoin :: Pattern Bool -> Pattern b -> Pattern (Pattern b)
- into :: Pattern Bool -> (Pattern a -> Pattern b) -> Pattern a -> Pattern b
- data Sign
- type ColourD = Colour Double
- class Enumerable a where
- fromTo :: a -> a -> Pattern a
- fromThenTo :: a -> a -> a -> Pattern a
- class Parseable a where
- data TPat a where
- TPat_Atom :: forall a. Maybe ((Int, Int), (Int, Int)) -> a -> TPat a
- TPat_Fast :: forall a. TPat Time -> TPat a -> TPat a
- TPat_Slow :: forall a. TPat Time -> TPat a -> TPat a
- TPat_DegradeBy :: forall a. Int -> Double -> TPat a -> TPat a
- TPat_CycleChoose :: forall a. Int -> [TPat a] -> TPat a
- TPat_Euclid :: forall a. TPat Int -> TPat Int -> TPat Int -> TPat a -> TPat a
- TPat_Stack :: forall a. [TPat a] -> TPat a
- TPat_Polyrhythm :: forall a. Maybe (TPat Rational) -> [TPat a] -> TPat a
- TPat_Seq :: forall a. [TPat a] -> TPat a
- TPat_Silence :: forall a. TPat a
- TPat_Foot :: forall a. TPat a
- TPat_Elongate :: forall a. Rational -> TPat a -> TPat a
- TPat_Repeat :: forall a. Int -> TPat a -> TPat a
- TPat_EnumFromTo :: forall a. TPat a -> TPat a -> TPat a
- TPat_Var :: forall a. String -> TPat a
- TPat_Chord :: forall b a. (Num b, Enum b, Parseable b, Enumerable b) => (b -> a) -> TPat b -> TPat String -> [TPat [Modifier]] -> TPat a
- type MyParser = Parsec String Int
- data TidalParseError = TidalParseError {
- parsecError :: ParseError
- code :: String
- tShowList :: Show a => [TPat a] -> String
- tShow :: Show a => TPat a -> String
- toPat :: (Parseable a, Enumerable a) => TPat a -> Pattern a
- resolve_tpat :: (Enumerable a, Parseable a) => TPat a -> (Rational, Pattern a)
- resolve_seq :: (Enumerable a, Parseable a) => [TPat a] -> (Rational, Pattern a)
- resolve_size :: [TPat a] -> [(Rational, TPat a)]
- steps_tpat :: Show a => TPat a -> (Rational, String)
- steps_seq :: Show a => [TPat a] -> (Rational, String)
- steps_size :: Show a => [TPat a] -> [(Rational, String)]
- parseBP :: (Enumerable a, Parseable a) => String -> Either ParseError (Pattern a)
- parseBP_E :: (Enumerable a, Parseable a) => String -> Pattern a
- parseTPat :: Parseable a => String -> Either ParseError (TPat a)
- parseRest :: Parseable a => MyParser (TPat a)
- cP :: (Enumerable a, Parseable a) => String -> Pattern a
- enumFromTo' :: (Ord a, Enum a) => a -> a -> Pattern a
- enumFromThenTo' :: (Ord a, Enum a, Num a) => a -> a -> a -> Pattern a
- lexer :: GenTokenParser String u Identity
- applySign :: Num a => Sign -> a -> a
- intOrFloat :: MyParser Double
- pTidal :: Parseable a => MyParser (TPat a) -> MyParser (TPat a)
- pSequence :: Parseable a => MyParser (TPat a) -> MyParser (TPat a)
- pFoot :: MyParser (TPat a)
- pEnumeration :: Parseable a => MyParser (TPat a) -> TPat a -> MyParser (TPat a)
- pRepeat :: TPat a -> MyParser (TPat a)
- pElongate :: TPat a -> MyParser (TPat a)
- pSingle :: MyParser (TPat a) -> MyParser (TPat a)
- pVar :: MyParser (TPat a)
- pPart :: Parseable a => MyParser (TPat a) -> MyParser (TPat a)
- newSeed :: MyParser Int
- pPolyIn :: Parseable a => MyParser (TPat a) -> MyParser (TPat a)
- pPolyOut :: Parseable a => MyParser (TPat a) -> MyParser (TPat a)
- pCharNum :: MyParser Char
- pString :: MyParser String
- wrapPos :: MyParser (TPat a) -> MyParser (TPat a)
- pVocable :: MyParser (TPat String)
- pChar :: MyParser (TPat Char)
- pDouble :: MyParser (TPat Double)
- pDoubleWithoutChord :: MyParser (TPat Double)
- pNote :: MyParser (TPat Note)
- pNoteWithoutChord :: MyParser (TPat Note)
- pBool :: MyParser (TPat Bool)
- parseIntNote :: Integral i => MyParser i
- pIntegral :: (Integral a, Parseable a, Enumerable a) => MyParser (TPat a)
- pIntegralWithoutChord :: (Integral a, Parseable a, Enumerable a) => MyParser (TPat a)
- parseChord :: (Enum a, Num a) => MyParser [a]
- parseNote :: Num a => MyParser a
- fromNote :: Num a => Pattern String -> Pattern a
- pColour :: MyParser (TPat ColourD)
- pMult :: TPat a -> MyParser (TPat a)
- pRand :: TPat a -> MyParser (TPat a)
- pE :: TPat a -> MyParser (TPat a)
- pRational :: MyParser (TPat Rational)
- pRatio :: MyParser Rational
- pInteger :: MyParser Double
- pFloat :: MyParser Double
- pFraction :: RealFrac a => a -> MyParser Rational
- pRatioChar :: Fractional a => MyParser a
- pRatioSingleChar :: Fractional a => Char -> a -> MyParser a
- isInt :: RealFrac a => a -> Bool
- parseModInv :: MyParser Modifier
- parseModInvNum :: MyParser [Modifier]
- parseModDrop :: MyParser [Modifier]
- parseModOpen :: MyParser Modifier
- parseModRange :: MyParser Modifier
- parseModifiers :: MyParser [Modifier]
- pModifiers :: MyParser (TPat [Modifier])
- pChord :: (Enum a, Num a, Parseable a, Enumerable a) => TPat a -> MyParser (TPat a)
- spin :: Pattern Int -> ControlPattern -> ControlPattern
- _spin :: Int -> ControlPattern -> ControlPattern
- chop :: Pattern Int -> ControlPattern -> ControlPattern
- chopArc :: Arc -> Int -> [Arc]
- _chop :: Int -> ControlPattern -> ControlPattern
- striate :: Pattern Int -> ControlPattern -> ControlPattern
- _striate :: Int -> ControlPattern -> ControlPattern
- mergePlayRange :: (Double, Double) -> ValueMap -> ValueMap
- striateBy :: Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern
- striate' :: Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern
- _striateBy :: Int -> Double -> ControlPattern -> ControlPattern
- gap :: Pattern Int -> ControlPattern -> ControlPattern
- _gap :: Int -> ControlPattern -> ControlPattern
- weave :: Time -> ControlPattern -> [ControlPattern] -> ControlPattern
- weaveWith :: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a
- weave' :: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a
- interlace :: ControlPattern -> ControlPattern -> ControlPattern
- slice :: Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern
- _slice :: Int -> Int -> ControlPattern -> ControlPattern
- randslice :: Pattern Int -> ControlPattern -> ControlPattern
- _splice :: Int -> Pattern Int -> ControlPattern -> Pattern (Map String Value)
- splice :: Pattern Int -> Pattern Int -> ControlPattern -> Pattern (Map String Value)
- loopAt :: Pattern Time -> ControlPattern -> ControlPattern
- hurry :: Pattern Rational -> ControlPattern -> ControlPattern
- smash :: Pattern Int -> [Pattern Time] -> ControlPattern -> Pattern ValueMap
- smash' :: Int -> [Pattern Time] -> ControlPattern -> ControlPattern
- _echo :: Integer -> Rational -> Double -> ControlPattern -> ControlPattern
- echoWith :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- _echoWith :: (Num n, Ord n) => n -> Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- stut :: Pattern Integer -> Pattern Double -> Pattern Rational -> ControlPattern -> ControlPattern
- _stut :: Integer -> Double -> Rational -> ControlPattern -> ControlPattern
- stutWith :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- _stutWith :: (Num n, Ord n) => n -> Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- stut' :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
- msec :: Fractional a => Pattern a -> Pattern a
- trigger :: Pattern a -> Pattern a
- qtrigger :: Pattern a -> Pattern a
- qt :: Pattern a -> Pattern a
- ctrigger :: Pattern a -> Pattern a
- rtrigger :: Pattern a -> Pattern a
- ftrigger :: Pattern a -> Pattern a
- mtrigger :: Int -> Pattern a -> Pattern a
- mt :: Int -> Pattern a -> Pattern a
- triggerWith :: (Time -> Time) -> Pattern a -> Pattern a
- splat :: Pattern Int -> ControlPattern -> ControlPattern -> ControlPattern
- crunch :: ControlPattern -> ControlPattern
- scratch :: ControlPattern -> ControlPattern
- louder :: ControlPattern -> ControlPattern
- quieter :: ControlPattern -> ControlPattern
- silent :: ControlPattern -> ControlPattern
- higher :: ControlPattern -> ControlPattern
- faster :: ControlPattern -> ControlPattern
- slower :: ControlPattern -> ControlPattern
- defaultConfig :: Config
- data Config = Config {}
- streamReplace :: Stream -> ID -> ControlPattern -> IO ()
- streamHush :: Stream -> IO ()
- streamMute :: Stream -> ID -> IO ()
- streamUnmute :: Stream -> ID -> IO ()
- streamSolo :: Stream -> ID -> IO ()
- streamUnsolo :: Stream -> ID -> IO ()
- streamOnce :: Stream -> ControlPattern -> IO ()
- streamFirst :: Stream -> ControlPattern -> IO ()
- streamNudgeAll :: Stream -> Double -> IO ()
- streamAll :: Stream -> (ControlPattern -> ControlPattern) -> IO ()
- streamResetCycles :: Stream -> IO ()
- streamSetI :: Stream -> String -> Pattern Int -> IO ()
- streamSetF :: Stream -> String -> Pattern Double -> IO ()
- streamSetS :: Stream -> String -> Pattern String -> IO ()
- streamSetR :: Stream -> String -> Pattern Rational -> IO ()
- streamSetB :: Stream -> String -> Pattern Bool -> IO ()
- transition :: Stream -> Bool -> TransitionMapper -> ID -> ControlPattern -> IO ()
- data Target = Target {}
- startTidal :: Target -> Config -> IO Stream
- superdirtTarget :: Target
- openListener :: Config -> IO (Maybe Udp)
- toClockConfig :: Config -> ClockConfig
- verbose :: Config -> String -> IO ()
- ctrlResponder :: Config -> Stream -> IO ()
- doTick :: MVar ValueMap -> MVar PlayMap -> MVar (ControlPattern -> ControlPattern) -> [Cx] -> (Time, Time) -> Double -> ClockConfig -> ClockRef -> (SessionState, SessionState) -> IO ()
- getCXs :: Config -> [(Target, [OSC])] -> IO [Cx]
- superdirtShape :: OSC
- tidal_status_string :: IO String
- data PlayState = PlayState {
- psPattern :: ControlPattern
- psMute :: Bool
- psSolo :: Bool
- psHistory :: [ControlPattern]
- tidal_version :: String
- setFrameTimespan :: Double -> Config -> Config
- setProcessAhead :: Double -> Config -> Config
- type PlayMap = Map PatId PlayState
- data Cx = Cx {}
- data StampStyle
- data Schedule
- = Pre StampStyle
- | Live
- data Args
- type PatId = String
- resolve :: String -> Int -> IO AddrInfo
- handshake :: Cx -> Config -> IO ()
- recvMessagesTimeout :: Transport t => Double -> t -> IO [Message]
- sendBndl :: Bool -> Cx -> Bundle -> IO ()
- sendO :: Bool -> Cx -> Message -> IO ()
- dirtTarget :: Target
- dirtShape :: OSC
- fDefault :: Double -> Maybe Value
- sDefault :: String -> Maybe Value
- iDefault :: Int -> Maybe Value
- rDefault :: Rational -> Maybe Value
- bDefault :: Bool -> Maybe Value
- xDefault :: [Word8] -> Maybe Value
- data ProcessedEvent = ProcessedEvent {
- peHasOnset :: Bool
- peEvent :: Event ValueMap
- peCps :: Double
- peDelta :: Micros
- peCycle :: Time
- peOnWholeOrPart :: Micros
- peOnWholeOrPartOsc :: Time
- peOnPart :: Micros
- peOnPartOsc :: Time
- playStack :: PlayMap -> ControlPattern
- processCps :: ClockConfig -> ClockRef -> (SessionState, SessionState) -> [Event ValueMap] -> IO [ProcessedEvent]
- toOSC :: Maybe [Int] -> ProcessedEvent -> OSC -> [(Double, Bool, Message)]
- setPreviousPatternOrSilence :: MVar PlayMap -> IO ()
- toData :: OSC -> Event ValueMap -> Maybe [Datum]
- substitutePath :: String -> ValueMap -> Maybe String
- toDatum :: Value -> Datum
- getString :: ValueMap -> String -> Maybe String
- hasSolo :: Map k PlayState -> Bool
- onSingleTick :: ClockConfig -> ClockRef -> MVar ValueMap -> MVar PlayMap -> MVar (ControlPattern -> ControlPattern) -> [Cx] -> ControlPattern -> IO ()
- updatePattern :: Stream -> ID -> Time -> ControlPattern -> IO ()
- streamSetCycle :: Stream -> Time -> IO ()
- streamSetCPS :: Stream -> Time -> IO ()
- streamSetBPM :: Stream -> Time -> IO ()
- streamGetCPS :: Stream -> IO Time
- streamGetcps :: Stream -> IO Time
- streamGetBPM :: Stream -> IO Time
- streamGetNow :: Stream -> IO Time
- streamGetnow :: Stream -> IO Time
- streamEnableLink :: Stream -> IO ()
- streamDisableLink :: Stream -> IO ()
- withPatIds :: Stream -> [ID] -> (PlayState -> PlayState) -> IO ()
- streamMutes :: Stream -> [ID] -> IO ()
- streamMuteAll :: Stream -> IO ()
- streamUnmuteAll :: Stream -> IO ()
- streamUnsoloAll :: Stream -> IO ()
- streamSilence :: Stream -> ID -> IO ()
- streamGet :: Stream -> String -> IO (Maybe Value)
- streamSet :: Valuable a => Stream -> String -> Pattern a -> IO ()
- type TransitionMapper = Time -> [ControlPattern] -> ControlPattern
- _mortalOverlay :: Time -> Time -> [Pattern a] -> Pattern a
- _wash :: (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Time -> Time -> Time -> Time -> [Pattern a] -> Pattern a
- _washIn :: (Pattern a -> Pattern a) -> Time -> Time -> [Pattern a] -> Pattern a
- _xfadeIn :: Time -> Time -> [ControlPattern] -> ControlPattern
- _histpan :: Int -> Time -> [ControlPattern] -> ControlPattern
- _wait :: Time -> Time -> [ControlPattern] -> ControlPattern
- _waitT :: (Time -> [ControlPattern] -> ControlPattern) -> Time -> Time -> [ControlPattern] -> ControlPattern
- _jump :: Time -> [ControlPattern] -> ControlPattern
- _jumpIn :: Int -> Time -> [ControlPattern] -> ControlPattern
- _jumpIn' :: Int -> Time -> [ControlPattern] -> ControlPattern
- _jumpMod :: Int -> Time -> [ControlPattern] -> ControlPattern
- _jumpMod' :: Int -> Int -> Time -> [ControlPattern] -> ControlPattern
- _mortal :: Time -> Time -> Time -> [ControlPattern] -> ControlPattern
- _interpolate :: Time -> [ControlPattern] -> ControlPattern
- _interpolateIn :: Time -> Time -> [ControlPattern] -> ControlPattern
- _clutch :: Time -> [Pattern a] -> Pattern a
- _clutchIn :: Time -> Time -> [Pattern a] -> Pattern a
- _anticipateIn :: Time -> Time -> [ControlPattern] -> ControlPattern
- _anticipate :: Time -> [ControlPattern] -> ControlPattern
- tidal_status :: IO ()
- startStream :: Config -> [(Target, [OSC])] -> IO Stream
- startMulti :: [Target] -> Config -> IO ()
- histpan :: Tidally => ID -> Int -> ControlPattern -> IO ()
- wait :: Tidally => ID -> Time -> ControlPattern -> IO ()
- waitT :: Tidally => ID -> (Time -> [ControlPattern] -> ControlPattern) -> Time -> ControlPattern -> IO ()
- jump :: Tidally => ID -> ControlPattern -> IO ()
- jumpIn :: Tidally => ID -> Int -> ControlPattern -> IO ()
- jumpIn' :: Tidally => ID -> Int -> ControlPattern -> IO ()
- jumpMod :: Tidally => ID -> Int -> ControlPattern -> IO ()
- jumpMod' :: Tidally => ID -> Int -> Int -> ControlPattern -> IO ()
- mortal :: Tidally => ID -> Time -> Time -> ControlPattern -> IO ()
- interpolate :: Tidally => ID -> ControlPattern -> IO ()
- interpolateIn :: Tidally => ID -> Time -> ControlPattern -> IO ()
- clutch :: Tidally => ID -> ControlPattern -> IO ()
- clutchIn :: Tidally => ID -> Time -> ControlPattern -> IO ()
- anticipate :: Tidally => ID -> ControlPattern -> IO ()
- anticipateIn :: Tidally => ID -> Time -> ControlPattern -> IO ()
- forId :: Tidally => ID -> Time -> ControlPattern -> IO ()
Documentation
Functions using this constraint can access the in-scope Tidal instance.
You must implement an instance of this in hs
. Note that GHC
will complain that it is an "orphan" instance, but that is ok.
Creates a Tidal instance using default config. Use mkTidalWith
to customize.
mkTidalWith :: OscMap -> Config -> IO Stream Source #
See startStream
.
p :: Tidally => ID -> ControlPattern -> IO () Source #
See streamReplace
.
_p :: Tidally => ID -> ControlPattern -> IO () Source #
Silences a specific stream, regardless of ControlPattern input. Useful for rapid muting of streams
p_ :: Tidally => ID -> ControlPattern -> IO () Source #
Silences a specific stream, regardless of ControlPattern input. Useful for rapid muting of streams
once :: Tidally => ControlPattern -> IO () Source #
See streamOnce
.
all :: Tidally => (ControlPattern -> ControlPattern) -> IO () Source #
See streamAll
.
resetCycles :: Tidally => IO () Source #
See resetCycles
.
enableLink :: Tidally => IO () Source #
disableLink :: Tidally => IO () Source #
_d10 :: Tidally => ControlPattern -> IO () Source #
Rapidly silence what's playing on the given orbit
_d11 :: Tidally => ControlPattern -> IO () Source #
Rapidly silence what's playing on the given orbit
_d12 :: Tidally => ControlPattern -> IO () Source #
Rapidly silence what's playing on the given orbit
_d13 :: Tidally => ControlPattern -> IO () Source #
Rapidly silence what's playing on the given orbit
_d14 :: Tidally => ControlPattern -> IO () Source #
Rapidly silence what's playing on the given orbit
_d15 :: Tidally => ControlPattern -> IO () Source #
Rapidly silence what's playing on the given orbit
_d16 :: Tidally => ControlPattern -> IO () Source #
Rapidly silence what's playing on the given orbit
d10_ :: Tidally => ControlPattern -> IO () Source #
Rapidly silence what's playing on the given orbit
d11_ :: Tidally => ControlPattern -> IO () Source #
Rapidly silence what's playing on the given orbit
d12_ :: Tidally => ControlPattern -> IO () Source #
Rapidly silence what's playing on the given orbit
d13_ :: Tidally => ControlPattern -> IO () Source #
Rapidly silence what's playing on the given orbit
d14_ :: Tidally => ControlPattern -> IO () Source #
Rapidly silence what's playing on the given orbit
d15_ :: Tidally => ControlPattern -> IO () Source #
Rapidly silence what's playing on the given orbit
d16_ :: Tidally => ControlPattern -> IO () Source #
Rapidly silence what's playing on the given orbit
array :: Pattern [Word8] -> ControlPattern #
freeze :: Pattern Double -> ControlPattern #
Spectral freeze
range :: Num a => Pattern a -> Pattern a -> Pattern a -> Pattern a #
range
will take a pattern which goes from 0 to 1 (like sine
), and range it to a different range - between the first and second arguments. In the below example, `range 1 1.5` shifts the range of sine1
from 0 - 1 to 1 - 1.5.
d1 $ jux (iter 4) $ sound "arpy arpy:2*2" |+ speed (slow 4 $ range 1 1.5 sine1)
The above is equivalent to:
d1 $ jux (iter 4) $ sound "arpy arpy:2*2" |+ speed (slow 4 $ sine1 * 0.5 + 1)
mask :: Pattern Bool -> Pattern a -> Pattern a #
mask
takes a boolean pattern and ‘masks’ another pattern with it. That is,
events are only carried over if they match within a ‘true’ event in the binary
pattern, i.e., it removes events from the second pattern that don't start during
an event from the first.
For example, consider this kind of messy rhythm without any rests.
d1 $ sound (slowcat ["sn*8", "[cp*4 bd*4, hc*5]"]) # n (run 8)
If we apply a mask to it
d1 $ s ( mask ("1 1 1 ~ 1 1 ~ 1" :: Pattern Bool) ( slowcat ["sn*8", "[cp*4 bd*4, bass*5]"] ) ) # n (run 8)
Due to the use of slowcat
here, the same mask is first applied to "sn*8"
and
in the next cycle to "[cp*4 bd*4, hc*5]"
.
You could achieve the same effect by adding rests within the slowcat
patterns,
but mask allows you to do this more easily. It kind of keeps the rhythmic
structure and you can change the used samples independently, e.g.,
d1 $ s ( mask ("1 ~ 1 ~ 1 1 ~ 1") ( slowcat ["can*8", "[cp*4 sn*4, jvbass*16]"] ) ) # n (run 8)
loop :: Pattern Double -> ControlPattern #
fromList :: [a] -> Pattern a #
Turns a list of values into a pattern, playing one of them per cycle. The following are equivalent:
d1 $ n (fromList [0, 1, 2]) # s "superpiano" d1 $ n "<0 1 2>" # s "superpiano"
(*>) :: Pattern (a -> b) -> Pattern a -> Pattern b infixl 4 #
Like *
, but the "wholes" come from the right
Rational numbers, with numerator and denominator of some Integral
type.
Note that Ratio
's instances inherit the deficiencies from the type
parameter's. For example, Ratio Natural
's Num
instance has similar
problems to Natural
's.
Instances
NFData1 Ratio | Available on Since: deepseq-1.4.3.0 |
Defined in Control.DeepSeq | |
Enumerable Rational | |
Parseable Rational | |
Moddable Rational | |
Valuable Rational | |
Defined in Sound.Tidal.Pattern | |
Integral a => Lift (Ratio a :: Type) | |
(Data a, Integral a) => Data (Ratio a) | Since: base-4.0.0.0 |
Defined in Data.Data Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Ratio a -> c (Ratio a) # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Ratio a) # toConstr :: Ratio a -> Constr # dataTypeOf :: Ratio a -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Ratio a)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Ratio a)) # gmapT :: (forall b. Data b => b -> b) -> Ratio a -> Ratio a # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ratio a -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ratio a -> r # gmapQ :: (forall d. Data d => d -> u) -> Ratio a -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Ratio a -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Ratio a -> m (Ratio a) # | |
(Storable a, Integral a) => Storable (Ratio a) | Since: base-4.8.0.0 |
Integral a => Enum (Ratio a) | Since: base-2.0.1 |
Integral a => Num (Ratio a) | Since: base-2.0.1 |
(Integral a, Read a) => Read (Ratio a) | Since: base-2.1 |
Integral a => Fractional (Ratio a) | Since: base-2.0.1 |
Integral a => Real (Ratio a) | Since: base-2.0.1 |
Defined in GHC.Real Methods toRational :: Ratio a -> Rational # | |
Integral a => RealFrac (Ratio a) | Since: base-2.0.1 |
Show a => Show (Ratio a) | Since: base-2.0.1 |
NFData a => NFData (Ratio a) | |
Defined in Control.DeepSeq | |
Eq a => Eq (Ratio a) | Since: base-2.1 |
Integral a => Ord (Ratio a) | Since: base-2.0.1 |
(<*) :: Pattern (a -> b) -> Pattern a -> Pattern b infixl 4 #
Like *
, but the "wholes" come from the left
when :: (Int -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
The given pattern transformation is applied only when
the given test function
returns True
. The test function will be called with the current cycle as
a number.
d1 $ when (elem '4' . show) (striate 4) $ sound "hh hc"
The above will only apply striate 4
to the pattern if the current
cycle number contains the number 4. So the fourth cycle will be
striated and the fourteenth and so on. Expect lots of striates after
cycle number 399.
Extract the numerator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive.
denominator :: Ratio a -> a #
Extract the denominator of the ratio in reduced form: the numerator and denominator have no common factor and the denominator is positive.
swap :: Eq a => [(a, b)] -> Pattern a -> Pattern b #
Looks up values from a list of tuples, in order to swap values in the given pattern
fix :: (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern #
The fix
function applies another function to matching events in a pattern of
controls. fix
is contrast
where the false-branching function is set to the
identity id
. It is like contrast
, but one function is given and applied to
events with matching controls.
For example, the following only adds the crush
control when the n
control
is set to either 1 or 4:
d1 $ slow 2 $ fix (# crush 3) (n "[1,4]") $ n "0 1 2 3 4 5 6" # sound "arpy"
You can be quite specific; for example, the following applies the function
to sample 1 of the drum sample set, and leaves the rest as they are:hurry
2
fix (hurry 2) (s "drum" # n "1")
Randomly picks an element from the given list.
sound "superpiano(3,8)" # note (choose ["a", "e", "g", "c"])
plays a melody randomly choosing one of the four notes "a", "e", "g", "c".
As with all continuous patterns, you have to be careful to give them structure; in this case choose gives you an infinitely detailed stream of random choices.
choose = 'chooseBy' 'rand'
from :: Pattern Double -> ControlPattern #
for internal sound routing
to :: Pattern Double -> ControlPattern #
for internal sound routing
An event is a value that's active during a timespan. If a whole is present, the part should be equal to or fit inside it.
Instances
squeeze :: Pattern Int -> [Pattern a] -> Pattern a #
Chooses from a list of patterns, using a pattern of integers.
release :: Pattern Double -> ControlPattern #
a pattern of numbers to specify the release time (in seconds) of an envelope applied to each sample.
left :: ControlPattern -> ControlPattern #
right :: ControlPattern -> ControlPattern #
approxRational :: RealFrac a => a -> a -> Rational #
approxRational
, applied to two real fractional numbers x
and epsilon
,
returns the simplest rational number within epsilon
of x
.
A rational number y
is said to be simpler than another y'
if
, andabs
(numerator
y) <=abs
(numerator
y')
.denominator
y <=denominator
y'
Any real interval contains a unique simplest rational;
in particular, note that 0/1
is the simplest rational of all.
append :: Pattern a -> Pattern a -> Pattern a #
Alternate between cycles of the two given patterns > d1 $ append (sound "bd*2 sn") (sound "arpy jvbass*2")
size :: Pattern Double -> ControlPattern #
a pattern of numbers from 0 to 1. Sets the perceptual size (reverb time) of the room
to be used in reverb.
skip :: ControlPattern -> ControlPattern #
chunk :: Pattern Int -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b #
Treats the given pattern p
as having n
chunks, and applies the function f
to one of those sections per cycle.
Running:
- from left to right if chunk number is positive
- from right to left if chunk number is negative
d1 $ chunk 4 (fast 4) $ sound "cp sn arpy [mt lt]"
The following:
d1 $ chunk 4 (# speed 2) $ sound "bd hh sn cp"
applies (# speed 2)
to the uppercased part of the cycle below:
BD hh sn cp bd HH sn cp bd hh SN cp bd hh sn CP
sec :: Fractional a => Pattern a -> Pattern a #
Turns a pattern of seconds into a pattern of (rational) cycle durations
scale :: Fractional a => Pattern String -> Pattern Int -> Pattern a #
Interprets a pattern of note numbers into a particular named scale. For example:
d1 $ jux rev $ chunk 4 (fast 2 . (|- n 12)) $ off 0.25 (|+ 7) $ struct (iter 4 "t(5,8)") $ n (scale "ritusen" "0 .. 7") # sound "superpiano"
an Arc and some named control values
select :: Pattern Double -> [Pattern a] -> Pattern a #
Chooses from a list of patterns, using a pattern of floats (from 0 to 1).
lower :: ControlPattern -> ControlPattern #
cat :: [Pattern a] -> Pattern a #
Like append
, but for a list of patterns. Interlaces them, playing the
first cycle from each in turn, then the second cycle from each, and so on. It
concatenates a list of patterns into a new pattern; each pattern in the list
will maintain its original duration. For example:
d1 $ cat [sound "bd*2 sn", sound "arpy jvbass*2"] d1 $ cat [sound "bd*2 sn", sound "arpy jvbass*2", sound "drum*2"] d1 $ cat [sound "bd*2 sn", sound "jvbass*3", sound "drum*2", sound "ht mt"]
run :: (Enum a, Num a, Real a) => Pattern a -> Pattern a #
A pattern of whole numbers from 0 to the given number, in a single cycle.
Can be used used to run
through a folder of samples in order:
d1 $ n (run 8) # sound "amencutup"
The first parameter to run can be given as a pattern:
d1 $ n (run "<4 8 4 6>") # sound "amencutup"
streamList :: Stream -> IO () Source #
iter :: Pattern Int -> Pattern c -> Pattern c #
Divides a pattern into a given number of subdivisions, plays the subdivisions in order, but increments the starting subdivision each cycle. The pattern wraps to the first subdivision after the last subdivision is played.
Example:
d1 $ iter 4 $ sound "bd hh sn cp"
This will produce the following over four cycles:
bd hh sn cp hh sn cp bd sn cp bd hh cp bd hh sn
There is also iter'
, which shifts the pattern in the opposite direction.
echo :: Pattern Integer -> Pattern Rational -> Pattern Double -> ControlPattern -> ControlPattern #
Applies a type of delay to a pattern.
It has three parameters, which could be called depth
, time
and feedback
.
depth
is and integer, and time
and feedback
are floating point numbers.
This adds a bit of echo:
d1 $ echo 4 0.2 0.5 $ sound "bd sn"
The above results in 4 echos, each one 50% quieter than the last, with 1/5th of a cycle between them.
It is possible to reverse the echo:
d1 $ echo 4 (-0.2) 0.5 $ sound "bd sn"
An arc of time, with a start time (or onset) and a stop time (or offset)
Instances
Applicative ArcF | |||||
Functor ArcF | |||||
Generic (ArcF a) | |||||
Defined in Sound.Tidal.Time Associated Types
| |||||
Num a => Num (ArcF a) | |||||
Fractional a => Fractional (ArcF a) | |||||
Show a => Show (ArcF a) | |||||
NFData a => NFData (ArcF a) | |||||
Defined in Sound.Tidal.Time | |||||
Eq a => Eq (ArcF a) | |||||
Ord a => Ord (ArcF a) | |||||
type Rep (ArcF a) | |||||
Defined in Sound.Tidal.Time type Rep (ArcF a) = D1 ('MetaData "ArcF" "Sound.Tidal.Time" "tidal-core-1.10.1-7X6NkZPbcj4BkiH17qI1Wp" 'False) (C1 ('MetaCons "Arc" 'PrefixI 'True) (S1 ('MetaSel ('Just "start") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "stop") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a))) |
The sam
(start of cycle) for the given time value.
Cycles have duration 1, so every integer Time value divides two cycles.
toTime :: Real a => a -> Rational #
Turns a number into a (rational) time value. An alias for toRational
.
fromTime :: Fractional a => Time -> a #
Turns a (rational) time value into another number. An alias for fromRational
.
subArc :: Arc -> Arc -> Maybe Arc #
subArc i j
is the timespan that is the intersection of i
and j
.
intersection
The definition is a bit fiddly as results might be zero-width, but
not at the end of an non-zero-width arc - e.g. (0,1) and (1,2) do
not intersect, but (1,1) (1,1) does.
timeToCycleArc :: Time -> Arc #
The Arc returned is the cycle that the Time falls within.
Edge case: If the Time is an integer, the Arc claiming it is the one starting at that Time, not the previous one ending at that Time.
Shifts an Arc to one of equal duration that starts within cycle zero. (Note that the output Arc probably does not start *at* Time 0 -- that only happens when the input Arc starts at an integral Time.)
cyclesInArc :: Integral a => Arc -> [a] #
Returns the numbers of the cycles that the input Arc
overlaps
(excluding the input Arc
's endpoint, unless it has duration 0 --
see "Edge cases" below).
(The "cycle number" of an Arc
is equal to its start value.
Thus, for instance, cyclesInArc (Arc 0 1.5) == [0,1]
.)
Edge cases: > cyclesInArc $ Arc 0 1.0001 == [0,1] > cyclesInArc $ Arc 0 1 == [0] -- the endpoint is excluded > cyclesInArc $ Arc 1 1 == [1] -- unless the Arc has duration 0
PITFALL: Don't be fooled by the name. The output cycles
are not necessarily completely contained in the input Arc
,
but they definitely overlap it,
and they include every cycle that overlaps it.
cycleArcsInArc :: Arc -> [Arc] #
This provides exactly the same information as cyclesInArc
,
except that this represents its output as Arc
s,
whereas cyclesInArc
represents the same information as integral indices.
(The Arc
from 0 to 1 corresponds to the index 0,
the one from 1 to 2 has index 1, etc.)
arcCyclesZW :: Arc -> [Arc] #
Like arcCycles, but returns zero-width arcs
mapCycle :: (Time -> Time) -> Arc -> Arc #
Similar to fmap
but time is relative to the cycle (i.e. the
sam of the start of the arc)
lcmr :: Rational -> Rational -> Rational #
Returns the lowest common multiple of two rational numbers
Note is Double, but with a different parser
Instances
Data Note | |||||
Defined in Sound.Tidal.Pattern Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Note -> c Note # gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Note # dataTypeOf :: Note -> DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Note) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Note) # gmapT :: (forall b. Data b => b -> b) -> Note -> Note # gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Note -> r # gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Note -> r # gmapQ :: (forall d. Data d => d -> u) -> Note -> [u] # gmapQi :: Int -> (forall d. Data d => d -> u) -> Note -> u # gmapM :: Monad m => (forall d. Data d => d -> m d) -> Note -> m Note # gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Note -> m Note # gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Note -> m Note # | |||||
Enum Note | |||||
Floating Note | |||||
Generic Note | |||||
Defined in Sound.Tidal.Pattern Associated Types
| |||||
Num Note | |||||
Fractional Note | |||||
Real Note | |||||
Defined in Sound.Tidal.Pattern Methods toRational :: Note -> Rational # | |||||
RealFrac Note | |||||
Show Note | |||||
NFData Note | |||||
Defined in Sound.Tidal.Pattern | |||||
Eq Note | |||||
Ord Note | |||||
Enumerable Note | |||||
Parseable Note | |||||
Moddable Note | |||||
Valuable Note | |||||
Defined in Sound.Tidal.Pattern | |||||
type Rep Note | |||||
Defined in Sound.Tidal.Pattern |
Instances
Valuable Rational | |
Defined in Sound.Tidal.Pattern | |
Valuable Note | |
Defined in Sound.Tidal.Pattern | |
Valuable String | |
Defined in Sound.Tidal.Pattern | |
Valuable Bool | |
Defined in Sound.Tidal.Pattern | |
Valuable Double | |
Defined in Sound.Tidal.Pattern | |
Valuable Int | |
Defined in Sound.Tidal.Pattern | |
Valuable [Word8] | |
Defined in Sound.Tidal.Pattern | |
Valuable [Value] | |
Defined in Sound.Tidal.Pattern |
Polymorphic values
Constructors
VS | |
VF | |
VN | |
VR | |
VI | |
VB | |
VX | |
VPattern | |
VList | |
VState | |
Fields
|
Instances
Floating ValueMap | |||||
Defined in Sound.Tidal.Pattern Methods sqrt :: ValueMap -> ValueMap # (**) :: ValueMap -> ValueMap -> ValueMap # logBase :: ValueMap -> ValueMap -> ValueMap # asin :: ValueMap -> ValueMap # acos :: ValueMap -> ValueMap # atan :: ValueMap -> ValueMap # sinh :: ValueMap -> ValueMap # cosh :: ValueMap -> ValueMap # tanh :: ValueMap -> ValueMap # asinh :: ValueMap -> ValueMap # acosh :: ValueMap -> ValueMap # atanh :: ValueMap -> ValueMap # log1p :: ValueMap -> ValueMap # expm1 :: ValueMap -> ValueMap # | |||||
Generic Value | |||||
Defined in Sound.Tidal.Pattern Associated Types
| |||||
Num ValueMap | |||||
Fractional ValueMap | |||||
NFData Value | |||||
Defined in Sound.Tidal.Pattern | |||||
Eq Value | |||||
Ord Value | |||||
Unionable ValueMap | |||||
Moddable ValueMap | |||||
Valuable [Value] | |||||
Defined in Sound.Tidal.Pattern | |||||
type Rep Value | |||||
Defined in Sound.Tidal.Pattern type Rep Value = D1 ('MetaData "Value" "Sound.Tidal.Pattern" "tidal-core-1.10.1-7X6NkZPbcj4BkiH17qI1Wp" 'False) (((C1 ('MetaCons "VS" 'PrefixI 'True) (S1 ('MetaSel ('Just "svalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 String)) :+: C1 ('MetaCons "VF" 'PrefixI 'True) (S1 ('MetaSel ('Just "fvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Double))) :+: (C1 ('MetaCons "VN" 'PrefixI 'True) (S1 ('MetaSel ('Just "nvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Note)) :+: (C1 ('MetaCons "VR" 'PrefixI 'True) (S1 ('MetaSel ('Just "rvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Rational)) :+: C1 ('MetaCons "VI" 'PrefixI 'True) (S1 ('MetaSel ('Just "ivalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Int))))) :+: ((C1 ('MetaCons "VB" 'PrefixI 'True) (S1 ('MetaSel ('Just "bvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 Bool)) :+: C1 ('MetaCons "VX" 'PrefixI 'True) (S1 ('MetaSel ('Just "xvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Word8]))) :+: (C1 ('MetaCons "VPattern" 'PrefixI 'True) (S1 ('MetaSel ('Just "pvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Pattern Value))) :+: (C1 ('MetaCons "VList" 'PrefixI 'True) (S1 ('MetaSel ('Just "lvalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 [Value])) :+: C1 ('MetaCons "VState" 'PrefixI 'True) (S1 ('MetaSel ('Just "statevalue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (ValueMap -> (ValueMap, Value)))))))) |
Some context for an event, currently just position within sourcecode
Instances
Generic Context | |||||
Defined in Sound.Tidal.Pattern Associated Types
| |||||
NFData Context | |||||
Defined in Sound.Tidal.Pattern | |||||
Eq Context | |||||
Ord Context | |||||
type Rep Context | |||||
Defined in Sound.Tidal.Pattern |
Methods
deltaContext :: Int -> Int -> a -> a #
Instances
Stringy String | |
Defined in Sound.Tidal.Pattern | |
Stringy (Pattern a) | |
Defined in Sound.Tidal.Pattern |
type ControlPattern = Pattern ValueMap #
A datatype representing events taking place over time
Instances
Applicative Pattern | |||||
Functor Pattern | |||||
Monad Pattern | |||||
Monoid (Pattern a) | |||||
Semigroup (Pattern a) | |||||
Enum a => Enum (Pattern a) | |||||
Defined in Sound.Tidal.Pattern Methods succ :: Pattern a -> Pattern a # pred :: Pattern a -> Pattern a # fromEnum :: Pattern a -> Int # enumFrom :: Pattern a -> [Pattern a] # enumFromThen :: Pattern a -> Pattern a -> [Pattern a] # enumFromTo :: Pattern a -> Pattern a -> [Pattern a] # enumFromThenTo :: Pattern a -> Pattern a -> Pattern a -> [Pattern a] # | |||||
Floating a => Floating (Pattern a) | |||||
Defined in Sound.Tidal.Pattern Methods exp :: Pattern a -> Pattern a # log :: Pattern a -> Pattern a # sqrt :: Pattern a -> Pattern a # (**) :: Pattern a -> Pattern a -> Pattern a # logBase :: Pattern a -> Pattern a -> Pattern a # sin :: Pattern a -> Pattern a # cos :: Pattern a -> Pattern a # tan :: Pattern a -> Pattern a # asin :: Pattern a -> Pattern a # acos :: Pattern a -> Pattern a # atan :: Pattern a -> Pattern a # sinh :: Pattern a -> Pattern a # cosh :: Pattern a -> Pattern a # tanh :: Pattern a -> Pattern a # asinh :: Pattern a -> Pattern a # acosh :: Pattern a -> Pattern a # atanh :: Pattern a -> Pattern a # log1p :: Pattern a -> Pattern a # expm1 :: Pattern a -> Pattern a # | |||||
RealFloat a => RealFloat (Pattern a) | |||||
Defined in Sound.Tidal.Pattern Methods floatRadix :: Pattern a -> Integer # floatDigits :: Pattern a -> Int # floatRange :: Pattern a -> (Int, Int) # decodeFloat :: Pattern a -> (Integer, Int) # encodeFloat :: Integer -> Int -> Pattern a # exponent :: Pattern a -> Int # significand :: Pattern a -> Pattern a # scaleFloat :: Int -> Pattern a -> Pattern a # isInfinite :: Pattern a -> Bool # isDenormalized :: Pattern a -> Bool # isNegativeZero :: Pattern a -> Bool # | |||||
Generic (Pattern a) | |||||
Defined in Sound.Tidal.Pattern Associated Types
| |||||
Num a => Num (Pattern a) | |||||
Defined in Sound.Tidal.Pattern | |||||
Fractional a => Fractional (Pattern a) | |||||
Integral a => Integral (Pattern a) | |||||
Defined in Sound.Tidal.Pattern Methods quot :: Pattern a -> Pattern a -> Pattern a # rem :: Pattern a -> Pattern a -> Pattern a # div :: Pattern a -> Pattern a -> Pattern a # mod :: Pattern a -> Pattern a -> Pattern a # quotRem :: Pattern a -> Pattern a -> (Pattern a, Pattern a) # divMod :: Pattern a -> Pattern a -> (Pattern a, Pattern a) # | |||||
(Num a, Ord a) => Real (Pattern a) | |||||
Defined in Sound.Tidal.Pattern Methods toRational :: Pattern a -> Rational # | |||||
RealFrac a => RealFrac (Pattern a) | |||||
NFData a => NFData (Pattern a) | |||||
Defined in Sound.Tidal.Pattern | |||||
Eq (Pattern a) | |||||
Ord a => Ord (Pattern a) | |||||
Stringy (Pattern a) | |||||
Defined in Sound.Tidal.Pattern | |||||
type Rep (Pattern a) | |||||
Defined in Sound.Tidal.Pattern type Rep (Pattern a) = D1 ('MetaData "Pattern" "Sound.Tidal.Pattern" "tidal-core-1.10.1-7X6NkZPbcj4BkiH17qI1Wp" 'False) (C1 ('MetaCons "Pattern" 'PrefixI 'True) (S1 ('MetaSel ('Just "query") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (State -> [Event a])) :*: (S1 ('MetaSel ('Just "steps") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe Rational)) :*: S1 ('MetaSel ('Just "pureValue") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (Maybe a))))) |
setStepsFrom :: Pattern b -> Pattern a -> Pattern a #
(<<*) :: Pattern (a -> b) -> Pattern a -> Pattern b infixl 4 #
Like *
, but the "wholes" come from the left
applyPatToPat :: (Maybe Arc -> Maybe Arc -> Maybe (Maybe Arc)) -> Pattern (a -> b) -> Pattern a -> Pattern b #
applyPatToPatBoth :: Pattern (a -> b) -> Pattern a -> Pattern b #
applyPatToPatLeft :: Pattern (a -> b) -> Pattern a -> Pattern b #
applyPatToPatRight :: Pattern (a -> b) -> Pattern a -> Pattern b #
applyPatToPatSqueeze :: Pattern (a -> b) -> Pattern a -> Pattern b #
unwrap :: Pattern (Pattern a) -> Pattern a #
Turns a pattern of patterns into a single pattern.
(this is actually join
)
1/ For query arc
, get the events from the outer pattern pp
2/ Query the inner pattern using the part
of the outer
3/ For each inner event, set the whole and part to be the intersection
of the outer whole and part, respectively
4 Concatenate all the events together (discarding wholesparts that didn't intersect)
TODO - what if a continuous pattern contains a discrete one, or vice-versa?
innerJoin :: Pattern (Pattern b) -> Pattern b #
Turns a pattern of patterns into a single pattern. Like unwrap
,
but structure only comes from the inner pattern.
outerJoin :: Pattern (Pattern a) -> Pattern a #
Turns a pattern of patterns into a single pattern. Like unwrap
,
but structure only comes from the outer pattern.
squeezeJoin :: Pattern (Pattern a) -> Pattern a #
Like unwrap
, but cycles of the inner patterns are compressed to fit the
timespan of the outer whole (or the original query if it's a continuous pattern?)
TODO - what if a continuous pattern contains a discrete one, or vice-versa?
TODO - steps
trigZeroJoin :: Pattern (Pattern a) -> Pattern a #
splitQueries :: Pattern a -> Pattern a #
Splits queries that span cycles. For example `query p (0.5, 1.5)` would be turned into two queries, `(0.5,1)` and `(1,1.5)`, and the results combined. Being able to assume queries don't span cycles often makes transformations easier to specify.
withResultArc :: (Arc -> Arc) -> Pattern a -> Pattern a #
Apply a function to the arcs/timespans (both whole and parts) of the result
withResultTime :: (Time -> Time) -> Pattern a -> Pattern a #
Apply a function to the time (both start and end of the timespans of both whole and parts) of the result
withQueryArc :: (Arc -> Arc) -> Pattern a -> Pattern a #
Apply a function to the timespan of the query
withQueryTime :: (Time -> Time) -> Pattern a -> Pattern a #
Apply a function to the time (both start and end) of the query
withQueryControls :: (ValueMap -> ValueMap) -> Pattern a -> Pattern a #
Apply a function to the control values of the query
withEvent :: (Event a -> Event b) -> Pattern a -> Pattern b #
withEvent f p
returns a new Pattern
with each event mapped over
function f
.
withValue :: (a -> b) -> Pattern a -> Pattern b #
withEvent f p
returns a new Pattern
with each value mapped over
function f
.
withEvents :: ([Event a] -> [Event b]) -> Pattern a -> Pattern b #
withEvent f p
returns a new Pattern
with f applied to the resulting list of events for each query
function f
.
withPart :: (Arc -> Arc) -> Pattern a -> Pattern a #
withPart f p
returns a new Pattern
with function f
applied
to the part.
extractI :: String -> ControlPattern -> Pattern Int #
Extract a pattern of integer values by from a control pattern, given the name of the control
extractF :: String -> ControlPattern -> Pattern Double #
Extract a pattern of floating point values by from a control pattern, given the name of the control
extractS :: String -> ControlPattern -> Pattern String #
Extract a pattern of string values by from a control pattern, given the name of the control
extractB :: String -> ControlPattern -> Pattern Bool #
Extract a pattern of boolean values by from a control pattern, given the name of the control
extractR :: String -> ControlPattern -> Pattern Rational #
Extract a pattern of rational values by from a control pattern, given the name of the control
extractN :: String -> ControlPattern -> Pattern Note #
Extract a pattern of note values by from a control pattern, given the name of the control
compressArc :: Arc -> Pattern a -> Pattern a #
compressArcTo :: Arc -> Pattern a -> Pattern a #
fast :: Pattern Time -> Pattern a -> Pattern a #
Speed up a pattern by the given time pattern.
For example, the following will play the sound pattern "bd sn kurt"
twice as
fast (i.e., so it repeats twice per cycle), and the vowel pattern three times
as fast:
d1 $ sound (fast 2 "bd sn kurt") # fast 3 (vowel "a e o")
The first parameter can be patterned to, for example, play the pattern at twice the speed for the first half of each cycle and then four times the speed for the second half:
d1 $ fast "2 4" $ sound "bd sn kurt cp"
fastSqueeze :: Pattern Time -> Pattern a -> Pattern a #
fastSqueeze
speeds up a pattern by a time pattern given as input,
squeezing the resulting pattern inside one cycle and playing the original
pattern at every repetition.
To better understand how it works, compare it with fast
:
>>>
fast "1 2" $ s "bd sn"
(0>½)|s: "bd" (½>¾)|s: "bd" (¾>1)|s: "sn"
This will give bd
played in the first half cycle, and bd sn
in the second
half. On the other hand, using fastSqueeze;
>>>
print $ fastSqueeze "1 2" $ s "bd sn"
(0>¼)|s: "bd" (¼>½)|s: "sn" (½>⅝)|s: "bd" (⅝>¾)|s: "sn" (¾>⅞)|s: "bd" (⅞>1)|s: "sn"
The original pattern will play in the first half, and two repetitions of the original pattern will play in the second half. That is, every repetition contains the whole pattern.
If the time pattern has a single value, it becomes equivalent to fast
:
d1 $ fastSqueeze 2 $ s "bd sn" d1 $ fast 2 $ s "bd sn" d1 $ s "[bd sn]*2"
slow :: Pattern Time -> Pattern a -> Pattern a #
Slow down a pattern by the given time pattern.
For example, the following will play the sound pattern "bd sn kurt"
twice as
slow (i.e., so it repeats once every two cycles), and the vowel pattern three
times as slow:
d1 $ sound (slow 2 "bd sn kurt") # slow 3 (vowel "a e o")
rotL :: Time -> Pattern a -> Pattern a #
Shifts a pattern back in time by the given amount, expressed in cycles.
This will skip to the fourth cycle:
do resetCycles d1 $ rotL 4 $ seqP [ (0, 12, sound "bd bd*2") , (4, 12, sound "hh*2 [sn cp] cp future*4") , (8, 12, sound (samples "arpy*8" (run 16))) ]
Useful when building and testing out longer sequences.
rotR :: Time -> Pattern a -> Pattern a #
Shifts a pattern forward in time by the given amount, expressed in cycles.
Opposite of rotL
.
rev :: Pattern a -> Pattern a #
rev p
returns p
with the event positions in each cycle reversed (or
mirrored).
For example rev "1 [~ 2] ~ 3"
is equivalent to rev "3 ~ [2 ~] 1"
.
Note that rev
reverses on a cycle-by-cycle basis. This means that rev (slow
2 "1 2 3 4")
would actually result in (slow 2 "2 1 4 3")
. This is because the
slow 2
makes the repeating pattern last two cycles, each of which is reversed
independently.
In practice rev is generally used with conditionals, for example with every:
d1 $ every 3 rev $ n "0 1 [~ 2] 3" # sound "arpy"
or jux
:
d1 $ jux rev $ n (iter 4 "0 1 [~ 2] 3") # sound "arpy"
matchManyToOne :: (b -> a -> Bool) -> Pattern a -> Pattern b -> Pattern (Bool, b) #
Mark values in the first pattern which match with at least one value in the second pattern.
filterValues :: (a -> Bool) -> Pattern a -> Pattern a #
Remove events from patterns that to not meet the given test
filterJust :: Pattern (Maybe a) -> Pattern a #
filterOnsets :: Pattern a -> Pattern a #
filterDigital :: Pattern a -> Pattern a #
filterAnalog :: Pattern a -> Pattern a #
separateCycles :: Int -> Pattern a -> [Pattern a] #
Splits a pattern into a list containing the given n
number of
patterns. Each one plays every n
th cycle, successfully offset by
a cycle.
patternify :: (t1 -> t2 -> Pattern a) -> Pattern t1 -> t2 -> Pattern a #
patternify2' :: (a -> b -> Pattern c -> Pattern d) -> Pattern a -> Pattern b -> Pattern c -> Pattern d #
patternify3 :: (a -> b -> c -> Pattern d -> Pattern e) -> Pattern a -> Pattern b -> Pattern c -> Pattern d -> Pattern e #
patternify3' :: (a -> b -> c -> Pattern d -> Pattern e) -> Pattern a -> Pattern b -> Pattern c -> Pattern d -> Pattern e #
combineContexts :: [Context] -> Context #
setContext :: Context -> Pattern a -> Pattern a #
defragParts :: Eq a => [Event a] -> [Event a] #
Returns a list of events, with any adjacent parts of the same whole combined
isAdjacent :: Eq a => Event a -> Event a -> Bool #
Returns True
if the two given events are adjacent parts of the same whole
wholeOrPart :: Event a -> Arc #
wholeStart :: Event a -> Time #
Get the onset of an event's whole
eventPartStart :: Event a -> Time #
Get the onset of an event's whole
eventPartStop :: Event a -> Time #
Get the offset of an event's part
eventValue :: Event a -> a #
eventHasOnset :: Event a -> Bool #
applyFIS :: (Double -> Double) -> (Int -> Int) -> (String -> String) -> Value -> Value #
General utilities..
Apply one of three functions to a Value, depending on its type
fNum2 :: (Int -> Int -> Int) -> (Double -> Double -> Double) -> Value -> Value -> Value #
Apply one of two functions to a pair of Values, depending on their types (int or float; strings and rationals are ignored)
valueToPattern :: Value -> Pattern Value #
collectEvent :: [Event a] -> Maybe (Event [a]) #
collectBy :: Eq a => (Event a -> Event a -> Bool) -> Pattern a -> Pattern [a] #
collects all events satisfying the same constraint into a list
collect :: Eq a => Pattern a -> Pattern [a] #
collects all events occuring at the exact same time into a list
uncollectEvent :: Event [a] -> [Event a] #
uncollectEvents :: [Event [a]] -> [Event a] #
uncollect :: Pattern [a] -> Pattern a #
merges all values in a list into one pattern by stacking the values
showStateful :: ControlPattern -> String #
drawLineSz :: Int -> Pattern Char -> Render #
sine :: Fractional a => Pattern a #
sine
- unipolar sinewave. A pattern of continuous values following a
sinewave with frequency of one cycle, and amplitude from 0 to 1.
sine2 :: Fractional a => Pattern a #
sine2
- bipolar sinewave. A pattern of continuous values following a
sinewave with frequency of one cycle, and amplitude from -1 to 1.
cosine :: Fractional a => Pattern a #
cosine
- unipolar cosine wave. A pattern of continuous values
following a cosine with frequency of one cycle, and amplitude from
0 to 1. Equivalent to 0.25 ~> sine
.
cosine2 :: Fractional a => Pattern a #
cosine2
- bipolar cosine wave. A pattern of continuous values
following a cosine with frequency of one cycle, and amplitude from
-1 to 1. Equivalent to 0.25 ~> sine2
.
saw :: (Fractional a, Real a) => Pattern a #
saw
- unipolar ascending sawtooth wave. A pattern of continuous values
following a sawtooth with frequency of one cycle, and amplitude from
0 to 1.
saw2 :: (Fractional a, Real a) => Pattern a #
saw2
- bipolar ascending sawtooth wave. A pattern of continuous values
following a sawtooth with frequency of one cycle, and amplitude from
-1 to 1.
isaw :: (Fractional a, Real a) => Pattern a #
isaw
like saw
, but a descending (inverse) sawtooth.
isaw2 :: (Fractional a, Real a) => Pattern a #
isaw2
like saw2
, but a descending (inverse) sawtooth.
tri :: (Fractional a, Real a) => Pattern a #
tri
- unipolar triangle wave. A pattern of continuous values
following a triangle wave with frequency of one cycle, and amplitude from
0 to 1.
tri2 :: (Fractional a, Real a) => Pattern a #
tri2
- bipolar triangle wave. A pattern of continuous values
following a triangle wave with frequency of one cycle, and amplitude from
-1 to 1.
square :: Fractional a => Pattern a #
square
- unipolar square wave. A pattern of continuous values
following a square wave with frequency of one cycle, and amplitude from
0 to 1.
| square
is like sine
, for square waves.
square2 :: Fractional a => Pattern a #
square2
- bipolar square wave. A pattern of continuous values
following a square wave with frequency of one cycle, and amplitude from
-1 to 1.
(|+|) :: (Applicative a, Num b) => a b -> a b -> a b #
(|/|) :: (Applicative a, Fractional b) => a b -> a b -> a b #
(|*|) :: (Applicative a, Num b) => a b -> a b -> a b #
(|-|) :: (Applicative a, Num b) => a b -> a b -> a b #
(|%|) :: (Applicative a, Moddable b) => a b -> a b -> a b #
(|**|) :: (Applicative a, Floating b) => a b -> a b -> a b #
(|>|) :: (Applicative a, Unionable b) => a b -> a b -> a b #
(|<|) :: (Applicative a, Unionable b) => a b -> a b -> a b #
fastFromList :: [a] -> Pattern a #
Turns a list of values into a pattern, playing all of them per cycle. The following are equivalent:
d1 $ n (fastFromList [0, 1, 2]) # s "superpiano" d1 $ n "[0 1 2]" # s "superpiano"
listToPat :: [a] -> Pattern a #
A synonym for fastFromList
fromMaybes :: [Maybe a] -> Pattern a #
scan :: (Enum a, Num a) => Pattern a -> Pattern a #
Similar to run
, but starts from 1
for the first cycle, successively
adds a number until it gets up to n
.
> d1 $ n (scan 8) # sound "amencutup"
slowappend :: Pattern a -> Pattern a -> Pattern a #
fastAppend :: Pattern a -> Pattern a -> Pattern a #
Like append
, but twice as fast
> d1 $ fastAppend (sound "bd*2 sn") (sound "arpy jvbass*2")
fastappend :: Pattern a -> Pattern a -> Pattern a #
fastCat :: [Pattern a] -> Pattern a #
The same as cat
, but speeds up the result by the number of
patterns there are, so the cycles from each are squashed to fit a
single cycle.
d1 $ fastcat [sound "bd*2 sn", sound "arpy jvbass*2"] d1 $ fastcat [sound "bd*2 sn", sound "arpy jvbass*2", sound "drum*2"] d1 $ fastcat [sound "bd*2 sn", sound "jvbass*3", sound "drum*2", sound "ht mt"]
timeCat :: [(Time, Pattern a)] -> Pattern a #
Similar to fastCat
, but each pattern is given a relative duration.
You provide proportionate sizes of the patterns to each other for when they’re
concatenated into one cycle. The larger the value in the list, the larger
relative size the pattern takes in the final loop. If all values are equal
then this is equivalent to fastcat (e.g. the following two code fragments are
equivalent).
d1 $ fastcat [s "bd*4", s "hh27*8", s "superpiano" # n 0]
d1 $ timeCat [ (1, s "bd*4") , (1, s "hh27*8") , (1, s "superpiano" # n 0) ]
overlay :: Pattern a -> Pattern a -> Pattern a #
overlay
combines two Pattern
s into a new pattern, so that their events
are combined over time. For example, the following two lines are equivalent:
d1 $ sound (overlay "bd sn:2" "cp*3") d1 $ sound "[bd sn:2, cp*3]"
overlay
is equal to <>
,
(<>) :: Semigroup a => a -> a -> a
which can thus be used as an infix operator equivalent of overlay
:
d1 $ sound ("bd sn:2" <> "cp*3")
mono :: Pattern a -> Pattern a #
Serialises a pattern so there's only one event playing at any one time, making it monophonic. Events which start/end earlier are given priority.
stack :: [Pattern a] -> Pattern a #
stack
combines a list of Pattern
s into a new pattern, so that their
events are combined over time, i.e., all of the patterns in the list are played
simultaneously.
d1 $ stack [ sound "bd bd*2", sound "hh*2 [sn cp] cp future*4", sound "arpy" +| n "0 .. 15" ]
This is particularly useful if you want to apply a function or synth control pattern to multiple patterns at once:
d1 $ whenmod 5 3 (striate 3) $ stack [ sound "bd bd*2", sound "hh*2 [sn cp] cp future*4", sound "arpy" +| n "0 .. 15" ] # speed "[[1 0.8], [1.5 2]*2]/3"
(<~) :: Pattern Time -> Pattern a -> Pattern a #
Shifts a pattern back in time by the given amount, expressed in cycles
(~>) :: Pattern Time -> Pattern a -> Pattern a #
Shifts a pattern forward in time by the given amount, expressed in cycles
slowSqueeze :: Pattern Time -> Pattern a -> Pattern a #
Slow down a pattern by the factors in the given time pattern, "squeezing"
the pattern to fit the slot given in the time pattern. It is the slow analogue
to fastSqueeze
.
If the time pattern only has a single value in a cycle, slowSqueeze
becomes equivalent to slow. These are equivalent:
d1 $ slow "<2 4>" $ s "bd*8" d1 $ slowSqueeze "<2 4>" $ s "bd*8"
When the time pattern has multiple values, however, the behavior is a little different. Instead, a slowed version of the pattern will be made for each value in the time pattern, and they’re all combined together in a cycle according to the structure of the time pattern. For example, these are equivalent:
d1 $ slowSqueeze "2 4 8 16" $ s "bd*8" d1 $ s "bd*4 bd*2 bd bd/2"
as are these:
d1 $ slowSqueeze "2 4 [8 16]" $ s "bd*8" d1 $ s "bd*4 bd*2 [bd bd/2]"
zoom :: (Time, Time) -> Pattern a -> Pattern a #
Plays a portion of a pattern, specified by a time arc (start and end time). The new resulting pattern is played over the time period of the original pattern.
d1 $ zoom (0.25, 0.75) $ sound "bd*2 hh*3 [sn bd]*2 drum"
In the pattern above, zoom
is used with an arc from 25% to 75%. It is
equivalent to:
d1 $ sound "hh*3 [sn bd]*2"
Here’s an example of it being used with a conditional:
d1 $ every 4 (zoom (0.25, 0.75)) $ sound "bd*2 hh*3 [sn bd]*2 drum"
fastGap :: Pattern Time -> Pattern a -> Pattern a #
fastGap
is similar to fast
but maintains its cyclic alignment, i.e.,
rather than playing the pattern multiple times, it instead leaves a gap in
the remaining space of the cycle. For example, fastGap 2 p
would squash the
events in pattern p
into the first half of each cycle (and the second halves
would be empty). The factor should be at least 1.
compress :: (Time, Time) -> Pattern a -> Pattern a #
compress
takes a pattern and squeezes it within the specified time span (i.e.
the ‘arc’). The new resulting pattern is a sped up version of the original.
d1 $ compress (1/4, 3/4) $ s "[bd sn]!"
In the above example, the pattern will play in an arc spanning from 25% to 75% of the duration of a cycle. It is equivalent to:
d1 $ s "~ [bd sn]! ~"
Another example, where all events are different:
d1 $ compress (1/4, 3/4) $ n (run 4) # s "arpy"
It differs from zoom
in that it preserves the original pattern but it speeds
up its events so to match with the new time period.
_repeatCycles :: Int -> Pattern a -> Pattern a #
fastRepeatCycles :: Int -> Pattern a -> Pattern a #
every :: Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
- Higher order functions
Functions which work on other functions (higher order functions)
every n f p
applies the function f
to p
, but only affects
every n
cycles.
It takes three inputs: how often the function should be applied (e.g. 3 to apply it every 3 cycles), the function to be applied, and the pattern you are applying it to. For example: to reverse a pattern every three cycles (and for the other two play it normally)
d1 $ every 3 rev $ n "0 1 [~ 2] 3" # sound "arpy"
Note that if the function you’re applying requires additional parameters itself (such as fast 2 to make a pattern twice as fast), then you’ll need to wrap it in parenthesis, like so:
d1 $ every 3 (fast 2) $ n "0 1 [~ 2] 3" # sound "arpy"
Otherwise, the every function will think it is being passed too many parameters.
every' :: Pattern Int -> Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
every' n o f p
is like every n f p
but with an offset of o
cycles.
For example, every' 3 0 (fast 2)
will speed up the cycle on cycles 0,3,6,…
whereas every' 3 1 (fast 2)
will transform the pattern on cycles 1,4,7,….
With this in mind, setting the second argument of every'
to 0 gives the
equivalent every function. For example, every 3 is equivalent to every' 3 0.
The every
functions can be used to silence a full cycle or part of a cycle
by using silent or mask "~". Mask provides additional flexibility to turn on/off
individual steps.
d1 $ every 3 silent $ n "2 9 11 2" # s "hh27" d1 $ every 3 (mask "~") $ n "2 9 10 2" # s "hh27" d1 $ every 3 (mask "0 0 0 0") $ n "2 9 11 2" # s "hh27"
foldEvery :: [Int] -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
foldEvery ns f p
applies the function f
to p
, and is applied for
each cycle in ns
.
It is similar to chaining multiple every
functions together. It transforms
a pattern with a function, once per any of the given number of cycles. If a
particular cycle is the start of more than one of the given cycle periods, then
it it applied more than once.
d1 $ foldEvery [5,3] (|+ n 1) $ s "moog" # legato 1
The first moog samples are tuned to C2, C3 and C4. Note how on cycles that are multiples of 3 or 5 the pitch is an octave higher, and on multiples of 15 the pitch is two octaves higher, as the transformation is applied twice.
whenT :: (Time -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
Like when
, but works on continuous time values rather than cycle numbers.
The following will apply # speed 2
only when the remainder of the current
Time
divided by 2 is less than 0.5:
d1 $ whenT ((< 0.5) . (flip Data.Fixed.mod' 2)) (# speed 2) $ sound "hh(4,8) hc(3,8)"
getScale :: Fractional a => [(String, [a])] -> Pattern String -> Pattern Int -> Pattern a #
Build a scale function, with additional scales if you wish. For example:
let myscale = getScale ( scaleTable ++ [ ("techno", [0,2,3,5,7,8,10]) , ("broken", [0,1,4,7,8,10]) ] )
The above takes the standard scaleTable
as a starting point and adds two custom scales to it. You’ll be able to use the new function in place of the normal one:
d1 $ n (myscale "techno" "0 1 2 3 4 5 6 7") # sound "superpiano"
scaleWithList :: (Eq a, Fractional a) => Pattern String -> [[a] -> [a]] -> Pattern Int -> Pattern a #
raiseDegree :: Fractional a => Int -> [a] -> [a] #
lowerDegree :: Fractional a => Int -> [a] -> [a] #
raiseDegrees :: Fractional a => Int -> Int -> [a] -> [a] #
lowerDegrees :: Fractional a => Int -> Int -> [a] -> [a] #
Outputs this list of all the available scales:
minPent majPent ritusen egyptian kumai hirajoshi iwato chinese indian pelog prometheus scriabin gong shang jiao zhi yu whole wholetone augmented augmented2 hexMajor7 hexDorian hexPhrygian hexSus hexMajor6 hexAeolian major ionian dorian phrygian lydian mixolydian aeolian minor locrian harmonicMinor harmonicMajor melodicMinor melodicMinorDesc melodicMajor bartok hindu todi purvi marva bhairav ahirbhairav superLocrian romanianMinor hungarianMinor neapolitanMinor enigmatic spanish leadingWhole lydianMinor neapolitanMajor locrianMajor diminished octatonic diminished2 octatonic2 messiaen1 messiaen2 messiaen3 messiaen4 messiaen5 messiaen6 messiaen7 chromatic bayati hijaz sikah rast saba iraq
scaleTable :: Fractional a => [(String, [a])] #
Outputs a list of all available scales and their corresponding notes. For
example, its first entry is ("minPent",[0,3,5,7,10]
) which means that
a minor pentatonic scale is formed by the root (0), the minor third (3 semitones
above the root), the perfect fourth (5 semitones above the root), etc.
As the list is big, you can use the Haskell function lookup to look up a
specific scale: lookup "phrygian" scaleTable
. This will output
Just [0.0,1.0,3.0,5.0,7.0,8.0,10.0]
.
You can also do a reverse lookup into the scale table. For example:
filter ( \(_, x) -> take 3 x == [0,2,4] ) scaleTable
The above example will output all scales of which the first three notes are the root, the major second (2 semitones above the fundamental), and the major third (4 semitones above the root).
Arguments
:: String | A parameter, e.g. |
-> String | Identifies the cycling state pattern. Can be anything the user wants. |
-> [Value] | The list to cycle through. |
-> ControlPattern |
pStateList
is made with cyclic lists in mind,
but it can even "cycle" through infinite lists.
pStateListF :: String -> String -> [Double] -> ControlPattern #
A wrapper for pStateList
that accepts a `[Double]`
rather than a `[Value]`.
pStateListS :: String -> String -> [String] -> ControlPattern #
A wrapper for pStateList
that accepts a `[String]`
rather than a `[Value]`.
sound :: Pattern String -> ControlPattern #
sTake :: String -> [String] -> ControlPattern #
cc :: Pattern String -> ControlPattern #
nrpn :: Pattern String -> ControlPattern #
nrpnn :: Pattern Int -> ControlPattern #
nrpnv :: Pattern Int -> ControlPattern #
grain' :: Pattern String -> ControlPattern #
grain'
is a shortcut to join a begin
and end
These are equivalent:
d1 $ slow 2 $ s "bev" # grain' "0.2:0.3" # legato 1 d1 $ slow 2 $ s "bev" # begin 0.2 # end 0.3 # legato 1
midinote :: Pattern Note -> ControlPattern #
drum :: Pattern String -> ControlPattern #
accelerate :: Pattern Double -> ControlPattern #
A pattern of numbers that speed up (or slow down) samples while they play.
In the following example, the sound starts at the original pitch and gets higher as it plays:
d1 $ s "arpy" # accelerate 2
You can use a negative number to make the sound get lower. In this example, a different acceleration is applied to each played note using state values:
d1 $ arp "up" $ note "c'maj'4" # s "arpy" # accelerateTake "susan" [0.2,1,-1]
accelerateTake :: String -> [Double] -> ControlPattern #
accelerateCount :: String -> ControlPattern #
acceleratebus :: Pattern Int -> Pattern Double -> ControlPattern #
amp :: Pattern Double -> ControlPattern #
Controls the amplitude (volume) of the sound. Like gain
, but linear.
Default value is 0.4.
d1 $ s "arpy" # amp "<0.4 0.8 0.2>"
ampTake :: String -> [Double] -> ControlPattern #
ampCount :: String -> ControlPattern #
amprecv :: Pattern Int -> ControlPattern #
arrayTake :: String -> [Double] -> ControlPattern #
attack :: Pattern Double -> ControlPattern #
a pattern of numbers to specify the attack time (in seconds) of an envelope applied to each sample.
attackTake :: String -> [Double] -> ControlPattern #
attackCount :: String -> ControlPattern #
attackrecv :: Pattern Int -> ControlPattern #
bandf :: Pattern Double -> ControlPattern #
a pattern of numbers from 0 to 1. Sets the center frequency of the band-pass filter.
bandfTake :: String -> [Double] -> ControlPattern #
bandfCount :: String -> ControlPattern #
bandfrecv :: Pattern Int -> ControlPattern #
bandq :: Pattern Double -> ControlPattern #
a pattern of anumbers from 0 to 1. Sets the q-factor of the band-pass filter.
bandqTake :: String -> [Double] -> ControlPattern #
bandqCount :: String -> ControlPattern #
bandqrecv :: Pattern Int -> ControlPattern #
bank :: Pattern String -> ControlPattern #
A pattern of strings. When sent to SuperDirt, will be prepended to sample folder names, separated by an underscore. This allows sample sets to be organised into separate banks. See https://github.com/musikinformatik/SuperDirt/pull/312
begin :: Pattern Double -> ControlPattern #
begin
receives a pattern of numbers from 0 to 1 and skips the beginning
of each sample by the indicated proportion. I.e., 0 would play the sample from
the start, 1 would skip the whole sample, and 0.25 would cut off the first
quarter.
In this example, the first 3 ade
samples are played on every cycle, but the
start point from which they are played changes on each cycle:
d1 $ n "0 1 2" # s "ade" # begin "<0 0.25 0.5 0.75>" # legato 1
beginTake :: String -> [Double] -> ControlPattern #
beginCount :: String -> ControlPattern #
binshift :: Pattern Double -> ControlPattern #
Spectral binshift
binshiftTake :: String -> [Double] -> ControlPattern #
binshiftCount :: String -> ControlPattern #
binshiftbus :: Pattern Int -> Pattern Double -> ControlPattern #
binshiftrecv :: Pattern Int -> ControlPattern #
button0 :: Pattern Double -> ControlPattern #
button0Take :: String -> [Double] -> ControlPattern #
button0Count :: String -> ControlPattern #
button0bus :: Pattern Int -> Pattern Double -> ControlPattern #
button0recv :: Pattern Int -> ControlPattern #
button1 :: Pattern Double -> ControlPattern #
button1Take :: String -> [Double] -> ControlPattern #
button1Count :: String -> ControlPattern #
button1bus :: Pattern Int -> Pattern Double -> ControlPattern #
button1recv :: Pattern Int -> ControlPattern #
button10 :: Pattern Double -> ControlPattern #
button10Take :: String -> [Double] -> ControlPattern #
button10Count :: String -> ControlPattern #
button10bus :: Pattern Int -> Pattern Double -> ControlPattern #
button10recv :: Pattern Int -> ControlPattern #
button11 :: Pattern Double -> ControlPattern #
button11Take :: String -> [Double] -> ControlPattern #
button11Count :: String -> ControlPattern #
button11bus :: Pattern Int -> Pattern Double -> ControlPattern #
button11recv :: Pattern Int -> ControlPattern #
button12 :: Pattern Double -> ControlPattern #
button12Take :: String -> [Double] -> ControlPattern #
button12Count :: String -> ControlPattern #
button12bus :: Pattern Int -> Pattern Double -> ControlPattern #
button12recv :: Pattern Int -> ControlPattern #
button13 :: Pattern Double -> ControlPattern #
button13Take :: String -> [Double] -> ControlPattern #
button13Count :: String -> ControlPattern #
button13bus :: Pattern Int -> Pattern Double -> ControlPattern #
button13recv :: Pattern Int -> ControlPattern #
button14 :: Pattern Double -> ControlPattern #
button14Take :: String -> [Double] -> ControlPattern #
button14Count :: String -> ControlPattern #
button14bus :: Pattern Int -> Pattern Double -> ControlPattern #
button14recv :: Pattern Int -> ControlPattern #
button15 :: Pattern Double -> ControlPattern #
button15Take :: String -> [Double] -> ControlPattern #
button15Count :: String -> ControlPattern #
button15bus :: Pattern Int -> Pattern Double -> ControlPattern #
button15recv :: Pattern Int -> ControlPattern #
button2 :: Pattern Double -> ControlPattern #
button2Take :: String -> [Double] -> ControlPattern #
button2Count :: String -> ControlPattern #
button2bus :: Pattern Int -> Pattern Double -> ControlPattern #
button2recv :: Pattern Int -> ControlPattern #
button3 :: Pattern Double -> ControlPattern #
button3Take :: String -> [Double] -> ControlPattern #
button3Count :: String -> ControlPattern #
button3bus :: Pattern Int -> Pattern Double -> ControlPattern #
button3recv :: Pattern Int -> ControlPattern #
button4 :: Pattern Double -> ControlPattern #
button4Take :: String -> [Double] -> ControlPattern #
button4Count :: String -> ControlPattern #
button4bus :: Pattern Int -> Pattern Double -> ControlPattern #
button4recv :: Pattern Int -> ControlPattern #
button5 :: Pattern Double -> ControlPattern #
button5Take :: String -> [Double] -> ControlPattern #
button5Count :: String -> ControlPattern #
button5bus :: Pattern Int -> Pattern Double -> ControlPattern #
button5recv :: Pattern Int -> ControlPattern #
button6 :: Pattern Double -> ControlPattern #
button6Take :: String -> [Double] -> ControlPattern #
button6Count :: String -> ControlPattern #
button6bus :: Pattern Int -> Pattern Double -> ControlPattern #
button6recv :: Pattern Int -> ControlPattern #
button7 :: Pattern Double -> ControlPattern #
button7Take :: String -> [Double] -> ControlPattern #
button7Count :: String -> ControlPattern #
button7bus :: Pattern Int -> Pattern Double -> ControlPattern #
button7recv :: Pattern Int -> ControlPattern #
button8 :: Pattern Double -> ControlPattern #
button8Take :: String -> [Double] -> ControlPattern #
button8Count :: String -> ControlPattern #
button8bus :: Pattern Int -> Pattern Double -> ControlPattern #
button8recv :: Pattern Int -> ControlPattern #
button9 :: Pattern Double -> ControlPattern #
button9Take :: String -> [Double] -> ControlPattern #
button9Count :: String -> ControlPattern #
button9bus :: Pattern Int -> Pattern Double -> ControlPattern #
button9recv :: Pattern Int -> ControlPattern #
ccn :: Pattern Double -> ControlPattern #
ccnTake :: String -> [Double] -> ControlPattern #
ccnCount :: String -> ControlPattern #
ccv :: Pattern Double -> ControlPattern #
ccvTake :: String -> [Double] -> ControlPattern #
ccvCount :: String -> ControlPattern #
channel :: Pattern Int -> ControlPattern #
choose the channel the pattern is sent to in superdirt
channelTake :: String -> [Double] -> ControlPattern #
channelCount :: String -> ControlPattern #
channelbus :: Pattern Int -> Pattern Int -> ControlPattern #
clhatdecay :: Pattern Double -> ControlPattern #
clhatdecayTake :: String -> [Double] -> ControlPattern #
clhatdecayCount :: String -> ControlPattern #
clhatdecaybus :: Pattern Int -> Pattern Double -> ControlPattern #
clhatdecayrecv :: Pattern Int -> ControlPattern #
coarse :: Pattern Double -> ControlPattern #
fake-resampling, a pattern of numbers for lowering the sample rate, i.e. 1 for original 2 for half, 3 for a third and so on.
coarseTake :: String -> [Double] -> ControlPattern #
coarseCount :: String -> ControlPattern #
coarserecv :: Pattern Int -> ControlPattern #
comb :: Pattern Double -> ControlPattern #
Spectral comb
combTake :: String -> [Double] -> ControlPattern #
combCount :: String -> ControlPattern #
combrecv :: Pattern Int -> ControlPattern #
control :: Pattern Double -> ControlPattern #
controlTake :: String -> [Double] -> ControlPattern #
controlCount :: String -> ControlPattern #
controlbus :: Pattern Int -> Pattern Double -> ControlPattern #
cps :: Pattern Double -> ControlPattern #
A control pattern; setcps
is the standalone function.
Patterns don’t (yet) have independent tempos though, if you change it on one pattern, it changes on all of them.
p "cpsfun" $ s "bd sd(3,8)" # cps (slow 8 $ 0.5 + saw)
cpsTake :: String -> [Double] -> ControlPattern #
cpsCount :: String -> ControlPattern #
cpsrecv :: Pattern Int -> ControlPattern #
crush :: Pattern Double -> ControlPattern #
bit crushing, a pattern of numbers from 1 (for drastic reduction in bit-depth) to 16 (for barely no reduction).
crushTake :: String -> [Double] -> ControlPattern #
crushCount :: String -> ControlPattern #
crushrecv :: Pattern Int -> ControlPattern #
ctlNum :: Pattern Double -> ControlPattern #
ctlNumTake :: String -> [Double] -> ControlPattern #
ctlNumCount :: String -> ControlPattern #
ctranspose :: Pattern Double -> ControlPattern #
ctransposeTake :: String -> [Double] -> ControlPattern #
ctransposeCount :: String -> ControlPattern #
ctransposebus :: Pattern Int -> Pattern Double -> ControlPattern #
ctransposerecv :: Pattern Int -> ControlPattern #
cut :: Pattern Int -> ControlPattern #
In the style of classic drum-machines, cut
will stop a playing sample as soon as another samples with in same cutgroup is to be played. An example would be an open hi-hat followed by a closed one, essentially muting the open.
cutTake :: String -> [Double] -> ControlPattern #
cutCount :: String -> ControlPattern #
cutrecv :: Pattern Int -> ControlPattern #
cutoff :: Pattern Double -> ControlPattern #
a pattern of numbers in Hz. Applies the cutoff frequency of the low-pass filter.
cutoffTake :: String -> [Double] -> ControlPattern #
cutoffCount :: String -> ControlPattern #
cutoffrecv :: Pattern Int -> ControlPattern #
cutoffegint :: Pattern Double -> ControlPattern #
cutoffegintTake :: String -> [Double] -> ControlPattern #
cutoffegintbus :: Pattern Int -> Pattern Double -> ControlPattern #
cutoffegintrecv :: Pattern Int -> ControlPattern #
decay :: Pattern Double -> ControlPattern #
decayTake :: String -> [Double] -> ControlPattern #
decayCount :: String -> ControlPattern #
decayrecv :: Pattern Int -> ControlPattern #
degree :: Pattern Double -> ControlPattern #
degreeTake :: String -> [Double] -> ControlPattern #
degreeCount :: String -> ControlPattern #
degreerecv :: Pattern Int -> ControlPattern #
delay :: Pattern Double -> ControlPattern #
a pattern of numbers from 0 to 1. Sets the level of the delay signal.
delayTake :: String -> [Double] -> ControlPattern #
delayCount :: String -> ControlPattern #
delayrecv :: Pattern Int -> ControlPattern #
delayfeedback :: Pattern Double -> ControlPattern #
a pattern of numbers from 0 to 1. Sets the amount of delay feedback.
delayfeedbackTake :: String -> [Double] -> ControlPattern #
delayfeedbackbus :: Pattern Int -> Pattern Double -> ControlPattern #
delaytime :: Pattern Double -> ControlPattern #
a pattern of numbers from 0 to 1. Sets the length of the delay.
delaytimeTake :: String -> [Double] -> ControlPattern #
delaytimeCount :: String -> ControlPattern #
delaytimebus :: Pattern Int -> Pattern Double -> ControlPattern #
delaytimerecv :: Pattern Int -> ControlPattern #
detune :: Pattern Double -> ControlPattern #
detuneTake :: String -> [Double] -> ControlPattern #
detuneCount :: String -> ControlPattern #
detunerecv :: Pattern Int -> ControlPattern #
distort :: Pattern Double -> ControlPattern #
noisy fuzzy distortion
distortTake :: String -> [Double] -> ControlPattern #
distortCount :: String -> ControlPattern #
distortbus :: Pattern Int -> Pattern Double -> ControlPattern #
distortrecv :: Pattern Int -> ControlPattern #
djf :: Pattern Double -> ControlPattern #
DJ filter, below 0.5 is low pass filter, above is high pass filter.
djfTake :: String -> [Double] -> ControlPattern #
djfCount :: String -> ControlPattern #
djfrecv :: Pattern Int -> ControlPattern #
dry :: Pattern Double -> ControlPattern #
dryTake :: String -> [Double] -> ControlPattern #
dryCount :: String -> ControlPattern #
dryrecv :: Pattern Int -> ControlPattern #
dur :: Pattern Double -> ControlPattern #
durTake :: String -> [Double] -> ControlPattern #
durCount :: String -> ControlPattern #
durrecv :: Pattern Int -> ControlPattern #
end :: Pattern Double -> ControlPattern #
Similar to begin
, but cuts the end off samples, shortening them; e.g.
0.75 to cut off the last quarter of each sample.
d1 $ s "bev" >| begin 0.5 >| end "[0.65 0.55]"
The example above will play the sample two times for cycle, but the second time will play a shorter segment than the first time, creating a kind of canon effect.
endTake :: String -> [Double] -> ControlPattern #
endCount :: String -> ControlPattern #
enhance :: Pattern Double -> ControlPattern #
Spectral enhance
enhanceTake :: String -> [Double] -> ControlPattern #
enhanceCount :: String -> ControlPattern #
enhancebus :: Pattern Int -> Pattern Double -> ControlPattern #
enhancerecv :: Pattern Int -> ControlPattern #
expression :: Pattern Double -> ControlPattern #
expressionTake :: String -> [Double] -> ControlPattern #
expressionCount :: String -> ControlPattern #
expressionbus :: Pattern Int -> Pattern Double -> ControlPattern #
expressionrecv :: Pattern Int -> ControlPattern #
fadeInTime :: Pattern Double -> ControlPattern #
As with fadeTime, but controls the fade in time of the grain envelope. Not used if the grain begins at position 0 in the sample.
fadeInTimeTake :: String -> [Double] -> ControlPattern #
fadeInTimeCount :: String -> ControlPattern #
fadeInTimebus :: Pattern Int -> Pattern Double -> ControlPattern #
fadeTime :: Pattern Double -> ControlPattern #
Used when using beginend or chopstriate and friends, to change the fade out time of the grain
envelope.
fadeTimeTake :: String -> [Double] -> ControlPattern #
fadeTimeCount :: String -> ControlPattern #
fadeTimebus :: Pattern Int -> Pattern Double -> ControlPattern #
frameRate :: Pattern Double -> ControlPattern #
frameRateTake :: String -> [Double] -> ControlPattern #
frameRateCount :: String -> ControlPattern #
frameRatebus :: Pattern Int -> Pattern Double -> ControlPattern #
frames :: Pattern Double -> ControlPattern #
framesTake :: String -> [Double] -> ControlPattern #
framesCount :: String -> ControlPattern #
freezeTake :: String -> [Double] -> ControlPattern #
freezeCount :: String -> ControlPattern #
freezerecv :: Pattern Int -> ControlPattern #
freq :: Pattern Double -> ControlPattern #
freqTake :: String -> [Double] -> ControlPattern #
freqCount :: String -> ControlPattern #
freqrecv :: Pattern Int -> ControlPattern #
fromTake :: String -> [Double] -> ControlPattern #
fromCount :: String -> ControlPattern #
fromrecv :: Pattern Int -> ControlPattern #
fshift :: Pattern Double -> ControlPattern #
frequency shifter
fshiftTake :: String -> [Double] -> ControlPattern #
fshiftCount :: String -> ControlPattern #
fshiftrecv :: Pattern Int -> ControlPattern #
fshiftnote :: Pattern Double -> ControlPattern #
frequency shifter
fshiftnoteTake :: String -> [Double] -> ControlPattern #
fshiftnoteCount :: String -> ControlPattern #
fshiftnotebus :: Pattern Int -> Pattern Double -> ControlPattern #
fshiftnoterecv :: Pattern Int -> ControlPattern #
fshiftphase :: Pattern Double -> ControlPattern #
frequency shifter
fshiftphaseTake :: String -> [Double] -> ControlPattern #
fshiftphasebus :: Pattern Int -> Pattern Double -> ControlPattern #
fshiftphaserecv :: Pattern Int -> ControlPattern #
gain :: Pattern Double -> ControlPattern #
Used to control the amplitude (volume) of the sound. Values less than 1 make the sound quieter and values greater than 1 make the sound louder.
gain
uses a power function, so the volume change around 1 is subtle, but it
gets more noticeable as it increases or decreases. Typical values for gain
are
between 0 and 1.5.
For the linear equivalent, see amp
.
d1 $ s "arpy" # gain 0.8
This plays the first arpy sample at a quieter level than the default.
d1 $ s "ab*16" # gain (range 0.8 1.3 $ sine)
This plays a hihat sound, 16 times per cycle, with a gain
moving from 0.8 to 1.3
following a sine wave.
gainTake :: String -> [Double] -> ControlPattern #
gainCount :: String -> ControlPattern #
gate :: Pattern Double -> ControlPattern #
gateTake :: String -> [Double] -> ControlPattern #
gateCount :: String -> ControlPattern #
gaterecv :: Pattern Int -> ControlPattern #
harmonic :: Pattern Double -> ControlPattern #
harmonicTake :: String -> [Double] -> ControlPattern #
harmonicCount :: String -> ControlPattern #
harmonicbus :: Pattern Int -> Pattern Double -> ControlPattern #
harmonicrecv :: Pattern Int -> ControlPattern #
hatgrain :: Pattern Double -> ControlPattern #
hatgrainTake :: String -> [Double] -> ControlPattern #
hatgrainCount :: String -> ControlPattern #
hatgrainbus :: Pattern Int -> Pattern Double -> ControlPattern #
hatgrainrecv :: Pattern Int -> ControlPattern #
hbrick :: Pattern Double -> ControlPattern #
High pass sort of spectral filter
hbrickTake :: String -> [Double] -> ControlPattern #
hbrickCount :: String -> ControlPattern #
hbrickrecv :: Pattern Int -> ControlPattern #
hcutoff :: Pattern Double -> ControlPattern #
a pattern of numbers from 0 to 1. Applies the cutoff frequency of the high-pass filter. Also has alias hpf
hcutoffTake :: String -> [Double] -> ControlPattern #
hcutoffCount :: String -> ControlPattern #
hcutoffbus :: Pattern Int -> Pattern Double -> ControlPattern #
hcutoffrecv :: Pattern Int -> ControlPattern #
hold :: Pattern Double -> ControlPattern #
holdTake :: String -> [Double] -> ControlPattern #
holdCount :: String -> ControlPattern #
holdrecv :: Pattern Int -> ControlPattern #
hours :: Pattern Double -> ControlPattern #
hoursTake :: String -> [Double] -> ControlPattern #
hoursCount :: String -> ControlPattern #
hresonance :: Pattern Double -> ControlPattern #
a pattern of numbers from 0 to 1. Applies the resonance of the high-pass filter. Has alias hpq
hresonanceTake :: String -> [Double] -> ControlPattern #
hresonanceCount :: String -> ControlPattern #
hresonancebus :: Pattern Int -> Pattern Double -> ControlPattern #
hresonancerecv :: Pattern Int -> ControlPattern #
imag :: Pattern Double -> ControlPattern #
imagTake :: String -> [Double] -> ControlPattern #
imagCount :: String -> ControlPattern #
imagrecv :: Pattern Int -> ControlPattern #
kcutoff :: Pattern Double -> ControlPattern #
kcutoffTake :: String -> [Double] -> ControlPattern #
kcutoffCount :: String -> ControlPattern #
kcutoffbus :: Pattern Int -> Pattern Double -> ControlPattern #
kcutoffrecv :: Pattern Int -> ControlPattern #
krush :: Pattern Double -> ControlPattern #
shape/bass enhancer
krushTake :: String -> [Double] -> ControlPattern #
krushCount :: String -> ControlPattern #
krushrecv :: Pattern Int -> ControlPattern #
lagogo :: Pattern Double -> ControlPattern #
lagogoTake :: String -> [Double] -> ControlPattern #
lagogoCount :: String -> ControlPattern #
lagogorecv :: Pattern Int -> ControlPattern #
lbrick :: Pattern Double -> ControlPattern #
Low pass sort of spectral filter
lbrickTake :: String -> [Double] -> ControlPattern #
lbrickCount :: String -> ControlPattern #
lbrickrecv :: Pattern Int -> ControlPattern #
lclap :: Pattern Double -> ControlPattern #
lclapTake :: String -> [Double] -> ControlPattern #
lclapCount :: String -> ControlPattern #
lclaprecv :: Pattern Int -> ControlPattern #
lclaves :: Pattern Double -> ControlPattern #
lclavesTake :: String -> [Double] -> ControlPattern #
lclavesCount :: String -> ControlPattern #
lclavesbus :: Pattern Int -> Pattern Double -> ControlPattern #
lclavesrecv :: Pattern Int -> ControlPattern #
lclhat :: Pattern Double -> ControlPattern #
lclhatTake :: String -> [Double] -> ControlPattern #
lclhatCount :: String -> ControlPattern #
lclhatrecv :: Pattern Int -> ControlPattern #
lcrash :: Pattern Double -> ControlPattern #
lcrashTake :: String -> [Double] -> ControlPattern #
lcrashCount :: String -> ControlPattern #
lcrashrecv :: Pattern Int -> ControlPattern #
legato :: Pattern Double -> ControlPattern #
controls the amount of overlap between two adjacent sounds
legatoTake :: String -> [Double] -> ControlPattern #
legatoCount :: String -> ControlPattern #
clip :: Pattern Double -> ControlPattern #
leslie :: Pattern Double -> ControlPattern #
leslieTake :: String -> [Double] -> ControlPattern #
leslieCount :: String -> ControlPattern #
leslierecv :: Pattern Int -> ControlPattern #
lfo :: Pattern Double -> ControlPattern #
lfoTake :: String -> [Double] -> ControlPattern #
lfoCount :: String -> ControlPattern #
lforecv :: Pattern Int -> ControlPattern #
lfocutoffint :: Pattern Double -> ControlPattern #
lfocutoffintTake :: String -> [Double] -> ControlPattern #
lfocutoffintbus :: Pattern Int -> Pattern Double -> ControlPattern #
lfodelay :: Pattern Double -> ControlPattern #
lfodelayTake :: String -> [Double] -> ControlPattern #
lfodelayCount :: String -> ControlPattern #
lfodelaybus :: Pattern Int -> Pattern Double -> ControlPattern #
lfodelayrecv :: Pattern Int -> ControlPattern #
lfoint :: Pattern Double -> ControlPattern #
lfointTake :: String -> [Double] -> ControlPattern #
lfointCount :: String -> ControlPattern #
lfointrecv :: Pattern Int -> ControlPattern #
lfopitchint :: Pattern Double -> ControlPattern #
lfopitchintTake :: String -> [Double] -> ControlPattern #
lfopitchintbus :: Pattern Int -> Pattern Double -> ControlPattern #
lfopitchintrecv :: Pattern Int -> ControlPattern #
lfoshape :: Pattern Double -> ControlPattern #
lfoshapeTake :: String -> [Double] -> ControlPattern #
lfoshapeCount :: String -> ControlPattern #
lfoshapebus :: Pattern Int -> Pattern Double -> ControlPattern #
lfoshaperecv :: Pattern Int -> ControlPattern #
lfosync :: Pattern Double -> ControlPattern #
lfosyncTake :: String -> [Double] -> ControlPattern #
lfosyncCount :: String -> ControlPattern #
lfosyncbus :: Pattern Int -> Pattern Double -> ControlPattern #
lfosyncrecv :: Pattern Int -> ControlPattern #
lhitom :: Pattern Double -> ControlPattern #
lhitomTake :: String -> [Double] -> ControlPattern #
lhitomCount :: String -> ControlPattern #
lhitomrecv :: Pattern Int -> ControlPattern #
lkick :: Pattern Double -> ControlPattern #
lkickTake :: String -> [Double] -> ControlPattern #
lkickCount :: String -> ControlPattern #
lkickrecv :: Pattern Int -> ControlPattern #
llotom :: Pattern Double -> ControlPattern #
llotomTake :: String -> [Double] -> ControlPattern #
llotomCount :: String -> ControlPattern #
llotomrecv :: Pattern Int -> ControlPattern #
lock :: Pattern Double -> ControlPattern #
A pattern of numbers. Specifies whether delaytime is calculated relative to cps. When set to 1, delaytime is a direct multiple of a cycle.
lockTake :: String -> [Double] -> ControlPattern #
lockCount :: String -> ControlPattern #
lockrecv :: Pattern Int -> ControlPattern #
loopTake :: String -> [Double] -> ControlPattern #
loopCount :: String -> ControlPattern #
lophat :: Pattern Double -> ControlPattern #
lophatTake :: String -> [Double] -> ControlPattern #
lophatCount :: String -> ControlPattern #
lophatrecv :: Pattern Int -> ControlPattern #
lrate :: Pattern Double -> ControlPattern #
lrateTake :: String -> [Double] -> ControlPattern #
lrateCount :: String -> ControlPattern #
lraterecv :: Pattern Int -> ControlPattern #
lsize :: Pattern Double -> ControlPattern #
lsizeTake :: String -> [Double] -> ControlPattern #
lsizeCount :: String -> ControlPattern #
lsizerecv :: Pattern Int -> ControlPattern #
lsnare :: Pattern Double -> ControlPattern #
lsnareTake :: String -> [Double] -> ControlPattern #
lsnareCount :: String -> ControlPattern #
lsnarerecv :: Pattern Int -> ControlPattern #
metatune :: Pattern Double -> ControlPattern #
A pattern of numbers. Specifies whether the pitch of played samples should be tuned relative to their pitch metadata, if it exists. When set to 1, pitch metadata is applied. When set to 0, pitch metadata is ignored.
metatuneTake :: String -> [Double] -> ControlPattern #
metatuneCount :: String -> ControlPattern #
metatunebus :: Pattern Int -> Pattern Double -> ControlPattern #
metatunerecv :: Pattern Int -> ControlPattern #
midibend :: Pattern Double -> ControlPattern #
midibendTake :: String -> [Double] -> ControlPattern #
midibendCount :: String -> ControlPattern #
midibendbus :: Pattern Int -> Pattern Double -> ControlPattern #
midichan :: Pattern Double -> ControlPattern #
midichanTake :: String -> [Double] -> ControlPattern #
midichanCount :: String -> ControlPattern #
midichanbus :: Pattern Int -> Pattern Double -> ControlPattern #
midicmd :: Pattern String -> ControlPattern #
midicmdTake :: String -> [Double] -> ControlPattern #
midicmdbus :: Pattern Int -> Pattern String -> ControlPattern #
miditouch :: Pattern Double -> ControlPattern #
miditouchTake :: String -> [Double] -> ControlPattern #
miditouchCount :: String -> ControlPattern #
miditouchbus :: Pattern Int -> Pattern Double -> ControlPattern #
minutes :: Pattern Double -> ControlPattern #
minutesTake :: String -> [Double] -> ControlPattern #
minutesCount :: String -> ControlPattern #
minutesbus :: Pattern Int -> Pattern Double -> ControlPattern #
modwheel :: Pattern Double -> ControlPattern #
modwheelTake :: String -> [Double] -> ControlPattern #
modwheelCount :: String -> ControlPattern #
modwheelbus :: Pattern Int -> Pattern Double -> ControlPattern #
modwheelrecv :: Pattern Int -> ControlPattern #
mtranspose :: Pattern Double -> ControlPattern #
mtransposeTake :: String -> [Double] -> ControlPattern #
mtransposeCount :: String -> ControlPattern #
mtransposebus :: Pattern Int -> Pattern Double -> ControlPattern #
mtransposerecv :: Pattern Int -> ControlPattern #
n :: Pattern Note -> ControlPattern #
The note or sample number to choose for a synth or sampleset
nTake :: String -> [Double] -> ControlPattern #
nCount :: String -> ControlPattern #
note :: Pattern Note -> ControlPattern #
The note or pitch to play a sound or synth with
noteTake :: String -> [Double] -> ControlPattern #
noteCount :: String -> ControlPattern #
nudge :: Pattern Double -> ControlPattern #
Nudges events into the future by the specified number of seconds. Negative numbers work up to a point as well (due to internal latency)
nudgeTake :: String -> [Double] -> ControlPattern #
nudgeCount :: String -> ControlPattern #
nudgerecv :: Pattern Int -> ControlPattern #
octave :: Pattern Int -> ControlPattern #
octaveTake :: String -> [Double] -> ControlPattern #
octaveCount :: String -> ControlPattern #
octaveR :: Pattern Double -> ControlPattern #
octaveRTake :: String -> [Double] -> ControlPattern #
octaveRCount :: String -> ControlPattern #
octaveRbus :: Pattern Int -> Pattern Double -> ControlPattern #
octaveRrecv :: Pattern Int -> ControlPattern #
octer :: Pattern Double -> ControlPattern #
octaver effect
octerTake :: String -> [Double] -> ControlPattern #
octerCount :: String -> ControlPattern #
octerrecv :: Pattern Int -> ControlPattern #
octersub :: Pattern Double -> ControlPattern #
octaver effect
octersubTake :: String -> [Double] -> ControlPattern #
octersubCount :: String -> ControlPattern #
octersubbus :: Pattern Int -> Pattern Double -> ControlPattern #
octersubrecv :: Pattern Int -> ControlPattern #
octersubsub :: Pattern Double -> ControlPattern #
octaver effect
octersubsubTake :: String -> [Double] -> ControlPattern #
octersubsubbus :: Pattern Int -> Pattern Double -> ControlPattern #
octersubsubrecv :: Pattern Int -> ControlPattern #
offset :: Pattern Double -> ControlPattern #
offsetTake :: String -> [Double] -> ControlPattern #
offsetCount :: String -> ControlPattern #
ophatdecay :: Pattern Double -> ControlPattern #
ophatdecayTake :: String -> [Double] -> ControlPattern #
ophatdecayCount :: String -> ControlPattern #
ophatdecaybus :: Pattern Int -> Pattern Double -> ControlPattern #
ophatdecayrecv :: Pattern Int -> ControlPattern #
orbit :: Pattern Int -> ControlPattern #
a pattern of numbers. An "orbit" is a global parameter context for patterns. Patterns with the same orbit will share hardware output bus offset and global effects, e.g. reverb and delay. The maximum number of orbits is specified in the superdirt startup, numbers higher than maximum will wrap around.
orbitTake :: String -> [Double] -> ControlPattern #
orbitCount :: String -> ControlPattern #
orbitrecv :: Pattern Int -> ControlPattern #
overgain :: Pattern Double -> ControlPattern #
overgainTake :: String -> [Double] -> ControlPattern #
overgainCount :: String -> ControlPattern #
overgainbus :: Pattern Int -> Pattern Double -> ControlPattern #
overshape :: Pattern Double -> ControlPattern #
overshapeTake :: String -> [Double] -> ControlPattern #
overshapeCount :: String -> ControlPattern #
overshapebus :: Pattern Int -> Pattern Double -> ControlPattern #
overshaperecv :: Pattern Int -> ControlPattern #
pan :: Pattern Double -> ControlPattern #
a pattern of numbers between 0 and 1, from left to right (assuming stereo), once round a circle (assuming multichannel)
panTake :: String -> [Double] -> ControlPattern #
panCount :: String -> ControlPattern #
panrecv :: Pattern Int -> ControlPattern #
panorient :: Pattern Double -> ControlPattern #
a pattern of numbers between -1.0 and 1.0, which controls the relative position of the centre pan in a pair of adjacent speakers (multichannel only)
panorientTake :: String -> [Double] -> ControlPattern #
panorientCount :: String -> ControlPattern #
panorientbus :: Pattern Int -> Pattern Double -> ControlPattern #
panorientrecv :: Pattern Int -> ControlPattern #
panspan :: Pattern Double -> ControlPattern #
a pattern of numbers between -inf and inf, which controls how much multichannel output is fanned out (negative is backwards ordering)
panspanTake :: String -> [Double] -> ControlPattern #
panspanCount :: String -> ControlPattern #
panspanbus :: Pattern Int -> Pattern Double -> ControlPattern #
panspanrecv :: Pattern Int -> ControlPattern #
pansplay :: Pattern Double -> ControlPattern #
a pattern of numbers between 0.0 and 1.0, which controls the multichannel spread range (multichannel only)
pansplayTake :: String -> [Double] -> ControlPattern #
pansplayCount :: String -> ControlPattern #
pansplaybus :: Pattern Int -> Pattern Double -> ControlPattern #
pansplayrecv :: Pattern Int -> ControlPattern #
panwidth :: Pattern Double -> ControlPattern #
a pattern of numbers between 0.0 and inf, which controls how much each channel is distributed over neighbours (multichannel only)
panwidthTake :: String -> [Double] -> ControlPattern #
panwidthCount :: String -> ControlPattern #
panwidthbus :: Pattern Int -> Pattern Double -> ControlPattern #
panwidthrecv :: Pattern Int -> ControlPattern #
partials :: Pattern Double -> ControlPattern #
partialsTake :: String -> [Double] -> ControlPattern #
partialsCount :: String -> ControlPattern #
partialsbus :: Pattern Int -> Pattern Double -> ControlPattern #
partialsrecv :: Pattern Int -> ControlPattern #
phaserdepth :: Pattern Double -> ControlPattern #
Phaser Audio DSP effect | params are phaserrate
and phaserdepth
phaserdepthTake :: String -> [Double] -> ControlPattern #
phaserdepthbus :: Pattern Int -> Pattern Double -> ControlPattern #
phaserdepthrecv :: Pattern Int -> ControlPattern #
phaserrate :: Pattern Double -> ControlPattern #
Phaser Audio DSP effect | params are phaserrate
and phaserdepth
phaserrateTake :: String -> [Double] -> ControlPattern #
phaserrateCount :: String -> ControlPattern #
phaserratebus :: Pattern Int -> Pattern Double -> ControlPattern #
phaserraterecv :: Pattern Int -> ControlPattern #
pitch1 :: Pattern Double -> ControlPattern #
pitch1Take :: String -> [Double] -> ControlPattern #
pitch1Count :: String -> ControlPattern #
pitch1recv :: Pattern Int -> ControlPattern #
pitch2 :: Pattern Double -> ControlPattern #
pitch2Take :: String -> [Double] -> ControlPattern #
pitch2Count :: String -> ControlPattern #
pitch2recv :: Pattern Int -> ControlPattern #
pitch3 :: Pattern Double -> ControlPattern #
pitch3Take :: String -> [Double] -> ControlPattern #
pitch3Count :: String -> ControlPattern #
pitch3recv :: Pattern Int -> ControlPattern #
polyTouch :: Pattern Double -> ControlPattern #
polyTouchTake :: String -> [Double] -> ControlPattern #
polyTouchCount :: String -> ControlPattern #
polyTouchbus :: Pattern Int -> Pattern Double -> ControlPattern #
portamento :: Pattern Double -> ControlPattern #
portamentoTake :: String -> [Double] -> ControlPattern #
portamentoCount :: String -> ControlPattern #
portamentobus :: Pattern Int -> Pattern Double -> ControlPattern #
portamentorecv :: Pattern Int -> ControlPattern #
progNum :: Pattern Double -> ControlPattern #
progNumTake :: String -> [Double] -> ControlPattern #
progNumCount :: String -> ControlPattern #
progNumbus :: Pattern Int -> Pattern Double -> ControlPattern #
rate :: Pattern Double -> ControlPattern #
used in SuperDirt softsynths as a control rate or "speed"
rateTake :: String -> [Double] -> ControlPattern #
rateCount :: String -> ControlPattern #
raterecv :: Pattern Int -> ControlPattern #
real :: Pattern Double -> ControlPattern #
Spectral conform
realTake :: String -> [Double] -> ControlPattern #
realCount :: String -> ControlPattern #
realrecv :: Pattern Int -> ControlPattern #
releaseTake :: String -> [Double] -> ControlPattern #
releaseCount :: String -> ControlPattern #
releasebus :: Pattern Int -> Pattern Double -> ControlPattern #
releaserecv :: Pattern Int -> ControlPattern #
resonance :: Pattern Double -> ControlPattern #
a pattern of numbers from 0 to 1. Specifies the resonance of the low-pass filter.
resonanceTake :: String -> [Double] -> ControlPattern #
resonanceCount :: String -> ControlPattern #
resonancebus :: Pattern Int -> Pattern Double -> ControlPattern #
resonancerecv :: Pattern Int -> ControlPattern #
ring :: Pattern Double -> ControlPattern #
ring modulation
ringTake :: String -> [Double] -> ControlPattern #
ringCount :: String -> ControlPattern #
ringrecv :: Pattern Int -> ControlPattern #
ringdf :: Pattern Double -> ControlPattern #
ring modulation
ringdfTake :: String -> [Double] -> ControlPattern #
ringdfCount :: String -> ControlPattern #
ringdfrecv :: Pattern Int -> ControlPattern #
ringf :: Pattern Double -> ControlPattern #
ring modulation
ringfTake :: String -> [Double] -> ControlPattern #
ringfCount :: String -> ControlPattern #
ringfrecv :: Pattern Int -> ControlPattern #
room :: Pattern Double -> ControlPattern #
a pattern of numbers from 0 to 1. Sets the level of reverb.
roomTake :: String -> [Double] -> ControlPattern #
roomCount :: String -> ControlPattern #
roomrecv :: Pattern Int -> ControlPattern #
sagogo :: Pattern Double -> ControlPattern #
sagogoTake :: String -> [Double] -> ControlPattern #
sagogoCount :: String -> ControlPattern #
sagogorecv :: Pattern Int -> ControlPattern #
sclap :: Pattern Double -> ControlPattern #
sclapTake :: String -> [Double] -> ControlPattern #
sclapCount :: String -> ControlPattern #
sclaprecv :: Pattern Int -> ControlPattern #
sclaves :: Pattern Double -> ControlPattern #
sclavesTake :: String -> [Double] -> ControlPattern #
sclavesCount :: String -> ControlPattern #
sclavesbus :: Pattern Int -> Pattern Double -> ControlPattern #
sclavesrecv :: Pattern Int -> ControlPattern #
scram :: Pattern Double -> ControlPattern #
Spectral scramble
scramTake :: String -> [Double] -> ControlPattern #
scramCount :: String -> ControlPattern #
scramrecv :: Pattern Int -> ControlPattern #
scrash :: Pattern Double -> ControlPattern #
scrashTake :: String -> [Double] -> ControlPattern #
scrashCount :: String -> ControlPattern #
scrashrecv :: Pattern Int -> ControlPattern #
seconds :: Pattern Double -> ControlPattern #
secondsTake :: String -> [Double] -> ControlPattern #
secondsCount :: String -> ControlPattern #
secondsbus :: Pattern Int -> Pattern Double -> ControlPattern #
semitone :: Pattern Double -> ControlPattern #
semitoneTake :: String -> [Double] -> ControlPattern #
semitoneCount :: String -> ControlPattern #
semitonebus :: Pattern Int -> Pattern Double -> ControlPattern #
semitonerecv :: Pattern Int -> ControlPattern #
shape :: Pattern Double -> ControlPattern #
wave shaping distortion, a pattern of numbers from 0 for no distortion up to 1 for loads of distortion.
shapeTake :: String -> [Double] -> ControlPattern #
shapeCount :: String -> ControlPattern #
shaperecv :: Pattern Int -> ControlPattern #
sizeTake :: String -> [Double] -> ControlPattern #
sizeCount :: String -> ControlPattern #
sizerecv :: Pattern Int -> ControlPattern #
slide :: Pattern Double -> ControlPattern #
slideTake :: String -> [Double] -> ControlPattern #
slideCount :: String -> ControlPattern #
sliderecv :: Pattern Int -> ControlPattern #
slider0 :: Pattern Double -> ControlPattern #
slider0Take :: String -> [Double] -> ControlPattern #
slider0Count :: String -> ControlPattern #
slider0bus :: Pattern Int -> Pattern Double -> ControlPattern #
slider0recv :: Pattern Int -> ControlPattern #
slider1 :: Pattern Double -> ControlPattern #
slider1Take :: String -> [Double] -> ControlPattern #
slider1Count :: String -> ControlPattern #
slider1bus :: Pattern Int -> Pattern Double -> ControlPattern #
slider1recv :: Pattern Int -> ControlPattern #
slider10 :: Pattern Double -> ControlPattern #
slider10Take :: String -> [Double] -> ControlPattern #
slider10Count :: String -> ControlPattern #
slider10bus :: Pattern Int -> Pattern Double -> ControlPattern #
slider10recv :: Pattern Int -> ControlPattern #
slider11 :: Pattern Double -> ControlPattern #
slider11Take :: String -> [Double] -> ControlPattern #
slider11Count :: String -> ControlPattern #
slider11bus :: Pattern Int -> Pattern Double -> ControlPattern #
slider11recv :: Pattern Int -> ControlPattern #
slider12 :: Pattern Double -> ControlPattern #
slider12Take :: String -> [Double] -> ControlPattern #
slider12Count :: String -> ControlPattern #
slider12bus :: Pattern Int -> Pattern Double -> ControlPattern #
slider12recv :: Pattern Int -> ControlPattern #
slider13 :: Pattern Double -> ControlPattern #
slider13Take :: String -> [Double] -> ControlPattern #
slider13Count :: String -> ControlPattern #
slider13bus :: Pattern Int -> Pattern Double -> ControlPattern #
slider13recv :: Pattern Int -> ControlPattern #
slider14 :: Pattern Double -> ControlPattern #
slider14Take :: String -> [Double] -> ControlPattern #
slider14Count :: String -> ControlPattern #
slider14bus :: Pattern Int -> Pattern Double -> ControlPattern #
slider14recv :: Pattern Int -> ControlPattern #
slider15 :: Pattern Double -> ControlPattern #
slider15Take :: String -> [Double] -> ControlPattern #
slider15Count :: String -> ControlPattern #
slider15bus :: Pattern Int -> Pattern Double -> ControlPattern #
slider15recv :: Pattern Int -> ControlPattern #
slider2 :: Pattern Double -> ControlPattern #
slider2Take :: String -> [Double] -> ControlPattern #
slider2Count :: String -> ControlPattern #
slider2bus :: Pattern Int -> Pattern Double -> ControlPattern #
slider2recv :: Pattern Int -> ControlPattern #
slider3 :: Pattern Double -> ControlPattern #
slider3Take :: String -> [Double] -> ControlPattern #
slider3Count :: String -> ControlPattern #
slider3bus :: Pattern Int -> Pattern Double -> ControlPattern #
slider3recv :: Pattern Int -> ControlPattern #
slider4 :: Pattern Double -> ControlPattern #
slider4Take :: String -> [Double] -> ControlPattern #
slider4Count :: String -> ControlPattern #
slider4bus :: Pattern Int -> Pattern Double -> ControlPattern #
slider4recv :: Pattern Int -> ControlPattern #
slider5 :: Pattern Double -> ControlPattern #
slider5Take :: String -> [Double] -> ControlPattern #
slider5Count :: String -> ControlPattern #
slider5bus :: Pattern Int -> Pattern Double -> ControlPattern #
slider5recv :: Pattern Int -> ControlPattern #
slider6 :: Pattern Double -> ControlPattern #
slider6Take :: String -> [Double] -> ControlPattern #
slider6Count :: String -> ControlPattern #
slider6bus :: Pattern Int -> Pattern Double -> ControlPattern #
slider6recv :: Pattern Int -> ControlPattern #
slider7 :: Pattern Double -> ControlPattern #
slider7Take :: String -> [Double] -> ControlPattern #
slider7Count :: String -> ControlPattern #
slider7bus :: Pattern Int -> Pattern Double -> ControlPattern #
slider7recv :: Pattern Int -> ControlPattern #
slider8 :: Pattern Double -> ControlPattern #
slider8Take :: String -> [Double] -> ControlPattern #
slider8Count :: String -> ControlPattern #
slider8bus :: Pattern Int -> Pattern Double -> ControlPattern #
slider8recv :: Pattern Int -> ControlPattern #
slider9 :: Pattern Double -> ControlPattern #
slider9Take :: String -> [Double] -> ControlPattern #
slider9Count :: String -> ControlPattern #
slider9bus :: Pattern Int -> Pattern Double -> ControlPattern #
slider9recv :: Pattern Int -> ControlPattern #
smear :: Pattern Double -> ControlPattern #
Spectral smear
smearTake :: String -> [Double] -> ControlPattern #
smearCount :: String -> ControlPattern #
smearrecv :: Pattern Int -> ControlPattern #
songPtr :: Pattern Double -> ControlPattern #
songPtrTake :: String -> [Double] -> ControlPattern #
songPtrCount :: String -> ControlPattern #
songPtrbus :: Pattern Int -> Pattern Double -> ControlPattern #
speed :: Pattern Double -> ControlPattern #
A pattern of numbers which changes the speed of sample playback which also changes pitch. Negative values will play the sample backwards.
d1 $ slow 5 $ s "sax:5" # legato 1 # speed 0.5
This will play the sax:5
sample at half its rate. As a result, the sample will
last twice the normal time, and will be pitched a whole octave lower. This is
equivalent to d1 $ slow 5 $ s "sax:5" # legato 1 |- note 12
.
d1 $ fast 2 $ s "breaks125:1" # cps (125/60/4) # speed (-2)
In the above example, the break (which lasts for exactly one bar at 125 BPM), will be played backwards, and at double speed (so, we use fast 2
to fill the whole cycle).
speedTake :: String -> [Double] -> ControlPattern #
speedCount :: String -> ControlPattern #
squiz :: Pattern Double -> ControlPattern #
squizTake :: String -> [Double] -> ControlPattern #
squizCount :: String -> ControlPattern #
squizrecv :: Pattern Int -> ControlPattern #
stepsPerOctaveTake :: String -> [Double] -> ControlPattern #
stepsPerOctavebus :: Pattern Int -> Pattern Double -> ControlPattern #
stutterdepth :: Pattern Double -> ControlPattern #
stutterdepthTake :: String -> [Double] -> ControlPattern #
stutterdepthbus :: Pattern Int -> Pattern Double -> ControlPattern #
stuttertime :: Pattern Double -> ControlPattern #
stuttertimeTake :: String -> [Double] -> ControlPattern #
stuttertimebus :: Pattern Int -> Pattern Double -> ControlPattern #
stuttertimerecv :: Pattern Int -> ControlPattern #
sustain :: Pattern Double -> ControlPattern #
A pattern of numbers that indicates the total duration of sample playback in seconds.
This sustain
refers to the whole playback duration and is not to be confused with the sustain level of a typical ADSR envelope.
d1 $ fast 2 $ s "breaks125:1" # cps (120/60/4) # sustain 1
At 120 BPM, a cycle lasts for two seconds. In the above example, we cut the sample so it plays just for one second, and repeat this part two times, so we fill the whole cycle. Note that sample pitch isn’t modified.
d1 $ s "breaks125:2!3" # cps (120/60/4) # sustain "0.4 0.2 0.4" # begin "0 0 0.4"
Here, we take advantage that sustain receives a pattern to build a different break from the original sample.
sustainTake :: String -> [Double] -> ControlPattern #
sustainCount :: String -> ControlPattern #
sustainbus :: Pattern Int -> Pattern Double -> ControlPattern #
sustainpedal :: Pattern Double -> ControlPattern #
sustainpedalTake :: String -> [Double] -> ControlPattern #
sustainpedalbus :: Pattern Int -> Pattern Double -> ControlPattern #
timescale :: Pattern Double -> ControlPattern #
timescale
is the main function used to activate time-stretching, and usually
the only one you need. It receives a single parameter which is the stretching
rate to apply.
You can use any positive number as the ratio, but the particular method used is designed for ratios greater than 1, and work reasonably well for values between 0.1 and 3.
d1 $ slow 2 $ s "breaks152" # legato 1 # timescale (152/130) # cps (130/60/4)
In the example above, we set tempo at 130 beats per minute. But we want to play
one of the breaks152
samples, which are, as indicated, at 152 BPM. So, the
ratio we want is 152 over 130. This will slow down the sample to fit in our 130
BPM tempo.
timescaleTake :: String -> [Double] -> ControlPattern #
timescaleCount :: String -> ControlPattern #
timescalebus :: Pattern Int -> Pattern Double -> ControlPattern #
timescalewin :: Pattern Double -> ControlPattern #
Time stretch window size.
The algorithm used to time-stretch a sample divides a sample in many little parts, modifies them, and puts them all together again. It uses one particular parameter, called windowSize
, which is the length of each sample part.
The windowSize
value is automatically calculated, but can be changed with timescalewin
. The windowSize
value is multiplied by the number provided.
timescalewin
can be used to improve the quality of time-stretching for some samples, or simply as an effect.
Consider the following two examples. In the first one, timescalewin 0.01
makes
the window size a lot smaller, and the extreme chopping of the sample causes
a rougher sound. In the second one, timescalewin 10
makes the chunks a lot
bigger. The method used overlaps the treated chunks when recomposing the sample,
and, with the bigger window size, this overlap is noticeable and causes a kind
of delay effect.
d1 $ slow 2 $ s "breaks152" # legato 1 # timescale (152/130) # timescalewin 0.01 # cps (130/60/4)
d1 $ slow 2 $ s "breaks152" # legato 1 # timescale (152/130) # timescalewin 10 # cps (130/60/4)
timescalewinTake :: String -> [Double] -> ControlPattern #
timescalewinbus :: Pattern Int -> Pattern Double -> ControlPattern #
toTake :: String -> [Double] -> ControlPattern #
toCount :: String -> ControlPattern #
torecv :: Pattern Int -> ControlPattern #
toArg :: Pattern String -> ControlPattern #
for internal sound routing
toArgTake :: String -> [Double] -> ControlPattern #
toArgrecv :: Pattern Int -> ControlPattern #
tomdecay :: Pattern Double -> ControlPattern #
tomdecayTake :: String -> [Double] -> ControlPattern #
tomdecayCount :: String -> ControlPattern #
tomdecaybus :: Pattern Int -> Pattern Double -> ControlPattern #
tomdecayrecv :: Pattern Int -> ControlPattern #
tremolodepth :: Pattern Double -> ControlPattern #
Tremolo Audio DSP effect | params are tremolorate
and tremolodepth
tremolodepthTake :: String -> [Double] -> ControlPattern #
tremolodepthbus :: Pattern Int -> Pattern Double -> ControlPattern #
tremolorate :: Pattern Double -> ControlPattern #
Tremolo Audio DSP effect | params are tremolorate
and tremolodepth
tremolorateTake :: String -> [Double] -> ControlPattern #
tremoloratebus :: Pattern Int -> Pattern Double -> ControlPattern #
tremoloraterecv :: Pattern Int -> ControlPattern #
triode :: Pattern Double -> ControlPattern #
tube distortion
triodeTake :: String -> [Double] -> ControlPattern #
triodeCount :: String -> ControlPattern #
trioderecv :: Pattern Int -> ControlPattern #
tsdelay :: Pattern Double -> ControlPattern #
tsdelayTake :: String -> [Double] -> ControlPattern #
tsdelayCount :: String -> ControlPattern #
tsdelaybus :: Pattern Int -> Pattern Double -> ControlPattern #
tsdelayrecv :: Pattern Int -> ControlPattern #
uid :: Pattern Double -> ControlPattern #
uidTake :: String -> [Double] -> ControlPattern #
uidCount :: String -> ControlPattern #
unit :: Pattern String -> ControlPattern #
Used in conjunction with speed
. It accepts values of r
(rate, default
behavior), c
(cycles), or s
(seconds). Using unit "c"
means speed
will be interpreted in units of cycles, e.g. speed "1"
means samples will be
stretched to fill a cycle. Using unit "s"
means the playback speed will be
adjusted so that the duration is the number of seconds specified by speed
.
In the following example, speed 2
means that samples will be stretched to fill
half a cycle:
d1 $ stack [ s "sax:5" # legato 1 # speed 2 # unit "c", s "bd*2" ]
unitTake :: String -> [Double] -> ControlPattern #
val :: Pattern Double -> ControlPattern #
valTake :: String -> [Double] -> ControlPattern #
valCount :: String -> ControlPattern #
vcfegint :: Pattern Double -> ControlPattern #
vcfegintTake :: String -> [Double] -> ControlPattern #
vcfegintCount :: String -> ControlPattern #
vcfegintbus :: Pattern Int -> Pattern Double -> ControlPattern #
vcfegintrecv :: Pattern Int -> ControlPattern #
vcoegint :: Pattern Double -> ControlPattern #
vcoegintTake :: String -> [Double] -> ControlPattern #
vcoegintCount :: String -> ControlPattern #
vcoegintbus :: Pattern Int -> Pattern Double -> ControlPattern #
vcoegintrecv :: Pattern Int -> ControlPattern #
velocity :: Pattern Double -> ControlPattern #
velocityTake :: String -> [Double] -> ControlPattern #
velocityCount :: String -> ControlPattern #
velocitybus :: Pattern Int -> Pattern Double -> ControlPattern #
velocityrecv :: Pattern Int -> ControlPattern #
voice :: Pattern Double -> ControlPattern #
voiceTake :: String -> [Double] -> ControlPattern #
voiceCount :: String -> ControlPattern #
voicerecv :: Pattern Int -> ControlPattern #
vowel :: Pattern String -> ControlPattern #
formant filter to make things sound like vowels, a pattern of either a
, e
, i
, o
or u
. Use a rest (~
) for no effect.
vowelTake :: String -> [Double] -> ControlPattern #
vowelrecv :: Pattern Int -> ControlPattern #
waveloss :: Pattern Double -> ControlPattern #
wavelossTake :: String -> [Double] -> ControlPattern #
wavelossCount :: String -> ControlPattern #
wavelossbus :: Pattern Int -> Pattern Double -> ControlPattern #
wavelossrecv :: Pattern Int -> ControlPattern #
xsdelay :: Pattern Double -> ControlPattern #
xsdelayTake :: String -> [Double] -> ControlPattern #
xsdelayCount :: String -> ControlPattern #
xsdelaybus :: Pattern Int -> Pattern Double -> ControlPattern #
xsdelayrecv :: Pattern Int -> ControlPattern #
voi :: Pattern Double -> ControlPattern #
voirecv :: Pattern Int -> ControlPattern #
vco :: Pattern Double -> ControlPattern #
vcorecv :: Pattern Int -> ControlPattern #
vcf :: Pattern Double -> ControlPattern #
vcfrecv :: Pattern Int -> ControlPattern #
up :: Pattern Note -> ControlPattern #
tremr :: Pattern Double -> ControlPattern #
tremrrecv :: Pattern Int -> ControlPattern #
tremdp :: Pattern Double -> ControlPattern #
tremdprecv :: Pattern Int -> ControlPattern #
tdecay :: Pattern Double -> ControlPattern #
tdecayrecv :: Pattern Int -> ControlPattern #
sz :: Pattern Double -> ControlPattern #
szrecv :: Pattern Int -> ControlPattern #
sus :: Pattern Double -> ControlPattern #
stt :: Pattern Double -> ControlPattern #
sttrecv :: Pattern Int -> ControlPattern #
std :: Pattern Double -> ControlPattern #
stdrecv :: Pattern Int -> ControlPattern #
sld :: Pattern Double -> ControlPattern #
sldrecv :: Pattern Int -> ControlPattern #
scr :: Pattern Double -> ControlPattern #
scrrecv :: Pattern Int -> ControlPattern #
scp :: Pattern Double -> ControlPattern #
scprecv :: Pattern Int -> ControlPattern #
scl :: Pattern Double -> ControlPattern #
sclrecv :: Pattern Int -> ControlPattern #
sag :: Pattern Double -> ControlPattern #
sagrecv :: Pattern Int -> ControlPattern #
s :: Pattern String -> ControlPattern #
rel :: Pattern Double -> ControlPattern #
relrecv :: Pattern Int -> ControlPattern #
por :: Pattern Double -> ControlPattern #
porrecv :: Pattern Int -> ControlPattern #
pit3 :: Pattern Double -> ControlPattern #
pit3recv :: Pattern Int -> ControlPattern #
pit2 :: Pattern Double -> ControlPattern #
pit2recv :: Pattern Int -> ControlPattern #
pit1 :: Pattern Double -> ControlPattern #
pit1recv :: Pattern Int -> ControlPattern #
phasr :: Pattern Double -> ControlPattern #
phasrrecv :: Pattern Int -> ControlPattern #
phasdp :: Pattern Double -> ControlPattern #
phasdprecv :: Pattern Int -> ControlPattern #
ohdecay :: Pattern Double -> ControlPattern #
ohdecaybus :: Pattern Int -> Pattern Double -> ControlPattern #
ohdecayrecv :: Pattern Int -> ControlPattern #
number :: Pattern Note -> ControlPattern #
lsn :: Pattern Double -> ControlPattern #
lsnrecv :: Pattern Int -> ControlPattern #
lpq :: Pattern Double -> ControlPattern #
lpqrecv :: Pattern Int -> ControlPattern #
lpf :: Pattern Double -> ControlPattern #
lpfrecv :: Pattern Int -> ControlPattern #
loh :: Pattern Double -> ControlPattern #
lohrecv :: Pattern Int -> ControlPattern #
llt :: Pattern Double -> ControlPattern #
lltrecv :: Pattern Int -> ControlPattern #
lht :: Pattern Double -> ControlPattern #
lhtrecv :: Pattern Int -> ControlPattern #
lfop :: Pattern Double -> ControlPattern #
lfoprecv :: Pattern Int -> ControlPattern #
lfoi :: Pattern Double -> ControlPattern #
lfoirecv :: Pattern Int -> ControlPattern #
lfoc :: Pattern Double -> ControlPattern #
lfocrecv :: Pattern Int -> ControlPattern #
lcr :: Pattern Double -> ControlPattern #
lcrrecv :: Pattern Int -> ControlPattern #
lcp :: Pattern Double -> ControlPattern #
lcprecv :: Pattern Int -> ControlPattern #
lcl :: Pattern Double -> ControlPattern #
lclrecv :: Pattern Int -> ControlPattern #
lch :: Pattern Double -> ControlPattern #
lchrecv :: Pattern Int -> ControlPattern #
lbd :: Pattern Double -> ControlPattern #
lbdrecv :: Pattern Int -> ControlPattern #
lag :: Pattern Double -> ControlPattern #
lagrecv :: Pattern Int -> ControlPattern #
hpq :: Pattern Double -> ControlPattern #
hpqrecv :: Pattern Int -> ControlPattern #
hpf :: Pattern Double -> ControlPattern #
hpfrecv :: Pattern Int -> ControlPattern #
hg :: Pattern Double -> ControlPattern #
hgrecv :: Pattern Int -> ControlPattern #
gat :: Pattern Double -> ControlPattern #
gatrecv :: Pattern Int -> ControlPattern #
fadeOutTime :: Pattern Double -> ControlPattern #
dt :: Pattern Double -> ControlPattern #
dtrecv :: Pattern Int -> ControlPattern #
dfb :: Pattern Double -> ControlPattern #
dfbrecv :: Pattern Int -> ControlPattern #
det :: Pattern Double -> ControlPattern #
detrecv :: Pattern Int -> ControlPattern #
delayt :: Pattern Double -> ControlPattern #
delaytrecv :: Pattern Int -> ControlPattern #
delayfb :: Pattern Double -> ControlPattern #
delayfbbus :: Pattern Int -> Pattern Double -> ControlPattern #
delayfbrecv :: Pattern Int -> ControlPattern #
ctfg :: Pattern Double -> ControlPattern #
ctfgrecv :: Pattern Int -> ControlPattern #
ctf :: Pattern Double -> ControlPattern #
ctfrecv :: Pattern Int -> ControlPattern #
chdecay :: Pattern Double -> ControlPattern #
chdecaybus :: Pattern Int -> Pattern Double -> ControlPattern #
chdecayrecv :: Pattern Int -> ControlPattern #
bpq :: Pattern Double -> ControlPattern #
bpqrecv :: Pattern Int -> ControlPattern #
bpf :: Pattern Double -> ControlPattern #
bpfrecv :: Pattern Int -> ControlPattern #
att :: Pattern Double -> ControlPattern #
attrecv :: Pattern Int -> ControlPattern #
An implementation of the well-known xorshift
random number generator.
Given a seed number, generates a reasonably random number out of it.
This is an efficient algorithm suitable for use in tight loops and used
to implement the below functions, which are used to implement rand
.
See George Marsaglia (2003). "Xorshift RNGs", in Journal of Statistical Software, pages 8–14.
timeToIntSeed :: RealFrac a => a -> Int #
intSeedToRand :: Fractional a => Int -> a #
timeToRand :: (RealFrac a, Fractional b) => a -> b #
timeToRands :: (RealFrac a, Fractional b) => a -> Int -> [b] #
timeToRands' :: Fractional a => Int -> Int -> [a] #
rand :: Fractional a => Pattern a #
rand
is an oscillator that generates a continuous pattern of (pseudo-)random
numbers between 0 and 1.
For example, to randomly pan around the stereo field:
d1 $ sound "bd*8" # pan rand
Or to enjoy a randomised speed from 0.5 to 1.5, add 0.5 to it:
d1 $ sound "arpy*4" # speed (rand + 0.5)
To make the snares randomly loud and quiet:
sound "sn sn ~ sn" # gain rand
Numbers coming from this pattern are 'seeded' by time. So if you reset time
(using resetCycles
, setCycle
, or cps
) the random pattern will emit the
exact same _random_ numbers again.
In cases where you need two different random patterns, you can shift one of them around to change the time from which the _random_ pattern is read, note the difference:
jux (# gain rand) $ sound "sn sn ~ sn" # gain rand
and with the juxed version shifted backwards for 1024 cycles:
jux (# ((1024 <~) $ gain rand)) $ sound "sn sn ~ sn" # gain rand
Boolean rand - a continuous stream of true/false values, with a 50/50 chance.
brandBy :: Pattern Double -> Pattern Bool #
Boolean rand with probability as input, e.g. brandBy 0.25
produces trues 25% of the time.
irand :: Num a => Pattern Int -> Pattern a #
Just like rand
but for whole numbers, irand n
generates a pattern of (pseudo-) random whole numbers between 0
to n-1
inclusive. Notably used to pick a random
samples from a folder:
d1 $ segment 4 $ n (irand 5) # sound "drum"
perlinWith :: Fractional a => Pattern Double -> Pattern a #
1D Perlin (smooth) noise, works like rand
but smoothly moves between random
values each cycle. perlinWith
takes a pattern as the random number generator's
"input" instead of automatically using the cycle count.
d1 $ s "arpy*32" # cutoff (perlinWith (saw * 4) * 2000)
will generate a smooth random pattern for the cutoff frequency which will repeat every cycle (because the saw does).
The perlin
function uses the cycle count as input and can be used much like rand
.
perlin :: Fractional a => Pattern a #
As perlin
with a suitable choice of input pattern (
).sig
fromRational
The perlin
function produces a new random value to move to every cycle. If
you want a new random value to be generated more or less frequently, you can use
fast or slow, respectively:
d1 $ sound "bd*32" # speed (fast 4 $ perlin + 0.5) d1 $ sound "bd*32" # speed (slow 4 $ perlin + 0.5)
perlin2With :: Pattern Double -> Pattern Double -> Pattern Double #
perlin2With
is Perlin noise with a 2-dimensional input. This can be
useful for more control over how the randomness repeats (or doesn't).
d1 $ s "[supersaw:-12*32]" # lpf (rangex 60 5000 $ perlin2With (cosine*2) (sine*2)) # lpq 0.3
The above will generate a smooth random cutoff pattern that repeats every cycle without any reversals or discontinuities (because the 2D path is a circle).
See also: perlin2
, which only needs one input because it uses the cycle count
as the second input.
perlin2 :: Pattern Double -> Pattern Double #
As perlin2
with a suitable choice of input pattern (
).sig
fromRational
normal :: (Floating a, Ord a) => Pattern a #
Generates values in [0,1] that follows a normal (bell-curve) distribution.
One possible application is to "humanize" drums with a slight random delay:
d1 $
s "bd sn bd sn"
# nudge (segment 4 (0.01 * normal))
Implemented with the Box-Muller transform.
* the max ensures we don't calculate log 0
* the rot in u2 ensures we don't just get the same value as u1
* clamp the Box-Muller generated values in a [-3,3] range
chooseBy :: Pattern Double -> [a] -> Pattern a #
Given a pattern of doubles, chooseBy
normalizes them so that each
corresponds to an index in the provided list. The returned pattern
contains the corresponding elements in the list.
It is like choose, but instead of selecting elements of the list randomly, it uses the given pattern to select elements.
choose
= chooseByrand
The following results in the pattern "a b c"
:
chooseBy "0 0.25 0.5" ["a","b","c","d"]
wchoose :: [(a, Pattern Double)] -> Pattern a #
Like choose
, but works on an a list of tuples of values and weights
sound "superpiano(3,8)" # note (wchoose [("a",1), ("e",0.5), ("g",2), ("c",1)])
In the above example, the "a" and "c" notes are twice as likely to play as the "e" note, and half as likely to play as the "g" note.
wchoose = 'wchooseBy' 'rand'
wchooseBy :: Pattern Double -> [(a, Pattern Double)] -> Pattern a #
Given a pattern of probabilities and a list of (value, weight)
pairs,
wchooseBy
creates a
by choosing values based on those
probabilities and weighted appropriately by the weights in the list of pairs.Pattern
value
randcat :: [Pattern a] -> Pattern a #
randcat ps
: does a slowcat
on the list of patterns ps
but
randomises the order in which they are played.
d1 $ sound (randcat ["bd*2 sn", "jvbass*3", "drum*2", "ht mt"])
wrandcat :: [(Pattern a, Pattern Double)] -> Pattern a #
As randcat
, but allowing weighted choice.
In the following, the first pattern is the most likely and will play about half the time, and the last pattern is the less likely, with only a 10% probability.
d1 $ sound $ wrandcat [ ("bd*2 sn", 5), ("jvbass*3", 2), ("drum*2", 2), ("ht mt", 1) ]
degrade :: Pattern a -> Pattern a #
degrade
randomly removes events from a pattern 50% of the time:
d1 $ slow 2 $ degrade $ sound "[[[feel:5*8,feel*3] feel:3*8], feel*4]" # accelerate "-6" # speed "2"
The shorthand syntax for degrade
is a question mark: ?
. Using ?
will allow you to randomly remove events from a portion of a pattern:
d1 $ slow 2 $ sound "bd ~ sn bd ~ bd? [sn bd?] ~"
You can also use ?
to randomly remove events from entire sub-patterns:
d1 $ slow 2 $ sound "[[[feel:5*8,feel*3] feel:3*8]?, feel*4]"
degradeBy :: Pattern Double -> Pattern a -> Pattern a #
Similar to degrade
, degradeBy
allows you to control the percentage of events that
are removed. For example, to remove events 90% of the time:
d1 $ slow 2 $ degradeBy 0.9 $ sound "[[[feel:5*8,feel*3] feel:3*8], feel*4]" # accelerate "-6" # speed "2"
You can also invoke this behavior in the shorthand notation by specifying a percentage, as a number between 0 and 1, after the question mark:
d1 $ s "bd hh?0.8 bd hh?0.4"
_degradeBy :: Double -> Pattern a -> Pattern a #
unDegradeBy :: Pattern Double -> Pattern a -> Pattern a #
As degradeBy
, but the pattern of probabilities represents the chances to retain rather
than remove the corresponding element.
_unDegradeBy :: Double -> Pattern a -> Pattern a #
sometimesBy :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
Use sometimesBy
to apply a given function "sometimes". For example, the
following code results in density 2
being applied about 25% of the time:
d1 $ sometimesBy 0.25 (density 2) $ sound "bd*8"
There are some aliases as well:
sometimes
= sometimesBy 0.5often
= sometimesBy 0.75rarely
= sometimesBy 0.25almostNever
= sometimesBy 0.1almostAlways
= sometimesBy 0.9
sometimesBy' :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
As sometimesBy
, but applies the given transformation to the pattern in its entirety
before filtering its actual appearances. Less efficient than sometimesBy
but may
be useful when the passed pattern transformation depends on properties of the
pattern before probabilities are taken into account.
sometimes'
= sometimesBy' 0.5often'
= sometimesBy' 0.75rarely'
= sometimesBy' 0.25almostNever'
= sometimesBy' 0.1almostAlways'
= sometimesBy' 0.9
sometimes :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
sometimes
is an alias for
.sometimesBy
0.5
sometimes' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
sometimes'
is an alias for
.sometimesBy'
0.5
often :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
often
is an alias for
.sometimesBy
0.75
often' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
often'
is an alias for
.sometimesBy'
0.75
rarely :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
rarely
is an alias for
.sometimesBy
0.25
rarely' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
rarely'
is an alias for
.sometimesBy'
0.25
almostNever :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
almostNever
is an alias for
.sometimesBy
0.1
almostNever' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
almostNever'
is an alias for
.sometimesBy'
0.1
almostAlways :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
almostAlways
is an alias for
.sometimesBy
0.9
almostAlways' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
almostAlways'
is an alias for
.sometimesBy'
0.9
never :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
Never apply a transformation, returning the pattern unmodified.
always :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
Apply the transformation to the pattern unconditionally.
always = id
someCyclesBy :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
someCyclesBy
is a cycle-by-cycle version of
.sometimesBy
For example the following will either distort all of the events in a cycle, or none of them:
d1 $ someCyclesBy 0.5 (# crush 2) $ n "0 1 [~ 2] 3" # sound "arpy"
somecyclesBy :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
Alias of someCyclesBy
.
someCycles :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
someCycles = someCyclesBy
0.5
somecycles :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
Alias of someCycles
.
brak :: Pattern a -> Pattern a #
brak
makes a pattern sound a bit like a breakbeat. It does this by, every
other cycle, squashing the pattern to fit half a cycle, and offsetting it by a
quarter of a cycle.
d1 $ sound (brak "bd sn kurt") d1 $ brak $ sound "[feel feel:3, hc:3 hc:2 hc:4 ho:1]"
iter' :: Pattern Int -> Pattern c -> Pattern c #
iter'
is the same as iter
, but decrements the starting
subdivision instead of incrementing it. For example,
d1 $ iter' 4 $ sound "bd hh sn cp"
produces
bd hh sn cp cp bd hh sn sn cp bd hh hh sn cp bd
palindrome :: Pattern a -> Pattern a #
palindrome p
applies rev
to p
every other cycle, so that the pattern
alternates between forwards and backwards. For example, these are equivalent:
d1 $ palindrome $ sound "arpy:0 arpy:1 arpy:2 arpy:3" d1 $ slow 2 $ sound "arpy:0 arpy:1 arpy:2 arpy:3 arpy:3 arpy:2 arpy:1 arpy:0" d1 $ every 2 rev $ sound "arpy:0 arpy:1 arpy:2 arpy:3"
fadeOutFrom :: Time -> Time -> Pattern a -> Pattern a #
Alternate version to fadeOut
where you can provide the time from which the fade starts
fadeInFrom :: Time -> Time -> Pattern a -> Pattern a #
Alternate version to fadeIn
where you can provide the time from
which the fade in starts
spread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b #
The spread
function allows you to take a pattern transformation
which takes a parameter, such as slow
, and provide several
parameters which are switched between. In other words it "spreads" a
function across several values.
Taking a simple high hat loop as an example:
d1 $ sound "ho ho:2 ho:3 hc"
We can slow it down by different amounts, such as by a half:
d1 $ slow 2 $ sound "ho ho:2 ho:3 hc"
Or by four thirds (i.e. speeding it up by a third; 4%3
means four over
three):
d1 $ slow (4%3) $ sound "ho ho:2 ho:3 hc"
But if we use spread
, we can make a pattern which alternates between
the two speeds:
d1 $ spread slow [2,4%3] $ sound "ho ho:2 ho:3 hc"
Note that if you pass ($)
as the function to spread values over, you
can put functions as the list of values. (spreadf
is an alias for spread ($)
.)
For example:
d1 $ spread ($) [density 2, rev, slow 2, striate 3, (# speed "0.8")] $ sound "[bd*2 [~ bd]] [sn future]*2 cp jvbass*4"
Above, the pattern will have these transforms applied to it, one at a time, per cycle:
- cycle 1:
density 2
- pattern will increase in speed - cycle 2:
rev
- pattern will be reversed - cycle 3:
slow 2
- pattern will decrease in speed - cycle 4:
striate 3
- pattern will be granualized - cycle 5:
(# speed "0.8")
- pattern samples will be played back more slowly
After (# speed "0.8")
, the transforms will repeat and start at density 2
again.
slowspread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b #
An alias for spread
consistent with fastspread
.
fastspread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b #
fastspread
works the same as spread
, but the result is squashed into a single cycle. If you gave four values to spread
, then the result would seem to speed up by a factor of four. Compare these two:
d1 $ spread chop [4,64,32,16] $ sound "ho ho:2 ho:3 hc" d1 $ fastspread chop [4,64,32,16] $ sound "ho ho:2 ho:3 hc"
There is also slowspread
, which is an alias of spread
.
spread' :: Monad m => (a -> b -> m c) -> m a -> b -> m c #
There's a version of this function, spread'
(pronounced "spread prime"), which takes a pattern of parameters, instead of a list:
d1 $ spread' slow "2 4%3" $ sound "ho ho:2 ho:3 hc"
This is quite a messy area of Tidal—due to a slight difference of
implementation this sounds completely different! One advantage of
using spread'
though is that you can provide polyphonic parameters, e.g.:
d1 $ spread' slow "[2 4%3, 3]" $ sound "ho ho:2 ho:3 hc"
spreadChoose :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b #
spreadChoose f xs p
is similar to slowspread
but picks values from
xs
at random, rather than cycling through them in order.
d1 $ spreadChoose ($) [gap 4, striate 4] $ sound "ho ho:2 ho:3 hc"
spreadr :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b #
A shorter alias for spreadChoose
.
ifp :: (Int -> Bool) -> (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
Decide whether to apply one or another function depending on the result of a test function, which is passed the current cycle as a number.
d1 $ ifp ((== 0) . flip mod 2) (striate 4) (# coarse "24 48") $ sound "hh hc"
This will apply
for every even cycle and apply striate
4# coarse "24 48"
for every odd.
Detail: As you can see the test function is arbitrary and does not rely on
anything Tidal specific. In fact it uses only plain Haskell functionality, that
is: it calculates the modulo of 2 of the current cycle which is either 0 (for
even cycles) or 1. It then compares this value against 0 and returns the result,
which is either True
or False
. This is what the ifp
signature's first part
signifies: (Int -> Bool)
, a function that takes a whole number and returns
either True
or False
.
wedge :: Pattern Time -> Pattern a -> Pattern a -> Pattern a #
wedge t p p'
combines patterns p
and p'
by squashing the
p
into the portion of each cycle given by t
, and p'
into the
remainer of each cycle.
> d1 $ wedge (1/4) (sound "bd*2 arpy*3 cp sn*2") (sound "odx [feel future]*2 hh hh")
whenmod :: Pattern Time -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
whenmod
has a similar form and behavior to every
, but requires an
additional number. It applies the function to the pattern when the
remainder of the current loop number divided by the first parameter
is greater or equal than the second parameter.
For example, the following makes every other block of four loops twice as dense:
d1 $ whenmod 8 4 (density 2) (sound "bd sn kurt")
superimpose :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
superimpose f p = stack [p, f p]
superimpose
plays a modified version of a pattern at the same time as the
original pattern, resulting in two patterns being played at the same time. The
following are equivalent:
d1 $ superimpose (fast 2) $ sound "bd sn [cp ht] hh" d1 $ stack [sound "bd sn [cp ht] hh", fast 2 $ sound "bd sn [cp ht] hh" ]
More examples:
d1 $ superimpose (density 2) $ sound "bd sn [cp ht] hh" d1 $ superimpose ((# speed "2") . (0.125 <~)) $ sound "bd sn cp hh"
trunc :: Pattern Time -> Pattern a -> Pattern a #
trunc
truncates a pattern so that only a fraction of the pattern is played.
The following example plays only the first quarter of the pattern:
d1 $ trunc 0.25 $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2"
You can also pattern the first parameter, for example to cycle through three values, one per cycle:
d1 $ trunc "<0.75 0.25 1>" $ sound "bd sn:2 [mt rs] hc"
linger :: Pattern Time -> Pattern a -> Pattern a #
linger
is similar to trunc
, in that it truncates a pattern so that
only the first fraction of the pattern is played, but the truncated part of the
pattern loops to fill the remainder of the cycle.
d1 $ linger 0.25 $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2"
For example this repeats the first quarter, so you only hear a single repeating note:
d1 $ linger 0.25 $ n "0 2 [3 4] 2" # sound "arpy"
or slightly more interesting, applied only every fourth cycle:
d1 $ every 4 (linger 0.25) $ n "0 2 [3 4] 2" # sound "arpy"
or to a chopped-up sample:
d1 $ every 2 (linger 0.25) $ loopAt 2 $ chop 8 $ sound "breaks125"
You can also pattern the first parameter, for example to cycle through three values, one per cycle:
d1 $ linger "<0.75 0.25 1>" $ sound "bd sn:2 [mt rs] hc" d1 $ linger "<0.25 0.5 1>" $ loopAt 2 $ chop 8 $ sound "breaks125"
If you give it a negative number, it will linger on the last part of the pattern, instead of the start of it. E.g. to linger on the last quarter:
d1 $ linger (-0.25) $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2"
within :: (Time, Time) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
Use within
to apply a function to only a part of a pattern. It takes two
arguments: a start time and an end time, specified as floats between 0 and 1,
which are applied to the relevant pattern. Note that the second argument must be
greater than the first for the function to have any effect.
For example, to apply
to only the first half of a pattern:fast
2
d1 $ within (0, 0.5) (fast 2) $ sound "bd*2 sn lt mt hh hh hh hh"
Or, to apply (#
to only the last quarter of a pattern:speed
"0.5")
d1 $ within (0.75, 1) (# speed "0.5") $ sound "bd*2 sn lt mt hh hh hh hh"
within' :: (Time, Time) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
For many cases, within'
will function exactly as within.
The difference between the two occurs when applying functions that change the timing of notes such as fast
or <~
.
within first applies the function to all notes in the cycle, then keeps the results in the specified interval, and then combines it with the old cycle (an "apply split combine" paradigm).
within' first keeps notes in the specified interval, then applies the function to these notes, and then combines it with the old cycle (a "split apply combine" paradigm).
For example, whereas using the standard version of within
d1 $ within (0, 0.25) (fast 2) $ sound "bd hh cp sd"
sounds like:
d1 $ sound "[bd hh] hh cp sd"
using this alternative version, within'
d1 $ within' (0, 0.25) (fast 2) $ sound "bd hh cp sd"
sounds like:
d1 $ sound "[bd bd] hh cp sd"
revArc :: (Time, Time) -> Pattern a -> Pattern a #
Reverse the part of the pattern sliced out by the (start, end)
pair.
revArc a = within a rev
euclid :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a #
You can use the euclid
function to apply a Euclidean algorithm over a
complex pattern, although the structure of that pattern will be lost:
d1 $ euclid 3 8 $ sound "bd*2 [sn cp]"
In the above, three sounds are picked from the pattern on the right according
to the structure given by the euclid 3 8
. It ends up picking two bd
sounds, a
cp
and missing the sn
entirely.
A negative first argument provides the inverse of the euclidean pattern.
These types of sequences use "Bjorklund's algorithm", which wasn't made for
music but for an application in nuclear physics, which is exciting. More
exciting still is that it is very similar in structure to the one of the first
known algorithms written in Euclid's book of elements in 300 BC. You can read
more about this in the paper
The Euclidean Algorithm Generates Traditional Musical Rhythms
by Toussaint. Some examples from this paper are included below,
including rotation as a third parameter in some cases (see euclidOff
).
Pattern | Example |
---|---|
(2,5) | A thirteenth century Persian rhythm called Khafif-e-ramal. |
(3,4) | The archetypal pattern of the Cumbia from Colombia, as well as a Calypso rhythm from Trinidad. |
(3,5,2) | Another thirteenth century Persian rhythm by the name of Khafif-e-ramal, as well as a Rumanian folk-dance rhythm. |
(3,7) | A Ruchenitza rhythm used in a Bulgarian folk-dance. |
(3,8) | The Cuban tresillo pattern. |
(4,7) | Another Ruchenitza Bulgarian folk-dance rhythm. |
(4,9) | The Aksak rhythm of Turkey. |
(4,11) | The metric pattern used by Frank Zappa in his piece titled Outside Now. |
(5,6) | Yields the York-Samai pattern, a popular Arab rhythm. |
(5,7) | The Nawakhat pattern, another popular Arab rhythm. |
(5,8) | The Cuban cinquillo pattern. |
(5,9) | A popular Arab rhythm called Agsag-Samai. |
(5,11) | The metric pattern used by Moussorgsky in Pictures at an Exhibition. |
(5,12) | The Venda clapping pattern of a South African children’s song. |
(5,16) | The Bossa-Nova rhythm necklace of Brazil. |
(7,8) | A typical rhythm played on the Bendir (frame drum). |
(7,12) | A common West African bell pattern. |
(7,16,14) | A Samba rhythm necklace from Brazil. |
(9,16) | A rhythm necklace used in the Central African Republic. |
(11,24,14) | A rhythm necklace of the Aka Pygmies of Central Africa. |
(13,24,5) | Another rhythm necklace of the Aka Pygmies of the upper Sangha. |
There was once a shorter alias e
for this function. It has been removed, but you
may see references to it in older Tidal code.
euclidFull :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a -> Pattern a #
euclidFull n k pa pb
stacks
with euclid
n k pa
. That
is, it plays one pattern on the euclidean rhythm and a different pattern on
the off-beat.euclidInv
n k pb
For example, to implement the traditional flamenco rhythm, you could use hard claps for the former and soft claps for the latter:
d1 $ euclidFull 3 7 "realclaps" ("realclaps" # gain 0.8)
_euclidBool :: Int -> Int -> Pattern Bool #
Less expressive than euclid
due to its constrained types, but may be more efficient.
euclidOff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a #
As euclid
, but taking a third rotational parameter corresponding to the onset
at which to start the rhythm.
eoff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a #
A shorter alias for euclidOff
.
euclidInv :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a #
euclidInv
fills in the blanks left by euclid
, i.e., it inverts the
pattern.
For example, whereas euclid 3 8 "x"
produces
"x ~ ~ x ~ ~ x ~"
euclidInv 3 8 "x"
produces
"~ x x ~ x x ~ x"
As another example, in
d1 $ stack [ euclid 5 8 $ s "bd" , euclidInv 5 8 $ s "hh27" ]
the hi-hat event fires on every one of the eight even beats that the bass drum does not.
rot :: Ord a => Pattern Int -> Pattern a -> Pattern a #
rot n p
"rotates" the values in a pattern p
by n
beats to the left,
preserving its structure. For example, in the following, each value will shift
to its neighbour's position one step to the left, so that b
takes the place of
a
, a
of c
, and c
of b
:
rot 1 "a ~ b c"
The result is equivalent of:
"b ~ c a"
The first parameter is the number of steps, and may be given as a pattern. For example, in
d1 $ rot "<0 0 1 3>" $ n "0 ~ 1 2 0 2 ~ 3*2" # sound "drum"
the pattern will not be rotated for the first two cycles, but will rotate it by one the third cycle, and by three the fourth cycle.
Additional example:
d1 $ every 4 (rot 2) $ slow 2 $ sound "bd hh hh hh"
_rot :: Ord a => Int -> Pattern a -> Pattern a #
Calculates a whole cycle, rotates it, then constrains events to the original query arc.
segment :: Pattern Time -> Pattern a -> Pattern a #
segment n p
’samples’ the pattern p
at a rate of n
events per cycle.
Useful for turning a continuous pattern into a discrete one.
In the following example, the pattern originates from the shape of a sine
wave, a continuous pattern. Without segment
, the samples will get triggered
at an undefined frequency which may be very high.
d1 $ n (slow 2 $ segment 16 $ range 0 32 $ sine) # sound "amencutup"
discretise :: Pattern Time -> Pattern a -> Pattern a #
discretise
: the old (deprecated) name for segment
fit :: Pattern Int -> [a] -> Pattern Int -> Pattern a #
The fit
function takes a pattern of integer numbers, which are used to select values from the given list. What makes this a bit strange is that only a given number of values are selected each cycle. For example:
d1 $ sound (fit 3 ["bd", "sn", "arpy", "arpy:1", "casio"] "0 [~ 1] 2 1")
The above fits three samples into the pattern, i.e. for the first cycle this
will be "bd"
, "sn"
and "arpy"
, giving the result "bd [~ sn] arpy sn"
(note that we start counting at zero, so that 0 picks the first value). The
following cycle the next three values in the list will be picked, i.e.
"arpy:1"
, "casio"
and "bd"
, giving the pattern
"arpy:1 [~ casio] bd casio"
(note that the list wraps round here).
struct :: Pattern Bool -> Pattern a -> Pattern a #
struct a b
structures pattern b
in terms of the pattern of boolean
values a
. Only True
values in the boolean pattern are used.
The following are equivalent:
d1 $ struct ("t ~ t*2 ~") $ sound "cp" d1 $ sound "cp ~ cp*2 ~"
The structure comes from a boolean pattern, i.e. a binary pattern containing
true or false values. Above we only used true values, denoted by t
. It’s also
possible to include false values with f
, which struct
will simply treat as
silence. For example, this would have the same outcome as the above:
d1 $ struct ("t f t*2 f") $ sound "cp"
These true / false binary patterns become useful when you conditionally
manipulate them, for example, ‘inverting’ the values using every
and inv
:
d1 $ struct (every 3 inv "t f t*2 f") $ sound "cp"
In the above, the boolean values will be ‘inverted’ every third cycle, so that
the structure comes from the f
s rather than t
. Note that euclidean patterns
also create true/false values, for example:
d1 $ struct (every 3 inv "t(3,8)") $ sound "cp"
In the above, the euclidean pattern creates "t f t f t f f t"
which gets
inverted to "f t f t f t t f"
every third cycle. Note that if you prefer you
can use 1 and 0 instead of t
and f
.
substruct :: Pattern Bool -> Pattern b -> Pattern b #
substruct a b
: similar to struct
, but each event in pattern a
gets replaced with pattern b
, compressed to fit the timespan of the event.
randStruct :: Int -> Pattern Int #
stripe :: Pattern Int -> Pattern a -> Pattern a #
stripe n p
: repeats pattern p
n
times per cycle, i.e., the first
parameter gives the number of cycles to operate over. So, it is similar to
fast
, but with random durations. For example stripe 2
will repeat a pattern
twice, over two cycles
In the following example, the start of every third repetition of the d1
pattern will match with the clap on the d2
pattern.
d1 $ stripe 3 $ sound "bd sd ~ [mt ht]" d2 $ sound "cp"
The repetitions will be contiguous (touching, but not overlapping) and the
durations will add up to a single cycle. n
can be supplied as a pattern of
integers.
slowstripe :: Pattern Int -> Pattern a -> Pattern a #
slowstripe n p
is the same as stripe
, but the result is also
n
times slower, so that the mean average duration of the stripes
is exactly one cycle, and every n
th stripe starts on a cycle
boundary (in Indian classical terms, the sam).
parseLMRule :: String -> [(String, String)] #
parseLMRule' :: String -> [(Char, String)] #
lindenmayer :: Int -> String -> String -> String #
Returns the n
th iteration of a
Lindenmayer System
with given start sequence.
It takes an integer b
, a Lindenmayer system rule set, and an initiating
string as input in order to generate an L-system tree string of b
iterations.
It can be used in conjunction with a step function to convert the generated
string into a playable pattern. For example,
d1 $ slow 16 $ sound $ step' ["feel:0", "sn:1", "bd:0"] ( take 512 $ lindenmayer 5 "0:1~~~,1:0~~~2~~~~~0~~~2~,2:2~1~,~:~~1~" "0" )
generates an L-system with initiating string "0"
and maps it onto a list
of samples.
Complex L-system trees with many rules and iterations can sometimes result in unwieldy strings. Using take n
to only use the first n
elements of the string, along with a slow
function, can make the generated values more manageable.
lindenmayerI :: Num b => Int -> String -> String -> [b] #
lindenmayerI
converts the resulting string into a a list of integers
with fromIntegral
applied (so they can be used seamlessly where floats or
rationals are required)
runMarkov :: Int -> [[Double]] -> Int -> Time -> [Int] #
runMarkov n tmat xi seed
generates a Markov chain (as a list) of length n
using the transition matrix tmat
starting from initial state xi
, starting
with random numbers generated from seed
Each entry in the chain is the index of state (starting from zero).
Each row of the matrix will be automatically normalized. For example:
runMarkov 8 [[2,3], [1,3]] 0 0
will produce a two-state chain 8 steps long, from initial state 0
, where the
transition probability from state 0->0 is 25, 0->1 is 35, 1->0 is 1/4, and
1->1 is 3/4.
markovPat :: Pattern Int -> Pattern Int -> [[Double]] -> Pattern Int #
markovPat n xi tp
generates a one-cycle pattern of n
steps in a Markov
chain starting from state xi
with transition matrix tp
. Each row of the
transition matrix is automatically normalized. For example:
>>>
markovPat 8 1 [[3,5,2], [4,4,2], [0,1,0]]
(0>⅛)|1 (⅛>¼)|2 (¼>⅜)|1 (⅜>½)|1 (½>⅝)|2 (⅝>¾)|1 (¾>⅞)|1 (⅞>1)|0
beat :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a #
beat
structures a pattern by picking subdivisions of a cycle.
Takes in a pattern that tells it which parts to play (polyphony is recommeded here),
and the number of parts by which to subdivide the cycle (also pattern-able).
For example:
> d1 $ beat "[3,4.2,9,11,14]" 16 $ s "sd"
enclosingArc :: [Arc] -> Arc #
stretch :: Pattern a -> Pattern a #
stretch
takes a pattern, and if there’s silences at the start or end of the
current cycle, it will zoom in to avoid them. The following are equivalent:
d1 $ note (stretch "~ 0 1 5 8*4 ~") # s "superpiano" d1 $ note "0 1 5 8*4" # s "superpiano"
You can pattern silences on the extremes of a cycle to make changes to the rhythm:
d1 $ note (stretch "~ <0 ~> 1 5 8*4 ~") # s "superpiano"
fit' :: Pattern Time -> Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a #
fit'
is a generalization of fit
, where the list is instead constructed
by using another integer pattern to slice up a given pattern. The first argument
is the number of cycles of that latter pattern to use when slicing. It's easier
to understand this with a few examples:
d1 $ sound (fit' 1 2 "0 1" "1 0" "bd sn")
So what does this do? The first 1
just tells it to slice up a single cycle of
"bd sn"
. The 2
tells it to select two values each cycle, just like the first
argument to fit
. The next pattern "0 1"
is the "from" pattern which tells
it how to slice, which in this case means "0"
maps to "bd"
, and "1"
maps
to "sn"
. The next pattern "1 0"
is the "to" pattern, which tells it how to
rearrange those slices. So the final result is the pattern "sn bd"
.
A more useful example might be something like
d1 $ fit' 1 4 (run 4) "[0 3*2 2 1 0 3*2 2 [1*8 ~]]/2" $ chop 4 $ (sound "breaks152" # unit "c")
which uses chop
to break a single sample into individual pieces, which fit'
then puts into a list (using the run 4
pattern) and reassembles according to the complicated integer pattern.
chunk' :: Integral a1 => Pattern a1 -> (Pattern a2 -> Pattern a2) -> Pattern a2 -> Pattern a2 #
DEPRECATED, use chunk
with negative numbers instead
_chunk' :: Integral a => a -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b #
DEPRECATED, use _chunk
with negative numbers instead
inside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a #
inside
carries out an operation inside a cycle.
For example, while rev "0 1 2 3 4 5 6 7"
is the same as "7 6 5 4 3 2 1 0"
,
inside 2 rev "0 1 2 3 4 5 6 7"
gives "3 2 1 0 7 6 5 4"
.
What this function is really doing is ‘slowing down’ the pattern by a given factor, applying the given function to it, and then ‘speeding it up’ by the same factor. In other words, this:
inside 2 rev "0 1 2 3 4 5 6 7"
Is doing this:
fast 2 $ rev $ slow 2 "0 1 2 3 4 5 6 7"
so rather than whole cycles, each half of a cycle is reversed.
outside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a #
outside
is the inverse of the inside
function. outside
applies its function outside the cycle.
Say you have a pattern that takes 4 cycles to repeat and apply the rev function:
d1 $ rev $ cat [s "bd bd sn",s "sn sn bd", s"lt lt sd", s "sd sd bd"]
The above generates:
d1 $ rev $ cat [s "sn bd bd",s "bd sn sn", s "sd lt lt", s "bd sd sd"]
However if you apply outside
:
d1 $ outside 4 (rev) $ cat [s "bd bd sn",s "sn sn bd", s"lt lt sd", s "sd sd bd"]
The result is:
d1 $ rev $ cat [s "bd sd sd", s "sd lt lt", s "sn sn bd", s "bd bd sn"]
Notice that the whole idea has been reversed. What this function is really doing is ‘speeding up’ the pattern by a given factor, applying the given function to it, and then ‘slowing it down’ by the same factor. In other words, this:
d1 $ slow 4 $ rev $ fast 4 $ cat [s "bd bd sn",s "sn sn bd", s"lt lt sd", s "sd sd bd"]
This compresses the idea into a single cycle before rev operates and then slows it back to the original speed.
loopFirst :: Pattern a -> Pattern a #
Takes a pattern and loops only the first cycle of the pattern. For example, the following code will only play the bass drum sample:
d1 $ loopFirst $ s "<<bd*4 ht*8> cp*4>"
This function combines with sometimes
to insert events from the first cycle randomly into subsequent cycles of the pattern:
d1 $ sometimes loopFirst $ s "<<bd*4 ht*8> cp*4>"
seqPLoop :: [(Time, Time, Pattern a)] -> Pattern a #
seqPLoop
will keep looping the sequence when it gets to the end:
d1 $ qtrigger $ seqPLoop [ (0, 12, sound "bd bd*2") , (4, 12, sound "hh*2 [sn cp] cp future*4") , (8, 12, sound (samples "arpy*8" (run 16))) ]
toScale :: Num a => [a] -> Pattern Int -> Pattern a #
toScale
lets you turn a pattern of notes within a scale (expressed as a
list) to note numbers.
For example:
toScale [0, 4, 7] "0 1 2 3"
will turn into the pattern "0 4 7 12"
.
toScale
is handy for quickly applying a scale without naming it:
d1 $ n (toScale [0,2,3,5,7,8,10] "0 1 2 3 4 5 6 7") # sound "superpiano"
This function assumes your scale fits within an octave; if that's not true,
use toScale'
.
toScale = toScale' 12
toScale' :: Num a => Int -> [a] -> Pattern Int -> Pattern a #
As toScale
, though allowing scales of arbitrary size.
An example: toScale' 24 [0,4,7,10,14,17] (run 8)
turns into "0 4 7 10 14 17 24 28"
.
swingBy :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a #
swingBy x n
divides a cycle into n
slices and delays the notes in the
second half of each slice by x
fraction of a slice. So if x
is 0 it does
nothing, 0.5 delays for half the note duration, and 1 will wrap around to
doing nothing again. The end result is a shuffle or swing-like rhythm. For
example, the following will delay every other "hh"
1/3 of the way to the
next "hh"
:
d1 $ swingBy (1/3) 4 $ sound "hh*8"
cycleChoose :: [a] -> Pattern a #
cycleChoose
is like choose
but only picks a new item from the list
once each cycle.
d1 $ sound "drum ~ drum drum" # n (cycleChoose [0,2,3])
_rearrangeWith :: Pattern Int -> Int -> Pattern a -> Pattern a #
Internal function used by shuffle and scramble
shuffle :: Pattern Int -> Pattern a -> Pattern a #
shuffle n p
evenly divides one cycle of the pattern p
into n
parts,
and returns a random permutation of the parts each cycle. For example,
shuffle 3 "a b c"
could return "a b c"
, "a c b"
, "b a c"
, "b c a"
,
"c a b"
, or "c b a"
. But it will never return "a a a"
, because that
is not a permutation of the parts.
This could also be called “sampling without replacement”.
scramble :: Pattern Int -> Pattern a -> Pattern a #
scramble n p
is like shuffle
but randomly selects from the parts
of p
instead of making permutations.
For example, scramble 3 "a b c"
will randomly select 3 parts from
"a"
"b"
and "c"
, possibly repeating a single part.
This could also be called “sampling with replacement”.
randrun :: Int -> Pattern Int #
randrun n
generates a pattern of random integers less than n
.
The following plays random notes in an octave:
d1 $ s "superhammond!12" # n (fromIntegral $ randrun 13)
seqP :: [(Time, Time, Pattern a)] -> Pattern a #
The function seqP
allows you to define when
a sound within a list starts and ends. The code below contains three
separate patterns in a stack
, but each has different start times
(zero cycles, eight cycles, and sixteen cycles, respectively). All
patterns stop after 128 cycles:
d1 $ seqP [ (0, 128, sound "bd bd*2"), (8, 128, sound "hh*2 [sn cp] cp future*4"), (16, 128, sound (samples "arpy*8" (run 16))) ]
ur :: Time -> Pattern String -> [(String, Pattern a)] -> [(String, Pattern a -> Pattern a)] -> Pattern a #
The ur
function is designed for longer form composition, by allowing you to
create ‘patterns of patterns’ in a repeating loop. It takes four parameters:
how long the loop will take, a pattern giving the structure of the composition,
a lookup table for named patterns to feed into that structure, and a second
lookup table for named transformations/effects.
The ur- prefix comes from German and means proto- or original. For a mnemonic device, think of this function as assembling a set of original patterns (ur-patterns) into a larger, newer whole.
Lets say you had three patterns (called a
, b
and c
), and that you wanted
to play them four cycles each, over twelve cycles in total. Here is one way to
do it:
let pats = [ ( "a", stack [ n "c4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7" , n "[c3,g4,c4]" # s "superpiano"# gain "0.7" ] ) , ( "b", stack [ n "d4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7" , n "[d3,a4,d4]" # s "superpiano"# gain "0.7" ] ) , ( "c", stack [ n "f4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7" , n "[f4,c5,f4]" # s "superpiano"# gain "0.7" ] ) ] in d1 $ ur 12 "a b c" pats []
In the above, the fourth parameter is given as an empty list, but that is where you can put another lookup table, of functions rather than patterns this time. For example:
let pats = ... fx = [ ("reverb", ( # (room 0.8 # sz 0.99 # orbit 1))) , ("faster", fast 2) ] in d1 $ ur 12 "a b:reverb c:faster" pats fx
In this example, b
has the function applied that’s named as reverb, while c
is made to go faster. It’s also possible to schedule multiple patterns at once,
like in the following:
let pats = [ ("drums", s "drum cp*2") , ("melody", s "arpy:2 arpy:3 arpy:5") , ("craziness", s "cp:4*8" # speed ( sine + 0.5 )) ] fx = [("higher", ( # speed 2))] in d1 $ ur 8 "[drums, melody] [drums,craziness,melody] melody:higher" pats fx
inhabit :: [(String, Pattern a)] -> Pattern String -> Pattern a #
A simpler version of ur
that just provides name-value bindings that are
reflected in the provided pattern.
inhabit
allows you to link patterns to some String
, or in other words,
to give patterns a name and then call them from within another pattern of
String
s.
For example, we can make our own bassdrum, hi-hat and snaredrum kit:
do let drum = inhabit [ ("bd", s "sine" |- accelerate 1.5) , ("hh", s "alphabet:7" # begin 0.7 # hpf 7000) , ("sd", s "invaders:3" # speed 12) ] d1 $ drum "[bd*8?, [~hh]*4, sd(6,16)]"
inhabit
can be very useful when using MIDI controlled drum machines, since you
can give understandable drum names to patterns of notes.
spaceOut :: [Time] -> Pattern a -> Pattern a #
spaceOut xs p
repeats a Pattern
p
at different durations given by the list of time values in xs
.
flatpat :: Pattern [a] -> Pattern a #
flatpat
takes a Pattern
of lists and pulls the list elements as
separate Event
s. For example, the following code uses flatpat
in combination with listToPat
to create an alternating pattern of chords:
d1 $ n (flatpat $ listToPat [[0,4,7],[(-12),(-8),(-5)]]) # s "superpiano" # sustain 2
This code is equivalent to:
d1 $ n ("[0,4,7] [-12,-8,-5]") # s "superpiano" # sustain 2
layer :: [a -> Pattern b] -> a -> Pattern b #
layer
takes a list of Pattern
-returning functions and a seed element,
stacking the result of applying the seed element to each function in the list.
It allows you to layer up multiple functions on one pattern. For example, the following will play two versions of the pattern at the same time, one reversed and one at twice the speed:
d1 $ layer [rev, fast 2] $ sound "arpy [~ arpy:4]"
The original version of the pattern can be included by using the id
function:
d1 $ layer [id, rev, fast 2] $ sound "arpy [~ arpy:4]"
arpeggiate :: Pattern a -> Pattern a #
arpeggiate
finds events that share the same timespan, and spreads
them out during that timespan, so for example arpeggiate "[bd,sn]"
gets turned into "bd sn"
. Useful for creating arpeggios/broken chords.
arp :: Pattern String -> Pattern a -> Pattern a #
The arp
function takes an additional pattern of arpeggiate modes. For example:
d1 $ sound "superpiano" # n (arp "down diverge" "e'7sus4'8")
The different arpeggiate modes are:
up down updown downup up&down down&up converge
diverge disconverge pinkyup pinkyupdown
thumbup thumbupdown
rolled :: Pattern a -> Pattern a #
rolled
plays each note of a chord quickly in order, as opposed to
simultaneously; to give a chord a harp-like or strum effect.
Notes are played low to high, and are evenly distributed within (14) of the chord event length, as opposed to arparpeggiate that spread the notes over the whole event.
rolled $ n "cmaj
4" # s "superpiano"
rolled = rolledBy (1/4)
ply :: Pattern Rational -> Pattern a -> Pattern a #
ply n
repeats each event n
times within its arc.
For example, the following are equivalent:
d1 $ ply 3 $ s "bd ~ sn cp" d1 $ s "[bd bd bd] ~ [sn sn sn] [cp cp cp]"
The first parameter may be given as a pattern, so that the following are equivalent:
d1 $ ply "2 3" $ s "bd ~ sn cp" d1 $ s "[bd bd] ~ [sn sn sn] [cp cp cp]"
Here is an example of it being used conditionally:
d1 $ every 3 (ply 4) $ s "bd ~ sn cp"
plyWith :: (Ord t, Num t) => Pattern t -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
As ply
, but applies a function each time. The applications are compounded.
press :: Pattern a -> Pattern a #
Syncopates a rhythm, shifting (delaying) each event halfway into its arc (timespan).
In mini-notation terms, it basically turns every instance of a into [~ a]
,
e.g., "a b [c d] e"
becomes the equivalent of
"[~ a] [~ b] [[~ c] [~ d]] [~ e]"
.
Every beat then becomes an offbeat, and so the overall effect is to
syncopate a pattern.
In the following example, you can hear that the piano chords play between the snare and the bass drum. In 4/4 time, they are playing in the 2 and a half, and 4 and a half beats:
do resetCycles d1 $ stack [ press $ n "~ c'maj ~ c'maj" # s "superpiano" # gain 0.9 # pan 0.6, s "[bd,clap sd bd sd]" # pan 0.4 ] # cps (90/60/4)
In the next example, the C major chord plays before the G major. As the slot that occupies the C chord is that of one eighth note, it is displaced by press only a sixteenth note:
do resetCycles d1 $ stack [ press $ n "~ [c'maj ~] ~ ~" # s "superpiano" # gain 0.9 # pan 0.6, press $ n "~ g'maj ~ ~" # s "superpiano" # gain 0.9 # pan 0.4, s "[bd,clap sd bd sd]" ] # cps (90/60/4)
pressBy :: Pattern Time -> Pattern a -> Pattern a #
Like press
, but allows you to specify the amount in which each event is
shifted as a float from 0 to 1 (exclusive).
pressBy 0.5
is the same as press
, while pressBy (1/3)
shifts each event
by a third of its arc.
You can pattern the displacement to create interesting rhythmic effects:
d1 $ stack [ s "bd sd bd sd", pressBy "<0 0.5>" $ s "co:2*4" ]
d1 $ stack [ s "[bd,co sd bd sd]", pressBy "<0 0.25 0.5 0.75>" $ s "cp" ]
stitch :: Pattern Bool -> Pattern a -> Pattern a -> Pattern a #
Uses the first (binary) pattern to switch between the following
two patterns. The resulting structure comes from the binary
pattern, not the source patterns. (In sew
, by contrast, the resulting structure comes from the source patterns.)
The following uses a euclidean pattern to control CC0:
d1 $ ccv (stitch "t(7,16)" 127 0) # ccn 0 # "midi"
while :: Pattern Bool -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
A binary pattern is used to conditionally apply a function to a
source pattern. The function is applied when a True
value is
active, and the pattern is let through unchanged when a False
value is active. No events are let through where no binary values
are active.
jux :: (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap #
The jux
function creates strange stereo effects by applying a
function to a pattern, but only in the right-hand channel. For
example, the following reverses the pattern on the righthand side:
d1 $ slow 32 $ jux (rev) $ striateBy 32 (1/16) $ sound "bev"
When passing pattern transforms to functions like jux
and every
,
it's possible to chain multiple transforms together with .
(function
composition). For example this both reverses and halves the playback speed of
the pattern in the righthand channel:
d1 $ slow 32 $ jux ((# speed "0.5") . rev) $ striateBy 32 (1/16) $ sound "bev"
jux' :: [t -> Pattern ValueMap] -> t -> Pattern ValueMap #
In addition to jux
, jux'
allows using a list of pattern
transformations. Resulting patterns from each transformation will be spread via
pan from left to right.
For example, the following will put iter 4
of the pattern to the far left
and palindrome
to the far right. In the center, the original pattern will
play and the chopped and the reversed version will appear mid left and mid
right respectively.
d1 $ jux' [iter 4, chop 16, id, rev, palindrome] $ sound "bd sn"
One could also write:
d1 $ stack [ iter 4 $ sound "bd sn" # pan "0" , chop 16 $ sound "bd sn" # pan "0.25" , sound "bd sn" # pan "0.5" , rev $ sound "bd sn" # pan "0.75" , palindrome $ sound "bd sn" # pan "1" ]
jux4 :: (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap #
Multichannel variant of jux
, not sure what it does
juxBy :: Pattern Double -> (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap #
With jux
, the original and effected versions of the pattern are
panned hard left and right (i.e., panned at 0 and 1). This can be a
bit much, especially when listening on headphones. The variant juxBy
has an additional parameter, which brings the channel closer to the
centre. For example:
d1 $ juxBy 0.5 (fast 2) $ sound "bd sn:1"
In the above, the two versions of the pattern would be panned at 0.25 and 0.75, rather than 0 and 1.
pick :: String -> Int -> String #
Given a sample's directory name and number, this generates a string
suitable to pass to fromString
to create a 'Pattern String'.
samples
is a Pattern
-compatible interface to this function.
pick name n = name ++ ":" ++ show n
samples :: Applicative f => f String -> f Int -> f String #
Given a pattern of sample directory names and a of pattern indices create a pattern of strings corresponding to the sample at each name-index pair.
An example:
samples "jvbass [~ latibro] [jvbass [latibro jvbass]]" ((1%2) `rotL` slow 6 "[1 6 8 7 3]")
The type signature is more general here, but you can consider this
to be a function of type Pattern String -> Pattern Int -> Pattern String
.
samples = liftA2 pick
samples' :: Applicative f => f String -> f Int -> f String #
Equivalent to samples
, though the sample specifier pattern
(the f Int
) will be evaluated first. Not a large difference
in the majority of cases.
rangex :: (Functor f, Floating b) => b -> b -> f b -> f b #
rangex
is an exponential version of range
, good for using with
frequencies. For example, range 20 2000 "0.5"
will give 1010
- halfway
between 20
and 2000
. But rangex 20 2000 0.5
will give 200
- halfway
between on a logarithmic scale. This usually sounds better if you’re using the
numbers as pitch frequencies. Since rangex uses logarithms, don’t try to scale
things to zero or less.
off :: Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
off
is similar to superimpose
, in that it applies a function to a pattern
and layers up the results on top of the original pattern. The difference
is that off
takes an extra pattern being a time (in cycles) to shift the
transformed version of the pattern by.
The following plays a pattern on top of itself, but offset by an eighth of a cycle, with a distorting bitcrush effect applied:
d1 $ off 0.125 (# crush 2) $ sound "bd [~ sn:2] mt lt*2"
The following makes arpeggios by adding offset patterns that are shifted up the scale:
d1 $ slow 2 $ n (off 0.25 (+12) $ off 0.125 (+7) $ slow 2 "c(3,8) a(3,8,2) f(3,8) e(3,8,4)") # sound "superpiano"
sseq :: String -> String -> Pattern String #
sseq
acts as a kind of simple step-sequencer using strings. For example,
sseq "sn" "x x 12"
is equivalent to the pattern of strings given by "sn ~
sn ~ sn:1 sn:2 ~"
. sseq
substitutes the given string for each x
, for each number
it substitutes the string followed by a colon and the number, and for everything
else it puts in a rest.
In other words, sseq
generates a pattern of strings in exactly the syntax you’d want for selecting samples and that can be fed directly into the s
function.
d1 $ s (sseq "sn" "x x 12 ")
sseqs :: [(String, String)] -> Pattern String #
sseqs
is like sseq
but it takes a list of pairs, like sseq would, and
it plays them all simultaneously.
d1 $ s (sseqs [("cp","x x x x x x"),("bd", "xxxx")])
sseq' :: [String] -> String -> Pattern String #
like sseq
, but allows you to specify an array of strings to use for 0,1,2...
For example,
d1 $ s (sseq' ["superpiano","supermandolin"] "0 1 000 1") # sustain 4 # n 0
is equivalent to
d1 $ s "superpiano ~ supermandolin ~ superpiano!3 ~ supermandolin" # sustain 4 # n 0
ghost'' :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
Deprecated backwards-compatible alias for ghostWith
.
ghostWith :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
Like ghost'
, but a user-supplied function describes how to alter the pattern.
In this example, ghost notes are applied to the snare hit, but these notes will be louder, not quieter, and the sample will have its beginning slightly cut:
d1 $ slow 2 $ ghostWith (1/16) ((|*| gain 1.1) . (|> begin 0.05)) $ sound "sn"
ghost :: Pattern ValueMap -> Pattern ValueMap #
As ghost'
, but with the copies set to appear one-eighth of a cycle afterwards.
ghost = ghost' 0.125
The following creates a kick snare pattern with ghost notes applied to the snare hit:
d1 $ stack [ ghost $ sound "~ sn", sound "bd*2 [~ bd]" ]
tabby :: Int -> Pattern a -> Pattern a -> Pattern a #
A more literal weaving than the weave
function. Given tabby threads p1 p
,
parameters representing the threads per cycle and the patterns to weave, and
this function will weave them together using a plain (aka ’tabby’) weave,
with a simple over/under structure
selectF :: Pattern Double -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a #
Chooses from a list of functions, using a pattern of floats (from 0 to 1).
pickF :: Pattern Int -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a #
Chooses from a list of functions, using a pattern of integers.
contrast :: (ControlPattern -> ControlPattern) -> (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern #
contrast f f' p p'
splits the control pattern p'
in two, applying
the function f
to one and f'
to the other. This depends on
whether events in p'
contain values matching with those in p
.
For example, in
contrast (# crush 3) (# vowel "a") (n "1") $ n "0 1" # s "bd sn" # speed 3
the first event will have the vowel effect applied and the second will have the crush applied.
contrast
is like an if-else-statement over patterns. For contrast t f p
you can think of t
as the true branch, f
as the false branch, and p
as
the test.
You can use any control pattern as a test of equality, e.g., n "1", speed
"0.5"
, or things like that. This lets you choose specific properties of the
pattern you’re transforming for testing, like in the following example,
d1 $ contrast (|+ n 12) (|- n 12) (n "c") $ n (run 4) # s "superpiano"
where every note that isn’t middle-c will be shifted down an octave but middle-c will be shifted up to c5.
Since the test given to contrast is also a pattern, you can do things like have it alternate between options:
d1 $ contrast (|+ n 12) (|- n 12) (s "<superpiano superchip>") $ s "superpiano superchip" # n 0
If you listen to this you’ll hear that which instrument is shifted up and which instrument is shifted down alternates between cycles.
contrastBy :: (a -> Value -> Bool) -> (ControlPattern -> Pattern b) -> (ControlPattern -> Pattern b) -> Pattern (Map String a) -> Pattern (Map String Value) -> Pattern b #
contrastBy
is contrastBy is the general version of contrast
, in which you can specify an abritrary boolean function that will be used to compare the control patterns.
d2 $ contrastBy (>=) (|+ n 12) (|- n 12) (n "2") $ n "0 1 2 [3 4]" # s "superpiano"
contrastRange :: (ControlPattern -> Pattern a) -> (ControlPattern -> Pattern a) -> Pattern (Map String (Value, Value)) -> ControlPattern -> Pattern a #
unfix :: (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern #
fixRange :: (ControlPattern -> Pattern ValueMap) -> Pattern (Map String (Value, Value)) -> ControlPattern -> ControlPattern #
The fixRange
function isn’t very user-friendly at the moment, but you can
create a fix
variant with a range condition. Any value of a ControlPattern
wich matches the values will apply the passed function.
d1 $ ( fixRange ( (# distort 1) . (# gain 0.8) ) ( pure $ Map.singleton "note" ((VN 0, VN 7)) ) ) $ s "superpiano" <| note "1 12 7 11"
unfixRange :: (ControlPattern -> Pattern ValueMap) -> Pattern (Map String (Value, Value)) -> ControlPattern -> ControlPattern #
quantise :: (Functor f, RealFrac b) => b -> f b -> f b #
quantise
limits values in a Pattern (or other Functor) to n
equally spaced
divisions of 1.
It is useful for rounding a collection of numbers to some particular base fraction. For example,
quantise 5 [0, 1.3 ,2.6,3.2,4.7,5]
It will round all the values to the nearest (1/5)=0.2
and thus will output
the list [0.0,1.2,2.6,3.2,4.8,5.0]
. You can use this function to force a
continuous pattern like sine into specific values. In the following example:
d1 $ s "superchip*8" # n (quantise 1 $ range (-10) (10) $ slow 8 $ cosine) # release (quantise 5 $ slow 8 $ sine + 0.1)
all the releases selected be rounded to the nearest 0.1
and the notes selected
to the nearest 1
.
quantise
with fractional inputs does the consistent thing: quantise 0.5
rounds values to the nearest 2
, quantise 0.25
rounds the nearest 4
, etc.
smooth :: Fractional a => Pattern a -> Pattern a #
smooth
receives a pattern of numbers and linearly goes from one to the next, passing through all of them. As time is cycle-based, after reaching the last number in the pattern, it will smoothly go to the first one again.
d1 $ sound "bd*4" # pan (slow 4 $ smooth "0 1 0.5 1")
This sound will pan gradually from left to right, then to the center, then to the right again, and finally comes back to the left.
snowball :: Int -> (Pattern a -> Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
snowball
takes a function that can combine patterns (like +
),
a function that transforms a pattern (like slow
),
a depth, and a starting pattern,
it will then transform the pattern and combine it with the last transformation until the depth is reached.
This is like putting an effect (like a filter) in the feedback of a delay line; each echo is more affected.
d1 $ note ( scale "hexDorian" $ snowball 8 (+) (slow 2 . rev) "0 ~ . -1 . 5 3 4 . ~ -2" ) # s "gtr"
soak :: Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
Applies a function to a pattern and cats the resulting pattern, then continues applying the function until the depth is reached this can be used to create a pattern that wanders away from the original pattern by continually adding random numbers.
d1 $ note ( scale "hexDorian" mutateBy (+ (range -1 1 $ irand 2)) 8 $ "0 1 . 2 3 4" ) # s "gtr"
deconstruct :: Int -> Pattern String -> String #
construct n p
breaks p
into pieces and then reassembles them
so that it fits into n
steps.
bite :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a #
bite n ipat pat
slices a pattern pat
into n
pieces, then uses the
ipat
pattern of integers to index into those slices. So bite 4 "0 2*2" (run
8)
is the same as "[0 1] [4 5]*2"
.
I.e., it allows you to slice each cycle into a given number of equal sized
bits, and then pattern those bits by number. It’s similar to slice
, but is
for slicing up patterns, rather than samples. The following slices the pattern
into four bits, and then plays those bits in turn:
d1 $ bite 4 "0 1 2 3" $ n "0 .. 7" # sound "arpy"
Of course that doesn’t actually change anything, but then you can reorder those bits:
d1 $ bite 4 "2 0 1 3" $ n "0 .. 7" # sound "arpy"
The slices bits of pattern will be squeezed or contracted to fit:
d1 $ bite 4 "2 [0 3] 1*4 1" $ n "0 .. 7" # sound "arpy"
_chew :: Int -> Pattern Int -> ControlPattern -> ControlPattern #
chew :: Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern #
chew
works the same as bite
, but speeds up/slows down playback of sounds as
well as squeezing/contracting the slices of the provided pattern. Compare:
d1 $ 'bite' 4 "0 1*2 2*2 [~ 3]" $ n "0 .. 7" # sound "drum" d1 $ chew 4 "0 1*2 2*2 [~ 3]" $ n "0 .. 7" # sound "drum"
grain :: Pattern Double -> Pattern Double -> ControlPattern #
Given a start point and a duration (both specified in cycles), this generates a control pattern that makes a sound begin at the start point and last the duration.
The following are equivalent:
d1 $ slow 2 $ s "bev" # grain 0.2 0.1 # legato 1 d1 $ slow 2 $ s "bev" # begin 0.2 # end 0.3 # legato 1
grain
is defined as:
grain s d = 'Sound.Tidal.Params.begin' s # 'Sound.Tidal.Params.end' (s+d)
necklace :: Rational -> [Int] -> Pattern Bool #
For specifying a boolean pattern according to a list of offsets
(aka inter-onset intervals). For example necklace 12 [4,2]
is
the same as "t f f f t f t f f f t f". That is, 12 steps per cycle,
with true values alternating between every 4 and every 2 steps.
chromaticiseBy :: (Num a, Enum a, Ord a) => Pattern a -> Pattern a -> Pattern a #
Inserts chromatic notes into a pattern.
The first argument indicates the (patternable) number of notes to insert, and the second argument is the base pattern of "anchor notes" that gets transformed.
The following are equivalent:
d1 $ up (chromaticiseBy "0 1 2 -1" "[0 2] [3 6] [5 6 8] [3 1 0]") # s "superpiano" d1 $ up "[0 2] [[3 4] [6 7]] [[5 6 7] [6 7 8] [8 9 10] [[3 2] [1 0] [0 -1]]" # s "superpiano"
chromaticizeBy :: (Num a, Enum a, Ord a) => Pattern a -> Pattern a -> Pattern a #
Alias for chromaticiseBy
ribbon :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a #
Loops a pattern inside an offset
for cycles
. If you think of the entire
span of time in cycles as a ribbon, you can cut a single piece and loop it.
unjoin :: Pattern Bool -> Pattern b -> Pattern (Pattern b) #
Turns a pattern into a pattern of patterns, according to the structure of another given pattern.
into :: Pattern Bool -> (Pattern a -> Pattern b) -> Pattern a -> Pattern b #
Applies a function to subcycles of a pattern, as defined by the structure of another given pattern.
class Enumerable a where #
Minimal complete definition
Methods
tPatParser :: MyParser (TPat a) #
doEuclid :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a #
getControl :: String -> Pattern a #
AST representation of patterns
Constructors
TPat_Atom :: forall a. Maybe ((Int, Int), (Int, Int)) -> a -> TPat a | |
TPat_Fast :: forall a. TPat Time -> TPat a -> TPat a | |
TPat_Slow :: forall a. TPat Time -> TPat a -> TPat a | |
TPat_DegradeBy :: forall a. Int -> Double -> TPat a -> TPat a | |
TPat_CycleChoose :: forall a. Int -> [TPat a] -> TPat a | |
TPat_Euclid :: forall a. TPat Int -> TPat Int -> TPat Int -> TPat a -> TPat a | |
TPat_Stack :: forall a. [TPat a] -> TPat a | |
TPat_Polyrhythm :: forall a. Maybe (TPat Rational) -> [TPat a] -> TPat a | |
TPat_Seq :: forall a. [TPat a] -> TPat a | |
TPat_Silence :: forall a. TPat a | |
TPat_Foot :: forall a. TPat a | |
TPat_Elongate :: forall a. Rational -> TPat a -> TPat a | |
TPat_Repeat :: forall a. Int -> TPat a -> TPat a | |
TPat_EnumFromTo :: forall a. TPat a -> TPat a -> TPat a | |
TPat_Var :: forall a. String -> TPat a | |
TPat_Chord :: forall b a. (Num b, Enum b, Parseable b, Enumerable b) => (b -> a) -> TPat b -> TPat String -> [TPat [Modifier]] -> TPat a |
data TidalParseError #
Constructors
TidalParseError | |
Fields
|
Instances
Exception TidalParseError | |
Defined in Sound.Tidal.ParseBP Methods toException :: TidalParseError -> SomeException # | |
Show TidalParseError | |
Defined in Sound.Tidal.ParseBP Methods showsPrec :: Int -> TidalParseError -> ShowS # show :: TidalParseError -> String # showList :: [TidalParseError] -> ShowS # | |
Eq TidalParseError | |
Defined in Sound.Tidal.ParseBP Methods (==) :: TidalParseError -> TidalParseError -> Bool # (/=) :: TidalParseError -> TidalParseError -> Bool # |
resolve_tpat :: (Enumerable a, Parseable a) => TPat a -> (Rational, Pattern a) #
resolve_seq :: (Enumerable a, Parseable a) => [TPat a] -> (Rational, Pattern a) #
resolve_size :: [TPat a] -> [(Rational, TPat a)] #
parseBP :: (Enumerable a, Parseable a) => String -> Either ParseError (Pattern a) #
parseRest :: Parseable a => MyParser (TPat a) #
a -
is a negative sign if followed anything but another dash
otherwise, it's treated as rest
enumFromTo' :: (Ord a, Enum a) => a -> a -> Pattern a #
lexer :: GenTokenParser String u Identity #
pSequence :: Parseable a => MyParser (TPat a) -> MyParser (TPat a) #
Try different parsers on a sequence of Tidal patterns
f
is the sequence so far, a
the next upcoming token/non-terminal
pNoteWithoutChord :: MyParser (TPat Note) #
parseIntNote :: Integral i => MyParser i #
pIntegralWithoutChord :: (Integral a, Parseable a, Enumerable a) => MyParser (TPat a) #
parseChord :: (Enum a, Num a) => MyParser [a] #
pRatioChar :: Fractional a => MyParser a #
pRatioSingleChar :: Fractional a => Char -> a -> MyParser a #
parseModInvNum :: MyParser [Modifier] #
parseModDrop :: MyParser [Modifier] #
parseModifiers :: MyParser [Modifier] #
pModifiers :: MyParser (TPat [Modifier]) #
spin :: Pattern Int -> ControlPattern -> ControlPattern #
spin
will "spin" and layer up a pattern the given number of times,
with each successive layer offset in time by an additional 1/n
of a cycle,
and panned by an additional 1/n
. The result is a pattern that seems to spin
around. This function work well on multichannel systems.
d1 $ slow 3 $ spin 4 $ sound "drum*3 tabla:4 [arpy:2 ~ arpy] [can:2 can:3]"
_spin :: Int -> ControlPattern -> ControlPattern #
chop :: Pattern Int -> ControlPattern -> ControlPattern #
chop
granularises every sample in place as it is played, turning a
pattern of samples into a pattern of sample parts. Can be used to explore
granular synthesis.
Use an integer value to specify how many granules each sample is chopped into:
d1 $ chop 16 $ sound "arpy arp feel*4 arpy*4"
Different values of chop
can yield very different results, depending on the
samples used:
d1 $ chop 16 $ sound (samples "arpy*8" (run 16)) d1 $ chop 32 $ sound (samples "arpy*8" (run 16)) d1 $ chop 256 $ sound "bd*4 [sn cp] [hh future]*2 [cp feel]"
You can also use chop
(or striate
) with very long samples to cut them into short
chunks and pattern those chunks. The following cuts a sample into 32 parts, and
plays it over 8 cycles:
d1 $ loopAt 8 $ chop 32 $ sound "bev"
The loopAt
takes care of changing the speed of sample playback so that the
sample fits in the given number of cycles perfectly. As a result, in the above
the granules line up perfectly, so you can’t really hear that the sample has
been cut into bits. Again, this becomes more apparent when you do further
manipulations of the pattern, for example rev
to reverse the order of the cut
up bits:
d1 $ loopAt 8 $ rev $ chop 32 $ sound "bev"
_chop :: Int -> ControlPattern -> ControlPattern #
striate :: Pattern Int -> ControlPattern -> ControlPattern #
Striate is a kind of granulator, cutting samples into bits in a similar to chop, but the resulting bits are organised differently. For example:
d1 $ striate 3 $ sound "ho ho:2 ho:3 hc"
This plays the loop the given number of times, but triggers progressive portions
of each sample. So in this case it plays the loop three times, the first
time playing the first third of each sample, then the second time playing the
second third of each sample, and lastly playing the last third of each sample.
Replacing striate
with chop
above, one can hear that the 'chop
version
plays the bits from each chopped-up sample in turn, while striate
"interlaces"
the cut up bits of samples together.
You can also use striate
with very long samples, to cut them into short
chunks and pattern those chunks. This is where things get towards granular
synthesis. The following cuts a sample into 128 parts, plays it over 8 cycles
and manipulates those parts by reversing and rotating the loops:
d1 $ slow 8 $ striate 128 $ sound "bev"
_striate :: Int -> ControlPattern -> ControlPattern #
striateBy :: Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern #
The striateBy
function is a variant of striate
with an extra
parameter which specifies the length of each part. The striateBy
function still scans across the sample over a single cycle, but if
each bit is longer, it creates a sort of stuttering effect. For
example the following will cut the bev
sample into 32 parts, but each
will be 1/16th of a sample long:
d1 $ slow 32 $ striateBy 32 (1/16) $ sound "bev"
Note that striate
and striateBy
use the begin
and end
parameters
internally. This means that you probably shouldn't also specify begin
or
end
.
striate' :: Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern #
DEPRECATED, use striateBy
instead.
_striateBy :: Int -> Double -> ControlPattern -> ControlPattern #
gap :: Pattern Int -> ControlPattern -> ControlPattern #
_gap :: Int -> ControlPattern -> ControlPattern #
weave :: Time -> ControlPattern -> [ControlPattern] -> ControlPattern #
weave
applies one control pattern to a list of other control patterns, with
a successive time offset. It uses an OscPattern
to apply the function at
different levels to each pattern, creating a weaving effect. For example:
d1 $ weave 16 (pan sine) [ sound "bd sn cp" , sound "casio casio:1" , sound "[jvbass*2 jvbass:2]/2" , sound "hc*4" ]
In the above, the pan sine
control pattern is slowed down by the given
number of cycles, in particular 16, and applied to all of the given sound
patterns. What makes this interesting is that the pan
control pattern is
successively offset for each of the given sound patterns; because the pan
is
closed down by 16 cycles, and there are four patterns, they are ‘spread out’,
i.e. with a gap of four cycles. For this reason, the four patterns seem to
chase after each other around the stereo field. Try listening on headphones to
hear this more clearly.
You can even have it the other way round, and have the effect parameters chasing after each other around a sound parameter, like this:
d1 $ weave 16 (sound "arpy" >| n (run 8)) [ vowel "a e i" , vowel "i [i o] o u" , vowel "[e o]/3 [i o u]/2" , speed "1 2 3" ]
weaveWith :: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a #
weaveWith
is similar to the above, but weaves with a list of functions, rather
than a list of controls. For example:
d1 $ weaveWith 3 (sound "bd [sn drum:2*2] bd*2 [sn drum:1]") [ fast 2 , (# speed "0.5") , chop 16 ]
interlace :: ControlPattern -> ControlPattern -> ControlPattern #
(A function that takes two ControlPatterns, and blends them together into a new ControlPattern. An ControlPattern is basically a pattern of messages to a synthesiser.)
Shifts between the two given patterns, using distortion.
Example:
d1 $ interlace (sound "bd sn kurt") (every 3 rev $ sound "bd sn:2")
slice :: Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern #
slice
is similar to chop
and striate
, in that it’s used to slice
samples up into bits. The difference is that it allows you to rearrange those
bits as a pattern.
d1 $ slice 8 "7 6 5 4 3 2 1 0" $ sound "breaks165" # legato 1
The above slices the sample into eight bits, and then plays them backwards, equivalent of applying rev $ chop 8. Here’s a more complex example:
d1 $ slice 8 "[<0*8 0*2> 3*4 2 4] [4 .. 7]" $ sound "breaks165" # legato 1
_slice :: Int -> Int -> ControlPattern -> ControlPattern #
randslice :: Pattern Int -> ControlPattern -> ControlPattern #
randslice
chops the sample into the given number of pieces and then plays back
a random one each cycle:
d1 $ randslice 32 $ sound "bev"
Use fast
to get more than one per cycle:
d1 $ fast 4 $ randslice 32 $ sound "bev"
splice :: Pattern Int -> Pattern Int -> ControlPattern -> Pattern (Map String Value) #
splice
is similar to slice
, but the slices are automatically pitched up or down
to fit their ‘slot’.
d1 $ splice 8 "[<0*8 0*2> 3*4 2 4] [4 .. 7]" $ sound "breaks165"
loopAt :: Pattern Time -> ControlPattern -> ControlPattern #
loopAt
makes a sample fit the given number of cycles. Internally, it
works by setting the unit
parameter to "c"
, changing the playback
speed of the sample with the speed
parameter, and setting setting
the density
of the pattern to match.
d1 $ loopAt 4 $ sound "breaks125"
It’s a good idea to use this in conjuction with chop
, so the break is chopped
into pieces and you don’t have to wait for the whole sample to start/stop.
d1 $ loopAt 4 $ chop 32 $ sound "breaks125"
Like all Tidal functions, you can mess about with this considerably. The below
example shows how you can supply a pattern of cycle counts to loopAt
:
d1 $ juxBy 0.6 (|* speed "2") $ slowspread (loopAt) [4,6,2,3] $ chop 12 $ sound "fm:14"
hurry :: Pattern Rational -> ControlPattern -> ControlPattern #
hurry
is similiar to fast
in that it speeds up a pattern, but it also
increases the speed control by the same factor. So, if you’re triggering
samples, the sound gets higher in pitch. For example:
d1 $ every 2 (hurry 2) $ sound "bd sn:2 ~ cp"
smash :: Pattern Int -> [Pattern Time] -> ControlPattern -> Pattern ValueMap #
smash
is a combination of spread
and striate
— it cuts the samples
into the given number of bits, and then cuts between playing the loop
at different speeds according to the values in the list. So this:
d1 $ smash 3 [2,3,4] $ sound "ho ho:2 ho:3 hc"
is a bit like this:
d1 $ spread (slow) [2,3,4] $ striate 3 $ sound "ho ho:2 ho:3 hc"
This is quite dancehall:
d1 $ ( spread' slow "1%4 2 1 3" $ spread (striate) [2,3,4,1] $ sound "sn:2 sid:3 cp sid:4" ) # speed "[1 2 1 1]/2"
smash' :: Int -> [Pattern Time] -> ControlPattern -> ControlPattern #
_echo :: Integer -> Rational -> Double -> ControlPattern -> ControlPattern #
echoWith :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
echoWith
is similar to echo
, but instead of just decreasing volume to
produce echoes, echoWith
applies a function each step and overlays the
result delayed by the given time.
d1 $ echoWith 2 "1%3" (# vowel "{a e i o u}%2") $ sound "bd sn"
In this case there are two _overlays_ delayed by 1/3 of a cycle, where each
has the vowel
filter applied.
d1 $ echoWith 4 (1/6) (|* speed "1.5") $ sound "arpy arpy:2"
In the above, three versions are put on top, with each step getting higher in
pitch as |* speed "1.5"
is successively applied.
stut :: Pattern Integer -> Pattern Double -> Pattern Rational -> ControlPattern -> ControlPattern #
DEPRECATED, use echo
instead
_stut :: Integer -> Double -> Rational -> ControlPattern -> ControlPattern #
stutWith :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
DEPRECATED, use echoWith
instead
stut' :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a #
DEPRECATED, use echoWith
instead
msec :: Fractional a => Pattern a -> Pattern a #
Turns a pattern of milliseconds into a pattern of (rational) cycle durations, according to the current cps.
trigger :: Pattern a -> Pattern a #
Align the start of a pattern with the time a pattern is evaluated, rather than the global start time. Because of this, the pattern will probably not be aligned to the pattern grid.
qtrigger :: Pattern a -> Pattern a #
(Alias qt
) Quantise trigger. Aligns the start of the pattern
with the next cycle boundary. For example, this pattern will fade in
starting with the next cycle after the pattern is evaluated:
d1 $ qtrigger $ s "hh(5, 8)" # amp envL
Note that the pattern will start playing immediately. The start of the pattern aligns with the next cycle boundary, but events will play before if the pattern has events at negative timestamps (which most loops do). These events can be filtered out, for example:
d1 $ qtrigger $ filterWhen (>= 0) $ s "hh(5, 8)"
Alternatively, you can use wait
to achieve the same result:
wait 1 1 $ s "bd hh hh hh"
ctrigger :: Pattern a -> Pattern a #
Ceiling trigger. Aligns the start of a pattern to the next cycle
boundary, just like qtrigger
.
rtrigger :: Pattern a -> Pattern a #
Rounded trigger. Aligns the start of a pattern to the nearest cycle boundary, either next or previous.
ftrigger :: Pattern a -> Pattern a #
Floor trigger. Aligns the start of a pattern to the previous cycle boundary.
mtrigger :: Int -> Pattern a -> Pattern a #
(Alias mt
) Mod trigger. Aligns the start of a pattern to the
next cycle boundary where the cycle is evenly divisible by a given
number. qtrigger
is equivalent to mtrigger 1
.
In the following example, when activating the d1
pattern, it will start at the
same time as the next clap, even if it has to wait for 3 cycles. Once activated,
the arpy
sound will play on every cycle, just like any other pattern:
do resetCycles d2 $ every 4 (# s "clap") $ s "bd"
d1 $ mtrigger 4 $ filterWhen (>=0) $ s "arpy"
triggerWith :: (Time -> Time) -> Pattern a -> Pattern a #
This aligns the start of a pattern to some value relative to the
time the pattern is evaluated. The provided function maps the evaluation
time (on the global cycle clock) to a new time, and then triggerWith
aligns the pattern's start to the time that's returned.
This is a more flexible triggering function. In fact, all the other trigger
functions are defined based on triggerWith
. For example, trigger
is just
triggerWith id
.
In the next example, use d1
as a metronome, and play with different values
(from 0 to 1) on the const
expression. You’ll notice how the clap
is
displaced from the beginning of each cycle to the end, as the number increases:
d1 $ s "bd hh!3" d2 $ triggerWith (const 0.1) $ s "clap"
This last example is equivalent to this:
d2 $ rotR 0.1 $ s "clap"
splat :: Pattern Int -> ControlPattern -> ControlPattern -> ControlPattern #
crunch :: ControlPattern -> ControlPattern #
scratch :: ControlPattern -> ControlPattern #
louder :: ControlPattern -> ControlPattern #
quieter :: ControlPattern -> ControlPattern #
silent :: ControlPattern -> ControlPattern #
higher :: ControlPattern -> ControlPattern #
faster :: ControlPattern -> ControlPattern #
slower :: ControlPattern -> ControlPattern #
Constructors
Config | |
Fields
|
streamReplace :: Stream -> ID -> ControlPattern -> IO () Source #
streamHush :: Stream -> IO () Source #
streamOnce :: Stream -> ControlPattern -> IO () Source #
streamFirst :: Stream -> ControlPattern -> IO () Source #
streamAll :: Stream -> (ControlPattern -> ControlPattern) -> IO () Source #
streamResetCycles :: Stream -> IO () Source #
transition :: Stream -> Bool -> TransitionMapper -> ID -> ControlPattern -> IO () Source #
Constructors
Target | |
toClockConfig :: Config -> ClockConfig Source #
doTick :: MVar ValueMap -> MVar PlayMap -> MVar (ControlPattern -> ControlPattern) -> [Cx] -> (Time, Time) -> Double -> ClockConfig -> ClockRef -> (SessionState, SessionState) -> IO () Source #
Query the current pattern (contained in argument stream :: Stream
)
for the events in the current arc (contained in argument st :: T.State
),
translate them to OSC messages, and send these.
If an exception occurs during sending, this functions prints a warning and continues, because the likely reason is that the backend (supercollider) isn't running.
If any exception occurs before or outside sending (e.g., while querying the pattern, while computing a message), this function prints a warning and resets the current pattern to the previous one (or to silence if there isn't one) and continues, because the likely reason is that something is wrong with the current pattern.
superdirtShape :: OSC Source #
Constructors
PlayState | |
Fields
|
data StampStyle Source #
Constructors
BundleStamp | |
MessageStamp |
Instances
Show StampStyle Source # | |
Defined in Sound.Tidal.Stream.Types Methods showsPrec :: Int -> StampStyle -> ShowS # show :: StampStyle -> String # showList :: [StampStyle] -> ShowS # | |
Eq StampStyle Source # | |
Defined in Sound.Tidal.Stream.Types |
dirtTarget :: Target Source #
data ProcessedEvent Source #
Constructors
ProcessedEvent | |
Fields
|
playStack :: PlayMap -> ControlPattern Source #
processCps :: ClockConfig -> ClockRef -> (SessionState, SessionState) -> [Event ValueMap] -> IO [ProcessedEvent] Source #
onSingleTick :: ClockConfig -> ClockRef -> MVar ValueMap -> MVar PlayMap -> MVar (ControlPattern -> ControlPattern) -> [Cx] -> ControlPattern -> IO () Source #
updatePattern :: Stream -> ID -> Time -> ControlPattern -> IO () Source #
streamEnableLink :: Stream -> IO () Source #
streamDisableLink :: Stream -> IO () Source #
streamMuteAll :: Stream -> IO () Source #
streamUnmuteAll :: Stream -> IO () Source #
streamUnsoloAll :: Stream -> IO () Source #
type TransitionMapper = Time -> [ControlPattern] -> ControlPattern Source #
_wash :: (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Time -> Time -> Time -> Time -> [Pattern a] -> Pattern a Source #
Washes away the current pattern after a certain delay by applying a function to it over time, then switching over to the next pattern to which another function is applied.
_xfadeIn :: Time -> Time -> [ControlPattern] -> ControlPattern Source #
_histpan :: Int -> Time -> [ControlPattern] -> ControlPattern Source #
Pans the last n versions of the pattern across the field
_wait :: Time -> Time -> [ControlPattern] -> ControlPattern Source #
Just stop for a bit before playing new pattern
_waitT :: (Time -> [ControlPattern] -> ControlPattern) -> Time -> Time -> [ControlPattern] -> ControlPattern Source #
_jump :: Time -> [ControlPattern] -> ControlPattern Source #
Jumps directly into the given pattern, this is essentially the _no transition_-transition.
Variants of jump
provide more useful capabilities, see jumpIn
and jumpMod
_jumpIn :: Int -> Time -> [ControlPattern] -> ControlPattern Source #
Sharp jump
transition after the specified number of cycles have passed.
t1 (jumpIn 2) $ sound "kick(3,8)"
_jumpIn' :: Int -> Time -> [ControlPattern] -> ControlPattern Source #
_jumpMod :: Int -> Time -> [ControlPattern] -> ControlPattern Source #
Sharp jump
transition at next cycle boundary where cycle mod n == 0
_jumpMod' :: Int -> Int -> Time -> [ControlPattern] -> ControlPattern Source #
Sharp jump
transition at next cycle boundary where cycle mod n == p
_mortal :: Time -> Time -> Time -> [ControlPattern] -> ControlPattern Source #
Degrade the new pattern over time until it ends in silence
_interpolate :: Time -> [ControlPattern] -> ControlPattern Source #
_interpolateIn :: Time -> Time -> [ControlPattern] -> ControlPattern Source #
_clutch :: Time -> [Pattern a] -> Pattern a Source #
Degrades the current pattern while undegrading the next.
This is like xfade
but not by gain of samples but by randomly removing events from the current pattern and slowly adding back in missing events from the next one.
d1 $ sound "bd(3,8)" t1 clutch $ sound "[hh*4, odx(3,8)]"
clutch
takes two cycles for the transition, essentially this is clutchIn 2
.
_clutchIn :: Time -> Time -> [Pattern a] -> Pattern a Source #
Also degrades the current pattern and undegrades the next.
To change the number of cycles the transition takes, you can use clutchIn
like so:
d1 $ sound "bd(5,8)" t1 (clutchIn 8) $ sound "[hh*4, odx(3,8)]"
will take 8 cycles for the transition.
_anticipateIn :: Time -> Time -> [ControlPattern] -> ControlPattern Source #
same as anticipate
though it allows you to specify the number of cycles until dropping to the new pattern, e.g.:
d1 $ sound "jvbass(3,8)" t1 (anticipateIn 4) $ sound "jvbass(5,8)"
_anticipate :: Time -> [ControlPattern] -> ControlPattern Source #
anticipate
is an increasing comb filter.
Build up some tension, culminating in a _drop_ to the new pattern after 8 cycles.
tidal_status :: IO () Source #
waitT :: Tidally => ID -> (Time -> [ControlPattern] -> ControlPattern) -> Time -> ControlPattern -> IO () Source #
interpolate :: Tidally => ID -> ControlPattern -> IO () Source #
interpolateIn :: Tidally => ID -> Time -> ControlPattern -> IO () Source #
anticipate :: Tidally => ID -> ControlPattern -> IO () Source #
anticipateIn :: Tidally => ID -> Time -> ControlPattern -> IO () Source #