Feat: refactoring codebase

docs/tutorials/generators.md

@@ -0,0 +1,138 @@
+# Generators & Sequences
+
+Sequences of values drive music: arpeggios, parameter sweeps, rhythmic patterns. Cagire has dedicated words for building sequences on the stack, transforming them, and collapsing them to single values.
+
+## Ranges
+
+`..` pushes an integer range onto the stack. Both endpoints are inclusive. If start exceeds end, it counts down:
+
+```forth
+1 5 ..          ;; 1 2 3 4 5
+5 1 ..          ;; 5 4 3 2 1
+0 7 ..          ;; 0 1 2 3 4 5 6 7
+```
+
+`.,` adds a step parameter. Works with floats:
+
+```forth
+0 1 0.25 .,     ;; 0 0.25 0.5 0.75 1
+0 10 2 .,       ;; 0 2 4 6 8 10
+1 0 0.5 .,      ;; 1 0.5 0 (descending)
+```
+
+`geom..` builds a geometric sequence. Takes start, ratio, and count:
+
+```forth
+1 2 4 geom..    ;; 1 2 4 8
+100 0.5 4 geom..  ;; 100 50 25 12.5
+```
+
+Build a harmonic series:
+
+```forth
+110 2 5 geom.. 5 rev freq
+```
+
+That gives you 110, 220, 440, 880, 1760 (reversed), ready to feed into `freq`.
+
+## Computed Sequences
+
+`gen` executes a quotation n times and collects all results. The quotation must push exactly one value per call:
+
+```forth
+{ 1 6 rand } 4 gen       ;; 4 random values between 1 and 6
+{ coin } 8 gen            ;; 8 random 0s and 1s
+```
+
+Contrast with `times`, which executes for side effects and does not collect. `times` sets `@i` to the current index:
+
+```forth
+4 { @i } times            ;; 0 1 2 3 (pushes @i each iteration)
+4 { @i 60 + note sine s . } times   ;; plays 4 notes, collects nothing
+```
+
+The distinction: `gen` is for building data. `times` is for doing things.
+
+## Euclidean Patterns
+
+`euclid` distributes k hits evenly across n positions and pushes the hit indices:
+
+```forth
+3 8 euclid      ;; 0 3 5
+4 8 euclid      ;; 0 2 4 6
+5 8 euclid      ;; 0 1 3 5 6
+```
+
+`euclidrot` adds a rotation parameter that shifts the pattern:
+
+```forth
+3 8 0 euclidrot   ;; 0 3 5 (no rotation)
+3 8 1 euclidrot   ;; 1 4 6
+3 8 2 euclidrot   ;; 1 4 6
+```
+
+These give you raw indices as data on the stack. This is different from `bjork` and `pbjork` (covered in the Randomness tutorial), which execute a quotation on matching steps. `euclid` gives you numbers to work with; `bjork` triggers actions.
+
+## Transforming Sequences
+
+Four words reshape values already on the stack. All take n (the count of items to operate on) from the top:
+
+`rev` reverses order:
+
+```forth
+1 2 3 4 4 rev     ;; 4 3 2 1
+c4 e4 g4 3 rev    ;; g4 e4 c4 (descending arpeggio)
+```
+
+`shuffle` randomizes order:
+
+```forth
+c4 e4 g4 b4 4 shuffle   ;; random permutation each time
+```
+
+`sort` and `rsort` for ascending and descending:
+
+```forth
+3 1 4 1 5 5 sort    ;; 1 1 3 4 5
+3 1 4 1 5 5 rsort   ;; 5 4 3 1 1
+```
+
+## Reducing Sequences
+
+`sum` and `prod` collapse n values into one:
+
+```forth
+1 2 3 4 4 sum      ;; 10
+1 2 3 4 4 prod     ;; 24
+```
+
+Useful for computing averages or accumulating values:
+
+```forth
+{ 1 6 rand } 4 gen 4 sum   ;; sum of 4 dice rolls
+```
+
+## Replication
+
+`dupn` (alias `!`) duplicates a value n times:
+
+```forth
+440 3 dupn        ;; 440 440 440
+c4 4 dupn         ;; c4 c4 c4 c4
+```
+
+Build a drone chord -- same note, different octaves:
+
+```forth
+c3 note 0.5 gain sine s .
+c3 note 12 + 0.5 gain sine s .
+c3 note 24 + 0.3 gain sine s .
+```
+
+Or replicate a value for batch processing:
+
+```forth
+0.5 4 dupn 4 sum   ;; 2.0
+```
+
+The generator words produce raw material. The transform words shape it. Together they let you express complex musical ideas in a few words.