-- 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.7.8

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 -> Double -> String -> Int -> Int -> Int -> Bool -> Config
[cCtrlListen] :: Config -> Bool
[cCtrlAddr] :: Config -> String
[cCtrlPort] :: Config -> Int
[cFrameTimespan] :: Config -> Double
[cTempoAddr] :: Config -> String
[cTempoPort] :: Config -> Int
[cTempoClientPort] :: Config -> Int
[cSkipTicks] :: Config -> Int
[cVerbose] :: Config -> Bool
defaultConfig :: Config

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 <a>sam</a> (start of cycle) for the given time value
sam :: Time -> Time

-- | Turns a number into a (rational) time value. An alias for
--   <a>toRational</a>.
toTime :: Real a => a -> Rational

-- | Turns a (rational) time value into another number. An alias for
--   <a>fromRational</a>.
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

-- | <tt>subArc i j</tt> is the timespan that is the intersection of
--   <tt>i</tt> and <tt>j</tt>. 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 of the whole cycle that the given time value falls within
timeToCycleArc :: Time -> Arc

-- | Shifts an arc to the equivalent one that starts during cycle zero
cycleArc :: Arc -> Arc

-- | A list of cycle numbers which are included in the given arc
cyclesInArc :: Integral a => Arc -> [a]

-- | A list of arcs of the whole cycles which are included in the given arc
cycleArcsInArc :: Arc -> [Arc]

-- | Splits the given <a>Arc</a> into a list of <a>Arc</a>s, at cycle
--   boundaries.
arcCycles :: Arc -> [Arc]

-- | Like arcCycles, but returns zero-width arcs
arcCyclesZW :: Arc -> [Arc]

-- | Similar to <a>fmap</a> but time is relative to the cycle (i.e. the sam
--   of the start of the arc)
mapCycle :: (Time -> Time) -> Arc -> Arc

-- | <tt>isIn a t</tt> is <tt>True</tt> if <tt>t</tt> is inside the arc
--   represented by <tt>a</tt>.
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

-- | Note is Double, but with a different parser
newtype Note
Note :: Double -> Note
[unNote] :: Note -> Double
type ValueMap = Map String Value
class Valuable a
toValue :: Valuable a => a -> Value

-- | 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)
type Event a = EventF (ArcF Time) 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

-- | 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

-- | A datatype representing events taking place over time
data Pattern a
Pattern :: (State -> [Event a]) -> Pattern a
[query] :: Pattern a -> State -> [Event a]

-- | an Arc and some named control values
data State
State :: Arc -> ValueMap -> State
[arc] :: State -> Arc
[controls] :: State -> ValueMap

-- | Like <a>*</a>, but the <tt>wholes</tt> come from the left
(<*) :: Pattern (a -> b) -> Pattern a -> Pattern b
infixl 4 <*

-- | Like <a>*</a>, but the <tt>wholes</tt> come from the right
(*>) :: Pattern (a -> b) -> Pattern a -> Pattern b
infixl 4 *>
applyPatToPat :: (Maybe Arc -> Maybe Arc -> Maybe (Maybe Arc)) -> Pattern (a -> b) -> Pattern a -> Pattern b
applyPatToPatBoth :: Pattern (a -> b) -> Pattern a -> Pattern b
applyPatToPatLeft :: Pattern (a -> b) -> Pattern a -> Pattern b
applyPatToPatRight :: Pattern (a -> b) -> Pattern a -> Pattern b

-- | Turns a pattern of patterns into a single pattern. (this is actually
--   <tt>join</tt>)
--   
--   1/ For query <a>arc</a>, get the events from the outer pattern
--   <tt>pp</tt> 2/ Query the inner pattern using the <a>part</a> 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<i>
--   Concatenate all the events together (discarding wholes</i>parts 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
--   <tt>unwrap</tt>, but structure only comes from the inner pattern.
innerJoin :: Pattern (Pattern a) -> Pattern a

-- | Turns a pattern of patterns into a single pattern. Like
--   <tt>unwrap</tt>, but structure only comes from the outer pattern.
outerJoin :: Pattern (Pattern a) -> Pattern a

-- | Like <tt>unwrap</tt>, 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

-- | <ul>
--   <li>Patterns as numbers</li>
--   </ul>
noOv :: String -> a
empty :: Pattern a
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

-- | <tt>withEvent f p</tt> returns a new <tt>Pattern</tt> with each event
--   mapped over function <tt>f</tt>.
withEvent :: (Event a -> Event b) -> Pattern a -> Pattern b

-- | <tt>withEvent f p</tt> returns a new <tt>Pattern</tt> with each value
--   mapped over function <tt>f</tt>.
withValue :: (a -> b) -> Pattern a -> Pattern b

-- | <tt>withEvent f p</tt> returns a new <tt>Pattern</tt> with f applied
--   to the resulting list of events for each query function <tt>f</tt>.
withEvents :: ([Event a] -> [Event b]) -> Pattern a -> Pattern b

-- | <tt>withPart f p</tt> returns a new <tt>Pattern</tt> with function
--   <tt>f</tt> applied to the part.
withPart :: (Arc -> Arc) -> Pattern a -> Pattern a
_extract :: (Value -> Maybe a) -> String -> ControlPattern -> Pattern a

-- | Extract a pattern of integer values by from a control pattern, given
--   the name of the control
extractI :: String -> ControlPattern -> Pattern Int

-- | Extract a pattern of floating point values by from a control pattern,
--   given the name of the control
extractF :: String -> ControlPattern -> Pattern Double

-- | Extract a pattern of string values by from a control pattern, given
--   the name of the control
extractS :: String -> ControlPattern -> Pattern String

-- | Extract a pattern of boolean values by from a control pattern, given
--   the name of the control
extractB :: String -> ControlPattern -> Pattern Bool

-- | Extract a pattern of rational values by from a control pattern, given
--   the name of the control
extractR :: String -> ControlPattern -> Pattern Rational
compressArc :: Arc -> Pattern a -> Pattern a
compressArcTo :: Arc -> Pattern a -> Pattern a
_fastGap :: Time -> Pattern a -> Pattern a

-- | Shifts a pattern back in time by the given amount, expressed in cycles
rotL :: Time -> Pattern a -> Pattern a

-- | Shifts a pattern forward in time by the given amount, expressed in
--   cycles
rotR :: 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

-- | Turns a pattern of <a>Maybe</a> values into a pattern of values,
--   dropping the events of <a>Nothing</a>.
filterJust :: Pattern (Maybe a) -> Pattern a
filterWhen :: (Time -> Bool) -> Pattern a -> Pattern a
filterOnsets :: Pattern a -> Pattern a
filterEvents :: (Event a -> Bool) -> Pattern a -> Pattern a
filterDigital :: Pattern a -> Pattern a
filterAnalog :: Pattern a -> Pattern a
playFor :: Time -> Time -> Pattern a -> Pattern a
tParam :: (t1 -> t2 -> Pattern a) -> Pattern t1 -> t2 -> 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
tParamSqueeze :: (a -> Pattern b -> Pattern c) -> Pattern a -> Pattern b -> Pattern c
combineContexts :: [Context] -> Context
setContext :: Context -> Pattern a -> Pattern a
withContext :: (Context -> Context) -> Pattern a -> Pattern a
deltaContext :: Int -> Int -> Pattern a -> Pattern a
isAnalog :: Event a -> Bool
isDigital :: Event a -> Bool

-- | <a>True</a> if an <a>Event</a>'s starts is within given <a>Arc</a>
onsetIn :: Arc -> Event a -> Bool

-- | Compares two lists of events, attempting to combine fragmented events
--   in the process for a <tt>truer</tt> compare
compareDefrag :: Ord a => [Event a] -> [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 <a>True</a> if the two given events are adjacent parts of the
--   same whole
isAdjacent :: Eq a => Event a -> Event a -> Bool
wholeOrPart :: Event a -> Arc

-- | Get the onset of an event's <a>whole</a>
wholeStart :: Event a -> Time

-- | Get the offset of an event's <a>whole</a>
wholeStop :: Event a -> Time

-- | Get the onset of an event's <a>whole</a>
eventPartStart :: Event a -> Time

-- | Get the offset of an event's <a>part</a>
eventPartStop :: Event a -> Time

-- | Get the timespan of an event's <a>part</a>
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])

