After watching the first video about mini notation I was experimenting a bit with n.

d1 $ n "0 1 2 3" # s "kick"

The above should be the same as using run

d1 $ n (run 4) # s "kick"

Then I tried to use irand and this is when I got lost:

d1 $ n (run (irand 4)) # s "kick"

or

I expected it to generate a random pattern. I got no errors and zero sound.

Then I try switching the patterns

d1 $ s "kick*4" # n (run 4)

The above is identical to the first and second examples.

I try to introduce irand again

d1 $ s "kick*4" # n (irand 4)

and it worked.

In the last example "kick*4" (the most left of the patterns is the one defining the rests) defines the 4 steps and n is evaluated every time with a new irand value generating a pattern of one single step.

I’m not sure I understand what’s happening in this example: d1 $ n (run (irand 4)) # s "kick".
My reasoning is:

irand 4 generates a random number between 0 and 3

run (irand 4) generated a pattern from 0 to the generated number

n (run (irand 4)) generated my control pattern.

Can anyone shed some light? what am I doing wrong?

When you combine patterns, the structure comes from the left. The problem is that irand 4 is a continuous, infinitely detailed stream of numbers, it doesn’t have any pattern. That leads to a run that is continuously changing. Currently when Tidal tries to schedule a continuously varying pattern, it gives up.

You could use segment to ‘sample and hold’ the pattern at a fixed rate, for example once per cycle:

Super interesting. So what’s happening here (the comment shows the result of just a straight eval of the pattern):

d1 $ s "kick" # n (run (irand 4))
-- plays every once in a while
s "kick" # n (run (irand 4))
-- tidal>
-- [((1,1),(5,1))](0>⅓)-1|n: 0.0f, s: "kick"
-- [((1,1),(5,1))]0-(⅓>⅔)-1|n: 1.0f, s: "kick"
-- [((1,1),(5,1))]0-(⅔>1)|n: 2.0f, s: "kick"

Is it because the pattern comes from the sound function, and then the randomness is just silencing every once in a while?

This was the result of eval’ing ohjimi*3’s pattern that was just silent:

d1
$ struct ("t*2 [t*2 ~] t(3,8) ~")
$ n (irand 6) |+ (sine * 5)
# s "[snare?0.2]"
-- # s "[dsynth?0.2]" --you can check with another sound with the same results

I've write that piece of code using "snare" sound from Extra-samples folder. If you hush the pattern you can hear a kind of reverse sound that ends few seconds later. But there's no sample like this in any of used folders. What is reversing and repitching that? How n (irand 6) |+ (sine * 5) are working here?
Thanks!!

n (irand 6) is evaluated first, then |+ (sine * 5). Tidal sees the latter as a control pattern, but there is no function to turn the pattern of numbers into a pattern of synth controls.. So it guesses that it is a speed pattern.

So this should be the same (I just inserted the speed):

d1
$ struct ("t*2 [t*2 ~] t(3,8) ~")
$ n (irand 6) |+ speed (sine * 5)
# s "[snare?0.2]"

But it isn't!! Somehow in your pattern the sine goes from -1 to 1, but in the above it goes from 0 to 1. I'm trying to work out why.. Weird..

Anyway you can fix your pattern with parenthesis, so make sure the sine gets added to the irand before being passed to n.

d1
$ struct ("t*2 [t*2 ~] t(3,8) ~")
$ n ((irand 6) |+ (sine * 5))
# s "[snare?0.2]"