Tidal's biggest limitation

The thing that I think could push tidalcycles forward is more abstract pattern parsing.

I’ve found that my biggest limitation working with tidal is how there’s no way to nest patterns.
For example, if I have two distinct rhythms, let’s say "t*2 [~ t t]" and "[t t*2 t] [t ~ t], I might want to combine them for a brief drum fill, making "t*2 [~ t t] [t t*2 t] [t ~ t]. This seems like a pretty simple task, but there’s no clear way accomplish this apart from just combining the strings
"t*2 [~ t t]" ++ "[t t*2 t] [t ~ t]" which quickly gets messy with larger and longer patterns.

If there were a function where you could give names to patterns
pt :: Pattern_Name -> Pattern -> Pattern_Shorthand"
pt "ex" = "t*2 [~ t t]"
pt "ex2" = "[t t*2 t] [t ~ t]"
it would make composing so so so so much easier
"t*ex t*ex2"

You could also rapidly compose new patterns by combining two shorthands, ie.
"ex*ex2" = "[[t t*2 t] [t ~ t]]*2 [~ [t t*2 t] [t ~ t] [t t*2 t] [t ~ t]]"
which would be great for improvising creating motifs of rhythms throughout a song as a whole
(like if you had a 90 cycle long pattern with a bunch of repeating elements).

Currently, the only way to even get close to this is by using ur and creating an effect that uses struct to change a pattern, which is incredibly cumbersome, not to mention capable of only one level of abstraction (you can’t combine more than one effect, hence no nested patterns).

This isn’t really a limitation of Tidal, but of the sequence parser, which is like a little language within Tidal. You can’t just drop expressions into the parser, because it’s a separate language. Tidal and the sequence parser could be brought closer in the future, with something called ‘template haskell’, so you could just say foo = [pat|bd sn] and then bar = [pat|cp ${foo}*2 cp cp ${foo}], or something like that. Not working yet, though.

But have you looked at e.g. squeeze? You give it a list of patterns, and then compose them together with a pattern of numbers that index into that list:

squeeze "0 1*2 0" ["t*2 [~ t t]", "[t t*2 t] [t ~ t]"]

That squeeze function is interesting. you could compose some pattern sequences with it:

let eu =
                [euclid "<3>" "<7>" $ n "8" # "808"
                ,euclid "<5>" "<10>" $ n "250" # "808"
d1 $ slow 4 $ squeeze "0!3 [0,1]" eu

Just a short example, but what I would like to do with it is gradually mix some tracks/patterns together, without changing the pulse speed. I tried using <[]> or {}%1 in combination with ! but there seems to be a parser issue doing that. Works with slow if you can calculate it right. The other option is to write it out, but that’s not really practical for the duration of a song. This could help sequence longer, structured compositions.

1 Like