-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Pattern language for improvised music
--   
--   Tidal is a domain specific language for live coding patterns.
@package tidal
@version 1.9.4

module Paths_tidal
version :: Version
getBinDir :: IO FilePath
getLibDir :: IO FilePath
getDynLibDir :: IO FilePath
getDataDir :: IO FilePath
getLibexecDir :: IO FilePath
getDataFileName :: FilePath -> IO FilePath
getSysconfDir :: IO FilePath

module Sound.Tidal.Bjorklund
bjorklund :: (Int, Int) -> [Bool]

module Sound.Tidal.Config
data Config
Config :: Bool -> String -> Int -> Bool -> Double -> Bool -> Double -> String -> Int -> Int -> Int64 -> Bool -> CDouble -> CDouble -> Config
[cCtrlListen] :: Config -> Bool
[cCtrlAddr] :: Config -> String
[cCtrlPort] :: Config -> Int
[cCtrlBroadcast] :: Config -> Bool
[cFrameTimespan] :: Config -> Double
[cEnableLink] :: Config -> Bool
[cProcessAhead] :: Config -> Double
[cTempoAddr] :: Config -> String
[cTempoPort] :: Config -> Int
[cTempoClientPort] :: Config -> Int
[cSkipTicks] :: Config -> Int64
[cVerbose] :: Config -> Bool
[cQuantum] :: Config -> CDouble
[cBeatsPerCycle] :: Config -> CDouble
defaultConfig :: Config

module Sound.Tidal.ID

-- | Wrapper for literals that can be coerced to a string and used as an
--   identifier. | Similar to Show typeclass, but constrained to strings
--   and integers and designed | so that similar cases (such as 1 and "1")
--   convert to the same value.
newtype ID
ID :: String -> ID
[fromID] :: ID -> String
instance GHC.Read.Read Sound.Tidal.ID.ID
instance GHC.Classes.Ord Sound.Tidal.ID.ID
instance GHC.Show.Show Sound.Tidal.ID.ID
instance GHC.Classes.Eq Sound.Tidal.ID.ID
instance GHC.Num.Num Sound.Tidal.ID.ID
instance Data.String.IsString Sound.Tidal.ID.ID

module Sound.Tidal.Time

-- | Time is rational
type Time = Rational

-- | An arc of time, with a start time (or onset) and a stop time (or
--   offset)
data ArcF a
Arc :: a -> a -> ArcF a
[start] :: ArcF a -> a
[stop] :: ArcF a -> a
type Arc = ArcF Time

-- | The <tt>sam</tt> (start of cycle) for the given time value. Cycles
--   have duration 1, so every integer Time value divides two cycles.
sam :: Time -> Time

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

-- | Turns a (rational) time value into another number. An alias for
--   <tt>fromRational</tt>.
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 returned is the cycle that the Time falls within.
--   
--   Edge case: If the Time is an integer, the Arc claiming it is the one
--   starting at that Time, not the previous one ending at that Time.
timeToCycleArc :: Time -> Arc

-- | Shifts an Arc to one of equal duration that starts within cycle zero.
--   (Note that the output Arc probably does not start *at* Time 0 -- that
--   only happens when the input Arc starts at an integral Time.)
cycleArc :: Arc -> Arc

-- | Returns the numbers of the cycles that the input <tt>Arc</tt> overlaps
--   (excluding the input <tt>Arc</tt>'s endpoint, unless it has duration 0
--   -- see "Edge cases" below). (The "cycle number" of an <tt>Arc</tt> is
--   equal to its start value. Thus, for instance, <tt>cyclesInArc (Arc 0
--   1.5) == [0,1]</tt>.)
--   
--   Edge cases: &gt; cyclesInArc $ Arc 0 1.0001 == [0,1] &gt; cyclesInArc
--   $ Arc 0 1 == [0] -- the endpoint is excluded &gt; cyclesInArc $ Arc 1
--   1 == [1] -- unless the Arc has duration 0
--   
--   PITFALL: Don't be fooled by the name. The output cycles are not
--   necessarily completely contained in the input <tt>Arc</tt>, but they
--   definitely overlap it, and they include every cycle that overlaps it.
cyclesInArc :: Integral a => Arc -> [a]

-- | This provides exactly the same information as <tt>cyclesInArc</tt>,
--   except that this represents its output as <tt>Arc</tt>s, whereas
--   <tt>cyclesInArc</tt> represents the same information as integral
--   indices. (The <tt>Arc</tt> from 0 to 1 corresponds to the index 0, the
--   one from 1 to 2 has index 1, etc.)
cycleArcsInArc :: Arc -> [Arc]

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

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

-- | Similar to <tt>fmap</tt> 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

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

-- | Some context for an event, currently just position within sourcecode
data Context
Context :: [((Int, Int), (Int, Int))] -> Context
[contextPosition] :: Context -> [((Int, Int), (Int, Int))]
type ControlPattern = Pattern ValueMap

-- | an Arc and some named control values
data State
State :: Arc -> ValueMap -> State
[arc] :: State -> Arc
[controls] :: State -> ValueMap
type ValueMap = Map String Value
type Event a = EventF (ArcF Time) a
class Moddable a
gmod :: Moddable a => a -> a -> a

-- | Note is Double, but with a different parser
newtype Note
Note :: Double -> Note
[unNote] :: Note -> Double

-- | Polymorphic values
data Value
VS :: String -> Value
[svalue] :: Value -> String
VF :: Double -> Value
[fvalue] :: Value -> Double
VN :: Note -> Value
[nvalue] :: Value -> Note
VR :: Rational -> Value
[rvalue] :: Value -> Rational
VI :: Int -> Value
[ivalue] :: Value -> Int
VB :: Bool -> Value
[bvalue] :: Value -> Bool
VX :: [Word8] -> Value
[xvalue] :: Value -> [Word8]
VPattern :: Pattern Value -> Value
[pvalue] :: Value -> Pattern Value
VList :: [Value] -> Value
[lvalue] :: Value -> [Value]
VState :: (ValueMap -> (ValueMap, Value)) -> Value
[statevalue] :: Value -> ValueMap -> (ValueMap, Value)
class Stringy a
deltaContext :: Stringy a => Int -> Int -> a -> a

-- | An event is a value that's active during a timespan. If a whole is
--   present, the part should be equal to or fit inside it.
data EventF a b
Event :: Context -> Maybe a -> a -> b -> EventF a b
[context] :: EventF a b -> Context
[whole] :: EventF a b -> Maybe a
[part] :: EventF a b -> a
[value] :: EventF a b -> b
class Valuable a
toValue :: Valuable a => a -> Value

-- | Like <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 *>
silence :: 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
reset :: Pattern Bool -> Pattern a -> Pattern a
empty :: Pattern a

-- | <ul>
--   <li>Patterns as numbers</li>
--   </ul>
noOv :: String -> a
applyPatToPatBoth :: Pattern (a -> b) -> Pattern a -> Pattern b
applyPatToPatLeft :: Pattern (a -> b) -> Pattern a -> Pattern b
applyPatToPatRight :: Pattern (a -> b) -> Pattern a -> Pattern b

-- | Like <a>*</a>, but the <tt>wholes</tt> come from the left
(<<*) :: Pattern (a -> b) -> Pattern a -> Pattern b
infixl 4 <<*
applyPatToPatSqueeze :: Pattern (a -> b) -> Pattern a -> Pattern b
applyPatToPat :: (Maybe Arc -> Maybe Arc -> Maybe (Maybe Arc)) -> Pattern (a -> b) -> Pattern a -> Pattern b
wholeOrPart :: Event a -> Arc
filterAnalog :: Pattern a -> Pattern a
filterDigital :: Pattern a -> Pattern a
combineContexts :: [Context] -> Context

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

-- | 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
focusArc :: Arc -> Pattern a -> Pattern a
_trigJoin :: Bool -> Pattern (Pattern a) -> Pattern a

-- | Shifts a pattern forward in time by the given amount, expressed in
--   cycles
rotR :: Time -> Pattern a -> Pattern a
trigJoin :: Pattern (Pattern a) -> Pattern a
trigZeroJoin :: Pattern (Pattern a) -> Pattern a
resetTo :: Pattern Rational -> Pattern a -> Pattern a

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

-- | General utilities..
--   
--   Apply one of three functions to a Value, depending on its type
applyFIS :: (Double -> Double) -> (Int -> Int) -> (String -> String) -> Value -> Value

-- | Apply one of two functions to a pair of Values, depending on their
--   types (int or float; strings and rationals are ignored)
fNum2 :: (Int -> Int -> Int) -> (Double -> Double -> Double) -> Value -> Value -> Value
queryArc :: Pattern a -> Arc -> [Event a]

-- | Splits queries that span cycles. For example `query p (0.5, 1.5)`
--   would be turned into two queries, `(0.5,1)` and `(1,1.5)`, and the
--   results combined. Being able to assume queries don't span cycles often
--   makes transformations easier to specify.
splitQueries :: Pattern a -> Pattern a

-- | Apply a function to the arcs/timespans (both whole and parts) of the
--   result
withResultArc :: (Arc -> Arc) -> Pattern a -> Pattern a

-- | Apply a function to the time (both start and end of the timespans of
--   both whole and parts) of the result
withResultTime :: (Time -> Time) -> Pattern a -> Pattern a

-- | Apply a function to the timespan of the query
withQueryArc :: (Arc -> Arc) -> Pattern a -> Pattern a

-- | Apply a function to the time (both start and end) of the query
withQueryTime :: (Time -> Time) -> Pattern a -> Pattern a

-- | Apply a function to the control values of the query
withQueryControls :: (ValueMap -> ValueMap) -> Pattern a -> Pattern a

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

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

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

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

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

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

-- | Extract a pattern of rational values by from a control pattern, given
--   the name of the control
extractR :: String -> ControlPattern -> Pattern Rational
getR :: Value -> Maybe Rational

-- | Extract a pattern of note values by from a control pattern, given the
--   name of the control
extractN :: String -> ControlPattern -> Pattern Note
getN :: Value -> Maybe Note
compressArc :: Arc -> Pattern a -> Pattern a
_fastGap :: Time -> Pattern a -> Pattern a
compressArcTo :: Arc -> Pattern a -> Pattern a
_fast :: Time -> Pattern a -> Pattern a

-- | Speed up a pattern by the given time pattern
fast :: Pattern Time -> Pattern a -> Pattern a
tParam :: (t1 -> t2 -> Pattern a) -> Pattern t1 -> t2 -> 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
tParamSqueeze :: (a -> Pattern b -> Pattern c) -> Pattern a -> Pattern b -> Pattern c

-- | An alias for <tt>fast</tt>
density :: Pattern 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

-- | Mark values in the first pattern which match with at least one value
--   in the second pattern.
matchManyToOne :: (b -> a -> Bool) -> Pattern a -> Pattern b -> Pattern (Bool, b)

