1 files changed, 48 insertions, 37 deletions
diff --git a/src/unheard/strudel/mini_notation_compiler.clj b/src/unheard/strudel/mini_notation_compiler.clj
index f3f597e..9e7b5cb 100644
--- a/src/unheard/strudel/mini_notation_compiler.clj
+++ b/src/unheard/strudel/mini_notation_compiler.clj
@@ -55,12 +55,13 @@
 (declare parse-sequence)
 (declare parse-element)
 
-(defn- parse-atom [s]
-  "Parse a single atom (note, number, or rest)."
+(defn- parse-atom [s get-value]
+  "Parse a single atom (note, number, or rest).
+  Uses get-value function to convert note names to values."
   (cond
     (= s "~") :r
     (re-matches #"\d+(/\d+)?" s) (parse-number s)
-    :else (keyword s)))
+    :else (get-value s)))
 
 (defn- apply-modifiers [expr modifiers]
   "Apply modifiers to an expression.
@@ -124,7 +125,7 @@
           :else
           (recur (rest chars) groups (conj current c) depth))))))
 
-(defn- parse-group [s open-char close-char combinator]
+(defn- parse-group [s open-char close-char combinator get-value]
   "Parse a bracketed group with a specific combinator."
   ;; Find the matching closing bracket, then extract modifiers after it
   (let [close-idx (.lastIndexOf s (int close-char))
@@ -138,20 +139,21 @@
         ;; Special handling for angle brackets with commas (polymeter)
         result (if (and (= combinator 'f) (str/includes? inner-content ","))
                  ;; Split on commas and parse each group
+                 ;; Create parallel composition of forked groups
                  (let [groups (split-on-comma inner-content)
-                       parsed-groups (map parse-sequence groups)
-                       ;; Zip groups together element-by-element and wrap in parallel
-                       max-length (apply max (map count parsed-groups))
-                       zipped (for [i (range max-length)]
-                                (let [elements (keep #(nth (vec %) i nil) parsed-groups)]
-                                  (if (= 1 (count elements))
-                                    (first elements)
-                                    (cons 'p elements))))]
-                   (if (= 1 (count zipped))
-                     (first zipped)
-                     (cons 'f zipped)))
+                       parsed-groups (map #(parse-sequence % get-value) groups)
+                       ;; Wrap each group in fork (unless single element)
+                       forked-groups (map (fn [group]
+                                           (let [elements (vec group)]
+                                             (if (= 1 (count elements))
+                                               (first elements)
+                                               (cons 'f elements))))
+                                         parsed-groups)]
+                   (if (= 1 (count forked-groups))
+                     (first forked-groups)
+                     (cons 'p forked-groups)))
                  ;; Normal handling without commas
-                 (let [elements (parse-sequence inner-content)]
+                 (let [elements (parse-sequence inner-content get-value)]
                    (if (= 1 (count elements))
                      (first elements)
                      (cons combinator elements))))]
@@ -185,44 +187,52 @@
           :else
           (recur (rest chars) tokens (conj current c) depth))))))
 
-(defn- parse-parallel [token]
+(defn- parse-parallel [token get-value]
   "Parse comma-separated elements into parallel structure."
   (if (str/includes? token ",")
     (let [parts (str/split token #",")
-          elements (map parse-element parts)]
+          elements (map #(parse-element % get-value) parts)]
       (cons 'p elements))
-    (parse-element token)))
+    (parse-element token get-value)))
 
-(defn- parse-element [token]
+(defn- parse-element [token get-value]
   "Parse a single element (may be atom, group, or have modifiers)."
   (cond
     ;; Square brackets - subdivision (l)
     ;; Check if starts with [ (may have modifiers at end)
     (str/starts-with? token "[")
-    (parse-group token \[ \] 'l)
+    (parse-group token \[ \] 'l get-value)
 
     ;; Angle brackets - alternation (f)
     ;; Check if starts with < (may have modifiers at end)
     (str/starts-with? token "<")
-    (parse-group token \< \> 'f)
+    (parse-group token \< \> 'f get-value)
 
     ;; Contains comma - parallel (p)
     (str/includes? token ",")
-    (parse-parallel token)
+    (parse-parallel token get-value)
 
     ;; Token with modifiers
     :else
     (let [[base modifiers] (parse-token-with-modifiers token)]
-      (apply-modifiers (parse-atom base) modifiers))))
+      (apply-modifiers (parse-atom base get-value) modifiers))))
 
-(defn- parse-sequence [s]
+(defn- parse-sequence [s get-value]
   "Parse a space-separated sequence."
   (let [tokens (tokenize s)]
-    (map parse-element tokens)))
+    (map #(parse-element % get-value) tokens)))
 
 (defn compile
   "Compile a Strudel mini-notation string to unheard.cycles code.
 
+  Takes a string in Strudel mini-notation and a function to convert
+  note names to values.
+
+  Arguments:
+    s - The mini-notation string to compile
+    get-value - Function of one argument that converts note names to values
+                (defaults to keyword)
+
   Returns a quoted expression that can be evaluated in the context
   where unheard.cycles functions are available.
 
@@ -230,23 +240,24 @@
   to allow for multi-line pattern notation.
 
   Examples:
-    (compile \"c e g\")
+    (compile \"c e g\" keyword)
     => (l :c :e :g)
 
-    (compile \"c [e g] b\")
+    (compile \"c [e g] b\" keyword)
     => (l :c (l :e :g) :b)
 
-    (compile \"<c e g b>*2\")
+    (compile \"<c e g b>*2\" keyword)
     => (rate 2 (f :c :e :g :b))
 
-    (compile \"[c,e,g] [d,f,a]\")
+    (compile \"[c,e,g] [d,f,a]\" keyword)
     => (l (p :c :e :g) (p :d :f :a))
 
-    (compile \"<a b\\nc d>\")
+    (compile \"<a b\\nc d>\" keyword)
     => (f :a :b :c :d)"
-  [s]
-  (let [normalized (str/replace s #"\n" " ")
-        elements (parse-sequence (str/trim normalized))]
-    (if (= 1 (count elements))
-      (first elements)
-      (cons 'l elements))))
+  ([s] (compile s keyword))
+  ([s get-value]
+   (let [normalized (str/replace s #"\n" " ")
+         elements (parse-sequence (str/trim normalized) get-value)]
+     (if (= 1 (count elements))
+       (first elements)
+       (cons 'l elements)))))