hacklab/strudel
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Tidy parser, implement polymeters (#336)

Browse source 
* rename parser stuff to be more explicit and fit with tidal concepts. qualify all strudel function calls
* Add {,}%n polymeter support, with a few tests
This commit is contained in:
Alex McLean 2022-12-31 21:42:49 +00:00 • committed by GitHub
parent c0a7173ca4
commit 8bb460701f
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 549 additions and 439 deletions
Download patch file Download diff file Expand all files Collapse all files

92
packages/mini/krill.pegjs
View file

@ -5,10 +5,10 @@ This program is free software: you can redistribute it and/or modify it under th
*/
// Some terminology:
// a sequence = a serie of elements placed between quotes
// a stack = a serie of vertically aligned slices sharing the same overall length
// a slice = a serie of horizontally aligned elements
// a choose = a serie of elements, one of which is chosen at random
// mini(notation) = a series of elements placed between quotes
// a stack = a series of vertically aligned slices sharing the same overall length
// a sequence = a series of horizontally aligned elements
// a choose = a series of elements, one of which is chosen at random
{
@ -93,18 +93,26 @@ step_char = [0-9a-zA-Z~] / "-" / "#" / "." / "^" / "_" / ":"
step = ws chars:step_char+ ws { return chars.join("") }
// define a sub cycle e.g. [1 2, 3 [4]]
sub_cycle = ws "[" ws s:stack_or_choose ws "]" ws { return s}
sub_cycle = ws "[" ws s:stack_or_choose ws "]" ws { return s }
// define a timeline e.g <1 3 [3 5]>. We simply defer to a stack and change the alignement
timeline = ws "<" ws sc:single_cycle ws ">" ws
{ sc.arguments_.alignment = "t"; return sc;}
// define a polymeter e.g. {1 2, 3 4 5}
polymeter = ws "{" ws s:polymeter_stack ws "}" stepsPerCycle:polymeter_steps? ws
{ s.arguments_.stepsPerCycle = stepsPerCycle ; return s; }
polymeter_steps = "%"a:number
{ return a }
// define a step-per-cycle timeline e.g <1 3 [3 5]>. We simply defer to a sequence and
// change the alignment to slowcat
slow_sequence = ws "<" ws s:sequence ws ">" ws
{ s.arguments_.alignment = 'slowcat'; return s; }
// a slice is either a single step or a sub cycle
slice = step / sub_cycle / timeline
slice = step / sub_cycle / polymeter / slow_sequence
// slice modifier affects the timing/size of a slice (e.g. [a b c]@3)
// at this point, we assume we can represent them as regular sequence operators
slice_modifier = slice_weight / slice_bjorklund / slice_slow / slice_fast / slice_fixed_step / slice_replicate / slice_degrade
slice_modifier = slice_weight / slice_bjorklund / slice_slow / slice_fast / slice_replicate / slice_degrade
slice_weight = "@" a:number
{ return { weight: a} }
@ -121,9 +129,6 @@ slice_slow = "/"a:number
slice_fast = "*"a:number
{ return { operator : { type_: "stretch", arguments_ :{ amount:a, type: 'fast' } } } }
slice_fixed_step = "%"a:number
{ return { operator : { type_: "fixed-step", arguments_ :{ amount:a } } } }
slice_degrade = "?"a:number?
{ return { operator : { type_: "degradeBy", arguments_ :{ amount:(a? a : 0.5) } } } }
@ -131,35 +136,42 @@ slice_degrade = "?"a:number?
slice_with_modifier = s:slice o:slice_modifier?
{ return new ElementStub(s, o);}
// a single cycle is a combination of one or more successive slices (as an array). If we
// have only one element, we skip the array and return the element itself
single_cycle = s:(slice_with_modifier)+
{ return new PatternStub(s,"h"); }
// a sequence is a combination of one or more successive slices (as an array)
sequence = s:(slice_with_modifier)+
{ return new PatternStub(s, 'fastcat'); }
// a stack is a serie of vertically aligned single cycles, separated by a comma
stack_tail = tail:(comma @single_cycle)+
{ return { alignment: 'v', list: tail }; }
// a stack is a series of vertically aligned sequence, separated by a comma
stack_tail = tail:(comma @sequence)+
{ return { alignment: 'stack', list: tail }; }
// a choose is a serie of pipe-separated single cycles, one of which is chosen
// at random each time through the pattern
choose_tail = tail:(pipe @single_cycle)+
{ return { alignment: 'r', list: tail }; }
// a choose is a series of pipe-separated sequence, one of which is
// chosen at random, each cycle
choose_tail = tail:(pipe @sequence)+
{ return { alignment: 'rand', list: tail }; }
// if the stack contains only one element, we don't create a stack but return the
// underlying element
stack_or_choose = head:single_cycle tail:(stack_tail / choose_tail)?
stack_or_choose = head:sequence tail:(stack_tail / choose_tail)?
{ if (tail && tail.list.length > 0) { return new PatternStub([head, ...tail.list], tail.alignment); } else { return head; } }
// a sequence is a quoted stack
sequence = ws quote sc:stack_or_choose quote
polymeter_stack = head:sequence tail:stack_tail?
{ return new PatternStub(tail ? [head, ...tail.list] : [head], 'polymeter'); }
// Mini-notation innards ends
// ---------->8---------->8---------->8---------->8---------->8----------
// Experimental haskellish parser begins
// mini-notation = a quoted stack
mini = ws quote sc:stack_or_choose quote
{ return sc; }
// ------------------ operators ---------------------------
operator = scale / slow / fast / target / bjorklund / struct / rotR / rotL
struct = "struct" ws s:sequence_or_operator
{ return { name: "struct", args: { sequence:s }}}
struct = "struct" ws s:mini_or_operator
{ return { name: "struct", args: { mini:s }}}
target = "target" ws quote s:step quote
{ return { name: "target", args : { name:s}}}
@ -189,27 +201,27 @@ comment = '//' p:([^\n]*)
group_operator = cat
// cat is another form of timeline
cat = "cat" ws "[" ws s:sequence_or_operator ss:(comma v:sequence_or_operator { return v})* ws "]"
{ ss.unshift(s); return new PatternStub(ss,"t"); }
cat = "cat" ws "[" ws s:mini_or_operator ss:(comma v:mini_or_operator { return v})* ws "]"
{ ss.unshift(s); return new PatternStub(ss, 'slowcat'); }
// ------------------ high level sequence ---------------------------
// ------------------ high level mini ---------------------------
sequence_or_group =
mini_or_group =
group_operator /
sequence
mini
sequence_or_operator =
sg:sequence_or_group ws (comment)*
mini_or_operator =
sg:mini_or_group ws (comment)*
{return sg}
/ o:operator ws "$" ws soc:sequence_or_operator
/ o:operator ws "$" ws soc:mini_or_operator
{ return new OperatorStub(o.name,o.args,soc)}
sequ_or_operator_or_comment =
sc: sequence_or_operator
sc: mini_or_operator
{ return sc }
/ comment
sequence_definition = s:sequ_or_operator_or_comment
mini_definition = s:sequ_or_operator_or_comment
// ---------------------- statements ----------------------------
@ -227,4 +239,4 @@ hush = "hush"
// ---------------------- statements ----------------------------
statement = sequence_definition / command
statement = mini_definition / command