-- | Remove events from patterns that to not meet the given test
filterValues :: (a -> Bool) -> Pattern a -> Pattern a
filterWhen :: (Time -> Bool) -> Pattern a -> Pattern a

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

-- | Get the onset of an event's <a>whole</a>
eventPartStart :: Event a -> Time
filterEvents :: (Event a -> Bool) -> Pattern a -> Pattern a
isDigital :: Event a -> Bool
isAnalog :: Event a -> Bool
playFor :: Time -> Time -> Pattern a -> Pattern a
tParam2 :: (a -> b -> c -> Pattern d) -> Pattern a -> Pattern b -> c -> Pattern d
tParam3 :: (a -> b -> c -> Pattern d -> Pattern e) -> Pattern a -> Pattern b -> Pattern c -> Pattern d -> Pattern e
setContext :: Context -> Pattern a -> Pattern a
withContext :: (Context -> Context) -> Pattern a -> Pattern a
deltaMini :: String -> String

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

-- | Returns a list of events, with any adjacent parts of the same whole
--   combined
defragParts :: Eq a => [Event a] -> [Event a]

-- | Returns <a>True</a> if the two given events are adjacent parts of the
--   same whole
isAdjacent :: Eq a => Event a -> Event a -> Bool

-- | Get the offset of an event's <a>whole</a>
wholeStop :: 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])
getBlob :: Value -> Maybe [Word8]
getList :: Value -> Maybe [Value]
valueToPattern :: Value -> Pattern Value
sameDur :: Event a -> Event a -> Bool
groupEventsBy :: Eq a => (Event a -> Event a -> Bool) -> [Event a] -> [[Event a]]
collectEvent :: [Event a] -> Maybe (Event [a])
collectEventsBy :: Eq a => (Event a -> Event a -> Bool) -> [Event a] -> [Event [a]]

-- | collects all events satisfying the same constraint into a list
collectBy :: Eq a => (Event a -> Event a -> Bool) -> Pattern a -> Pattern [a]

-- | collects all events occuring at the exact same time into a list
collect :: Eq a => Pattern a -> Pattern [a]
uncollectEvent :: Event [a] -> [Event a]
uncollectEvents :: [Event [a]] -> [Event a]

-- | merges all values in a list into one pattern by stacking the values
uncollect :: Pattern [a] -> Pattern a
instance GHC.Generics.Generic Sound.Tidal.Pattern.Context
instance GHC.Classes.Ord Sound.Tidal.Pattern.Context
instance GHC.Classes.Eq Sound.Tidal.Pattern.Context
instance GHC.Generics.Generic (Sound.Tidal.Pattern.EventF a b)
instance GHC.Base.Functor (Sound.Tidal.Pattern.EventF a)
instance (GHC.Classes.Ord a, GHC.Classes.Ord b) => GHC.Classes.Ord (Sound.Tidal.Pattern.EventF a b)
instance (GHC.Classes.Eq a, GHC.Classes.Eq b) => GHC.Classes.Eq (Sound.Tidal.Pattern.EventF a b)
instance GHC.Real.RealFrac Sound.Tidal.Pattern.Note
instance GHC.Real.Real Sound.Tidal.Pattern.Note
instance GHC.Float.Floating Sound.Tidal.Pattern.Note
instance GHC.Real.Fractional Sound.Tidal.Pattern.Note
instance GHC.Num.Num Sound.Tidal.Pattern.Note
instance GHC.Enum.Enum Sound.Tidal.Pattern.Note
instance GHC.Classes.Ord Sound.Tidal.Pattern.Note
instance GHC.Classes.Eq Sound.Tidal.Pattern.Note
instance GHC.Generics.Generic Sound.Tidal.Pattern.Note
instance Data.Data.Data Sound.Tidal.Pattern.Note
instance GHC.Base.Functor Sound.Tidal.Pattern.Pattern
instance GHC.Generics.Generic (Sound.Tidal.Pattern.Pattern a)
instance GHC.Generics.Generic Sound.Tidal.Pattern.Value
instance Sound.Tidal.Pattern.Valuable GHC.Base.String
instance Sound.Tidal.Pattern.Valuable GHC.Types.Double
instance Sound.Tidal.Pattern.Valuable GHC.Real.Rational
instance Sound.Tidal.Pattern.Valuable GHC.Types.Int
instance Sound.Tidal.Pattern.Valuable GHC.Types.Bool
instance Sound.Tidal.Pattern.Valuable Sound.Tidal.Pattern.Note
instance Sound.Tidal.Pattern.Valuable [GHC.Word.Word8]
instance Sound.Tidal.Pattern.Valuable [Sound.Tidal.Pattern.Value]
instance Control.DeepSeq.NFData a => Control.DeepSeq.NFData (Sound.Tidal.Pattern.Pattern a)
instance GHC.Base.Applicative Sound.Tidal.Pattern.Pattern
instance GHC.Base.Monad Sound.Tidal.Pattern.Pattern
instance GHC.Classes.Eq (Sound.Tidal.Pattern.Pattern a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Sound.Tidal.Pattern.Pattern a)
instance GHC.Num.Num a => GHC.Num.Num (Sound.Tidal.Pattern.Pattern a)
instance GHC.Enum.Enum a => GHC.Enum.Enum (Sound.Tidal.Pattern.Pattern a)
instance GHC.Base.Monoid (Sound.Tidal.Pattern.Pattern a)
instance GHC.Base.Semigroup (Sound.Tidal.Pattern.Pattern a)
instance (GHC.Num.Num a, GHC.Classes.Ord a) => GHC.Real.Real (Sound.Tidal.Pattern.Pattern a)
instance GHC.Real.Integral a => GHC.Real.Integral (Sound.Tidal.Pattern.Pattern a)
instance GHC.Real.Fractional a => GHC.Real.Fractional (Sound.Tidal.Pattern.Pattern a)
instance GHC.Float.Floating a => GHC.Float.Floating (Sound.Tidal.Pattern.Pattern a)
instance GHC.Real.RealFrac a => GHC.Real.RealFrac (Sound.Tidal.Pattern.Pattern a)
instance GHC.Float.RealFloat a => GHC.Float.RealFloat (Sound.Tidal.Pattern.Pattern a)
instance GHC.Num.Num Sound.Tidal.Pattern.ValueMap
instance GHC.Real.Fractional Sound.Tidal.Pattern.ValueMap
instance Sound.Tidal.Pattern.Moddable Sound.Tidal.Pattern.ValueMap
instance GHC.Float.Floating Sound.Tidal.Pattern.ValueMap
instance Sound.Tidal.Pattern.Stringy (Sound.Tidal.Pattern.Pattern a)
instance Control.DeepSeq.NFData Sound.Tidal.Pattern.Value
instance GHC.Classes.Eq Sound.Tidal.Pattern.Value
instance GHC.Classes.Ord Sound.Tidal.Pattern.Value
instance Sound.Tidal.Pattern.Moddable Sound.Tidal.Pattern.Note
instance Control.DeepSeq.NFData Sound.Tidal.Pattern.Note
instance GHC.Show.Show Sound.Tidal.Pattern.Note
instance (Control.DeepSeq.NFData a, Control.DeepSeq.NFData b) => Control.DeepSeq.NFData (Sound.Tidal.Pattern.EventF a b)
instance Control.DeepSeq.NFData Sound.Tidal.Pattern.Context
instance Sound.Tidal.Pattern.Stringy GHC.Base.String
instance Sound.Tidal.Pattern.Moddable GHC.Types.Double
instance Sound.Tidal.Pattern.Moddable GHC.Real.Rational
instance Sound.Tidal.Pattern.Moddable GHC.Types.Int

module Sound.Tidal.Show
show :: Show a => a -> String
showAll :: Show a => Arc -> Pattern a -> String
draw :: Pattern Char -> Render
drawLine :: Pattern Char -> Render
drawLineSz :: Int -> Pattern Char -> Render
stepcount :: Pattern a -> Int
showStateful :: ControlPattern -> String
instance GHC.Show.Show Sound.Tidal.Show.Render
instance GHC.Show.Show a => GHC.Show.Show (Sound.Tidal.Pattern.Pattern a)
instance GHC.Show.Show Sound.Tidal.Pattern.Context
instance GHC.Show.Show Sound.Tidal.Pattern.Value
instance GHC.Show.Show Sound.Tidal.Pattern.ValueMap
instance GHC.Show.Show Sound.Tidal.Time.Arc
instance GHC.Show.Show a => GHC.Show.Show (Sound.Tidal.Pattern.Event a)

module Sound.Tidal.StreamTypes
data PlayState
PlayState :: ControlPattern -> Bool -> Bool -> [ControlPattern] -> PlayState
[pattern] :: PlayState -> ControlPattern
[mute] :: PlayState -> Bool
[solo] :: PlayState -> Bool
[history] :: PlayState -> [ControlPattern]
type PatId = String
type PlayMap = Map PatId PlayState
data TickState
TickState :: Arc -> Double -> TickState
[tickArc] :: TickState -> Arc
[tickNudge] :: TickState -> Double
instance GHC.Show.Show Sound.Tidal.StreamTypes.PlayState
instance GHC.Show.Show Sound.Tidal.StreamTypes.TickState

module Sound.Tidal.Core

