-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Pattern language for improvised music
--
-- Tidal is a domain specific language for live coding patterns.
@package tidal
@version 1.9.5
module Paths_tidal
version :: Version
getBinDir :: IO FilePath
getLibDir :: IO FilePath
getDynLibDir :: IO FilePath
getDataDir :: IO FilePath
getLibexecDir :: IO FilePath
getDataFileName :: FilePath -> IO FilePath
getSysconfDir :: IO FilePath
module Sound.Tidal.Bjorklund
bjorklund :: (Int, Int) -> [Bool]
module Sound.Tidal.Config
data Config
Config :: Bool -> String -> Int -> Bool -> Double -> Bool -> Double -> String -> Int -> Int -> Int64 -> Bool -> CDouble -> CDouble -> Config
[cCtrlListen] :: Config -> Bool
[cCtrlAddr] :: Config -> String
[cCtrlPort] :: Config -> Int
[cCtrlBroadcast] :: Config -> Bool
[cFrameTimespan] :: Config -> Double
[cEnableLink] :: Config -> Bool
[cProcessAhead] :: Config -> Double
[cTempoAddr] :: Config -> String
[cTempoPort] :: Config -> Int
[cTempoClientPort] :: Config -> Int
[cSkipTicks] :: Config -> Int64
[cVerbose] :: Config -> Bool
[cQuantum] :: Config -> CDouble
[cBeatsPerCycle] :: Config -> CDouble
defaultConfig :: Config
module Sound.Tidal.ID
-- | Wrapper for literals that can be coerced to a string and used as an
-- identifier. | Similar to Show typeclass, but constrained to strings
-- and integers and designed | so that similar cases (such as 1 and "1")
-- convert to the same value.
newtype ID
ID :: String -> ID
[fromID] :: ID -> String
instance GHC.Read.Read Sound.Tidal.ID.ID
instance GHC.Classes.Ord Sound.Tidal.ID.ID
instance GHC.Show.Show Sound.Tidal.ID.ID
instance GHC.Classes.Eq Sound.Tidal.ID.ID
instance GHC.Num.Num Sound.Tidal.ID.ID
instance Data.String.IsString Sound.Tidal.ID.ID
module Sound.Tidal.Time
-- | Time is rational
type Time = Rational
-- | An arc of time, with a start time (or onset) and a stop time (or
-- offset)
data ArcF a
Arc :: a -> a -> ArcF a
[start] :: ArcF a -> a
[stop] :: ArcF a -> a
type Arc = ArcF Time
-- | The sam (start of cycle) for the given time value. Cycles
-- have duration 1, so every integer Time value divides two cycles.
sam :: Time -> Time
-- | Turns a number into a (rational) time value. An alias for
-- toRational.
toTime :: Real a => a -> Rational
-- | Turns a (rational) time value into another number. An alias for
-- fromRational.
fromTime :: Fractional a => Time -> a
-- | The end point of the current cycle (and starting point of the next
-- cycle)
nextSam :: Time -> Time
-- | The position of a time value relative to the start of its cycle.
cyclePos :: Time -> Time
-- | convex hull union
hull :: Arc -> Arc -> 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.
subArc :: Arc -> Arc -> Maybe Arc
subMaybeArc :: Maybe Arc -> Maybe Arc -> Maybe (Maybe Arc)
-- | Simple intersection of two arcs
sect :: Arc -> Arc -> 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.
timeToCycleArc :: Time -> Arc
-- | 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.)
cycleArc :: Arc -> Arc
-- | 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.
cyclesInArc :: Integral a => Arc -> [a]
-- | This provides exactly the same information as cyclesInArc,
-- except that this represents its output as Arcs, 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.)
cycleArcsInArc :: Arc -> [Arc]
-- | Splits the given Arc into a list of Arcs, at cycle
-- boundaries.
arcCycles :: Arc -> [Arc]
-- | Like arcCycles, but returns zero-width arcs
arcCyclesZW :: Arc -> [Arc]
-- | Similar to fmap but time is relative to the cycle (i.e. the
-- sam of the start of the arc)
mapCycle :: (Time -> Time) -> Arc -> Arc
-- | isIn a t is True if t is inside the arc
-- represented by a.
isIn :: Arc -> Time -> Bool
instance GHC.Generics.Generic (Sound.Tidal.Time.ArcF a)
instance GHC.Show.Show a => GHC.Show.Show (Sound.Tidal.Time.ArcF a)
instance GHC.Base.Functor Sound.Tidal.Time.ArcF
instance GHC.Classes.Ord a => GHC.Classes.Ord (Sound.Tidal.Time.ArcF a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Sound.Tidal.Time.ArcF a)
instance GHC.Base.Applicative Sound.Tidal.Time.ArcF
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Sound.Tidal.Time.ArcF a)
instance GHC.Num.Num a => GHC.Num.Num (Sound.Tidal.Time.ArcF a)
instance GHC.Real.Fractional a => GHC.Real.Fractional (Sound.Tidal.Time.ArcF a)
module Sound.Tidal.Pattern
type Event a = EventF (ArcF Time) a
-- | an Arc and some named control values
data State
State :: Arc -> ValueMap -> State
[arc] :: State -> Arc
[controls] :: State -> ValueMap
-- | A datatype representing events taking place over time
data Pattern a
Pattern :: (State -> [Event a]) -> Pattern a
[query] :: Pattern a -> State -> [Event a]
-- | Some context for an event, currently just position within sourcecode
data Context
Context :: [((Int, Int), (Int, Int))] -> Context
[contextPosition] :: Context -> [((Int, Int), (Int, Int))]
type ControlPattern = Pattern ValueMap
type ValueMap = Map String Value
class Moddable a
gmod :: Moddable a => a -> a -> a
-- | Note is Double, but with a different parser
newtype Note
Note :: Double -> Note
[unNote] :: Note -> Double
-- | Polymorphic values
data Value
VS :: String -> Value
[svalue] :: Value -> String
VF :: Double -> Value
[fvalue] :: Value -> Double
VN :: Note -> Value
[nvalue] :: Value -> Note
VR :: Rational -> Value
[rvalue] :: Value -> Rational
VI :: Int -> Value
[ivalue] :: Value -> Int
VB :: Bool -> Value
[bvalue] :: Value -> Bool
VX :: [Word8] -> Value
[xvalue] :: Value -> [Word8]
VPattern :: Pattern Value -> Value
[pvalue] :: Value -> Pattern Value
VList :: [Value] -> Value
[lvalue] :: Value -> [Value]
VState :: (ValueMap -> (ValueMap, Value)) -> Value
[statevalue] :: Value -> ValueMap -> (ValueMap, Value)
class Stringy a
deltaContext :: Stringy a => Int -> Int -> a -> a
-- | 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.
data EventF a b
Event :: Context -> Maybe a -> a -> b -> EventF a b
[context] :: EventF a b -> Context
[whole] :: EventF a b -> Maybe a
[part] :: EventF a b -> a
[value] :: EventF a b -> b
class Valuable a
toValue :: Valuable a => a -> Value
-- | Like *, but the "wholes" come from the right
(*>) :: Pattern (a -> b) -> Pattern a -> Pattern b
infixl 4 *>
empty :: Pattern a
-- | Like *, but the "wholes" come from the left
(<*) :: Pattern (a -> b) -> Pattern a -> Pattern b
infixl 4 <*
reset :: Pattern Bool -> Pattern a -> Pattern a
silence :: 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"
--
rev :: Pattern a -> Pattern a
-- |
-- - Patterns as numbers
--
noOv :: String -> a
applyPatToPatBoth :: Pattern (a -> b) -> Pattern a -> Pattern b
applyPatToPatLeft :: Pattern (a -> b) -> Pattern a -> Pattern b
applyPatToPatRight :: Pattern (a -> b) -> Pattern a -> Pattern b
-- | Like *, but the "wholes" come from the left
(<<*) :: Pattern (a -> b) -> Pattern a -> Pattern b
infixl 4 <<*
applyPatToPatSqueeze :: Pattern (a -> b) -> Pattern a -> Pattern b
applyPatToPat :: (Maybe Arc -> Maybe Arc -> Maybe (Maybe Arc)) -> Pattern (a -> b) -> Pattern a -> Pattern b
wholeOrPart :: Event a -> Arc
filterAnalog :: Pattern a -> Pattern a
filterDigital :: Pattern a -> Pattern a
combineContexts :: [Context] -> Context
-- | 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?
squeezeJoin :: 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?
unwrap :: Pattern (Pattern a) -> Pattern a
-- | Turns a pattern of patterns into a single pattern. Like
-- unwrap, but structure only comes from the inner pattern.
innerJoin :: Pattern (Pattern a) -> Pattern a
-- | Turns a pattern of patterns into a single pattern. Like
-- unwrap, but structure only comes from the outer pattern.
outerJoin :: Pattern (Pattern a) -> Pattern a
focusArc :: Arc -> Pattern a -> Pattern a
_trigJoin :: Bool -> Pattern (Pattern a) -> Pattern a
-- | Shifts a pattern forward in time by the given amount, expressed in
-- cycles. Opposite of rotL.
rotR :: Time -> Pattern a -> Pattern a
trigJoin :: Pattern (Pattern a) -> Pattern a
trigZeroJoin :: Pattern (Pattern a) -> Pattern a
resetTo :: Pattern Rational -> 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.
rotL :: Time -> Pattern a -> Pattern a
restart :: Pattern Bool -> Pattern a -> Pattern a
restartTo :: Pattern Rational -> Pattern a -> Pattern a
-- | General utilities..
--
-- Apply one of three functions to a Value, depending on its type
applyFIS :: (Double -> Double) -> (Int -> Int) -> (String -> String) -> Value -> Value
-- | Apply one of two functions to a pair of Values, depending on their
-- types (int or float; strings and rationals are ignored)
fNum2 :: (Int -> Int -> Int) -> (Double -> Double -> Double) -> Value -> Value -> Value
queryArc :: Pattern a -> Arc -> [Event 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.
splitQueries :: Pattern a -> Pattern a
-- | Apply a function to the arcs/timespans (both whole and parts) of the
-- result
withResultArc :: (Arc -> Arc) -> 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
withResultTime :: (Time -> Time) -> Pattern a -> Pattern a
-- | Apply a function to the timespan of the query
withQueryArc :: (Arc -> Arc) -> Pattern a -> Pattern a
-- | Apply a function to the time (both start and end) of the query
withQueryTime :: (Time -> Time) -> Pattern a -> Pattern a
-- | Apply a function to the control values of the query
withQueryControls :: (ValueMap -> ValueMap) -> Pattern a -> Pattern a
-- | withEvent f p returns a new Pattern with each event
-- mapped over function f.
withEvent :: (Event a -> Event b) -> Pattern a -> Pattern b
-- | withEvent f p returns a new Pattern with each value
-- mapped over function f.
withValue :: (a -> 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.
withEvents :: ([Event a] -> [Event b]) -> Pattern a -> Pattern b
-- | withPart f p returns a new Pattern with function
-- f applied to the part.
withPart :: (Arc -> Arc) -> Pattern a -> Pattern a
_extract :: (Value -> Maybe a) -> String -> ControlPattern -> Pattern a
-- | Turns a pattern of Maybe values into a pattern of values,
-- dropping the events of Nothing.
filterJust :: Pattern (Maybe a) -> Pattern a
-- | Extract a pattern of integer values by from a control pattern, given
-- the name of the control
extractI :: String -> ControlPattern -> Pattern Int
getI :: Value -> Maybe Int
-- | Extract a pattern of floating point values by from a control pattern,
-- given the name of the control
extractF :: String -> ControlPattern -> Pattern Double
getF :: Value -> Maybe Double
-- | Extract a pattern of string values by from a control pattern, given
-- the name of the control
extractS :: String -> ControlPattern -> Pattern String
getS :: Value -> Maybe String
-- | Extract a pattern of boolean values by from a control pattern, given
-- the name of the control
extractB :: String -> ControlPattern -> Pattern Bool
getB :: Value -> Maybe Bool
-- | Extract a pattern of rational values by from a control pattern, given
-- the name of the control
extractR :: String -> ControlPattern -> Pattern Rational
getR :: Value -> Maybe Rational
-- | Extract a pattern of note values by from a control pattern, given the
-- name of the control
extractN :: String -> ControlPattern -> Pattern Note
getN :: Value -> Maybe Note
compressArc :: Arc -> Pattern a -> Pattern a
_fastGap :: Time -> Pattern a -> Pattern a
compressArcTo :: Arc -> Pattern a -> Pattern a
_fast :: 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"
--
fast :: Pattern Time -> Pattern a -> Pattern a
tParam :: (t1 -> t2 -> Pattern a) -> Pattern t1 -> t2 -> 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:
--
--
-- >>> print $ 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"
--
fastSqueeze :: Pattern Time -> Pattern a -> Pattern a
tParamSqueeze :: (a -> Pattern b -> Pattern c) -> Pattern a -> Pattern b -> Pattern c
-- | An alias for fast
density :: 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")
--
slow :: Pattern Time -> Pattern a -> Pattern a
_slow :: Time -> Pattern a -> Pattern a
-- | Mark values in the first pattern which match with at least one value
-- in the second pattern.
matchManyToOne :: (b -> a -> Bool) -> Pattern a -> Pattern b -> Pattern (Bool, b)
-- | Remove events from patterns that to not meet the given test
filterValues :: (a -> Bool) -> Pattern a -> Pattern a
filterWhen :: (Time -> Bool) -> Pattern a -> Pattern a
-- | Get the onset of an event's whole
wholeStart :: Event a -> Time
filterOnsets :: Pattern a -> Pattern a
-- | Get the onset of an event's whole
eventPartStart :: Event a -> Time
filterEvents :: (Event a -> Bool) -> Pattern a -> Pattern a
isDigital :: Event a -> Bool
isAnalog :: Event a -> Bool
playFor :: Time -> Time -> Pattern a -> Pattern a
tParam2 :: (a -> b -> c -> Pattern d) -> Pattern a -> Pattern b -> c -> Pattern d
tParam3 :: (a -> b -> c -> Pattern d -> Pattern e) -> Pattern a -> Pattern b -> Pattern c -> Pattern d -> Pattern e
setContext :: Context -> Pattern a -> Pattern a
withContext :: (Context -> Context) -> Pattern a -> Pattern a
deltaMini :: String -> String
-- | True if an EventF's starts is within given ArcF
onsetIn :: Arc -> Event a -> Bool
-- | Returns a list of events, with any adjacent parts of the same whole
-- combined
defragParts :: Eq a => [Event a] -> [Event a]
-- | Returns True if the two given events are adjacent parts of the
-- same whole
isAdjacent :: Eq a => Event a -> Event a -> Bool
-- | Get the offset of an event's whole
wholeStop :: Event a -> Time
-- | Get the offset of an event's part
eventPartStop :: Event a -> Time
-- | Get the timespan of an event's part
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])
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]]
-- | collects all events satisfying the same constraint into a list
collectBy :: Eq a => (Event a -> Event a -> Bool) -> Pattern a -> Pattern [a]
-- | collects all events occuring at the exact same time into a list
collect :: Eq a => Pattern a -> Pattern [a]
uncollectEvent :: Event [a] -> [Event a]
uncollectEvents :: [Event [a]] -> [Event a]
-- | merges all values in a list into one pattern by stacking the values
uncollect :: Pattern [a] -> Pattern a
instance GHC.Generics.Generic Sound.Tidal.Pattern.Context
instance GHC.Classes.Ord Sound.Tidal.Pattern.Context
instance GHC.Classes.Eq Sound.Tidal.Pattern.Context
instance GHC.Generics.Generic (Sound.Tidal.Pattern.EventF a b)
instance GHC.Base.Functor (Sound.Tidal.Pattern.EventF a)
instance (GHC.Classes.Ord a, GHC.Classes.Ord b) => GHC.Classes.Ord (Sound.Tidal.Pattern.EventF a b)
instance (GHC.Classes.Eq a, GHC.Classes.Eq b) => GHC.Classes.Eq (Sound.Tidal.Pattern.EventF a b)
instance GHC.Real.RealFrac Sound.Tidal.Pattern.Note
instance GHC.Real.Real Sound.Tidal.Pattern.Note
instance GHC.Float.Floating Sound.Tidal.Pattern.Note
instance GHC.Real.Fractional Sound.Tidal.Pattern.Note
instance GHC.Num.Num Sound.Tidal.Pattern.Note
instance GHC.Enum.Enum Sound.Tidal.Pattern.Note
instance GHC.Classes.Ord Sound.Tidal.Pattern.Note
instance GHC.Classes.Eq Sound.Tidal.Pattern.Note
instance GHC.Generics.Generic Sound.Tidal.Pattern.Note
instance Data.Data.Data Sound.Tidal.Pattern.Note
instance GHC.Base.Functor Sound.Tidal.Pattern.Pattern
instance GHC.Generics.Generic (Sound.Tidal.Pattern.Pattern a)
instance GHC.Generics.Generic Sound.Tidal.Pattern.Value
instance Sound.Tidal.Pattern.Valuable GHC.Base.String
instance Sound.Tidal.Pattern.Valuable GHC.Types.Double
instance Sound.Tidal.Pattern.Valuable GHC.Real.Rational
instance Sound.Tidal.Pattern.Valuable GHC.Types.Int
instance Sound.Tidal.Pattern.Valuable GHC.Types.Bool
instance Sound.Tidal.Pattern.Valuable Sound.Tidal.Pattern.Note
instance Sound.Tidal.Pattern.Valuable [GHC.Word.Word8]
instance Sound.Tidal.Pattern.Valuable [Sound.Tidal.Pattern.Value]
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Sound.Tidal.Pattern.Pattern a)
instance GHC.Base.Applicative Sound.Tidal.Pattern.Pattern
instance GHC.Base.Monad Sound.Tidal.Pattern.Pattern
instance GHC.Classes.Eq (Sound.Tidal.Pattern.Pattern a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Sound.Tidal.Pattern.Pattern a)
instance GHC.Num.Num a => GHC.Num.Num (Sound.Tidal.Pattern.Pattern a)
instance GHC.Enum.Enum a => GHC.Enum.Enum (Sound.Tidal.Pattern.Pattern a)
instance GHC.Base.Monoid (Sound.Tidal.Pattern.Pattern a)
instance GHC.Base.Semigroup (Sound.Tidal.Pattern.Pattern a)
instance (GHC.Num.Num a, GHC.Classes.Ord a) => GHC.Real.Real (Sound.Tidal.Pattern.Pattern a)
instance GHC.Real.Integral a => GHC.Real.Integral (Sound.Tidal.Pattern.Pattern a)
instance GHC.Real.Fractional a => GHC.Real.Fractional (Sound.Tidal.Pattern.Pattern a)
instance GHC.Float.Floating a => GHC.Float.Floating (Sound.Tidal.Pattern.Pattern a)
instance GHC.Real.RealFrac a => GHC.Real.RealFrac (Sound.Tidal.Pattern.Pattern a)
instance GHC.Float.RealFloat a => GHC.Float.RealFloat (Sound.Tidal.Pattern.Pattern a)
instance GHC.Num.Num Sound.Tidal.Pattern.ValueMap
instance GHC.Real.Fractional Sound.Tidal.Pattern.ValueMap
instance Sound.Tidal.Pattern.Moddable Sound.Tidal.Pattern.ValueMap
instance GHC.Float.Floating Sound.Tidal.Pattern.ValueMap
instance Sound.Tidal.Pattern.Stringy (Sound.Tidal.Pattern.Pattern a)
instance Control.DeepSeq.NFData Sound.Tidal.Pattern.Value
instance GHC.Classes.Eq Sound.Tidal.Pattern.Value
instance GHC.Classes.Ord Sound.Tidal.Pattern.Value
instance Sound.Tidal.Pattern.Moddable Sound.Tidal.Pattern.Note
instance Control.DeepSeq.NFData Sound.Tidal.Pattern.Note
instance GHC.Show.Show Sound.Tidal.Pattern.Note
instance (Control.DeepSeq.NFData a, Control.DeepSeq.NFData b) => Control.DeepSeq.NFData (Sound.Tidal.Pattern.EventF a b)
instance Control.DeepSeq.NFData Sound.Tidal.Pattern.Context
instance Sound.Tidal.Pattern.Stringy GHC.Base.String
instance Sound.Tidal.Pattern.Moddable GHC.Types.Double
instance Sound.Tidal.Pattern.Moddable GHC.Real.Rational
instance Sound.Tidal.Pattern.Moddable GHC.Types.Int
module Sound.Tidal.Show
-- | A specialised variant of showsPrec, using precedence context
-- zero, and returning an ordinary String.
show :: Show a => a -> String
showAll :: Show a => Arc -> Pattern a -> String
draw :: Pattern Char -> Render
drawLine :: Pattern Char -> Render
drawLineSz :: Int -> Pattern Char -> Render
stepcount :: Pattern a -> Int
showStateful :: ControlPattern -> String
instance GHC.Show.Show Sound.Tidal.Show.Render
instance GHC.Show.Show a => GHC.Show.Show (Sound.Tidal.Pattern.Pattern a)
instance GHC.Show.Show Sound.Tidal.Pattern.Context
instance GHC.Show.Show Sound.Tidal.Pattern.Value
instance GHC.Show.Show Sound.Tidal.Pattern.ValueMap
instance GHC.Show.Show Sound.Tidal.Time.Arc
instance GHC.Show.Show a => GHC.Show.Show (Sound.Tidal.Pattern.Event a)
module Sound.Tidal.StreamTypes
data PlayState
PlayState :: ControlPattern -> Bool -> Bool -> [ControlPattern] -> PlayState
[pattern] :: PlayState -> ControlPattern
[mute] :: PlayState -> Bool
[solo] :: PlayState -> Bool
[history] :: PlayState -> [ControlPattern]
type PatId = String
type PlayMap = Map PatId PlayState
data TickState
TickState :: Arc -> Double -> TickState
[tickArc] :: TickState -> Arc
[tickNudge] :: TickState -> Double
patternTimeID :: String
instance GHC.Show.Show Sound.Tidal.StreamTypes.PlayState
instance GHC.Show.Show Sound.Tidal.StreamTypes.TickState
module Sound.Tidal.Core
-- | Takes a function of time to values, and turns it into a
-- Pattern. Useful for creating continuous patterns such as
-- sine or perlin.
--
-- For example, saw is defined as
--
--
-- saw = sig $ \t -> mod' (fromRational t) 1
--
sig :: (Time -> 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.
sine :: 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.
sine2 :: 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.
cosine :: 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.
cosine2 :: Fractional 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.
saw :: (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.
saw2 :: (Fractional a, Real a) => Pattern a
-- | isaw like saw, but a descending (inverse) sawtooth.
isaw :: (Fractional a, Real a) => Pattern a
-- | isaw2 like saw2, but a descending (inverse)
-- sawtooth.
isaw2 :: (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.
tri :: (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.
tri2 :: (Fractional a, Real 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.
square :: 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.
square2 :: Fractional a => Pattern a
-- | envL is a Pattern of continuous Double values,
-- representing a linear interpolation between 0 and 1 during the first
-- cycle, then staying constant at 1 for all following cycles. Possibly
-- only useful if you're using something like the retrig function defined
-- in tidal.el.
envL :: Pattern Double
-- | like envL but reversed.
envLR :: Pattern Double
-- | 'Equal power' version of env, for gain-based transitions
envEq :: Pattern Double
-- | Equal power reversed
envEqR :: Pattern Double
class Unionable a
union :: Unionable a => a -> a -> 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 => 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
(||>) :: 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 a => Pattern a -> Pattern a -> Pattern a
(#) :: Unionable b => Pattern b -> Pattern b -> Pattern b
-- | 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"
--
fromList :: [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"
--
fastFromList :: [a] -> Pattern a
-- | A synonym for fastFromList
listToPat :: [a] -> Pattern a
-- | 'fromMaybes; is similar to fromList, but allows values to be
-- optional using the Maybe type, so that Nothing results
-- in gaps in the pattern. The following are equivalent: > d1 $ n
-- (fromMaybes [Just 0, Nothing, Just 2]) # s "superpiano" > d1 $ n "0
-- ~ 2" # s "superpiano"
fromMaybes :: [Maybe 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"
--
run :: (Enum a, Num a) => Pattern a -> Pattern a
_run :: (Enum a, Num a) => 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"
scan :: (Enum a, Num a) => Pattern a -> Pattern a
_scan :: (Enum a, Num a) => a -> Pattern a
-- | Alternate between cycles of the two given patterns > d1 $ append
-- (sound "bd*2 sn") (sound "arpy jvbass*2")
append :: Pattern a -> 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"]
--
cat :: [Pattern a] -> Pattern a
-- | Alias for cat
slowCat :: [Pattern a] -> Pattern a
slowcat :: [Pattern a] -> Pattern a
-- | Alias for append
slowAppend :: Pattern a -> Pattern a -> Pattern a
slowappend :: 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
fastappend :: Pattern a -> 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"]
--
fastCat :: [Pattern a] -> Pattern a
-- | Alias for fastCat
fastcat :: [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)
-- ]
--
timeCat :: [(Time, Pattern a)] -> Pattern a
-- | Alias for timeCat
timecat :: [(Time, Pattern a)] -> Pattern a
-- | overlay combines two Patterns 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")
--
overlay :: Pattern a -> Pattern a -> Pattern a
-- | stack combines a list of Patterns 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"
--
stack :: [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
(~>) :: 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]"
--
slowSqueeze :: Pattern Time -> Pattern a -> Pattern a
-- | An alias for slow
sparsity :: Pattern 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"
--
zoom :: (Time, Time) -> Pattern a -> Pattern a
zoomArc :: Arc -> 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.
fastGap :: Pattern Time -> Pattern a -> Pattern a
-- | An alias for fastGap
densityGap :: Pattern 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.
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
-- |
-- - 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 a -> Pattern a) -> Pattern a -> Pattern a
_every :: 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"
--
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 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.
foldEvery :: [Int] -> (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.
when :: (Int -> 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)"
--
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
instance Sound.Tidal.Core.Unionable a
instance Sound.Tidal.Core.Unionable Sound.Tidal.Pattern.ValueMap
module Sound.Tidal.Chords
major :: Num a => [a]
aug :: Num a => [a]
six :: Num a => [a]
sixNine :: Num a => [a]
major7 :: Num a => [a]
major9 :: Num a => [a]
add9 :: Num a => [a]
major11 :: Num a => [a]
add11 :: Num a => [a]
major13 :: Num a => [a]
add13 :: Num a => [a]
dom7 :: Num a => [a]
dom9 :: Num a => [a]
dom11 :: Num a => [a]
dom13 :: Num a => [a]
sevenFlat5 :: Num a => [a]
sevenSharp5 :: Num a => [a]
sevenFlat9 :: Num a => [a]
nine :: Num a => [a]
eleven :: Num a => [a]
thirteen :: Num a => [a]
minor :: Num a => [a]
diminished :: Num a => [a]
minorSharp5 :: Num a => [a]
minor6 :: Num a => [a]
minorSixNine :: Num a => [a]
minor7flat5 :: Num a => [a]
minor7 :: Num a => [a]
minor7sharp5 :: Num a => [a]
minor7flat9 :: Num a => [a]
minor7sharp9 :: Num a => [a]
diminished7 :: Num a => [a]
minor9 :: Num a => [a]
minor11 :: Num a => [a]
minor13 :: Num a => [a]
minorMajor7 :: Num a => [a]
one :: Num a => [a]
five :: Num a => [a]
sus2 :: Num a => [a]
sus4 :: Num a => [a]
sevenSus2 :: Num a => [a]
sevenSus4 :: Num a => [a]
nineSus4 :: Num a => [a]
sevenFlat10 :: Num a => [a]
nineSharp5 :: Num a => [a]
minor9sharp5 :: Num a => [a]
sevenSharp5flat9 :: Num a => [a]
minor7sharp5flat9 :: Num a => [a]
elevenSharp :: Num a => [a]
minor11sharp :: Num a => [a]
-- | chordate cs m n selects the nth "chord" (a chord is
-- a list of Ints) from a list of chords cs and transposes it by
-- m chordate :: Num b => [[b]] -> b -> Int -> [b]
-- chordate cs m n = map (+m) $ cs!!n
--
-- enchord chords pn pc turns every note in the note pattern
-- pn into a chord, selecting from the chord lists
-- chords using the index pattern pc. For example,
-- Chords.enchord [Chords.major Chords.minor] "c g" "0 1" will
-- create a pattern of a C-major chord followed by a G-minor chord.
-- enchord :: Num a => [[a]] -> Pattern a -> Pattern Int ->
-- Pattern a enchord chords pn pc = flatpat $ (chordate chords) $
-- pn * pc
--
-- The chordTable function outputs a list of all available
-- chords and their corresponding notes. For example, its first entry is
-- ("major",[0,4,7]) which means that a major triad is formed by
-- the root (0), the major third (4 semitones above the root), and the
-- perfect fifth (7 semitones above the root).
--
-- As the list is big, you can use the function chordL.
--
-- If you know the notes from a chord, but can’t find the name of it, you
-- can use this Haskell code to do a reverse look up into the table:
--
--
-- filter (\(_,x)->x==[0,4,7,10]) chordTable
--
--
-- This will output [("dom7",[0,4,7,10])]
--
-- (You’ll need to run import Sound.Tidal.Chords before using
-- this function.)
chordTable :: Num a => [(String, [a])]
-- | Look up a specific chord: chordL "minor7" returns
-- (0>1)|[0,3,7,10].
chordL :: Num a => Pattern String -> Pattern [a]
-- | Outputs all the available chords:
--
--
-- major maj M aug plus sharp5 six 6 sixNine six9 sixby9 6by9 major7 maj7
-- major9 maj9 add9 major11 maj11 add11 major13 maj13 add13 dom7 dom9 dom11
-- dom13 sevenFlat5 7f5 sevenSharp5 7s5 sevenFlat9 7f9 nine eleven 11 thirteen 13
-- minor min m diminished dim minorSharp5 msharp5 mS5 minor6 min6 m6 minorSixNine
-- minor69 min69 minSixNine m69 mSixNine m6by9 minor7flat5 minor7f5 min7flat5
-- min7f5 m7flat5 m7f5 minor7 min7 m7 minor7sharp5 minor7s5 min7sharp5 min7s5
-- m7sharp5 m7s5 minor7flat9 minor7f9 min7flat9 min7f9 m7flat9 m7f9 minor7sharp9
-- minor7s9 min7sharp9 min7s9 m7sharp9 m7s9 diminished7 dim7 minor9 min9 m9
-- minor11 min11 m11 minor13 min13 m13 minorMajor7 minMaj7 mmaj7 one 1 five 5
-- sus2 sus4 sevenSus2 7sus2 sevenSus4 7sus4 nineSus4 ninesus4 9sus4 sevenFlat10
-- 7f10 nineSharp5 9sharp5 9s5 minor9sharp5 minor9s5 min9sharp5 min9s5 m9sharp5
-- m9s5 sevenSharp5flat9 7s5f9 minor7sharp5flat9 m7sharp5flat9 elevenSharp 11s
-- minor11sharp m11sharp m11s
--
--
-- (You’ll need to run import Sound.Tidal.Chords before using
-- this function.)
chordList :: String
data Modifier
Range :: Int -> Modifier
Drop :: Int -> Modifier
Invert :: Modifier
Open :: Modifier
applyModifier :: (Enum a, Num a) => Modifier -> [a] -> [a]
applyModifierPat :: (Num a, Enum a) => Pattern [a] -> Pattern [Modifier] -> Pattern [a]
applyModifierPatSeq :: (Num a, Enum a) => (a -> b) -> Pattern [a] -> [Pattern [Modifier]] -> Pattern [b]
chordToPatSeq :: (Num a, Enum a) => (a -> b) -> Pattern a -> Pattern String -> [Pattern [Modifier]] -> Pattern b
-- | Turns a given pattern of some Num type, a pattern of chord
-- names, and a list of patterns of modifiers into a chord pattern
chord :: (Num a, Enum a) => Pattern a -> Pattern String -> [Pattern [Modifier]] -> Pattern a
instance GHC.Classes.Eq Sound.Tidal.Chords.Modifier
instance GHC.Show.Show Sound.Tidal.Chords.Modifier
module Sound.Tidal.Utils
writeError :: String -> IO ()
mapBoth :: (a -> a) -> (a, a) -> (a, a)
mapPartTimes :: (a -> a) -> ((a, a), (a, a)) -> ((a, a), (a, a))
mapFst :: (a -> b) -> (a, c) -> (b, c)
mapSnd :: (a -> b) -> (c, a) -> (c, b)
delta :: Num a => (a, a) -> a
-- | The midpoint of two values
mid :: Fractional a => (a, a) -> a
removeCommon :: Eq a => [a] -> [a] -> ([a], [a])
readMaybe :: Read a => String -> Maybe a
-- | like !! selects nth element from xs, but wraps over at
-- the end of xs
--
--
-- >>> map ((!!!) [1,3,5]) [0,1,2,3,4,5]
-- [1,3,5,1,3,5]
--
(!!!) :: [a] -> Int -> a
-- | Safer version of !! -
nth :: Int -> [a] -> Maybe a
accumulate :: Num t => [t] -> [t]
-- | enumerate a list of things
--
--
-- >>> enumerate ["foo","bar","baz"]
-- [(1,"foo"), (2,"bar"), (3,"baz")]
--
enumerate :: [a] -> [(Int, a)]
-- | split given list of a by given single a, e.g.
--
--
-- >>> wordsBy (== ':') "bd:3"
-- ["bd", "3"]
--
wordsBy :: (a -> Bool) -> [a] -> [[a]]
matchMaybe :: Maybe a -> Maybe a -> Maybe a
fromRight :: b -> Either a b -> b
module Sound.Tidal.Tempo
type TransitionMapper = Time -> [ControlPattern] -> ControlPattern
data TempoAction
SetCycle :: Time -> TempoAction
SingleTick :: ControlPattern -> TempoAction
SetNudge :: Double -> TempoAction
StreamReplace :: ID -> ControlPattern -> TempoAction
Transition :: Bool -> TransitionMapper -> ID -> ControlPattern -> TempoAction
data State
State :: Int64 -> Micros -> Arc -> Double -> State
[ticks] :: State -> Int64
[start] :: State -> Micros
[nowArc] :: State -> Arc
[nudged] :: State -> Double
data ActionHandler
ActionHandler :: (TickState -> LinkOperations -> ValueMap -> IO ValueMap) -> (LinkOperations -> ValueMap -> ControlPattern -> IO ValueMap) -> (ID -> Time -> ControlPattern -> IO ()) -> ActionHandler
[onTick] :: ActionHandler -> TickState -> LinkOperations -> ValueMap -> IO ValueMap
[onSingleTick] :: ActionHandler -> LinkOperations -> ValueMap -> ControlPattern -> IO ValueMap
[updatePattern] :: ActionHandler -> ID -> Time -> ControlPattern -> IO ()
data LinkOperations
LinkOperations :: (Beat -> IO Micros) -> (Micros -> IO Time) -> IO BPM -> (BPM -> Micros -> IO ()) -> (Micros -> Time) -> (CDouble -> CDouble) -> (CDouble -> CDouble) -> LinkOperations
[timeAtBeat] :: LinkOperations -> Beat -> IO Micros
[timeToCycles] :: LinkOperations -> Micros -> IO Time
[getTempo] :: LinkOperations -> IO BPM
[setTempo] :: LinkOperations -> BPM -> Micros -> IO ()
[linkToOscTime] :: LinkOperations -> Micros -> Time
[beatToCycles] :: LinkOperations -> CDouble -> CDouble
[cyclesToBeat] :: LinkOperations -> CDouble -> CDouble
-- | Start cycles from the given cycle number.
--
--
-- setCycle 5
-- d1 $ n "6 2 0 8" # s "east"
--
setCycle :: Time -> MVar [TempoAction] -> IO ()
setNudge :: MVar [TempoAction] -> Double -> IO ()
timeToCycles' :: Config -> SessionState -> Micros -> IO Time
cyclesToTime :: Config -> SessionState -> Time -> IO Micros
addMicrosToOsc :: Micros -> Time -> Time
clocked :: Config -> MVar ValueMap -> MVar PlayMap -> MVar [TempoAction] -> ActionHandler -> AbletonLink -> IO [ThreadId]
instance GHC.Show.Show Sound.Tidal.Tempo.State
instance GHC.Show.Show Sound.Osc.Transport.Fd.Udp.Udp
module Sound.Tidal.Scales
-- | 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"
--
scale :: Fractional a => Pattern String -> Pattern Int -> Pattern 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
--
scaleList :: String
-- | 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).
scaleTable :: Fractional a => [(String, [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"
--
getScale :: Fractional a => [(String, [a])] -> Pattern String -> Pattern Int -> Pattern a
module Sound.Tidal.Params
-- | Group multiple params into one.
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 is made with cyclic lists in mind, but it can even
-- "cycle" through infinite lists.
pStateList :: String -> String -> [Value] -> ControlPattern
-- | A wrapper for pStateList that accepts a `[Double]` rather than
-- a `[Value]`.
pStateListF :: String -> String -> [Double] -> ControlPattern
-- | A wrapper for pStateList that accepts a `[String]` rather than
-- a `[Value]`.
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' 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
--
grain' :: Pattern String -> ControlPattern
midinote :: Pattern Note -> ControlPattern
drum :: Pattern String -> ControlPattern
drumN :: Num a => String -> a
-- | 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]
--
accelerate :: Pattern Double -> ControlPattern
accelerateTake :: String -> [Double] -> ControlPattern
accelerateCount :: String -> ControlPattern
accelerateCountTo :: String -> Pattern Double -> Pattern ValueMap
acceleratebus :: Pattern Int -> 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>"
--
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
array :: Pattern [Word8] -> ControlPattern
arrayTake :: String -> [Double] -> ControlPattern
arraybus :: Pattern Int -> Pattern [Word8] -> ControlPattern
-- | a pattern of numbers to specify the attack time (in seconds) of an
-- envelope applied to each sample.
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
-- | a pattern of numbers from 0 to 1. Sets the center frequency of the
-- band-pass filter.
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
-- | a pattern of anumbers from 0 to 1. Sets the q-factor of the band-pass
-- filter.
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
-- | 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
--
begin :: Pattern Double -> ControlPattern
beginTake :: String -> [Double] -> ControlPattern
beginCount :: String -> ControlPattern
beginCountTo :: String -> Pattern Double -> Pattern ValueMap
beginbus :: Pattern Int -> Pattern Double -> ControlPattern
-- | Spectral binshift
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
-- | choose the channel the pattern is sent to in superdirt
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
-- | 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.
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
-- | Spectral comb
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
-- | 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)
--
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
-- | bit crushing, a pattern of numbers from 1 (for drastic reduction in
-- bit-depth) to 16 (for barely no reduction).
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
-- | 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.
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
-- | a pattern of numbers from 0 to 1. Applies the cutoff frequency of the
-- low-pass filter.
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
-- | a pattern of numbers from 0 to 1. Sets the level of the delay signal.
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
-- | a pattern of numbers from 0 to 1. Sets the amount of delay feedback.
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
-- | a pattern of numbers from 0 to 1. Sets the length of the delay.
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
-- | noisy fuzzy distortion
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
-- | DJ filter, below 0.5 is low pass filter, above is high pass filter.
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
-- | when set to `1` will disable all reverb for this pattern. See
-- room and size for more information about reverb.
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
-- | 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.
end :: Pattern Double -> ControlPattern
endTake :: String -> [Double] -> ControlPattern
endCount :: String -> ControlPattern
endCountTo :: String -> Pattern Double -> Pattern ValueMap
endbus :: Pattern Int -> Pattern Double -> ControlPattern
-- | Spectral enhance
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
-- | 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.
fadeInTime :: Pattern Double -> ControlPattern
fadeInTimeTake :: String -> [Double] -> ControlPattern
fadeInTimeCount :: String -> ControlPattern
fadeInTimeCountTo :: String -> Pattern Double -> Pattern ValueMap
fadeInTimebus :: Pattern Int -> Pattern Double -> ControlPattern
-- | Used when using beginend or chopstriate and friends, to change
-- the fade out time of the grain envelope.
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
-- | Spectral freeze
freeze :: 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
-- | for internal sound routing
from :: Pattern Double -> ControlPattern
fromTake :: String -> [Double] -> ControlPattern
fromCount :: String -> ControlPattern
fromCountTo :: String -> Pattern Double -> Pattern ValueMap
frombus :: Pattern Int -> Pattern Double -> ControlPattern
fromrecv :: Pattern Int -> ControlPattern
-- | frequency shifter
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
-- | frequency shifter
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
-- | frequency shifter
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
-- | 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.
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
-- | High pass sort of spectral filter
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
-- | a pattern of numbers from 0 to 1. Applies the cutoff frequency of the
-- high-pass filter. Also has alias hpf
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
-- | a pattern of numbers to specify the hold time (in seconds) of an
-- envelope applied to each sample. Only takes effect if attack
-- and release are also specified.
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
-- | a pattern of numbers from 0 to 1. Applies the resonance of the
-- high-pass filter. Has alias hpq
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
-- | shape/bass enhancer
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
-- | Low pass sort of spectral filter
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
-- | controls the amount of overlap between two adjacent sounds
legato :: Pattern Double -> ControlPattern
legatoTake :: String -> [Double] -> ControlPattern
legatoCount :: String -> ControlPattern
legatoCountTo :: String -> Pattern Double -> Pattern ValueMap
legatobus :: Pattern Int -> 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
-- | A pattern of numbers. Specifies whether delaytime is calculated
-- relative to cps. When set to 1, delaytime is a direct multiple of a
-- cycle.
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
-- | loops the sample (from begin to end) the specified
-- number of times.
loop :: Pattern Double -> 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
-- | 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.
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
-- | The note or sample number to choose for a synth or sampleset
n :: Pattern Note -> ControlPattern
nTake :: String -> [Double] -> ControlPattern
nCount :: String -> ControlPattern
nCountTo :: String -> Pattern Double -> Pattern ValueMap
nbus :: Pattern Int -> Pattern Note -> ControlPattern
-- | The note or pitch to play a sound or synth with
note :: Pattern Note -> ControlPattern
noteTake :: String -> [Double] -> ControlPattern
noteCount :: String -> ControlPattern
noteCountTo :: String -> Pattern Double -> Pattern ValueMap
notebus :: Pattern Int -> Pattern Note -> 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)
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
-- | octaver effect
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
-- | octaver effect
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
-- | octaver effect
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
-- | 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.
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
-- | a pattern of numbers between 0 and 1, from left to right (assuming
-- stereo), once round a circle (assuming multichannel)
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
-- | 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)
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
-- | a pattern of numbers between -inf and inf, which controls how much
-- multichannel output is fanned out (negative is backwards ordering)
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
-- | a pattern of numbers between 0.0 and 1.0, which controls the
-- multichannel spread range (multichannel only)
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
-- | a pattern of numbers between 0.0 and inf, which controls how much each
-- channel is distributed over neighbours (multichannel only)
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
-- | Phaser Audio DSP effect | params are phaserrate and
-- phaserdepth
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
-- | Phaser Audio DSP effect | params are phaserrate and
-- phaserdepth
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
-- | used in SuperDirt softsynths as a control rate or "speed"
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
-- | Spectral conform
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
-- | a pattern of numbers to specify the release time (in seconds) of an
-- envelope applied to each sample.
release :: Pattern Double -> ControlPattern
releaseTake :: String -> [Double] -> ControlPattern
releaseCount :: String -> ControlPattern
releaseCountTo :: String -> Pattern Double -> Pattern ValueMap
releasebus :: Pattern Int -> Pattern Double -> ControlPattern
releaserecv :: Pattern Int -> ControlPattern
-- | a pattern of numbers from 0 to 1. Specifies the resonance of the
-- low-pass filter.
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 modulation
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
-- | ring modulation
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
-- | ring modulation
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
-- | a pattern of numbers from 0 to 1. Sets the level of reverb.
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
-- | Spectral scramble
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
-- | wave shaping distortion, a pattern of numbers from 0 for no distortion
-- up to 1 for loads of distortion.
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
-- | a pattern of numbers from 0 to 1. Sets the perceptual size (reverb
-- time) of the room to be used in reverb.
size :: Pattern Double -> 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
-- | Spectral smear
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
-- | 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).
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
-- | 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.
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 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.
timescale :: Pattern Double -> ControlPattern
timescaleTake :: String -> [Double] -> ControlPattern
timescaleCount :: String -> ControlPattern
timescaleCountTo :: String -> Pattern Double -> Pattern ValueMap
timescalebus :: Pattern Int -> 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)
--
timescalewin :: Pattern Double -> ControlPattern
timescalewinTake :: String -> [Double] -> ControlPattern
timescalewinCount :: String -> ControlPattern
timescalewinCountTo :: String -> Pattern Double -> Pattern ValueMap
timescalewinbus :: Pattern Int -> Pattern Double -> ControlPattern
-- | for internal sound routing
to :: 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
-- | for internal sound routing
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
-- | Tremolo Audio DSP effect | params are tremolorate and
-- tremolodepth
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
-- | Tremolo Audio DSP effect | params are tremolorate and
-- tremolodepth
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
-- | tube distortion
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
-- | 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"
-- ]
--
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
-- | formant filter to make things sound like vowels, a pattern of either
-- a, e, i, o or u. Use a
-- rest (~) for no effect.
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
-- | This module provides the main user interface functions, including
-- sources of randomness and transformations of patterns. All these
-- functions are available in the context of the TidalCycles REPL.
--
-- Many functions in this module taking Pattern values as
-- arguments have a corresponding function with an underscore prepended
-- to its name (e.g. degradeBy and _degradeBy). These
-- functions accept plain values, not Patterns, and are generally
-- intended for those developing or extending Tidal.
module Sound.Tidal.UI
-- | 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.
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 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
--
rand :: Fractional a => Pattern a
-- | Boolean rand - a continuous stream of true/false values, with a 50/50
-- chance.
brand :: Pattern Bool
-- | Boolean rand with probability as input, e.g. brandBy 0.25
-- produces trues 25% of the time.
brandBy :: Pattern Double -> Pattern Bool
_brandBy :: Double -> Pattern Bool
-- | 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"
--
irand :: Num a => Pattern Int -> Pattern a
_irand :: Num a => Int -> 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.
perlinWith :: Fractional a => Pattern Double -> 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)
--
perlin :: Fractional a => Pattern a
-- | 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.
perlin2With :: Pattern Double -> Pattern Double -> Pattern Double
-- | As perlin2 with a suitable choice of input pattern
-- (sig fromRational).
perlin2 :: Pattern Double -> Pattern Double
-- | 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'
--
choose :: [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 = chooseBy rand
--
--
-- The following results in the pattern "a b c":
--
--
-- chooseBy "0 0.25 0.5" ["a","b","c","d"]
--
chooseBy :: Pattern Double -> [a] -> 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'
--
wchoose :: [(a, Double)] -> Pattern a
-- | Given a pattern of probabilities and a list of (value,
-- weight) pairs, wchooseBy creates a Pattern
-- value by choosing values based on those probabilities and
-- weighted appropriately by the weights in the list of pairs.
wchooseBy :: Pattern Double -> [(a, Double)] -> 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"])
--
randcat :: [Pattern a] -> 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) ]
--
wrandcat :: [(Pattern a, Double)] -> 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]"
--
degrade :: 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 :: Pattern Double -> Pattern a -> Pattern a
_degradeBy :: Double -> Pattern a -> Pattern a
_degradeByUsing :: Pattern Double -> Double -> Pattern a -> Pattern a
-- | As degradeBy, but the pattern of probabilities represents the
-- chances to retain rather than remove the corresponding element.
unDegradeBy :: Pattern Double -> Pattern a -> Pattern a
_unDegradeBy :: Double -> Pattern a -> Pattern a
degradeOverBy :: Int -> Pattern Double -> 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.5
-- often = sometimesBy 0.75
-- rarely = sometimesBy 0.25
-- almostNever = sometimesBy 0.1
-- almostAlways = 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.5
-- often' = sometimesBy' 0.75
-- rarely' = sometimesBy' 0.25
-- almostNever' = sometimesBy' 0.1
-- almostAlways' = sometimesBy' 0.9
--
sometimesBy' :: Pattern Double -> (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.
sometimes' :: (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.
often' :: (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.
rarely' :: (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.
almostNever' :: (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.
almostAlways' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | Never apply a transformation, returning the pattern unmodified.
--
--
-- never = flip const
--
never :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | Apply the transformation to the pattern unconditionally.
--
--
-- always = id
--
always :: (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
_someCyclesBy :: Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | Alias of someCyclesBy.
somecyclesBy :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- |
-- someCycles = someCyclesBy 0.5
--
someCycles :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | Alias of someCycles.
somecycles :: (Pattern a -> Pattern a) -> 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]"
--
brak :: Pattern a -> Pattern a
-- | 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.
iter :: Pattern Int -> Pattern c -> Pattern c
_iter :: Int -> Pattern a -> Pattern a
-- | 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
--
iter' :: Pattern Int -> Pattern c -> Pattern c
_iter' :: Int -> 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"
--
palindrome :: Pattern a -> Pattern a
-- | Degrades a pattern over the given time.
fadeOut :: Time -> Pattern a -> Pattern a
-- | Alternate version to fadeOut where you can provide the time
-- from which the fade starts
fadeOutFrom :: Time -> Time -> Pattern a -> Pattern a
-- | ’Undegrades’ a pattern over the given time.
fadeIn :: Time -> Pattern a -> Pattern a
-- | Alternate version to fadeIn where you can provide the time
-- from which the fade in starts
fadeInFrom :: Time -> Time -> Pattern a -> Pattern a
-- | 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.
spread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b
-- | An alias for spread consistent with fastspread.
slowspread :: (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.
fastspread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b
-- | 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"
--
spread' :: Monad m => (a -> b -> m c) -> m a -> b -> m c
-- | 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"
--
spreadChoose :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b
-- | A shorter alias for spreadChoose.
spreadr :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b
-- | 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 striate 4 for every even
-- cycle and apply # 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.
ifp :: (Int -> Bool) -> (Pattern a -> Pattern a) -> (Pattern a -> 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")
wedge :: Pattern Time -> Pattern a -> Pattern a -> Pattern a
_wedge :: Time -> 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")
--
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 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"
--
superimpose :: (Pattern a -> Pattern a) -> 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"
--
trunc :: Pattern Time -> Pattern a -> Pattern a
_trunc :: 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"
--
linger :: Pattern Time -> Pattern a -> Pattern a
_linger :: Time -> 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 fast 2 to only the first half of
-- a pattern:
--
--
-- d1 $ within (0, 0.5) (fast 2) $ sound "bd*2 sn lt mt hh hh hh hh"
--
--
-- Or, to apply (# speed "0.5") to only the last
-- quarter of a pattern:
--
--
-- 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
withinArc :: Arc -> (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"
--
within' :: (Time, Time) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | Reverse the part of the pattern sliced out by the (start,
-- end) pair.
--
--
-- revArc a = within a rev
--
revArc :: (Time, Time) -> 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).
--
-- TODO: table
--
-- 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.
euclid :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_euclid :: Int -> Int -> Pattern a -> Pattern a
-- | euclidFull n k pa pb stacks euclid n k pa
-- with euclidInv n k pb. That is, it plays one pattern
-- on the euclidean rhythm and a different pattern on the off-beat.
--
-- 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)
--
euclidFull :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a -> Pattern a
-- | Less expressive than euclid due to its constrained types, but
-- may be more efficient.
_euclidBool :: Int -> Int -> Pattern Bool
_euclid' :: Int -> Int -> Pattern a -> Pattern a
-- | As euclid, but taking a third rotational parameter
-- corresponding to the onset at which to start the rhythm.
euclidOff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
-- | A shorter alias for euclidOff.
eoff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_euclidOff :: Int -> Int -> Int -> Pattern a -> Pattern a
-- | As euclidOff, but specialized to Bool. May be more
-- efficient than euclidOff.
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 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.
euclidInv :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_euclidInv :: Int -> Int -> Pattern a -> Pattern a
index :: Real b => b -> Pattern b -> Pattern c -> Pattern c
-- | 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 => Pattern Int -> Pattern a -> Pattern a
-- | Calculates a whole cycle, rotates it, then constrains events to the
-- original query arc.
_rot :: Ord a => Int -> 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"
--
segment :: Pattern Time -> Pattern a -> Pattern a
_segment :: Time -> Pattern a -> Pattern a
-- | discretise: the old (deprecated) name for segment
discretise :: Pattern Time -> Pattern a -> 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).
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 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 fs 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.
struct :: Pattern Bool -> Pattern a -> Pattern a
-- | 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.
substruct :: Pattern Bool -> Pattern b -> Pattern b
randArcs :: Int -> Pattern [Arc]
randStruct :: Int -> Pattern Int
substruct' :: 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.
stripe :: Pattern Int -> Pattern a -> Pattern a
_stripe :: 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 nth stripe starts
-- on a cycle boundary (in Indian classical terms, the sam).
slowstripe :: Pattern Int -> Pattern a -> Pattern a
parseLMRule :: String -> [(String, String)]
parseLMRule' :: String -> [(Char, String)]
-- | Returns the nth 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.
lindenmayer :: Int -> String -> String -> String
-- | 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)
lindenmayerI :: Num b => Int -> String -> String -> [b]
-- | 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.
runMarkov :: Int -> [[Double]] -> Int -> Time -> [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
--
markovPat :: Pattern Int -> Pattern Int -> [[Double]] -> Pattern Int
_markovPat :: Int -> Int -> [[Double]] -> Pattern Int
-- | 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)
--
mask :: Pattern Bool -> Pattern a -> Pattern a
enclosingArc :: [Arc] -> Arc
-- | 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"
--
stretch :: 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.
fit' :: Pattern Time -> Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
-- | 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
--
chunk :: Pattern Int -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b
_chunk :: Integral a => a -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b
-- | DEPRECATED, use chunk with negative numbers instead
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
-- | 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.
inside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a
_inside :: 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.
outside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a
_outside :: Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> 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>"
--
loopFirst :: Pattern a -> Pattern a
timeLoop :: Pattern 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)))
-- ]
--
seqPLoop :: [(Time, Time, Pattern a)] -> 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 => [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".
toScale' :: Num a => Int -> [a] -> Pattern Int -> 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"
--
swingBy :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a
-- | As swingBy, with the cycle division set to ⅓.
swing :: Pattern Time -> Pattern 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])
--
cycleChoose :: [a] -> Pattern a
-- | Internal function used by shuffle and scramble
_rearrangeWith :: Pattern Int -> 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”.
shuffle :: Pattern Int -> Pattern a -> Pattern a
_shuffle :: 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”.
scramble :: Pattern Int -> Pattern a -> Pattern a
_scramble :: Int -> Pattern a -> Pattern a
-- | 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)
--
randrun :: Int -> Pattern Int
-- | 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)))
-- ]
--
seqP :: [(Time, Time, 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
--
ur :: Time -> Pattern String -> [(String, Pattern a)] -> [(String, Pattern a -> Pattern a)] -> 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 Strings.
--
-- 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.
inhabit :: [(String, Pattern a)] -> Pattern String -> Pattern a
-- | spaceOut xs p repeats a Pattern p at
-- different durations given by the list of time values in xs.
spaceOut :: [Time] -> Pattern a -> Pattern a
-- | flatpat takes a Pattern of lists and pulls the list
-- elements as separate EventFs. 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
--
flatpat :: Pattern [a] -> Pattern a
-- | 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]"
--
layer :: [a -> Pattern b] -> a -> Pattern b
-- | 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.
arpeggiate :: Pattern a -> Pattern a
-- | Shorthand alias for arpeggiate
arpg :: Pattern a -> Pattern a
arpWith :: ([EventF (ArcF Time) a] -> [EventF (ArcF Time) b]) -> Pattern a -> Pattern b
-- | 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
arp :: Pattern String -> Pattern a -> Pattern a
_arp :: String -> 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 "cmaj4" # s "superpiano"
--
--
--
-- rolled = rolledBy (1/4)
--
rolled :: Pattern a -> Pattern a
rolledBy :: Pattern (Ratio Integer) -> Pattern a -> Pattern a
rolledWith :: Ratio Integer -> 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"
--
ply :: Pattern Rational -> Pattern a -> Pattern a
_ply :: Rational -> Pattern a -> Pattern a
-- | As ply, but applies a function each time. The applications are
-- compounded.
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
-- | 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)
--
press :: 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"
-- ]
--
pressBy :: Pattern Time -> Pattern a -> Pattern a
_pressBy :: Time -> Pattern a -> Pattern a
sew :: 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"
--
stitch :: Pattern Bool -> 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.
while :: Pattern Bool -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | stutter n t pat repeats each event in pat n
-- times, separated by t time (in fractions of a cycle). It is
-- like echo that doesn't reduce the volume, or ply if you
-- controlled the timing.
--
--
-- d1 $ stutter 4 (1/16) $ s "bd cp"
--
--
-- is functionally equivalent to
--
--
-- d1 $ stut 4 1 (1/16) $ s "bd cp"
--
stutter :: Integral i => i -> Time -> Pattern a -> Pattern a
-- | 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 :: (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap
juxcut :: (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap
juxcut' :: [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"
-- ]
--
jux' :: [t -> Pattern ValueMap] -> t -> Pattern ValueMap
-- | Multichannel variant of jux, not sure what it does
jux4 :: (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.
juxBy :: Pattern Double -> (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap
-- | 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
--
pick :: String -> Int -> 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.
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 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)
--
range :: Num a => Pattern a -> Pattern a -> Pattern a -> Pattern a
_range :: (Functor f, Num 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.
rangex :: (Functor f, Floating b) => b -> b -> f b -> f b
-- | 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"
--
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
-- | step acts as a kind of simple step-sequencer using strings.
-- For example, step "sn" "x x 12" is equivalent to the pattern
-- of strings given by "sn ~ sn ~ sn:1 sn:2 ~". step
-- 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, step 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 (step "sn" "x x 12 ")
--
step :: String -> String -> Pattern String
-- | steps is like step but it takes a list of pairs,
-- like step would, and it plays them all simultaneously.
--
--
-- d1 $ s (steps [("cp","x x x x x x"),("bd", "xxxx")])
--
steps :: [(String, String)] -> Pattern String
-- | like step, but allows you to specify an array of strings to use
-- for 0,1,2... For example,
--
--
-- d1 $ s (step' ["superpiano","supermandolin"] "0 1 000 1")
-- # sustain 4 # n 0
--
--
-- is equivalent to
--
--
-- d1 $ s "superpiano ~ supermandolin ~ superpiano!3 ~ supermandolin"
-- # sustain 4 # n 0
--
step' :: [String] -> String -> Pattern String
-- | Deprecated backwards-compatible alias for ghostWith.
ghost'' :: 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"
--
ghostWith :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
ghost' :: Time -> 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]" ]
--
ghost :: Pattern ValueMap -> Pattern ValueMap
-- | 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
tabby :: Int -> Pattern a -> Pattern a -> Pattern a
-- | Chooses from a list of patterns, using a pattern of floats (from 0 to
-- 1).
select :: Pattern Double -> [Pattern a] -> Pattern a
_select :: Double -> [Pattern a] -> Pattern a
-- | Chooses from a list of functions, using a pattern of floats (from 0 to
-- 1).
selectF :: Pattern Double -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a
_selectF :: Double -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a
-- | Chooses from a list of functions, using a pattern of integers.
pickF :: Pattern Int -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a
_pickF :: Int -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a
-- | 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.
contrast :: (ControlPattern -> ControlPattern) -> (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern
-- | 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"
--
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
-- | 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 hurry 2 to sample 1 of the drum sample set,
-- and leaves the rest as they are:
--
--
-- fix (hurry 2) (s "drum" # n "1")
--
fix :: (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern
-- | Like contrast, but one function is given, and applied to events
-- with controls which don't match. unfix is fix but only
-- applies when the testing pattern is not a match.
unfix :: (ControlPattern -> ControlPattern) -> ControlPattern -> 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"
--
fixRange :: (ControlPattern -> Pattern ValueMap) -> Pattern (Map String (Value, Value)) -> ControlPattern -> ControlPattern
unfixRange :: (ControlPattern -> Pattern ValueMap) -> Pattern (Map String (Value, Value)) -> ControlPattern -> ControlPattern
-- | 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.
quantise :: (Functor f, RealFrac b) => b -> f b -> f b
-- | As quantise, but uses floor to calculate divisions.
qfloor :: (Functor f, RealFrac b) => b -> f b -> f b
-- | As quantise, but uses ceiling to calculate divisions.
qceiling :: (Functor f, RealFrac b) => b -> f b -> f b
-- | An alias for quantise.
qround :: (Functor f, RealFrac b) => b -> f b -> f b
-- | Inverts all the values in a boolean pattern
inv :: Functor f => f Bool -> f Bool
-- | 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.
mono :: 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.
smooth :: Fractional a => Pattern a -> Pattern a
-- | Looks up values from a list of tuples, in order to swap values in the
-- given pattern
swap :: Eq a => [(a, b)] -> Pattern a -> Pattern b
-- | 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"
--
snowball :: Int -> (Pattern a -> Pattern a -> Pattern a) -> (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"
--
soak :: Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | construct n p breaks p into pieces and then
-- reassembles them so that it fits into n steps.
deconstruct :: Int -> Pattern String -> String
-- | 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"
--
bite :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_bite :: Int -> Pattern Int -> Pattern a -> Pattern a
-- | Chooses from a list of patterns, using a pattern of integers.
squeeze :: Pattern Int -> [Pattern a] -> Pattern a
squeezeJoinUp :: Pattern ControlPattern -> ControlPattern
_chew :: 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"
--
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
binary :: Pattern Int -> Pattern Bool
ascii :: Pattern String -> Pattern Bool
-- | 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)
--
grain :: Pattern Double -> Pattern Double -> ControlPattern
-- | 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.
necklace :: Rational -> [Int] -> Pattern Bool
module Sound.Tidal.ParseBP
data TidalParseError
TidalParseError :: ParseError -> String -> TidalParseError
[parsecError] :: TidalParseError -> ParseError
[code] :: TidalParseError -> String
type MyParser = Parsec String Int
-- | AST representation of patterns
data TPat a
[TPat_Atom] :: Maybe ((Int, Int), (Int, Int)) -> a -> TPat a
[TPat_Fast] :: TPat Time -> TPat a -> TPat a
[TPat_Slow] :: TPat Time -> TPat a -> TPat a
[TPat_DegradeBy] :: Int -> Double -> TPat a -> TPat a
[TPat_CycleChoose] :: Int -> [TPat a] -> TPat a
[TPat_Euclid] :: TPat Int -> TPat Int -> TPat Int -> TPat a -> TPat a
[TPat_Stack] :: [TPat a] -> TPat a
[TPat_Polyrhythm] :: Maybe (TPat Rational) -> [TPat a] -> TPat a
[TPat_Seq] :: [TPat a] -> TPat a
[TPat_Silence] :: TPat a
[TPat_Foot] :: TPat a
[TPat_Elongate] :: Rational -> TPat a -> TPat a
[TPat_Repeat] :: Int -> TPat a -> TPat a
[TPat_EnumFromTo] :: TPat a -> TPat a -> TPat a
[TPat_Var] :: String -> TPat a
[TPat_Chord] :: (Num b, Enum b, Parseable b, Enumerable b) => (b -> a) -> TPat b -> TPat String -> [TPat [Modifier]] -> TPat a
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)
cP :: (Enumerable a, Parseable a) => String -> Pattern a
class Parseable a
tPatParser :: Parseable a => MyParser (TPat a)
doEuclid :: Parseable a => Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
getControl :: Parseable a => String -> Pattern a
class Enumerable a
fromTo :: Enumerable a => a -> a -> Pattern a
fromThenTo :: Enumerable a => a -> a -> a -> Pattern a
enumFromTo' :: (Ord a, Enum a) => a -> a -> Pattern a
enumFromThenTo' :: (Ord a, Enum a, Num a) => a -> a -> a -> Pattern a
type ColourD = Colour Double
lexer :: GenTokenParser String u Identity
braces :: MyParser a -> MyParser a
brackets :: MyParser a -> MyParser a
parens :: MyParser a -> MyParser a
angles :: MyParser a -> MyParser a
symbol :: String -> MyParser String
natural :: MyParser Integer
integer :: MyParser Integer
decimal :: MyParser Integer
float :: MyParser Double
naturalOrFloat :: MyParser (Either Integer Double)
data Sign
Positive :: Sign
Negative :: Sign
applySign :: Num a => Sign -> a -> a
sign :: MyParser Sign
intOrFloat :: MyParser Double
pSequence :: Parseable a => MyParser (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)
instance GHC.Classes.Eq Sound.Tidal.ParseBP.TidalParseError
instance Sound.Tidal.ParseBP.Parseable Sound.Tidal.ParseBP.ColourD
instance Sound.Tidal.ParseBP.Enumerable Sound.Tidal.ParseBP.ColourD
instance GHC.Show.Show a => GHC.Show.Show (Sound.Tidal.ParseBP.TPat a)
instance GHC.Base.Functor Sound.Tidal.ParseBP.TPat
instance Sound.Tidal.ParseBP.Parseable GHC.Types.Char
instance Sound.Tidal.ParseBP.Parseable GHC.Types.Double
instance Sound.Tidal.ParseBP.Parseable Sound.Tidal.Pattern.Note
instance Sound.Tidal.ParseBP.Parseable GHC.Base.String
instance Sound.Tidal.ParseBP.Parseable GHC.Types.Bool
instance Sound.Tidal.ParseBP.Parseable GHC.Types.Int
instance Sound.Tidal.ParseBP.Parseable GHC.Num.Integer.Integer
instance Sound.Tidal.ParseBP.Parseable GHC.Real.Rational
instance (Sound.Tidal.ParseBP.Enumerable a, Sound.Tidal.ParseBP.Parseable a) => Data.String.IsString (Sound.Tidal.Pattern.Pattern a)
instance Sound.Tidal.ParseBP.Parseable [Sound.Tidal.Chords.Modifier]
instance Sound.Tidal.ParseBP.Enumerable GHC.Types.Char
instance Sound.Tidal.ParseBP.Enumerable GHC.Types.Double
instance Sound.Tidal.ParseBP.Enumerable Sound.Tidal.Pattern.Note
instance Sound.Tidal.ParseBP.Enumerable GHC.Base.String
instance Sound.Tidal.ParseBP.Enumerable GHC.Types.Bool
instance Sound.Tidal.ParseBP.Enumerable GHC.Types.Int
instance Sound.Tidal.ParseBP.Enumerable GHC.Num.Integer.Integer
instance Sound.Tidal.ParseBP.Enumerable GHC.Real.Rational
instance Sound.Tidal.ParseBP.Enumerable [Sound.Tidal.Chords.Modifier]
instance GHC.Exception.Type.Exception Sound.Tidal.ParseBP.TidalParseError
instance GHC.Show.Show Sound.Tidal.ParseBP.TidalParseError
module Sound.Tidal.Control
-- | 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 :: Pattern Int -> ControlPattern -> ControlPattern
_spin :: 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 :: Pattern Int -> ControlPattern -> ControlPattern
chopArc :: Arc -> Int -> [Arc]
_chop :: 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 :: Pattern Int -> ControlPattern -> ControlPattern
_striate :: Int -> ControlPattern -> ControlPattern
mergePlayRange :: (Double, Double) -> ValueMap -> ValueMap
-- | 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.
striateBy :: Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern
-- | DEPRECATED, use striateBy instead.
striate' :: Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern
_striateBy :: Int -> Double -> ControlPattern -> ControlPattern
-- | gap is similar to chop in that it granualizes every
-- sample in place as it is played, but every other grain is silent. Use
-- an integer value to specify how many granules each sample is chopped
-- into:
--
--
-- d1 $ gap 8 $ sound "jvbass"
-- d1 $ gap 16 $ sound "[jvbass drum:4]"
--
gap :: Pattern Int -> ControlPattern -> ControlPattern
_gap :: Int -> 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"
-- ]
--
weave :: Time -> ControlPattern -> [ControlPattern] -> ControlPattern
-- | 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
-- ]
--
weaveWith :: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a
-- | An old alias for weaveWith.
weave' :: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a
-- | (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")
--
interlace :: ControlPattern -> 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 :: Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern
_slice :: Int -> 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"
--
randslice :: Pattern Int -> ControlPattern -> ControlPattern
_splice :: 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"
--
splice :: Pattern Int -> Pattern Int -> ControlPattern -> Pattern (Map String Value)
-- | 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"
--
loopAt :: Pattern Time -> 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"
--
hurry :: Pattern Rational -> ControlPattern -> ControlPattern
-- | 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 :: Pattern Int -> [Pattern Time] -> ControlPattern -> Pattern ValueMap
-- | An altenative form of smash, which uses chop instead of
-- striate.
--
-- Compare the following variations:
--
--
-- d1 $ smash 6 [2,3,4] $ sound "ho ho:2 ho:3 hc"
-- d1 $ smash' 6 [2,3,4] $ sound "ho ho:2 ho:3 hc"
-- d1 $ smash 12 [2,3,4] $ s "bev*4"
-- d1 $ smash' 12 [2,3,4] $ s "bev*4"
--
smash' :: Int -> [Pattern Time] -> 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"
--
echo :: Pattern Integer -> Pattern Rational -> Pattern Double -> ControlPattern -> ControlPattern
_echo :: Integer -> Rational -> Double -> ControlPattern -> ControlPattern
-- | 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.
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
-- | DEPRECATED, use echo instead
stut :: Pattern Integer -> Pattern Double -> Pattern Rational -> ControlPattern -> ControlPattern
_stut :: Integer -> Double -> Rational -> ControlPattern -> ControlPattern
-- | DEPRECATED, use echoWith instead
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
-- | DEPRECATED, use echoWith instead
stut' :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | Turns a pattern of seconds into a pattern of (rational) cycle
-- durations
sec :: Fractional a => Pattern a -> Pattern a
-- | Turns a pattern of milliseconds into a pattern of (rational) cycle
-- durations, according to the current cps.
msec :: Fractional a => 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.
trigger :: 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"
--
qtrigger :: Pattern a -> Pattern a
-- | Alias for qtrigger.
qt :: Pattern a -> Pattern a
-- | Ceiling trigger. Aligns the start of a pattern to the next cycle
-- boundary, just like qtrigger.
ctrigger :: Pattern a -> Pattern a
-- | Rounded trigger. Aligns the start of a pattern to the nearest cycle
-- boundary, either next or previous.
rtrigger :: Pattern a -> Pattern a
-- | Floor trigger. Aligns the start of a pattern to the previous cycle
-- boundary.
ftrigger :: 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"
--
mtrigger :: Int -> Pattern a -> Pattern a
-- | Alias for mtrigger.
mt :: Int -> 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"
--
triggerWith :: (Time -> Time) -> Pattern a -> Pattern a
splat :: Pattern Int -> ControlPattern -> ControlPattern -> ControlPattern
module Sound.Tidal.Simple
crunch :: ControlPattern -> ControlPattern
scratch :: ControlPattern -> ControlPattern
louder :: ControlPattern -> ControlPattern
quieter :: ControlPattern -> ControlPattern
silent :: ControlPattern -> ControlPattern
skip :: ControlPattern -> ControlPattern
left :: ControlPattern -> ControlPattern
right :: ControlPattern -> ControlPattern
higher :: ControlPattern -> ControlPattern
lower :: ControlPattern -> ControlPattern
faster :: ControlPattern -> ControlPattern
slower :: ControlPattern -> ControlPattern
instance Data.String.IsString Sound.Tidal.Pattern.ControlPattern
module Sound.Tidal.Version
tidal_version :: String
tidal_status :: IO ()
tidal_status_string :: IO String
module Sound.Tidal.Stream
instance GHC.Show.Show Sound.Tidal.Stream.StampStyle
instance GHC.Classes.Eq Sound.Tidal.Stream.StampStyle
instance GHC.Show.Show Sound.Tidal.Stream.Schedule
instance GHC.Classes.Eq Sound.Tidal.Stream.Schedule
instance GHC.Show.Show Sound.Tidal.Stream.Target
instance GHC.Show.Show Sound.Tidal.Stream.Args
instance GHC.Show.Show Sound.Tidal.Stream.OSC
instance GHC.Show.Show Sound.Tidal.Stream.Cx
module Sound.Tidal.Transition
transition :: Stream -> Bool -> (Time -> [ControlPattern] -> ControlPattern) -> ID -> ControlPattern -> IO ()
mortalOverlay :: Time -> Time -> [Pattern a] -> Pattern a
-- | 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.
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
-- | Pans the last n versions of the pattern across the field
histpan :: Int -> Time -> [ControlPattern] -> ControlPattern
-- | Just stop for a bit before playing new pattern
wait :: Time -> Time -> [ControlPattern] -> ControlPattern
-- | Just as wait, waitT stops for a bit and then applies the
-- given transition to the playing pattern
--
--
-- d1 $ sound "bd"
--
-- t1 (waitT (xfadeIn 8) 4) $ sound "hh*8"
--
waitT :: (Time -> [ControlPattern] -> ControlPattern) -> Time -> Time -> [ControlPattern] -> ControlPattern
-- | Jumps directly into the given pattern, this is essentially the _no
-- transition_-transition.
--
-- Variants of jump provide more useful capabilities, see
-- jumpIn and jumpMod
jump :: Time -> [ControlPattern] -> ControlPattern
-- | Sharp jump transition after the specified number of cycles have
-- passed.
--
--
-- t1 (jumpIn 2) $ sound "kick(3,8)"
--
jumpIn :: Int -> Time -> [ControlPattern] -> ControlPattern
-- | Unlike jumpIn the variant jumpIn' will only transition
-- at cycle boundary (e.g. when the cycle count is an integer).
jumpIn' :: Int -> Time -> [ControlPattern] -> ControlPattern
-- | Sharp jump transition at next cycle boundary where cycle mod n
-- == 0
jumpMod :: Int -> Time -> [ControlPattern] -> ControlPattern
-- | Sharp jump transition at next cycle boundary where cycle mod n
-- == p
jumpMod' :: Int -> Int -> Time -> [ControlPattern] -> ControlPattern
-- | Degrade the new pattern over time until it ends in silence
mortal :: Time -> Time -> Time -> [ControlPattern] -> ControlPattern
interpolate :: Time -> [ControlPattern] -> ControlPattern
interpolateIn :: Time -> Time -> [ControlPattern] -> ControlPattern
-- | 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.
clutch :: Time -> [Pattern a] -> Pattern a
-- | 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.
clutchIn :: Time -> Time -> [Pattern a] -> Pattern a
-- | 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)"
--
anticipateIn :: Time -> Time -> [ControlPattern] -> ControlPattern
-- | anticipate is an increasing comb filter.
--
-- Build up some tension, culminating in a _drop_ to the new pattern
-- after 8 cycles.
anticipate :: Time -> [ControlPattern] -> ControlPattern
module Sound.Tidal.Context
module Sound.Tidal.Safe.Context
data Op r
exec :: Stream -> Op r -> IO r
streamReplace :: ID -> ControlPattern -> Op ()
streamHush :: Op ()
streamList :: Op ()
streamMute :: ID -> Op ()
streamUnmute :: ID -> Op ()
streamSolo :: ID -> Op ()
streamUnsolo :: ID -> Op ()
streamOnce :: ControlPattern -> Op ()
streamFirst :: ControlPattern -> Op ()
streamNudgeAll :: Double -> Op ()
streamAll :: (ControlPattern -> ControlPattern) -> Op ()
streamResetCycles :: Op ()
streamSetI :: String -> Pattern Int -> Op ()
streamSetF :: String -> Pattern Double -> Op ()
streamSetS :: String -> Pattern String -> Op ()
streamSetR :: String -> Pattern Rational -> Op ()
streamSetB :: String -> Pattern Bool -> Op ()
transition :: Bool -> (Time -> [ControlPattern] -> ControlPattern) -> ID -> ControlPattern -> Op ()
data Target
Target :: String -> String -> Int -> Maybe Int -> Double -> Maybe Arc -> Schedule -> Bool -> Target
[oName] :: Target -> String
[oAddress] :: Target -> String
[oPort] :: Target -> Int
[oBusPort] :: Target -> Maybe Int
[oLatency] :: Target -> Double
[oWindow] :: Target -> Maybe Arc
[oSchedule] :: Target -> Schedule
[oHandshake] :: Target -> Bool
instance Control.Monad.Catch.MonadThrow Sound.Tidal.Safe.Context.Op
instance Control.Monad.Catch.MonadCatch Sound.Tidal.Safe.Context.Op
instance GHC.Base.Monad Sound.Tidal.Safe.Context.Op
instance GHC.Base.Applicative Sound.Tidal.Safe.Context.Op
instance GHC.Base.Functor Sound.Tidal.Safe.Context.Op
module Sound.Tidal.Safe.Boot
p :: ID -> ControlPattern -> Op ()
hush :: Op ()
list :: Op ()
mute :: ID -> Op ()
unmute :: ID -> Op ()
solo :: ID -> Op ()
unsolo :: ID -> Op ()
once :: ControlPattern -> Op ()
first :: ControlPattern -> Op ()
asap :: ControlPattern -> Op ()
nudgeAll :: Double -> Op ()
all :: (ControlPattern -> ControlPattern) -> Op ()
-- | Resets the cycle count back to 0. Useful to make sure a pattern or set
-- of patterns start from the beginning:
--
--
-- do
-- resetCycles
-- d1 $ s "bd hh hh hh"
-- d2 $ s "ade" # cut 1
--
--
-- Cycle count affects all patterns, so if there are any active, all of
-- them will immediately jump to the beginning. resetCycles is
-- also userful in multi-user Tidal.
--
-- Also see setCycle, getnow.
resetCycles :: Op ()
-- | Adjusts the number of cycles per second, i.e., tempo. Accepts
-- integers, decimals, and fractions.
--
-- The default number of cycles per second is 0.5625, equivalent to
-- 135/60/4, i.e., 135 beats per minute if there are 4 beats per cycle.
--
-- Representing cycles per second using fractions has the advantage of
-- being more human-readable and more closely aligned with how tempo is
-- commonly represented in music as beats per minute (bpm). For example,
-- techno has a typical range of 120-140 bpm and house has a range of
-- 115-130 bpm. To set the tempo in Tidal to fast house, e.g.,:
-- setcps (130/60/4).
--
-- The following sound the same:
--
--
-- setcps (130/60/4)
-- d1 $ n "1" # s "kick kick kick kick"
--
--
-- and
--
--
-- setcps (130/60/1)
-- d1 $ n "1" # s "kick"
--
setcps :: Pattern Double -> Op ()
xfade :: ID -> ControlPattern -> Op ()
xfadeIn :: ID -> Time -> ControlPattern -> Op ()
histpan :: ID -> Int -> ControlPattern -> Op ()
wait :: ID -> Time -> ControlPattern -> Op ()
waitT :: ID -> (Time -> [ControlPattern] -> ControlPattern) -> Time -> ControlPattern -> Op ()
jump :: ID -> ControlPattern -> Op ()
jumpIn :: ID -> Int -> ControlPattern -> Op ()
jumpIn' :: ID -> Int -> ControlPattern -> Op ()
jumpMod :: ID -> Int -> ControlPattern -> Op ()
mortal :: ID -> Time -> Time -> ControlPattern -> Op ()
interpolate :: ID -> ControlPattern -> Op ()
interpolateIn :: ID -> Time -> ControlPattern -> Op ()
clutch :: ID -> ControlPattern -> Op ()
clutchIn :: ID -> Time -> ControlPattern -> Op ()
anticipate :: ID -> ControlPattern -> Op ()
anticipateIn :: ID -> Time -> ControlPattern -> Op ()
forId :: ID -> Time -> ControlPattern -> Op ()
d1 :: Pattern ValueMap -> Op ()
d2 :: Pattern ValueMap -> Op ()
d3 :: Pattern ValueMap -> Op ()
d4 :: Pattern ValueMap -> Op ()
d5 :: Pattern ValueMap -> Op ()
d6 :: Pattern ValueMap -> Op ()
d7 :: Pattern ValueMap -> Op ()
d8 :: Pattern ValueMap -> Op ()
d9 :: Pattern ValueMap -> Op ()
d10 :: Pattern ValueMap -> Op ()
d11 :: Pattern ValueMap -> Op ()
d12 :: Pattern ValueMap -> Op ()
d13 :: ControlPattern -> Op ()
d14 :: ControlPattern -> Op ()
d15 :: ControlPattern -> Op ()
d16 :: ControlPattern -> Op ()
setI :: String -> Pattern Int -> Op ()
setF :: String -> Pattern Double -> Op ()
setS :: String -> Pattern String -> Op ()
setR :: String -> Pattern Rational -> Op ()
setB :: String -> Pattern Bool -> Op ()