-- 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 pattern.
@package tidal
@version 0.9.10

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


module Sound.Tidal.Utils

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

-- | apply <tt>f</tt> to the first element of a tuple
mapFst :: (a -> b) -> (a, c) -> (b, c)

-- | apply function to the first value of each tuple in given list
mapFsts :: (a -> b) -> [(a, c)] -> [(b, c)]

-- | apply <tt>f</tt> to the second element of a tuple
mapSnd :: (a -> b) -> (c, a) -> (c, b)

-- | apply function to the second value of each tuple in given list
mapSnds :: (a -> b) -> [(c, a)] -> [(c, b)]

-- | 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]]
maybeRead :: String -> Maybe Double

-- | shorthand for first element of triple
fst' :: () => (a, b, c) -> a

-- | shorthand for second element of triple
snd' :: () => (a, b, c) -> b

-- | shorthand for third element of triple
thd' :: () => (a, b, c) -> c

-- | apply <tt>f</tt> to the first element of a triple
mapFst' :: (a -> x) -> (a, b, c) -> (x, b, c)

-- | apply <tt>f</tt> to the second element of a triple
mapSnd' :: (b -> x) -> (a, b, c) -> (a, x, c)

-- | apply <tt>f</tt> to the third element of a triple
mapThd' :: (c -> x) -> (a, b, c) -> (a, b, x)

-- | apply function to the second value of each triple in given list
mapFsts' :: (a -> x) -> [(a, b, c)] -> [(x, b, c)]

-- | apply function to the second value of each triple in given list
mapSnds' :: (b -> x) -> [(a, b, c)] -> [(a, x, c)]

-- | apply function to the third value of each triple in given list
mapThds' :: (c -> x) -> [(a, b, c)] -> [(a, b, x)]

-- | map <tt>f</tt> over a given list of arcs
mapArcs :: (a -> a) -> [(a, a, x)] -> [(a, a, x)]

-- | combines two lists by interleaving them
--   
--   <pre>
--   &gt;&gt;&gt; mergelists [1,2,3] [9,8,7]
--   [1,9,2,8,3,7]
--   </pre>
mergelists :: [a] -> [a] -> [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
accumulate :: Num t => [t] -> [t]


module Sound.Tidal.Time

-- | Time is represented by a rational number. Each natural number
--   represents both the start of the next rhythmic cycle, and the end of
--   the previous one. Rational numbers are used so that subdivisions of
--   each cycle can be accurately represented.
type Time = Rational

-- | <tt>(s,e) :: Arc</tt> represents a time interval with a start and end
--   value. <tt> { t : s &lt;= t &amp;&amp; t &lt; e } </tt>
type Arc = (Time, Time)

-- | An Event is a value that occurs during the period given by the first
--   <tt>Arc</tt>. The second one indicates the event's "domain of
--   influence". These will often be the same, but many temporal
--   transformations, such as rotation and scaling time, may result in arcs
--   being split or truncated. In such cases, the first arc is preserved,
--   but the second arc reflects the portion of the event which is
--   relevant.
type Event a = (Arc, Arc, a)

-- | The starting point of the current cycle. A cycle occurs from each
--   natural number to the next, so this is equivalent to <tt>floor</tt>.
sam :: Time -> Time

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

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

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

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

-- | <tt>subArc i j</tt> is the arc that is the intersection of <tt>i</tt>
--   and <tt>j</tt>.
subArc :: Arc -> Arc -> Maybe Arc

-- | Map the given function over both the start and end <tt>Time</tt>
--   values of the given <tt>Arc</tt>.
mapArc :: (Time -> Time) -> Arc -> Arc

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

-- | Returns the `mirror image' of an <tt>Arc</tt> around the given point
--   intime, used by <tt>Sound.Tidal.Pattern.rev</tt>.
mirrorArc :: Time -> Arc -> Arc

-- | The start time of the given <tt>Event</tt>
eventStart :: Event a -> Time

-- | The original onset of the given <tt>Event</tt>
eventOnset :: Event a -> Time

-- | The original offset of the given <tt>Event</tt>
eventOffset :: Event a -> Time

-- | The arc of the given <tt>Event</tt>
eventArc :: Event a -> Arc

-- | The midpoint of an <tt>Arc</tt>
midPoint :: Arc -> Time

-- | <a>True</a> if an <a>Event</a>'s first and second <a>Arc</a>'s start
--   times match
hasOnset :: Event a -> Bool

-- | <a>True</a> if an <a>Event</a>'s first and second <a>Arc</a>'s end
--   times match
hasOffset :: Event a -> Bool

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

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

module Sound.Tidal.Tempo
data Tempo
Tempo :: UTCTime -> Double -> Double -> Bool -> Double -> Tempo
[at] :: Tempo -> UTCTime
[beat] :: Tempo -> Double
[cps] :: Tempo -> Double
[paused] :: Tempo -> Bool
[clockLatency] :: Tempo -> Double
type ClientState = [TConnection]
data ServerMode
Master :: ServerMode
Slave :: UDP -> ServerMode
data TConnection
TConnection :: Unique -> Connection -> TConnection
wsConn :: TConnection -> Connection
getLatency :: IO Double
getClockIp :: IO String
getServerPort :: IO Int
getMasterPort :: IO Int
getSlavePort :: IO Int
readTempo :: String -> Tempo
logicalTime :: Tempo -> Double -> Double
beatNow :: Tempo -> IO (Double)
getCurrentBeat :: MVar Tempo -> IO Rational
clientApp :: MVar Tempo -> MVar Double -> MVar Double -> ClientApp ()
sendTempo :: [Connection] -> Tempo -> IO ()
sendCps :: Connection -> MVar Double -> IO ()
sendNudge :: Connection -> MVar Double -> IO ()
connectClient :: Bool -> String -> MVar Tempo -> MVar Double -> MVar Double -> IO ()
runClient :: IO ((MVar Tempo, MVar Double, MVar Double))
cpsUtils' :: IO ((Double -> IO (), (Double -> IO ()), IO Rational))
cpsUtils :: IO (Double -> IO (), IO Rational)
bpsUtils :: IO ((Double -> IO (), IO (Rational)))
cpsSetter :: IO (Double -> IO ())
clocked :: (Tempo -> Int -> IO ()) -> IO ()
clockedTick :: Int -> (Tempo -> Int -> IO ()) -> IO ()
updateTempo :: Tempo -> Double -> IO (Tempo)
nudgeTempo :: Tempo -> Double -> Tempo
removeClient :: TConnection -> ClientState -> ClientState
broadcast :: Text -> ClientState -> IO ()
startServer :: IO (ThreadId)
serverApp :: MVar Tempo -> MVar ServerMode -> MVar ClientState -> ServerApp
slave :: MVar ServerMode -> MVar ClientState -> IO ()
slaveAct :: String -> MVar ServerMode -> MVar ClientState -> Message -> IO ()
setSlave :: MVar ServerMode -> IO ()
serverLoop :: TConnection -> MVar Tempo -> MVar ServerMode -> MVar ClientState -> IO ()
serverAct :: String -> ServerMode -> MVar Tempo -> MVar ClientState -> IO ()
setCps :: Double -> ServerMode -> MVar Tempo -> MVar ClientState -> IO ()
setNudge :: Double -> ServerMode -> MVar Tempo -> MVar ClientState -> IO ()
instance GHC.Classes.Eq Sound.Tidal.Tempo.TConnection
instance GHC.Show.Show Sound.Tidal.Tempo.ServerMode
instance GHC.Show.Show Sound.Tidal.Tempo.Tempo

module Sound.Tidal.Pattern

-- | The pattern datatype, a function from a time <tt>Arc</tt> to
--   <tt>Event</tt> values. For discrete patterns, this returns the events
--   which are active during that time. For continuous patterns, events
--   with values for the midpoint of the given <tt>Arc</tt> is returned.
newtype Pattern a
Pattern :: Arc -> [Event a] -> Pattern a
[arc] :: Pattern a -> Arc -> [Event a]
noOv :: String -> a

-- | converts a ratio into human readable string, e.g. <tt>1/3</tt>
showTime :: (Show a, Integral a) => Ratio a -> String

-- | converts a time arc into human readable string, e.g. <tt>1<i>3
--   3</i>4</tt>
showArc :: Arc -> String

-- | converts an event into human readable string, e.g. <tt>("bd" 1<i>4
--   2</i>3)</tt>
showEvent :: (Show a) => Event a -> String
unwrap :: Pattern (Pattern a) -> Pattern a

-- | <tt>atom</tt> is a synonym for <tt>pure</tt>.
atom :: a -> Pattern a

-- | <tt>silence</tt> returns a pattern with no events.
silence :: Pattern a

-- | <tt>withQueryArc f p</tt> returns a new <tt>Pattern</tt> with function
--   <tt>f</tt> applied to the <tt>Arc</tt> values passed to the original
--   <tt>Pattern</tt> <tt>p</tt>.
withQueryArc :: (Arc -> Arc) -> Pattern a -> Pattern a

-- | <tt>withQueryTime f p</tt> returns a new <tt>Pattern</tt> with
--   function <tt>f</tt> applied to the both the start and end
--   <tt>Time</tt> of the <tt>Arc</tt> passed to <tt>Pattern</tt>
--   <tt>p</tt>.
withQueryTime :: (Time -> Time) -> Pattern a -> Pattern a

-- | <tt>withResultArc f p</tt> returns a new <tt>Pattern</tt> with
--   function <tt>f</tt> applied to the <tt>Arc</tt> values in the events
--   returned from the original <tt>Pattern</tt> <tt>p</tt>.
withResultArc :: (Arc -> Arc) -> Pattern a -> Pattern a

-- | <tt>withResultTime f p</tt> returns a new <tt>Pattern</tt> with
--   function <tt>f</tt> applied to the both the start and end
--   <tt>Time</tt> of the <tt>Arc</tt> values in the events returned from
--   the original <tt>Pattern</tt> <tt>p</tt>.
withResultTime :: (Time -> Time) -> Pattern a -> Pattern a

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

-- | <tt>timedValues p</tt> returns a new <tt>Pattern</tt> where values are
--   turned into tuples of <tt>Arc</tt> and value.
timedValues :: Pattern a -> Pattern (Arc, a)

-- | <tt>overlay</tt> combines two <tt>Pattern</tt>s into a new pattern, so
--   that their events are combined over time. This is the same as the
--   infix operator <a>&lt;&gt;</a>.
overlay :: Pattern a -> Pattern a -> Pattern a

-- | <tt>stack</tt> combines a list of <tt>Pattern</tt>s into a new
--   pattern, so that their events are combined over time.
stack :: [Pattern a] -> Pattern a

-- | <tt>append</tt> combines two patterns <tt>Pattern</tt>s into a new
--   pattern, so that the events of the second pattern are appended to
--   those of the first pattern, within a single cycle
append :: Pattern a -> Pattern a -> Pattern a

-- | <tt>append'</tt> does the same as <tt>append</tt>, but over two
--   cycles, so that the cycles alternate between the two patterns.
append' :: Pattern a -> Pattern a -> Pattern a

-- | <tt>fastcat</tt> returns a new pattern which interlaces the cycles of
--   the given patterns, within a single cycle. It's the equivalent of
--   <tt>append</tt>, but with a list of patterns.
fastcat :: [Pattern a] -> Pattern a
splitAtSam :: Pattern a -> Pattern a

-- | <tt>slowcat</tt> does the same as <tt>fastcat</tt>, but maintaining
--   the duration of the original patterns. It is the equivalent of
--   <tt>append'</tt>, but with a list of patterns.
slowcat :: [Pattern a] -> Pattern a

-- | <tt>cat</tt> is an alias of <tt>slowcat</tt>
cat :: [Pattern a] -> Pattern a

-- | <tt>listToPat</tt> turns the given list of values to a Pattern, which
--   cycles through the list.
listToPat :: [a] -> Pattern a
patToList :: Pattern a -> [a]

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

-- | <tt>run</tt> <tt>n</tt> returns a pattern representing a cycle of
--   numbers from <tt>0</tt> to <tt>n-1</tt>.
run :: (Enum a, Num a) => Pattern a -> Pattern a
_run :: (Enum a, Num a) => a -> Pattern a
scan :: (Enum a, Num a) => Pattern a -> Pattern a
_scan :: (Enum a, Num a) => a -> Pattern a
temporalParam :: (a -> Pattern b -> Pattern c) -> (Pattern a -> Pattern b -> Pattern c)
temporalParam2 :: (a -> b -> Pattern c -> Pattern d) -> (Pattern a -> Pattern b -> Pattern c -> Pattern d)
temporalParam3 :: (a -> b -> c -> Pattern d -> Pattern e) -> (Pattern a -> Pattern b -> Pattern c -> Pattern d -> Pattern e)
temporalParam' :: (a -> Pattern b -> Pattern c) -> (Pattern a -> Pattern b -> Pattern c)
temporalParam2' :: (a -> b -> Pattern c -> Pattern d) -> (Pattern a -> Pattern b -> Pattern c -> Pattern d)
temporalParam3' :: (a -> b -> c -> Pattern d -> Pattern e) -> (Pattern a -> Pattern b -> Pattern c -> Pattern d -> Pattern e)

-- | <tt>fast</tt> (also known as <tt>density</tt>) returns the given
--   pattern with speed (or density) increased by the given <tt>Time</tt>
--   factor. Therefore <tt>fast 2 p</tt> will return a pattern that is
--   twice as fast, and <tt>fast (1/3) p</tt> will return one three times
--   as slow.
fast :: Pattern Time -> Pattern a -> Pattern a
_fast :: Time -> Pattern a -> Pattern a
fast' :: Pattern Time -> Pattern a -> Pattern a

-- | <tt>density</tt> is an alias of <tt>fast</tt>. <tt>fast</tt> is
--   quicker to type, but <tt>density</tt> is its old name so is used in a
--   lot of examples.
density :: Pattern Time -> Pattern a -> Pattern a
_density :: Time -> Pattern a -> Pattern a

-- | <tt>fastGap</tt> (also known as <tt>densityGap</tt> is similar to
--   <tt>fast</tt> 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).
fastGap :: Time -> Pattern a -> Pattern a
densityGap :: Time -> Pattern a -> Pattern a

-- | <tt>slow</tt> does the opposite of <tt>fast</tt>, i.e. <tt>slow 2
--   p</tt> will return a pattern that is half the speed.
slow :: Pattern Time -> Pattern a -> Pattern a
sparsity :: Pattern Time -> Pattern a -> Pattern a
slow' :: Pattern Time -> Pattern a -> Pattern a
_slow :: Time -> Pattern a -> Pattern a

-- | The <tt>&lt;~</tt> operator shifts (or rotates) a pattern to the left
--   (or counter-clockwise) by the given <tt>Time</tt> value. For example
--   <tt>(1%16) &lt;~ p</tt> will return a pattern with all the events
--   moved one 16th of a cycle to the left.
rotL :: Time -> Pattern a -> Pattern a
(<~) :: Pattern Time -> Pattern a -> Pattern a

-- | The <tt>~&gt;</tt> operator does the same as <tt>&lt;~</tt> but shifts
--   events to the right (or clockwise) rather than to the left.
rotR :: Time -> Pattern a -> Pattern a
(~>) :: Pattern Time -> Pattern a -> Pattern a

-- | (The above means that <a>brak</a> is a function from patterns of any
--   type, to a pattern of the same type.)
--   
--   Make a pattern sound a bit like a breakbeat
--   
--   Example:
--   
--   <pre>
--   d1 $ sound (brak "bd sn kurt")
--   </pre>
brak :: Pattern a -> Pattern a

-- | Divides a pattern into a given number of subdivisions, plays the
--   subdivisions in order, but increments the starting subdivision each
--   cycle. The pattern wraps to the first subdivision after the last
--   subdivision is played.
--   
--   Example:
--   
--   <pre>
--   d1 $ iter 4 $ sound "bd hh sn cp"
--   </pre>
--   
--   This will produce the following over four cycles:
--   
--   <pre>
--   bd hh sn cp
--   hh sn cp bd
--   sn cp bd hh
--   cp bd hh sn
--   </pre>
--   
--   There is also <a>iter'</a>, which shifts the pattern in the opposite
--   direction.
iter :: Pattern Int -> Pattern c -> Pattern c
_iter :: Int -> Pattern a -> Pattern a

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

-- | <tt>rev p</tt> returns <tt>p</tt> with the event positions in each
--   cycle reversed (or mirrored).
rev :: 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

-- | 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
whenT :: (Time -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
playWhen :: (Time -> Bool) -> Pattern a -> Pattern a
playFor :: Time -> Time -> Pattern a -> Pattern a

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

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

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

-- | <tt>sinewave</tt> returns a <tt>Pattern</tt> of continuous
--   <tt>Fractional</tt> values following a sinewave with frequency of one
--   cycle, and amplitude from 0 to 1.
sinewave :: Fractional a => Pattern a

-- | <tt>sine</tt> is a synonym for <tt>sinewave</tt>.
sine :: Fractional a => Pattern a

-- | <tt>sine</tt> is a synonym for <tt>0.25 ~&gt; sine</tt>.
cosine :: Fractional a => Pattern a

-- | <tt>sineAmp d</tt> returns <tt>sinewave</tt> with its amplitude offset
--   by <tt>d</tt>. Deprecated, as these days you can simply do e.g. (sine
--   + 0.5)
sineAmp :: Fractional a => a -> Pattern a

-- | <tt>sawwave</tt> is the equivalent of <tt>sinewave</tt> for
--   (ascending) sawtooth waves.
sawwave :: (Fractional a, Real a) => Pattern a

-- | <tt>saw</tt> is a synonym for <tt>sawwave</tt>.
saw :: (Fractional a, Real a) => Pattern a

-- | <tt>triwave</tt> is the equivalent of <tt>sinewave</tt> for triangular
--   waves.
triwave :: (Fractional a, Real a) => Pattern a

-- | <tt>tri</tt> is a synonym for <tt>triwave</tt>.
tri :: (Fractional a, Real a) => Pattern a

-- | <tt>squarewave1</tt> is the equivalent of <tt>sinewave</tt> for square
--   waves.
squarewave :: (Fractional a, Real a) => Pattern a

-- | <tt>square</tt> is a synonym for <tt>squarewave</tt>.
square :: (Fractional a, Real a) => Pattern a
sinewave1 :: Fractional a => Pattern a
sine1 :: Fractional a => Pattern a
sinerat :: Pattern Double
ratsine :: Pattern Double
sinerat1 :: Pattern Double
sineAmp1 :: Fractional a => a -> Pattern a
sawwave1 :: (Fractional a, Real a) => Pattern a
saw1 :: (Fractional a, Real a) => Pattern a
sawrat :: Pattern Double
sawrat1 :: Pattern Double
triwave1 :: (Fractional a, Real a) => Pattern a
tri1 :: (Fractional a, Real a) => Pattern a
trirat :: Pattern Double
trirat1 :: Pattern Double
squarewave1 :: (Fractional a, Real a) => Pattern a
square1 :: (Fractional a, Real a) => Pattern a

-- | <tt>envL</tt> is a <tt>Pattern</tt> of continuous <tt>Double</tt>
--   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
envLR :: Pattern Double
envEq :: Pattern Double
envEqR :: Pattern Double
fadeOut :: Time -> Pattern a -> Pattern a
fadeOut' :: Time -> Time -> Pattern a -> Pattern a
fadeIn' :: Time -> Time -> Pattern a -> Pattern a
fadeIn :: Time -> Pattern a -> Pattern a

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

-- | <tt>fastspread</tt> works the same as <tt>spread</tt>, but the result
--   is squashed into a single cycle. If you gave four values to
--   <tt>spread</tt>, then the result would seem to speed up by a factor of
--   four. Compare these two:
--   
--   d1 $ spread chop [4,64,32,16] $ sound "ho ho:2 ho:3 hc"
--   
--   d1 $ fastspread chop [4,64,32,16] $ sound "ho ho:2 ho:3 hc"
--   
--   There is also <tt>slowspread</tt>, which is an alias of
--   <tt>spread</tt>.
fastspread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b

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

-- | `spreadChoose f xs p` is similar to <a>slowspread</a> but picks values
--   from <tt>xs</tt> at random, rather than cycling through them in order.
--   It has a shorter alias <a>spreadr</a>.
spreadChoose :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b
spreadr :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b
filterValues :: (a -> Bool) -> Pattern a -> Pattern a
filterJust :: Pattern (Maybe a) -> Pattern a
filterOnsets :: Pattern a -> Pattern a
filterStartInRange :: Pattern a -> Pattern a
filterOnsetsInRange :: Pattern a -> Pattern a
seqToRelOnsetDeltas :: Arc -> Pattern a -> [(Double, Double, a)]
segment :: Pattern a -> Pattern [a]
segment' :: [Event a] -> [Event a]
split :: Time -> [Event a] -> [Event a]
points :: [Event a] -> [Time]
groupByTime :: [Event a] -> [Event [a]]

-- | Decide whether to apply one or another function depending on the
--   result of a test function that is passed the current cycle as a
--   number.
--   
--   <pre>
--   d1 $ ifp ((== 0).(flip mod 2))
--     (striate 4)
--     (# coarse "24 48") $
--     sound "hh hc"
--   </pre>
--   
--   This will apply `striate 4` for every _even_ cycle and aply `# coarse
--   "24 48"` for every _odd_.
--   
--   Detail: As you can see the test function is arbitrary and does not
--   rely on anything tidal specific. In fact it uses only plain haskell
--   functionality, that is: it calculates the modulo of 2 of the current
--   cycle which is either 0 (for even cycles) or 1. It then compares this
--   value against 0 and returns the result, which is either <a>True</a> or
--   <a>False</a>. This is what the <a>ifp</a> signature's first part
--   signifies `(Int -&gt; Bool)`, a function that takes a whole number and
--   returns either <a>True</a> or <a>False</a>.
ifp :: (Int -> Bool) -> (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <a>rand</a> generates a continuous pattern of (pseudo-)random,
--   floating point numbers between `0` and `1`.
--   
--   <pre>
--   d1 $ sound "bd*8" # pan rand
--   </pre>
--   
--   pans bass drums randomly
--   
--   <pre>
--   d1 $ sound "sn sn ~ sn" # gain rand
--   </pre>
--   
--   makes the snares' randomly loud and quiet.
--   
--   Numbers coming from this pattern are random, but dependent on time. So
--   if you reset time via `cps (-1)` 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>
--   d1 $ jux (|+| gain rand) $ sound "sn sn ~ sn" # gain rand
--   </pre>
--   
--   and with the juxed version shifted backwards for 1024 cycles:
--   
--   <pre>
--   d1 $ jux (|+| ((1024 &lt;~) $ gain rand)) $ sound "sn sn ~ sn" # gain rand
--   </pre>
rand :: Pattern Double
timeToRand :: RealFrac r => r -> Double

-- | Just like <a>rand</a> but for whole numbers, `irand n` generates a
--   pattern of (pseudo-) random whole numbers between `0` to `n-1`
--   inclusive. Notably used to pick a random samples from a folder:
--   
--   <pre>
--   d1 $ n (irand 5) # sound "drum"
--   </pre>
irand :: Num a => Int -> Pattern a

-- | Randomly picks an element from the given list
--   
--   <pre>
--   d1 $ sound (samples "xx(3,8)" (tom $ choose ["a", "e", "g", "c"]))
--   </pre>
--   
--   plays a melody randomly choosing one of the four notes "a", "e", "g",
--   "c".
choose :: [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>
degradeBy :: Pattern Double -> Pattern a -> Pattern a
_degradeBy :: Double -> Pattern a -> Pattern a
unDegradeBy :: Pattern Double -> Pattern a -> Pattern a
_unDegradeBy :: Double -> Pattern a -> Pattern a
degradeOverBy :: Int -> Pattern Double -> Pattern a -> Pattern a

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

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

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

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

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

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

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

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

-- | <tt>wedge t p p'</tt> combines patterns <tt>p</tt> and <tt>p'</tt> by
--   squashing the <tt>p</tt> into the portion of each cycle given by
--   <tt>t</tt>, and <tt>p'</tt> into the remainer of each cycle.
wedge :: Time -> Pattern a -> Pattern a -> Pattern a
timeCat :: [(Time, 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 :: Int -> Int -> (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>splitQueries p</tt> wraps <tt>p</tt> to ensure that it does not
--   get queries that span arcs. For example `arc 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

-- | <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>
linger :: Pattern Time -> Pattern a -> Pattern a
_linger :: Time -> Pattern a -> Pattern a

-- | Plays a portion of a pattern, specified by a beginning and end arc of
--   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 :: Arc -> Pattern a -> Pattern a
compress :: Arc -> Pattern a -> Pattern a
sliceArc :: Arc -> 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 :: 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' :: Arc -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
revArc :: Arc -> Pattern a -> Pattern a

-- | You can use the <tt>e</tt> function to apply a Euclidean algorithm
--   over a complex pattern, although the structure of that pattern will be
--   lost:
--   
--   <pre>
--   d1 $ e 3 8 $ sound "bd*2 [sn cp]"
--   </pre>
--   
--   In the above, three sounds are picked from the pattern on the right
--   according to the structure given by the `e 3 8`. It ends up picking
--   two <tt>bd</tt> sounds, a <tt>cp</tt> and missing the <tt>sn</tt>
--   entirely.
--   
--   These types of sequences use "Bjorklund's algorithm", which wasn't
--   made for music but for an application in nuclear physics, which is
--   exciting. More exciting still is that it is very similar in structure
--   to the one of the first known algorithms written in Euclid's book of
--   elements in 300 BC. You can read more about this in the paper [The
--   Euclidean Algorithm Generates Traditional Musical
--   Rhythms](http:/<i>cgm.cs.mcgill.ca</i>~godfried<i>publications</i>banff.pdf)
--   by Toussaint. Some examples from this paper are included below,
--   including rotation in some cases.
--   
--   <pre>
--   - (2,5) : A thirteenth century Persian rhythm called Khafif-e-ramal.
--   - (3,4) : The archetypal pattern of the Cumbia from Colombia, as well as a Calypso rhythm from Trinidad.
--   - (3,5,2) : Another thirteenth century Persian rhythm by the name of Khafif-e-ramal, as well as a Rumanian folk-dance rhythm.
--   - (3,7) : A Ruchenitza rhythm used in a Bulgarian folk-dance.
--   - (3,8) : The Cuban tresillo pattern.
--   - (4,7) : Another Ruchenitza Bulgarian folk-dance rhythm.
--   - (4,9) : The Aksak rhythm of Turkey.
--   - (4,11) : The metric pattern used by Frank Zappa in his piece titled Outside Now.
--   - (5,6) : Yields the York-Samai pattern, a popular Arab rhythm.
--   - (5,7) : The Nawakhat pattern, another popular Arab rhythm.
--   - (5,8) : The Cuban cinquillo pattern.
--   - (5,9) : A popular Arab rhythm called Agsag-Samai.
--   - (5,11) : The metric pattern used by Moussorgsky in Pictures at an Exhibition.
--   - (5,12) : The Venda clapping pattern of a South African children’s song.
--   - (5,16) : The Bossa-Nova rhythm necklace of Brazil.
--   - (7,8) : A typical rhythm played on the Bendir (frame drum).
--   - (7,12) : A common West African bell pattern.
--   - (7,16,14) : A Samba rhythm necklace from Brazil.
--   - (9,16) : A rhythm necklace used in the Central African Republic.
--   - (11,24,14) : A rhythm necklace of the Aka Pygmies of Central Africa.
--   - (13,24,5) : Another rhythm necklace of the Aka Pygmies of the upper Sangha.
--   </pre>
e :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_e :: Int -> Int -> Pattern a -> Pattern a
e' :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_e' :: Int -> Int -> Pattern a -> Pattern a
distrib :: [Pattern Int] -> Pattern a -> Pattern a
_distrib :: [Int] -> Pattern a -> Pattern a

-- | <a>einv</a> fills in the blanks left by <a>e</a> - <tt>e 3 8 "x"</tt>
--   -&gt; <tt>"x ~ ~ x ~ ~ x ~"</tt>
--   
--   <tt>einv 3 8 "x"</tt> -&gt; <tt>"~ x x ~ x x ~ x"</tt>
einv :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_einv :: Int -> Int -> Pattern a -> Pattern a

-- | `efull n k pa pb` stacks <tt>e n k pa</tt> with <tt>einv n k pb</tt>
efull :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a -> Pattern a
index :: Real b => b -> Pattern b -> Pattern c -> Pattern c

-- | <tt>prrw f rot (blen, vlen) beatPattern valuePattern</tt>: pattern
--   rotate/replace.
prrw :: (a -> b -> c) -> Int -> (Time, Time) -> Pattern a -> Pattern b -> Pattern c

-- | <tt>prr rot (blen, vlen) beatPattern valuePattern</tt>: pattern
--   rotate/replace.
prr :: Int -> (Time, Time) -> Pattern String -> Pattern b -> Pattern b

-- | <tt>preplace (blen, plen) beats values</tt> combines the timing of
--   <tt>beats</tt> with the values of <tt>values</tt>. Other ways of
--   saying this are: * sequential convolution * <tt>values</tt> quantized
--   to <tt>beats</tt>.
--   
--   Examples:
--   
--   <pre>
--   d1 $ sound $ preplace (1,1) "x [~ x] x x" "bd sn"
--   d1 $ sound $ preplace (1,1) "x(3,8)" "bd sn"
--   d1 $ sound $ "x(3,8)" <a>~</a> "bd sn"
--   d1 $ sound "[jvbass jvbass:5]*3" |+| (shape $ "1 1 1 1 1" <a>~</a> "0.2 0.9")
--   </pre>
--   
--   It is assumed the pattern fits into a single cycle. This works well
--   with pattern literals, but not always with patterns defined elsewhere.
--   In those cases use <tt>preplace</tt> and provide desired pattern
--   lengths: @ let p = slow 2 $ "x x x"
--   
--   d1 $ sound $ preplace (2,1) p "bd sn" @
preplace :: (Time, Time) -> Pattern String -> Pattern b -> Pattern b

-- | <tt>prep</tt> is an alias for preplace.
prep :: (Time, Time) -> Pattern String -> Pattern b -> Pattern b
preplace1 :: Pattern String -> Pattern b -> Pattern b
preplaceWith :: (a -> b -> c) -> (Time, Time) -> Pattern a -> Pattern b -> Pattern c
prw :: (a -> b -> c) -> (Time, Time) -> Pattern a -> Pattern b -> Pattern c
preplaceWith1 :: (a -> b -> c) -> Pattern a -> Pattern b -> Pattern c
prw1 :: (a -> b -> c) -> Pattern a -> Pattern b -> Pattern c
(<~>) :: Pattern String -> Pattern b -> Pattern b

-- | <tt>protate len rot p</tt> rotates pattern <tt>p</tt> by <tt>rot</tt>
--   beats to the left. <tt>len</tt>: length of the pattern, in cycles.
--   Example: <tt>d1 $ every 4 (protate 2 (-1)) $ slow 2 $ sound "bd hh hh
--   hh"</tt>
protate :: Time -> Int -> Pattern a -> Pattern a
prot :: Time -> Int -> Pattern a -> Pattern a
prot1 :: Int -> Pattern a -> Pattern a

-- | The <tt>&lt;&lt;~</tt> operator rotates a unit pattern to the left,
--   similar to <tt>&lt;~</tt>, but by events rather than linear time. The
--   timing of the pattern remains constant:
--   
--   <pre>
--   d1 $ (1 &lt;&lt;~) $ sound "bd ~ sn hh"
--   -- will become
--   d1 $ sound "sn ~ hh bd"
--   </pre>
(<<~) :: Int -> Pattern a -> Pattern a

-- | <tt>~&gt;&gt;</tt> is like <tt>&lt;&lt;~</tt> but for shifting to the
--   right.
(~>>) :: Int -> Pattern a -> Pattern a

-- | <tt>pequal cycles p1 p2</tt>: quickly test if <tt>p1</tt> and
--   <tt>p2</tt> are the same.
pequal :: Ord a => Time -> Pattern a -> Pattern a -> Bool

-- | <tt>discretise n p</tt>: <tt>samples</tt> 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.
discretise :: Time -> Pattern a -> Pattern a
discretise' :: Pattern Time -> Pattern a -> Pattern a
_discretise :: Time -> Pattern a -> Pattern a

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

-- | The <a>fit</a> function takes a pattern of integer numbers, which are
--   used to select values from the given list. What makes this a bit
--   strange is that only a given number of values are selected each cycle.
--   For example:
--   
--   <pre>
--   d1 $ sound (fit 3 ["bd", "sn", "arpy", "arpy:1", "casio"] "0 [~ 1] 2 1")
--   </pre>
--   
--   The above fits three samples into the pattern, i.e. for the first
--   cycle this will be `"bd"`, `"sn"` and `"arpy"`, giving the result `"bd
--   [~ sn] arpy sn"` (note that we start counting at zero, so that `0`
--   picks the first value). The following cycle the *next* three values in
--   the list will be picked, i.e. `"arpy:1"`, `"casio"` and `"bd"`, giving
--   the pattern `"arpy:1 [~ casio] bd casio"` (note that the list wraps
--   round here).
fit :: Int -> [a] -> Pattern Int -> Pattern a
permstep :: RealFrac b => Int -> [a] -> Pattern b -> Pattern a

-- | <tt>struct a b</tt>: structures pattern <tt>b</tt> in terms of
--   <tt>a</tt>.
struct :: Pattern String -> 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 String -> Pattern b -> Pattern b
compressTo :: Arc -> Pattern a -> Pattern a
randArcs :: Int -> Pattern [Arc]
randStruct :: Int -> Pattern Int
substruct' :: Pattern Int -> Pattern a -> Pattern a

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

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

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

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

-- | 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" :: Pattern Bool)
--     (slowcat ["can*8", "[cp*4 sn*4, jvbass*16]"] ))
--     # n (run 8)
--   </pre>
--   
--   Detail: It is currently needed to explicitly _tell_ Tidal that the
--   mask itself is a `Pattern Bool` as it cannot infer this by itself,
--   otherwise it will complain as it does not know how to interpret your
--   input.
mask :: Pattern a -> Pattern b -> Pattern b
enclosingArc :: [Arc] -> Arc
stretch :: Pattern a -> Pattern a

