tidal 0.4.5 → 0.4.6
raw patch · 5 files changed
+310/−141 lines, 5 files
Files
- Sound/Tidal/Dirt.hs +4/−1
- doc/tidal.md +296/−134
- doc/tidal.pdf binary
- tidal.cabal +2/−2
- tidal.el +8/−4
Sound/Tidal/Dirt.hs view
@@ -70,8 +70,11 @@ dirtToColour p = s where s = fmap (\x -> maybe black (maybe black datumToColour) (Map.lookup (param dirt "sound") x)) p +showToColour :: Show a => a -> ColourD+showToColour = stringToColour . show+ datumToColour :: Datum -> ColourD-datumToColour = stringToColour . show+datumToColour = showToColour stringToColour :: String -> ColourD stringToColour s = sRGB (r/256) (g/256) (b/256)
doc/tidal.md view
@@ -19,6 +19,9 @@ Mac OS X installation: <https://github.com/yaxu/Tidal/blob/master/doc/install-osx.md> +Windows installation:+<https://github.com/yaxu/Tidal/blob/master/doc/install-windows.md>+ Feel free to ask questions and share problems and success stories on the mailing list. @@ -32,7 +35,7 @@ Tidal starts with nine connections to the dirt synthesiser, named from `d1` to `d9`. Here's a minimal example, that plays a bass drum every loop: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound "bd" ~~~~ @@ -49,14 +52,14 @@ number, for example this picks the fourth bass drum (it counts from 0, so :3 gives you the fourth sound): -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound "bd:3" ~~~~ Putting things in quotes actually defines a sequence. For example, the following gives you a pattern of bass drum then snare: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound "bd sn" ~~~~ @@ -67,7 +70,7 @@ The `sound` function in the above is just one possible parameter that we can send to the synth. Below show a couple more, `pan` and `vowel`: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound "bd sn sn" |+| vowel "a o e" |+| pan "0 0.5 1"@@ -84,26 +87,26 @@ When specifying a sequence you can group together several events to play inside a single event by using square brackets: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound "[bd sn sn] sn" ~~~~ This is good for creating compound time signatures (sn = snare, cp = clap): -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound "[bd sn sn] [cp cp]" ~~~~ And you put events inside events to create any level of detail: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound "[bd bd] [bd [sn [sn sn] sn] sn]" ~~~~ You can also layer up several loops, by using commas to separate the different parts: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound "[bd bd bd, sn cp sn cp]" ~~~~ @@ -114,23 +117,23 @@ Try replacing the square brackets with curly brackets: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound "{bd ht lt, sn cp}" ~~~~ This is a different way of specifying a polyrhythm. Instead of both parts taking up the same amount of time, each event within the second-part takes up the same amount of time as the second part. You can-embed these different forms inside each other:+part takes up the same amount of time as one (top-level) event in the+first part. You can embed these different forms inside each other: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound "{bd [ht sn, lt mt ht] lt, sn cp}" ~~~~ You can make parts of patterns repeat by using `*`, for example the following expressions produce the same pattern: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound "[bd bd bd, sn cp sn cp]" d1 $ sound "[bd*3, [sn cp]*2]"@@ -139,7 +142,7 @@ Conversely, you can slow down patterns by using `/`, the following pattern plays part of each subpattern each cycle: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound "[bd sn sn*3]/2 [bd sn*3 bd*4]/3" ~~~~ @@ -148,35 +151,35 @@ An empty pattern is defined as `silence`, so if you want to 'switch off' a pattern, you can just set it to that: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 silence ~~~~ If you want to set all the connections (from `d1` to `d9`) to silence at once, there's a single-word shortcut for that: -~~~~ {#mycode .haskell}+~~~~ {.haskell} hush ~~~~ You can also isolate a single connection and silence all others with the `solo` function: -~~~~ {#mycode .haskell}+~~~~ {.haskell} solo $ d1 $ sound "bd sn" ~~~~ -# Beats per second+# Tempo You can change the beats per second (bps) like this: -~~~~ {#mycode .haskell}+~~~~ {.haskell} bps 1 ~~~~ If you prefer to think in beats per minute, simply divide by 60 -~~~~ {#mycode .haskell}+~~~~ {.haskell} bps (140 / 60) ~~~~ @@ -190,6 +193,7 @@ odx diphone2 house off ht tink perc bd industrial pluck trump printshort jazz voodoo birds3 procshort blip drum jvbass psr wobble drumtraks koy rave bottle kurt latibro rm sax lighter lt+ arpy feel less stab ul Each one is a folder containing one or more wav files. For example when you put `bd:1` in a sequence, you're picking up the second wav@@ -206,7 +210,7 @@ (for panning sounds between speakers) and `shape` (for adding distortion) which are patterns of numbers. -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound "[bd bd] [bd [sn [sn sn] sn] sn]" |+| pan sinewave1 |+| shape sinewave1@@ -225,31 +229,31 @@ For example, `rev` reverses a pattern: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ rev (sound "[bd bd] [bd [sn [sn sn] sn] sn]") ~~~~ That's not so exciting, but things get more interesting when this is-used in combination another function. For example `every` takes two+used in combination with another function. For example `every` takes two parameters, a number, a function and a pattern to apply the function to. The number specifies how often the function is applied to the pattern. For example, the following reverses the pattern every fourth repetition: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ every 4 (rev) (sound "bd*2 [bd [sn sn*2 sn] sn]") ~~~~ You can also slow down or speed up the playback of a pattern, this makes it a quarter of the speed: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ slow 4 $ sound "bd*2 [bd [sn sn*2 sn] sn]" ~~~~ And this four times the speed: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ density 4 $ sound "bd*2 [bd [sn sn*2 sn] sn]" ~~~~ @@ -257,7 +261,7 @@ Again, this can be applied selectively: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ every 4 (density 4) $ sound "bd*2 [bd [sn sn*2 sn] sn]" ~~~~ @@ -268,7 +272,7 @@ Instead of putting transformations up front, separated by the pattern by the `$` symbol, you can put them inside the pattern, for example: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound (every 4 (density 4) "bd*2 [bd [sn sn*2 sn] sn]") |+| pan sinewave1 ~~~~@@ -280,7 +284,7 @@ around `every` and its parameters before passing to its function `sound`. -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound (every 4 (density 4) "bd*2 [bd [sn sn*2 sn] sn]") |+| pan (slow 16 sinewave1) ~~~~@@ -295,7 +299,7 @@ wanted to pass a sinewave to `shape`, but wanted the sinewave to go from `0` to `0.5` rather than from `0` to `1`, you could do this: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound "bd*2 [bd [sn sn*2 sn] sn]")) |+| shape ((/ 2) <$> sinewave1) ~~~~@@ -303,33 +307,62 @@ The above applies the function `(/ 2)` (which simply means divide by two), to all the values inside the `sinewave1` pattern. -# Parameters+# Synth Parameters -These are the synthesis parameters you can use+Synth parameters generate or affect sample playback. These are the +synthesis parameters you can use: -* `sound` - a pattern of strings representing sound sample names (required)-* `pan` - a pattern of numbers between 0 and 1, from left to right (assuming stereo)-* `shape` - wave shaping distortion, a pattern of numbers from 0 for no distortion up to 1 for loads of distortion-* `vowel` - formant filter to make things sound like vowels, a pattern of either `a`, `e`, `i`, `o` or `u`. Use a rest (`~`) for no effect.-* `cutoff` - a pattern of numbers from 0 to 1-* `resonance` - a pattern of numbers from 0 to 1-* `speed` - a pattern of numbers from 0 to 1, which changes the speed of sample playback, i.e. a cheap way of changing pitch * `accelerate` - a pattern of numbers that speed up (or slow down) samples while they play.-* `begin` - a pattern of numbers from 0 to 1. Skips the beginning of each sample, e.g. `0.25` to miss off the first quarter from each sample.-* `end` - the same as `begin`, but cuts the end off samples, shortening them;- e.g. `0.75` to miss off the last quarter of each sample.+* `begin` - 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.+* `cutoff` - a pattern of numbers from 0 to 1. Applies the cutoff frequency of the low-pass filter. * `delay` - a pattern of numbers from 0 to 1. Sets the level of the delay signal. * `delayfeedback` - a pattern of numbers from 0 to 1. Sets the amount of delay feedback. * `delaytime` - a pattern of numbers from 0 to 1. Sets the length of the delay.+* `end` - 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.+* `gain` - a pattern of numbers that specify volume. Values less than 1 make the sound quieter. Values greater than 1 make the sound louder.+* `pan` - a pattern of numbers between 0 and 1, from left to right (assuming stereo)+* `resonance` - a pattern of numbers from 0 to 1. Applies the resonance of the low-pass filter.+* `shape` - wave shaping distortion, a pattern of numbers from 0 for no distortion up to 1 for loads of distortion+* `sound` - a pattern of strings representing sound sample names (required)+* `speed` - a pattern of numbers from 0 to 1, which changes the speed of sample playback, i.e. a cheap way of changing pitch+* `vowel` - formant filter to make things sound like vowels, a pattern of either `a`, `e`, `i`, `o` or `u`. Use a rest (`~`) for no effect. # Pattern transformers +Pattern transformers are functions that take a pattern as input and transform+it into a new pattern.+ In the following, functions are shown with their Haskell type and a short description of how they work. +## Beat rotation++~~~~ {.haskell}+(<~) :: Time -> Pattern a -> Pattern a+~~~~++or++~~~~ {.haskell}+(~>) :: Time -> Pattern a -> Pattern a+~~~~++(The above means that `<~` and `~>` are functions that are given a+time value and a pattern of any type, and returns a pattern of the+same type.)++Rotate a loop either to the left or the right.++Example:++~~~~ {.haskell}+d1 $ every 4 (0.25 <~) $ sound (density 2 "bd sn kurt")+~~~~+ ## brak -~~~~ {#mycode .haskell}+~~~~ {.haskell} brak :: Pattern a -> Pattern a ~~~~ @@ -340,72 +373,68 @@ Example: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound (brak "bd sn kurt") ~~~~ -## Reversal+## degrade and degradeBy -~~~~ {#mycode .haskell}-rev :: Pattern a -> Pattern a+~~~~ {.haskell}+degrade :: Pattern a -> Pattern a+degradeBy :: Double -> Pattern a -> Pattern a ~~~~ -Reverse a pattern--Examples:+`degrade` randomly removes events from a pattern 50% of the time: -~~~~ {#mycode .haskell}-d1 $ every 3 (rev) $ sound (density 2 "bd sn kurt")+~~~~ {.haskell}+d1 $ slow 2 $ degrade $ sound "[[[feel:5*8,feel*3] feel:3*8], feel*4]"+ |+| accelerate "-6"+ |+| speed "2" ~~~~ -## Beat rotation+The shorthand syntax for `degrade` is a question mark: `?`. Using `?`+will allow you to randomly remove events from a portion of a pattern: -~~~~ {#mycode .haskell}-(<~) :: Time -> Pattern a -> Pattern a+~~~~ {.haskell}+d1 $ slow 2 $ sound "bd ~ sn bd ~ bd? [sn bd?] ~" ~~~~ -or+You can also use `?` to randomly remove events from entire sub-patterns: -~~~~ {#mycode .haskell}-(~>) :: Time -> Pattern a -> Pattern a+~~~~ {.haskell}+d1 $ slow 2 $ sound "[[[feel:5*8,feel*3] feel:3*8]?, feel*4]" ~~~~ -(The above means that `<~` and `~>` are functions that are given a-time value and a pattern of any type, and returns a pattern of the-same type.)--Rotate a loop either to the left or the right.--Example:+`degradeBy` allows you to control the percentage of events that+are removed. For example, to remove events 90% of the time: -~~~~ {#mycode .haskell}-d1 $ every 4 (0.25 <~) $ sound (density 2 "bd sn kurt")+~~~~ {.haskell}+d1 $ slow 2 $ degradeBy 0.9 $ sound "[[[feel:5*8,feel*3] feel:3*8], feel*4]"+ |+| accelerate "-6"+ |+| speed "2" ~~~~ -## Increase or decrease density+## density -~~~~ {#mycode .haskell}+~~~~ {.haskell} density :: Time -> Pattern a -> Pattern a ~~~~ -or -~~~~ {#mycode .haskell}-slow :: Time -> Pattern a -> Pattern a-~~~~--Speed up or slow down a pattern.+Speed up a pattern. Example: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound (density 2 "bd sn kurt")- |+| slow 3 (vowel "a e o")+ |+| density 3 (vowel "a e o") ~~~~ -## Every nth repetition, do this+Also, see `slow`. -~~~~ {#mycode .haskell}+## every nth repetition, do this++~~~~ {.haskell} every :: Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a ~~~~ @@ -418,31 +447,15 @@ Example: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound (every 3 (density 2) "bd sn kurt") ~~~~ -~~~~ {#mycode .haskell}-whenmod :: Int -> Int -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a-~~~~--(The above has a similar form to `every`, but requires an additional-number.)--Similar to `every`, but applies the function to the pattern, when the-remainder of the current loop number divided by the first parameter,-is less than the second parameter.--For example the following makes every other block of four loops twice-as dense:--~~~~ {#mycode .haskell}-d1 $ whenmod 8 4 (density 2) (sound "bd sn kurt")-~~~~+Also, see `whenmod`. -# Interlace+## interlace -~~~~ {#mycode .haskell}+~~~~ {.haskell} interlace :: OscPattern -> OscPattern -> OscPattern ~~~~ @@ -454,13 +467,107 @@ Example: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ interlace (sound "bd sn kurt") (every 3 rev $ sound "bd sn:2") ~~~~ -# Spread+## rev -~~~~ {#mycode .haskell}+~~~~ {.haskell}+rev :: Pattern a -> Pattern a+~~~~++Reverse a pattern++Examples:++~~~~ {.haskell}+d1 $ every 3 (rev) $ sound (density 2 "bd sn kurt")+~~~~++## slow++~~~~ {.haskell}+slow :: Time -> Pattern a -> Pattern a+~~~~++Slow down a pattern.++Example:++~~~~ {.haskell}+d1 $ sound (slow 2 "bd sn kurt")+ |+| slow 3 (vowel "a e o")+~~~~++Slow also accepts numbers between 0 and 1, which causes the pattern to speed up:++~~~~ {.haskell}+d1 $ sound (slow 0.5 "bd sn kurt")+ |+| slow 0.75 (vowel "a e o")+~~~~++Also, see `density`.++## slowspread++~~~~ {.haskell}+slowspread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b+~~~~++`slowspread` takes a list of pattern transforms and applies them one at a time, per cycle, +then repeats.++Example:++~~~~ {.haskell}+d1 $ slowspread ($) [density 2, rev, slow 2, striate 3, (|+| speed "0.8")] + $ sound "[bd*2 [~ bd]] [sn future]*2 cp jvbass*4"+~~~~++Above, the pattern will have these transforms applied to it, one at a time, per cycle:++* cycle 1: `density 2` - pattern will increase in speed+* cycle 2: `rev` - pattern will be reversed+* cycle 3: `slow 2` - pattern will decrease in speed+* cycle 4: `striate 3` - pattern will be granualized+* cycle 5: `(|+| speed "0.8")` - pattern samples will be played back more slowly++After `(|+| speed "0.8")`, the transforms will repeat and start at `density 2` again.++## smash++~~~~ {.haskell}+smash :: Int -> [Time] -> OscPattern -> OscPattern+~~~~++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"+~~~~++## spread++~~~~ {.haskell} spread :: (a -> t -> Pattern b) -> [a] -> t -> Pattern b ~~~~ @@ -474,33 +581,33 @@ Taking a simple high hat loop as an example: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound "ho ho:2 ho:3 hc" ~~~~ We can slow it down by different amounts, such as by a half: -~~~~ {#mycode .haskell}+~~~~ {.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): -~~~~ {#mycode .haskell}+~~~~ {.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: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ spread slow [2,4%3] $ sound "ho ho:2 ho:3 hc" ~~~~ There's a version of this function, `spread'` (pronounced "spread prime"), which takes a *pattern* of parameters, instead of a list: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ spread' slow "2 4%3" $ sound "ho ho:2 ho:3 hc" ~~~~ @@ -508,19 +615,19 @@ implementation this sounds completely different! One advantage of using `spread'` though is that you can provide polyphonic parameters, e.g.: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ spread' slow "[2 4%3, 3]" $ sound "ho ho:2 ho:3 hc" ~~~~ -# Striate+## striate -~~~~ {#mycode .haskell}+~~~~ {.haskell} striate :: Int -> OscPattern -> OscPattern ~~~~ Striate is a kind of granulator, for example: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ striate 3 $ sound "ho ho:2 ho:3 hc" ~~~~ @@ -537,7 +644,7 @@ it over 8 cycles and manipulates those parts by reversing and rotating the loops. -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ slow 8 $ striate 128 $ sound "bev" ~~~~ @@ -548,7 +655,7 @@ example the following will cut the bev sample into 32 parts, but each will be 1/16th of a sample long: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ slow 32 $ striate' 32 (1/16) $ sound "bev" ~~~~ @@ -556,36 +663,60 @@ internally. This means that if you're using `striate` (or `striate'`) you probably shouldn't also specify `begin` or `end`. -# Smash+## stut -~~~~ {#mycode .haskell}-smash :: Int -> [Time] -> OscPattern -> OscPattern+~~~~ {.haskell}+stut :: Integer -> Double -> Rational -> OscPattern -> OscPattern ~~~~ -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.+Stut applies a type of delay to a pattern. It has three parameters, +which could be called depth, feedback and time. Depth is an integer+and the others floating point. This adds a bit of echo: -So this:+~~~~ {.haskell}+d1 $ stut 4 0.5 0.2 $ sound "bd sn"+~~~~ -~~~~ {#mycode .haskell}- d1 $ smash 3 [2,3,4] $ sound "ho ho:2 ho:3 hc"+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:++~~~~ {.haskell}+d1 $ stut 4 0.5 (-0.2) $ sound "bd sn" ~~~~ -Is a bit like this:+## wedge -~~~~ {#mycode .haskell}- d1 $ spread (slow) [2,3,4] $ striate 3 $ sound "ho ho:2 ho:3 hc"+~~~~{.haskell}+wedge :: Time -> Pattern a -> Pattern a -> Pattern a ~~~~ -This is quite dancehall:+`wedge` combines two patterns by squashing two patterns into a single pattern cycle.+It takes a ratio as the first argument. The ratio determines what percentage of the+pattern cycle is taken up by the first pattern. The second pattern fills in the+remainder of the pattern cycle. -~~~~ {#mycode .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"+~~~~{.haskell}+d1 $ wedge (1/4) "bd*2 arpy*3 cp sn*2" "odx [feel future]*2 hh hh" ~~~~ +## whenmod++~~~~ {.haskell}+whenmod :: Int -> Int -> (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 less 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")+~~~~+ # Combining patterns Because Tidal patterns are defined as something called an "applicative@@ -593,7 +724,7 @@ patterns of numbers, you can combine the patterns by, for example, multiplying the numbers inside them together, like this: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ (brak (sound "bd sn:2 bd sn")) |+| pan ((*) <$> sinewave1 <*> (slow 8 $ "0 0.25 0.75")) ~~~~@@ -605,7 +736,7 @@ Here's another example of this technique: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ sound (pick <$> "kurt mouth can*3 sn" <*> slow 7 "0 1 2 3 4") ~~~~ @@ -620,13 +751,41 @@ By the way, "0 1 2 3 4" in the above could be replaced with the pattern generator `run 5`. +# Stacking++~~~~ {.haskell}+stack :: [Pattern a] -> Pattern a+~~~~++`stack` takes a list of patterns and combines them into a new pattern by+playing all of the patterns in the list simultaneously.++~~~~ {.haskell}+d1 $ stack [ + sound "bd bd*2", + sound "hh*s [sn cp] cp future*4", + sound (samples "arpy*8", (run 16))+]+~~~~++This is useful if you want to use a transform or synth parameter on the entire +stack:++~~~~ {.haskell}+d1 $ whenmod 5 3 (striate 3) $ stack [ + sound "bd bd*2", + sound "hh*s [sn cp] cp future*4", + sound (samples "arpy*8", (run 16))+] |+| speed "[[1 0.8], [1.5 2]*2]/3"+~~~~+ # Juxtapositions 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: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ slow 32 $ jux (rev) $ striate' 32 (1/16) $ sound "bev" ~~~~ @@ -635,7 +794,7 @@ example this both reverses and halves the playback speed of the pattern in the righthand channel: -~~~~ {#mycode .haskell}+~~~~ {.haskell} d1 $ slow 32 $ jux ((|+| speed "0.5") . rev) $ striate' 32 (1/16) $ sound "bev" ~~~~ @@ -644,6 +803,9 @@ You can find a stream of minimal cycles written in Tidal in the following twitter feed: <http://twitter.com/tidalcycles/>++You can look for additional information in the tidal wiki:+ <https://github.com/yaxu/Tidal/wiki> # Acknowledgments
− doc/tidal.pdf
binary file changed (82680 → absent bytes)
tidal.cabal view
@@ -1,5 +1,5 @@ name: tidal-version: 0.4.5+version: 0.4.6 synopsis: Pattern language for improvised music -- description: homepage: http://yaxu.org/tidal/@@ -13,7 +13,7 @@ build-type: Simple cabal-version: >=1.4 -Extra-source-files: README.md tidal.el doc/tidal.md doc/tidal.pdf+Extra-source-files: README.md tidal.el doc/tidal.md Description: Tidal is a domain specific language for live coding pattern.
tidal.el view
@@ -56,9 +56,10 @@ (tidal-see-output)) (tidal-send-string ":set prompt \"\"") (tidal-send-string ":module Sound.Tidal.Context")- ;(tidal-send-string ":module Volca.Beat Volca.Key")- ;(tidal-send-string "(note, [portamento, expression, voice, octave, detune, vcoegint, cutoff, vcfegint, lforate, lfopitchint, lfocutoffint, attack, decay, sustain, delaytime , delayfeedback], keystop) <- keystart")- ;(tidal-send-string "(drum, [clapSpeed, clavesSpeed, agogoSpeed, crashSpeed, stutterTime, stutterDepth, tomDecay, clhatDecay, ophatDecay, hatGrain], beatstop) <- startbeat")+; (tidal-send-string "import Volca.Beat")+; (tidal-send-string "import Volca.Key")+; (tidal-send-string "(note, [portamento, expression, voice, octave, detune, vcoegint, kcutoff, vcfegint, lforate, lfopitchint, lfocutoffint, attack, decay, sustain, dtime , dfeedback], keystop) <- keystart")+; (tidal-send-string "(drum, [clapSpeed, clavesSpeed, agogoSpeed, crashSpeed, stutterTime, stutterDepth, tomDecay, clhatDecay, ophatDecay, hatGrain], beatstop) <- startbeat") (tidal-send-string "d1 <- dirtStream") (tidal-send-string "d2 <- dirtStream") (tidal-send-string "d3 <- dirtStream")@@ -68,9 +69,10 @@ (tidal-send-string "d7 <- dirtStream") (tidal-send-string "d8 <- dirtStream") (tidal-send-string "d9 <- dirtStream")+ (tidal-send-string "d10 <- dirtStream") (tidal-send-string "(cps, getNow) <- bpsUtils") (tidal-send-string "let bps x = cps (x/2)")- (tidal-send-string "let hush = mapM_ ($ silence) [d1,d2,d3,d4,d5,d6,d7,d8,d9]")+ (tidal-send-string "let hush = mapM_ ($ silence) [d1,d2,d3,d4,d5,d6,d7,d8,d9,d10]") (tidal-send-string "let solo = (>>) hush") (tidal-send-string ":set prompt \"tidal> \"") )@@ -346,6 +348,7 @@ (define-key map [?\C-c ?\C-q] 'tidal-quit-haskell) (define-key map [?\C-c ?\C-c] 'tidal-run-line) (define-key map [?\C-c ?\C-e] 'tidal-run-multiple-lines)+ (define-key map (kbd "<C-return>") 'tidal-run-multiple-lines) (define-key map [?\C-c ?\C-r] 'tidal-run-region) (define-key map [?\C-c ?\C-l] 'tidal-load-buffer) (define-key map [?\C-c ?\C-i] 'tidal-interrupt-haskell)@@ -377,6 +380,7 @@ (local-set-key [?\C-c ?\C-q] 'tidal-quit-haskell) (local-set-key [?\C-c ?\C-c] 'tidal-run-line) (local-set-key [?\C-c ?\C-e] 'tidal-run-multiple-lines)+ (local-set-key (kbd "<C-return>") 'tidal-run-multiple-lines) (local-set-key [?\C-c ?\C-r] 'tidal-run-region) (local-set-key [?\C-c ?\C-l] 'tidal-load-buffer) (local-set-key [?\C-c ?\C-i] 'tidal-interrupt-haskell)