-- region Lesson 1: exploring the ‘every’ function, including tackling the meaning of ‘$’
-- every

-- 'every' is one of a family of Tidal functions, that takes another
-- function as one of its inputs.

-- Let's say we had a simple pattern like this:
d1 $ sound "bd sd ~ cp"

-- ... and we wanted to speed it up like this:
d1 $ fast 2 $ sound "bd sd ~ cp"

-- ... but only one cycle out of three.

-- Here's how we'd use 'every' to do that:
d1 $ every 3 (fast 2) $ sound "bd sd ~ cp"

-- You can read this as "every 3rd cycle, make 'sound "bd sd ~ cp"',
-- go faster by a factor of two."

-- We'll take this apart to work out why we sometimes use (), and
-- sometimes '$' later. First, lets look at more, practical examples
-- of using 'every'.

-- We can use every with any function that takes single pattern as
-- input (and returns a transformed version as output). For example,
-- we can use 'hurry' instead of fast:
d1 $ every 3 (hurry 2) $ sound "bd sd [~ bd] [cp bd*2]"

-- Or use 'rev':
d1 $ every 3 (rev) $ sound "bd sd [~ bd] [cp bd*2]"

-- Because 'rev' is a single word, we don't actually need to put it in
-- parenthesis:
d1 $ every 3 rev $ sound "bd sd [~ bd] [cp bd*2]"

-- Here's a trick with using effects as functions..
-- Lets look at this:
d1 $ sound "bd sd [~ bd] [cp bd*2]"
   # squiz "5"

-- We can treat the '# speed 5' bit as a function. If you think about
-- it, it does something to a pattern, just like 'fast 2' does.

