diff --git a/docs/library/autogenerated/Sound-Tidal-Bjorklund/Sound-Tidal-Bjorklund.mdx b/docs/library/autogenerated/Sound-Tidal-Bjorklund/Sound-Tidal-Bjorklund.mdx new file mode 100644 index 0000000000..134262743e --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Bjorklund/Sound-Tidal-Bjorklund.mdx @@ -0,0 +1,20 @@ +--- +title: Sound.Tidal.Bjorklund +slug: /library/modules/Sound.Tidal.Bjorklund +--- + + + +### bjorklund +``` +bjorklund :: (Int, Int) -> [Bool] +``` + diff --git a/docs/library/autogenerated/Sound-Tidal-Chords/Sound-Tidal-Chords.mdx b/docs/library/autogenerated/Sound-Tidal-Chords/Sound-Tidal-Chords.mdx new file mode 100644 index 0000000000..7c6820f942 --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Chords/Sound-Tidal-Chords.mdx @@ -0,0 +1,319 @@ +--- +title: Sound.Tidal.Chords +slug: /library/modules/Sound.Tidal.Chords +--- + + + +### major +``` +major :: Num a => [a] +``` + +### aug +``` +aug :: Num a => [a] +``` + +### six +``` +six :: Num a => [a] +``` + +### sixNine +``` +sixNine :: Num a => [a] +``` + +### major7 +``` +major7 :: Num a => [a] +``` + +### major9 +``` +major9 :: Num a => [a] +``` + +### add9 +``` +add9 :: Num a => [a] +``` + +### major11 +``` +major11 :: Num a => [a] +``` + +### add11 +``` +add11 :: Num a => [a] +``` + +### major13 +``` +major13 :: Num a => [a] +``` + +### add13 +``` +add13 :: Num a => [a] +``` + +### dom7 +``` +dom7 :: Num a => [a] +``` + +### dom9 +``` +dom9 :: Num a => [a] +``` + +### dom11 +``` +dom11 :: Num a => [a] +``` + +### dom13 +``` +dom13 :: Num a => [a] +``` + +### sevenFlat5 +``` +sevenFlat5 :: Num a => [a] +``` + +### sevenSharp5 +``` +sevenSharp5 :: Num a => [a] +``` + +### sevenFlat9 +``` +sevenFlat9 :: Num a => [a] +``` + +### nine +``` +nine :: Num a => [a] +``` + +### eleven +``` +eleven :: Num a => [a] +``` + +### thirteen +``` +thirteen :: Num a => [a] +``` + +### minor +``` +minor :: Num a => [a] +``` + +### diminished +``` +diminished :: Num a => [a] +``` + +### minorSharp5 +``` +minorSharp5 :: Num a => [a] +``` + +### minor6 +``` +minor6 :: Num a => [a] +``` + +### minorSixNine +``` +minorSixNine :: Num a => [a] +``` + +### minor7flat5 +``` +minor7flat5 :: Num a => [a] +``` + +### minor7 +``` +minor7 :: Num a => [a] +``` + +### minor7sharp5 +``` +minor7sharp5 :: Num a => [a] +``` + +### minor7flat9 +``` +minor7flat9 :: Num a => [a] +``` + +### minor7sharp9 +``` +minor7sharp9 :: Num a => [a] +``` + +### diminished7 +``` +diminished7 :: Num a => [a] +``` + +### minor9 +``` +minor9 :: Num a => [a] +``` + +### minor11 +``` +minor11 :: Num a => [a] +``` + +### minor13 +``` +minor13 :: Num a => [a] +``` + +### one +``` +one :: Num a => [a] +``` + +### five +``` +five :: Num a => [a] +``` + +### sus2 +``` +sus2 :: Num a => [a] +``` + +### sus4 +``` +sus4 :: Num a => [a] +``` + +### sevenSus2 +``` +sevenSus2 :: Num a => [a] +``` + +### sevenSus4 +``` +sevenSus4 :: Num a => [a] +``` + +### nineSus4 +``` +nineSus4 :: Num a => [a] +``` + +### sevenFlat10 +``` +sevenFlat10 :: Num a => [a] +``` + +### nineSharp5 +``` +nineSharp5 :: Num a => [a] +``` + +### minor9sharp5 +``` +minor9sharp5 :: Num a => [a] +``` + +### sevenSharp5flat9 +``` +sevenSharp5flat9 :: Num a => [a] +``` + +### minor7sharp5flat9 +``` +minor7sharp5flat9 :: Num a => [a] +``` + +### elevenSharp +``` +elevenSharp :: Num a => [a] +``` + +### minor11sharp +``` +minor11sharp :: Num a => [a] +``` + +### chordTable +``` +chordTable :: Num a => [(String, [a])] +``` + +`chordate cs m n` selects the `n`th "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 + +### chordL +``` +chordL :: Num a => Pattern String -> Pattern [a] +``` + +### chordList +``` +chordList :: String +``` + +### data +``` +data Modifier +``` + +### applyModifier +``` +applyModifier :: (Enum a, Num a) => Modifier -> [a] -> [a] +``` + +### applyModifierPat +``` +applyModifierPat :: (Num a, Enum a) => Pattern [a] -> Pattern [Modifier] -> Pattern [a] +``` + +### applyModifierPatSeq +``` +applyModifierPatSeq :: (Num a, Enum a) => (a -> b) -> Pattern [a] -> [Pattern [Modifier]] -> Pattern [b] +``` + +### chordToPatSeq +``` +chordToPatSeq :: (Num a, Enum a) => (a -> b) -> Pattern a -> Pattern String -> [Pattern [Modifier]] -> Pattern b +``` + +### chord +``` +chord :: (Num a, Enum a) => Pattern a -> Pattern String -> [Pattern [Modifier]] -> Pattern a +``` + +turns a given pattern of some Num type, a pattern of chord names and a list of patterns of modifiers into a chord pattern + diff --git a/docs/library/autogenerated/Sound-Tidal-Config/Sound-Tidal-Config.mdx b/docs/library/autogenerated/Sound-Tidal-Config/Sound-Tidal-Config.mdx new file mode 100644 index 0000000000..6f66e1023a --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Config/Sound-Tidal-Config.mdx @@ -0,0 +1,25 @@ +--- +title: Sound.Tidal.Config +slug: /library/modules/Sound.Tidal.Config +--- + + + +### data +``` +data Config +``` + +### defaultConfig +``` +defaultConfig :: Config +``` + diff --git a/docs/library/autogenerated/Sound-Tidal-Context/Sound-Tidal-Context.mdx b/docs/library/autogenerated/Sound-Tidal-Context/Sound-Tidal-Context.mdx new file mode 100644 index 0000000000..f3662ac3aa --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Context/Sound-Tidal-Context.mdx @@ -0,0 +1,85 @@ +--- +title: Sound.Tidal.Context +slug: /library/modules/Sound.Tidal.Context +--- + + + +### module +``` +module Sound.Tidal.Version +``` + +### module +``` +module Sound.Tidal.UI +``` + +### module +``` +module Sound.Tidal.Transition +``` + +### module +``` +module Sound.Tidal.Stream +``` + +### module +``` +module Sound.Tidal.Simple +``` + +### module +``` +module Sound.Tidal.Show +``` + +### module +``` +module Sound.Tidal.Scales +``` + +### module +``` +module Sound.Tidal.Pattern +``` + +### module +``` +module Sound.Tidal.ParseBP +``` + +### module +``` +module Sound.Tidal.Params +``` + +### module +``` +module Sound.Tidal.Core +``` + +### module +``` +module Sound.Tidal.Control +``` + +### module +``` +module Sound.Tidal.Config +``` + +### module +``` +module Data.Ratio +``` + diff --git a/docs/library/autogenerated/Sound-Tidal-Control/Sound-Tidal-Control.mdx b/docs/library/autogenerated/Sound-Tidal-Control/Sound-Tidal-Control.mdx new file mode 100644 index 0000000000..469011658e --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Control/Sound-Tidal-Control.mdx @@ -0,0 +1,441 @@ +--- +title: Sound.Tidal.Control +slug: /library/modules/Sound.Tidal.Control +--- + + + +### spin +``` +spin :: Pattern Int -> ControlPattern -> ControlPattern +``` + +`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. + +```haskell +d1 $ slow 3 $ spin 4 $ sound "drum*3 tabla:4 [arpy:2 ~ arpy] [can:2 can:3]" +``` +### _spin +``` +_spin :: Int -> ControlPattern -> ControlPattern +``` + +### chop +``` +chop :: Pattern 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: + +```haskell +d1 $ chop 16 $ sound "arpy arp feel*4 arpy*4" +``` +Different values of `chop` can yield very different results, depending +on the samples used: + +```haskell +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]" +``` +### chopArc +``` +chopArc :: Arc -> Int -> [Arc] +``` + +### _chop +``` +_chop :: Int -> ControlPattern -> ControlPattern +``` + +### striate +``` +striate :: Pattern Int -> ControlPattern -> ControlPattern +``` + +Striate is a kind of granulator, for example: + +```haskell +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. + +```haskell +d1 $ slow 8 $ striate 128 $ sound "bev" +``` +### _striate +``` +_striate :: Int -> ControlPattern -> ControlPattern +``` + +### mergePlayRange +``` +mergePlayRange :: (Double, Double) -> ValueMap -> ValueMap +``` + +### striateBy +``` +striateBy :: Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern +``` + +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: + +```haskell +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`. + +### striate' +``` +striate' :: Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern +``` + +DEPRECATED, use `striateBy` instead. + +### _striateBy +``` +_striateBy :: Int -> Double -> ControlPattern -> ControlPattern +``` + +### gap +``` +gap :: Pattern Int -> 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: + +```haskell +d1 $ gap 8 $ sound "jvbass" +d1 $ gap 16 $ sound "[jvbass drum:4]" +``` +### _gap +``` +_gap :: Int -> ControlPattern -> ControlPattern +``` + +### weave +``` +weave :: Time -> ControlPattern -> [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. + +```haskell +d1 $ weave 3 (shape $ sine1) [sound "bd [sn drum:2*2] bd*2 [sn drum:1]", sound "arpy*8 ~"] +``` +### weaveWith +``` +weaveWith :: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a +``` + +`weaveWith` is similar in that it blends functions at the same time at different amounts over a pattern: + +```haskell +d1 $ weaveWith 3 (sound "bd [sn drum:2*2] bd*2 [sn drum:1]") [density 2, (# speed "0.5"), chop 16] +``` +### weave' +``` +weave' :: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a +``` + +### interlace +``` +interlace :: ControlPattern -> ControlPattern -> ControlPattern +``` + +(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: + +```haskell +d1 $ interlace (sound "bd sn kurt") (every 3 rev $ sound "bd sn:2") +``` +### slice +``` +slice :: Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern +``` + +### _slice +``` +_slice :: Int -> Int -> ControlPattern -> ControlPattern +``` + +### randslice +``` +randslice :: Pattern Int -> ControlPattern -> ControlPattern +``` + +### _splice +``` +_splice :: Int -> Pattern Int -> ControlPattern -> Pattern (Map String Value) +``` + +### splice +``` +splice :: Pattern Int -> Pattern Int -> ControlPattern -> Pattern (Map String Value) +``` + +### loopAt +``` +loopAt :: Pattern Time -> 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. + +```haskell +d1 $ loopAt 4 $ sound "breaks125" +d1 $ juxBy 0.6 (|* speed "2") $ slowspread (loopAt) [4,6,2,3] $ chop 12 $ sound "fm:14" +``` +### hurry +``` +hurry :: Pattern Rational -> ControlPattern -> ControlPattern +``` + +### smash +``` +smash :: Pattern Int -> [Pattern Time] -> ControlPattern -> Pattern ValueMap +``` + +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: + +```haskell +d1 $ smash 3 [2,3,4] $ sound "ho ho:2 ho:3 hc" +``` +Is a bit like this: + +```haskell +d1 $ spread (slow) [2,3,4] $ striate 3 $ sound "ho ho:2 ho:3 hc" +``` +This is quite dancehall: + +```haskell +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' +``` +smash' :: Int -> [Pattern Time] -> ControlPattern -> ControlPattern +``` + +an altenative form to `smash` is `smash'` which will use `chop` instead of `striate`. + +### echo +``` +echo :: Pattern Integer -> Pattern Rational -> Pattern Double -> ControlPattern -> ControlPattern +``` + +Applies a type of delay to a pattern. + It has three parameters, which could be called depth, time and feedback. + +This adds a bit of echo: + ` + d1 $ echo 4 0.2 0.5 $ 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 $ echo 4 (-0.2) 0.5 $ sound "bd sn" + ` + +### _echo +``` +_echo :: Integer -> Rational -> Double -> ControlPattern -> ControlPattern +``` + +### echoWith +``` +echoWith :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +Allows to apply a function for each step and overlays the result delayed by the given time. + +```haskell + d1 $ echoWith 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. + +### _echoWith +``` +_echoWith :: (Num n, Ord n) => n -> Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### stut +``` +stut :: Pattern Integer -> Pattern Double -> Pattern Rational -> ControlPattern -> ControlPattern +``` + +DEPRECATED, use `echo` instead + +### _stut +``` +_stut :: Integer -> Double -> Rational -> ControlPattern -> ControlPattern +``` + +### stutWith +``` +stutWith :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +DEPRECATED, use `echoWith` instead + +### _stutWith +``` +_stutWith :: (Num n, Ord n) => n -> Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### stut' +``` +stut' :: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +DEPRECATED, use `echoWith` instead + +### sec +``` +sec :: Fractional a => Pattern a -> Pattern a +``` + +Turns a pattern of seconds into a pattern of (rational) cycle durations + +### msec +``` +msec :: Fractional a => Pattern a -> Pattern a +``` + +Turns a pattern of milliseconds into a pattern of (rational) + cycle durations, according to the current cps. + +### trigger +``` +trigger :: Pattern a -> Pattern a +``` + +Align the start of a pattern with the time a pattern is evaluated, + rather than the global start time. Because of this, the pattern will + probably not be aligned to the pattern grid. + +### qtrigger +``` +qtrigger :: Pattern a -> Pattern a +``` + +(Alias `qt`) Quantise trigger. Aligns the start of the pattern + with the next cycle boundary. For example, this pattern will fade in + starting with the next cycle after the pattern is evaluated: + +```haskell +d1 $ qtrigger $ s "hh(5, 8)" # amp envL +``` +Note that the pattern will start playing immediately. The start of the + pattern aligns with the next cycle boundary, but events will play before + if the pattern has events at negative timestamps (which most loops do). + These events can be filtered out, for example: + +```haskell +d1 $ qtrigger $ filterWhen (>= 0) $ s "hh(5, 8)" +``` +### qt +``` +qt :: Pattern a -> Pattern a +``` + +### ctrigger +``` +ctrigger :: Pattern a -> Pattern a +``` + +Ceiling trigger. Aligns the start of a pattern to the next cycle + boundary, just like `qtrigger`. + +### rtrigger +``` +rtrigger :: Pattern a -> Pattern a +``` + +Rounded trigger. Aligns the start of a pattern to the nearest cycle + boundary, either next or previous. + +### ftrigger +``` +ftrigger :: Pattern a -> Pattern a +``` + +Floor trigger. Aligns the start of a pattern to the previous cycle + boundary. + +### mtrigger +``` +mtrigger :: Int -> Pattern a -> Pattern a +``` + +(Alias `mt`) Mod trigger. Aligns the start of a pattern to the + next cycle boundary where the cycle is evenly divisible by a given + number. `qtrigger` is equivalent to `mtrigger 1`. + +### mt +``` +mt :: Int -> Pattern a -> Pattern a +``` + +### triggerWith +``` +triggerWith :: (Time -> Time) -> Pattern a -> Pattern a +``` + +This aligns the start of a pattern to some value relative to the + time the pattern is evaluated. The provided function maps the evaluation + time (on the global cycle clock) to a new time, and then `triggerWith` + aligns the pattern's start to the time that's returned. + +### splat +``` +splat :: Pattern Int -> ControlPattern -> ControlPattern -> ControlPattern +``` + diff --git a/docs/library/autogenerated/Sound-Tidal-Core/Sound-Tidal-Core.mdx b/docs/library/autogenerated/Sound-Tidal-Core/Sound-Tidal-Core.mdx new file mode 100644 index 0000000000..9f29d7efaf --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Core/Sound-Tidal-Core.mdx @@ -0,0 +1,1421 @@ +--- +title: Sound.Tidal.Core +slug: /library/modules/Sound.Tidal.Core +--- + + + +## Elemental patterns +### sig +``` +sig :: (Time -> a) -> Pattern a +``` + +Takes a function from time to values, and turns it into a `Pattern`. + +### sine +``` +sine :: Fractional a => Pattern a +``` + +`sine` - unipolar sinewave. A pattern of continuous values following a + sinewave with frequency of one cycle, and amplitude from 0 to 1. + +### sine2 +``` +sine2 :: Fractional a => Pattern a +``` + +`sine2` - bipolar sinewave. A pattern of continuous values following a + sinewave with frequency of one cycle, and amplitude from -1 to 1. + +### cosine +``` +cosine :: Fractional a => Pattern a +``` + +`cosine` - unipolar cosine wave. A pattern of continuous values + following a cosine with frequency of one cycle, and amplitude from + 0 to 1. Equivalent to `0.25 ~> sine`. + +### cosine2 +``` +cosine2 :: Fractional a => Pattern a +``` + +`cosine2` - bipolar cosine wave. A pattern of continuous values + following a cosine with frequency of one cycle, and amplitude from + -1 to 1. Equivalent to `0.25 ~> sine2`. + +### saw +``` +saw :: (Fractional a, Real a) => Pattern a +``` + +`saw` - unipolar ascending sawtooth wave. A pattern of continuous values + following a sawtooth with frequency of one cycle, and amplitude from + 0 to 1. + +### saw2 +``` +saw2 :: (Fractional a, Real a) => Pattern a +``` + +`saw2` - bipolar ascending sawtooth wave. A pattern of continuous values + following a sawtooth with frequency of one cycle, and amplitude from + -1 to 1. + +### isaw +``` +isaw :: (Fractional a, Real a) => Pattern a +``` + +`isaw` like `saw`, but a descending (inverse) sawtooth. + +### isaw2 +``` +isaw2 :: (Fractional a, Real a) => Pattern a +``` + +`isaw2` like `saw2`, but a descending (inverse) sawtooth. + +### tri +``` +tri :: (Fractional a, Real a) => Pattern a +``` + +`tri` - unipolar triangle wave. A pattern of continuous values + following a triangle wave with frequency of one cycle, and amplitude from + 0 to 1. + +### tri2 +``` +tri2 :: (Fractional a, Real a) => Pattern a +``` + +`tri2` - bipolar triangle wave. A pattern of continuous values + following a triangle wave with frequency of one cycle, and amplitude from + -1 to 1. + +### square +``` +square :: Fractional a => Pattern a +``` + +`square` - unipolar square wave. A pattern of continuous values + following a square wave with frequency of one cycle, and amplitude from + 0 to 1. + | `square` is like `sine`, for square waves. + +### square2 +``` +square2 :: Fractional a => Pattern a +``` + +`square2` - bipolar square wave. A pattern of continuous values + following a square wave with frequency of one cycle, and amplitude from + -1 to 1. + +### envL +``` +envL :: Pattern Double +``` + +`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. + +### envLR +``` +envLR :: Pattern Double +``` + +like `envL` but reversed. + +### envEq +``` +envEq :: Pattern Double +``` + +'Equal power' version of `env`, for gain-based transitions + +### envEqR +``` +envEqR :: Pattern Double +``` + +Equal power reversed + +## Pattern algebra +### class +``` +class Unionable a where +``` + +### (|+|) +``` +(|+|) :: (Applicative a, Num b) => a b -> a b -> a b +``` + +### (|+) +``` +(|+) :: Num a => Pattern a -> Pattern a -> Pattern a +``` + +### (+|) +``` +(+|) :: Num a => Pattern a -> Pattern a -> Pattern a +``` + +### (||+) +``` +(||+) :: Num a => Pattern a -> Pattern a -> Pattern a +``` + +### (|++|) +``` +(|++|) :: Applicative a => a String -> a String -> a String +``` + +### (|++) +``` +(|++) :: Pattern String -> Pattern String -> Pattern String +``` + +### (++|) +``` +(++|) :: Pattern String -> Pattern String -> Pattern String +``` + +### (||++) +``` +(||++) :: Pattern String -> Pattern String -> Pattern String +``` + +### (|/|) +``` +(|/|) :: (Applicative a, Fractional b) => a b -> a b -> a b +``` + +### (|/) +``` +(|/) :: Fractional a => Pattern a -> Pattern a -> Pattern a +``` + +### (/|) +``` +(/|) :: Fractional a => Pattern a -> Pattern a -> Pattern a +``` + +### (||/) +``` +(||/) :: Fractional a => Pattern a -> Pattern a -> Pattern a +``` + +### (|*|) +``` +(|*|) :: (Applicative a, Num b) => a b -> a b -> a b +``` + +### (|*) +``` +(|*) :: Num a => Pattern a -> Pattern a -> Pattern a +``` + +### (*|) +``` +(*|) :: Num a => Pattern a -> Pattern a -> Pattern a +``` + +### (||*) +``` +(||*) :: Num a => Pattern a -> Pattern a -> Pattern a +``` + +### (|-|) +``` +(|-|) :: (Applicative a, Num b) => a b -> a b -> a b +``` + +### (|-) +``` +(|-) :: Num a => Pattern a -> Pattern a -> Pattern a +``` + +### (-|) +``` +(-|) :: Num a => Pattern a -> Pattern a -> Pattern a +``` + +### (||-) +``` +(||-) :: Num a => Pattern a -> Pattern a -> Pattern a +``` + +### (|%|) +``` +(|%|) :: (Applicative a, Moddable b) => a b -> a b -> a b +``` + +### (|%) +``` +(|%) :: Moddable a => Pattern a -> Pattern a -> Pattern a +``` + +### (%|) +``` +(%|) :: Moddable a => Pattern a -> Pattern a -> Pattern a +``` + +### (||%) +``` +(||%) :: Moddable a => Pattern a -> Pattern a -> Pattern a +``` + +### (|**|) +``` +(|**|) :: (Applicative a, Floating b) => a b -> a b -> a b +``` + +### (|**) +``` +(|**) :: Floating a => Pattern a -> Pattern a -> Pattern a +``` + +### (**|) +``` +(**|) :: Floating a => Pattern a -> Pattern a -> Pattern a +``` + +### (||**) +``` +(||**) :: Floating a => Pattern a -> Pattern a -> Pattern a +``` + +### (|>|) +``` +(|>|) :: (Applicative a, Unionable b) => a b -> a b -> a b +``` + +### (|>) +``` +(|>) :: Unionable a => Pattern a -> Pattern a -> Pattern a +``` + +### (>|) +``` +(>|) :: Unionable a => Pattern a -> Pattern a -> Pattern a +``` + +### (||>) +``` +(||>) :: Unionable a => Pattern a -> Pattern a -> Pattern a +``` + +### (|<|) +``` +(|<|) :: (Applicative a, Unionable b) => a b -> a b -> a b +``` + +### (|<) +``` +(|<) :: Unionable a => Pattern a -> Pattern a -> Pattern a +``` + +### (<|) +``` +(<|) :: Unionable a => Pattern a -> Pattern a -> Pattern a +``` + +### (||<) +``` +(||<) :: Unionable a => Pattern a -> Pattern a -> Pattern a +``` + +### (#) +``` +(#) :: Unionable b => Pattern b -> Pattern b -> Pattern b +``` + +## Constructing patterns +### fromList +``` +fromList :: [a] -> Pattern a +``` + +Turns a list of values into a pattern, playing one of them per cycle. + +### fastFromList +``` +fastFromList :: [a] -> Pattern a +``` + +Turns a list of values into a pattern, playing all of them per cycle. + +### listToPat +``` +listToPat :: [a] -> Pattern a +``` + +A synonym for `fastFromList` + +### fromMaybes +``` +fromMaybes :: [Maybe 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. + +### run +``` +run :: (Enum a, Num a) => Pattern a -> Pattern a +``` + +A pattern of whole numbers from 0 to the given number, in a single cycle. + +### _run +``` +_run :: (Enum a, Num a) => a -> Pattern a +``` + +### scan +``` +scan :: (Enum a, Num a) => Pattern a -> Pattern a +``` + +From `1` for the first cycle, successively adds a number until it gets up to `n` + +### _scan +``` +_scan :: (Enum a, Num a) => a -> Pattern a +``` + +## Combining patterns +### append +``` +append :: Pattern a -> Pattern a -> Pattern a +``` + +Alternate between cycles of the two given patterns + +### cat +``` +cat :: [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. + +### slowCat +``` +slowCat :: [Pattern a] -> Pattern a +``` + +Alias for `cat` + +### slowcat +``` +slowcat :: [Pattern a] -> Pattern a +``` + +### slowAppend +``` +slowAppend :: Pattern a -> Pattern a -> Pattern a +``` + +Alias for `append` + +### slowappend +``` +slowappend :: Pattern a -> Pattern a -> Pattern a +``` + +### fastAppend +``` +fastAppend :: Pattern a -> Pattern a -> Pattern a +``` + +Like `append`, but twice as fast + +### fastappend +``` +fastappend :: Pattern a -> Pattern a -> Pattern a +``` + +### fastCat +``` +fastCat :: [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 +``` +fastcat :: [Pattern a] -> Pattern a +``` + +Alias for `fastCat` + +### timeCat +``` +timeCat :: [(Time, Pattern a)] -> Pattern a +``` + +Similar to `fastCat`, but each pattern is given a relative duration + +### timecat +``` +timecat :: [(Time, Pattern a)] -> Pattern a +``` + +Alias for `timeCat` + +### overlay +``` +overlay :: Pattern a -> Pattern a -> Pattern a +``` + +`overlay` combines two `Pattern`s into a new pattern, so that + their events are combined over time. + +### stack +``` +stack :: [Pattern a] -> Pattern a +``` + +`stack` combines a list of `Pattern`s into a new pattern, so that + their events are combined over time. + +## Manipulating time +### (<~) +``` +(<~) :: Pattern Time -> 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 + +### slowSqueeze +``` +slowSqueeze :: 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 + +### sparsity +``` +sparsity :: Pattern Time -> Pattern a -> Pattern a +``` + +An alias for `slow` + +### zoom +``` +zoom :: (Time, Time) -> Pattern a -> Pattern a +``` + +Plays a portion of a pattern, specified by a time arc (start and end time). +The new resulting pattern is played over the time period of the original pattern: + +```haskell +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: + +```haskell +d1 $ sound "hh*3 [sn bd]*2" +``` +### zoomArc +``` +zoomArc :: Arc -> Pattern a -> Pattern a +``` + +### fastGap +``` +fastGap :: Pattern Time -> 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 + +### densityGap +``` +densityGap :: Pattern Time -> Pattern a -> Pattern a +``` + +An alias for `fastGap` + +### compress +``` +compress :: (Time, Time) -> Pattern a -> Pattern a +``` + +### compressTo +``` +compressTo :: (Time, Time) -> Pattern a -> Pattern a +``` + +### repeatCycles +``` +repeatCycles :: Pattern Int -> Pattern a -> Pattern a +``` + +### _repeatCycles +``` +_repeatCycles :: Int -> Pattern a -> Pattern a +``` + +### fastRepeatCycles +``` +fastRepeatCycles :: Int -> Pattern a -> Pattern a +``` + +### every +``` +every :: Pattern Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +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 +``` +_every :: Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### every' +``` +every' :: Pattern Int -> Pattern 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' +``` +_every' :: Int -> Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### foldEvery +``` +foldEvery :: [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`. + +### when +``` +when :: (Int -> Bool) -> (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. + +```haskell +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. + +### whenT +``` +whenT :: (Time -> Bool) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +Like `when`, but works on continuous time values rather than cycle numbers. + +### _getP_ +``` +_getP_ :: (Value -> Maybe a) -> Pattern Value -> Pattern a +``` + +### _getP +``` +_getP :: a -> (Value -> Maybe a) -> Pattern Value -> Pattern a +``` + +### _cX +``` +_cX :: a -> (Value -> Maybe a) -> String -> Pattern a +``` + +### _cX_ +``` +_cX_ :: (Value -> Maybe a) -> String -> Pattern a +``` + +### cF +``` +cF :: Double -> String -> Pattern Double +``` + +### cF_ +``` +cF_ :: String -> Pattern Double +``` + +### cF0 +``` +cF0 :: String -> Pattern Double +``` + +### cN +``` +cN :: Note -> String -> Pattern Note +``` + +### cN_ +``` +cN_ :: String -> Pattern Note +``` + +### cN0 +``` +cN0 :: String -> Pattern Note +``` + +### cI +``` +cI :: Int -> String -> Pattern Int +``` + +### cI_ +``` +cI_ :: String -> Pattern Int +``` + +### cI0 +``` +cI0 :: String -> Pattern Int +``` + +### cB +``` +cB :: Bool -> String -> Pattern Bool +``` + +### cB_ +``` +cB_ :: String -> Pattern Bool +``` + +### cB0 +``` +cB0 :: String -> Pattern Bool +``` + +### cR +``` +cR :: Rational -> String -> Pattern Rational +``` + +### cR_ +``` +cR_ :: String -> Pattern Rational +``` + +### cR0 +``` +cR0 :: String -> Pattern Rational +``` + +### cT +``` +cT :: Time -> String -> Pattern Time +``` + +### cT0 +``` +cT0 :: String -> Pattern Time +``` + +### cT_ +``` +cT_ :: String -> Pattern Time +``` + +### cS +``` +cS :: String -> String -> Pattern String +``` + +### cS_ +``` +cS_ :: String -> Pattern String +``` + +### cS0 +``` +cS0 :: String -> Pattern String +``` + +### in0 +``` +in0 :: Pattern Double +``` + +### in1 +``` +in1 :: Pattern Double +``` + +### in2 +``` +in2 :: Pattern Double +``` + +### in3 +``` +in3 :: Pattern Double +``` + +### in4 +``` +in4 :: Pattern Double +``` + +### in5 +``` +in5 :: Pattern Double +``` + +### in6 +``` +in6 :: Pattern Double +``` + +### in7 +``` +in7 :: Pattern Double +``` + +### in8 +``` +in8 :: Pattern Double +``` + +### in9 +``` +in9 :: Pattern Double +``` + +### in10 +``` +in10 :: Pattern Double +``` + +### in11 +``` +in11 :: Pattern Double +``` + +### in12 +``` +in12 :: Pattern Double +``` + +### in13 +``` +in13 :: Pattern Double +``` + +### in14 +``` +in14 :: Pattern Double +``` + +### in15 +``` +in15 :: Pattern Double +``` + +### in16 +``` +in16 :: Pattern Double +``` + +### in17 +``` +in17 :: Pattern Double +``` + +### in18 +``` +in18 :: Pattern Double +``` + +### in19 +``` +in19 :: Pattern Double +``` + +### in20 +``` +in20 :: Pattern Double +``` + +### in21 +``` +in21 :: Pattern Double +``` + +### in22 +``` +in22 :: Pattern Double +``` + +### in23 +``` +in23 :: Pattern Double +``` + +### in24 +``` +in24 :: Pattern Double +``` + +### in25 +``` +in25 :: Pattern Double +``` + +### in26 +``` +in26 :: Pattern Double +``` + +### in27 +``` +in27 :: Pattern Double +``` + +### in28 +``` +in28 :: Pattern Double +``` + +### in29 +``` +in29 :: Pattern Double +``` + +### in30 +``` +in30 :: Pattern Double +``` + +### in31 +``` +in31 :: Pattern Double +``` + +### in32 +``` +in32 :: Pattern Double +``` + +### in33 +``` +in33 :: Pattern Double +``` + +### in34 +``` +in34 :: Pattern Double +``` + +### in35 +``` +in35 :: Pattern Double +``` + +### in36 +``` +in36 :: Pattern Double +``` + +### in37 +``` +in37 :: Pattern Double +``` + +### in38 +``` +in38 :: Pattern Double +``` + +### in39 +``` +in39 :: Pattern Double +``` + +### in40 +``` +in40 :: Pattern Double +``` + +### in41 +``` +in41 :: Pattern Double +``` + +### in42 +``` +in42 :: Pattern Double +``` + +### in43 +``` +in43 :: Pattern Double +``` + +### in44 +``` +in44 :: Pattern Double +``` + +### in45 +``` +in45 :: Pattern Double +``` + +### in46 +``` +in46 :: Pattern Double +``` + +### in47 +``` +in47 :: Pattern Double +``` + +### in48 +``` +in48 :: Pattern Double +``` + +### in49 +``` +in49 :: Pattern Double +``` + +### in50 +``` +in50 :: Pattern Double +``` + +### in51 +``` +in51 :: Pattern Double +``` + +### in52 +``` +in52 :: Pattern Double +``` + +### in53 +``` +in53 :: Pattern Double +``` + +### in54 +``` +in54 :: Pattern Double +``` + +### in55 +``` +in55 :: Pattern Double +``` + +### in56 +``` +in56 :: Pattern Double +``` + +### in57 +``` +in57 :: Pattern Double +``` + +### in58 +``` +in58 :: Pattern Double +``` + +### in59 +``` +in59 :: Pattern Double +``` + +### in60 +``` +in60 :: Pattern Double +``` + +### in61 +``` +in61 :: Pattern Double +``` + +### in62 +``` +in62 :: Pattern Double +``` + +### in63 +``` +in63 :: Pattern Double +``` + +### in64 +``` +in64 :: Pattern Double +``` + +### in65 +``` +in65 :: Pattern Double +``` + +### in66 +``` +in66 :: Pattern Double +``` + +### in67 +``` +in67 :: Pattern Double +``` + +### in68 +``` +in68 :: Pattern Double +``` + +### in69 +``` +in69 :: Pattern Double +``` + +### in70 +``` +in70 :: Pattern Double +``` + +### in71 +``` +in71 :: Pattern Double +``` + +### in72 +``` +in72 :: Pattern Double +``` + +### in73 +``` +in73 :: Pattern Double +``` + +### in74 +``` +in74 :: Pattern Double +``` + +### in75 +``` +in75 :: Pattern Double +``` + +### in76 +``` +in76 :: Pattern Double +``` + +### in77 +``` +in77 :: Pattern Double +``` + +### in78 +``` +in78 :: Pattern Double +``` + +### in79 +``` +in79 :: Pattern Double +``` + +### in80 +``` +in80 :: Pattern Double +``` + +### in81 +``` +in81 :: Pattern Double +``` + +### in82 +``` +in82 :: Pattern Double +``` + +### in83 +``` +in83 :: Pattern Double +``` + +### in84 +``` +in84 :: Pattern Double +``` + +### in85 +``` +in85 :: Pattern Double +``` + +### in86 +``` +in86 :: Pattern Double +``` + +### in87 +``` +in87 :: Pattern Double +``` + +### in88 +``` +in88 :: Pattern Double +``` + +### in89 +``` +in89 :: Pattern Double +``` + +### in90 +``` +in90 :: Pattern Double +``` + +### in91 +``` +in91 :: Pattern Double +``` + +### in92 +``` +in92 :: Pattern Double +``` + +### in93 +``` +in93 :: Pattern Double +``` + +### in94 +``` +in94 :: Pattern Double +``` + +### in95 +``` +in95 :: Pattern Double +``` + +### in96 +``` +in96 :: Pattern Double +``` + +### in97 +``` +in97 :: Pattern Double +``` + +### in98 +``` +in98 :: Pattern Double +``` + +### in99 +``` +in99 :: Pattern Double +``` + +### in100 +``` +in100 :: Pattern Double +``` + +### in101 +``` +in101 :: Pattern Double +``` + +### in102 +``` +in102 :: Pattern Double +``` + +### in103 +``` +in103 :: Pattern Double +``` + +### in104 +``` +in104 :: Pattern Double +``` + +### in105 +``` +in105 :: Pattern Double +``` + +### in106 +``` +in106 :: Pattern Double +``` + +### in107 +``` +in107 :: Pattern Double +``` + +### in108 +``` +in108 :: Pattern Double +``` + +### in109 +``` +in109 :: Pattern Double +``` + +### in110 +``` +in110 :: Pattern Double +``` + +### in111 +``` +in111 :: Pattern Double +``` + +### in112 +``` +in112 :: Pattern Double +``` + +### in113 +``` +in113 :: Pattern Double +``` + +### in114 +``` +in114 :: Pattern Double +``` + +### in115 +``` +in115 :: Pattern Double +``` + +### in116 +``` +in116 :: Pattern Double +``` + +### in117 +``` +in117 :: Pattern Double +``` + +### in118 +``` +in118 :: Pattern Double +``` + +### in119 +``` +in119 :: Pattern Double +``` + +### in120 +``` +in120 :: Pattern Double +``` + +### in121 +``` +in121 :: Pattern Double +``` + +### in122 +``` +in122 :: Pattern Double +``` + +### in123 +``` +in123 :: Pattern Double +``` + +### in124 +``` +in124 :: Pattern Double +``` + +### in125 +``` +in125 :: Pattern Double +``` + +### in126 +``` +in126 :: Pattern Double +``` + +### in127 +``` +in127 :: Pattern Double +``` + diff --git a/docs/library/autogenerated/Sound-Tidal-ID/Sound-Tidal-ID.mdx b/docs/library/autogenerated/Sound-Tidal-ID/Sound-Tidal-ID.mdx new file mode 100644 index 0000000000..e4aad77f7b --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-ID/Sound-Tidal-ID.mdx @@ -0,0 +1,24 @@ +--- +title: Sound.Tidal.ID +slug: /library/modules/Sound.Tidal.ID +--- + + + +### newtype +``` +newtype ID +``` + +Wrapper for literals that can be coerced to a string and used as an identifier. + | Similar to Show typeclass, but constrained to strings and integers and designed + | so that similar cases (such as 1 and "1") convert to the same value. + diff --git a/docs/library/autogenerated/Sound-Tidal-Params/Sound-Tidal-Params.mdx b/docs/library/autogenerated/Sound-Tidal-Params/Sound-Tidal-Params.mdx new file mode 100644 index 0000000000..4d869fff92 --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Params/Sound-Tidal-Params.mdx @@ -0,0 +1,6655 @@ +--- +title: Sound.Tidal.Params +slug: /library/modules/Sound.Tidal.Params +--- + + + +### grp +``` +grp :: [String -> ValueMap] -> Pattern String -> ControlPattern +``` + +group multiple params into one + +### mF +``` +mF :: String -> String -> ValueMap +``` + +### mI +``` +mI :: String -> String -> ValueMap +``` + +### mS +``` +mS :: String -> String -> ValueMap +``` + +### pF +``` +pF :: String -> Pattern Double -> ControlPattern +``` + +Param makers + +### pI +``` +pI :: String -> Pattern Int -> ControlPattern +``` + +### pB +``` +pB :: String -> Pattern Bool -> ControlPattern +``` + +### pR +``` +pR :: String -> Pattern Rational -> ControlPattern +``` + +### pN +``` +pN :: String -> Pattern Note -> ControlPattern +``` + +### pS +``` +pS :: String -> Pattern String -> ControlPattern +``` + +### pX +``` +pX :: String -> Pattern [Word8] -> ControlPattern +``` + +### pStateF +``` +pStateF +``` + +### pStateList +``` +pStateList +``` + +### pStateListF +``` +pStateListF :: String -> String -> [Double] -> ControlPattern +``` + +A wrapper for `pStateList` that accepts a `[Double]` + rather than a `[Value]`. + +### pStateListS +``` +pStateListS :: String -> String -> [String] -> ControlPattern +``` + +A wrapper for `pStateList` that accepts a `[String]` + rather than a `[Value]`. + +### sound +``` +sound :: Pattern String -> ControlPattern +``` + +Grouped params + +### sTake +``` +sTake :: String -> [String] -> ControlPattern +``` + +### cc +``` +cc :: Pattern String -> ControlPattern +``` + +### nrpn +``` +nrpn :: Pattern String -> ControlPattern +``` + +### nrpnn +``` +nrpnn :: Pattern Int -> ControlPattern +``` + +### nrpnv +``` +nrpnv :: Pattern Int -> ControlPattern +``` + +### grain' +``` +grain' :: Pattern String -> ControlPattern +``` + +### midinote +``` +midinote :: Pattern Note -> ControlPattern +``` + +### drum +``` +drum :: Pattern String -> ControlPattern +``` + +### drumN +``` +drumN :: Num a => String -> a +``` + +### accelerate +``` +accelerate :: Pattern Double -> ControlPattern +``` + +a pattern of numbers that speed up (or slow down) samples while they play. + +### accelerateTake +``` +accelerateTake :: String -> [Double] -> ControlPattern +``` + +### accelerateCount +``` +accelerateCount :: String -> ControlPattern +``` + +### accelerateCountTo +``` +accelerateCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### acceleratebus +``` +acceleratebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### amp +``` +amp :: Pattern Double -> ControlPattern +``` + +like `gain`, but linear. + +### ampTake +``` +ampTake :: String -> [Double] -> ControlPattern +``` + +### ampCount +``` +ampCount :: String -> ControlPattern +``` + +### ampCountTo +``` +ampCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### ampbus +``` +ampbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### amprecv +``` +amprecv :: Pattern Int -> ControlPattern +``` + +### array +``` +array :: Pattern [Word8] -> ControlPattern +``` + +### arrayTake +``` +arrayTake :: String -> [Double] -> ControlPattern +``` + +### arraybus +``` +arraybus :: Pattern Int -> Pattern [Word8] -> ControlPattern +``` + +### attack +``` +attack :: Pattern Double -> ControlPattern +``` + +a pattern of numbers to specify the attack time (in seconds) of an envelope applied to each sample. + +### attackTake +``` +attackTake :: String -> [Double] -> ControlPattern +``` + +### attackCount +``` +attackCount :: String -> ControlPattern +``` + +### attackCountTo +``` +attackCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### attackbus +``` +attackbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### attackrecv +``` +attackrecv :: Pattern Int -> ControlPattern +``` + +### bandf +``` +bandf :: Pattern Double -> ControlPattern +``` + +a pattern of numbers from 0 to 1. Sets the center frequency of the band-pass filter. + +### bandfTake +``` +bandfTake :: String -> [Double] -> ControlPattern +``` + +### bandfCount +``` +bandfCount :: String -> ControlPattern +``` + +### bandfCountTo +``` +bandfCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### bandfbus +``` +bandfbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### bandfrecv +``` +bandfrecv :: Pattern Int -> ControlPattern +``` + +### bandq +``` +bandq :: Pattern Double -> ControlPattern +``` + +a pattern of anumbers from 0 to 1. Sets the q-factor of the band-pass filter. + +### bandqTake +``` +bandqTake :: String -> [Double] -> ControlPattern +``` + +### bandqCount +``` +bandqCount :: String -> ControlPattern +``` + +### bandqCountTo +``` +bandqCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### bandqbus +``` +bandqbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### bandqrecv +``` +bandqrecv :: Pattern Int -> ControlPattern +``` + +### begin +``` +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. + +### beginTake +``` +beginTake :: String -> [Double] -> ControlPattern +``` + +### beginCount +``` +beginCount :: String -> ControlPattern +``` + +### beginCountTo +``` +beginCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### beginbus +``` +beginbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### binshift +``` +binshift :: Pattern Double -> ControlPattern +``` + +Spectral binshift + +### binshiftTake +``` +binshiftTake :: String -> [Double] -> ControlPattern +``` + +### binshiftCount +``` +binshiftCount :: String -> ControlPattern +``` + +### binshiftCountTo +``` +binshiftCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### binshiftbus +``` +binshiftbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### binshiftrecv +``` +binshiftrecv :: Pattern Int -> ControlPattern +``` + +### button0 +``` +button0 :: Pattern Double -> ControlPattern +``` + +### button0Take +``` +button0Take :: String -> [Double] -> ControlPattern +``` + +### button0Count +``` +button0Count :: String -> ControlPattern +``` + +### button0CountTo +``` +button0CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### button0bus +``` +button0bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### button0recv +``` +button0recv :: Pattern Int -> ControlPattern +``` + +### button1 +``` +button1 :: Pattern Double -> ControlPattern +``` + +### button1Take +``` +button1Take :: String -> [Double] -> ControlPattern +``` + +### button1Count +``` +button1Count :: String -> ControlPattern +``` + +### button1CountTo +``` +button1CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### button1bus +``` +button1bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### button1recv +``` +button1recv :: Pattern Int -> ControlPattern +``` + +### button10 +``` +button10 :: Pattern Double -> ControlPattern +``` + +### button10Take +``` +button10Take :: String -> [Double] -> ControlPattern +``` + +### button10Count +``` +button10Count :: String -> ControlPattern +``` + +### button10CountTo +``` +button10CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### button10bus +``` +button10bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### button10recv +``` +button10recv :: Pattern Int -> ControlPattern +``` + +### button11 +``` +button11 :: Pattern Double -> ControlPattern +``` + +### button11Take +``` +button11Take :: String -> [Double] -> ControlPattern +``` + +### button11Count +``` +button11Count :: String -> ControlPattern +``` + +### button11CountTo +``` +button11CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### button11bus +``` +button11bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### button11recv +``` +button11recv :: Pattern Int -> ControlPattern +``` + +### button12 +``` +button12 :: Pattern Double -> ControlPattern +``` + +### button12Take +``` +button12Take :: String -> [Double] -> ControlPattern +``` + +### button12Count +``` +button12Count :: String -> ControlPattern +``` + +### button12CountTo +``` +button12CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### button12bus +``` +button12bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### button12recv +``` +button12recv :: Pattern Int -> ControlPattern +``` + +### button13 +``` +button13 :: Pattern Double -> ControlPattern +``` + +### button13Take +``` +button13Take :: String -> [Double] -> ControlPattern +``` + +### button13Count +``` +button13Count :: String -> ControlPattern +``` + +### button13CountTo +``` +button13CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### button13bus +``` +button13bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### button13recv +``` +button13recv :: Pattern Int -> ControlPattern +``` + +### button14 +``` +button14 :: Pattern Double -> ControlPattern +``` + +### button14Take +``` +button14Take :: String -> [Double] -> ControlPattern +``` + +### button14Count +``` +button14Count :: String -> ControlPattern +``` + +### button14CountTo +``` +button14CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### button14bus +``` +button14bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### button14recv +``` +button14recv :: Pattern Int -> ControlPattern +``` + +### button15 +``` +button15 :: Pattern Double -> ControlPattern +``` + +### button15Take +``` +button15Take :: String -> [Double] -> ControlPattern +``` + +### button15Count +``` +button15Count :: String -> ControlPattern +``` + +### button15CountTo +``` +button15CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### button15bus +``` +button15bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### button15recv +``` +button15recv :: Pattern Int -> ControlPattern +``` + +### button2 +``` +button2 :: Pattern Double -> ControlPattern +``` + +### button2Take +``` +button2Take :: String -> [Double] -> ControlPattern +``` + +### button2Count +``` +button2Count :: String -> ControlPattern +``` + +### button2CountTo +``` +button2CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### button2bus +``` +button2bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### button2recv +``` +button2recv :: Pattern Int -> ControlPattern +``` + +### button3 +``` +button3 :: Pattern Double -> ControlPattern +``` + +### button3Take +``` +button3Take :: String -> [Double] -> ControlPattern +``` + +### button3Count +``` +button3Count :: String -> ControlPattern +``` + +### button3CountTo +``` +button3CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### button3bus +``` +button3bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### button3recv +``` +button3recv :: Pattern Int -> ControlPattern +``` + +### button4 +``` +button4 :: Pattern Double -> ControlPattern +``` + +### button4Take +``` +button4Take :: String -> [Double] -> ControlPattern +``` + +### button4Count +``` +button4Count :: String -> ControlPattern +``` + +### button4CountTo +``` +button4CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### button4bus +``` +button4bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### button4recv +``` +button4recv :: Pattern Int -> ControlPattern +``` + +### button5 +``` +button5 :: Pattern Double -> ControlPattern +``` + +### button5Take +``` +button5Take :: String -> [Double] -> ControlPattern +``` + +### button5Count +``` +button5Count :: String -> ControlPattern +``` + +### button5CountTo +``` +button5CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### button5bus +``` +button5bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### button5recv +``` +button5recv :: Pattern Int -> ControlPattern +``` + +### button6 +``` +button6 :: Pattern Double -> ControlPattern +``` + +### button6Take +``` +button6Take :: String -> [Double] -> ControlPattern +``` + +### button6Count +``` +button6Count :: String -> ControlPattern +``` + +### button6CountTo +``` +button6CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### button6bus +``` +button6bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### button6recv +``` +button6recv :: Pattern Int -> ControlPattern +``` + +### button7 +``` +button7 :: Pattern Double -> ControlPattern +``` + +### button7Take +``` +button7Take :: String -> [Double] -> ControlPattern +``` + +### button7Count +``` +button7Count :: String -> ControlPattern +``` + +### button7CountTo +``` +button7CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### button7bus +``` +button7bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### button7recv +``` +button7recv :: Pattern Int -> ControlPattern +``` + +### button8 +``` +button8 :: Pattern Double -> ControlPattern +``` + +### button8Take +``` +button8Take :: String -> [Double] -> ControlPattern +``` + +### button8Count +``` +button8Count :: String -> ControlPattern +``` + +### button8CountTo +``` +button8CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### button8bus +``` +button8bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### button8recv +``` +button8recv :: Pattern Int -> ControlPattern +``` + +### button9 +``` +button9 :: Pattern Double -> ControlPattern +``` + +### button9Take +``` +button9Take :: String -> [Double] -> ControlPattern +``` + +### button9Count +``` +button9Count :: String -> ControlPattern +``` + +### button9CountTo +``` +button9CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### button9bus +``` +button9bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### button9recv +``` +button9recv :: Pattern Int -> ControlPattern +``` + +### ccn +``` +ccn :: Pattern Double -> ControlPattern +``` + +### ccnTake +``` +ccnTake :: String -> [Double] -> ControlPattern +``` + +### ccnCount +``` +ccnCount :: String -> ControlPattern +``` + +### ccnCountTo +``` +ccnCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### ccnbus +``` +ccnbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### ccv +``` +ccv :: Pattern Double -> ControlPattern +``` + +### ccvTake +``` +ccvTake :: String -> [Double] -> ControlPattern +``` + +### ccvCount +``` +ccvCount :: String -> ControlPattern +``` + +### ccvCountTo +``` +ccvCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### ccvbus +``` +ccvbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### channel +``` +channel :: Pattern Int -> ControlPattern +``` + +choose the channel the pattern is sent to in superdirt + +### channelTake +``` +channelTake :: String -> [Double] -> ControlPattern +``` + +### channelCount +``` +channelCount :: String -> ControlPattern +``` + +### channelCountTo +``` +channelCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### channelbus +``` +channelbus :: Pattern Int -> Pattern Int -> ControlPattern +``` + +### clhatdecay +``` +clhatdecay :: Pattern Double -> ControlPattern +``` + +### clhatdecayTake +``` +clhatdecayTake :: String -> [Double] -> ControlPattern +``` + +### clhatdecayCount +``` +clhatdecayCount :: String -> ControlPattern +``` + +### clhatdecayCountTo +``` +clhatdecayCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### clhatdecaybus +``` +clhatdecaybus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### clhatdecayrecv +``` +clhatdecayrecv :: Pattern Int -> ControlPattern +``` + +### coarse +``` +coarse :: Pattern Double -> 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. + +### coarseTake +``` +coarseTake :: String -> [Double] -> ControlPattern +``` + +### coarseCount +``` +coarseCount :: String -> ControlPattern +``` + +### coarseCountTo +``` +coarseCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### coarsebus +``` +coarsebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### coarserecv +``` +coarserecv :: Pattern Int -> ControlPattern +``` + +### comb +``` +comb :: Pattern Double -> ControlPattern +``` + +Spectral comb + +### combTake +``` +combTake :: String -> [Double] -> ControlPattern +``` + +### combCount +``` +combCount :: String -> ControlPattern +``` + +### combCountTo +``` +combCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### combbus +``` +combbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### combrecv +``` +combrecv :: Pattern Int -> ControlPattern +``` + +### control +``` +control :: Pattern Double -> ControlPattern +``` + +### controlTake +``` +controlTake :: String -> [Double] -> ControlPattern +``` + +### controlCount +``` +controlCount :: String -> ControlPattern +``` + +### controlCountTo +``` +controlCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### controlbus +``` +controlbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### cps +``` +cps :: Pattern Double -> ControlPattern +``` + +### cpsTake +``` +cpsTake :: String -> [Double] -> ControlPattern +``` + +### cpsCount +``` +cpsCount :: String -> ControlPattern +``` + +### cpsCountTo +``` +cpsCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### cpsbus +``` +cpsbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### cpsrecv +``` +cpsrecv :: Pattern Int -> ControlPattern +``` + +### crush +``` +crush :: Pattern Double -> ControlPattern +``` + +bit crushing, a pattern of numbers from 1 (for drastic reduction in bit-depth) to 16 (for barely no reduction). + +### crushTake +``` +crushTake :: String -> [Double] -> ControlPattern +``` + +### crushCount +``` +crushCount :: String -> ControlPattern +``` + +### crushCountTo +``` +crushCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### crushbus +``` +crushbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### crushrecv +``` +crushrecv :: Pattern Int -> ControlPattern +``` + +### ctlNum +``` +ctlNum :: Pattern Double -> ControlPattern +``` + +### ctlNumTake +``` +ctlNumTake :: String -> [Double] -> ControlPattern +``` + +### ctlNumCount +``` +ctlNumCount :: String -> ControlPattern +``` + +### ctlNumCountTo +``` +ctlNumCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### ctlNumbus +``` +ctlNumbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### ctranspose +``` +ctranspose :: Pattern Double -> ControlPattern +``` + +### ctransposeTake +``` +ctransposeTake :: String -> [Double] -> ControlPattern +``` + +### ctransposeCount +``` +ctransposeCount :: String -> ControlPattern +``` + +### ctransposeCountTo +``` +ctransposeCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### ctransposebus +``` +ctransposebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### ctransposerecv +``` +ctransposerecv :: Pattern Int -> ControlPattern +``` + +### cut +``` +cut :: 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. + +### cutTake +``` +cutTake :: String -> [Double] -> ControlPattern +``` + +### cutCount +``` +cutCount :: String -> ControlPattern +``` + +### cutCountTo +``` +cutCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### cutbus +``` +cutbus :: Pattern Int -> Pattern Int -> ControlPattern +``` + +### cutrecv +``` +cutrecv :: Pattern Int -> ControlPattern +``` + +### cutoff +``` +cutoff :: Pattern Double -> ControlPattern +``` + +a pattern of numbers from 0 to 1. Applies the cutoff frequency of the low-pass filter. + +### cutoffTake +``` +cutoffTake :: String -> [Double] -> ControlPattern +``` + +### cutoffCount +``` +cutoffCount :: String -> ControlPattern +``` + +### cutoffCountTo +``` +cutoffCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### cutoffbus +``` +cutoffbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### cutoffrecv +``` +cutoffrecv :: Pattern Int -> ControlPattern +``` + +### cutoffegint +``` +cutoffegint :: Pattern Double -> ControlPattern +``` + +### cutoffegintTake +``` +cutoffegintTake :: String -> [Double] -> ControlPattern +``` + +### cutoffegintCount +``` +cutoffegintCount :: String -> ControlPattern +``` + +### cutoffegintCountTo +``` +cutoffegintCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### cutoffegintbus +``` +cutoffegintbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### cutoffegintrecv +``` +cutoffegintrecv :: Pattern Int -> ControlPattern +``` + +### decay +``` +decay :: Pattern Double -> ControlPattern +``` + +### decayTake +``` +decayTake :: String -> [Double] -> ControlPattern +``` + +### decayCount +``` +decayCount :: String -> ControlPattern +``` + +### decayCountTo +``` +decayCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### decaybus +``` +decaybus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### decayrecv +``` +decayrecv :: Pattern Int -> ControlPattern +``` + +### degree +``` +degree :: Pattern Double -> ControlPattern +``` + +### degreeTake +``` +degreeTake :: String -> [Double] -> ControlPattern +``` + +### degreeCount +``` +degreeCount :: String -> ControlPattern +``` + +### degreeCountTo +``` +degreeCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### degreebus +``` +degreebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### degreerecv +``` +degreerecv :: Pattern Int -> ControlPattern +``` + +### delay +``` +delay :: Pattern Double -> ControlPattern +``` + +a pattern of numbers from 0 to 1. Sets the level of the delay signal. + +### delayTake +``` +delayTake :: String -> [Double] -> ControlPattern +``` + +### delayCount +``` +delayCount :: String -> ControlPattern +``` + +### delayCountTo +``` +delayCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### delaybus +``` +delaybus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### delayrecv +``` +delayrecv :: Pattern Int -> ControlPattern +``` + +### delayfeedback +``` +delayfeedback :: Pattern Double -> ControlPattern +``` + +a pattern of numbers from 0 to 1. Sets the amount of delay feedback. + +### delayfeedbackTake +``` +delayfeedbackTake :: String -> [Double] -> ControlPattern +``` + +### delayfeedbackCount +``` +delayfeedbackCount :: String -> ControlPattern +``` + +### delayfeedbackCountTo +``` +delayfeedbackCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### delayfeedbackbus +``` +delayfeedbackbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### delayfeedbackrecv +``` +delayfeedbackrecv :: Pattern Int -> ControlPattern +``` + +### delaytime +``` +delaytime :: Pattern Double -> ControlPattern +``` + +a pattern of numbers from 0 to 1. Sets the length of the delay. + +### delaytimeTake +``` +delaytimeTake :: String -> [Double] -> ControlPattern +``` + +### delaytimeCount +``` +delaytimeCount :: String -> ControlPattern +``` + +### delaytimeCountTo +``` +delaytimeCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### delaytimebus +``` +delaytimebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### delaytimerecv +``` +delaytimerecv :: Pattern Int -> ControlPattern +``` + +### detune +``` +detune :: Pattern Double -> ControlPattern +``` + +### detuneTake +``` +detuneTake :: String -> [Double] -> ControlPattern +``` + +### detuneCount +``` +detuneCount :: String -> ControlPattern +``` + +### detuneCountTo +``` +detuneCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### detunebus +``` +detunebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### detunerecv +``` +detunerecv :: Pattern Int -> ControlPattern +``` + +### distort +``` +distort :: Pattern Double -> ControlPattern +``` + +noisy fuzzy distortion + +### distortTake +``` +distortTake :: String -> [Double] -> ControlPattern +``` + +### distortCount +``` +distortCount :: String -> ControlPattern +``` + +### distortCountTo +``` +distortCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### distortbus +``` +distortbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### distortrecv +``` +distortrecv :: Pattern Int -> ControlPattern +``` + +### djf +``` +djf :: Pattern Double -> ControlPattern +``` + +DJ filter, below 0.5 is low pass filter, above is high pass filter. + +### djfTake +``` +djfTake :: String -> [Double] -> ControlPattern +``` + +### djfCount +``` +djfCount :: String -> ControlPattern +``` + +### djfCountTo +``` +djfCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### djfbus +``` +djfbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### djfrecv +``` +djfrecv :: Pattern Int -> ControlPattern +``` + +### dry +``` +dry :: Pattern Double -> ControlPattern +``` + +when set to `1` will disable all reverb for this pattern. See `room` and `size` for more information about reverb. + +### dryTake +``` +dryTake :: String -> [Double] -> ControlPattern +``` + +### dryCount +``` +dryCount :: String -> ControlPattern +``` + +### dryCountTo +``` +dryCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### drybus +``` +drybus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### dryrecv +``` +dryrecv :: Pattern Int -> ControlPattern +``` + +### dur +``` +dur :: Pattern Double -> ControlPattern +``` + +### durTake +``` +durTake :: String -> [Double] -> ControlPattern +``` + +### durCount +``` +durCount :: String -> ControlPattern +``` + +### durCountTo +``` +durCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### durbus +``` +durbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### durrecv +``` +durrecv :: Pattern Int -> ControlPattern +``` + +### end +``` +end :: Pattern Double -> ControlPattern +``` + +the same as `begin`, but cuts the end off samples, shortening them; e.g. `0.75` to cut off the last quarter of each sample. + +### endTake +``` +endTake :: String -> [Double] -> ControlPattern +``` + +### endCount +``` +endCount :: String -> ControlPattern +``` + +### endCountTo +``` +endCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### endbus +``` +endbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### enhance +``` +enhance :: Pattern Double -> ControlPattern +``` + +Spectral enhance + +### enhanceTake +``` +enhanceTake :: String -> [Double] -> ControlPattern +``` + +### enhanceCount +``` +enhanceCount :: String -> ControlPattern +``` + +### enhanceCountTo +``` +enhanceCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### enhancebus +``` +enhancebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### enhancerecv +``` +enhancerecv :: Pattern Int -> ControlPattern +``` + +### expression +``` +expression :: Pattern Double -> ControlPattern +``` + +### expressionTake +``` +expressionTake :: String -> [Double] -> ControlPattern +``` + +### expressionCount +``` +expressionCount :: String -> ControlPattern +``` + +### expressionCountTo +``` +expressionCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### expressionbus +``` +expressionbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### expressionrecv +``` +expressionrecv :: Pattern Int -> ControlPattern +``` + +### fadeInTime +``` +fadeInTime :: Pattern Double -> ControlPattern +``` + +As with fadeTime, but controls the fade in time of the grain envelope. Not used if the grain begins at position 0 in the sample. + +### fadeInTimeTake +``` +fadeInTimeTake :: String -> [Double] -> ControlPattern +``` + +### fadeInTimeCount +``` +fadeInTimeCount :: String -> ControlPattern +``` + +### fadeInTimeCountTo +``` +fadeInTimeCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### fadeInTimebus +``` +fadeInTimebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### fadeTime +``` +fadeTime :: Pattern Double -> ControlPattern +``` + +Used when using beginend or chopstriate and friends, to change the fade out time of the `grain` envelope. + +### fadeTimeTake +``` +fadeTimeTake :: String -> [Double] -> ControlPattern +``` + +### fadeTimeCount +``` +fadeTimeCount :: String -> ControlPattern +``` + +### fadeTimeCountTo +``` +fadeTimeCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### fadeTimebus +``` +fadeTimebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### frameRate +``` +frameRate :: Pattern Double -> ControlPattern +``` + +### frameRateTake +``` +frameRateTake :: String -> [Double] -> ControlPattern +``` + +### frameRateCount +``` +frameRateCount :: String -> ControlPattern +``` + +### frameRateCountTo +``` +frameRateCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### frameRatebus +``` +frameRatebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### frames +``` +frames :: Pattern Double -> ControlPattern +``` + +### framesTake +``` +framesTake :: String -> [Double] -> ControlPattern +``` + +### framesCount +``` +framesCount :: String -> ControlPattern +``` + +### framesCountTo +``` +framesCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### framesbus +``` +framesbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### freeze +``` +freeze :: Pattern Double -> ControlPattern +``` + +Spectral freeze + +### freezeTake +``` +freezeTake :: String -> [Double] -> ControlPattern +``` + +### freezeCount +``` +freezeCount :: String -> ControlPattern +``` + +### freezeCountTo +``` +freezeCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### freezebus +``` +freezebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### freezerecv +``` +freezerecv :: Pattern Int -> ControlPattern +``` + +### freq +``` +freq :: Pattern Double -> ControlPattern +``` + +### freqTake +``` +freqTake :: String -> [Double] -> ControlPattern +``` + +### freqCount +``` +freqCount :: String -> ControlPattern +``` + +### freqCountTo +``` +freqCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### freqbus +``` +freqbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### freqrecv +``` +freqrecv :: Pattern Int -> ControlPattern +``` + +### from +``` +from :: Pattern Double -> ControlPattern +``` + +for internal sound routing + +### fromTake +``` +fromTake :: String -> [Double] -> ControlPattern +``` + +### fromCount +``` +fromCount :: String -> ControlPattern +``` + +### fromCountTo +``` +fromCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### frombus +``` +frombus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### fromrecv +``` +fromrecv :: Pattern Int -> ControlPattern +``` + +### fshift +``` +fshift :: Pattern Double -> ControlPattern +``` + +frequency shifter + +### fshiftTake +``` +fshiftTake :: String -> [Double] -> ControlPattern +``` + +### fshiftCount +``` +fshiftCount :: String -> ControlPattern +``` + +### fshiftCountTo +``` +fshiftCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### fshiftbus +``` +fshiftbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### fshiftrecv +``` +fshiftrecv :: Pattern Int -> ControlPattern +``` + +### fshiftnote +``` +fshiftnote :: Pattern Double -> ControlPattern +``` + +frequency shifter + +### fshiftnoteTake +``` +fshiftnoteTake :: String -> [Double] -> ControlPattern +``` + +### fshiftnoteCount +``` +fshiftnoteCount :: String -> ControlPattern +``` + +### fshiftnoteCountTo +``` +fshiftnoteCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### fshiftnotebus +``` +fshiftnotebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### fshiftnoterecv +``` +fshiftnoterecv :: Pattern Int -> ControlPattern +``` + +### fshiftphase +``` +fshiftphase :: Pattern Double -> ControlPattern +``` + +frequency shifter + +### fshiftphaseTake +``` +fshiftphaseTake :: String -> [Double] -> ControlPattern +``` + +### fshiftphaseCount +``` +fshiftphaseCount :: String -> ControlPattern +``` + +### fshiftphaseCountTo +``` +fshiftphaseCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### fshiftphasebus +``` +fshiftphasebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### fshiftphaserecv +``` +fshiftphaserecv :: Pattern Int -> ControlPattern +``` + +### gain +``` +gain :: 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. For the linear equivalent, see `amp`. + +### gainTake +``` +gainTake :: String -> [Double] -> ControlPattern +``` + +### gainCount +``` +gainCount :: String -> ControlPattern +``` + +### gainCountTo +``` +gainCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### gainbus +``` +gainbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### gate +``` +gate :: Pattern Double -> ControlPattern +``` + +### gateTake +``` +gateTake :: String -> [Double] -> ControlPattern +``` + +### gateCount +``` +gateCount :: String -> ControlPattern +``` + +### gateCountTo +``` +gateCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### gatebus +``` +gatebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### gaterecv +``` +gaterecv :: Pattern Int -> ControlPattern +``` + +### harmonic +``` +harmonic :: Pattern Double -> ControlPattern +``` + +### harmonicTake +``` +harmonicTake :: String -> [Double] -> ControlPattern +``` + +### harmonicCount +``` +harmonicCount :: String -> ControlPattern +``` + +### harmonicCountTo +``` +harmonicCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### harmonicbus +``` +harmonicbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### harmonicrecv +``` +harmonicrecv :: Pattern Int -> ControlPattern +``` + +### hatgrain +``` +hatgrain :: Pattern Double -> ControlPattern +``` + +### hatgrainTake +``` +hatgrainTake :: String -> [Double] -> ControlPattern +``` + +### hatgrainCount +``` +hatgrainCount :: String -> ControlPattern +``` + +### hatgrainCountTo +``` +hatgrainCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### hatgrainbus +``` +hatgrainbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### hatgrainrecv +``` +hatgrainrecv :: Pattern Int -> ControlPattern +``` + +### hbrick +``` +hbrick :: Pattern Double -> ControlPattern +``` + +High pass sort of spectral filter + +### hbrickTake +``` +hbrickTake :: String -> [Double] -> ControlPattern +``` + +### hbrickCount +``` +hbrickCount :: String -> ControlPattern +``` + +### hbrickCountTo +``` +hbrickCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### hbrickbus +``` +hbrickbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### hbrickrecv +``` +hbrickrecv :: Pattern Int -> ControlPattern +``` + +### hcutoff +``` +hcutoff :: Pattern Double -> ControlPattern +``` + +a pattern of numbers from 0 to 1. Applies the cutoff frequency of the high-pass filter. Also has alias `hpf` + +### hcutoffTake +``` +hcutoffTake :: String -> [Double] -> ControlPattern +``` + +### hcutoffCount +``` +hcutoffCount :: String -> ControlPattern +``` + +### hcutoffCountTo +``` +hcutoffCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### hcutoffbus +``` +hcutoffbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### hcutoffrecv +``` +hcutoffrecv :: Pattern Int -> ControlPattern +``` + +### hold +``` +hold :: 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. + +### holdTake +``` +holdTake :: String -> [Double] -> ControlPattern +``` + +### holdCount +``` +holdCount :: String -> ControlPattern +``` + +### holdCountTo +``` +holdCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### holdbus +``` +holdbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### holdrecv +``` +holdrecv :: Pattern Int -> ControlPattern +``` + +### hours +``` +hours :: Pattern Double -> ControlPattern +``` + +### hoursTake +``` +hoursTake :: String -> [Double] -> ControlPattern +``` + +### hoursCount +``` +hoursCount :: String -> ControlPattern +``` + +### hoursCountTo +``` +hoursCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### hoursbus +``` +hoursbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### hresonance +``` +hresonance :: Pattern Double -> ControlPattern +``` + +a pattern of numbers from 0 to 1. Applies the resonance of the high-pass filter. Has alias `hpq` + +### hresonanceTake +``` +hresonanceTake :: String -> [Double] -> ControlPattern +``` + +### hresonanceCount +``` +hresonanceCount :: String -> ControlPattern +``` + +### hresonanceCountTo +``` +hresonanceCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### hresonancebus +``` +hresonancebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### hresonancerecv +``` +hresonancerecv :: Pattern Int -> ControlPattern +``` + +### imag +``` +imag :: Pattern Double -> ControlPattern +``` + +### imagTake +``` +imagTake :: String -> [Double] -> ControlPattern +``` + +### imagCount +``` +imagCount :: String -> ControlPattern +``` + +### imagCountTo +``` +imagCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### imagbus +``` +imagbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### imagrecv +``` +imagrecv :: Pattern Int -> ControlPattern +``` + +### kcutoff +``` +kcutoff :: Pattern Double -> ControlPattern +``` + +### kcutoffTake +``` +kcutoffTake :: String -> [Double] -> ControlPattern +``` + +### kcutoffCount +``` +kcutoffCount :: String -> ControlPattern +``` + +### kcutoffCountTo +``` +kcutoffCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### kcutoffbus +``` +kcutoffbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### kcutoffrecv +``` +kcutoffrecv :: Pattern Int -> ControlPattern +``` + +### krush +``` +krush :: Pattern Double -> ControlPattern +``` + +shape/bass enhancer + +### krushTake +``` +krushTake :: String -> [Double] -> ControlPattern +``` + +### krushCount +``` +krushCount :: String -> ControlPattern +``` + +### krushCountTo +``` +krushCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### krushbus +``` +krushbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### krushrecv +``` +krushrecv :: Pattern Int -> ControlPattern +``` + +### lagogo +``` +lagogo :: Pattern Double -> ControlPattern +``` + +### lagogoTake +``` +lagogoTake :: String -> [Double] -> ControlPattern +``` + +### lagogoCount +``` +lagogoCount :: String -> ControlPattern +``` + +### lagogoCountTo +``` +lagogoCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lagogobus +``` +lagogobus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lagogorecv +``` +lagogorecv :: Pattern Int -> ControlPattern +``` + +### lbrick +``` +lbrick :: Pattern Double -> ControlPattern +``` + +Low pass sort of spectral filter + +### lbrickTake +``` +lbrickTake :: String -> [Double] -> ControlPattern +``` + +### lbrickCount +``` +lbrickCount :: String -> ControlPattern +``` + +### lbrickCountTo +``` +lbrickCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lbrickbus +``` +lbrickbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lbrickrecv +``` +lbrickrecv :: Pattern Int -> ControlPattern +``` + +### lclap +``` +lclap :: Pattern Double -> ControlPattern +``` + +### lclapTake +``` +lclapTake :: String -> [Double] -> ControlPattern +``` + +### lclapCount +``` +lclapCount :: String -> ControlPattern +``` + +### lclapCountTo +``` +lclapCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lclapbus +``` +lclapbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lclaprecv +``` +lclaprecv :: Pattern Int -> ControlPattern +``` + +### lclaves +``` +lclaves :: Pattern Double -> ControlPattern +``` + +### lclavesTake +``` +lclavesTake :: String -> [Double] -> ControlPattern +``` + +### lclavesCount +``` +lclavesCount :: String -> ControlPattern +``` + +### lclavesCountTo +``` +lclavesCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lclavesbus +``` +lclavesbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lclavesrecv +``` +lclavesrecv :: Pattern Int -> ControlPattern +``` + +### lclhat +``` +lclhat :: Pattern Double -> ControlPattern +``` + +### lclhatTake +``` +lclhatTake :: String -> [Double] -> ControlPattern +``` + +### lclhatCount +``` +lclhatCount :: String -> ControlPattern +``` + +### lclhatCountTo +``` +lclhatCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lclhatbus +``` +lclhatbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lclhatrecv +``` +lclhatrecv :: Pattern Int -> ControlPattern +``` + +### lcrash +``` +lcrash :: Pattern Double -> ControlPattern +``` + +### lcrashTake +``` +lcrashTake :: String -> [Double] -> ControlPattern +``` + +### lcrashCount +``` +lcrashCount :: String -> ControlPattern +``` + +### lcrashCountTo +``` +lcrashCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lcrashbus +``` +lcrashbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lcrashrecv +``` +lcrashrecv :: Pattern Int -> ControlPattern +``` + +### legato +``` +legato :: Pattern Double -> ControlPattern +``` + +controls the amount of overlap between two adjacent sounds + +### legatoTake +``` +legatoTake :: String -> [Double] -> ControlPattern +``` + +### legatoCount +``` +legatoCount :: String -> ControlPattern +``` + +### legatoCountTo +``` +legatoCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### legatobus +``` +legatobus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### leslie +``` +leslie :: Pattern Double -> ControlPattern +``` + +### leslieTake +``` +leslieTake :: String -> [Double] -> ControlPattern +``` + +### leslieCount +``` +leslieCount :: String -> ControlPattern +``` + +### leslieCountTo +``` +leslieCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lesliebus +``` +lesliebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### leslierecv +``` +leslierecv :: Pattern Int -> ControlPattern +``` + +### lfo +``` +lfo :: Pattern Double -> ControlPattern +``` + +### lfoTake +``` +lfoTake :: String -> [Double] -> ControlPattern +``` + +### lfoCount +``` +lfoCount :: String -> ControlPattern +``` + +### lfoCountTo +``` +lfoCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lfobus +``` +lfobus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lforecv +``` +lforecv :: Pattern Int -> ControlPattern +``` + +### lfocutoffint +``` +lfocutoffint :: Pattern Double -> ControlPattern +``` + +### lfocutoffintTake +``` +lfocutoffintTake :: String -> [Double] -> ControlPattern +``` + +### lfocutoffintCount +``` +lfocutoffintCount :: String -> ControlPattern +``` + +### lfocutoffintCountTo +``` +lfocutoffintCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lfocutoffintbus +``` +lfocutoffintbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lfocutoffintrecv +``` +lfocutoffintrecv :: Pattern Int -> ControlPattern +``` + +### lfodelay +``` +lfodelay :: Pattern Double -> ControlPattern +``` + +### lfodelayTake +``` +lfodelayTake :: String -> [Double] -> ControlPattern +``` + +### lfodelayCount +``` +lfodelayCount :: String -> ControlPattern +``` + +### lfodelayCountTo +``` +lfodelayCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lfodelaybus +``` +lfodelaybus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lfodelayrecv +``` +lfodelayrecv :: Pattern Int -> ControlPattern +``` + +### lfoint +``` +lfoint :: Pattern Double -> ControlPattern +``` + +### lfointTake +``` +lfointTake :: String -> [Double] -> ControlPattern +``` + +### lfointCount +``` +lfointCount :: String -> ControlPattern +``` + +### lfointCountTo +``` +lfointCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lfointbus +``` +lfointbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lfointrecv +``` +lfointrecv :: Pattern Int -> ControlPattern +``` + +### lfopitchint +``` +lfopitchint :: Pattern Double -> ControlPattern +``` + +### lfopitchintTake +``` +lfopitchintTake :: String -> [Double] -> ControlPattern +``` + +### lfopitchintCount +``` +lfopitchintCount :: String -> ControlPattern +``` + +### lfopitchintCountTo +``` +lfopitchintCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lfopitchintbus +``` +lfopitchintbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lfopitchintrecv +``` +lfopitchintrecv :: Pattern Int -> ControlPattern +``` + +### lfoshape +``` +lfoshape :: Pattern Double -> ControlPattern +``` + +### lfoshapeTake +``` +lfoshapeTake :: String -> [Double] -> ControlPattern +``` + +### lfoshapeCount +``` +lfoshapeCount :: String -> ControlPattern +``` + +### lfoshapeCountTo +``` +lfoshapeCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lfoshapebus +``` +lfoshapebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lfoshaperecv +``` +lfoshaperecv :: Pattern Int -> ControlPattern +``` + +### lfosync +``` +lfosync :: Pattern Double -> ControlPattern +``` + +### lfosyncTake +``` +lfosyncTake :: String -> [Double] -> ControlPattern +``` + +### lfosyncCount +``` +lfosyncCount :: String -> ControlPattern +``` + +### lfosyncCountTo +``` +lfosyncCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lfosyncbus +``` +lfosyncbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lfosyncrecv +``` +lfosyncrecv :: Pattern Int -> ControlPattern +``` + +### lhitom +``` +lhitom :: Pattern Double -> ControlPattern +``` + +### lhitomTake +``` +lhitomTake :: String -> [Double] -> ControlPattern +``` + +### lhitomCount +``` +lhitomCount :: String -> ControlPattern +``` + +### lhitomCountTo +``` +lhitomCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lhitombus +``` +lhitombus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lhitomrecv +``` +lhitomrecv :: Pattern Int -> ControlPattern +``` + +### lkick +``` +lkick :: Pattern Double -> ControlPattern +``` + +### lkickTake +``` +lkickTake :: String -> [Double] -> ControlPattern +``` + +### lkickCount +``` +lkickCount :: String -> ControlPattern +``` + +### lkickCountTo +``` +lkickCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lkickbus +``` +lkickbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lkickrecv +``` +lkickrecv :: Pattern Int -> ControlPattern +``` + +### llotom +``` +llotom :: Pattern Double -> ControlPattern +``` + +### llotomTake +``` +llotomTake :: String -> [Double] -> ControlPattern +``` + +### llotomCount +``` +llotomCount :: String -> ControlPattern +``` + +### llotomCountTo +``` +llotomCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### llotombus +``` +llotombus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### llotomrecv +``` +llotomrecv :: Pattern Int -> ControlPattern +``` + +### lock +``` +lock :: 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. + +### lockTake +``` +lockTake :: String -> [Double] -> ControlPattern +``` + +### lockCount +``` +lockCount :: String -> ControlPattern +``` + +### lockCountTo +``` +lockCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lockbus +``` +lockbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lockrecv +``` +lockrecv :: Pattern Int -> ControlPattern +``` + +### loop +``` +loop :: Pattern Double -> ControlPattern +``` + +loops the sample (from `begin` to `end`) the specified number of times. + +### loopTake +``` +loopTake :: String -> [Double] -> ControlPattern +``` + +### loopCount +``` +loopCount :: String -> ControlPattern +``` + +### loopCountTo +``` +loopCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### loopbus +``` +loopbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lophat +``` +lophat :: Pattern Double -> ControlPattern +``` + +### lophatTake +``` +lophatTake :: String -> [Double] -> ControlPattern +``` + +### lophatCount +``` +lophatCount :: String -> ControlPattern +``` + +### lophatCountTo +``` +lophatCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lophatbus +``` +lophatbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lophatrecv +``` +lophatrecv :: Pattern Int -> ControlPattern +``` + +### lrate +``` +lrate :: Pattern Double -> ControlPattern +``` + +### lrateTake +``` +lrateTake :: String -> [Double] -> ControlPattern +``` + +### lrateCount +``` +lrateCount :: String -> ControlPattern +``` + +### lrateCountTo +``` +lrateCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lratebus +``` +lratebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lraterecv +``` +lraterecv :: Pattern Int -> ControlPattern +``` + +### lsize +``` +lsize :: Pattern Double -> ControlPattern +``` + +### lsizeTake +``` +lsizeTake :: String -> [Double] -> ControlPattern +``` + +### lsizeCount +``` +lsizeCount :: String -> ControlPattern +``` + +### lsizeCountTo +``` +lsizeCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lsizebus +``` +lsizebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lsizerecv +``` +lsizerecv :: Pattern Int -> ControlPattern +``` + +### lsnare +``` +lsnare :: Pattern Double -> ControlPattern +``` + +### lsnareTake +``` +lsnareTake :: String -> [Double] -> ControlPattern +``` + +### lsnareCount +``` +lsnareCount :: String -> ControlPattern +``` + +### lsnareCountTo +``` +lsnareCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### lsnarebus +``` +lsnarebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lsnarerecv +``` +lsnarerecv :: Pattern Int -> ControlPattern +``` + +### midibend +``` +midibend :: Pattern Double -> ControlPattern +``` + +### midibendTake +``` +midibendTake :: String -> [Double] -> ControlPattern +``` + +### midibendCount +``` +midibendCount :: String -> ControlPattern +``` + +### midibendCountTo +``` +midibendCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### midibendbus +``` +midibendbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### midichan +``` +midichan :: Pattern Double -> ControlPattern +``` + +### midichanTake +``` +midichanTake :: String -> [Double] -> ControlPattern +``` + +### midichanCount +``` +midichanCount :: String -> ControlPattern +``` + +### midichanCountTo +``` +midichanCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### midichanbus +``` +midichanbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### midicmd +``` +midicmd :: Pattern String -> ControlPattern +``` + +### midicmdTake +``` +midicmdTake :: String -> [Double] -> ControlPattern +``` + +### midicmdbus +``` +midicmdbus :: Pattern Int -> Pattern String -> ControlPattern +``` + +### miditouch +``` +miditouch :: Pattern Double -> ControlPattern +``` + +### miditouchTake +``` +miditouchTake :: String -> [Double] -> ControlPattern +``` + +### miditouchCount +``` +miditouchCount :: String -> ControlPattern +``` + +### miditouchCountTo +``` +miditouchCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### miditouchbus +``` +miditouchbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### minutes +``` +minutes :: Pattern Double -> ControlPattern +``` + +### minutesTake +``` +minutesTake :: String -> [Double] -> ControlPattern +``` + +### minutesCount +``` +minutesCount :: String -> ControlPattern +``` + +### minutesCountTo +``` +minutesCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### minutesbus +``` +minutesbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### modwheel +``` +modwheel :: Pattern Double -> ControlPattern +``` + +### modwheelTake +``` +modwheelTake :: String -> [Double] -> ControlPattern +``` + +### modwheelCount +``` +modwheelCount :: String -> ControlPattern +``` + +### modwheelCountTo +``` +modwheelCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### modwheelbus +``` +modwheelbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### modwheelrecv +``` +modwheelrecv :: Pattern Int -> ControlPattern +``` + +### mtranspose +``` +mtranspose :: Pattern Double -> ControlPattern +``` + +### mtransposeTake +``` +mtransposeTake :: String -> [Double] -> ControlPattern +``` + +### mtransposeCount +``` +mtransposeCount :: String -> ControlPattern +``` + +### mtransposeCountTo +``` +mtransposeCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### mtransposebus +``` +mtransposebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### mtransposerecv +``` +mtransposerecv :: Pattern Int -> ControlPattern +``` + +### n +``` +n :: Pattern Note -> ControlPattern +``` + +The note or sample number to choose for a synth or sampleset + +### nTake +``` +nTake :: String -> [Double] -> ControlPattern +``` + +### nCount +``` +nCount :: String -> ControlPattern +``` + +### nCountTo +``` +nCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### nbus +``` +nbus :: Pattern Int -> Pattern Note -> ControlPattern +``` + +### note +``` +note :: Pattern Note -> ControlPattern +``` + +The note or pitch to play a sound or synth with + +### noteTake +``` +noteTake :: String -> [Double] -> ControlPattern +``` + +### noteCount +``` +noteCount :: String -> ControlPattern +``` + +### noteCountTo +``` +noteCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### notebus +``` +notebus :: Pattern Int -> Pattern Note -> ControlPattern +``` + +### nudge +``` +nudge :: Pattern Double -> ControlPattern +``` + +Nudges events into the future by the specified number of seconds. Negative numbers work up to a point as well (due to internal latency) + +### nudgeTake +``` +nudgeTake :: String -> [Double] -> ControlPattern +``` + +### nudgeCount +``` +nudgeCount :: String -> ControlPattern +``` + +### nudgeCountTo +``` +nudgeCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### nudgebus +``` +nudgebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### nudgerecv +``` +nudgerecv :: Pattern Int -> ControlPattern +``` + +### octave +``` +octave :: Pattern Int -> ControlPattern +``` + +### octaveTake +``` +octaveTake :: String -> [Double] -> ControlPattern +``` + +### octaveCount +``` +octaveCount :: String -> ControlPattern +``` + +### octaveCountTo +``` +octaveCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### octavebus +``` +octavebus :: Pattern Int -> Pattern Int -> ControlPattern +``` + +### octaveR +``` +octaveR :: Pattern Double -> ControlPattern +``` + +### octaveRTake +``` +octaveRTake :: String -> [Double] -> ControlPattern +``` + +### octaveRCount +``` +octaveRCount :: String -> ControlPattern +``` + +### octaveRCountTo +``` +octaveRCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### octaveRbus +``` +octaveRbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### octaveRrecv +``` +octaveRrecv :: Pattern Int -> ControlPattern +``` + +### octer +``` +octer :: Pattern Double -> ControlPattern +``` + +octaver effect + +### octerTake +``` +octerTake :: String -> [Double] -> ControlPattern +``` + +### octerCount +``` +octerCount :: String -> ControlPattern +``` + +### octerCountTo +``` +octerCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### octerbus +``` +octerbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### octerrecv +``` +octerrecv :: Pattern Int -> ControlPattern +``` + +### octersub +``` +octersub :: Pattern Double -> ControlPattern +``` + +octaver effect + +### octersubTake +``` +octersubTake :: String -> [Double] -> ControlPattern +``` + +### octersubCount +``` +octersubCount :: String -> ControlPattern +``` + +### octersubCountTo +``` +octersubCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### octersubbus +``` +octersubbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### octersubrecv +``` +octersubrecv :: Pattern Int -> ControlPattern +``` + +### octersubsub +``` +octersubsub :: Pattern Double -> ControlPattern +``` + +octaver effect + +### octersubsubTake +``` +octersubsubTake :: String -> [Double] -> ControlPattern +``` + +### octersubsubCount +``` +octersubsubCount :: String -> ControlPattern +``` + +### octersubsubCountTo +``` +octersubsubCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### octersubsubbus +``` +octersubsubbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### octersubsubrecv +``` +octersubsubrecv :: Pattern Int -> ControlPattern +``` + +### offset +``` +offset :: Pattern Double -> ControlPattern +``` + +### offsetTake +``` +offsetTake :: String -> [Double] -> ControlPattern +``` + +### offsetCount +``` +offsetCount :: String -> ControlPattern +``` + +### offsetCountTo +``` +offsetCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### offsetbus +``` +offsetbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### ophatdecay +``` +ophatdecay :: Pattern Double -> ControlPattern +``` + +### ophatdecayTake +``` +ophatdecayTake :: String -> [Double] -> ControlPattern +``` + +### ophatdecayCount +``` +ophatdecayCount :: String -> ControlPattern +``` + +### ophatdecayCountTo +``` +ophatdecayCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### ophatdecaybus +``` +ophatdecaybus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### ophatdecayrecv +``` +ophatdecayrecv :: Pattern Int -> ControlPattern +``` + +### orbit +``` +orbit :: Pattern Int -> ControlPattern +``` + +a pattern of numbers. An `orbit` is a global parameter context for patterns. Patterns with the same orbit will share hardware output bus offset and global effects, e.g. reverb and delay. The maximum number of orbits is specified in the superdirt startup, numbers higher than maximum will wrap around. + +### orbitTake +``` +orbitTake :: String -> [Double] -> ControlPattern +``` + +### orbitCount +``` +orbitCount :: String -> ControlPattern +``` + +### orbitCountTo +``` +orbitCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### orbitbus +``` +orbitbus :: Pattern Int -> Pattern Int -> ControlPattern +``` + +### orbitrecv +``` +orbitrecv :: Pattern Int -> ControlPattern +``` + +### overgain +``` +overgain :: Pattern Double -> ControlPattern +``` + +### overgainTake +``` +overgainTake :: String -> [Double] -> ControlPattern +``` + +### overgainCount +``` +overgainCount :: String -> ControlPattern +``` + +### overgainCountTo +``` +overgainCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### overgainbus +``` +overgainbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### overshape +``` +overshape :: Pattern Double -> ControlPattern +``` + +### overshapeTake +``` +overshapeTake :: String -> [Double] -> ControlPattern +``` + +### overshapeCount +``` +overshapeCount :: String -> ControlPattern +``` + +### overshapeCountTo +``` +overshapeCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### overshapebus +``` +overshapebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### overshaperecv +``` +overshaperecv :: Pattern Int -> ControlPattern +``` + +### pan +``` +pan :: Pattern Double -> ControlPattern +``` + +a pattern of numbers between 0 and 1, from left to right (assuming stereo), once round a circle (assuming multichannel) + +### panTake +``` +panTake :: String -> [Double] -> ControlPattern +``` + +### panCount +``` +panCount :: String -> ControlPattern +``` + +### panCountTo +``` +panCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### panbus +``` +panbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### panrecv +``` +panrecv :: Pattern Int -> ControlPattern +``` + +### panorient +``` +panorient :: 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) + +### panorientTake +``` +panorientTake :: String -> [Double] -> ControlPattern +``` + +### panorientCount +``` +panorientCount :: String -> ControlPattern +``` + +### panorientCountTo +``` +panorientCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### panorientbus +``` +panorientbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### panorientrecv +``` +panorientrecv :: Pattern Int -> ControlPattern +``` + +### panspan +``` +panspan :: Pattern Double -> ControlPattern +``` + +a pattern of numbers between -inf and inf, which controls how much multichannel output is fanned out (negative is backwards ordering) + +### panspanTake +``` +panspanTake :: String -> [Double] -> ControlPattern +``` + +### panspanCount +``` +panspanCount :: String -> ControlPattern +``` + +### panspanCountTo +``` +panspanCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### panspanbus +``` +panspanbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### panspanrecv +``` +panspanrecv :: Pattern Int -> ControlPattern +``` + +### pansplay +``` +pansplay :: Pattern Double -> ControlPattern +``` + +a pattern of numbers between 0.0 and 1.0, which controls the multichannel spread range (multichannel only) + +### pansplayTake +``` +pansplayTake :: String -> [Double] -> ControlPattern +``` + +### pansplayCount +``` +pansplayCount :: String -> ControlPattern +``` + +### pansplayCountTo +``` +pansplayCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### pansplaybus +``` +pansplaybus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### pansplayrecv +``` +pansplayrecv :: Pattern Int -> ControlPattern +``` + +### panwidth +``` +panwidth :: Pattern Double -> ControlPattern +``` + +a pattern of numbers between 0.0 and inf, which controls how much each channel is distributed over neighbours (multichannel only) + +### panwidthTake +``` +panwidthTake :: String -> [Double] -> ControlPattern +``` + +### panwidthCount +``` +panwidthCount :: String -> ControlPattern +``` + +### panwidthCountTo +``` +panwidthCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### panwidthbus +``` +panwidthbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### panwidthrecv +``` +panwidthrecv :: Pattern Int -> ControlPattern +``` + +### partials +``` +partials :: Pattern Double -> ControlPattern +``` + +### partialsTake +``` +partialsTake :: String -> [Double] -> ControlPattern +``` + +### partialsCount +``` +partialsCount :: String -> ControlPattern +``` + +### partialsCountTo +``` +partialsCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### partialsbus +``` +partialsbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### partialsrecv +``` +partialsrecv :: Pattern Int -> ControlPattern +``` + +### phaserdepth +``` +phaserdepth :: Pattern Double -> ControlPattern +``` + +Phaser Audio DSP effect | params are `phaserrate` and `phaserdepth` + +### phaserdepthTake +``` +phaserdepthTake :: String -> [Double] -> ControlPattern +``` + +### phaserdepthCount +``` +phaserdepthCount :: String -> ControlPattern +``` + +### phaserdepthCountTo +``` +phaserdepthCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### phaserdepthbus +``` +phaserdepthbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### phaserdepthrecv +``` +phaserdepthrecv :: Pattern Int -> ControlPattern +``` + +### phaserrate +``` +phaserrate :: Pattern Double -> ControlPattern +``` + +Phaser Audio DSP effect | params are `phaserrate` and `phaserdepth` + +### phaserrateTake +``` +phaserrateTake :: String -> [Double] -> ControlPattern +``` + +### phaserrateCount +``` +phaserrateCount :: String -> ControlPattern +``` + +### phaserrateCountTo +``` +phaserrateCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### phaserratebus +``` +phaserratebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### phaserraterecv +``` +phaserraterecv :: Pattern Int -> ControlPattern +``` + +### pitch1 +``` +pitch1 :: Pattern Double -> ControlPattern +``` + +### pitch1Take +``` +pitch1Take :: String -> [Double] -> ControlPattern +``` + +### pitch1Count +``` +pitch1Count :: String -> ControlPattern +``` + +### pitch1CountTo +``` +pitch1CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### pitch1bus +``` +pitch1bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### pitch1recv +``` +pitch1recv :: Pattern Int -> ControlPattern +``` + +### pitch2 +``` +pitch2 :: Pattern Double -> ControlPattern +``` + +### pitch2Take +``` +pitch2Take :: String -> [Double] -> ControlPattern +``` + +### pitch2Count +``` +pitch2Count :: String -> ControlPattern +``` + +### pitch2CountTo +``` +pitch2CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### pitch2bus +``` +pitch2bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### pitch2recv +``` +pitch2recv :: Pattern Int -> ControlPattern +``` + +### pitch3 +``` +pitch3 :: Pattern Double -> ControlPattern +``` + +### pitch3Take +``` +pitch3Take :: String -> [Double] -> ControlPattern +``` + +### pitch3Count +``` +pitch3Count :: String -> ControlPattern +``` + +### pitch3CountTo +``` +pitch3CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### pitch3bus +``` +pitch3bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### pitch3recv +``` +pitch3recv :: Pattern Int -> ControlPattern +``` + +### polyTouch +``` +polyTouch :: Pattern Double -> ControlPattern +``` + +### polyTouchTake +``` +polyTouchTake :: String -> [Double] -> ControlPattern +``` + +### polyTouchCount +``` +polyTouchCount :: String -> ControlPattern +``` + +### polyTouchCountTo +``` +polyTouchCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### polyTouchbus +``` +polyTouchbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### portamento +``` +portamento :: Pattern Double -> ControlPattern +``` + +### portamentoTake +``` +portamentoTake :: String -> [Double] -> ControlPattern +``` + +### portamentoCount +``` +portamentoCount :: String -> ControlPattern +``` + +### portamentoCountTo +``` +portamentoCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### portamentobus +``` +portamentobus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### portamentorecv +``` +portamentorecv :: Pattern Int -> ControlPattern +``` + +### progNum +``` +progNum :: Pattern Double -> ControlPattern +``` + +### progNumTake +``` +progNumTake :: String -> [Double] -> ControlPattern +``` + +### progNumCount +``` +progNumCount :: String -> ControlPattern +``` + +### progNumCountTo +``` +progNumCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### progNumbus +``` +progNumbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### rate +``` +rate :: Pattern Double -> ControlPattern +``` + +used in SuperDirt softsynths as a control rate or `speed` + +### rateTake +``` +rateTake :: String -> [Double] -> ControlPattern +``` + +### rateCount +``` +rateCount :: String -> ControlPattern +``` + +### rateCountTo +``` +rateCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### ratebus +``` +ratebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### raterecv +``` +raterecv :: Pattern Int -> ControlPattern +``` + +### real +``` +real :: Pattern Double -> ControlPattern +``` + +Spectral conform + +### realTake +``` +realTake :: String -> [Double] -> ControlPattern +``` + +### realCount +``` +realCount :: String -> ControlPattern +``` + +### realCountTo +``` +realCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### realbus +``` +realbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### realrecv +``` +realrecv :: Pattern Int -> ControlPattern +``` + +### release +``` +release :: Pattern Double -> ControlPattern +``` + +a pattern of numbers to specify the release time (in seconds) of an envelope applied to each sample. + +### releaseTake +``` +releaseTake :: String -> [Double] -> ControlPattern +``` + +### releaseCount +``` +releaseCount :: String -> ControlPattern +``` + +### releaseCountTo +``` +releaseCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### releasebus +``` +releasebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### releaserecv +``` +releaserecv :: Pattern Int -> ControlPattern +``` + +### resonance +``` +resonance :: Pattern Double -> ControlPattern +``` + +a pattern of numbers from 0 to 1. Specifies the resonance of the low-pass filter. + +### resonanceTake +``` +resonanceTake :: String -> [Double] -> ControlPattern +``` + +### resonanceCount +``` +resonanceCount :: String -> ControlPattern +``` + +### resonanceCountTo +``` +resonanceCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### resonancebus +``` +resonancebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### resonancerecv +``` +resonancerecv :: Pattern Int -> ControlPattern +``` + +### ring +``` +ring :: Pattern Double -> ControlPattern +``` + +ring modulation + +### ringTake +``` +ringTake :: String -> [Double] -> ControlPattern +``` + +### ringCount +``` +ringCount :: String -> ControlPattern +``` + +### ringCountTo +``` +ringCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### ringbus +``` +ringbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### ringrecv +``` +ringrecv :: Pattern Int -> ControlPattern +``` + +### ringdf +``` +ringdf :: Pattern Double -> ControlPattern +``` + +ring modulation + +### ringdfTake +``` +ringdfTake :: String -> [Double] -> ControlPattern +``` + +### ringdfCount +``` +ringdfCount :: String -> ControlPattern +``` + +### ringdfCountTo +``` +ringdfCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### ringdfbus +``` +ringdfbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### ringdfrecv +``` +ringdfrecv :: Pattern Int -> ControlPattern +``` + +### ringf +``` +ringf :: Pattern Double -> ControlPattern +``` + +ring modulation + +### ringfTake +``` +ringfTake :: String -> [Double] -> ControlPattern +``` + +### ringfCount +``` +ringfCount :: String -> ControlPattern +``` + +### ringfCountTo +``` +ringfCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### ringfbus +``` +ringfbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### ringfrecv +``` +ringfrecv :: Pattern Int -> ControlPattern +``` + +### room +``` +room :: Pattern Double -> ControlPattern +``` + +a pattern of numbers from 0 to 1. Sets the level of reverb. + +### roomTake +``` +roomTake :: String -> [Double] -> ControlPattern +``` + +### roomCount +``` +roomCount :: String -> ControlPattern +``` + +### roomCountTo +``` +roomCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### roombus +``` +roombus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### roomrecv +``` +roomrecv :: Pattern Int -> ControlPattern +``` + +### sagogo +``` +sagogo :: Pattern Double -> ControlPattern +``` + +### sagogoTake +``` +sagogoTake :: String -> [Double] -> ControlPattern +``` + +### sagogoCount +``` +sagogoCount :: String -> ControlPattern +``` + +### sagogoCountTo +``` +sagogoCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### sagogobus +``` +sagogobus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### sagogorecv +``` +sagogorecv :: Pattern Int -> ControlPattern +``` + +### sclap +``` +sclap :: Pattern Double -> ControlPattern +``` + +### sclapTake +``` +sclapTake :: String -> [Double] -> ControlPattern +``` + +### sclapCount +``` +sclapCount :: String -> ControlPattern +``` + +### sclapCountTo +``` +sclapCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### sclapbus +``` +sclapbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### sclaprecv +``` +sclaprecv :: Pattern Int -> ControlPattern +``` + +### sclaves +``` +sclaves :: Pattern Double -> ControlPattern +``` + +### sclavesTake +``` +sclavesTake :: String -> [Double] -> ControlPattern +``` + +### sclavesCount +``` +sclavesCount :: String -> ControlPattern +``` + +### sclavesCountTo +``` +sclavesCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### sclavesbus +``` +sclavesbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### sclavesrecv +``` +sclavesrecv :: Pattern Int -> ControlPattern +``` + +### scram +``` +scram :: Pattern Double -> ControlPattern +``` + +Spectral scramble + +### scramTake +``` +scramTake :: String -> [Double] -> ControlPattern +``` + +### scramCount +``` +scramCount :: String -> ControlPattern +``` + +### scramCountTo +``` +scramCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### scrambus +``` +scrambus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### scramrecv +``` +scramrecv :: Pattern Int -> ControlPattern +``` + +### scrash +``` +scrash :: Pattern Double -> ControlPattern +``` + +### scrashTake +``` +scrashTake :: String -> [Double] -> ControlPattern +``` + +### scrashCount +``` +scrashCount :: String -> ControlPattern +``` + +### scrashCountTo +``` +scrashCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### scrashbus +``` +scrashbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### scrashrecv +``` +scrashrecv :: Pattern Int -> ControlPattern +``` + +### seconds +``` +seconds :: Pattern Double -> ControlPattern +``` + +### secondsTake +``` +secondsTake :: String -> [Double] -> ControlPattern +``` + +### secondsCount +``` +secondsCount :: String -> ControlPattern +``` + +### secondsCountTo +``` +secondsCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### secondsbus +``` +secondsbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### semitone +``` +semitone :: Pattern Double -> ControlPattern +``` + +### semitoneTake +``` +semitoneTake :: String -> [Double] -> ControlPattern +``` + +### semitoneCount +``` +semitoneCount :: String -> ControlPattern +``` + +### semitoneCountTo +``` +semitoneCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### semitonebus +``` +semitonebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### semitonerecv +``` +semitonerecv :: Pattern Int -> ControlPattern +``` + +### shape +``` +shape :: Pattern Double -> ControlPattern +``` + +wave shaping distortion, a pattern of numbers from 0 for no distortion up to 1 for loads of distortion. + +### shapeTake +``` +shapeTake :: String -> [Double] -> ControlPattern +``` + +### shapeCount +``` +shapeCount :: String -> ControlPattern +``` + +### shapeCountTo +``` +shapeCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### shapebus +``` +shapebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### shaperecv +``` +shaperecv :: Pattern Int -> ControlPattern +``` + +### size +``` +size :: 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. + +### sizeTake +``` +sizeTake :: String -> [Double] -> ControlPattern +``` + +### sizeCount +``` +sizeCount :: String -> ControlPattern +``` + +### sizeCountTo +``` +sizeCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### sizebus +``` +sizebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### sizerecv +``` +sizerecv :: Pattern Int -> ControlPattern +``` + +### slide +``` +slide :: Pattern Double -> ControlPattern +``` + +### slideTake +``` +slideTake :: String -> [Double] -> ControlPattern +``` + +### slideCount +``` +slideCount :: String -> ControlPattern +``` + +### slideCountTo +``` +slideCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### slidebus +``` +slidebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### sliderecv +``` +sliderecv :: Pattern Int -> ControlPattern +``` + +### slider0 +``` +slider0 :: Pattern Double -> ControlPattern +``` + +### slider0Take +``` +slider0Take :: String -> [Double] -> ControlPattern +``` + +### slider0Count +``` +slider0Count :: String -> ControlPattern +``` + +### slider0CountTo +``` +slider0CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### slider0bus +``` +slider0bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### slider0recv +``` +slider0recv :: Pattern Int -> ControlPattern +``` + +### slider1 +``` +slider1 :: Pattern Double -> ControlPattern +``` + +### slider1Take +``` +slider1Take :: String -> [Double] -> ControlPattern +``` + +### slider1Count +``` +slider1Count :: String -> ControlPattern +``` + +### slider1CountTo +``` +slider1CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### slider1bus +``` +slider1bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### slider1recv +``` +slider1recv :: Pattern Int -> ControlPattern +``` + +### slider10 +``` +slider10 :: Pattern Double -> ControlPattern +``` + +### slider10Take +``` +slider10Take :: String -> [Double] -> ControlPattern +``` + +### slider10Count +``` +slider10Count :: String -> ControlPattern +``` + +### slider10CountTo +``` +slider10CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### slider10bus +``` +slider10bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### slider10recv +``` +slider10recv :: Pattern Int -> ControlPattern +``` + +### slider11 +``` +slider11 :: Pattern Double -> ControlPattern +``` + +### slider11Take +``` +slider11Take :: String -> [Double] -> ControlPattern +``` + +### slider11Count +``` +slider11Count :: String -> ControlPattern +``` + +### slider11CountTo +``` +slider11CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### slider11bus +``` +slider11bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### slider11recv +``` +slider11recv :: Pattern Int -> ControlPattern +``` + +### slider12 +``` +slider12 :: Pattern Double -> ControlPattern +``` + +### slider12Take +``` +slider12Take :: String -> [Double] -> ControlPattern +``` + +### slider12Count +``` +slider12Count :: String -> ControlPattern +``` + +### slider12CountTo +``` +slider12CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### slider12bus +``` +slider12bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### slider12recv +``` +slider12recv :: Pattern Int -> ControlPattern +``` + +### slider13 +``` +slider13 :: Pattern Double -> ControlPattern +``` + +### slider13Take +``` +slider13Take :: String -> [Double] -> ControlPattern +``` + +### slider13Count +``` +slider13Count :: String -> ControlPattern +``` + +### slider13CountTo +``` +slider13CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### slider13bus +``` +slider13bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### slider13recv +``` +slider13recv :: Pattern Int -> ControlPattern +``` + +### slider14 +``` +slider14 :: Pattern Double -> ControlPattern +``` + +### slider14Take +``` +slider14Take :: String -> [Double] -> ControlPattern +``` + +### slider14Count +``` +slider14Count :: String -> ControlPattern +``` + +### slider14CountTo +``` +slider14CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### slider14bus +``` +slider14bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### slider14recv +``` +slider14recv :: Pattern Int -> ControlPattern +``` + +### slider15 +``` +slider15 :: Pattern Double -> ControlPattern +``` + +### slider15Take +``` +slider15Take :: String -> [Double] -> ControlPattern +``` + +### slider15Count +``` +slider15Count :: String -> ControlPattern +``` + +### slider15CountTo +``` +slider15CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### slider15bus +``` +slider15bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### slider15recv +``` +slider15recv :: Pattern Int -> ControlPattern +``` + +### slider2 +``` +slider2 :: Pattern Double -> ControlPattern +``` + +### slider2Take +``` +slider2Take :: String -> [Double] -> ControlPattern +``` + +### slider2Count +``` +slider2Count :: String -> ControlPattern +``` + +### slider2CountTo +``` +slider2CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### slider2bus +``` +slider2bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### slider2recv +``` +slider2recv :: Pattern Int -> ControlPattern +``` + +### slider3 +``` +slider3 :: Pattern Double -> ControlPattern +``` + +### slider3Take +``` +slider3Take :: String -> [Double] -> ControlPattern +``` + +### slider3Count +``` +slider3Count :: String -> ControlPattern +``` + +### slider3CountTo +``` +slider3CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### slider3bus +``` +slider3bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### slider3recv +``` +slider3recv :: Pattern Int -> ControlPattern +``` + +### slider4 +``` +slider4 :: Pattern Double -> ControlPattern +``` + +### slider4Take +``` +slider4Take :: String -> [Double] -> ControlPattern +``` + +### slider4Count +``` +slider4Count :: String -> ControlPattern +``` + +### slider4CountTo +``` +slider4CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### slider4bus +``` +slider4bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### slider4recv +``` +slider4recv :: Pattern Int -> ControlPattern +``` + +### slider5 +``` +slider5 :: Pattern Double -> ControlPattern +``` + +### slider5Take +``` +slider5Take :: String -> [Double] -> ControlPattern +``` + +### slider5Count +``` +slider5Count :: String -> ControlPattern +``` + +### slider5CountTo +``` +slider5CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### slider5bus +``` +slider5bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### slider5recv +``` +slider5recv :: Pattern Int -> ControlPattern +``` + +### slider6 +``` +slider6 :: Pattern Double -> ControlPattern +``` + +### slider6Take +``` +slider6Take :: String -> [Double] -> ControlPattern +``` + +### slider6Count +``` +slider6Count :: String -> ControlPattern +``` + +### slider6CountTo +``` +slider6CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### slider6bus +``` +slider6bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### slider6recv +``` +slider6recv :: Pattern Int -> ControlPattern +``` + +### slider7 +``` +slider7 :: Pattern Double -> ControlPattern +``` + +### slider7Take +``` +slider7Take :: String -> [Double] -> ControlPattern +``` + +### slider7Count +``` +slider7Count :: String -> ControlPattern +``` + +### slider7CountTo +``` +slider7CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### slider7bus +``` +slider7bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### slider7recv +``` +slider7recv :: Pattern Int -> ControlPattern +``` + +### slider8 +``` +slider8 :: Pattern Double -> ControlPattern +``` + +### slider8Take +``` +slider8Take :: String -> [Double] -> ControlPattern +``` + +### slider8Count +``` +slider8Count :: String -> ControlPattern +``` + +### slider8CountTo +``` +slider8CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### slider8bus +``` +slider8bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### slider8recv +``` +slider8recv :: Pattern Int -> ControlPattern +``` + +### slider9 +``` +slider9 :: Pattern Double -> ControlPattern +``` + +### slider9Take +``` +slider9Take :: String -> [Double] -> ControlPattern +``` + +### slider9Count +``` +slider9Count :: String -> ControlPattern +``` + +### slider9CountTo +``` +slider9CountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### slider9bus +``` +slider9bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### slider9recv +``` +slider9recv :: Pattern Int -> ControlPattern +``` + +### smear +``` +smear :: Pattern Double -> ControlPattern +``` + +Spectral smear + +### smearTake +``` +smearTake :: String -> [Double] -> ControlPattern +``` + +### smearCount +``` +smearCount :: String -> ControlPattern +``` + +### smearCountTo +``` +smearCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### smearbus +``` +smearbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### smearrecv +``` +smearrecv :: Pattern Int -> ControlPattern +``` + +### songPtr +``` +songPtr :: Pattern Double -> ControlPattern +``` + +### songPtrTake +``` +songPtrTake :: String -> [Double] -> ControlPattern +``` + +### songPtrCount +``` +songPtrCount :: String -> ControlPattern +``` + +### songPtrCountTo +``` +songPtrCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### songPtrbus +``` +songPtrbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### speed +``` +speed :: 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! + +### speedTake +``` +speedTake :: String -> [Double] -> ControlPattern +``` + +### speedCount +``` +speedCount :: String -> ControlPattern +``` + +### speedCountTo +``` +speedCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### speedbus +``` +speedbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### squiz +``` +squiz :: Pattern Double -> ControlPattern +``` + +### squizTake +``` +squizTake :: String -> [Double] -> ControlPattern +``` + +### squizCount +``` +squizCount :: String -> ControlPattern +``` + +### squizCountTo +``` +squizCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### squizbus +``` +squizbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### squizrecv +``` +squizrecv :: Pattern Int -> ControlPattern +``` + +### stepsPerOctave +``` +stepsPerOctave :: Pattern Double -> ControlPattern +``` + +### stepsPerOctaveTake +``` +stepsPerOctaveTake :: String -> [Double] -> ControlPattern +``` + +### stepsPerOctaveCount +``` +stepsPerOctaveCount :: String -> ControlPattern +``` + +### stepsPerOctaveCountTo +``` +stepsPerOctaveCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### stepsPerOctavebus +``` +stepsPerOctavebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### stepsPerOctaverecv +``` +stepsPerOctaverecv :: Pattern Int -> ControlPattern +``` + +### stutterdepth +``` +stutterdepth :: Pattern Double -> ControlPattern +``` + +### stutterdepthTake +``` +stutterdepthTake :: String -> [Double] -> ControlPattern +``` + +### stutterdepthCount +``` +stutterdepthCount :: String -> ControlPattern +``` + +### stutterdepthCountTo +``` +stutterdepthCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### stutterdepthbus +``` +stutterdepthbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### stutterdepthrecv +``` +stutterdepthrecv :: Pattern Int -> ControlPattern +``` + +### stuttertime +``` +stuttertime :: Pattern Double -> ControlPattern +``` + +### stuttertimeTake +``` +stuttertimeTake :: String -> [Double] -> ControlPattern +``` + +### stuttertimeCount +``` +stuttertimeCount :: String -> ControlPattern +``` + +### stuttertimeCountTo +``` +stuttertimeCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### stuttertimebus +``` +stuttertimebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### stuttertimerecv +``` +stuttertimerecv :: Pattern Int -> ControlPattern +``` + +### sustain +``` +sustain :: Pattern Double -> ControlPattern +``` + +### sustainTake +``` +sustainTake :: String -> [Double] -> ControlPattern +``` + +### sustainCount +``` +sustainCount :: String -> ControlPattern +``` + +### sustainCountTo +``` +sustainCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### sustainbus +``` +sustainbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### sustainpedal +``` +sustainpedal :: Pattern Double -> ControlPattern +``` + +### sustainpedalTake +``` +sustainpedalTake :: String -> [Double] -> ControlPattern +``` + +### sustainpedalCount +``` +sustainpedalCount :: String -> ControlPattern +``` + +### sustainpedalCountTo +``` +sustainpedalCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### sustainpedalbus +``` +sustainpedalbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### sustainpedalrecv +``` +sustainpedalrecv :: Pattern Int -> ControlPattern +``` + +### timescale +``` +timescale :: Pattern Double -> ControlPattern +``` + +time stretch amount + +### timescaleTake +``` +timescaleTake :: String -> [Double] -> ControlPattern +``` + +### timescaleCount +``` +timescaleCount :: String -> ControlPattern +``` + +### timescaleCountTo +``` +timescaleCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### timescalebus +``` +timescalebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### timescalewin +``` +timescalewin :: Pattern Double -> ControlPattern +``` + +time stretch window size + +### timescalewinTake +``` +timescalewinTake :: String -> [Double] -> ControlPattern +``` + +### timescalewinCount +``` +timescalewinCount :: String -> ControlPattern +``` + +### timescalewinCountTo +``` +timescalewinCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### timescalewinbus +``` +timescalewinbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### to +``` +to :: Pattern Double -> ControlPattern +``` + +for internal sound routing + +### toTake +``` +toTake :: String -> [Double] -> ControlPattern +``` + +### toCount +``` +toCount :: String -> ControlPattern +``` + +### toCountTo +``` +toCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### tobus +``` +tobus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### torecv +``` +torecv :: Pattern Int -> ControlPattern +``` + +### toArg +``` +toArg :: Pattern String -> ControlPattern +``` + +for internal sound routing + +### toArgTake +``` +toArgTake :: String -> [Double] -> ControlPattern +``` + +### toArgbus +``` +toArgbus :: Pattern Int -> Pattern String -> ControlPattern +``` + +### toArgrecv +``` +toArgrecv :: Pattern Int -> ControlPattern +``` + +### tomdecay +``` +tomdecay :: Pattern Double -> ControlPattern +``` + +### tomdecayTake +``` +tomdecayTake :: String -> [Double] -> ControlPattern +``` + +### tomdecayCount +``` +tomdecayCount :: String -> ControlPattern +``` + +### tomdecayCountTo +``` +tomdecayCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### tomdecaybus +``` +tomdecaybus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### tomdecayrecv +``` +tomdecayrecv :: Pattern Int -> ControlPattern +``` + +### tremolodepth +``` +tremolodepth :: Pattern Double -> ControlPattern +``` + +Tremolo Audio DSP effect | params are `tremolorate` and `tremolodepth` + +### tremolodepthTake +``` +tremolodepthTake :: String -> [Double] -> ControlPattern +``` + +### tremolodepthCount +``` +tremolodepthCount :: String -> ControlPattern +``` + +### tremolodepthCountTo +``` +tremolodepthCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### tremolodepthbus +``` +tremolodepthbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### tremolodepthrecv +``` +tremolodepthrecv :: Pattern Int -> ControlPattern +``` + +### tremolorate +``` +tremolorate :: Pattern Double -> ControlPattern +``` + +Tremolo Audio DSP effect | params are `tremolorate` and `tremolodepth` + +### tremolorateTake +``` +tremolorateTake :: String -> [Double] -> ControlPattern +``` + +### tremolorateCount +``` +tremolorateCount :: String -> ControlPattern +``` + +### tremolorateCountTo +``` +tremolorateCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### tremoloratebus +``` +tremoloratebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### tremoloraterecv +``` +tremoloraterecv :: Pattern Int -> ControlPattern +``` + +### triode +``` +triode :: Pattern Double -> ControlPattern +``` + +tube distortion + +### triodeTake +``` +triodeTake :: String -> [Double] -> ControlPattern +``` + +### triodeCount +``` +triodeCount :: String -> ControlPattern +``` + +### triodeCountTo +``` +triodeCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### triodebus +``` +triodebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### trioderecv +``` +trioderecv :: Pattern Int -> ControlPattern +``` + +### tsdelay +``` +tsdelay :: Pattern Double -> ControlPattern +``` + +### tsdelayTake +``` +tsdelayTake :: String -> [Double] -> ControlPattern +``` + +### tsdelayCount +``` +tsdelayCount :: String -> ControlPattern +``` + +### tsdelayCountTo +``` +tsdelayCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### tsdelaybus +``` +tsdelaybus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### tsdelayrecv +``` +tsdelayrecv :: Pattern Int -> ControlPattern +``` + +### uid +``` +uid :: Pattern Double -> ControlPattern +``` + +### uidTake +``` +uidTake :: String -> [Double] -> ControlPattern +``` + +### uidCount +``` +uidCount :: String -> ControlPattern +``` + +### uidCountTo +``` +uidCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### uidbus +``` +uidbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### unit +``` +unit :: Pattern String -> 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`. + +### unitTake +``` +unitTake :: String -> [Double] -> ControlPattern +``` + +### unitbus +``` +unitbus :: Pattern Int -> Pattern String -> ControlPattern +``` + +### val +``` +val :: Pattern Double -> ControlPattern +``` + +### valTake +``` +valTake :: String -> [Double] -> ControlPattern +``` + +### valCount +``` +valCount :: String -> ControlPattern +``` + +### valCountTo +``` +valCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### valbus +``` +valbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### vcfegint +``` +vcfegint :: Pattern Double -> ControlPattern +``` + +### vcfegintTake +``` +vcfegintTake :: String -> [Double] -> ControlPattern +``` + +### vcfegintCount +``` +vcfegintCount :: String -> ControlPattern +``` + +### vcfegintCountTo +``` +vcfegintCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### vcfegintbus +``` +vcfegintbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### vcfegintrecv +``` +vcfegintrecv :: Pattern Int -> ControlPattern +``` + +### vcoegint +``` +vcoegint :: Pattern Double -> ControlPattern +``` + +### vcoegintTake +``` +vcoegintTake :: String -> [Double] -> ControlPattern +``` + +### vcoegintCount +``` +vcoegintCount :: String -> ControlPattern +``` + +### vcoegintCountTo +``` +vcoegintCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### vcoegintbus +``` +vcoegintbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### vcoegintrecv +``` +vcoegintrecv :: Pattern Int -> ControlPattern +``` + +### velocity +``` +velocity :: Pattern Double -> ControlPattern +``` + +### velocityTake +``` +velocityTake :: String -> [Double] -> ControlPattern +``` + +### velocityCount +``` +velocityCount :: String -> ControlPattern +``` + +### velocityCountTo +``` +velocityCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### velocitybus +``` +velocitybus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### velocityrecv +``` +velocityrecv :: Pattern Int -> ControlPattern +``` + +### voice +``` +voice :: Pattern Double -> ControlPattern +``` + +### voiceTake +``` +voiceTake :: String -> [Double] -> ControlPattern +``` + +### voiceCount +``` +voiceCount :: String -> ControlPattern +``` + +### voiceCountTo +``` +voiceCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### voicebus +``` +voicebus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### voicerecv +``` +voicerecv :: Pattern Int -> ControlPattern +``` + +### vowel +``` +vowel :: Pattern String -> 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. + +### vowelTake +``` +vowelTake :: String -> [Double] -> ControlPattern +``` + +### vowelbus +``` +vowelbus :: Pattern Int -> Pattern String -> ControlPattern +``` + +### vowelrecv +``` +vowelrecv :: Pattern Int -> ControlPattern +``` + +### waveloss +``` +waveloss :: Pattern Double -> ControlPattern +``` + +### wavelossTake +``` +wavelossTake :: String -> [Double] -> ControlPattern +``` + +### wavelossCount +``` +wavelossCount :: String -> ControlPattern +``` + +### wavelossCountTo +``` +wavelossCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### wavelossbus +``` +wavelossbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### wavelossrecv +``` +wavelossrecv :: Pattern Int -> ControlPattern +``` + +### xsdelay +``` +xsdelay :: Pattern Double -> ControlPattern +``` + +### xsdelayTake +``` +xsdelayTake :: String -> [Double] -> ControlPattern +``` + +### xsdelayCount +``` +xsdelayCount :: String -> ControlPattern +``` + +### xsdelayCountTo +``` +xsdelayCountTo :: String -> Pattern Double -> Pattern ValueMap +``` + +### xsdelaybus +``` +xsdelaybus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### xsdelayrecv +``` +xsdelayrecv :: Pattern Int -> ControlPattern +``` + +### voi +``` +voi :: Pattern Double -> ControlPattern +``` + +### voibus +``` +voibus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### voirecv +``` +voirecv :: Pattern Int -> ControlPattern +``` + +### vco +``` +vco :: Pattern Double -> ControlPattern +``` + +### vcobus +``` +vcobus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### vcorecv +``` +vcorecv :: Pattern Int -> ControlPattern +``` + +### vcf +``` +vcf :: Pattern Double -> ControlPattern +``` + +### vcfbus +``` +vcfbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### vcfrecv +``` +vcfrecv :: Pattern Int -> ControlPattern +``` + +### up +``` +up :: Pattern Note -> ControlPattern +``` + +### tremr +``` +tremr :: Pattern Double -> ControlPattern +``` + +### tremrbus +``` +tremrbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### tremrrecv +``` +tremrrecv :: Pattern Int -> ControlPattern +``` + +### tremdp +``` +tremdp :: Pattern Double -> ControlPattern +``` + +### tremdpbus +``` +tremdpbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### tremdprecv +``` +tremdprecv :: Pattern Int -> ControlPattern +``` + +### tdecay +``` +tdecay :: Pattern Double -> ControlPattern +``` + +### tdecaybus +``` +tdecaybus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### tdecayrecv +``` +tdecayrecv :: Pattern Int -> ControlPattern +``` + +### sz +``` +sz :: Pattern Double -> ControlPattern +``` + +### szbus +``` +szbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### szrecv +``` +szrecv :: Pattern Int -> ControlPattern +``` + +### sus +``` +sus :: Pattern Double -> ControlPattern +``` + +### stt +``` +stt :: Pattern Double -> ControlPattern +``` + +### sttbus +``` +sttbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### sttrecv +``` +sttrecv :: Pattern Int -> ControlPattern +``` + +### std +``` +std :: Pattern Double -> ControlPattern +``` + +### stdbus +``` +stdbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### stdrecv +``` +stdrecv :: Pattern Int -> ControlPattern +``` + +### sld +``` +sld :: Pattern Double -> ControlPattern +``` + +### sldbus +``` +sldbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### sldrecv +``` +sldrecv :: Pattern Int -> ControlPattern +``` + +### scr +``` +scr :: Pattern Double -> ControlPattern +``` + +### scrbus +``` +scrbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### scrrecv +``` +scrrecv :: Pattern Int -> ControlPattern +``` + +### scp +``` +scp :: Pattern Double -> ControlPattern +``` + +### scpbus +``` +scpbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### scprecv +``` +scprecv :: Pattern Int -> ControlPattern +``` + +### scl +``` +scl :: Pattern Double -> ControlPattern +``` + +### sclbus +``` +sclbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### sclrecv +``` +sclrecv :: Pattern Int -> ControlPattern +``` + +### sag +``` +sag :: Pattern Double -> ControlPattern +``` + +### sagbus +``` +sagbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### sagrecv +``` +sagrecv :: Pattern Int -> ControlPattern +``` + +### s +``` +s :: Pattern String -> ControlPattern +``` + +### rel +``` +rel :: Pattern Double -> ControlPattern +``` + +### relbus +``` +relbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### relrecv +``` +relrecv :: Pattern Int -> ControlPattern +``` + +### por +``` +por :: Pattern Double -> ControlPattern +``` + +### porbus +``` +porbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### porrecv +``` +porrecv :: Pattern Int -> ControlPattern +``` + +### pit3 +``` +pit3 :: Pattern Double -> ControlPattern +``` + +### pit3bus +``` +pit3bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### pit3recv +``` +pit3recv :: Pattern Int -> ControlPattern +``` + +### pit2 +``` +pit2 :: Pattern Double -> ControlPattern +``` + +### pit2bus +``` +pit2bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### pit2recv +``` +pit2recv :: Pattern Int -> ControlPattern +``` + +### pit1 +``` +pit1 :: Pattern Double -> ControlPattern +``` + +### pit1bus +``` +pit1bus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### pit1recv +``` +pit1recv :: Pattern Int -> ControlPattern +``` + +### phasr +``` +phasr :: Pattern Double -> ControlPattern +``` + +### phasrbus +``` +phasrbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### phasrrecv +``` +phasrrecv :: Pattern Int -> ControlPattern +``` + +### phasdp +``` +phasdp :: Pattern Double -> ControlPattern +``` + +### phasdpbus +``` +phasdpbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### phasdprecv +``` +phasdprecv :: Pattern Int -> ControlPattern +``` + +### ohdecay +``` +ohdecay :: Pattern Double -> ControlPattern +``` + +### ohdecaybus +``` +ohdecaybus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### ohdecayrecv +``` +ohdecayrecv :: Pattern Int -> ControlPattern +``` + +### number +``` +number :: Pattern Note -> ControlPattern +``` + +### lsn +``` +lsn :: Pattern Double -> ControlPattern +``` + +### lsnbus +``` +lsnbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lsnrecv +``` +lsnrecv :: Pattern Int -> ControlPattern +``` + +### lpq +``` +lpq :: Pattern Double -> ControlPattern +``` + +### lpqbus +``` +lpqbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lpqrecv +``` +lpqrecv :: Pattern Int -> ControlPattern +``` + +### lpf +``` +lpf :: Pattern Double -> ControlPattern +``` + +### lpfbus +``` +lpfbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lpfrecv +``` +lpfrecv :: Pattern Int -> ControlPattern +``` + +### loh +``` +loh :: Pattern Double -> ControlPattern +``` + +### lohbus +``` +lohbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lohrecv +``` +lohrecv :: Pattern Int -> ControlPattern +``` + +### llt +``` +llt :: Pattern Double -> ControlPattern +``` + +### lltbus +``` +lltbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lltrecv +``` +lltrecv :: Pattern Int -> ControlPattern +``` + +### lht +``` +lht :: Pattern Double -> ControlPattern +``` + +### lhtbus +``` +lhtbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lhtrecv +``` +lhtrecv :: Pattern Int -> ControlPattern +``` + +### lfop +``` +lfop :: Pattern Double -> ControlPattern +``` + +### lfopbus +``` +lfopbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lfoprecv +``` +lfoprecv :: Pattern Int -> ControlPattern +``` + +### lfoi +``` +lfoi :: Pattern Double -> ControlPattern +``` + +### lfoibus +``` +lfoibus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lfoirecv +``` +lfoirecv :: Pattern Int -> ControlPattern +``` + +### lfoc +``` +lfoc :: Pattern Double -> ControlPattern +``` + +### lfocbus +``` +lfocbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lfocrecv +``` +lfocrecv :: Pattern Int -> ControlPattern +``` + +### lcr +``` +lcr :: Pattern Double -> ControlPattern +``` + +### lcrbus +``` +lcrbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lcrrecv +``` +lcrrecv :: Pattern Int -> ControlPattern +``` + +### lcp +``` +lcp :: Pattern Double -> ControlPattern +``` + +### lcpbus +``` +lcpbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lcprecv +``` +lcprecv :: Pattern Int -> ControlPattern +``` + +### lcl +``` +lcl :: Pattern Double -> ControlPattern +``` + +### lclbus +``` +lclbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lclrecv +``` +lclrecv :: Pattern Int -> ControlPattern +``` + +### lch +``` +lch :: Pattern Double -> ControlPattern +``` + +### lchbus +``` +lchbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lchrecv +``` +lchrecv :: Pattern Int -> ControlPattern +``` + +### lbd +``` +lbd :: Pattern Double -> ControlPattern +``` + +### lbdbus +``` +lbdbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lbdrecv +``` +lbdrecv :: Pattern Int -> ControlPattern +``` + +### lag +``` +lag :: Pattern Double -> ControlPattern +``` + +### lagbus +``` +lagbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### lagrecv +``` +lagrecv :: Pattern Int -> ControlPattern +``` + +### hpq +``` +hpq :: Pattern Double -> ControlPattern +``` + +### hpqbus +``` +hpqbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### hpqrecv +``` +hpqrecv :: Pattern Int -> ControlPattern +``` + +### hpf +``` +hpf :: Pattern Double -> ControlPattern +``` + +### hpfbus +``` +hpfbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### hpfrecv +``` +hpfrecv :: Pattern Int -> ControlPattern +``` + +### hg +``` +hg :: Pattern Double -> ControlPattern +``` + +### hgbus +``` +hgbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### hgrecv +``` +hgrecv :: Pattern Int -> ControlPattern +``` + +### gat +``` +gat :: Pattern Double -> ControlPattern +``` + +### gatbus +``` +gatbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### gatrecv +``` +gatrecv :: Pattern Int -> ControlPattern +``` + +### fadeOutTime +``` +fadeOutTime :: Pattern Double -> ControlPattern +``` + +### dt +``` +dt :: Pattern Double -> ControlPattern +``` + +### dtbus +``` +dtbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### dtrecv +``` +dtrecv :: Pattern Int -> ControlPattern +``` + +### dfb +``` +dfb :: Pattern Double -> ControlPattern +``` + +### dfbbus +``` +dfbbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### dfbrecv +``` +dfbrecv :: Pattern Int -> ControlPattern +``` + +### det +``` +det :: Pattern Double -> ControlPattern +``` + +### detbus +``` +detbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### detrecv +``` +detrecv :: Pattern Int -> ControlPattern +``` + +### delayt +``` +delayt :: Pattern Double -> ControlPattern +``` + +### delaytbus +``` +delaytbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### delaytrecv +``` +delaytrecv :: Pattern Int -> ControlPattern +``` + +### delayfb +``` +delayfb :: Pattern Double -> ControlPattern +``` + +### delayfbbus +``` +delayfbbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### delayfbrecv +``` +delayfbrecv :: Pattern Int -> ControlPattern +``` + +### ctfg +``` +ctfg :: Pattern Double -> ControlPattern +``` + +### ctfgbus +``` +ctfgbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### ctfgrecv +``` +ctfgrecv :: Pattern Int -> ControlPattern +``` + +### ctf +``` +ctf :: Pattern Double -> ControlPattern +``` + +### ctfbus +``` +ctfbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### ctfrecv +``` +ctfrecv :: Pattern Int -> ControlPattern +``` + +### chdecay +``` +chdecay :: Pattern Double -> ControlPattern +``` + +### chdecaybus +``` +chdecaybus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### chdecayrecv +``` +chdecayrecv :: Pattern Int -> ControlPattern +``` + +### bpq +``` +bpq :: Pattern Double -> ControlPattern +``` + +### bpqbus +``` +bpqbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### bpqrecv +``` +bpqrecv :: Pattern Int -> ControlPattern +``` + +### bpf +``` +bpf :: Pattern Double -> ControlPattern +``` + +### bpfbus +``` +bpfbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### bpfrecv +``` +bpfrecv :: Pattern Int -> ControlPattern +``` + +### att +``` +att :: Pattern Double -> ControlPattern +``` + +### attbus +``` +attbus :: Pattern Int -> Pattern Double -> ControlPattern +``` + +### attrecv +``` +attrecv :: Pattern Int -> ControlPattern +``` + diff --git a/docs/library/autogenerated/Sound-Tidal-ParseBP/Sound-Tidal-ParseBP.mdx b/docs/library/autogenerated/Sound-Tidal-ParseBP/Sound-Tidal-ParseBP.mdx new file mode 100644 index 0000000000..0ced99bb37 --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-ParseBP/Sound-Tidal-ParseBP.mdx @@ -0,0 +1,422 @@ +--- +title: Sound.Tidal.ParseBP +slug: /library/modules/Sound.Tidal.ParseBP +--- + + + +### data +``` +data TidalParseError +``` + +### type +``` +type MyParser = Parsec String Int +``` + +### data +``` +data TPat a where +``` + +AST representation of patterns + +### tShowList +``` +tShowList :: Show a => [TPat a] -> String +``` + +### tShow +``` +tShow :: Show a => TPat a -> String +``` + +### toPat +``` +toPat :: (Parseable a, Enumerable a) => TPat a -> Pattern a +``` + +### resolve_tpat +``` +resolve_tpat :: (Enumerable a, Parseable a) => TPat a -> (Rational, Pattern a) +``` + +### resolve_seq +``` +resolve_seq :: (Enumerable a, Parseable a) => [TPat a] -> (Rational, Pattern a) +``` + +### resolve_size +``` +resolve_size :: [TPat a] -> [(Rational, TPat a)] +``` + +### steps_tpat +``` +steps_tpat :: Show a => TPat a -> (Rational, String) +``` + +### steps_seq +``` +steps_seq :: Show a => [TPat a] -> (Rational, String) +``` + +### steps_size +``` +steps_size :: Show a => [TPat a] -> [(Rational, String)] +``` + +### parseBP +``` +parseBP :: (Enumerable a, Parseable a) => String -> Either ParseError (Pattern a) +``` + +### parseBP_E +``` +parseBP_E :: (Enumerable a, Parseable a) => String -> Pattern a +``` + +### parseTPat +``` +parseTPat :: Parseable a => String -> Either ParseError (TPat a) +``` + +### cP +``` +cP :: (Enumerable a, Parseable a) => String -> Pattern a +``` + +### class +``` +class Parseable a where +``` + +### class +``` +class Enumerable a where +``` + +### enumFromTo' +``` +enumFromTo' :: (Ord a, Enum a) => a -> a -> Pattern a +``` + +### enumFromThenTo' +``` +enumFromThenTo' :: (Ord a, Enum a, Num a) => a -> a -> a -> Pattern a +``` + +### type +``` +type ColourD = Colour Double +``` + +### lexer +``` +lexer :: GenTokenParser String u Identity +``` + +### braces +``` +braces :: MyParser a -> MyParser a +``` + +### brackets +``` +brackets :: MyParser a -> MyParser a +``` + +### parens +``` +parens :: MyParser a -> MyParser a +``` + +### angles +``` +angles :: MyParser a -> MyParser a +``` + +### symbol +``` +symbol :: String -> MyParser String +``` + +### natural +``` +natural :: MyParser Integer +``` + +### integer +``` +integer :: MyParser Integer +``` + +### decimal +``` +decimal :: MyParser Integer +``` + +### float +``` +float :: MyParser Double +``` + +### naturalOrFloat +``` +naturalOrFloat :: MyParser (Either Integer Double) +``` + +### data +``` +data Sign +``` + +### applySign +``` +applySign :: Num a => Sign -> a -> a +``` + +### sign +``` +sign :: MyParser Sign +``` + +### intOrFloat +``` +intOrFloat :: MyParser Double +``` + +### pSequence +``` +pSequence :: Parseable a => MyParser (TPat a) -> MyParser (TPat a) +``` + +### pRepeat +``` +pRepeat :: TPat a -> MyParser (TPat a) +``` + +### pElongate +``` +pElongate :: TPat a -> MyParser (TPat a) +``` + +### pSingle +``` +pSingle :: MyParser (TPat a) -> MyParser (TPat a) +``` + +### pVar +``` +pVar :: MyParser (TPat a) +``` + +### pPart +``` +pPart :: Parseable a => MyParser (TPat a) -> MyParser (TPat a) +``` + +### newSeed +``` +newSeed :: MyParser Int +``` + +### pPolyIn +``` +pPolyIn :: Parseable a => MyParser (TPat a) -> MyParser (TPat a) +``` + +### pPolyOut +``` +pPolyOut :: Parseable a => MyParser (TPat a) -> MyParser (TPat a) +``` + +### pCharNum +``` +pCharNum :: MyParser Char +``` + +### pString +``` +pString :: MyParser String +``` + +### wrapPos +``` +wrapPos :: MyParser (TPat a) -> MyParser (TPat a) +``` + +### pVocable +``` +pVocable :: MyParser (TPat String) +``` + +### pChar +``` +pChar :: MyParser (TPat Char) +``` + +### pDouble +``` +pDouble :: MyParser (TPat Double) +``` + +### pDoubleWithoutChord +``` +pDoubleWithoutChord :: MyParser (TPat Double) +``` + +### pNote +``` +pNote :: MyParser (TPat Note) +``` + +### pNoteWithoutChord +``` +pNoteWithoutChord :: MyParser (TPat Note) +``` + +### pBool +``` +pBool :: MyParser (TPat Bool) +``` + +### parseIntNote +``` +parseIntNote :: Integral i => MyParser i +``` + +### pIntegral +``` +pIntegral :: (Integral a, Parseable a, Enumerable a) => MyParser (TPat a) +``` + +### pIntegralWithoutChord +``` +pIntegralWithoutChord :: (Integral a, Parseable a, Enumerable a) => MyParser (TPat a) +``` + +### parseChord +``` +parseChord :: (Enum a, Num a) => MyParser [a] +``` + +### parseNote +``` +parseNote :: Num a => MyParser a +``` + +### fromNote +``` +fromNote :: Num a => Pattern String -> Pattern a +``` + +### pColour +``` +pColour :: MyParser (TPat ColourD) +``` + +### pMult +``` +pMult :: TPat a -> MyParser (TPat a) +``` + +### pRand +``` +pRand :: TPat a -> MyParser (TPat a) +``` + +### pE +``` +pE :: TPat a -> MyParser (TPat a) +``` + +### pRational +``` +pRational :: MyParser (TPat Rational) +``` + +### pRatio +``` +pRatio :: MyParser Rational +``` + +### pInteger +``` +pInteger :: MyParser Double +``` + +### pFloat +``` +pFloat :: MyParser Double +``` + +### pFraction +``` +pFraction :: RealFrac a => a -> MyParser Rational +``` + +### pRatioChar +``` +pRatioChar :: Fractional a => MyParser a +``` + +### pRatioSingleChar +``` +pRatioSingleChar :: Fractional a => Char -> a -> MyParser a +``` + +### isInt +``` +isInt :: RealFrac a => a -> Bool +``` + +### parseModInv +``` +parseModInv :: MyParser Modifier +``` + +### parseModInvNum +``` +parseModInvNum :: MyParser [Modifier] +``` + +### parseModDrop +``` +parseModDrop :: MyParser [Modifier] +``` + +### parseModOpen +``` +parseModOpen :: MyParser Modifier +``` + +### parseModRange +``` +parseModRange :: MyParser Modifier +``` + +### parseModifiers +``` +parseModifiers :: MyParser [Modifier] +``` + +### pModifiers +``` +pModifiers :: MyParser (TPat [Modifier]) +``` + +### pChord +``` +pChord :: (Enum a, Num a, Parseable a, Enumerable a) => TPat a -> MyParser (TPat a) +``` + diff --git a/docs/library/autogenerated/Sound-Tidal-Pattern/Sound-Tidal-Pattern.mdx b/docs/library/autogenerated/Sound-Tidal-Pattern/Sound-Tidal-Pattern.mdx new file mode 100644 index 0000000000..1921f06412 --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Pattern/Sound-Tidal-Pattern.mdx @@ -0,0 +1,696 @@ +--- +title: Sound.Tidal.Pattern +slug: /library/modules/Sound.Tidal.Pattern +--- + + + +### type +``` +type Event a = EventF (ArcF Time) a +``` + +### data +``` +data State +``` + +an Arc and some named control values + +### data +``` +data Pattern a +``` + +A datatype representing events taking place over time + +### data +``` +data Context +``` + +Some context for an event, currently just position within sourcecode + +### type +``` +type ControlPattern = Pattern ValueMap +``` + +### type +``` +type ValueMap = Map String Value +``` + +### class +``` +class Moddable a where +``` + +### newtype +``` +newtype Note +``` + +Note is Double, but with a different parser + +### data +``` +data Value +``` + +Polymorphic values + +### class +``` +class Stringy a where +``` + +### data +``` +data EventF a b +``` + +An event is a value that's active during a timespan. If a whole + is present, the part should be equal to or fit inside it. + +### class +``` +class Valuable a where +``` + +### (*>) +``` +(*>) :: Pattern (a -> b) -> Pattern a -> Pattern b infixl 4 +``` + +Like *, but the `wholes` come from the right + +### empty +``` +empty :: Pattern a +``` + +### (<*) +``` +(<*) :: Pattern (a -> b) -> Pattern a -> Pattern b infixl 4 +``` + +Like *, but the `wholes` come from the left + +### silence +``` +silence :: Pattern a +``` + +### rev +``` +rev :: Pattern a -> Pattern a +``` + +`rev p` returns `p` with the event positions in each cycle + reversed (or mirrored). + +### noOv +``` +noOv :: String -> a +``` + +### applyPatToPatBoth +``` +applyPatToPatBoth :: Pattern (a -> b) -> Pattern a -> Pattern b +``` + +### applyPatToPatLeft +``` +applyPatToPatLeft :: Pattern (a -> b) -> Pattern a -> Pattern b +``` + +### applyPatToPatRight +``` +applyPatToPatRight :: Pattern (a -> b) -> Pattern a -> Pattern b +``` + +### (<<*) +``` +(<<*) :: Pattern (a -> b) -> Pattern a -> Pattern b infixl 4 +``` + +Like *, but the `wholes` come from the left + +### applyPatToPatSqueeze +``` +applyPatToPatSqueeze :: Pattern (a -> b) -> Pattern a -> Pattern b +``` + +### applyPatToPat +``` +applyPatToPat :: (Maybe Arc -> Maybe Arc -> Maybe (Maybe Arc)) -> Pattern (a -> b) -> Pattern a -> Pattern b +``` + +### wholeOrPart +``` +wholeOrPart :: Event a -> Arc +``` + +### filterAnalog +``` +filterAnalog :: Pattern a -> Pattern a +``` + +### filterDigital +``` +filterDigital :: Pattern a -> Pattern a +``` + +### combineContexts +``` +combineContexts :: [Context] -> Context +``` + +### squeezeJoin +``` +squeezeJoin :: 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? + +### unwrap +``` +unwrap :: Pattern (Pattern a) -> Pattern a +``` + +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? + +### innerJoin +``` +innerJoin :: Pattern (Pattern a) -> Pattern a +``` + +Turns a pattern of patterns into a single pattern. Like `unwrap`, + but structure only comes from the inner pattern. + +### outerJoin +``` +outerJoin :: Pattern (Pattern a) -> Pattern a +``` + +Turns a pattern of patterns into a single pattern. Like `unwrap`, + but structure only comes from the outer pattern. + +### focusArc +``` +focusArc :: Arc -> Pattern a -> Pattern a +``` + +### applyFIS +``` +applyFIS :: (Double -> Double) -> (Int -> Int) -> (String -> String) -> Value -> Value +``` + +General utilities.. + +Apply one of three functions to a Value, depending on its type + +### fNum2 +``` +fNum2 :: (Int -> Int -> Int) -> (Double -> Double -> Double) -> Value -> Value -> Value +``` + +Apply one of two functions to a pair of Values, depending on their types (int + or float; strings and rationals are ignored) + +### queryArc +``` +queryArc :: Pattern a -> Arc -> [Event a] +``` + +### splitQueries +``` +splitQueries :: Pattern a -> Pattern a +``` + +Splits queries that span cycles. For example `query p (0.5, 1.5)` would be + turned into two queries, `(0.5,1)` and `(1,1.5)`, and the results + combined. Being able to assume queries don't span cycles often + makes transformations easier to specify. + +### withResultArc +``` +withResultArc :: (Arc -> Arc) -> Pattern a -> Pattern a +``` + +Apply a function to the arcs/timespans (both whole and parts) of the result + +### withResultTime +``` +withResultTime :: (Time -> Time) -> 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 + +### withQueryArc +``` +withQueryArc :: (Arc -> Arc) -> Pattern a -> Pattern a +``` + +Apply a function to the timespan of the query + +### withQueryTime +``` +withQueryTime :: (Time -> Time) -> Pattern a -> Pattern a +``` + +Apply a function to the time (both start and end) of the query + +### withQueryControls +``` +withQueryControls :: (ValueMap -> ValueMap) -> Pattern a -> Pattern a +``` + +Apply a function to the control values of the query + +### withEvent +``` +withEvent :: (Event a -> Event b) -> Pattern a -> Pattern b +``` + +`withEvent f p` returns a new `Pattern` with each event mapped over + function `f`. + +### withValue +``` +withValue :: (a -> b) -> Pattern a -> Pattern b +``` + +`withEvent f p` returns a new `Pattern` with each value mapped over + function `f`. + +### withEvents +``` +withEvents :: ([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`. + +### withPart +``` +withPart :: (Arc -> Arc) -> Pattern a -> Pattern a +``` + +`withPart f p` returns a new `Pattern` with function `f` applied + to the part. + +### _extract +``` +_extract :: (Value -> Maybe a) -> String -> ControlPattern -> Pattern a +``` + +### filterJust +``` +filterJust :: Pattern (Maybe a) -> Pattern a +``` + +Turns a pattern of `Maybe` values into a pattern of values, + dropping the events of `Nothing`. + +### extractI +``` +extractI :: String -> ControlPattern -> Pattern Int +``` + +Extract a pattern of integer values by from a control pattern, given the name of the control + +### getI +``` +getI :: Value -> Maybe Int +``` + +### extractF +``` +extractF :: String -> ControlPattern -> Pattern Double +``` + +Extract a pattern of floating point values by from a control pattern, given the name of the control + +### getF +``` +getF :: Value -> Maybe Double +``` + +### extractS +``` +extractS :: String -> ControlPattern -> Pattern String +``` + +Extract a pattern of string values by from a control pattern, given the name of the control + +### getS +``` +getS :: Value -> Maybe String +``` + +### extractB +``` +extractB :: String -> ControlPattern -> Pattern Bool +``` + +Extract a pattern of boolean values by from a control pattern, given the name of the control + +### getB +``` +getB :: Value -> Maybe Bool +``` + +### extractR +``` +extractR :: String -> ControlPattern -> Pattern Rational +``` + +Extract a pattern of rational values by from a control pattern, given the name of the control + +### getR +``` +getR :: Value -> Maybe Rational +``` + +### compressArc +``` +compressArc :: Arc -> Pattern a -> Pattern a +``` + +### rotR +``` +rotR :: Time -> Pattern a -> Pattern a +``` + +Shifts a pattern forward in time by the given amount, expressed in cycles + +### _fastGap +``` +_fastGap :: Time -> Pattern a -> Pattern a +``` + +### compressArcTo +``` +compressArcTo :: Arc -> Pattern a -> Pattern a +``` + +### _fast +``` +_fast :: Time -> Pattern a -> Pattern a +``` + +### fast +``` +fast :: Pattern Time -> Pattern a -> Pattern a +``` + +Speed up a pattern by the given time pattern + +### tParam +``` +tParam :: (t1 -> t2 -> Pattern a) -> Pattern t1 -> t2 -> Pattern a +``` + +### fastSqueeze +``` +fastSqueeze :: 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 + +### tParamSqueeze +``` +tParamSqueeze :: (a -> Pattern b -> Pattern c) -> Pattern a -> Pattern b -> Pattern c +``` + +### density +``` +density :: Pattern Time -> Pattern a -> Pattern a +``` + +An alias for `fast` + +### slow +``` +slow :: Pattern Time -> Pattern a -> Pattern a +``` + +Slow down a pattern by the given time pattern + +### _slow +``` +_slow :: Time -> Pattern a -> Pattern a +``` + +### rotL +``` +rotL :: Time -> Pattern a -> Pattern a +``` + +Shifts a pattern back in time by the given amount, expressed in cycles + +### matchManyToOne +``` +matchManyToOne :: (b -> a -> Bool) -> Pattern a -> Pattern b -> Pattern (Bool, b) +``` + +Mark values in the first pattern which match with at least one + value in the second pattern. + +### filterValues +``` +filterValues :: (a -> Bool) -> Pattern a -> Pattern a +``` + +Remove events from patterns that to not meet the given test + +### filterWhen +``` +filterWhen :: (Time -> Bool) -> Pattern a -> Pattern a +``` + +### wholeStart +``` +wholeStart :: Event a -> Time +``` + +Get the onset of an event's `whole` + +### filterOnsets +``` +filterOnsets :: Pattern a -> Pattern a +``` + +### eventPartStart +``` +eventPartStart :: Event a -> Time +``` + +Get the onset of an event's `whole` + +### filterEvents +``` +filterEvents :: (Event a -> Bool) -> Pattern a -> Pattern a +``` + +### isDigital +``` +isDigital :: Event a -> Bool +``` + +### isAnalog +``` +isAnalog :: Event a -> Bool +``` + +### playFor +``` +playFor :: Time -> Time -> Pattern a -> Pattern a +``` + +### tParam2 +``` +tParam2 :: (a -> b -> c -> Pattern d) -> Pattern a -> Pattern b -> c -> Pattern d +``` + +### tParam3 +``` +tParam3 :: (a -> b -> c -> Pattern d -> Pattern e) -> Pattern a -> Pattern b -> Pattern c -> Pattern d -> Pattern e +``` + +### setContext +``` +setContext :: Context -> Pattern a -> Pattern a +``` + +### withContext +``` +withContext :: (Context -> Context) -> Pattern a -> Pattern a +``` + +### deltaMini +``` +deltaMini :: String -> String +``` + +### onsetIn +``` +onsetIn :: Arc -> Event a -> Bool +``` + +`True` if an `EventF`'s starts is within given `ArcF` + +### defragParts +``` +defragParts :: Eq a => [Event a] -> [Event a] +``` + +Returns a list of events, with any adjacent parts of the same whole combined + +### isAdjacent +``` +isAdjacent :: Eq a => Event a -> Event a -> Bool +``` + +Returns `True` if the two given events are adjacent parts of the same whole + +### wholeStop +``` +wholeStop :: Event a -> Time +``` + +Get the offset of an event's `whole` + +### eventPartStop +``` +eventPartStop :: Event a -> Time +``` + +Get the offset of an event's `part` + +### eventPart +``` +eventPart :: Event a -> Arc +``` + +Get the timespan of an event's `part` + +### eventValue +``` +eventValue :: Event a -> a +``` + +### eventHasOnset +``` +eventHasOnset :: Event a -> Bool +``` + +### toEvent +``` +toEvent :: (((Time, Time), (Time, Time)), a) -> Event a +``` + +### resolveState +``` +resolveState :: ValueMap -> [Event ValueMap] -> (ValueMap, [Event ValueMap]) +``` + +### getN +``` +getN :: Value -> Maybe Note +``` + +### getBlob +``` +getBlob :: Value -> Maybe [Word8] +``` + +### getList +``` +getList :: Value -> Maybe [Value] +``` + +### valueToPattern +``` +valueToPattern :: Value -> Pattern Value +``` + +### sameDur +``` +sameDur :: Event a -> Event a -> Bool +``` + +### groupEventsBy +``` +groupEventsBy :: Eq a => (Event a -> Event a -> Bool) -> [Event a] -> [[Event a]] +``` + +### collectEvent +``` +collectEvent :: [Event a] -> Maybe (Event [a]) +``` + +### collectEventsBy +``` +collectEventsBy :: Eq a => (Event a -> Event a -> Bool) -> [Event a] -> [Event [a]] +``` + +### collectBy +``` +collectBy :: Eq a => (Event a -> Event a -> Bool) -> Pattern a -> Pattern [a] +``` + +collects all events satisfying the same constraint into a list + +### collect +``` +collect :: Eq a => Pattern a -> Pattern [a] +``` + +collects all events occuring at the exact same time into a list + +### uncollectEvent +``` +uncollectEvent :: Event [a] -> [Event a] +``` + +### uncollectEvents +``` +uncollectEvents :: [Event [a]] -> [Event a] +``` + +### uncollect +``` +uncollect :: Pattern [a] -> Pattern a +``` + +merges all values in a list into one pattern by stacking the values + +### module +``` +module Sound.Tidal.Time +``` + diff --git a/docs/library/autogenerated/Sound-Tidal-Safe-Boot/Sound-Tidal-Safe-Boot.mdx b/docs/library/autogenerated/Sound-Tidal-Safe-Boot/Sound-Tidal-Safe-Boot.mdx new file mode 100644 index 0000000000..0216171eb7 --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Safe-Boot/Sound-Tidal-Safe-Boot.mdx @@ -0,0 +1,275 @@ +--- +title: Sound.Tidal.Safe.Boot +slug: /library/modules/Sound.Tidal.Safe.Boot +--- + + + +### p +``` +p :: ID -> ControlPattern -> Op () +``` + +### hush +``` +hush :: Op () +``` + +### list +``` +list :: Op () +``` + +### mute +``` +mute :: ID -> Op () +``` + +### unmute +``` +unmute :: ID -> Op () +``` + +### solo +``` +solo :: ID -> Op () +``` + +### unsolo +``` +unsolo :: ID -> Op () +``` + +### once +``` +once :: ControlPattern -> Op () +``` + +### first +``` +first :: ControlPattern -> Op () +``` + +### asap +``` +asap :: ControlPattern -> Op () +``` + +### nudgeAll +``` +nudgeAll :: Double -> Op () +``` + +### all +``` +all :: (ControlPattern -> ControlPattern) -> Op () +``` + +### resetCycles +``` +resetCycles :: Op () +``` + +### setcps +``` +setcps :: Pattern Double -> Op () +``` + +### xfade +``` +xfade :: ID -> ControlPattern -> Op () +``` + +### xfadeIn +``` +xfadeIn :: ID -> Time -> ControlPattern -> Op () +``` + +### histpan +``` +histpan :: ID -> Int -> ControlPattern -> Op () +``` + +### wait +``` +wait :: ID -> Time -> ControlPattern -> Op () +``` + +### waitT +``` +waitT :: ID -> (Time -> [ControlPattern] -> ControlPattern) -> Time -> ControlPattern -> Op () +``` + +### jump +``` +jump :: ID -> ControlPattern -> Op () +``` + +### jumpIn +``` +jumpIn :: ID -> Int -> ControlPattern -> Op () +``` + +### jumpIn' +``` +jumpIn' :: ID -> Int -> ControlPattern -> Op () +``` + +### jumpMod +``` +jumpMod :: ID -> Int -> ControlPattern -> Op () +``` + +### mortal +``` +mortal :: ID -> Time -> Time -> ControlPattern -> Op () +``` + +### interpolate +``` +interpolate :: ID -> ControlPattern -> Op () +``` + +### interpolateIn +``` +interpolateIn :: ID -> Time -> ControlPattern -> Op () +``` + +### clutch +``` +clutch :: ID -> ControlPattern -> Op () +``` + +### clutchIn +``` +clutchIn :: ID -> Time -> ControlPattern -> Op () +``` + +### anticipate +``` +anticipate :: ID -> ControlPattern -> Op () +``` + +### anticipateIn +``` +anticipateIn :: ID -> Time -> ControlPattern -> Op () +``` + +### forId +``` +forId :: ID -> Time -> ControlPattern -> Op () +``` + +### d1 +``` +d1 :: Pattern ValueMap -> Op () +``` + +### d2 +``` +d2 :: Pattern ValueMap -> Op () +``` + +### d3 +``` +d3 :: Pattern ValueMap -> Op () +``` + +### d4 +``` +d4 :: Pattern ValueMap -> Op () +``` + +### d5 +``` +d5 :: Pattern ValueMap -> Op () +``` + +### d6 +``` +d6 :: Pattern ValueMap -> Op () +``` + +### d7 +``` +d7 :: Pattern ValueMap -> Op () +``` + +### d8 +``` +d8 :: Pattern ValueMap -> Op () +``` + +### d9 +``` +d9 :: Pattern ValueMap -> Op () +``` + +### d10 +``` +d10 :: Pattern ValueMap -> Op () +``` + +### d11 +``` +d11 :: Pattern ValueMap -> Op () +``` + +### d12 +``` +d12 :: Pattern ValueMap -> Op () +``` + +### d13 +``` +d13 :: ControlPattern -> Op () +``` + +### d14 +``` +d14 :: ControlPattern -> Op () +``` + +### d15 +``` +d15 :: ControlPattern -> Op () +``` + +### d16 +``` +d16 :: ControlPattern -> Op () +``` + +### setI +``` +setI :: String -> Pattern Int -> Op () +``` + +### setF +``` +setF :: String -> Pattern Double -> Op () +``` + +### setS +``` +setS :: String -> Pattern String -> Op () +``` + +### setR +``` +setR :: String -> Pattern Rational -> Op () +``` + +### setB +``` +setB :: String -> Pattern Bool -> Op () +``` + diff --git a/docs/library/autogenerated/Sound-Tidal-Safe-Context/Sound-Tidal-Safe-Context.mdx b/docs/library/autogenerated/Sound-Tidal-Safe-Context/Sound-Tidal-Safe-Context.mdx new file mode 100644 index 0000000000..06332bd77e --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Safe-Context/Sound-Tidal-Safe-Context.mdx @@ -0,0 +1,180 @@ +--- +title: Sound.Tidal.Safe.Context +slug: /library/modules/Sound.Tidal.Safe.Context +--- + + + +### data +``` +data Op r +``` + +### exec +``` +exec :: Stream -> Op r -> IO r +``` + +### streamReplace +``` +streamReplace :: ID -> ControlPattern -> Op () +``` + +### streamHush +``` +streamHush :: Op () +``` + +### streamList +``` +streamList :: Op () +``` + +### streamMute +``` +streamMute :: ID -> Op () +``` + +### streamUnmute +``` +streamUnmute :: ID -> Op () +``` + +### streamSolo +``` +streamSolo :: ID -> Op () +``` + +### streamUnsolo +``` +streamUnsolo :: ID -> Op () +``` + +### streamOnce +``` +streamOnce :: ControlPattern -> Op () +``` + +### streamFirst +``` +streamFirst :: ControlPattern -> Op () +``` + +### streamNudgeAll +``` +streamNudgeAll :: Double -> Op () +``` + +### streamAll +``` +streamAll :: (ControlPattern -> ControlPattern) -> Op () +``` + +### streamResetCycles +``` +streamResetCycles :: Op () +``` + +### streamSetI +``` +streamSetI :: String -> Pattern Int -> Op () +``` + +### streamSetF +``` +streamSetF :: String -> Pattern Double -> Op () +``` + +### streamSetS +``` +streamSetS :: String -> Pattern String -> Op () +``` + +### streamSetR +``` +streamSetR :: String -> Pattern Rational -> Op () +``` + +### streamSetB +``` +streamSetB :: String -> Pattern Bool -> Op () +``` + +### transition +``` +transition :: Bool -> (Time -> [ControlPattern] -> ControlPattern) -> ID -> ControlPattern -> Op () +``` + +### module +``` +module Sound.Tidal.Context +``` + +### module +``` +module Sound.Tidal.Version +``` + +### module +``` +module Sound.Tidal.UI +``` + +### module +``` +module Sound.Tidal.Simple +``` + +### module +``` +module Sound.Tidal.Scales +``` + +### module +``` +module Sound.Tidal.Pattern +``` + +### module +``` +module Sound.Tidal.ParseBP +``` + +### module +``` +module Sound.Tidal.Params +``` + +### module +``` +module Sound.Tidal.Core +``` + +### module +``` +module Sound.Tidal.Control +``` + +### module +``` +module Sound.Tidal.Config +``` + +### module +``` +module Data.Ratio +``` + +### data +``` +data Target +``` + diff --git a/docs/library/autogenerated/Sound-Tidal-Scales/Sound-Tidal-Scales.mdx b/docs/library/autogenerated/Sound-Tidal-Scales/Sound-Tidal-Scales.mdx new file mode 100644 index 0000000000..6005d775f4 --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Scales/Sound-Tidal-Scales.mdx @@ -0,0 +1,35 @@ +--- +title: Sound.Tidal.Scales +slug: /library/modules/Sound.Tidal.Scales +--- + + + +### scale +``` +scale :: Fractional a => Pattern String -> Pattern Int -> Pattern a +``` + +### scaleList +``` +scaleList :: String +``` + +### scaleTable +``` +scaleTable :: Fractional a => [(String, [a])] +``` + +### getScale +``` +getScale :: Fractional a => [(String, [a])] -> Pattern String -> Pattern Int -> Pattern a +``` + diff --git a/docs/library/autogenerated/Sound-Tidal-Show/Sound-Tidal-Show.mdx b/docs/library/autogenerated/Sound-Tidal-Show/Sound-Tidal-Show.mdx new file mode 100644 index 0000000000..ee49c85119 --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Show/Sound-Tidal-Show.mdx @@ -0,0 +1,53 @@ +--- +title: Sound.Tidal.Show +slug: /library/modules/Sound.Tidal.Show +--- + + + +### show +``` +show :: Show a => a -> String +``` + +A specialised variant of `showsPrec`, using precedence context + zero, and returning an ordinary `String`. + +### showAll +``` +showAll :: Show a => Arc -> Pattern a -> String +``` + +### draw +``` +draw :: Pattern Char -> Render +``` + +### drawLine +``` +drawLine :: Pattern Char -> Render +``` + +### drawLineSz +``` +drawLineSz :: Int -> Pattern Char -> Render +``` + +### stepcount +``` +stepcount :: Pattern a -> Int +``` + +### showStateful +``` +showStateful :: ControlPattern -> String +``` + diff --git a/docs/library/autogenerated/Sound-Tidal-Simple/Sound-Tidal-Simple.mdx b/docs/library/autogenerated/Sound-Tidal-Simple/Sound-Tidal-Simple.mdx new file mode 100644 index 0000000000..11bb4b2c41 --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Simple/Sound-Tidal-Simple.mdx @@ -0,0 +1,75 @@ +--- +title: Sound.Tidal.Simple +slug: /library/modules/Sound.Tidal.Simple +--- + + + +### crunch +``` +crunch :: ControlPattern -> ControlPattern +``` + +### scratch +``` +scratch :: ControlPattern -> ControlPattern +``` + +### louder +``` +louder :: ControlPattern -> ControlPattern +``` + +### quieter +``` +quieter :: ControlPattern -> ControlPattern +``` + +### silent +``` +silent :: ControlPattern -> ControlPattern +``` + +### skip +``` +skip :: ControlPattern -> ControlPattern +``` + +### left +``` +left :: ControlPattern -> ControlPattern +``` + +### right +``` +right :: ControlPattern -> ControlPattern +``` + +### higher +``` +higher :: ControlPattern -> ControlPattern +``` + +### lower +``` +lower :: ControlPattern -> ControlPattern +``` + +### faster +``` +faster :: ControlPattern -> ControlPattern +``` + +### slower +``` +slower :: ControlPattern -> ControlPattern +``` + diff --git a/docs/library/autogenerated/Sound-Tidal-Stream/Sound-Tidal-Stream.mdx b/docs/library/autogenerated/Sound-Tidal-Stream/Sound-Tidal-Stream.mdx new file mode 100644 index 0000000000..1d461dd91e --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Stream/Sound-Tidal-Stream.mdx @@ -0,0 +1,20 @@ +--- +title: Sound.Tidal.Stream +slug: /library/modules/Sound.Tidal.Stream +--- + + + +### module +``` +module Sound.Tidal.StreamTypes +``` + diff --git a/docs/library/autogenerated/Sound-Tidal-StreamTypes/Sound-Tidal-StreamTypes.mdx b/docs/library/autogenerated/Sound-Tidal-StreamTypes/Sound-Tidal-StreamTypes.mdx new file mode 100644 index 0000000000..49a89a059f --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-StreamTypes/Sound-Tidal-StreamTypes.mdx @@ -0,0 +1,35 @@ +--- +title: Sound.Tidal.StreamTypes +slug: /library/modules/Sound.Tidal.StreamTypes +--- + + + +### data +``` +data PlayState +``` + +### type +``` +type PatId = String +``` + +### type +``` +type PlayMap = Map PatId PlayState +``` + +### data +``` +data TickState +``` + diff --git a/docs/library/autogenerated/Sound-Tidal-Tempo/Sound-Tidal-Tempo.mdx b/docs/library/autogenerated/Sound-Tidal-Tempo/Sound-Tidal-Tempo.mdx new file mode 100644 index 0000000000..4347825f80 --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Tempo/Sound-Tidal-Tempo.mdx @@ -0,0 +1,70 @@ +--- +title: Sound.Tidal.Tempo +slug: /library/modules/Sound.Tidal.Tempo +--- + + + +### type +``` +type TransitionMapper = Time -> [ControlPattern] -> ControlPattern +``` + +### data +``` +data TempoAction +``` + +### data +``` +data State +``` + +### data +``` +data ActionHandler +``` + +### data +``` +data LinkOperations +``` + +### setCycle +``` +setCycle :: Time -> MVar [TempoAction] -> IO () +``` + +### setNudge +``` +setNudge :: MVar [TempoAction] -> Double -> IO () +``` + +### timeToCycles' +``` +timeToCycles' :: Config -> SessionState -> Micros -> IO Time +``` + +### cyclesToTime +``` +cyclesToTime :: Config -> SessionState -> Time -> IO Micros +``` + +### addMicrosToOsc +``` +addMicrosToOsc :: Micros -> Time -> Time +``` + +### clocked +``` +clocked :: Config -> MVar ValueMap -> MVar PlayMap -> MVar [TempoAction] -> ActionHandler -> AbletonLink -> IO [ThreadId] +``` + diff --git a/docs/library/autogenerated/Sound-Tidal-Time/Sound-Tidal-Time.mdx b/docs/library/autogenerated/Sound-Tidal-Time/Sound-Tidal-Time.mdx new file mode 100644 index 0000000000..b0108246f7 --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Time/Sound-Tidal-Time.mdx @@ -0,0 +1,182 @@ +--- +title: Sound.Tidal.Time +slug: /library/modules/Sound.Tidal.Time +--- + + + +### type +``` +type Time = Rational +``` + +Time is rational + +### data +``` +data ArcF a +``` + +An arc of time, with a start time (or onset) and a stop time (or offset) + +### type +``` +type Arc = ArcF Time +``` + +### sam +``` +sam :: Time -> Time +``` + +The `sam` (start of cycle) for the given time value. + Cycles have duration 1, so every integer Time value divides two cycles. + +### toTime +``` +toTime :: Real a => a -> Rational +``` + +Turns a number into a (rational) time value. An alias for `toRational`. + +### fromTime +``` +fromTime :: Fractional a => Time -> a +``` + +Turns a (rational) time value into another number. An alias for `fromRational`. + +### nextSam +``` +nextSam :: Time -> Time +``` + +The end point of the current cycle (and starting point of the next cycle) + +### cyclePos +``` +cyclePos :: Time -> Time +``` + +The position of a time value relative to the start of its cycle. + +### hull +``` +hull :: Arc -> Arc -> Arc +``` + +convex hull union + +### subArc +``` +subArc :: Arc -> Arc -> Maybe 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. + +### subMaybeArc +``` +subMaybeArc :: Maybe Arc -> Maybe Arc -> Maybe (Maybe Arc) +``` + +### sect +``` +sect :: Arc -> Arc -> Arc +``` + +Simple intersection of two arcs + +### timeToCycleArc +``` +timeToCycleArc :: Time -> Arc +``` + +The Arc returned is the cycle that the Time falls within. + +Edge case: If the Time is an integer, + the Arc claiming it is the one starting at that Time, + not the previous one ending at that Time. + +### cycleArc +``` +cycleArc :: Arc -> Arc +``` + +Shifts an Arc to one of equal duration that starts within cycle zero. + (Note that the output Arc probably does not start *at* Time 0 -- + that only happens when the input Arc starts at an integral Time.) + +### cyclesInArc +``` +cyclesInArc :: Integral a => Arc -> [a] +``` + +Returns the numbers of the cycles that the input `Arc` overlaps + (excluding the input `Arc`'s endpoint, unless it has duration 0 -- + see "Edge cases" below). + (The "cycle number" of an `Arc` is equal to its start value. + Thus, for instance, `cyclesInArc (Arc 0 1.5) == [0,1]`.) + +Edge cases: + > cyclesInArc $ Arc 0 1.0001 == [0,1] + > cyclesInArc $ Arc 0 1 == [0] -- the endpoint is excluded + > cyclesInArc $ Arc 1 1 == [1] -- unless the Arc has duration 0 + +PITFALL: Don't be fooled by the name. The output cycles + are not necessarily completely contained in the input `Arc`, + but they definitely overlap it, + and they include every cycle that overlaps it. + +### cycleArcsInArc +``` +cycleArcsInArc :: Arc -> [Arc] +``` + +This provides exactly the same information as `cyclesInArc`, + except that this represents its output as `Arc`s, + whereas `cyclesInArc` represents the same information as integral indices. + (The `Arc` from 0 to 1 corresponds to the index 0, + the one from 1 to 2 has index 1, etc.) + +### arcCycles +``` +arcCycles :: Arc -> [Arc] +``` + +Splits the given `Arc` into a list of `Arc`s, at cycle boundaries. + +### arcCyclesZW +``` +arcCyclesZW :: Arc -> [Arc] +``` + +Like arcCycles, but returns zero-width arcs + +### mapCycle +``` +mapCycle :: (Time -> Time) -> Arc -> Arc +``` + +Similar to `fmap` but time is relative to the cycle (i.e. the + sam of the start of the arc) + +### isIn +``` +isIn :: Arc -> Time -> Bool +``` + +`isIn a t` is `True` if `t` is inside + the arc represented by `a`. + diff --git a/docs/library/autogenerated/Sound-Tidal-Transition/Sound-Tidal-Transition.mdx b/docs/library/autogenerated/Sound-Tidal-Transition/Sound-Tidal-Transition.mdx new file mode 100644 index 0000000000..7088f0e78a --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Transition/Sound-Tidal-Transition.mdx @@ -0,0 +1,179 @@ +--- +title: Sound.Tidal.Transition +slug: /library/modules/Sound.Tidal.Transition +--- + + + +### transition +``` +transition :: Stream -> Bool -> (Time -> [ControlPattern] -> ControlPattern) -> ID -> ControlPattern -> IO () +``` + +### mortalOverlay +``` +mortalOverlay :: Time -> Time -> [Pattern a] -> Pattern a +``` + +### wash +``` +wash :: (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Time -> Time -> Time -> Time -> [Pattern a] -> Pattern a +``` + +Washes away the current pattern after a certain delay by applying a + function to it over time, then switching over to the next pattern to + which another function is applied. + +### washIn +``` +washIn :: (Pattern a -> Pattern a) -> Time -> Time -> [Pattern a] -> Pattern a +``` + +### xfadeIn +``` +xfadeIn :: Time -> Time -> [ControlPattern] -> ControlPattern +``` + +### histpan +``` +histpan :: Int -> Time -> [ControlPattern] -> ControlPattern +``` + +Pans the last n versions of the pattern across the field + +### wait +``` +wait :: Time -> Time -> [ControlPattern] -> ControlPattern +``` + +Just stop for a bit before playing new pattern + +### waitT +``` +waitT :: (Time -> [ControlPattern] -> ControlPattern) -> Time -> Time -> [ControlPattern] -> ControlPattern +``` + +Just as `wait`, `waitT` stops for a bit and then applies the given transition to the playing pattern + +```haskell +d1 $ sound "bd" + +t1 (waitT (xfadeIn 8) 4) $ sound "hh*8" +``` +### jump +``` +jump :: 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` + +### jumpIn +``` +jumpIn :: Int -> Time -> [ControlPattern] -> ControlPattern +``` + +Sharp `jump` transition after the specified number of cycles have passed. + +```haskell +t1 (jumpIn 2) $ sound "kick(3,8)" +``` +### jumpIn' +``` +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). + +### jumpMod +``` +jumpMod :: Int -> Time -> [ControlPattern] -> ControlPattern +``` + +Sharp `jump` transition at next cycle boundary where cycle mod n == 0 + +### jumpMod' +``` +jumpMod' :: Int -> Int -> Time -> [ControlPattern] -> ControlPattern +``` + +Sharp `jump` transition at next cycle boundary where cycle mod n == p + +### mortal +``` +mortal :: Time -> Time -> Time -> [ControlPattern] -> ControlPattern +``` + +Degrade the new pattern over time until it ends in silence + +### interpolate +``` +interpolate :: Time -> [ControlPattern] -> ControlPattern +``` + +### interpolateIn +``` +interpolateIn :: Time -> Time -> [ControlPattern] -> ControlPattern +``` + +### clutch +``` +clutch :: Time -> [Pattern a] -> Pattern a +``` + +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. + +```haskell +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`. + +### clutchIn +``` +clutchIn :: Time -> 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: + +```haskell +d1 $ sound "bd(5,8)" + +t1 (clutchIn 8) $ sound "[hh*4, odx(3,8)]" +``` +will take 8 cycles for the transition. + +### anticipateIn +``` +anticipateIn :: Time -> Time -> [ControlPattern] -> ControlPattern +``` + +same as `anticipate` though it allows you to specify the number of cycles until dropping to the new pattern, e.g.: + +```haskell +d1 $ sound "jvbass(3,8)" + +t1 (anticipateIn 4) $ sound "jvbass(5,8)" +``` +### anticipate +``` +anticipate :: Time -> [ControlPattern] -> ControlPattern +``` + +`anticipate` is an increasing comb filter. + +Build up some tension, culminating in a _drop_ to the new pattern after 8 cycles. + diff --git a/docs/library/autogenerated/Sound-Tidal-UI/Sound-Tidal-UI.mdx b/docs/library/autogenerated/Sound-Tidal-UI/Sound-Tidal-UI.mdx new file mode 100644 index 0000000000..8f93ecfb0f --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-UI/Sound-Tidal-UI.mdx @@ -0,0 +1,1823 @@ +--- +title: Sound.Tidal.UI +slug: /library/modules/Sound.Tidal.UI +--- + + + +### xorwise +``` +xorwise :: Int -> Int +``` + +Randomisation + +### timeToIntSeed +``` +timeToIntSeed :: RealFrac a => a -> Int +``` + +### intSeedToRand +``` +intSeedToRand :: Fractional a => Int -> a +``` + +### timeToRand +``` +timeToRand :: (RealFrac a, Fractional b) => a -> b +``` + +### timeToRands +``` +timeToRands :: (RealFrac a, Fractional b) => a -> Int -> [b] +``` + +### timeToRands' +``` +timeToRands' :: Fractional a => Int -> Int -> [a] +``` + +### rand +``` +rand :: Fractional a => Pattern a +``` + +`rand` generates a continuous pattern of (pseudo-)random numbers between `0` and `1`. + +```haskell +sound "bd*8" # pan rand +``` +pans bass drums randomly + +```haskell +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: + +```haskell +jux (# gain rand) $ sound "sn sn ~ sn" # gain rand +``` +and with the juxed version shifted backwards for 1024 cycles: + +```haskell +jux (# ((1024 <~) $ gain rand)) $ sound "sn sn ~ sn" # gain rand +``` +### brand +``` +brand :: Pattern Bool +``` + +Boolean rand - a continuous stream of truefalse values, with a 5050 chance. + +### brandBy +``` +brandBy :: Pattern Double -> Pattern Bool +``` + +Boolean rand with probability as input, e.g. brandBy 0.25 is 25% chance of being true. + +### _brandBy +``` +_brandBy :: Double -> Pattern Bool +``` + +### irand +``` +irand :: Num a => Pattern Int -> 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: + +```haskell +d1 $ segment 4 $ n (irand 5) # sound "drum" +``` +### _irand +``` +_irand :: Num a => Int -> Pattern a +``` + +### perlinWith +``` +perlinWith :: Fractional a => Pattern Double -> 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`. + +### perlin +``` +perlin :: Fractional a => Pattern a +``` + +### perlin2With +``` +perlin2With :: Pattern Double -> Pattern Double -> Pattern Double +``` + +### perlin2 +``` +perlin2 :: Pattern Double -> Pattern Double +``` + +### choose +``` +choose :: [a] -> Pattern a +``` + +Randomly picks an element from the given list + +```haskell +sound "superpiano(3,8)" # note (choose ["a", "e", "g", "c"]) +``` +plays a melody randomly choosing one of the four notes "a", "e", "g", "c". + +### chooseBy +``` +chooseBy :: Pattern Double -> [a] -> Pattern a +``` + +### wchoose +``` +wchoose :: [(a, Double)] -> Pattern a +``` + +Like `choose`, but works on an a list of tuples of values and weights + +```haskell +sound "superpiano(3,8)" # note (wchoose [("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. + +### wchooseBy +``` +wchooseBy :: Pattern Double -> [(a, Double)] -> Pattern a +``` + +### degradeBy +``` +degradeBy :: Pattern Double -> Pattern a -> 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: + +```haskell +d1 $ slow 2 $ degradeBy 0.9 $ sound "[[[feel:5*8,feel*3] feel:3*8], feel*4]" + # accelerate "-6" + # speed "2" +``` +### _degradeBy +``` +_degradeBy :: Double -> Pattern a -> Pattern a +``` + +### _degradeByUsing +``` +_degradeByUsing :: Pattern Double -> Double -> Pattern a -> Pattern a +``` + +### unDegradeBy +``` +unDegradeBy :: Pattern Double -> Pattern a -> Pattern a +``` + +### _unDegradeBy +``` +_unDegradeBy :: Double -> Pattern a -> Pattern a +``` + +### degradeOverBy +``` +degradeOverBy :: Int -> Pattern Double -> Pattern a -> Pattern a +``` + +### sometimesBy +``` +sometimesBy :: Pattern Double -> (Pattern a -> Pattern a) -> 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: + +```haskell +d1 $ sometimesBy 0.25 (density 2) $ sound "bd*8" +``` +There are some aliases as well: + +```haskell +sometimes = sometimesBy 0.5 +often = sometimesBy 0.75 +rarely = sometimesBy 0.25 +almostNever = sometimesBy 0.1 +almostAlways = sometimesBy 0.9 +``` +### sometimesBy' +``` +sometimesBy' :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### sometimes +``` +sometimes :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +`sometimes` is an alias for sometimesBy 0.5. + +### sometimes' +``` +sometimes' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### often +``` +often :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +`often` is an alias for sometimesBy 0.75. + +### often' +``` +often' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### rarely +``` +rarely :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +`rarely` is an alias for sometimesBy 0.25. + +### rarely' +``` +rarely' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### almostNever +``` +almostNever :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +`almostNever` is an alias for sometimesBy 0.1 + +### almostNever' +``` +almostNever' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### almostAlways +``` +almostAlways :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +`almostAlways` is an alias for sometimesBy 0.9 + +### almostAlways' +``` +almostAlways' :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### never +``` +never :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### always +``` +always :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### someCyclesBy +``` +someCyclesBy :: Pattern Double -> (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 +``` +_someCyclesBy :: Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### somecyclesBy +``` +somecyclesBy :: Pattern Double -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### someCycles +``` +someCycles :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### somecycles +``` +somecycles :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### degrade +``` +degrade :: Pattern a -> Pattern a +``` + +`degrade` randomly removes events from a pattern 50% of the time: + +```haskell +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: + +```haskell +d1 $ slow 2 $ sound "bd ~ sn bd ~ bd? [sn bd?] ~" +``` +You can also use `?` to randomly remove events from entire sub-patterns: + +```haskell +d1 $ slow 2 $ sound "[[[feel:5*8,feel*3] feel:3*8]?, feel*4]" +``` +### brak +``` +brak :: 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: + +```haskell +d1 $ sound (brak "bd sn kurt") +``` +### iter +``` +iter :: Pattern Int -> Pattern c -> Pattern c +``` + +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: + +```haskell +d1 $ iter 4 $ sound "bd hh sn cp" +``` +This will produce the following over four cycles: + +```haskell +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 +``` +_iter :: Int -> Pattern a -> Pattern a +``` + +### iter' +``` +iter' :: Pattern Int -> Pattern c -> Pattern c +``` + +`iter'` is the same as `iter`, but decrements the starting + subdivision instead of incrementing it. + +### _iter' +``` +_iter' :: Int -> Pattern a -> Pattern a +``` + +### palindrome +``` +palindrome :: Pattern a -> Pattern a +``` + +`palindrome p` applies `rev` to `p` every other cycle, so that + the pattern alternates between forwards and backwards. + +### seqP +``` +seqP :: [(Time, Time, 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: + +```haskell +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))) +] +``` +### fadeOut +``` +fadeOut :: Time -> Pattern a -> Pattern a +``` + +Degrades a pattern over the given time. + +### fadeOutFrom +``` +fadeOutFrom :: Time -> Time -> Pattern a -> Pattern a +``` + +Alternate version to `fadeOut` where you can provide the time from which the fade starts + +### fadeIn +``` +fadeIn :: Time -> Pattern a -> Pattern a +``` + +`Undegrades` a pattern over the given time. + +### fadeInFrom +``` +fadeInFrom :: Time -> Time -> Pattern a -> Pattern a +``` + +Alternate version to `fadeIn` where you can provide the time from + which the fade in starts + +### spread +``` +spread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b +``` + +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: + +```haskell +d1 $ sound "ho ho:2 ho:3 hc" +``` +We can slow it down by different amounts, such as by a half: + +```haskell +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): + +```haskell +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: + +```haskell +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: + +```haskell +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: + +After `(# speed "0.8")`, the transforms will repeat and start at `density 2` again. + +### slowspread +``` +slowspread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b +``` + +### fastspread +``` +fastspread :: (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`. + +### spread' +``` +spread' :: Monad m => (a -> b -> m c) -> m a -> b -> m c +``` + +There's a version of this function, `spread'` (pronounced "spread prime"), which takes a *pattern* of parameters, instead of a list: + +```haskell +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.: + +```haskell +d1 $ spread' slow "[2 4%3, 3]" $ sound "ho ho:2 ho:3 hc" +``` +### spreadChoose +``` +spreadChoose :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b +``` + +`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`. + +### spreadr +``` +spreadr :: (t -> t1 -> Pattern b) -> [t] -> t1 -> Pattern b +``` + +### ifp +``` +ifp :: (Int -> Bool) -> (Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +Decide whether to apply one or another function depending on the result of a test function that is passed the current cycle as a number. + +```haskell +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`. + +### wedge +``` +wedge :: Pattern Time -> 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 +``` +_wedge :: Time -> Pattern a -> Pattern a -> Pattern a +``` + +### whenmod +``` +whenmod :: Pattern Time -> Pattern Time -> (Pattern a -> 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: + +```haskell +d1 $ whenmod 8 4 (density 2) (sound "bd sn kurt") +``` +### _whenmod +``` +_whenmod :: Time -> Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### superimpose +``` +superimpose :: (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +```haskell +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. + +```haskell +d1 $ superimpose (density 2) $ sound "bd sn [cp ht] hh" +d1 $ superimpose ((# speed "2") . (0.125 <~)) $ sound "bd sn cp hh" +``` +### trunc +``` +trunc :: Pattern Time -> 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: + +```haskell +d1 $ trunc 0.25 $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2" +``` +### _trunc +``` +_trunc :: Time -> Pattern a -> Pattern a +``` + +### linger +``` +linger :: Pattern Time -> Pattern a -> Pattern a +``` + +`linger` is similar to `trunc` but the truncated part of the pattern loops until the end of the cycle. + +```haskell +d1 $ linger 0.25 $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2" +``` +If you give it a negative number, it will linger on the last part of +the pattern, instead of the start of it. E.g. to linger on the last +quarter: + +```haskell +d1 $ linger (-0.25) $ sound "bd sn*2 cp hh*4 arpy bd*2 cp bd*2" +``` +### _linger +``` +_linger :: Time -> Pattern a -> Pattern a +``` + +### within +``` +within :: (Time, Time) -> (Pattern a -> Pattern a) -> 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: + +```haskell +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: + +```haskell +d1 $ within (0.75, 1) (# speed "0.5") $ sound "bd*2 sn lt mt hh hh hh hh" +``` +### withinArc +``` +withinArc :: Arc -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### within' +``` +within' :: (Time, Time) -> (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 + +```haskell +d1 $ within (0, 0.25) (fast 2) $ sound "bd hh cp sd" +``` +sounds like: + +```haskell +d1 $ sound "[bd hh] hh cp sd" +``` +using this alternative version, within' + +```haskell +d1 $ within' (0, 0.25) (fast 2) $ sound "bd hh cp sd" +``` +sounds like: + +```haskell +d1 $ sound "[bd bd] hh cp sd" +``` +### revArc +``` +revArc :: (Time, Time) -> Pattern a -> Pattern a +``` + +### euclid +``` +euclid :: Pattern Int -> Pattern Int -> 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: + +```haskell +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. + +A negative first argument provides the inverse of the euclidean pattern. + +These types of sequences use "Bjorklund's algorithm", which wasn't made for +music but for an application in nuclear physics, which is exciting. More +exciting still is that it is very similar in structure to the one of the first +known algorithms written in Euclid's book of elements in 300 BC. You can read +more about this in the paper +The Euclidean Algorithm Generates Traditional Musical Rhythms +by Toussaint. Some examples from this paper are included below, +including rotation in some cases. + +```haskell +- (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 +``` +_euclid :: Int -> Int -> Pattern a -> Pattern a +``` + +### euclidFull +``` +euclidFull :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a -> Pattern a +``` + +`euclidfull n k pa pb` stacks `e n k pa` with `einv n k pb` + +### _euclidBool +``` +_euclidBool :: Int -> Int -> Pattern Bool +``` + +### _euclid' +``` +_euclid' :: Int -> Int -> Pattern a -> Pattern a +``` + +### euclidOff +``` +euclidOff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a +``` + +### eoff +``` +eoff :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern a -> Pattern a +``` + +### _euclidOff +``` +_euclidOff :: Int -> Int -> Int -> Pattern a -> Pattern a +``` + +### euclidOffBool +``` +euclidOffBool :: Pattern Int -> Pattern Int -> Pattern Int -> Pattern Bool -> Pattern Bool +``` + +### _euclidOffBool +``` +_euclidOffBool :: Int -> Int -> Int -> Pattern Bool -> Pattern Bool +``` + +### distrib +``` +distrib :: [Pattern Int] -> Pattern a -> Pattern a +``` + +### _distrib +``` +_distrib :: [Int] -> Pattern a -> Pattern a +``` + +### euclidInv +``` +euclidInv :: Pattern Int -> Pattern 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 +``` +_euclidInv :: Int -> Int -> Pattern a -> Pattern a +``` + +### index +``` +index :: Real b => b -> Pattern b -> Pattern c -> Pattern c +``` + +### rot +``` +rot :: Ord a => Pattern Int -> Pattern a -> Pattern a +``` + +`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 +``` +_rot :: Ord a => Int -> Pattern a -> Pattern a +``` + +### segment +``` +segment :: Pattern Time -> 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 +``` +_segment :: Time -> Pattern a -> Pattern a +``` + +### discretise +``` +discretise :: Pattern Time -> Pattern a -> Pattern a +``` + +`discretise`: the old (deprecated) name for `segment` + +### randcat +``` +randcat :: [Pattern a] -> Pattern a +``` + +`randcat ps`: does a `slowcat` on the list of patterns `ps` but + randomises the order in which they are played. + +### wrandcat +``` +wrandcat :: [(Pattern a, Double)] -> Pattern a +``` + +### _fit +``` +_fit :: Int -> [a] -> Pattern Int -> 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: + +```haskell +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 +``` +fit :: Pattern Int -> [a] -> Pattern Int -> Pattern a +``` + +### permstep +``` +permstep :: RealFrac b => Int -> [a] -> Pattern b -> Pattern a +``` + +### struct +``` +struct :: Pattern Bool -> Pattern a -> 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. + +### substruct +``` +substruct :: Pattern Bool -> Pattern b -> Pattern b +``` + +`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. + +### randArcs +``` +randArcs :: Int -> Pattern [Arc] +``` + +### randStruct +``` +randStruct :: Int -> Pattern Int +``` + +### substruct' +``` +substruct' :: Pattern Int -> Pattern a -> Pattern a +``` + +### stripe +``` +stripe :: 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 +``` +_stripe :: Int -> Pattern a -> Pattern a +``` + +### slowstripe +``` +slowstripe :: Pattern 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 `n`th stripe starts on a cycle + boundary (in indian classical terms, the `sam`). + +### parseLMRule +``` +parseLMRule :: String -> [(String, String)] +``` + +### parseLMRule' +``` +parseLMRule' :: String -> [(Char, String)] +``` + +### lindenmayer +``` +lindenmayer :: Int -> String -> String -> String +``` + +returns the `n`th iteration of a Lindenmayer System with given start sequence. + +for example: + +```haskell +lindenmayer 1 "a:b,b:ab" "ab" -> "bab" +``` +### lindenmayerI +``` +lindenmayerI :: Num b => Int -> String -> String -> [b] +``` + +`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) + +### runMarkov +``` +runMarkov :: Int -> [[Double]] -> Int -> Time -> [Int] +``` + +`runMarkov n tmat xi seed` generates a Markov chain (as a list) of length `n` +using the transition matrix `tmat` starting from initial state `xi`, starting +with random numbers generated from `seed` +Each entry in the chain is the index of state (starting from zero). +Each row of the matrix will be automatically normalized. For example: +` +runMarkov 8 [[2,3], [1,3]] 0 0 +` +will produce a two-state chain 8 steps long, from initial state `0`, where the +transition probability from state 0->0 is 25, 0->1 is 35, 1->0 is 1/4, and +1->1 is 3/4. + +### markovPat +``` +markovPat :: Pattern Int -> Pattern Int -> [[Double]] -> Pattern Int +``` + +### _markovPat +``` +_markovPat :: Int -> Int -> [[Double]] -> Pattern Int +``` + +### mask +``` +mask :: Pattern Bool -> 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. + +```haskell +d1 $ sound (slowcat ["sn*8", "[cp*4 bd*4, hc*5]"]) # n (run 8) +``` +If we apply a mask to it + +```haskell +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. + +```haskell +d1 $ s (mask ("1 ~ 1 ~ 1 1 ~ 1") + (slowcat ["can*8", "[cp*4 sn*4, jvbass*16]"] )) + # n (run 8) +``` +### enclosingArc +``` +enclosingArc :: [Arc] -> Arc +``` + +TODO: refactor towards union + +### stretch +``` +stretch :: Pattern a -> Pattern a +``` + +### fit' +``` +fit' :: Pattern Time -> Int -> Pattern Int -> Pattern Int -> 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: + +```haskell +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 + +```haskell +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. + +### chunk +``` +chunk :: Pattern Int -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b +``` + +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 if chunk number is positive + - from right to left if chunk number is negative + +```haskell + d1 $ chunk 4 (fast 4) $ sound "cp sn arpy [mt lt]" + ``` +### _chunk +``` +_chunk :: Integral a => a -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b +``` + +### chunk' +``` +chunk' :: Integral a1 => Pattern a1 -> (Pattern a2 -> Pattern a2) -> Pattern a2 -> Pattern a2 +``` + +DEPRECATED, use `chunk` with negative numbers instead + +### _chunk' +``` +_chunk' :: Integral a => a -> (Pattern b -> Pattern b) -> Pattern b -> Pattern b +``` + +DEPRECATED, use `_chunk` with negative numbers instead + +### _inside +``` +_inside :: Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a +``` + +### inside +``` +inside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a +``` + +### _outside +``` +_outside :: Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a +``` + +### outside +``` +outside :: Pattern Time -> (Pattern a1 -> Pattern a) -> Pattern a1 -> Pattern a +``` + +### loopFirst +``` +loopFirst :: Pattern a -> Pattern a +``` + +### timeLoop +``` +timeLoop :: Pattern Time -> Pattern a -> Pattern a +``` + +### seqPLoop +``` +seqPLoop :: [(Time, Time, Pattern a)] -> Pattern a +``` + +### toScale' +``` +toScale' :: Num a => Int -> [a] -> Pattern Int -> 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 +``` +toScale :: Num a => [a] -> Pattern Int -> Pattern a +``` + +### swingBy +``` +swingBy :: Pattern Time -> Pattern Time -> Pattern a -> 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)` + +### swing +``` +swing :: Pattern Time -> Pattern a -> Pattern a +``` + +### cycleChoose +``` +cycleChoose :: [a] -> Pattern a +``` + +`cycleChoose` is like `choose` but only picks a new item from the list +once each cycle + +### _rearrangeWith +``` +_rearrangeWith :: Pattern Int -> Int -> Pattern a -> Pattern a +``` + +Internal function used by shuffle and scramble + +### shuffle +``` +shuffle :: Pattern Int -> Pattern 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 +``` +_shuffle :: Int -> Pattern a -> Pattern a +``` + +### scramble +``` +scramble :: Pattern 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 +``` +_scramble :: Int -> Pattern a -> Pattern a +``` + +### randrun +``` +randrun :: Int -> Pattern Int +``` + +### ur +``` +ur :: Time -> Pattern String -> [(String, Pattern a)] -> [(String, Pattern a -> Pattern a)] -> Pattern a +``` + +### inhabit +``` +inhabit :: [(String, Pattern a)] -> Pattern String -> Pattern a +``` + +### spaceOut +``` +spaceOut :: [Time] -> Pattern a -> Pattern a +``` + +`spaceOut xs p` repeats a pattern `p` at different durations given by the list of time values in `xs` + +### flatpat +``` +flatpat :: Pattern [a] -> Pattern a +``` + +`flatpat` takes a Pattern of lists and pulls the list elements as + separate Events + +### layer +``` +layer :: [a -> Pattern b] -> a -> Pattern b +``` + +`layer` takes a Pattern of lists and pulls the list elements as + separate Events + +### arpeggiate +``` +arpeggiate :: Pattern a -> Pattern a +``` + +`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. + +### arpg +``` +arpg :: Pattern a -> Pattern a +``` + +Shorthand alias for arpeggiate + +### arpWith +``` +arpWith :: ([EventF (ArcF Time) a] -> [EventF (ArcF Time) b]) -> Pattern a -> Pattern b +``` + +### arp +``` +arp :: Pattern String -> Pattern a -> Pattern a +``` + +### _arp +``` +_arp :: String -> Pattern a -> Pattern a +``` + +### rolledWith +``` +rolledWith :: Ratio Integer -> Pattern a -> Pattern a +``` + +`rolled` plays each note of a chord quickly in order, as opposed to simultaneously; to give a chord a harp-like effect. +This will played from the lowest note to the highest note of the chord +` +rolled $ n "cmaj4" # s "superpiano" +` + +And you can use `rolledBy` or `rolledBy'` to specify the length of the roll. The value in the passed pattern +is the divisor of the cycle length. A negative value will play the arpeggio in reverse order. + +```haskell +rolledBy "-0.5 0.25 -0.125" $ note "c'maj9" # s "superpiano" +``` +### rolledBy +``` +rolledBy :: Pattern (Ratio Integer) -> Pattern a -> Pattern a +``` + +### rolled +``` +rolled :: Pattern a -> Pattern a +``` + +### ply +``` +ply :: Pattern Rational -> Pattern a -> Pattern a +``` + +### _ply +``` +_ply :: Rational -> Pattern a -> Pattern a +``` + +### plyWith +``` +plyWith :: (Ord t, Num t) => Pattern t -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### _plyWith +``` +_plyWith :: (Ord t, Num t) => t -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### press +``` +press :: Pattern a -> Pattern a +``` + +Syncopates a rhythm, shifting each event halfway into its arc (aka timespan), e.g. `"a b [c d] e"` becomes the equivalent of `"[~ a] [~ b] [[~ c] [~ d]] [~ e]"` + +### pressBy +``` +pressBy :: Pattern Time -> Pattern a -> Pattern a +``` + +Like `press`, but allows you to specify the amount in which each event is shifted. `pressBy 0.5` is the same as `press`, while `pressBy (1/3)` shifts each event by a third of its arc. + +### _pressBy +``` +_pressBy :: Time -> Pattern a -> Pattern a +``` + +### sew +``` +sew :: Pattern Bool -> Pattern a -> Pattern a -> Pattern a +``` + +Uses the first (binary) pattern to switch between the following + two patterns. The resulting structure comes from the source patterns, not the + binary pattern. See also `stitch`. + +### stitch +``` +stitch :: Pattern Bool -> Pattern a -> Pattern a -> Pattern a +``` + +Uses the first (binary) pattern to switch between the following + two patterns. The resulting structure comes from the binary + pattern, not the source patterns. See also `sew`. + +### while +``` +while :: Pattern Bool -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +A binary pattern is used to conditionally apply a function to a + source pattern. The function is applied when a `True` value is + active, and the pattern is let through unchanged when a `False` + value is active. No events are let through where no binary values + are active. + +### stutter +``` +stutter :: Integral i => i -> Time -> Pattern a -> Pattern a +``` + +### jux +``` +jux :: (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap +``` + +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: + +```haskell +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: + +```haskell +d1 $ slow 32 $ jux ((# speed "0.5") . rev) $ striateBy 32 (1/16) $ sound "bev" +``` +### juxcut +``` +juxcut :: (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap +``` + +### juxcut' +``` +juxcut' :: [t -> Pattern ValueMap] -> t -> Pattern ValueMap +``` + +### jux' +``` +jux' :: [t -> Pattern ValueMap] -> t -> Pattern ValueMap +``` + +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: + +```haskell +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: + +```haskell +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", + ] +``` +### jux4 +``` +jux4 :: (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap +``` + +Multichannel variant of `jux`, _not sure what it does_ + +### juxBy +``` +juxBy :: Pattern Double -> (Pattern ValueMap -> Pattern ValueMap) -> Pattern ValueMap -> Pattern ValueMap +``` + +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: + +```haskell +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. + +### pick +``` +pick :: String -> Int -> String +``` + +### samples +``` +samples :: Applicative f => f String -> f Int -> f String +``` + +### samples' +``` +samples' :: Applicative f => f String -> f Int -> f String +``` + +### spreadf +``` +spreadf :: [a -> Pattern b] -> a -> Pattern b +``` + +### stackwith +``` +stackwith :: Unionable a => Pattern a -> [Pattern a] -> Pattern a +``` + +### range +``` +range :: Num a => Pattern 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. + +```haskell +d1 $ jux (iter 4) $ sound "arpy arpy:2*2" + |+ speed (slow 4 $ range 1 1.5 sine1) +``` +### _range +``` +_range :: (Functor f, Num b) => b -> b -> f b -> f b +``` + +### rangex +``` +rangex :: (Functor f, Floating 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! + +### off +``` +off :: Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### _off +``` +_off :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### offadd +``` +offadd :: Num a => Pattern Time -> Pattern a -> Pattern a -> Pattern a +``` + +### step +``` +step :: String -> String -> Pattern String +``` + +Step sequencing + +### steps +``` +steps :: [(String, String)] -> Pattern String +``` + +### step' +``` +step' :: [String] -> String -> Pattern String +``` + +like `step`, but allows you to specify an array of strings to use for 0,1,2... + +### ghost'' +``` +ghost'' :: Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### ghost' +``` +ghost' :: Time -> Pattern ValueMap -> Pattern ValueMap +``` + +### ghost +``` +ghost :: Pattern ValueMap -> Pattern ValueMap +``` + +### tabby +``` +tabby :: Int -> Pattern a -> Pattern a -> Pattern a +``` + +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 + +### select +``` +select :: Pattern Double -> [Pattern a] -> Pattern a +``` + +chooses between a list of patterns, using a pattern of floats (from 0-1) + +### _select +``` +_select :: Double -> [Pattern a] -> Pattern a +``` + +### selectF +``` +selectF :: Pattern Double -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a +``` + +chooses between a list of functions, using a pattern of floats (from 0-1) + +### _selectF +``` +_selectF :: Double -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a +``` + +### pickF +``` +pickF :: Pattern Int -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a +``` + +chooses between a list of functions, using a pattern of integers + +### _pickF +``` +_pickF :: Int -> [Pattern a -> Pattern a] -> Pattern a -> Pattern a +``` + +### contrast +``` +contrast :: (ControlPattern -> ControlPattern) -> (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern +``` + +`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 (# crush 3) (# vowel "a") (n "1") $ n "0 1" # s "bd sn" # speed 3`, + the first event will have the vowel effect applied and the second + will have the crush applied. + +### contrastBy +``` +contrastBy :: (a -> Value -> Bool) -> (ControlPattern -> Pattern b) -> (ControlPattern -> Pattern b) -> Pattern (Map String a) -> Pattern (Map String Value) -> Pattern b +``` + +### contrastRange +``` +contrastRange :: (ControlPattern -> Pattern a) -> (ControlPattern -> Pattern a) -> Pattern (Map String (Value, Value)) -> ControlPattern -> Pattern a +``` + +### fix +``` +fix :: (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern +``` + +Like `contrast`, but one function is given, and applied to events with matching controls. + +### unfix +``` +unfix :: (ControlPattern -> ControlPattern) -> ControlPattern -> ControlPattern -> ControlPattern +``` + +Like `contrast`, but one function is given, and applied to events + with controls which don't match. + +### fixRange +``` +fixRange :: (ControlPattern -> Pattern ValueMap) -> Pattern (Map String (Value, Value)) -> ControlPattern -> ControlPattern +``` + +### unfixRange +``` +unfixRange :: (ControlPattern -> Pattern ValueMap) -> Pattern (Map String (Value, Value)) -> ControlPattern -> ControlPattern +``` + +### quantise +``` +quantise :: (Functor f, RealFrac b) => b -> f b -> f b +``` + +limit values in a Pattern (or other Functor) to n equally spaced + divisions of 1. + +### qfloor +``` +qfloor :: (Functor f, RealFrac b) => b -> f b -> f b +``` + +### qceiling +``` +qceiling :: (Functor f, RealFrac b) => b -> f b -> f b +``` + +### qround +``` +qround :: (Functor f, RealFrac b) => b -> f b -> f b +``` + +### inv +``` +inv :: Functor f => f Bool -> f Bool +``` + +Inverts all the values in a boolean pattern + +### mono +``` +mono :: Pattern a -> Pattern a +``` + +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. + +### smooth +``` +smooth :: Fractional a => Pattern a -> Pattern a +``` + +### swap +``` +swap :: Eq a => [(a, b)] -> Pattern a -> Pattern b +``` + +Looks up values from a list of tuples, in order to swap values in the given pattern + +### snowball +``` +snowball :: Int -> (Pattern a -> Pattern a -> Pattern a) -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### soak +``` +soak :: Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a +``` + +### deconstruct +``` +deconstruct :: Int -> Pattern String -> String +``` + +### bite +``` +bite :: Pattern Int -> Pattern Int -> Pattern a -> Pattern a +``` + +### _bite +``` +_bite :: Int -> Pattern Int -> Pattern a -> Pattern a +``` + +### squeeze +``` +squeeze :: Pattern Int -> [Pattern a] -> Pattern a +``` + +### squeezeJoinUp +``` +squeezeJoinUp :: Pattern ControlPattern -> ControlPattern +``` + +### _chew +``` +_chew :: Int -> Pattern Int -> ControlPattern -> ControlPattern +``` + +### chew +``` +chew :: Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern +``` + +### __binary +``` +__binary :: Bits b => Int -> b -> [Bool] +``` + +### _binary +``` +_binary :: Bits b => Int -> b -> Pattern Bool +``` + +### _binaryN +``` +_binaryN :: Int -> Pattern Int -> Pattern Bool +``` + +### binaryN +``` +binaryN :: Pattern Int -> Pattern Int -> Pattern Bool +``` + +### binary +``` +binary :: Pattern Int -> Pattern Bool +``` + +### ascii +``` +ascii :: Pattern String -> Pattern Bool +``` + +### grain +``` +grain :: Pattern Double -> Pattern Double -> ControlPattern +``` + +### necklace +``` +necklace :: Rational -> [Int] -> Pattern Bool +``` + +For specifying a boolean pattern according to a list of offsets + (aka inter-onset intervals). For example `necklace 12 [4,2]` is + the same as "t f f f t f t f f f t f". That is, 12 steps per cycle, + with true values alternating between every 4 and every 2 steps. + diff --git a/docs/library/autogenerated/Sound-Tidal-Utils/Sound-Tidal-Utils.mdx b/docs/library/autogenerated/Sound-Tidal-Utils/Sound-Tidal-Utils.mdx new file mode 100644 index 0000000000..2e27238b20 --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Utils/Sound-Tidal-Utils.mdx @@ -0,0 +1,117 @@ +--- +title: Sound.Tidal.Utils +slug: /library/modules/Sound.Tidal.Utils +--- + + + +### writeError +``` +writeError :: String -> IO () +``` + +### mapBoth +``` +mapBoth :: (a -> a) -> (a, a) -> (a, a) +``` + +### mapPartTimes +``` +mapPartTimes :: (a -> a) -> ((a, a), (a, a)) -> ((a, a), (a, a)) +``` + +### mapFst +``` +mapFst :: (a -> b) -> (a, c) -> (b, c) +``` + +### mapSnd +``` +mapSnd :: (a -> b) -> (c, a) -> (c, b) +``` + +### delta +``` +delta :: Num a => (a, a) -> a +``` + +### mid +``` +mid :: Fractional a => (a, a) -> a +``` + +The midpoint of two values + +### removeCommon +``` +removeCommon :: Eq a => [a] -> [a] -> ([a], [a]) +``` + +### readMaybe +``` +readMaybe :: Read a => String -> Maybe a +``` + +### (!!!) +``` +(!!!) :: [a] -> Int -> a +``` + +like `!!` selects `n`th element from xs, but wraps over at the end of `xs` + +```haskell +>>> map ((!!!) [1,3,5]) [0,1,2,3,4,5] +[1,3,5,1,3,5] +``` +### nth +``` +nth :: Int -> [a] -> Maybe a +``` + +Safer version of !! - + +### accumulate +``` +accumulate :: Num t => [t] -> [t] +``` + +### enumerate +``` +enumerate :: [a] -> [(Int, a)] +``` + +enumerate a list of things + +```haskell +>>> enumerate ["foo","bar","baz"] +[(1,"foo"), (2,"bar"), (3,"baz")] +``` +### wordsBy +``` +wordsBy :: (a -> Bool) -> [a] -> [[a]] +``` + +split given list of `a` by given single a, e.g. + +```haskell +>>> wordsBy (== ':') "bd:3" +["bd", "3"] +``` +### matchMaybe +``` +matchMaybe :: Maybe a -> Maybe a -> Maybe a +``` + +### fromRight +``` +fromRight :: b -> Either a b -> b +``` + diff --git a/docs/library/autogenerated/Sound-Tidal-Version/Sound-Tidal-Version.mdx b/docs/library/autogenerated/Sound-Tidal-Version/Sound-Tidal-Version.mdx new file mode 100644 index 0000000000..1f7217aaa8 --- /dev/null +++ b/docs/library/autogenerated/Sound-Tidal-Version/Sound-Tidal-Version.mdx @@ -0,0 +1,30 @@ +--- +title: Sound.Tidal.Version +slug: /library/modules/Sound.Tidal.Version +--- + + + +### tidal_version +``` +tidal_version :: String +``` + +### tidal_status +``` +tidal_status :: IO () +``` + +### tidal_status_string +``` +tidal_status_string :: IO String +``` + diff --git a/docs/library/autogenerated/sidebar.json b/docs/library/autogenerated/sidebar.json new file mode 100644 index 0000000000..31631d4d9c --- /dev/null +++ b/docs/library/autogenerated/sidebar.json @@ -0,0 +1 @@ +["library/autogenerated/Sound-Tidal-Bjorklund/Sound-Tidal-Bjorklund","library/autogenerated/Sound-Tidal-Chords/Sound-Tidal-Chords","library/autogenerated/Sound-Tidal-Config/Sound-Tidal-Config","library/autogenerated/Sound-Tidal-Context/Sound-Tidal-Context","library/autogenerated/Sound-Tidal-Control/Sound-Tidal-Control","library/autogenerated/Sound-Tidal-Core/Sound-Tidal-Core","library/autogenerated/Sound-Tidal-ID/Sound-Tidal-ID","library/autogenerated/Sound-Tidal-Params/Sound-Tidal-Params","library/autogenerated/Sound-Tidal-ParseBP/Sound-Tidal-ParseBP","library/autogenerated/Sound-Tidal-Pattern/Sound-Tidal-Pattern","library/autogenerated/Sound-Tidal-Safe-Boot/Sound-Tidal-Safe-Boot","library/autogenerated/Sound-Tidal-Safe-Context/Sound-Tidal-Safe-Context","library/autogenerated/Sound-Tidal-Scales/Sound-Tidal-Scales","library/autogenerated/Sound-Tidal-Show/Sound-Tidal-Show","library/autogenerated/Sound-Tidal-Simple/Sound-Tidal-Simple","library/autogenerated/Sound-Tidal-Stream/Sound-Tidal-Stream","library/autogenerated/Sound-Tidal-StreamTypes/Sound-Tidal-StreamTypes","library/autogenerated/Sound-Tidal-Tempo/Sound-Tidal-Tempo","library/autogenerated/Sound-Tidal-Time/Sound-Tidal-Time","library/autogenerated/Sound-Tidal-Transition/Sound-Tidal-Transition","library/autogenerated/Sound-Tidal-UI/Sound-Tidal-UI","library/autogenerated/Sound-Tidal-Utils/Sound-Tidal-Utils","library/autogenerated/Sound-Tidal-Version/Sound-Tidal-Version"] \ No newline at end of file diff --git a/docs/library/introduction.mdx b/docs/library/introduction.mdx new file mode 100644 index 0000000000..5b99f31e9f --- /dev/null +++ b/docs/library/introduction.mdx @@ -0,0 +1,24 @@ +--- +title: Library Reference +slug: /library +--- + +This is the complete reference to all functions in the TidalCycles library. + +## Type Signatures + +[Migrate the section on interpreting type signatures here...] + +## Basic Types + +### Boolean + +### String + +### Int + +### Double + +### Rational + +### List \ No newline at end of file diff --git a/docusaurus.config.js b/docusaurus.config.js index 4f19d09c65..b443b9ce98 100644 --- a/docusaurus.config.js +++ b/docusaurus.config.js @@ -36,6 +36,12 @@ module.exports = { label: "Reference", position: "left", }, + { + to: "docs/library", + activeBasePath: "docs/library", + label: "Library", + position: "left" + }, { to: "blog", label: "Blog", position: "left" }, { to: "docs/community", diff --git a/scripts/doc-gen/.gitignore b/scripts/doc-gen/.gitignore new file mode 100644 index 0000000000..b512c09d47 --- /dev/null +++ b/scripts/doc-gen/.gitignore @@ -0,0 +1 @@ +node_modules \ No newline at end of file diff --git a/scripts/doc-gen/README.md b/scripts/doc-gen/README.md new file mode 100644 index 0000000000..c2f212d6a3 --- /dev/null +++ b/scripts/doc-gen/README.md @@ -0,0 +1,9 @@ +This script generates the MDX docs for the /docs/library section of the site +based on the Haddock documentation in the Tidal repository. + +It [will eventually be autogenerated] by GitHub actions, so it's not necessary +to invoke it manually. If you do want to run it locally, first generate the +Haddocks docs page by cloning the main Tidal repository and running +`cabal haddock`. Then navigate to this directory and run the command +`yarn run `, passing in the path to the generated documentation +(usually something like `/dist-newstyle/build/.../doc/html/tidal`) \ No newline at end of file diff --git a/scripts/doc-gen/index.js b/scripts/doc-gen/index.js new file mode 100644 index 0000000000..a18f9a8462 --- /dev/null +++ b/scripts/doc-gen/index.js @@ -0,0 +1,121 @@ +import { basename, resolve } from "path"; +import { createWriteStream } from "fs"; +import { readdir, readFile, rm, mkdir, writeFile } from "fs/promises"; +import { parse } from "parse5"; + +import { Tree } from "./tree.js"; + +if (!process.argv[2]) { + console.log("Please provide a path to documentation folder"); +} else { + generateDocs(process.argv[2]); +} + +async function generateDocs(path) { + let modules = (await readdir(path)).filter(p => p.startsWith("Sound-Tidal-")); + + // Clear out autogenerated folder (rm -rf) + await rm("../../docs/library/autogenerated", { recursive: true, force: true }); + + let modulePromises = []; + + for (let module of modules) { + modulePromises.push(generateModuleDocs(resolve(path, module))); + } + + let modulePaths = await Promise.all(modulePromises); + await writeFile("../../docs/library/autogenerated/sidebar.json", JSON.stringify(modulePaths)); +} + +async function generateModuleDocs(path) { + let moduleSlug = basename(path, ".html"); + let moduleName = moduleSlug.replaceAll("-", "."); + let moduleFile = moduleSlug + ".mdx"; + + let sidebarPrefix = "library/autogenerated"; + let folderPath = resolve("../../docs", sidebarPrefix, moduleSlug); + await mkdir(folderPath, { recursive: true }); + + let sidebarPath = `${sidebarPrefix}/${moduleSlug}/${moduleSlug}`; + + let modulePath = resolve(folderPath, moduleFile); + let outputStream = createWriteStream(modulePath); + + function write(text) { + outputStream.write(text); + } + + function writeLn(text, num = 1) { + outputStream.write(text + "\n".repeat(num)); + } + + function header(module, frontmatter) { + writeLn("---"); + for (let key in frontmatter) { + writeLn(`${key}: ${frontmatter[key]}`); + } + writeLn("---", 2); + + let srcPath = module.split(".").join("/"); + writeLn( +``, 2); + } + + header(moduleName, { title: moduleName, slug: `/library/modules/${moduleName}`}); + + let tree = new Tree(parse(await readFile(path, "utf-8"))); + + let nodes = tree.getChild("html") + .getChild("body") + .getChildID("content") + .getChildID("interface").childNodes; + + for (let node of nodes) { + if (node.hasClass("top")) { + let [src, desc] = node.childNodes; + + // Write out definition + let [def, ...typeParts] = src.childNodes; + let funcName = def.text; + let type = typeParts.filter(n => !(n.hasClass("link") || n.hasClass("selflink"))).map(n => n.text).join(""); + let typeSig = `${funcName}${type}` + writeLn(`### ${funcName}`); + writeLn("```"); + writeLn(`${typeSig}`); + writeLn("```", 2); + + if (desc && desc.hasClass("doc")) { + for (let paragraph of desc.childNodes) { + if (paragraph.tagName === "p") { + for (let part of paragraph.childNodes) { + if (part.tagName === "code") { + write(`\`${part.text}\``); + } else { + write(part.text); + } + } + writeLn("", 2); + } else if (paragraph.tagName === "pre") { + writeLn("```haskell"); + write(paragraph.text); + writeLn("```"); + } + } + } + } else if (node.tagName === "a" && node.getChild("h2")) { + writeLn(`## ${node.text}`); + } + } + + outputStream.close(); + + return sidebarPath; +} \ No newline at end of file diff --git a/scripts/doc-gen/package.json b/scripts/doc-gen/package.json new file mode 100644 index 0000000000..cb880361a9 --- /dev/null +++ b/scripts/doc-gen/package.json @@ -0,0 +1,14 @@ +{ + "name": "tidal-doc-gen", + "version": "0.0.0", + "description": "Script for automatically parsing Haddock docs and generating Tidal API reference.", + "type": "module", + "license": "GPL3-or-later", + "private": true, + "scripts": { + "start": "node index.js" + }, + "dependencies": { + "parse5": "^7.1.2" + } +} diff --git a/scripts/doc-gen/tree.js b/scripts/doc-gen/tree.js new file mode 100644 index 0000000000..9d3b5d9d70 --- /dev/null +++ b/scripts/doc-gen/tree.js @@ -0,0 +1,57 @@ +export class Tree { + tree; + + constructor(tree) { + this.tree = tree; + } + + get childNodes() { + if (!this.tree.childNodes) return []; + + return this.tree.childNodes.map(n => new Tree(n)); + } + + get nodeName() { + return this.tree.nodeName; + } + + get tagName() { + if (!this.tree.tagName) return undefined; + + return this.tree.tagName; + } + + get id() { + if (!this.tree.attrs) return undefined; + + let attr = this.tree.attrs.find(a => a.name === "id"); + return attr ? attr.value : undefined; + } + + get text() { + if (this.nodeName === "#text") { + return this.tree.value; + } else { + return this.childNodes.map(n => n.text).join(""); + } + } + + getChild(tagName) { + return this.getChildren(tagName)[0]; + } + + getChildren(tagName) { + return this.childNodes.filter(n => n.tagName === tagName); + } + + getChildID(idName) { + return this.childNodes.find(n => n.id === idName); + } + + hasClass(className) { + if (!this.tree.attrs) return false; + + let attr = this.tree.attrs.find(a => a.name === "class" && a.value === className); + return !!attr; + } +} \ No newline at end of file diff --git a/scripts/doc-gen/yarn.lock b/scripts/doc-gen/yarn.lock new file mode 100644 index 0000000000..214a91f09c --- /dev/null +++ b/scripts/doc-gen/yarn.lock @@ -0,0 +1,15 @@ +# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. +# yarn lockfile v1 + + +entities@^4.4.0: + version "4.4.0" + resolved "https://registry.yarnpkg.com/entities/-/entities-4.4.0.tgz#97bdaba170339446495e653cfd2db78962900174" + integrity sha512-oYp7156SP8LkeGD0GF85ad1X9Ai79WtRsZ2gxJqtBuzH+98YUV6jkHEKlZkMbcrjJjIVJNIDP/3WL9wQkoPbWA== + +parse5@^7.1.2: + version "7.1.2" + resolved "https://registry.yarnpkg.com/parse5/-/parse5-7.1.2.tgz#0736bebbfd77793823240a23b7fc5e010b7f8e32" + integrity sha512-Czj1WaSVpaoj0wbhMzLmWD69anp2WH7FXMB9n1Sy8/ZFF9jolSQVMu1Ij5WIyGmcBmhk7EOndpO4mIpihVqAXw== + dependencies: + entities "^4.4.0" diff --git a/sidebars.js b/sidebars.js index 27a37eea87..7ee7593bd8 100644 --- a/sidebars.js +++ b/sidebars.js @@ -1,3 +1,5 @@ +let libraryModules = require("./docs/library/autogenerated/sidebar.json"); + module.exports = { docs: { Presentation: [ @@ -131,6 +133,11 @@ module.exports = { "reference/control_busses", ], }, + library: ["library/introduction", + { + Modules: libraryModules + } + ], community: [ "resource/Community", "resource/Friends_and_relations",