Sound.Tidal.Pattern

Like *, but the "wholes" come from the right

Like *, but the "wholes" come from the left

Like *, but the "wholes" come from the left

General utilities..

Apply one of three functions to a Value, depending on its type

collects all events occuring at the exact same time into a list

collects all events satisfying the same constraint into a list

Returns a list of events, with any adjacent parts of the same whole combined

An alias for fast

Get the timespan of an event's part

Get the onset of an event's whole

Get the offset of an event's part

Extract a pattern of boolean values by from a control pattern, given the name of the control

Extract a pattern of floating point values by from a control pattern, given the name of the control

Extract a pattern of integer values by from a control pattern, given the name of the control

Extract a pattern of note values by from a control pattern, given the name of the control

Extract a pattern of rational values by from a control pattern, given the name of the control

Extract a pattern of string values by from a control pattern, given the name of the control

Apply one of two functions to a pair of Values, depending on their types (int or float; strings and rationals are ignored)

Speed up a pattern by the given time pattern.

For example, the following will play the sound pattern "bd sn kurt" twice as fast (i.e., so it repeats twice per cycle), and the vowel pattern three times as fast:

d1 $ sound (fast 2 "bd sn kurt")
   # fast 3 (vowel "a e o")

The first parameter can be patterned to, for example, play the pattern at twice the speed for the first half of each cycle and then four times the speed for the second half:

d1 $ fast "2 4" $ sound "bd sn kurt cp"

fastSqueeze speeds up a pattern by a time pattern given as input, squeezing the resulting pattern inside one cycle and playing the original pattern at every repetition.

To better understand how it works, compare it with fast:

>>> fast "1 2" $ s "bd sn"(0>½)|s: "bd"(½>¾)|s: "bd"(¾>1)|s: "sn"

This will give bd played in the first half cycle, and bd sn in the second half. On the other hand, using fastSqueeze;

>>> print $ fastSqueeze "1 2" $ s "bd sn"(0>¼)|s: "bd"(¼>½)|s: "sn"(½>⅝)|s: "bd"(⅝>¾)|s: "sn"(¾>⅞)|s: "bd"(⅞>1)|s: "sn"

The original pattern will play in the first half, and two repetitions of the original pattern will play in the second half. That is, every repetition contains the whole pattern.

If the time pattern has a single value, it becomes equivalent to fast:

d1 $ fastSqueeze 2 $ s "bd sn"
d1 $ fast 2 $ s "bd sn"
d1 $ s "[bd sn]*2"

Turns a pattern of Maybe values into a pattern of values, dropping the events of Nothing.

Remove events from patterns that to not meet the given test

Turns a pattern of patterns into a single pattern. Like unwrap, but structure only comes from the inner pattern.

Returns True if the two given events are adjacent parts of the same whole

Mark values in the first pattern which match with at least one value in the second pattern.

• Patterns as numbers

True if an Event's starts is within given Arc

Turns a pattern of patterns into a single pattern. Like unwrap, but structure only comes from the outer pattern.

rev p returns p with the event positions in each cycle reversed (or mirrored).

For example rev "1 [~ 2] ~ 3" is equivalent to rev "3 ~ [2 ~] 1".

Note that rev reverses on a cycle-by-cycle basis. This means that rev (slow 2 "1 2 3 4") would actually result in (slow 2 "2 1 4 3"). This is because the slow 2 makes the repeating pattern last two cycles, each of which is reversed independently.

In practice rev is generally used with conditionals, for example with every:

d1 $ every 3 rev $ n "0 1 [~ 2] 3" # sound "arpy"

or jux:

d1 $ jux rev $ n (iter 4 "0 1 [~ 2] 3") # sound "arpy"

Shifts a pattern back in time by the given amount, expressed in cycles.

This will skip to the fourth cycle:

do
  resetCycles
  d1 $ rotL 4 $ seqP
    [ (0, 12, sound "bd bd*2")
    , (4, 12, sound "hh*2 [sn cp] cp future*4")
    , (8, 12, sound (samples "arpy*8" (run 16)))
    ]

Useful when building and testing out longer sequences.

Shifts a pattern forward in time by the given amount, expressed in cycles. Opposite of rotL.

Splits a pattern into a list containing the given n number of patterns. Each one plays every nth cycle, successfully offset by a cycle.

Slow down a pattern by the given time pattern.

For example, the following will play the sound pattern "bd sn kurt" twice as slow (i.e., so it repeats once every two cycles), and the vowel pattern three times as slow:

d1 $ sound (slow 2 "bd sn kurt")
   # slow 3 (vowel "a e o")

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.

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? TODO - steps

merges all values in a list into one pattern by stacking the values

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?

Get the onset of an event's whole

Get the offset of an event's whole

withEvent f p returns a new Pattern with each event mapped over function f.

withEvent f p returns a new Pattern with f applied to the resulting list of events for each query function f.

withPart f p returns a new Pattern with function f applied to the part.

Apply a function to the timespan of the query

Apply a function to the control values of the query

Apply a function to the time (both start and end) of the query

Apply a function to the arcs/timespans (both whole and parts) of the result

Apply a function to the time (both start and end of the timespans of both whole and parts) of the result

withEvent f p returns a new Pattern with each value mapped over function f.

Some context for an event, currently just position within sourcecode

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.

Note is Double, but with a different parser

A datatype representing events taking place over time

an Arc and some named control values

Polymorphic values