Условные модификаторы

lastOf

Применяет заданную функцию каждые n циклов, начиная с последнего цикла.

n (number): сколько циклов
func (function): функция для применения

note("c3 d3 e3 g3").lastOf(4, x=>x.rev())

firstOf

Применяет заданную функцию каждые n циклов, начиная с первого цикла.

n (number): сколько циклов
func (function): функция для применения

note("c3 d3 e3 g3").firstOf(4, x=>x.rev())

when

Применяет заданную функцию всякий раз, когда заданный pattern находится в истинном состоянии.

binary_pat (Pattern):
func (function):

"c3 eb3 g3".when("<0 1>/2", x=>x.sub("5")).note()

chunk

Synonyms: slowChunk, slowchunk

Делит паттерн на заданное число частей, а затем по очереди перебирает эти части, применяя заданную функцию к каждой части по очереди (по одной части за цикл).

"0 1 2 3".chunk(4, x=>x.add(7))
.scale("A:minor").note()

chunkBack

Synonyms: chunkback

Как chunk, но перебирает части в обратном порядке. В tidalcycles известна как chunk'

"0 1 2 3".chunkBack(4, x=>x.add(7))
.scale("A:minor").note()

fastChunk

Synonyms: fastchunk

Как chunk, но циклы исходного паттерна не повторяются для каждого набора чанков.

"<0 8> 1 2 3 4 5 6 7"
.scale("C2:major").note()
.fastChunk(4, x => x.color('red')).slow(2)

arp

Выбирает индексы в наложенных нотах.

note("<[c,eb,g]!2 [c,f,ab] [d,f,ab]>")
.arp("0 [0,2] 1 [0,2]")

arpWith 🧪

Выбирает индексы в наложенных нотах.

note("<[c,eb,g]!2 [c,f,ab] [d,f,ab]>")
.arpWith(haps => haps[2])

struct

Применяет заданную структуру к pattern:

note("c,eb,g")
  .struct("x ~ x ~ ~ x ~ x ~ ~ ~ x ~ x ~ ~")
  .slow(2)

mask

Возвращает silence, когда mask равна 0 или "~"

note("c [eb,g] d [eb,g]").mask("<1 [0 1]>")

reset

Сбрасывает pattern к началу цикла для каждого onset pattern сброса.

s("[<bd lt> sd]*2, hh*8").reset("<x@3 x(5,8)>")

restart

Перезапускает pattern для каждого onset pattern перезапуска. В то время как reset сбросит только текущий цикл, restart начнёт с цикла 0.

s("[<bd lt> sd]*2, hh*8").restart("<x@3 x(5,8)>")

hush

Заглушает pattern.

stack(
  s("bd").hush(),
  s("hh*3")
)

invert

Synonyms: inv

Меняет местами 1 и 0 в бинарном pattern.

s("bd").struct("1 0 0 1 0 0 1 0".lastOf(4, invert))

pick

Выбирает patterns (или простые значения) либо из списка (по индексу), либо из таблицы поиска (по имени). Похож на inhabit, но сохраняет структуру исходных patterns.

pat (Pattern):
xs (*):

note("<0 1 2!2 3>".pick(["g a", "e f", "f g f g" , "g c d"]))

sound("<0 1 [2,0]>".pick(["bd sd", "cp cp", "hh hh"]))

sound("<0!2 [0,1] 1>".pick(["bd(3,8)", "sd sd"]))

s("<a!2 [a,b] b>".pick({a: "bd(3,8)", b: "sd sd"}))

pickmod

То же самое, что pick, но если вы выбираете число больше размера списка, оно зацикливается, вместо того чтобы остановиться на максимальном значении. Например, если вы выбираете пятый pattern из списка из трех, вы получите второй.

pat (Pattern):
xs (*):

pickF

pickF позволяет использовать pattern чисел для выбора функции, которую нужно применить к другому pattern.

pat (Pattern):
lookup (Pattern): pattern индексов
lookup (Array.<function()>|object): pattern индексов

s("bd [rim hh]").pickF("<0 1 2>", [rev,jux(rev),fast(2)])

note("<c2 d2>(3,8)").s("square")
.pickF("<0 2> 1", [jux(rev), fast(2), x=>x.lpf(800)])

note("<c2 d2>(3,8)").s("square")
.pickF("<jr l> f", { jr:jux(rev), f:fast(2), l:x=>x.lpf(800) })

pickmodF

То же самое, что pickF, но если вы выбираете число больше размера списка функций, оно зацикливается, вместо того чтобы остановиться на максимальном значении.

pat (Pattern):
lookup (Pattern): pattern индексов
lookup (Array.<function()>|object): pattern индексов

pickRestart

Похож на pick, но выбранный pattern перезапускается, когда активируется его индекс.

pat (Pattern):
xs (*):

pickmodRestart

То же самое, что pickRestart, но если вы выбираете число больше размера списка, оно зацикливается, вместо того чтобы остановиться на максимальном значении.

pat (Pattern):
xs (*):

"<a@2 b@2 c@2 d@2>".pickRestart({
        a: n("0 1 2 0"),
        b: n("2 3 4 ~"),
        c: n("[4 5] [4 3] 2 0"),
        d: n("0 -3 0 ~")
      }).scale("C:major").s("piano")

pickReset

Похож на pick, но выбранный pattern сбрасывается, когда активируется его индекс.

pat (Pattern):
xs (*):

pickmodReset

То же самое, что pickReset, но если вы выбираете число больше размера списка, оно зацикливается, вместо того чтобы остановиться на максимальном значении.

pat (Pattern):
xs (*):

inhabit

Synonyms: pickSqueeze

Выбирает patterns (или простые значения) либо из списка (по индексу), либо из таблицы поиска (по имени). Похож на pick, но cycle сжимаются в целевой ('обитаемый') pattern.

pat (Pattern):
xs (*):

let a = s("bd(3,8)")
let b = s("cp sd")
"<a b [a,b]>".inhabit({ a, b })

s("a@2 [a b] a"
.inhabit({a: "bd(3,8)", b: "sd sd"}))
.slow(4)

inhabitmod

Synonyms: pickmodSqueeze

То же самое, что inhabit, но если вы выбираете число больше размера списка, оно зацикливается, вместо того чтобы остановиться на максимальном значении. Например, если вы выбираете пятый pattern из списка из трех, вы получите второй.

pat (Pattern):
xs (*):

squeeze

Выбирает из списка значений (или patterns значений) по индексу, используя заданный pattern целых чисел. Выбранный pattern будет сжат, чтобы соответствовать длительности выбирающего события

pat (Pattern):
xs (*):

note(squeeze("<0@2 [1!2] 2>", ["g a", "f g f g" , "g a c d"]))

После условных модификаторов давайте посмотрим, что могут предложить Модификаторы накопления.