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

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

Divides a pattern into a given number of parts, then cycles through those parts in turn, applying the given function to each part in turn (one part per cycle).

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

chunkBack

Synonyms: chunkback

Like chunk, but cycles through the parts in reverse order. Known as chunk' in tidalcycles

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

fastChunk

Synonyms: fastchunk

Like chunk, but the cycles of the source pattern aren't repeated for each set of chunks.

"<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 индексов
funcs (Array.<function()>): массив функций, из которых нужно выбирать

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

pickmodF

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

pat (Pattern):
lookup (Pattern): pattern индексов
funcs (Array.<function()>): массив функций, из которых нужно выбирать

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 (*):

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

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

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