-- | <a>fit'</a> is a generalization of <a>fit</a>, where the list is
--   instead constructed by using another integer pattern to slice up a
--   given pattern. The first argument is the number of cycles of that
--   latter pattern to use when slicing. It's easier to understand this
--   with a few examples:
--   
--   <pre>
--   d1 $ sound (fit' 1 2 "0 1" "1 0" "bd sn")
--   </pre>
--   
--   So what does this do? The first `1` just tells it to slice up a single
--   cycle of `"bd sn"`. The `2` tells it to select two values each cycle,
--   just like the first argument to <a>fit</a>. The next pattern `"0 1"`
--   is the "from" pattern which tells it how to slice, which in this case
--   means `"0"` maps to `"bd"`, and `"1"` maps to `"sn"`. The next pattern
--   `"1 0"` is the "to" pattern, which tells it how to rearrange those
--   slices. So the final result is the pattern `"sn bd"`.
--   
--   A more useful example might be something like
--   
--   <pre>
--   d1 $ fit' 1 4 (run 4) "[0 3*2 2 1 0 3*2 2 [1*8 ~]]/2" $ chop 4 $ (sound "breaks152" # unit "c")
--   </pre>
--   
--   which uses <tt>chop</tt> to break a single sample into individual
--   pieces, which <a>fit'</a> then puts into a list (using the `run 4`
--   pattern) and reassembles according to the complicated integer pattern.
fit' :: Pattern Time -> Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a

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

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

-- | <tt>toScale</tt> lets you turn a pattern of notes within a scale
--   (expressed as a list) to note numbers. For example `toScale [0, 4, 7]
--   "0 1 2 3"` will turn into the pattern `"0 4 7 12"`. It assumes your
--   scale fits within an octave; to change this use <a>toScale</a> size`.
--   Example: <a>toScale</a> 24 [0,4,7,10,14,17] (run 8)` turns into `"0 4
--   7 10 14 17 24 28"`
toScale' :: Num a => Int -> [a] -> Pattern Int -> Pattern a
toScale :: Num a => [a] -> Pattern Int -> Pattern a

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

-- | <a>cycleChoose</a> is like <a>choose</a> but only picks a new item
--   from the list once each cycle
cycleChoose :: [a] -> Pattern a

-- | `shuffle n p` evenly divides one cycle of the pattern <tt>p</tt> into
--   <tt>n</tt> parts, and returns a random permutation of the parts each
--   cycle. For example, `shuffle 3 "a b c"` could return `"a b c"`, `"a c
--   b"`, `"b a c"`, `"b c a"`, `"c a b"`, or `"c b a"`. But it will
--   **never** return `"a a a"`, because that is not a permutation of the
--   parts.
shuffle :: Int -> Pattern a -> Pattern a

-- | `scramble n p` is like <a>shuffle</a> but randomly selects from the
--   parts of <tt>p</tt> instead of making permutations. For example,
--   `scramble 3 "a b c"` will randomly select 3 parts from `"a"` `"b"` and
--   `"c"`, possibly repeating a single part.
scramble :: Int -> Pattern a -> Pattern a
ur :: Time -> Pattern String -> [(String, Pattern a)] -> [(String, Pattern a -> Pattern a)] -> Pattern a
inhabit :: [(String, Pattern a)] -> Pattern String -> Pattern a
repeatCycles :: Int -> Pattern a -> Pattern a

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

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

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

-- | <tt>breakUp</tt> finds events that share the same timespan, and
--   spreads them out during that timespan, so for example <tt>breakUp
--   "[bd,sn]"</tt> gets turned into <tt>"bd sn"</tt>
breakUp :: Pattern a -> Pattern a

-- | <tt>fill</tt> 'fills in' gaps in one pattern with events from another.
--   For example <tt>fill "bd" "cp ~ cp"</tt> would result in the
--   equivalent of `"~ bd ~"`. This only finds gaps in a resulting pattern,
--   in other words <tt>"[bd ~, sn]"</tt> doesn't contain any gaps (because
--   <tt>sn</tt> covers it all), and <tt>"bd ~ ~ sn"</tt> only contains a
--   single gap that bridges two steps.
fill :: Pattern a -> Pattern a -> Pattern a
ply :: Pattern Int -> Pattern a -> Pattern a
_ply :: Int -> Pattern a -> Pattern a
sew :: Pattern Bool -> Pattern a -> Pattern a -> Pattern a
instance GHC.Classes.Eq (Sound.Tidal.Pattern.Pattern a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Sound.Tidal.Pattern.Pattern a)
instance GHC.Num.Num a => GHC.Num.Num (Sound.Tidal.Pattern.Pattern a)
instance GHC.Enum.Enum a => GHC.Enum.Enum (Sound.Tidal.Pattern.Pattern a)
instance (GHC.Num.Num a, GHC.Classes.Ord a) => GHC.Real.Real (Sound.Tidal.Pattern.Pattern a)
instance GHC.Real.Integral a => GHC.Real.Integral (Sound.Tidal.Pattern.Pattern a)
instance GHC.Real.Fractional a => GHC.Real.Fractional (Sound.Tidal.Pattern.Pattern a)
instance GHC.Float.Floating a => GHC.Float.Floating (Sound.Tidal.Pattern.Pattern a)
instance GHC.Real.RealFrac a => GHC.Real.RealFrac (Sound.Tidal.Pattern.Pattern a)
instance GHC.Float.RealFloat a => GHC.Float.RealFloat (Sound.Tidal.Pattern.Pattern a)
instance GHC.Show.Show a => GHC.Show.Show (Sound.Tidal.Pattern.Pattern a)
instance GHC.Base.Functor Sound.Tidal.Pattern.Pattern
instance GHC.Base.Applicative Sound.Tidal.Pattern.Pattern
instance GHC.Base.Monad Sound.Tidal.Pattern.Pattern

module Sound.Tidal.Scales
minPent :: Num a => [a]
majPent :: Num a => [a]
ritusen :: Num a => [a]
egyptian :: Num a => [a]
kumai :: Num a => [a]
hirajoshi :: Num a => [a]
iwato :: Num a => [a]
chinese :: Num a => [a]
indian :: Num a => [a]
pelog :: Num a => [a]
prometheus :: Num a => [a]
scriabin :: Num a => [a]
gong :: Num a => [a]
shang :: Num a => [a]
jiao :: Num a => [a]
zhi :: Num a => [a]
yu :: Num a => [a]
whole :: Num a => [a]
augmented :: Num a => [a]
augmented2 :: Num a => [a]
hexMajor7 :: Num a => [a]
hexDorian :: Num a => [a]
hexPhrygian :: Num a => [a]
hexSus :: Num a => [a]
hexMajor6 :: Num a => [a]
hexAeolian :: Num a => [a]
major :: Num a => [a]
ionian :: Num a => [a]
dorian :: Num a => [a]
phrygian :: Num a => [a]
lydian :: Num a => [a]
mixolydian :: Num a => [a]
aeolian :: Num a => [a]
minor :: Num a => [a]
locrian :: Num a => [a]
harmonicMinor :: Num a => [a]
harmonicMajor :: Num a => [a]
melodicMinor :: Num a => [a]
melodicMinorDesc :: Num a => [a]
melodicMajor :: Num a => [a]
bartok :: Num a => [a]
hindu :: Num a => [a]
todi :: Num a => [a]
purvi :: Num a => [a]
marva :: Num a => [a]
bhairav :: Num a => [a]
ahirbhairav :: Num a => [a]
superLocrian :: Num a => [a]
romanianMinor :: Num a => [a]
hungarianMinor :: Num a => [a]
neapolitanMinor :: Num a => [a]
enigmatic :: Num a => [a]
spanish :: Num a => [a]
leadingWhole :: Num a => [a]
lydianMinor :: Num a => [a]
neapolitanMajor :: Num a => [a]
locrianMajor :: Num a => [a]
diminished :: Num a => [a]
diminished2 :: Num a => [a]
chromatic :: Num a => [a]
scaleP :: Num a => Pattern String -> Pattern Int -> Pattern a
scaleTable :: Num a => [(String, [a])]

module Sound.Tidal.Parse

-- | AST representation of patterns
data TPat a
TPat_Atom :: a -> TPat a
TPat_Density :: (TPat Time) -> (TPat a) -> TPat a
TPat_Slow :: (TPat Time) -> (TPat a) -> TPat a
TPat_Zoom :: Arc -> (TPat a) -> TPat a
TPat_DegradeBy :: Double -> (TPat a) -> TPat a
TPat_Silence :: TPat a
TPat_Foot :: TPat a
TPat_Elongate :: Int -> TPat a
TPat_EnumFromTo :: (TPat a) -> (TPat a) -> TPat a
TPat_Cat :: [TPat a] -> TPat a
TPat_TimeCat :: [TPat a] -> TPat a
TPat_Overlay :: (TPat a) -> (TPat a) -> TPat a
TPat_ShiftL :: Time -> (TPat a) -> TPat a
TPat_pE :: (TPat Int) -> (TPat Int) -> (TPat Integer) -> (TPat a) -> TPat a
toPat :: Enumerable a => TPat a -> Pattern a
durations :: [TPat a] -> [(Int, TPat a)]
p :: (Enumerable a, Parseable a) => String -> Pattern a
class Parseable a
parseTPat :: Parseable a => String -> TPat 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 :: Parser a -> Parser a
brackets :: Parser a -> Parser a
parens :: Parser a -> Parser a
angles :: Parser a -> Parser a
symbol :: String -> Parser String
natural :: Parser Integer
integer :: Parser Integer
float :: Parser Double
naturalOrFloat :: Parser (Either Integer Double)
data Sign
Positive :: Sign
Negative :: Sign
applySign :: Num a => Sign -> a -> a
sign :: Parser Sign
intOrFloat :: Parser Double
r :: (Enumerable a, Parseable a) => String -> Pattern a -> IO (Pattern a)
parseRhythm :: Parseable a => Parser (TPat a) -> String -> TPat a
pSequenceN :: Parseable a => Parser (TPat a) -> GenParser Char () (Int, TPat a)
elongate :: () => [TPat a] -> TPat a
splitFeet :: [TPat t] -> [[TPat t]]
pSequence :: Parseable a => Parser (TPat a) -> GenParser Char () (TPat a)
pSingle :: Parseable a => Parser (TPat a) -> Parser (TPat a)
pPart :: Parseable a => Parser (TPat a) -> Parser [TPat a]
pPolyIn :: Parseable a => Parser (TPat a) -> Parser (TPat a)
pPolyOut :: Parseable a => Parser (TPat a) -> Parser (TPat a)
pString :: Parser (String)
pVocable :: Parser (TPat String)
pDouble :: Parser (TPat Double)
pBool :: Parser (TPat Bool)
parseIntNote :: Integral i => Parser i
parseInt :: Parser Int
pIntegral :: Parseable a => Integral a => Parser (TPat a)
parseNote :: Num a => Parser a
fromNote :: Num a => Pattern String -> Pattern a
pColour :: Parser (TPat ColourD)
pMult :: Parseable a => TPat a -> Parser (TPat a)
pRand :: Parseable a => TPat a -> Parser (TPat a)
pE :: Parseable a => TPat a -> Parser (TPat a)
eoff :: Pattern Int -> Pattern Int -> Pattern Integer -> Pattern a -> Pattern a
_eoff :: Int -> Int -> Integer -> Pattern a -> Pattern a
pReplicate :: Parseable a => TPat a -> Parser [TPat a]
pStretch :: Parseable a => TPat a -> Parser [TPat a]
pRatio :: Parser (Rational)
pRational :: Parser (TPat Rational)
instance GHC.Show.Show a => GHC.Show.Show (Sound.Tidal.Parse.TPat a)
instance Sound.Tidal.Parse.Parseable Sound.Tidal.Parse.ColourD
instance Sound.Tidal.Parse.Enumerable Sound.Tidal.Parse.ColourD
instance Sound.Tidal.Parse.Enumerable GHC.Types.Double
instance Sound.Tidal.Parse.Enumerable GHC.Base.String
instance Sound.Tidal.Parse.Enumerable GHC.Types.Bool
instance Sound.Tidal.Parse.Enumerable GHC.Types.Int
instance Sound.Tidal.Parse.Enumerable GHC.Integer.Type.Integer
instance Sound.Tidal.Parse.Enumerable GHC.Real.Rational
instance (Sound.Tidal.Parse.Enumerable a, Sound.Tidal.Parse.Parseable a) => Data.String.IsString (Sound.Tidal.Pattern.Pattern a)
instance Sound.Tidal.Parse.Parseable GHC.Types.Double
instance Sound.Tidal.Parse.Parseable GHC.Base.String
instance Sound.Tidal.Parse.Parseable GHC.Types.Bool
instance Sound.Tidal.Parse.Parseable GHC.Types.Int
instance Sound.Tidal.Parse.Parseable GHC.Integer.Type.Integer
instance Sound.Tidal.Parse.Parseable GHC.Real.Rational

