A Pattern is a finite or infinite stream of values of a certain type.

There are four different types in the pattern language, real numbers (Scalar), boolean values (Boolean), two dimensional coordinates (Coord) and synthesis events (Event).

The pattern functions in this module can be used to combine patterns in various ways in order to build more complex expressions.

For the Scalar pattern type, many unary functions (UnaryFunc) and binary functions (BinaryFunc) are mapped to standard Haskell type classes. This allows to use more descriptive function names and binary operators, in particular the ones from the Num, Fractional and Floating type classes.

Construct an abstract syntax tree from an event pattern.

This is the main entry point, a patch will always look like this:

 it = patch (<expressions>)

Scalar expression.

Scalars represent streams of real numbers.

Construct an infinite constant value scalar pattern.

Map a unary function to a scalar.

Combine two scalars with a binary function.

Return the smaller of the arguments.

min a b

Return the bigger of the arguments.

max a b

Truncate scalar towards -Infinity.

Round scalar to the closest integer.

Return the next integer bigger than a scalar.

Truncate scalar towards zero.

Constrain a scalar to the interval [min,max].

clip min max x

Wrap a scalar into the interval [min,max].

wrap min max x

Fold a scalar into the interval [min,max].

fold min max x

Generate white noise in a given range.

rand min max

• min Minimum value.
• max Maximum value.

Generate integer random value in [min,max[.

randi min max

• min Minimum value (inclusive).
• max Maximum value (exclusive).

Generate exponential noise in a given range.

exprand min max

• min Minimum value.
• max Maximum value.

Generate gaussian noise with the given mean and variance.

gaussian mean var

• mean Mean value.
• var Variance, or standard deviation squared.

Generate brown noise in a given range with a given step size.

brown limmit stepMin stepMax min max

• limit Interval boundary behavior.
• stepMin Minimum step size.
• stepMax Maximum step size.
• min Minimum value.
• max Maximum value.

Boolean expression.

Return True if a equals b.

a |==| b

Return True if a is greater than b.

a |>| b

Return True if a is greater than or equal to b.

a |>=| b

Return True if a is smaller than b.

a |<| b

Return True if a is smaller than or equal to b.

a |<=| b

Coordinate expression.

Construct a coordinate pattern from a pair of scalar patterns, one for each axis.

coord 0.5 (rand 0.4 0.6)

Construct a coordinate pattern from a center coordinate, a radius and an angle in radians.

polar (coord 0.5 0.5) 0.5 (pi/2)

Retrieve the x value from a coordinate.

Retrieve the y value from a coordinate.

Return the center of the specified feature space region.

Return the radius of the specified feature space region.

Event expression.

Events can be thought of as notes controlling the synthesizer. They are either silent, or rests, or carry parameter that affect the synthesis and the sequencer.

They carry the time to the next event in the stream in the Delta field.

Return a rest of the specified duration.

Select the unit closest to a given coordinate.

closest cursor defaultDelta radius coord

• cursor Cursor id for the generated event.
• defaultDelta Default delta time in case no unit is found.
• radius Radius to restrict the search; if the found unit is outside the given radius around the coordinate, a rest is generated.
• coord Coordinate for nearest neighbor search.

Select a unit from a region according to the iterator.

region cursor defaultDelta iterator

• cursor Cursor and region id for this event.
• defaultDelta Default delta time in case the region is empty.
• iterator Scalar pattern in the range [0;1[ that selects a unit from the region.

Represents the various fields in a synthesis event.

Note that some fields can be queried but not modified (Cursor, CursorValue and Feature).

Return the value of an event field.

get Duration e

Set the value of an event field

set Duration 0.1 e

Spectral feature at index 0 or 1.

Power feature in dB.

Fundamental frequency feature in Hz.

Map a unary function to a field.

Combine a scalar with a field value.

Combine a field value with a scalar.

Add a scalar to a field value.

Multiply a field value by a scalar.

Filter an event stream with the given boolean pattern.

Events for which the predicate returns True are replaced by rests.

bind (<event expression>) (\e -> filter (get Duration e |>| 0.5) e)

Filter out events that don't have the cursor set.

stepPlayer rowInc colInc pattern

• rowInc Cursor row increment.
• colInc Cursor column increment.
• pattern The pattern to filter.

Given a tick increment in seconds filter the event pattern argument so that only cursor values greater than zero produce events.

sequencer tick pattern

• tick Tick increment in seconds.
• pattern The pattern to filter.

Set envelope attack and release time.

envelope attackTime releaseTime e

Repeat a pattern indefinitely.

Constant signal. constant, c :: Double -> Pattern Scalar constant = cycle . value c = constant

Repeat a pattern n times.

repeat n p

Repeat a pattern n times.

This is the same as replicate with the arguments flipped in order to allow infix application:

p `times` 4

Take the first n values of a pattern.

If the pattern is shorter, a smaller number of values is returned.

Take the n initial values of a pattern repeated infinitely.

This is the same as take with the arguments flipped in order to allow infix application:

p `only` 4

Take the n initial values of a pattern repeated infinitely.

restrict n p = cycle (take n p)

Take the n initial values of a pattern repeated infinitely.

This is the same as restrict with the arguments flipped in order to allow infix application:

p `gimme` 4

Take the first value of a pattern.

Take the first value of a pattern.

Short for once.

Limit an event pattern to the first n seconds.

takeDur 2.125 e

Combine a list of event patterns by merging their event streams.

Enumerate a list of patterns sequentially, n times.

seq n ps

• n Number of repeats.
• ps List of patterns.

Enumerate a list of patterns sequentially, n times.

Similar to seq but applies once to each of the patterns, so that sequences of scalars can be written more conveniently:

seq1 (once 4) [0.5, 0.6, 0.8, 1.3]

Enumerate a list of patterns sequentially, returning n items.

ser n ps

• n Number of items to return.
• ps List of patterns.

Enumerate a list of patterns sequentially, returning n items.

Similar to ser but applies once to each of the patterns, so that sequences of scalars can be written more conveniently:

ser1 (once 7) [0.5, 0.6, 0.8, 1.3]

Returns one item from the list at random for each repeat.

choose n ps

• n Number of repeats.
• ps List of patterns.

Returns one item from the list at random for each repeat.

Similar to choose but applies once to each of the patterns, so that sequences of scalars can be written more conveniently:

choose1 (once 7) [seq1 (once 1) [0 1], 0.6, 0.8, 1.3]

Returns one item from the list at random for each repeat.

Similar to choose but doesn't return the same item twice in a row.

Returns one item from the list at random for each repeat.

Similar to chooseNew but but applies once to each of the patterns.

Bind the current value of a pattern to a function argument.

This function is needed to express value sharing (as opposed to expression sharing) in the pattern language.

bind (<event pattern expression>) (\e -> set Delta (get Duration e) e)

Interval boundary behavior.

Print the current value of the argument pattern to the console.