-- | 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
(||+) :: Num a => Pattern a -> Pattern a -> Pattern a
(|++|) :: Applicative a => a String -> a String -> a String
(|++) :: Pattern String -> Pattern String -> Pattern String
(++|) :: Pattern String -> Pattern String -> Pattern String
(||++) :: Pattern String -> Pattern String -> Pattern String
(|/|) :: (Applicative a, Fractional b) => a b -> a b -> a b
(|/) :: Fractional a => Pattern a -> Pattern a -> Pattern a
(/|) :: Fractional a => Pattern a -> Pattern a -> Pattern a
(||/) :: Fractional a => Pattern a -> Pattern a -> Pattern a
(|*|) :: (Applicative a, Num b) => a b -> a b -> a b
(|*) :: Num a => Pattern a -> Pattern a -> Pattern a
(*|) :: Num a => Pattern a -> Pattern a -> Pattern a
(||*) :: Num a => Pattern a -> Pattern a -> Pattern a
(|-|) :: (Applicative a, Num b) => a b -> a b -> a b
(|-) :: Num a => Pattern a -> Pattern a -> Pattern a
(-|) :: Num a => Pattern a -> Pattern a -> Pattern a
(||-) :: Num a => Pattern a -> Pattern a -> Pattern a
(|%|) :: (Applicative a, Moddable b) => a b -> a b -> a b
(|%) :: Moddable a => Pattern a -> Pattern a -> Pattern a
(%|) :: Moddable a => Pattern a -> Pattern a -> Pattern a
(||%) :: Moddable a => Pattern a -> Pattern a -> Pattern a
(|**|) :: (Applicative a, Floating b) => a b -> a b -> a b
(|**) :: Floating a => Pattern a -> Pattern a -> Pattern a
(**|) :: Floating a => Pattern a -> Pattern a -> Pattern a
(||**) :: Floating a => Pattern a -> Pattern a -> Pattern a
(|>|) :: (Applicative a, Unionable b) => a b -> a b -> a b
(|>) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(>|) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(||>) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(|<|) :: (Applicative a, Unionable b) => a b -> a b -> a b
(|<) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(<|) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(||<) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(#) :: Unionable b => Pattern b -> Pattern b -> Pattern b

-- | Turns a list of values into a pattern, playing one of them per cycle.
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

-- | Alias for <tt>fastCat</tt>
fastcat :: [Pattern a] -> Pattern a

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

-- | Alias for <tt>timeCat</tt>
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

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

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

-- | 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]
minorMajor7 :: Num a => [a]
one :: Num a => [a]
five :: Num a => [a]
sus2 :: Num a => [a]
sus4 :: Num a => [a]
sevenSus2 :: Num a => [a]
sevenSus4 :: Num a => [a]
nineSus4 :: Num a => [a]
sevenFlat10 :: Num a => [a]
nineSharp5 :: Num a => [a]
minor9sharp5 :: Num a => [a]
sevenSharp5flat9 :: Num a => [a]
minor7sharp5flat9 :: Num a => [a]
elevenSharp :: Num a => [a]
minor11sharp :: Num a => [a]

-- | <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
data Modifier
Range :: Int -> Modifier
Drop :: Int -> Modifier
Invert :: Modifier
Open :: Modifier
applyModifier :: (Enum a, Num a) => Modifier -> [a] -> [a]
applyModifierPat :: (Num a, Enum a) => Pattern [a] -> Pattern [Modifier] -> Pattern [a]
applyModifierPatSeq :: (Num a, Enum a) => (a -> b) -> Pattern [a] -> [Pattern [Modifier]] -> Pattern [b]
chordToPatSeq :: (Num a, Enum a) => (a -> b) -> Pattern a -> Pattern String -> [Pattern [Modifier]] -> Pattern b

-- | turns a given pattern of some Num type, a pattern of chord names and a
--   list of patterns of modifiers into a chord pattern
chord :: (Num a, Enum a) => Pattern a -> Pattern String -> [Pattern [Modifier]] -> Pattern a
instance GHC.Classes.Eq Sound.Tidal.Chords.Modifier
instance GHC.Show.Show Sound.Tidal.Chords.Modifier

module Sound.Tidal.Utils
writeError :: String -> IO ()
mapBoth :: (a -> a) -> (a, a) -> (a, a)
mapPartTimes :: (a -> a) -> ((a, a), (a, a)) -> ((a, a), (a, a))
mapFst :: (a -> b) -> (a, c) -> (b, c)
mapSnd :: (a -> b) -> (c, a) -> (c, b)
delta :: Num a => (a, a) -> a

-- | The midpoint of two values
mid :: Fractional a => (a, a) -> a
removeCommon :: Eq a => [a] -> [a] -> ([a], [a])
readMaybe :: Read a => String -> Maybe a

-- | like <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]]
matchMaybe :: Maybe a -> Maybe a -> Maybe a
fromRight :: b -> Either a b -> b

module Sound.Tidal.Tempo
type TransitionMapper = Time -> [ControlPattern] -> ControlPattern
data TempoAction
SetCycle :: Time -> TempoAction
SingleTick :: ControlPattern -> TempoAction
SetNudge :: Double -> TempoAction
StreamReplace :: ID -> ControlPattern -> TempoAction
Transition :: Bool -> TransitionMapper -> ID -> ControlPattern -> TempoAction
data State
State :: Int64 -> Micros -> Arc -> Double -> State
[ticks] :: State -> Int64
[start] :: State -> Micros
[nowArc] :: State -> Arc
[nudged] :: State -> Double
data ActionHandler
ActionHandler :: (TickState -> LinkOperations -> ValueMap -> IO ValueMap) -> (LinkOperations -> ValueMap -> ControlPattern -> IO ValueMap) -> (ID -> Time -> ControlPattern -> IO ()) -> ActionHandler
[onTick] :: ActionHandler -> TickState -> LinkOperations -> ValueMap -> IO ValueMap
[onSingleTick] :: ActionHandler -> LinkOperations -> ValueMap -> ControlPattern -> IO ValueMap
[updatePattern] :: ActionHandler -> ID -> Time -> ControlPattern -> IO ()
data LinkOperations
LinkOperations :: (Beat -> IO Micros) -> (Micros -> IO Time) -> IO BPM -> (BPM -> Micros -> IO ()) -> (Micros -> Time) -> (CDouble -> CDouble) -> (CDouble -> CDouble) -> LinkOperations
[timeAtBeat] :: LinkOperations -> Beat -> IO Micros
[timeToCycles] :: LinkOperations -> Micros -> IO Time
[getTempo] :: LinkOperations -> IO BPM
[setTempo] :: LinkOperations -> BPM -> Micros -> IO ()
[linkToOscTime] :: LinkOperations -> Micros -> Time
[beatToCycles] :: LinkOperations -> CDouble -> CDouble
[cyclesToBeat] :: LinkOperations -> CDouble -> CDouble
setCycle :: Time -> MVar [TempoAction] -> IO ()
setNudge :: MVar [TempoAction] -> Double -> IO ()
timeToCycles' :: Config -> SessionState -> Micros -> IO Time
cyclesToTime :: Config -> SessionState -> Time -> IO Micros
addMicrosToOsc :: Micros -> Time -> Time
clocked :: Config -> MVar ValueMap -> MVar PlayMap -> MVar [TempoAction] -> ActionHandler -> AbletonLink -> IO [ThreadId]
instance GHC.Show.Show Sound.Tidal.Tempo.State
instance GHC.Show.Show Sound.Osc.Transport.Fd.Udp.Udp

module Sound.Tidal.Scales
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

-- | <a>pStateList</a> is made with cyclic lists in mind, but it can even
--   "cycle" through infinite lists.
pStateList :: String -> String -> [Value] -> ControlPattern

-- | A wrapper for <a>pStateList</a> that accepts a `[Double]` rather than
--   a `[Value]`.
pStateListF :: String -> String -> [Double] -> ControlPattern

-- | A wrapper for <a>pStateList</a> that accepts a `[String]` rather than
--   a `[Value]`.
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

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

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

-- | time stretch amount
timescale :: Pattern Double -> ControlPattern
timescaleTake :: String -> [Double] -> ControlPattern
timescaleCount :: String -> ControlPattern
timescaleCountTo :: String -> Pattern Double -> Pattern ValueMap
timescalebus :: Pattern Int -> Pattern Double -> ControlPattern

-- | time stretch window size
timescalewin :: Pattern Double -> ControlPattern
timescalewinTake :: String -> [Double] -> ControlPattern
timescalewinCount :: String -> ControlPattern
timescalewinCountTo :: String -> Pattern Double -> Pattern ValueMap
timescalewinbus :: Pattern Int -> Pattern Double -> ControlPattern

-- | for internal sound routing
to :: Pattern Double -> ControlPattern
toTake :: String -> [Double] -> ControlPattern
toCount :: String -> ControlPattern
toCountTo :: String -> Pattern Double -> Pattern ValueMap
tobus :: Pattern Int -> Pattern Double -> ControlPattern
torecv :: Pattern Int -> ControlPattern

-- | for internal sound routing
toArg :: Pattern String -> ControlPattern
toArgTake :: String -> [Double] -> ControlPattern
toArgbus :: Pattern Int -> Pattern String -> ControlPattern
toArgrecv :: Pattern Int -> ControlPattern

tomdecay :: Pattern Double -> ControlPattern
tomdecayTake :: String -> [Double] -> ControlPattern
tomdecayCount :: String -> ControlPattern
tomdecayCountTo :: String -> Pattern Double -> Pattern ValueMap
tomdecaybus :: Pattern Int -> Pattern Double -> ControlPattern
tomdecayrecv :: Pattern Int -> ControlPattern

-- | Tremolo Audio DSP effect | params are <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 (<a>~</a>) for no effect.
vowel :: Pattern String -> ControlPattern
vowelTake :: String -> [Double] -> ControlPattern
vowelbus :: Pattern Int -> Pattern String -> ControlPattern
vowelrecv :: Pattern Int -> ControlPattern

waveloss :: Pattern Double -> ControlPattern
wavelossTake :: String -> [Double] -> ControlPattern
wavelossCount :: String -> ControlPattern
wavelossCountTo :: String -> Pattern Double -> Pattern ValueMap
wavelossbus :: Pattern Int -> Pattern Double -> ControlPattern
wavelossrecv :: Pattern Int -> ControlPattern

