Control

spin

:: Pattern Int -> ControlPattern -> ControlPattern

spin will “spin” and 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 work well on multichannel systems.

d1 $ slow 3
   $ spin 4
   $ sound "drum*3 tabla:4 [arpy:2 ~ arpy] [can:2 can:3]"

_spin

:: Int -> ControlPattern -> ControlPattern

chop

:: Pattern Int -> ControlPattern -> ControlPattern

chop granularises every sample in place as it is played, turning a pattern of samples into a pattern of sample parts. Can be used to explore granular synthesis.

Use an integer value to specify how many granules each sample is chopped into:

d1 $ chop 16 $ sound "arpy arp feel*4 arpy*4"

Different values of chop can yield very different results, depending on the samples used:

d1 $ chop 16 $ sound (samples "arpy*8" (run 16))
d1 $ chop 32 $ sound (samples "arpy*8" (run 16))
d1 $ chop 256 $ sound "bd*4 [sn cp] [hh future]*2 [cp feel]"

You can also use chop (or striate) with very long samples to cut them into short chunks and pattern those chunks. The following cuts a sample into 32 parts, and plays it over 8 cycles:

d1 $ loopAt 8 $ chop 32 $ sound "bev"

The loopAt takes care of changing the speed of sample playback so that the sample fits in the given number of cycles perfectly. As a result, in the above the granules line up perfectly, so you can’t really hear that the sample has been cut into bits. Again, this becomes more apparent when you do further manipulations of the pattern, for example rev to reverse the order of the cut up bits:

d1 $ loopAt 8 $ rev $ chop 32 $ sound "bev"

chopArc

:: Arc -> Int -> [Arc]

_chop

:: Int -> ControlPattern -> ControlPattern

striate

:: Pattern Int -> ControlPattern -> ControlPattern

Striate is a kind of granulator, cutting samples into bits in a similar to chop, but the resulting bits are organised differently. For example:

d1 $ striate 3 $ sound "ho ho:2 ho:3 hc"

This plays the loop the given number of times, but triggers progressive portions of each sample. So in this case it plays the loop three times, the first time playing the first third of each sample, then the second time playing the second third of each sample, and lastly playing the last third of each sample. Replacing striate with chop above, one can hear that the ‘chop version plays the bits from each chopped-up sample in turn, while striate “interlaces” the cut up bits of samples together.

You can also use striate with very long samples, to cut them into short chunks and pattern those chunks. This is where things get towards granular synthesis. The following cuts a sample into 128 parts, plays it over 8 cycles and manipulates those parts by reversing and rotating the loops:

d1 $  slow 8 $ striate 128 $ sound "bev"

_striate

:: Int -> ControlPattern -> ControlPattern

mergePlayRange

:: (Double, Double) -> ValueMap -> ValueMap

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:

d1 $ slow 32 $ striateBy 32 (1/16) $ sound "bev"

Note that striate and striateBy use the begin and end parameters internally. This means that you probably shouldn’t also specify begin or end.

striate'

:: Pattern Int -> Pattern Double -> ControlPattern -> ControlPattern

DEPRECATED, use striateBy instead.

_striateBy

:: Int -> Double -> ControlPattern -> ControlPattern

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:

d1 $ gap 8 $ sound "jvbass"
d1 $ gap 16 $ sound "[jvbass drum:4]"

_gap

:: Int -> ControlPattern -> ControlPattern

weave

:: Time -> ControlPattern -> [ControlPattern] -> ControlPattern

weave applies one control pattern to a list of other control patterns, with a successive time offset. It uses an OscPattern to apply the function at different levels to each pattern, creating a weaving effect. For example:

d1
  $ weave 16 (pan sine)
      [ sound "bd sn cp"
      , sound "casio casio:1"
      , sound "[jvbass*2 jvbass:2]/2"
      , sound "hc*4"
      ]