-- | 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
getI :: Value -> Maybe Int
getF :: Value -> Maybe Double
getN :: Value -> Maybe Note
getS :: Value -> Maybe String
getB :: Value -> Maybe Bool
getR :: Value -> Maybe Rational
getBlob :: Value -> Maybe [Word8]
getList :: Value -> Maybe [Value]
valueToPattern :: Value -> Pattern Value
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.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.Show.Show 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 [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.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 Control.DeepSeq.NFData Sound.Tidal.Pattern.Value
instance GHC.Classes.Eq Sound.Tidal.Pattern.Value
instance GHC.Classes.Ord Sound.Tidal.Pattern.Value
instance Control.DeepSeq.NFData 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

module Sound.Tidal.Show

-- | A specialised variant of <a>showsPrec</a>, using precedence context
--   zero, and returning an ordinary <a>String</a>.
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.Core

-- | An empty pattern
silence :: Pattern a

-- | Takes a function from time to values, and turns it into a
--   <a>Pattern</a>.
sig :: (Time -> a) -> Pattern a

-- | <tt>sine</tt> - 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

-- | <tt>sine2</tt> - 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

-- | <tt>cosine</tt> - 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 ~&gt; sine`.
cosine :: Fractional a => Pattern a

-- | <tt>cosine2</tt> - 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 ~&gt; sine2`.
cosine2 :: Fractional a => Pattern a

-- | <tt>saw</tt> - 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

-- | <tt>saw2</tt> - 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

-- | <tt>isaw</tt> like <tt>saw</tt>, but a descending (inverse) sawtooth.
isaw :: (Fractional a, Real a) => Pattern a

-- | <tt>isaw2</tt> like <tt>saw2</tt>, but a descending (inverse)
--   sawtooth.
isaw2 :: (Fractional a, Real a) => Pattern a

-- | <tt>tri</tt> - 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

-- | <tt>tri2</tt> - 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

-- | <tt>square</tt> - unipolar square wave. A pattern of continuous values
--   following a square wave with frequency of one cycle, and amplitude
--   from 0 to 1. | <tt>square</tt> is like <a>sine</a>, for square waves.
square :: Fractional a => Pattern a

-- | <tt>square2</tt> - 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

-- | <tt>envL</tt> is a <a>Pattern</a> of continuous <a>Double</a> 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 <a>envL</a> but reversed.
envLR :: Pattern Double

-- | 'Equal power' version of <tt>env</tt>, 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
(|++|) :: Applicative a => a String -> a String -> a 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
(|*|) :: (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
(|-|) :: (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
(|%|) :: (Applicative a, Real b) => a b -> a b -> a b
(|%) :: Real a => Pattern a -> Pattern a -> Pattern a
(%|) :: Real 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
(|>|) :: (Applicative a, Unionable b) => a b -> a b -> a b
(|>) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(>|) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(|<|) :: (Applicative a, Unionable b) => a b -> a b -> a b
(|<) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(<|) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(#) :: Unionable b => Pattern b -> Pattern b -> Pattern b

-- | Turns a list of values into a pattern, playing one of them per cycle.
fromList :: [a] -> Pattern a

-- | Turns a list of values into a pattern, playing all of them per cycle.
fastFromList :: [a] -> Pattern a

-- | A synonym for <a>fastFromList</a>
listToPat :: [a] -> Pattern a

-- | 'fromMaybes; is similar to <a>fromList</a>, but allows values to be
--   optional using the <a>Maybe</a> type, so that <a>Nothing</a> results
--   in gaps in the pattern.
fromMaybes :: [Maybe a] -> Pattern a

-- | A pattern of whole numbers from 0 to the given number, in a single
--   cycle.
run :: (Enum a, Num a) => Pattern a -> Pattern a
_run :: (Enum a, Num a) => a -> Pattern a

-- | From <tt>1</tt> for the first cycle, successively adds a number until
--   it gets up to <tt>n</tt>
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
append :: Pattern a -> Pattern a -> Pattern a

-- | Like <a>append</a>, 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.
cat :: [Pattern a] -> Pattern a

-- | Alias for <a>cat</a>
slowCat :: [Pattern a] -> Pattern a
slowcat :: [Pattern a] -> Pattern a

-- | Alias for <a>append</a>
slowAppend :: Pattern a -> Pattern a -> Pattern a
slowappend :: Pattern a -> Pattern a -> Pattern a

-- | Like <a>append</a>, but twice as fast
fastAppend :: Pattern a -> Pattern a -> Pattern a
fastappend :: Pattern a -> Pattern a -> Pattern a

-- | The same as <a>cat</a>, but speeds up the result by the number of
--   patterns there are, so the cycles from each are squashed to fit a
--   single cycle.
fastCat :: [Pattern a] -> Pattern a
fastcat :: [Pattern a] -> Pattern a

-- | Similar to <tt>fastCat</tt>, but each pattern is given a relative
--   duration
timeCat :: [(Time, Pattern a)] -> Pattern a

-- | <a>overlay</a> combines two <a>Pattern</a>s into a new pattern, so
--   that their events are combined over time.
overlay :: Pattern a -> Pattern a -> Pattern a

-- | An infix alias of <tt>overlay</tt>
(<>) :: Pattern a -> Pattern a -> Pattern a

-- | <a>stack</a> combines a list of <a>Pattern</a>s into a new pattern, so
--   that their events are combined over time.
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

-- | Speed up a pattern by the given time pattern
fast :: Pattern Time -> Pattern a -> Pattern a

-- | Slow down a pattern by the factors in the given time pattern,
--   <tt>squeezing</tt> the pattern to fit the slot given in the time
--   pattern
fastSqueeze :: Pattern Time -> Pattern a -> Pattern a

-- | An alias for <tt>fast</tt>
density :: Pattern Time -> Pattern a -> Pattern a
_fast :: Time -> Pattern a -> Pattern a

-- | Slow down a pattern by the given time pattern
slow :: Pattern Time -> Pattern a -> Pattern a
_slow :: Time -> Pattern a -> Pattern a

-- | Slow down a pattern by the factors in the given time pattern,
--   <tt>squeezing</tt> the pattern to fit the slot given in the time
--   pattern
slowSqueeze :: Pattern Time -> Pattern a -> Pattern a

-- | An alias for <tt>slow</tt>
sparsity :: Pattern Time -> Pattern a -> Pattern a

-- | <tt>rev p</tt> returns <tt>p</tt> with the event positions in each
--   cycle reversed (or mirrored).
rev :: 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:
--   
--   <pre>
--   d1 $ zoom (0.25, 0.75) $ sound "bd*2 hh*3 [sn bd]*2 drum"
--   </pre>
--   
--   In the pattern above, <a>zoom</a> is used with an arc from 25% to 75%.
--   It is equivalent to this pattern:
--   
--   <pre>
--   d1 $ sound "hh*3 [sn bd]*2"
--   </pre>
zoom :: (Time, Time) -> Pattern a -> Pattern a
zoomArc :: Arc -> Pattern a -> Pattern a

-- | <tt>fastGap</tt> is similar to <a>fast</a> but maintains its cyclic
--   alignment. For example, <tt>fastGap 2 p</tt> would squash the events
--   in pattern <tt>p</tt> 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 <tt>fastGap</tt>
densityGap :: Pattern Time -> Pattern a -> Pattern a
compress :: (Time, Time) -> Pattern a -> Pattern a
compressTo :: (Time, Time) -> Pattern a -> Pattern a
repeatCycles :: Pattern Int -> Pattern a -> Pattern a
_repeatCycles :: Int -> Pattern a -> Pattern a
fastRepeatCycles :: Int -> Pattern a -> Pattern a

-- | <ul>
--   <li>Higher order functions</li>
--   </ul>
--   
--   Functions which work on other functions (higher order functions)
--   
--   <tt>every n f p</tt> applies the function <tt>f</tt> to <tt>p</tt>,
--   but only affects every <tt>n</tt> cycles.
every :: Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_every :: Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <tt>every n o f'</tt> is like <tt>every n f</tt> with an offset of
--   <tt>o</tt> cycles
every' :: Pattern Int -> Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_every' :: Int -> Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <tt>foldEvery ns f p</tt> applies the function <tt>f</tt> to
--   <tt>p</tt>, and is applied for each cycle in <tt>ns</tt>.
foldEvery :: [Int] -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | Only <a>when</a> the given test function returns <a>True</a> the given
--   pattern transformation is applied. The test function will be called
--   with the current cycle as a number.
--   
--   <pre>
--   d1 $ when ((elem '4').show)
--     (striate 4)
--     $ sound "hh hc"
--   </pre>
--   
--   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 <a>when</a>, but works on continuous time values rather than
--   cycle numbers.
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]
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]
m9sharp5 :: Num a => [a]
sevenSharp5flat9 :: Num a => [a]
m7sharp5flat9 :: Num a => [a]
elevenSharp :: Num a => [a]
m11sharp :: Num a => [a]

-- | <tt>chordate cs m n</tt> selects the <tt>n</tt>th "chord" (a chord is
--   a list of Ints) from a list of chords <tt>cs</tt> and transposes it by
--   <tt>m</tt> chordate :: Num b =&gt; [[b]] -&gt; b -&gt; Int -&gt; [b]
--   chordate cs m n = map (+m) $ cs!!n
--   
--   <tt>enchord chords pn pc</tt> turns every note in the note pattern
--   <tt>pn</tt> into a chord, selecting from the chord lists
--   <tt>chords</tt> using the index pattern <tt>pc</tt>. For example,
--   <tt>Chords.enchord [Chords.major Chords.minor] "c g" "0 1"</tt> will
--   create a pattern of a C-major chord followed by a G-minor chord.
--   enchord :: Num a =&gt; [[a]] -&gt; Pattern a -&gt; Pattern Int -&gt;
--   Pattern a enchord chords pn pc = flatpat $ (chordate chords) <a>$</a>
--   pn <a>*</a> pc
chordTable :: Num a => [(String, [a])]
chordL :: Num a => Pattern String -> Pattern [a]
chordList :: String

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 <a>!!</a> selects <tt>n</tt>th element from xs, but wraps over at
--   the end of <tt>xs</tt>
--   
--   <pre>
--   &gt;&gt;&gt; map ((!!!) [1,3,5]) [0,1,2,3,4,5]
--   [1,3,5,1,3,5]
--   </pre>
(!!!) :: [a] -> Int -> a

-- | Safer version of !! -
nth :: Int -> [a] -> Maybe a
accumulate :: Num t => [t] -> [t]

-- | enumerate a list of things
--   
--   <pre>
--   &gt;&gt;&gt; enumerate ["foo","bar","baz"]
--   [(1,"foo"), (2,"bar"), (3,"baz")]
--   </pre>
enumerate :: [a] -> [(Int, a)]

-- | split given list of <tt>a</tt> by given single a, e.g.
--   
--   <pre>
--   &gt;&gt;&gt; wordsBy (== ':') "bd:3"
--   ["bd", "3"]
--   </pre>
wordsBy :: (a -> Bool) -> [a] -> [[a]]
deltaMini :: String -> String
matchMaybe :: Maybe a -> Maybe a -> Maybe a
fromRight :: b -> Either a b -> b

module Sound.Tidal.Tempo
data Tempo
Tempo :: Time -> Rational -> Time -> Bool -> Double -> UDP -> SockAddr -> Bool -> Tempo
[atTime] :: Tempo -> Time
[atCycle] :: Tempo -> Rational
[cps] :: Tempo -> Time
[paused] :: Tempo -> Bool
[nudged] :: Tempo -> Double
[localUDP] :: Tempo -> UDP
[remoteAddr] :: Tempo -> SockAddr
[synched] :: Tempo -> Bool
data State
State :: Int -> Time -> (Time, Time) -> Arc -> Bool -> State
[ticks] :: State -> Int
[start] :: State -> Time
[nowTimespan] :: State -> (Time, Time)
[nowArc] :: State -> Arc
[starting] :: State -> Bool
changeTempo :: MVar Tempo -> (Time -> Tempo -> Tempo) -> IO Tempo
changeTempo' :: Tempo -> Time -> Rational -> Tempo
resetCycles :: MVar Tempo -> IO Tempo
setCps :: MVar Tempo -> Time -> IO Tempo
defaultCps :: Time
defaultTempo :: Time -> UDP -> SockAddr -> Tempo

-- | Returns the given time in terms of cycles relative to metrical grid of
--   a given Tempo
timeToCycles :: Tempo -> Time -> Rational
cyclesToTime :: Tempo -> Rational -> Time
clocked :: Config -> MVar Tempo -> (State -> IO ()) -> IO [ThreadId]
clientListen :: Config -> MVar Tempo -> Time -> IO ThreadId
sendTempo :: Tempo -> IO ()
listenTempo :: UDP -> MVar Tempo -> IO ()
serverListen :: Config -> IO (Maybe ThreadId)
instance GHC.Show.Show Sound.Tidal.Tempo.Tempo
instance GHC.Show.Show Sound.Tidal.Tempo.State
instance GHC.Classes.Eq Sound.Tidal.Tempo.Tempo
instance GHC.Show.Show Sound.OSC.Transport.FD.UDP.UDP

module Sound.Tidal.Scales
scale :: Fractional a => Pattern String -> Pattern Int -> Pattern a
scaleList :: String
scaleTable :: Fractional a => [(String, [a])]
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

-- | Param makers
pF :: String -> Pattern Double -> ControlPattern
pI :: String -> Pattern Int -> ControlPattern
pB :: String -> Pattern Bool -> ControlPattern
pR :: String -> Pattern Rational -> ControlPattern
pN :: String -> Pattern Note -> ControlPattern
pS :: String -> Pattern String -> ControlPattern
pX :: String -> Pattern [Word8] -> ControlPattern
pStateF :: String -> String -> (Maybe Double -> Double) -> ControlPattern
pStateList :: String -> String -> [Value] -> ControlPattern
pStateListF :: String -> String -> [Double] -> ControlPattern
pStateListS :: String -> String -> [String] -> ControlPattern

-- | Grouped params
sound :: Pattern String -> ControlPattern
sTake :: String -> [String] -> ControlPattern
cc :: Pattern String -> ControlPattern
nrpn :: Pattern String -> ControlPattern
nrpnn :: Pattern Int -> ControlPattern
nrpnv :: Pattern Int -> ControlPattern
grain' :: Pattern String -> ControlPattern
midinote :: Pattern Note -> ControlPattern
drum :: Pattern String -> ControlPattern
drumN :: Num a => String -> a

-- | a pattern of numbers that speed up (or slow down) samples while they
--   play.
accelerate :: Pattern Double -> ControlPattern
accelerateTake :: String -> [Double] -> ControlPattern
accelerateCount :: String -> ControlPattern
accelerateCountTo :: String -> Pattern Double -> Pattern ValueMap
acceleratebus :: Pattern Int -> Pattern Double -> ControlPattern
acceleraterecv :: Pattern Int -> ControlPattern

-- | like <tt>gain</tt>, but linear.
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

-- | a pattern of numbers from 0 to 1. Skips the beginning of each sample,
--   e.g. `0.25` to cut off the first quarter from each sample.
begin :: Pattern Double -> ControlPattern
beginTake :: String -> [Double] -> ControlPattern
beginCount :: String -> ControlPattern
beginCountTo :: String -> Pattern Double -> Pattern ValueMap
beginbus :: Pattern Int -> Pattern Double -> ControlPattern
beginrecv :: Pattern Int -> 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

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, <a>cut</a> 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
--   <a>room</a> and <a>size</a> 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

-- | the same as <a>begin</a>, but cuts the end off samples, shortening
--   them; e.g. `0.75` to cut off the last quarter of each sample.
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 begin<i>end or chop</i>striate and friends, to change
--   the fade out time of the <tt>grain</tt> 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

-- | a pattern of numbers that specify volume. Values less than 1 make the
--   sound quieter. Values greater than 1 make the sound louder. For the
--   linear equivalent, see <tt>amp</tt>.
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 <tt>hpf</tt>
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 <a>attack</a>
--   and <a>release</a> 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 <tt>hpq</tt>
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 <a>begin</a> to <a>end</a>) 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

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 <a>orbit</a> 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 <a>phaserrate</a> and
--   <a>phaserdepth</a>
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 <a>phaserrate</a> and
--   <a>phaserdepth</a>
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 <a>speed</a>
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 <a>room</a> 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, i.e.
--   a cheap way of changing pitch. Negative values will play the sample
--   backwards!
speed :: Pattern Double -> ControlPattern
speedTake :: String -> [Double] -> ControlPattern
speedCount :: String -> ControlPattern
speedCountTo :: String -> Pattern Double -> Pattern ValueMap
speedbus :: Pattern Int -> Pattern Double -> ControlPattern

squiz :: Pattern Double -> ControlPattern
squizTake :: String -> [Double] -> ControlPattern
squizCount :: String -> ControlPattern
squizCountTo :: String -> Pattern Double -> Pattern ValueMap
squizbus :: Pattern Int -> Pattern Double -> ControlPattern
squizrecv :: Pattern Int -> ControlPattern

stepsPerOctave :: Pattern Double -> ControlPattern
stepsPerOctaveTake :: String -> [Double] -> ControlPattern
stepsPerOctaveCount :: String -> ControlPattern
stepsPerOctaveCountTo :: String -> Pattern Double -> Pattern ValueMap
stepsPerOctavebus :: Pattern Int -> Pattern Double -> ControlPattern
stepsPerOctaverecv :: Pattern Int -> ControlPattern

stutterdepth :: Pattern Double -> ControlPattern
stutterdepthTake :: String -> [Double] -> ControlPattern
stutterdepthCount :: String -> ControlPattern
stutterdepthCountTo :: String -> Pattern Double -> Pattern ValueMap
stutterdepthbus :: Pattern Int -> Pattern Double -> ControlPattern
stutterdepthrecv :: Pattern Int -> ControlPattern

stuttertime :: Pattern Double -> ControlPattern
stuttertimeTake :: String -> [Double] -> ControlPattern
stuttertimeCount :: String -> ControlPattern
stuttertimeCountTo :: String -> Pattern Double -> Pattern ValueMap
stuttertimebus :: Pattern Int -> Pattern Double -> ControlPattern
stuttertimerecv :: Pattern Int -> ControlPattern

sustain :: Pattern Double -> ControlPattern
sustainTake :: String -> [Double] -> ControlPattern
sustainCount :: String -> ControlPattern
sustainCountTo :: String -> Pattern Double -> Pattern ValueMap
sustainbus :: Pattern Int -> Pattern Double -> ControlPattern

sustainpedal :: Pattern Double -> ControlPattern
sustainpedalTake :: String -> [Double] -> ControlPattern
sustainpedalCount :: String -> ControlPattern
sustainpedalCountTo :: String -> Pattern Double -> Pattern ValueMap
sustainpedalbus :: Pattern Int -> Pattern Double -> ControlPattern
sustainpedalrecv :: Pattern Int -> ControlPattern

-- | 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 <a>tremolorate</a> and
--   <a>tremolodepth</a>
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 <a>tremolorate</a> and
--   <a>tremolodepth</a>
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 <a>speed</a>, accepts values of "r" (rate,
--   default behavior), "c" (cycles), or "s" (seconds). Using `unit "c"`
--   means <a>speed</a> 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 <a>speed</a>.
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
--   <tt>a</tt>, <tt>e</tt>, <tt>i</tt>, <tt>o</tt> or <tt>u</tt>. 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
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

module Sound.Tidal.UI

-- | Randomisation
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]