-- So.. does this work?
d1 $ every 3 (# squiz 5) $ sound "bd sd [~ bd] [cp bd*2]"

-- Yes it does!

-- You can also add more than one 'every' manipulation, giving them
-- different periods for their first input, to create longer form
-- variety:
d1 $ every 3 (# squiz 5) $ sound "bd sd [~ bd] [cp bd*2]"

d1 $ every 2 (hurry 2) $ every 3 (# squiz 5) $ sound "bd sd [~ bd] [cp bd*2]"

-- keep going..
d1 $ every 4 rev $ every 2 (hurry 2) $ every 3 (# squiz 5)
   $ sound "bd sd [~ bd] [cp bd*2]"

-- In Tidal, the pattern that a function is manipulating is generally
-- its final input, which makes it easy to 'chain together' functions
-- like this.

-- Ok as promised, lets go back to our original, simple example:
d1 $ every 3 (fast 2) $ sound "bd sd ~ cp"

-- Lets go through the three 'inputs' (also sometimes called
-- 'parameters' or 'arguments') for every.

-- [a] 3 - how often a function is applied
-- [b] fast 2 - the function that is applied
-- [c] sound "bd sd ~ cp" - the pattern that it's applied to.

-- Looking again at this pattern, you can see that the inputs are
-- given in three different ways:
d1 $ every 3 (fast 2) $ sound "bd sd ~ cp"

-- '3' is just on its own. It's a single number so tidal has no
-- problem knowing it's a single input.

-- 'fast 2' is in parenthesis '(fast 2)'. Then the word 'fast' and
-- number '2' are grouped together into a function, _before_ being
-- passed to 'every' as its second input.

-- 'sound "bd sd ~ cp"' has $ in front. We *could* have done this
-- instead:
d1 $ every 3 (fast 2) (sound "bd sd ~ cp")

-- That works fine, but '$' does the same kind of job. It passes
-- what's on its left, to the function on its right, as a single
-- parameter. '$' has really low priority, which means everything on
-- its right is worked out first before being passed to the left.
d1 $ every 3 (fast 2) $ sound "bd sd ~ cp"

-- This saves you from having to match up ( and ) around a function's
-- final input. It doesn't work with anything other than the final
-- input, so unfortunately this _doesn't_ work

d1 $ every 3 $ fast 2 $ sound "bd sd ~ cp"

-- The above would work out 'fast 2 $ sound "bd sd ~ cp"' first, and
-- would then try to pass that to 'every' as its second parameter,
-- which doesn't make sense to tidal, so it returns an error.

-- Note that when Tidal makes an error, if there was already a
-- pattern running, it will keep that going. If you're live coding
-- in front of an audience, you probably don't want an error to
-- result in silence!

-- endregion


-- region Lesson 2: cut vs legato

d1 $ jux rev $ speed "<1 0.5 0.75>(<3 5>,8)" # sound "bev" # cut 1
  # room 0.4 # sz 0.9 # gain 1.3

d2 $ jux rev $ sound "sax(3,8)" # legato 1 # n 3
  # note "<[9 7] 5 [9 12]>" # djf 0.7 # sz 0.4 # room 0.4

-- endregion

-- region Lesson 3: slice and splice to for perfect spice
setcps 0.6

-- Hear it straight
d1 $ splice 8 "0 1 2 3 4 5 6 7" $ sound "break:4"

-- Now with a more messed-up pattern
d1 $ splice 8 "6 1 [2 3] ~ 4 1 6*2 7" $ sound "break:4"

-- Try changing the cps to hear it at different speeds

-- Try manipulating the pattern of slices
d1 $ splice 8 (fast "1 [0.5 0.75]" "6 1 [2 3] ~ 4 1 6*2 7")
   $ sound "break:4"

-- Now try all the above with 'slice' instead of 'splice'.
-- Slice _doesn't_ do the pitching up/down thing to splice the
-- sound to the step.

-- Here I put six slices from a loop originally in 4/4, to create
-- a 3/4 waltz
d1 $ splice 8 ("0 1 2 3 4 5") $ sound "break:4" # gain 1.1
d2 $ sound "kick snare*2 clap:4" # speed 2

-- endregion

-- region Lesson 4: chop and striate

-- Let's take a nice break:
once $ sound "break:8"

-- We can use 'begin' and 'end' to only play part of the sound, in this
-- case the final quarter of it:
d1 $ sound "break:8*4" # begin 0.75 # end 1

-- We can also use 'unit "c"' to change the behaviour of 'speed' so it
-- changes the playback speed to match the cps
d1 $ sound "break:8" # speed 1 # unit "c" # begin 0.75 #
end 1

-- Lets play four of those to fill the cycle
d1 $ sound "break:8*4" # speed 1 # unit "c" # begin 0.75 # end 1

-- Then play with the cps to hear it change, fitting the cps perfectly
setcps 0.8

-- Normally, I wouldn't use 'unit', 'begin' and 'end' by hand. Instead
-- I'd use splice / slice from the previous lesson, or 'chop' to cut
-- a sound into bits, and set the length of the loop in cycles with
-- 'loopAt'
d1 $ loopAt 2 $ chop 4 $ sound "break:8"

-- The above sounds pretty continuous, but it is chopped into four parts.
-- We can hear that by reversing the chopped up parts:
d1 $ loopAt 2 $ rev $ chop 1 $ sound "break:8"

-- If we slow the pattern we can hear each part separately:
d1 $ slow 2 $ loopAt 2 $ chop 4 $ sound "break:8"

-- Here's a different sample:
d1 $ slow 2 $ loopAt 2 $ chop 4 $ sound "break:9"

-- Now what happens if we put both breaks in the sequence?
d1 $ slow 2 $ loopAt 2 $ chop 4 $ sound "break:8 break:9"

-- With 'chop', it will play all the parts of break:8, followed by
-- all the parts of 'break:9'.

-- If we swap 'chop' for its friend 'striate', then parts from the
-- two breaks are instead interlaced:
d1 $ slow 2 $ loopAt 2 $ striate 32 $ sound "break:8 break:9"

-- Play with that striate value for fun:
d1 $ slow 2 $ loopAt 2 $ striate 32 $ sound "break:8 break:9"

-- If you use the *same* loop multiple times with striate, it kind
-- of stretches it:
d1 $ slow 4 $ loopAt 1 $ striate 4 $ sound "break:1*4"

-- Here's what that normally sounds like:
once $ sound "break:1"

-- 'bev' is an even longer sample..
d1 $ loopAt 16 $ striate 32 $ sound "bev"

d1 $ slow 4 $ jux rev $ loopAt 16 $ striate 128 $ sound "bev*4"

-- Club: striate fun by @vin
d2
  $ every (irand 3) (degradeBy rand)
  $ slow ((irand 4)+1)
  $ loopAt ((irand 5) +1)
  $ striate (irand 64)
  -- $ slice 16 "0 1 5 4 8 6 1 0"
  $ s "break:10"
    # room 0.5
    # cut 1
    # att rand
    # hold rand
    # rel rand

-- endregion

-- TODO:

-- HIHATS! ho hc
-- (Cut though)

-- Speed with unit 'c' to make things fit, whatever the cps

-- Other students
-- 'sort of wavetable synthesis'
d1
-- $ slice 8 (slow 1 "0*8 1 2 3 4 5 6 7")
$ slice 8 (slow 1 "0*5 1*7 [2*4 3*8] ~ 4*7 1*16 6*8 7*37")
$ s "break:4"
# gain 0.9


-- region Etude w3:
setcps 0.6

d1 $ loopAt 1 $ s "breaks125" # gain 0.
d1 $ loopAt 1 $ s "breaks125" # gain 0.5

d1 $ splice 8 "<0!8 2!8> 1 <2!8 0!8> 3 4 <5!3 7> <6!7 7> 7"
$ sound "break:4"
# gain 0.7

d2 $ slice 8 "[5(3,8),6*3]" $ s "bev" # gain 0.8


d1 $ loopAt 1 $ rev $ chop 4 $ sound "break:8"

d1
$ slow 2 $ loopAt 2
$ every' 2 1 (chop 4)
$ every' 2 0 (striate 4)
$ sound "break:8 break:9"
# gain 0.6

d1
$ slow 2 $ loopAt 2
$ striate 4
$ n "8 9" # s "break"
# gain 0.8

-- begaye
d1
$ loopAt 19
$ striate 64 $ sound "bogdan:14*4"
# cut 7 # gain 0.9

once $ s "bogdan:14" # cut 7 # gain 0.8

-- Idees:
do
  solo 1
  solo 2
  solo 3
  solo 4
  solo 5
  solo 6
  solo 7



-- Le crapeau russe
do
  setcps (120/60/4)
  d1 -- Kick techno regulier variations filtre
    $ whenmod 32 24 (<| n "0*2")
    $ whenmod 32 16 (<| n "0")
    $ s "k(<4!3 [4 8 8 4!3]>,4)" # s "jazz"
    # lpf (slow 64 $ range 40 400 sine)
    # gain 0.8
  d3 -- Les snares bogdanesques
    $ fast 4
    $ "~ <h!3 h*2>"
    # s "bogdan:1"
    # cut 3 # gain 0.8
  d4 -- begaye!
    $ someCyclesBy 0.8
     (# gain 0)
    $ rarely (# lpf 3000)
    $ often (# hpf 1500)
    $ loopAt 19
    $ striate "64 <64!3 [64 128]>"
    $ sound "bogdan:14*4"
    # cut 4
    # room 0.4
    # size 0.5
    # gain 0.7
  d5 -- Electric Bassline TODO Variations
    $ note (scale "aeolian" (
      "0 1 0 1 0 1 2 3"
      )
      - 24
    )
    # s "supersquare" # voice 0.1 # gain 0.5
  d6 -- Le crapeau!
    $ someCyclesBy 0.1 (# gain 0.6)
    $ loopAt 0.5 $ striate 4 $ sound "bogdan:2"
    # cut 7 # gain 0
    # pan rand
  d7
    $ slow 2 $ loopAt 2
    $ striate (slow 8 "<8 4 2 1>")
    $ s "break:9"
    # gain 0.4


-- TECHNO_TAMBOURINO
do
  d1
    $ slow 2 $ loopAt 2
    $ striate 8
    $ n "[8(1,8,5),9*4]"  -- 8 9, 8-fun 9, 9*4, etc
    # s "break"
    # gain 0.8
  d2 $ s "jazz" # gain 0.8
  d3 $ s "dr*[8 16]" # gain 0.7

-- Variably-sized chops invertion
d1
$ loopAt 1
$ every' 4 3 rev
$ chop (slow 4 $ "<1 2 4 8>")
$ sound "break:8"
# gain 0.8


do
  d1 -- Valse!
    $ slice 8 "[<0!4 3!4> 1 <2!3 5>]*2"
    $ s "breaks125" # gain 0.8
  d2
    $ fast "<8 6> <12!3 24>" $ s "drum:8"
    # gain 0.8
  d3
    $ superimpose ( -- cloches
      (sometimesBy ("<0.1 0.25 0.5 0.75>") (fast 2)) .
      (jux rev) . (# s "superfork")
      . (|+ note 12) . (|+ gain 0.2)
    )
    $ fast 3
    $ note (
      "<5 3 5 [0 1 2 3] 5 3 [6 5] ~>"
    - 24)
    # s "supersaw" # voice 0.1
    # gain 0.4

-- endregion