xsdelay :: Pattern Double -> ControlPattern
xsdelayTake :: String -> [Double] -> ControlPattern
xsdelayCount :: String -> ControlPattern
xsdelayCountTo :: String -> Pattern Double -> Pattern ValueMap
xsdelaybus :: Pattern Int -> Pattern Double -> ControlPattern
xsdelayrecv :: Pattern Int -> ControlPattern
voi :: Pattern Double -> ControlPattern
voibus :: Pattern Int -> Pattern Double -> ControlPattern
voirecv :: Pattern Int -> ControlPattern
vco :: Pattern Double -> ControlPattern
vcobus :: Pattern Int -> Pattern Double -> ControlPattern
vcorecv :: Pattern Int -> ControlPattern
vcf :: Pattern Double -> ControlPattern
vcfbus :: Pattern Int -> Pattern Double -> ControlPattern
vcfrecv :: Pattern Int -> ControlPattern
up :: Pattern Note -> ControlPattern
tremr :: Pattern Double -> ControlPattern
tremrbus :: Pattern Int -> Pattern Double -> ControlPattern
tremrrecv :: Pattern Int -> ControlPattern
tremdp :: Pattern Double -> ControlPattern
tremdpbus :: Pattern Int -> Pattern Double -> ControlPattern
tremdprecv :: Pattern Int -> ControlPattern
tdecay :: Pattern Double -> ControlPattern
tdecaybus :: Pattern Int -> Pattern Double -> ControlPattern
tdecayrecv :: Pattern Int -> ControlPattern
sz :: Pattern Double -> ControlPattern
szbus :: Pattern Int -> Pattern Double -> ControlPattern
szrecv :: Pattern Int -> ControlPattern
sus :: Pattern Double -> ControlPattern
stt :: Pattern Double -> ControlPattern
sttbus :: Pattern Int -> Pattern Double -> ControlPattern
sttrecv :: Pattern Int -> ControlPattern
std :: Pattern Double -> ControlPattern
stdbus :: Pattern Int -> Pattern Double -> ControlPattern
stdrecv :: Pattern Int -> ControlPattern
sld :: Pattern Double -> ControlPattern
sldbus :: Pattern Int -> Pattern Double -> ControlPattern
sldrecv :: Pattern Int -> ControlPattern
scr :: Pattern Double -> ControlPattern
scrbus :: Pattern Int -> Pattern Double -> ControlPattern
scrrecv :: Pattern Int -> ControlPattern
scp :: Pattern Double -> ControlPattern
scpbus :: Pattern Int -> Pattern Double -> ControlPattern
scprecv :: Pattern Int -> ControlPattern
scl :: Pattern Double -> ControlPattern
sclbus :: Pattern Int -> Pattern Double -> ControlPattern
sclrecv :: Pattern Int -> ControlPattern
sag :: Pattern Double -> ControlPattern
sagbus :: Pattern Int -> Pattern Double -> ControlPattern
sagrecv :: Pattern Int -> ControlPattern
s :: Pattern String -> ControlPattern
rel :: Pattern Double -> ControlPattern
relbus :: Pattern Int -> Pattern Double -> ControlPattern
relrecv :: Pattern Int -> ControlPattern
por :: Pattern Double -> ControlPattern
porbus :: Pattern Int -> Pattern Double -> ControlPattern
porrecv :: Pattern Int -> ControlPattern
pit3 :: Pattern Double -> ControlPattern
pit3bus :: Pattern Int -> Pattern Double -> ControlPattern
pit3recv :: Pattern Int -> ControlPattern
pit2 :: Pattern Double -> ControlPattern
pit2bus :: Pattern Int -> Pattern Double -> ControlPattern
pit2recv :: Pattern Int -> ControlPattern
pit1 :: Pattern Double -> ControlPattern
pit1bus :: Pattern Int -> Pattern Double -> ControlPattern
pit1recv :: Pattern Int -> ControlPattern
phasr :: Pattern Double -> ControlPattern
phasrbus :: Pattern Int -> Pattern Double -> ControlPattern
phasrrecv :: Pattern Int -> ControlPattern
phasdp :: Pattern Double -> ControlPattern
phasdpbus :: Pattern Int -> Pattern Double -> ControlPattern
phasdprecv :: Pattern Int -> ControlPattern
ohdecay :: Pattern Double -> ControlPattern
ohdecaybus :: Pattern Int -> Pattern Double -> ControlPattern
ohdecayrecv :: Pattern Int -> ControlPattern
number :: Pattern Note -> ControlPattern
lsn :: Pattern Double -> ControlPattern
lsnbus :: Pattern Int -> Pattern Double -> ControlPattern
lsnrecv :: Pattern Int -> ControlPattern
lpq :: Pattern Double -> ControlPattern
lpqbus :: Pattern Int -> Pattern Double -> ControlPattern
lpqrecv :: Pattern Int -> ControlPattern
lpf :: Pattern Double -> ControlPattern
lpfbus :: Pattern Int -> Pattern Double -> ControlPattern
lpfrecv :: Pattern Int -> ControlPattern
loh :: Pattern Double -> ControlPattern
lohbus :: Pattern Int -> Pattern Double -> ControlPattern
lohrecv :: Pattern Int -> ControlPattern
llt :: Pattern Double -> ControlPattern
lltbus :: Pattern Int -> Pattern Double -> ControlPattern
lltrecv :: Pattern Int -> ControlPattern
lht :: Pattern Double -> ControlPattern
lhtbus :: Pattern Int -> Pattern Double -> ControlPattern
lhtrecv :: Pattern Int -> ControlPattern
lfop :: Pattern Double -> ControlPattern
lfopbus :: Pattern Int -> Pattern Double -> ControlPattern
lfoprecv :: Pattern Int -> ControlPattern
lfoi :: Pattern Double -> ControlPattern
lfoibus :: Pattern Int -> Pattern Double -> ControlPattern
lfoirecv :: Pattern Int -> ControlPattern
lfoc :: Pattern Double -> ControlPattern
lfocbus :: Pattern Int -> Pattern Double -> ControlPattern
lfocrecv :: Pattern Int -> ControlPattern
lcr :: Pattern Double -> ControlPattern
lcrbus :: Pattern Int -> Pattern Double -> ControlPattern
lcrrecv :: Pattern Int -> ControlPattern
lcp :: Pattern Double -> ControlPattern
lcpbus :: Pattern Int -> Pattern Double -> ControlPattern
lcprecv :: Pattern Int -> ControlPattern
lcl :: Pattern Double -> ControlPattern
lclbus :: Pattern Int -> Pattern Double -> ControlPattern
lclrecv :: Pattern Int -> ControlPattern
lch :: Pattern Double -> ControlPattern
lchbus :: Pattern Int -> Pattern Double -> ControlPattern
lchrecv :: Pattern Int -> ControlPattern
lbd :: Pattern Double -> ControlPattern
lbdbus :: Pattern Int -> Pattern Double -> ControlPattern
lbdrecv :: Pattern Int -> ControlPattern
lag :: Pattern Double -> ControlPattern
lagbus :: Pattern Int -> Pattern Double -> ControlPattern
lagrecv :: Pattern Int -> ControlPattern
hpq :: Pattern Double -> ControlPattern
hpqbus :: Pattern Int -> Pattern Double -> ControlPattern
hpqrecv :: Pattern Int -> ControlPattern
hpf :: Pattern Double -> ControlPattern
hpfbus :: Pattern Int -> Pattern Double -> ControlPattern
hpfrecv :: Pattern Int -> ControlPattern
hg :: Pattern Double -> ControlPattern
hgbus :: Pattern Int -> Pattern Double -> ControlPattern
hgrecv :: Pattern Int -> ControlPattern
gat :: Pattern Double -> ControlPattern
gatbus :: Pattern Int -> Pattern Double -> ControlPattern
gatrecv :: Pattern Int -> ControlPattern
fadeOutTime :: Pattern Double -> ControlPattern
dt :: Pattern Double -> ControlPattern
dtbus :: Pattern Int -> Pattern Double -> ControlPattern
dtrecv :: Pattern Int -> ControlPattern
dfb :: Pattern Double -> ControlPattern
dfbbus :: Pattern Int -> Pattern Double -> ControlPattern
dfbrecv :: Pattern Int -> ControlPattern
det :: Pattern Double -> ControlPattern
detbus :: Pattern Int -> Pattern Double -> ControlPattern
detrecv :: Pattern Int -> ControlPattern
delayt :: Pattern Double -> ControlPattern
delaytbus :: Pattern Int -> Pattern Double -> ControlPattern
delaytrecv :: Pattern Int -> ControlPattern
delayfb :: Pattern Double -> ControlPattern
delayfbbus :: Pattern Int -> Pattern Double -> ControlPattern
delayfbrecv :: Pattern Int -> ControlPattern
ctfg :: Pattern Double -> ControlPattern
ctfgbus :: Pattern Int -> Pattern Double -> ControlPattern
ctfgrecv :: Pattern Int -> ControlPattern
ctf :: Pattern Double -> ControlPattern
ctfbus :: Pattern Int -> Pattern Double -> ControlPattern
ctfrecv :: Pattern Int -> ControlPattern
chdecay :: Pattern Double -> ControlPattern
chdecaybus :: Pattern Int -> Pattern Double -> ControlPattern
chdecayrecv :: Pattern Int -> ControlPattern
bpq :: Pattern Double -> ControlPattern
bpqbus :: Pattern Int -> Pattern Double -> ControlPattern
bpqrecv :: Pattern Int -> ControlPattern
bpf :: Pattern Double -> ControlPattern
bpfbus :: Pattern Int -> Pattern Double -> ControlPattern
bpfrecv :: Pattern Int -> ControlPattern
att :: Pattern Double -> ControlPattern
attbus :: Pattern Int -> Pattern Double -> ControlPattern
attrecv :: Pattern Int -> ControlPattern


-- | This module provides the main user interface functions, including
--   sources of randomness and transformations of patterns. All these
--   functions are available in the context of the TidalCycles REPL.
--   
--   Many functions in this module taking <a>Pattern</a> values as
--   arguments have a corresponding function with an underscore prepended
--   to its name (e.g. <a>degradeBy</a> and <a>_degradeBy</a>). These
--   functions accept plain values, not <a>Pattern</a>s, and are generally
--   intended for those developing or extending Tidal.
module Sound.Tidal.UI

-- | An implementation of the well-known <tt>xorshift</tt> random number
--   generator. Given a seed number, generates a reasonably random number
--   out of it. This is an efficient algorithm suitable for use in tight
--   loops and used to implement the below functions, which are used to
--   implement <a>rand</a>.
--   
--   See George Marsaglia (2003). <a>"Xorshift RNGs"</a>, in Journal of
--   Statistical Software, pages 8–14.
xorwise :: Int -> Int
timeToIntSeed :: RealFrac a => a -> Int
intSeedToRand :: Fractional a => Int -> a
timeToRand :: (RealFrac a, Fractional b) => a -> b
timeToRands :: (RealFrac a, Fractional b) => a -> Int -> [b]
timeToRands' :: Fractional a => Int -> Int -> [a]

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

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

-- | Boolean rand with probability as input, e.g. <tt>brandBy 0.25</tt>
--   produces trues 25% of the time.
brandBy :: Pattern Double -> Pattern Bool
_brandBy :: Double -> Pattern Bool

-- | Just like <a>rand</a> but for whole numbers, <tt>irand n</tt>
--   generates a pattern of (pseudo-) random whole numbers between
--   <tt>0</tt> to <tt>n-1</tt> 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 :: Fractional a => Pattern Double -> Pattern a

-- | As <a>perlin</a> with a suitable choice of input pattern
--   (<tt><a>sig</a> <a>fromRational</a></tt>).
perlin :: Fractional a => Pattern a

