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


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

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

module Sound.Tidal.Config
data Config
Config :: Bool -> String -> Int -> Bool -> Bool -> CDouble -> CDouble -> Double -> Bool -> Int64 -> Double -> Config
[cCtrlListen] :: Config -> Bool
[cCtrlAddr] :: Config -> String
[cCtrlPort] :: Config -> Int
[cCtrlBroadcast] :: Config -> Bool
[cVerbose] :: Config -> Bool
[cQuantum] :: Config -> CDouble
[cBeatsPerCycle] :: Config -> CDouble
[cFrameTimespan] :: Config -> Double
[cEnableLink] :: Config -> Bool
[cSkipTicks] :: Config -> Int64
[cProcessAhead] :: Config -> Double
defaultConfig :: Config
toClockConfig :: Config -> ClockConfig
verbose :: Config -> String -> IO ()
setFrameTimespan :: Double -> Config -> Config
setProcessAhead :: Double -> Config -> Config

module Sound.Tidal.ID

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

module Sound.Tidal.Stream.Types
data Stream
Stream :: Config -> MVar ValueMap -> ClockRef -> Maybe Udp -> MVar PlayMap -> MVar (ControlPattern -> ControlPattern) -> [Cx] -> Stream
[sConfig] :: Stream -> Config
[sStateMV] :: Stream -> MVar ValueMap
[sClockRef] :: Stream -> ClockRef
[sListen] :: Stream -> Maybe Udp
[sPMapMV] :: Stream -> MVar PlayMap
[sGlobalFMV] :: Stream -> MVar (ControlPattern -> ControlPattern)
[sCxs] :: Stream -> [Cx]
data Cx
Cx :: Target -> Udp -> [OSC] -> AddrInfo -> Maybe AddrInfo -> Maybe (MVar [Int]) -> Cx
[cxTarget] :: Cx -> Target
[cxUDP] :: Cx -> Udp
[cxOSCs] :: Cx -> [OSC]
[cxAddr] :: Cx -> AddrInfo
[cxBusAddr] :: Cx -> Maybe AddrInfo
[cxBusses] :: Cx -> Maybe (MVar [Int])
data StampStyle
BundleStamp :: StampStyle
MessageStamp :: StampStyle
data Schedule
Pre :: StampStyle -> Schedule
Live :: Schedule
data Target
Target :: String -> String -> Int -> Maybe Int -> Double -> Maybe Arc -> Schedule -> Bool -> Target
[oName] :: Target -> String
[oAddress] :: Target -> String
[oPort] :: Target -> Int
[oBusPort] :: Target -> Maybe Int
[oLatency] :: Target -> Double
[oWindow] :: Target -> Maybe Arc
[oSchedule] :: Target -> Schedule
[oHandshake] :: Target -> Bool
data Args
Named :: [String] -> Args
[requiredArgs] :: Args -> [String]
ArgList :: [(String, Maybe Value)] -> Args
data OSC
OSC :: String -> Args -> OSC
[path] :: OSC -> String
[args] :: OSC -> Args
OSCContext :: String -> OSC
[path] :: OSC -> String
data PlayState
PlayState :: ControlPattern -> Bool -> Bool -> [ControlPattern] -> PlayState
[psPattern] :: PlayState -> ControlPattern
[psMute] :: PlayState -> Bool
[psSolo] :: PlayState -> Bool
[psHistory] :: PlayState -> [ControlPattern]
type PatId = String
type PlayMap = Map PatId PlayState
instance GHC.Classes.Eq Sound.Tidal.Stream.Types.Schedule
instance GHC.Classes.Eq Sound.Tidal.Stream.Types.StampStyle
instance GHC.Internal.Show.Show Sound.Tidal.Stream.Types.Args
instance GHC.Internal.Show.Show Sound.Tidal.Stream.Types.OSC
instance GHC.Internal.Show.Show Sound.Tidal.Stream.Types.PlayState
instance GHC.Internal.Show.Show Sound.Tidal.Stream.Types.Schedule
instance GHC.Internal.Show.Show Sound.Tidal.Stream.Types.StampStyle
instance GHC.Internal.Show.Show Sound.Tidal.Stream.Types.Target

module Sound.Tidal.Stream.Target
getCXs :: Config -> [(Target, [OSC])] -> IO [Cx]
resolve :: String -> Int -> IO AddrInfo
handshake :: Cx -> Config -> IO ()
recvMessagesTimeout :: Transport t => Double -> t -> IO [Message]
send :: Cx -> Double -> Double -> (Double, Bool, Message) -> IO ()
sendBndl :: Bool -> Cx -> Bundle -> IO ()
sendO :: Bool -> Cx -> Message -> IO ()
superdirtTarget :: Target
superdirtShape :: OSC
dirtTarget :: Target
dirtShape :: OSC
sDefault :: String -> Maybe Value
fDefault :: Double -> Maybe Value
rDefault :: Rational -> Maybe Value
iDefault :: Int -> Maybe Value
bDefault :: Bool -> Maybe Value
xDefault :: [Word8] -> Maybe Value

module Sound.Tidal.Stream.Process
data ProcessedEvent
ProcessedEvent :: Bool -> Event ValueMap -> Double -> Micros -> Time -> Micros -> Time -> Micros -> Time -> ProcessedEvent
[peHasOnset] :: ProcessedEvent -> Bool
[peEvent] :: ProcessedEvent -> Event ValueMap
[peCps] :: ProcessedEvent -> Double
[peDelta] :: ProcessedEvent -> Micros
[peCycle] :: ProcessedEvent -> Time
[peOnWholeOrPart] :: ProcessedEvent -> Micros
[peOnWholeOrPartOsc] :: ProcessedEvent -> Time
[peOnPart] :: ProcessedEvent -> Micros
[peOnPartOsc] :: ProcessedEvent -> Time

