Examples for cycles/pcycles

[emenel]

I've been playing with pcycles using the drum-tab notation from the included examples, but I'm curious if there is more documentation/examples for the cycles mini-language showing how to use sub-division lists or other features of the TidalCycles-like pattern language. Does it do more than the ---o--- style syntax? (which is already very very useful).

Thanks!

[defaultxr]

Thanks for the question! Looking at it now, I'm realizing I should probably improve pcycles' docstring to make its functionality more clear; the current one is pretty sparse.

To sub-divide a "step" of pcycles, you'll want to be sure you're using a list rather than a string. So for example:

Flat list of 6 elements. Yields 6 events, each 1/6 dur as expected:

> (next-upto-n (pcycles '(1 - - 2 - -) :repeats 1))
((EVENT :VALUE 1 :DUR 1/6)
 (EVENT :TYPE :REST :DUR 1/6)
 (EVENT :TYPE :REST :DUR 1/6)
 (EVENT :VALUE 2 :DUR 1/6)
 (EVENT :TYPE :REST :DUR 1/6)
 (EVENT :TYPE :REST :DUR 1/6))

List of 4 elements, whose last element is a 3-element sub-list. Also yields 6 events, but the first 3 fit in 3/4 dur, while the last 3 fit in 1/4 dur:

> (next-upto-n (pcycles '(1 - - (2 - -)) :repeats 1))
((EVENT :VALUE 1 :DUR 1/4)
 (EVENT :TYPE :REST :DUR 1/4)
 (EVENT :TYPE :REST :DUR 1/4)
 (EVENT :VALUE 2 :DUR 1/12)
 (EVENT :TYPE :REST :DUR 1/12)
 (EVENT :TYPE :REST :DUR 1/12))

Besides dividing the dur of sub-lists like this, it doesn't support any other TidalCycles features yet. Looks like I started working on the * and / notation that TidalCycles supports, but they aren't fully implemented yet, so doing (1 - -)*3 will result in a list of 4 elements, rather than 3 elements with their durs adjusted. I intend to revisit pcycles in the future and steal implement more from TidalCycles.

---

For now, pcycles does support a few other convenient features, which you may have already discovered by the &key arguments in the function signature:

• map - plist specifying values that should be replaced with other values:

> (next-upto-n (pcycles '(foo 1 (2 3)) :repeats 1 :map (list 'foo (event :value 9))))
((EVENT :VALUE 9 :DUR 1/3) ; 'foo has been replaced with (event :value 9)
 (EVENT :VALUE 1 :DUR 1/3)
 (EVENT :VALUE 2 :DUR 1/6)
 (EVENT :VALUE 3 :DUR 1/6))

• key - the key that the values in the list should be set to in the output rather than the default :value. This makes it easier to :embed the pcycles into a pbind or similar:

> (next-upto-n (pbind :amp 1/4
                      :embed (pcycles '(62 - (64 65)) :repeats 1 :key :midinote)))
((EVENT :AMP 1/4 :MIDINOTE 62 :DUR 1/3) ; :amp is set to 1/4 as per the pbind, but the pcycles yields :midinote values rather than :value
 (EVENT :AMP 1/4 :TYPE :REST :DUR 1/3)
 (EVENT :AMP 1/4 :MIDINOTE 64 :DUR 1/6)
 (EVENT :AMP 1/4 :MIDINOTE 65 :DUR 1/6))

• dur - set the overall length of one "cycle" of pcycles' output:

> (next-upto-n (pcycles '(62 - 64 65) :repeats 1 :dur 4))
((EVENT :VALUE 62 :DUR 1) ; :dur is 1 rather than 1/4, thus one "cycle" is 4 beats long rather than the default of 1 beat long
 (EVENT :TYPE :REST :DUR 1)
 (EVENT :VALUE 64 :DUR 1)
 (EVENT :VALUE 65 :DUR 1))

• repeats - set the number of times that pcycles will loop through the list before ending:

> (next-upto-n (pcycles '(62 -) :repeats 2)) ; 2 items in the input list * 2 repeats of the input list = 4 total events before pcycles ends.
((EVENT :VALUE 62 :DUR 1/2)
 (EVENT :TYPE :REST :DUR 1/2)
 (EVENT :VALUE 62 :DUR 1/2)
 (EVENT :TYPE :REST :DUR 1/2))

[emenel]

This is fantastic, thank you!