-- | <a>perlin2With</a> is Perlin noise with a 2-dimensional input. This
--   can be useful for more control over how the randomness repeats (or
--   doesn't).
--   
--   <pre>
--   d1
--    $ s "[supersaw:-12*32]"
--    # lpf (rangex 60 5000 $ perlin2With (cosine*2) (sine*2))
--    # lpq 0.3
--   </pre>
--   
--   will generate a smooth random cutoff pattern that repeats every cycle
--   without any reversals or discontinuities (because the 2D path is a
--   circle). <a>perlin2</a> only needs one input because it uses the cycle
--   count as the second input.
perlin2With :: Pattern Double -> Pattern Double -> Pattern Double

-- | As <a>perlin2</a> with a suitable choice of input pattern
--   (<tt><a>sig</a> <a>fromRational</a></tt>).
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

-- | Given a pattern of doubles, <a>chooseBy</a> normalizes them so that
--   each corresponds to an index in the provided list. The returned
--   pattern contains the corresponding elements in the list.
--   
--   <pre>
--   <a>choose</a> = chooseBy <a>rand</a>
--   </pre>
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

-- | Given a pattern of probabilities and an list of <tt>(value,
--   weight)</tt> pairs, <a>wchooseBy</a> creates a <tt><a>Pattern</a>
--   value</tt> by choosing values based on those probabilities and,
--   weighted appropriately by the weights in the list of pairs.
--   
--   <pre>
--   <a>wchoose</a> = wchooseBy <a>rand</a>
--   </pre>
wchooseBy :: Pattern Double -> [(a, Double)] -> 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

-- | As <a>randcat</a>, but allowing weighted choice.
wrandcat :: [(Pattern a, Double)] -> 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

-- | 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>
--   
--   You can also invoke this behavior in the shorthand notation by
--   specifying a percentage, as a number between 0 and 1, after the
--   question mark:
--   
--   <pre>
--   d1 $ s "bd hh?0.8 bd hh?0.4"
--   </pre>
degradeBy :: Pattern Double -> Pattern a -> Pattern a
_degradeBy :: Double -> Pattern a -> Pattern a
_degradeByUsing :: Pattern Double -> Double -> Pattern a -> Pattern a

-- | As <a>degradeBy</a>, but the pattern of probabilities represents the
--   chances to retain rather than remove the corresponding element.
unDegradeBy :: Pattern Double -> Pattern a -> Pattern a
_unDegradeBy :: Double -> Pattern a -> Pattern a
degradeOverBy :: Int -> Pattern Double -> Pattern a -> Pattern a

-- | Use <tt>sometimesBy</tt> to apply a given function "sometimes". For
--   example, the following code results in <tt>density 2</tt> 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>
--   <a>sometimes</a> = sometimesBy 0.5
--   <a>often</a> = sometimesBy 0.75
--   <a>rarely</a> = sometimesBy 0.25
--   <a>almostNever</a> = sometimesBy 0.1
--   <a>almostAlways</a> = sometimesBy 0.9
--   </pre>
sometimesBy :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | As <a>sometimesBy</a>, but applies the given transformation to the
--   pattern in its entirety before filtering its actual appearances. Less
--   efficient than <a>sometimesBy</a> but may be useful when the passed
--   pattern transformation depends on properties of the pattern before
--   probabilities are taken into account.
--   
--   <pre>
--   <a>sometimes'</a> = sometimesBy' 0.5
--   <a>often'</a> = sometimesBy' 0.75
--   <a>rarely'</a> = sometimesBy' 0.25
--   <a>almostNever'</a> = sometimesBy' 0.1
--   <a>almostAlways'</a> = sometimesBy' 0.9
--   </pre>
sometimesBy' :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <tt>sometimes</tt> is an alias for <tt>sometimesBy 0.5</tt>.
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 <tt>sometimesBy 0.75</tt>.
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 <tt>sometimesBy 0.25</tt>.
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 <tt>sometimesBy 0.1</tt>.
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 <tt>sometimesBy 0.9</tt>.
almostAlways :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
almostAlways' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | Never apply a transformation, returning the pattern unmodified.
--   
--   <pre>
--   never = flip const
--   </pre>
never :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | Apply the transformation to the pattern unconditionally.
--   
--   <pre>
--   always = id
--   </pre>
always :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <tt>someCyclesBy</tt> is a cycle-by-cycle version of
--   <tt><a>sometimesBy</a></tt>.
--   
--   <pre>
--   someCycles = someCyclesBy 0.5
--   </pre>
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

-- | <pre>
--   someCycles = someCyclesBy 0.5
--   </pre>
someCycles :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
somecycles :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | Pattern transformations are functions generally of type
--   <tt><a>Pattern</a> a -&gt; <a>Pattern</a> a</tt>. This means they take
--   a pattern of any type and return a pattern of that type.
--   
--   This transformation makes 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

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

-- | ’Undegrades’ 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; <tt>4%3</tt> 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 <tt>($)</tt> as the function to spread values
--   over, you can put functions as the list of values. (<a>spreadf</a> is
--   an alias for <tt>spread ($)</tt>.) 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: <tt>density 2</tt> - pattern will increase in speed</li>
--   <li>cycle 2: <tt>rev</tt> - pattern will be reversed</li>
--   <li>cycle 3: <tt>slow 2</tt> - pattern will decrease in speed</li>
--   <li>cycle 4: <tt>striate 3</tt> - pattern will be granualized</li>
--   <li>cycle 5: <tt>(# speed "0.8")</tt> - pattern samples will be played
--   back more slowly</li>
--   </ul>
--   
--   After <tt>(# speed "0.8")</tt>, the transforms will repeat and start
--   at <tt>density 2</tt> again.
spread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b

-- | An alias for <a>spread</a> consistent with <a>fastspread</a>.
slowspread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b

-- | <tt>fastspread</tt> works the same as <a>spread</a>, 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:
--   
--   <pre>
--   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"
--   </pre>
--   
--   There is also <a>slowspread</a>, 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 <i>pattern</i> 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

-- | <tt>spreadChoose f xs p</tt> is similar to <a>slowspread</a> but picks
--   values from <tt>xs</tt> at random, rather than cycling through them in
--   order.
spreadChoose :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b

-- | A shorter alias for <a>spreadChoose</a>.
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 <tt><tt>striate</tt> 4</tt> for every _even_ cycle and
--   apply <tt># coarse "24 48"</tt> 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 :: Pattern Time -> Pattern a -> Pattern a -> Pattern a
_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

-- | Reverse the part of the pattern sliced out by the <tt>(start,
--   end)</tt> pair.
--   
--   <pre>
--   revArc a = within a rev
--   </pre>
revArc :: (Time, Time) -> Pattern a -> Pattern a

-- | You can use the <tt>euclid</tt> function to apply a Euclidean
--   algorithm over a complex pattern, although the structure of that
--   pattern will be lost:
--   
--   <pre>
--   d1 $ euclid 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 <tt>euclid 3 8</tt>. It ends
--   up picking two <tt>bd</tt> sounds, a <tt>cp</tt> and missing the
--   <tt>sn</tt> entirely.
--   
--   A negative first argument provides the inverse of the euclidean
--   pattern.
--   
--   These types of sequences use "Bjorklund's algorithm", which wasn't
--   made for music but for an application in nuclear physics, which is
--   exciting. More exciting still is that it is very similar in structure
--   to the one of the first known algorithms written in Euclid's book of
--   elements in 300 BC. You can read more about this in the paper <a>The
--   Euclidean Algorithm Generates Traditional Musical Rhythms</a> by
--   Toussaint. Some examples from this paper are included below, including
--   rotation as a third parameter in some cases (see <a>euclidOff</a>).
--   
--   <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>
--   
--   There was once a shorter alias <tt>e</tt> for this function. It has
--   been removed, but you may see references to it in older Tidal code.
euclid :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_euclid :: Int -> Int -> Pattern a -> Pattern a

-- | <tt>euclidFull n k pa pb</tt> stacks <tt><a>euclid</a> n k pa</tt>
--   with <tt><a>euclidInv</a> n k pb</tt>. For example, to implement the
--   traditional flamenco rhythm, you could use hard claps for the former
--   and soft claps for the latter:
--   
--   <pre>
--   d1 $ euclidFull 3 7 "realclaps" ("realclaps" # gain 0.8)
--   </pre>
euclidFull :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a -> Pattern a

-- | Less expressive than <a>euclid</a> due to its constrained types, but
--   may be more efficient.
_euclidBool :: Int -> Int -> Pattern Bool
_euclid' :: Int -> Int -> Pattern a -> Pattern a

-- | As <a>euclid</a>, but taking a third rotational parameter
--   corresponding to the onset at which to start the rhythm.
euclidOff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a

-- | A shorter alias for <a>euclidOff</a>.
eoff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_euclidOff :: Int -> Int -> Int -> Pattern a -> Pattern a

-- | As <a>euclidOff</a>, but specialized to <a>Bool</a>. May be more
--   efficient than <a>euclidOff</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 <a>euclid</a>.
--   
--   Whereas <tt>euclid 3 8 "x"</tt> produces <tt>"x ~ ~ x ~ ~ x ~"</tt>,
--   <tt>euclidInv 3 8 "x"</tt> produces <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

-- | Calculates a whole cycle, rotates it, then constrains events to the
--   original query arc.
_rot :: Ord a => Int -> Pattern a -> Pattern a

-- | <tt>segment n p</tt>: ’samples’ 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

-- | 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 :: Pattern Int -> [a] -> Pattern Int -> Pattern a
_fit :: 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> is 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 <i>sam</i>).
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.
--   
--   An 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

-- | 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 if chunk number is positive - from right
--   to left if chunk number is negative
--   
--   <pre>
--   d1 $ chunk 4 (fast 4) $ sound "cp sn arpy [mt lt]"
--   
--   </pre>
chunk :: Pattern Int -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b
_chunk :: Integral a => a -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b

-- | DEPRECATED, use <a>chunk</a> with negative numbers instead
chunk' :: Integral a1 => Pattern a1 -> (Pattern a2 -> Pattern a2) -> Pattern a2 -> Pattern a2

-- | DEPRECATED, use <a>_chunk</a> with negative numbers instead
_chunk' :: Integral a => a -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b

-- | <tt>inside</tt> carries out an operation <i>inside</i> a cycle. For
--   example, while <tt>rev "0 1 2 3 4 5 6 7"</tt> is the same as <tt>"7 6
--   5 4 3 2 1 0"</tt>, <tt>inside 2 rev "0 1 2 3 4 5 6 7"</tt> gives
--   <tt>"3 2 1 0 7 6 5 4"</tt>.
inside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a
_inside :: Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a

-- | <tt>outside</tt> is the inverse of the <a>inside</a> function.
--   <tt>outside</tt> applies its function <i>outside</i> the cycle. Say
--   you have a pattern that takes 4 cycles to repeat and apply the rev
--   function:
--   
--   <pre>
--   d1 $ rev $ cat [s "bd bd sn",s "sn sn bd", s"lt lt sd", s "sd sd bd"]
--   </pre>
--   
--   The above generates:
--   
--   <pre>
--   d1 $ rev $ cat [s "sn bd bd",s "bd sn sn", s "sd lt lt", s "bd sd sd"]
--   </pre>
--   
--   However if you apply <tt>outside</tt>:
--   
--   <pre>
--   d1 $ outside 4 (rev) $ cat [s "bd bd sn",s "sn sn bd", s"lt lt sd", s "sd sd bd"]
--   </pre>
--   
--   The result is:
--   
--   <pre>
--   d1 $ rev $ cat [s "bd sd sd", s "sd lt lt", s "sn sn bd", s "bd bd sn"]
--   </pre>
outside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a
_outside :: Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a
loopFirst :: Pattern a -> Pattern a
timeLoop :: Pattern Time -> Pattern a -> Pattern a
seqPLoop :: [(Time, Time, Pattern a)] -> Pattern a

-- | <tt>toScale</tt> lets you turn a pattern of notes within a scale
--   (expressed as a list) to note numbers.
--   
--   For example: <tt>toScale [0, 4, 7] "0 1 2 3"</tt> will turn into the
--   pattern <tt>"0 4 7 12"</tt>.
--   
--   This function assumes your scale fits within an octave; if that's not
--   true, use <a>toScale'</a>.
--   
--   <pre>
--   toScale = toScale' 12
--   </pre>
toScale :: Num a => [a] -> Pattern Int -> Pattern a

-- | As <a>toScale</a>, though allowing scales of arbitrary size.
--   
--   An example: <tt>toScale' 24 [0,4,7,10,14,17] (run 8)</tt> turns into
--   <tt>"0 4 7 10 14 17 24 28"</tt>.
toScale' :: Num a => Int -> [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.
swingBy :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a

-- | As <a>swingBy</a>, with the cycle division set to ⅓.
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

-- | <tt>shuffle n p</tt> 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, <tt>shuffle 3 "a b c"</tt> could
--   return <tt>"a b c"</tt>, <tt>"a c b"</tt>, <tt>"b a c"</tt>, <tt>"b c
--   a"</tt>, <tt>"c a b"</tt>, or <tt>"c b a"</tt>. But it will **never**
--   return <tt>"a a a"</tt>, because that is not a permutation of the
--   parts.
shuffle :: Pattern Int -> Pattern a -> Pattern a
_shuffle :: Int -> Pattern a -> Pattern a

-- | <tt>scramble n p</tt> is like <a>shuffle</a> but randomly selects from
--   the parts of <tt>p</tt> instead of making permutations. For example,
--   <tt>scramble 3 "a b c"</tt> will randomly select 3 parts from
--   <tt>"a"</tt> <tt>"b"</tt> and <tt>"c"</tt>, possibly repeating a
--   single part.
scramble :: Pattern Int -> Pattern a -> Pattern a
_scramble :: Int -> Pattern a -> Pattern a

-- | <tt>randrun n</tt> generates a pattern of random integers less than
--   <tt>n</tt>.
--   
--   The following plays random notes in an octave:
--   
--   <pre>
--   d1 $ s "superhammond!12" # n (fromIntegral <a>$</a> randrun 13)
--   </pre>
randrun :: Int -> Pattern Int

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

-- | The <tt>ur</tt> function is designed for longer form composition, by
--   allowing you to create ’patterns of patterns’ in a repeating loop. It
--   takes four parameters: how long the loop will take, a pattern giving
--   the structure of the composition, a lookup table for named patterns to
--   feed into that structure, and a second lookup table for named
--   transformations/effects.
--   
--   The <i>ur-</i> prefix <a>comes from German</a> and means <i>proto-</i>
--   or <i>original</i>. For a mnemonic device, think of this function as
--   assembling a set of original patterns (ur-patterns) into a larger,
--   newer whole.
--   
--   Lets say you had three patterns (called <tt>a</tt>, <tt>b</tt> and
--   <tt>c</tt>), and that you wanted to play them four cycles each, over
--   twelve cycles in total. Here is one way to do it:
--   
--   <pre>
--   let pats =
--         [
--           ("a", stack [n "c4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7",
--                        n "[c3,g4,c4]" # s "superpiano"# gain "0.7"
--                       ]
--           ),
--           ("b", stack [n "d4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7",
--                        n "[d3,a4,d4]" # s "superpiano"# gain "0.7"
--                       ]
--           ),
--           ("c", stack [n "f4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7",
--                        n "[f4,c5,f4]" # s "superpiano"# gain "0.7"
--                       ]
--           )
--         ]
--   in
--   d1 $ ur 12 "a b c" pats []
--   </pre>
ur :: Time -> Pattern String -> [(String, Pattern a)] -> [(String, Pattern a -> Pattern a)] -> Pattern a

-- | A simpler version of <a>ur</a> that just provides name-value bindings
--   that are reflected in the provided pattern.
inhabit :: [(String, Pattern a)] -> Pattern String -> Pattern a

-- | <tt>spaceOut xs p</tt> repeats a <a>Pattern</a> <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 <a>Pattern</a> of lists and pulls the list
--   elements as separate <a>EventF</a>s.
flatpat :: Pattern [a] -> Pattern a

-- | <tt>layer</tt> takes a list of <a>Pattern</a>-returning functions and
--   a seed element, stacking the result of applying the seed element to
--   each function in the list.
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

-- | The <tt>arp</tt> function takes an additional pattern of arpeggiate
--   modes. For example:
--   
--   <pre>
--   d1 $ sound "superpiano" # n (arp "<a>down diverge</a>" "<a>e'7sus4'8</a>")
--   </pre>
--   
--   The different arpeggiate modes are: <tt> up down updown downup
--   up&amp;down down&amp;up converge diverge disconverge pinkyup
--   pinkyupdown thumbup thumbupdown- </tt>
arp :: Pattern String -> Pattern a -> Pattern a
_arp :: String -> Pattern a -> Pattern a

-- | <a>rolled</a> plays each note of a chord quickly in order, as opposed
--   to simultaneously; to give a chord a harp-like effect. This will
--   played from the lowest note to the highest note of the chord: <tt>
--   rolled $ n "c<tt>maj</tt>4" # s "superpiano" </tt>
--   
--   <pre>
--   rolled = rolledBy (1/4)
--   </pre>
rolled :: Pattern a -> Pattern a
rolledBy :: Pattern (Ratio Integer) -> Pattern a -> Pattern a
rolledWith :: Ratio Integer -> Pattern a -> Pattern a

-- | <tt>ply n</tt> repeats each event <tt>n</tt> times within its arc.
ply :: Pattern Rational -> Pattern a -> Pattern a
_ply :: Rational -> Pattern a -> Pattern a

-- | As <a>ply</a>, but applies a function each time. The applications are
--   compounded.
plyWith :: (Ord t, Num t) => Pattern t -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_plyWith :: (Ord t, Num t) => t -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | Syncopates a rhythm, shifting 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

-- | <tt>stutter n t pat</tt> repeats each event in <tt>pat</tt> <tt>n</tt>
--   times, separated by <tt>t</tt> time (in fractions of a cycle). It is
--   like <a>echo</a> that doesn't reduce the volume, or <a>ply</a> if you
--   controlled the timing.
--   
--   <pre>
--   d1 $ stutter 4 (1/16) $ s "bd cp"
--   </pre>
--   
--   is functionally equivalent to <tt> d1 $ stut 4 1 (1/16) $ s "bd cp"
--   </tt>
stutter :: Integral i => i -> 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

-- | Given a sample's directory name and number, this generates a string
--   suitable to pass to <a>fromString</a> to create a 'Pattern String'.
--   <a>samples</a> is a <a>Pattern</a>-compatible interface to this
--   function.
--   
--   <pre>
--   pick name n = name ++ ":" ++ show n
--   </pre>
pick :: String -> Int -> String

-- | Given a pattern of sample directory names and a of pattern indices
--   create a pattern of strings corresponding to the sample at each
--   name-index pair.
--   
--   An example: <tt>samples "jvbass [~ latibro] [jvbass [latibro jvbass]]"
--   ((1%2) <a>rotL</a> slow 6 "[1 6 8 7 3]")</tt>
--   
--   The type signature is more general here, but you can consider this to
--   be a function of type @Pattern String -&gt; Pattern Int -&gt; Pattern
--   String.
--   
--   <pre>
--   samples = liftA2 pick
--   </pre>
samples :: Applicative f => f String -> f Int -> f String

-- | Equivalent to <a>samples</a>, though the sample specifier pattern (the
--   <tt>f Int</tt>) will be evaluated first. Not a large difference in the
--   majority of cases.
samples' :: Applicative f => f String -> f Int -> f String
spreadf :: [a -> Pattern b] -> a -> Pattern b
stackwith :: Unionable a => Pattern a -> [Pattern a] -> Pattern a

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

-- | Deprecated backwards-compatible alias for <a>ghostWith</a>.
ghost'' :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | Like <a>ghost'</a>, but a user-supplied function describes how to
--   alter the pattern.
ghostWith :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
ghost' :: Time -> Pattern ValueMap -> Pattern ValueMap

-- | As <a>ghost</a>, but with the copies set to appear one-eighth of a
--   cycle afterwards.
--   
--   <pre>
--   ghost = ghost' 0.125
--   </pre>
ghost :: Pattern ValueMap -> Pattern ValueMap

-- | A more literal weaving than the <tt>weave</tt> function. Given
--   <tt>tabby threads p1 p</tt>, parameters representing the threads per
--   cycle and the patterns to weave, and this function will weave them
--   together using a plain (aka ’tabby’) weave, with a simple over/under
--   structure
tabby :: Int -> Pattern a -> Pattern a -> Pattern a

-- | chooses 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 the control pattern <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 (# crush 3) (#
--   vowel "a") (n "1") $ n "0 1" # s "bd sn" # 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

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

-- | As <a>quantise</a>, but uses <a>floor</a> to calculate divisions.
qfloor :: (Functor f, RealFrac b) => b -> f b -> f b

-- | As <a>quantise</a>, but uses <a>ceiling</a> to calculate divisions.
qceiling :: (Functor f, RealFrac b) => b -> f b -> f b

-- | An alias for <a>quantise</a>.
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 <i>monophonic</i>. Events which start/end earlier are
--   given priority.
mono :: Pattern a -> Pattern a

-- | <tt>smooth</tt> receives a pattern of numbers and linearly goes from
--   one to the next, passing through all of them. As time is cycle-based,
--   after reaching the last number in the pattern, it will smoothly go to
--   the first one again.
--   
--   <pre>
--   d1 $ sound "bd*4" # pan (slow 4 $ smooth "0 1 0.5 1")
--   </pre>
--   
--   This sound will pan gradually from left to right, then to the center,
--   then to the right again, and finally comes back to the left.
smooth :: Fractional a => Pattern a -> Pattern a

-- | Looks up values from a list of tuples, in order to swap values in the
--   given pattern
swap :: Eq a => [(a, b)] -> Pattern a -> Pattern b

-- | <tt>snowball</tt> takes a function that can combine patterns (like
--   <a>+</a>), a function that transforms a pattern (like <a>slow</a>), a
--   depth, and a starting pattern, it will then transform the pattern and
--   combine it with the last transformation until the depth is reached.
--   This is like putting an effect (like a filter) in the feedback of a
--   delay line; each echo is more affected.
--   
--   <pre>
--   d1 $ note (scale "hexDorian" $ snowball 8 (+) (slow 2 . rev) "0 ~ . -1 . 5 3 4 . ~ -2") # s "gtr"
--   </pre>
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

-- | <tt>construct n p</tt> breaks <tt>p</tt> into pieces and then
--   reassembles them so that it fits into <tt>n</tt> steps.
deconstruct :: Int -> Pattern String -> String

-- | <tt>bite n ipat pat</tt> slices a pattern <tt>pat</tt> into <tt>n</tt>
--   pieces, then uses the <tt>ipat</tt> pattern of integers to index into
--   those slices. So <tt>bite 4 "0 2*2" (run 8)</tt> is the same as
--   <tt>"[0 1] [4 5]*2"</tt>.
bite :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_bite :: Int -> Pattern Int -> Pattern a -> Pattern a

-- | <tt>squeeze</tt> uses a pattern of integers to index into a list of
--   patterns.
squeeze :: Pattern Int -> [Pattern a] -> Pattern a
squeezeJoinUp :: Pattern ControlPattern -> ControlPattern
_chew :: Int -> Pattern Int -> ControlPattern -> ControlPattern

-- | <tt>chew</tt> works the same as <a>bite</a>, but speeds up/slows down
--   playback of sounds as well as squeezing/contracting the slices of the
--   provided pattern.
chew :: Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern
__binary :: Bits b => Int -> b -> [Bool]
_binary :: Bits b => Int -> b -> Pattern Bool
_binaryN :: Int -> Pattern Int -> Pattern Bool
binaryN :: Pattern Int -> Pattern Int -> Pattern Bool
binary :: Pattern Int -> Pattern Bool
ascii :: Pattern String -> Pattern Bool

-- | Given a start point and a duration (both specified in cycles), this
--   generates a control pattern that makes a sound begin at the start
--   point and last the duration.
--   
--   <pre>
--   grain s d = <a>begin</a> s # <a>end</a> (s+d)
--   </pre>
grain :: Pattern Double -> Pattern Double -> ControlPattern

-- | For specifying a boolean pattern according to a list of offsets (aka
--   inter-onset intervals). For example `necklace 12 [4,2]` is the same as
--   "t f f f t f t f f f t f". That is, 12 steps per cycle, with true
--   values alternating between every 4 and every 2 steps.
necklace :: Rational -> [Int] -> Pattern Bool

module Sound.Tidal.ParseBP
data TidalParseError
TidalParseError :: ParseError -> String -> TidalParseError
[parsecError] :: TidalParseError -> ParseError
[code] :: TidalParseError -> String
type MyParser = Parsec String Int

-- | AST representation of patterns
data TPat a
[TPat_Atom] :: Maybe ((Int, Int), (Int, Int)) -> a -> TPat a
[TPat_Fast] :: TPat Time -> TPat a -> TPat a
[TPat_Slow] :: TPat Time -> TPat a -> TPat a
[TPat_DegradeBy] :: Int -> Double -> TPat a -> TPat a
[TPat_CycleChoose] :: Int -> [TPat a] -> TPat a
[TPat_Euclid] :: TPat Int -> TPat Int -> TPat Int -> TPat a -> TPat a
[TPat_Stack] :: [TPat a] -> TPat a
[TPat_Polyrhythm] :: Maybe (TPat Rational) -> [TPat a] -> TPat a
[TPat_Seq] :: [TPat a] -> TPat a
[TPat_Silence] :: TPat a
[TPat_Foot] :: TPat a
[TPat_Elongate] :: Rational -> TPat a -> TPat a
[TPat_Repeat] :: Int -> TPat a -> TPat a
[TPat_EnumFromTo] :: TPat a -> TPat a -> TPat a
[TPat_Var] :: String -> TPat a
[TPat_Chord] :: (Num b, Enum b, Parseable b, Enumerable b) => (b -> a) -> TPat b -> TPat String -> [TPat [Modifier]] -> TPat a
tShowList :: Show a => [TPat a] -> String
tShow :: Show a => TPat a -> String
toPat :: (Parseable a, Enumerable a) => TPat a -> Pattern a
resolve_tpat :: (Enumerable a, Parseable a) => TPat a -> (Rational, Pattern a)
resolve_seq :: (Enumerable a, Parseable a) => [TPat a] -> (Rational, Pattern a)
resolve_size :: [TPat a] -> [(Rational, TPat a)]
steps_tpat :: Show a => TPat a -> (Rational, String)
steps_seq :: Show a => [TPat a] -> (Rational, String)
steps_size :: Show a => [TPat a] -> [(Rational, String)]
parseBP :: (Enumerable a, Parseable a) => String -> Either ParseError (Pattern a)
parseBP_E :: (Enumerable a, Parseable a) => String -> Pattern a
parseTPat :: Parseable a => String -> Either ParseError (TPat a)
cP :: (Enumerable a, Parseable a) => String -> Pattern a
class Parseable a
tPatParser :: Parseable a => MyParser (TPat a)
doEuclid :: Parseable a => Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
getControl :: Parseable a => String -> Pattern a
class Enumerable a
fromTo :: Enumerable a => a -> a -> Pattern a
fromThenTo :: Enumerable a => a -> a -> a -> Pattern a
enumFromTo' :: (Ord a, Enum a) => a -> a -> Pattern a
enumFromThenTo' :: (Ord a, Enum a, Num a) => a -> a -> a -> Pattern a
type ColourD = Colour Double
lexer :: GenTokenParser String u Identity
braces :: MyParser a -> MyParser a
brackets :: MyParser a -> MyParser a
parens :: MyParser a -> MyParser a
angles :: MyParser a -> MyParser a
symbol :: String -> MyParser String
natural :: MyParser Integer
integer :: MyParser Integer
decimal :: MyParser Integer
float :: MyParser Double
naturalOrFloat :: MyParser (Either Integer Double)
data Sign
Positive :: Sign
Negative :: Sign
applySign :: Num a => Sign -> a -> a
sign :: MyParser Sign
intOrFloat :: MyParser Double
pSequence :: Parseable a => MyParser (TPat a) -> MyParser (TPat a)
pRepeat :: TPat a -> MyParser (TPat a)
pElongate :: TPat a -> MyParser (TPat a)
pSingle :: MyParser (TPat a) -> MyParser (TPat a)
pVar :: MyParser (TPat a)
pPart :: Parseable a => MyParser (TPat a) -> MyParser (TPat a)
newSeed :: MyParser Int
pPolyIn :: Parseable a => MyParser (TPat a) -> MyParser (TPat a)
pPolyOut :: Parseable a => MyParser (TPat a) -> MyParser (TPat a)
pCharNum :: MyParser Char
pString :: MyParser String
wrapPos :: MyParser (TPat a) -> MyParser (TPat a)
pVocable :: MyParser (TPat String)
pChar :: MyParser (TPat Char)
pDouble :: MyParser (TPat Double)
pDoubleWithoutChord :: MyParser (TPat Double)
pNote :: MyParser (TPat Note)
pNoteWithoutChord :: MyParser (TPat Note)
pBool :: MyParser (TPat Bool)
parseIntNote :: Integral i => MyParser i
pIntegral :: (Integral a, Parseable a, Enumerable a) => MyParser (TPat a)
pIntegralWithoutChord :: (Integral a, Parseable a, Enumerable a) => MyParser (TPat a)
parseChord :: (Enum a, Num a) => MyParser [a]
parseNote :: Num a => MyParser a
fromNote :: Num a => Pattern String -> Pattern a
pColour :: MyParser (TPat ColourD)
pMult :: TPat a -> MyParser (TPat a)
pRand :: TPat a -> MyParser (TPat a)
pE :: TPat a -> MyParser (TPat a)
pRational :: MyParser (TPat Rational)
pRatio :: MyParser Rational
pInteger :: MyParser Double
pFloat :: MyParser Double
pFraction :: RealFrac a => a -> MyParser Rational
pRatioChar :: Fractional a => MyParser a
pRatioSingleChar :: Fractional a => Char -> a -> MyParser a
isInt :: RealFrac a => a -> Bool
parseModInv :: MyParser Modifier
parseModInvNum :: MyParser [Modifier]
parseModDrop :: MyParser [Modifier]
parseModOpen :: MyParser Modifier
parseModRange :: MyParser Modifier
parseModifiers :: MyParser [Modifier]
pModifiers :: MyParser (TPat [Modifier])
pChord :: (Enum a, Num a, Parseable a, Enumerable a) => TPat a -> MyParser (TPat a)
instance GHC.Classes.Eq Sound.Tidal.ParseBP.TidalParseError
instance Sound.Tidal.ParseBP.Parseable Sound.Tidal.ParseBP.ColourD
instance Sound.Tidal.ParseBP.Enumerable Sound.Tidal.ParseBP.ColourD
instance GHC.Show.Show a => GHC.Show.Show (Sound.Tidal.ParseBP.TPat a)
instance GHC.Base.Functor Sound.Tidal.ParseBP.TPat
instance Sound.Tidal.ParseBP.Parseable GHC.Types.Char
instance Sound.Tidal.ParseBP.Parseable GHC.Types.Double
instance Sound.Tidal.ParseBP.Parseable Sound.Tidal.Pattern.Note
instance Sound.Tidal.ParseBP.Parseable GHC.Base.String
instance Sound.Tidal.ParseBP.Parseable GHC.Types.Bool
instance Sound.Tidal.ParseBP.Parseable GHC.Types.Int
instance Sound.Tidal.ParseBP.Parseable GHC.Num.Integer.Integer
instance Sound.Tidal.ParseBP.Parseable GHC.Real.Rational
instance (Sound.Tidal.ParseBP.Enumerable a, Sound.Tidal.ParseBP.Parseable a) => Data.String.IsString (Sound.Tidal.Pattern.Pattern a)
instance Sound.Tidal.ParseBP.Parseable [Sound.Tidal.Chords.Modifier]
instance Sound.Tidal.ParseBP.Enumerable GHC.Types.Char
instance Sound.Tidal.ParseBP.Enumerable GHC.Types.Double
instance Sound.Tidal.ParseBP.Enumerable Sound.Tidal.Pattern.Note
instance Sound.Tidal.ParseBP.Enumerable GHC.Base.String
instance Sound.Tidal.ParseBP.Enumerable GHC.Types.Bool
instance Sound.Tidal.ParseBP.Enumerable GHC.Types.Int
instance Sound.Tidal.ParseBP.Enumerable GHC.Num.Integer.Integer
instance Sound.Tidal.ParseBP.Enumerable GHC.Real.Rational
instance Sound.Tidal.ParseBP.Enumerable [Sound.Tidal.Chords.Modifier]
instance GHC.Exception.Type.Exception Sound.Tidal.ParseBP.TidalParseError
instance GHC.Show.Show Sound.Tidal.ParseBP.TidalParseError

module Sound.Tidal.Version
tidal_version :: String
tidal_status :: IO ()
tidal_status_string :: IO String

module Sound.Tidal.Stream
instance GHC.Show.Show Sound.Tidal.Stream.StampStyle
instance GHC.Classes.Eq Sound.Tidal.Stream.StampStyle
instance GHC.Show.Show Sound.Tidal.Stream.Schedule
instance GHC.Classes.Eq Sound.Tidal.Stream.Schedule
instance GHC.Show.Show Sound.Tidal.Stream.Target
instance GHC.Show.Show Sound.Tidal.Stream.Args
instance GHC.Show.Show Sound.Tidal.Stream.OSC
instance GHC.Show.Show Sound.Tidal.Stream.Cx

module Sound.Tidal.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

-- | DEPRECATED, use <a>striateBy</a> instead.
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

-- | Applies a type of delay to a pattern. It has three parameters, which
--   could be called depth, time and feedback.
--   
--   This adds a bit of echo: <tt> d1 $ echo 4 0.2 0.5 $ sound "bd sn"
--   </tt>
--   
--   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: <tt> d1 $ echo 4 (-0.2) 0.5 $
--   sound "bd sn" </tt>
echo :: Pattern Integer -> Pattern Rational -> Pattern Double -> ControlPattern -> ControlPattern
_echo :: Integer -> Rational -> Double -> ControlPattern -> ControlPattern

-- | Allows to apply a function for each step and overlays the result
--   delayed by the given time.
--   
--   <pre>
--   d1 $ echoWith 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.
echoWith :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_echoWith :: (Num n, Ord n) => n -> Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | DEPRECATED, use <a>echo</a> instead
stut :: Pattern Integer -> Pattern Double -> Pattern Rational -> ControlPattern -> ControlPattern
_stut :: Integer -> Double -> Rational -> ControlPattern -> ControlPattern

-- | DEPRECATED, use <a>echoWith</a> instead
stutWith :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_stutWith :: (Num n, Ord n) => n -> Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | DEPRECATED, use <a>echoWith</a> instead
stut' :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | Turns a pattern of seconds into a pattern of (rational) cycle
--   durations
sec :: Fractional a => Pattern a -> Pattern a

-- | Turns a pattern of milliseconds into a pattern of (rational) cycle
--   durations, according to the current cps.
msec :: Fractional a => Pattern a -> Pattern a

-- | Align the start of a pattern with the time a pattern is evaluated,
--   rather than the global start time. Because of this, the pattern will
--   probably not be aligned to the pattern grid.
trigger :: Pattern a -> Pattern a

-- | (Alias <tt><b>qt</b></tt>) Quantise trigger. Aligns the start of the
--   pattern with the next cycle boundary. For example, this pattern will
--   fade in starting with the next cycle after the pattern is evaluated:
--   
--   <pre>
--   d1 $ qtrigger $ s "hh(5, 8)" # amp envL
--   </pre>
--   
--   Note that the pattern will start playing immediately. The <i>start</i>
--   of the pattern aligns with the next cycle boundary, but events will
--   play before if the pattern has events at negative timestamps (which
--   most loops do). These events can be filtered out, for example:
--   
--   <pre>
--   d1 $ qtrigger $ filterWhen (&gt;= 0) $ s "hh(5, 8)"
--   </pre>
qtrigger :: Pattern a -> Pattern a
qt :: Pattern a -> Pattern a

-- | Ceiling trigger. Aligns the start of a pattern to the next cycle
--   boundary, just like <a>qtrigger</a>.
ctrigger :: Pattern a -> Pattern a

-- | Rounded trigger. Aligns the start of a pattern to the nearest cycle
--   boundary, either next or previous.
rtrigger :: Pattern a -> Pattern a

-- | Floor trigger. Aligns the start of a pattern to the previous cycle
--   boundary.
ftrigger :: Pattern a -> Pattern a

-- | (Alias <tt><b>mt</b></tt>) Mod trigger. Aligns the start of a pattern
--   to the next cycle boundary where the cycle is evenly divisible by a
--   given number. <a>qtrigger</a> is equivalent to <tt>mtrigger 1</tt>.
mtrigger :: Int -> Pattern a -> Pattern a
mt :: Int -> Pattern a -> Pattern a

-- | This aligns the start of a pattern to some value relative to the time
--   the pattern is evaluated. The provided function maps the evaluation
--   time (on the global cycle clock) to a new time, and then
--   <tt>triggerWith</tt> aligns the pattern's start to the time that's
--   returned.
triggerWith :: (Time -> Time) -> Pattern a -> Pattern a
splat :: Pattern Int -> ControlPattern -> ControlPattern -> ControlPattern

module Sound.Tidal.Transition
transition :: Stream -> Bool -> (Time -> [ControlPattern] -> ControlPattern) -> ID -> ControlPattern -> IO ()
mortalOverlay :: Time -> Time -> [Pattern a] -> Pattern a

-- | Washes away the current pattern after a certain delay by applying a
--   function to it over time, then switching over to the next pattern to
--   which another function is applied.
wash :: (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Time -> Time -> Time -> Time -> [Pattern a] -> Pattern a
washIn :: (Pattern a -> Pattern a) -> Time -> Time -> [Pattern a] -> Pattern a
xfadeIn :: Time -> Time -> [ControlPattern] -> ControlPattern

-- | Pans the last n versions of the pattern across the field
histpan :: Int -> Time -> [ControlPattern] -> ControlPattern

-- | Just stop for a bit before playing new pattern
wait :: Time -> Time -> [ControlPattern] -> ControlPattern

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

-- | Sharp <a>jump</a> transition at next cycle boundary where cycle mod n
--   == p
jumpMod' :: Int -> Int -> Time -> [ControlPattern] -> ControlPattern

-- | Degrade the new pattern over time until it ends in silence
mortal :: Time -> Time -> Time -> [ControlPattern] -> ControlPattern
interpolate :: Time -> [ControlPattern] -> ControlPattern
interpolateIn :: Time -> Time -> [ControlPattern] -> ControlPattern

-- | Degrades the current pattern while undegrading the next.
--   
--   This is like <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.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.Context

module Sound.Tidal.Safe.Context
data Op r
exec :: Stream -> Op r -> IO r
streamReplace :: ID -> ControlPattern -> Op ()
streamHush :: Op ()
streamList :: Op ()
streamMute :: ID -> Op ()
streamUnmute :: ID -> Op ()
streamSolo :: ID -> Op ()
streamUnsolo :: ID -> Op ()
streamOnce :: ControlPattern -> Op ()
streamFirst :: ControlPattern -> Op ()
streamNudgeAll :: Double -> Op ()
streamAll :: (ControlPattern -> ControlPattern) -> Op ()
streamResetCycles :: Op ()
streamSetI :: String -> Pattern Int -> Op ()
streamSetF :: String -> Pattern Double -> Op ()
streamSetS :: String -> Pattern String -> Op ()
streamSetR :: String -> Pattern Rational -> Op ()
streamSetB :: String -> Pattern Bool -> Op ()
transition :: Bool -> (Time -> [ControlPattern] -> ControlPattern) -> ID -> ControlPattern -> Op ()
data Target
Target :: String -> String -> Int -> Maybe Int -> Double -> Maybe Arc -> Schedule -> Bool -> Target
[oName] :: Target -> String
[oAddress] :: Target -> String
[oPort] :: Target -> Int
[oBusPort] :: Target -> Maybe Int
[oLatency] :: Target -> Double
[oWindow] :: Target -> Maybe Arc
[oSchedule] :: Target -> Schedule
[oHandshake] :: Target -> Bool
instance Control.Monad.Catch.MonadThrow Sound.Tidal.Safe.Context.Op
instance Control.Monad.Catch.MonadCatch Sound.Tidal.Safe.Context.Op
instance GHC.Base.Monad Sound.Tidal.Safe.Context.Op
instance GHC.Base.Applicative Sound.Tidal.Safe.Context.Op
instance GHC.Base.Functor Sound.Tidal.Safe.Context.Op

module Sound.Tidal.Safe.Boot
p :: ID -> ControlPattern -> Op ()
hush :: Op ()
list :: Op ()
mute :: ID -> Op ()
unmute :: ID -> Op ()
solo :: ID -> Op ()
unsolo :: ID -> Op ()
once :: ControlPattern -> Op ()
first :: ControlPattern -> Op ()
asap :: ControlPattern -> Op ()
nudgeAll :: Double -> Op ()
all :: (ControlPattern -> ControlPattern) -> Op ()
resetCycles :: Op ()
setcps :: Pattern Double -> Op ()
xfade :: ID -> ControlPattern -> Op ()
xfadeIn :: ID -> Time -> ControlPattern -> Op ()
histpan :: ID -> Int -> ControlPattern -> Op ()
wait :: ID -> Time -> ControlPattern -> Op ()
waitT :: ID -> (Time -> [ControlPattern] -> ControlPattern) -> Time -> ControlPattern -> Op ()
jump :: ID -> ControlPattern -> Op ()
jumpIn :: ID -> Int -> ControlPattern -> Op ()
jumpIn' :: ID -> Int -> ControlPattern -> Op ()
jumpMod :: ID -> Int -> ControlPattern -> Op ()
mortal :: ID -> Time -> Time -> ControlPattern -> Op ()
interpolate :: ID -> ControlPattern -> Op ()
interpolateIn :: ID -> Time -> ControlPattern -> Op ()
clutch :: ID -> ControlPattern -> Op ()
clutchIn :: ID -> Time -> ControlPattern -> Op ()
anticipate :: ID -> ControlPattern -> Op ()
anticipateIn :: ID -> Time -> ControlPattern -> Op ()
forId :: ID -> Time -> ControlPattern -> Op ()
d1 :: Pattern ValueMap -> Op ()
d2 :: Pattern ValueMap -> Op ()
d3 :: Pattern ValueMap -> Op ()
d4 :: Pattern ValueMap -> Op ()
d5 :: Pattern ValueMap -> Op ()
d6 :: Pattern ValueMap -> Op ()
d7 :: Pattern ValueMap -> Op ()
d8 :: Pattern ValueMap -> Op ()
d9 :: Pattern ValueMap -> Op ()
d10 :: Pattern ValueMap -> Op ()
d11 :: Pattern ValueMap -> Op ()
d12 :: Pattern ValueMap -> Op ()
d13 :: ControlPattern -> Op ()
d14 :: ControlPattern -> Op ()
d15 :: ControlPattern -> Op ()
d16 :: ControlPattern -> Op ()
setI :: String -> Pattern Int -> Op ()
setF :: String -> Pattern Double -> Op ()
setS :: String -> Pattern String -> Op ()
setR :: String -> Pattern Rational -> Op ()
setB :: String -> Pattern Bool -> Op ()
