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

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


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' :: (t2, t1, t) -> t2

-- | shorthand for second element of triple
snd' :: (t1, t2, t) -> t2

-- | shorthand for third element of triple
thd' :: (t1, t, t2) -> t2

-- | 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
tempoMVar :: IO (MVar (Tempo))
beatNow :: Tempo -> IO (Double)
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.Show.Show Sound.Tidal.Tempo.ServerMode
instance GHC.Classes.Eq Sound.Tidal.Tempo.TConnection
instance GHC.Show.Show Sound.Tidal.Tempo.Tempo

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]

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

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.
data Pattern a
Pattern :: (Arc -> [Event a]) -> Pattern a
[arc] :: Pattern a -> Arc -> [Event a]
noOv :: String -> a

-- | <tt>show (p :: Pattern)</tt> returns a text string representing the
--   event values active during the first cycle of the given pattern.

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

-- | <tt>pure a</tt> returns a pattern with an event with value <tt>a</tt>,
--   which has a duration of one cycle, and repeats every cycle.

-- | <tt>mempty</tt> is a synonym for <tt>silence</tt>. | <tt>mappend</tt>
--   is a synonym for <tt>overlay</tt>.
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>Double</tt> values following a sinewave with frequency of one
--   cycle, and amplitude from 0 to 1.
sinewave :: Pattern Double

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

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

-- | <tt>sinerat</tt> is equivalent to <tt>sinewave</tt> for
--   <tt>Rational</tt> values, suitable for use as <tt>Time</tt> offsets.
sinerat :: Pattern Rational

-- | <tt>ratsine</tt> is a synonym for <tt>sinerat</tt>.
ratsine :: Pattern Rational

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

-- | <tt>sawwave</tt> is the equivalent of <tt>sinewave</tt> for
--   (ascending) sawtooth waves.
sawwave :: Pattern Double

-- | <tt>saw</tt> is a synonym for <tt>sawwave</tt>.
saw :: Pattern Double

-- | <tt>sawrat</tt> is the same as <tt>sawwave</tt> but returns
--   <tt>Rational</tt> values suitable for use as <tt>Time</tt> offsets.
sawrat :: Pattern Rational

-- | <tt>triwave</tt> is the equivalent of <tt>sinewave</tt> for triangular
--   waves.
triwave :: Pattern Double

-- | <tt>tri</tt> is a synonym for <tt>triwave</tt>.
tri :: Pattern Double

-- | <tt>trirat</tt> is the same as <tt>triwave</tt> but returns
--   <tt>Rational</tt> values suitable for use as <tt>Time</tt> offsets.
trirat :: Pattern Rational

-- | <tt>squarewave1</tt> is the equivalent of <tt>sinewave</tt> for square
--   waves.
squarewave :: Pattern Double

-- | <tt>square</tt> is a synonym for <tt>squarewave</tt>.
square :: Pattern Double
sinewave1 :: Pattern Double
sine1 :: Pattern Double
sinerat1 :: Pattern Rational
sineAmp1 :: Double -> Pattern Double
sawwave1 :: Pattern Double
saw1 :: Pattern Double
sawrat1 :: Pattern Rational
triwave1 :: Pattern Double
tri1 :: Pattern Double
trirat1 :: Pattern Rational
squarewave1 :: Pattern Double
square1 :: Pattern Double

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

-- | <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
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 :: Int -> Int -> Pattern a -> Pattern a
e' :: Int -> Int -> 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' :: 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
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' :: Int -> [Int] -> Pattern Int -> Pattern Int
toScale :: [Int] -> Pattern Int -> Pattern Int

-- | `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 -> [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
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.Monoid (Sound.Tidal.Pattern.Pattern a)
instance GHC.Base.Monad Sound.Tidal.Pattern.Pattern

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

module Sound.Tidal.Parse

-- | AST representation of patterns
data TPat a
TPat_Atom :: a -> TPat a
TPat_Density :: Time -> (TPat a) -> TPat a
TPat_Slow :: 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 :: Parseable a => TPat a -> Pattern a
durations :: [TPat a] -> [(Int, TPat a)]
p :: Parseable a => String -> Pattern a
class Parseable a
parseTPat :: Parseable a => String -> TPat a
fromTo :: Parseable a => a -> a -> Pattern a
fromThenTo :: Parseable a => a -> a -> a -> Pattern a
enumFromTo' :: (Enum a, Ord a) => a -> a -> Pattern a
enumFromThenTo' :: (Num a, Enum a, Ord 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 (Either Integer Double)
r :: 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 :: Integral a => Parser a
fromNote :: Integral c => Pattern String -> Pattern c
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 :: 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 a => GHC.Base.Monoid (Sound.Tidal.Parse.TPat 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
instance Sound.Tidal.Parse.Parseable Sound.Tidal.Parse.ColourD
instance Sound.Tidal.Parse.Parseable a => Data.String.IsString (Sound.Tidal.Pattern.Pattern a)

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 t => t
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 t => Tempo -> t -> 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 GHC.Classes.Eq Sound.Tidal.Stream.Param
instance GHC.Classes.Ord Sound.Tidal.Stream.Param
instance GHC.Show.Show Sound.Tidal.Stream.Param
instance GHC.Show.Show 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

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.
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
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 variation to be used
n :: Pattern Int -> 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
note :: Pattern Int -> ParamPattern
midinote :: Pattern Int -> ParamPattern
drum :: Pattern String -> ParamPattern
drumN :: String -> Int

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.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.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 :: t -> 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 :: 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 :: t1 -> t -> [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' :: t -> Pattern ParamMap -> Pattern ParamMap
ghost :: Pattern ParamMap -> Pattern ParamMap
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.Context
