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.

Constructors

Instances

an Arc and some named control values

Constructors

Some context for an event, currently just position within sourcecode

Constructors

Instances

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

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

A datatype representing events taking place over time

Constructors

Instances

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

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

Note thatrev reverses on a cycle-by-cycle basis. This means thatrev (slow 2 "1 2 3 4") would actually result in(slow 2 "2 1 4 3"). This is because theslow 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"

orjux:

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

• Patterns as numbers

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

Likeunwrap, 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?

Turns a pattern of patterns into a single pattern. (this is actuallyjoin)

1/ For queryarc, get the events from the outer patternpp 2/ Query the inner pattern using thepart 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?

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

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

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

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.

General utilities..

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

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

Polymorphic values

Constructors

Instances

Methods

gmod :: a -> a -> aSource#

Instances

Note is Double, but with a different parser

Constructors

Instances

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.

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

Apply a function to the timespan of the query

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

Apply a function to the control values of the query

withEvent f p returns a newPattern with each event mapped over functionf.

withEvent f p returns a newPattern with each value mapped over functionf.

withEvent f p returns a newPattern with f applied to the resulting list of events for each query functionf.

withPart f p returns a newPattern with functionf applied to the part.

Turns a pattern ofMaybe values into a pattern of values, dropping the events ofNothing.

Extract a pattern of integer 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 string values by from a control pattern, given the name of the control

Extract a pattern of boolean 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 note values by from a control pattern, given the name of the control

Speed up a pattern by the given time pattern.

For example, the following will play the sound pattern"bd sn kurt" twice asfast (i.e., so it repeats twice per cycle), and the vowel pattern three timesas 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 twicethe speed for the first half of each cycle and then four times the speed for thesecond 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 withfast:

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

This will givebd played in the first half cycle, andbd 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 tofast:

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

An alias forfast

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")

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

Remove events from patterns that to not meet the given test

Get the onset of an event'swhole

Get the onset of an event'swhole

Methods

deltaContext ::Int ->Int -> a -> aSource#

Instances

True if anEvent's starts is within givenArc

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

ReturnsTrue if the two given events are adjacent parts of the same whole

Get the offset of an event'swhole

Get the offset of an event'spart

Get the timespan of an event'spart

Methods

toValue :: a ->ValueSource#

Instances

collects all events satisfying the same constraint into a list

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

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