In the above, the pan sine control pattern is slowed down by the given number of cycles, in particular 16, and applied to all of the given sound patterns. What makes this interesting is that the pan control pattern is successively offset for each of the given sound patterns; because the pan is closed down by 16 cycles, and there are four patterns, they are ‘spread out’, i.e. with a gap of four cycles. For this reason, the four patterns seem to chase after each other around the stereo field. Try listening on headphones to hear this more clearly.

You can even have it the other way round, and have the effect parameters chasing after each other around a sound parameter, like this:

d1
  $ weave 16 (sound "arpy" >| n (run 8))
      [ vowel "a e i"
      , vowel "i [i o] o u"
      , vowel "[e o]/3 [i o u]/2"
      , speed "1 2 3"
      ]

weaveWith

:: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a

weaveWith is similar to the above, but weaves with a list of functions, rather than a list of controls. For example:

d1
  $ weaveWith 3 (sound "bd [sn drum:2*2] bd*2 [sn drum:1]")
      [ fast 2
      , (# speed "0.5")
      , chop 16
      ]

weave'

:: Time -> Pattern a -> [Pattern a -> Pattern a] -> Pattern a

An old alias for weaveWith.

interlace

:: ControlPattern -> ControlPattern -> ControlPattern

(A function that takes two ControlPatterns, and blends them together into a new ControlPattern. A ControlPattern is basically a pattern of messages to a synthesiser.)

Shifts between the two given patterns, using distortion.

Example:

d1 $ interlace (sound  "bd sn kurt") (every 3 rev $ sound  "bd sn:2")

slice

:: Pattern Int -> Pattern Int -> ControlPattern -> ControlPattern

slice is similar to chop and striate, in that it’s used to slice samples up into bits. The difference is that it allows you to rearrange those bits as a pattern.

d1 $ slice 8 "7 6 5 4 3 2 1 0"
   $ sound "breaks165"
   # legato 1

The above slices the sample into eight bits, and then plays them backwards, equivalent of applying rev $ chop 8. Here’s a more complex example:

d1 $ slice 8 "[<0*8 0*2> 3*4 2 4] [4 .. 7]"
   $ sound "breaks165"
   # legato 1

_slice

:: Int -> Int -> ControlPattern -> ControlPattern

randslice

:: Pattern Int -> ControlPattern -> ControlPattern

randslice chops the sample into the given number of pieces and then plays back a random one each cycle:

d1 $ randslice 32 $ sound "bev"

Use fast to get more than one per cycle:

d1 $ fast 4 $ randslice 32 $ sound "bev"

_splice

:: Int -> Pattern Int -> ControlPattern -> Pattern (Map String Value)

splice

:: Pattern Int -> Pattern Int -> ControlPattern -> Pattern (Map String Value)

splice is similar to slice, but the slices are automatically pitched up or down to fit their ‘slot’.

d1 $ splice 8 "[<0*8 0*2> 3*4 2 4] [4 .. 7]" $ sound "breaks165"

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 the density of the pattern to match.

d1 $ loopAt 4 $ sound "breaks125"

It’s a good idea to use this in conjunction with chop, so the break is chopped into pieces, and you don’t have to wait for the whole sample to start/stop.

d1 $ loopAt 4 $ chop 32 $ sound "breaks125"

Like all Tidal functions, you can mess about with this considerably. The below example shows how you can supply a pattern of cycle counts to loopAt:

d1 $ juxBy 0.6 (|* speed "2")
   $ slowspread (loopAt) [4,6,2,3]
   $ chop 12
   $ sound "fm:14"

hurry

:: Pattern Rational -> ControlPattern -> ControlPattern

hurry is similar to fast in that it speeds up a pattern, but it also increases the speed control by the same factor. So, if you’re triggering samples, the sound gets higher in pitch. For example:

d1 $ every 2 (hurry 2) $ sound "bd sn:2 ~ cp"

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:

d1 $ smash 3 [2,3,4] $ sound "ho ho:2 ho:3 hc"

is a bit like this:

d1 $ spread (slow) [2,3,4] $ striate 3 $ sound "ho ho:2 ho:3 hc"

This is quite dancehall:

d1 $ ( spread' slow "1%4 2 1 3"
     $ spread (striate) [2,3,4,1]
     $ sound "sn:2 sid:3 cp sid:4"
     )
   # speed "[1 2 1 1]/2"

smash'

:: Int -> [Pattern Time] -> ControlPattern -> ControlPattern

An alternative form of smash, which uses chop instead of striate.

Compare the following variations:

d1 $ smash 6 [2,3,4] $ sound "ho ho:2 ho:3 hc"
d1 $ smash' 6 [2,3,4] $ sound "ho ho:2 ho:3 hc"
d1 $ smash 12 [2,3,4] $ s "bev*4"
d1 $ smash' 12 [2,3,4] $ s "bev*4"

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. depth is an integer, and time and feedback are floating point numbers.

This adds a bit of echo:

d1 $ echo 4 0.2 0.5 $ sound "bd sn"

The above results in 4 echoes, 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

:: Integer -> Rational -> Double -> ControlPattern -> ControlPattern

echoWith

:: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

echoWith is similar to echo, but instead of just decreasing volume to produce echoes, echoWith applies a function each step and overlays the result delayed by the given time.

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.

d1 $ echoWith 4 (1/6) (|* speed "1.5") $ sound "arpy arpy:2"

In the above, three versions are put on top, with each step getting higher in pitch as |* speed "1.5" is successively applied.

_echoWith

:: (Num n, Ord n) => n -> Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

stut

:: Pattern Integer -> Pattern Double -> Pattern Rational -> ControlPattern -> ControlPattern

DEPRECATED, use echo instead

_stut

:: Integer -> Double -> Rational -> ControlPattern -> ControlPattern

stutWith

:: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

DEPRECATED, use echoWith instead

_stutWith

:: (Num n, Ord n) => n -> Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

stut'

:: Pattern Int -> Pattern Time -> (Pattern a -> Pattern a) -> Pattern a -> Pattern a

DEPRECATED, use echoWith instead

sec

:: Fractional a => Pattern a -> Pattern a

Turns a pattern of seconds into a pattern of (rational) cycle durations

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

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

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

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:

d1 $ qtrigger $ filterWhen (>= 0) $ s "hh(5, 8)"

Alternatively, you can use wait to achieve the same result:

wait 1 1 $ s "bd hh hh hh"

qt

:: Pattern a -> Pattern a

Alias for qtrigger.

ctrigger

:: Pattern a -> Pattern a

Ceiling trigger. Aligns the start of a pattern to the next cycle boundary, just like qtrigger.

rtrigger

:: Pattern a -> Pattern a

Rounded trigger. Aligns the start of a pattern to the nearest cycle boundary, either next or previous.

ftrigger

:: Pattern a -> Pattern a

Floor trigger. Aligns the start of a pattern to the previous cycle boundary.

mtrigger

:: Int -> Pattern a -> Pattern a

(Alias <strong>mt</strong>) 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.

In the following example, when activating the d1 pattern, it will start at the same time as the next clap, even if it has to wait for 3 cycles. Once activated, the arpy sound will play on every cycle, just like any other pattern:

do
  resetCycles
  d2 $ every 4 (# s "clap") $ s "bd"

d1 $ mtrigger 4 $ filterWhen (>=0) $ s "arpy"

mt

:: Int -> Pattern a -> Pattern a

Alias for mtrigger.

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.

This is a more flexible triggering function. In fact, all the other trigger functions are defined based on triggerWith. For example, trigger is just triggerWith id.

In the next example, use d1 as a metronome, and play with different values (from 0 to 1) on the const expression. You’ll notice how the clap is displaced from the beginning of each cycle to the end, as the number increases:

d1 $ s "bd hh!3"

d2 $ triggerWith (const 0.1) $ s "clap"

This last example is equivalent to this:

d2 $ rotR 0.1 $ s "clap"

splat

:: Pattern Int -> ControlPattern -> ControlPattern -> ControlPattern