tur/pattern

(pat-at [p time])

evaluate a pattern at a specific time.

Pattern value at the given time.

  (pat-at (const 5) 2.3)  ; => 5

(pat-start [p])

evaluate a pattern at time 0.

Pattern value at time 0.

  (pat-start (cycle 10 20 30))  ; => 10

(const [value])

constant pattern that always returns the same value.

Pattern<T> that always returns value.

  (const 0.5)

(silence)

pattern that always returns none (for option types).

(cycle [& values])

cycle through values one per beat.

Pattern<T> advancing to the next value each beat.

  ((cycle 1 2 3) 0.0)  ; => 1
  ((cycle 1 2 3) 1.0)  ; => 2

(fast-cycle [rate & values])

cycle through values at a faster rate.

Pattern<T> cycling rate times faster than cycle.

  ((fast-cycle 2 1 2 3) 0.5)  ; evaluates as if time=1.0

(phase [& [cycle_length 1.0])

return the fractional phase within a cycle.

NumPattern returning phase in [0, cycle_length).

  ((phase 2.0) 1.5)  ; => 1.5

(P [& exprs])

macro shorthand: (P x) => (const x), (P x y ...) => (cycle x y ...).

(P 1 2 3)  ; same as (cycle 1 2 3)
  (P 5)      ; same as (const 5)

(rand-choice [& values])

randomly pick a value from the supplied list on each evaluation.

Pattern<T> returning a random element each time it is evaluated.

  ((rand-choice 1 2 3) 0.0)  ; => 1, 2, or 3 at random

(rand-int [min max])

pattern returning a random integer in [min, max) each evaluation.

(rand-float)

pattern returning a random float in [0, 1) each evaluation.

(rand-range [min max])

pattern returning a random float in [min, max) each evaluation.

(identity)

pattern that returns its time argument unchanged.

(time-pat)

pattern returning the current time value.

(beat-number)

pattern returning the integer beat number.

NumPattern returning floor(time).

  ((beat-number) 2.7)  ; => 2.0

(beat-fraction)

pattern returning the fractional part of the current beat.

NumPattern returning time - floor(time).

  ((beat-fraction) 2.7)  ; => 0.7

(alt [a b])

alternate between two values on even/odd beats.

Pattern<T> alternating between a and b.

  ((alt 1 2) 0.0)  ; => 1
  ((alt 1 2) 1.0)  ; => 2

(if-pat [condition a b])

choose between two values based on a boolean pattern.

(every-n [n])

true when the beat number is a multiple of n.

BoolPattern that is true when floor(time) mod n == 0.

  ((every-n 4) 4.0)  ; => true

(when-mod [n & [offset 0])

true when beat number mod n equals a given offset.

(when [cond p & [zero 0])

gate a pattern through a boolean condition.

Pattern<T>.

  (when (every-n 2) (const 1) 0)

(every [n p & [zero 0])

play a pattern only every n beats.

Pattern<T>.

  (every 4 my-pat)

(pattern-length [p])

attempt to determine the cycle length of a pattern.

(pattern-constant? [p])

check whether a pattern is constant.

(defstruct PatternWithMeta<T> [])

pattern bundled with introspection metadata.

(with-meta [pattern & [name "" description "" tags [])

attach metadata to a pattern.

(pattern-of [p])

extract the underlying pattern from a PatternWithMeta value.