-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Pattern language for improvised music
--
-- Tidal is a domain specific language for live coding pattern.
@package tidal
@version 1.0.3
module Sound.Tidal.Bjorklund
bjorklund :: (Int, Int) -> [Bool]
module Sound.Tidal.Config
data Config
Config :: Bool -> String -> Int -> Double -> String -> Int -> Config
[cCtrlListen] :: Config -> Bool
[cCtrlAddr] :: Config -> String
[cCtrlPort] :: Config -> Int
[cFrameTimespan] :: Config -> Double
[cTempoAddr] :: Config -> String
[cTempoPort] :: Config -> Int
defaultConfig :: Config
module Sound.Tidal.Pattern
-- | Time is rational
type Time = Rational
-- | The sam (start of cycle) for the given time value
sam :: Time -> Time
-- | Turns a number into a (rational) time value. An alias for
-- toRational.
toTime :: Real a => a -> Rational
-- | 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
-- | An arc of time, with a start time (or onset) and a stop time (or
-- offset)
data ArcF a
Arc :: a -> a -> ArcF a
[start] :: ArcF a -> a
[stop] :: ArcF a -> a
type Arc = ArcF Time
sect :: Arc -> Arc -> Arc
-- | convex hull union
hull :: Arc -> Arc -> Arc
-- | subArc i j is the timespan that is the intersection of
-- i and j. 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
-- | The arc of the whole cycle that the given time value falls within
timeToCycleArc :: Time -> Arc
-- | A list of cycle numbers which are included in the given arc
cyclesInArc :: Integral a => Arc -> [a]
-- | A list of arcs of the whole cycles which are included in the given arc
cycleArcsInArc :: Arc -> [Arc]
-- | Splits the given ArcF into a list of ArcFs, at cycle
-- boundaries.
arcCycles :: Arc -> [Arc]
-- | Like arcCycles, but returns zero-width arcs
arcCyclesZW :: Arc -> [Arc]
-- | Similar to fmap but time is relative to the cycle (i.e. the sam
-- of the start of the arc)
mapCycle :: (Time -> Time) -> Arc -> Arc
-- | isIn a t is True if t is inside the arc
-- represented by a.
isIn :: Arc -> Time -> Bool
-- | An event is a value that's active during a timespan The part should be
-- equal to or fit inside the whole
data EventF a b
Event :: a -> a -> b -> EventF a b
[whole] :: EventF a b -> a
[part] :: EventF a b -> a
[value] :: EventF a b -> b
type Event a = EventF (ArcF Time) a
-- | True if an EventF's starts is within given ArcF
onsetIn :: Arc -> Event a -> Bool
-- | Compares two lists of events, attempting to combine fragmented events
-- in the process for a truer compare
compareDefrag :: Ord a => [Event a] -> [Event a] -> Bool
-- | Returns a list of events, with any adjacent parts of the same whole
-- combined
defragParts :: Eq a => [Event a] -> [Event a]
-- | Returns True if the two given events are adjacent parts of the
-- same whole
isAdjacent :: Eq a => Event a -> Event a -> Bool
-- | Get the onset of an event's whole
wholeStart :: Event a -> Time
-- | Get the offset of an event's whole
wholeStop :: Event a -> Time
-- | Get the onset of an event's whole
eventPartStart :: Event a -> Time
-- | Get the offset of an event's part
eventPartStop :: Event a -> Time
-- | Get the timespan of an event's part
eventPart :: Event a -> Arc
eventValue :: Event a -> a
eventHasOnset :: Event a -> Bool
toEvent :: (((Time, Time), (Time, Time)), a) -> Event a
-- | an Arc and some named control values
data State
State :: Arc -> ControlMap -> State
[arc] :: State -> Arc
[controls] :: State -> ControlMap
-- | A function that represents events taking place over time
type Query a = (State -> [Event a])
-- | Also known as Continuous vs Discrete/Amorphous vs Pulsating etc.
data Nature
Analog :: Nature
Digital :: Nature
-- | A datatype that's basically a query, plus a hint about whether its
-- events are Analogue or Digital by nature
data Pattern a
Pattern :: Nature -> Query a -> Pattern a
[nature] :: Pattern a -> Nature
[query] :: Pattern a -> Query a
data Value
VS :: String -> Value
[svalue] :: Value -> String
VF :: Double -> Value
[fvalue] :: Value -> Double
VI :: Int -> Value
[ivalue] :: Value -> Int
type ControlMap = Map String Value
type ControlPattern = Pattern ControlMap
-- | Like *, but the structure only comes from the left
(<*) :: Pattern (a -> b) -> Pattern a -> Pattern b
infixl 4 <*
-- | Like *, but the structure only comes from the right
(*>) :: Pattern (a -> b) -> Pattern a -> Pattern b
infixl 4 *>
-- | Turns a pattern of patterns into a single pattern. (this is actually
-- join)
--
-- 1/ For query arc, get the events from the outer pattern
-- pp 2/ Query the inner pattern using the part 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
-- Concatenate all the events together (discarding wholesparts 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
-- unwrap, but structure only comes from the inner pattern.
innerJoin :: Pattern (Pattern a) -> Pattern a
-- | Turns a pattern of patterns into a single pattern. Like
-- unwrap, but structure only comes from the outer pattern.
outerJoin :: Pattern (Pattern a) -> Pattern a
-- | Like unwrap, 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?
unwrapSqueeze :: Pattern (Pattern a) -> Pattern a
noOv :: String -> a
class TolerantEq a
(~==) :: TolerantEq a => a -> a -> Bool
showPattern :: Show a => Arc -> Pattern a -> String
prettyRat :: Rational -> String
showFrac :: Integer -> Integer -> String
empty :: Pattern a
queryArc :: Pattern a -> Arc -> [Event a]
isDigital :: Pattern a -> Bool
isAnalog :: Pattern a -> Bool
-- | Splits queries that span cycles. For example `query p (0.5, 1.5)`
-- would be turned into two queries, `(0.5,1)` and `(1,1.5)`, and the
-- results combined. Being able to assume queries don't span cycles often
-- makes transformations easier to specify.
splitQueries :: Pattern a -> Pattern a
-- | Apply a function to the arcs/timespans (both whole and parts) of the
-- result
withResultArc :: (Arc -> Arc) -> Pattern a -> Pattern a
-- | Apply a function to the time (both start and end of the timespans of
-- both whole and parts) of the result
withResultTime :: (Time -> Time) -> Pattern a -> Pattern a
-- | Apply a function to the timespan of the query
withQueryArc :: (Arc -> Arc) -> Pattern a -> Pattern a
-- | Apply a function to the time (both start and end) of the query
withQueryTime :: (Time -> Time) -> Pattern a -> Pattern a
-- | withEvent f p returns a new Pattern with each event
-- mapped over function f.
withEvent :: (Event a -> Event b) -> Pattern a -> Pattern b
-- | withEvent f p returns a new Pattern with f applied
-- to the resulting list of events for each query function f.
withEvents :: ([Event a] -> [Event b]) -> Pattern a -> Pattern b
-- | withPart f p returns a new Pattern with function
-- f applied to the part.
withPart :: (Arc -> Arc) -> Pattern a -> Pattern a
-- | 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 Value, depending on its type (int or
-- float; strings are ignored)
fNum2 :: (Int -> Int -> Int) -> (Double -> Double -> Double) -> Value -> Value -> Value
getI :: Value -> Maybe Int
getF :: Value -> Maybe Double
getS :: Value -> Maybe String
compressArc :: Arc -> Pattern a -> Pattern a
compressArcTo :: Arc -> Pattern a -> Pattern a
_fastGap :: Time -> Pattern a -> Pattern a
-- | Shifts a pattern back in time by the given amount, expressed in cycles
rotL :: Time -> Pattern a -> Pattern a
-- | Shifts a pattern forward in time by the given amount, expressed in
-- cycles
rotR :: Time -> Pattern a -> Pattern a
-- | Remove events from patterns that to not meet the given test
filterValues :: (a -> Bool) -> Pattern a -> Pattern a
-- | Turns a pattern of Maybe values in to a pattern of values,
-- dropping the events of Nothing.
filterJust :: Pattern (Maybe a) -> Pattern a
filterWhen :: (Time -> Bool) -> Pattern a -> Pattern a
playFor :: Time -> Time -> Pattern a -> Pattern a
tParam :: (t1 -> t2 -> Pattern a) -> Pattern t1 -> t2 -> Pattern a
tParam2 :: (a -> b -> c -> Pattern d) -> Pattern a -> Pattern b -> c -> Pattern d
tParam3 :: (a -> b -> c -> Pattern d -> Pattern e) -> Pattern a -> Pattern b -> Pattern c -> Pattern d -> Pattern e
tParamSqueeze :: (a -> Pattern b -> Pattern c) -> Pattern a -> Pattern b -> Pattern c
-- | 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)
instance Data.Data.Data Sound.Tidal.Pattern.Value
instance GHC.Classes.Ord Sound.Tidal.Pattern.Value
instance GHC.Classes.Eq Sound.Tidal.Pattern.Value
instance GHC.Classes.Eq Sound.Tidal.Pattern.Nature
instance GHC.Base.Functor (Sound.Tidal.Pattern.EventF a)
instance (GHC.Classes.Ord a, GHC.Classes.Ord b) => GHC.Classes.Ord (Sound.Tidal.Pattern.EventF a b)
instance (GHC.Classes.Eq a, GHC.Classes.Eq b) => GHC.Classes.Eq (Sound.Tidal.Pattern.EventF a b)
instance GHC.Base.Functor Sound.Tidal.Pattern.ArcF
instance GHC.Classes.Ord a => GHC.Classes.Ord (Sound.Tidal.Pattern.ArcF a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Sound.Tidal.Pattern.ArcF a)
instance Sound.Tidal.Pattern.TolerantEq Sound.Tidal.Pattern.Value
instance Sound.Tidal.Pattern.TolerantEq Sound.Tidal.Pattern.ControlMap
instance Sound.Tidal.Pattern.TolerantEq (Sound.Tidal.Pattern.Event Sound.Tidal.Pattern.ControlMap)
instance Sound.Tidal.Pattern.TolerantEq a => Sound.Tidal.Pattern.TolerantEq [a]
instance GHC.Base.Functor Sound.Tidal.Pattern.Pattern
instance GHC.Base.Applicative Sound.Tidal.Pattern.Pattern
instance GHC.Base.Monad Sound.Tidal.Pattern.Pattern
instance GHC.Classes.Eq (Sound.Tidal.Pattern.Pattern a)
instance GHC.Classes.Ord a => GHC.Classes.Ord (Sound.Tidal.Pattern.Pattern a)
instance GHC.Num.Num a => GHC.Num.Num (Sound.Tidal.Pattern.Pattern a)
instance GHC.Enum.Enum a => GHC.Enum.Enum (Sound.Tidal.Pattern.Pattern a)
instance (GHC.Num.Num a, GHC.Classes.Ord a) => GHC.Real.Real (Sound.Tidal.Pattern.Pattern a)
instance GHC.Real.Integral a => GHC.Real.Integral (Sound.Tidal.Pattern.Pattern a)
instance GHC.Real.Fractional a => GHC.Real.Fractional (Sound.Tidal.Pattern.Pattern a)
instance GHC.Float.Floating a => GHC.Float.Floating (Sound.Tidal.Pattern.Pattern a)
instance GHC.Real.RealFrac a => GHC.Real.RealFrac (Sound.Tidal.Pattern.Pattern a)
instance GHC.Float.RealFloat a => GHC.Float.RealFloat (Sound.Tidal.Pattern.Pattern a)
instance GHC.Show.Show a => GHC.Show.Show (Sound.Tidal.Pattern.Pattern a)
instance GHC.Num.Num Sound.Tidal.Pattern.ControlMap
instance GHC.Real.Fractional Sound.Tidal.Pattern.ControlMap
instance GHC.Show.Show Sound.Tidal.Pattern.ControlMap
instance GHC.Show.Show Sound.Tidal.Pattern.Value
instance GHC.Show.Show a => GHC.Show.Show (Sound.Tidal.Pattern.Event a)
instance Data.Bifunctor.Bifunctor Sound.Tidal.Pattern.EventF
instance GHC.Show.Show Sound.Tidal.Pattern.Arc
instance GHC.Num.Num a => GHC.Num.Num (Sound.Tidal.Pattern.ArcF a)
instance GHC.Real.Fractional a => GHC.Real.Fractional (Sound.Tidal.Pattern.ArcF a)
instance GHC.Base.Applicative Sound.Tidal.Pattern.ArcF
module Sound.Tidal.Core
-- | An empty pattern
silence :: Pattern a
-- | Takes a function from time to values, and turns it into a
-- Pattern.
sig :: (Time -> a) -> Pattern a
-- | sine returns a Pattern of continuous Fractional
-- values following a sinewave with frequency of one cycle, and amplitude
-- from 0 to 1.
sine :: Fractional a => Pattern a
-- | cosine is a synonym for 0.25 ~> sine.
cosine :: Fractional a => Pattern a
-- | saw is the equivalent of sine for (ascending) sawtooth
-- waves.
saw :: (Fractional a, Real a) => Pattern a
-- | isaw is the equivalent of sine for inverse
-- (descending) sawtooth waves.
isaw :: (Fractional a, Real a) => Pattern a
-- | tri is the equivalent of sine for triangular waves.
tri :: (Fractional a, Real a) => Pattern a
-- | square is the equivalent of sine for square waves.
square :: Fractional a => Pattern a
-- | envL is a Pattern of continuous Double 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 envL but reversed.
envLR :: Pattern Double
-- | 'Equal power' version of env, for gain-based transitions
envEq :: Pattern Double
-- | Equal power reversed
envEqR :: Pattern Double
class Unionable a
union :: Unionable a => a -> a -> a
(|+|) :: (Applicative a, Num b) => a b -> a b -> a b
(|+) :: Num a => Pattern a -> Pattern a -> Pattern a
(+|) :: Num a => Pattern a -> Pattern a -> Pattern a
(|/|) :: (Applicative a, Fractional b) => a b -> a b -> a b
(|/) :: Fractional a => Pattern a -> Pattern a -> Pattern a
(/|) :: Fractional a => Pattern a -> Pattern a -> Pattern a
(|*|) :: (Applicative a, Num b) => a b -> a b -> a b
(|*) :: Num a => Pattern a -> Pattern a -> Pattern a
(*|) :: Num a => Pattern a -> Pattern a -> Pattern a
(|-|) :: (Applicative a, Num b) => a b -> a b -> a b
(|-) :: Num a => Pattern a -> Pattern a -> Pattern a
(-|) :: Num a => Pattern a -> Pattern a -> Pattern a
(|%|) :: (Applicative a, Real b) => a b -> a b -> a b
(|%) :: Real a => Pattern a -> Pattern a -> Pattern a
(%|) :: Real a => Pattern a -> Pattern a -> Pattern a
(|>|) :: (Applicative a, Unionable b) => a b -> a b -> a b
(|>) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(>|) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(|<|) :: (Applicative a, Unionable b) => a b -> a b -> a b
(|<) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(<|) :: Unionable a => Pattern a -> Pattern a -> Pattern a
(#) :: Unionable b => Pattern b -> Pattern b -> Pattern b
-- | Turns a list of values into a pattern, playing one of them per cycle.
fromList :: [a] -> Pattern a
-- | Turns a list of values into a pattern, playing one of them per cycle.
fastFromList :: [a] -> Pattern a
-- | A synonym for fastFromList
listToPat :: [a] -> Pattern a
-- | 'fromMaybes; is similar to fromList, but allows values to be
-- optional using the Maybe type, so that Nothing results
-- in gaps in the pattern.
fromMaybes :: [Maybe a] -> Pattern a
-- | A pattern of whole numbers from 0 to the given number, in a single
-- cycle.
run :: (Enum a, Num a) => Pattern a -> Pattern a
_run :: (Enum a, Num a) => a -> Pattern a
-- | From 1 for the first cycle, successively adds a number until
-- it gets up to n
scan :: (Enum a, Num a) => Pattern a -> Pattern a
_scan :: (Enum a, Num a) => a -> Pattern a
-- | Alternate between cycles of the two given patterns
append :: Pattern a -> Pattern a -> Pattern a
-- | Like append, but for a list of patterns. Interlaces them,
-- playing the first cycle from each in turn, then the second cycle from
-- each, and so on.
cat :: [Pattern a] -> Pattern a
-- | Alias for cat
slowCat :: [Pattern a] -> Pattern a
slowcat :: [Pattern a] -> Pattern a
-- | Alias for append
slowAppend :: Pattern a -> Pattern a -> Pattern a
-- | Like append, but twice as fast
fastAppend :: Pattern a -> Pattern a -> Pattern a
-- | The same as cat, but speeds up the result by the number of
-- patterns there are, so the cycles from each are squashed to fit a
-- single cycle.
fastCat :: [Pattern a] -> Pattern a
fastcat :: [Pattern a] -> Pattern a
-- | Similar to fastCat, but each pattern is given a relative
-- duration
timeCat :: [(Time, Pattern a)] -> Pattern a
-- | overlay combines two Patterns into a new pattern, so
-- that their events are combined over time.
overlay :: Pattern a -> Pattern a -> Pattern a
-- | stack combines a list of Patterns into a new pattern, so
-- that their events are combined over time.
stack :: [Pattern a] -> Pattern a
-- | Shifts a pattern back in time by the given amount, expressed in cycles
(<~) :: Pattern Time -> Pattern a -> Pattern a
-- | Shifts a pattern forward in time by the given amount, expressed in
-- cycles
(~>) :: Pattern Time -> Pattern a -> Pattern a
-- | Speed up a pattern by the given time pattern
fast :: Pattern Time -> Pattern a -> Pattern a
-- | Slow down a pattern by the factors in the given time pattern,
-- squeezing the pattern to fit the slot given in the time
-- pattern
fastSqueeze :: Pattern Time -> Pattern a -> Pattern a
-- | An alias for fast
density :: Pattern Time -> Pattern a -> Pattern a
_fast :: Time -> Pattern a -> Pattern a
-- | Slow down a pattern by the given time pattern
slow :: Pattern Time -> Pattern a -> Pattern a
_slow :: Time -> Pattern a -> Pattern a
-- | Slow down a pattern by the factors in the given time pattern,
-- squeezing the pattern to fit the slot given in the time
-- pattern
slowSqueeze :: Pattern Time -> Pattern a -> Pattern a
-- | An alias for slow
sparsity :: Pattern Time -> Pattern a -> Pattern a
-- | rev p returns p with the event positions in each
-- cycle reversed (or mirrored).
rev :: Pattern a -> Pattern a
-- | Plays a portion of a pattern, specified by a time arc (start and end
-- time). The new resulting pattern is played over the time period of the
-- original pattern:
--
--
-- d1 $ zoom (0.25, 0.75) $ sound "bd*2 hh*3 [sn bd]*2 drum"
--
--
-- In the pattern above, zoom is used with an arc from 25% to 75%.
-- It is equivalent to this pattern:
--
--
-- d1 $ sound "hh*3 [sn bd]*2"
--
zoom :: (Time, Time) -> Pattern a -> Pattern a
zoomArc :: Arc -> Pattern a -> Pattern a
-- | fastGap is similar to fast but maintains its cyclic
-- alignment. For example, fastGap 2 p would squash the events
-- in pattern p 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 fastGap
densityGap :: Pattern Time -> Pattern a -> Pattern a
compress :: (Time, Time) -> Pattern a -> Pattern a
compressTo :: (Time, Time) -> Pattern a -> Pattern a
repeatCycles :: Int -> Pattern a -> Pattern a
fastRepeatCycles :: Int -> Pattern a -> Pattern a
-- |
-- - Higher order functions
--
--
-- Functions which work on other functions (higher order functions)
--
-- every n f p applies the function f to p,
-- but only affects every n cycles.
every :: Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_every :: Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | every n o f' is like every n f with an offset of
-- o cycles
every' :: Pattern Int -> Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_every' :: Int -> Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | foldEvery ns f p applies the function f to
-- p, and is applied for each cycle in ns.
foldEvery :: [Int] -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | Only when the given test function returns True the given
-- pattern transformation is applied. The test function will be called
-- with the current cycle as a number.
--
--
-- d1 $ when ((elem '4').show)
-- (striate 4)
-- $ sound "hh hc"
--
--
-- The above will only apply `striate 4` to the pattern if the current
-- cycle number contains the number 4. So the fourth cycle will be
-- striated and the fourteenth and so on. Expect lots of striates after
-- cycle number 399.
when :: (Int -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | Like when, but works on continuous time values rather than
-- cycle numbers.
whenT :: (Time -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
instance Sound.Tidal.Core.Unionable a
instance Sound.Tidal.Core.Unionable Sound.Tidal.Pattern.ControlMap
module Sound.Tidal.Chords
major :: Num a => [a]
minor :: Num a => [a]
major7 :: Num a => [a]
dom7 :: Num a => [a]
minor7 :: Num a => [a]
aug :: Num a => [a]
dim :: Num a => [a]
dim7 :: Num a => [a]
one :: Num a => [a]
five :: Num a => [a]
plus :: Num a => [a]
sharp5 :: Num a => [a]
msharp5 :: Num a => [a]
sus2 :: Num a => [a]
sus4 :: Num a => [a]
six :: Num a => [a]
m6 :: Num a => [a]
sevenSus2 :: Num a => [a]
sevenSus4 :: Num a => [a]
sevenFlat5 :: Num a => [a]
m7flat5 :: Num a => [a]
sevenSharp5 :: Num a => [a]
m7sharp5 :: Num a => [a]
nine :: Num a => [a]
m9 :: Num a => [a]
m7sharp9 :: Num a => [a]
maj9 :: Num a => [a]
nineSus4 :: Num a => [a]
sixby9 :: Num a => [a]
m6by9 :: Num a => [a]
sevenFlat9 :: Num a => [a]
m7flat9 :: Num a => [a]
sevenFlat10 :: Num a => [a]
nineSharp5 :: Num a => [a]
m9sharp5 :: Num a => [a]
sevenSharp5flat9 :: Num a => [a]
m7sharp5flat9 :: Num a => [a]
eleven :: Num a => [a]
m11 :: Num a => [a]
maj11 :: Num a => [a]
elevenSharp :: Num a => [a]
m11sharp :: Num a => [a]
thirteen :: Num a => [a]
m13 :: Num a => [a]
-- | chordate cs m n selects the nth "chord" (a chord is
-- a list of Ints) from a list of chords cs and transposes it by
-- m chordate :: Num b => [[b]] -> b -> Int -> [b]
-- chordate cs m n = map (+m) $ cs!!n
--
-- enchord chords pn pc turns every note in the note pattern
-- pn into a chord, selecting from the chord lists
-- chords using the index pattern pc. For example,
-- Chords.enchord [Chords.major Chords.minor] "c g" "0 1" will
-- create a pattern of a C-major chord followed by a G-minor chord.
-- enchord :: Num a => [[a]] -> Pattern a -> Pattern Int ->
-- Pattern a enchord chords pn pc = flatpat $ (chordate chords) $
-- pn * pc
chordTable :: Num a => [(String, [a])]
chordL :: Num a => Pattern String -> Pattern [a]
module Sound.Tidal.Tempo
data Tempo
Tempo :: Time -> Rational -> Time -> Bool -> Double -> UDP -> SockAddr -> Tempo
[atTime] :: Tempo -> Time
[atCycle] :: Tempo -> Rational
[cps] :: Tempo -> Time
[paused] :: Tempo -> Bool
[nudged] :: Tempo -> Double
[localUDP] :: Tempo -> UDP
[remoteAddr] :: Tempo -> SockAddr
data State
State :: Int -> Time -> Time -> Arc -> State
[ticks] :: State -> Int
[start] :: State -> Time
[nowTime] :: State -> Time
[nowArc] :: State -> Arc
resetCycles :: MVar Tempo -> IO Tempo
setCps :: MVar Tempo -> Time -> IO Tempo
defaultTempo :: Time -> UDP -> SockAddr -> Tempo
-- | Returns the given time in terms of cycles relative to metrical grid of
-- a given Tempo
timeToCycles :: Tempo -> Time -> Rational
clocked :: Config -> (MVar Tempo -> State -> IO ()) -> IO (MVar Tempo, [ThreadId])
clientListen :: Config -> Time -> IO (MVar Tempo, ThreadId)
sendTempo :: Tempo -> IO ()
listenTempo :: UDP -> MVar Tempo -> IO ()
serverListen :: Config -> IO (Maybe ThreadId)
module Sound.Tidal.Stream
data TimeStamp
BundleStamp :: TimeStamp
MessageStamp :: TimeStamp
NoStamp :: TimeStamp
data Stream
Stream :: Config -> MVar ControlMap -> MVar ControlPattern -> Maybe ThreadId -> MVar PlayMap -> MVar Tempo -> OSCTarget -> UDP -> Stream
[sConfig] :: Stream -> Config
[sInput] :: Stream -> MVar ControlMap
[sOutput] :: Stream -> MVar ControlPattern
[sListenTid] :: Stream -> Maybe ThreadId
[sPMapMV] :: Stream -> MVar PlayMap
[sTempoMV] :: Stream -> MVar Tempo
[sTarget] :: Stream -> OSCTarget
[sUDP] :: Stream -> UDP
type PatId = String
data OSCTarget
OSCTarget :: String -> Int -> String -> Maybe [(String, Maybe Value)] -> Double -> [Datum] -> TimeStamp -> OSCTarget
[oAddress] :: OSCTarget -> String
[oPort] :: OSCTarget -> Int
[oPath] :: OSCTarget -> String
[oShape] :: OSCTarget -> Maybe [(String, Maybe Value)]
[oLatency] :: OSCTarget -> Double
[oPreamble] :: OSCTarget -> [Datum]
[oTimestamp] :: OSCTarget -> TimeStamp
superdirtTarget :: OSCTarget
startStream :: Config -> MVar ControlMap -> OSCTarget -> IO (MVar ControlPattern, MVar Tempo, UDP)
data PlayState
PlayState :: ControlPattern -> Bool -> Bool -> [ControlPattern] -> PlayState
[pattern] :: PlayState -> ControlPattern
[mute] :: PlayState -> Bool
[solo] :: PlayState -> Bool
[history] :: PlayState -> [ControlPattern]
type PlayMap = Map PatId PlayState
toDatum :: Value -> Datum
toData :: Event ControlMap -> [Datum]
toMessage :: OSCTarget -> Tempo -> Event (Map String Value) -> Message
doCps :: MVar Tempo -> (Double, Maybe Value) -> IO ()
onTick :: Config -> MVar ControlMap -> MVar ControlPattern -> OSCTarget -> UDP -> MVar Tempo -> State -> IO ()
send :: Transport t => Double -> t -> (Double, Message) -> IO ()
sched :: Tempo -> Rational -> Double
streamNudgeAll :: Stream -> Double -> IO ()
streamResetCycles :: Stream -> IO ()
hasSolo :: Map k PlayState -> Bool
streamList :: Stream -> IO ()
streamReplace :: Show a => Stream -> a -> ControlPattern -> IO ()
streamMute :: Show a => Stream -> a -> IO ()
streamMutes :: Show a => Stream -> [a] -> IO ()
streamUnmute :: Show a => Stream -> a -> IO ()
streamSolo :: Show a => Stream -> a -> IO ()
streamUnsolo :: Show a => Stream -> a -> IO ()
streamOnce :: Stream -> Bool -> ControlPattern -> IO ()
withPatId :: Stream -> PatId -> (PlayState -> PlayState) -> IO ()
withPatIds :: Stream -> [PatId] -> (PlayState -> PlayState) -> IO ()
streamMuteAll :: Stream -> IO ()
streamHush :: Stream -> IO ()
streamUnmuteAll :: Stream -> IO ()
calcOutput :: Stream -> IO ()
startTidal :: OSCTarget -> Config -> IO Stream
ctrlListen :: MVar ControlMap -> Config -> IO (Maybe ThreadId)
instance GHC.Show.Show Sound.Tidal.Stream.PlayState
instance GHC.Classes.Eq Sound.Tidal.Stream.TimeStamp
module Sound.Tidal.EspGrid
tidalEspGridLink :: MVar Tempo -> IO ()
cpsEsp :: Real t => t -> IO ()
module Sound.Tidal.Utils
mapBoth :: (a -> a) -> (a, a) -> (a, a)
mapPartTimes :: (a -> a) -> ((a, a), (a, a)) -> ((a, a), (a, a))
mapFst :: (a -> b) -> (a, c) -> (b, c)
mapSnd :: (a -> b) -> (c, a) -> (c, b)
delta :: Num a => (a, a) -> a
-- | The midpoint of two values
mid :: Fractional a => (a, a) -> a
removeCommon :: Eq a => [a] -> [a] -> ([a], [a])
readMaybe :: Read a => String -> Maybe a
-- | like !! selects nth element from xs, but wraps over at
-- the end of xs
--
--
-- >>> map ((!!!) [1,3,5]) [0,1,2,3,4,5]
-- [1,3,5,1,3,5]
--
(!!!) :: [a] -> Int -> a
-- | Safer version of !! -
nth :: Int -> [a] -> Maybe a
accumulate :: Num t => [t] -> [t]
-- | enumerate a list of things
--
--
-- >>> enumerate ["foo","bar","baz"]
-- [(1,"foo"), (2,"bar"), (3,"baz")]
--
enumerate :: [a] -> [(Int, a)]
-- | split given list of a by given single a, e.g.
--
--
-- >>> wordsBy (== ':') "bd:3"
-- ["bd", "3"]
--
wordsBy :: (a -> Bool) -> [a] -> [[a]]
module Sound.Tidal.Scales
scale :: Num a => Pattern String -> Pattern Int -> Pattern a
scaleList :: String
module Sound.Tidal.Params
-- | group multiple params into one
grp :: [String -> ControlMap] -> Pattern String -> ControlPattern
mF :: String -> String -> ControlMap
mI :: String -> String -> ControlMap
mS :: String -> String -> ControlMap
-- | Grouped params
sound :: Pattern String -> ControlPattern
s :: Pattern String -> ControlPattern
cc :: Pattern String -> ControlPattern
-- | Singular params
pF :: String -> Pattern Double -> ControlPattern
pI :: String -> Pattern Int -> ControlPattern
pS :: String -> Pattern String -> ControlPattern
-- | a pattern of numbers that speed up (or slow down) samples while they
-- play.
accelerate :: Pattern Double -> ControlPattern
-- | a pattern of numbers to specify the attack time (in seconds) of an
-- envelope applied to each sample. Only takes effect if release
-- is also specified.
attack :: Pattern Double -> ControlPattern
-- | a pattern of numbers from 0 to 1. Sets the center frequency of the
-- band-pass filter.
bandf :: Pattern Double -> ControlPattern
-- | a pattern of numbers from 0 to 1. Sets the q-factor of the band-pass
-- filter.y
bandq :: Pattern Double -> ControlPattern
-- | a pattern of numbers from 0 to 1. Skips the beginning of each sample,
-- e.g. `0.25` to cut off the first quarter from each sample.
--
-- Using `begin "-1"` combined with `cut "-1"` means that when the sample
-- cuts itself it will begin playback from where the previous one left
-- off, so it will sound like one seamless sample. This allows you to
-- apply a synth param across a long sample in a way similar to
-- chop:
--
--
-- cps 0.5
--
-- d1 $ sound "breaks125*8" begin "-1" coarse "1 2 4 8 16 32 64 128"
--
--
-- This will play the breaks125 sample and apply the changing
-- coarse parameter over the sample. Compare to:
--
--
-- d1 $ (chop 8 $ sounds "breaks125") coarse "1 2 4 8 16 32 64 128"
--
--
-- which performs a similar effect, but due to differences in
-- implementation sounds different.
begin :: Pattern Double -> ControlPattern
-- | a pattern of numbers from 0 to 1. Skips the beginning of each sample,
-- e.g. `0.25` to cut off the first quarter from each sample.
--
-- Using `begin "-1"` combined with `cut "-1"` means that when the sample
-- cuts itself it will begin playback from where the previous one left
-- off, so it will sound like one seamless sample. This allows you to
-- apply a synth param across a long sample in a way similar to
-- chop:
--
--
-- cps 0.5
--
-- d1 $ sound "breaks125*8" begin "-1" coarse "1 2 4 8 16 32 64 128"
--
--
-- This will play the breaks125 sample and apply the changing
-- coarse parameter over the sample. Compare to:
--
--
-- d1 $ (chop 8 $ sounds "breaks125") coarse "1 2 4 8 16 32 64 128"
--
--
-- which performs a similar effect, but due to differences in
-- implementation sounds different.
legato :: Pattern Double -> ControlPattern
-- | a pattern of numbers from 0 to 1. Skips the beginning of each sample,
-- e.g. `0.25` to cut off the first quarter from each sample.
--
-- Using `begin "-1"` combined with `cut "-1"` means that when the sample
-- cuts itself it will begin playback from where the previous one left
-- off, so it will sound like one seamless sample. This allows you to
-- apply a synth param across a long sample in a way similar to
-- chop:
--
--
-- cps 0.5
--
-- d1 $ sound "breaks125*8" begin "-1" coarse "1 2 4 8 16 32 64 128"
--
--
-- This will play the breaks125 sample and apply the changing
-- coarse parameter over the sample. Compare to:
--
--
-- d1 $ (chop 8 $ sounds "breaks125") coarse "1 2 4 8 16 32 64 128"
--
--
-- which performs a similar effect, but due to differences in
-- implementation sounds different.
clhatdecay :: Pattern Double -> ControlPattern
-- | bit crushing, a pattern of numbers from 1 (for drastic reduction in
-- bit-depth) to 16 (for barely no reduction).
--
-- a pattern of numbers from 0 to 1. Skips the beginning of each sample,
-- e.g. `0.25` to cut off the first quarter from each sample.
--
-- Using `begin "-1"` combined with `cut "-1"` means that when the sample
-- cuts itself it will begin playback from where the previous one left
-- off, so it will sound like one seamless sample. This allows you to
-- apply a synth param across a long sample in a way similar to
-- chop:
--
--
-- cps 0.5
--
-- d1 $ sound "breaks125*8" begin "-1" coarse "1 2 4 8 16 32 64 128"
--
--
-- This will play the breaks125 sample and apply the changing
-- coarse parameter over the sample. Compare to:
--
--
-- d1 $ (chop 8 $ sounds "breaks125") coarse "1 2 4 8 16 32 64 128"
--
--
-- which performs a similar effect, but due to differences in
-- implementation sounds different.
crush :: Pattern Double -> ControlPattern
-- | choose the physical channel the pattern is sent to, this is super dirt
-- specific
channel :: 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 Int -> ControlPattern
-- | In the style of classic drum-machines, cut 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.
--
--
-- d1 $ stack [
-- sound "bd",
-- sound "~ [~ [ho:2 hc/2]]" # cut "1"
-- ]
--
--
-- This will mute the open hi-hat every second cycle when the closed one
-- is played.
--
-- Using cut with negative values will only cut the same sample.
-- This is useful to cut very long samples
--
--
-- d1 $ sound "bev, [ho:3]" # cut "-1"
--
--
-- Using `cut "0"` is effectively _no_ cutgroup.
cut :: Pattern Int -> ControlPattern
-- | a pattern of numbers from 0 to 1. Applies the cutoff frequency of the
-- low-pass filter.
cutoff :: Pattern Double -> ControlPattern
cutoffegint :: Pattern Double -> ControlPattern
decay :: Pattern Double -> ControlPattern
-- | a pattern of numbers from 0 to 1. Sets the level of the delay signal.
delay :: Pattern Double -> ControlPattern
-- | a pattern of numbers from 0 to 1. Sets the amount of delay feedback.
delayfeedback :: Pattern Double -> ControlPattern
-- | a pattern of numbers from 0 to 1. Sets the length of the delay.
delaytime :: Pattern Double -> ControlPattern
detune :: Pattern Double -> ControlPattern
-- | when set to `1` will disable all reverb for this pattern. See
-- room and size for more information about reverb.
dry :: Pattern Double -> ControlPattern
end :: Pattern Double -> ControlPattern
-- | a pattern of numbers that specify volume. Values less than 1 make the
-- sound quieter. Values greater than 1 make the sound louder.
gain :: Pattern Double -> ControlPattern
gate :: Pattern Double -> ControlPattern
hatgrain :: Pattern Double -> ControlPattern
-- | a pattern of numbers from 0 to 1. Applies the cutoff frequency of the
-- high-pass filter.
hcutoff :: Pattern Double -> ControlPattern
-- | a pattern of numbers to specify the hold time (in seconds) of an
-- envelope applied to each sample. Only takes effect if attack
-- and release are also specified.
hold :: Pattern Double -> ControlPattern
-- | a pattern of numbers from 0 to 1. Applies the resonance of the
-- high-pass filter.
hresonance :: Pattern Double -> ControlPattern
kriole :: Pattern Int -> ControlPattern
lagogo :: Pattern Double -> ControlPattern
lclap :: Pattern Double -> ControlPattern
lclaves :: Pattern Double -> ControlPattern
lclhat :: Pattern Double -> ControlPattern
lcrash :: Pattern Double -> ControlPattern
leslie :: Pattern Double -> ControlPattern
lrate :: Pattern Double -> ControlPattern
lsize :: Pattern Double -> ControlPattern
lfo :: Pattern Double -> ControlPattern
lfocutoffint :: Pattern Double -> ControlPattern
lfodelay :: Pattern Double -> ControlPattern
lfoint :: Pattern Double -> ControlPattern
lfopitchint :: Pattern Double -> ControlPattern
lfoshape :: Pattern Double -> ControlPattern
lfosync :: Pattern Double -> ControlPattern
lhitom :: Pattern Double -> ControlPattern
lkick :: Pattern Double -> ControlPattern
llotom :: Pattern Double -> 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
-- | loops the sample (from begin to end) the specified
-- number of times.
loop :: Pattern Double -> ControlPattern
lophat :: Pattern Double -> ControlPattern
lsnare :: Pattern Double -> ControlPattern
-- | specifies the sample or note number to be used
n :: Pattern Double -> ControlPattern
note :: Pattern Double -> ControlPattern
-- | Pushes things forward (or backwards within built-in latency) in time.
-- Allows for nice things like _swing_ feeling:
--
--
-- d1 $ stack [
-- sound "bd bd/4",
-- sound "hh(5,8)"
-- ] # nudge "[0 0.04]*4"
--
--
--
degree :: Pattern Double -> ControlPattern
-- | Pushes things forward (or backwards within built-in latency) in time.
-- Allows for nice things like _swing_ feeling:
--
--
-- d1 $ stack [
-- sound "bd bd/4",
-- sound "hh(5,8)"
-- ] # nudge "[0 0.04]*4"
--
--
--
mtranspose :: Pattern Double -> ControlPattern
-- | Pushes things forward (or backwards within built-in latency) in time.
-- Allows for nice things like _swing_ feeling:
--
--
-- d1 $ stack [
-- sound "bd bd/4",
-- sound "hh(5,8)"
-- ] # nudge "[0 0.04]*4"
--
--
--
ctranspose :: Pattern Double -> ControlPattern
-- | Pushes things forward (or backwards within built-in latency) in time.
-- Allows for nice things like _swing_ feeling:
--
--
-- d1 $ stack [
-- sound "bd bd/4",
-- sound "hh(5,8)"
-- ] # nudge "[0 0.04]*4"
--
--
--
harmonic :: Pattern Double -> ControlPattern
-- | Pushes things forward (or backwards within built-in latency) in time.
-- Allows for nice things like _swing_ feeling:
--
--
-- d1 $ stack [
-- sound "bd bd/4",
-- sound "hh(5,8)"
-- ] # nudge "[0 0.04]*4"
--
--
--
stepsPerOctave :: Pattern Double -> ControlPattern
-- | Pushes things forward (or backwards within built-in latency) in time.
-- Allows for nice things like _swing_ feeling:
--
--
-- d1 $ stack [
-- sound "bd bd/4",
-- sound "hh(5,8)"
-- ] # nudge "[0 0.04]*4"
--
--
--
octaveRatio :: Pattern Double -> ControlPattern
nudge :: Pattern Double -> ControlPattern
octave :: Pattern Int -> ControlPattern
offset :: Pattern Double -> ControlPattern
ophatdecay :: Pattern Double -> 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
-- | a pattern of numbers between 0 and 1, from left to right (assuming
-- stereo), once round a circle (assuming multichannel)
pan :: Pattern Double -> 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
-- | a pattern of numbers between 0.0 and 1.0, which controls the
-- multichannel spread range (multichannel only)
pansplay :: Pattern Double -> 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
-- | 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
pitch1 :: Pattern Double -> ControlPattern
pitch2 :: Pattern Double -> ControlPattern
pitch3 :: Pattern Double -> ControlPattern
portamento :: Pattern Double -> ControlPattern
-- | a pattern of numbers to specify the release time (in seconds) of an
-- envelope applied to each sample. Only takes effect if attack is
-- also specified.
release :: Pattern Double -> ControlPattern
-- | a pattern of numbers from 0 to 1. Specifies the resonance of the
-- low-pass filter.
resonance :: Pattern Double -> ControlPattern
-- | a pattern of numbers from 0 to 1. Sets the level of reverb.
room :: Pattern Double -> ControlPattern
sagogo :: Pattern Double -> ControlPattern
sclap :: Pattern Double -> ControlPattern
sclaves :: Pattern Double -> ControlPattern
scrash :: Pattern Double -> ControlPattern
semitone :: Pattern Double -> ControlPattern
-- | wave shaping distortion, a pattern of numbers from 0 for no distortion
-- up to 1 for loads of distortion.
shape :: Pattern Double -> ControlPattern
-- | a pattern of numbers from 0 to 1. Sets the perceptual size (reverb
-- time) of the room to be used in reverb.
size :: Pattern Double -> ControlPattern
slide :: Pattern Double -> ControlPattern
-- | a pattern of numbers which changes the speed of sample playback, i.e.
-- a cheap way of changing pitch. Negative values will play the sample
-- backwards!
speed :: Pattern Double -> ControlPattern
squiz :: Pattern Double -> ControlPattern
-- | a pattern of strings. Selects the sample to be played.
s' :: Pattern String -> ControlPattern
stutterdepth :: Pattern Double -> ControlPattern
stuttertime :: Pattern Double -> ControlPattern
sustain :: Pattern Double -> ControlPattern
tomdecay :: Pattern Double -> ControlPattern
-- | used in conjunction with speed, accepts values of "r" (rate,
-- default behavior), "c" (cycles), or "s" (seconds). Using `unit "c"`
-- means speed will be interpreted in units of cycles, e.g. `speed
-- "1"` means samples will be stretched to fill a cycle. Using `unit "s"`
-- means the playback speed will be adjusted so that the duration is the
-- number of seconds specified by speed.
unit :: Pattern String -> ControlPattern
velocity :: Pattern Double -> ControlPattern
vcfegint :: Pattern Double -> ControlPattern
vcoegint :: Pattern Double -> ControlPattern
voice :: Pattern Double -> ControlPattern
-- | formant filter to make things sound like vowels, a pattern of either
-- a, e, i, o or u. Use a
-- rest (`~`) for no effect.
vowel :: Pattern String -> ControlPattern
waveloss :: Pattern Double -> ControlPattern
dur :: Pattern Double -> ControlPattern
modwheel :: Pattern Double -> ControlPattern
expression :: Pattern Double -> ControlPattern
sustainpedal :: Pattern Double -> ControlPattern
tremolorate :: Pattern Double -> ControlPattern
tremolodepth :: Pattern Double -> ControlPattern
phaserrate :: Pattern Double -> ControlPattern
phaserdepth :: Pattern Double -> ControlPattern
att :: Pattern Double -> ControlPattern
bpf :: Pattern Double -> ControlPattern
bpq :: Pattern Double -> ControlPattern
chdecay :: Pattern Double -> ControlPattern
ctf :: Pattern Double -> ControlPattern
ctfg :: Pattern Double -> ControlPattern
delayfb :: Pattern Double -> ControlPattern
delayt :: Pattern Double -> ControlPattern
det :: Pattern Double -> ControlPattern
gat :: Pattern Double -> ControlPattern
hg :: Pattern Double -> ControlPattern
hpf :: Pattern Double -> ControlPattern
hpq :: Pattern Double -> ControlPattern
lag :: Pattern Double -> ControlPattern
lbd :: Pattern Double -> ControlPattern
lch :: Pattern Double -> ControlPattern
lcl :: Pattern Double -> ControlPattern
lcp :: Pattern Double -> ControlPattern
lcr :: Pattern Double -> ControlPattern
lfoc :: Pattern Double -> ControlPattern
lfoi :: Pattern Double -> ControlPattern
lfop :: Pattern Double -> ControlPattern
lht :: Pattern Double -> ControlPattern
llt :: Pattern Double -> ControlPattern
loh :: Pattern Double -> ControlPattern
lpf :: Pattern Double -> ControlPattern
lpq :: Pattern Double -> ControlPattern
lsn :: Pattern Double -> ControlPattern
ohdecay :: Pattern Double -> ControlPattern
phasdp :: Pattern Double -> ControlPattern
phasr :: Pattern Double -> ControlPattern
pit1 :: Pattern Double -> ControlPattern
pit2 :: Pattern Double -> ControlPattern
pit3 :: Pattern Double -> ControlPattern
por :: Pattern Double -> ControlPattern
rel :: Pattern Double -> ControlPattern
sz :: Pattern Double -> ControlPattern
sag :: Pattern Double -> ControlPattern
scl :: Pattern Double -> ControlPattern
scp :: Pattern Double -> ControlPattern
scr :: Pattern Double -> ControlPattern
sld :: Pattern Double -> ControlPattern
std :: Pattern Double -> ControlPattern
stt :: Pattern Double -> ControlPattern
sus :: Pattern Double -> ControlPattern
tdecay :: Pattern Double -> ControlPattern
tremdp :: Pattern Double -> ControlPattern
tremr :: Pattern Double -> ControlPattern
vcf :: Pattern Double -> ControlPattern
vco :: Pattern Double -> ControlPattern
voi :: Pattern Double -> ControlPattern
midinote :: Pattern Double -> ControlPattern
drum :: Pattern String -> ControlPattern
drumN :: Num a => String -> a
array :: Pattern Double -> ControlPattern
midichan :: Pattern Double -> ControlPattern
control :: Pattern Double -> ControlPattern
ccn :: Pattern Double -> ControlPattern
ccv :: Pattern Double -> ControlPattern
ctlNum :: Pattern Double -> ControlPattern
frameRate :: Pattern Double -> ControlPattern
frames :: Pattern Double -> ControlPattern
hours :: Pattern Double -> ControlPattern
midicmd :: Pattern String -> ControlPattern
command :: Pattern String -> ControlPattern
minutes :: Pattern Double -> ControlPattern
progNum :: Pattern Double -> ControlPattern
seconds :: Pattern Double -> ControlPattern
songPtr :: Pattern Double -> ControlPattern
uid :: Pattern Double -> ControlPattern
val :: Pattern Double -> ControlPattern
-- | up is now an alias of note.
up :: Pattern Double -> ControlPattern
cps :: Pattern Double -> ControlPattern
button0 :: Pattern Double -> ControlPattern
button1 :: Pattern Double -> ControlPattern
button2 :: Pattern Double -> ControlPattern
button3 :: Pattern Double -> ControlPattern
button4 :: Pattern Double -> ControlPattern
button5 :: Pattern Double -> ControlPattern
button6 :: Pattern Double -> ControlPattern
button7 :: Pattern Double -> ControlPattern
button8 :: Pattern Double -> ControlPattern
button9 :: Pattern Double -> ControlPattern
button10 :: Pattern Double -> ControlPattern
button11 :: Pattern Double -> ControlPattern
button12 :: Pattern Double -> ControlPattern
button13 :: Pattern Double -> ControlPattern
button14 :: Pattern Double -> ControlPattern
button15 :: Pattern Double -> ControlPattern
button16 :: Pattern Double -> ControlPattern
button17 :: Pattern Double -> ControlPattern
button18 :: Pattern Double -> ControlPattern
button19 :: Pattern Double -> ControlPattern
button20 :: Pattern Double -> ControlPattern
button21 :: Pattern Double -> ControlPattern
button22 :: Pattern Double -> ControlPattern
button23 :: Pattern Double -> ControlPattern
button24 :: Pattern Double -> ControlPattern
button25 :: Pattern Double -> ControlPattern
button26 :: Pattern Double -> ControlPattern
button27 :: Pattern Double -> ControlPattern
button28 :: Pattern Double -> ControlPattern
button29 :: Pattern Double -> ControlPattern
button30 :: Pattern Double -> ControlPattern
button31 :: Pattern Double -> ControlPattern
slider0 :: Pattern Double -> ControlPattern
slider1 :: Pattern Double -> ControlPattern
slider2 :: Pattern Double -> ControlPattern
slider3 :: Pattern Double -> ControlPattern
slider4 :: Pattern Double -> ControlPattern
slider5 :: Pattern Double -> ControlPattern
slider6 :: Pattern Double -> ControlPattern
slider7 :: Pattern Double -> ControlPattern
slider8 :: Pattern Double -> ControlPattern
slider9 :: Pattern Double -> ControlPattern
slider10 :: Pattern Double -> ControlPattern
slider11 :: Pattern Double -> ControlPattern
slider12 :: Pattern Double -> ControlPattern
slider13 :: Pattern Double -> ControlPattern
slider14 :: Pattern Double -> ControlPattern
slider15 :: Pattern Double -> ControlPattern
slider16 :: Pattern Double -> ControlPattern
slider17 :: Pattern Double -> ControlPattern
slider18 :: Pattern Double -> ControlPattern
slider19 :: Pattern Double -> ControlPattern
slider20 :: Pattern Double -> ControlPattern
slider21 :: Pattern Double -> ControlPattern
slider22 :: Pattern Double -> ControlPattern
slider23 :: Pattern Double -> ControlPattern
slider24 :: Pattern Double -> ControlPattern
slider25 :: Pattern Double -> ControlPattern
slider26 :: Pattern Double -> ControlPattern
slider27 :: Pattern Double -> ControlPattern
slider28 :: Pattern Double -> ControlPattern
slider29 :: Pattern Double -> ControlPattern
slider30 :: Pattern Double -> ControlPattern
slider31 :: Pattern Double -> ControlPattern
module Sound.Tidal.UI
-- | Randomisation
timeToRand :: RealFrac a => a -> Double
-- | rand generates a continuous pattern of (pseudo-)random numbers
-- between `0` and `1`.
--
--
-- sound "bd*8" # pan rand
--
--
-- pans bass drums randomly
--
--
-- sound "sn sn ~ sn" # gain rand
--
--
-- makes the snares' randomly loud and quiet.
--
-- Numbers coming from this pattern are seeded by time. So if
-- you reset time (via `cps (-1)`, then `cps 1.1` or whatever cps you
-- want to restart with) the random pattern will emit the exact same
-- _random_ numbers again.
--
-- In cases where you need two different random patterns, you can shift
-- one of them around to change the time from which the _random_ pattern
-- is read, note the difference:
--
--
-- jux ( gain rand
--
--
-- and with the juxed version shifted backwards for 1024 cycles:
--
--
-- jux ( gain rand
--
rand :: Fractional a => Pattern a
-- | Just like rand but for whole numbers, `irand n` generates a
-- pattern of (pseudo-) random whole numbers between `0` to `n-1`
-- inclusive. Notably used to pick a random samples from a folder:
--
--
-- d1 $ n (irand 5) # sound "drum"
--
irand :: Num a => Int -> Pattern a
-- | 1D Perlin (smooth) noise, works like rand but smoothly moves between
-- random values each cycle. perlinWith takes a pattern as the
-- RNG's "input" instead of automatically using the cycle count. d1
-- $ s "arpy*32" # cutoff (perlinWith (saw * 4) * 2000) will
-- generate a smooth random pattern for the cutoff frequency which will
-- repeat every cycle (because the saw does) The perlin function
-- uses the cycle count as input and can be used much like rand.
perlinWith :: Pattern Double -> Pattern Double
perlin :: Pattern Double
perlin2With :: Pattern Double -> Pattern Double -> Pattern Double
perlin2 :: Pattern Double -> Pattern Double
-- | Randomly picks an element from the given list
--
--
-- sound "superpiano(3,8)" # note (choose ["a", "e", "g", "c"])
--
--
-- plays a melody randomly choosing one of the four notes "a", "e", "g",
-- "c".
choose :: [a] -> Pattern a
chooseBy :: Pattern Double -> [a] -> Pattern a
-- | Like choose, but works on an a list of tuples of values and
-- weights
--
--
-- sound "superpiano(3,8)" # note (choose [("a",1), ("e",0.5), ("g",2), ("c",1)])
--
--
-- In the above example, the "a" and "c" notes are twice as likely to
-- play as the "e" note, and half as likely to play as the "g" note.
wchoose :: [(a, Double)] -> Pattern a
wchooseBy :: Pattern Double -> [(a, Double)] -> Pattern a
-- | Similar to degrade degradeBy allows you to control the
-- percentage of events that are removed. For example, to remove events
-- 90% of the time:
--
--
-- d1 $ slow 2 $ degradeBy 0.9 $ sound "[[[feel:5*8,feel*3] feel:3*8], feel*4]"
-- # accelerate "-6"
-- # speed "2"
--
degradeBy :: Pattern Double -> Pattern a -> Pattern a
_degradeBy :: Double -> Pattern a -> Pattern a
unDegradeBy :: Pattern Double -> Pattern a -> Pattern a
_unDegradeBy :: Double -> Pattern a -> Pattern a
degradeOverBy :: Int -> Pattern Double -> Pattern a -> Pattern a
-- | Use sometimesBy to apply a given function "sometimes". For
-- example, the following code results in `density 2` being applied about
-- 25% of the time:
--
--
-- d1 $ sometimesBy 0.25 (density 2) $ sound "bd*8"
--
--
-- There are some aliases as well:
--
--
-- sometimes = sometimesBy 0.5
-- often = sometimesBy 0.75
-- rarely = sometimesBy 0.25
-- almostNever = sometimesBy 0.1
-- almostAlways = sometimesBy 0.9
--
sometimesBy :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | sometimes is an alias for sometimesBy 0.5.
sometimes :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | often is an alias for sometimesBy 0.75.
often :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | rarely is an alias for sometimesBy 0.25.
rarely :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | almostNever is an alias for sometimesBy 0.1
almostNever :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | almostAlways is an alias for sometimesBy 0.9
almostAlways :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
never :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
always :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | someCyclesBy is a cycle-by-cycle version of
-- sometimesBy. It has a `someCycles = someCyclesBy 0.5` alias
someCyclesBy :: Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
somecyclesBy :: Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
someCycles :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
somecycles :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | degrade randomly removes events from a pattern 50% of the time:
--
--
-- d1 $ slow 2 $ degrade $ sound "[[[feel:5*8,feel*3] feel:3*8], feel*4]"
-- # accelerate "-6"
-- # speed "2"
--
--
-- The shorthand syntax for degrade is a question mark:
-- ?. Using ? will allow you to randomly remove events
-- from a portion of a pattern:
--
--
-- d1 $ slow 2 $ sound "bd ~ sn bd ~ bd? [sn bd?] ~"
--
--
-- You can also use ? to randomly remove events from entire
-- sub-patterns:
--
--
-- d1 $ slow 2 $ sound "[[[feel:5*8,feel*3] feel:3*8]?, feel*4]"
--
degrade :: Pattern a -> Pattern a
-- | (The above means that brak is a function from patterns of any
-- type, to a pattern of the same type.)
--
-- Make a pattern sound a bit like a breakbeat
--
-- Example:
--
--
-- d1 $ sound (brak "bd sn kurt")
--
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:
--
--
-- d1 $ iter 4 $ sound "bd hh sn cp"
--
--
-- This will produce the following over four cycles:
--
--
-- bd hh sn cp
-- hh sn cp bd
-- sn cp bd hh
-- cp bd hh sn
--
--
-- There is also iter', which shifts the pattern in the opposite
-- direction.
iter :: Pattern Int -> Pattern c -> Pattern c
_iter :: Int -> Pattern a -> Pattern a
-- | iter' is the same as iter, but decrements the
-- starting subdivision instead of incrementing it.
iter' :: Pattern Int -> Pattern c -> Pattern c
_iter' :: Int -> Pattern a -> Pattern a
-- | palindrome p applies rev to p every other
-- cycle, so that the pattern alternates between forwards and backwards.
palindrome :: Pattern a -> Pattern a
-- | Composing patterns
--
-- The function seqP allows you to define when a sound within a
-- list starts and ends. The code below contains three separate patterns
-- in a stack, but each has different start times (zero cycles,
-- eight cycles, and sixteen cycles, respectively). All patterns stop
-- after 128 cycles:
--
--
-- 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)))
-- ]
--
seqP :: [(Time, Time, Pattern a)] -> Pattern a
-- | Degrades a pattern over the given time.
fadeOut :: Time -> Pattern a -> Pattern a
-- | Alternate version to fadeOut 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 fadeIn where you can provide the time
-- from which the fade in starts
fadeInFrom :: Time -> Time -> Pattern a -> Pattern a
-- | The spread function allows you to take a pattern transformation
-- which takes a parameter, such as slow, 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:
--
--
-- d1 $ sound "ho ho:2 ho:3 hc"
--
--
-- We can slow it down by different amounts, such as by a half:
--
--
-- d1 $ slow 2 $ sound "ho ho:2 ho:3 hc"
--
--
-- Or by four thirds (i.e. speeding it up by a third; `4%3` means four
-- over three):
--
--
-- d1 $ slow (4%3) $ sound "ho ho:2 ho:3 hc"
--
--
-- But if we use spread, we can make a pattern which alternates
-- between the two speeds:
--
--
-- d1 $ spread slow [2,4%3] $ sound "ho ho:2 ho:3 hc"
--
--
-- Note that if you pass ($) as the function to spread values over, you
-- can put functions as the list of values. For example:
--
--
-- d1 $ spread ($) [density 2, rev, slow 2, striate 3, (# speed "0.8")]
-- $ sound "[bd*2 [~ bd]] [sn future]*2 cp jvbass*4"
--
--
-- Above, the pattern will have these transforms applied to it, one at a
-- time, per cycle:
--
--
-- - cycle 1: `density 2` - pattern will increase in speed
-- - cycle 2: rev - pattern will be reversed
-- - cycle 3: `slow 2` - pattern will decrease in speed
-- - cycle 4: `striate 3` - pattern will be granualized
-- - cycle 5: `(# speed "0.8")` - pattern samples will be played back
-- more slowly
--
--
-- After `(# speed "0.8")`, the transforms will repeat and start at
-- `density 2` again.
spread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b
slowspread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b
-- | fastspread works the same as spread, but the result
-- is squashed into a single cycle. If you gave four values to
-- spread, then the result would seem to speed up by a factor of
-- four. Compare these two:
--
-- d1 $ spread chop [4,64,32,16] $ sound "ho ho:2 ho:3 hc"
--
-- d1 $ fastspread chop [4,64,32,16] $ sound "ho ho:2 ho:3 hc"
--
-- There is also slowspread, which is an alias of
-- spread.
fastspread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b
-- | There's a version of this function, spread' (pronounced "spread
-- prime"), which takes a *pattern* of parameters, instead of a list:
--
--
-- d1 $ spread' slow "2 4%3" $ sound "ho ho:2 ho:3 hc"
--
--
-- This is quite a messy area of Tidal - due to a slight difference of
-- implementation this sounds completely different! One advantage of
-- using spread' though is that you can provide polyphonic
-- parameters, e.g.:
--
--
-- d1 $ spread' slow "[2 4%3, 3]" $ sound "ho ho:2 ho:3 hc"
--
spread' :: Monad m => (a -> b -> m c) -> m a -> b -> m c
-- | `spreadChoose f xs p` is similar to slowspread but picks values
-- from xs at random, rather than cycling through them in order.
-- It has a shorter alias spreadr.
spreadChoose :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b
spreadr :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b
-- | Decide whether to apply one or another function depending on the
-- result of a test function that is passed the current cycle as a
-- number.
--
--
-- d1 $ ifp ((== 0).(flip mod 2))
-- (striate 4)
-- (# coarse "24 48") $
-- sound "hh hc"
--
--
-- This will apply `striate 4` for every _even_ cycle and aply `# coarse
-- "24 48"` for every _odd_.
--
-- Detail: As you can see the test function is arbitrary and does not
-- rely on anything tidal specific. In fact it uses only plain haskell
-- functionality, that is: it calculates the modulo of 2 of the current
-- cycle which is either 0 (for even cycles) or 1. It then compares this
-- value against 0 and returns the result, which is either True or
-- False. This is what the ifp signature's first part
-- signifies `(Int -> Bool)`, a function that takes a whole number and
-- returns either True or False.
ifp :: (Int -> Bool) -> (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | wedge t p p' combines patterns p and p' by
-- squashing the p into the portion of each cycle given by
-- t, and p' into the remainer of each cycle.
wedge :: Time -> Pattern a -> Pattern a -> Pattern a
-- | whenmod has a similar form and behavior to every, but
-- requires an additional number. Applies the function to the pattern,
-- when the remainder of the current loop number divided by the first
-- parameter, is greater or equal than the second parameter.
--
-- For example the following makes every other block of four loops twice
-- as dense:
--
--
-- d1 $ whenmod 8 4 (density 2) (sound "bd sn kurt")
--
whenmod :: Int -> Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- |
-- superimpose f p = stack [p, f p]
--
--
-- superimpose 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.
--
--
-- d1 $ superimpose (density 2) $ sound "bd sn [cp ht] hh"
-- d1 $ superimpose ((# speed "2") . (0.125 <~)) $ sound "bd sn cp hh"
--
superimpose :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | trunc truncates a pattern so that only a fraction of the
-- pattern is played. The following example plays only the first quarter
-- of the pattern:
--
--
-- d1 $ trunc 0.25 $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2"
--
trunc :: Pattern Time -> Pattern a -> Pattern a
_trunc :: Time -> Pattern a -> Pattern a
-- | linger is similar to trunc but the truncated part of
-- the pattern loops until the end of the cycle
--
--
-- d1 $ linger 0.25 $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2"
--
linger :: Pattern Time -> Pattern a -> Pattern a
_linger :: Time -> Pattern a -> Pattern a
-- | Use within to apply a function to only a part of a pattern. For
-- example, to apply `density 2` to only the first half of a pattern:
--
--
-- d1 $ within (0, 0.5) (density 2) $ sound "bd*2 sn lt mt hh hh hh hh"
--
--
-- Or, to apply `(# speed "0.5") to only the last quarter of a pattern:
--
--
-- d1 $ within (0.75, 1) (# speed "0.5") $ sound "bd*2 sn lt mt hh hh hh hh"
--
within :: (Time, Time) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
withinArc :: Arc -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | For many cases, within' will function exactly as within. The
-- difference between the two occurs when applying functions that change
-- the timing of notes such as fast or <~. 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
--
--
-- d1 $ within (0, 0.25) (fast 2) $ sound "bd hh cp sd"
--
--
-- sounds like:
--
--
-- d1 $ sound "[bd hh] hh cp sd"
--
--
-- using this alternative version, within'
--
--
-- d1 $ within' (0, 0.25) (fast 2) $ sound "bd hh cp sd"
--
--
-- sounds like:
--
--
-- d1 $ sound "[bd bd] hh cp sd"
--
within' :: (Time, Time) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
revArc :: (Time, Time) -> Pattern a -> Pattern a
-- | You can use the e function to apply a Euclidean algorithm
-- over a complex pattern, although the structure of that pattern will be
-- lost:
--
--
-- d1 $ e 3 8 $ sound "bd*2 [sn cp]"
--
--
-- In the above, three sounds are picked from the pattern on the right
-- according to the structure given by the `e 3 8`. It ends up picking
-- two bd sounds, a cp and missing the sn
-- entirely.
--
-- These types of sequences use "Bjorklund's algorithm", which wasn't
-- made for music but for an application in nuclear physics, which is
-- exciting. More exciting still is that it is very similar in structure
-- to the one of the first known algorithms written in Euclid's book of
-- elements in 300 BC. You can read more about this in the paper [The
-- Euclidean Algorithm Generates Traditional Musical
-- Rhythms](http:/cgm.cs.mcgill.ca~godfriedpublicationsbanff.pdf)
-- by Toussaint. Some examples from this paper are included below,
-- including rotation in some cases.
--
--
-- - (2,5) : A thirteenth century Persian rhythm called Khafif-e-ramal.
-- - (3,4) : The archetypal pattern of the Cumbia from Colombia, as well as a Calypso rhythm from Trinidad.
-- - (3,5,2) : Another thirteenth century Persian rhythm by the name of Khafif-e-ramal, as well as a Rumanian folk-dance rhythm.
-- - (3,7) : A Ruchenitza rhythm used in a Bulgarian folk-dance.
-- - (3,8) : The Cuban tresillo pattern.
-- - (4,7) : Another Ruchenitza Bulgarian folk-dance rhythm.
-- - (4,9) : The Aksak rhythm of Turkey.
-- - (4,11) : The metric pattern used by Frank Zappa in his piece titled Outside Now.
-- - (5,6) : Yields the York-Samai pattern, a popular Arab rhythm.
-- - (5,7) : The Nawakhat pattern, another popular Arab rhythm.
-- - (5,8) : The Cuban cinquillo pattern.
-- - (5,9) : A popular Arab rhythm called Agsag-Samai.
-- - (5,11) : The metric pattern used by Moussorgsky in Pictures at an Exhibition.
-- - (5,12) : The Venda clapping pattern of a South African children’s song.
-- - (5,16) : The Bossa-Nova rhythm necklace of Brazil.
-- - (7,8) : A typical rhythm played on the Bendir (frame drum).
-- - (7,12) : A common West African bell pattern.
-- - (7,16,14) : A Samba rhythm necklace from Brazil.
-- - (9,16) : A rhythm necklace used in the Central African Republic.
-- - (11,24,14) : A rhythm necklace of the Aka Pygmies of Central Africa.
-- - (13,24,5) : Another rhythm necklace of the Aka Pygmies of the upper Sangha.
--
euclid :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_euclid :: Int -> Int -> Pattern a -> Pattern a
-- | `euclidfull n k pa pb` stacks e n k pa with einv n k
-- pb
euclidFull :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a -> Pattern a
_euclidBool :: Int -> Int -> Pattern Bool
_euclidFull :: Int -> Int -> Pattern a -> Pattern a -> Pattern a
_euclid' :: Int -> Int -> Pattern a -> Pattern a
euclidOff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
eoff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
_euclidOff :: Int -> Int -> Int -> Pattern a -> Pattern a
euclidOffBool :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern Bool -> Pattern Bool
_euclidOffBool :: Int -> Int -> Int -> Pattern Bool -> Pattern Bool
distrib :: [Pattern Int] -> Pattern a -> Pattern a
_distrib :: [Int] -> Pattern a -> Pattern a
-- | euclidInv fills in the blanks left by e - e 3 8
-- "x" -> "x ~ ~ x ~ ~ x ~"
--
-- euclidInv 3 8 "x" -> "~ x x ~ x x ~ x"
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
-- | rot n p rotates the values in a pattern p by
-- n beats to the left. Example: d1 $ every 4 (rot 2) $ slow
-- 2 $ sound "bd hh hh hh"
rot :: Ord a => Pattern Int -> Pattern a -> Pattern a
_rot :: Ord a => Int -> Pattern a -> Pattern a
-- | segment n p: samples the pattern p at a rate
-- of n events per cycle. Useful for turning a continuous
-- pattern into a discrete one.
segment :: Pattern Time -> Pattern a -> Pattern a
_segment :: Time -> Pattern a -> Pattern a
-- | discretise: the old (deprecated) name for segment
discretise :: Pattern Time -> Pattern a -> Pattern a
-- | randcat ps: does a slowcat on the list of patterns
-- ps but randomises the order in which they are played.
randcat :: [Pattern a] -> Pattern a
-- | The fit 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:
--
--
-- d1 $ sound (fit 3 ["bd", "sn", "arpy", "arpy:1", "casio"] "0 [~ 1] 2 1")
--
--
-- The above fits three samples into the pattern, i.e. for the first
-- cycle this will be `"bd"`, `"sn"` and `"arpy"`, giving the result `"bd
-- [~ sn] arpy sn"` (note that we start counting at zero, so that `0`
-- picks the first value). The following cycle the *next* three values in
-- the list will be picked, i.e. `"arpy:1"`, `"casio"` and `"bd"`, giving
-- the pattern `"arpy:1 [~ casio] bd casio"` (note that the list wraps
-- round here).
fit :: Int -> [a] -> Pattern Int -> Pattern a
permstep :: RealFrac b => Int -> [a] -> Pattern b -> Pattern a
-- | struct a b: structures pattern b in terms of the
-- pattern of boolean values a. Only True values in the
-- boolean pattern are used.
struct :: Pattern Bool -> Pattern a -> Pattern a
-- | substruct a b: similar to struct, but each event in
-- pattern a gets replaced with pattern b, compressed
-- to fit the timespan of the event.
substruct :: Pattern String -> Pattern b -> Pattern b
randArcs :: Int -> Pattern [Arc]
randStruct :: Int -> Pattern Int
substruct' :: Pattern Int -> Pattern a -> Pattern a
-- | stripe n p: repeats pattern p, n times per
-- cycle. So similar to fast, but with random durations. The
-- repetitions will be continguous (touching, but not overlapping) and
-- the durations will add up to a single cycle. n can be
-- supplied as a pattern of integers.
stripe :: Pattern Int -> Pattern a -> Pattern a
_stripe :: Int -> Pattern a -> Pattern a
-- | slowstripe n p: The same as stripe, but the result
-- is also n times slower, so that the mean average duration of
-- the stripes is exactly one cycle, and every nth stripe starts
-- on a cycle boundary (in indian classical terms, the sam).
slowstripe :: Pattern Int -> Pattern a -> Pattern a
parseLMRule :: String -> [(String, String)]
parseLMRule' :: String -> [(Char, String)]
-- | returns the nth iteration of a Lindenmayer System with
-- given start sequence.
--
-- for example:
--
--
-- lindenmayer 1 "a:b,b:ab" "ab" -> "bab"
--
lindenmayer :: Int -> String -> String -> String
-- | lindenmayerI converts the resulting string into a a list of
-- integers with fromIntegral applied (so they can be used
-- seamlessly where floats or rationals are required)
lindenmayerI :: Num b => Int -> String -> String -> [b]
unwrap' :: Pattern (Pattern a) -> Pattern a
-- | Removes events from second pattern that don't start during an event
-- from first.
--
-- Consider this, kind of messy rhythm without any rests.
--
--
-- d1 $ sound (slowcat ["sn*8", "[cp*4 bd*4, hc*5]"]) # n (run 8)
--
--
-- If we apply a mask to it
--
--
-- d1 $ s (mask ("1 1 1 ~ 1 1 ~ 1" :: Pattern Bool)
-- (slowcat ["sn*8", "[cp*4 bd*4, bass*5]"] ))
-- # n (run 8)
--
--
-- Due to the use of slowcat here, the same mask is first applied
-- to `"sn*8"` and in the next cycle to `"[cp*4 bd*4, hc*5]".
--
-- You could achieve the same effect by adding rests within the
-- slowcat 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.
--
--
-- d1 $ s (mask ("1 ~ 1 ~ 1 1 ~ 1")
-- (slowcat ["can*8", "[cp*4 sn*4, jvbass*16]"] ))
-- # n (run 8)
--
mask :: Pattern Bool -> Pattern a -> Pattern a
-- | TODO: refactor towards union
enclosingArc :: [Arc] -> Arc
stretch :: Pattern a -> Pattern a
-- | fit' is a generalization of fit, 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:
--
--
-- d1 $ sound (fit' 1 2 "0 1" "1 0" "bd sn")
--
--
-- So what does this do? The first `1` just tells it to slice up a single
-- cycle of `"bd sn"`. The `2` tells it to select two values each cycle,
-- just like the first argument to fit. The next pattern `"0 1"`
-- is the "from" pattern which tells it how to slice, which in this case
-- means `"0"` maps to `"bd"`, and `"1"` maps to `"sn"`. The next pattern
-- `"1 0"` is the "to" pattern, which tells it how to rearrange those
-- slices. So the final result is the pattern `"sn bd"`.
--
-- A more useful example might be something like
--
--
-- d1 $ fit' 1 4 (run 4) "[0 3*2 2 1 0 3*2 2 [1*8 ~]]/2" $ chop 4 $ (sound "breaks152" # unit "c")
--
--
-- which uses chop to break a single sample into individual
-- pieces, which fit' then puts into a list (using the `run 4`
-- pattern) and reassembles according to the complicated integer pattern.
fit' :: Pattern Time -> Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
-- | chunk n f p treats the given pattern p as having
-- n chunks, and applies the function f to one of those
-- sections per cycle, running from left to right.
--
--
-- d1 $ chunk 4 (density 4) $ sound "cp sn arpy [mt lt]"
--
chunk :: Int -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b
runWith :: Int -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b
-- | chunk' works much the same as chunk, but runs from
-- right to left.
chunk' :: Integral a => a -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b
runWith' :: Integral a => a -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b
inside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a
outside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a
loopFirst :: Pattern a -> Pattern a
timeLoop :: Pattern Time -> Pattern a -> Pattern a
seqPLoop :: [(Time, Time, Pattern a)] -> Pattern a
-- | toScale lets you turn a pattern of notes within a scale
-- (expressed as a list) to note numbers. For example `toScale [0, 4, 7]
-- "0 1 2 3"` will turn into the pattern `"0 4 7 12"`. It assumes your
-- scale fits within an octave; to change this use toScale size`.
-- Example: toScale 24 [0,4,7,10,14,17] (run 8)` turns into `"0 4
-- 7 10 14 17 24 28"`
toScale' :: Num a => Int -> [a] -> Pattern Int -> Pattern a
toScale :: Num a => [a] -> Pattern Int -> Pattern a
-- | `swingBy x n` divides a cycle into n slices and delays the
-- notes in the second half of each slice by x fraction of a
-- slice . swing is an alias for `swingBy (1%3)`
swingBy :: Pattern Time -> Pattern Time -> Pattern a -> Pattern a
swing :: Pattern Time -> Pattern a -> Pattern a
-- | cycleChoose is like choose but only picks a new item
-- from the list once each cycle
cycleChoose :: [a] -> Pattern a
-- | `shuffle n p` evenly divides one cycle of the pattern p into
-- n parts, and returns a random permutation of the parts each
-- cycle. For example, `shuffle 3 "a b c"` could return `"a b c"`, `"a c
-- b"`, `"b a c"`, `"b c a"`, `"c a b"`, or `"c b a"`. But it will
-- **never** return `"a a a"`, because that is not a permutation of the
-- parts.
shuffle :: Int -> Pattern a -> Pattern a
-- | `scramble n p` is like shuffle but randomly selects from the
-- parts of p instead of making permutations. For example,
-- `scramble 3 "a b c"` will randomly select 3 parts from `"a"` `"b"` and
-- `"c"`, possibly repeating a single part.
scramble :: Int -> Pattern a -> Pattern a
ur :: Time -> Pattern String -> [(String, Pattern a)] -> [(String, Pattern a -> Pattern a)] -> Pattern a
inhabit :: [(String, Pattern a)] -> Pattern String -> Pattern a
-- | spaceOut xs p repeats a pattern p at different
-- durations given by the list of time values in xs
spaceOut :: [Time] -> Pattern a -> Pattern a
-- | flatpat takes a Pattern of lists and pulls the list elements
-- as separate Events
flatpat :: Pattern [a] -> Pattern a
-- | layer takes a Pattern of lists and pulls the list elements as
-- separate Events
layer :: [a -> Pattern b] -> a -> Pattern b
-- | arpeggiate finds events that share the same timespan, and
-- spreads them out during that timespan, so for example arpeggiate
-- "[bd,sn]" gets turned into "bd sn". Useful for creating
-- arpeggios/broken chords.
arpeggiate :: Pattern a -> Pattern a
-- | Shorthand alias for arpeggiate
arpg :: Pattern a -> Pattern a
ply :: Pattern Int -> Pattern a -> Pattern a
_ply :: Int -> Pattern a -> Pattern a
sew :: Pattern Bool -> Pattern a -> Pattern a -> Pattern a
stutter :: Integral i => i -> Time -> Pattern a -> Pattern a
echo :: Time -> Pattern a -> Pattern a
triple :: Time -> Pattern a -> Pattern a
quad :: Time -> Pattern a -> Pattern a
double :: Time -> Pattern a -> Pattern a
-- | The jux 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:
--
--
-- d1 $ slow 32 $ jux (rev) $ striateBy 32 (1/16) $ sound "bev"
--
--
-- When passing pattern transforms to functions like jux and
-- every, it's possible to chain multiple transforms together with
-- ., for example this both reverses and halves the playback speed
-- of the pattern in the righthand channel:
--
--
-- d1 $ slow 32 $ jux ((# speed "0.5") . rev) $ striateBy 32 (1/16) $ sound "bev"
--
jux :: (Pattern ControlMap -> Pattern ControlMap) -> Pattern ControlMap -> Pattern ControlMap
juxcut :: (Pattern ControlMap -> Pattern ControlMap) -> Pattern ControlMap -> Pattern ControlMap
juxcut' :: [t -> Pattern ControlMap] -> t -> Pattern ControlMap
-- | In addition to jux, jux' allows using a list of pattern
-- transform. resulting patterns from each transformation will be spread
-- via pan from left to right.
--
-- For example:
--
--
-- d1 $ jux' [iter 4, chop 16, id, rev, palindrome] $ sound "bd sn"
--
--
-- will put `iter 4` of the pattern to the far left and palindrome
-- to the far right. In the center the original pattern will play and mid
-- left mid right the chopped and the reversed version will appear.
--
-- One could also write:
--
--
-- 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",
-- ]
--
jux' :: [t -> Pattern ControlMap] -> t -> Pattern ControlMap
-- | Multichannel variant of jux, _not sure what it does_
jux4 :: (Pattern ControlMap -> Pattern ControlMap) -> Pattern ControlMap -> Pattern ControlMap
-- | With jux, 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
-- juxBy has an additional parameter, which brings the channel
-- closer to the centre. For example:
--
--
-- d1 $ juxBy 0.5 (density 2) $ sound "bd sn:1"
--
--
-- 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 ControlMap -> Pattern ControlMap) -> Pattern ControlMap -> Pattern ControlMap
pick :: String -> Int -> String
samples :: Applicative f => f String -> f Int -> f String
samples' :: Applicative f => f String -> f Int -> f String
spreadf :: [a -> Pattern b] -> a -> Pattern b
stackwith :: Unionable a => Pattern a -> [Pattern a] -> Pattern a
-- | range will take a pattern which goes from 0 to 1 (like
-- sine), 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 sine1 from 0 - 1 to 1 - 1.5.
--
--
-- d1 $ jux (iter 4) $ sound "arpy arpy:2*2"
-- |+ speed (slow 4 $ range 1 1.5 sine1)
--
range :: Num a => Pattern a -> Pattern a -> Pattern a -> Pattern a
_range :: (Functor f, Num b) => b -> b -> f b -> f b
-- | rangex is an exponential version of range, good for
-- using with frequencies. Do *not* use negative numbers or zero as
-- arguments!
rangex :: (Functor f, Floating b) => b -> b -> f b -> f b
off :: Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_off :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
offadd :: Num a => Pattern Time -> Pattern a -> Pattern a -> Pattern a
-- | Step sequencing
step :: String -> String -> Pattern String
steps :: [(String, String)] -> Pattern String
-- | like step, but allows you to specify an array of strings to use
-- for 0,1,2...
step' :: [String] -> String -> Pattern String
ghost'' :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
ghost' :: Time -> Pattern ControlMap -> Pattern ControlMap
ghost :: Pattern ControlMap -> Pattern ControlMap
-- | tabby - A more literal weaving than the weave function, give
-- number of threads per cycle and two patterns, 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
_select :: Double -> [Pattern a] -> Pattern a
-- | chooses between a list of patterns, using a pattern of floats (from
-- 0-1)
select :: Pattern Double -> [Pattern a] -> Pattern a
-- | contrast p f f' p' splits controlpattern p' in two,
-- applying the function f to one and f' to the other.
-- This depends on whether events in it contains values matching with
-- those in p. For example in contrast (n "1") ( vowel "a")
-- $ n "0 1" speed 3, the first event will have the vowel effect
-- applied and the second will have the crush applied.
contrast :: (ControlPattern -> ControlPattern) -> (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern
contrastBy :: (a -> Value -> Bool) -> (ControlPattern -> Pattern b) -> (ControlPattern -> Pattern b) -> Pattern (Map String a) -> Pattern (Map String Value) -> Pattern b
contrastRange :: (ControlPattern -> Pattern a) -> (ControlPattern -> Pattern a) -> Pattern (Map String (Value, Value)) -> ControlPattern -> Pattern a
-- | Like contrast, but one function is given, and applied to
-- events with matching controls.
fix :: (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern
-- | Like contrast, but one function is given, and applied to
-- events with controls which don't match.
unfix :: (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern
fixRange :: (ControlPattern -> Pattern ControlMap) -> Pattern (Map String (Value, Value)) -> ControlPattern -> Pattern ControlMap
unfixRange :: (ControlPattern -> Pattern ControlMap) -> Pattern (Map String (Value, Value)) -> ControlPattern -> Pattern ControlMap
-- | limit values in a Pattern (or other Functor) to n equally spaced
-- divisions of 1.
quantise :: (Functor f, RealFrac b) => b -> f b -> f b
-- | Inverts all the values in a boolean pattern
inv :: Functor f => f Bool -> f Bool
-- | Serialises a pattern so there's only one event playing at any one
-- time, making it monophonic. Events which start/end earlier
-- are given priority.
mono :: Pattern a -> Pattern a
smooth :: Fractional a => Pattern a -> Pattern a
module Sound.Tidal.ParseBP
data TidalParseError
TidalParseError :: ParseError -> String -> TidalParseError
[parsecError] :: TidalParseError -> ParseError
[code] :: TidalParseError -> String
-- | AST representation of patterns
data TPat a
TPat_Atom :: a -> TPat a
TPat_Density :: TPat Time -> TPat a -> TPat a
TPat_Slow :: TPat Time -> TPat a -> TPat a
TPat_Zoom :: Arc -> TPat a -> TPat a
TPat_DegradeBy :: Double -> TPat a -> TPat a
TPat_Silence :: TPat a
TPat_Foot :: TPat a
TPat_Elongate :: Int -> TPat a
TPat_EnumFromTo :: TPat a -> TPat a -> TPat a
TPat_Cat :: [TPat a] -> TPat a
TPat_TimeCat :: [TPat a] -> TPat a
TPat_Overlay :: TPat a -> TPat a -> TPat a
TPat_Stack :: [TPat a] -> TPat a
TPat_ShiftL :: Time -> TPat a -> TPat a
TPat_pE :: TPat Int -> TPat Int -> TPat Int -> TPat a -> TPat a
toPat :: (Enumerable a, Parseable a) => TPat a -> Pattern a
durations :: [TPat a] -> [(Int, TPat a)]
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)
class Parseable a
tPatParser :: Parseable a => Parser (TPat a)
doEuclid :: Parseable a => Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a
class Enumerable a
fromTo :: Enumerable a => a -> a -> Pattern a
fromThenTo :: Enumerable a => a -> a -> a -> Pattern a
enumFromTo' :: (Ord a, Enum a) => a -> a -> Pattern a
enumFromThenTo' :: (Ord a, Enum a, Num a) => a -> a -> a -> Pattern a
type ColourD = Colour Double
lexer :: GenTokenParser String u Identity
braces :: Parser a -> Parser a
brackets :: Parser a -> Parser a
parens :: Parser a -> Parser a
angles :: Parser a -> Parser a
symbol :: String -> Parser String
natural :: Parser Integer
integer :: Parser Integer
float :: Parser Double
naturalOrFloat :: Parser (Either Integer Double)
data Sign
Positive :: Sign
Negative :: Sign
applySign :: Num a => Sign -> a -> a
sign :: Parser Sign
intOrFloat :: Parser Double
parseRhythm :: Parseable a => Parser (TPat a) -> String -> Either ParseError (TPat a)
pSequenceN :: Parseable a => Parser (TPat a) -> GenParser Char () (Int, TPat a)
elongate :: [TPat a] -> TPat a
splitFeet :: [TPat t] -> [[TPat t]]
pSequence :: Parseable a => Parser (TPat a) -> GenParser Char () (TPat a)
pSingle :: Parser (TPat a) -> Parser (TPat a)
pPart :: Parseable a => Parser (TPat a) -> Parser [TPat a]
pPolyIn :: Parseable a => Parser (TPat a) -> Parser (TPat a)
pPolyOut :: Parseable a => Parser (TPat a) -> Parser (TPat a)
pString :: Parser String
pVocable :: Parser (TPat String)
pDouble :: Parser (TPat Double)
pBool :: Parser (TPat Bool)
parseIntNote :: Integral i => Parser i
parseInt :: Parser Int
pIntegral :: Integral a => Parser (TPat a)
parseChord :: Num a => Parser [a]
parseNote :: Num a => Parser a
fromNote :: Num a => Pattern String -> Pattern a
pColour :: Parser (TPat ColourD)
pMult :: TPat a -> Parser (TPat a)
pRand :: TPat a -> Parser (TPat a)
pE :: TPat a -> Parser (TPat a)
pReplicate :: TPat a -> Parser [TPat a]
pStretch :: TPat a -> Parser [TPat a]
pRatio :: Parser Rational
pRational :: Parser (TPat Rational)
instance GHC.Show.Show a => GHC.Show.Show (Sound.Tidal.ParseBP.TPat a)
instance GHC.Classes.Eq Sound.Tidal.ParseBP.TidalParseError
instance Sound.Tidal.ParseBP.Parseable Sound.Tidal.ParseBP.ColourD
instance Sound.Tidal.ParseBP.Enumerable Sound.Tidal.ParseBP.ColourD
instance Sound.Tidal.ParseBP.Enumerable GHC.Types.Double
instance Sound.Tidal.ParseBP.Enumerable GHC.Base.String
instance Sound.Tidal.ParseBP.Enumerable GHC.Types.Bool
instance Sound.Tidal.ParseBP.Enumerable GHC.Types.Int
instance Sound.Tidal.ParseBP.Enumerable GHC.Integer.Type.Integer
instance Sound.Tidal.ParseBP.Enumerable GHC.Real.Rational
instance (Sound.Tidal.ParseBP.Enumerable a, Sound.Tidal.ParseBP.Parseable a) => Data.String.IsString (Sound.Tidal.Pattern.Pattern a)
instance Sound.Tidal.ParseBP.Parseable GHC.Types.Double
instance Sound.Tidal.ParseBP.Parseable GHC.Base.String
instance Sound.Tidal.ParseBP.Parseable GHC.Types.Bool
instance Sound.Tidal.ParseBP.Parseable GHC.Types.Int
instance Sound.Tidal.ParseBP.Parseable GHC.Integer.Type.Integer
instance Sound.Tidal.ParseBP.Parseable GHC.Real.Rational
instance GHC.Exception.Type.Exception Sound.Tidal.ParseBP.TidalParseError
instance GHC.Show.Show Sound.Tidal.ParseBP.TidalParseError
module Sound.Tidal.Control
-- | spin will "spin" a layer up a pattern the given number of
-- times, with each successive layer offset in time by an additional
-- `1/n` of a cycle, and panned by an additional `1/n`. The result is a
-- pattern that seems to spin around. This function works best on
-- multichannel systems.
--
--
-- d1 $ slow 3 $ spin 4 $ sound "drum*3 tabla:4 [arpy:2 ~ arpy] [can:2 can:3]"
--
spin :: Pattern Int -> ControlPattern -> ControlPattern
_spin :: Int -> ControlPattern -> ControlPattern
-- | chop granualizes every sample in place as it is played, turning
-- a pattern of samples into a pattern of sample parts. Use an integer
-- value to specify how many granules each sample is chopped into:
--
--
-- d1 $ chop 16 $ sound "arpy arp feel*4 arpy*4"
--
--
-- Different values of chop can yield very different results,
-- depending on the samples used:
--
--
-- 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]"
--
chop :: Pattern Int -> ControlPattern -> ControlPattern
chopArc :: Arc -> Int -> [Arc]
_chop :: Int -> ControlPattern -> ControlPattern
-- | Striate is a kind of granulator, for example:
--
--
-- d1 $ striate 3 $ sound "ho ho:2 ho:3 hc"
--
--
-- This plays the loop the given number of times, but triggering
-- progressive portions of each sample. So in this case it plays the loop
-- three times, the first time playing the first third of each sample,
-- then the second time playing the second third of each sample, etc..
-- With the highhat samples in the above example it sounds a bit like
-- reverb, but it isn't really.
--
-- You can also use striate with very long samples, to cut it into short
-- chunks and pattern those chunks. This is where things get towards
-- granular synthesis. The following cuts a sample into 128 parts, plays
-- it over 8 cycles and manipulates those parts by reversing and rotating
-- the loops.
--
--
-- d1 $ slow 8 $ striate 128 $ sound "bev"
--
striate :: Pattern Int -> ControlPattern -> ControlPattern
_striate :: Int -> ControlPattern -> ControlPattern
mergePlayRange :: (Double, Double) -> ControlMap -> ControlMap
-- | The striateBy function is a variant of striate with an
-- extra parameter, which specifies the length of each part. The
-- striateBy function still scans across the sample over a single
-- cycle, but if each bit is longer, it creates a sort of stuttering
-- effect. For example the following will cut the bev sample into 32
-- parts, but each will be 1/16th of a sample long:
--
--
-- d1 $ slow 32 $ striateBy 32 (1/16) $ sound "bev"
--
--
-- Note that striate uses the begin and end
-- parameters internally. This means that if you're using striate
-- (or striateBy) you probably shouldn't also specify
-- begin or end.
striateBy :: Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern
striate' :: Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern
_striateBy :: Int -> Double -> ControlPattern -> ControlPattern
-- | gap is similar to chop 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:
--
--
-- d1 $ gap 8 $ sound "jvbass"
-- d1 $ gap 16 $ sound "[jvbass drum:4]"
--
gap :: Pattern Int -> ControlPattern -> ControlPattern
_gap :: Int -> ControlPattern -> ControlPattern
-- | weave applies a function smoothly over an array of different
-- patterns. It uses an OscPattern to apply the function at
-- different levels to each pattern, creating a weaving effect.
--
--
-- d1 $ weave 3 (shape $ sine1) [sound "bd [sn drum:2*2] bd*2 [sn drum:1]", sound "arpy*8 ~"]
--
weave :: Time -> ControlPattern -> [ControlPattern] -> ControlPattern
-- | weaveWith is similar in that it blends functions at the same
-- time at different amounts over a pattern:
--
--
-- d1 $ weaveWith 3 (sound "bd [sn drum:2*2] bd*2 [sn drum:1]") [density 2, (# speed "0.5"), chop 16]
--
weaveWith :: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a
weave' :: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a
-- | (A function that takes two ControlPatterns, and blends them together
-- into a new ControlPattern. An ControlPattern is basically a pattern of
-- messages to a synthesiser.)
--
-- Shifts between the two given patterns, using distortion.
--
-- Example:
--
--
-- d1 $ interlace (sound "bd sn kurt") (every 3 rev $ sound "bd sn:2")
--
interlace :: ControlPattern -> ControlPattern -> ControlPattern
slice :: Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern
_slice :: Int -> Int -> ControlPattern -> ControlPattern
randslice :: Pattern Int -> ControlPattern -> ControlPattern
-- | loopAt makes a sample fit the given number of cycles.
-- Internally, it works by setting the unit parameter to "c",
-- changing the playback speed of the sample with the speed
-- parameter, and setting setting the density of the pattern to
-- match.
--
--
-- d1 $ loopAt 4 $ sound "breaks125"
-- d1 $ juxBy 0.6 (|* speed "2") $ slowspread (loopAt) [4,6,2,3] $ chop 12 $ sound "fm:14"
--
loopAt :: Pattern Time -> ControlPattern -> ControlPattern
hurry :: Pattern Rational -> ControlPattern -> ControlPattern
-- | Smash is a combination of spread and striate - 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:
--
--
-- d1 $ smash 3 [2,3,4] $ sound "ho ho:2 ho:3 hc"
--
--
-- Is a bit like this:
--
--
-- d1 $ spread (slow) [2,3,4] $ striate 3 $ sound "ho ho:2 ho:3 hc"
--
--
-- This is quite dancehall:
--
--
-- 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"
--
smash :: Pattern Int -> [Pattern Time] -> ControlPattern -> Pattern ControlMap
-- | an altenative form to smash is smash' which will use
-- chop instead of striate.
smash' :: Int -> [Pattern Time] -> ControlPattern -> Pattern ControlMap
-- | Stut applies a type of delay to a pattern. It has three parameters,
-- which could be called depth, feedback and time. Depth is an integer
-- and the others floating point. This adds a bit of echo:
--
--
-- d1 $ stut 4 0.5 0.2 $ sound "bd sn"
--
--
-- 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:
--
--
-- d1 $ stut 4 0.5 (-0.2) $ sound "bd sn"
--
stut :: Pattern Integer -> Pattern Double -> Pattern Rational -> ControlPattern -> ControlPattern
_stut :: Integer -> Double -> Rational -> ControlPattern -> ControlPattern
-- | Instead of just decreasing volume to produce echoes, stut'
-- allows to apply a function for each step and overlays the result
-- delayed by the given time.
--
--
-- d1 $ stut' 2 (1%3) (# vowel "{a e i o u}%2") $ sound "bd sn"
--
--
-- In this case there are two _overlays_ delayed by 1/3 of a cycle, where
-- each has the vowel filter applied.
stutWith :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
_stutWith :: (Num n, Ord n) => n -> Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
-- | The old name for stutWith
stut' :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a
cI :: String -> Pattern Int
_cX :: (Arc -> Value -> [Event a]) -> [a] -> String -> Pattern a
_cF :: [Double] -> String -> Pattern Double
cF :: Double -> String -> Pattern Double
cF0 :: String -> Pattern Double
cF_ :: String -> Pattern Double
cT :: Time -> String -> Pattern Time
cT0 :: String -> Pattern Time
cT_ :: String -> Pattern Time
cR :: Time -> String -> Pattern Rational
cR0 :: String -> Pattern Time
cR_ :: String -> Pattern Time
_cS :: [String] -> String -> Pattern String
cS :: String -> String -> Pattern String
cS_ :: String -> Pattern String
_cP :: (Enumerable a, Parseable a) => [Pattern a] -> String -> Pattern a
cP :: (Enumerable a, Parseable a) => Pattern a -> String -> Pattern a
cP_ :: (Enumerable a, Parseable a) => String -> Pattern a
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
module Sound.Tidal.Transition
transition :: Show a => Stream -> (Time -> [ControlPattern] -> ControlPattern) -> a -> ControlPattern -> IO ()
-- | 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 wait, waitT stops for a bit and then applies the
-- given transition to the playing pattern
--
--
-- d1 $ sound "bd"
--
-- t1 (waitT (xfadeIn 8) 4) $ sound "hh*8"
--
waitT :: (Time -> [ControlPattern] -> ControlPattern) -> Time -> Time -> [ControlPattern] -> ControlPattern
-- | Jumps directly into the given pattern, this is essentially the _no
-- transition_-transition.
--
-- Variants of jump provide more useful capabilities, see
-- jumpIn and jumpMod
jump :: Time -> [ControlPattern] -> ControlPattern
-- | Sharp jump transition after the specified number of cycles have
-- passed.
--
--
-- t1 (jumpIn 2) $ sound "kick(3,8)"
--
jumpIn :: Int -> Time -> [ControlPattern] -> ControlPattern
-- | Unlike jumpIn the variant jumpIn' will only transition
-- at cycle boundary (e.g. when the cycle count is an integer).
jumpIn' :: Int -> Time -> [ControlPattern] -> ControlPattern
-- | Sharp jump transition at next cycle boundary where cycle mod n
-- == 0
jumpMod :: Int -> Time -> [ControlPattern] -> ControlPattern
-- | Degrade the new pattern over time until it ends in silence
mortal :: Time -> Time -> Time -> [ControlPattern] -> ControlPattern
interpolate :: Time -> [ControlPattern] -> ControlPattern
interpolateIn :: Time -> Time -> [ControlPattern] -> ControlPattern
-- | Degrades the current pattern while undegrading the next.
--
-- This is like xfade 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.
--
--
-- d1 $ sound "bd(3,8)"
--
-- t1 clutch $ sound "[hh*4, odx(3,8)]"
--
--
-- clutch takes two cycles for the transition, essentially this
-- is clutchIn 2.
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
-- clutchIn like so:
--
--
-- d1 $ sound "bd(5,8)"
--
-- t1 (clutchIn 8) $ sound "[hh*4, odx(3,8)]"
--
--
-- will take 8 cycles for the transition.
clutchIn :: Time -> Time -> [Pattern a] -> Pattern a
-- | same as anticipate though it allows you to specify the number
-- of cycles until dropping to the new pattern, e.g.:
--
--
-- d1 $ sound "jvbass(3,8)"
--
-- t1 (anticipateIn 4) $ sound "jvbass(5,8)"
--
anticipateIn :: Time -> Time -> [ControlPattern] -> ControlPattern
-- | anticipate is an increasing comb filter.
--
-- Build up some tension, culminating in a _drop_ to the new pattern
-- after 8 cycles.
anticipate :: Time -> [ControlPattern] -> ControlPattern
module Sound.Tidal.Simple
crunch :: ControlPattern -> ControlPattern
scratch :: ControlPattern -> ControlPattern
louder :: ControlPattern -> ControlPattern
quieter :: ControlPattern -> ControlPattern
silent :: ControlPattern -> ControlPattern
skip :: ControlPattern -> ControlPattern
left :: ControlPattern -> ControlPattern
right :: ControlPattern -> ControlPattern
higher :: ControlPattern -> ControlPattern
lower :: ControlPattern -> ControlPattern
faster :: ControlPattern -> ControlPattern
slower :: ControlPattern -> ControlPattern
module Sound.Tidal.Context
module Sound.Tidal.MiniTidal
miniTidal :: String -> Either ParseError (Pattern ControlMap)
miniTidalIO :: Stream -> String -> Either ParseError (IO ())
main :: IO ()
instance Sound.Tidal.MiniTidal.Pattern' Sound.Tidal.Pattern.ControlMap
instance Sound.Tidal.MiniTidal.Pattern' GHC.Types.Int
instance Sound.Tidal.MiniTidal.Pattern' GHC.Integer.Type.Integer
instance Sound.Tidal.MiniTidal.Pattern' GHC.Types.Double
instance Sound.Tidal.MiniTidal.Pattern' Sound.Tidal.Pattern.Time
instance Sound.Tidal.MiniTidal.Pattern' Sound.Tidal.Pattern.Arc
instance Sound.Tidal.MiniTidal.Pattern' GHC.Base.String