-- | <a>rand</a> generates a continuous pattern of (pseudo-)random numbers
--   between `0` and `1`.
--   
--   <pre>
--   sound "bd*8" # pan rand
--   </pre>
--   
--   pans bass drums randomly
--   
--   <pre>
--   sound "sn sn ~ sn" # gain rand
--   </pre>
--   
--   makes the snares' randomly loud and quiet.
--   
--   Numbers coming from this pattern are <tt>seeded</tt> by time. So if
--   you reset time (via `cps (-1)`, then `cps 1.1` or whatever cps you
--   want to restart with) 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:
--   
--   <pre>
--   jux ( gain rand
--   </pre>
--   
--   and with the juxed version shifted backwards for 1024 cycles:
--   
--   <pre>
--   jux ( gain rand
--   </pre>
rand :: Fractional a => Pattern a

-- | Boolean rand - a continuous stream of true<i>false values, with a
--   50</i>50 chance.
brand :: Pattern Bool

-- | Boolean rand with probability as input, e.g. brandBy 0.25 is 25%
--   chance of being true.
brandBy :: Pattern Double -> Pattern Bool
_brandBy :: Double -> Pattern Bool

-- | Just like <a>rand</a> 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:
--   
--   <pre>
--   d1 $ segment 4 $ n (irand 5) # sound "drum"
--   </pre>
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. <a>perlinWith</a> takes a pattern as the
--   RNG's "input" instead of automatically using the cycle count. <tt> d1
--   $ s "arpy*32" # cutoff (perlinWith (saw * 4) * 2000) </tt> will
--   generate a smooth random pattern for the cutoff frequency which will
--   repeat every cycle (because the saw does) The <a>perlin</a> function
--   uses the cycle count as input and can be used much like <tt>rand</tt>.
perlinWith :: Pattern Double -> Pattern Double
perlin :: Pattern Double
perlin2With :: Pattern Double -> Pattern Double -> Pattern Double
perlin2 :: Pattern Double -> Pattern Double

-- | Randomly picks an element from the given list
--   
--   <pre>
--   sound "superpiano(3,8)" # note (choose ["a", "e", "g", "c"])
--   </pre>
--   
--   plays a melody randomly choosing one of the four notes "a", "e", "g",
--   "c".
choose :: [a] -> Pattern a
chooseBy :: Pattern Double -> [a] -> Pattern a

-- | Like <tt>choose</tt>, but works on an a list of tuples of values and
--   weights
--   
--   <pre>
--   sound "superpiano(3,8)" # note (wchoose [("a",1), ("e",0.5), ("g",2), ("c",1)])
--   </pre>
--   
--   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 :: [(a, Double)] -> Pattern a
wchooseBy :: Pattern Double -> [(a, Double)] -> Pattern a

-- | Similar to <a>degrade</a> <a>degradeBy</a> allows you to control the
--   percentage of events that are removed. For example, to remove events
--   90% of the time:
--   
--   <pre>
--   d1 $ slow 2 $ degradeBy 0.9 $ sound "[[[feel:5*8,feel*3] feel:3*8], feel*4]"
--      # accelerate "-6"
--      # speed "2"
--   </pre>
degradeBy :: Pattern Double -> Pattern a -> Pattern a
_degradeBy :: Double -> Pattern a -> Pattern a
_degradeByUsing :: Pattern Double -> Double -> Pattern a -> Pattern a
unDegradeBy :: Pattern Double -> Pattern a -> Pattern a
_unDegradeBy :: Double -> Pattern a -> Pattern a
degradeOverBy :: Int -> Pattern Double -> Pattern a -> Pattern a

-- | Use <tt>sometimesBy</tt> to apply a given function "sometimes". For
--   example, the following code results in `density 2` being applied about
--   25% of the time:
--   
--   <pre>
--   d1 $ sometimesBy 0.25 (density 2) $ sound "bd*8"
--   </pre>
--   
--   There are some aliases as well:
--   
--   <pre>
--   sometimes = sometimesBy 0.5
--   often = sometimesBy 0.75
--   rarely = sometimesBy 0.25
--   almostNever = sometimesBy 0.1
--   almostAlways = sometimesBy 0.9
--   </pre>
sometimesBy :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
sometimesBy' :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <tt>sometimes</tt> is an alias for sometimesBy 0.5.
sometimes :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
sometimes' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <tt>often</tt> is an alias for sometimesBy 0.75.
often :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
often' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <tt>rarely</tt> is an alias for sometimesBy 0.25.
rarely :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
rarely' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <tt>almostNever</tt> is an alias for sometimesBy 0.1
almostNever :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
almostNever' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <tt>almostAlways</tt> is an alias for sometimesBy 0.9
almostAlways :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
almostAlways' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
never :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
always :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <tt>someCyclesBy</tt> is a cycle-by-cycle version of
--   <tt>sometimesBy</tt>. It has a `someCycles = someCyclesBy 0.5` alias
someCyclesBy :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_someCyclesBy :: Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
somecyclesBy :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
someCycles :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
somecycles :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <a>degrade</a> randomly removes events from a pattern 50% of the time:
--   
--   <pre>
--   d1 $ slow 2 $ degrade $ sound "[[[feel:5*8,feel*3] feel:3*8], feel*4]"
--      # accelerate "-6"
--      # speed "2"
--   </pre>
--   
--   The shorthand syntax for <a>degrade</a> is a question mark:
--   <tt>?</tt>. Using <tt>?</tt> will allow you to randomly remove events
--   from a portion of a pattern:
--   
--   <pre>
--   d1 $ slow 2 $ sound "bd ~ sn bd ~ bd? [sn bd?] ~"
--   </pre>
--   
--   You can also use <tt>?</tt> to randomly remove events from entire
--   sub-patterns:
--   
--   <pre>
--   d1 $ slow 2 $ sound "[[[feel:5*8,feel*3] feel:3*8]?, feel*4]"
--   </pre>
degrade :: Pattern a -> Pattern a

-- | (The above means that <a>brak</a> is a function from patterns of any
--   type, to a pattern of the same type.)
--   
--   Make a pattern sound a bit like a breakbeat
--   
--   Example:
--   
--   <pre>
--   d1 $ sound (brak "bd sn kurt")
--   </pre>
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:
--   
--   <pre>
--   d1 $ iter 4 $ sound "bd hh sn cp"
--   </pre>
--   
--   This will produce the following over four cycles:
--   
--   <pre>
--   bd hh sn cp
--   hh sn cp bd
--   sn cp bd hh
--   cp bd hh sn
--   </pre>
--   
--   There is also <a>iter</a>`, which shifts the pattern in the opposite
--   direction.
iter :: Pattern Int -> Pattern c -> Pattern c
_iter :: Int -> Pattern a -> Pattern a

-- | <tt>iter'</tt> is the same as <tt>iter</tt>, but decrements the
--   starting subdivision instead of incrementing it.
iter' :: Pattern Int -> Pattern c -> Pattern c
_iter' :: Int -> Pattern a -> Pattern a

-- | <tt>palindrome p</tt> applies <tt>rev</tt> to <tt>p</tt> every other
--   cycle, so that the pattern alternates between forwards and backwards.
palindrome :: Pattern a -> Pattern a

-- | Composing patterns
--   
--   The function <tt>seqP</tt> allows you to define when a sound within a
--   list starts and ends. The code below contains three separate patterns
--   in a <a>stack</a>, but each has different start times (zero cycles,
--   eight cycles, and sixteen cycles, respectively). All patterns stop
--   after 128 cycles:
--   
--   <pre>
--   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)))
--   ]
--   </pre>
seqP :: [(Time, Time, Pattern a)] -> Pattern a

-- | Degrades a pattern over the given time.
fadeOut :: Time -> Pattern a -> Pattern a

-- | Alternate version to <tt>fadeOut</tt> where you can provide the time
--   from which the fade starts
fadeOutFrom :: Time -> Time -> Pattern a -> Pattern a

-- | <tt>Undegrades</tt> a pattern over the given time.
fadeIn :: Time -> Pattern a -> Pattern a

-- | Alternate version to <tt>fadeIn</tt> where you can provide the time
--   from which the fade in starts
fadeInFrom :: Time -> Time -> Pattern a -> Pattern a

-- | The <a>spread</a> function allows you to take a pattern transformation
--   which takes a parameter, such as <a>slow</a>, and provide several
--   parameters which are switched between. In other words it
--   <tt>spreads</tt> a function across several values.
--   
--   Taking a simple high hat loop as an example:
--   
--   <pre>
--   d1 $ sound "ho ho:2 ho:3 hc"
--   </pre>
--   
--   We can slow it down by different amounts, such as by a half:
--   
--   <pre>
--   d1 $ slow 2 $ sound "ho ho:2 ho:3 hc"
--   </pre>
--   
--   Or by four thirds (i.e. speeding it up by a third; `4%3` means four
--   over three):
--   
--   <pre>
--   d1 $ slow (4%3) $ sound "ho ho:2 ho:3 hc"
--   </pre>
--   
--   But if we use <a>spread</a>, we can make a pattern which alternates
--   between the two speeds:
--   
--   <pre>
--   d1 $ spread slow [2,4%3] $ sound "ho ho:2 ho:3 hc"
--   </pre>
--   
--   Note that if you pass ($) as the function to spread values over, you
--   can put functions as the list of values. For example:
--   
--   <pre>
--   d1 $ spread ($) [density 2, rev, slow 2, striate 3, (# speed "0.8")]
--       $ sound "[bd*2 [~ bd]] [sn future]*2 cp jvbass*4"
--   </pre>
--   
--   Above, the pattern will have these transforms applied to it, one at a
--   time, per cycle:
--   
--   <ul>
--   <li>cycle 1: `density 2` - pattern will increase in speed</li>
--   <li>cycle 2: <a>rev</a> - pattern will be reversed</li>
--   <li>cycle 3: `slow 2` - pattern will decrease in speed</li>
--   <li>cycle 4: `striate 3` - pattern will be granualized</li>
--   <li>cycle 5: `(# speed "0.8")` - pattern samples will be played back
--   more slowly</li>
--   </ul>
--   
--   After `(# speed "0.8")`, the transforms will repeat and start at
--   `density 2` again.
spread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b
slowspread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b

-- | <tt>fastspread</tt> works the same as <tt>spread</tt>, but the result
--   is squashed into a single cycle. If you gave four values to
--   <tt>spread</tt>, 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 <tt>slowspread</tt>, which is an alias of
--   <tt>spread</tt>.
fastspread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b

-- | There's a version of this function, <a>spread</a>` (pronounced "spread
--   prime"), which takes a *pattern* of parameters, instead of a list:
--   
--   <pre>
--   d1 $ spread' slow "2 4%3" $ sound "ho ho:2 ho:3 hc"
--   </pre>
--   
--   This is quite a messy area of Tidal - due to a slight difference of
--   implementation this sounds completely different! One advantage of
--   using <a>spread</a>` though is that you can provide polyphonic
--   parameters, e.g.:
--   
--   <pre>
--   d1 $ spread' slow "[2 4%3, 3]" $ sound "ho ho:2 ho:3 hc"
--   </pre>
spread' :: Monad m => (a -> b -> m c) -> m a -> b -> m c

-- | `spreadChoose f xs p` is similar to <a>slowspread</a> but picks values
--   from <tt>xs</tt> at random, rather than cycling through them in order.
--   It has a shorter alias <a>spreadr</a>.
spreadChoose :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b
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 that is passed the current cycle as a
--   number.
--   
--   <pre>
--   d1 $ ifp ((== 0).(flip mod 2))
--     (striate 4)
--     (# coarse "24 48") $
--     sound "hh hc"
--   </pre>
--   
--   This will apply `striate 4` for every _even_ cycle and aply `# 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 <a>True</a> or
--   <a>False</a>. This is what the <a>ifp</a> signature's first part
--   signifies `(Int -&gt; Bool)`, a function that takes a whole number and
--   returns either <a>True</a> or <a>False</a>.
ifp :: (Int -> Bool) -> (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <tt>wedge t p p'</tt> combines patterns <tt>p</tt> and <tt>p'</tt> by
--   squashing the <tt>p</tt> into the portion of each cycle given by
--   <tt>t</tt>, and <tt>p'</tt> into the remainer of each cycle.
wedge :: Time -> Pattern a -> Pattern a -> Pattern a

-- | <tt>whenmod</tt> has a similar form and behavior to <a>every</a>, but
--   requires an additional number. 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:
--   
--   <pre>
--   d1 $ whenmod 8 4 (density 2) (sound "bd sn kurt")
--   </pre>
whenmod :: Pattern Time -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_whenmod :: Time -> Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <pre>
--   superimpose f p = stack [p, f p]
--   </pre>
--   
--   <a>superimpose</a> 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.
--   
--   <pre>
--   d1 $ superimpose (density 2) $ sound "bd sn [cp ht] hh"
--   d1 $ superimpose ((# speed "2") . (0.125 &lt;~)) $ sound "bd sn cp hh"
--   </pre>
superimpose :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <tt>trunc</tt> truncates a pattern so that only a fraction of the
--   pattern is played. The following example plays only the first quarter
--   of the pattern:
--   
--   <pre>
--   d1 $ trunc 0.25 $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2"
--   </pre>
trunc :: Pattern Time -> Pattern a -> Pattern a
_trunc :: Time -> Pattern a -> Pattern a

-- | <tt>linger</tt> is similar to <a>trunc</a> but the truncated part of
--   the pattern loops until the end of the cycle.
--   
--   <pre>
--   d1 $ linger 0.25 $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2"
--   </pre>
--   
--   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:
--   
--   <pre>
--   d1 $ linger (-0.25) $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2"
--   </pre>
linger :: Pattern Time -> Pattern a -> Pattern a
_linger :: Time -> Pattern a -> Pattern a

-- | Use <a>within</a> to apply a function to only a part of a pattern. For
--   example, to apply `density 2` to only the first half of a pattern:
--   
--   <pre>
--   d1 $ within (0, 0.5) (density 2) $ sound "bd*2 sn lt mt hh hh hh hh"
--   </pre>
--   
--   Or, to apply `(# speed "0.5") to only the last quarter of a pattern:
--   
--   <pre>
--   d1 $ within (0.75, 1) (# speed "0.5") $ sound "bd*2 sn lt mt hh hh hh hh"
--   </pre>
within :: (Time, Time) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
withinArc :: Arc -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | For many cases, <tt>within'</tt> will function exactly as within. The
--   difference between the two occurs when applying functions that change
--   the timing of notes such as <a>fast</a> or <a>&lt;~</a>. 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
--   
--   <pre>
--   d1 $ within (0, 0.25) (fast 2) $ sound "bd hh cp sd"
--   </pre>
--   
--   sounds like:
--   
--   <pre>
--   d1 $ sound "[bd hh] hh cp sd"
--   </pre>
--   
--   using this alternative version, within'
--   
--   <pre>
--   d1 $ within' (0, 0.25) (fast 2) $ sound "bd hh cp sd"
--   </pre>
--   
--   sounds like:
--   
--   <pre>
--   d1 $ sound "[bd bd] hh cp sd"
--   </pre>
within' :: (Time, Time) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
revArc :: (Time, Time) -> Pattern a -> Pattern a

-- | You can use the <tt>e</tt> function to apply a Euclidean algorithm
--   over a complex pattern, although the structure of that pattern will be
--   lost:
--   
--   <pre>
--   d1 $ e 3 8 $ sound "bd*2 [sn cp]"
--   </pre>
--   
--   In the above, three sounds are picked from the pattern on the right
--   according to the structure given by the `e 3 8`. It ends up picking
--   two <tt>bd</tt> sounds, a <tt>cp</tt> and missing the <tt>sn</tt>
--   entirely.
--   
--   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](http:/<i>cgm.cs.mcgill.ca</i>~godfried<i>publications</i>banff.pdf)
--   by Toussaint. Some examples from this paper are included below,
--   including rotation in some cases.
--   
--   <pre>
--   - (2,5) : A thirteenth century Persian rhythm called Khafif-e-ramal.
--   - (3,4) : The archetypal pattern of the Cumbia from Colombia, as well as a Calypso rhythm from Trinidad.
--   - (3,5,2) : Another thirteenth century Persian rhythm by the name of Khafif-e-ramal, as well as a Rumanian folk-dance rhythm.
--   - (3,7) : A Ruchenitza rhythm used in a Bulgarian folk-dance.
--   - (3,8) : The Cuban tresillo pattern.
--   - (4,7) : Another Ruchenitza Bulgarian folk-dance rhythm.
--   - (4,9) : The Aksak rhythm of Turkey.
--   - (4,11) : The metric pattern used by Frank Zappa in his piece titled Outside Now.
--   - (5,6) : Yields the York-Samai pattern, a popular Arab rhythm.
--   - (5,7) : The Nawakhat pattern, another popular Arab rhythm.
--   - (5,8) : The Cuban cinquillo pattern.
--   - (5,9) : A popular Arab rhythm called Agsag-Samai.
--   - (5,11) : The metric pattern used by Moussorgsky in Pictures at an Exhibition.
--   - (5,12) : The Venda clapping pattern of a South African children’s song.
--   - (5,16) : The Bossa-Nova rhythm necklace of Brazil.
--   - (7,8) : A typical rhythm played on the Bendir (frame drum).
--   - (7,12) : A common West African bell pattern.
--   - (7,16,14) : A Samba rhythm necklace from Brazil.
--   - (9,16) : A rhythm necklace used in the Central African Republic.
--   - (11,24,14) : A rhythm necklace of the Aka Pygmies of Central Africa.
--   - (13,24,5) : Another rhythm necklace of the Aka Pygmies of the upper Sangha.
--   </pre>
euclid :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_euclid :: Int -> Int -> Pattern a -> Pattern a

-- | `euclidfull n k pa pb` stacks <tt>e n k pa</tt> with <tt>einv n k
--   pb</tt>
euclidFull :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a -> Pattern a
_euclidBool :: Int -> Int -> Pattern Bool
_euclid' :: Int -> Int -> Pattern a -> Pattern a
euclidOff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
eoff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_euclidOff :: Int -> Int -> Int -> Pattern a -> Pattern a
euclidOffBool :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern Bool -> Pattern Bool
_euclidOffBool :: Int -> Int -> Int -> Pattern Bool -> Pattern Bool
distrib :: [Pattern Int] -> Pattern a -> Pattern a
_distrib :: [Int] -> Pattern a -> Pattern a

-- | <a>euclidInv</a> fills in the blanks left by <tt>e</tt> - <tt>e 3 8
--   "x"</tt> -&gt; <tt>"x ~ ~ x ~ ~ x ~"</tt>
--   
--   <tt>euclidInv 3 8 "x"</tt> -&gt; <tt>"~ x x ~ x x ~ x"</tt>
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

-- | <tt>rot n p</tt> rotates the values in a pattern <tt>p</tt> by
--   <tt>n</tt> beats to the left. Example: <tt>d1 $ every 4 (rot 2) $ slow
--   2 $ sound "bd hh hh hh"</tt>
rot :: Ord a => Pattern Int -> Pattern a -> Pattern a
_rot :: Ord a => Int -> Pattern a -> Pattern a

-- | <tt>segment n p</tt>: <a>samples</a> the pattern <tt>p</tt> at a rate
--   of <tt>n</tt> events per cycle. Useful for turning a continuous
--   pattern into a discrete one.
segment :: Pattern Time -> Pattern a -> Pattern a
_segment :: Time -> Pattern a -> Pattern a

-- | <tt>discretise</tt>: the old (deprecated) name for <a>segment</a>
discretise :: Pattern Time -> Pattern a -> Pattern a

-- | <tt>randcat ps</tt>: does a <tt>slowcat</tt> on the list of patterns
--   <tt>ps</tt> but randomises the order in which they are played.
randcat :: [Pattern a] -> Pattern a
wrandcat :: [(Pattern a, Double)] -> Pattern a

-- | The <a>fit</a> 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:
--   
--   <pre>
--   d1 $ sound (fit 3 ["bd", "sn", "arpy", "arpy:1", "casio"] "0 [~ 1] 2 1")
--   </pre>
--   
--   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 :: Int -> [a] -> Pattern Int -> Pattern a
fit :: Pattern Int -> [a] -> Pattern Int -> Pattern a
permstep :: RealFrac b => Int -> [a] -> Pattern b -> Pattern a

-- | <tt>struct a b</tt>: structures pattern <tt>b</tt> in terms of the
--   pattern of boolean values <tt>a</tt>. Only <tt>True</tt> values in the
--   boolean pattern are used.
struct :: Pattern Bool -> Pattern a -> Pattern a

-- | <tt>substruct a b</tt>: similar to <tt>struct</tt>, but each event in
--   pattern <tt>a</tt> gets replaced with pattern <tt>b</tt>, 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

-- | <tt>stripe n p</tt>: repeats pattern <tt>p</tt>, <tt>n</tt> times per
--   cycle. So similar to <tt>fast</tt>, but with random durations. The
--   repetitions will be continguous (touching, but not overlapping) and
--   the durations will add up to a single cycle. <tt>n</tt> can be
--   supplied as a pattern of integers.
stripe :: Pattern Int -> Pattern a -> Pattern a
_stripe :: Int -> Pattern a -> Pattern a

-- | <tt>slowstripe n p</tt>: The same as <tt>stripe</tt>, but the result
--   is also <tt>n</tt> times slower, so that the mean average duration of
--   the stripes is exactly one cycle, and every <tt>n</tt>th stripe starts
--   on a cycle boundary (in indian classical terms, the <tt>sam</tt>).
slowstripe :: Pattern Int -> Pattern a -> Pattern a
parseLMRule :: String -> [(String, String)]
parseLMRule' :: String -> [(Char, String)]

-- | returns the <tt>n</tt>th iteration of a <a>Lindenmayer System</a> with
--   given start sequence.
--   
--   for example:
--   
--   <pre>
--   lindenmayer 1 "a:b,b:ab" "ab" -&gt; "bab"
--   </pre>
lindenmayer :: Int -> String -> String -> String

-- | <tt>lindenmayerI</tt> converts the resulting string into a a list of
--   integers with <tt>fromIntegral</tt> applied (so they can be used
--   seamlessly where floats or rationals are required)
lindenmayerI :: Num b => Int -> String -> String -> [b]

-- | <tt>runMarkov n tmat xi seed</tt> generates a Markov chain (as a list)
--   of length <tt>n</tt> using the transition matrix <tt>tmat</tt>
--   starting from initial state <tt>xi</tt>, starting with random numbers
--   generated from <tt>seed</tt> Each entry in the chain is the index of
--   state (starting from zero). Each row of the matrix will be
--   automatically normalized. For example: <tt> runMarkov 8 [[2,3], [1,3]]
--   0 0 </tt> will produce a two-state chain 8 steps long, from initial
--   state <tt>0</tt>, where the transition probability from state 0-&gt;0
--   is 2<i>5, 0-&gt;1 is 3</i>5, 1-&gt;0 is 1/4, and 1-&gt;1 is 3/4.
runMarkov :: Int -> [[Double]] -> Int -> Time -> [Int]
markovPat :: Pattern Int -> Pattern Int -> [[Double]] -> Pattern Int
_markovPat :: Int -> Int -> [[Double]] -> Pattern Int

-- | Removes events from second pattern that don't start during an event
--   from first.
--   
--   Consider this, kind of messy rhythm without any rests.
--   
--   <pre>
--   d1 $ sound (slowcat ["sn*8", "[cp*4 bd*4, hc*5]"]) # n (run 8)
--   </pre>
--   
--   If we apply a mask to it
--   
--   <pre>
--   d1 $ s (mask ("1 1 1 ~ 1 1 ~ 1" :: Pattern Bool)
--     (slowcat ["sn*8", "[cp*4 bd*4, bass*5]"] ))
--     # n (run 8)
--   </pre>
--   
--   Due to the use of <a>slowcat</a> 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
--   <a>slowcat</a> 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.
--   
--   <pre>
--   d1 $ s (mask ("1 ~ 1 ~ 1 1 ~ 1")
--     (slowcat ["can*8", "[cp*4 sn*4, jvbass*16]"] ))
--     # n (run 8)
--   </pre>
mask :: Pattern Bool -> Pattern a -> Pattern a

-- | TODO: refactor towards union
enclosingArc :: [Arc] -> Arc
stretch :: Pattern a -> Pattern a

-- | <a>fit</a>` is a generalization of <a>fit</a>, 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:
--   
--   <pre>
--   d1 $ sound (fit' 1 2 "0 1" "1 0" "bd sn")
--   </pre>
--   
--   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 <a>fit</a>. 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
--   
--   <pre>
--   d1 $ fit' 1 4 (run 4) "[0 3*2 2 1 0 3*2 2 [1*8 ~]]/2" $ chop 4 $ (sound "breaks152" # unit "c")
--   </pre>
--   
--   which uses <tt>chop</tt> to break a single sample into individual
--   pieces, which <a>fit</a>` 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

-- | <tt>chunk n f p</tt> treats the given pattern <tt>p</tt> as having
--   <tt>n</tt> chunks, and applies the function <tt>f</tt> to one of those
--   sections per cycle, running from left to right.
--   
--   <pre>
--   d1 $ chunk 4 (density 4) $ sound "cp sn arpy [mt lt]"
--   </pre>
_chunk :: Int -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b
chunk :: Pattern Int -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b
runWith :: Int -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b

-- | <tt>chunk'</tt> works much the same as <a>chunk</a>, but runs from
--   right to left.
_chunk' :: Integral a => a -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b
chunk' :: Integral a1 => Pattern a1 -> (Pattern a2 -> Pattern a2) -> Pattern a2 -> Pattern a2
inside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a
outside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a
loopFirst :: Pattern a -> Pattern a
timeLoop :: Pattern Time -> Pattern a -> Pattern a
seqPLoop :: [(Time, Time, Pattern a)] -> Pattern a

-- | <tt>toScale</tt> 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"`. It assumes your
--   scale fits within an octave; to change this use <a>toScale</a> size`.
--   Example: <a>toScale</a> 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
toScale :: Num a => [a] -> Pattern Int -> Pattern a

-- | `swingBy x n` divides a cycle into <tt>n</tt> slices and delays the
--   notes in the second half of each slice by <tt>x</tt> fraction of a
--   slice . <tt>swing</tt> is an alias for `swingBy (1%3)`
swingBy :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a
swing :: Pattern Time -> Pattern a -> Pattern a

-- | <a>cycleChoose</a> is like <a>choose</a> but only picks a new item
--   from the list once each cycle
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 <tt>p</tt> into
--   <tt>n</tt> 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.
shuffle :: Pattern Int -> Pattern a -> Pattern a
_shuffle :: Int -> Pattern a -> Pattern a

-- | `scramble n p` is like <a>shuffle</a> but randomly selects from the
--   parts of <tt>p</tt> 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.
scramble :: Pattern Int -> Pattern a -> Pattern a
_scramble :: Int -> Pattern a -> Pattern a
randrun :: Int -> Pattern Int
ur :: Time -> Pattern String -> [(String, Pattern a)] -> [(String, Pattern a -> Pattern a)] -> Pattern a
inhabit :: [(String, Pattern a)] -> Pattern String -> Pattern a

-- | <tt>spaceOut xs p</tt> repeats a pattern <tt>p</tt> at different
--   durations given by the list of time values in <tt>xs</tt>
spaceOut :: [Time] -> Pattern a -> Pattern a

-- | <tt>flatpat</tt> takes a Pattern of lists and pulls the list elements
--   as separate Events
flatpat :: Pattern [a] -> Pattern a

-- | <tt>layer</tt> takes a Pattern of lists and pulls the list elements as
--   separate Events
layer :: [a -> Pattern b] -> a -> Pattern b

-- | <tt>arpeggiate</tt> finds events that share the same timespan, and
--   spreads them out during that timespan, so for example <tt>arpeggiate
--   "[bd,sn]"</tt> gets turned into <tt>"bd sn"</tt>. 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
arp :: Pattern String -> Pattern a -> Pattern a
_arp :: String -> Pattern a -> Pattern a
ply :: Pattern Rational -> Pattern a -> Pattern a
_ply :: Rational -> Pattern a -> Pattern a
plyWith :: (Ord t, Num t) => Pattern t -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_plyWith :: (Ord t, Num t) => t -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | Syncopates a rhythm, shifting each event halfway into its arc (aka
--   timespan), e.g. <tt>"a b [c d] e"</tt> becomes the equivalent of
--   <tt>"[~ a] [~ b] [[~ c] [~ d]] [~ e]"</tt>
press :: Pattern a -> Pattern a

-- | Like <tt>press</tt>, but allows you to specify the amount in which
--   each event is shifted. <tt>pressBy 0.5</tt> is the same as
--   <tt>press</tt>, while <tt>pressBy (1/3)</tt> shifts each event by a
--   third of its arc.
pressBy :: Pattern Time -> Pattern a -> Pattern a
_pressBy :: Time -> Pattern a -> Pattern a

-- | Uses the first (binary) pattern to switch between the following two
--   patterns. The resulting structure comes from the source patterns, not
--   the binary pattern. See also <tt>stitch</tt>.
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. See also <tt>sew</tt>.
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 <tt>True</tt> value is active,
--   and the pattern is let through unchanged when a <tt>False</tt> 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 :: Integral i => i -> Time -> Pattern a -> Pattern a
echo :: Time -> Pattern a -> Pattern a
triple :: Time -> Pattern a -> Pattern a
quad :: Time -> Pattern a -> Pattern a
double :: Time -> Pattern a -> Pattern a

-- | The <a>jux</a> 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:
--   
--   <pre>
--   d1 $ slow 32 $ jux (rev) $ striateBy 32 (1/16) $ sound "bev"
--   </pre>
--   
--   When passing pattern transforms to functions like <a>jux</a> and
--   <a>every</a>, it's possible to chain multiple transforms together with
--   <a>.</a>, for example this both reverses and halves the playback speed
--   of the pattern in the righthand channel:
--   
--   <pre>
--   d1 $ slow 32 $ jux ((# speed "0.5") . rev) $ striateBy 32 (1/16) $ sound "bev"
--   </pre>
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 <a>jux</a>, <a>jux</a>` allows using a list of pattern
--   transform. resulting patterns from each transformation will be spread
--   via pan from left to right.
--   
--   For example:
--   
--   <pre>
--   d1 $ jux' [iter 4, chop 16, id, rev, palindrome] $ sound "bd sn"
--   </pre>
--   
--   will put `iter 4` of the pattern to the far left and <a>palindrome</a>
--   to the far right. In the center the original pattern will play and mid
--   left mid right the chopped and the reversed version will appear.
--   
--   One could also write:
--   
--   <pre>
--   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",
--       ]
--   </pre>
jux' :: [t -> Pattern ValueMap] -> t -> Pattern ValueMap

-- | Multichannel variant of <a>jux</a>, _not sure what it does_
jux4 :: (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap

-- | With <a>jux</a>, 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
--   <a>juxBy</a> has an additional parameter, which brings the channel
--   closer to the centre. For example:
--   
--   <pre>
--   d1 $ juxBy 0.5 (density 2) $ sound "bd sn:1"
--   </pre>
--   
--   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
pick :: String -> Int -> String
samples :: Applicative f => f String -> f Int -> f String
samples' :: Applicative f => f String -> f Int -> f String
spreadf :: [a -> Pattern b] -> a -> Pattern b
stackwith :: Unionable a => Pattern a -> [Pattern a] -> Pattern a

-- | <a>range</a> will take a pattern which goes from 0 to 1 (like
--   <a>sine</a>), 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 <tt>sine1</tt> from 0 - 1 to 1 - 1.5.
--   
--   <pre>
--   d1 $ jux (iter 4) $ sound "arpy arpy:2*2"
--     |+ speed (slow 4 $ range 1 1.5 sine1)
--   </pre>
range :: Num a => Pattern a -> Pattern a -> Pattern a -> Pattern a
_range :: (Functor f, Num b) => b -> b -> f b -> f b

-- | <a>rangex</a> is an exponential version of <a>range</a>, good for
--   using with frequencies. Do *not* use negative numbers or zero as
--   arguments!
rangex :: (Functor f, Floating b) => b -> b -> f b -> f b
off :: Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_off :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
offadd :: Num a => Pattern Time -> Pattern a -> Pattern a -> Pattern a

-- | Step sequencing
step :: String -> String -> Pattern String
steps :: [(String, String)] -> Pattern String

-- | like <a>step</a>, but allows you to specify an array of strings to use
--   for 0,1,2...
step' :: [String] -> String -> Pattern String
ghost'' :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
ghost' :: Time -> Pattern ValueMap -> Pattern ValueMap
ghost :: Pattern ValueMap -> Pattern ValueMap

-- | tabby - A more literal weaving than the <tt>weave</tt> function, give
--   number of <tt>threads</tt> per cycle and two patterns, and this
--   function will weave them together using a plain (aka <a>tabby</a>)
--   weave, with a simple over/under structure
tabby :: Int -> Pattern a -> Pattern a -> Pattern a

-- | chooses between a list of patterns, using a pattern of floats (from
--   0-1)
select :: Pattern Double -> [Pattern a] -> Pattern a
_select :: Double -> [Pattern a] -> Pattern a

-- | chooses between a list of functions, using a pattern of floats (from
--   0-1)
selectF :: Pattern Double -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a
_selectF :: Double -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a

-- | chooses between 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

-- | <tt>contrast p f f' p'</tt> splits controlpattern <tt>p'</tt> in two,
--   applying the function <tt>f</tt> to one and <tt>f'</tt> to the other.
--   This depends on whether events in it contains values matching with
--   those in <tt>p</tt>. For example in <tt>contrast ( vowel "a") (n "1")
--   $ n "0 1" speed 3</tt>, the first event will have the vowel effect
--   applied and the second will have the crush applied.
contrast :: (ControlPattern -> ControlPattern) -> (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern
contrastBy :: (a -> Value -> Bool) -> (ControlPattern -> Pattern b) -> (ControlPattern -> Pattern b) -> Pattern (Map String a) -> Pattern (Map String Value) -> Pattern b
contrastRange :: (ControlPattern -> Pattern a) -> (ControlPattern -> Pattern a) -> Pattern (Map String (Value, Value)) -> ControlPattern -> Pattern a

-- | Like <tt>contrast</tt>, but one function is given, and applied to
--   events with matching controls.
fix :: (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern

-- | Like <tt>contrast</tt>, but one function is given, and applied to
--   events with controls which don't match.
unfix :: (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern
fixRange :: (ControlPattern -> Pattern ValueMap) -> Pattern (Map String (Value, Value)) -> ControlPattern -> ControlPattern
unfixRange :: (ControlPattern -> Pattern ValueMap) -> Pattern (Map String (Value, Value)) -> ControlPattern -> ControlPattern

-- | limit values in a Pattern (or other Functor) to n equally spaced
--   divisions of 1.
quantise :: (Functor f, RealFrac b) => b -> f b -> f b
qfloor :: (Functor f, RealFrac b) => b -> f b -> f b
qceiling :: (Functor f, RealFrac b) => b -> f b -> f b
qround :: (Functor f, RealFrac b) => b -> f b -> f b

-- | 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 <tt>monophonic</tt>. Events which start/end earlier
--   are given priority.
mono :: Pattern a -> Pattern a
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 :: Int -> (Pattern a -> Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
soak :: Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
deconstruct :: Int -> Pattern String -> String
bite :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_bite :: Int -> Pattern Int -> Pattern a -> Pattern a
squeeze :: Pattern Int -> [Pattern a] -> Pattern a
squeezeJoinUp :: Pattern ControlPattern -> ControlPattern
_chew :: Int -> Pattern Int -> ControlPattern -> ControlPattern
chew :: Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern
__binary :: Bits b => Int -> b -> [Bool]
_binary :: Bits b => Int -> b -> Pattern Bool
_binaryN :: Int -> Pattern Int -> Pattern Bool
binaryN :: Pattern Int -> Pattern Int -> Pattern Bool
binary :: Pattern Int -> Pattern Bool
ascii :: Pattern String -> Pattern Bool
grain :: Pattern Double -> Pattern Double -> ControlPattern

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
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
parseRhythm :: Parseable a => MyParser (TPat a) -> String -> Either ParseError (TPat a)
pSequence :: Parseable a => MyParser (TPat a) -> GenParser Char Int (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)
pNote :: MyParser (TPat Note)
pBool :: MyParser (TPat Bool)
parseIntNote :: Integral i => MyParser i
pIntegral :: Integral 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
pRatioChar :: Fractional a => MyParser a
instance GHC.Classes.Eq Sound.Tidal.ParseBP.TidalParseError
instance GHC.Base.Functor Sound.Tidal.ParseBP.TPat
instance GHC.Show.Show a => GHC.Show.Show (Sound.Tidal.ParseBP.TPat a)
instance Sound.Tidal.ParseBP.Parseable Sound.Tidal.ParseBP.ColourD
instance Sound.Tidal.ParseBP.Enumerable Sound.Tidal.ParseBP.ColourD
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.Integer.Type.Integer
instance Sound.Tidal.ParseBP.Enumerable 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 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.Integer.Type.Integer
instance Sound.Tidal.ParseBP.Parseable GHC.Real.Rational
instance GHC.Exception.Type.Exception Sound.Tidal.ParseBP.TidalParseError
instance GHC.Show.Show Sound.Tidal.ParseBP.TidalParseError

module Sound.Tidal.Control

-- | <a>spin</a> will "spin" a 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 works best on
--   multichannel systems.
--   
--   <pre>
--   d1 $ slow 3 $ spin 4 $ sound "drum*3 tabla:4 [arpy:2 ~ arpy] [can:2 can:3]"
--   </pre>
spin :: Pattern Int -> ControlPattern -> ControlPattern
_spin :: Int -> ControlPattern -> ControlPattern

-- | <a>chop</a> granualizes every sample in place as it is played, turning
--   a pattern of samples into a pattern of sample parts. Use an integer
--   value to specify how many granules each sample is chopped into:
--   
--   <pre>
--   d1 $ chop 16 $ sound "arpy arp feel*4 arpy*4"
--   </pre>
--   
--   Different values of <a>chop</a> can yield very different results,
--   depending on the samples used:
--   
--   <pre>
--   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]"
--   </pre>
chop :: Pattern Int -> ControlPattern -> ControlPattern
chopArc :: Arc -> Int -> [Arc]
_chop :: Int -> ControlPattern -> ControlPattern

-- | Striate is a kind of granulator, for example:
--   
--   <pre>
--   d1 $ striate 3 $ sound "ho ho:2 ho:3 hc"
--   </pre>
--   
--   This plays the loop the given number of times, but triggering
--   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, etc..
--   With the highhat samples in the above example it sounds a bit like
--   reverb, but it isn't really.
--   
--   You can also use striate with very long samples, to cut it 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.
--   
--   <pre>
--   d1 $  slow 8 $ striate 128 $ sound "bev"
--   </pre>
striate :: Pattern Int -> ControlPattern -> ControlPattern
_striate :: Int -> ControlPattern -> ControlPattern
mergePlayRange :: (Double, Double) -> ValueMap -> ValueMap

-- | The <a>striateBy</a> function is a variant of <a>striate</a> with an
--   extra parameter, which specifies the length of each part. The
--   <a>striateBy</a> 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:
--   
--   <pre>
--   d1 $ slow 32 $ striateBy 32 (1/16) $ sound "bev"
--   </pre>
--   
--   Note that <a>striate</a> uses the <tt>begin</tt> and <tt>end</tt>
--   parameters internally. This means that if you're using <a>striate</a>
--   (or <a>striateBy</a>) you probably shouldn't also specify
--   <tt>begin</tt> or <tt>end</tt>.
striateBy :: Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern
striate' :: Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern
_striateBy :: Int -> Double -> ControlPattern -> ControlPattern

-- | <a>gap</a> is similar to <a>chop</a> 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:
--   
--   <pre>
--   d1 $ gap 8 $ sound "jvbass"
--   d1 $ gap 16 $ sound "[jvbass drum:4]"
--   </pre>
gap :: Pattern Int -> ControlPattern -> ControlPattern
_gap :: Int -> ControlPattern -> ControlPattern

-- | <a>weave</a> applies a function smoothly over an array of different
--   patterns. It uses an <tt>OscPattern</tt> to apply the function at
--   different levels to each pattern, creating a weaving effect.
--   
--   <pre>
--   d1 $ weave 3 (shape $ sine1) [sound "bd [sn drum:2*2] bd*2 [sn drum:1]", sound "arpy*8 ~"]
--   </pre>
weave :: Time -> ControlPattern -> [ControlPattern] -> ControlPattern

-- | <a>weaveWith</a> is similar in that it blends functions at the same
--   time at different amounts over a pattern:
--   
--   <pre>
--   d1 $ weaveWith 3 (sound "bd [sn drum:2*2] bd*2 [sn drum:1]") [density 2, (# speed "0.5"), chop 16]
--   </pre>
weaveWith :: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a
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:
--   
--   <pre>
--   d1 $ interlace (sound  "bd sn kurt") (every 3 rev $ sound  "bd sn:2")
--   </pre>
interlace :: ControlPattern -> ControlPattern -> ControlPattern
slice :: Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern
_slice :: Int -> Int -> ControlPattern -> ControlPattern
randslice :: Pattern Int -> ControlPattern -> ControlPattern
_splice :: Int -> Pattern Int -> ControlPattern -> Pattern (Map String Value)
splice :: Pattern Int -> Pattern Int -> ControlPattern -> Pattern (Map String Value)

-- | <a>loopAt</a> makes a sample fit the given number of cycles.
--   Internally, it works by setting the <tt>unit</tt> parameter to "c",
--   changing the playback speed of the sample with the <tt>speed</tt>
--   parameter, and setting setting the <a>density</a> of the pattern to
--   match.
--   
--   <pre>
--   d1 $ loopAt 4 $ sound "breaks125"
--   d1 $ juxBy 0.6 (|* speed "2") $ slowspread (loopAt) [4,6,2,3] $ chop 12 $ sound "fm:14"
--   </pre>
loopAt :: Pattern Time -> ControlPattern -> ControlPattern
hurry :: Pattern Rational -> ControlPattern -> ControlPattern

-- | Smash is a combination of <a>spread</a> and <a>striate</a> - 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:
--   
--   <pre>
--   d1 $ smash 3 [2,3,4] $ sound "ho ho:2 ho:3 hc"
--   </pre>
--   
--   Is a bit like this:
--   
--   <pre>
--   d1 $ spread (slow) [2,3,4] $ striate 3 $ sound "ho ho:2 ho:3 hc"
--   </pre>
--   
--   This is quite dancehall:
--   
--   <pre>
--   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"
--   </pre>
smash :: Pattern Int -> [Pattern Time] -> ControlPattern -> Pattern ValueMap

-- | an altenative form to <a>smash</a> is <a>smash</a>` which will use
--   <a>chop</a> instead of <a>striate</a>.
smash' :: Int -> [Pattern Time] -> ControlPattern -> ControlPattern

-- | Stut applies a type of delay to a pattern. It has three parameters,
--   which could be called depth, feedback and time. Depth is an integer
--   and the others floating point. This adds a bit of echo:
--   
--   <pre>
--   d1 $ stut 4 0.5 0.2 $ sound "bd sn"
--   </pre>
--   
--   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:
--   
--   <pre>
--   d1 $ stut 4 0.5 (-0.2) $ sound "bd sn"
--   </pre>
stut :: Pattern Integer -> Pattern Double -> Pattern Rational -> ControlPattern -> ControlPattern
_stut :: Integer -> Double -> Rational -> ControlPattern -> ControlPattern

-- | Instead of just decreasing volume to produce echoes, <tt>stut'</tt>
--   allows to apply a function for each step and overlays the result
--   delayed by the given time.
--   
--   <pre>
--   d1 $ stut' 2 (1%3) (# vowel "{a e i o u}%2") $ sound "bd sn"
--   </pre>
--   
--   In this case there are two _overlays_ delayed by 1/3 of a cycle, where
--   each has the <tt>vowel</tt> filter applied.
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

-- | The old name for stutWith
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
triggerWith :: Show a => (Time -> Time) -> a -> Pattern b -> Pattern b
trigger :: Show a => a -> Pattern b -> Pattern b
ctrigger :: Show a => a -> Pattern b -> Pattern b
qtrigger :: Show a => a -> Pattern b -> Pattern b
rtrigger :: Show a => a -> Pattern b -> Pattern b
ftrigger :: Show a => a -> Pattern b -> Pattern b
qt :: Show a => a -> Pattern b -> Pattern b
reset :: Show a => a -> Pattern b -> Pattern b
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
data Stream
Stream :: Config -> MVar [Int] -> MVar ValueMap -> Maybe UDP -> MVar PlayMap -> MVar Tempo -> MVar (ControlPattern -> ControlPattern) -> [Cx] -> Stream
[sConfig] :: Stream -> Config
[sBusses] :: Stream -> MVar [Int]
[sStateMV] :: Stream -> MVar ValueMap
[sListen] :: Stream -> Maybe UDP
[sPMapMV] :: Stream -> MVar PlayMap
[sTempoMV] :: Stream -> MVar Tempo
[sGlobalFMV] :: Stream -> MVar (ControlPattern -> ControlPattern)
[sCxs] :: Stream -> [Cx]
type PatId = String
data Cx
Cx :: Target -> UDP -> [OSC] -> AddrInfo -> Maybe AddrInfo -> Cx
[cxTarget] :: Cx -> Target
[cxUDP] :: Cx -> UDP
[cxOSCs] :: Cx -> [OSC]
[cxAddr] :: Cx -> AddrInfo
[cxBusAddr] :: Cx -> Maybe AddrInfo
data StampStyle
BundleStamp :: StampStyle
MessageStamp :: StampStyle
data Schedule
Pre :: StampStyle -> Schedule
Live :: Schedule
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
data Args
Named :: [String] -> Args
[requiredArgs] :: Args -> [String]
ArgList :: [(String, Maybe Value)] -> Args
data OSC
OSC :: String -> Args -> OSC
[path] :: OSC -> String
[args] :: OSC -> Args
OSCContext :: String -> OSC
[path] :: OSC -> String
data PlayState
PlayState :: ControlPattern -> Bool -> Bool -> [ControlPattern] -> PlayState
[pattern] :: PlayState -> ControlPattern
[mute] :: PlayState -> Bool
[solo] :: PlayState -> Bool
[history] :: PlayState -> [ControlPattern]
type PlayMap = Map PatId PlayState
sDefault :: String -> Maybe Value
fDefault :: Double -> Maybe Value
rDefault :: Rational -> Maybe Value
iDefault :: Int -> Maybe Value
bDefault :: Bool -> Maybe Value
xDefault :: [Word8] -> Maybe Value
required :: Maybe Value
superdirtTarget :: Target
superdirtShape :: OSC
dirtTarget :: Target
dirtShape :: OSC
startStream :: Config -> [(Target, [OSC])] -> IO Stream
sendHandshakes :: Stream -> IO ()
sendO :: Bool -> Maybe UDP -> Cx -> Message -> IO ()
sendBndl :: Bool -> Maybe UDP -> Cx -> Bundle -> IO ()
resolve :: String -> String -> IO AddrInfo
startTidal :: Target -> Config -> IO Stream
startMulti :: [Target] -> Config -> IO ()
toDatum :: Value -> Datum
toData :: OSC -> Event ValueMap -> Maybe [Datum]
substitutePath :: String -> ValueMap -> Maybe String
getString :: ValueMap -> String -> Maybe String
playStack :: PlayMap -> ControlPattern
toOSC :: Double -> [Int] -> Event ValueMap -> Tempo -> OSC -> [(Double, Bool, Message)]
doCps :: MVar Tempo -> (Double, Maybe Value) -> IO ()
onTick :: Stream -> State -> IO ()
processCps :: Tempo -> [Event ValueMap] -> ([(Tempo, Event ValueMap)], Tempo)
streamOnce :: Stream -> ControlPattern -> IO ()
streamFirst :: Stream -> ControlPattern -> IO ()

-- | Query the current pattern (contained in argument <tt>stream ::
--   Stream</tt>) for the events in the current arc (contained in argument
--   <tt>st :: T.State</tt>), translate them to OSC messages, and send
--   these.
--   
--   If an exception occurs during sending, this functions prints a warning
--   and continues, because the likely reason is that the backend
--   (supercollider) isn't running.
--   
--   If any exception occurs before or outside sending (e.g., while
--   querying the pattern, while computing a message), this function prints
--   a warning and resets the current pattern to the previous one (or to
--   silence if there isn't one) and continues, because the likely reason
--   is that something is wrong with the current pattern.
doTick :: Bool -> Stream -> State -> IO ()
setPreviousPatternOrSilence :: Stream -> IO ()
send :: Maybe UDP -> Cx -> (Double, Bool, Message) -> IO ()
sched :: Tempo -> Rational -> Double
streamNudgeAll :: Stream -> Double -> IO ()
streamResetCycles :: Stream -> IO ()
hasSolo :: Map k PlayState -> Bool
streamList :: Stream -> IO ()
streamReplace :: Show a => Stream -> a -> ControlPattern -> IO ()
streamMute :: Show a => Stream -> a -> IO ()
streamMutes :: Show a => Stream -> [a] -> IO ()
streamUnmute :: Show a => Stream -> a -> IO ()
streamSolo :: Show a => Stream -> a -> IO ()
streamUnsolo :: Show a => Stream -> a -> IO ()
withPatId :: Stream -> PatId -> (PlayState -> PlayState) -> IO ()
withPatIds :: Stream -> [PatId] -> (PlayState -> PlayState) -> IO ()
streamMuteAll :: Stream -> IO ()
streamHush :: Stream -> IO ()
streamUnmuteAll :: Stream -> IO ()
streamUnsoloAll :: Stream -> IO ()
streamAll :: Stream -> (ControlPattern -> ControlPattern) -> IO ()
streamGet :: Stream -> String -> IO (Maybe Value)
streamSet :: Valuable a => Stream -> String -> Pattern a -> IO ()
streamSetI :: Stream -> String -> Pattern Int -> IO ()
streamSetF :: Stream -> String -> Pattern Double -> IO ()
streamSetS :: Stream -> String -> Pattern String -> IO ()
streamSetB :: Stream -> String -> Pattern Bool -> IO ()
streamSetR :: Stream -> String -> Pattern Rational -> IO ()
openListener :: Config -> IO (Maybe UDP)
ctrlResponder :: Int -> Config -> Stream -> IO ()
verbose :: Config -> String -> IO ()
recvMessagesTimeout :: Transport t => Double -> t -> IO [Message]
streamGetcps :: Stream -> IO Time
streamGetnow :: Stream -> IO Double
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
instance GHC.Show.Show Sound.Tidal.Stream.PlayState

module Sound.Tidal.Transition
transition :: Show a => Stream -> Bool -> (Time -> [ControlPattern] -> ControlPattern) -> a -> 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 <a>wait</a>, <a>waitT</a> stops for a bit and then applies the
--   given transition to the playing pattern
--   
--   <pre>
--   d1 $ sound "bd"
--   
--   t1 (waitT (xfadeIn 8) 4) $ sound "hh*8"
--   </pre>
waitT :: (Time -> [ControlPattern] -> ControlPattern) -> Time -> Time -> [ControlPattern] -> ControlPattern

-- | Jumps directly into the given pattern, this is essentially the _no
--   transition_-transition.
--   
--   Variants of <tt>jump</tt> provide more useful capabilities, see
--   <tt>jumpIn</tt> and <tt>jumpMod</tt>
jump :: Time -> [ControlPattern] -> ControlPattern

-- | Sharp <a>jump</a> transition after the specified number of cycles have
--   passed.
--   
--   <pre>
--   t1 (jumpIn 2) $ sound "kick(3,8)"
--   </pre>
jumpIn :: Int -> Time -> [ControlPattern] -> ControlPattern

-- | Unlike <a>jumpIn</a> the variant <a>jumpIn</a>` will only transition
--   at cycle boundary (e.g. when the cycle count is an integer).
jumpIn' :: Int -> Time -> [ControlPattern] -> ControlPattern

-- | Sharp <a>jump</a> transition at next cycle boundary where cycle mod n
--   == 0
jumpMod :: 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 <tt>xfade</tt> 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.
--   
--   <pre>
--   d1 $ sound "bd(3,8)"
--   
--   t1 clutch $ sound "[hh*4, odx(3,8)]"
--   </pre>
--   
--   <tt>clutch</tt> takes two cycles for the transition, essentially this
--   is <tt>clutchIn 2</tt>.
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
--   <tt>clutchIn</tt> like so:
--   
--   <pre>
--   d1 $ sound "bd(5,8)"
--   
--   t1 (clutchIn 8) $ sound "[hh*4, odx(3,8)]"
--   </pre>
--   
--   will take 8 cycles for the transition.
clutchIn :: Time -> Time -> [Pattern a] -> Pattern a

-- | same as <a>anticipate</a> though it allows you to specify the number
--   of cycles until dropping to the new pattern, e.g.:
--   
--   <pre>
--   d1 $ sound "jvbass(3,8)"
--   
--   t1 (anticipateIn 4) $ sound "jvbass(5,8)"
--   </pre>
anticipateIn :: Time -> Time -> [ControlPattern] -> ControlPattern

-- | <a>anticipate</a> 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.EspGrid
tidalEspGridLink :: MVar Tempo -> IO ()
cpsEsp :: Real t => t -> IO ()
espgrid :: Stream -> IO ()

module Sound.Tidal.Carabiner
carabiner :: Stream -> Int -> Double -> IO Socket
client :: Stream -> Int -> Double -> String -> Int -> IO Socket
listener :: Stream -> Int -> Double -> Socket -> IO ()
act :: Stream -> Int -> Double -> String -> [(String, String)] -> IO ()
sendMsg :: Socket -> String -> IO ()

module Sound.Tidal.Context