module Sound.Tidal.Stream
type ToMessageFunc = Shape -> Tempo -> Int -> (Double, Double, ParamMap) -> Maybe (IO ())
data Backend a
Backend :: ToMessageFunc -> Shape -> Tempo -> Int -> IO () -> Backend a
[toMessage] :: Backend a -> ToMessageFunc
[flush] :: Backend a -> Shape -> Tempo -> Int -> IO ()
data Param
S :: String -> Maybe String -> Param
[name] :: Param -> String
[sDefault] :: Param -> Maybe String
F :: String -> Maybe Double -> Param
[name] :: Param -> String
[fDefault] :: Param -> Maybe Double
I :: String -> Maybe Int -> Param
[name] :: Param -> String
[iDefault] :: Param -> Maybe Int
data Shape
Shape :: [Param] -> Double -> Bool -> Shape
[params] :: Shape -> [Param]
[latency] :: Shape -> Double
[cpsStamp] :: Shape -> Bool
data Value
VS :: String -> Value
[svalue] :: Value -> String
VF :: Double -> Value
[fvalue] :: Value -> Double
VI :: Int -> Value
[ivalue] :: Value -> Int
class ParamType a
fromV :: ParamType a => Value -> Maybe a
toV :: ParamType a => a -> Value
type ParamMap = Map Param Value
type ParamPattern = Pattern ParamMap
ticksPerCycle :: Num p => p
defaultValue :: Param -> Value
hasDefault :: Param -> Bool
defaulted :: Shape -> [Param]
defaultMap :: Shape -> ParamMap
required :: Shape -> [Param]
hasRequired :: Shape -> ParamMap -> Bool
isSubset :: (Eq a) => [a] -> [a] -> Bool
doAt :: RealFrac a => a -> IO () -> IO ()
logicalOnset' :: Integral a => Tempo -> a -> Double -> Double -> Double
applyShape' :: Shape -> ParamMap -> Maybe ParamMap
start :: Backend a -> Shape -> IO (MVar (ParamPattern))
state :: Backend a -> Shape -> IO (MVar (ParamPattern, [ParamPattern]))
stream :: Backend a -> Shape -> IO (ParamPattern -> IO ())
streamcallback :: (ParamPattern -> IO ()) -> Backend a -> Shape -> IO (ParamPattern -> IO ())
onTick :: Backend a -> Shape -> MVar (ParamPattern) -> Tempo -> Int -> IO ()
onTick' :: Backend a -> Shape -> MVar (ParamPattern, [ParamPattern]) -> Tempo -> Int -> IO ()
make :: (a -> Value) -> Shape -> String -> Pattern a -> ParamPattern
make' :: ParamType a => (a -> Value) -> Param -> Pattern a -> ParamPattern
makeP :: ParamType a => Param -> Pattern a -> ParamPattern
makeS :: Shape -> String -> Pattern String -> ParamPattern
makeF :: Shape -> String -> Pattern Double -> ParamPattern
makeI :: Shape -> String -> Pattern Int -> ParamPattern
param :: Shape -> String -> Param
merge :: ParamPattern -> ParamPattern -> ParamPattern
(|=|) :: ParamPattern -> ParamPattern -> ParamPattern
infixl 1 |=|
(#) :: ParamPattern -> ParamPattern -> ParamPattern
infixl 1 #
mergeWith :: (Ord k, Applicative f) => (k -> a -> a -> a) -> f (Map k a) -> f (Map k a) -> f (Map k a)
mergeNumWith :: Applicative f => Int -> Int -> Int -> Double -> Double -> Double -> f Map Param Value -> f Map Param Value -> f Map Param Value
mergePlus :: Applicative f => f Map Param Value -> f Map Param Value -> f Map Param Value
(|*|) :: ParamPattern -> ParamPattern -> ParamPattern
infixl 1 |*|
(|+|) :: ParamPattern -> ParamPattern -> ParamPattern
infixl 1 |+|
(|-|) :: ParamPattern -> ParamPattern -> ParamPattern
infixl 1 |-|
(|/|) :: ParamPattern -> ParamPattern -> ParamPattern
infixl 1 |/|

-- | These are shorthand for merging lists of patterns with <tt>#</tt>,
--   <tt>|*|</tt>, <tt>|+|</tt>, or <tt>|/|</tt>. Sometimes this saves a
--   little typing and can improve readability when passing things into
--   other functions. As an example, instead of writing <tt> d1 $ sometimes
--   ((|*| speed "2") . (|*| cutoff "2") . (|*| shape "1.5")) $ sound
--   "arpy*4" shape "0.3" </tt> you can write <tt> d1 $ sometimes (***
--   [speed "2", cutoff "2", shape "1.5"]) $ sound "arpy*4" ### [cutoff
--   "350", shape "0.3"] </tt>
(###) :: Foldable t => ParamPattern -> t ParamPattern -> ParamPattern
(***) :: Foldable t => ParamPattern -> t ParamPattern -> ParamPattern
(+++) :: Foldable t => ParamPattern -> t ParamPattern -> ParamPattern
(///) :: Foldable t => ParamPattern -> t ParamPattern -> ParamPattern
setter :: MVar (a, [a]) -> a -> IO ()

-- | Copies values from one parameter to another. Used by <tt>nToOrbit</tt>
--   in <tt>Sound.Tidal.Dirt</tt>.
copyParam :: Param -> Param -> ParamPattern -> ParamPattern
get :: ParamType a => Param -> ParamPattern -> Pattern a
getI :: Param -> ParamPattern -> Pattern Int
getF :: Param -> ParamPattern -> Pattern Double
getS :: Param -> ParamPattern -> Pattern String
with :: (ParamType a) => Param -> (Pattern a -> Pattern a) -> ParamPattern -> ParamPattern
withI :: Param -> (Pattern Int -> Pattern Int) -> ParamPattern -> ParamPattern
withF :: Param -> (Pattern Double -> Pattern Double) -> ParamPattern -> ParamPattern
withS :: Param -> (Pattern String -> Pattern String) -> ParamPattern -> ParamPattern
follow :: (ParamType a, ParamType b) => Param -> Param -> (Pattern a -> Pattern b) -> ParamPattern -> ParamPattern
follow' :: ParamType a => Param -> Param -> (Pattern a -> Pattern a) -> ParamPattern -> ParamPattern
followI :: Param -> Param -> (Pattern Int -> Pattern Int) -> ParamPattern -> ParamPattern
followF :: Param -> Param -> (Pattern Double -> Pattern Double) -> ParamPattern -> ParamPattern
followS :: Param -> Param -> (Pattern String -> Pattern String) -> ParamPattern -> ParamPattern
coerce :: Param -> ParamPattern -> ParamPattern
instance GHC.Classes.Ord Sound.Tidal.Stream.Value
instance GHC.Classes.Eq Sound.Tidal.Stream.Value
instance Sound.Tidal.Stream.ParamType GHC.Base.String
instance Sound.Tidal.Stream.ParamType GHC.Types.Double
instance Sound.Tidal.Stream.ParamType GHC.Types.Int
instance GHC.Show.Show Sound.Tidal.Stream.Value
instance GHC.Classes.Eq Sound.Tidal.Stream.Param
instance GHC.Classes.Ord Sound.Tidal.Stream.Param
instance GHC.Show.Show Sound.Tidal.Stream.Param

module Sound.Tidal.Chords
major :: Num a => [a]
minor :: Num a => [a]
major7 :: Num a => [a]
dom7 :: Num a => [a]
minor7 :: Num a => [a]
aug :: Num a => [a]
dim :: Num a => [a]
dim7 :: Num a => [a]
one :: Num a => [a]
five :: Num a => [a]
plus :: Num a => [a]
sharp5 :: Num a => [a]
msharp5 :: Num a => [a]
sus2 :: Num a => [a]
sus4 :: Num a => [a]
six :: Num a => [a]
m6 :: Num a => [a]
sevenSus2 :: Num a => [a]
sevenSus4 :: Num a => [a]
sevenFlat5 :: Num a => [a]
m7flat5 :: Num a => [a]
sevenSharp5 :: Num a => [a]
m7sharp5 :: Num a => [a]
nine :: Num a => [a]
m9 :: Num a => [a]
m7sharp9 :: Num a => [a]
maj9 :: Num a => [a]
nineSus4 :: Num a => [a]
sixby9 :: Num a => [a]
m6by9 :: Num a => [a]
sevenFlat9 :: Num a => [a]
m7flat9 :: Num a => [a]
sevenFlat10 :: Num a => [a]
nineSharp5 :: Num a => [a]
m9sharp5 :: Num a => [a]
sevenSharp5flat9 :: Num a => [a]
m7sharp5flat9 :: Num a => [a]
eleven :: Num a => [a]
m11 :: Num a => [a]
maj11 :: Num a => [a]
evelenSharp :: Num a => [a]
m11sharp :: Num a => [a]
thirteen :: Num a => [a]
m13 :: 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 => [[b]] -> b -> Int -> [b]

-- | <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 => [[a]] -> Pattern a -> Pattern Int -> Pattern a
chordTable :: Num a => [(String, [a])]
chordL :: Num a => Pattern String -> Pattern [a]

-- | <tt>chord p</tt> turns a pattern of chord names into a pattern of
--   numbers, representing note value offsets for the chords
chord :: Num a => Pattern String -> Pattern a

-- | <tt>arpg p</tt> turns a pattern of chord names into a pattern of
--   arpeggios of the those chords respectively
arpg :: Num a => Pattern String -> Pattern a

module Sound.Tidal.Params

-- | group multiple params into one
grp :: [Param] -> Pattern String -> ParamPattern

-- | A pattern of strings representing sounds or synth notes.
--   
--   Internally, <a>sound</a> or its shorter alias <a>s</a> is a
--   combination of the samplebank name and number when used with samples,
--   or synth name and note number when used with a synthesiser. For
--   example `bd:2` specifies the third sample (not the second as you might
--   expect, because we start counting at zero) in the <tt>bd</tt> sample
--   folder.
--   
--   <ul>
--   <li>Internally, <a>sound</a>/<a>s</a> is a combination of two
--   parameters, the hidden parameter <a>s'</a> which specifies the
--   samplebank or synth, and the <a>n</a> parameter which specifies the
--   sample or note number. For example:</li>
--   </ul>
--   
--   <pre>
--   d1 $ sound "bd:2 sn:0"
--   </pre>
--   
--   is essentially the same as:
--   
--   <pre>
--   d1 $ s' "bd sn" # n "2 0"
--   </pre>
--   
--   <a>n</a> is therefore useful when you want to pattern the sample or
--   note number separately from the samplebank or synth. For example:
--   
--   <pre>
--   d1 $ n "0 5 ~ 2" # sound "drum"
--   </pre>
--   
--   is equivalent to:
--   
--   <pre>
--   d1 $ sound "drum:0 drum:5 ~ drum:2"
--   </pre>
sound :: Pattern String -> ParamPattern
s :: Pattern String -> ParamPattern
pF :: String -> Maybe Double -> (Pattern Double -> ParamPattern, Param)
pI :: String -> Maybe Int -> (Pattern Int -> ParamPattern, Param)
pS :: String -> Maybe String -> (Pattern String -> ParamPattern, Param)

-- | a pattern of numbers that speed up (or slow down) samples while they
--   play.
accelerate :: Pattern Double -> ParamPattern

-- | a pattern of numbers to specify the attack time (in seconds) of an
--   envelope applied to each sample. Only takes effect if <a>release</a>
--   is also specified.
attack :: Pattern Double -> ParamPattern

-- | a pattern of numbers from 0 to 1. Sets the center frequency of the
--   band-pass filter.
bandf :: Pattern Double -> ParamPattern

-- | a pattern of numbers from 0 to 1. Sets the q-factor of the band-pass
--   filter.y
bandq :: Pattern Double -> ParamPattern

-- | 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.
--   
--   Using `begin "-1"` combined with `cut "-1"` means that when the sample
--   cuts itself it will begin playback from where the previous one left
--   off, so it will sound like one seamless sample. This allows you to
--   apply a synth param across a long sample in a way similar to
--   <tt>chop</tt>:
--   
--   <pre>
--   cps 0.5
--   
--   d1 $ sound "breaks125*8"  begin "-1"  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   This will play the <tt>breaks125</tt> sample and apply the changing
--   <a>coarse</a> parameter over the sample. Compare to:
--   
--   <pre>
--   d1 $ (chop 8 $ sounds "breaks125")  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   which performs a similar effect, but due to differences in
--   implementation sounds different.
begin_p :: Param

-- | 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.
--   
--   Using `begin "-1"` combined with `cut "-1"` means that when the sample
--   cuts itself it will begin playback from where the previous one left
--   off, so it will sound like one seamless sample. This allows you to
--   apply a synth param across a long sample in a way similar to
--   <tt>chop</tt>:
--   
--   <pre>
--   cps 0.5
--   
--   d1 $ sound "breaks125*8"  begin "-1"  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   This will play the <tt>breaks125</tt> sample and apply the changing
--   <a>coarse</a> parameter over the sample. Compare to:
--   
--   <pre>
--   d1 $ (chop 8 $ sounds "breaks125")  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   which performs a similar effect, but due to differences in
--   implementation sounds different.
channel_p :: Param

-- | 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.
--   
--   Using `begin "-1"` combined with `cut "-1"` means that when the sample
--   cuts itself it will begin playback from where the previous one left
--   off, so it will sound like one seamless sample. This allows you to
--   apply a synth param across a long sample in a way similar to
--   <tt>chop</tt>:
--   
--   <pre>
--   cps 0.5
--   
--   d1 $ sound "breaks125*8"  begin "-1"  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   This will play the <tt>breaks125</tt> sample and apply the changing
--   <a>coarse</a> parameter over the sample. Compare to:
--   
--   <pre>
--   d1 $ (chop 8 $ sounds "breaks125")  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   which performs a similar effect, but due to differences in
--   implementation sounds different.
legato_p :: Param

-- | 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.
--   
--   Using `begin "-1"` combined with `cut "-1"` means that when the sample
--   cuts itself it will begin playback from where the previous one left
--   off, so it will sound like one seamless sample. This allows you to
--   apply a synth param across a long sample in a way similar to
--   <tt>chop</tt>:
--   
--   <pre>
--   cps 0.5
--   
--   d1 $ sound "breaks125*8"  begin "-1"  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   This will play the <tt>breaks125</tt> sample and apply the changing
--   <a>coarse</a> parameter over the sample. Compare to:
--   
--   <pre>
--   d1 $ (chop 8 $ sounds "breaks125")  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   which performs a similar effect, but due to differences in
--   implementation sounds different.
clhatdecay_p :: Param

-- | 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.
--   
--   Using `begin "-1"` combined with `cut "-1"` means that when the sample
--   cuts itself it will begin playback from where the previous one left
--   off, so it will sound like one seamless sample. This allows you to
--   apply a synth param across a long sample in a way similar to
--   <tt>chop</tt>:
--   
--   <pre>
--   cps 0.5
--   
--   d1 $ sound "breaks125*8"  begin "-1"  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   This will play the <tt>breaks125</tt> sample and apply the changing
--   <a>coarse</a> parameter over the sample. Compare to:
--   
--   <pre>
--   d1 $ (chop 8 $ sounds "breaks125")  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   which performs a similar effect, but due to differences in
--   implementation sounds different.
coarse_p :: Param

-- | 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.
--   
--   Using `begin "-1"` combined with `cut "-1"` means that when the sample
--   cuts itself it will begin playback from where the previous one left
--   off, so it will sound like one seamless sample. This allows you to
--   apply a synth param across a long sample in a way similar to
--   <tt>chop</tt>:
--   
--   <pre>
--   cps 0.5
--   
--   d1 $ sound "breaks125*8"  begin "-1"  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   This will play the <tt>breaks125</tt> sample and apply the changing
--   <a>coarse</a> parameter over the sample. Compare to:
--   
--   <pre>
--   d1 $ (chop 8 $ sounds "breaks125")  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   which performs a similar effect, but due to differences in
--   implementation sounds different.
crush_p :: Param
begin :: Pattern Double -> ParamPattern
legato :: Pattern Double -> ParamPattern
clhatdecay :: Pattern Double -> ParamPattern

-- | bit crushing, a pattern of numbers from 1 (for drastic reduction in
--   bit-depth) to 16 (for barely no reduction).
crush :: Pattern Double -> ParamPattern

-- | choose the physical channel the pattern is sent to, this is super dirt
--   specific
channel :: Pattern Int -> ParamPattern

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

-- | 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.
--   
--   <pre>
--   d1 $ stack [
--     sound "bd",
--     sound "~ [~ [ho:2 hc/2]]" # cut "1"
--     ]
--   </pre>
--   
--   This will mute the open hi-hat every second cycle when the closed one
--   is played.
--   
--   Using <a>cut</a> with negative values will only cut the same sample.
--   This is useful to cut very long samples
--   
--   <pre>
--   d1 $ sound "<a>bev, [ho:3</a>]" # cut "-1"
--   </pre>
--   
--   Using `cut "0"` is effectively _no_ cutgroup.
cut :: Pattern Int -> ParamPattern

-- | a pattern of numbers from 0 to 1. Applies the cutoff frequency of the
--   low-pass filter.
cutoff :: Pattern Double -> ParamPattern
cutoffegint :: Pattern Double -> ParamPattern
decay :: Pattern Double -> ParamPattern

-- | a pattern of numbers from 0 to 1. Sets the level of the delay signal.
delay :: Pattern Double -> ParamPattern

-- | a pattern of numbers from 0 to 1. Sets the amount of delay feedback.
delayfeedback :: Pattern Double -> ParamPattern

-- | a pattern of numbers from 0 to 1. Sets the length of the delay.
delaytime :: Pattern Double -> ParamPattern
detune :: Pattern Double -> ParamPattern

-- | 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 -> ParamPattern
end :: Pattern Double -> ParamPattern

-- | a pattern of numbers that specify volume. Values less than 1 make the
--   sound quieter. Values greater than 1 make the sound louder.
gain :: Pattern Double -> ParamPattern
gate :: Pattern Double -> ParamPattern
hatgrain :: Pattern Double -> ParamPattern

-- | a pattern of numbers from 0 to 1. Applies the cutoff frequency of the
--   high-pass filter.
hcutoff :: Pattern Double -> ParamPattern

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

-- | a pattern of numbers from 0 to 1. Applies the resonance of the
--   high-pass filter.
hresonance :: Pattern Double -> ParamPattern
kriole :: Pattern Int -> ParamPattern
lagogo :: Pattern Double -> ParamPattern
lclap :: Pattern Double -> ParamPattern
lclaves :: Pattern Double -> ParamPattern
lclhat :: Pattern Double -> ParamPattern
lcrash :: Pattern Double -> ParamPattern
leslie :: Pattern Double -> ParamPattern
lrate :: Pattern Double -> ParamPattern
lsize :: Pattern Double -> ParamPattern
lfo :: Pattern Double -> ParamPattern
lfocutoffint :: Pattern Double -> ParamPattern
lfodelay :: Pattern Double -> ParamPattern
lfoint :: Pattern Double -> ParamPattern
lfopitchint :: Pattern Double -> ParamPattern
lfoshape :: Pattern Double -> ParamPattern
lfosync :: Pattern Double -> ParamPattern
lhitom :: Pattern Double -> ParamPattern
lkick :: Pattern Double -> ParamPattern
llotom :: Pattern Double -> ParamPattern

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

-- | loops the sample (from <a>begin</a> to <a>end</a>) the specified
--   number of times.
loop :: Pattern Double -> ParamPattern
lophat :: Pattern Double -> ParamPattern
lsnare :: Pattern Double -> ParamPattern

-- | specifies the sample or note number to be used
n :: Pattern Double -> ParamPattern
note :: Pattern Double -> ParamPattern

-- | Pushes things forward (or backwards within built-in latency) in time.
--   Allows for nice things like _swing_ feeling:
--   
--   <pre>
--   d1 $ stack [
--     sound "bd bd/4",
--     sound "hh(5,8)"
--     ] # nudge "[0 0.04]*4"
--   </pre>
--   
--   <ul>
--   <li>-pitch model</li>
--   </ul>
degree :: Pattern Double -> ParamPattern

-- | Pushes things forward (or backwards within built-in latency) in time.
--   Allows for nice things like _swing_ feeling:
--   
--   <pre>
--   d1 $ stack [
--     sound "bd bd/4",
--     sound "hh(5,8)"
--     ] # nudge "[0 0.04]*4"
--   </pre>
--   
--   <ul>
--   <li>-pitch model</li>
--   </ul>
mtranspose :: Pattern Double -> ParamPattern

-- | Pushes things forward (or backwards within built-in latency) in time.
--   Allows for nice things like _swing_ feeling:
--   
--   <pre>
--   d1 $ stack [
--     sound "bd bd/4",
--     sound "hh(5,8)"
--     ] # nudge "[0 0.04]*4"
--   </pre>
--   
--   <ul>
--   <li>-pitch model</li>
--   </ul>
ctranspose :: Pattern Double -> ParamPattern

-- | Pushes things forward (or backwards within built-in latency) in time.
--   Allows for nice things like _swing_ feeling:
--   
--   <pre>
--   d1 $ stack [
--     sound "bd bd/4",
--     sound "hh(5,8)"
--     ] # nudge "[0 0.04]*4"
--   </pre>
--   
--   <ul>
--   <li>-pitch model</li>
--   </ul>
harmonic :: Pattern Double -> ParamPattern

-- | Pushes things forward (or backwards within built-in latency) in time.
--   Allows for nice things like _swing_ feeling:
--   
--   <pre>
--   d1 $ stack [
--     sound "bd bd/4",
--     sound "hh(5,8)"
--     ] # nudge "[0 0.04]*4"
--   </pre>
--   
--   <ul>
--   <li>-pitch model</li>
--   </ul>
stepsPerOctave :: Pattern Double -> ParamPattern

-- | Pushes things forward (or backwards within built-in latency) in time.
--   Allows for nice things like _swing_ feeling:
--   
--   <pre>
--   d1 $ stack [
--     sound "bd bd/4",
--     sound "hh(5,8)"
--     ] # nudge "[0 0.04]*4"
--   </pre>
--   
--   <ul>
--   <li>-pitch model</li>
--   </ul>
octaveRatio :: Pattern Double -> ParamPattern
degree_p :: Param
mtranspose_p :: Param
ctranspose_p :: Param
harmonic_p :: Param
stepsPerOctave_p :: Param
octaveRatio_p :: Param
nudge :: Pattern Double -> ParamPattern
octave :: Pattern Int -> ParamPattern
offset :: Pattern Double -> ParamPattern
ophatdecay :: Pattern Double -> ParamPattern

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

-- | a pattern of numbers between 0 and 1, from left to right (assuming
--   stereo), once round a circle (assuming multichannel)
pan :: Pattern Double -> ParamPattern

-- | a pattern of numbers between -inf and inf, which controls how much
--   multichannel output is fanned out (negative is backwards ordering)
panspan :: Pattern Double -> ParamPattern

-- | a pattern of numbers between 0.0 and 1.0, which controls the
--   multichannel spread range (multichannel only)
pansplay :: Pattern Double -> ParamPattern

-- | a pattern of numbers between 0.0 and inf, which controls how much each
--   channel is distributed over neighbours (multichannel only)
panwidth :: Pattern Double -> ParamPattern

-- | 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 -> ParamPattern
pitch1 :: Pattern Double -> ParamPattern
pitch2 :: Pattern Double -> ParamPattern
pitch3 :: Pattern Double -> ParamPattern
portamento :: Pattern Double -> ParamPattern

-- | a pattern of numbers to specify the release time (in seconds) of an
--   envelope applied to each sample. Only takes effect if <a>attack</a> is
--   also specified.
release :: Pattern Double -> ParamPattern

-- | a pattern of numbers from 0 to 1. Specifies the resonance of the
--   low-pass filter.
resonance :: Pattern Double -> ParamPattern

-- | a pattern of numbers from 0 to 1. Sets the level of reverb.
room :: Pattern Double -> ParamPattern
sagogo :: Pattern Double -> ParamPattern
sclap :: Pattern Double -> ParamPattern
sclaves :: Pattern Double -> ParamPattern
scrash :: Pattern Double -> ParamPattern
semitone :: Pattern Double -> ParamPattern

-- | wave shaping distortion, a pattern of numbers from 0 for no distortion
--   up to 1 for loads of distortion.
shape :: Pattern Double -> ParamPattern

-- | 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 -> ParamPattern
slide :: Pattern Double -> ParamPattern

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

-- | a pattern of strings. Selects the sample to be played.
s' :: Pattern String -> ParamPattern
stutterdepth :: Pattern Double -> ParamPattern
stuttertime :: Pattern Double -> ParamPattern
sustain :: Pattern Double -> ParamPattern
tomdecay :: Pattern Double -> ParamPattern

-- | 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 -> ParamPattern
velocity :: Pattern Double -> ParamPattern
vcfegint :: Pattern Double -> ParamPattern
vcoegint :: Pattern Double -> ParamPattern
voice :: Pattern Double -> ParamPattern

-- | formant filter to make things sound like vowels, a pattern of either
--   <tt>a</tt>, <a>e</a>, <tt>i</tt>, <tt>o</tt> or <tt>u</tt>. Use a rest
--   (`~`) for no effect.
vowel :: Pattern String -> ParamPattern
dur :: Pattern Double -> ParamPattern
modwheel :: Pattern Double -> ParamPattern
expression :: Pattern Double -> ParamPattern
sustainpedal :: Pattern Double -> ParamPattern
tremolorate :: Pattern Double -> ParamPattern
tremolodepth :: Pattern Double -> ParamPattern
tremolorate_p :: Param
tremolodepth_p :: Param
phaserrate :: Pattern Double -> ParamPattern
phaserdepth :: Pattern Double -> ParamPattern
phaserrate_p :: Param
phaserdepth_p :: Param
att :: Pattern Double -> ParamPattern
chdecay :: Pattern Double -> ParamPattern
ctf :: Pattern Double -> ParamPattern
ctfg :: Pattern Double -> ParamPattern
delayfb :: Pattern Double -> ParamPattern
delayt :: Pattern Double -> ParamPattern
lbd :: Pattern Double -> ParamPattern
lch :: Pattern Double -> ParamPattern
lcl :: Pattern Double -> ParamPattern
lcp :: Pattern Double -> ParamPattern
lcr :: Pattern Double -> ParamPattern
lfoc :: Pattern Double -> ParamPattern
lfoi :: Pattern Double -> ParamPattern
lfop :: Pattern Double -> ParamPattern
lht :: Pattern Double -> ParamPattern
llt :: Pattern Double -> ParamPattern
loh :: Pattern Double -> ParamPattern
lsn :: Pattern Double -> ParamPattern
ohdecay :: Pattern Double -> ParamPattern
phasdp :: Pattern Double -> ParamPattern
phasr :: Pattern Double -> ParamPattern
pit1 :: Pattern Double -> ParamPattern
pit2 :: Pattern Double -> ParamPattern
pit3 :: Pattern Double -> ParamPattern
por :: Pattern Double -> ParamPattern
sag :: Pattern Double -> ParamPattern
scl :: Pattern Double -> ParamPattern
scp :: Pattern Double -> ParamPattern
scr :: Pattern Double -> ParamPattern
sld :: Pattern Double -> ParamPattern
std :: Pattern Double -> ParamPattern
stt :: Pattern Double -> ParamPattern
sus :: Pattern Double -> ParamPattern
tdecay :: Pattern Double -> ParamPattern
tremdp :: Pattern Double -> ParamPattern
tremr :: Pattern Double -> ParamPattern
vcf :: Pattern Double -> ParamPattern
vco :: Pattern Double -> ParamPattern
voi :: Pattern Double -> ParamPattern
bpf :: Pattern Double -> ParamPattern
bpf_p :: Param
bpq :: Pattern Double -> ParamPattern
bpq_p :: Param
det :: Pattern Double -> ParamPattern
gat :: Pattern Double -> ParamPattern
hg :: Pattern Double -> ParamPattern
hpf :: Pattern Double -> ParamPattern
hpf_p :: Param
hpq :: Pattern Double -> ParamPattern
hpq_p :: Param
lag :: Pattern Double -> ParamPattern
lpf :: Pattern Double -> ParamPattern
lpf_p :: Param
lpq :: Pattern Double -> ParamPattern
lpq_p :: Param
rel :: Pattern Double -> ParamPattern
sz :: Pattern Double -> ParamPattern
midinote :: Pattern Double -> ParamPattern
drum :: Pattern String -> ParamPattern
drumN :: Num a => String -> a
array :: Pattern Double -> ParamPattern
midichan :: Pattern Double -> ParamPattern
control :: Pattern Double -> ParamPattern
ccn :: Pattern Double -> ParamPattern
ccv :: Pattern Double -> ParamPattern
cc :: Pattern String -> ParamPattern
ctlNum :: Pattern Double -> ParamPattern
frameRate :: Pattern Double -> ParamPattern
frames :: Pattern Double -> ParamPattern
hours :: Pattern Double -> ParamPattern
midicmd :: Pattern String -> ParamPattern
command :: Pattern String -> ParamPattern
minutes :: Pattern Double -> ParamPattern
progNum :: Pattern Double -> ParamPattern
seconds :: Pattern Double -> ParamPattern
songPtr :: Pattern Double -> ParamPattern
uid :: Pattern Double -> ParamPattern
val :: Pattern Double -> ParamPattern

module Sound.Tidal.Transition
transition :: (IO Time) -> MVar (ParamPattern, [ParamPattern]) -> (Time -> [ParamPattern] -> ParamPattern) -> ParamPattern -> IO ()

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

-- | A generalization of <a>wash</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.
superwash :: (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Time -> Time -> Time -> Time -> [Pattern a] -> Pattern a

-- | Wash away the current pattern by applying a function to it over time,
--   then switching over to the next.
--   
--   <pre>
--   d1 $ sound "feel ! feel:1 feel:2"
--   
--   t1 (wash (chop 8) 4) $ sound "feel*4 [feel:2 sn:2]"
--   </pre>
--   
--   Note that `chop 8` is applied to `sound "feel ! feel:1 feel:2"` for 4
--   cycles and then the whole pattern is replaced by `sound "feel*4
--   [feel:2 sn:2]`
wash :: (Pattern a -> Pattern a) -> Time -> Time -> [Pattern a] -> Pattern a

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

-- | Just as <a>wait</a>, <a>wait'</a> stops for a bit and then applies the
--   given transition to the playing pattern
--   
--   <pre>
--   d1 $ sound "bd"
--   
--   t1 (wait' (xfadeIn 8) 4) $ sound "hh*8"
--   </pre>
wait' :: (Time -> [ParamPattern] -> ParamPattern) -> Time -> Time -> [ParamPattern] -> ParamPattern

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

-- | 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 -> [ParamPattern] -> ParamPattern

-- | 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 -> [ParamPattern] -> ParamPattern

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

-- | Degrade the new pattern over time until it ends in silence
mortal :: Time -> Time -> Time -> [ParamPattern] -> ParamPattern
combineV :: (Value -> Value -> Value) -> ParamMap -> ParamMap -> ParamMap
mixNums :: Double -> Value -> Value -> Value
interpolateIn :: Time -> Time -> [ParamPattern] -> ParamPattern

module Sound.Tidal.OscStream
data TimeStamp
BundleStamp :: TimeStamp
MessageStamp :: TimeStamp
NoStamp :: TimeStamp
data OscSlang
OscSlang :: String -> TimeStamp -> Bool -> [Datum] -> OscSlang
[path] :: OscSlang -> String
[timestamp] :: OscSlang -> TimeStamp
[namedParams] :: OscSlang -> Bool
[preamble] :: OscSlang -> [Datum]
type OscMap = Map Param Datum
toOscDatum :: Value -> Datum
toOscMap :: ParamMap -> OscMap
send :: (Integral a) => UDP -> OscSlang -> Shape -> Tempo -> a -> (Double, Double, OscMap) -> IO ()
makeConnection :: String -> Int -> OscSlang -> IO (ToMessageFunc)
instance GHC.Classes.Eq Sound.Tidal.OscStream.TimeStamp

module Sound.Tidal.SuperCollider
supercollider :: [Param] -> Double -> Shape
scSlang :: String -> OscSlang
scBackend :: String -> IO (Backend a)
scStream :: String -> [Param] -> Double -> IO (ParamPattern -> IO (), Shape)

module Sound.Tidal.Dirt
dirt :: Shape
dirtSlang :: OscSlang
superDirtSlang :: OscSlang
superDirtBackend :: () => Int -> IO Backend a
superDirtState :: Int -> IO MVar (ParamPattern, [ParamPattern])
dirtBackend :: () => IO Backend a
dirtStream :: IO ParamPattern -> IO ()
dirtState :: IO MVar (ParamPattern, [ParamPattern])
dirtSetters :: IO Time -> IO (ParamPattern -> IO (), (Time -> [ParamPattern] -> ParamPattern) -> ParamPattern -> IO ())
superDirtSetters :: IO Time -> IO (ParamPattern -> IO (), (Time -> [ParamPattern] -> ParamPattern) -> ParamPattern -> IO ())
superDirts :: [Int] -> IO [(ParamPattern -> IO (), (Time -> [ParamPattern] -> ParamPattern) -> ParamPattern -> IO ())]
dirtstream :: () => p -> IO ParamPattern -> IO ()
dirtToColour :: ParamPattern -> Pattern ColourD
showToColour :: Show a => a -> ColourD
datumToColour :: Value -> ColourD
stringToColour :: String -> ColourD
pick :: String -> Int -> String

-- | 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 -> ParamPattern -> ParamPattern
_striate :: Int -> ParamPattern -> ParamPattern

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

-- | like <a>striate</a>, but with an offset to the begin and end values
striateO :: Pattern Int -> Pattern Double -> ParamPattern -> ParamPattern
_striateO :: Int -> Double -> ParamPattern -> ParamPattern

-- | Just like <a>striate</a>, but also loops each sample chunk a number of
--   times specified in the second argument. The primed version is just
--   like <a>striate'</a>, where the loop count is the third argument. For
--   example:
--   
--   <pre>
--   d1 $ striateL' 3 0.125 4 $ sound "feel sn:2"
--   </pre>
--   
--   Like <a>striate</a>, these use the <a>begin</a> and <a>end</a>
--   parameters internally, as well as the <a>loop</a> parameter for these
--   versions.
striateL :: Pattern Int -> Pattern Int -> ParamPattern -> ParamPattern
striateL' :: Pattern Int -> Pattern Double -> Pattern Int -> ParamPattern -> ParamPattern
_striateL :: Int -> Int -> ParamPattern -> ParamPattern
_striateL' :: Integral a => Int -> Double -> a -> ParamPattern -> ParamPattern
metronome :: Pattern ParamMap

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

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

-- | crossfades between old and new pattern over given number of cycles,
--   e.g.:
--   
--   <pre>
--   d1 $ sound "bd sn"
--   
--   t1 (xfadeIn 16) $ sound "jvbass*3"
--   </pre>
--   
--   Will fade over 16 cycles from "bd sn" to "jvbass*3"
xfadeIn :: Time -> Time -> [ParamPattern] -> ParamPattern

-- | Crossfade between old and new pattern over the next two cycles.
--   
--   <pre>
--   d1 $ sound "bd sn"
--   
--   t1 xfade $ sound "can*3"
--   </pre>
--   
--   <a>xfade</a> is built with <a>xfadeIn</a> in this case taking two
--   cycles for the fade.
xfade :: Time -> [ParamPattern] -> ParamPattern

-- | Stut applies a type of delay to a pattern. It has three parameters,
--   which could be called depth, feedback and time. Depth is an integer
--   and the others floating point. This adds a bit of echo:
--   
--   <pre>
--   d1 $ stut 4 0.5 0.2 $ sound "bd sn"
--   </pre>
--   
--   The above results in 4 echos, each one 50% quieter than the last, with
--   1/5th of a cycle between them. It is possible to reverse the echo:
--   
--   <pre>
--   d1 $ stut 4 0.5 (-0.2) $ sound "bd sn"
--   </pre>
stut :: Pattern Integer -> Pattern Double -> Pattern Rational -> ParamPattern -> ParamPattern
_stut :: Integer -> Double -> Rational -> ParamPattern -> ParamPattern

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

-- | <tt>durPattern</tt> takes a pattern and returns the length of events
--   in that pattern as a new pattern. For example the result of
--   `durPattern "[a ~] b"` would be `"[0.25 ~] 0.5"`.
durPattern :: Pattern a -> Pattern Time

-- | <tt>durPattern'</tt> is similar to <tt>durPattern</tt>, but does some
--   lookahead to try to find the length of time to the *next* event. For
--   example, the result of <a>durPattern</a> "[a ~] b"` would be `"[0.5 ~]
--   0.5"`.
durPattern' :: Pattern a -> Pattern Time

-- | <tt>stutx</tt> is like <tt>stut'</tt> but will limit the number of
--   repeats using the duration of the original sound. This usually
--   prevents overlapping "stutters" from subsequent sounds.
stutx :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> 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 -> [ParamPattern] -> ParamPattern

-- | <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 -> [ParamPattern] -> ParamPattern

-- | Copies the <tt>n</tt> parameter to the <tt>orbit</tt> parameter, so
--   different sound variants or notes go to different orbits in SuperDirt.
nToOrbit :: ParamPattern -> ParamPattern

-- | Maps the sample or synth names to different <tt>orbit</tt>s, using
--   indexes from the given list. E.g. <tt>soundToOrbit ["bd", "sn", "cp"]
--   $ sound "bd [cp sn]"</tt> would cause the bd, sn and cp smamples to be
--   sent to orbit 0, 1, 2 respectively.
soundToOrbit :: [String] -> ParamPattern -> ParamPattern

module Sound.Tidal.Strategies
stutter :: Integral i => i -> Time -> Pattern a -> Pattern a
echo :: Time -> Pattern a -> Pattern a
triple :: Time -> Pattern a -> Pattern a
quad :: Time -> Pattern a -> Pattern a
double :: Time -> Pattern a -> Pattern a

-- | The <a>jux</a> function creates strange stereo effects, by applying a
--   function to a pattern, but only in the right-hand channel. For
--   example, the following reverses the pattern on the righthand side:
--   
--   <pre>
--   d1 $ slow 32 $ jux (rev) $ striate' 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) $ striate' 32 (1/16) $ sound "bev"
--   </pre>
jux :: ParamPattern -> Pattern ParamMap -> ParamPattern -> Pattern ParamMap
juxcut :: ParamPattern -> Pattern ParamMap -> ParamPattern -> Pattern ParamMap
juxcut' :: () => [t -> ParamPattern] -> t -> Pattern ParamMap

-- | 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 -> ParamPattern] -> t -> Pattern ParamMap

-- | Multichannel variant of <a>jux</a>, _not sure what it does_
jux4 :: ParamPattern -> Pattern ParamMap -> ParamPattern -> Pattern ParamMap

-- | 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 -> ParamPattern -> Pattern ParamMap -> ParamPattern -> Pattern ParamMap

-- | 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] -> ParamPattern -> Pattern ParamMap

-- | 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] -> ParamPattern -> Pattern ParamMap
samples :: Applicative f => f String -> f Int -> f String
samples' :: Applicative f => f String -> f Int -> f String
spreadf :: () => p1 -> p2 -> [a -> Pattern b] -> a -> Pattern b

-- | <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 -> ParamPattern -> ParamPattern
_spin :: Int -> ParamPattern -> ParamPattern
sawwave4 :: Pattern Double
sinewave4 :: Pattern Double
rand4 :: Pattern Double
stackwith :: Pattern ParamMap -> [ParamPattern] -> Pattern ParamMap

-- | <a>scale</a> will take a pattern which goes from 0 to 1 (like
--   <a>sine1</a>), and scale it to a different range - between the first
--   and second arguments. In the below example, `scale 1 1.5` shifts the
--   range of <a>sine1</a> from 0 - 1 to 1 - 1.5.
--   
--   <pre>
--   d1 $ jux (iter 4) $ sound "arpy arpy:2*2"
--     |+| speed (slow 4 $ scale 1 1.5 sine1)
--   </pre>
scale :: (Functor f, Num b) => b -> b -> f b -> f b

-- | <a>scalex</a> is an exponential version of <a>scale</a>, good for
--   using with frequencies. Do *not* use negative numbers or zero as
--   arguments!
scalex :: (Functor f, Floating b) => b -> b -> f b -> f b

-- | <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 -> ParamPattern -> ParamPattern
_chop :: Int -> ParamPattern -> ParamPattern

-- | <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 -> ParamPattern -> ParamPattern
_gap :: Int -> ParamPattern -> ParamPattern
chopArc :: Arc -> Int -> [Arc]
en :: [(Int, Int)] -> Pattern String -> Pattern String

-- | <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 :: Rational -> ParamPattern -> [ParamPattern] -> ParamPattern

-- | <a>weave'</a> is similar in that it blends functions at the same time
--   at different amounts over a pattern:
--   
--   <pre>
--   d1 $ weave' 3 (sound "bd [sn drum:2*2] bd*2 [sn drum:1]") [density 2, (# speed "0.5"), chop 16]
--   </pre>
weave' :: Rational -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a

-- | (A function that takes two OscPatterns, and blends them together into
--   a new OscPattern. An OscPattern 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 :: ParamPattern -> ParamPattern -> ParamPattern

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

-- | <a>up</a> does a poor man's pitchshift by semitones via <a>speed</a>.
--   
--   You can easily produce melodies from a single sample with up:
--   
--   <pre>
--   d1  sound "arpy"
--   </pre>
--   
--   This will play the _arpy_ sample four times a cycle in the original
--   pitch, pitched by 5 semitones, by 4 and then by an octave.
up :: Pattern Double -> ParamPattern
ghost'' :: () => Time -> Pattern a -> Pattern a -> Pattern a -> Pattern a
ghost' :: () => p -> Pattern ParamMap -> Pattern ParamMap
ghost :: Pattern ParamMap -> Pattern ParamMap
slice :: Pattern Int -> Pattern Int -> ParamPattern -> ParamPattern
_slice :: Int -> Int -> ParamPattern -> ParamPattern
randslice :: Int -> ParamPattern -> ParamPattern

-- | <a>loopAt</a> makes a sample fit the given number of cycles.
--   Internally, it works by setting the <a>unit</a> parameter to "c",
--   changing the playback speed of the sample with the <a>speed</a>
--   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 -> ParamPattern -> ParamPattern

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

module Sound.Tidal.Sieve
data Sieve a
Sieve :: Int -> a -> Sieve a
[sieveAt] :: Sieve a -> Int -> a

-- | The basic notation for and constructor of a boolean <a>Sieve</a> is
--   <tt>m@@n</tt>, which represents all integers whose modulo with
--   <tt>m</tt> is equal to <tt>n</tt>
(@@) :: Int -> Int -> Sieve Bool
infixl 9 @@

-- | <tt>not'</tt> gives the complement of a sieve
not' :: Applicative f => f Bool -> f Bool

-- | <tt></tt> gives the union (logical OR) of two sieves
(#||#) :: Applicative f => f Bool -> f Bool -> f Bool
infixl 2 #||#

-- | <tt></tt> gives the intersection (logical AND) of two sieves
(#&&#) :: Applicative f => f Bool -> f Bool -> f Bool
infixl 3 #&&#

-- | <a>#^^#</a> gives the exclusive disjunction (logical XOR) of two
--   sieves
(#^^#) :: Applicative f => f Bool -> f Bool -> f Bool
infixl 2 #^^#

-- | <tt>sieveToList n</tt> returns a list of the values of the sieve for
--   each nonnegative integer less than <tt>n</tt> For example:
--   <tt>sieveToList 10 $ 3@@1</tt> returns `[False, True, False, False,
--   True, False, False, True, False, False]`
sieveToList :: Int -> Sieve a -> [a]

-- | <tt>sieveToString n</tt> represents the sieve as a character string,
--   where <tt>-</tt> represents False and <tt>x</tt> represents True
sieveToString :: Int -> Sieve Bool -> [Char]

-- | <tt>sieveToInts n</tt> returns a list of nonnegative integers less
--   than <tt>n</tt> where the sieve is True
sieveToInts :: Int -> Sieve Bool -> [Int]

-- | <tt>sieveToPat n</tt> returns a pattern where the cycle is divided
--   into <tt>n</tt> beats, and there is an event whenever the matching
--   beat number is in the sieve For example: <tt>sieveToPat 8 $ 3@@1</tt>
--   returns <tt>"~ x ~ ~ x ~ ~ x"</tt>
sieveToPat :: Int -> Sieve Bool -> Pattern String

-- | <tt>stepSieve n str</tt> works like <a>sieveToPat</a> but uses
--   <tt>str</tt> in the pattern instead of <tt>x</tt>
stepSieve :: Int -> String -> Sieve Bool -> Pattern String

-- | <tt>slowstepSieve t</tt> is shorthand for applying <tt>slow t</tt> to
--   the result of <a>stepSieve</a>
slowstepSieve :: Pattern Time -> Int -> String -> Sieve Bool -> Pattern String

-- | <tt>scaleSieve n</tt> uses <a>sieveToInts</a> to turn a sieve into a
--   list of integers, and then uses that with the <tt>toScale</tt>
--   function to turn a pattern of numbers into a pattern of notes in the
--   scale. For example: <tt>scaleSieve 8 (3@@1) "0 1 2 1"</tt> first
--   converts the sieve to the scale <tt>[1, 4, 7]</tt> and then uses that
--   with <tt>toScale</tt> to return the pattern <tt>"1 4 7 4"</tt>
scaleSieve :: Int -> Sieve Bool -> Pattern Int -> Pattern Int
instance GHC.Base.Functor Sound.Tidal.Sieve.Sieve
instance GHC.Base.Applicative Sound.Tidal.Sieve.Sieve
instance GHC.Show.Show (Sound.Tidal.Sieve.Sieve GHC.Types.Bool)

module Sound.Tidal.EspGrid
parseEspTempo :: [Datum] -> Maybe Tempo
changeTempo :: MVar Tempo -> Packet -> IO ()
getTempo :: MVar Tempo -> IO Tempo
runClientEsp :: IO (MVar Tempo, MVar Double)
sendEspTempo :: Real t => t -> IO ()
cpsUtilsEsp :: IO (Double -> IO (), IO Rational, IO Tempo)
clockedTickEsp :: Int -> (Tempo -> Int -> IO ()) -> IO ()
clockedTickLoopEsp :: Int -> (Tempo -> Int -> IO ()) -> MVar Tempo -> Int -> IO Int
streamEsp :: Backend a -> Shape -> IO (ParamPattern -> IO ())
dirtStreamEsp :: IO (ParamPattern -> IO ())
stateEsp :: Backend a -> Shape -> IO (MVar (ParamPattern, [ParamPattern]))
dirtSettersEsp :: IO Time -> IO (ParamPattern -> IO (), (Time -> [ParamPattern] -> ParamPattern) -> ParamPattern -> IO ())
superDirtSettersEsp :: IO Time -> IO (ParamPattern -> IO (), (Time -> [ParamPattern] -> ParamPattern) -> ParamPattern -> IO ())

module Sound.Tidal.MultiMode
data StreamType
Dirt :: StreamType
SuperDirt :: StreamType
data SyncType
NoSync :: SyncType
Esp :: SyncType
initializeStreamType :: IO (MVar StreamType)
changeStreamType :: MVar StreamType -> StreamType -> IO (IO StreamType)
initializeSyncType :: IO (MVar SyncType)
changeSyncType :: MVar SyncType -> SyncType -> IO (IO SyncType)
type CpsUtils = (Double -> IO (), IO Rational)
multiModeCpsUtils :: CpsUtils -> CpsUtils -> MVar SyncType -> IO CpsUtils
multiModeSetters :: IO Rational -> IO Rational -> MVar SyncType -> MVar StreamType -> IO (ParamPattern -> IO ())

module Sound.Tidal.Version
tidal_version :: [Char]

module Sound.Tidal.Context

-- | Append two lists, i.e.,
--   
--   <pre>
--   [x1, ..., xm] ++ [y1, ..., yn] == [x1, ..., xm, y1, ..., yn]
--   [x1, ..., xm] ++ [y1, ...] == [x1, ..., xm, y1, ...]
--   </pre>
--   
--   If the first list is not finite, the result is the first list.
(++) :: () => [a] -> [a] -> [a]
infixr 5 ++

-- | <a>filter</a>, applied to a predicate and a list, returns the list of
--   those elements that satisfy the predicate; i.e.,
--   
--   <pre>
--   filter p xs = [ x | x &lt;- xs, p x]
--   </pre>
filter :: () => a -> Bool -> [a] -> [a]

-- | <a>zip</a> takes two lists and returns a list of corresponding pairs.
--   If one input list is short, excess elements of the longer list are
--   discarded.
--   
--   <a>zip</a> is right-lazy:
--   
--   <pre>
--   zip [] _|_ = []
--   </pre>
zip :: () => [a] -> [b] -> [(a, b)]

-- | <a>map</a> <tt>f xs</tt> is the list obtained by applying <tt>f</tt>
--   to each element of <tt>xs</tt>, i.e.,
--   
--   <pre>
--   map f [x1, x2, ..., xn] == [f x1, f x2, ..., f xn]
--   map f [x1, x2, ...] == [f x1, f x2, ...]
--   </pre>
map :: () => a -> b -> [a] -> [b]

-- | Replace all locations in the input with the same value. The default
--   definition is <tt><a>fmap</a> . <a>const</a></tt>, but this may be
--   overridden with a more efficient version.
(<$) :: Functor f => a -> f b -> f a
infixl 4 <$

-- | A functor with application, providing operations to
--   
--   <ul>
--   <li>embed pure expressions (<a>pure</a>), and</li>
--   <li>sequence computations and combine their results (<a>&lt;*&gt;</a>
--   and <a>liftA2</a>).</li>
--   </ul>
--   
--   A minimal complete definition must include implementations of
--   <a>pure</a> and of either <a>&lt;*&gt;</a> or <a>liftA2</a>. If it
--   defines both, then they must behave the same as their default
--   definitions:
--   
--   <pre>
--   (<a>&lt;*&gt;</a>) = <a>liftA2</a> <a>id</a>
--   </pre>
--   
--   <pre>
--   <a>liftA2</a> f x y = f <tt>&lt;$&gt;</tt> x <a>&lt;*&gt;</a> y
--   </pre>
--   
--   Further, any definition must satisfy the following:
--   
--   <ul>
--   <li><i><i>identity</i></i> <pre><a>pure</a> <a>id</a> <a>&lt;*&gt;</a>
--   v = v</pre></li>
--   <li><i><i>composition</i></i> <pre><a>pure</a> (.) <a>&lt;*&gt;</a> u
--   <a>&lt;*&gt;</a> v <a>&lt;*&gt;</a> w = u <a>&lt;*&gt;</a> (v
--   <a>&lt;*&gt;</a> w)</pre></li>
--   <li><i><i>homomorphism</i></i> <pre><a>pure</a> f <a>&lt;*&gt;</a>
--   <a>pure</a> x = <a>pure</a> (f x)</pre></li>
--   <li><i><i>interchange</i></i> <pre>u <a>&lt;*&gt;</a> <a>pure</a> y =
--   <a>pure</a> (<a>$</a> y) <a>&lt;*&gt;</a> u</pre></li>
--   </ul>
--   
--   The other methods have the following default definitions, which may be
--   overridden with equivalent specialized implementations:
--   
--   <ul>
--   <li><pre>u <a>*&gt;</a> v = (<a>id</a> <a>&lt;$</a> u)
--   <a>&lt;*&gt;</a> v</pre></li>
--   <li><pre>u <a>&lt;*</a> v = <a>liftA2</a> <a>const</a> u v</pre></li>
--   </ul>
--   
--   As a consequence of these laws, the <a>Functor</a> instance for
--   <tt>f</tt> will satisfy
--   
--   <ul>
--   <li><pre><a>fmap</a> f x = <a>pure</a> f <a>&lt;*&gt;</a> x</pre></li>
--   </ul>
--   
--   It may be useful to note that supposing
--   
--   <pre>
--   forall x y. p (q x y) = f x . g y
--   </pre>
--   
--   it follows from the above that
--   
--   <pre>
--   <a>liftA2</a> p (<a>liftA2</a> q u v) = <a>liftA2</a> f u . <a>liftA2</a> g v
--   </pre>
--   
--   If <tt>f</tt> is also a <a>Monad</a>, it should satisfy
--   
--   <ul>
--   <li><pre><a>pure</a> = <a>return</a></pre></li>
--   <li><pre>(<a>&lt;*&gt;</a>) = <a>ap</a></pre></li>
--   <li><pre>(<a>*&gt;</a>) = (<a>&gt;&gt;</a>)</pre></li>
--   </ul>
--   
--   (which implies that <a>pure</a> and <a>&lt;*&gt;</a> satisfy the
--   applicative functor laws).
class Functor f => Applicative (f :: * -> *)

-- | Lift a value.
pure :: Applicative f => a -> f a

-- | Sequential application.
--   
--   A few functors support an implementation of <a>&lt;*&gt;</a> that is
--   more efficient than the default one.
(<*>) :: Applicative f => f a -> b -> f a -> f b

-- | Lift a binary function to actions.
--   
--   Some functors support an implementation of <a>liftA2</a> that is more
--   efficient than the default one. In particular, if <a>fmap</a> is an
--   expensive operation, it is likely better to use <a>liftA2</a> than to
--   <a>fmap</a> over the structure and then use <a>&lt;*&gt;</a>.
liftA2 :: Applicative f => a -> b -> c -> f a -> f b -> f c

-- | Sequence actions, discarding the value of the first argument.
(*>) :: Applicative f => f a -> f b -> f b

-- | Sequence actions, discarding the value of the second argument.
(<*) :: Applicative f => f a -> f b -> f a

-- | Right-associative fold of a structure.
--   
--   In the case of lists, <a>foldr</a>, when applied to a binary operator,
--   a starting value (typically the right-identity of the operator), and a
--   list, reduces the list using the binary operator, from right to left:
--   
--   <pre>
--   foldr f z [x1, x2, ..., xn] == x1 `f` (x2 `f` ... (xn `f` z)...)
--   </pre>
--   
--   Note that, since the head of the resulting expression is produced by
--   an application of the operator to the first element of the list,
--   <a>foldr</a> can produce a terminating expression from an infinite
--   list.
--   
--   For a general <a>Foldable</a> structure this should be semantically
--   identical to,
--   
--   <pre>
--   foldr f z = <a>foldr</a> f z . <a>toList</a>
--   </pre>
foldr :: Foldable t => a -> b -> b -> b -> t a -> b

-- | Test whether the structure is empty. The default implementation is
--   optimized for structures that are similar to cons-lists, because there
--   is no general way to do better.
null :: Foldable t => t a -> Bool

-- | Returns the size/length of a finite structure as an <a>Int</a>. The
--   default implementation is optimized for structures that are similar to
--   cons-lists, because there is no general way to do better.
length :: Foldable t => t a -> Int

-- | Left-associative fold of a structure.
--   
--   In the case of lists, <a>foldl</a>, when applied to a binary operator,
--   a starting value (typically the left-identity of the operator), and a
--   list, reduces the list using the binary operator, from left to right:
--   
--   <pre>
--   foldl f z [x1, x2, ..., xn] == (...((z `f` x1) `f` x2) `f`...) `f` xn
--   </pre>
--   
--   Note that to produce the outermost application of the operator the
--   entire input list must be traversed. This means that <a>foldl'</a>
--   will diverge if given an infinite list.
--   
--   Also note that if you want an efficient left-fold, you probably want
--   to use <a>foldl'</a> instead of <a>foldl</a>. The reason for this is
--   that latter does not force the "inner" results (e.g. <tt>z <tt>f</tt>
--   x1</tt> in the above example) before applying them to the operator
--   (e.g. to <tt>(<tt>f</tt> x2)</tt>). This results in a thunk chain
--   <tt>O(n)</tt> elements long, which then must be evaluated from the
--   outside-in.
--   
--   For a general <a>Foldable</a> structure this should be semantically
--   identical to,
--   
--   <pre>
--   foldl f z = <a>foldl</a> f z . <a>toList</a>
--   </pre>
foldl :: Foldable t => b -> a -> b -> b -> t a -> b

-- | Left-associative fold of a structure but with strict application of
--   the operator.
--   
--   This ensures that each step of the fold is forced to weak head normal
--   form before being applied, avoiding the collection of thunks that
--   would otherwise occur. This is often what you want to strictly reduce
--   a finite list to a single, monolithic result (e.g. <a>length</a>).
--   
--   For a general <a>Foldable</a> structure this should be semantically
--   identical to,
--   
--   <pre>
--   foldl f z = <a>foldl'</a> f z . <a>toList</a>
--   </pre>
foldl' :: Foldable t => b -> a -> b -> b -> t a -> b

-- | A variant of <a>foldl</a> that has no base case, and thus may only be
--   applied to non-empty structures.
--   
--   <pre>
--   <a>foldl1</a> f = <a>foldl1</a> f . <a>toList</a>
--   </pre>
foldl1 :: Foldable t => a -> a -> a -> t a -> a

-- | The <a>sum</a> function computes the sum of the numbers of a
--   structure.
sum :: (Foldable t, Num a) => t a -> a

-- | The <a>product</a> function computes the product of the numbers of a
--   structure.
product :: (Foldable t, Num a) => t a -> a

-- | A variant of <a>foldr</a> that has no base case, and thus may only be
--   applied to non-empty structures.
--   
--   <pre>
--   <a>foldr1</a> f = <a>foldr1</a> f . <a>toList</a>
--   </pre>
foldr1 :: Foldable t => a -> a -> a -> t a -> a

-- | The largest element of a non-empty structure.
maximum :: (Foldable t, Ord a) => t a -> a

-- | The least element of a non-empty structure.
minimum :: (Foldable t, Ord a) => t a -> a

-- | Does the element occur in the structure?
elem :: (Foldable t, Eq a) => a -> t a -> Bool
infix 4 `elem`

-- | An associative operation.
(<>) :: Semigroup a => a -> a -> a
infixr 6 <>

-- | The class of monoids (types with an associative binary operation that
--   has an identity). Instances should satisfy the following laws:
--   
--   <ul>
--   <li><pre>x <a>&lt;&gt;</a> <a>mempty</a> = x</pre></li>
--   <li><pre><a>mempty</a> <a>&lt;&gt;</a> x = x</pre></li>
--   <li><tt>x <a>&lt;&gt;</a> (y <a>&lt;&gt;</a> z) = (x <a>&lt;&gt;</a>
--   y) <a>&lt;&gt;</a> z</tt> (<a>Semigroup</a> law)</li>
--   <li><pre><a>mconcat</a> = <a>foldr</a> '(&lt;&gt;)'
--   <a>mempty</a></pre></li>
--   </ul>
--   
--   The method names refer to the monoid of lists under concatenation, but
--   there are many other instances.
--   
--   Some types can be viewed as a monoid in more than one way, e.g. both
--   addition and multiplication on numbers. In such cases we often define
--   <tt>newtype</tt>s and make those instances of <a>Monoid</a>, e.g.
--   <tt>Sum</tt> and <tt>Product</tt>.
--   
--   <b>NOTE</b>: <a>Semigroup</a> is a superclass of <a>Monoid</a> since
--   <i>base-4.11.0.0</i>.
class Semigroup a => Monoid a

-- | Identity of <a>mappend</a>
mempty :: Monoid a => a

-- | An associative operation
--   
--   <b>NOTE</b>: This method is redundant and has the default
--   implementation <tt><a>mappend</a> = '(&lt;&gt;)'</tt> since
--   <i>base-4.11.0.0</i>.
mappend :: Monoid a => a -> a -> a

-- | Fold a list using the monoid.
--   
--   For most types, the default definition for <a>mconcat</a> will be
--   used, but the function is included in the class definition so that an
--   optimized version can be provided for specific types.
mconcat :: Monoid a => [a] -> a

-- | Rational numbers, with numerator and denominator of some
--   <a>Integral</a> type.
data Ratio a

-- | Arbitrary-precision rational numbers, represented as a ratio of two
--   <a>Integer</a> values. A rational number may be constructed using the
--   <a>%</a> operator.
type Rational = Ratio Integer

-- | Returns an STM action that can be used to wait until data can be
--   written to a file descriptor. The second returned value is an IO
--   action that can be used to deregister interest in the file descriptor.
threadWaitWriteSTM :: Fd -> IO (STM (), IO ())

-- | Returns an STM action that can be used to wait for data to read from a
--   file descriptor. The second returned value is an IO action that can be
--   used to deregister interest in the file descriptor.
threadWaitReadSTM :: Fd -> IO (STM (), IO ())

-- | Block the current thread until data can be written to the given file
--   descriptor (GHC only).
--   
--   This will throw an <a>IOError</a> if the file descriptor was closed
--   while this thread was blocked. To safely close a file descriptor that
--   has been used with <a>threadWaitWrite</a>, use <a>closeFdWith</a>.
threadWaitWrite :: Fd -> IO ()

-- | Block the current thread until data is available to read on the given
--   file descriptor (GHC only).
--   
--   This will throw an <a>IOError</a> if the file descriptor was closed
--   while this thread was blocked. To safely close a file descriptor that
--   has been used with <a>threadWaitRead</a>, use <a>closeFdWith</a>.
threadWaitRead :: Fd -> IO ()

-- | Run the <a>IO</a> computation passed as the first argument. If the
--   calling thread is <i>bound</i>, an unbound thread is created
--   temporarily using <a>forkIO</a>. <tt>runInBoundThread</tt> doesn't
--   finish until the <a>IO</a> computation finishes.
--   
--   Use this function <i>only</i> in the rare case that you have actually
--   observed a performance loss due to the use of bound threads. A program
--   that doesn't need its main thread to be bound and makes <i>heavy</i>
--   use of concurrency (e.g. a web server), might want to wrap its
--   <tt>main</tt> action in <tt>runInUnboundThread</tt>.
--   
--   Note that exceptions which are thrown to the current thread are thrown
--   in turn to the thread that is executing the given computation. This
--   ensures there's always a way of killing the forked thread.
runInUnboundThread :: () => IO a -> IO a

-- | Run the <a>IO</a> computation passed as the first argument. If the
--   calling thread is not <i>bound</i>, a bound thread is created
--   temporarily. <tt>runInBoundThread</tt> doesn't finish until the
--   <a>IO</a> computation finishes.
--   
--   You can wrap a series of foreign function calls that rely on
--   thread-local state with <tt>runInBoundThread</tt> so that you can use
--   them without knowing whether the current thread is <i>bound</i>.
runInBoundThread :: () => IO a -> IO a

-- | Returns <a>True</a> if the calling thread is <i>bound</i>, that is, if
--   it is safe to use foreign libraries that rely on thread-local state
--   from the calling thread.
isCurrentThreadBound :: IO Bool

-- | Like <a>forkIOWithUnmask</a>, but the child thread is a bound thread,
--   as with <a>forkOS</a>.
forkOSWithUnmask :: forall a. () => IO a -> IO a -> IO () -> IO ThreadId

-- | Like <a>forkIO</a>, this sparks off a new thread to run the <a>IO</a>
--   computation passed as the first argument, and returns the
--   <a>ThreadId</a> of the newly created thread.
--   
--   However, <a>forkOS</a> creates a <i>bound</i> thread, which is
--   necessary if you need to call foreign (non-Haskell) libraries that
--   make use of thread-local state, such as OpenGL (see
--   <a>Control.Concurrent#boundthreads</a>).
--   
--   Using <a>forkOS</a> instead of <a>forkIO</a> makes no difference at
--   all to the scheduling behaviour of the Haskell runtime system. It is a
--   common misconception that you need to use <a>forkOS</a> instead of
--   <a>forkIO</a> to avoid blocking all the Haskell threads when making a
--   foreign call; this isn't the case. To allow foreign calls to be made
--   without blocking all the Haskell threads (with GHC), it is only
--   necessary to use the <tt>-threaded</tt> option when linking your
--   program, and to make sure the foreign import is not marked
--   <tt>unsafe</tt>.
forkOS :: IO () -> IO ThreadId

-- | Fork a thread and call the supplied function when the thread is about
--   to terminate, with an exception or a returned value. The function is
--   called with asynchronous exceptions masked.
--   
--   <pre>
--   forkFinally action and_then =
--     mask $ \restore -&gt;
--       forkIO $ try (restore action) &gt;&gt;= and_then
--   </pre>
--   
--   This function is useful for informing the parent when a child
--   terminates, for example.
forkFinally :: () => IO a -> Either SomeException a -> IO () -> IO ThreadId

-- | <a>True</a> if bound threads are supported. If
--   <tt>rtsSupportsBoundThreads</tt> is <a>False</a>,
--   <a>isCurrentThreadBound</a> will always return <a>False</a> and both
--   <a>forkOS</a> and <a>runInBoundThread</a> will fail.
rtsSupportsBoundThreads :: Bool

-- | Write an entire list of items to a <a>Chan</a>.
writeList2Chan :: () => Chan a -> [a] -> IO ()

-- | Return a lazy list representing the contents of the supplied
--   <a>Chan</a>, much like <a>hGetContents</a>.
getChanContents :: () => Chan a -> IO [a]

-- | Duplicate a <a>Chan</a>: the duplicate channel begins empty, but data
--   written to either channel from then on will be available from both.
--   Hence this creates a kind of broadcast channel, where data written by
--   anyone is seen by everyone else.
--   
--   (Note that a duplicated channel is not equal to its original. So:
--   <tt>fmap (c /=) $ dupChan c</tt> returns <tt>True</tt> for all
--   <tt>c</tt>.)
dupChan :: () => Chan a -> IO Chan a

-- | Read the next value from the <a>Chan</a>. Blocks when the channel is
--   empty. Since the read end of a channel is an <a>MVar</a>, this
--   operation inherits fairness guarantees of <a>MVar</a>s (e.g. threads
--   blocked in this operation are woken up in FIFO order).
--   
--   Throws <tt>BlockedIndefinitelyOnMVar</tt> when the channel is empty
--   and no other thread holds a reference to the channel.
readChan :: () => Chan a -> IO a

-- | Write a value to a <a>Chan</a>.
writeChan :: () => Chan a -> a -> IO ()

-- | Build and returns a new instance of <a>Chan</a>.
newChan :: () => IO Chan a

-- | <a>Chan</a> is an abstract type representing an unbounded FIFO
--   channel.
data Chan a

-- | Signal that a unit of the <a>QSem</a> is available
signalQSem :: QSem -> IO ()

-- | Wait for a unit to become available
waitQSem :: QSem -> IO ()

-- | Build a new <a>QSem</a> with a supplied initial quantity. The initial
--   quantity must be at least 0.
newQSem :: Int -> IO QSem

-- | <a>QSem</a> is a quantity semaphore in which the resource is aqcuired
--   and released in units of one. It provides guaranteed FIFO ordering for
--   satisfying blocked <a>waitQSem</a> calls.
--   
--   The pattern
--   
--   <pre>
--   bracket_ waitQSem signalQSem (...)
--   </pre>
--   
--   is safe; it never loses a unit of the resource.
data QSem

-- | Signal that a given quantity is now available from the <a>QSemN</a>.
signalQSemN :: QSemN -> Int -> IO ()

-- | Wait for the specified quantity to become available
waitQSemN :: QSemN -> Int -> IO ()

-- | Build a new <a>QSemN</a> with a supplied initial quantity. The initial
--   quantity must be at least 0.
newQSemN :: Int -> IO QSemN

-- | <a>QSemN</a> is a quantity semaphore in which the resource is aqcuired
--   and released in units of one. It provides guaranteed FIFO ordering for
--   satisfying blocked <a>waitQSemN</a> calls.
--   
--   The pattern
--   
--   <pre>
--   bracket_ (waitQSemN n) (signalQSemN n) (...)
--   </pre>
--   
--   is safe; it never loses any of the resource.
data QSemN

-- | <a>approxRational</a>, applied to two real fractional numbers
--   <tt>x</tt> and <tt>epsilon</tt>, returns the simplest rational number
--   within <tt>epsilon</tt> of <tt>x</tt>. A rational number <tt>y</tt> is
--   said to be <i>simpler</i> than another <tt>y'</tt> if
--   
--   <ul>
--   <li><tt><a>abs</a> (<a>numerator</a> y) &lt;= <a>abs</a>
--   (<a>numerator</a> y')</tt>, and</li>
--   <li><tt><a>denominator</a> y &lt;= <a>denominator</a> y'</tt>.</li>
--   </ul>
--   
--   Any real interval contains a unique simplest rational; in particular,
--   note that <tt>0/1</tt> is the simplest rational of all.
approxRational :: RealFrac a => a -> a -> Rational

-- | The <a>isSubsequenceOf</a> function takes two lists and returns
--   <a>True</a> if all the elements of the first list occur, in order, in
--   the second. The elements do not have to occur consecutively.
--   
--   <tt><a>isSubsequenceOf</a> x y</tt> is equivalent to <tt><a>elem</a> x
--   (<a>subsequences</a> y)</tt>.
--   
--   <h4><b>Examples</b></h4>
--   
--   <pre>
--   &gt;&gt;&gt; isSubsequenceOf "GHC" "The Glorious Haskell Compiler"
--   True
--   
--   &gt;&gt;&gt; isSubsequenceOf ['a','d'..'z'] ['a'..'z']
--   True
--   
--   &gt;&gt;&gt; isSubsequenceOf [1..10] [10,9..0]
--   False
--   </pre>
isSubsequenceOf :: Eq a => [a] -> [a] -> Bool

-- | The <a>mapAccumR</a> function behaves like a combination of
--   <a>fmap</a> and <tt>foldr</tt>; it applies a function to each element
--   of a structure, passing an accumulating parameter from right to left,
--   and returning a final value of this accumulator together with the new
--   structure.
mapAccumR :: Traversable t => a -> b -> (a, c) -> a -> t b -> (a, t c)

-- | The <a>mapAccumL</a> function behaves like a combination of
--   <a>fmap</a> and <tt>foldl</tt>; it applies a function to each element
--   of a structure, passing an accumulating parameter from left to right,
--   and returning a final value of this accumulator together with the new
--   structure.
mapAccumL :: Traversable t => a -> b -> (a, c) -> a -> t b -> (a, t c)

-- | One or none.
optional :: Alternative f => f a -> f Maybe a
newtype WrappedMonad (m :: * -> *) a
WrapMonad :: m a -> WrappedMonad a
[unwrapMonad] :: WrappedMonad a -> m a
newtype WrappedArrow (a :: * -> * -> *) b c
WrapArrow :: a b c -> WrappedArrow b c
[unwrapArrow] :: WrappedArrow b c -> a b c

-- | Lists, but with an <a>Applicative</a> functor based on zipping.
newtype ZipList a
ZipList :: [a] -> ZipList a
[getZipList] :: ZipList a -> [a]

-- | Suspends the current thread for a given number of microseconds (GHC
--   only).
--   
--   There is no guarantee that the thread will be rescheduled promptly
--   when the delay has expired, but the thread will never continue to run
--   <i>earlier</i> than specified.
threadDelay :: Int -> IO ()

-- | Make a <a>Weak</a> pointer to an <a>MVar</a>, using the second
--   argument as a finalizer to run when <a>MVar</a> is garbage-collected
mkWeakMVar :: () => MVar a -> IO () -> IO Weak MVar a
addMVarFinalizer :: () => MVar a -> IO () -> IO ()

-- | Like <a>modifyMVar</a>, but the <tt>IO</tt> action in the second
--   argument is executed with asynchronous exceptions masked.
modifyMVarMasked :: () => MVar a -> a -> IO (a, b) -> IO b

-- | Like <a>modifyMVar_</a>, but the <tt>IO</tt> action in the second
--   argument is executed with asynchronous exceptions masked.
modifyMVarMasked_ :: () => MVar a -> a -> IO a -> IO ()

-- | A slight variation on <a>modifyMVar_</a> that allows a value to be
--   returned (<tt>b</tt>) in addition to the modified value of the
--   <a>MVar</a>.
modifyMVar :: () => MVar a -> a -> IO (a, b) -> IO b

-- | An exception-safe wrapper for modifying the contents of an
--   <a>MVar</a>. Like <a>withMVar</a>, <a>modifyMVar</a> will replace the
--   original contents of the <a>MVar</a> if an exception is raised during
--   the operation. This function is only atomic if there are no other
--   producers for this <a>MVar</a>.
modifyMVar_ :: () => MVar a -> a -> IO a -> IO ()

-- | Like <a>withMVar</a>, but the <tt>IO</tt> action in the second
--   argument is executed with asynchronous exceptions masked.
withMVarMasked :: () => MVar a -> a -> IO b -> IO b

-- | <a>withMVar</a> is an exception-safe wrapper for operating on the
--   contents of an <a>MVar</a>. This operation is exception-safe: it will
--   replace the original contents of the <a>MVar</a> if an exception is
--   raised (see <a>Control.Exception</a>). However, it is only atomic if
--   there are no other producers for this <a>MVar</a>.
withMVar :: () => MVar a -> a -> IO b -> IO b

-- | Take a value from an <a>MVar</a>, put a new value into the <a>MVar</a>
--   and return the value taken. This function is atomic only if there are
--   no other producers for this <a>MVar</a>.
swapMVar :: () => MVar a -> a -> IO a

-- | Make a weak pointer to a <a>ThreadId</a>. It can be important to do
--   this if you want to hold a reference to a <a>ThreadId</a> while still
--   allowing the thread to receive the <tt>BlockedIndefinitely</tt> family
--   of exceptions (e.g. <a>BlockedIndefinitelyOnMVar</a>). Holding a
--   normal <a>ThreadId</a> reference will prevent the delivery of
--   <tt>BlockedIndefinitely</tt> exceptions because the reference could be
--   used as the target of <a>throwTo</a> at any time, which would unblock
--   the thread.
--   
--   Holding a <tt>Weak ThreadId</tt>, on the other hand, will not prevent
--   the thread from receiving <tt>BlockedIndefinitely</tt> exceptions. It
--   is still possible to throw an exception to a <tt>Weak ThreadId</tt>,
--   but the caller must use <tt>deRefWeak</tt> first to determine whether
--   the thread still exists.
mkWeakThreadId :: ThreadId -> IO Weak ThreadId

-- | Returns the number of the capability on which the thread is currently
--   running, and a boolean indicating whether the thread is locked to that
--   capability or not. A thread is locked to a capability if it was
--   created with <tt>forkOn</tt>.
threadCapability :: ThreadId -> IO (Int, Bool)

-- | The <a>yield</a> action allows (forces, in a co-operative multitasking
--   implementation) a context-switch to any other currently runnable
--   threads (if any), and is occasionally useful when implementing
--   concurrency abstractions.
yield :: IO ()

-- | Returns the <a>ThreadId</a> of the calling thread (GHC only).
myThreadId :: IO ThreadId

-- | <a>throwTo</a> raises an arbitrary exception in the target thread (GHC
--   only).
--   
--   Exception delivery synchronizes between the source and target thread:
--   <a>throwTo</a> does not return until the exception has been raised in
--   the target thread. The calling thread can thus be certain that the
--   target thread has received the exception. Exception delivery is also
--   atomic with respect to other exceptions. Atomicity is a useful
--   property to have when dealing with race conditions: e.g. if there are
--   two threads that can kill each other, it is guaranteed that only one
--   of the threads will get to kill the other.
--   
--   Whatever work the target thread was doing when the exception was
--   raised is not lost: the computation is suspended until required by
--   another thread.
--   
--   If the target thread is currently making a foreign call, then the
--   exception will not be raised (and hence <a>throwTo</a> will not
--   return) until the call has completed. This is the case regardless of
--   whether the call is inside a <a>mask</a> or not. However, in GHC a
--   foreign call can be annotated as <tt>interruptible</tt>, in which case
--   a <a>throwTo</a> will cause the RTS to attempt to cause the call to
--   return; see the GHC documentation for more details.
--   
--   Important note: the behaviour of <a>throwTo</a> differs from that
--   described in the paper "Asynchronous exceptions in Haskell"
--   (<a>http://research.microsoft.com/~simonpj/Papers/asynch-exns.htm</a>).
--   In the paper, <a>throwTo</a> is non-blocking; but the library
--   implementation adopts a more synchronous design in which
--   <a>throwTo</a> does not return until the exception is received by the
--   target thread. The trade-off is discussed in Section 9 of the paper.
--   Like any blocking operation, <a>throwTo</a> is therefore interruptible
--   (see Section 5.3 of the paper). Unlike other interruptible operations,
--   however, <a>throwTo</a> is <i>always</i> interruptible, even if it
--   does not actually block.
--   
--   There is no guarantee that the exception will be delivered promptly,
--   although the runtime will endeavour to ensure that arbitrary delays
--   don't occur. In GHC, an exception can only be raised when a thread
--   reaches a <i>safe point</i>, where a safe point is where memory
--   allocation occurs. Some loops do not perform any memory allocation
--   inside the loop and therefore cannot be interrupted by a
--   <a>throwTo</a>.
--   
--   If the target of <a>throwTo</a> is the calling thread, then the
--   behaviour is the same as <a>throwIO</a>, except that the exception is
--   thrown as an asynchronous exception. This means that if there is an
--   enclosing pure computation, which would be the case if the current IO
--   operation is inside <a>unsafePerformIO</a> or
--   <a>unsafeInterleaveIO</a>, that computation is not permanently
--   replaced by the exception, but is suspended as if it had received an
--   asynchronous exception.
--   
--   Note that if <a>throwTo</a> is called with the current thread as the
--   target, the exception will be thrown even if the thread is currently
--   inside <a>mask</a> or <a>uninterruptibleMask</a>.
throwTo :: Exception e => ThreadId -> e -> IO ()

-- | <a>killThread</a> raises the <a>ThreadKilled</a> exception in the
--   given thread (GHC only).
--   
--   <pre>
--   killThread tid = throwTo tid ThreadKilled
--   </pre>
killThread :: ThreadId -> IO ()

-- | Set the number of Haskell threads that can run truly simultaneously
--   (on separate physical processors) at any given time. The number passed
--   to <a>forkOn</a> is interpreted modulo this value. The initial value
--   is given by the <tt>+RTS -N</tt> runtime flag.
--   
--   This is also the number of threads that will participate in parallel
--   garbage collection. It is strongly recommended that the number of
--   capabilities is not set larger than the number of physical processor
--   cores, and it may often be beneficial to leave one or more cores free
--   to avoid contention with other processes in the machine.
setNumCapabilities :: Int -> IO ()

-- | Returns the number of Haskell threads that can run truly
--   simultaneously (on separate physical processors) at any given time. To
--   change this value, use <a>setNumCapabilities</a>.
getNumCapabilities :: IO Int

-- | Like <a>forkIOWithUnmask</a>, but the child thread is pinned to the
--   given CPU, as with <a>forkOn</a>.
forkOnWithUnmask :: Int -> forall a. () => IO a -> IO a -> IO () -> IO ThreadId

-- | Like <a>forkIO</a>, but lets you specify on which capability the
--   thread should run. Unlike a <a>forkIO</a> thread, a thread created by
--   <a>forkOn</a> will stay on the same capability for its entire lifetime
--   (<a>forkIO</a> threads can migrate between capabilities according to
--   the scheduling policy). <a>forkOn</a> is useful for overriding the
--   scheduling policy when you know in advance how best to distribute the
--   threads.
--   
--   The <a>Int</a> argument specifies a <i>capability number</i> (see
--   <a>getNumCapabilities</a>). Typically capabilities correspond to
--   physical processors, but the exact behaviour is
--   implementation-dependent. The value passed to <a>forkOn</a> is
--   interpreted modulo the total number of capabilities as returned by
--   <a>getNumCapabilities</a>.
--   
--   GHC note: the number of capabilities is specified by the <tt>+RTS
--   -N</tt> option when the program is started. Capabilities can be fixed
--   to actual processor cores with <tt>+RTS -qa</tt> if the underlying
--   operating system supports that, although in practice this is usually
--   unnecessary (and may actually degrade performance in some cases -
--   experimentation is recommended).
forkOn :: Int -> IO () -> IO ThreadId

-- | Like <a>forkIO</a>, but the child thread is passed a function that can
--   be used to unmask asynchronous exceptions. This function is typically
--   used in the following way
--   
--   <pre>
--   ... mask_ $ forkIOWithUnmask $ \unmask -&gt;
--                  catch (unmask ...) handler
--   </pre>
--   
--   so that the exception handler in the child thread is established with
--   asynchronous exceptions masked, meanwhile the main body of the child
--   thread is executed in the unmasked state.
--   
--   Note that the unmask function passed to the child thread should only
--   be used in that thread; the behaviour is undefined if it is invoked in
--   a different thread.
forkIOWithUnmask :: forall a. () => IO a -> IO a -> IO () -> IO ThreadId

-- | Creates a new thread to run the <a>IO</a> computation passed as the
--   first argument, and returns the <a>ThreadId</a> of the newly created
--   thread.
--   
--   The new thread will be a lightweight, <i>unbound</i> thread. Foreign
--   calls made by this thread are not guaranteed to be made by any
--   particular OS thread; if you need foreign calls to be made by a
--   particular OS thread, then use <a>forkOS</a> instead.
--   
--   The new thread inherits the <i>masked</i> state of the parent (see
--   <a>mask</a>).
--   
--   The newly created thread has an exception handler that discards the
--   exceptions <a>BlockedIndefinitelyOnMVar</a>,
--   <a>BlockedIndefinitelyOnSTM</a>, and <a>ThreadKilled</a>, and passes
--   all other exceptions to the uncaught exception handler.
forkIO :: IO () -> IO ThreadId

-- | A <a>ThreadId</a> is an abstract type representing a handle to a
--   thread. <a>ThreadId</a> is an instance of <a>Eq</a>, <a>Ord</a> and
--   <a>Show</a>, where the <a>Ord</a> instance implements an arbitrary
--   total ordering over <a>ThreadId</a>s. The <a>Show</a> instance lets
--   you convert an arbitrary-valued <a>ThreadId</a> to string form;
--   showing a <a>ThreadId</a> value is occasionally useful when debugging
--   or diagnosing the behaviour of a concurrent program.
--   
--   <i>Note</i>: in GHC, if you have a <a>ThreadId</a>, you essentially
--   have a pointer to the thread itself. This means the thread itself
--   can't be garbage collected until you drop the <a>ThreadId</a>. This
--   misfeature will hopefully be corrected at a later date.
data ThreadId

-- | The <a>Const</a> functor.
newtype Const a (b :: k) :: forall k. () => * -> k -> *
Const :: a -> Const a
[getConst] :: Const a -> a

-- | The <a>find</a> function takes a predicate and a structure and returns
--   the leftmost element of the structure matching the predicate, or
--   <a>Nothing</a> if there is no such element.
find :: Foldable t => a -> Bool -> t a -> Maybe a

-- | <a>notElem</a> is the negation of <a>elem</a>.
notElem :: (Foldable t, Eq a) => a -> t a -> Bool
infix 4 `notElem`

-- | The least element of a non-empty structure with respect to the given
--   comparison function.
minimumBy :: Foldable t => a -> a -> Ordering -> t a -> a

-- | The largest element of a non-empty structure with respect to the given
--   comparison function.
maximumBy :: Foldable t => a -> a -> Ordering -> t a -> a

-- | Determines whether all elements of the structure satisfy the
--   predicate.
all :: Foldable t => a -> Bool -> t a -> Bool

-- | Determines whether any element of the structure satisfies the
--   predicate.
any :: Foldable t => a -> Bool -> t a -> Bool

-- | <a>or</a> returns the disjunction of a container of Bools. For the
--   result to be <a>False</a>, the container must be finite; <a>True</a>,
--   however, results from a <a>True</a> value finitely far from the left
--   end.
or :: Foldable t => t Bool -> Bool

-- | <a>and</a> returns the conjunction of a container of Bools. For the
--   result to be <a>True</a>, the container must be finite; <a>False</a>,
--   however, results from a <a>False</a> value finitely far from the left
--   end.
and :: Foldable t => t Bool -> Bool

-- | Map a function over all the elements of a container and concatenate
--   the resulting lists.
concatMap :: Foldable t => a -> [b] -> t a -> [b]

-- | The concatenation of all the elements of a container of lists.
concat :: Foldable t => t [a] -> [a]

-- | Maybe monoid returning the leftmost non-Nothing value.
--   
--   <tt><a>First</a> a</tt> is isomorphic to <tt><a>Alt</a> <a>Maybe</a>
--   a</tt>, but precedes it historically.
--   
--   <pre>
--   &gt;&gt;&gt; getFirst (First (Just "hello") &lt;&gt; First Nothing &lt;&gt; First (Just "world"))
--   Just "hello"
--   </pre>
newtype First a
First :: Maybe a -> First a
[getFirst] :: First a -> Maybe a

-- | Maybe monoid returning the rightmost non-Nothing value.
--   
--   <tt><a>Last</a> a</tt> is isomorphic to <tt><a>Dual</a> (<a>First</a>
--   a)</tt>, and thus to <tt><a>Dual</a> (<a>Alt</a> <a>Maybe</a> a)</tt>
--   
--   <pre>
--   &gt;&gt;&gt; getLast (Last (Just "hello") &lt;&gt; Last Nothing &lt;&gt; Last (Just "world"))
--   Just "world"
--   </pre>
newtype Last a
Last :: Maybe a -> Last a
[getLast] :: Last a -> Maybe a

-- | The dual of a <a>Monoid</a>, obtained by swapping the arguments of
--   <a>mappend</a>.
--   
--   <pre>
--   &gt;&gt;&gt; getDual (mappend (Dual "Hello") (Dual "World"))
--   "WorldHello"
--   </pre>
newtype Dual a
Dual :: a -> Dual a
[getDual] :: Dual a -> a

-- | The monoid of endomorphisms under composition.
--   
--   <pre>
--   &gt;&gt;&gt; let computation = Endo ("Hello, " ++) &lt;&gt; Endo (++ "!")
--   
--   &gt;&gt;&gt; appEndo computation "Haskell"
--   "Hello, Haskell!"
--   </pre>
newtype Endo a
Endo :: a -> a -> Endo a
[appEndo] :: Endo a -> a -> a

-- | Boolean monoid under conjunction (<a>&amp;&amp;</a>).
--   
--   <pre>
--   &gt;&gt;&gt; getAll (All True &lt;&gt; mempty &lt;&gt; All False)
--   False
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; getAll (mconcat (map (\x -&gt; All (even x)) [2,4,6,7,8]))
--   False
--   </pre>
newtype All
All :: Bool -> All
[getAll] :: All -> Bool

-- | Boolean monoid under disjunction (<a>||</a>).
--   
--   <pre>
--   &gt;&gt;&gt; getAny (Any True &lt;&gt; mempty &lt;&gt; Any False)
--   True
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; getAny (mconcat (map (\x -&gt; Any (even x)) [2,4,6,7,8]))
--   True
--   </pre>
newtype Any
Any :: Bool -> Any
[getAny] :: Any -> Bool

-- | Monoid under addition.
--   
--   <pre>
--   &gt;&gt;&gt; getSum (Sum 1 &lt;&gt; Sum 2 &lt;&gt; mempty)
--   3
--   </pre>
newtype Sum a
Sum :: a -> Sum a
[getSum] :: Sum a -> a

-- | Monoid under multiplication.
--   
--   <pre>
--   &gt;&gt;&gt; getProduct (Product 3 &lt;&gt; Product 4 &lt;&gt; mempty)
--   12
--   </pre>
newtype Product a
Product :: a -> Product a
[getProduct] :: Product a -> a

-- | Monoid under <a>&lt;|&gt;</a>.
newtype Alt (f :: k -> *) (a :: k) :: forall k. () => k -> * -> k -> *
Alt :: f a -> Alt
[getAlt] :: Alt -> f a

-- | <a>unwords</a> is an inverse operation to <a>words</a>. It joins words
--   with separating spaces.
--   
--   <pre>
--   &gt;&gt;&gt; unwords ["Lorem", "ipsum", "dolor"]
--   "Lorem ipsum dolor"
--   </pre>
unwords :: [String] -> String

-- | <a>words</a> breaks a string up into a list of words, which were
--   delimited by white space.
--   
--   <pre>
--   &gt;&gt;&gt; words "Lorem ipsum\ndolor"
--   ["Lorem","ipsum","dolor"]
--   </pre>
words :: String -> [String]

-- | <a>unlines</a> is an inverse operation to <a>lines</a>. It joins
--   lines, after appending a terminating newline to each.
--   
--   <pre>
--   &gt;&gt;&gt; unlines ["Hello", "World", "!"]
--   "Hello\nWorld\n!\n"
--   </pre>
unlines :: [String] -> String

-- | <a>lines</a> breaks a string up into a list of strings at newline
--   characters. The resulting strings do not contain newlines.
--   
--   Note that after splitting the string at newline characters, the last
--   part of the string is considered a line even if it doesn't end with a
--   newline. For example,
--   
--   <pre>
--   &gt;&gt;&gt; lines ""
--   []
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "\n"
--   [""]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "one"
--   ["one"]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "one\n"
--   ["one"]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "one\n\n"
--   ["one",""]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "one\ntwo"
--   ["one","two"]
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; lines "one\ntwo\n"
--   ["one","two"]
--   </pre>
--   
--   Thus <tt><a>lines</a> s</tt> contains at least as many elements as
--   newlines in <tt>s</tt>.
lines :: String -> [String]

-- | The <a>unfoldr</a> function is a `dual' to <a>foldr</a>: while
--   <a>foldr</a> reduces a list to a summary value, <a>unfoldr</a> builds
--   a list from a seed value. The function takes the element and returns
--   <a>Nothing</a> if it is done producing the list or returns <a>Just</a>
--   <tt>(a,b)</tt>, in which case, <tt>a</tt> is a prepended to the list
--   and <tt>b</tt> is used as the next element in a recursive call. For
--   example,
--   
--   <pre>
--   iterate f == unfoldr (\x -&gt; Just (x, f x))
--   </pre>
--   
--   In some cases, <a>unfoldr</a> can undo a <a>foldr</a> operation:
--   
--   <pre>
--   unfoldr f' (foldr f z xs) == xs
--   </pre>
--   
--   if the following holds:
--   
--   <pre>
--   f' (f x y) = Just (x,y)
--   f' z       = Nothing
--   </pre>
--   
--   A simple use of unfoldr:
--   
--   <pre>
--   &gt;&gt;&gt; unfoldr (\b -&gt; if b == 0 then Nothing else Just (b, b-1)) 10
--   [10,9,8,7,6,5,4,3,2,1]
--   </pre>
unfoldr :: () => b -> Maybe (a, b) -> b -> [a]

-- | Sort a list by comparing the results of a key function applied to each
--   element. <tt>sortOn f</tt> is equivalent to <tt>sortBy (comparing
--   f)</tt>, but has the performance advantage of only evaluating
--   <tt>f</tt> once for each element in the input list. This is called the
--   decorate-sort-undecorate paradigm, or Schwartzian transform.
--   
--   Elements are arranged from from lowest to highest, keeping duplicates
--   in the order they appeared in the input.
--   
--   <pre>
--   &gt;&gt;&gt; sortOn fst [(2, "world"), (4, "!"), (1, "Hello")]
--   [(1,"Hello"),(2,"world"),(4,"!")]
--   </pre>
sortOn :: Ord b => a -> b -> [a] -> [a]

-- | The <a>sortBy</a> function is the non-overloaded version of
--   <a>sort</a>.
--   
--   <pre>
--   &gt;&gt;&gt; sortBy (\(a,_) (b,_) -&gt; compare a b) [(2, "world"), (4, "!"), (1, "Hello")]
--   [(1,"Hello"),(2,"world"),(4,"!")]
--   </pre>
sortBy :: () => a -> a -> Ordering -> [a] -> [a]

-- | The <a>sort</a> function implements a stable sorting algorithm. It is
--   a special case of <a>sortBy</a>, which allows the programmer to supply
--   their own comparison function.
--   
--   Elements are arranged from from lowest to highest, keeping duplicates
--   in the order they appeared in the input.
--   
--   <pre>
--   &gt;&gt;&gt; sort [1,6,4,3,2,5]
--   [1,2,3,4,5,6]
--   </pre>
sort :: Ord a => [a] -> [a]

-- | The <a>permutations</a> function returns the list of all permutations
--   of the argument.
--   
--   <pre>
--   &gt;&gt;&gt; permutations "abc"
--   ["abc","bac","cba","bca","cab","acb"]
--   </pre>
permutations :: () => [a] -> [[a]]

-- | The <a>subsequences</a> function returns the list of all subsequences
--   of the argument.
--   
--   <pre>
--   &gt;&gt;&gt; subsequences "abc"
--   ["","a","b","ab","c","ac","bc","abc"]
--   </pre>
subsequences :: () => [a] -> [[a]]

-- | The <a>tails</a> function returns all final segments of the argument,
--   longest first. For example,
--   
--   <pre>
--   &gt;&gt;&gt; tails "abc"
--   ["abc","bc","c",""]
--   </pre>
--   
--   Note that <a>tails</a> has the following strictness property:
--   <tt>tails _|_ = _|_ : _|_</tt>
tails :: () => [a] -> [[a]]

-- | The <a>inits</a> function returns all initial segments of the
--   argument, shortest first. For example,
--   
--   <pre>
--   &gt;&gt;&gt; inits "abc"
--   ["","a","ab","abc"]
--   </pre>
--   
--   Note that <a>inits</a> has the following strictness property:
--   <tt>inits (xs ++ _|_) = inits xs ++ _|_</tt>
--   
--   In particular, <tt>inits _|_ = [] : _|_</tt>
inits :: () => [a] -> [[a]]

-- | The <a>groupBy</a> function is the non-overloaded version of
--   <a>group</a>.
groupBy :: () => a -> a -> Bool -> [a] -> [[a]]

-- | The <a>group</a> function takes a list and returns a list of lists
--   such that the concatenation of the result is equal to the argument.
--   Moreover, each sublist in the result contains only equal elements. For
--   example,
--   
--   <pre>
--   &gt;&gt;&gt; group "Mississippi"
--   ["M","i","ss","i","ss","i","pp","i"]
--   </pre>
--   
--   It is a special case of <a>groupBy</a>, which allows the programmer to
--   supply their own equality test.
group :: Eq a => [a] -> [[a]]

-- | The <a>deleteFirstsBy</a> function takes a predicate and two lists and
--   returns the first list with the first occurrence of each element of
--   the second list removed.
deleteFirstsBy :: () => a -> a -> Bool -> [a] -> [a] -> [a]

-- | The <a>unzip7</a> function takes a list of seven-tuples and returns
--   seven lists, analogous to <a>unzip</a>.
unzip7 :: () => [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])

-- | The <a>unzip6</a> function takes a list of six-tuples and returns six
--   lists, analogous to <a>unzip</a>.
unzip6 :: () => [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])

-- | The <a>unzip5</a> function takes a list of five-tuples and returns
--   five lists, analogous to <a>unzip</a>.
unzip5 :: () => [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])

-- | The <a>unzip4</a> function takes a list of quadruples and returns four
--   lists, analogous to <a>unzip</a>.
unzip4 :: () => [(a, b, c, d)] -> ([a], [b], [c], [d])

-- | The <a>zipWith7</a> function takes a function which combines seven
--   elements, as well as seven lists and returns a list of their
--   point-wise combination, analogous to <a>zipWith</a>.
zipWith7 :: () => a -> b -> c -> d -> e -> f -> g -> h -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]

-- | The <a>zipWith6</a> function takes a function which combines six
--   elements, as well as six lists and returns a list of their point-wise
--   combination, analogous to <a>zipWith</a>.
zipWith6 :: () => a -> b -> c -> d -> e -> f -> g -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]

-- | The <a>zipWith5</a> function takes a function which combines five
--   elements, as well as five lists and returns a list of their point-wise
--   combination, analogous to <a>zipWith</a>.
zipWith5 :: () => a -> b -> c -> d -> e -> f -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]

-- | The <a>zipWith4</a> function takes a function which combines four
--   elements, as well as four lists and returns a list of their point-wise
--   combination, analogous to <a>zipWith</a>.
zipWith4 :: () => a -> b -> c -> d -> e -> [a] -> [b] -> [c] -> [d] -> [e]

-- | The <a>zip7</a> function takes seven lists and returns a list of
--   seven-tuples, analogous to <a>zip</a>.
zip7 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]

-- | The <a>zip6</a> function takes six lists and returns a list of
--   six-tuples, analogous to <a>zip</a>.
zip6 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]

-- | The <a>zip5</a> function takes five lists and returns a list of
--   five-tuples, analogous to <a>zip</a>.
zip5 :: () => [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]

-- | The <a>zip4</a> function takes four lists and returns a list of
--   quadruples, analogous to <a>zip</a>.
zip4 :: () => [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]

-- | The <a>genericReplicate</a> function is an overloaded version of
--   <a>replicate</a>, which accepts any <a>Integral</a> value as the
--   number of repetitions to make.
genericReplicate :: Integral i => i -> a -> [a]

-- | The <a>genericIndex</a> function is an overloaded version of
--   <a>!!</a>, which accepts any <a>Integral</a> value as the index.
genericIndex :: Integral i => [a] -> i -> a

-- | The <a>genericSplitAt</a> function is an overloaded version of
--   <a>splitAt</a>, which accepts any <a>Integral</a> value as the
--   position at which to split.
genericSplitAt :: Integral i => i -> [a] -> ([a], [a])

-- | The <a>genericDrop</a> function is an overloaded version of
--   <a>drop</a>, which accepts any <a>Integral</a> value as the number of
--   elements to drop.
genericDrop :: Integral i => i -> [a] -> [a]

-- | The <a>genericTake</a> function is an overloaded version of
--   <a>take</a>, which accepts any <a>Integral</a> value as the number of
--   elements to take.
genericTake :: Integral i => i -> [a] -> [a]

-- | The <a>genericLength</a> function is an overloaded version of
--   <a>length</a>. In particular, instead of returning an <a>Int</a>, it
--   returns any type which is an instance of <a>Num</a>. It is, however,
--   less efficient than <a>length</a>.
genericLength :: Num i => [a] -> i

-- | The non-overloaded version of <a>insert</a>.
insertBy :: () => a -> a -> Ordering -> a -> [a] -> [a]

-- | The <a>insert</a> function takes an element and a list and inserts the
--   element into the list at the first position where it is less than or
--   equal to the next element. In particular, if the list is sorted before
--   the call, the result will also be sorted. It is a special case of
--   <a>insertBy</a>, which allows the programmer to supply their own
--   comparison function.
--   
--   <pre>
--   &gt;&gt;&gt; insert 4 [1,2,3,5,6,7]
--   [1,2,3,4,5,6,7]
--   </pre>
insert :: Ord a => a -> [a] -> [a]

-- | The <a>partition</a> function takes a predicate a list and returns the
--   pair of lists of elements which do and do not satisfy the predicate,
--   respectively; i.e.,
--   
--   <pre>
--   partition p xs == (filter p xs, filter (not . p) xs)
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; partition (`elem` "aeiou") "Hello World!"
--   ("eoo","Hll Wrld!")
--   </pre>
partition :: () => a -> Bool -> [a] -> ([a], [a])

-- | The <a>transpose</a> function transposes the rows and columns of its
--   argument. For example,
--   
--   <pre>
--   &gt;&gt;&gt; transpose [[1,2,3],[4,5,6]]
--   [[1,4],[2,5],[3,6]]
--   </pre>
--   
--   If some of the rows are shorter than the following rows, their
--   elements are skipped:
--   
--   <pre>
--   &gt;&gt;&gt; transpose [[10,11],[20],[],[30,31,32]]
--   [[10,20,30],[11,31],[32]]
--   </pre>
transpose :: () => [[a]] -> [[a]]

-- | <a>intercalate</a> <tt>xs xss</tt> is equivalent to <tt>(<a>concat</a>
--   (<a>intersperse</a> xs xss))</tt>. It inserts the list <tt>xs</tt> in
--   between the lists in <tt>xss</tt> and concatenates the result.
--   
--   <pre>
--   &gt;&gt;&gt; intercalate ", " ["Lorem", "ipsum", "dolor"]
--   "Lorem, ipsum, dolor"
--   </pre>
intercalate :: () => [a] -> [[a]] -> [a]

-- | The <a>intersperse</a> function takes an element and a list and
--   `intersperses' that element between the elements of the list. For
--   example,
--   
--   <pre>
--   &gt;&gt;&gt; intersperse ',' "abcde"
--   "a,b,c,d,e"
--   </pre>
intersperse :: () => a -> [a] -> [a]

-- | The <a>intersectBy</a> function is the non-overloaded version of
--   <a>intersect</a>.
intersectBy :: () => a -> a -> Bool -> [a] -> [a] -> [a]

-- | The <a>intersect</a> function takes the list intersection of two
--   lists. For example,
--   
--   <pre>
--   &gt;&gt;&gt; [1,2,3,4] `intersect` [2,4,6,8]
--   [2,4]
--   </pre>
--   
--   If the first list contains duplicates, so will the result.
--   
--   <pre>
--   &gt;&gt;&gt; [1,2,2,3,4] `intersect` [6,4,4,2]
--   [2,2,4]
--   </pre>
--   
--   It is a special case of <a>intersectBy</a>, which allows the
--   programmer to supply their own equality test. If the element is found
--   in both the first and the second list, the element from the first list
--   will be used.
intersect :: Eq a => [a] -> [a] -> [a]

-- | The <a>unionBy</a> function is the non-overloaded version of
--   <a>union</a>.
unionBy :: () => a -> a -> Bool -> [a] -> [a] -> [a]

-- | The <a>union</a> function returns the list union of the two lists. For
--   example,
--   
--   <pre>
--   &gt;&gt;&gt; "dog" `union` "cow"
--   "dogcw"
--   </pre>
--   
--   Duplicates, and elements of the first list, are removed from the the
--   second list, but if the first list contains duplicates, so will the
--   result. It is a special case of <a>unionBy</a>, which allows the
--   programmer to supply their own equality test.
union :: Eq a => [a] -> [a] -> [a]

-- | The <a>\\</a> function is list difference (non-associative). In the
--   result of <tt>xs</tt> <a>\\</a> <tt>ys</tt>, the first occurrence of
--   each element of <tt>ys</tt> in turn (if any) has been removed from
--   <tt>xs</tt>. Thus
--   
--   <pre>
--   (xs ++ ys) \\ xs == ys.
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; "Hello World!" \\ "ell W"
--   "Hoorld!"
--   </pre>
--   
--   It is a special case of <a>deleteFirstsBy</a>, which allows the
--   programmer to supply their own equality test.
(\\) :: Eq a => [a] -> [a] -> [a]
infix 5 \\

-- | The <a>deleteBy</a> function behaves like <a>delete</a>, but takes a
--   user-supplied equality predicate.
--   
--   <pre>
--   &gt;&gt;&gt; deleteBy (&lt;=) 4 [1..10]
--   [1,2,3,5,6,7,8,9,10]
--   </pre>
deleteBy :: () => a -> a -> Bool -> a -> [a] -> [a]

-- | <a>delete</a> <tt>x</tt> removes the first occurrence of <tt>x</tt>
--   from its list argument. For example,
--   
--   <pre>
--   &gt;&gt;&gt; delete 'a' "banana"
--   "bnana"
--   </pre>
--   
--   It is a special case of <a>deleteBy</a>, which allows the programmer
--   to supply their own equality test.
delete :: Eq a => a -> [a] -> [a]

-- | The <a>nubBy</a> function behaves just like <a>nub</a>, except it uses
--   a user-supplied equality predicate instead of the overloaded <a>==</a>
--   function.
--   
--   <pre>
--   &gt;&gt;&gt; nubBy (\x y -&gt; mod x 3 == mod y 3) [1,2,4,5,6]
--   [1,2,6]
--   </pre>
nubBy :: () => a -> a -> Bool -> [a] -> [a]

-- | <i>O(n^2)</i>. The <a>nub</a> function removes duplicate elements from
--   a list. In particular, it keeps only the first occurrence of each
--   element. (The name <a>nub</a> means `essence'.) It is a special case
--   of <a>nubBy</a>, which allows the programmer to supply their own
--   equality test.
--   
--   <pre>
--   &gt;&gt;&gt; nub [1,2,3,4,3,2,1,2,4,3,5]
--   [1,2,3,4,5]
--   </pre>
nub :: Eq a => [a] -> [a]

-- | The <a>isInfixOf</a> function takes two lists and returns <a>True</a>
--   iff the first list is contained, wholly and intact, anywhere within
--   the second.
--   
--   <pre>
--   &gt;&gt;&gt; isInfixOf "Haskell" "I really like Haskell."
--   True
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; isInfixOf "Ial" "I really like Haskell."
--   False
--   </pre>
isInfixOf :: Eq a => [a] -> [a] -> Bool

-- | The <a>isSuffixOf</a> function takes two lists and returns <a>True</a>
--   iff the first list is a suffix of the second. The second list must be
--   finite.
--   
--   <pre>
--   &gt;&gt;&gt; "ld!" `isSuffixOf` "Hello World!"
--   True
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; "World" `isSuffixOf` "Hello World!"
--   False
--   </pre>
isSuffixOf :: Eq a => [a] -> [a] -> Bool

-- | The <a>isPrefixOf</a> function takes two lists and returns <a>True</a>
--   iff the first list is a prefix of the second.
--   
--   <pre>
--   &gt;&gt;&gt; "Hello" `isPrefixOf` "Hello World!"
--   True
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; "Hello" `isPrefixOf` "Wello Horld!"
--   False
--   </pre>
isPrefixOf :: Eq a => [a] -> [a] -> Bool

-- | The <a>findIndices</a> function extends <a>findIndex</a>, by returning
--   the indices of all elements satisfying the predicate, in ascending
--   order.
--   
--   <pre>
--   &gt;&gt;&gt; findIndices (`elem` "aeiou") "Hello World!"
--   [1,4,7]
--   </pre>
findIndices :: () => a -> Bool -> [a] -> [Int]

-- | The <a>findIndex</a> function takes a predicate and a list and returns
--   the index of the first element in the list satisfying the predicate,
--   or <a>Nothing</a> if there is no such element.
--   
--   <pre>
--   &gt;&gt;&gt; findIndex isSpace "Hello World!"
--   Just 5
--   </pre>
findIndex :: () => a -> Bool -> [a] -> Maybe Int

-- | The <a>elemIndices</a> function extends <a>elemIndex</a>, by returning
--   the indices of all elements equal to the query element, in ascending
--   order.
--   
--   <pre>
--   &gt;&gt;&gt; elemIndices 'o' "Hello World"
--   [4,7]
--   </pre>
elemIndices :: Eq a => a -> [a] -> [Int]

-- | The <a>elemIndex</a> function returns the index of the first element
--   in the given list which is equal (by <a>==</a>) to the query element,
--   or <a>Nothing</a> if there is no such element.
--   
--   <pre>
--   &gt;&gt;&gt; elemIndex 4 [0..]
--   Just 4
--   </pre>
elemIndex :: Eq a => a -> [a] -> Maybe Int

-- | The <a>stripPrefix</a> function drops the given prefix from a list. It
--   returns <a>Nothing</a> if the list did not start with the prefix
--   given, or <a>Just</a> the list after the prefix, if it does.
--   
--   <pre>
--   &gt;&gt;&gt; stripPrefix "foo" "foobar"
--   Just "bar"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; stripPrefix "foo" "foo"
--   Just ""
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; stripPrefix "foo" "barfoo"
--   Nothing
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; stripPrefix "foo" "barfoobaz"
--   Nothing
--   </pre>
stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]

-- | The <a>dropWhileEnd</a> function drops the largest suffix of a list in
--   which the given predicate holds for all elements. For example:
--   
--   <pre>
--   &gt;&gt;&gt; dropWhileEnd isSpace "foo\n"
--   "foo"
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; dropWhileEnd isSpace "foo bar"
--   "foo bar"
--   </pre>
--   
--   <pre>
--   dropWhileEnd isSpace ("foo\n" ++ undefined) == "foo" ++ undefined
--   </pre>
dropWhileEnd :: () => a -> Bool -> [a] -> [a]

-- | An infix synonym for <a>fmap</a>.
--   
--   The name of this operator is an allusion to <tt>$</tt>. Note the
--   similarities between their types:
--   
--   <pre>
--    ($)  ::              (a -&gt; b) -&gt;   a -&gt;   b
--   (&lt;$&gt;) :: Functor f =&gt; (a -&gt; b) -&gt; f a -&gt; f b
--   </pre>
--   
--   Whereas <tt>$</tt> is function application, <a>&lt;$&gt;</a> is
--   function application lifted over a <a>Functor</a>.
--   
--   <h4><b>Examples</b></h4>
--   
--   Convert from a <tt><tt>Maybe</tt> <tt>Int</tt></tt> to a
--   <tt><tt>Maybe</tt> <tt>String</tt></tt> using <tt>show</tt>:
--   
--   <pre>
--   &gt;&gt;&gt; show &lt;$&gt; Nothing
--   Nothing
--   
--   &gt;&gt;&gt; show &lt;$&gt; Just 3
--   Just "3"
--   </pre>
--   
--   Convert from an <tt><tt>Either</tt> <tt>Int</tt> <tt>Int</tt></tt> to
--   an <tt><tt>Either</tt> <tt>Int</tt></tt> <tt>String</tt> using
--   <tt>show</tt>:
--   
--   <pre>
--   &gt;&gt;&gt; show &lt;$&gt; Left 17
--   Left 17
--   
--   &gt;&gt;&gt; show &lt;$&gt; Right 17
--   Right "17"
--   </pre>
--   
--   Double each element of a list:
--   
--   <pre>
--   &gt;&gt;&gt; (*2) &lt;$&gt; [1,2,3]
--   [2,4,6]
--   </pre>
--   
--   Apply <tt>even</tt> to the second element of a pair:
--   
--   <pre>
--   &gt;&gt;&gt; even &lt;$&gt; (2,2)
--   (2,True)
--   </pre>
(<$>) :: Functor f => a -> b -> f a -> f b
infixl 4 <$>

-- | Extract the denominator of the ratio in reduced form: the numerator
--   and denominator have no common factor and the denominator is positive.
denominator :: () => Ratio a -> a

-- | Extract the numerator of the ratio in reduced form: the numerator and
--   denominator have no common factor and the denominator is positive.
numerator :: () => Ratio a -> a

-- | Forms the ratio of two integral numbers.
(%) :: Integral a => a -> a -> Ratio a
infixl 7 %

-- | The <a>unzip3</a> function takes a list of triples and returns three
--   lists, analogous to <a>unzip</a>.
unzip3 :: () => [(a, b, c)] -> ([a], [b], [c])

-- | <a>unzip</a> transforms a list of pairs into a list of first
--   components and a list of second components.
unzip :: () => [(a, b)] -> ([a], [b])

-- | The <a>zipWith3</a> function takes a function which combines three
--   elements, as well as three lists and returns a list of their
--   point-wise combination, analogous to <a>zipWith</a>.
zipWith3 :: () => a -> b -> c -> d -> [a] -> [b] -> [c] -> [d]

-- | <a>zipWith</a> generalises <a>zip</a> by zipping with the function
--   given as the first argument, instead of a tupling function. For
--   example, <tt><a>zipWith</a> (+)</tt> is applied to two lists to
--   produce the list of corresponding sums.
--   
--   <a>zipWith</a> is right-lazy:
--   
--   <pre>
--   zipWith f [] _|_ = []
--   </pre>
zipWith :: () => a -> b -> c -> [a] -> [b] -> [c]

-- | <a>zip3</a> takes three lists and returns a list of triples, analogous
--   to <a>zip</a>.
zip3 :: () => [a] -> [b] -> [c] -> [(a, b, c)]

-- | List index (subscript) operator, starting from 0. It is an instance of
--   the more general <a>genericIndex</a>, which takes an index of any
--   integral type.
(!!) :: () => [a] -> Int -> a
infixl 9 !!

-- | <a>lookup</a> <tt>key assocs</tt> looks up a key in an association
--   list.
lookup :: Eq a => a -> [(a, b)] -> Maybe b

-- | <a>reverse</a> <tt>xs</tt> returns the elements of <tt>xs</tt> in
--   reverse order. <tt>xs</tt> must be finite.
reverse :: () => [a] -> [a]

-- | <a>break</a>, applied to a predicate <tt>p</tt> and a list
--   <tt>xs</tt>, returns a tuple where first element is longest prefix
--   (possibly empty) of <tt>xs</tt> of elements that <i>do not satisfy</i>
--   <tt>p</tt> and second element is the remainder of the list:
--   
--   <pre>
--   break (&gt; 3) [1,2,3,4,1,2,3,4] == ([1,2,3],[4,1,2,3,4])
--   break (&lt; 9) [1,2,3] == ([],[1,2,3])
--   break (&gt; 9) [1,2,3] == ([1,2,3],[])
--   </pre>
--   
--   <a>break</a> <tt>p</tt> is equivalent to <tt><a>span</a> (<a>not</a> .
--   p)</tt>.
break :: () => a -> Bool -> [a] -> ([a], [a])

-- | <a>span</a>, applied to a predicate <tt>p</tt> and a list <tt>xs</tt>,
--   returns a tuple where first element is longest prefix (possibly empty)
--   of <tt>xs</tt> of elements that satisfy <tt>p</tt> and second element
--   is the remainder of the list:
--   
--   <pre>
--   span (&lt; 3) [1,2,3,4,1,2,3,4] == ([1,2],[3,4,1,2,3,4])
--   span (&lt; 9) [1,2,3] == ([1,2,3],[])
--   span (&lt; 0) [1,2,3] == ([],[1,2,3])
--   </pre>
--   
--   <a>span</a> <tt>p xs</tt> is equivalent to <tt>(<a>takeWhile</a> p xs,
--   <a>dropWhile</a> p xs)</tt>
span :: () => a -> Bool -> [a] -> ([a], [a])

-- | <a>splitAt</a> <tt>n xs</tt> returns a tuple where first element is
--   <tt>xs</tt> prefix of length <tt>n</tt> and second element is the
--   remainder of the list:
--   
--   <pre>
--   splitAt 6 "Hello World!" == ("Hello ","World!")
--   splitAt 3 [1,2,3,4,5] == ([1,2,3],[4,5])
--   splitAt 1 [1,2,3] == ([1],[2,3])
--   splitAt 3 [1,2,3] == ([1,2,3],[])
--   splitAt 4 [1,2,3] == ([1,2,3],[])
--   splitAt 0 [1,2,3] == ([],[1,2,3])
--   splitAt (-1) [1,2,3] == ([],[1,2,3])
--   </pre>
--   
--   It is equivalent to <tt>(<a>take</a> n xs, <a>drop</a> n xs)</tt> when
--   <tt>n</tt> is not <tt>_|_</tt> (<tt>splitAt _|_ xs = _|_</tt>).
--   <a>splitAt</a> is an instance of the more general
--   <a>genericSplitAt</a>, in which <tt>n</tt> may be of any integral
--   type.
splitAt :: () => Int -> [a] -> ([a], [a])

-- | <a>drop</a> <tt>n xs</tt> returns the suffix of <tt>xs</tt> after the
--   first <tt>n</tt> elements, or <tt>[]</tt> if <tt>n &gt; <a>length</a>
--   xs</tt>:
--   
--   <pre>
--   drop 6 "Hello World!" == "World!"
--   drop 3 [1,2,3,4,5] == [4,5]
--   drop 3 [1,2] == []
--   drop 3 [] == []
--   drop (-1) [1,2] == [1,2]
--   drop 0 [1,2] == [1,2]
--   </pre>
--   
--   It is an instance of the more general <a>genericDrop</a>, in which
--   <tt>n</tt> may be of any integral type.
drop :: () => Int -> [a] -> [a]

-- | <a>take</a> <tt>n</tt>, applied to a list <tt>xs</tt>, returns the
--   prefix of <tt>xs</tt> of length <tt>n</tt>, or <tt>xs</tt> itself if
--   <tt>n &gt; <a>length</a> xs</tt>:
--   
--   <pre>
--   take 5 "Hello World!" == "Hello"
--   take 3 [1,2,3,4,5] == [1,2,3]
--   take 3 [1,2] == [1,2]
--   take 3 [] == []
--   take (-1) [1,2] == []
--   take 0 [1,2] == []
--   </pre>
--   
--   It is an instance of the more general <a>genericTake</a>, in which
--   <tt>n</tt> may be of any integral type.
take :: () => Int -> [a] -> [a]

-- | <a>dropWhile</a> <tt>p xs</tt> returns the suffix remaining after
--   <a>takeWhile</a> <tt>p xs</tt>:
--   
--   <pre>
--   dropWhile (&lt; 3) [1,2,3,4,5,1,2,3] == [3,4,5,1,2,3]
--   dropWhile (&lt; 9) [1,2,3] == []
--   dropWhile (&lt; 0) [1,2,3] == [1,2,3]
--   </pre>
dropWhile :: () => a -> Bool -> [a] -> [a]

-- | <a>takeWhile</a>, applied to a predicate <tt>p</tt> and a list
--   <tt>xs</tt>, returns the longest prefix (possibly empty) of
--   <tt>xs</tt> of elements that satisfy <tt>p</tt>:
--   
--   <pre>
--   takeWhile (&lt; 3) [1,2,3,4,1,2,3,4] == [1,2]
--   takeWhile (&lt; 9) [1,2,3] == [1,2,3]
--   takeWhile (&lt; 0) [1,2,3] == []
--   </pre>
takeWhile :: () => a -> Bool -> [a] -> [a]

-- | <a>cycle</a> ties a finite list into a circular one, or equivalently,
--   the infinite repetition of the original list. It is the identity on
--   infinite lists.
cycle :: () => [a] -> [a]

-- | <a>replicate</a> <tt>n x</tt> is a list of length <tt>n</tt> with
--   <tt>x</tt> the value of every element. It is an instance of the more
--   general <a>genericReplicate</a>, in which <tt>n</tt> may be of any
--   integral type.
replicate :: () => Int -> a -> [a]

-- | <a>repeat</a> <tt>x</tt> is an infinite list, with <tt>x</tt> the
--   value of every element.
repeat :: () => a -> [a]

-- | 'iterate\'' is the strict version of <a>iterate</a>.
--   
--   It ensures that the result of each application of force to weak head
--   normal form before proceeding.
iterate' :: () => a -> a -> a -> [a]

-- | <a>iterate</a> <tt>f x</tt> returns an infinite list of repeated
--   applications of <tt>f</tt> to <tt>x</tt>:
--   
--   <pre>
--   iterate f x == [x, f x, f (f x), ...]
--   </pre>
--   
--   Note that <a>iterate</a> is lazy, potentially leading to thunk
--   build-up if the consumer doesn't force each iterate. See 'iterate\''
--   for a strict variant of this function.
iterate :: () => a -> a -> a -> [a]

-- | <a>scanr1</a> is a variant of <a>scanr</a> that has no starting value
--   argument.
scanr1 :: () => a -> a -> a -> [a] -> [a]

-- | <a>scanr</a> is the right-to-left dual of <a>scanl</a>. Note that
--   
--   <pre>
--   head (scanr f z xs) == foldr f z xs.
--   </pre>
scanr :: () => a -> b -> b -> b -> [a] -> [b]

-- | A strictly accumulating version of <a>scanl</a>
scanl' :: () => b -> a -> b -> b -> [a] -> [b]

-- | <a>scanl1</a> is a variant of <a>scanl</a> that has no starting value
--   argument:
--   
--   <pre>
--   scanl1 f [x1, x2, ...] == [x1, x1 `f` x2, ...]
--   </pre>
scanl1 :: () => a -> a -> a -> [a] -> [a]

-- | <a>scanl</a> is similar to <a>foldl</a>, but returns a list of
--   successive reduced values from the left:
--   
--   <pre>
--   scanl f z [x1, x2, ...] == [z, z `f` x1, (z `f` x1) `f` x2, ...]
--   </pre>
--   
--   Note that
--   
--   <pre>
--   last (scanl f z xs) == foldl f z xs.
--   </pre>
scanl :: () => b -> a -> b -> b -> [a] -> [b]

-- | A strict version of <a>foldl1</a>
foldl1' :: () => a -> a -> a -> [a] -> a

-- | Return all the elements of a list except the last one. The list must
--   be non-empty.
init :: () => [a] -> [a]

-- | Extract the last element of a list, which must be finite and
--   non-empty.
last :: () => [a] -> a

-- | Extract the elements after the head of a list, which must be
--   non-empty.
tail :: () => [a] -> [a]

-- | Decompose a list into its head and tail. If the list is empty, returns
--   <a>Nothing</a>. If the list is non-empty, returns <tt><a>Just</a> (x,
--   xs)</tt>, where <tt>x</tt> is the head of the list and <tt>xs</tt> its
--   tail.
uncons :: () => [a] -> Maybe (a, [a])

-- | Extract the first element of a list, which must be non-empty.
head :: () => [a] -> a

-- | Check whether a given <a>MVar</a> is empty.
--   
--   Notice that the boolean value returned is just a snapshot of the state
--   of the MVar. By the time you get to react on its result, the MVar may
--   have been filled (or emptied) - so be extremely careful when using
--   this operation. Use <a>tryTakeMVar</a> instead if possible.
isEmptyMVar :: () => MVar a -> IO Bool

-- | A non-blocking version of <a>readMVar</a>. The <a>tryReadMVar</a>
--   function returns immediately, with <a>Nothing</a> if the <a>MVar</a>
--   was empty, or <tt><a>Just</a> a</tt> if the <a>MVar</a> was full with
--   contents <tt>a</tt>.
tryReadMVar :: () => MVar a -> IO Maybe a

-- | A non-blocking version of <a>putMVar</a>. The <a>tryPutMVar</a>
--   function attempts to put the value <tt>a</tt> into the <a>MVar</a>,
--   returning <a>True</a> if it was successful, or <a>False</a> otherwise.
tryPutMVar :: () => MVar a -> a -> IO Bool

-- | A non-blocking version of <a>takeMVar</a>. The <a>tryTakeMVar</a>
--   function returns immediately, with <a>Nothing</a> if the <a>MVar</a>
--   was empty, or <tt><a>Just</a> a</tt> if the <a>MVar</a> was full with
--   contents <tt>a</tt>. After <a>tryTakeMVar</a>, the <a>MVar</a> is left
--   empty.
tryTakeMVar :: () => MVar a -> IO Maybe a

-- | Put a value into an <a>MVar</a>. If the <a>MVar</a> is currently full,
--   <a>putMVar</a> will wait until it becomes empty.
--   
--   There are two further important properties of <a>putMVar</a>:
--   
--   <ul>
--   <li><a>putMVar</a> is single-wakeup. That is, if there are multiple
--   threads blocked in <a>putMVar</a>, and the <a>MVar</a> becomes empty,
--   only one thread will be woken up. The runtime guarantees that the
--   woken thread completes its <a>putMVar</a> operation.</li>
--   <li>When multiple threads are blocked on an <a>MVar</a>, they are
--   woken up in FIFO order. This is useful for providing fairness
--   properties of abstractions built using <a>MVar</a>s.</li>
--   </ul>
putMVar :: () => MVar a -> a -> IO ()

-- | Atomically read the contents of an <a>MVar</a>. If the <a>MVar</a> is
--   currently empty, <a>readMVar</a> will wait until it is full.
--   <a>readMVar</a> is guaranteed to receive the next <a>putMVar</a>.
--   
--   <a>readMVar</a> is multiple-wakeup, so when multiple readers are
--   blocked on an <a>MVar</a>, all of them are woken up at the same time.
--   
--   <i>Compatibility note:</i> Prior to base 4.7, <a>readMVar</a> was a
--   combination of <a>takeMVar</a> and <a>putMVar</a>. This mean that in
--   the presence of other threads attempting to <a>putMVar</a>,
--   <a>readMVar</a> could block. Furthermore, <a>readMVar</a> would not
--   receive the next <a>putMVar</a> if there was already a pending thread
--   blocked on <a>takeMVar</a>. The old behavior can be recovered by
--   implementing 'readMVar as follows:
--   
--   <pre>
--   readMVar :: MVar a -&gt; IO a
--   readMVar m =
--     mask_ $ do
--       a &lt;- takeMVar m
--       putMVar m a
--       return a
--   </pre>
readMVar :: () => MVar a -> IO a

-- | Return the contents of the <a>MVar</a>. If the <a>MVar</a> is
--   currently empty, <a>takeMVar</a> will wait until it is full. After a
--   <a>takeMVar</a>, the <a>MVar</a> is left empty.
--   
--   There are two further important properties of <a>takeMVar</a>:
--   
--   <ul>
--   <li><a>takeMVar</a> is single-wakeup. That is, if there are multiple
--   threads blocked in <a>takeMVar</a>, and the <a>MVar</a> becomes full,
--   only one thread will be woken up. The runtime guarantees that the
--   woken thread completes its <a>takeMVar</a> operation.</li>
--   <li>When multiple threads are blocked on an <a>MVar</a>, they are
--   woken up in FIFO order. This is useful for providing fairness
--   properties of abstractions built using <a>MVar</a>s.</li>
--   </ul>
takeMVar :: () => MVar a -> IO a

-- | Create an <a>MVar</a> which contains the supplied value.
newMVar :: () => a -> IO MVar a

-- | Create an <a>MVar</a> which is initially empty.
newEmptyMVar :: () => IO MVar a

-- | An <a>MVar</a> (pronounced "em-var") is a synchronising variable, used
--   for communication between concurrent threads. It can be thought of as
--   a a box, which may be empty or full.
data MVar a

-- | Lift a ternary function to actions.
liftA3 :: Applicative f => a -> b -> c -> d -> f a -> f b -> f c -> f d

-- | Lift a function to actions. This function may be used as a value for
--   <a>fmap</a> in a <a>Functor</a> instance.
liftA :: Applicative f => a -> b -> f a -> f b

-- | A variant of <a>&lt;*&gt;</a> with the arguments reversed.
(<**>) :: Applicative f => f a -> f a -> b -> f b
infixl 4 <**>

-- | A monoid on applicative functors.
--   
--   If defined, <a>some</a> and <a>many</a> should be the least solutions
--   of the equations:
--   
--   <ul>
--   <li><pre><a>some</a> v = (:) <tt>&lt;$&gt;</tt> v <a>&lt;*&gt;</a>
--   <a>many</a> v</pre></li>
--   <li><pre><a>many</a> v = <a>some</a> v <a>&lt;|&gt;</a> <a>pure</a>
--   []</pre></li>
--   </ul>
class Applicative f => Alternative (f :: * -> *)

-- | The identity of <a>&lt;|&gt;</a>
empty :: Alternative f => f a

-- | An associative binary operation
(<|>) :: Alternative f => f a -> f a -> f a

-- | One or more.
some :: Alternative f => f a -> f [a]

-- | Zero or more.
many :: Alternative f => f a -> f [a]

-- | An Event is a value that occurs during the period given by the first
--   <tt>Arc</tt>. The second one indicates the event's "domain of
--   influence". These will often be the same, but many temporal
--   transformations, such as rotation and scaling time, may result in arcs
--   being split or truncated. In such cases, the first arc is preserved,
--   but the second arc reflects the portion of the event which is
--   relevant.
type Event a = (Arc, Arc, a)

-- | <tt>(s,e) :: Arc</tt> represents a time interval with a start and end
--   value. <tt> { t : s &lt;= t &amp;&amp; t &lt; e } </tt>
type Arc = (Time, Time)

-- | Time is represented by a rational number. Each natural number
--   represents both the start of the next rhythmic cycle, and the end of
--   the previous one. Rational numbers are used so that subdivisions of
--   each cycle can be accurately represented.
type Time = Rational

-- | The starting point of the current cycle. A cycle occurs from each
--   natural number to the next, so this is equivalent to <tt>floor</tt>.
sam :: Time -> Time

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

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

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

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

-- | <tt>subArc i j</tt> is the arc that is the intersection of <tt>i</tt>
--   and <tt>j</tt>.
subArc :: Arc -> Arc -> Maybe Arc

-- | Map the given function over both the start and end <tt>Time</tt>
--   values of the given <tt>Arc</tt>.
mapArc :: (Time -> Time) -> Arc -> Arc

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

-- | Returns the `mirror image' of an <tt>Arc</tt> around the given point
--   intime, used by <tt>Sound.Tidal.Pattern.rev</tt>.
mirrorArc :: Time -> Arc -> Arc

-- | The start time of the given <tt>Event</tt>
eventStart :: Event a -> Time

-- | The original onset of the given <tt>Event</tt>
eventOnset :: Event a -> Time

-- | The original offset of the given <tt>Event</tt>
eventOffset :: Event a -> Time

-- | The arc of the given <tt>Event</tt>
eventArc :: Event a -> Arc

-- | The midpoint of an <tt>Arc</tt>
midPoint :: Arc -> Time

-- | <a>True</a> if an <a>Event</a>'s first and second <a>Arc</a>'s start
--   times match
hasOnset :: Event a -> Bool

-- | <a>True</a> if an <a>Event</a>'s first and second <a>Arc</a>'s end
--   times match
hasOffset :: Event a -> Bool

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

-- | <a>True</a> if an <a>Event</a>'s ends is within given <a>Arc</a>
offsetIn :: Arc -> Event a -> Bool
data TConnection
TConnection :: Unique -> Connection -> TConnection
data ServerMode
Master :: ServerMode
Slave :: UDP -> ServerMode
type ClientState = [TConnection]
data Tempo
Tempo :: UTCTime -> Double -> Double -> Bool -> Double -> Tempo
[at] :: Tempo -> UTCTime
[beat] :: Tempo -> Double
[cps] :: Tempo -> Double
[paused] :: Tempo -> Bool
[clockLatency] :: Tempo -> Double
wsConn :: TConnection -> Connection
getLatency :: IO Double
getClockIp :: IO String
getServerPort :: IO Int
getMasterPort :: IO Int
getSlavePort :: IO Int
readTempo :: String -> Tempo
logicalTime :: Tempo -> Double -> Double
beatNow :: Tempo -> IO (Double)
getCurrentBeat :: MVar Tempo -> IO Rational
clientApp :: MVar Tempo -> MVar Double -> MVar Double -> ClientApp ()
sendTempo :: [Connection] -> Tempo -> IO ()
sendCps :: Connection -> MVar Double -> IO ()
sendNudge :: Connection -> MVar Double -> IO ()
connectClient :: Bool -> String -> MVar Tempo -> MVar Double -> MVar Double -> IO ()
runClient :: IO ((MVar Tempo, MVar Double, MVar Double))
cpsUtils' :: IO ((Double -> IO (), (Double -> IO ()), IO Rational))
cpsUtils :: IO (Double -> IO (), IO Rational)
bpsUtils :: IO ((Double -> IO (), IO (Rational)))
cpsSetter :: IO (Double -> IO ())
clocked :: (Tempo -> Int -> IO ()) -> IO ()
clockedTick :: Int -> (Tempo -> Int -> IO ()) -> IO ()
updateTempo :: Tempo -> Double -> IO (Tempo)
nudgeTempo :: Tempo -> Double -> Tempo
removeClient :: TConnection -> ClientState -> ClientState
broadcast :: Text -> ClientState -> IO ()
startServer :: IO (ThreadId)
serverApp :: MVar Tempo -> MVar ServerMode -> MVar ClientState -> ServerApp
slave :: MVar ServerMode -> MVar ClientState -> IO ()
slaveAct :: String -> MVar ServerMode -> MVar ClientState -> Message -> IO ()
setSlave :: MVar ServerMode -> IO ()
serverLoop :: TConnection -> MVar Tempo -> MVar ServerMode -> MVar ClientState -> IO ()
serverAct :: String -> ServerMode -> MVar Tempo -> MVar ClientState -> IO ()
setCps :: Double -> ServerMode -> MVar Tempo -> MVar ClientState -> IO ()
setNudge :: Double -> ServerMode -> MVar Tempo -> MVar ClientState -> IO ()

-- | The pattern datatype, a function from a time <tt>Arc</tt> to
--   <tt>Event</tt> values. For discrete patterns, this returns the events
--   which are active during that time. For continuous patterns, events
--   with values for the midpoint of the given <tt>Arc</tt> is returned.
newtype Pattern a
Pattern :: Arc -> [Event a] -> Pattern a
[arc] :: Pattern a -> Arc -> [Event a]
noOv :: String -> a

-- | converts a ratio into human readable string, e.g. <tt>1/3</tt>
showTime :: (Show a, Integral a) => Ratio a -> String

-- | converts a time arc into human readable string, e.g. <tt>1<i>3
--   3</i>4</tt>
showArc :: Arc -> String

-- | converts an event into human readable string, e.g. <tt>("bd" 1<i>4
--   2</i>3)</tt>
showEvent :: (Show a) => Event a -> String
unwrap :: Pattern (Pattern a) -> Pattern a

-- | <tt>atom</tt> is a synonym for <tt>pure</tt>.
atom :: a -> Pattern a

-- | <tt>silence</tt> returns a pattern with no events.
silence :: Pattern a

-- | <tt>withQueryArc f p</tt> returns a new <tt>Pattern</tt> with function
--   <tt>f</tt> applied to the <tt>Arc</tt> values passed to the original
--   <tt>Pattern</tt> <tt>p</tt>.
withQueryArc :: (Arc -> Arc) -> Pattern a -> Pattern a

-- | <tt>withQueryTime f p</tt> returns a new <tt>Pattern</tt> with
--   function <tt>f</tt> applied to the both the start and end
--   <tt>Time</tt> of the <tt>Arc</tt> passed to <tt>Pattern</tt>
--   <tt>p</tt>.
withQueryTime :: (Time -> Time) -> Pattern a -> Pattern a

-- | <tt>withResultArc f p</tt> returns a new <tt>Pattern</tt> with
--   function <tt>f</tt> applied to the <tt>Arc</tt> values in the events
--   returned from the original <tt>Pattern</tt> <tt>p</tt>.
withResultArc :: (Arc -> Arc) -> Pattern a -> Pattern a

-- | <tt>withResultTime f p</tt> returns a new <tt>Pattern</tt> with
--   function <tt>f</tt> applied to the both the start and end
--   <tt>Time</tt> of the <tt>Arc</tt> values in the events returned from
--   the original <tt>Pattern</tt> <tt>p</tt>.
withResultTime :: (Time -> Time) -> Pattern a -> Pattern a

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

-- | <tt>timedValues p</tt> returns a new <tt>Pattern</tt> where values are
--   turned into tuples of <tt>Arc</tt> and value.
timedValues :: Pattern a -> Pattern (Arc, a)

-- | <tt>overlay</tt> combines two <tt>Pattern</tt>s into a new pattern, so
--   that their events are combined over time. This is the same as the
--   infix operator <a>&lt;&gt;</a>.
overlay :: Pattern a -> Pattern a -> Pattern a

-- | <tt>stack</tt> combines a list of <tt>Pattern</tt>s into a new
--   pattern, so that their events are combined over time.
stack :: [Pattern a] -> Pattern a

-- | <tt>append</tt> combines two patterns <tt>Pattern</tt>s into a new
--   pattern, so that the events of the second pattern are appended to
--   those of the first pattern, within a single cycle
append :: Pattern a -> Pattern a -> Pattern a

-- | <tt>append'</tt> does the same as <tt>append</tt>, but over two
--   cycles, so that the cycles alternate between the two patterns.
append' :: Pattern a -> Pattern a -> Pattern a

-- | <tt>fastcat</tt> returns a new pattern which interlaces the cycles of
--   the given patterns, within a single cycle. It's the equivalent of
--   <tt>append</tt>, but with a list of patterns.
fastcat :: [Pattern a] -> Pattern a
splitAtSam :: Pattern a -> Pattern a

-- | <tt>slowcat</tt> does the same as <tt>fastcat</tt>, but maintaining
--   the duration of the original patterns. It is the equivalent of
--   <tt>append'</tt>, but with a list of patterns.
slowcat :: [Pattern a] -> Pattern a

-- | <tt>cat</tt> is an alias of <tt>slowcat</tt>
cat :: [Pattern a] -> Pattern a

-- | <tt>listToPat</tt> turns the given list of values to a Pattern, which
--   cycles through the list.
listToPat :: [a] -> Pattern a
patToList :: Pattern a -> [a]

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

-- | <tt>run</tt> <tt>n</tt> returns a pattern representing a cycle of
--   numbers from <tt>0</tt> to <tt>n-1</tt>.
run :: (Enum a, Num a) => Pattern a -> Pattern a
_run :: (Enum a, Num a) => a -> Pattern a
scan :: (Enum a, Num a) => Pattern a -> Pattern a
_scan :: (Enum a, Num a) => a -> Pattern a
temporalParam :: (a -> Pattern b -> Pattern c) -> (Pattern a -> Pattern b -> Pattern c)
temporalParam2 :: (a -> b -> Pattern c -> Pattern d) -> (Pattern a -> Pattern b -> Pattern c -> Pattern d)
temporalParam3 :: (a -> b -> c -> Pattern d -> Pattern e) -> (Pattern a -> Pattern b -> Pattern c -> Pattern d -> Pattern e)
temporalParam' :: (a -> Pattern b -> Pattern c) -> (Pattern a -> Pattern b -> Pattern c)
temporalParam2' :: (a -> b -> Pattern c -> Pattern d) -> (Pattern a -> Pattern b -> Pattern c -> Pattern d)
temporalParam3' :: (a -> b -> c -> Pattern d -> Pattern e) -> (Pattern a -> Pattern b -> Pattern c -> Pattern d -> Pattern e)

-- | <tt>fast</tt> (also known as <tt>density</tt>) returns the given
--   pattern with speed (or density) increased by the given <tt>Time</tt>
--   factor. Therefore <tt>fast 2 p</tt> will return a pattern that is
--   twice as fast, and <tt>fast (1/3) p</tt> will return one three times
--   as slow.
fast :: Pattern Time -> Pattern a -> Pattern a
_fast :: Time -> Pattern a -> Pattern a
fast' :: Pattern Time -> Pattern a -> Pattern a

-- | <tt>density</tt> is an alias of <tt>fast</tt>. <tt>fast</tt> is
--   quicker to type, but <tt>density</tt> is its old name so is used in a
--   lot of examples.
density :: Pattern Time -> Pattern a -> Pattern a
_density :: Time -> Pattern a -> Pattern a

-- | <tt>fastGap</tt> (also known as <tt>densityGap</tt> is similar to
--   <tt>fast</tt> 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).
fastGap :: Time -> Pattern a -> Pattern a
densityGap :: Time -> Pattern a -> Pattern a

-- | <tt>slow</tt> does the opposite of <tt>fast</tt>, i.e. <tt>slow 2
--   p</tt> will return a pattern that is half the speed.
slow :: Pattern Time -> Pattern a -> Pattern a
sparsity :: Pattern Time -> Pattern a -> Pattern a
slow' :: Pattern Time -> Pattern a -> Pattern a
_slow :: Time -> Pattern a -> Pattern a

-- | The <tt>&lt;~</tt> operator shifts (or rotates) a pattern to the left
--   (or counter-clockwise) by the given <tt>Time</tt> value. For example
--   <tt>(1%16) &lt;~ p</tt> will return a pattern with all the events
--   moved one 16th of a cycle to the left.
rotL :: Time -> Pattern a -> Pattern a
(<~) :: Pattern Time -> Pattern a -> Pattern a

-- | The <tt>~&gt;</tt> operator does the same as <tt>&lt;~</tt> but shifts
--   events to the right (or clockwise) rather than to the left.
rotR :: Time -> Pattern a -> Pattern a
(~>) :: Pattern Time -> Pattern a -> Pattern a

-- | (The above means that <a>brak</a> is a function from patterns of any
--   type, to a pattern of the same type.)
--   
--   Make a pattern sound a bit like a breakbeat
--   
--   Example:
--   
--   <pre>
--   d1 $ sound (brak "bd sn kurt")
--   </pre>
brak :: Pattern a -> Pattern a

-- | Divides a pattern into a given number of subdivisions, plays the
--   subdivisions in order, but increments the starting subdivision each
--   cycle. The pattern wraps to the first subdivision after the last
--   subdivision is played.
--   
--   Example:
--   
--   <pre>
--   d1 $ iter 4 $ sound "bd hh sn cp"
--   </pre>
--   
--   This will produce the following over four cycles:
--   
--   <pre>
--   bd hh sn cp
--   hh sn cp bd
--   sn cp bd hh
--   cp bd hh sn
--   </pre>
--   
--   There is also <a>iter'</a>, which shifts the pattern in the opposite
--   direction.
iter :: Pattern Int -> Pattern c -> Pattern c
_iter :: Int -> Pattern a -> Pattern a

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

-- | <tt>rev p</tt> returns <tt>p</tt> with the event positions in each
--   cycle reversed (or mirrored).
rev :: 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

-- | 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
whenT :: (Time -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
playWhen :: (Time -> Bool) -> Pattern a -> Pattern a
playFor :: Time -> Time -> Pattern a -> Pattern a

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

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

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

-- | <tt>sinewave</tt> returns a <tt>Pattern</tt> of continuous
--   <tt>Fractional</tt> values following a sinewave with frequency of one
--   cycle, and amplitude from 0 to 1.
sinewave :: Fractional a => Pattern a

-- | <tt>sine</tt> is a synonym for <tt>sinewave</tt>.
sine :: Fractional a => Pattern a

-- | <tt>sine</tt> is a synonym for <tt>0.25 ~&gt; sine</tt>.
cosine :: Fractional a => Pattern a

-- | <tt>sineAmp d</tt> returns <tt>sinewave</tt> with its amplitude offset
--   by <tt>d</tt>. Deprecated, as these days you can simply do e.g. (sine
--   + 0.5)
sineAmp :: Fractional a => a -> Pattern a

-- | <tt>sawwave</tt> is the equivalent of <tt>sinewave</tt> for
--   (ascending) sawtooth waves.
sawwave :: (Fractional a, Real a) => Pattern a

-- | <tt>saw</tt> is a synonym for <tt>sawwave</tt>.
saw :: (Fractional a, Real a) => Pattern a

-- | <tt>triwave</tt> is the equivalent of <tt>sinewave</tt> for triangular
--   waves.
triwave :: (Fractional a, Real a) => Pattern a

-- | <tt>tri</tt> is a synonym for <tt>triwave</tt>.
tri :: (Fractional a, Real a) => Pattern a

-- | <tt>squarewave1</tt> is the equivalent of <tt>sinewave</tt> for square
--   waves.
squarewave :: (Fractional a, Real a) => Pattern a

-- | <tt>square</tt> is a synonym for <tt>squarewave</tt>.
square :: (Fractional a, Real a) => Pattern a
sinewave1 :: Fractional a => Pattern a
sine1 :: Fractional a => Pattern a
sinerat :: Pattern Double
ratsine :: Pattern Double
sinerat1 :: Pattern Double
sineAmp1 :: Fractional a => a -> Pattern a
sawwave1 :: (Fractional a, Real a) => Pattern a
saw1 :: (Fractional a, Real a) => Pattern a
sawrat :: Pattern Double
sawrat1 :: Pattern Double
triwave1 :: (Fractional a, Real a) => Pattern a
tri1 :: (Fractional a, Real a) => Pattern a
trirat :: Pattern Double
trirat1 :: Pattern Double
squarewave1 :: (Fractional a, Real a) => Pattern a
square1 :: (Fractional a, Real a) => Pattern a

-- | <tt>envL</tt> is a <tt>Pattern</tt> of continuous <tt>Double</tt>
--   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
envLR :: Pattern Double
envEq :: Pattern Double
envEqR :: Pattern Double
fadeOut :: Time -> Pattern a -> Pattern a
fadeOut' :: Time -> Time -> Pattern a -> Pattern a
fadeIn' :: Time -> Time -> Pattern a -> Pattern a
fadeIn :: Time -> Pattern a -> Pattern a

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

-- | <tt>fastspread</tt> works the same as <tt>spread</tt>, but the result
--   is squashed into a single cycle. If you gave four values to
--   <tt>spread</tt>, then the result would seem to speed up by a factor of
--   four. Compare these two:
--   
--   d1 $ spread chop [4,64,32,16] $ sound "ho ho:2 ho:3 hc"
--   
--   d1 $ fastspread chop [4,64,32,16] $ sound "ho ho:2 ho:3 hc"
--   
--   There is also <tt>slowspread</tt>, which is an alias of
--   <tt>spread</tt>.
fastspread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b

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

-- | `spreadChoose f xs p` is similar to <a>slowspread</a> but picks values
--   from <tt>xs</tt> at random, rather than cycling through them in order.
--   It has a shorter alias <a>spreadr</a>.
spreadChoose :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b
spreadr :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b
filterValues :: (a -> Bool) -> Pattern a -> Pattern a
filterJust :: Pattern (Maybe a) -> Pattern a
filterOnsets :: Pattern a -> Pattern a
filterStartInRange :: Pattern a -> Pattern a
filterOnsetsInRange :: Pattern a -> Pattern a
seqToRelOnsetDeltas :: Arc -> Pattern a -> [(Double, Double, a)]
segment :: Pattern a -> Pattern [a]
segment' :: [Event a] -> [Event a]
split :: Time -> [Event a] -> [Event a]
points :: [Event a] -> [Time]
groupByTime :: [Event a] -> [Event [a]]

-- | Decide whether to apply one or another function depending on the
--   result of a test function that is passed the current cycle as a
--   number.
--   
--   <pre>
--   d1 $ ifp ((== 0).(flip mod 2))
--     (striate 4)
--     (# coarse "24 48") $
--     sound "hh hc"
--   </pre>
--   
--   This will apply `striate 4` for every _even_ cycle and aply `# coarse
--   "24 48"` for every _odd_.
--   
--   Detail: As you can see the test function is arbitrary and does not
--   rely on anything tidal specific. In fact it uses only plain haskell
--   functionality, that is: it calculates the modulo of 2 of the current
--   cycle which is either 0 (for even cycles) or 1. It then compares this
--   value against 0 and returns the result, which is either <a>True</a> or
--   <a>False</a>. This is what the <a>ifp</a> signature's first part
--   signifies `(Int -&gt; Bool)`, a function that takes a whole number and
--   returns either <a>True</a> or <a>False</a>.
ifp :: (Int -> Bool) -> (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <a>rand</a> generates a continuous pattern of (pseudo-)random,
--   floating point numbers between `0` and `1`.
--   
--   <pre>
--   d1 $ sound "bd*8" # pan rand
--   </pre>
--   
--   pans bass drums randomly
--   
--   <pre>
--   d1 $ sound "sn sn ~ sn" # gain rand
--   </pre>
--   
--   makes the snares' randomly loud and quiet.
--   
--   Numbers coming from this pattern are random, but dependent on time. So
--   if you reset time via `cps (-1)` 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>
--   d1 $ jux (|+| gain rand) $ sound "sn sn ~ sn" # gain rand
--   </pre>
--   
--   and with the juxed version shifted backwards for 1024 cycles:
--   
--   <pre>
--   d1 $ jux (|+| ((1024 &lt;~) $ gain rand)) $ sound "sn sn ~ sn" # gain rand
--   </pre>
rand :: Pattern Double
timeToRand :: RealFrac r => r -> Double

-- | Just like <a>rand</a> but for whole numbers, `irand n` generates a
--   pattern of (pseudo-) random whole numbers between `0` to `n-1`
--   inclusive. Notably used to pick a random samples from a folder:
--   
--   <pre>
--   d1 $ n (irand 5) # sound "drum"
--   </pre>
irand :: Num a => Int -> Pattern a

-- | Randomly picks an element from the given list
--   
--   <pre>
--   d1 $ sound (samples "xx(3,8)" (tom $ choose ["a", "e", "g", "c"]))
--   </pre>
--   
--   plays a melody randomly choosing one of the four notes "a", "e", "g",
--   "c".
choose :: [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>
degradeBy :: Pattern Double -> Pattern a -> Pattern a
_degradeBy :: Double -> Pattern a -> Pattern a
unDegradeBy :: Pattern Double -> Pattern a -> Pattern a
_unDegradeBy :: Double -> Pattern a -> Pattern a
degradeOverBy :: Int -> Pattern Double -> Pattern a -> Pattern a

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

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

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

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

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

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

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

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

-- | <tt>wedge t p p'</tt> combines patterns <tt>p</tt> and <tt>p'</tt> by
--   squashing the <tt>p</tt> into the portion of each cycle given by
--   <tt>t</tt>, and <tt>p'</tt> into the remainer of each cycle.
wedge :: Time -> Pattern a -> Pattern a -> Pattern a
timeCat :: [(Time, 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 :: Int -> Int -> (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>splitQueries p</tt> wraps <tt>p</tt> to ensure that it does not
--   get queries that span arcs. For example `arc 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

-- | <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>
linger :: Pattern Time -> Pattern a -> Pattern a
_linger :: Time -> Pattern a -> Pattern a

-- | Plays a portion of a pattern, specified by a beginning and end arc of
--   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 :: Arc -> Pattern a -> Pattern a
compress :: Arc -> Pattern a -> Pattern a
sliceArc :: Arc -> 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 :: 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' :: Arc -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
revArc :: Arc -> Pattern a -> Pattern a

-- | You can use the <tt>e</tt> function to apply a Euclidean algorithm
--   over a complex pattern, although the structure of that pattern will be
--   lost:
--   
--   <pre>
--   d1 $ e 3 8 $ sound "bd*2 [sn cp]"
--   </pre>
--   
--   In the above, three sounds are picked from the pattern on the right
--   according to the structure given by the `e 3 8`. It ends up picking
--   two <tt>bd</tt> sounds, a <tt>cp</tt> and missing the <tt>sn</tt>
--   entirely.
--   
--   These types of sequences use "Bjorklund's algorithm", which wasn't
--   made for music but for an application in nuclear physics, which is
--   exciting. More exciting still is that it is very similar in structure
--   to the one of the first known algorithms written in Euclid's book of
--   elements in 300 BC. You can read more about this in the paper [The
--   Euclidean Algorithm Generates Traditional Musical
--   Rhythms](http:/<i>cgm.cs.mcgill.ca</i>~godfried<i>publications</i>banff.pdf)
--   by Toussaint. Some examples from this paper are included below,
--   including rotation in some cases.
--   
--   <pre>
--   - (2,5) : A thirteenth century Persian rhythm called Khafif-e-ramal.
--   - (3,4) : The archetypal pattern of the Cumbia from Colombia, as well as a Calypso rhythm from Trinidad.
--   - (3,5,2) : Another thirteenth century Persian rhythm by the name of Khafif-e-ramal, as well as a Rumanian folk-dance rhythm.
--   - (3,7) : A Ruchenitza rhythm used in a Bulgarian folk-dance.
--   - (3,8) : The Cuban tresillo pattern.
--   - (4,7) : Another Ruchenitza Bulgarian folk-dance rhythm.
--   - (4,9) : The Aksak rhythm of Turkey.
--   - (4,11) : The metric pattern used by Frank Zappa in his piece titled Outside Now.
--   - (5,6) : Yields the York-Samai pattern, a popular Arab rhythm.
--   - (5,7) : The Nawakhat pattern, another popular Arab rhythm.
--   - (5,8) : The Cuban cinquillo pattern.
--   - (5,9) : A popular Arab rhythm called Agsag-Samai.
--   - (5,11) : The metric pattern used by Moussorgsky in Pictures at an Exhibition.
--   - (5,12) : The Venda clapping pattern of a South African children’s song.
--   - (5,16) : The Bossa-Nova rhythm necklace of Brazil.
--   - (7,8) : A typical rhythm played on the Bendir (frame drum).
--   - (7,12) : A common West African bell pattern.
--   - (7,16,14) : A Samba rhythm necklace from Brazil.
--   - (9,16) : A rhythm necklace used in the Central African Republic.
--   - (11,24,14) : A rhythm necklace of the Aka Pygmies of Central Africa.
--   - (13,24,5) : Another rhythm necklace of the Aka Pygmies of the upper Sangha.
--   </pre>
e :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_e :: Int -> Int -> Pattern a -> Pattern a
e' :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_e' :: Int -> Int -> Pattern a -> Pattern a
distrib :: [Pattern Int] -> Pattern a -> Pattern a
_distrib :: [Int] -> Pattern a -> Pattern a

-- | <a>einv</a> fills in the blanks left by <a>e</a> - <tt>e 3 8 "x"</tt>
--   -&gt; <tt>"x ~ ~ x ~ ~ x ~"</tt>
--   
--   <tt>einv 3 8 "x"</tt> -&gt; <tt>"~ x x ~ x x ~ x"</tt>
einv :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_einv :: Int -> Int -> Pattern a -> Pattern a

-- | `efull n k pa pb` stacks <tt>e n k pa</tt> with <tt>einv n k pb</tt>
efull :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a -> Pattern a
index :: Real b => b -> Pattern b -> Pattern c -> Pattern c

-- | <tt>prrw f rot (blen, vlen) beatPattern valuePattern</tt>: pattern
--   rotate/replace.
prrw :: (a -> b -> c) -> Int -> (Time, Time) -> Pattern a -> Pattern b -> Pattern c

-- | <tt>prr rot (blen, vlen) beatPattern valuePattern</tt>: pattern
--   rotate/replace.
prr :: Int -> (Time, Time) -> Pattern String -> Pattern b -> Pattern b

-- | <tt>preplace (blen, plen) beats values</tt> combines the timing of
--   <tt>beats</tt> with the values of <tt>values</tt>. Other ways of
--   saying this are: * sequential convolution * <tt>values</tt> quantized
--   to <tt>beats</tt>.
--   
--   Examples:
--   
--   <pre>
--   d1 $ sound $ preplace (1,1) "x [~ x] x x" "bd sn"
--   d1 $ sound $ preplace (1,1) "x(3,8)" "bd sn"
--   d1 $ sound $ "x(3,8)" <a>~</a> "bd sn"
--   d1 $ sound "[jvbass jvbass:5]*3" |+| (shape $ "1 1 1 1 1" <a>~</a> "0.2 0.9")
--   </pre>
--   
--   It is assumed the pattern fits into a single cycle. This works well
--   with pattern literals, but not always with patterns defined elsewhere.
--   In those cases use <tt>preplace</tt> and provide desired pattern
--   lengths: @ let p = slow 2 $ "x x x"
--   
--   d1 $ sound $ preplace (2,1) p "bd sn" @
preplace :: (Time, Time) -> Pattern String -> Pattern b -> Pattern b

-- | <tt>prep</tt> is an alias for preplace.
prep :: (Time, Time) -> Pattern String -> Pattern b -> Pattern b
preplace1 :: Pattern String -> Pattern b -> Pattern b
preplaceWith :: (a -> b -> c) -> (Time, Time) -> Pattern a -> Pattern b -> Pattern c
prw :: (a -> b -> c) -> (Time, Time) -> Pattern a -> Pattern b -> Pattern c
preplaceWith1 :: (a -> b -> c) -> Pattern a -> Pattern b -> Pattern c
prw1 :: (a -> b -> c) -> Pattern a -> Pattern b -> Pattern c
(<~>) :: Pattern String -> Pattern b -> Pattern b

-- | <tt>protate len rot p</tt> rotates pattern <tt>p</tt> by <tt>rot</tt>
--   beats to the left. <tt>len</tt>: length of the pattern, in cycles.
--   Example: <tt>d1 $ every 4 (protate 2 (-1)) $ slow 2 $ sound "bd hh hh
--   hh"</tt>
protate :: Time -> Int -> Pattern a -> Pattern a
prot :: Time -> Int -> Pattern a -> Pattern a
prot1 :: Int -> Pattern a -> Pattern a

-- | The <tt>&lt;&lt;~</tt> operator rotates a unit pattern to the left,
--   similar to <tt>&lt;~</tt>, but by events rather than linear time. The
--   timing of the pattern remains constant:
--   
--   <pre>
--   d1 $ (1 &lt;&lt;~) $ sound "bd ~ sn hh"
--   -- will become
--   d1 $ sound "sn ~ hh bd"
--   </pre>
(<<~) :: Int -> Pattern a -> Pattern a

-- | <tt>~&gt;&gt;</tt> is like <tt>&lt;&lt;~</tt> but for shifting to the
--   right.
(~>>) :: Int -> Pattern a -> Pattern a

-- | <tt>pequal cycles p1 p2</tt>: quickly test if <tt>p1</tt> and
--   <tt>p2</tt> are the same.
pequal :: Ord a => Time -> Pattern a -> Pattern a -> Bool

-- | <tt>discretise n p</tt>: <tt>samples</tt> 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.
discretise :: Time -> Pattern a -> Pattern a
discretise' :: Pattern Time -> Pattern a -> Pattern a
_discretise :: Time -> Pattern a -> Pattern a

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

-- | The <a>fit</a> function takes a pattern of integer numbers, which are
--   used to select values from the given list. What makes this a bit
--   strange is that only a given number of values are selected each cycle.
--   For example:
--   
--   <pre>
--   d1 $ sound (fit 3 ["bd", "sn", "arpy", "arpy:1", "casio"] "0 [~ 1] 2 1")
--   </pre>
--   
--   The above fits three samples into the pattern, i.e. for the first
--   cycle this will be `"bd"`, `"sn"` and `"arpy"`, giving the result `"bd
--   [~ sn] arpy sn"` (note that we start counting at zero, so that `0`
--   picks the first value). The following cycle the *next* three values in
--   the list will be picked, i.e. `"arpy:1"`, `"casio"` and `"bd"`, giving
--   the pattern `"arpy:1 [~ casio] bd casio"` (note that the list wraps
--   round here).
fit :: Int -> [a] -> Pattern Int -> Pattern a
permstep :: RealFrac b => Int -> [a] -> Pattern b -> Pattern a

-- | <tt>struct a b</tt>: structures pattern <tt>b</tt> in terms of
--   <tt>a</tt>.
struct :: Pattern String -> 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 String -> Pattern b -> Pattern b
compressTo :: Arc -> Pattern a -> Pattern a
randArcs :: Int -> Pattern [Arc]
randStruct :: Int -> Pattern Int
substruct' :: Pattern Int -> Pattern a -> Pattern a

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

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

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

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

-- | 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" :: Pattern Bool)
--     (slowcat ["can*8", "[cp*4 sn*4, jvbass*16]"] ))
--     # n (run 8)
--   </pre>
--   
--   Detail: It is currently needed to explicitly _tell_ Tidal that the
--   mask itself is a `Pattern Bool` as it cannot infer this by itself,
--   otherwise it will complain as it does not know how to interpret your
--   input.
mask :: Pattern a -> Pattern b -> Pattern b
enclosingArc :: [Arc] -> Arc
stretch :: Pattern a -> Pattern a

-- | <a>fit'</a> is a generalization of <a>fit</a>, where the list is
--   instead constructed by using another integer pattern to slice up a
--   given pattern. The first argument is the number of cycles of that
--   latter pattern to use when slicing. It's easier to understand this
--   with a few examples:
--   
--   <pre>
--   d1 $ sound (fit' 1 2 "0 1" "1 0" "bd sn")
--   </pre>
--   
--   So what does this do? The first `1` just tells it to slice up a single
--   cycle of `"bd sn"`. The `2` tells it to select two values each cycle,
--   just like the first argument to <a>fit</a>. The next pattern `"0 1"`
--   is the "from" pattern which tells it how to slice, which in this case
--   means `"0"` maps to `"bd"`, and `"1"` maps to `"sn"`. The next pattern
--   `"1 0"` is the "to" pattern, which tells it how to rearrange those
--   slices. So the final result is the pattern `"sn bd"`.
--   
--   A more useful example might be something like
--   
--   <pre>
--   d1 $ fit' 1 4 (run 4) "[0 3*2 2 1 0 3*2 2 [1*8 ~]]/2" $ chop 4 $ (sound "breaks152" # unit "c")
--   </pre>
--   
--   which uses <tt>chop</tt> to break a single sample into individual
--   pieces, which <a>fit'</a> then puts into a list (using the `run 4`
--   pattern) and reassembles according to the complicated integer pattern.
fit' :: Pattern Time -> Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a

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

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

-- | <tt>toScale</tt> lets you turn a pattern of notes within a scale
--   (expressed as a list) to note numbers. For example `toScale [0, 4, 7]
--   "0 1 2 3"` will turn into the pattern `"0 4 7 12"`. It assumes your
--   scale fits within an octave; to change this use <a>toScale</a> size`.
--   Example: <a>toScale</a> 24 [0,4,7,10,14,17] (run 8)` turns into `"0 4
--   7 10 14 17 24 28"`
toScale' :: Num a => Int -> [a] -> Pattern Int -> Pattern a
toScale :: Num a => [a] -> Pattern Int -> Pattern a

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

-- | <a>cycleChoose</a> is like <a>choose</a> but only picks a new item
--   from the list once each cycle
cycleChoose :: [a] -> Pattern a

-- | `shuffle n p` evenly divides one cycle of the pattern <tt>p</tt> into
--   <tt>n</tt> parts, and returns a random permutation of the parts each
--   cycle. For example, `shuffle 3 "a b c"` could return `"a b c"`, `"a c
--   b"`, `"b a c"`, `"b c a"`, `"c a b"`, or `"c b a"`. But it will
--   **never** return `"a a a"`, because that is not a permutation of the
--   parts.
shuffle :: Int -> Pattern a -> Pattern a

-- | `scramble n p` is like <a>shuffle</a> but randomly selects from the
--   parts of <tt>p</tt> instead of making permutations. For example,
--   `scramble 3 "a b c"` will randomly select 3 parts from `"a"` `"b"` and
--   `"c"`, possibly repeating a single part.
scramble :: Int -> Pattern a -> Pattern a
ur :: Time -> Pattern String -> [(String, Pattern a)] -> [(String, Pattern a -> Pattern a)] -> Pattern a
inhabit :: [(String, Pattern a)] -> Pattern String -> Pattern a
repeatCycles :: Int -> Pattern a -> Pattern a

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

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

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

-- | <tt>breakUp</tt> finds events that share the same timespan, and
--   spreads them out during that timespan, so for example <tt>breakUp
--   "[bd,sn]"</tt> gets turned into <tt>"bd sn"</tt>
breakUp :: Pattern a -> Pattern a

-- | <tt>fill</tt> 'fills in' gaps in one pattern with events from another.
--   For example <tt>fill "bd" "cp ~ cp"</tt> would result in the
--   equivalent of `"~ bd ~"`. This only finds gaps in a resulting pattern,
--   in other words <tt>"[bd ~, sn]"</tt> doesn't contain any gaps (because
--   <tt>sn</tt> covers it all), and <tt>"bd ~ ~ sn"</tt> only contains a
--   single gap that bridges two steps.
fill :: Pattern a -> Pattern a -> Pattern a
ply :: Pattern Int -> Pattern a -> Pattern a
_ply :: Int -> Pattern a -> Pattern a
sew :: Pattern Bool -> Pattern a -> Pattern a -> Pattern a
scaleP :: Num a => Pattern String -> Pattern Int -> Pattern a
data Sign
Positive :: Sign
Negative :: Sign
type ColourD = Colour Double
class Enumerable a
fromTo :: Enumerable a => a -> a -> Pattern a
fromThenTo :: Enumerable a => a -> a -> a -> Pattern a
class Parseable a
parseTPat :: Parseable a => String -> TPat a

-- | AST representation of patterns
data TPat a
TPat_Atom :: a -> TPat a
TPat_Density :: (TPat Time) -> (TPat a) -> TPat a
TPat_Slow :: (TPat Time) -> (TPat a) -> TPat a
TPat_Zoom :: Arc -> (TPat a) -> TPat a
TPat_DegradeBy :: Double -> (TPat a) -> TPat a
TPat_Silence :: TPat a
TPat_Foot :: TPat a
TPat_Elongate :: Int -> TPat a
TPat_EnumFromTo :: (TPat a) -> (TPat a) -> TPat a
TPat_Cat :: [TPat a] -> TPat a
TPat_TimeCat :: [TPat a] -> TPat a
TPat_Overlay :: (TPat a) -> (TPat a) -> TPat a
TPat_ShiftL :: Time -> (TPat a) -> TPat a
TPat_pE :: (TPat Int) -> (TPat Int) -> (TPat Integer) -> (TPat a) -> TPat a
toPat :: Enumerable a => TPat a -> Pattern a
durations :: [TPat a] -> [(Int, TPat a)]
p :: (Enumerable a, Parseable a) => String -> Pattern a
enumFromTo' :: (Ord a, Enum a) => a -> a -> Pattern a
enumFromThenTo' :: (Ord a, Enum a, Num a) => a -> a -> a -> Pattern a
lexer :: () => GenTokenParser String u Identity
braces :: Parser a -> Parser a
brackets :: Parser a -> Parser a
parens :: Parser a -> Parser a
angles :: Parser a -> Parser a
symbol :: String -> Parser String
natural :: Parser Integer
integer :: Parser Integer
float :: Parser Double
naturalOrFloat :: Parser (Either Integer Double)
applySign :: Num a => Sign -> a -> a
sign :: Parser Sign
intOrFloat :: Parser Double
r :: (Enumerable a, Parseable a) => String -> Pattern a -> IO (Pattern a)
parseRhythm :: Parseable a => Parser (TPat a) -> String -> TPat a
pSequenceN :: Parseable a => Parser (TPat a) -> GenParser Char () (Int, TPat a)
elongate :: () => [TPat a] -> TPat a
splitFeet :: [TPat t] -> [[TPat t]]
pSequence :: Parseable a => Parser (TPat a) -> GenParser Char () (TPat a)
pSingle :: Parseable a => Parser (TPat a) -> Parser (TPat a)
pPart :: Parseable a => Parser (TPat a) -> Parser [TPat a]
pPolyIn :: Parseable a => Parser (TPat a) -> Parser (TPat a)
pPolyOut :: Parseable a => Parser (TPat a) -> Parser (TPat a)
pString :: Parser (String)
pVocable :: Parser (TPat String)
pDouble :: Parser (TPat Double)
pBool :: Parser (TPat Bool)
parseIntNote :: Integral i => Parser i
parseInt :: Parser Int
pIntegral :: Parseable a => Integral a => Parser (TPat a)
parseNote :: Num a => Parser a
fromNote :: Num a => Pattern String -> Pattern a
pColour :: Parser (TPat ColourD)
pMult :: Parseable a => TPat a -> Parser (TPat a)
pRand :: Parseable a => TPat a -> Parser (TPat a)
pE :: Parseable a => TPat a -> Parser (TPat a)
eoff :: Pattern Int -> Pattern Int -> Pattern Integer -> Pattern a -> Pattern a
_eoff :: Int -> Int -> Integer -> Pattern a -> Pattern a
pReplicate :: Parseable a => TPat a -> Parser [TPat a]
pStretch :: Parseable a => TPat a -> Parser [TPat a]
pRatio :: Parser (Rational)
pRational :: Parser (TPat Rational)
type ParamPattern = Pattern ParamMap
type ParamMap = Map Param Value
class ParamType a
fromV :: ParamType a => Value -> Maybe a
toV :: ParamType a => a -> Value
data Value
VS :: String -> Value
[svalue] :: Value -> String
VF :: Double -> Value
[fvalue] :: Value -> Double
VI :: Int -> Value
[ivalue] :: Value -> Int
data Shape
Shape :: [Param] -> Double -> Bool -> Shape
[params] :: Shape -> [Param]
[latency] :: Shape -> Double
[cpsStamp] :: Shape -> Bool
data Param
S :: String -> Maybe String -> Param
[name] :: Param -> String
[sDefault] :: Param -> Maybe String
F :: String -> Maybe Double -> Param
[name] :: Param -> String
[fDefault] :: Param -> Maybe Double
I :: String -> Maybe Int -> Param
[name] :: Param -> String
[iDefault] :: Param -> Maybe Int
data Backend a
Backend :: ToMessageFunc -> Shape -> Tempo -> Int -> IO () -> Backend a
[toMessage] :: Backend a -> ToMessageFunc
[flush] :: Backend a -> Shape -> Tempo -> Int -> IO ()
type ToMessageFunc = Shape -> Tempo -> Int -> (Double, Double, ParamMap) -> Maybe (IO ())
ticksPerCycle :: Num p => p
defaultValue :: Param -> Value
hasDefault :: Param -> Bool
defaulted :: Shape -> [Param]
defaultMap :: Shape -> ParamMap
required :: Shape -> [Param]
hasRequired :: Shape -> ParamMap -> Bool
isSubset :: (Eq a) => [a] -> [a] -> Bool
doAt :: RealFrac a => a -> IO () -> IO ()
logicalOnset' :: Integral a => Tempo -> a -> Double -> Double -> Double
applyShape' :: Shape -> ParamMap -> Maybe ParamMap
start :: Backend a -> Shape -> IO (MVar (ParamPattern))
state :: Backend a -> Shape -> IO (MVar (ParamPattern, [ParamPattern]))
stream :: Backend a -> Shape -> IO (ParamPattern -> IO ())
streamcallback :: (ParamPattern -> IO ()) -> Backend a -> Shape -> IO (ParamPattern -> IO ())
onTick :: Backend a -> Shape -> MVar (ParamPattern) -> Tempo -> Int -> IO ()
onTick' :: Backend a -> Shape -> MVar (ParamPattern, [ParamPattern]) -> Tempo -> Int -> IO ()
make :: (a -> Value) -> Shape -> String -> Pattern a -> ParamPattern
make' :: ParamType a => (a -> Value) -> Param -> Pattern a -> ParamPattern
makeP :: ParamType a => Param -> Pattern a -> ParamPattern
makeS :: Shape -> String -> Pattern String -> ParamPattern
makeF :: Shape -> String -> Pattern Double -> ParamPattern
makeI :: Shape -> String -> Pattern Int -> ParamPattern
param :: Shape -> String -> Param
merge :: ParamPattern -> ParamPattern -> ParamPattern
(|=|) :: ParamPattern -> ParamPattern -> ParamPattern
infixl 1 |=|
(#) :: ParamPattern -> ParamPattern -> ParamPattern
infixl 1 #
mergeWith :: (Ord k, Applicative f) => (k -> a -> a -> a) -> f (Map k a) -> f (Map k a) -> f (Map k a)
mergeNumWith :: Applicative f => Int -> Int -> Int -> Double -> Double -> Double -> f Map Param Value -> f Map Param Value -> f Map Param Value
mergePlus :: Applicative f => f Map Param Value -> f Map Param Value -> f Map Param Value
(|*|) :: ParamPattern -> ParamPattern -> ParamPattern
infixl 1 |*|
(|+|) :: ParamPattern -> ParamPattern -> ParamPattern
infixl 1 |+|
(|-|) :: ParamPattern -> ParamPattern -> ParamPattern
infixl 1 |-|
(|/|) :: ParamPattern -> ParamPattern -> ParamPattern
infixl 1 |/|

-- | These are shorthand for merging lists of patterns with <tt>#</tt>,
--   <tt>|*|</tt>, <tt>|+|</tt>, or <tt>|/|</tt>. Sometimes this saves a
--   little typing and can improve readability when passing things into
--   other functions. As an example, instead of writing <tt> d1 $ sometimes
--   ((|*| speed "2") . (|*| cutoff "2") . (|*| shape "1.5")) $ sound
--   "arpy*4" shape "0.3" </tt> you can write <tt> d1 $ sometimes (***
--   [speed "2", cutoff "2", shape "1.5"]) $ sound "arpy*4" ### [cutoff
--   "350", shape "0.3"] </tt>
(###) :: Foldable t => ParamPattern -> t ParamPattern -> ParamPattern
(***) :: Foldable t => ParamPattern -> t ParamPattern -> ParamPattern
(+++) :: Foldable t => ParamPattern -> t ParamPattern -> ParamPattern
(///) :: Foldable t => ParamPattern -> t ParamPattern -> ParamPattern
setter :: MVar (a, [a]) -> a -> IO ()

-- | Copies values from one parameter to another. Used by <tt>nToOrbit</tt>
--   in <tt>Sound.Tidal.Dirt</tt>.
copyParam :: Param -> Param -> ParamPattern -> ParamPattern
get :: ParamType a => Param -> ParamPattern -> Pattern a
getI :: Param -> ParamPattern -> Pattern Int
getF :: Param -> ParamPattern -> Pattern Double
getS :: Param -> ParamPattern -> Pattern String
with :: (ParamType a) => Param -> (Pattern a -> Pattern a) -> ParamPattern -> ParamPattern
withI :: Param -> (Pattern Int -> Pattern Int) -> ParamPattern -> ParamPattern
withF :: Param -> (Pattern Double -> Pattern Double) -> ParamPattern -> ParamPattern
withS :: Param -> (Pattern String -> Pattern String) -> ParamPattern -> ParamPattern
follow :: (ParamType a, ParamType b) => Param -> Param -> (Pattern a -> Pattern b) -> ParamPattern -> ParamPattern
follow' :: ParamType a => Param -> Param -> (Pattern a -> Pattern a) -> ParamPattern -> ParamPattern
followI :: Param -> Param -> (Pattern Int -> Pattern Int) -> ParamPattern -> ParamPattern
followF :: Param -> Param -> (Pattern Double -> Pattern Double) -> ParamPattern -> ParamPattern
followS :: Param -> Param -> (Pattern String -> Pattern String) -> ParamPattern -> ParamPattern
coerce :: Param -> ParamPattern -> ParamPattern

-- | <tt>chord p</tt> turns a pattern of chord names into a pattern of
--   numbers, representing note value offsets for the chords
chord :: Num a => Pattern String -> Pattern a

-- | group multiple params into one
grp :: [Param] -> Pattern String -> ParamPattern

-- | A pattern of strings representing sounds or synth notes.
--   
--   Internally, <a>sound</a> or its shorter alias <a>s</a> is a
--   combination of the samplebank name and number when used with samples,
--   or synth name and note number when used with a synthesiser. For
--   example `bd:2` specifies the third sample (not the second as you might
--   expect, because we start counting at zero) in the <tt>bd</tt> sample
--   folder.
--   
--   <ul>
--   <li>Internally, <a>sound</a>/<a>s</a> is a combination of two
--   parameters, the hidden parameter <a>s'</a> which specifies the
--   samplebank or synth, and the <a>n</a> parameter which specifies the
--   sample or note number. For example:</li>
--   </ul>
--   
--   <pre>
--   d1 $ sound "bd:2 sn:0"
--   </pre>
--   
--   is essentially the same as:
--   
--   <pre>
--   d1 $ s' "bd sn" # n "2 0"
--   </pre>
--   
--   <a>n</a> is therefore useful when you want to pattern the sample or
--   note number separately from the samplebank or synth. For example:
--   
--   <pre>
--   d1 $ n "0 5 ~ 2" # sound "drum"
--   </pre>
--   
--   is equivalent to:
--   
--   <pre>
--   d1 $ sound "drum:0 drum:5 ~ drum:2"
--   </pre>
sound :: Pattern String -> ParamPattern
s :: Pattern String -> ParamPattern
pF :: String -> Maybe Double -> (Pattern Double -> ParamPattern, Param)
pI :: String -> Maybe Int -> (Pattern Int -> ParamPattern, Param)
pS :: String -> Maybe String -> (Pattern String -> ParamPattern, Param)

-- | a pattern of numbers that speed up (or slow down) samples while they
--   play.
accelerate :: Pattern Double -> ParamPattern
accelerate_p :: Param

-- | a pattern of numbers to specify the attack time (in seconds) of an
--   envelope applied to each sample. Only takes effect if <a>release</a>
--   is also specified.
attack :: Pattern Double -> ParamPattern
attack_p :: Param

-- | a pattern of numbers from 0 to 1. Sets the center frequency of the
--   band-pass filter.
bandf :: Pattern Double -> ParamPattern
bandf_p :: Param

-- | a pattern of numbers from 0 to 1. Sets the q-factor of the band-pass
--   filter.y
bandq :: Pattern Double -> ParamPattern
bandq_p :: Param
begin :: Pattern Double -> ParamPattern

-- | 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.
--   
--   Using `begin "-1"` combined with `cut "-1"` means that when the sample
--   cuts itself it will begin playback from where the previous one left
--   off, so it will sound like one seamless sample. This allows you to
--   apply a synth param across a long sample in a way similar to
--   <tt>chop</tt>:
--   
--   <pre>
--   cps 0.5
--   
--   d1 $ sound "breaks125*8"  begin "-1"  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   This will play the <tt>breaks125</tt> sample and apply the changing
--   <a>coarse</a> parameter over the sample. Compare to:
--   
--   <pre>
--   d1 $ (chop 8 $ sounds "breaks125")  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   which performs a similar effect, but due to differences in
--   implementation sounds different.
begin_p :: Param

-- | choose the physical channel the pattern is sent to, this is super dirt
--   specific
channel :: Pattern Int -> ParamPattern

-- | 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.
--   
--   Using `begin "-1"` combined with `cut "-1"` means that when the sample
--   cuts itself it will begin playback from where the previous one left
--   off, so it will sound like one seamless sample. This allows you to
--   apply a synth param across a long sample in a way similar to
--   <tt>chop</tt>:
--   
--   <pre>
--   cps 0.5
--   
--   d1 $ sound "breaks125*8"  begin "-1"  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   This will play the <tt>breaks125</tt> sample and apply the changing
--   <a>coarse</a> parameter over the sample. Compare to:
--   
--   <pre>
--   d1 $ (chop 8 $ sounds "breaks125")  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   which performs a similar effect, but due to differences in
--   implementation sounds different.
channel_p :: Param
legato :: Pattern Double -> ParamPattern

-- | 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.
--   
--   Using `begin "-1"` combined with `cut "-1"` means that when the sample
--   cuts itself it will begin playback from where the previous one left
--   off, so it will sound like one seamless sample. This allows you to
--   apply a synth param across a long sample in a way similar to
--   <tt>chop</tt>:
--   
--   <pre>
--   cps 0.5
--   
--   d1 $ sound "breaks125*8"  begin "-1"  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   This will play the <tt>breaks125</tt> sample and apply the changing
--   <a>coarse</a> parameter over the sample. Compare to:
--   
--   <pre>
--   d1 $ (chop 8 $ sounds "breaks125")  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   which performs a similar effect, but due to differences in
--   implementation sounds different.
legato_p :: Param
clhatdecay :: Pattern Double -> ParamPattern

-- | 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.
--   
--   Using `begin "-1"` combined with `cut "-1"` means that when the sample
--   cuts itself it will begin playback from where the previous one left
--   off, so it will sound like one seamless sample. This allows you to
--   apply a synth param across a long sample in a way similar to
--   <tt>chop</tt>:
--   
--   <pre>
--   cps 0.5
--   
--   d1 $ sound "breaks125*8"  begin "-1"  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   This will play the <tt>breaks125</tt> sample and apply the changing
--   <a>coarse</a> parameter over the sample. Compare to:
--   
--   <pre>
--   d1 $ (chop 8 $ sounds "breaks125")  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   which performs a similar effect, but due to differences in
--   implementation sounds different.
clhatdecay_p :: Param

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

-- | 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.
--   
--   Using `begin "-1"` combined with `cut "-1"` means that when the sample
--   cuts itself it will begin playback from where the previous one left
--   off, so it will sound like one seamless sample. This allows you to
--   apply a synth param across a long sample in a way similar to
--   <tt>chop</tt>:
--   
--   <pre>
--   cps 0.5
--   
--   d1 $ sound "breaks125*8"  begin "-1"  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   This will play the <tt>breaks125</tt> sample and apply the changing
--   <a>coarse</a> parameter over the sample. Compare to:
--   
--   <pre>
--   d1 $ (chop 8 $ sounds "breaks125")  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   which performs a similar effect, but due to differences in
--   implementation sounds different.
coarse_p :: Param

-- | bit crushing, a pattern of numbers from 1 (for drastic reduction in
--   bit-depth) to 16 (for barely no reduction).
crush :: Pattern Double -> ParamPattern

-- | 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.
--   
--   Using `begin "-1"` combined with `cut "-1"` means that when the sample
--   cuts itself it will begin playback from where the previous one left
--   off, so it will sound like one seamless sample. This allows you to
--   apply a synth param across a long sample in a way similar to
--   <tt>chop</tt>:
--   
--   <pre>
--   cps 0.5
--   
--   d1 $ sound "breaks125*8"  begin "-1"  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   This will play the <tt>breaks125</tt> sample and apply the changing
--   <a>coarse</a> parameter over the sample. Compare to:
--   
--   <pre>
--   d1 $ (chop 8 $ sounds "breaks125")  coarse "1 2 4 8 16 32 64 128"
--   </pre>
--   
--   which performs a similar effect, but due to differences in
--   implementation sounds different.
crush_p :: Param

-- | 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.
--   
--   <pre>
--   d1 $ stack [
--     sound "bd",
--     sound "~ [~ [ho:2 hc/2]]" # cut "1"
--     ]
--   </pre>
--   
--   This will mute the open hi-hat every second cycle when the closed one
--   is played.
--   
--   Using <a>cut</a> with negative values will only cut the same sample.
--   This is useful to cut very long samples
--   
--   <pre>
--   d1 $ sound "<a>bev, [ho:3</a>]" # cut "-1"
--   </pre>
--   
--   Using `cut "0"` is effectively _no_ cutgroup.
cut :: Pattern Int -> ParamPattern
cut_p :: Param

-- | a pattern of numbers from 0 to 1. Applies the cutoff frequency of the
--   low-pass filter.
cutoff :: Pattern Double -> ParamPattern
cutoff_p :: Param
cutoffegint :: Pattern Double -> ParamPattern
cutoffegint_p :: Param
decay :: Pattern Double -> ParamPattern
decay_p :: Param

-- | a pattern of numbers from 0 to 1. Sets the level of the delay signal.
delay :: Pattern Double -> ParamPattern
delay_p :: Param

-- | a pattern of numbers from 0 to 1. Sets the amount of delay feedback.
delayfeedback :: Pattern Double -> ParamPattern
delayfeedback_p :: Param

-- | a pattern of numbers from 0 to 1. Sets the length of the delay.
delaytime :: Pattern Double -> ParamPattern
delaytime_p :: Param
detune :: Pattern Double -> ParamPattern
detune_p :: Param

-- | 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 -> ParamPattern
dry_p :: Param
end :: Pattern Double -> ParamPattern
end_p :: Param

-- | a pattern of numbers that specify volume. Values less than 1 make the
--   sound quieter. Values greater than 1 make the sound louder.
gain :: Pattern Double -> ParamPattern
gain_p :: Param
gate :: Pattern Double -> ParamPattern
gate_p :: Param
hatgrain :: Pattern Double -> ParamPattern
hatgrain_p :: Param

-- | a pattern of numbers from 0 to 1. Applies the cutoff frequency of the
--   high-pass filter.
hcutoff :: Pattern Double -> ParamPattern
hcutoff_p :: Param

-- | 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 -> ParamPattern
hold_p :: Param

-- | a pattern of numbers from 0 to 1. Applies the resonance of the
--   high-pass filter.
hresonance :: Pattern Double -> ParamPattern
hresonance_p :: Param
kriole :: Pattern Int -> ParamPattern
kriole_p :: Param
lagogo :: Pattern Double -> ParamPattern
lagogo_p :: Param
lclap :: Pattern Double -> ParamPattern
lclap_p :: Param
lclaves :: Pattern Double -> ParamPattern
lclaves_p :: Param
lclhat :: Pattern Double -> ParamPattern
lclhat_p :: Param
lcrash :: Pattern Double -> ParamPattern
lcrash_p :: Param
leslie :: Pattern Double -> ParamPattern
leslie_p :: Param
lrate :: Pattern Double -> ParamPattern
lrate_p :: Param
lsize :: Pattern Double -> ParamPattern
lsize_p :: Param
lfo :: Pattern Double -> ParamPattern
lfo_p :: Param
lfocutoffint :: Pattern Double -> ParamPattern
lfocutoffint_p :: Param
lfodelay :: Pattern Double -> ParamPattern
lfodelay_p :: Param
lfoint :: Pattern Double -> ParamPattern
lfoint_p :: Param
lfopitchint :: Pattern Double -> ParamPattern
lfopitchint_p :: Param
lfoshape :: Pattern Double -> ParamPattern
lfoshape_p :: Param
lfosync :: Pattern Double -> ParamPattern
lfosync_p :: Param
lhitom :: Pattern Double -> ParamPattern
lhitom_p :: Param
lkick :: Pattern Double -> ParamPattern
lkick_p :: Param
llotom :: Pattern Double -> ParamPattern
llotom_p :: Param

-- | 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 -> ParamPattern
lock_p :: Param

-- | loops the sample (from <a>begin</a> to <a>end</a>) the specified
--   number of times.
loop :: Pattern Double -> ParamPattern
loop_p :: Param
lophat :: Pattern Double -> ParamPattern
lophat_p :: Param
lsnare :: Pattern Double -> ParamPattern
lsnare_p :: Param

-- | specifies the sample or note number to be used
n :: Pattern Double -> ParamPattern
n_p :: Param
note :: Pattern Double -> ParamPattern
note_p :: Param

-- | Pushes things forward (or backwards within built-in latency) in time.
--   Allows for nice things like _swing_ feeling:
--   
--   <pre>
--   d1 $ stack [
--     sound "bd bd/4",
--     sound "hh(5,8)"
--     ] # nudge "[0 0.04]*4"
--   </pre>
--   
--   <ul>
--   <li>-pitch model</li>
--   </ul>
degree :: Pattern Double -> ParamPattern
degree_p :: Param

-- | Pushes things forward (or backwards within built-in latency) in time.
--   Allows for nice things like _swing_ feeling:
--   
--   <pre>
--   d1 $ stack [
--     sound "bd bd/4",
--     sound "hh(5,8)"
--     ] # nudge "[0 0.04]*4"
--   </pre>
--   
--   <ul>
--   <li>-pitch model</li>
--   </ul>
mtranspose :: Pattern Double -> ParamPattern
mtranspose_p :: Param

-- | Pushes things forward (or backwards within built-in latency) in time.
--   Allows for nice things like _swing_ feeling:
--   
--   <pre>
--   d1 $ stack [
--     sound "bd bd/4",
--     sound "hh(5,8)"
--     ] # nudge "[0 0.04]*4"
--   </pre>
--   
--   <ul>
--   <li>-pitch model</li>
--   </ul>
ctranspose :: Pattern Double -> ParamPattern
ctranspose_p :: Param

-- | Pushes things forward (or backwards within built-in latency) in time.
--   Allows for nice things like _swing_ feeling:
--   
--   <pre>
--   d1 $ stack [
--     sound "bd bd/4",
--     sound "hh(5,8)"
--     ] # nudge "[0 0.04]*4"
--   </pre>
--   
--   <ul>
--   <li>-pitch model</li>
--   </ul>
harmonic :: Pattern Double -> ParamPattern
harmonic_p :: Param

-- | Pushes things forward (or backwards within built-in latency) in time.
--   Allows for nice things like _swing_ feeling:
--   
--   <pre>
--   d1 $ stack [
--     sound "bd bd/4",
--     sound "hh(5,8)"
--     ] # nudge "[0 0.04]*4"
--   </pre>
--   
--   <ul>
--   <li>-pitch model</li>
--   </ul>
stepsPerOctave :: Pattern Double -> ParamPattern
stepsPerOctave_p :: Param

-- | Pushes things forward (or backwards within built-in latency) in time.
--   Allows for nice things like _swing_ feeling:
--   
--   <pre>
--   d1 $ stack [
--     sound "bd bd/4",
--     sound "hh(5,8)"
--     ] # nudge "[0 0.04]*4"
--   </pre>
--   
--   <ul>
--   <li>-pitch model</li>
--   </ul>
octaveRatio :: Pattern Double -> ParamPattern
octaveRatio_p :: Param
nudge :: Pattern Double -> ParamPattern
nudge_p :: Param
octave :: Pattern Int -> ParamPattern
octave_p :: Param
offset :: Pattern Double -> ParamPattern
offset_p :: Param
ophatdecay :: Pattern Double -> ParamPattern
ophatdecay_p :: Param

-- | 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 -> ParamPattern
orbit_p :: Param

-- | a pattern of numbers between 0 and 1, from left to right (assuming
--   stereo), once round a circle (assuming multichannel)
pan :: Pattern Double -> ParamPattern
pan_p :: Param

-- | a pattern of numbers between -inf and inf, which controls how much
--   multichannel output is fanned out (negative is backwards ordering)
panspan :: Pattern Double -> ParamPattern
panspan_p :: Param

-- | a pattern of numbers between 0.0 and 1.0, which controls the
--   multichannel spread range (multichannel only)
pansplay :: Pattern Double -> ParamPattern
pansplay_p :: Param

-- | a pattern of numbers between 0.0 and inf, which controls how much each
--   channel is distributed over neighbours (multichannel only)
panwidth :: Pattern Double -> ParamPattern
panwidth_p :: Param

-- | 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 -> ParamPattern
panorient_p :: Param
pitch1 :: Pattern Double -> ParamPattern
pitch1_p :: Param
pitch2 :: Pattern Double -> ParamPattern
pitch2_p :: Param
pitch3 :: Pattern Double -> ParamPattern
pitch3_p :: Param
portamento :: Pattern Double -> ParamPattern
portamento_p :: Param

-- | a pattern of numbers to specify the release time (in seconds) of an
--   envelope applied to each sample. Only takes effect if <a>attack</a> is
--   also specified.
release :: Pattern Double -> ParamPattern
release_p :: Param

-- | a pattern of numbers from 0 to 1. Specifies the resonance of the
--   low-pass filter.
resonance :: Pattern Double -> ParamPattern
resonance_p :: Param

-- | a pattern of numbers from 0 to 1. Sets the level of reverb.
room :: Pattern Double -> ParamPattern
room_p :: Param
sagogo :: Pattern Double -> ParamPattern
sagogo_p :: Param
sclap :: Pattern Double -> ParamPattern
sclap_p :: Param
sclaves :: Pattern Double -> ParamPattern
sclaves_p :: Param
scrash :: Pattern Double -> ParamPattern
scrash_p :: Param
semitone :: Pattern Double -> ParamPattern
semitone_p :: Param

-- | wave shaping distortion, a pattern of numbers from 0 for no distortion
--   up to 1 for loads of distortion.
shape :: Pattern Double -> ParamPattern
shape_p :: Param

-- | 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 -> ParamPattern
size_p :: Param
slide :: Pattern Double -> ParamPattern
slide_p :: Param

-- | 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 -> ParamPattern
speed_p :: Param

-- | a pattern of strings. Selects the sample to be played.
s' :: Pattern String -> ParamPattern
s_p :: Param
stutterdepth :: Pattern Double -> ParamPattern
stutterdepth_p :: Param
stuttertime :: Pattern Double -> ParamPattern
stuttertime_p :: Param
sustain :: Pattern Double -> ParamPattern
sustain_p :: Param
tomdecay :: Pattern Double -> ParamPattern
tomdecay_p :: Param

-- | 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 -> ParamPattern
unit_p :: Param
velocity :: Pattern Double -> ParamPattern
velocity_p :: Param
vcfegint :: Pattern Double -> ParamPattern
vcfegint_p :: Param
vcoegint :: Pattern Double -> ParamPattern
vcoegint_p :: Param
voice :: Pattern Double -> ParamPattern
voice_p :: Param

-- | formant filter to make things sound like vowels, a pattern of either
--   <tt>a</tt>, <a>e</a>, <tt>i</tt>, <tt>o</tt> or <tt>u</tt>. Use a rest
--   (`~`) for no effect.
vowel :: Pattern String -> ParamPattern
vowel_p :: Param
dur :: Pattern Double -> ParamPattern
dur_p :: Param
modwheel :: Pattern Double -> ParamPattern
modwheel_p :: Param
expression :: Pattern Double -> ParamPattern
expression_p :: Param
sustainpedal :: Pattern Double -> ParamPattern
sustainpedal_p :: Param
tremolorate :: Pattern Double -> ParamPattern
tremolorate_p :: Param
tremolodepth :: Pattern Double -> ParamPattern
tremolodepth_p :: Param
phaserrate :: Pattern Double -> ParamPattern
phaserrate_p :: Param
phaserdepth :: Pattern Double -> ParamPattern
phaserdepth_p :: Param
att :: Pattern Double -> ParamPattern
bpf :: Pattern Double -> ParamPattern
bpf_p :: Param
bpq :: Pattern Double -> ParamPattern
bpq_p :: Param
chdecay :: Pattern Double -> ParamPattern
ctf :: Pattern Double -> ParamPattern
ctfg :: Pattern Double -> ParamPattern
delayfb :: Pattern Double -> ParamPattern
delayt :: Pattern Double -> ParamPattern
det :: Pattern Double -> ParamPattern
gat :: Pattern Double -> ParamPattern
hg :: Pattern Double -> ParamPattern
hpf :: Pattern Double -> ParamPattern
hpf_p :: Param
hpq :: Pattern Double -> ParamPattern
hpq_p :: Param
lag :: Pattern Double -> ParamPattern
lbd :: Pattern Double -> ParamPattern
lch :: Pattern Double -> ParamPattern
lcl :: Pattern Double -> ParamPattern
lcp :: Pattern Double -> ParamPattern
lcr :: Pattern Double -> ParamPattern
lfoc :: Pattern Double -> ParamPattern
lfoi :: Pattern Double -> ParamPattern
lfop :: Pattern Double -> ParamPattern
lht :: Pattern Double -> ParamPattern
llt :: Pattern Double -> ParamPattern
loh :: Pattern Double -> ParamPattern
lpf :: Pattern Double -> ParamPattern
lpf_p :: Param
lpq :: Pattern Double -> ParamPattern
lpq_p :: Param
lsn :: Pattern Double -> ParamPattern
ohdecay :: Pattern Double -> ParamPattern
phasdp :: Pattern Double -> ParamPattern
phasr :: Pattern Double -> ParamPattern
pit1 :: Pattern Double -> ParamPattern
pit2 :: Pattern Double -> ParamPattern
pit3 :: Pattern Double -> ParamPattern
por :: Pattern Double -> ParamPattern
rel :: Pattern Double -> ParamPattern
sag :: Pattern Double -> ParamPattern
scl :: Pattern Double -> ParamPattern
scp :: Pattern Double -> ParamPattern
scr :: Pattern Double -> ParamPattern
sz :: Pattern Double -> ParamPattern
sld :: Pattern Double -> ParamPattern
std :: Pattern Double -> ParamPattern
stt :: Pattern Double -> ParamPattern
sus :: Pattern Double -> ParamPattern
tdecay :: Pattern Double -> ParamPattern
tremdp :: Pattern Double -> ParamPattern
tremr :: Pattern Double -> ParamPattern
vcf :: Pattern Double -> ParamPattern
vco :: Pattern Double -> ParamPattern
voi :: Pattern Double -> ParamPattern
midinote :: Pattern Double -> ParamPattern
drum :: Pattern String -> ParamPattern
drumN :: Num a => String -> a
array :: Pattern Double -> ParamPattern
array_p :: Param
midichan :: Pattern Double -> ParamPattern
midichan_p :: Param
control :: Pattern Double -> ParamPattern
control_p :: Param
ccn :: Pattern Double -> ParamPattern
ccn_p :: Param
ccv :: Pattern Double -> ParamPattern
ccv_p :: Param
cc :: Pattern String -> ParamPattern
ctlNum :: Pattern Double -> ParamPattern
ctlNum_p :: Param
frameRate :: Pattern Double -> ParamPattern
frameRate_p :: Param
frames :: Pattern Double -> ParamPattern
frames_p :: Param
hours :: Pattern Double -> ParamPattern
hours_p :: Param
midicmd :: Pattern String -> ParamPattern
midicmd_p :: Param
command :: Pattern String -> ParamPattern
minutes :: Pattern Double -> ParamPattern
minutes_p :: Param
progNum :: Pattern Double -> ParamPattern
progNum_p :: Param
seconds :: Pattern Double -> ParamPattern
seconds_p :: Param
songPtr :: Pattern Double -> ParamPattern
songPtr_p :: Param
uid :: Pattern Double -> ParamPattern
uid_p :: Param
val :: Pattern Double -> ParamPattern
val_p :: Param
transition :: (IO Time) -> MVar (ParamPattern, [ParamPattern]) -> (Time -> [ParamPattern] -> ParamPattern) -> ParamPattern -> IO ()

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

-- | A generalization of <a>wash</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.
superwash :: (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Time -> Time -> Time -> Time -> [Pattern a] -> Pattern a

-- | Wash away the current pattern by applying a function to it over time,
--   then switching over to the next.
--   
--   <pre>
--   d1 $ sound "feel ! feel:1 feel:2"
--   
--   t1 (wash (chop 8) 4) $ sound "feel*4 [feel:2 sn:2]"
--   </pre>
--   
--   Note that `chop 8` is applied to `sound "feel ! feel:1 feel:2"` for 4
--   cycles and then the whole pattern is replaced by `sound "feel*4
--   [feel:2 sn:2]`
wash :: (Pattern a -> Pattern a) -> Time -> Time -> [Pattern a] -> Pattern a

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

-- | Just as <a>wait</a>, <a>wait'</a> stops for a bit and then applies the
--   given transition to the playing pattern
--   
--   <pre>
--   d1 $ sound "bd"
--   
--   t1 (wait' (xfadeIn 8) 4) $ sound "hh*8"
--   </pre>
wait' :: (Time -> [ParamPattern] -> ParamPattern) -> Time -> Time -> [ParamPattern] -> ParamPattern

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

-- | 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 -> [ParamPattern] -> ParamPattern

-- | 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 -> [ParamPattern] -> ParamPattern

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

-- | Degrade the new pattern over time until it ends in silence
mortal :: Time -> Time -> Time -> [ParamPattern] -> ParamPattern
combineV :: (Value -> Value -> Value) -> ParamMap -> ParamMap -> ParamMap
mixNums :: Double -> Value -> Value -> Value
interpolateIn :: Time -> Time -> [ParamPattern] -> ParamPattern
supercollider :: [Param] -> Double -> Shape
scSlang :: String -> OscSlang
scBackend :: String -> IO (Backend a)
scStream :: String -> [Param] -> Double -> IO (ParamPattern -> IO (), Shape)
dirt :: Shape
dirtSlang :: OscSlang
superDirtSlang :: OscSlang
superDirtBackend :: () => Int -> IO Backend a
superDirtState :: Int -> IO MVar (ParamPattern, [ParamPattern])
dirtBackend :: () => IO Backend a
dirtStream :: IO ParamPattern -> IO ()
dirtState :: IO MVar (ParamPattern, [ParamPattern])
dirtSetters :: IO Time -> IO (ParamPattern -> IO (), (Time -> [ParamPattern] -> ParamPattern) -> ParamPattern -> IO ())
superDirtSetters :: IO Time -> IO (ParamPattern -> IO (), (Time -> [ParamPattern] -> ParamPattern) -> ParamPattern -> IO ())
superDirts :: [Int] -> IO [(ParamPattern -> IO (), (Time -> [ParamPattern] -> ParamPattern) -> ParamPattern -> IO ())]
dirtstream :: () => p -> IO ParamPattern -> IO ()
dirtToColour :: ParamPattern -> Pattern ColourD
showToColour :: Show a => a -> ColourD
datumToColour :: Value -> ColourD
stringToColour :: String -> ColourD
pick :: String -> Int -> String

-- | 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 -> ParamPattern -> ParamPattern
_striate :: Int -> ParamPattern -> ParamPattern

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

-- | like <a>striate</a>, but with an offset to the begin and end values
striateO :: Pattern Int -> Pattern Double -> ParamPattern -> ParamPattern
_striateO :: Int -> Double -> ParamPattern -> ParamPattern

-- | Just like <a>striate</a>, but also loops each sample chunk a number of
--   times specified in the second argument. The primed version is just
--   like <a>striate'</a>, where the loop count is the third argument. For
--   example:
--   
--   <pre>
--   d1 $ striateL' 3 0.125 4 $ sound "feel sn:2"
--   </pre>
--   
--   Like <a>striate</a>, these use the <a>begin</a> and <a>end</a>
--   parameters internally, as well as the <a>loop</a> parameter for these
--   versions.
striateL :: Pattern Int -> Pattern Int -> ParamPattern -> ParamPattern
striateL' :: Pattern Int -> Pattern Double -> Pattern Int -> ParamPattern -> ParamPattern
_striateL :: Int -> Int -> ParamPattern -> ParamPattern
_striateL' :: Integral a => Int -> Double -> a -> ParamPattern -> ParamPattern
metronome :: Pattern ParamMap

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

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

-- | crossfades between old and new pattern over given number of cycles,
--   e.g.:
--   
--   <pre>
--   d1 $ sound "bd sn"
--   
--   t1 (xfadeIn 16) $ sound "jvbass*3"
--   </pre>
--   
--   Will fade over 16 cycles from "bd sn" to "jvbass*3"
xfadeIn :: Time -> Time -> [ParamPattern] -> ParamPattern

-- | Crossfade between old and new pattern over the next two cycles.
--   
--   <pre>
--   d1 $ sound "bd sn"
--   
--   t1 xfade $ sound "can*3"
--   </pre>
--   
--   <a>xfade</a> is built with <a>xfadeIn</a> in this case taking two
--   cycles for the fade.
xfade :: Time -> [ParamPattern] -> ParamPattern

-- | Stut applies a type of delay to a pattern. It has three parameters,
--   which could be called depth, feedback and time. Depth is an integer
--   and the others floating point. This adds a bit of echo:
--   
--   <pre>
--   d1 $ stut 4 0.5 0.2 $ sound "bd sn"
--   </pre>
--   
--   The above results in 4 echos, each one 50% quieter than the last, with
--   1/5th of a cycle between them. It is possible to reverse the echo:
--   
--   <pre>
--   d1 $ stut 4 0.5 (-0.2) $ sound "bd sn"
--   </pre>
stut :: Pattern Integer -> Pattern Double -> Pattern Rational -> ParamPattern -> ParamPattern
_stut :: Integer -> Double -> Rational -> ParamPattern -> ParamPattern

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

-- | <tt>durPattern</tt> takes a pattern and returns the length of events
--   in that pattern as a new pattern. For example the result of
--   `durPattern "[a ~] b"` would be `"[0.25 ~] 0.5"`.
durPattern :: Pattern a -> Pattern Time

-- | <tt>durPattern'</tt> is similar to <tt>durPattern</tt>, but does some
--   lookahead to try to find the length of time to the *next* event. For
--   example, the result of <a>durPattern</a> "[a ~] b"` would be `"[0.5 ~]
--   0.5"`.
durPattern' :: Pattern a -> Pattern Time

-- | <tt>stutx</tt> is like <tt>stut'</tt> but will limit the number of
--   repeats using the duration of the original sound. This usually
--   prevents overlapping "stutters" from subsequent sounds.
stutx :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> 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 -> [ParamPattern] -> ParamPattern

-- | <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 -> [ParamPattern] -> ParamPattern

-- | Copies the <tt>n</tt> parameter to the <tt>orbit</tt> parameter, so
--   different sound variants or notes go to different orbits in SuperDirt.
nToOrbit :: ParamPattern -> ParamPattern

-- | Maps the sample or synth names to different <tt>orbit</tt>s, using
--   indexes from the given list. E.g. <tt>soundToOrbit ["bd", "sn", "cp"]
--   $ sound "bd [cp sn]"</tt> would cause the bd, sn and cp smamples to be
--   sent to orbit 0, 1, 2 respectively.
soundToOrbit :: [String] -> ParamPattern -> ParamPattern
stutter :: Integral i => i -> Time -> Pattern a -> Pattern a
echo :: Time -> Pattern a -> Pattern a
triple :: Time -> Pattern a -> Pattern a
quad :: Time -> Pattern a -> Pattern a
double :: Time -> Pattern a -> Pattern a

-- | The <a>jux</a> function creates strange stereo effects, by applying a
--   function to a pattern, but only in the right-hand channel. For
--   example, the following reverses the pattern on the righthand side:
--   
--   <pre>
--   d1 $ slow 32 $ jux (rev) $ striate' 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) $ striate' 32 (1/16) $ sound "bev"
--   </pre>
jux :: ParamPattern -> Pattern ParamMap -> ParamPattern -> Pattern ParamMap
juxcut :: ParamPattern -> Pattern ParamMap -> ParamPattern -> Pattern ParamMap
juxcut' :: () => [t -> ParamPattern] -> t -> Pattern ParamMap

-- | 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 -> ParamPattern] -> t -> Pattern ParamMap

-- | Multichannel variant of <a>jux</a>, _not sure what it does_
jux4 :: ParamPattern -> Pattern ParamMap -> ParamPattern -> Pattern ParamMap

-- | 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 -> ParamPattern -> Pattern ParamMap -> ParamPattern -> Pattern ParamMap

-- | 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] -> ParamPattern -> Pattern ParamMap

-- | 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] -> ParamPattern -> Pattern ParamMap
samples :: Applicative f => f String -> f Int -> f String
samples' :: Applicative f => f String -> f Int -> f String
spreadf :: () => p1 -> p2 -> [a -> Pattern b] -> a -> Pattern b

-- | <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 -> ParamPattern -> ParamPattern
_spin :: Int -> ParamPattern -> ParamPattern
sawwave4 :: Pattern Double
sinewave4 :: Pattern Double
rand4 :: Pattern Double
stackwith :: Pattern ParamMap -> [ParamPattern] -> Pattern ParamMap

-- | <a>scale</a> will take a pattern which goes from 0 to 1 (like
--   <a>sine1</a>), and scale it to a different range - between the first
--   and second arguments. In the below example, `scale 1 1.5` shifts the
--   range of <a>sine1</a> from 0 - 1 to 1 - 1.5.
--   
--   <pre>
--   d1 $ jux (iter 4) $ sound "arpy arpy:2*2"
--     |+| speed (slow 4 $ scale 1 1.5 sine1)
--   </pre>
scale :: (Functor f, Num b) => b -> b -> f b -> f b

-- | <a>scalex</a> is an exponential version of <a>scale</a>, good for
--   using with frequencies. Do *not* use negative numbers or zero as
--   arguments!
scalex :: (Functor f, Floating b) => b -> b -> f b -> f b

-- | <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 -> ParamPattern -> ParamPattern
_chop :: Int -> ParamPattern -> ParamPattern

-- | <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 -> ParamPattern -> ParamPattern
_gap :: Int -> ParamPattern -> ParamPattern
chopArc :: Arc -> Int -> [Arc]
en :: [(Int, Int)] -> Pattern String -> Pattern String

-- | <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 :: Rational -> ParamPattern -> [ParamPattern] -> ParamPattern

-- | <a>weave'</a> is similar in that it blends functions at the same time
--   at different amounts over a pattern:
--   
--   <pre>
--   d1 $ weave' 3 (sound "bd [sn drum:2*2] bd*2 [sn drum:1]") [density 2, (# speed "0.5"), chop 16]
--   </pre>
weave' :: Rational -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a

-- | (A function that takes two OscPatterns, and blends them together into
--   a new OscPattern. An OscPattern 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 :: ParamPattern -> ParamPattern -> ParamPattern

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

-- | <a>up</a> does a poor man's pitchshift by semitones via <a>speed</a>.
--   
--   You can easily produce melodies from a single sample with up:
--   
--   <pre>
--   d1  sound "arpy"
--   </pre>
--   
--   This will play the _arpy_ sample four times a cycle in the original
--   pitch, pitched by 5 semitones, by 4 and then by an octave.
up :: Pattern Double -> ParamPattern
ghost'' :: () => Time -> Pattern a -> Pattern a -> Pattern a -> Pattern a
ghost' :: () => p -> Pattern ParamMap -> Pattern ParamMap
ghost :: Pattern ParamMap -> Pattern ParamMap
slice :: Pattern Int -> Pattern Int -> ParamPattern -> ParamPattern
_slice :: Int -> Int -> ParamPattern -> ParamPattern
randslice :: Int -> ParamPattern -> ParamPattern

-- | <a>loopAt</a> makes a sample fit the given number of cycles.
--   Internally, it works by setting the <a>unit</a> parameter to "c",
--   changing the playback speed of the sample with the <a>speed</a>
--   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 -> ParamPattern -> ParamPattern

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

-- | The basic notation for and constructor of a boolean <a>Sieve</a> is
--   <tt>m@@n</tt>, which represents all integers whose modulo with
--   <tt>m</tt> is equal to <tt>n</tt>
(@@) :: Int -> Int -> Sieve Bool
infixl 9 @@

-- | <tt>not'</tt> gives the complement of a sieve
not' :: Applicative f => f Bool -> f Bool

-- | <tt></tt> gives the union (logical OR) of two sieves
(#||#) :: Applicative f => f Bool -> f Bool -> f Bool
infixl 2 #||#

-- | <tt></tt> gives the intersection (logical AND) of two sieves
(#&&#) :: Applicative f => f Bool -> f Bool -> f Bool
infixl 3 #&&#

-- | <a>#^^#</a> gives the exclusive disjunction (logical XOR) of two
--   sieves
(#^^#) :: Applicative f => f Bool -> f Bool -> f Bool
infixl 2 #^^#

-- | <tt>sieveToList n</tt> returns a list of the values of the sieve for
--   each nonnegative integer less than <tt>n</tt> For example:
--   <tt>sieveToList 10 $ 3@@1</tt> returns `[False, True, False, False,
--   True, False, False, True, False, False]`
sieveToList :: Int -> Sieve a -> [a]

-- | <tt>sieveToString n</tt> represents the sieve as a character string,
--   where <tt>-</tt> represents False and <tt>x</tt> represents True
sieveToString :: Int -> Sieve Bool -> [Char]

-- | <tt>sieveToInts n</tt> returns a list of nonnegative integers less
--   than <tt>n</tt> where the sieve is True
sieveToInts :: Int -> Sieve Bool -> [Int]

-- | <tt>sieveToPat n</tt> returns a pattern where the cycle is divided
--   into <tt>n</tt> beats, and there is an event whenever the matching
--   beat number is in the sieve For example: <tt>sieveToPat 8 $ 3@@1</tt>
--   returns <tt>"~ x ~ ~ x ~ ~ x"</tt>
sieveToPat :: Int -> Sieve Bool -> Pattern String

-- | <tt>stepSieve n str</tt> works like <a>sieveToPat</a> but uses
--   <tt>str</tt> in the pattern instead of <tt>x</tt>
stepSieve :: Int -> String -> Sieve Bool -> Pattern String

-- | <tt>slowstepSieve t</tt> is shorthand for applying <tt>slow t</tt> to
--   the result of <a>stepSieve</a>
slowstepSieve :: Pattern Time -> Int -> String -> Sieve Bool -> Pattern String

-- | <tt>scaleSieve n</tt> uses <a>sieveToInts</a> to turn a sieve into a
--   list of integers, and then uses that with the <tt>toScale</tt>
--   function to turn a pattern of numbers into a pattern of notes in the
--   scale. For example: <tt>scaleSieve 8 (3@@1) "0 1 2 1"</tt> first
--   converts the sieve to the scale <tt>[1, 4, 7]</tt> and then uses that
--   with <tt>toScale</tt> to return the pattern <tt>"1 4 7 4"</tt>
scaleSieve :: Int -> Sieve Bool -> Pattern Int -> Pattern Int
parseEspTempo :: [Datum] -> Maybe Tempo
changeTempo :: MVar Tempo -> Packet -> IO ()
getTempo :: MVar Tempo -> IO Tempo
runClientEsp :: IO (MVar Tempo, MVar Double)
sendEspTempo :: Real t => t -> IO ()
cpsUtilsEsp :: IO (Double -> IO (), IO Rational, IO Tempo)
clockedTickEsp :: Int -> (Tempo -> Int -> IO ()) -> IO ()
clockedTickLoopEsp :: Int -> (Tempo -> Int -> IO ()) -> MVar Tempo -> Int -> IO Int
streamEsp :: Backend a -> Shape -> IO (ParamPattern -> IO ())
dirtStreamEsp :: IO (ParamPattern -> IO ())
stateEsp :: Backend a -> Shape -> IO (MVar (ParamPattern, [ParamPattern]))
dirtSettersEsp :: IO Time -> IO (ParamPattern -> IO (), (Time -> [ParamPattern] -> ParamPattern) -> ParamPattern -> IO ())
superDirtSettersEsp :: IO Time -> IO (ParamPattern -> IO (), (Time -> [ParamPattern] -> ParamPattern) -> ParamPattern -> IO ())
type CpsUtils = (Double -> IO (), IO Rational)
data SyncType
NoSync :: SyncType
Esp :: SyncType
data StreamType
Dirt :: StreamType
SuperDirt :: StreamType
initializeStreamType :: IO (MVar StreamType)
changeStreamType :: MVar StreamType -> StreamType -> IO (IO StreamType)
initializeSyncType :: IO (MVar SyncType)
changeSyncType :: MVar SyncType -> SyncType -> IO (IO SyncType)
multiModeCpsUtils :: CpsUtils -> CpsUtils -> MVar SyncType -> IO CpsUtils
multiModeSetters :: IO Rational -> IO Rational -> MVar SyncType -> MVar StreamType -> IO (ParamPattern -> IO ())
tidal_version :: [Char]

module Sound.Tidal.Simple
crunch :: ParamPattern -> ParamPattern
scratch :: ParamPattern -> ParamPattern
louder :: ParamPattern -> ParamPattern
quieter :: ParamPattern -> ParamPattern
mute :: ParamPattern -> ParamPattern
jump :: ParamPattern -> ParamPattern
left :: ParamPattern -> ParamPattern
right :: ParamPattern -> ParamPattern
higher :: ParamPattern -> ParamPattern
lower :: ParamPattern -> ParamPattern
faster :: ParamPattern -> ParamPattern
slower :: ParamPattern -> ParamPattern