-- | Query the current pattern (contained in argument <tt>stream ::
--   Stream</tt>) for the events in the current arc (contained in argument
--   <tt>st :: T.State</tt>), translate them to OSC messages, and send
--   these.
--   
--   If an exception occurs during sending, this functions prints a warning
--   and continues, because the likely reason is that the backend
--   (supercollider) isn't running.
--   
--   If any exception occurs before or outside sending (e.g., while
--   querying the pattern, while computing a message), this function prints
--   a warning and resets the current pattern to the previous one (or to
--   silence if there isn't one) and continues, because the likely reason
--   is that something is wrong with the current pattern.
doTick :: MVar ValueMap -> MVar PlayMap -> MVar (ControlPattern -> ControlPattern) -> [Cx] -> (Time, Time) -> Double -> ClockConfig -> ClockRef -> (SessionState, SessionState) -> IO ()
processCps :: ClockConfig -> ClockRef -> (SessionState, SessionState) -> [Event ValueMap] -> IO [ProcessedEvent]
toOSC :: Maybe [Int] -> ProcessedEvent -> OSC -> [(Double, Bool, Message)]
toData :: OSC -> Event ValueMap -> Maybe [Datum]
toDatum :: Value -> Datum
substitutePath :: String -> ValueMap -> Maybe String
getString :: ValueMap -> String -> Maybe String
playStack :: PlayMap -> ControlPattern
hasSolo :: Map k PlayState -> Bool
onSingleTick :: ClockConfig -> ClockRef -> MVar ValueMap -> MVar PlayMap -> MVar (ControlPattern -> ControlPattern) -> [Cx] -> ControlPattern -> IO ()
updatePattern :: Stream -> ID -> Time -> ControlPattern -> IO ()
setPreviousPatternOrSilence :: MVar PlayMap -> IO ()

module Sound.Tidal.Stream.UI
streamNudgeAll :: Stream -> Double -> IO ()
streamResetCycles :: Stream -> IO ()
streamSetCycle :: Stream -> Time -> IO ()
streamSetCPS :: Stream -> Time -> IO ()
streamSetBPM :: Stream -> Time -> IO ()
streamGetCPS :: Stream -> IO Time
streamGetcps :: Stream -> IO Time
streamGetBPM :: Stream -> IO Time
streamGetNow :: Stream -> IO Time
streamGetnow :: Stream -> IO Time
streamEnableLink :: Stream -> IO ()
streamDisableLink :: Stream -> IO ()
streamList :: Stream -> IO ()
streamReplace :: Stream -> ID -> ControlPattern -> IO ()
streamOnce :: Stream -> ControlPattern -> IO ()
streamFirst :: Stream -> ControlPattern -> IO ()
streamMute :: Stream -> ID -> IO ()
streamMutes :: Stream -> [ID] -> IO ()
streamUnmute :: Stream -> ID -> IO ()
streamSolo :: Stream -> ID -> IO ()
streamUnsolo :: Stream -> ID -> IO ()
withPatIds :: Stream -> [ID] -> (PlayState -> PlayState) -> IO ()
streamMuteAll :: Stream -> IO ()
streamHush :: Stream -> IO ()
streamUnmuteAll :: Stream -> IO ()
streamUnsoloAll :: Stream -> IO ()
streamSilence :: Stream -> ID -> IO ()
streamAll :: Stream -> (ControlPattern -> ControlPattern) -> IO ()
streamGet :: Stream -> String -> IO (Maybe Value)
streamSet :: Valuable a => Stream -> String -> Pattern a -> IO ()
streamSetI :: Stream -> String -> Pattern Int -> IO ()
streamSetF :: Stream -> String -> Pattern Double -> IO ()
streamSetS :: Stream -> String -> Pattern String -> IO ()
streamSetB :: Stream -> String -> Pattern Bool -> IO ()
streamSetR :: Stream -> String -> Pattern Rational -> IO ()

module Sound.Tidal.Stream.Listen
openListener :: Config -> IO (Maybe Udp)
ctrlResponder :: Config -> Stream -> IO ()

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

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

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

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

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

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

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

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

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

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

-- | Degrade the new pattern over time until it ends in silence
_mortal :: Time -> Time -> Time -> [ControlPattern] -> ControlPattern
_interpolate :: Time -> [ControlPattern] -> ControlPattern
_interpolateIn :: Time -> Time -> [ControlPattern] -> ControlPattern

-- | Degrades the current pattern while undegrading the next.
--   
--   This is like <tt>xfade</tt> but not by gain of samples but by randomly
--   removing events from the current pattern and slowly adding back in
--   missing events from the next one.
--   
--   <pre>
--   d1 $ sound "bd(3,8)"
--   
--   t1 clutch $ sound "[hh*4, odx(3,8)]"
--   </pre>
--   
--   <tt>clutch</tt> takes two cycles for the transition, essentially this
--   is <tt>clutchIn 2</tt>.
_clutch :: Time -> [Pattern a] -> Pattern a

-- | Also degrades the current pattern and undegrades the next. To change
--   the number of cycles the transition takes, you can use
--   <tt>clutchIn</tt> like so:
--   
--   <pre>
--   d1 $ sound "bd(5,8)"
--   
--   t1 (clutchIn 8) $ sound "[hh*4, odx(3,8)]"
--   </pre>
--   
--   will take 8 cycles for the transition.
_clutchIn :: Time -> Time -> [Pattern a] -> Pattern a

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

-- | <a>anticipate</a> is an increasing comb filter.
--   
--   Build up some tension, culminating in a _drop_ to the new pattern
--   after 8 cycles.
_anticipate :: Time -> [ControlPattern] -> ControlPattern
mortalOverlay :: Time -> Time -> [Pattern a] -> Pattern a
wash :: (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Time -> Time -> Time -> Time -> [Pattern a] -> Pattern a
washIn :: (Pattern a -> Pattern a) -> Time -> Time -> [Pattern a] -> Pattern a
xfadeIn :: Time -> Time -> [ControlPattern] -> ControlPattern
histpan :: Int -> Time -> [ControlPattern] -> ControlPattern
wait :: Time -> Time -> [ControlPattern] -> ControlPattern
waitT :: (Time -> [ControlPattern] -> ControlPattern) -> Time -> Time -> [ControlPattern] -> ControlPattern
jump :: Time -> [ControlPattern] -> ControlPattern
jumpIn :: Int -> Time -> [ControlPattern] -> ControlPattern
jumpIn' :: Int -> Time -> [ControlPattern] -> ControlPattern
jumpMod :: Int -> Time -> [ControlPattern] -> ControlPattern
jumpMod' :: Int -> Int -> Time -> [ControlPattern] -> ControlPattern
mortal :: Time -> Time -> Time -> [ControlPattern] -> ControlPattern
interpolate :: Time -> [ControlPattern] -> ControlPattern
interpolateIn :: Time -> Time -> [ControlPattern] -> ControlPattern
clutch :: Time -> [Pattern a] -> Pattern a
clutchIn :: Time -> Time -> [Pattern a] -> Pattern a
anticipateIn :: Time -> Time -> [ControlPattern] -> ControlPattern
anticipate :: Time -> [ControlPattern] -> ControlPattern

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

module Sound.Tidal.Stream.Main
startTidal :: Target -> Config -> IO Stream
startStream :: Config -> [(Target, [OSC])] -> IO Stream
startMulti :: [Target] -> Config -> IO ()

module Sound.Tidal.Stream

module Sound.Tidal.Context
data Ratio a
type Rational = Ratio Integer
denominator :: Ratio a -> a
numerator :: Ratio a -> a
(%) :: Integral a => a -> a -> Ratio a
approxRational :: RealFrac a => a -> a -> Rational

module Sound.Tidal.Safe.Context
data Op r
exec :: Stream -> Op r -> IO r
streamReplace :: ID -> ControlPattern -> Op ()
streamHush :: Op ()
streamList :: Op ()
streamMute :: ID -> Op ()
streamUnmute :: ID -> Op ()
streamSolo :: ID -> Op ()
streamUnsolo :: ID -> Op ()
streamOnce :: ControlPattern -> Op ()
streamFirst :: ControlPattern -> Op ()
streamNudgeAll :: Double -> Op ()
streamAll :: (ControlPattern -> ControlPattern) -> Op ()
streamResetCycles :: Op ()
streamSetI :: String -> Pattern Int -> Op ()
streamSetF :: String -> Pattern Double -> Op ()
streamSetS :: String -> Pattern String -> Op ()
streamSetR :: String -> Pattern Rational -> Op ()
streamSetB :: String -> Pattern Bool -> Op ()
transition :: Bool -> TransitionMapper -> ID -> ControlPattern -> Op ()
show :: Show a => a -> String
data Ratio a
type Rational = Ratio Integer
data Stream
data Target
Target :: String -> String -> Int -> Maybe Int -> Double -> Maybe Arc -> Schedule -> Bool -> Target
[oName] :: Target -> String
[oAddress] :: Target -> String
[oPort] :: Target -> Int
[oBusPort] :: Target -> Maybe Int
[oLatency] :: Target -> Double
[oWindow] :: Target -> Maybe Arc
[oSchedule] :: Target -> Schedule
[oHandshake] :: Target -> Bool
startTidal :: Target -> Config -> IO Stream
superdirtTarget :: Target
denominator :: Ratio a -> a
numerator :: Ratio a -> a
(%) :: Integral a => a -> a -> Ratio a
approxRational :: RealFrac a => a -> a -> Rational
data Target
Target :: String -> String -> Int -> Maybe Int -> Double -> Maybe Arc -> Schedule -> Bool -> Target
[oName] :: Target -> String
[oAddress] :: Target -> String
[oPort] :: Target -> Int
[oBusPort] :: Target -> Maybe Int
[oLatency] :: Target -> Double
[oWindow] :: Target -> Maybe Arc
[oSchedule] :: Target -> Schedule
[oHandshake] :: Target -> Bool
instance GHC.Internal.Base.Applicative Sound.Tidal.Safe.Context.Op
instance GHC.Internal.Base.Functor Sound.Tidal.Safe.Context.Op
instance Control.Monad.Catch.MonadCatch Sound.Tidal.Safe.Context.Op
instance GHC.Internal.Base.Monad Sound.Tidal.Safe.Context.Op
instance Control.Monad.Catch.MonadThrow Sound.Tidal.Safe.Context.Op

module Sound.Tidal.Safe.Boot
p :: ID -> ControlPattern -> Op ()
hush :: Op ()
list :: Op ()
mute :: ID -> Op ()
unmute :: ID -> Op ()
solo :: ID -> Op ()
unsolo :: ID -> Op ()
once :: ControlPattern -> Op ()
first :: ControlPattern -> Op ()
asap :: ControlPattern -> Op ()
nudgeAll :: Double -> Op ()
all :: (ControlPattern -> ControlPattern) -> Op ()

-- | Resets the cycle count back to 0. Useful to make sure a pattern or set
--   of patterns start from the beginning:
--   
--   <pre>
--   do
--     resetCycles
--     d1 $ s "bd hh hh hh"
--     d2 $ s "ade" # cut 1
--   </pre>
--   
--   Cycle count affects all patterns, so if there are any active, all of
--   them will immediately jump to the beginning. <tt>resetCycles</tt> is
--   also userful in multi-user Tidal.
--   
--   Also see <tt>setCycle</tt>, <tt>getnow</tt>.
resetCycles :: Op ()

-- | Adjusts the number of cycles per second, i.e., tempo. Accepts
--   integers, decimals, and fractions.
--   
--   The default number of cycles per second is 0.5625, equivalent to
--   135/60/4, i.e., 135 beats per minute if there are 4 beats per cycle.
--   
--   Representing cycles per second using fractions has the advantage of
--   being more human-readable and more closely aligned with how tempo is
--   commonly represented in music as beats per minute (bpm). For example,
--   techno has a typical range of 120-140 bpm and house has a range of
--   115-130 bpm. To set the tempo in Tidal to fast house, e.g.,:
--   <tt>setcps (130/60/4)</tt>.
--   
--   The following sound the same:
--   
--   <pre>
--   setcps (130/60/4)
--   d1 $ n "1" # s "kick kick kick kick"
--   </pre>
--   
--   and
--   
--   <pre>
--   setcps (130/60/1)
--   d1 $ n "1" # s "kick"
--   </pre>
setcps :: Pattern Double -> Op ()
xfade :: ID -> ControlPattern -> Op ()
xfadeIn :: ID -> Time -> ControlPattern -> Op ()
histpan :: ID -> Int -> ControlPattern -> Op ()
wait :: ID -> Time -> ControlPattern -> Op ()
waitT :: ID -> (Time -> [ControlPattern] -> ControlPattern) -> Time -> ControlPattern -> Op ()
jump :: ID -> ControlPattern -> Op ()
jumpIn :: ID -> Int -> ControlPattern -> Op ()
jumpIn' :: ID -> Int -> ControlPattern -> Op ()
jumpMod :: ID -> Int -> ControlPattern -> Op ()
mortal :: ID -> Time -> Time -> ControlPattern -> Op ()
interpolate :: ID -> ControlPattern -> Op ()
interpolateIn :: ID -> Time -> ControlPattern -> Op ()
clutch :: ID -> ControlPattern -> Op ()
clutchIn :: ID -> Time -> ControlPattern -> Op ()
anticipate :: ID -> ControlPattern -> Op ()
anticipateIn :: ID -> Time -> ControlPattern -> Op ()
forId :: ID -> Time -> ControlPattern -> Op ()
d1 :: Pattern ValueMap -> Op ()
d2 :: Pattern ValueMap -> Op ()
d3 :: Pattern ValueMap -> Op ()
d4 :: Pattern ValueMap -> Op ()
d5 :: Pattern ValueMap -> Op ()
d6 :: Pattern ValueMap -> Op ()
d7 :: Pattern ValueMap -> Op ()
d8 :: Pattern ValueMap -> Op ()
d9 :: Pattern ValueMap -> Op ()
d10 :: Pattern ValueMap -> Op ()
d11 :: Pattern ValueMap -> Op ()
d12 :: Pattern ValueMap -> Op ()
d13 :: ControlPattern -> Op ()
d14 :: ControlPattern -> Op ()
d15 :: ControlPattern -> Op ()
d16 :: ControlPattern -> Op ()
setI :: String -> Pattern Int -> Op ()
setF :: String -> Pattern Double -> Op ()
setS :: String -> Pattern String -> Op ()
setR :: String -> Pattern Rational -> Op ()
setB :: String -> Pattern Bool -> Op ()

module Sound.Tidal.Boot

-- | Functions using this constraint can access the in-scope Tidal
--   instance. You must implement an instance of this in <a>hs</a>. Note
--   that GHC will complain that it is an "orphan" instance, but that is
--   ok.
class Tidally
tidal :: Tidally => Stream
type OscMap = [(Target, [OSC])]

-- | A reasonable OscMap
mkOscMap :: OscMap

-- | Creates a Tidal instance using default config. Use <a>mkTidalWith</a>
--   to customize.
mkTidal :: IO Stream

-- | See <a>startStream</a>.
mkTidalWith :: OscMap -> Config -> IO Stream

-- | <a>hush</a> then execute the given action.
only :: Tidally => IO () -> IO ()

-- | See <a>streamReplace</a>.
p :: Tidally => ID -> ControlPattern -> IO ()

-- | Silences a specific stream, regardless of ControlPattern input. Useful
--   for rapid muting of streams
_p :: Tidally => ID -> ControlPattern -> IO ()

-- | Silences a specific stream, regardless of ControlPattern input. Useful
--   for rapid muting of streams
p_ :: Tidally => ID -> ControlPattern -> IO ()

-- | See <a>streamHush</a>.
hush :: Tidally => IO ()
panic :: Tidally => IO ()

-- | See <a>streamList</a>.
list :: Tidally => IO ()

-- | See <a>streamMute</a>.
mute :: Tidally => ID -> IO ()

-- | See <a>streamUnmute</a>.
unmute :: Tidally => ID -> IO ()

-- | See <a>streamUnmuteAll</a>.
unmuteAll :: Tidally => IO ()

-- | See <a>streamUnsoloAll</a>.
unsoloAll :: Tidally => IO ()

-- | See <a>streamSolo</a>.
solo :: Tidally => ID -> IO ()

-- | See <a>streamUnsolo</a>.
unsolo :: Tidally => ID -> IO ()

-- | See <a>streamOnce</a>.
once :: Tidally => ControlPattern -> IO ()

-- | An alias for <a>once</a>.
asap :: Tidally => ControlPattern -> IO ()

-- | See <a>first</a>.
first :: Tidally => ControlPattern -> IO ()

-- | See <a>nudgeAll</a>.
nudgeAll :: Tidally => Double -> IO ()

-- | See <a>streamAll</a>.
all :: Tidally => (ControlPattern -> ControlPattern) -> IO ()

-- | See <a>resetCycles</a>.
resetCycles :: Tidally => IO ()

-- | See <a>streamSetCycle</a>.
setCycle :: Tidally => Time -> IO ()

-- | See <a>cps</a>.
setcps :: Tidally => Pattern Double -> IO ()

-- | See <a>streamGetCPS</a>.
getcps :: Tidally => IO Time

-- | See <a>streamGetBPM</a>.
setbpm :: Tidally => Time -> IO ()

-- | See <a>streamGetBPM</a>.
getbpm :: Tidally => IO Time

-- | See <a>streamGetnow</a>.
getnow :: Tidally => IO Time
enableLink :: Tidally => IO ()
disableLink :: Tidally => IO ()

-- | Replace what's playing on the given orbit.
d1 :: Tidally => ControlPattern -> IO ()

-- | Replace what's playing on the given orbit.
d2 :: Tidally => ControlPattern -> IO ()

-- | Replace what's playing on the given orbit.
d3 :: Tidally => ControlPattern -> IO ()

-- | Replace what's playing on the given orbit.
d4 :: Tidally => ControlPattern -> IO ()

-- | Replace what's playing on the given orbit.
d5 :: Tidally => ControlPattern -> IO ()

-- | Replace what's playing on the given orbit.
d6 :: Tidally => ControlPattern -> IO ()

-- | Replace what's playing on the given orbit.
d7 :: Tidally => ControlPattern -> IO ()

-- | Replace what's playing on the given orbit.
d8 :: Tidally => ControlPattern -> IO ()

-- | Replace what's playing on the given orbit.
d9 :: Tidally => ControlPattern -> IO ()

-- | Replace what's playing on the given orbit.
d10 :: Tidally => ControlPattern -> IO ()

-- | Replace what's playing on the given orbit.
d11 :: Tidally => ControlPattern -> IO ()

-- | Replace what's playing on the given orbit.
d12 :: Tidally => ControlPattern -> IO ()

-- | Replace what's playing on the given orbit.
d13 :: Tidally => ControlPattern -> IO ()

-- | Replace what's playing on the given orbit.
d14 :: Tidally => ControlPattern -> IO ()

-- | Replace what's playing on the given orbit.
d15 :: Tidally => ControlPattern -> IO ()

-- | Replace what's playing on the given orbit.
d16 :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
_d1 :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
_d2 :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
_d3 :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
_d4 :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
_d5 :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
_d6 :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
_d7 :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
_d8 :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
_d9 :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
_d10 :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
_d11 :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
_d12 :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
_d13 :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
_d14 :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
_d15 :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
_d16 :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
d1_ :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
d2_ :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
d3_ :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
d4_ :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
d5_ :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
d6_ :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
d7_ :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
d8_ :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
d9_ :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
d10_ :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
d11_ :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
d12_ :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
d13_ :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
d14_ :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
d15_ :: Tidally => ControlPattern -> IO ()

-- | Rapidly silence what's playing on the given orbit
d16_ :: Tidally => ControlPattern -> IO ()

-- | See <a>streamGet</a>.
getState :: Tidally => String -> IO (Maybe Value)

-- | See <a>streamSetI</a>.
setI :: Tidally => String -> Pattern Int -> IO ()

-- | See <a>streamSetF</a>.
setF :: Tidally => String -> Pattern Double -> IO ()

-- | See <a>streamSetS</a>.
setS :: Tidally => String -> Pattern String -> IO ()

-- | See <a>streamSetR</a>.
setR :: Tidally => String -> Pattern Rational -> IO ()

-- | See <a>streamSetB</a>.
setB :: Tidally => String -> Pattern Bool -> IO ()
xfade :: Tidally => ID -> ControlPattern -> IO ()
xfadeIn :: Tidally => ID -> Time -> ControlPattern -> IO ()
array :: Pattern [Word8] -> ControlPattern
binary :: Pattern Int -> Pattern Bool

-- | Applies a type of delay to a pattern. It has three parameters, which
--   could be called <tt>depth</tt>, <tt>time</tt> and <tt>feedback</tt>.
--   <tt>depth</tt> is and integer, and <tt>time</tt> and <tt>feedback</tt>
--   are floating point numbers.
--   
--   This adds a bit of echo:
--   
--   <pre>
--   d1 $ echo 4 0.2 0.5 $ 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 $ echo 4 (-0.2) 0.5 $ sound "bd sn"
--   </pre>
echo :: Pattern Integer -> Pattern Rational -> Pattern Double -> ControlPattern -> ControlPattern
show :: Show a => a -> String
type Arc = ArcF Time

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

-- | Time is rational
type Time = Rational

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

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

-- | Turns a (rational) time value into another number. An alias for
--   <tt>fromRational</tt>.
fromTime :: Fractional a => Time -> a

-- | The end point of the current cycle (and starting point of the next
--   cycle)
nextSam :: Time -> Time

-- | The position of a time value relative to the start of its cycle.
cyclePos :: Time -> Time

-- | convex hull union
hull :: Arc -> Arc -> Arc

-- | <tt>subArc i j</tt> is the timespan that is the intersection of
--   <tt>i</tt> and <tt>j</tt>. intersection The definition is a bit fiddly
--   as results might be zero-width, but not at the end of an
--   non-zero-width arc - e.g. (0,1) and (1,2) do not intersect, but (1,1)
--   (1,1) does.
subArc :: Arc -> Arc -> Maybe Arc
subMaybeArc :: Maybe Arc -> Maybe Arc -> Maybe (Maybe Arc)

-- | Simple intersection of two arcs
sect :: Arc -> Arc -> Arc

-- | The Arc returned is the cycle that the Time falls within.
--   
--   Edge case: If the Time is an integer, the Arc claiming it is the one
--   starting at that Time, not the previous one ending at that Time.
timeToCycleArc :: Time -> Arc

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

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

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

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

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

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

-- | <tt>isIn a t</tt> is <tt>True</tt> if <tt>t</tt> is inside the arc
--   represented by <tt>a</tt>.
isIn :: Arc -> Time -> Bool

-- | Returns the lowest common multiple of two rational numbers
lcmr :: Rational -> Rational -> Rational

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

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

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

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

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

-- | an Arc and some named control values
data State
State :: Arc -> ValueMap -> State
[arc] :: State -> Arc
[controls] :: State -> ValueMap
pattern :: (State -> [Event a]) -> Pattern a
setSteps :: Maybe Rational -> Pattern a -> Pattern a
setStepsFrom :: Pattern b -> Pattern a -> Pattern a
withSteps :: (Rational -> Rational) -> Pattern a -> Pattern a
pace :: Rational -> Pattern a -> Pattern a
keepMeta :: Pattern a -> Pattern a -> Pattern a
keepSteps :: Pattern a -> Pattern b -> Pattern b

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

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

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

-- | Turns a pattern of patterns into a single pattern. (this is actually
--   <tt>join</tt>)
--   
--   1/ For query <a>arc</a>, get the events from the outer pattern
--   <tt>pp</tt> 2/ Query the inner pattern using the <a>part</a> of the
--   outer 3/ For each inner event, set the whole and part to be the
--   intersection of the outer whole and part, respectively 4<i>
--   Concatenate all the events together (discarding wholes</i>parts that
--   didn't intersect)
--   
--   TODO - what if a continuous pattern contains a discrete one, or
--   vice-versa?
unwrap :: Pattern (Pattern a) -> Pattern a

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

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

-- | Like <tt>unwrap</tt>, but cycles of the inner patterns are compressed
--   to fit the timespan of the outer whole (or the original query if it's
--   a continuous pattern?) TODO - what if a continuous pattern contains a
--   discrete one, or vice-versa? TODO - steps
squeezeJoin :: Pattern (Pattern a) -> Pattern a
_trigJoin :: Bool -> Pattern (Pattern a) -> Pattern a
trigJoin :: Pattern (Pattern a) -> Pattern a
trigZeroJoin :: Pattern (Pattern a) -> Pattern a
reset :: Pattern Bool -> Pattern a -> Pattern a
resetTo :: Pattern Rational -> Pattern a -> Pattern a
restart :: Pattern Bool -> Pattern a -> Pattern a
restartTo :: Pattern Rational -> Pattern a -> Pattern a

-- | <ul>
--   <li>Patterns as numbers</li>
--   </ul>
noOv :: String -> a
empty :: Pattern a
silence :: Pattern a
nothing :: Pattern a
queryArc :: Pattern a -> Arc -> [Event a]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Extract a pattern of note values by from a control pattern, given the
--   name of the control
extractN :: String -> ControlPattern -> Pattern Note
compressArc :: Arc -> Pattern a -> Pattern a
compressArcTo :: Arc -> Pattern a -> Pattern a
focusArc :: Arc -> Pattern a -> Pattern a

-- | Speed up a pattern by the given time pattern.
--   
--   For example, the following will play the sound pattern <tt>"bd sn
--   kurt"</tt> twice as fast (i.e., so it repeats twice per cycle), and
--   the vowel pattern three times as fast:
--   
--   <pre>
--   d1 $ sound (fast 2 "bd sn kurt")
--      # fast 3 (vowel "a e o")
--   </pre>
--   
--   The first parameter can be patterned to, for example, play the pattern
--   at twice the speed for the first half of each cycle and then four
--   times the speed for the second half:
--   
--   <pre>
--   d1 $ fast "2 4" $ sound "bd sn kurt cp"
--   </pre>
fast :: Pattern Time -> Pattern a -> Pattern a

-- | <tt>fastSqueeze</tt> speeds up a pattern by a time pattern given as
--   input, squeezing the resulting pattern inside one cycle and playing
--   the original pattern at every repetition.
--   
--   To better understand how it works, compare it with <a>fast</a>:
--   
--   <pre>
--   &gt;&gt;&gt; fast "1 2" $ s "bd sn"
--   (0&gt;½)|s: "bd"
--   (½&gt;¾)|s: "bd"
--   (¾&gt;1)|s: "sn"
--   </pre>
--   
--   This will give <tt>bd</tt> played in the first half cycle, and <tt>bd
--   sn</tt> in the second half. On the other hand, using fastSqueeze;
--   
--   <pre>
--   &gt;&gt;&gt; print $ fastSqueeze "1 2" $ s "bd sn"
--   (0&gt;¼)|s: "bd"
--   (¼&gt;½)|s: "sn"
--   (½&gt;⅝)|s: "bd"
--   (⅝&gt;¾)|s: "sn"
--   (¾&gt;⅞)|s: "bd"
--   (⅞&gt;1)|s: "sn"
--   </pre>
--   
--   The original pattern will play in the first half, and two repetitions
--   of the original pattern will play in the second half. That is, every
--   repetition contains the whole pattern.
--   
--   If the time pattern has a single value, it becomes equivalent to
--   <a>fast</a>:
--   
--   <pre>
--   d1 $ fastSqueeze 2 $ s "bd sn"
--   d1 $ fast 2 $ s "bd sn"
--   d1 $ s "[bd sn]*2"
--   </pre>
fastSqueeze :: Pattern Time -> Pattern a -> Pattern a

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

-- | Slow down a pattern by the given time pattern.
--   
--   For example, the following will play the sound pattern <tt>"bd sn
--   kurt"</tt> twice as slow (i.e., so it repeats once every two cycles),
--   and the vowel pattern three times as slow:
--   
--   <pre>
--   d1 $ sound (slow 2 "bd sn kurt")
--      # slow 3 (vowel "a e o")
--   </pre>
slow :: Pattern Time -> Pattern a -> Pattern a
_slow :: Time -> Pattern a -> Pattern a
_fastGap :: Time -> Pattern a -> Pattern a

-- | Shifts a pattern back in time by the given amount, expressed in
--   cycles.
--   
--   This will skip to the fourth cycle:
--   
--   <pre>
--   do
--     resetCycles
--     d1 $ rotL 4 $ seqP
--       [ (0, 12, sound "bd bd*2")
--       , (4, 12, sound "hh*2 [sn cp] cp future*4")
--       , (8, 12, sound (samples "arpy*8" (run 16)))
--       ]
--   </pre>
--   
--   Useful when building and testing out longer sequences.
rotL :: Time -> Pattern a -> Pattern a

-- | Shifts a pattern forward in time by the given amount, expressed in
--   cycles. Opposite of <a>rotL</a>.
rotR :: Time -> Pattern a -> Pattern a

-- | <tt>rev p</tt> returns <tt>p</tt> with the event positions in each
--   cycle reversed (or mirrored).
--   
--   For example rev <tt>"1 [~ 2] ~ 3"</tt> is equivalent to rev <tt>"3 ~
--   [2 ~] 1"</tt>.
--   
--   Note that <tt>rev</tt> reverses on a cycle-by-cycle basis. This means
--   that <tt>rev (slow 2 "1 2 3 4")</tt> would actually result in
--   <tt>(slow 2 "2 1 4 3")</tt>. This is because the <tt>slow 2</tt> makes
--   the repeating pattern last two cycles, each of which is reversed
--   independently.
--   
--   In practice rev is generally used with conditionals, for example with
--   every:
--   
--   <pre>
--   d1 $ every 3 rev $ n "0 1 [~ 2] 3" # sound "arpy"
--   </pre>
--   
--   or <tt>jux</tt>:
--   
--   <pre>
--   d1 $ jux rev $ n (iter 4 "0 1 [~ 2] 3") # sound "arpy"
--   </pre>
rev :: Pattern a -> Pattern a

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

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

-- | Turns a pattern of <a>Maybe</a> values into a pattern of values,
--   dropping the events of <a>Nothing</a>.
filterJust :: Pattern (Maybe a) -> Pattern a
filterWhen :: (Time -> Bool) -> Pattern a -> Pattern a
filterOnsets :: Pattern a -> Pattern a
filterEvents :: (Event a -> Bool) -> Pattern a -> Pattern a
filterDigital :: Pattern a -> Pattern a
filterAnalog :: Pattern a -> Pattern a
playFor :: Time -> Time -> Pattern a -> Pattern a

-- | Splits a pattern into a list containing the given <tt>n</tt> number of
--   patterns. Each one plays every <tt>n</tt>th cycle, successfully offset
--   by a cycle.
separateCycles :: Int -> Pattern a -> [Pattern a]
patternify :: (t1 -> t2 -> Pattern a) -> Pattern t1 -> t2 -> Pattern a
patternify' :: (b -> Pattern c -> Pattern a) -> Pattern b -> Pattern c -> Pattern a
patternify2 :: (a -> b -> c -> Pattern d) -> Pattern a -> Pattern b -> c -> Pattern d
patternify2' :: (a -> b -> Pattern c -> Pattern d) -> Pattern a -> Pattern b -> Pattern c -> Pattern d
patternify3 :: (a -> b -> c -> Pattern d -> Pattern e) -> Pattern a -> Pattern b -> Pattern c -> Pattern d -> Pattern e
patternify3' :: (a -> b -> c -> Pattern d -> Pattern e) -> Pattern a -> Pattern b -> Pattern c -> Pattern d -> Pattern e
patternifySqueeze :: (a -> Pattern b -> Pattern c) -> Pattern a -> Pattern b -> Pattern c
combineContexts :: [Context] -> Context
setContext :: Context -> Pattern a -> Pattern a
withContext :: (Context -> Context) -> Pattern a -> Pattern a
deltaMini :: String -> String
isAnalog :: Event a -> Bool
isDigital :: Event a -> Bool

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

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

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

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

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

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

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

-- | Get the timespan of an event's <a>part</a>
eventPart :: Event a -> Arc
eventValue :: Event a -> a
eventHasOnset :: Event a -> Bool
toEvent :: (((Time, Time), (Time, Time)), a) -> Event a
resolveState :: ValueMap -> [Event ValueMap] -> (ValueMap, [Event ValueMap])

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

-- | Apply one of two functions to a pair of Values, depending on their
--   types (int or float; strings and rationals are ignored)
fNum2 :: (Int -> Int -> Int) -> (Double -> Double -> Double) -> Value -> Value -> Value
getI :: Value -> Maybe Int
getF :: Value -> Maybe Double
getN :: Value -> Maybe Note
getS :: Value -> Maybe String
getB :: Value -> Maybe Bool
getR :: Value -> Maybe Rational
getBlob :: Value -> Maybe [Word8]
getList :: Value -> Maybe [Value]
valueToPattern :: Value -> Pattern Value
sameDur :: Event a -> Event a -> Bool
groupEventsBy :: Eq a => (Event a -> Event a -> Bool) -> [Event a] -> [[Event a]]
collectEvent :: [Event a] -> Maybe (Event [a])
collectEventsBy :: Eq a => (Event a -> Event a -> Bool) -> [Event a] -> [Event [a]]

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

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

-- | merges all values in a list into one pattern by stacking the values
uncollect :: Pattern [a] -> Pattern a
showStateful :: ControlPattern -> String
showAll :: Show a => Arc -> Pattern a -> String
stepcount :: Pattern a -> Int
drawLine :: Pattern Char -> Render
drawLineSz :: Int -> Pattern Char -> Render
draw :: Pattern Char -> Render
class Unionable a
union :: Unionable a => a -> a -> a

-- | Takes a function of time to values, and turns it into a
--   <a>Pattern</a>. Useful for creating continuous patterns such as
--   <a>sine</a> or <tt>perlin</tt>.
--   
--   For example, <a>saw</a> is defined as
--   
--   <pre>
--   saw = sig $ \t -&gt; mod' (fromRational t) 1
--   </pre>
sig :: (Time -> a) -> Pattern a

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

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

-- | <tt>cosine</tt> - unipolar cosine wave. A pattern of continuous values
--   following a cosine with frequency of one cycle, and amplitude from 0
--   to 1. Equivalent to <tt>0.25 ~&gt; sine</tt>.
cosine :: Fractional a => Pattern a

-- | <tt>cosine2</tt> - bipolar cosine wave. A pattern of continuous values
--   following a cosine with frequency of one cycle, and amplitude from -1
--   to 1. Equivalent to <tt>0.25 ~&gt; sine2</tt>.
cosine2 :: Fractional a => Pattern a

-- | <tt>saw</tt> - unipolar ascending sawtooth wave. A pattern of
--   continuous values following a sawtooth with frequency of one cycle,
--   and amplitude from 0 to 1.
saw :: (Fractional a, Real a) => Pattern a

-- | <tt>saw2</tt> - bipolar ascending sawtooth wave. A pattern of
--   continuous values following a sawtooth with frequency of one cycle,
--   and amplitude from -1 to 1.
saw2 :: (Fractional a, Real a) => Pattern a

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

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

-- | <tt>tri</tt> - unipolar triangle wave. A pattern of continuous values
--   following a triangle wave with frequency of one cycle, and amplitude
--   from 0 to 1.
tri :: (Fractional a, Real a) => Pattern a

-- | <tt>tri2</tt> - bipolar triangle wave. A pattern of continuous values
--   following a triangle wave with frequency of one cycle, and amplitude
--   from -1 to 1.
tri2 :: (Fractional a, Real a) => Pattern a

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

-- | <tt>square2</tt> - bipolar square wave. A pattern of continuous values
--   following a square wave with frequency of one cycle, and amplitude
--   from -1 to 1.
square2 :: Fractional a => Pattern a

-- | <tt>envL</tt> is a <a>Pattern</a> of continuous <a>Double</a> values,
--   representing a linear interpolation between 0 and 1 during the first
--   cycle, then staying constant at 1 for all following cycles. Possibly
--   only useful if you're using something like the retrig function defined
--   in tidal.el.
envL :: Pattern Double

-- | like <a>envL</a> but reversed.
envLR :: Pattern Double

-- | 'Equal power' version of <tt>env</tt>, for gain-based transitions
envEq :: Pattern Double

-- | Equal power reversed
envEqR :: Pattern Double
(|+|) :: (Applicative a, Num b) => a b -> a b -> a b
(|+) :: Num a => Pattern a -> Pattern a -> Pattern a
(+|) :: Num a => Pattern a -> Pattern a -> Pattern a
(||+) :: Num a => Pattern a -> Pattern a -> Pattern a
(|++|) :: Applicative a => a String -> a String -> a String
(|++) :: Pattern String -> Pattern String -> Pattern String
(++|) :: Pattern String -> Pattern String -> Pattern String
(||++) :: Pattern String -> Pattern String -> Pattern String
(|/|) :: (Applicative a, Fractional b) => a b -> a b -> a b
(|/) :: Fractional a => Pattern a -> Pattern a -> Pattern a
(/|) :: Fractional a => Pattern a -> Pattern a -> Pattern a
(||/) :: Fractional a => Pattern a -> Pattern a -> Pattern a
(|*|) :: (Applicative a, Num b) => a b -> a b -> a b
(|*) :: Num a => Pattern a -> Pattern a -> Pattern a
(*|) :: Num a => Pattern a -> Pattern a -> Pattern a
(||*) :: Num a => Pattern a -> Pattern a -> Pattern a
(|-|) :: (Applicative a, Num b) => a b -> a b -> a b
(|-) :: Num a => Pattern a -> Pattern a -> Pattern a
(-|) :: Num a => Pattern a -> Pattern a -> Pattern a
(||-) :: Num a => Pattern a -> Pattern a -> Pattern a
(|%|) :: (Applicative a, Moddable b) => a b -> a b -> a b
(|%) :: Moddable a => Pattern a -> Pattern a -> Pattern a
(%|) :: Moddable a => Pattern a -> Pattern a -> Pattern a
(||%) :: Moddable a => Pattern a -> Pattern a -> Pattern a
(|**|) :: (Applicative a, Floating b) => a b -> a b -> a b
(|**) :: Floating a => Pattern a -> Pattern a -> Pattern a
(**|) :: Floating a => Pattern a -> Pattern a -> Pattern a
(||**) :: Floating a => Pattern a -> Pattern a -> Pattern a
(|>|) :: (Applicative a, Unionable b) => a b -> a b -> a b
(|>) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(>|) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(||>) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(|<|) :: (Applicative a, Unionable b) => a b -> a b -> a b
(|<) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(<|) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(||<) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(#) :: Unionable b => Pattern b -> Pattern b -> Pattern b

-- | Turns a list of values into a pattern, playing one of them per cycle.
--   The following are equivalent:
--   
--   <pre>
--   d1 $ n (fromList [0, 1, 2]) # s "superpiano"
--   d1 $ n "&lt;0 1 2&gt;" # s "superpiano"
--   </pre>
fromList :: [a] -> Pattern a

-- | Turns a list of values into a pattern, playing <i>all</i> of them per
--   cycle. The following are equivalent:
--   
--   <pre>
--   d1 $ n (fastFromList [0, 1, 2]) # s "superpiano"
--   d1 $ n "[0 1 2]" # s "superpiano"
--   </pre>
fastFromList :: [a] -> Pattern a

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

-- | 'fromMaybes; is similar to <a>fromList</a>, but allows values to be
--   optional using the <a>Maybe</a> type, so that <a>Nothing</a> results
--   in gaps in the pattern. The following are equivalent: &gt; d1 $ n
--   (fromMaybes [Just 0, Nothing, Just 2]) # s "superpiano" &gt; d1 $ n "0
--   ~ 2" # s "superpiano"
fromMaybes :: [Maybe a] -> Pattern a

-- | A pattern of whole numbers from 0 to the given number, in a single
--   cycle. Can be used used to <tt>run</tt> through a folder of samples in
--   order:
--   
--   <pre>
--   d1 $ n (run 8) # sound "amencutup"
--   </pre>
--   
--   The first parameter to run can be given as a pattern:
--   
--   <pre>
--   d1 $ n (run "&lt;4 8 4 6&gt;") # sound "amencutup"
--   </pre>
run :: (Enum a, Num a, Real a) => Pattern a -> Pattern a
_run :: (Enum a, Num a) => a -> Pattern a

-- | Similar to <a>run</a>, but starts from <tt>1</tt> for the first cycle,
--   successively adds a number until it gets up to <tt>n</tt>. &gt; d1 $ n
--   (scan 8) # sound "amencutup"
scan :: (Enum a, Num a) => Pattern a -> Pattern a
_scan :: (Enum a, Num a) => a -> Pattern a

-- | Alternate between cycles of the two given patterns &gt; d1 $ append
--   (sound "bd*2 sn") (sound "arpy jvbass*2")
append :: Pattern a -> Pattern a -> Pattern a

-- | Like <a>append</a>, but for a list of patterns. Interlaces them,
--   playing the first cycle from each in turn, then the second cycle from
--   each, and so on. It concatenates a list of patterns into a new
--   pattern; each pattern in the list will maintain its original duration.
--   For example:
--   
--   <pre>
--   d1 $ cat [sound "bd*2 sn", sound "arpy jvbass*2"]
--   d1 $ cat [sound "bd*2 sn", sound "arpy jvbass*2", sound "drum*2"]
--   d1 $ cat [sound "bd*2 sn", sound "jvbass*3", sound "drum*2", sound "ht mt"]
--   </pre>
cat :: [Pattern a] -> Pattern a

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

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

-- | Like <a>append</a>, but twice as fast &gt; d1 $ fastAppend (sound
--   "bd*2 sn") (sound "arpy jvbass*2")
fastAppend :: Pattern a -> Pattern a -> Pattern a
fastappend :: Pattern a -> Pattern a -> Pattern a

-- | The same as <a>cat</a>, but speeds up the result by the number of
--   patterns there are, so the cycles from each are squashed to fit a
--   single cycle.
--   
--   <pre>
--   d1 $ fastcat [sound "bd*2 sn", sound "arpy jvbass*2"]
--   d1 $ fastcat [sound "bd*2 sn", sound "arpy jvbass*2", sound "drum*2"]
--   d1 $ fastcat [sound "bd*2 sn", sound "jvbass*3", sound "drum*2", sound "ht mt"]
--   </pre>
fastCat :: [Pattern a] -> Pattern a

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

-- | Similar to <tt>fastCat</tt>, but each pattern is given a relative
--   duration. You provide proportionate sizes of the patterns to each
--   other for when they’re concatenated into one cycle. The larger the
--   value in the list, the larger relative size the pattern takes in the
--   final loop. If all values are equal then this is equivalent to fastcat
--   (e.g. the following two code fragments are equivalent).
--   
--   <pre>
--   d1 $ fastcat [s "bd*4", s "hh27*8", s "superpiano" # n 0]
--   </pre>
--   
--   <pre>
--   d1 $ timeCat [ (1, s "bd*4")
--                , (1, s "hh27*8")
--                , (1, s "superpiano" # n 0)
--                ]
--   </pre>
timeCat :: [(Time, Pattern a)] -> Pattern a

-- | Alias for <tt>timeCat</tt>
timecat :: [(Time, Pattern a)] -> Pattern a

-- | <tt>overlay</tt> combines two <a>Pattern</a>s into a new pattern, so
--   that their events are combined over time. For example, the following
--   two lines are equivalent:
--   
--   <pre>
--   d1 $ sound (overlay "bd sn:2" "cp*3")
--   d1 $ sound "[bd sn:2, cp*3]"
--   </pre>
--   
--   <tt>overlay</tt> is equal to <a>&lt;&gt;</a>,
--   
--   <pre>
--   (&lt;&gt;) :: Semigroup a =&gt; a -&gt; a -&gt; a
--   </pre>
--   
--   which can thus be used as an infix operator equivalent of
--   <a>overlay</a>:
--   
--   <pre>
--   d1 $ sound ("bd sn:2" &lt;&gt; "cp*3")
--   </pre>
overlay :: Pattern a -> Pattern a -> Pattern a

-- | Serialises a pattern so there's only one event playing at any one
--   time, making it <i>monophonic</i>. Events which start/end earlier are
--   given priority.
mono :: Pattern a -> Pattern a

-- | <a>stack</a> combines a list of <a>Pattern</a>s into a new pattern, so
--   that their events are combined over time, i.e., all of the patterns in
--   the list are played simultaneously.
--   
--   <pre>
--   d1 $ stack [
--    sound "bd bd*2",
--    sound "hh*2 [sn cp] cp future*4",
--    sound "arpy" +| n "0 .. 15"
--   ]
--   </pre>
--   
--   This is particularly useful if you want to apply a function or synth
--   control pattern to multiple patterns at once:
--   
--   <pre>
--   d1 $ whenmod 5 3 (striate 3) $ stack [
--    sound "bd bd*2",
--    sound "hh*2 [sn cp] cp future*4",
--    sound "arpy" +| n "0 .. 15"
--   ] # speed "[[1 0.8], [1.5 2]*2]/3"
--   </pre>
stack :: [Pattern a] -> Pattern a

-- | Shifts a pattern back in time by the given amount, expressed in cycles
(<~) :: Pattern Time -> Pattern a -> Pattern a

-- | Shifts a pattern forward in time by the given amount, expressed in
--   cycles
(~>) :: Pattern Time -> Pattern a -> Pattern a

-- | Slow down a pattern by the factors in the given time pattern,
--   "squeezing" the pattern to fit the slot given in the time pattern. It
--   is the slow analogue to <a>fastSqueeze</a>.
--   
--   If the time pattern only has a single value in a cycle,
--   <tt>slowSqueeze</tt> becomes equivalent to slow. These are equivalent:
--   
--   <pre>
--   d1 $ slow "&lt;2 4&gt;" $ s "bd*8"
--   d1 $ slowSqueeze "&lt;2 4&gt;" $ s "bd*8"
--   </pre>
--   
--   When the time pattern has multiple values, however, the behavior is a
--   little different. Instead, a slowed version of the pattern will be
--   made for each value in the time pattern, and they’re all combined
--   together in a cycle according to the structure of the time pattern.
--   For example, these are equivalent:
--   
--   <pre>
--   d1 $ slowSqueeze "2 4 8 16" $ s "bd*8"
--   d1 $ s "bd*4 bd*2 bd bd/2"
--   </pre>
--   
--   as are these:
--   
--   <pre>
--   d1 $ slowSqueeze "2 4 [8 16]" $ s "bd*8"
--   d1 $ s "bd*4 bd*2 [bd bd/2]"
--   </pre>
slowSqueeze :: Pattern Time -> Pattern a -> Pattern a

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

-- | Plays a portion of a pattern, specified by a time arc (start and end
--   time). The new resulting pattern is played over the time period of the
--   original pattern.
--   
--   <pre>
--   d1 $ zoom (0.25, 0.75) $ sound "bd*2 hh*3 [sn bd]*2 drum"
--   </pre>
--   
--   In the pattern above, <tt>zoom</tt> is used with an arc from 25% to
--   75%. It is equivalent to:
--   
--   <pre>
--   d1 $ sound "hh*3 [sn bd]*2"
--   </pre>
--   
--   Here’s an example of it being used with a conditional:
--   
--   <pre>
--   d1 $ every 4 (zoom (0.25, 0.75)) $ sound "bd*2 hh*3 [sn bd]*2 drum"
--   </pre>
zoom :: (Time, Time) -> Pattern a -> Pattern a
zoompat :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a
zoomArc :: Arc -> Pattern a -> Pattern a

-- | <tt>fastGap</tt> is similar to <a>fast</a> but maintains its cyclic
--   alignment, i.e., rather than playing the pattern multiple times, it
--   instead leaves a gap in the remaining space of the cycle. For example,
--   <tt>fastGap 2 p</tt> would squash the events in pattern <tt>p</tt>
--   into the first half of each cycle (and the second halves would be
--   empty). The factor should be at least 1.
fastGap :: Pattern Time -> Pattern a -> Pattern a

-- | An alias for <tt>fastGap</tt>
densityGap :: Pattern Time -> Pattern a -> Pattern a

-- | <tt>compress</tt> takes a pattern and squeezes it within the specified
--   time span (i.e. the ‘arc’). The new resulting pattern is a sped up
--   version of the original.
--   
--   <pre>
--   d1 $ compress (1/4, 3/4) $ s "[bd sn]!"
--   </pre>
--   
--   In the above example, the pattern will play in an arc spanning from
--   25% to 75% of the duration of a cycle. It is equivalent to:
--   
--   <pre>
--   d1 $ s "~ [bd sn]! ~"
--   </pre>
--   
--   Another example, where all events are different:
--   
--   <pre>
--   d1 $ compress (1/4, 3/4) $ n (run 4) # s "arpy"
--   </pre>
--   
--   It differs from <a>zoom</a> in that it preserves the original pattern
--   but it speeds up its events so to match with the new time period.
compress :: (Time, Time) -> Pattern a -> Pattern a
compressTo :: (Time, Time) -> Pattern a -> Pattern a
repeatCycles :: Pattern Int -> Pattern a -> Pattern a
_repeatCycles :: Int -> Pattern a -> Pattern a
fastRepeatCycles :: Int -> Pattern a -> Pattern a

-- | <ul>
--   <li>Higher order functions</li>
--   </ul>
--   
--   Functions which work on other functions (higher order functions)
--   
--   <tt>every n f p</tt> applies the function <tt>f</tt> to <tt>p</tt>,
--   but only affects every <tt>n</tt> cycles.
--   
--   It takes three inputs: how often the function should be applied (e.g.
--   3 to apply it every 3 cycles), the function to be applied, and the
--   pattern you are applying it to. For example: to reverse a pattern
--   every three cycles (and for the other two play it normally)
--   
--   <pre>
--   d1 $ every 3 rev $ n "0 1 [~ 2] 3" # sound "arpy"
--   </pre>
--   
--   Note that if the function you’re applying requires additional
--   parameters itself (such as fast 2 to make a pattern twice as fast),
--   then you’ll need to wrap it in parenthesis, like so:
--   
--   <pre>
--   d1 $ every 3 (fast 2) $ n "0 1 [~ 2] 3" # sound "arpy"
--   </pre>
--   
--   Otherwise, the every function will think it is being passed too many
--   parameters.
every :: Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_every :: Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <tt>every' n o f p</tt> is like <tt>every n f p</tt> but with an
--   offset of <tt>o</tt> cycles.
--   
--   For example, <tt>every' 3 0 (fast 2)</tt> will speed up the cycle on
--   cycles 0,3,6,… whereas <tt>every' 3 1 (fast 2)</tt> will transform the
--   pattern on cycles 1,4,7,….
--   
--   With this in mind, setting the second argument of <tt>every'</tt> to 0
--   gives the equivalent every function. For example, every 3 is
--   equivalent to every' 3 0.
--   
--   The <tt>every</tt> functions can be used to silence a full cycle or
--   part of a cycle by using silent or mask "~". Mask provides additional
--   flexibility to turn on/off individual steps.
--   
--   <pre>
--   d1 $ every 3 silent $ n "2 9 11 2" # s "hh27"
--   d1 $ every 3 (mask "~") $ n "2 9 10 2" # s "hh27"
--   d1 $ every 3 (mask "0 0 0 0") $ n "2 9 11 2" # s "hh27"
--   </pre>
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>.
--   
--   It is similar to chaining multiple <tt>every</tt> functions together.
--   It transforms a pattern with a function, once per any of the given
--   number of cycles. If a particular cycle is the start of more than one
--   of the given cycle periods, then it it applied more than once.
--   
--   <pre>
--   d1 $ foldEvery [5,3] (|+ n 1) $ s "moog" # legato 1
--   </pre>
--   
--   The first moog samples are tuned to C2, C3 and C4. Note how on cycles
--   that are multiples of 3 or 5 the pitch is an octave higher, and on
--   multiples of 15 the pitch is two octaves higher, as the transformation
--   is applied twice.
foldEvery :: [Int] -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | The given pattern transformation is applied only <tt>when</tt> the
--   given test function returns <tt>True</tt>. 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 <tt>striate 4</tt> to the pattern if the
--   current cycle number contains the number 4. So the fourth cycle will
--   be striated and the fourteenth and so on. Expect lots of striates
--   after cycle number 399.
when :: (Int -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | Like <a>when</a>, but works on continuous time values rather than
--   cycle numbers. The following will apply <tt># speed 2</tt> only when
--   the remainder of the current <tt>Time</tt> divided by 2 is less than
--   0.5:
--   
--   <pre>
--   d1 $ whenT ((&lt; 0.5) . (flip Data.Fixed.mod' 2))
--              (# speed 2)
--      $ sound "hh(4,8) hc(3,8)"
--   </pre>
whenT :: (Time -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_getP_ :: (Value -> Maybe a) -> Pattern Value -> Pattern a
_getP :: a -> (Value -> Maybe a) -> Pattern Value -> Pattern a
_cX :: a -> (Value -> Maybe a) -> String -> Pattern a
_cX_ :: (Value -> Maybe a) -> String -> Pattern a
cF :: Double -> String -> Pattern Double
cF_ :: String -> Pattern Double
cF0 :: String -> Pattern Double
cN :: Note -> String -> Pattern Note
cN_ :: String -> Pattern Note
cN0 :: String -> Pattern Note
cI :: Int -> String -> Pattern Int
cI_ :: String -> Pattern Int
cI0 :: String -> Pattern Int
cB :: Bool -> String -> Pattern Bool
cB_ :: String -> Pattern Bool
cB0 :: String -> Pattern Bool
cR :: Rational -> String -> Pattern Rational
cR_ :: String -> Pattern Rational
cR0 :: String -> Pattern Rational
cT :: Time -> String -> Pattern Time
cT0 :: String -> Pattern Time
cT_ :: String -> Pattern Time
cS :: String -> String -> Pattern String
cS_ :: String -> Pattern String
cS0 :: String -> Pattern String
in0 :: Pattern Double
in1 :: Pattern Double
in2 :: Pattern Double
in3 :: Pattern Double
in4 :: Pattern Double
in5 :: Pattern Double
in6 :: Pattern Double
in7 :: Pattern Double
in8 :: Pattern Double
in9 :: Pattern Double
in10 :: Pattern Double
in11 :: Pattern Double
in12 :: Pattern Double
in13 :: Pattern Double
in14 :: Pattern Double
in15 :: Pattern Double
in16 :: Pattern Double
in17 :: Pattern Double
in18 :: Pattern Double
in19 :: Pattern Double
in20 :: Pattern Double
in21 :: Pattern Double
in22 :: Pattern Double
in23 :: Pattern Double
in24 :: Pattern Double
in25 :: Pattern Double
in26 :: Pattern Double
in27 :: Pattern Double
in28 :: Pattern Double
in29 :: Pattern Double
in30 :: Pattern Double
in31 :: Pattern Double
in32 :: Pattern Double
in33 :: Pattern Double
in34 :: Pattern Double
in35 :: Pattern Double
in36 :: Pattern Double
in37 :: Pattern Double
in38 :: Pattern Double
in39 :: Pattern Double
in40 :: Pattern Double
in41 :: Pattern Double
in42 :: Pattern Double
in43 :: Pattern Double
in44 :: Pattern Double
in45 :: Pattern Double
in46 :: Pattern Double
in47 :: Pattern Double
in48 :: Pattern Double
in49 :: Pattern Double
in50 :: Pattern Double
in51 :: Pattern Double
in52 :: Pattern Double
in53 :: Pattern Double
in54 :: Pattern Double
in55 :: Pattern Double
in56 :: Pattern Double
in57 :: Pattern Double
in58 :: Pattern Double
in59 :: Pattern Double
in60 :: Pattern Double
in61 :: Pattern Double
in62 :: Pattern Double
in63 :: Pattern Double
in64 :: Pattern Double
in65 :: Pattern Double
in66 :: Pattern Double
in67 :: Pattern Double
in68 :: Pattern Double
in69 :: Pattern Double
in70 :: Pattern Double
in71 :: Pattern Double
in72 :: Pattern Double
in73 :: Pattern Double
in74 :: Pattern Double
in75 :: Pattern Double
in76 :: Pattern Double
in77 :: Pattern Double
in78 :: Pattern Double
in79 :: Pattern Double
in80 :: Pattern Double
in81 :: Pattern Double
in82 :: Pattern Double
in83 :: Pattern Double
in84 :: Pattern Double
in85 :: Pattern Double
in86 :: Pattern Double
in87 :: Pattern Double
in88 :: Pattern Double
in89 :: Pattern Double
in90 :: Pattern Double
in91 :: Pattern Double
in92 :: Pattern Double
in93 :: Pattern Double
in94 :: Pattern Double
in95 :: Pattern Double
in96 :: Pattern Double
in97 :: Pattern Double
in98 :: Pattern Double
in99 :: Pattern Double
in100 :: Pattern Double
in101 :: Pattern Double
in102 :: Pattern Double
in103 :: Pattern Double
in104 :: Pattern Double
in105 :: Pattern Double
in106 :: Pattern Double
in107 :: Pattern Double
in108 :: Pattern Double
in109 :: Pattern Double
in110 :: Pattern Double
in111 :: Pattern Double
in112 :: Pattern Double
in113 :: Pattern Double
in114 :: Pattern Double
in115 :: Pattern Double
in116 :: Pattern Double
in117 :: Pattern Double
in118 :: Pattern Double
in119 :: Pattern Double
in120 :: Pattern Double
in121 :: Pattern Double
in122 :: Pattern Double
in123 :: Pattern Double
in124 :: Pattern Double
in125 :: Pattern Double
in126 :: Pattern Double
in127 :: Pattern Double
s_patternify :: (a -> Pattern b -> Pattern c) -> Pattern a -> Pattern b -> Pattern c
s_patternify2 :: (a -> b -> c -> Pattern d) -> Pattern a -> Pattern b -> c -> Pattern d
stepJoin :: Pattern (Pattern a) -> Pattern a
stepcat :: [Pattern a] -> Pattern a
_take :: Time -> Pattern a -> Pattern a
steptake :: Pattern Time -> Pattern a -> Pattern a
_stepdrop :: Time -> Pattern a -> Pattern a
stepdrop :: Pattern Time -> Pattern a -> Pattern a
_expand :: Rational -> Pattern a -> Pattern a
_contract :: Rational -> Pattern a -> Pattern a
expand :: Pattern Rational -> Pattern a -> Pattern a
contract :: Pattern Rational -> Pattern a -> Pattern a
_extend :: Rational -> Pattern a -> Pattern a
extend :: Pattern Rational -> Pattern a -> Pattern a

-- | Successively plays a pattern from each group in turn
stepalt :: [[Pattern a]] -> Pattern a

-- | Interprets a pattern of note numbers into a particular named scale.
--   For example:
--   
--   <pre>
--   d1
--     $ jux rev
--     $ chunk 4 (fast 2 . (|- n 12))
--     $ off 0.25 (|+ 7)
--     $ struct (iter 4 "t(5,8)")
--     $ n (scale "ritusen" "0 .. 7")
--     # sound "superpiano"
--   </pre>
scale :: Fractional a => Pattern String -> Pattern Int -> Pattern a

-- | Build a scale function, with additional scales if you wish. For
--   example:
--   
--   <pre>
--   let myscale =
--     getScale
--       ( scaleTable ++
--           [ ("techno", [0,2,3,5,7,8,10])
--           , ("broken", [0,1,4,7,8,10])
--           ]
--       )
--   </pre>
--   
--   The above takes the standard <a>scaleTable</a> as a starting point and
--   adds two custom scales to it. You’ll be able to use the new function
--   in place of the normal one:
--   
--   <pre>
--   d1 $ n (myscale "techno" "0 1 2 3 4 5 6 7") # sound "superpiano"
--   </pre>
getScale :: Fractional a => [(String, [a])] -> Pattern String -> Pattern Int -> Pattern a
scaleWith :: (Eq a, Fractional a) => Pattern String -> ([a] -> [a]) -> Pattern Int -> Pattern a
scaleWithList :: (Eq a, Fractional a) => Pattern String -> [[a] -> [a]] -> Pattern Int -> Pattern a
raiseDegree :: Fractional a => Int -> [a] -> [a]
lowerDegree :: Fractional a => Int -> [a] -> [a]
raiseDegrees :: Fractional a => Int -> Int -> [a] -> [a]
lowerDegrees :: Fractional a => Int -> Int -> [a] -> [a]

-- | Outputs this list of all the available scales:
--   
--   <pre>
--   minPent majPent ritusen egyptian kumai hirajoshi iwato chinese indian pelog
--   prometheus scriabin gong shang jiao zhi yu whole wholetone augmented augmented2
--   hexMajor7 hexDorian hexPhrygian hexSus hexMajor6 hexAeolian major ionian dorian
--   phrygian lydian mixolydian aeolian minor locrian harmonicMinor harmonicMajor
--   melodicMinor melodicMinorDesc melodicMajor bartok hindu todi purvi marva bhairav
--   ahirbhairav superLocrian romanianMinor hungarianMinor neapolitanMinor enigmatic
--   spanish leadingWhole lydianMinor neapolitanMajor locrianMajor diminished
--   octatonic diminished2 octatonic2 messiaen1 messiaen2 messiaen3 messiaen4
--   messiaen5 messiaen6 messiaen7 chromatic bayati hijaz sikah rast saba iraq
--   </pre>
scaleList :: String

-- | Outputs a list of all available scales and their corresponding notes.
--   For example, its first entry is <tt>("minPent",[0,3,5,7,10]</tt>)
--   which means that a minor pentatonic scale is formed by the root (0),
--   the minor third (3 semitones above the root), the perfect fourth (5
--   semitones above the root), etc.
--   
--   As the list is big, you can use the Haskell function lookup to look up
--   a specific scale: <tt>lookup "phrygian" scaleTable</tt>. This will
--   output <tt>Just [0.0,1.0,3.0,5.0,7.0,8.0,10.0]</tt>.
--   
--   You can also do a reverse lookup into the scale table. For example:
--   
--   <pre>
--   filter ( \(_, x) -&gt; take 3 x == [0,2,4] ) scaleTable
--   </pre>
--   
--   The above example will output all scales of which the first three
--   notes are the root, the major second (2 semitones above the
--   fundamental), and the major third (4 semitones above the root).
scaleTable :: Fractional a => [(String, [a])]

-- | Group multiple params into one.
grp :: [String -> ValueMap] -> Pattern String -> ControlPattern
mF :: String -> String -> ValueMap
mI :: String -> String -> ValueMap
mS :: String -> String -> ValueMap
pF :: String -> Pattern Double -> ControlPattern
pI :: String -> Pattern Int -> ControlPattern
pB :: String -> Pattern Bool -> ControlPattern
pR :: String -> Pattern Rational -> ControlPattern
pN :: String -> Pattern Note -> ControlPattern
pS :: String -> Pattern String -> ControlPattern
pX :: String -> Pattern [Word8] -> ControlPattern
pStateF :: String -> String -> (Maybe Double -> Double) -> ControlPattern

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

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

-- | A wrapper for <a>pStateList</a> that accepts a `[String]` rather than
--   a `[Value]`.
pStateListS :: String -> String -> [String] -> ControlPattern
sound :: Pattern String -> ControlPattern
sTake :: String -> [String] -> ControlPattern
cc :: Pattern String -> ControlPattern
nrpn :: Pattern String -> ControlPattern
nrpnn :: Pattern Int -> ControlPattern
nrpnv :: Pattern Int -> ControlPattern

-- | <tt>grain'</tt> is a shortcut to join a <tt>begin</tt> and
--   <tt>end</tt>
--   
--   These are equivalent:
--   
--   <pre>
--   d1 $ slow 2 $ s "bev" # grain' "0.2:0.3" # legato 1
--   d1 $ slow 2 $ s "bev" # begin 0.2 # end 0.3 # legato 1
--   </pre>
grain' :: Pattern String -> ControlPattern
midinote :: Pattern Note -> ControlPattern
drum :: Pattern String -> ControlPattern
drumN :: Num a => String -> a

-- | A pattern of numbers that speed up (or slow down) samples while they
--   play.
--   
--   In the following example, the sound starts at the original pitch and
--   gets higher as it plays:
--   
--   <pre>
--   d1 $ s "arpy" # accelerate 2
--   </pre>
--   
--   You can use a negative number to make the sound get lower. In this
--   example, a different acceleration is applied to each played note using
--   state values:
--   
--   <pre>
--   d1 $ arp "up" $ note "c'maj'4" # s "arpy" # accelerateTake "susan" [0.2,1,-1]
--   </pre>
accelerate :: Pattern Double -> ControlPattern
accelerateTake :: String -> [Double] -> ControlPattern
accelerateCount :: String -> ControlPattern
accelerateCountTo :: String -> Pattern Double -> Pattern ValueMap
acceleratebus :: Pattern Int -> Pattern Double -> ControlPattern

-- | Controls the amplitude (volume) of the sound. Like <a>gain</a>, but
--   linear. Default value is 0.4.
--   
--   <pre>
--   d1 $ s "arpy" # amp "&lt;0.4 0.8 0.2&gt;"
--   </pre>
amp :: Pattern Double -> ControlPattern
ampTake :: String -> [Double] -> ControlPattern
ampCount :: String -> ControlPattern
ampCountTo :: String -> Pattern Double -> Pattern ValueMap
ampbus :: Pattern Int -> Pattern Double -> ControlPattern
amprecv :: Pattern Int -> ControlPattern
arrayTake :: String -> [Double] -> ControlPattern
arraybus :: Pattern Int -> Pattern [Word8] -> ControlPattern

-- | a pattern of numbers to specify the attack time (in seconds) of an
--   envelope applied to each sample.
attack :: Pattern Double -> ControlPattern
attackTake :: String -> [Double] -> ControlPattern
attackCount :: String -> ControlPattern
attackCountTo :: String -> Pattern Double -> Pattern ValueMap
attackbus :: Pattern Int -> Pattern Double -> ControlPattern
attackrecv :: Pattern Int -> ControlPattern

-- | a pattern of numbers from 0 to 1. Sets the center frequency of the
--   band-pass filter.
bandf :: Pattern Double -> ControlPattern
bandfTake :: String -> [Double] -> ControlPattern
bandfCount :: String -> ControlPattern
bandfCountTo :: String -> Pattern Double -> Pattern ValueMap
bandfbus :: Pattern Int -> Pattern Double -> ControlPattern
bandfrecv :: Pattern Int -> ControlPattern

-- | a pattern of anumbers from 0 to 1. Sets the q-factor of the band-pass
--   filter.
bandq :: Pattern Double -> ControlPattern
bandqTake :: String -> [Double] -> ControlPattern
bandqCount :: String -> ControlPattern
bandqCountTo :: String -> Pattern Double -> Pattern ValueMap
bandqbus :: Pattern Int -> Pattern Double -> ControlPattern
bandqrecv :: Pattern Int -> ControlPattern

-- | A pattern of strings. When sent to SuperDirt, will be prepended to
--   sample folder names, separated by an underscore. This allows sample
--   sets to be organised into separate banks. See
--   <a>https://github.com/musikinformatik/SuperDirt/pull/312</a>
bank :: Pattern String -> ControlPattern

-- | <tt>begin</tt> receives a pattern of numbers from 0 to 1 and skips the
--   beginning of each sample by the indicated proportion. I.e., 0 would
--   play the sample from the start, 1 would skip the whole sample, and
--   0.25 would cut off the first quarter.
--   
--   In this example, the first 3 <tt>ade</tt> samples are played on every
--   cycle, but the start point from which they are played changes on each
--   cycle:
--   
--   <pre>
--   d1 $ n "0 1 2" # s "ade" # begin "&lt;0 0.25 0.5 0.75&gt;" # legato 1
--   </pre>
begin :: Pattern Double -> ControlPattern
beginTake :: String -> [Double] -> ControlPattern
beginCount :: String -> ControlPattern
beginCountTo :: String -> Pattern Double -> Pattern ValueMap
beginbus :: Pattern Int -> Pattern Double -> ControlPattern

-- | Spectral binshift
binshift :: Pattern Double -> ControlPattern
binshiftTake :: String -> [Double] -> ControlPattern
binshiftCount :: String -> ControlPattern
binshiftCountTo :: String -> Pattern Double -> Pattern ValueMap
binshiftbus :: Pattern Int -> Pattern Double -> ControlPattern
binshiftrecv :: Pattern Int -> ControlPattern
button0 :: Pattern Double -> ControlPattern
button0Take :: String -> [Double] -> ControlPattern
button0Count :: String -> ControlPattern
button0CountTo :: String -> Pattern Double -> Pattern ValueMap
button0bus :: Pattern Int -> Pattern Double -> ControlPattern
button0recv :: Pattern Int -> ControlPattern
button1 :: Pattern Double -> ControlPattern
button1Take :: String -> [Double] -> ControlPattern
button1Count :: String -> ControlPattern
button1CountTo :: String -> Pattern Double -> Pattern ValueMap
button1bus :: Pattern Int -> Pattern Double -> ControlPattern
button1recv :: Pattern Int -> ControlPattern
button10 :: Pattern Double -> ControlPattern
button10Take :: String -> [Double] -> ControlPattern
button10Count :: String -> ControlPattern
button10CountTo :: String -> Pattern Double -> Pattern ValueMap
button10bus :: Pattern Int -> Pattern Double -> ControlPattern
button10recv :: Pattern Int -> ControlPattern
button11 :: Pattern Double -> ControlPattern
button11Take :: String -> [Double] -> ControlPattern
button11Count :: String -> ControlPattern
button11CountTo :: String -> Pattern Double -> Pattern ValueMap
button11bus :: Pattern Int -> Pattern Double -> ControlPattern
button11recv :: Pattern Int -> ControlPattern
button12 :: Pattern Double -> ControlPattern
button12Take :: String -> [Double] -> ControlPattern
button12Count :: String -> ControlPattern
button12CountTo :: String -> Pattern Double -> Pattern ValueMap
button12bus :: Pattern Int -> Pattern Double -> ControlPattern
button12recv :: Pattern Int -> ControlPattern
button13 :: Pattern Double -> ControlPattern
button13Take :: String -> [Double] -> ControlPattern
button13Count :: String -> ControlPattern
button13CountTo :: String -> Pattern Double -> Pattern ValueMap
button13bus :: Pattern Int -> Pattern Double -> ControlPattern
button13recv :: Pattern Int -> ControlPattern
button14 :: Pattern Double -> ControlPattern
button14Take :: String -> [Double] -> ControlPattern
button14Count :: String -> ControlPattern
button14CountTo :: String -> Pattern Double -> Pattern ValueMap
button14bus :: Pattern Int -> Pattern Double -> ControlPattern
button14recv :: Pattern Int -> ControlPattern
button15 :: Pattern Double -> ControlPattern
button15Take :: String -> [Double] -> ControlPattern
button15Count :: String -> ControlPattern
button15CountTo :: String -> Pattern Double -> Pattern ValueMap
button15bus :: Pattern Int -> Pattern Double -> ControlPattern
button15recv :: Pattern Int -> ControlPattern
button2 :: Pattern Double -> ControlPattern
button2Take :: String -> [Double] -> ControlPattern
button2Count :: String -> ControlPattern
button2CountTo :: String -> Pattern Double -> Pattern ValueMap
button2bus :: Pattern Int -> Pattern Double -> ControlPattern
button2recv :: Pattern Int -> ControlPattern
button3 :: Pattern Double -> ControlPattern
button3Take :: String -> [Double] -> ControlPattern
button3Count :: String -> ControlPattern
button3CountTo :: String -> Pattern Double -> Pattern ValueMap
button3bus :: Pattern Int -> Pattern Double -> ControlPattern
button3recv :: Pattern Int -> ControlPattern
button4 :: Pattern Double -> ControlPattern
button4Take :: String -> [Double] -> ControlPattern
button4Count :: String -> ControlPattern
button4CountTo :: String -> Pattern Double -> Pattern ValueMap
button4bus :: Pattern Int -> Pattern Double -> ControlPattern
button4recv :: Pattern Int -> ControlPattern
button5 :: Pattern Double -> ControlPattern
button5Take :: String -> [Double] -> ControlPattern
button5Count :: String -> ControlPattern
button5CountTo :: String -> Pattern Double -> Pattern ValueMap
button5bus :: Pattern Int -> Pattern Double -> ControlPattern
button5recv :: Pattern Int -> ControlPattern
button6 :: Pattern Double -> ControlPattern
button6Take :: String -> [Double] -> ControlPattern
button6Count :: String -> ControlPattern
button6CountTo :: String -> Pattern Double -> Pattern ValueMap
button6bus :: Pattern Int -> Pattern Double -> ControlPattern
button6recv :: Pattern Int -> ControlPattern
button7 :: Pattern Double -> ControlPattern
button7Take :: String -> [Double] -> ControlPattern
button7Count :: String -> ControlPattern
button7CountTo :: String -> Pattern Double -> Pattern ValueMap
button7bus :: Pattern Int -> Pattern Double -> ControlPattern
button7recv :: Pattern Int -> ControlPattern
button8 :: Pattern Double -> ControlPattern
button8Take :: String -> [Double] -> ControlPattern
button8Count :: String -> ControlPattern
button8CountTo :: String -> Pattern Double -> Pattern ValueMap
button8bus :: Pattern Int -> Pattern Double -> ControlPattern
button8recv :: Pattern Int -> ControlPattern
button9 :: Pattern Double -> ControlPattern
button9Take :: String -> [Double] -> ControlPattern
button9Count :: String -> ControlPattern
button9CountTo :: String -> Pattern Double -> Pattern ValueMap
button9bus :: Pattern Int -> Pattern Double -> ControlPattern
button9recv :: Pattern Int -> ControlPattern
ccn :: Pattern Double -> ControlPattern
ccnTake :: String -> [Double] -> ControlPattern
ccnCount :: String -> ControlPattern
ccnCountTo :: String -> Pattern Double -> Pattern ValueMap
ccnbus :: Pattern Int -> Pattern Double -> ControlPattern
ccv :: Pattern Double -> ControlPattern
ccvTake :: String -> [Double] -> ControlPattern
ccvCount :: String -> ControlPattern
ccvCountTo :: String -> Pattern Double -> Pattern ValueMap
ccvbus :: Pattern Int -> Pattern Double -> ControlPattern

-- | choose the channel the pattern is sent to in superdirt
channel :: Pattern Int -> ControlPattern
channelTake :: String -> [Double] -> ControlPattern
channelCount :: String -> ControlPattern
channelCountTo :: String -> Pattern Double -> Pattern ValueMap
channelbus :: Pattern Int -> Pattern Int -> ControlPattern
clhatdecay :: Pattern Double -> ControlPattern
clhatdecayTake :: String -> [Double] -> ControlPattern
clhatdecayCount :: String -> ControlPattern
clhatdecayCountTo :: String -> Pattern Double -> Pattern ValueMap
clhatdecaybus :: Pattern Int -> Pattern Double -> ControlPattern
clhatdecayrecv :: Pattern Int -> ControlPattern

-- | fake-resampling, a pattern of numbers for lowering the sample rate,
--   i.e. 1 for original 2 for half, 3 for a third and so on.
coarse :: Pattern Double -> ControlPattern
coarseTake :: String -> [Double] -> ControlPattern
coarseCount :: String -> ControlPattern
coarseCountTo :: String -> Pattern Double -> Pattern ValueMap
coarsebus :: Pattern Int -> Pattern Double -> ControlPattern
coarserecv :: Pattern Int -> ControlPattern

-- | Spectral comb
comb :: Pattern Double -> ControlPattern
combTake :: String -> [Double] -> ControlPattern
combCount :: String -> ControlPattern
combCountTo :: String -> Pattern Double -> Pattern ValueMap
combbus :: Pattern Int -> Pattern Double -> ControlPattern
combrecv :: Pattern Int -> ControlPattern
control :: Pattern Double -> ControlPattern
controlTake :: String -> [Double] -> ControlPattern
controlCount :: String -> ControlPattern
controlCountTo :: String -> Pattern Double -> Pattern ValueMap
controlbus :: Pattern Int -> Pattern Double -> ControlPattern

-- | A control pattern; <tt>setcps</tt> is the standalone function.
--   
--   Patterns don’t (yet) have independent tempos though, if you change it
--   on one pattern, it changes on all of them.
--   
--   <pre>
--   p "cpsfun" $ s "bd sd(3,8)" # cps (slow 8 $ 0.5 + saw)
--   </pre>
cps :: Pattern Double -> ControlPattern
cpsTake :: String -> [Double] -> ControlPattern
cpsCount :: String -> ControlPattern
cpsCountTo :: String -> Pattern Double -> Pattern ValueMap
cpsbus :: Pattern Int -> Pattern Double -> ControlPattern
cpsrecv :: Pattern Int -> ControlPattern

-- | bit crushing, a pattern of numbers from 1 (for drastic reduction in
--   bit-depth) to 16 (for barely no reduction).
crush :: Pattern Double -> ControlPattern
crushTake :: String -> [Double] -> ControlPattern
crushCount :: String -> ControlPattern
crushCountTo :: String -> Pattern Double -> Pattern ValueMap
crushbus :: Pattern Int -> Pattern Double -> ControlPattern
crushrecv :: Pattern Int -> ControlPattern
ctlNum :: Pattern Double -> ControlPattern
ctlNumTake :: String -> [Double] -> ControlPattern
ctlNumCount :: String -> ControlPattern
ctlNumCountTo :: String -> Pattern Double -> Pattern ValueMap
ctlNumbus :: Pattern Int -> Pattern Double -> ControlPattern
ctranspose :: Pattern Double -> ControlPattern
ctransposeTake :: String -> [Double] -> ControlPattern
ctransposeCount :: String -> ControlPattern
ctransposeCountTo :: String -> Pattern Double -> Pattern ValueMap
ctransposebus :: Pattern Int -> Pattern Double -> ControlPattern
ctransposerecv :: Pattern Int -> ControlPattern

-- | In the style of classic drum-machines, <a>cut</a> will stop a playing
--   sample as soon as another samples with in same cutgroup is to be
--   played. An example would be an open hi-hat followed by a closed one,
--   essentially muting the open.
cut :: Pattern Int -> ControlPattern
cutTake :: String -> [Double] -> ControlPattern
cutCount :: String -> ControlPattern
cutCountTo :: String -> Pattern Double -> Pattern ValueMap
cutbus :: Pattern Int -> Pattern Int -> ControlPattern
cutrecv :: Pattern Int -> ControlPattern

-- | a pattern of numbers in Hz. Applies the cutoff frequency of the
--   low-pass filter.
cutoff :: Pattern Double -> ControlPattern
cutoffTake :: String -> [Double] -> ControlPattern
cutoffCount :: String -> ControlPattern
cutoffCountTo :: String -> Pattern Double -> Pattern ValueMap
cutoffbus :: Pattern Int -> Pattern Double -> ControlPattern
cutoffrecv :: Pattern Int -> ControlPattern
cutoffegint :: Pattern Double -> ControlPattern
cutoffegintTake :: String -> [Double] -> ControlPattern
cutoffegintCount :: String -> ControlPattern
cutoffegintCountTo :: String -> Pattern Double -> Pattern ValueMap
cutoffegintbus :: Pattern Int -> Pattern Double -> ControlPattern
cutoffegintrecv :: Pattern Int -> ControlPattern
decay :: Pattern Double -> ControlPattern
decayTake :: String -> [Double] -> ControlPattern
decayCount :: String -> ControlPattern
decayCountTo :: String -> Pattern Double -> Pattern ValueMap
decaybus :: Pattern Int -> Pattern Double -> ControlPattern
decayrecv :: Pattern Int -> ControlPattern
degree :: Pattern Double -> ControlPattern
degreeTake :: String -> [Double] -> ControlPattern
degreeCount :: String -> ControlPattern
degreeCountTo :: String -> Pattern Double -> Pattern ValueMap
degreebus :: Pattern Int -> Pattern Double -> ControlPattern
degreerecv :: Pattern Int -> ControlPattern

-- | a pattern of numbers from 0 to 1. Sets the level of the delay signal.
delay :: Pattern Double -> ControlPattern
delayTake :: String -> [Double] -> ControlPattern
delayCount :: String -> ControlPattern
delayCountTo :: String -> Pattern Double -> Pattern ValueMap
delaybus :: Pattern Int -> Pattern Double -> ControlPattern
delayrecv :: Pattern Int -> ControlPattern

-- | a pattern of numbers from 0 to 1. Sets the amount of delay feedback.
delayfeedback :: Pattern Double -> ControlPattern
delayfeedbackTake :: String -> [Double] -> ControlPattern
delayfeedbackCount :: String -> ControlPattern
delayfeedbackCountTo :: String -> Pattern Double -> Pattern ValueMap
delayfeedbackbus :: Pattern Int -> Pattern Double -> ControlPattern
delayfeedbackrecv :: Pattern Int -> ControlPattern

-- | a pattern of numbers from 0 to 1. Sets the length of the delay.
delaytime :: Pattern Double -> ControlPattern
delaytimeTake :: String -> [Double] -> ControlPattern
delaytimeCount :: String -> ControlPattern
delaytimeCountTo :: String -> Pattern Double -> Pattern ValueMap
delaytimebus :: Pattern Int -> Pattern Double -> ControlPattern
delaytimerecv :: Pattern Int -> ControlPattern
detune :: Pattern Double -> ControlPattern
detuneTake :: String -> [Double] -> ControlPattern
detuneCount :: String -> ControlPattern
detuneCountTo :: String -> Pattern Double -> Pattern ValueMap
detunebus :: Pattern Int -> Pattern Double -> ControlPattern
detunerecv :: Pattern Int -> ControlPattern

-- | noisy fuzzy distortion
distort :: Pattern Double -> ControlPattern
distortTake :: String -> [Double] -> ControlPattern
distortCount :: String -> ControlPattern
distortCountTo :: String -> Pattern Double -> Pattern ValueMap
distortbus :: Pattern Int -> Pattern Double -> ControlPattern
distortrecv :: Pattern Int -> ControlPattern

-- | DJ filter, below 0.5 is low pass filter, above is high pass filter.
djf :: Pattern Double -> ControlPattern
djfTake :: String -> [Double] -> ControlPattern
djfCount :: String -> ControlPattern
djfCountTo :: String -> Pattern Double -> Pattern ValueMap
djfbus :: Pattern Int -> Pattern Double -> ControlPattern
djfrecv :: Pattern Int -> ControlPattern

-- | when set to `1` will disable all reverb for this pattern. See
--   <a>room</a> and <a>size</a> for more information about reverb.
dry :: Pattern Double -> ControlPattern
dryTake :: String -> [Double] -> ControlPattern
dryCount :: String -> ControlPattern
dryCountTo :: String -> Pattern Double -> Pattern ValueMap
drybus :: Pattern Int -> Pattern Double -> ControlPattern
dryrecv :: Pattern Int -> ControlPattern
dur :: Pattern Double -> ControlPattern
durTake :: String -> [Double] -> ControlPattern
durCount :: String -> ControlPattern
durCountTo :: String -> Pattern Double -> Pattern ValueMap
durbus :: Pattern Int -> Pattern Double -> ControlPattern
durrecv :: Pattern Int -> ControlPattern

-- | Similar to <a>begin</a>, but cuts the end off samples, shortening
--   them; e.g. 0.75 to cut off the last quarter of each sample.
--   
--   <pre>
--   d1 $ s "bev" &gt;| begin 0.5 &gt;| end "[0.65 0.55]"
--   </pre>
--   
--   The example above will play the sample two times for cycle, but the
--   second time will play a shorter segment than the first time, creating
--   a kind of canon effect.
end :: Pattern Double -> ControlPattern
endTake :: String -> [Double] -> ControlPattern
endCount :: String -> ControlPattern
endCountTo :: String -> Pattern Double -> Pattern ValueMap
endbus :: Pattern Int -> Pattern Double -> ControlPattern

-- | Spectral enhance
enhance :: Pattern Double -> ControlPattern
enhanceTake :: String -> [Double] -> ControlPattern
enhanceCount :: String -> ControlPattern
enhanceCountTo :: String -> Pattern Double -> Pattern ValueMap
enhancebus :: Pattern Int -> Pattern Double -> ControlPattern
enhancerecv :: Pattern Int -> ControlPattern
expression :: Pattern Double -> ControlPattern
expressionTake :: String -> [Double] -> ControlPattern
expressionCount :: String -> ControlPattern
expressionCountTo :: String -> Pattern Double -> Pattern ValueMap
expressionbus :: Pattern Int -> Pattern Double -> ControlPattern
expressionrecv :: Pattern Int -> ControlPattern

-- | As with fadeTime, but controls the fade in time of the grain envelope.
--   Not used if the grain begins at position 0 in the sample.
fadeInTime :: Pattern Double -> ControlPattern
fadeInTimeTake :: String -> [Double] -> ControlPattern
fadeInTimeCount :: String -> ControlPattern
fadeInTimeCountTo :: String -> Pattern Double -> Pattern ValueMap
fadeInTimebus :: Pattern Int -> Pattern Double -> ControlPattern

-- | Used when using begin<i>end or chop</i>striate and friends, to change
--   the fade out time of the <tt>grain</tt> envelope.
fadeTime :: Pattern Double -> ControlPattern
fadeTimeTake :: String -> [Double] -> ControlPattern
fadeTimeCount :: String -> ControlPattern
fadeTimeCountTo :: String -> Pattern Double -> Pattern ValueMap
fadeTimebus :: Pattern Int -> Pattern Double -> ControlPattern
frameRate :: Pattern Double -> ControlPattern
frameRateTake :: String -> [Double] -> ControlPattern
frameRateCount :: String -> ControlPattern
frameRateCountTo :: String -> Pattern Double -> Pattern ValueMap
frameRatebus :: Pattern Int -> Pattern Double -> ControlPattern
frames :: Pattern Double -> ControlPattern
framesTake :: String -> [Double] -> ControlPattern
framesCount :: String -> ControlPattern
framesCountTo :: String -> Pattern Double -> Pattern ValueMap
framesbus :: Pattern Int -> Pattern Double -> ControlPattern

-- | Spectral freeze
freeze :: Pattern Double -> ControlPattern
freezeTake :: String -> [Double] -> ControlPattern
freezeCount :: String -> ControlPattern
freezeCountTo :: String -> Pattern Double -> Pattern ValueMap
freezebus :: Pattern Int -> Pattern Double -> ControlPattern
freezerecv :: Pattern Int -> ControlPattern
freq :: Pattern Double -> ControlPattern
freqTake :: String -> [Double] -> ControlPattern
freqCount :: String -> ControlPattern
freqCountTo :: String -> Pattern Double -> Pattern ValueMap
freqbus :: Pattern Int -> Pattern Double -> ControlPattern
freqrecv :: Pattern Int -> ControlPattern

-- | for internal sound routing
from :: Pattern Double -> ControlPattern
fromTake :: String -> [Double] -> ControlPattern
fromCount :: String -> ControlPattern
fromCountTo :: String -> Pattern Double -> Pattern ValueMap
frombus :: Pattern Int -> Pattern Double -> ControlPattern
fromrecv :: Pattern Int -> ControlPattern

-- | frequency shifter
fshift :: Pattern Double -> ControlPattern
fshiftTake :: String -> [Double] -> ControlPattern
fshiftCount :: String -> ControlPattern
fshiftCountTo :: String -> Pattern Double -> Pattern ValueMap
fshiftbus :: Pattern Int -> Pattern Double -> ControlPattern
fshiftrecv :: Pattern Int -> ControlPattern

-- | frequency shifter
fshiftnote :: Pattern Double -> ControlPattern
fshiftnoteTake :: String -> [Double] -> ControlPattern
fshiftnoteCount :: String -> ControlPattern
fshiftnoteCountTo :: String -> Pattern Double -> Pattern ValueMap
fshiftnotebus :: Pattern Int -> Pattern Double -> ControlPattern
fshiftnoterecv :: Pattern Int -> ControlPattern

-- | frequency shifter
fshiftphase :: Pattern Double -> ControlPattern
fshiftphaseTake :: String -> [Double] -> ControlPattern
fshiftphaseCount :: String -> ControlPattern
fshiftphaseCountTo :: String -> Pattern Double -> Pattern ValueMap
fshiftphasebus :: Pattern Int -> Pattern Double -> ControlPattern
fshiftphaserecv :: Pattern Int -> ControlPattern

-- | Used to control the amplitude (volume) of the sound. Values less than
--   1 make the sound quieter and values greater than 1 make the sound
--   louder.
--   
--   <tt>gain</tt> uses a power function, so the volume change around 1 is
--   subtle, but it gets more noticeable as it increases or decreases.
--   Typical values for <tt>gain</tt> are between 0 and 1.5.
--   
--   For the linear equivalent, see <a>amp</a>.
--   
--   <pre>
--   d1 $ s "arpy" # gain 0.8
--   </pre>
--   
--   This plays the first arpy sample at a quieter level than the default.
--   
--   <pre>
--   d1 $ s "ab*16" # gain (range 0.8 1.3 $ sine)
--   </pre>
--   
--   This plays a hihat sound, 16 times per cycle, with a <tt>gain</tt>
--   moving from 0.8 to 1.3 following a sine wave.
gain :: Pattern Double -> ControlPattern
gainTake :: String -> [Double] -> ControlPattern
gainCount :: String -> ControlPattern
gainCountTo :: String -> Pattern Double -> Pattern ValueMap
gainbus :: Pattern Int -> Pattern Double -> ControlPattern
gate :: Pattern Double -> ControlPattern
gateTake :: String -> [Double] -> ControlPattern
gateCount :: String -> ControlPattern
gateCountTo :: String -> Pattern Double -> Pattern ValueMap
gatebus :: Pattern Int -> Pattern Double -> ControlPattern
gaterecv :: Pattern Int -> ControlPattern
harmonic :: Pattern Double -> ControlPattern
harmonicTake :: String -> [Double] -> ControlPattern
harmonicCount :: String -> ControlPattern
harmonicCountTo :: String -> Pattern Double -> Pattern ValueMap
harmonicbus :: Pattern Int -> Pattern Double -> ControlPattern
harmonicrecv :: Pattern Int -> ControlPattern
hatgrain :: Pattern Double -> ControlPattern
hatgrainTake :: String -> [Double] -> ControlPattern
hatgrainCount :: String -> ControlPattern
hatgrainCountTo :: String -> Pattern Double -> Pattern ValueMap
hatgrainbus :: Pattern Int -> Pattern Double -> ControlPattern
hatgrainrecv :: Pattern Int -> ControlPattern

-- | High pass sort of spectral filter
hbrick :: Pattern Double -> ControlPattern
hbrickTake :: String -> [Double] -> ControlPattern
hbrickCount :: String -> ControlPattern
hbrickCountTo :: String -> Pattern Double -> Pattern ValueMap
hbrickbus :: Pattern Int -> Pattern Double -> ControlPattern
hbrickrecv :: Pattern Int -> ControlPattern

-- | a pattern of numbers from 0 to 1. Applies the cutoff frequency of the
--   high-pass filter. Also has alias <tt>hpf</tt>
hcutoff :: Pattern Double -> ControlPattern
hcutoffTake :: String -> [Double] -> ControlPattern
hcutoffCount :: String -> ControlPattern
hcutoffCountTo :: String -> Pattern Double -> Pattern ValueMap
hcutoffbus :: Pattern Int -> Pattern Double -> ControlPattern
hcutoffrecv :: Pattern Int -> ControlPattern

-- | a pattern of numbers to specify the hold time (in seconds) of an
--   envelope applied to each sample. Only takes effect if <a>attack</a>
--   and <a>release</a> are also specified.
hold :: Pattern Double -> ControlPattern
holdTake :: String -> [Double] -> ControlPattern
holdCount :: String -> ControlPattern
holdCountTo :: String -> Pattern Double -> Pattern ValueMap
holdbus :: Pattern Int -> Pattern Double -> ControlPattern
holdrecv :: Pattern Int -> ControlPattern
hours :: Pattern Double -> ControlPattern
hoursTake :: String -> [Double] -> ControlPattern
hoursCount :: String -> ControlPattern
hoursCountTo :: String -> Pattern Double -> Pattern ValueMap
hoursbus :: Pattern Int -> Pattern Double -> ControlPattern

-- | a pattern of numbers from 0 to 1. Applies the resonance of the
--   high-pass filter. Has alias <tt>hpq</tt>
hresonance :: Pattern Double -> ControlPattern
hresonanceTake :: String -> [Double] -> ControlPattern
hresonanceCount :: String -> ControlPattern
hresonanceCountTo :: String -> Pattern Double -> Pattern ValueMap
hresonancebus :: Pattern Int -> Pattern Double -> ControlPattern
hresonancerecv :: Pattern Int -> ControlPattern
imag :: Pattern Double -> ControlPattern
imagTake :: String -> [Double] -> ControlPattern
imagCount :: String -> ControlPattern
imagCountTo :: String -> Pattern Double -> Pattern ValueMap
imagbus :: Pattern Int -> Pattern Double -> ControlPattern
imagrecv :: Pattern Int -> ControlPattern
kcutoff :: Pattern Double -> ControlPattern
kcutoffTake :: String -> [Double] -> ControlPattern
kcutoffCount :: String -> ControlPattern
kcutoffCountTo :: String -> Pattern Double -> Pattern ValueMap
kcutoffbus :: Pattern Int -> Pattern Double -> ControlPattern
kcutoffrecv :: Pattern Int -> ControlPattern

-- | shape/bass enhancer
krush :: Pattern Double -> ControlPattern
krushTake :: String -> [Double] -> ControlPattern
krushCount :: String -> ControlPattern
krushCountTo :: String -> Pattern Double -> Pattern ValueMap
krushbus :: Pattern Int -> Pattern Double -> ControlPattern
krushrecv :: Pattern Int -> ControlPattern
lagogo :: Pattern Double -> ControlPattern
lagogoTake :: String -> [Double] -> ControlPattern
lagogoCount :: String -> ControlPattern
lagogoCountTo :: String -> Pattern Double -> Pattern ValueMap
lagogobus :: Pattern Int -> Pattern Double -> ControlPattern
lagogorecv :: Pattern Int -> ControlPattern

-- | Low pass sort of spectral filter
lbrick :: Pattern Double -> ControlPattern
lbrickTake :: String -> [Double] -> ControlPattern
lbrickCount :: String -> ControlPattern
lbrickCountTo :: String -> Pattern Double -> Pattern ValueMap
lbrickbus :: Pattern Int -> Pattern Double -> ControlPattern
lbrickrecv :: Pattern Int -> ControlPattern
lclap :: Pattern Double -> ControlPattern
lclapTake :: String -> [Double] -> ControlPattern
lclapCount :: String -> ControlPattern
lclapCountTo :: String -> Pattern Double -> Pattern ValueMap
lclapbus :: Pattern Int -> Pattern Double -> ControlPattern
lclaprecv :: Pattern Int -> ControlPattern
lclaves :: Pattern Double -> ControlPattern
lclavesTake :: String -> [Double] -> ControlPattern
lclavesCount :: String -> ControlPattern
lclavesCountTo :: String -> Pattern Double -> Pattern ValueMap
lclavesbus :: Pattern Int -> Pattern Double -> ControlPattern
lclavesrecv :: Pattern Int -> ControlPattern
lclhat :: Pattern Double -> ControlPattern
lclhatTake :: String -> [Double] -> ControlPattern
lclhatCount :: String -> ControlPattern
lclhatCountTo :: String -> Pattern Double -> Pattern ValueMap
lclhatbus :: Pattern Int -> Pattern Double -> ControlPattern
lclhatrecv :: Pattern Int -> ControlPattern
lcrash :: Pattern Double -> ControlPattern
lcrashTake :: String -> [Double] -> ControlPattern
lcrashCount :: String -> ControlPattern
lcrashCountTo :: String -> Pattern Double -> Pattern ValueMap
lcrashbus :: Pattern Int -> Pattern Double -> ControlPattern
lcrashrecv :: Pattern Int -> ControlPattern

-- | controls the amount of overlap between two adjacent sounds
legato :: Pattern Double -> ControlPattern
legatoTake :: String -> [Double] -> ControlPattern
legatoCount :: String -> ControlPattern
legatoCountTo :: String -> Pattern Double -> Pattern ValueMap
legatobus :: Pattern Int -> Pattern Double -> ControlPattern
clip :: Pattern Double -> ControlPattern
leslie :: Pattern Double -> ControlPattern
leslieTake :: String -> [Double] -> ControlPattern
leslieCount :: String -> ControlPattern
leslieCountTo :: String -> Pattern Double -> Pattern ValueMap
lesliebus :: Pattern Int -> Pattern Double -> ControlPattern
leslierecv :: Pattern Int -> ControlPattern
lfo :: Pattern Double -> ControlPattern
lfoTake :: String -> [Double] -> ControlPattern
lfoCount :: String -> ControlPattern
lfoCountTo :: String -> Pattern Double -> Pattern ValueMap
lfobus :: Pattern Int -> Pattern Double -> ControlPattern
lforecv :: Pattern Int -> ControlPattern
lfocutoffint :: Pattern Double -> ControlPattern
lfocutoffintTake :: String -> [Double] -> ControlPattern
lfocutoffintCount :: String -> ControlPattern
lfocutoffintCountTo :: String -> Pattern Double -> Pattern ValueMap
lfocutoffintbus :: Pattern Int -> Pattern Double -> ControlPattern
lfocutoffintrecv :: Pattern Int -> ControlPattern
lfodelay :: Pattern Double -> ControlPattern
lfodelayTake :: String -> [Double] -> ControlPattern
lfodelayCount :: String -> ControlPattern
lfodelayCountTo :: String -> Pattern Double -> Pattern ValueMap
lfodelaybus :: Pattern Int -> Pattern Double -> ControlPattern
lfodelayrecv :: Pattern Int -> ControlPattern
lfoint :: Pattern Double -> ControlPattern
lfointTake :: String -> [Double] -> ControlPattern
lfointCount :: String -> ControlPattern
lfointCountTo :: String -> Pattern Double -> Pattern ValueMap
lfointbus :: Pattern Int -> Pattern Double -> ControlPattern
lfointrecv :: Pattern Int -> ControlPattern
lfopitchint :: Pattern Double -> ControlPattern
lfopitchintTake :: String -> [Double] -> ControlPattern
lfopitchintCount :: String -> ControlPattern
lfopitchintCountTo :: String -> Pattern Double -> Pattern ValueMap
lfopitchintbus :: Pattern Int -> Pattern Double -> ControlPattern
lfopitchintrecv :: Pattern Int -> ControlPattern
lfoshape :: Pattern Double -> ControlPattern
lfoshapeTake :: String -> [Double] -> ControlPattern
lfoshapeCount :: String -> ControlPattern
lfoshapeCountTo :: String -> Pattern Double -> Pattern ValueMap
lfoshapebus :: Pattern Int -> Pattern Double -> ControlPattern
lfoshaperecv :: Pattern Int -> ControlPattern
lfosync :: Pattern Double -> ControlPattern
lfosyncTake :: String -> [Double] -> ControlPattern
lfosyncCount :: String -> ControlPattern
lfosyncCountTo :: String -> Pattern Double -> Pattern ValueMap
lfosyncbus :: Pattern Int -> Pattern Double -> ControlPattern
lfosyncrecv :: Pattern Int -> ControlPattern
lhitom :: Pattern Double -> ControlPattern
lhitomTake :: String -> [Double] -> ControlPattern
lhitomCount :: String -> ControlPattern
lhitomCountTo :: String -> Pattern Double -> Pattern ValueMap
lhitombus :: Pattern Int -> Pattern Double -> ControlPattern
lhitomrecv :: Pattern Int -> ControlPattern
lkick :: Pattern Double -> ControlPattern
lkickTake :: String -> [Double] -> ControlPattern
lkickCount :: String -> ControlPattern
lkickCountTo :: String -> Pattern Double -> Pattern ValueMap
lkickbus :: Pattern Int -> Pattern Double -> ControlPattern
lkickrecv :: Pattern Int -> ControlPattern
llotom :: Pattern Double -> ControlPattern
llotomTake :: String -> [Double] -> ControlPattern
llotomCount :: String -> ControlPattern
llotomCountTo :: String -> Pattern Double -> Pattern ValueMap
llotombus :: Pattern Int -> Pattern Double -> ControlPattern
llotomrecv :: Pattern Int -> ControlPattern

-- | A pattern of numbers. Specifies whether delaytime is calculated
--   relative to cps. When set to 1, delaytime is a direct multiple of a
--   cycle.
lock :: Pattern Double -> ControlPattern
lockTake :: String -> [Double] -> ControlPattern
lockCount :: String -> ControlPattern
lockCountTo :: String -> Pattern Double -> Pattern ValueMap
lockbus :: Pattern Int -> Pattern Double -> ControlPattern
lockrecv :: Pattern Int -> ControlPattern

-- | loops the sample (from <a>begin</a> to <a>end</a>) the specified
--   number of times.
loop :: Pattern Double -> ControlPattern
loopTake :: String -> [Double] -> ControlPattern
loopCount :: String -> ControlPattern
loopCountTo :: String -> Pattern Double -> Pattern ValueMap
loopbus :: Pattern Int -> Pattern Double -> ControlPattern
lophat :: Pattern Double -> ControlPattern
lophatTake :: String -> [Double] -> ControlPattern
lophatCount :: String -> ControlPattern
lophatCountTo :: String -> Pattern Double -> Pattern ValueMap
lophatbus :: Pattern Int -> Pattern Double -> ControlPattern
lophatrecv :: Pattern Int -> ControlPattern
lrate :: Pattern Double -> ControlPattern
lrateTake :: String -> [Double] -> ControlPattern
lrateCount :: String -> ControlPattern
lrateCountTo :: String -> Pattern Double -> Pattern ValueMap
lratebus :: Pattern Int -> Pattern Double -> ControlPattern
lraterecv :: Pattern Int -> ControlPattern
lsize :: Pattern Double -> ControlPattern
lsizeTake :: String -> [Double] -> ControlPattern
lsizeCount :: String -> ControlPattern
lsizeCountTo :: String -> Pattern Double -> Pattern ValueMap
lsizebus :: Pattern Int -> Pattern Double -> ControlPattern
lsizerecv :: Pattern Int -> ControlPattern
lsnare :: Pattern Double -> ControlPattern
lsnareTake :: String -> [Double] -> ControlPattern
lsnareCount :: String -> ControlPattern
lsnareCountTo :: String -> Pattern Double -> Pattern ValueMap
lsnarebus :: Pattern Int -> Pattern Double -> ControlPattern
lsnarerecv :: Pattern Int -> ControlPattern

-- | A pattern of numbers. Specifies whether the pitch of played samples
--   should be tuned relative to their pitch metadata, if it exists. When
--   set to 1, pitch metadata is applied. When set to 0, pitch metadata is
--   ignored.
metatune :: Pattern Double -> ControlPattern
metatuneTake :: String -> [Double] -> ControlPattern
metatuneCount :: String -> ControlPattern
metatuneCountTo :: String -> Pattern Double -> Pattern ValueMap
metatunebus :: Pattern Int -> Pattern Double -> ControlPattern
metatunerecv :: Pattern Int -> ControlPattern
midibend :: Pattern Double -> ControlPattern
midibendTake :: String -> [Double] -> ControlPattern
midibendCount :: String -> ControlPattern
midibendCountTo :: String -> Pattern Double -> Pattern ValueMap
midibendbus :: Pattern Int -> Pattern Double -> ControlPattern
midichan :: Pattern Double -> ControlPattern
midichanTake :: String -> [Double] -> ControlPattern
midichanCount :: String -> ControlPattern
midichanCountTo :: String -> Pattern Double -> Pattern ValueMap
midichanbus :: Pattern Int -> Pattern Double -> ControlPattern
midicmd :: Pattern String -> ControlPattern
midicmdTake :: String -> [Double] -> ControlPattern
midicmdbus :: Pattern Int -> Pattern String -> ControlPattern
miditouch :: Pattern Double -> ControlPattern
miditouchTake :: String -> [Double] -> ControlPattern
miditouchCount :: String -> ControlPattern
miditouchCountTo :: String -> Pattern Double -> Pattern ValueMap
miditouchbus :: Pattern Int -> Pattern Double -> ControlPattern
minutes :: Pattern Double -> ControlPattern
minutesTake :: String -> [Double] -> ControlPattern
minutesCount :: String -> ControlPattern
minutesCountTo :: String -> Pattern Double -> Pattern ValueMap
minutesbus :: Pattern Int -> Pattern Double -> ControlPattern
modwheel :: Pattern Double -> ControlPattern
modwheelTake :: String -> [Double] -> ControlPattern
modwheelCount :: String -> ControlPattern
modwheelCountTo :: String -> Pattern Double -> Pattern ValueMap
modwheelbus :: Pattern Int -> Pattern Double -> ControlPattern
modwheelrecv :: Pattern Int -> ControlPattern
mtranspose :: Pattern Double -> ControlPattern
mtransposeTake :: String -> [Double] -> ControlPattern
mtransposeCount :: String -> ControlPattern
mtransposeCountTo :: String -> Pattern Double -> Pattern ValueMap
mtransposebus :: Pattern Int -> Pattern Double -> ControlPattern
mtransposerecv :: Pattern Int -> ControlPattern

-- | The note or sample number to choose for a synth or sampleset
n :: Pattern Note -> ControlPattern
nTake :: String -> [Double] -> ControlPattern
nCount :: String -> ControlPattern
nCountTo :: String -> Pattern Double -> Pattern ValueMap
nbus :: Pattern Int -> Pattern Note -> ControlPattern

-- | The note or pitch to play a sound or synth with
note :: Pattern Note -> ControlPattern
noteTake :: String -> [Double] -> ControlPattern
noteCount :: String -> ControlPattern
noteCountTo :: String -> Pattern Double -> Pattern ValueMap
notebus :: Pattern Int -> Pattern Note -> ControlPattern

-- | Nudges events into the future by the specified number of seconds.
--   Negative numbers work up to a point as well (due to internal latency)
nudge :: Pattern Double -> ControlPattern
nudgeTake :: String -> [Double] -> ControlPattern
nudgeCount :: String -> ControlPattern
nudgeCountTo :: String -> Pattern Double -> Pattern ValueMap
nudgebus :: Pattern Int -> Pattern Double -> ControlPattern
nudgerecv :: Pattern Int -> ControlPattern
octave :: Pattern Int -> ControlPattern
octaveTake :: String -> [Double] -> ControlPattern
octaveCount :: String -> ControlPattern
octaveCountTo :: String -> Pattern Double -> Pattern ValueMap
octavebus :: Pattern Int -> Pattern Int -> ControlPattern
octaveR :: Pattern Double -> ControlPattern
octaveRTake :: String -> [Double] -> ControlPattern
octaveRCount :: String -> ControlPattern
octaveRCountTo :: String -> Pattern Double -> Pattern ValueMap
octaveRbus :: Pattern Int -> Pattern Double -> ControlPattern
octaveRrecv :: Pattern Int -> ControlPattern

-- | octaver effect
octer :: Pattern Double -> ControlPattern
octerTake :: String -> [Double] -> ControlPattern
octerCount :: String -> ControlPattern
octerCountTo :: String -> Pattern Double -> Pattern ValueMap
octerbus :: Pattern Int -> Pattern Double -> ControlPattern
octerrecv :: Pattern Int -> ControlPattern

-- | octaver effect
octersub :: Pattern Double -> ControlPattern
octersubTake :: String -> [Double] -> ControlPattern
octersubCount :: String -> ControlPattern
octersubCountTo :: String -> Pattern Double -> Pattern ValueMap
octersubbus :: Pattern Int -> Pattern Double -> ControlPattern
octersubrecv :: Pattern Int -> ControlPattern

-- | octaver effect
octersubsub :: Pattern Double -> ControlPattern
octersubsubTake :: String -> [Double] -> ControlPattern
octersubsubCount :: String -> ControlPattern
octersubsubCountTo :: String -> Pattern Double -> Pattern ValueMap
octersubsubbus :: Pattern Int -> Pattern Double -> ControlPattern
octersubsubrecv :: Pattern Int -> ControlPattern
offset :: Pattern Double -> ControlPattern
offsetTake :: String -> [Double] -> ControlPattern
offsetCount :: String -> ControlPattern
offsetCountTo :: String -> Pattern Double -> Pattern ValueMap
offsetbus :: Pattern Int -> Pattern Double -> ControlPattern
ophatdecay :: Pattern Double -> ControlPattern
ophatdecayTake :: String -> [Double] -> ControlPattern
ophatdecayCount :: String -> ControlPattern
ophatdecayCountTo :: String -> Pattern Double -> Pattern ValueMap
ophatdecaybus :: Pattern Int -> Pattern Double -> ControlPattern
ophatdecayrecv :: Pattern Int -> ControlPattern

-- | a pattern of numbers. An "orbit" is a global parameter context for
--   patterns. Patterns with the same orbit will share hardware output bus
--   offset and global effects, e.g. reverb and delay. The maximum number
--   of orbits is specified in the superdirt startup, numbers higher than
--   maximum will wrap around.
orbit :: Pattern Int -> ControlPattern
orbitTake :: String -> [Double] -> ControlPattern
orbitCount :: String -> ControlPattern
orbitCountTo :: String -> Pattern Double -> Pattern ValueMap
orbitbus :: Pattern Int -> Pattern Int -> ControlPattern
orbitrecv :: Pattern Int -> ControlPattern
overgain :: Pattern Double -> ControlPattern
overgainTake :: String -> [Double] -> ControlPattern
overgainCount :: String -> ControlPattern
overgainCountTo :: String -> Pattern Double -> Pattern ValueMap
overgainbus :: Pattern Int -> Pattern Double -> ControlPattern
overshape :: Pattern Double -> ControlPattern
overshapeTake :: String -> [Double] -> ControlPattern
overshapeCount :: String -> ControlPattern
overshapeCountTo :: String -> Pattern Double -> Pattern ValueMap
overshapebus :: Pattern Int -> Pattern Double -> ControlPattern
overshaperecv :: Pattern Int -> ControlPattern

-- | a pattern of numbers between 0 and 1, from left to right (assuming
--   stereo), once round a circle (assuming multichannel)
pan :: Pattern Double -> ControlPattern
panTake :: String -> [Double] -> ControlPattern
panCount :: String -> ControlPattern
panCountTo :: String -> Pattern Double -> Pattern ValueMap
panbus :: Pattern Int -> Pattern Double -> ControlPattern
panrecv :: Pattern Int -> ControlPattern

-- | a pattern of numbers between -1.0 and 1.0, which controls the relative
--   position of the centre pan in a pair of adjacent speakers
--   (multichannel only)
panorient :: Pattern Double -> ControlPattern
panorientTake :: String -> [Double] -> ControlPattern
panorientCount :: String -> ControlPattern
panorientCountTo :: String -> Pattern Double -> Pattern ValueMap
panorientbus :: Pattern Int -> Pattern Double -> ControlPattern
panorientrecv :: Pattern Int -> ControlPattern

-- | a pattern of numbers between -inf and inf, which controls how much
--   multichannel output is fanned out (negative is backwards ordering)
panspan :: Pattern Double -> ControlPattern
panspanTake :: String -> [Double] -> ControlPattern
panspanCount :: String -> ControlPattern
panspanCountTo :: String -> Pattern Double -> Pattern ValueMap
panspanbus :: Pattern Int -> Pattern Double -> ControlPattern
panspanrecv :: Pattern Int -> ControlPattern

-- | a pattern of numbers between 0.0 and 1.0, which controls the
--   multichannel spread range (multichannel only)
pansplay :: Pattern Double -> ControlPattern
pansplayTake :: String -> [Double] -> ControlPattern
pansplayCount :: String -> ControlPattern
pansplayCountTo :: String -> Pattern Double -> Pattern ValueMap
pansplaybus :: Pattern Int -> Pattern Double -> ControlPattern
pansplayrecv :: Pattern Int -> ControlPattern

-- | a pattern of numbers between 0.0 and inf, which controls how much each
--   channel is distributed over neighbours (multichannel only)
panwidth :: Pattern Double -> ControlPattern
panwidthTake :: String -> [Double] -> ControlPattern
panwidthCount :: String -> ControlPattern
panwidthCountTo :: String -> Pattern Double -> Pattern ValueMap
panwidthbus :: Pattern Int -> Pattern Double -> ControlPattern
panwidthrecv :: Pattern Int -> ControlPattern
partials :: Pattern Double -> ControlPattern
partialsTake :: String -> [Double] -> ControlPattern
partialsCount :: String -> ControlPattern
partialsCountTo :: String -> Pattern Double -> Pattern ValueMap
partialsbus :: Pattern Int -> Pattern Double -> ControlPattern
partialsrecv :: Pattern Int -> ControlPattern

-- | Phaser Audio DSP effect | params are <a>phaserrate</a> and
--   <a>phaserdepth</a>
phaserdepth :: Pattern Double -> ControlPattern
phaserdepthTake :: String -> [Double] -> ControlPattern
phaserdepthCount :: String -> ControlPattern
phaserdepthCountTo :: String -> Pattern Double -> Pattern ValueMap
phaserdepthbus :: Pattern Int -> Pattern Double -> ControlPattern
phaserdepthrecv :: Pattern Int -> ControlPattern

-- | Phaser Audio DSP effect | params are <a>phaserrate</a> and
--   <a>phaserdepth</a>
phaserrate :: Pattern Double -> ControlPattern
phaserrateTake :: String -> [Double] -> ControlPattern
phaserrateCount :: String -> ControlPattern
phaserrateCountTo :: String -> Pattern Double -> Pattern ValueMap
phaserratebus :: Pattern Int -> Pattern Double -> ControlPattern
phaserraterecv :: Pattern Int -> ControlPattern
pitch1 :: Pattern Double -> ControlPattern
pitch1Take :: String -> [Double] -> ControlPattern
pitch1Count :: String -> ControlPattern
pitch1CountTo :: String -> Pattern Double -> Pattern ValueMap
pitch1bus :: Pattern Int -> Pattern Double -> ControlPattern
pitch1recv :: Pattern Int -> ControlPattern
pitch2 :: Pattern Double -> ControlPattern
pitch2Take :: String -> [Double] -> ControlPattern
pitch2Count :: String -> ControlPattern
pitch2CountTo :: String -> Pattern Double -> Pattern ValueMap
pitch2bus :: Pattern Int -> Pattern Double -> ControlPattern
pitch2recv :: Pattern Int -> ControlPattern
pitch3 :: Pattern Double -> ControlPattern
pitch3Take :: String -> [Double] -> ControlPattern
pitch3Count :: String -> ControlPattern
pitch3CountTo :: String -> Pattern Double -> Pattern ValueMap
pitch3bus :: Pattern Int -> Pattern Double -> ControlPattern
pitch3recv :: Pattern Int -> ControlPattern
polyTouch :: Pattern Double -> ControlPattern
polyTouchTake :: String -> [Double] -> ControlPattern
polyTouchCount :: String -> ControlPattern
polyTouchCountTo :: String -> Pattern Double -> Pattern ValueMap
polyTouchbus :: Pattern Int -> Pattern Double -> ControlPattern
portamento :: Pattern Double -> ControlPattern
portamentoTake :: String -> [Double] -> ControlPattern
portamentoCount :: String -> ControlPattern
portamentoCountTo :: String -> Pattern Double -> Pattern ValueMap
portamentobus :: Pattern Int -> Pattern Double -> ControlPattern
portamentorecv :: Pattern Int -> ControlPattern
progNum :: Pattern Double -> ControlPattern
progNumTake :: String -> [Double] -> ControlPattern
progNumCount :: String -> ControlPattern
progNumCountTo :: String -> Pattern Double -> Pattern ValueMap
progNumbus :: Pattern Int -> Pattern Double -> ControlPattern

-- | used in SuperDirt softsynths as a control rate or "speed"
rate :: Pattern Double -> ControlPattern
rateTake :: String -> [Double] -> ControlPattern
rateCount :: String -> ControlPattern
rateCountTo :: String -> Pattern Double -> Pattern ValueMap
ratebus :: Pattern Int -> Pattern Double -> ControlPattern
raterecv :: Pattern Int -> ControlPattern

-- | Spectral conform
real :: Pattern Double -> ControlPattern
realTake :: String -> [Double] -> ControlPattern
realCount :: String -> ControlPattern
realCountTo :: String -> Pattern Double -> Pattern ValueMap
realbus :: Pattern Int -> Pattern Double -> ControlPattern
realrecv :: Pattern Int -> ControlPattern

-- | a pattern of numbers to specify the release time (in seconds) of an
--   envelope applied to each sample.
release :: Pattern Double -> ControlPattern
releaseTake :: String -> [Double] -> ControlPattern
releaseCount :: String -> ControlPattern
releaseCountTo :: String -> Pattern Double -> Pattern ValueMap
releasebus :: Pattern Int -> Pattern Double -> ControlPattern
releaserecv :: Pattern Int -> ControlPattern

-- | a pattern of numbers from 0 to 1. Specifies the resonance of the
--   low-pass filter.
resonance :: Pattern Double -> ControlPattern
resonanceTake :: String -> [Double] -> ControlPattern
resonanceCount :: String -> ControlPattern
resonanceCountTo :: String -> Pattern Double -> Pattern ValueMap
resonancebus :: Pattern Int -> Pattern Double -> ControlPattern
resonancerecv :: Pattern Int -> ControlPattern

-- | ring modulation
ring :: Pattern Double -> ControlPattern
ringTake :: String -> [Double] -> ControlPattern
ringCount :: String -> ControlPattern
ringCountTo :: String -> Pattern Double -> Pattern ValueMap
ringbus :: Pattern Int -> Pattern Double -> ControlPattern
ringrecv :: Pattern Int -> ControlPattern

-- | ring modulation
ringdf :: Pattern Double -> ControlPattern
ringdfTake :: String -> [Double] -> ControlPattern
ringdfCount :: String -> ControlPattern
ringdfCountTo :: String -> Pattern Double -> Pattern ValueMap
ringdfbus :: Pattern Int -> Pattern Double -> ControlPattern
ringdfrecv :: Pattern Int -> ControlPattern

-- | ring modulation
ringf :: Pattern Double -> ControlPattern
ringfTake :: String -> [Double] -> ControlPattern
ringfCount :: String -> ControlPattern
ringfCountTo :: String -> Pattern Double -> Pattern ValueMap
ringfbus :: Pattern Int -> Pattern Double -> ControlPattern
ringfrecv :: Pattern Int -> ControlPattern

-- | a pattern of numbers from 0 to 1. Sets the level of reverb.
room :: Pattern Double -> ControlPattern
roomTake :: String -> [Double] -> ControlPattern
roomCount :: String -> ControlPattern
roomCountTo :: String -> Pattern Double -> Pattern ValueMap
roombus :: Pattern Int -> Pattern Double -> ControlPattern
roomrecv :: Pattern Int -> ControlPattern
sagogo :: Pattern Double -> ControlPattern
sagogoTake :: String -> [Double] -> ControlPattern
sagogoCount :: String -> ControlPattern
sagogoCountTo :: String -> Pattern Double -> Pattern ValueMap
sagogobus :: Pattern Int -> Pattern Double -> ControlPattern
sagogorecv :: Pattern Int -> ControlPattern
sclap :: Pattern Double -> ControlPattern
sclapTake :: String -> [Double] -> ControlPattern
sclapCount :: String -> ControlPattern
sclapCountTo :: String -> Pattern Double -> Pattern ValueMap
sclapbus :: Pattern Int -> Pattern Double -> ControlPattern
sclaprecv :: Pattern Int -> ControlPattern
sclaves :: Pattern Double -> ControlPattern
sclavesTake :: String -> [Double] -> ControlPattern
sclavesCount :: String -> ControlPattern
sclavesCountTo :: String -> Pattern Double -> Pattern ValueMap
sclavesbus :: Pattern Int -> Pattern Double -> ControlPattern
sclavesrecv :: Pattern Int -> ControlPattern

-- | Spectral scramble
scram :: Pattern Double -> ControlPattern
scramTake :: String -> [Double] -> ControlPattern
scramCount :: String -> ControlPattern
scramCountTo :: String -> Pattern Double -> Pattern ValueMap
scrambus :: Pattern Int -> Pattern Double -> ControlPattern
scramrecv :: Pattern Int -> ControlPattern
scrash :: Pattern Double -> ControlPattern
scrashTake :: String -> [Double] -> ControlPattern
scrashCount :: String -> ControlPattern
scrashCountTo :: String -> Pattern Double -> Pattern ValueMap
scrashbus :: Pattern Int -> Pattern Double -> ControlPattern
scrashrecv :: Pattern Int -> ControlPattern
seconds :: Pattern Double -> ControlPattern
secondsTake :: String -> [Double] -> ControlPattern
secondsCount :: String -> ControlPattern
secondsCountTo :: String -> Pattern Double -> Pattern ValueMap
secondsbus :: Pattern Int -> Pattern Double -> ControlPattern
semitone :: Pattern Double -> ControlPattern
semitoneTake :: String -> [Double] -> ControlPattern
semitoneCount :: String -> ControlPattern
semitoneCountTo :: String -> Pattern Double -> Pattern ValueMap
semitonebus :: Pattern Int -> Pattern Double -> ControlPattern
semitonerecv :: Pattern Int -> ControlPattern

-- | wave shaping distortion, a pattern of numbers from 0 for no distortion
--   up to 1 for loads of distortion.
shape :: Pattern Double -> ControlPattern
shapeTake :: String -> [Double] -> ControlPattern
shapeCount :: String -> ControlPattern
shapeCountTo :: String -> Pattern Double -> Pattern ValueMap
shapebus :: Pattern Int -> Pattern Double -> ControlPattern
shaperecv :: Pattern Int -> ControlPattern

-- | a pattern of numbers from 0 to 1. Sets the perceptual size (reverb
--   time) of the <a>room</a> to be used in reverb.
size :: Pattern Double -> ControlPattern
sizeTake :: String -> [Double] -> ControlPattern
sizeCount :: String -> ControlPattern
sizeCountTo :: String -> Pattern Double -> Pattern ValueMap
sizebus :: Pattern Int -> Pattern Double -> ControlPattern
sizerecv :: Pattern Int -> ControlPattern
slide :: Pattern Double -> ControlPattern
slideTake :: String -> [Double] -> ControlPattern
slideCount :: String -> ControlPattern
slideCountTo :: String -> Pattern Double -> Pattern ValueMap
slidebus :: Pattern Int -> Pattern Double -> ControlPattern
sliderecv :: Pattern Int -> ControlPattern
slider0 :: Pattern Double -> ControlPattern
slider0Take :: String -> [Double] -> ControlPattern
slider0Count :: String -> ControlPattern
slider0CountTo :: String -> Pattern Double -> Pattern ValueMap
slider0bus :: Pattern Int -> Pattern Double -> ControlPattern
slider0recv :: Pattern Int -> ControlPattern
slider1 :: Pattern Double -> ControlPattern
slider1Take :: String -> [Double] -> ControlPattern
slider1Count :: String -> ControlPattern
slider1CountTo :: String -> Pattern Double -> Pattern ValueMap
slider1bus :: Pattern Int -> Pattern Double -> ControlPattern
slider1recv :: Pattern Int -> ControlPattern
slider10 :: Pattern Double -> ControlPattern
slider10Take :: String -> [Double] -> ControlPattern
slider10Count :: String -> ControlPattern
slider10CountTo :: String -> Pattern Double -> Pattern ValueMap
slider10bus :: Pattern Int -> Pattern Double -> ControlPattern
slider10recv :: Pattern Int -> ControlPattern
slider11 :: Pattern Double -> ControlPattern
slider11Take :: String -> [Double] -> ControlPattern
slider11Count :: String -> ControlPattern
slider11CountTo :: String -> Pattern Double -> Pattern ValueMap
slider11bus :: Pattern Int -> Pattern Double -> ControlPattern
slider11recv :: Pattern Int -> ControlPattern
slider12 :: Pattern Double -> ControlPattern
slider12Take :: String -> [Double] -> ControlPattern
slider12Count :: String -> ControlPattern
slider12CountTo :: String -> Pattern Double -> Pattern ValueMap
slider12bus :: Pattern Int -> Pattern Double -> ControlPattern
slider12recv :: Pattern Int -> ControlPattern
slider13 :: Pattern Double -> ControlPattern
slider13Take :: String -> [Double] -> ControlPattern
slider13Count :: String -> ControlPattern
slider13CountTo :: String -> Pattern Double -> Pattern ValueMap
slider13bus :: Pattern Int -> Pattern Double -> ControlPattern
slider13recv :: Pattern Int -> ControlPattern
slider14 :: Pattern Double -> ControlPattern
slider14Take :: String -> [Double] -> ControlPattern
slider14Count :: String -> ControlPattern
slider14CountTo :: String -> Pattern Double -> Pattern ValueMap
slider14bus :: Pattern Int -> Pattern Double -> ControlPattern
slider14recv :: Pattern Int -> ControlPattern
slider15 :: Pattern Double -> ControlPattern
slider15Take :: String -> [Double] -> ControlPattern
slider15Count :: String -> ControlPattern
slider15CountTo :: String -> Pattern Double -> Pattern ValueMap
slider15bus :: Pattern Int -> Pattern Double -> ControlPattern
slider15recv :: Pattern Int -> ControlPattern
slider2 :: Pattern Double -> ControlPattern
slider2Take :: String -> [Double] -> ControlPattern
slider2Count :: String -> ControlPattern
slider2CountTo :: String -> Pattern Double -> Pattern ValueMap
slider2bus :: Pattern Int -> Pattern Double -> ControlPattern
slider2recv :: Pattern Int -> ControlPattern
slider3 :: Pattern Double -> ControlPattern
slider3Take :: String -> [Double] -> ControlPattern
slider3Count :: String -> ControlPattern
slider3CountTo :: String -> Pattern Double -> Pattern ValueMap
slider3bus :: Pattern Int -> Pattern Double -> ControlPattern
slider3recv :: Pattern Int -> ControlPattern
slider4 :: Pattern Double -> ControlPattern
slider4Take :: String -> [Double] -> ControlPattern
slider4Count :: String -> ControlPattern
slider4CountTo :: String -> Pattern Double -> Pattern ValueMap
slider4bus :: Pattern Int -> Pattern Double -> ControlPattern
slider4recv :: Pattern Int -> ControlPattern
slider5 :: Pattern Double -> ControlPattern
slider5Take :: String -> [Double] -> ControlPattern
slider5Count :: String -> ControlPattern
slider5CountTo :: String -> Pattern Double -> Pattern ValueMap
slider5bus :: Pattern Int -> Pattern Double -> ControlPattern
slider5recv :: Pattern Int -> ControlPattern
slider6 :: Pattern Double -> ControlPattern
slider6Take :: String -> [Double] -> ControlPattern
slider6Count :: String -> ControlPattern
slider6CountTo :: String -> Pattern Double -> Pattern ValueMap
slider6bus :: Pattern Int -> Pattern Double -> ControlPattern
slider6recv :: Pattern Int -> ControlPattern
slider7 :: Pattern Double -> ControlPattern
slider7Take :: String -> [Double] -> ControlPattern
slider7Count :: String -> ControlPattern
slider7CountTo :: String -> Pattern Double -> Pattern ValueMap
slider7bus :: Pattern Int -> Pattern Double -> ControlPattern
slider7recv :: Pattern Int -> ControlPattern
slider8 :: Pattern Double -> ControlPattern
slider8Take :: String -> [Double] -> ControlPattern
slider8Count :: String -> ControlPattern
slider8CountTo :: String -> Pattern Double -> Pattern ValueMap
slider8bus :: Pattern Int -> Pattern Double -> ControlPattern
slider8recv :: Pattern Int -> ControlPattern
slider9 :: Pattern Double -> ControlPattern
slider9Take :: String -> [Double] -> ControlPattern
slider9Count :: String -> ControlPattern
slider9CountTo :: String -> Pattern Double -> Pattern ValueMap
slider9bus :: Pattern Int -> Pattern Double -> ControlPattern
slider9recv :: Pattern Int -> ControlPattern

-- | Spectral smear
smear :: Pattern Double -> ControlPattern
smearTake :: String -> [Double] -> ControlPattern
smearCount :: String -> ControlPattern
smearCountTo :: String -> Pattern Double -> Pattern ValueMap
smearbus :: Pattern Int -> Pattern Double -> ControlPattern
smearrecv :: Pattern Int -> ControlPattern
songPtr :: Pattern Double -> ControlPattern
songPtrTake :: String -> [Double] -> ControlPattern
songPtrCount :: String -> ControlPattern
songPtrCountTo :: String -> Pattern Double -> Pattern ValueMap
songPtrbus :: Pattern Int -> Pattern Double -> ControlPattern

-- | A pattern of numbers which changes the speed of sample playback which
--   also changes pitch. Negative values will play the sample backwards.
--   
--   <pre>
--   d1 $ slow 5 $ s "sax:5" # legato 1 # speed 0.5
--   </pre>
--   
--   This will play the <tt>sax:5</tt> sample at half its rate. As a
--   result, the sample will last twice the normal time, and will be
--   pitched a whole octave lower. This is equivalent to <tt>d1 $ slow 5 $
--   s "sax:5" # legato 1 |- note 12</tt>.
--   
--   <pre>
--   d1 $ fast 2 $ s "breaks125:1" # cps (125/60/4) # speed (-2)
--   </pre>
--   
--   In the above example, the break (which lasts for exactly one bar at
--   125 BPM), will be played backwards, and at double speed (so, we use
--   <tt>fast 2</tt> to fill the whole cycle).
speed :: Pattern Double -> ControlPattern
speedTake :: String -> [Double] -> ControlPattern
speedCount :: String -> ControlPattern
speedCountTo :: String -> Pattern Double -> Pattern ValueMap
speedbus :: Pattern Int -> Pattern Double -> ControlPattern
squiz :: Pattern Double -> ControlPattern
squizTake :: String -> [Double] -> ControlPattern
squizCount :: String -> ControlPattern
squizCountTo :: String -> Pattern Double -> Pattern ValueMap
squizbus :: Pattern Int -> Pattern Double -> ControlPattern
squizrecv :: Pattern Int -> ControlPattern
stepsPerOctave :: Pattern Double -> ControlPattern
stepsPerOctaveTake :: String -> [Double] -> ControlPattern
stepsPerOctaveCount :: String -> ControlPattern
stepsPerOctaveCountTo :: String -> Pattern Double -> Pattern ValueMap
stepsPerOctavebus :: Pattern Int -> Pattern Double -> ControlPattern
stepsPerOctaverecv :: Pattern Int -> ControlPattern
stutterdepth :: Pattern Double -> ControlPattern
stutterdepthTake :: String -> [Double] -> ControlPattern
stutterdepthCount :: String -> ControlPattern
stutterdepthCountTo :: String -> Pattern Double -> Pattern ValueMap
stutterdepthbus :: Pattern Int -> Pattern Double -> ControlPattern
stutterdepthrecv :: Pattern Int -> ControlPattern
stuttertime :: Pattern Double -> ControlPattern
stuttertimeTake :: String -> [Double] -> ControlPattern
stuttertimeCount :: String -> ControlPattern
stuttertimeCountTo :: String -> Pattern Double -> Pattern ValueMap
stuttertimebus :: Pattern Int -> Pattern Double -> ControlPattern
stuttertimerecv :: Pattern Int -> ControlPattern

-- | A pattern of numbers that indicates the total duration of sample
--   playback in seconds.
--   
--   This <tt>sustain</tt> refers to the whole playback duration and is not
--   to be confused with the sustain level of a typical ADSR envelope.
--   
--   <pre>
--   d1 $ fast 2 $ s "breaks125:1" # cps (120/60/4) # sustain 1
--   </pre>
--   
--   At 120 BPM, a cycle lasts for two seconds. In the above example, we
--   cut the sample so it plays just for one second, and repeat this part
--   two times, so we fill the whole cycle. Note that sample pitch isn’t
--   modified.
--   
--   <pre>
--   d1 $ s "breaks125:2!3" # cps (120/60/4) # sustain "0.4 0.2 0.4" # begin "0 0 0.4"
--   </pre>
--   
--   Here, we take advantage that sustain receives a pattern to build a
--   different break from the original sample.
sustain :: Pattern Double -> ControlPattern
sustainTake :: String -> [Double] -> ControlPattern
sustainCount :: String -> ControlPattern
sustainCountTo :: String -> Pattern Double -> Pattern ValueMap
sustainbus :: Pattern Int -> Pattern Double -> ControlPattern
sustainpedal :: Pattern Double -> ControlPattern
sustainpedalTake :: String -> [Double] -> ControlPattern
sustainpedalCount :: String -> ControlPattern
sustainpedalCountTo :: String -> Pattern Double -> Pattern ValueMap
sustainpedalbus :: Pattern Int -> Pattern Double -> ControlPattern
sustainpedalrecv :: Pattern Int -> ControlPattern

-- | <tt>timescale</tt> is the main function used to activate
--   time-stretching, and usually the only one you need. It receives a
--   single parameter which is the stretching rate to apply.
--   
--   You can use any positive number as the ratio, but the particular
--   method used is designed for ratios greater than 1, and work reasonably
--   well for values between 0.1 and 3.
--   
--   <pre>
--   d1 $ slow 2 $ s "breaks152" # legato 1 # timescale (152/130) # cps (130/60/4)
--   </pre>
--   
--   In the example above, we set tempo at 130 beats per minute. But we
--   want to play one of the <tt>breaks152</tt> samples, which are, as
--   indicated, at 152 BPM. So, the ratio we want is 152 over 130. This
--   will slow down the sample to fit in our 130 BPM tempo.
timescale :: Pattern Double -> ControlPattern
timescaleTake :: String -> [Double] -> ControlPattern
timescaleCount :: String -> ControlPattern
timescaleCountTo :: String -> Pattern Double -> Pattern ValueMap
timescalebus :: Pattern Int -> Pattern Double -> ControlPattern

-- | Time stretch window size.
--   
--   The algorithm used to time-stretch a sample divides a sample in many
--   little parts, modifies them, and puts them all together again. It uses
--   one particular parameter, called <tt>windowSize</tt>, which is the
--   length of each sample part.
--   
--   The <tt>windowSize</tt> value is automatically calculated, but can be
--   changed with <tt>timescalewin</tt>. The <tt>windowSize</tt> value is
--   multiplied by the number provided.
--   
--   <tt>timescalewin</tt> can be used to improve the quality of
--   time-stretching for some samples, or simply as an effect.
--   
--   Consider the following two examples. In the first one,
--   <tt>timescalewin 0.01</tt> makes the window size a lot smaller, and
--   the extreme chopping of the sample causes a rougher sound. In the
--   second one, <tt>timescalewin 10</tt> makes the chunks a lot bigger.
--   The method used overlaps the treated chunks when recomposing the
--   sample, and, with the bigger window size, this overlap is noticeable
--   and causes a kind of delay effect.
--   
--   <pre>
--   d1 $ slow 2
--      $ s "breaks152"
--      # legato 1
--      # timescale (152/130)
--      # timescalewin 0.01
--      # cps (130/60/4)
--   </pre>
--   
--   <pre>
--   d1 $ slow 2
--      $ s "breaks152"
--      # legato 1
--      # timescale (152/130)
--      # timescalewin 10
--      # cps (130/60/4)
--   </pre>
timescalewin :: Pattern Double -> ControlPattern
timescalewinTake :: String -> [Double] -> ControlPattern
timescalewinCount :: String -> ControlPattern
timescalewinCountTo :: String -> Pattern Double -> Pattern ValueMap
timescalewinbus :: Pattern Int -> Pattern Double -> ControlPattern

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

-- | for internal sound routing
toArg :: Pattern String -> ControlPattern
toArgTake :: String -> [Double] -> ControlPattern
toArgbus :: Pattern Int -> Pattern String -> ControlPattern
toArgrecv :: Pattern Int -> ControlPattern
tomdecay :: Pattern Double -> ControlPattern
tomdecayTake :: String -> [Double] -> ControlPattern
tomdecayCount :: String -> ControlPattern
tomdecayCountTo :: String -> Pattern Double -> Pattern ValueMap
tomdecaybus :: Pattern Int -> Pattern Double -> ControlPattern
tomdecayrecv :: Pattern Int -> ControlPattern

-- | Tremolo Audio DSP effect | params are <a>tremolorate</a> and
--   <a>tremolodepth</a>
tremolodepth :: Pattern Double -> ControlPattern
tremolodepthTake :: String -> [Double] -> ControlPattern
tremolodepthCount :: String -> ControlPattern
tremolodepthCountTo :: String -> Pattern Double -> Pattern ValueMap
tremolodepthbus :: Pattern Int -> Pattern Double -> ControlPattern
tremolodepthrecv :: Pattern Int -> ControlPattern

-- | Tremolo Audio DSP effect | params are <a>tremolorate</a> and
--   <a>tremolodepth</a>
tremolorate :: Pattern Double -> ControlPattern
tremolorateTake :: String -> [Double] -> ControlPattern
tremolorateCount :: String -> ControlPattern
tremolorateCountTo :: String -> Pattern Double -> Pattern ValueMap
tremoloratebus :: Pattern Int -> Pattern Double -> ControlPattern
tremoloraterecv :: Pattern Int -> ControlPattern

-- | tube distortion
triode :: Pattern Double -> ControlPattern
triodeTake :: String -> [Double] -> ControlPattern
triodeCount :: String -> ControlPattern
triodeCountTo :: String -> Pattern Double -> Pattern ValueMap
triodebus :: Pattern Int -> Pattern Double -> ControlPattern
trioderecv :: Pattern Int -> ControlPattern
tsdelay :: Pattern Double -> ControlPattern
tsdelayTake :: String -> [Double] -> ControlPattern
tsdelayCount :: String -> ControlPattern
tsdelayCountTo :: String -> Pattern Double -> Pattern ValueMap
tsdelaybus :: Pattern Int -> Pattern Double -> ControlPattern
tsdelayrecv :: Pattern Int -> ControlPattern
uid :: Pattern Double -> ControlPattern
uidTake :: String -> [Double] -> ControlPattern
uidCount :: String -> ControlPattern
uidCountTo :: String -> Pattern Double -> Pattern ValueMap
uidbus :: Pattern Int -> Pattern Double -> ControlPattern

-- | Used in conjunction with <a>speed</a>. It accepts values of <tt>r</tt>
--   (rate, default behavior), <tt>c</tt> (cycles), or <tt>s</tt>
--   (seconds). Using <tt>unit "c"</tt> means <a>speed</a> will be
--   interpreted in units of cycles, e.g. <tt>speed "1"</tt> means samples
--   will be stretched to fill a cycle. Using <tt>unit "s"</tt> means the
--   playback speed will be adjusted so that the duration is the number of
--   seconds specified by <a>speed</a>.
--   
--   In the following example, <tt>speed 2</tt> means that samples will be
--   stretched to fill half a cycle:
--   
--   <pre>
--   d1 $ stack [
--     s "sax:5" # legato 1 # speed 2 # unit "c",
--     s "bd*2"
--   ]
--   </pre>
unit :: Pattern String -> ControlPattern
unitTake :: String -> [Double] -> ControlPattern
unitbus :: Pattern Int -> Pattern String -> ControlPattern
val :: Pattern Double -> ControlPattern
valTake :: String -> [Double] -> ControlPattern
valCount :: String -> ControlPattern
valCountTo :: String -> Pattern Double -> Pattern ValueMap
valbus :: Pattern Int -> Pattern Double -> ControlPattern
vcfegint :: Pattern Double -> ControlPattern
vcfegintTake :: String -> [Double] -> ControlPattern
vcfegintCount :: String -> ControlPattern
vcfegintCountTo :: String -> Pattern Double -> Pattern ValueMap
vcfegintbus :: Pattern Int -> Pattern Double -> ControlPattern
vcfegintrecv :: Pattern Int -> ControlPattern
vcoegint :: Pattern Double -> ControlPattern
vcoegintTake :: String -> [Double] -> ControlPattern
vcoegintCount :: String -> ControlPattern
vcoegintCountTo :: String -> Pattern Double -> Pattern ValueMap
vcoegintbus :: Pattern Int -> Pattern Double -> ControlPattern
vcoegintrecv :: Pattern Int -> ControlPattern
velocity :: Pattern Double -> ControlPattern
velocityTake :: String -> [Double] -> ControlPattern
velocityCount :: String -> ControlPattern
velocityCountTo :: String -> Pattern Double -> Pattern ValueMap
velocitybus :: Pattern Int -> Pattern Double -> ControlPattern
velocityrecv :: Pattern Int -> ControlPattern
voice :: Pattern Double -> ControlPattern
voiceTake :: String -> [Double] -> ControlPattern
voiceCount :: String -> ControlPattern
voiceCountTo :: String -> Pattern Double -> Pattern ValueMap
voicebus :: Pattern Int -> Pattern Double -> ControlPattern
voicerecv :: Pattern Int -> ControlPattern

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

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

-- | <tt>rand</tt> is an oscillator that generates a continuous pattern of
--   (pseudo-)random numbers between 0 and 1.
--   
--   For example, to randomly pan around the stereo field:
--   
--   <pre>
--   d1 $ sound "bd*8" # pan rand
--   </pre>
--   
--   Or to enjoy a randomised speed from 0.5 to 1.5, add 0.5 to it:
--   
--   <pre>
--   d1 $ sound "arpy*4" # speed (rand + 0.5)
--   </pre>
--   
--   To make the snares randomly loud and quiet:
--   
--   <pre>
--   sound "sn sn ~ sn" # gain rand
--   </pre>
--   
--   Numbers coming from this pattern are 'seeded' by time. So if you reset
--   time (using <tt>resetCycles</tt>, <tt>setCycle</tt>, or <tt>cps</tt>)
--   the random pattern will emit the exact same _random_ numbers again.
--   
--   In cases where you need two different random patterns, you can shift
--   one of them around to change the time from which the _random_ pattern
--   is read, note the difference:
--   
--   <pre>
--   jux (# gain rand) $ sound "sn sn ~ sn" # gain rand
--   </pre>
--   
--   and with the juxed version shifted backwards for 1024 cycles:
--   
--   <pre>
--   jux (# ((1024 &lt;~) $ gain rand)) $ sound "sn sn ~ sn" # gain rand
--   </pre>
rand :: Fractional a => Pattern a

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

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

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

-- | 1D Perlin (smooth) noise, works like <a>rand</a> but smoothly moves
--   between random values each cycle. <tt>perlinWith</tt> takes a pattern
--   as the random number generator's "input" instead of automatically
--   using the cycle count.
--   
--   <pre>
--   d1 $ s "arpy*32" # cutoff (perlinWith (saw * 4) * 2000)
--   </pre>
--   
--   will generate a smooth random pattern for the cutoff frequency which
--   will repeat every cycle (because the saw does).
--   
--   The <a>perlin</a> function uses the cycle count as input and can be
--   used much like <tt>rand</tt>.
perlinWith :: Fractional a => Pattern Double -> Pattern a

-- | As <a>perlin</a> with a suitable choice of input pattern
--   (<tt><a>sig</a> <a>fromRational</a></tt>).
--   
--   The <tt>perlin</tt> function produces a new random value to move to
--   every cycle. If you want a new random value to be generated more or
--   less frequently, you can use fast or slow, respectively:
--   
--   <pre>
--   d1 $ sound "bd*32" # speed (fast 4 $ perlin + 0.5)
--   d1 $ sound "bd*32" # speed (slow 4 $ perlin + 0.5)
--   </pre>
perlin :: Fractional a => Pattern a

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

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

-- | Generates values in [0,1] that follows a normal (bell-curve)
--   distribution. One possible application is to "humanize" drums with a
--   slight random delay: <tt> d1 $ s "bd sn bd sn" # nudge (segment 4
--   (0.01 * normal)) </tt> Implemented with the Box-Muller transform. *
--   the max ensures we don't calculate log 0 * the rot in u2 ensures we
--   don't just get the same value as u1 * clamp the Box-Muller generated
--   values in a [-3,3] range
normal :: (Floating a, Ord a) => Pattern a

-- | Randomly picks an element from the given list.
--   
--   <pre>
--   sound "superpiano(3,8)" # note (choose ["a", "e", "g", "c"])
--   </pre>
--   
--   plays a melody randomly choosing one of the four notes "a", "e", "g",
--   "c".
--   
--   As with all continuous patterns, you have to be careful to give them
--   structure; in this case choose gives you an infinitely detailed stream
--   of random choices.
--   
--   <pre>
--   choose = 'chooseBy' 'rand'
--   </pre>
choose :: [a] -> Pattern a

-- | Given a pattern of doubles, <tt>chooseBy</tt> normalizes them so that
--   each corresponds to an index in the provided list. The returned
--   pattern contains the corresponding elements in the list.
--   
--   It is like choose, but instead of selecting elements of the list
--   randomly, it uses the given pattern to select elements.
--   
--   <pre>
--   <a>choose</a> = chooseBy <a>rand</a>
--   </pre>
--   
--   The following results in the pattern <tt>"a b c"</tt>:
--   
--   <pre>
--   chooseBy "0 0.25 0.5" ["a","b","c","d"]
--   </pre>
chooseBy :: Pattern Double -> [a] -> Pattern a

-- | Like <tt>choose</tt>, but works on an a list of tuples of values and
--   weights
--   
--   <pre>
--   sound "superpiano(3,8)" # note (wchoose [("a",1), ("e",0.5), ("g",2), ("c",1)])
--   </pre>
--   
--   In the above example, the "a" and "c" notes are twice as likely to
--   play as the "e" note, and half as likely to play as the "g" note.
--   
--   <pre>
--   wchoose = 'wchooseBy' 'rand'
--   </pre>
wchoose :: [(a, Pattern Double)] -> Pattern a

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

-- | <tt>randcat ps</tt>: does a <tt>slowcat</tt> on the list of patterns
--   <tt>ps</tt> but randomises the order in which they are played.
--   
--   <pre>
--   d1 $ sound (randcat ["bd*2 sn", "jvbass*3", "drum*2", "ht mt"])
--   </pre>
randcat :: [Pattern a] -> Pattern a

-- | As <a>randcat</a>, but allowing weighted choice.
--   
--   In the following, the first pattern is the most likely and will play
--   about half the time, and the last pattern is the less likely, with
--   only a 10% probability.
--   
--   <pre>
--   d1 $ sound
--      $ wrandcat
--          [ ("bd*2 sn", 5), ("jvbass*3", 2), ("drum*2", 2), ("ht mt", 1) ]
--   </pre>
wrandcat :: [(Pattern a, Pattern Double)] -> Pattern a

-- | <tt>degrade</tt> 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 <tt>degrade</tt> is a question mark:
--   <tt>?</tt>. Using <tt>?</tt> will allow you to randomly remove events
--   from a portion of a pattern:
--   
--   <pre>
--   d1 $ slow 2 $ sound "bd ~ sn bd ~ bd? [sn bd?] ~"
--   </pre>
--   
--   You can also use <tt>?</tt> to randomly remove events from entire
--   sub-patterns:
--   
--   <pre>
--   d1 $ slow 2 $ sound "[[[feel:5*8,feel*3] feel:3*8]?, feel*4]"
--   </pre>
degrade :: Pattern a -> Pattern a

-- | Similar to <a>degrade</a>, <tt>degradeBy</tt> allows you to control
--   the percentage of events that are removed. For example, to remove
--   events 90% of the time:
--   
--   <pre>
--   d1 $ slow 2 $ degradeBy 0.9 $ sound "[[[feel:5*8,feel*3] feel:3*8], feel*4]"
--      # accelerate "-6"
--      # speed "2"
--   </pre>
--   
--   You can also invoke this behavior in the shorthand notation by
--   specifying a percentage, as a number between 0 and 1, after the
--   question mark:
--   
--   <pre>
--   d1 $ s "bd hh?0.8 bd hh?0.4"
--   </pre>
degradeBy :: Pattern Double -> Pattern a -> Pattern a
_degradeBy :: Double -> Pattern a -> Pattern a
_degradeByUsing :: Pattern Double -> Double -> Pattern a -> Pattern a

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

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

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

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

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

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

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

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

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

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

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

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

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

-- | Never apply a transformation, returning the pattern unmodified.
never :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a

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

-- | <tt>someCyclesBy</tt> is a cycle-by-cycle version of
--   <tt><a>sometimesBy</a></tt>.
--   
--   For example the following will either distort all of the events in a
--   cycle, or none of them:
--   
--   <pre>
--   d1 $ someCyclesBy 0.5 (# crush 2) $ n "0 1 [~ 2] 3" # sound "arpy"
--   </pre>
someCyclesBy :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_someCyclesBy :: Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | Alias of <a>someCyclesBy</a>.
somecyclesBy :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

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

-- | Alias of <a>someCycles</a>.
somecycles :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <tt>brak</tt> makes a pattern sound a bit like a breakbeat. It does
--   this by, every other cycle, squashing the pattern to fit half a cycle,
--   and offsetting it by a quarter of a cycle.
--   
--   <pre>
--   d1 $ sound (brak "bd sn kurt")
--   d1 $ brak $ sound "[feel feel:3, hc:3 hc:2 hc:4 ho:1]"
--   </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. For example,
--   
--   <pre>
--   d1 $ iter' 4 $ sound "bd hh sn cp"
--   </pre>
--   
--   produces
--   
--   <pre>
--   bd hh sn cp
--   cp bd hh sn
--   sn cp bd hh
--   hh sn cp bd
--   </pre>
iter' :: Pattern Int -> Pattern c -> Pattern c
_iter' :: Int -> Pattern a -> Pattern a

-- | <tt>palindrome p</tt> applies <tt>rev</tt> to <tt>p</tt> every other
--   cycle, so that the pattern alternates between forwards and backwards.
--   For example, these are equivalent:
--   
--   <pre>
--   d1 $ palindrome $ sound "arpy:0 arpy:1 arpy:2 arpy:3"
--   d1 $ slow 2 $ sound "arpy:0 arpy:1 arpy:2 arpy:3 arpy:3 arpy:2 arpy:1 arpy:0"
--   d1 $ every 2 rev $ sound "arpy:0 arpy:1 arpy:2 arpy:3"
--   </pre>
palindrome :: Pattern a -> Pattern a

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

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

-- | ’Undegrades’ a pattern over the given time.
fadeIn :: Time -> Pattern a -> Pattern a

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

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

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

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

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

-- | <tt>spreadChoose f xs p</tt> is similar to <a>slowspread</a> but picks
--   values from <tt>xs</tt> at random, rather than cycling through them in
--   order.
--   
--   <pre>
--   d1 $ spreadChoose ($) [gap 4, striate 4] $ sound "ho ho:2 ho:3 hc"
--   </pre>
spreadChoose :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b

-- | A shorter alias for <a>spreadChoose</a>.
spreadr :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b

-- | Decide whether to apply one or another function depending on the
--   result of a test function, which is passed the current cycle as a
--   number.
--   
--   <pre>
--   d1 $ ifp ((== 0) . flip mod 2)
--           (striate 4)
--           (# coarse "24 48")
--     $ sound "hh hc"
--   </pre>
--   
--   This will apply <tt><tt>striate</tt> 4</tt> for every <i>even</i>
--   cycle and apply <tt># coarse "24 48"</tt> for every <i>odd</i>.
--   
--   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 <tt>True</tt>
--   or <tt>False</tt>. This is what the <tt>ifp</tt> signature's first
--   part signifies: <tt>(Int -&gt; Bool)</tt>, a function that takes a
--   whole number and returns either <tt>True</tt> or <tt>False</tt>.
ifp :: (Int -> Bool) -> (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <tt>wedge t p p'</tt> combines patterns <tt>p</tt> and <tt>p'</tt> by
--   squashing the <tt>p</tt> into the portion of each cycle given by
--   <tt>t</tt>, and <tt>p'</tt> into the remainer of each cycle. &gt; d1 $
--   wedge (1/4) (sound "bd*2 arpy*3 cp sn*2") (sound "odx [feel future]*2
--   hh hh")
wedge :: Pattern Time -> Pattern a -> Pattern a -> Pattern a
_wedge :: Time -> Pattern a -> Pattern a -> Pattern a

-- | <tt>whenmod</tt> has a similar form and behavior to <a>every</a>, but
--   requires an additional number. It applies the function to the pattern
--   when the remainder of the current loop number divided by the first
--   parameter is greater or equal than the second parameter.
--   
--   For example, the following makes every other block of four loops twice
--   as dense:
--   
--   <pre>
--   d1 $ whenmod 8 4 (density 2) (sound "bd sn kurt")
--   </pre>
whenmod :: Pattern Time -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_whenmod :: Time -> Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <pre>
--   superimpose f p = stack [p, f p]
--   </pre>
--   
--   <tt>superimpose</tt> plays a modified version of a pattern at the same
--   time as the original pattern, resulting in two patterns being played
--   at the same time. The following are equivalent:
--   
--   <pre>
--   d1 $ superimpose (fast 2) $ sound "bd sn [cp ht] hh"
--   d1 $ stack [sound "bd sn [cp ht] hh",
--               fast 2 $ sound "bd sn [cp ht] hh"
--              ]
--   </pre>
--   
--   More examples:
--   
--   <pre>
--   d1 $ superimpose (density 2) $ sound "bd sn [cp ht] hh"
--   d1 $ superimpose ((# speed "2") . (0.125 &lt;~)) $ sound "bd sn cp hh"
--   </pre>
superimpose :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | <tt>trunc</tt> truncates a pattern so that only a fraction of the
--   pattern is played. The following example plays only the first quarter
--   of the pattern:
--   
--   <pre>
--   d1 $ trunc 0.25 $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2"
--   </pre>
--   
--   You can also pattern the first parameter, for example to cycle through
--   three values, one per cycle:
--   
--   <pre>
--   d1 $ trunc "&lt;0.75 0.25 1&gt;" $ sound "bd sn:2 [mt rs] hc"
--   </pre>
trunc :: Pattern Time -> Pattern a -> Pattern a
_trunc :: Time -> Pattern a -> Pattern a

-- | <tt>linger</tt> is similar to <a>trunc</a>, in that it truncates a
--   pattern so that only the first fraction of the pattern is played, but
--   the truncated part of the pattern loops to fill the remainder of the
--   cycle.
--   
--   <pre>
--   d1 $ linger 0.25 $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2"
--   </pre>
--   
--   For example this repeats the first quarter, so you only hear a single
--   repeating note:
--   
--   <pre>
--   d1 $ linger 0.25 $ n "0 2 [3 4] 2" # sound "arpy"
--   </pre>
--   
--   or slightly more interesting, applied only every fourth cycle:
--   
--   <pre>
--   d1 $ every 4 (linger 0.25) $ n "0 2 [3 4] 2" # sound "arpy"
--   </pre>
--   
--   or to a chopped-up sample:
--   
--   <pre>
--   d1 $ every 2 (linger 0.25) $ loopAt 2 $ chop 8 $ sound "breaks125"
--   </pre>
--   
--   You can also pattern the first parameter, for example to cycle through
--   three values, one per cycle:
--   
--   <pre>
--   d1 $ linger "&lt;0.75 0.25 1&gt;" $ sound "bd sn:2 [mt rs] hc"
--   d1 $ linger "&lt;0.25 0.5 1&gt;" $ loopAt 2 $ chop 8 $ sound "breaks125"
--   </pre>
--   
--   If you give it a negative number, it will linger on the last part of
--   the pattern, instead of the start of it. E.g. to linger on the last
--   quarter:
--   
--   <pre>
--   d1 $ linger (-0.25) $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2"
--   </pre>
linger :: Pattern Time -> Pattern a -> Pattern a
_linger :: Time -> Pattern a -> Pattern a

-- | Use <tt>within</tt> to apply a function to only a part of a pattern.
--   It takes two arguments: a start time and an end time, specified as
--   floats between 0 and 1, which are applied to the relevant pattern.
--   Note that the second argument must be greater than the first for the
--   function to have any effect.
--   
--   For example, to apply <tt><a>fast</a> 2</tt> to only the first half of
--   a pattern:
--   
--   <pre>
--   d1 $ within (0, 0.5) (fast 2) $ sound "bd*2 sn lt mt hh hh hh hh"
--   </pre>
--   
--   Or, to apply <tt>(# <tt>speed</tt> "0.5")</tt> to only the last
--   quarter of a pattern:
--   
--   <pre>
--   d1 $ within (0.75, 1) (# speed "0.5") $ sound "bd*2 sn lt mt hh hh hh hh"
--   </pre>
within :: (Time, Time) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
withinArc :: Arc -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

-- | For many cases, <tt>within'</tt> will function exactly as within. The
--   difference between the two occurs when applying functions that change
--   the timing of notes such as <a>fast</a> or <a>&lt;~</a>. within first
--   applies the function to all notes in the cycle, then keeps the results
--   in the specified interval, and then combines it with the old cycle (an
--   "apply split combine" paradigm). within' first keeps notes in the
--   specified interval, then applies the function to these notes, and then
--   combines it with the old cycle (a "split apply combine" paradigm).
--   
--   For example, whereas using the standard version of within
--   
--   <pre>
--   d1 $ within (0, 0.25) (fast 2) $ sound "bd hh cp sd"
--   </pre>
--   
--   sounds like:
--   
--   <pre>
--   d1 $ sound "[bd hh] hh cp sd"
--   </pre>
--   
--   using this alternative version, within'
--   
--   <pre>
--   d1 $ within' (0, 0.25) (fast 2) $ sound "bd hh cp sd"
--   </pre>
--   
--   sounds like:
--   
--   <pre>
--   d1 $ sound "[bd bd] hh cp sd"
--   </pre>
within' :: (Time, Time) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

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

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

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

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

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

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

-- | As <a>euclidOff</a>, but specialized to <a>Bool</a>. May be more
--   efficient than <a>euclidOff</a>.
euclidOffBool :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern Bool -> Pattern Bool
_euclidOffBool :: Int -> Int -> Int -> Pattern Bool -> Pattern Bool
distrib :: [Pattern Int] -> Pattern a -> Pattern a
_distrib :: [Int] -> Pattern a -> Pattern a

-- | <tt>euclidInv</tt> fills in the blanks left by <a>euclid</a>, i.e., it
--   inverts the pattern.
--   
--   For example, whereas <tt>euclid 3 8 "x"</tt> produces
--   
--   <pre>
--   "x ~ ~ x ~ ~ x ~"
--   </pre>
--   
--   <tt>euclidInv 3 8 "x"</tt> produces
--   
--   <pre>
--   "~ x x ~ x x ~ x"
--   </pre>
--   
--   As another example, in
--   
--   <pre>
--   d1 $ stack [ euclid 5 8 $ s "bd"
--              , euclidInv 5 8 $ s "hh27"
--              ]
--   </pre>
--   
--   the hi-hat event fires on every one of the eight even beats that the
--   bass drum does not.
euclidInv :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_euclidInv :: Int -> Int -> Pattern a -> Pattern a
index :: Real b => b -> Pattern b -> Pattern c -> Pattern c

-- | <tt>rot n p</tt> "rotates" the values in a pattern <tt>p</tt> by
--   <tt>n</tt> beats to the left, preserving its structure. For example,
--   in the following, each value will shift to its neighbour's position
--   one step to the left, so that <tt>b</tt> takes the place of
--   <tt>a</tt>, <tt>a</tt> of <tt>c</tt>, and <tt>c</tt> of <tt>b</tt>:
--   
--   <pre>
--   rot 1 "a ~ b c"
--   </pre>
--   
--   The result is equivalent of:
--   
--   <pre>
--   "b ~ c a"
--   </pre>
--   
--   The first parameter is the number of steps, and may be given as a
--   pattern. For example, in
--   
--   <pre>
--   d1 $ rot "&lt;0 0 1 3&gt;" $ n "0 ~ 1 2 0 2 ~ 3*2" # sound "drum"
--   </pre>
--   
--   the pattern will not be rotated for the first two cycles, but will
--   rotate it by one the third cycle, and by three the fourth cycle.
--   
--   Additional example:
--   
--   <pre>
--   d1 $ every 4 (rot 2) $ slow 2 $ sound "bd hh hh hh"
--   </pre>
rot :: Ord a => Pattern Int -> Pattern a -> Pattern a

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

-- | <tt>segment n p</tt> ’samples’ the pattern <tt>p</tt> at a rate of
--   <tt>n</tt> events per cycle. Useful for turning a continuous pattern
--   into a discrete one.
--   
--   In the following example, the pattern originates from the shape of a
--   sine wave, a continuous pattern. Without <tt>segment</tt>, the samples
--   will get triggered at an undefined frequency which may be very high.
--   
--   <pre>
--   d1 $ n (slow 2 $ segment 16 $ range 0 32 $ sine) # sound "amencutup"
--   </pre>
segment :: Pattern Time -> Pattern a -> Pattern a
_segment :: Time -> Pattern a -> Pattern a

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

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

-- | <tt>struct a b</tt> structures pattern <tt>b</tt> in terms of the
--   pattern of boolean values <tt>a</tt>. Only <tt>True</tt> values in the
--   boolean pattern are used.
--   
--   The following are equivalent:
--   
--   <pre>
--   d1 $ struct ("t ~ t*2 ~") $ sound "cp"
--   d1 $ sound "cp ~ cp*2 ~"
--   </pre>
--   
--   The structure comes from a boolean pattern, i.e. a binary pattern
--   containing true or false values. Above we only used true values,
--   denoted by <tt>t</tt>. It’s also possible to include false values with
--   <tt>f</tt>, which <tt>struct</tt> will simply treat as silence. For
--   example, this would have the same outcome as the above:
--   
--   <pre>
--   d1 $ struct ("t f t*2 f") $ sound "cp"
--   </pre>
--   
--   These true / false binary patterns become useful when you
--   conditionally manipulate them, for example, ‘inverting’ the values
--   using <a>every</a> and <a>inv</a>:
--   
--   <pre>
--   d1 $ struct (every 3 inv "t f t*2 f") $ sound "cp"
--   </pre>
--   
--   In the above, the boolean values will be ‘inverted’ every third cycle,
--   so that the structure comes from the <tt>f</tt>s rather than
--   <tt>t</tt>. Note that euclidean patterns also create true/false
--   values, for example:
--   
--   <pre>
--   d1 $ struct (every 3 inv "t(3,8)") $ sound "cp"
--   </pre>
--   
--   In the above, the euclidean pattern creates <tt>"t f t f t f f t"</tt>
--   which gets inverted to <tt>"f t f t f t t f"</tt> every third cycle.
--   Note that if you prefer you can use 1 and 0 instead of <tt>t</tt> and
--   <tt>f</tt>.
struct :: Pattern Bool -> Pattern a -> Pattern a

-- | <tt>substruct a b</tt>: similar to <tt>struct</tt>, but each event in
--   pattern <tt>a</tt> gets replaced with pattern <tt>b</tt>, compressed
--   to fit the timespan of the event.
substruct :: Pattern Bool -> Pattern b -> Pattern b
randArcs :: Int -> Pattern [Arc]
randStruct :: Int -> Pattern Int
substruct' :: Pattern Int -> Pattern a -> Pattern a

-- | <tt>stripe n p</tt>: repeats pattern <tt>p</tt> <tt>n</tt> times per
--   cycle, i.e., the first parameter gives the number of cycles to operate
--   over. So, it is similar to <tt>fast</tt>, but with random durations.
--   For example <tt>stripe 2</tt> will repeat a pattern twice, over two
--   cycles
--   
--   In the following example, the start of every third repetition of the
--   <tt>d1</tt> pattern will match with the clap on the <tt>d2</tt>
--   pattern.
--   
--   <pre>
--   d1 $ stripe 3 $ sound "bd sd ~ [mt ht]"
--   d2 $ sound "cp"
--   </pre>
--   
--   The repetitions will be contiguous (touching, but not overlapping) and
--   the durations will add up to a single cycle. <tt>n</tt> can be
--   supplied as a pattern of integers.
stripe :: Pattern Int -> Pattern a -> Pattern a
_stripe :: Int -> Pattern a -> Pattern a

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

-- | Returns the <tt>n</tt>th iteration of a <a>Lindenmayer System</a> with
--   given start sequence.
--   
--   It takes an integer <tt>b</tt>, a Lindenmayer system rule set, and an
--   initiating string as input in order to generate an L-system tree
--   string of <tt>b</tt> iterations. It can be used in conjunction with a
--   step function to convert the generated string into a playable pattern.
--   For example,
--   
--   <pre>
--   d1 $ slow 16
--      $ sound
--      $ step' ["feel:0", "sn:1", "bd:0"]
--          ( take 512
--          $ lindenmayer 5 "0:1~~~,1:0~~~2~~~~~0~~~2~,2:2~1~,~:~~1~" "0"
--          )
--   </pre>
--   
--   generates an L-system with initiating string <tt>"0"</tt> and maps it
--   onto a list of samples.
--   
--   Complex L-system trees with many rules and iterations can sometimes
--   result in unwieldy strings. Using <tt>take n</tt> to only use the
--   first <tt>n</tt> elements of the string, along with a <a>slow</a>
--   function, can make the generated values more manageable.
lindenmayer :: Int -> String -> String -> String

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

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

-- | <tt>markovPat n xi tp</tt> generates a one-cycle pattern of <tt>n</tt>
--   steps in a Markov chain starting from state <tt>xi</tt> with
--   transition matrix <tt>tp</tt>. Each row of the transition matrix is
--   automatically normalized. For example:
--   
--   <pre>
--   &gt;&gt;&gt; markovPat 8 1 [[3,5,2], [4,4,2], [0,1,0]]
--   (0&gt;⅛)|1
--   (⅛&gt;¼)|2
--   (¼&gt;⅜)|1
--   (⅜&gt;½)|1
--   (½&gt;⅝)|2
--   (⅝&gt;¾)|1
--   (¾&gt;⅞)|1
--   (⅞&gt;1)|0
--   </pre>
markovPat :: Pattern Int -> Pattern Int -> [[Double]] -> Pattern Int
_markovPat :: Int -> Int -> [[Double]] -> Pattern Int

-- | <tt>beat</tt> structures a pattern by picking subdivisions of a cycle.
--   Takes in a pattern that tells it which parts to play (polyphony is
--   recommeded here), and the number of parts by which to subdivide the
--   cycle (also pattern-able). For example: &gt; d1 $ beat
--   "[3,4.2,9,11,14]" 16 $ s "sd"
beat :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a
__beat :: (Pattern (Pattern a) -> Pattern a) -> Time -> Time -> Pattern a -> Pattern a

-- | <tt>mask</tt> takes a boolean pattern and ‘masks’ another pattern with
--   it. That is, events are only carried over if they match within a
--   ‘true’ event in the binary pattern, i.e., it removes events from the
--   second pattern that don't start during an event from the first.
--   
--   For example, consider this kind of messy rhythm without any rests.
--   
--   <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 <tt>"sn*8"</tt> and in the next cycle to <tt>"[cp*4 bd*4,
--   hc*5]"</tt>.
--   
--   You could achieve the same effect by adding rests within the
--   <a>slowcat</a> patterns, but mask allows you to do this more easily.
--   It kind of keeps the rhythmic structure and you can change the used
--   samples independently, e.g.,
--   
--   <pre>
--   d1 $ s ( mask ("1 ~ 1 ~ 1 1 ~ 1")
--            ( slowcat ["can*8", "[cp*4 sn*4, jvbass*16]"] )
--          )
--     # n (run 8)
--   </pre>
mask :: Pattern Bool -> Pattern a -> Pattern a
enclosingArc :: [Arc] -> Arc

-- | <tt>stretch</tt> takes a pattern, and if there’s silences at the start
--   or end of the current cycle, it will zoom in to avoid them. The
--   following are equivalent:
--   
--   <pre>
--   d1 $ note (stretch "~ 0 1 5 8*4 ~") # s "superpiano"
--   d1 $ note "0 1 5 8*4" # s "superpiano"
--   </pre>
--   
--   You can pattern silences on the extremes of a cycle to make changes to
--   the rhythm:
--   
--   <pre>
--   d1 $ note (stretch "~ &lt;0 ~&gt; 1 5 8*4 ~") # s "superpiano"
--   </pre>
stretch :: Pattern a -> Pattern a

-- | <tt>fit'</tt> 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 <tt>1</tt> just tells it to slice up a
--   single cycle of <tt>"bd sn"</tt>. The <tt>2</tt> tells it to select
--   two values each cycle, just like the first argument to <tt>fit</tt>.
--   The next pattern <tt>"0 1"</tt> is the "from" pattern which tells it
--   how to slice, which in this case means <tt>"0"</tt> maps to
--   <tt>"bd"</tt>, and <tt>"1"</tt> maps to <tt>"sn"</tt>. The next
--   pattern <tt>"1 0"</tt> is the "to" pattern, which tells it how to
--   rearrange those slices. So the final result is the pattern <tt>"sn
--   bd"</tt>.
--   
--   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 <tt>fit'</tt> then puts into a list (using the <tt>run
--   4</tt> pattern) and reassembles according to the complicated integer
--   pattern.
fit' :: Pattern Time -> Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a

-- | Treats the given pattern <tt>p</tt> as having <tt>n</tt> chunks, and
--   applies the function <tt>f</tt> to one of those sections per cycle.
--   Running: - from left to right if chunk number is positive - from right
--   to left if chunk number is negative
--   
--   <pre>
--   d1 $ chunk 4 (fast 4) $ sound "cp sn arpy [mt lt]"
--   </pre>
--   
--   The following:
--   
--   <pre>
--   d1 $ chunk 4 (# speed 2) $ sound "bd hh sn cp"
--   </pre>
--   
--   applies <tt>(# speed 2)</tt> to the uppercased part of the cycle
--   below:
--   
--   <pre>
--   BD hh sn cp
--   bd HH sn cp
--   bd hh SN cp
--   bd hh sn CP
--   </pre>
chunk :: Pattern Int -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b
_chunk :: Integral a => a -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b

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

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

-- | <tt>inside</tt> carries out an operation <i>inside</i> a cycle. For
--   example, while <tt>rev "0 1 2 3 4 5 6 7"</tt> is the same as <tt>"7 6
--   5 4 3 2 1 0"</tt>, <tt>inside 2 rev "0 1 2 3 4 5 6 7"</tt> gives
--   <tt>"3 2 1 0 7 6 5 4"</tt>.
--   
--   What this function is really doing is ‘slowing down’ the pattern by a
--   given factor, applying the given function to it, and then ‘speeding it
--   up’ by the same factor. In other words, this:
--   
--   <pre>
--   inside 2 rev "0 1 2 3 4 5 6 7"
--   </pre>
--   
--   Is doing this:
--   
--   <pre>
--   fast 2 $ rev $ slow 2 "0 1 2 3 4 5 6 7"
--   </pre>
--   
--   so rather than whole cycles, each half of a cycle is reversed.
inside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a
_inside :: Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a

-- | <tt>outside</tt> is the inverse of the <a>inside</a> function.
--   <tt>outside</tt> applies its function <i>outside</i> the cycle. Say
--   you have a pattern that takes 4 cycles to repeat and apply the rev
--   function:
--   
--   <pre>
--   d1 $ rev $ cat [s "bd bd sn",s "sn sn bd", s"lt lt sd", s "sd sd bd"]
--   </pre>
--   
--   The above generates:
--   
--   <pre>
--   d1 $ rev $ cat [s "sn bd bd",s "bd sn sn", s "sd lt lt", s "bd sd sd"]
--   </pre>
--   
--   However if you apply <tt>outside</tt>:
--   
--   <pre>
--   d1 $ outside 4 (rev) $ cat [s "bd bd sn",s "sn sn bd", s"lt lt sd", s "sd sd bd"]
--   </pre>
--   
--   The result is:
--   
--   <pre>
--   d1 $ rev $ cat [s "bd sd sd", s "sd lt lt", s "sn sn bd", s "bd bd sn"]
--   </pre>
--   
--   Notice that the whole idea has been reversed. What this function is
--   really doing is ‘speeding up’ the pattern by a given factor, applying
--   the given function to it, and then ‘slowing it down’ by the same
--   factor. In other words, this:
--   
--   <pre>
--   d1 $ slow 4 $ rev $ fast 4
--      $ cat [s "bd bd sn",s "sn sn bd", s"lt lt sd", s "sd sd bd"]
--   </pre>
--   
--   This compresses the idea into a single cycle before rev operates and
--   then slows it back to the original speed.
outside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a
_outside :: Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a

-- | Takes a pattern and loops only the first cycle of the pattern. For
--   example, the following code will only play the bass drum sample:
--   
--   <pre>
--   d1 $ loopFirst $ s "&lt;&lt;bd*4 ht*8&gt; cp*4&gt;"
--   </pre>
--   
--   This function combines with <a>sometimes</a> to insert events from the
--   first cycle randomly into subsequent cycles of the pattern:
--   
--   <pre>
--   d1 $ sometimes loopFirst $ s "&lt;&lt;bd*4 ht*8&gt; cp*4&gt;"
--   </pre>
loopFirst :: Pattern a -> Pattern a
timeLoop :: Pattern Time -> Pattern a -> Pattern a

-- | <tt>seqPLoop</tt> will keep looping the sequence when it gets to the
--   end:
--   
--   <pre>
--   d1 $ qtrigger $ seqPLoop
--     [ (0, 12, sound "bd bd*2")
--     , (4, 12, sound "hh*2 [sn cp] cp future*4")
--     , (8, 12, sound (samples "arpy*8" (run 16)))
--     ]
--   </pre>
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:
--   
--   <pre>
--   toScale [0, 4, 7] "0 1 2 3"
--   </pre>
--   
--   will turn into the pattern <tt>"0 4 7 12"</tt>.
--   
--   <tt>toScale</tt> is handy for quickly applying a scale without naming
--   it:
--   
--   <pre>
--   d1 $ n (toScale [0,2,3,5,7,8,10] "0 1 2 3 4 5 6 7") # sound "superpiano"
--   </pre>
--   
--   This function assumes your scale fits within an octave; if that's not
--   true, use <a>toScale'</a>.
--   
--   <pre>
--   toScale = toScale' 12
--   </pre>
toScale :: Num a => [a] -> Pattern Int -> Pattern a

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

-- | <tt>swingBy x n</tt> 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. So if <tt>x</tt> is 0 it does nothing, 0.5 delays for half the
--   note duration, and 1 will wrap around to doing nothing again. The end
--   result is a shuffle or swing-like rhythm. For example, the following
--   will delay every other <tt>"hh"</tt> 1/3 of the way to the next
--   <tt>"hh"</tt>:
--   
--   <pre>
--   d1 $ swingBy (1/3) 4 $ sound "hh*8"
--   </pre>
swingBy :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a

-- | As <a>swingBy</a>, with the cycle division set to ⅓.
swing :: Pattern Time -> Pattern a -> Pattern a

-- | <tt>cycleChoose</tt> is like <a>choose</a> but only picks a new item
--   from the list once each cycle.
--   
--   <pre>
--   d1 $ sound "drum ~ drum drum" # n (cycleChoose [0,2,3])
--   </pre>
cycleChoose :: [a] -> Pattern a

-- | Internal function used by shuffle and scramble
_rearrangeWith :: Pattern Int -> Int -> Pattern a -> Pattern a

-- | <tt>shuffle n p</tt> evenly divides one cycle of the pattern
--   <tt>p</tt> into <tt>n</tt> parts, and returns a random permutation of
--   the parts each cycle. For example, <tt>shuffle 3 "a b c"</tt> could
--   return <tt>"a b c"</tt>, <tt>"a c b"</tt>, <tt>"b a c"</tt>, <tt>"b c
--   a"</tt>, <tt>"c a b"</tt>, or <tt>"c b a"</tt>. But it will
--   <i>never</i> return <tt>"a a a"</tt>, because that is not a
--   permutation of the parts.
--   
--   This could also be called “sampling without replacement”.
shuffle :: Pattern Int -> Pattern a -> Pattern a
_shuffle :: Int -> Pattern a -> Pattern a

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

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

-- | The function <tt>seqP</tt> allows you to define when a sound within a
--   list starts and ends. The code below contains three separate patterns
--   in a <a>stack</a>, but each has different start times (zero cycles,
--   eight cycles, and sixteen cycles, respectively). All patterns stop
--   after 128 cycles:
--   
--   <pre>
--   d1 $ seqP [
--    (0, 128, sound "bd bd*2"),
--    (8, 128, sound "hh*2 [sn cp] cp future*4"),
--    (16, 128, sound (samples "arpy*8" (run 16)))
--   ]
--   </pre>
seqP :: [(Time, Time, Pattern a)] -> Pattern a

-- | The <tt>ur</tt> function is designed for longer form composition, by
--   allowing you to create ‘patterns of patterns’ in a repeating loop. It
--   takes four parameters: how long the loop will take, a pattern giving
--   the structure of the composition, a lookup table for named patterns to
--   feed into that structure, and a second lookup table for named
--   transformations/effects.
--   
--   The <i>ur-</i> prefix <a>comes from German</a> and means <i>proto-</i>
--   or <i>original</i>. For a mnemonic device, think of this function as
--   assembling a set of original patterns (ur-patterns) into a larger,
--   newer whole.
--   
--   Lets say you had three patterns (called <tt>a</tt>, <tt>b</tt> and
--   <tt>c</tt>), and that you wanted to play them four cycles each, over
--   twelve cycles in total. Here is one way to do it:
--   
--   <pre>
--   let pats =
--     [ ( "a", stack [ n "c4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7"
--                    , n "[c3,g4,c4]" # s "superpiano"# gain "0.7"
--                    ]
--       )
--     , ( "b", stack [ n "d4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7"
--                    , n "[d3,a4,d4]" # s "superpiano"# gain "0.7"
--                    ]
--       )
--     , ( "c", stack [ n "f4 c5 g4 f4 f5 g4 e5 g4" # s "superpiano" # gain "0.7"
--                    , n "[f4,c5,f4]" # s "superpiano"# gain "0.7"
--                    ]
--       )
--     ]
--   in
--   d1 $ ur 12 "a b c" pats []
--   </pre>
--   
--   In the above, the fourth parameter is given as an empty list, but that
--   is where you can put another lookup table, of functions rather than
--   patterns this time. For example:
--   
--   <pre>
--   let
--     pats = ...
--     fx   = [ ("reverb", ( # (room 0.8 # sz 0.99 # orbit 1)))
--            , ("faster", fast 2)
--            ]
--   in
--   d1 $ ur 12 "a b:reverb c:faster" pats fx
--   </pre>
--   
--   In this example, <tt>b</tt> has the function applied that’s named as
--   reverb, while <tt>c</tt> is made to go faster. It’s also possible to
--   schedule multiple patterns at once, like in the following:
--   
--   <pre>
--   let pats = [ ("drums", s "drum cp*2")
--              , ("melody", s "arpy:2 arpy:3 arpy:5")
--              , ("craziness", s "cp:4*8" # speed ( sine + 0.5 ))
--              ]
--       fx = [("higher", ( # speed 2))]
--   in
--   d1 $ ur 8 "[drums, melody] [drums,craziness,melody] melody:higher" pats fx
--   </pre>
ur :: Time -> Pattern String -> [(String, Pattern a)] -> [(String, Pattern a -> Pattern a)] -> Pattern a

-- | A simpler version of <a>ur</a> that just provides name-value bindings
--   that are reflected in the provided pattern.
--   
--   <tt>inhabit</tt> allows you to link patterns to some <tt>String</tt>,
--   or in other words, to give patterns a name and then call them from
--   within another pattern of <tt>String</tt>s.
--   
--   For example, we can make our own bassdrum, hi-hat and snaredrum kit:
--   
--   <pre>
--   do
--     let drum = inhabit [ ("bd", s "sine" |- accelerate 1.5)
--                        , ("hh", s "alphabet:7" # begin 0.7 # hpf 7000)
--                        , ("sd", s "invaders:3" # speed 12)
--                        ]
--     d1 $ drum "[bd*8?, [~hh]*4, sd(6,16)]"
--   </pre>
--   
--   <tt>inhabit</tt> can be very useful when using MIDI controlled drum
--   machines, since you can give understandable drum names to patterns of
--   notes.
inhabit :: [(String, Pattern a)] -> Pattern String -> Pattern a

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

-- | <tt>flatpat</tt> takes a <a>Pattern</a> of lists and pulls the list
--   elements as separate <a>Event</a>s. For example, the following code
--   uses <tt>flatpat</tt> in combination with <tt>listToPat</tt> to create
--   an alternating pattern of chords:
--   
--   <pre>
--   d1 $ n (flatpat $ listToPat [[0,4,7],[(-12),(-8),(-5)]])
--      # s "superpiano" # sustain 2
--   </pre>
--   
--   This code is equivalent to:
--   
--   <pre>
--   d1 $ n ("[0,4,7] [-12,-8,-5]") # s "superpiano" # sustain 2
--   </pre>
flatpat :: Pattern [a] -> Pattern a

-- | <tt>layer</tt> takes a list of <a>Pattern</a>-returning functions and
--   a seed element, stacking the result of applying the seed element to
--   each function in the list.
--   
--   It allows you to layer up multiple functions on one pattern. For
--   example, the following will play two versions of the pattern at the
--   same time, one reversed and one at twice the speed:
--   
--   <pre>
--   d1 $ layer [rev, fast 2] $ sound "arpy [~ arpy:4]"
--   </pre>
--   
--   The original version of the pattern can be included by using the
--   <tt>id</tt> function:
--   
--   <pre>
--   d1 $ layer [id, rev, fast 2] $ sound "arpy [~ arpy:4]"
--   </pre>
layer :: [a -> Pattern b] -> a -> Pattern b

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

-- | Shorthand alias for arpeggiate
arpg :: Pattern a -> Pattern a
arpWith :: ([EventF (ArcF Time) a] -> [EventF (ArcF Time) b]) -> Pattern a -> Pattern b

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

-- | <tt>rolled</tt> plays each note of a chord quickly in order, as
--   opposed to simultaneously; to give a chord a harp-like or strum
--   effect.
--   
--   Notes are played low to high, and are evenly distributed within
--   (1<i>4) of the chord event length, as opposed to arp</i>arpeggiate
--   that spread the notes over the whole event.
--   
--   <pre>
--   rolled $ n "c<tt>maj</tt>4" # s "superpiano"
--   </pre>
--   
--   <pre>
--   rolled = rolledBy (1/4)
--   </pre>
rolled :: Pattern a -> Pattern a
rolledBy :: Pattern (Ratio Integer) -> Pattern a -> Pattern a
rolledWith :: Ratio Integer -> Pattern a -> Pattern a

-- | <tt>ply n</tt> repeats each event <tt>n</tt> times within its arc.
--   
--   For example, the following are equivalent:
--   
--   <pre>
--   d1 $ ply 3 $ s "bd ~ sn cp"
--   d1 $ s "[bd bd bd] ~ [sn sn sn] [cp cp cp]"
--   </pre>
--   
--   The first parameter may be given as a pattern, so that the following
--   are equivalent:
--   
--   <pre>
--   d1 $ ply "2 3" $ s "bd ~ sn cp"
--   d1 $ s "[bd bd] ~ [sn sn sn] [cp cp cp]"
--   </pre>
--   
--   Here is an example of it being used conditionally:
--   
--   <pre>
--   d1 $ every 3 (ply 4) $ s "bd ~ sn cp"
--   </pre>
ply :: Pattern Rational -> Pattern a -> Pattern a
_ply :: Rational -> Pattern a -> Pattern a

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

-- | Syncopates a rhythm, shifting (delaying) each event halfway into its
--   arc (timespan).
--   
--   In mini-notation terms, it basically turns every instance of a into
--   <tt>[~ a]</tt>, e.g., <tt>"a b [c d] e"</tt> becomes the equivalent of
--   <tt>"[~ a] [~ b] [[~ c] [~ d]] [~ e]"</tt>. Every beat then becomes an
--   offbeat, and so the overall effect is to syncopate a pattern.
--   
--   In the following example, you can hear that the piano chords play
--   between the snare and the bass drum. In 4/4 time, they are playing in
--   the 2 and a half, and 4 and a half beats:
--   
--   <pre>
--   do
--     resetCycles
--     d1 $ stack [
--       press $ n "~ c'maj ~ c'maj" # s "superpiano" # gain 0.9 # pan 0.6,
--       s "[bd,clap sd bd sd]" # pan 0.4
--       ] # cps (90/60/4)
--   </pre>
--   
--   In the next example, the C major chord plays before the G major. As
--   the slot that occupies the C chord is that of one eighth note, it is
--   displaced by press only a sixteenth note:
--   
--   <pre>
--   do
--     resetCycles
--     d1 $ stack [
--       press $ n "~ [c'maj ~] ~ ~" # s "superpiano" # gain 0.9 # pan 0.6,
--       press $ n "~ g'maj ~ ~" # s "superpiano" # gain 0.9 # pan 0.4,
--       s "[bd,clap sd bd sd]"
--      ] # cps (90/60/4)
--   </pre>
press :: Pattern a -> Pattern a

-- | Like <tt>press</tt>, but allows you to specify the amount in which
--   each event is shifted as a float from 0 to 1 (exclusive).
--   
--   <tt>pressBy 0.5</tt> is the same as <tt>press</tt>, while <tt>pressBy
--   (1/3)</tt> shifts each event by a third of its arc.
--   
--   You can pattern the displacement to create interesting rhythmic
--   effects:
--   
--   <pre>
--   d1 $ stack [
--     s "bd sd bd sd",
--     pressBy "&lt;0 0.5&gt;" $ s "co:2*4"
--   ]
--   </pre>
--   
--   <pre>
--   d1 $ stack [
--     s "[bd,co sd bd sd]",
--     pressBy "&lt;0 0.25 0.5 0.75&gt;" $ s "cp"
--   ]
--   </pre>
pressBy :: Pattern Time -> Pattern a -> Pattern a
_pressBy :: Time -> Pattern a -> Pattern a
sew :: Pattern Bool -> Pattern a -> Pattern a -> Pattern a

-- | Uses the first (binary) pattern to switch between the following two
--   patterns. The resulting structure comes from the binary pattern, not
--   the source patterns. (In <a>sew</a>, by contrast, the resulting
--   structure comes from the source patterns.)
--   
--   The following uses a euclidean pattern to control CC0:
--   
--   <pre>
--   d1 $ ccv (stitch "t(7,16)" 127 0) # ccn 0  # "midi"
--   </pre>
stitch :: Pattern Bool -> Pattern a -> Pattern a -> Pattern a

-- | A binary pattern is used to conditionally apply a function to a source
--   pattern. The function is applied when a <tt>True</tt> value is active,
--   and the pattern is let through unchanged when a <tt>False</tt> value
--   is active. No events are let through where no binary values are
--   active.
while :: Pattern Bool -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

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

-- | The <tt>jux</tt> function creates strange stereo effects by applying a
--   function to a pattern, but only in the right-hand channel. For
--   example, the following reverses the pattern on the righthand side:
--   
--   <pre>
--   d1 $ slow 32 $ jux (rev) $ striateBy 32 (1/16) $ sound "bev"
--   </pre>
--   
--   When passing pattern transforms to functions like <tt>jux</tt> and
--   <a>every</a>, it's possible to chain multiple transforms together with
--   <a>.</a> (function composition). For example this both reverses and
--   halves the playback speed of the pattern in the righthand channel:
--   
--   <pre>
--   d1 $ slow 32 $ jux ((# speed "0.5") . rev) $ striateBy 32 (1/16) $ sound "bev"
--   </pre>
jux :: (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap
juxcut :: (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap
juxcut' :: [t -> Pattern ValueMap] -> t -> Pattern ValueMap

-- | In addition to <a>jux</a>, <a>jux'</a> allows using a list of pattern
--   transformations. Resulting patterns from each transformation will be
--   spread via pan from left to right.
--   
--   For example, the following will put <tt>iter 4</tt> of the pattern to
--   the far left and <a>palindrome</a> to the far right. In the center,
--   the original pattern will play and the chopped and the reversed
--   version will appear mid left and mid right respectively.
--   
--   <pre>
--   d1 $ jux' [iter 4, chop 16, id, rev, palindrome] $ sound "bd sn"
--   </pre>
--   
--   One could also write:
--   
--   <pre>
--   d1 $ stack
--        [ iter 4 $ sound "bd sn" # pan "0"
--        , chop 16 $ sound "bd sn" # pan "0.25"
--        , sound "bd sn" # pan "0.5"
--        , rev $ sound "bd sn" # pan "0.75"
--        , palindrome $ sound "bd sn" # pan "1"
--        ]
--   </pre>
jux' :: [t -> Pattern ValueMap] -> t -> Pattern ValueMap

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

-- | With <a>jux</a>, the original and effected versions of the pattern are
--   panned hard left and right (i.e., panned at 0 and 1). This can be a
--   bit much, especially when listening on headphones. The variant
--   <tt>juxBy</tt> has an additional parameter, which brings the channel
--   closer to the centre. For example:
--   
--   <pre>
--   d1 $ juxBy 0.5 (fast 2) $ sound "bd sn:1"
--   </pre>
--   
--   In the above, the two versions of the pattern would be panned at 0.25
--   and 0.75, rather than 0 and 1.
juxBy :: Pattern Double -> (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap

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

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

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

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

-- | <a>rangex</a> is an exponential version of <a>range</a>, good for
--   using with frequencies. For example, <tt>range 20 2000 "0.5"</tt> will
--   give <tt>1010</tt> - halfway between <tt>20</tt> and <tt>2000</tt>.
--   But <tt>rangex 20 2000 0.5</tt> will give <tt>200</tt> - halfway
--   between on a logarithmic scale. This usually sounds better if you’re
--   using the numbers as pitch frequencies. Since rangex uses logarithms,
--   don’t try to scale things to zero or less.
rangex :: (Functor f, Floating b) => b -> b -> f b -> f b

-- | <tt>off</tt> is similar to <a>superimpose</a>, in that it applies a
--   function to a pattern and layers up the results on top of the original
--   pattern. The difference is that <tt>off</tt> takes an extra pattern
--   being a time (in cycles) to shift the transformed version of the
--   pattern by.
--   
--   The following plays a pattern on top of itself, but offset by an
--   eighth of a cycle, with a distorting bitcrush effect applied:
--   
--   <pre>
--   d1 $ off 0.125 (# crush 2) $ sound "bd [~ sn:2] mt lt*2"
--   </pre>
--   
--   The following makes arpeggios by adding offset patterns that are
--   shifted up the scale:
--   
--   <pre>
--   d1 $ slow 2
--      $ n (off 0.25 (+12)
--      $ off 0.125 (+7)
--      $ slow 2 "c(3,8) a(3,8,2) f(3,8) e(3,8,4)")
--      # sound "superpiano"
--   </pre>
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

-- | <tt>sseq</tt> acts as a kind of simple step-sequencer using strings.
--   For example, <tt>sseq "sn" "x x 12"</tt> is equivalent to the pattern
--   of strings given by <tt>"sn ~ sn ~ sn:1 sn:2 ~"</tt>. <tt>sseq</tt>
--   substitutes the given string for each <tt>x</tt>, for each number it
--   substitutes the string followed by a colon and the number, and for
--   everything else it puts in a rest.
--   
--   In other words, <tt>sseq</tt> generates a pattern of strings in
--   exactly the syntax you’d want for selecting samples and that can be
--   fed directly into the <tt>s</tt> function.
--   
--   <pre>
--   d1 $ s (sseq "sn" "x x 12 ")
--   </pre>
sseq :: String -> String -> Pattern String

-- | <tt>sseqs</tt> is like <tt>sseq</tt> but it takes a list of pairs,
--   like sseq would, and it plays them all simultaneously.
--   
--   <pre>
--   d1 $ s (sseqs [("cp","x  x x  x x  x"),("bd", "xxxx")])
--   </pre>
sseqs :: [(String, String)] -> Pattern String

-- | like <a>sseq</a>, but allows you to specify an array of strings to use
--   for <tt>0,1,2...</tt> For example,
--   
--   <pre>
--   d1 $ s (sseq' ["superpiano","supermandolin"] "0 1 000 1")
--      # sustain 4 # n 0
--   </pre>
--   
--   is equivalent to
--   
--   <pre>
--   d1 $ s "superpiano ~ supermandolin ~ superpiano!3 ~ supermandolin"
--      # sustain 4 # n 0
--   </pre>
sseq' :: [String] -> String -> Pattern String

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

-- | Like <a>ghost'</a>, but a user-supplied function describes how to
--   alter the pattern.
--   
--   In this example, ghost notes are applied to the snare hit, but these
--   notes will be louder, not quieter, and the sample will have its
--   beginning slightly cut:
--   
--   <pre>
--   d1 $ slow 2
--      $ ghostWith (1/16) ((|*| gain 1.1) . (|&gt; begin 0.05))
--      $ sound "sn"
--   </pre>
ghostWith :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
ghost' :: Time -> Pattern ValueMap -> Pattern ValueMap

-- | As <a>ghost'</a>, but with the copies set to appear one-eighth of a
--   cycle afterwards.
--   
--   <pre>
--   ghost = ghost' 0.125
--   </pre>
--   
--   The following creates a kick snare pattern with ghost notes applied to
--   the snare hit:
--   
--   <pre>
--   d1 $ stack [ ghost $ sound "~ sn", sound "bd*2 [~ bd]" ]
--   </pre>
ghost :: Pattern ValueMap -> Pattern ValueMap

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

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

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

-- | Chooses from a list of functions, using a pattern of integers.
pickF :: Pattern Int -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a
_pickF :: Int -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a

-- | <tt>contrast f f' p p'</tt> splits the control pattern <tt>p'</tt> in
--   two, applying the function <tt>f</tt> to one and <tt>f'</tt> to the
--   other. This depends on whether events in <tt>p'</tt> contain values
--   matching with those in <tt>p</tt>. For example, in
--   
--   <pre>
--   contrast (# crush 3) (# vowel "a") (n "1") $ n "0 1" # s "bd sn" # speed 3
--   </pre>
--   
--   the first event will have the vowel effect applied and the second will
--   have the crush applied.
--   
--   <tt>contrast</tt> is like an if-else-statement over patterns. For
--   <tt>contrast t f p</tt> you can think of <tt>t</tt> as the true
--   branch, <tt>f</tt> as the false branch, and <tt>p</tt> as the test.
--   
--   You can use any control pattern as a test of equality, e.g., <tt>n
--   "<a>1</a>", speed "0.5"</tt>, or things like that. This lets you
--   choose specific properties of the pattern you’re transforming for
--   testing, like in the following example,
--   
--   <pre>
--   d1 $ contrast (|+ n 12) (|- n 12) (n "c") $ n (run 4) # s "superpiano"
--   </pre>
--   
--   where every note that isn’t middle-c will be shifted down an octave
--   but middle-c will be shifted up to c5.
--   
--   Since the test given to contrast is also a pattern, you can do things
--   like have it alternate between options:
--   
--   <pre>
--   d1 $ contrast (|+ n 12) (|- n 12) (s "&lt;superpiano superchip&gt;")
--      $ s "superpiano superchip" # n 0
--   </pre>
--   
--   If you listen to this you’ll hear that which instrument is shifted up
--   and which instrument is shifted down alternates between cycles.
contrast :: (ControlPattern -> ControlPattern) -> (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern

-- | <tt>contrastBy</tt> is contrastBy is the general version of
--   <a>contrast</a>, in which you can specify an abritrary boolean
--   function that will be used to compare the control patterns.
--   
--   <pre>
--   d2 $ contrastBy (&gt;=) (|+ n 12) (|- n 12) (n "2") $ n "0 1 2 [3 4]" # s "superpiano"
--   </pre>
contrastBy :: (a -> Value -> Bool) -> (ControlPattern -> Pattern b) -> (ControlPattern -> Pattern b) -> Pattern (Map String a) -> Pattern (Map String Value) -> Pattern b
contrastRange :: (ControlPattern -> Pattern a) -> (ControlPattern -> Pattern a) -> Pattern (Map String (Value, Value)) -> ControlPattern -> Pattern a

-- | The <tt>fix</tt> function applies another function to matching events
--   in a pattern of controls. <tt>fix</tt> is <a>contrast</a> where the
--   false-branching function is set to the identity <a>id</a>. It is like
--   <a>contrast</a>, but one function is given and applied to events with
--   matching controls.
--   
--   For example, the following only adds the <tt>crush</tt> control when
--   the <tt>n</tt> control is set to either 1 or 4:
--   
--   <pre>
--   d1 $ slow 2
--      $ fix (# crush 3) (n "[1,4]")
--      $ n "0 1 2 3 4 5 6"
--      # sound "arpy"
--   </pre>
--   
--   You can be quite specific; for example, the following applies the
--   function <tt><tt>hurry</tt> 2</tt> to sample 1 of the drum sample set,
--   and leaves the rest as they are:
--   
--   <pre>
--   fix (hurry 2) (s "drum" # n "1")
--   </pre>
fix :: (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern

-- | Like <a>contrast</a>, but one function is given, and applied to events
--   with controls which don't match. <tt>unfix</tt> is <a>fix</a> but only
--   applies when the testing pattern is <i>not</i> a match.
unfix :: (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern

-- | The <tt>fixRange</tt> function isn’t very user-friendly at the moment,
--   but you can create a <tt>fix</tt> variant with a range condition. Any
--   value of a <a>ControlPattern</a> wich matches the values will apply
--   the passed function.
--   
--   <pre>
--   d1 $ ( fixRange ( (# distort 1) . (# gain 0.8) )
--                   ( pure $ Map.singleton "note" ((VN 0, VN 7)) )
--        )
--      $ s "superpiano"
--     &lt;| note "1 12 7 11"
--   </pre>
fixRange :: (ControlPattern -> Pattern ValueMap) -> Pattern (Map String (Value, Value)) -> ControlPattern -> ControlPattern
unfixRange :: (ControlPattern -> Pattern ValueMap) -> Pattern (Map String (Value, Value)) -> ControlPattern -> ControlPattern

-- | <tt>quantise</tt> limits values in a Pattern (or other Functor) to
--   <tt>n</tt> equally spaced divisions of 1.
--   
--   It is useful for rounding a collection of numbers to some particular
--   base fraction. For example,
--   
--   <pre>
--   quantise 5 [0, 1.3 ,2.6,3.2,4.7,5]
--   </pre>
--   
--   It will round all the values to the nearest <tt>(1/5)=0.2</tt> and
--   thus will output the list <tt>[0.0,1.2,2.6,3.2,4.8,5.0]</tt>. You can
--   use this function to force a continuous pattern like sine into
--   specific values. In the following example:
--   
--   <pre>
--   d1 $ s "superchip*8" # n (quantise 1 $ range (-10) (10) $ slow 8 $ cosine)
--                        # release (quantise 5 $ slow 8 $ sine + 0.1)
--   </pre>
--   
--   all the releases selected be rounded to the nearest <tt>0.1</tt> and
--   the notes selected to the nearest <tt>1</tt>.
--   
--   <tt>quantise</tt> with fractional inputs does the consistent thing:
--   <tt>quantise 0.5</tt> rounds values to the nearest <tt>2</tt>,
--   <tt>quantise 0.25</tt> rounds the nearest <tt>4</tt>, etc.
quantise :: (Functor f, RealFrac b) => b -> f b -> f b

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

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

-- | An alias for <a>quantise</a>.
qround :: (Functor f, RealFrac b) => b -> f b -> f b

-- | Inverts all the values in a boolean pattern
inv :: Functor f => f Bool -> f Bool

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

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

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

-- | Applies a function to a pattern and cats the resulting pattern, then
--   continues applying the function until the depth is reached this can be
--   used to create a pattern that wanders away from the original pattern
--   by continually adding random numbers.
--   
--   <pre>
--   d1 $ note ( scale "hexDorian" mutateBy (+ (range -1 1 $ irand 2)) 8
--             $ "0 1 . 2 3 4"
--             )
--      # s "gtr"
--   </pre>
soak :: Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

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

-- | <tt>bite n ipat pat</tt> slices a pattern <tt>pat</tt> into <tt>n</tt>
--   pieces, then uses the <tt>ipat</tt> pattern of integers to index into
--   those slices. So <tt>bite 4 "0 2*2" (run 8)</tt> is the same as
--   <tt>"[0 1] [4 5]*2"</tt>.
--   
--   I.e., it allows you to slice each cycle into a given number of equal
--   sized bits, and then pattern those bits by number. It’s similar to
--   <tt>slice</tt>, but is for slicing up patterns, rather than samples.
--   The following slices the pattern into four bits, and then plays those
--   bits in turn:
--   
--   <pre>
--   d1 $ bite 4 "0 1 2 3" $ n "0 .. 7" # sound "arpy"
--   </pre>
--   
--   Of course that doesn’t actually change anything, but then you can
--   reorder those bits:
--   
--   <pre>
--   d1 $ bite 4 "2 0 1 3" $ n "0 .. 7" # sound "arpy"
--   </pre>
--   
--   The slices bits of pattern will be squeezed or contracted to fit:
--   
--   <pre>
--   d1 $ bite 4 "2 [0 3] 1*4 1" $ n "0 .. 7" # sound "arpy"
--   </pre>
bite :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_bite :: Int -> Pattern Int -> Pattern a -> Pattern a

-- | Chooses from a list of patterns, using a pattern of integers.
squeeze :: Pattern Int -> [Pattern a] -> Pattern a
squeezeJoinUp :: Pattern ControlPattern -> ControlPattern
_chew :: Int -> Pattern Int -> ControlPattern -> ControlPattern

-- | <tt>chew</tt> works the same as <a>bite</a>, but speeds up/slows down
--   playback of sounds as well as squeezing/contracting the slices of the
--   provided pattern. Compare:
--   
--   <pre>
--   d1 $ 'bite' 4 "0 1*2 2*2 [~ 3]" $ n "0 .. 7" # sound "drum"
--   d1 $ chew 4 "0 1*2 2*2 [~ 3]" $ n "0 .. 7" # sound "drum"
--   </pre>
chew :: Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern
__binary :: Bits b => Int -> b -> [Bool]
_binary :: Bits b => Int -> b -> Pattern Bool
_binaryN :: Int -> Pattern Int -> Pattern Bool
binaryN :: Pattern Int -> Pattern Int -> Pattern Bool
ascii :: Pattern String -> Pattern Bool

-- | Given a start point and a duration (both specified in cycles), this
--   generates a control pattern that makes a sound begin at the start
--   point and last the duration.
--   
--   The following are equivalent:
--   
--   <pre>
--   d1 $ slow 2 $ s "bev" # grain 0.2 0.1 # legato 1
--   d1 $ slow 2 $ s "bev" # begin 0.2 # end 0.3 # legato 1
--   </pre>
--   
--   <tt>grain</tt> is defined as:
--   
--   <pre>
--   grain s d = 'Sound.Tidal.Params.begin' s # 'Sound.Tidal.Params.end' (s+d)
--   </pre>
grain :: Pattern Double -> Pattern Double -> ControlPattern

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

-- | Inserts chromatic notes into a pattern.
--   
--   The first argument indicates the (patternable) number of notes to
--   insert, and the second argument is the base pattern of "anchor notes"
--   that gets transformed.
--   
--   The following are equivalent:
--   
--   <pre>
--   d1 $ up (chromaticiseBy "0 1 2 -1" "[0 2] [3 6] [5 6 8] [3 1 0]") # s "superpiano"
--   d1 $ up "[0 2] [[3 4] [6 7]] [[5 6 7] [6 7 8] [8 9 10] [[3 2] [1 0] [0 -1]]" # s "superpiano"
--   </pre>
chromaticiseBy :: (Num a, Enum a, Ord a) => Pattern a -> Pattern a -> Pattern a
_chromaticiseBy :: (Num a, Enum a, Ord a) => a -> Pattern a -> Pattern a

-- | Alias for chromaticiseBy
chromaticizeBy :: (Num a, Enum a, Ord a) => Pattern a -> Pattern a -> Pattern a
_ribbon :: Time -> Time -> Pattern a -> Pattern a

-- | Loops a pattern inside an <tt>offset</tt> for <tt>cycles</tt>. If you
--   think of the entire span of time in cycles as a ribbon, you can cut a
--   single piece and loop it.
ribbon :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a

-- | Shorthand for <a>ribbon</a>.
rib :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a

-- | Turns a pattern into a pattern of patterns, according to the structure
--   of another given pattern.
unjoin :: Pattern Bool -> Pattern b -> Pattern (Pattern b)

-- | Applies a function to subcycles of a pattern, as defined by the
--   structure of another given pattern.
into :: Pattern Bool -> (Pattern a -> Pattern b) -> Pattern a -> Pattern b
data Sign
Positive :: Sign
Negative :: Sign
type ColourD = Colour Double
class Enumerable a
fromTo :: Enumerable a => a -> a -> Pattern a
fromThenTo :: Enumerable a => a -> a -> a -> Pattern a
class Parseable a
tPatParser :: Parseable a => MyParser (TPat a)
doEuclid :: Parseable a => Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
getControl :: Parseable a => String -> Pattern a

-- | AST representation of patterns
data TPat a
[TPat_Atom] :: forall a. Maybe ((Int, Int), (Int, Int)) -> a -> TPat a
[TPat_Fast] :: forall a. TPat Time -> TPat a -> TPat a
[TPat_Slow] :: forall a. TPat Time -> TPat a -> TPat a
[TPat_DegradeBy] :: forall a. Int -> Double -> TPat a -> TPat a
[TPat_CycleChoose] :: forall a. Int -> [TPat a] -> TPat a
[TPat_Euclid] :: forall a. TPat Int -> TPat Int -> TPat Int -> TPat a -> TPat a
[TPat_Stack] :: forall a. [TPat a] -> TPat a
[TPat_Polyrhythm] :: forall a. Maybe (TPat Rational) -> [TPat a] -> TPat a
[TPat_Seq] :: forall a. [TPat a] -> TPat a
[TPat_Silence] :: forall a. TPat a
[TPat_Foot] :: forall a. TPat a
[TPat_Elongate] :: forall a. Rational -> TPat a -> TPat a
[TPat_Repeat] :: forall a. Int -> TPat a -> TPat a
[TPat_EnumFromTo] :: forall a. TPat a -> TPat a -> TPat a
[TPat_Var] :: forall a. String -> TPat a
[TPat_Chord] :: forall b a. (Num b, Enum b, Parseable b, Enumerable b) => (b -> a) -> TPat b -> TPat String -> [TPat [Modifier]] -> TPat a
type MyParser = Parsec String Int
data TidalParseError
TidalParseError :: ParseError -> String -> TidalParseError
[parsecError] :: TidalParseError -> ParseError
[code] :: TidalParseError -> String
tShowList :: Show a => [TPat a] -> String
tShow :: Show a => TPat a -> String
toPat :: (Parseable a, Enumerable a) => TPat a -> Pattern a
resolve_tpat :: (Enumerable a, Parseable a) => TPat a -> (Rational, Pattern a)
resolve_seq :: (Enumerable a, Parseable a) => [TPat a] -> (Rational, Pattern a)
resolve_size :: [TPat a] -> [(Rational, TPat a)]
steps_tpat :: Show a => TPat a -> (Rational, String)
steps_seq :: Show a => [TPat a] -> (Rational, String)
steps_size :: Show a => [TPat a] -> [(Rational, String)]
parseBP :: (Enumerable a, Parseable a) => String -> Either ParseError (Pattern a)
parseBP_E :: (Enumerable a, Parseable a) => String -> Pattern a
parseTPat :: Parseable a => String -> Either ParseError (TPat a)

-- | a <a>-</a> is a negative sign if followed anything but another dash
--   otherwise, it's treated as rest
parseRest :: Parseable a => MyParser (TPat a)
cP :: (Enumerable a, Parseable a) => String -> Pattern a
enumFromTo' :: (Ord a, Enum a) => a -> a -> Pattern a
enumFromThenTo' :: (Ord a, Enum a, Num a) => a -> a -> a -> Pattern a
lexer :: GenTokenParser String u Identity
braces :: MyParser a -> MyParser a
brackets :: MyParser a -> MyParser a
parens :: MyParser a -> MyParser a
angles :: MyParser a -> MyParser a
symbol :: String -> MyParser String
natural :: MyParser Integer
integer :: MyParser Integer
decimal :: MyParser Integer
float :: MyParser Double
naturalOrFloat :: MyParser (Either Integer Double)
applySign :: Num a => Sign -> a -> a
sign :: MyParser Sign
intOrFloat :: MyParser Double

-- | parser starting point
pTidal :: Parseable a => MyParser (TPat a) -> MyParser (TPat a)

-- | Try different parsers on a sequence of Tidal patterns <tt>f</tt> is
--   the sequence so far, <tt>a</tt> the next upcoming token/non-terminal
pSequence :: Parseable a => MyParser (TPat a) -> MyParser (TPat a)
pFoot :: MyParser (TPat a)
pEnumeration :: Parseable a => MyParser (TPat a) -> TPat a -> MyParser (TPat a)
pRepeat :: TPat a -> MyParser (TPat a)
pElongate :: TPat a -> MyParser (TPat a)
pSingle :: MyParser (TPat a) -> MyParser (TPat a)
pVar :: MyParser (TPat a)
pPart :: Parseable a => MyParser (TPat a) -> MyParser (TPat a)
newSeed :: MyParser Int
pPolyIn :: Parseable a => MyParser (TPat a) -> MyParser (TPat a)
pPolyOut :: Parseable a => MyParser (TPat a) -> MyParser (TPat a)
pCharNum :: MyParser Char
pString :: MyParser String
wrapPos :: MyParser (TPat a) -> MyParser (TPat a)
pVocable :: MyParser (TPat String)
pChar :: MyParser (TPat Char)
pDouble :: MyParser (TPat Double)
pDoubleWithoutChord :: MyParser (TPat Double)
pNote :: MyParser (TPat Note)
pNoteWithoutChord :: MyParser (TPat Note)
pBool :: MyParser (TPat Bool)
parseIntNote :: Integral i => MyParser i
pIntegral :: (Integral a, Parseable a, Enumerable a) => MyParser (TPat a)
pIntegralWithoutChord :: (Integral a, Parseable a, Enumerable a) => MyParser (TPat a)
parseChord :: (Enum a, Num a) => MyParser [a]
parseNote :: Num a => MyParser a
fromNote :: Num a => Pattern String -> Pattern a
pColour :: MyParser (TPat ColourD)
pMult :: TPat a -> MyParser (TPat a)
pRand :: TPat a -> MyParser (TPat a)

-- | parse Euclidean notation like 'bd(3,8)'
pE :: TPat a -> MyParser (TPat a)
pRational :: MyParser (TPat Rational)
pRatio :: MyParser Rational
pInteger :: MyParser Double
pFloat :: MyParser Double
pFraction :: RealFrac a => a -> MyParser Rational
pRatioChar :: Fractional a => MyParser a
pRatioSingleChar :: Fractional a => Char -> a -> MyParser a
isInt :: RealFrac a => a -> Bool
parseModInv :: MyParser Modifier
parseModInvNum :: MyParser [Modifier]
parseModDrop :: MyParser [Modifier]
parseModOpen :: MyParser Modifier
parseModRange :: MyParser Modifier
parseModifiers :: MyParser [Modifier]
pModifiers :: MyParser (TPat [Modifier])
pChord :: (Enum a, Num a, Parseable a, Enumerable a) => TPat a -> MyParser (TPat a)

-- | <a>spin</a> will "spin" and layer up a pattern the given number of
--   times, with each successive layer offset in time by an additional
--   <tt>1/n</tt> of a cycle, and panned by an additional <tt>1/n</tt>. The
--   result is a pattern that seems to spin around. This function work well
--   on multichannel systems.
--   
--   <pre>
--   d1 $ slow 3
--      $ spin 4
--      $ sound "drum*3 tabla:4 [arpy:2 ~ arpy] [can:2 can:3]"
--   </pre>
spin :: Pattern Int -> ControlPattern -> ControlPattern
_spin :: Int -> ControlPattern -> ControlPattern

-- | <a>chop</a> granularises every sample in place as it is played,
--   turning a pattern of samples into a pattern of sample parts. Can be
--   used to explore granular synthesis.
--   
--   Use an integer value to specify how many granules each sample is
--   chopped into:
--   
--   <pre>
--   d1 $ chop 16 $ sound "arpy arp feel*4 arpy*4"
--   </pre>
--   
--   Different values of <tt>chop</tt> 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>
--   
--   You can also use <tt>chop</tt> (or <a>striate</a>) with very long
--   samples to cut them into short chunks and pattern those chunks. The
--   following cuts a sample into 32 parts, and plays it over 8 cycles:
--   
--   <pre>
--   d1 $ loopAt 8 $ chop 32 $ sound "bev"
--   </pre>
--   
--   The <a>loopAt</a> takes care of changing the speed of sample playback
--   so that the sample fits in the given number of cycles perfectly. As a
--   result, in the above the granules line up perfectly, so you can’t
--   really hear that the sample has been cut into bits. Again, this
--   becomes more apparent when you do further manipulations of the
--   pattern, for example <a>rev</a> to reverse the order of the cut up
--   bits:
--   
--   <pre>
--   d1 $ loopAt 8 $ rev $ chop 32 $ sound "bev"
--   </pre>
chop :: Pattern Int -> ControlPattern -> ControlPattern
chopArc :: Arc -> Int -> [Arc]
_chop :: Int -> ControlPattern -> ControlPattern

-- | Striate is a kind of granulator, cutting samples into bits in a
--   similar to chop, but the resulting bits are organised differently. For
--   example:
--   
--   <pre>
--   d1 $ striate 3 $ sound "ho ho:2 ho:3 hc"
--   </pre>
--   
--   This plays the loop the given number of times, but triggers
--   progressive portions of each sample. So in this case it plays the loop
--   three times, the first time playing the first third of each sample,
--   then the second time playing the second third of each sample, and
--   lastly playing the last third of each sample. Replacing
--   <tt>striate</tt> with <a>chop</a> above, one can hear that the
--   '<a>chop</a> version plays the bits from each chopped-up sample in
--   turn, while <tt>striate</tt> "interlaces" the cut up bits of samples
--   together.
--   
--   You can also use <tt>striate</tt> with very long samples, to cut them
--   into short chunks and pattern those chunks. This is where things get
--   towards granular synthesis. The following cuts a sample into 128
--   parts, plays it over 8 cycles and manipulates those parts by reversing
--   and rotating the loops:
--   
--   <pre>
--   d1 $  slow 8 $ striate 128 $ sound "bev"
--   </pre>
striate :: Pattern Int -> ControlPattern -> ControlPattern
_striate :: Int -> ControlPattern -> ControlPattern
mergePlayRange :: (Double, Double) -> ValueMap -> ValueMap

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

-- | DEPRECATED, use <a>striateBy</a> instead.
striate' :: Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern
_striateBy :: Int -> Double -> ControlPattern -> ControlPattern

-- | <a>gap</a> is similar to <a>chop</a> in that it granualizes every
--   sample in place as it is played, but every other grain is silent. Use
--   an integer value to specify how many granules each sample is chopped
--   into:
--   
--   <pre>
--   d1 $ gap 8 $ sound "jvbass"
--   d1 $ gap 16 $ sound "[jvbass drum:4]"
--   </pre>
gap :: Pattern Int -> ControlPattern -> ControlPattern
_gap :: Int -> ControlPattern -> ControlPattern

-- | <tt>weave</tt> applies one control pattern to a list of other control
--   patterns, with a successive time offset. It uses an
--   <tt>OscPattern</tt> to apply the function at different levels to each
--   pattern, creating a weaving effect. For example:
--   
--   <pre>
--   d1 $ weave 16 (pan sine)
--        [ sound "bd sn cp"
--        , sound "casio casio:1"
--        , sound "[jvbass*2 jvbass:2]/2"
--        , sound "hc*4"
--        ]
--   </pre>
--   
--   In the above, the <tt>pan sine</tt> control pattern is slowed down by
--   the given number of cycles, in particular 16, and applied to all of
--   the given sound patterns. What makes this interesting is that the
--   <tt>pan</tt> control pattern is successively offset for each of the
--   given sound patterns; because the <tt>pan</tt> is closed down by 16
--   cycles, and there are four patterns, they are ‘spread out’, i.e. with
--   a gap of four cycles. For this reason, the four patterns seem to chase
--   after each other around the stereo field. Try listening on headphones
--   to hear this more clearly.
--   
--   You can even have it the other way round, and have the effect
--   parameters chasing after each other around a sound parameter, like
--   this:
--   
--   <pre>
--   d1 $ weave 16 (sound "arpy" &gt;| n (run 8))
--        [ vowel "a e i"
--        , vowel "i [i o] o u"
--        , vowel "[e o]/3 [i o u]/2"
--        , speed "1 2 3"
--        ]
--   </pre>
weave :: Time -> ControlPattern -> [ControlPattern] -> ControlPattern

-- | <tt>weaveWith</tt> is similar to the above, but weaves with a list of
--   functions, rather than a list of controls. For example:
--   
--   <pre>
--   d1 $ weaveWith 3 (sound "bd [sn drum:2*2] bd*2 [sn drum:1]")
--        [ fast 2
--        , (# speed "0.5")
--        , chop 16
--        ]
--   </pre>
weaveWith :: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a

-- | An old alias for <a>weaveWith</a>.
weave' :: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a

-- | (A function that takes two ControlPatterns, and blends them together
--   into a new ControlPattern. An ControlPattern is basically a pattern of
--   messages to a synthesiser.)
--   
--   Shifts between the two given patterns, using distortion.
--   
--   Example:
--   
--   <pre>
--   d1 $ interlace (sound  "bd sn kurt") (every 3 rev $ sound  "bd sn:2")
--   </pre>
interlace :: ControlPattern -> ControlPattern -> ControlPattern

-- | <tt>slice</tt> is similar to <a>chop</a> and <a>striate</a>, in that
--   it’s used to slice samples up into bits. The difference is that it
--   allows you to rearrange those bits as a pattern.
--   
--   <pre>
--   d1 $ slice 8 "7 6 5 4 3 2 1 0"
--      $ sound "breaks165"
--      # legato 1
--   </pre>
--   
--   The above slices the sample into eight bits, and then plays them
--   backwards, equivalent of applying rev $ chop 8. Here’s a more complex
--   example:
--   
--   <pre>
--   d1 $ slice 8 "[&lt;0*8 0*2&gt; 3*4 2 4] [4 .. 7]"
--      $ sound "breaks165"
--      # legato 1
--   </pre>
slice :: Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern
_slice :: Int -> Int -> ControlPattern -> ControlPattern

-- | <tt>randslice</tt> chops the sample into the given number of pieces
--   and then plays back a random one each cycle:
--   
--   <pre>
--   d1 $ randslice 32 $ sound "bev"
--   </pre>
--   
--   Use <a>fast</a> to get more than one per cycle:
--   
--   <pre>
--   d1 $ fast 4 $ randslice 32 $ sound "bev"
--   </pre>
randslice :: Pattern Int -> ControlPattern -> ControlPattern
_splice :: Int -> Pattern Int -> ControlPattern -> Pattern (Map String Value)

-- | <tt>splice</tt> is similar to <a>slice</a>, but the slices are
--   automatically pitched up or down to fit their ‘slot’.
--   
--   <pre>
--   d1 $ splice 8 "[&lt;0*8 0*2&gt; 3*4 2 4] [4 .. 7]" $ sound "breaks165"
--   </pre>
splice :: Pattern Int -> Pattern Int -> ControlPattern -> Pattern (Map String Value)

-- | <tt>loopAt</tt> makes a sample fit the given number of cycles.
--   Internally, it works by setting the <tt>unit</tt> parameter to
--   <tt>"c"</tt>, changing the playback speed of the sample with the
--   <tt>speed</tt> parameter, and setting setting the <a>density</a> of
--   the pattern to match.
--   
--   <pre>
--   d1 $ loopAt 4 $ sound "breaks125"
--   </pre>
--   
--   It’s a good idea to use this in conjuction with <a>chop</a>, so the
--   break is chopped into pieces and you don’t have to wait for the whole
--   sample to start/stop.
--   
--   <pre>
--   d1 $ loopAt 4 $ chop 32 $ sound "breaks125"
--   </pre>
--   
--   Like all Tidal functions, you can mess about with this considerably.
--   The below example shows how you can supply a pattern of cycle counts
--   to <tt>loopAt</tt>:
--   
--   <pre>
--   d1 $ juxBy 0.6 (|* speed "2")
--      $ slowspread (loopAt) [4,6,2,3]
--      $ chop 12
--      $ sound "fm:14"
--   </pre>
loopAt :: Pattern Time -> ControlPattern -> ControlPattern

-- | <tt>hurry</tt> is similiar to <a>fast</a> in that it speeds up a
--   pattern, but it also increases the speed control by the same factor.
--   So, if you’re triggering samples, the sound gets higher in pitch. For
--   example:
--   
--   <pre>
--   d1 $ every 2 (hurry 2) $ sound "bd sn:2 ~ cp"
--   </pre>
hurry :: Pattern Rational -> ControlPattern -> ControlPattern

-- | <tt>smash</tt> is a combination of <tt>spread</tt> and <a>striate</a>
--   — it cuts the samples into the given number of bits, and then cuts
--   between playing the loop at different speeds according to the values
--   in the list. So this:
--   
--   <pre>
--   d1 $ smash 3 [2,3,4] $ sound "ho ho:2 ho:3 hc"
--   </pre>
--   
--   is a bit like this:
--   
--   <pre>
--   d1 $ spread (slow) [2,3,4] $ striate 3 $ sound "ho ho:2 ho:3 hc"
--   </pre>
--   
--   This is quite dancehall:
--   
--   <pre>
--   d1 $ ( spread' slow "1%4 2 1 3"
--        $ spread (striate) [2,3,4,1]
--        $ sound "sn:2 sid:3 cp sid:4"
--        )
--      # speed "[1 2 1 1]/2"
--   </pre>
smash :: Pattern Int -> [Pattern Time] -> ControlPattern -> Pattern ValueMap

-- | An altenative form of <a>smash</a>, which uses <a>chop</a> instead of
--   <a>striate</a>.
--   
--   Compare the following variations:
--   
--   <pre>
--   d1 $ smash 6 [2,3,4] $ sound "ho ho:2 ho:3 hc"
--   d1 $ smash' 6 [2,3,4] $ sound "ho ho:2 ho:3 hc"
--   d1 $ smash 12 [2,3,4] $ s "bev*4"
--   d1 $ smash' 12 [2,3,4] $ s "bev*4"
--   </pre>
smash' :: Int -> [Pattern Time] -> ControlPattern -> ControlPattern
_echo :: Integer -> Rational -> Double -> ControlPattern -> ControlPattern

-- | <tt>echoWith</tt> is similar to <a>echo</a>, but instead of just
--   decreasing volume to produce echoes, <tt>echoWith</tt> applies a
--   function each step and overlays the result delayed by the given time.
--   
--   <pre>
--   d1 $ echoWith 2 "1%3" (# vowel "{a e i o u}%2") $ sound "bd sn"
--   </pre>
--   
--   In this case there are two _overlays_ delayed by 1/3 of a cycle, where
--   each has the <tt>vowel</tt> filter applied.
--   
--   <pre>
--   d1 $ echoWith 4 (1/6) (|* speed "1.5") $ sound "arpy arpy:2"
--   </pre>
--   
--   In the above, three versions are put on top, with each step getting
--   higher in pitch as <tt>|* speed "1.5"</tt> is successively applied.
echoWith :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_echoWith :: (Num n, Ord n) => n -> Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

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

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

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

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

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

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

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

-- | Alias for <a>qtrigger</a>.
qt :: Pattern a -> Pattern a

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

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

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

-- | (Alias <tt><b>mt</b></tt>) Mod trigger. Aligns the start of a pattern
--   to the next cycle boundary where the cycle is evenly divisible by a
--   given number. <a>qtrigger</a> is equivalent to <tt>mtrigger 1</tt>.
--   
--   In the following example, when activating the <tt>d1</tt> pattern, it
--   will start at the same time as the next clap, even if it has to wait
--   for 3 cycles. Once activated, the <tt>arpy</tt> sound will play on
--   every cycle, just like any other pattern:
--   
--   <pre>
--   do
--     resetCycles
--     d2 $ every 4 (# s "clap") $ s "bd"
--   </pre>
--   
--   <pre>
--   d1 $ mtrigger 4 $ filterWhen (&gt;=0) $ s "arpy"
--   </pre>
mtrigger :: Int -> Pattern a -> Pattern a

-- | Alias for <a>mtrigger</a>.
mt :: Int -> Pattern a -> Pattern a

-- | This aligns the start of a pattern to some value relative to the time
--   the pattern is evaluated. The provided function maps the evaluation
--   time (on the global cycle clock) to a new time, and then
--   <tt>triggerWith</tt> aligns the pattern's start to the time that's
--   returned.
--   
--   This is a more flexible triggering function. In fact, all the other
--   trigger functions are defined based on <tt>triggerWith</tt>. For
--   example, <a>trigger</a> is just <tt>triggerWith id</tt>.
--   
--   In the next example, use <tt>d1</tt> as a metronome, and play with
--   different values (from 0 to 1) on the <tt>const</tt> expression.
--   You’ll notice how the <tt>clap</tt> is displaced from the beginning of
--   each cycle to the end, as the number increases:
--   
--   <pre>
--   d1 $ s "bd hh!3"
--   
--   d2 $ triggerWith (const 0.1) $ s "clap"
--   </pre>
--   
--   This last example is equivalent to this:
--   
--   <pre>
--   d2 $ rotR 0.1 $ s "clap"
--   </pre>
triggerWith :: (Time -> Time) -> Pattern a -> Pattern a
splat :: Pattern Int -> ControlPattern -> ControlPattern -> ControlPattern
crunch :: ControlPattern -> ControlPattern
scratch :: ControlPattern -> ControlPattern
louder :: ControlPattern -> ControlPattern
quieter :: ControlPattern -> ControlPattern
silent :: ControlPattern -> ControlPattern
skip :: ControlPattern -> ControlPattern
left :: ControlPattern -> ControlPattern
right :: ControlPattern -> ControlPattern
higher :: ControlPattern -> ControlPattern
lower :: ControlPattern -> ControlPattern
faster :: ControlPattern -> ControlPattern
slower :: ControlPattern -> ControlPattern
data Ratio a
type Rational = Ratio Integer
defaultConfig :: Config
data Config
Config :: Bool -> String -> Int -> Bool -> Bool -> CDouble -> CDouble -> Double -> Bool -> Int64 -> Double -> Config
[cCtrlListen] :: Config -> Bool
[cCtrlAddr] :: Config -> String
[cCtrlPort] :: Config -> Int
[cCtrlBroadcast] :: Config -> Bool
[cVerbose] :: Config -> Bool
[cQuantum] :: Config -> CDouble
[cBeatsPerCycle] :: Config -> CDouble
[cFrameTimespan] :: Config -> Double
[cEnableLink] :: Config -> Bool
[cSkipTicks] :: Config -> Int64
[cProcessAhead] :: Config -> Double
data Stream
Stream :: Config -> MVar ValueMap -> ClockRef -> Maybe Udp -> MVar PlayMap -> MVar (ControlPattern -> ControlPattern) -> [Cx] -> Stream
[sConfig] :: Stream -> Config
[sStateMV] :: Stream -> MVar ValueMap
[sClockRef] :: Stream -> ClockRef
[sListen] :: Stream -> Maybe Udp
[sPMapMV] :: Stream -> MVar PlayMap
[sGlobalFMV] :: Stream -> MVar (ControlPattern -> ControlPattern)
[sCxs] :: Stream -> [Cx]
streamReplace :: Stream -> ID -> ControlPattern -> IO ()
streamHush :: Stream -> IO ()
streamList :: Stream -> IO ()
streamMute :: Stream -> ID -> IO ()
streamUnmute :: Stream -> ID -> IO ()
streamSolo :: Stream -> ID -> IO ()
streamUnsolo :: Stream -> ID -> IO ()
streamOnce :: Stream -> ControlPattern -> IO ()
streamFirst :: Stream -> ControlPattern -> IO ()
streamNudgeAll :: Stream -> Double -> IO ()
streamAll :: Stream -> (ControlPattern -> ControlPattern) -> IO ()
streamResetCycles :: Stream -> IO ()
streamSetI :: Stream -> String -> Pattern Int -> IO ()
streamSetF :: Stream -> String -> Pattern Double -> IO ()
streamSetS :: Stream -> String -> Pattern String -> IO ()
streamSetR :: Stream -> String -> Pattern Rational -> IO ()
streamSetB :: Stream -> String -> Pattern Bool -> IO ()
transition :: Stream -> Bool -> TransitionMapper -> ID -> ControlPattern -> IO ()
data Target
Target :: String -> String -> Int -> Maybe Int -> Double -> Maybe Arc -> Schedule -> Bool -> Target
[oName] :: Target -> String
[oAddress] :: Target -> String
[oPort] :: Target -> Int
[oBusPort] :: Target -> Maybe Int
[oLatency] :: Target -> Double
[oWindow] :: Target -> Maybe Arc
[oSchedule] :: Target -> Schedule
[oHandshake] :: Target -> Bool
startTidal :: Target -> Config -> IO Stream
superdirtTarget :: Target
openListener :: Config -> IO (Maybe Udp)
toClockConfig :: Config -> ClockConfig
verbose :: Config -> String -> IO ()
ctrlResponder :: Config -> Stream -> IO ()

-- | Query the current pattern (contained in argument <tt>stream ::
--   Stream</tt>) for the events in the current arc (contained in argument
--   <tt>st :: T.State</tt>), translate them to OSC messages, and send
--   these.
--   
--   If an exception occurs during sending, this functions prints a warning
--   and continues, because the likely reason is that the backend
--   (supercollider) isn't running.
--   
--   If any exception occurs before or outside sending (e.g., while
--   querying the pattern, while computing a message), this function prints
--   a warning and resets the current pattern to the previous one (or to
--   silence if there isn't one) and continues, because the likely reason
--   is that something is wrong with the current pattern.
doTick :: MVar ValueMap -> MVar PlayMap -> MVar (ControlPattern -> ControlPattern) -> [Cx] -> (Time, Time) -> Double -> ClockConfig -> ClockRef -> (SessionState, SessionState) -> IO ()
getCXs :: Config -> [(Target, [OSC])] -> IO [Cx]
superdirtShape :: OSC
data OSC
OSC :: String -> Args -> OSC
[path] :: OSC -> String
[args] :: OSC -> Args
OSCContext :: String -> OSC
[path] :: OSC -> String
tidal_status_string :: IO String
send :: Cx -> Double -> Double -> (Double, Bool, Message) -> IO ()
data PlayState
PlayState :: ControlPattern -> Bool -> Bool -> [ControlPattern] -> PlayState
[psPattern] :: PlayState -> ControlPattern
[psMute] :: PlayState -> Bool
[psSolo] :: PlayState -> Bool
[psHistory] :: PlayState -> [ControlPattern]
tidal_version :: String
denominator :: Ratio a -> a
numerator :: Ratio a -> a
setFrameTimespan :: Double -> Config -> Config
setProcessAhead :: Double -> Config -> Config
(%) :: Integral a => a -> a -> Ratio a
type PlayMap = Map PatId PlayState
data Cx
Cx :: Target -> Udp -> [OSC] -> AddrInfo -> Maybe AddrInfo -> Maybe (MVar [Int]) -> Cx
[cxTarget] :: Cx -> Target
[cxUDP] :: Cx -> Udp
[cxOSCs] :: Cx -> [OSC]
[cxAddr] :: Cx -> AddrInfo
[cxBusAddr] :: Cx -> Maybe AddrInfo
[cxBusses] :: Cx -> Maybe (MVar [Int])
data StampStyle
BundleStamp :: StampStyle
MessageStamp :: StampStyle
data Schedule
Pre :: StampStyle -> Schedule
Live :: Schedule
data Args
Named :: [String] -> Args
[requiredArgs] :: Args -> [String]
ArgList :: [(String, Maybe Value)] -> Args
type PatId = String
resolve :: String -> Int -> IO AddrInfo
handshake :: Cx -> Config -> IO ()
recvMessagesTimeout :: Transport t => Double -> t -> IO [Message]
sendBndl :: Bool -> Cx -> Bundle -> IO ()
sendO :: Bool -> Cx -> Message -> IO ()
dirtTarget :: Target
dirtShape :: OSC
fDefault :: Double -> Maybe Value
sDefault :: String -> Maybe Value
iDefault :: Int -> Maybe Value
rDefault :: Rational -> Maybe Value
bDefault :: Bool -> Maybe Value
xDefault :: [Word8] -> Maybe Value
data ProcessedEvent
ProcessedEvent :: Bool -> Event ValueMap -> Double -> Micros -> Time -> Micros -> Time -> Micros -> Time -> ProcessedEvent
[peHasOnset] :: ProcessedEvent -> Bool
[peEvent] :: ProcessedEvent -> Event ValueMap
[peCps] :: ProcessedEvent -> Double
[peDelta] :: ProcessedEvent -> Micros
[peCycle] :: ProcessedEvent -> Time
[peOnWholeOrPart] :: ProcessedEvent -> Micros
[peOnWholeOrPartOsc] :: ProcessedEvent -> Time
[peOnPart] :: ProcessedEvent -> Micros
[peOnPartOsc] :: ProcessedEvent -> Time
playStack :: PlayMap -> ControlPattern
processCps :: ClockConfig -> ClockRef -> (SessionState, SessionState) -> [Event ValueMap] -> IO [ProcessedEvent]
toOSC :: Maybe [Int] -> ProcessedEvent -> OSC -> [(Double, Bool, Message)]
setPreviousPatternOrSilence :: MVar PlayMap -> IO ()
toData :: OSC -> Event ValueMap -> Maybe [Datum]
substitutePath :: String -> ValueMap -> Maybe String
toDatum :: Value -> Datum
getString :: ValueMap -> String -> Maybe String
hasSolo :: Map k PlayState -> Bool
onSingleTick :: ClockConfig -> ClockRef -> MVar ValueMap -> MVar PlayMap -> MVar (ControlPattern -> ControlPattern) -> [Cx] -> ControlPattern -> IO ()
updatePattern :: Stream -> ID -> Time -> ControlPattern -> IO ()
streamSetCycle :: Stream -> Time -> IO ()
streamSetCPS :: Stream -> Time -> IO ()
streamSetBPM :: Stream -> Time -> IO ()
streamGetCPS :: Stream -> IO Time
streamGetcps :: Stream -> IO Time
streamGetBPM :: Stream -> IO Time
streamGetNow :: Stream -> IO Time
streamGetnow :: Stream -> IO Time
streamEnableLink :: Stream -> IO ()
streamDisableLink :: Stream -> IO ()
withPatIds :: Stream -> [ID] -> (PlayState -> PlayState) -> IO ()
streamMutes :: Stream -> [ID] -> IO ()
streamMuteAll :: Stream -> IO ()
streamUnmuteAll :: Stream -> IO ()
streamUnsoloAll :: Stream -> IO ()
streamSilence :: Stream -> ID -> IO ()
streamGet :: Stream -> String -> IO (Maybe Value)
streamSet :: Valuable a => Stream -> String -> Pattern a -> IO ()
type TransitionMapper = Time -> [ControlPattern] -> ControlPattern
_mortalOverlay :: Time -> Time -> [Pattern a] -> Pattern a

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

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

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

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

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

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

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

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

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

-- | Degrade the new pattern over time until it ends in silence
_mortal :: Time -> Time -> Time -> [ControlPattern] -> ControlPattern
_interpolate :: Time -> [ControlPattern] -> ControlPattern
_interpolateIn :: Time -> Time -> [ControlPattern] -> ControlPattern

-- | Degrades the current pattern while undegrading the next.
--   
--   This is like <tt>xfade</tt> but not by gain of samples but by randomly
--   removing events from the current pattern and slowly adding back in
--   missing events from the next one.
--   
--   <pre>
--   d1 $ sound "bd(3,8)"
--   
--   t1 clutch $ sound "[hh*4, odx(3,8)]"
--   </pre>
--   
--   <tt>clutch</tt> takes two cycles for the transition, essentially this
--   is <tt>clutchIn 2</tt>.
_clutch :: Time -> [Pattern a] -> Pattern a

-- | Also degrades the current pattern and undegrades the next. To change
--   the number of cycles the transition takes, you can use
--   <tt>clutchIn</tt> like so:
--   
--   <pre>
--   d1 $ sound "bd(5,8)"
--   
--   t1 (clutchIn 8) $ sound "[hh*4, odx(3,8)]"
--   </pre>
--   
--   will take 8 cycles for the transition.
_clutchIn :: Time -> Time -> [Pattern a] -> Pattern a

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

-- | <a>anticipate</a> is an increasing comb filter.
--   
--   Build up some tension, culminating in a _drop_ to the new pattern
--   after 8 cycles.
_anticipate :: Time -> [ControlPattern] -> ControlPattern
tidal_status :: IO ()
startStream :: Config -> [(Target, [OSC])] -> IO Stream
startMulti :: [Target] -> Config -> IO ()
approxRational :: RealFrac a => a -> a -> Rational
histpan :: Tidally => ID -> Int -> ControlPattern -> IO ()
wait :: Tidally => ID -> Time -> ControlPattern -> IO ()
waitT :: Tidally => ID -> (Time -> [ControlPattern] -> ControlPattern) -> Time -> ControlPattern -> IO ()
jump :: Tidally => ID -> ControlPattern -> IO ()
jumpIn :: Tidally => ID -> Int -> ControlPattern -> IO ()
jumpIn' :: Tidally => ID -> Int -> ControlPattern -> IO ()
jumpMod :: Tidally => ID -> Int -> ControlPattern -> IO ()
jumpMod' :: Tidally => ID -> Int -> Int -> ControlPattern -> IO ()
mortal :: Tidally => ID -> Time -> Time -> ControlPattern -> IO ()
interpolate :: Tidally => ID -> ControlPattern -> IO ()
interpolateIn :: Tidally => ID -> Time -> ControlPattern -> IO ()
clutch :: Tidally => ID -> ControlPattern -> IO ()
clutchIn :: Tidally => ID -> Time -> ControlPattern -> IO ()
anticipate :: Tidally => ID -> ControlPattern -> IO ()
anticipateIn :: Tidally => ID -> Time -> ControlPattern -> IO ()
forId :: Tidally => ID -> Time -> ControlPattern -> IO ()
