start packaging

packages/mini/krill.pegjs

@@ -0,0 +1,211 @@
+// 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
+
+
+{
+  var PatternStub = function(source, alignment)
+  {
+    this.type_ = "pattern";
+    this.arguments_ = { alignment : alignment};
+    this.source_ = source;
+  }
+
+  var OperatorStub = function(name, args, source)
+  {
+    this.type_ = name;
+    this.arguments_ = args;
+    this.source_ = source;
+  }
+
+  var ElementStub = function(source, options)
+  {
+    this.type_ = "element";
+    this.source_ = source;
+    this.options_ = options;
+    this.location_ = location();
+  }
+
+  var CommandStub = function(name, options)
+  {
+    this.type_ = "command";
+    this.name_ = name;
+    this.options_ = options;
+  }
+
+}
+
+start = statement
+
+// ----- Numbers -----
+
+number "number"
+  = minus? int frac? exp? { return parseFloat(text()); }
+
+decimal_point
+  = "."
+
+digit1_9
+  = [1-9]
+
+e
+  = [eE]
+
+exp
+  = e (minus / plus)? DIGIT+
+
+frac
+  = decimal_point DIGIT+
+
+int
+  = zero / (digit1_9 DIGIT*)
+
+minus
+  = "-"
+
+plus
+  = "+"
+
+zero
+  = "0"
+
+DIGIT  = [0-9]
+
+// ------------------ delimiters ---------------------------
+
+ws "whitespace" = [ \n\r\t]*
+comma = ws "," ws;
+quote = '"' / "'"
+
+// ------------------ steps and cycles ---------------------------
+
+// single step definition (e.g bd)
+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 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;}
+
+// a slice is either a single step or a sub cycle
+slice = step / sub_cycle  / timeline
+
+// 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_weight =  "@" a:number
+  { return { weight: a} }
+  
+slice_replicate = "!"a:number
+  { return { replicate: a  } }
+
+slice_bjorklund = "(" ws p:number ws comma ws s:number ws comma? ws r:number? ws ")"
+  { return { operator : { type_: "bjorklund", arguments_ :{ pulse: p, step:s, rotation:r || 0 } } } }
+
+slice_slow = "/"a:number
+  { return { operator : { type_: "stretch", arguments_ :{ amount:a } } } }
+
+slice_fast = "*"a:number
+  { return { operator : { type_: "stretch", arguments_ :{ amount:"1/"+a } } } }
+
+slice_fixed_step = "%"a:number
+  { return { operator : { type_: "fixed-step", arguments_ :{ amount:a } } } }
+
+// a slice with an modifier applied i.e [bd@4 sd@3]@2 hh]
+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 stack is a serie of vertically aligned single cycles, separated by a comma
+// if the stack contains only one element, we don't create a stack but return the
+// underlying element
+stack = c:single_cycle cs:(comma v:single_cycle { return v})*
+  { if (cs.length == 0 && c instanceof Object) { return c;} else { cs.unshift(c); return new PatternStub(cs,"v");}  }
+
+// a sequence is a quoted stack
+sequence = ws quote s:stack quote
+  { return s; }
+
+// ------------------ operators ---------------------------
+
+operator = scale / slow / fast / target / bjorklund / struct / rotR / rotL
+
+struct = "struct" ws s:sequence_or_operator
+  { return { name: "struct", args: { sequence:s }}}
+
+target = "target" ws quote s:step quote
+  { return { name: "target", args : { name:s}}}
+
+bjorklund = "euclid" ws p:int ws s:int ws r:int?
+  { return { name: "bjorklund", args :{ pulse: parseInt(p), step:parseInt(s) }}}
+
+slow = "slow" ws a:number
+  { return { name: "stretch", args :{ amount: a}}}
+
+rotL = "rotL" ws a:number
+  { return { name: "shift", args :{ amount: "-"+a}}}
+
+rotR = "rotR" ws a:number
+  { return { name: "shift", args :{ amount: a}}}
+
+fast = "fast" ws a:number
+  { return { name: "stretch", args :{ amount: "1/"+a}}}
+
+scale = "scale" ws quote s:(step_char)+ quote
+{ return { name: "scale", args :{ scale: s.join("")}}}
+
+comment = '//' p:([^\n]*)
+
+// ---------------- grouping --------------------------------
+
+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"); }
+
+// ------------------ high level sequence ---------------------------
+
+sequence_or_group =
+  group_operator /
+  sequence
+
+sequence_or_operator =
+  sg:sequence_or_group ws (comment)*
+    {return sg}
+  / o:operator ws "$" ws soc:sequence_or_operator
+    { return new OperatorStub(o.name,o.args,soc)}
+
+sequ_or_operator_or_comment =
+  sc: sequence_or_operator
+    { return sc }
+   / comment
+
+sequence_definition = s:sequ_or_operator_or_comment
+
+// ---------------------- statements ----------------------------
+
+command = ws c:(setcps / setbpm / hush) ws
+  { return c }
+
+setcps = "setcps" ws v:number
+  { return new CommandStub("setcps", { value: v})}
+
+setbpm = "setbpm" ws v:number
+  { return new CommandStub("setcps", { value: (v/120/2)})}
+
+hush = "hush"
+  { return new CommandStub("hush")}
+
+// ---------------------- statements ----------------------------
+
+statement = sequence_definition / command

packages/mini/mini.mjs

@@ -0,0 +1,175 @@
+import * as krill from './krill-parser.js';
+import * as strudel from '../core/strudel.mjs';
+import { addMiniLocations } from '../eval/shapeshifter.mjs';
+
+const { pure, Pattern, Fraction, stack, slowcat, sequence, timeCat, silence } = strudel;
+
+const applyOptions = (parent) => (pat, i) => {
+  const ast = parent.source_[i];
+  const options = ast.options_;
+  const operator = options?.operator;
+  if (operator) {
+    switch (operator.type_) {
+      case 'stretch':
+        const speed = Fraction(operator.arguments_.amount).inverse();
+        return reify(pat).fast(speed);
+      case 'bjorklund':
+        return pat.euclid(operator.arguments_.pulse, operator.arguments_.step, operator.arguments_.rotation);
+      // TODO: case 'fixed-step': "%"
+    }
+    console.warn(`operator "${operator.type_}" not implemented`);
+  }
+  if (options?.weight) {
+    // weight is handled by parent
+    return pat;
+  }
+  // TODO: bjorklund e.g. "c3(5,8)"
+  const unimplemented = Object.keys(options || {}).filter((key) => key !== 'operator');
+  if (unimplemented.length) {
+    console.warn(
+      `option${unimplemented.length > 1 ? 's' : ''} ${unimplemented.map((o) => `"${o}"`).join(', ')} not implemented`,
+    );
+  }
+  return pat;
+};
+
+function resolveReplications(ast) {
+  // the general idea here: x!3 = [x*3]@3
+  // could this be made easier?!
+  ast.source_ = ast.source_.map((child) => {
+    const { replicate, ...options } = child.options_ || {};
+    if (replicate) {
+      return {
+        ...child,
+        options_: { ...options, weight: replicate },
+        source_: {
+          type_: 'pattern',
+          arguments_: {
+            alignment: 'h',
+          },
+          source_: [
+            {
+              type_: 'element',
+              source_: child.source_,
+              location_: child.location_,
+              options_: {
+                operator: {
+                  type_: 'stretch',
+                  arguments_: { amount: Fraction(replicate).inverse().toString() },
+                },
+              },
+            },
+          ],
+        },
+      };
+    }
+    return child;
+  });
+}
+
+export function patternifyAST(ast) {
+  switch (ast.type_) {
+    case 'pattern':
+      resolveReplications(ast);
+      const children = ast.source_.map(patternifyAST).map(applyOptions(ast));
+      const alignment = ast.arguments_.alignment;
+      if (alignment === 'v') {
+        return stack(...children);
+      }
+      const weightedChildren = ast.source_.some((child) => !!child.options_?.weight);
+      if (!weightedChildren && alignment === 't') {
+        return slowcat(...children);
+      }
+      if (weightedChildren) {
+        const pat = timeCat(...ast.source_.map((child, i) => [child.options_?.weight || 1, children[i]]));
+        if (alignment === 't') {
+          const weightSum = ast.source_.reduce((sum, child) => sum + (child.options_?.weight || 1), 0);
+          return pat._slow(weightSum); // timecat + slow
+        }
+        return pat;
+      }
+      return sequence(...children);
+    case 'element':
+      if (ast.source_ === '~') {
+        return silence;
+      }
+      if (typeof ast.source_ !== 'object') {
+        if (!addMiniLocations) {
+          return ast.source_;
+        }
+        if (!ast.location_) {
+          console.warn('no location for', ast);
+          return ast.source_;
+        }
+        const { start, end } = ast.location_;
+        const value = !isNaN(Number(ast.source_)) ? Number(ast.source_) : ast.source_;
+        // the following line expects the shapeshifter append .withMiniLocation
+        // because location_ is only relative to the mini string, but we need it relative to whole code
+        return pure(value).withLocation([start.line, start.column, start.offset], [end.line, end.column, end.offset]);
+      }
+      return patternifyAST(ast.source_);
+    case 'stretch':
+      return patternifyAST(ast.source_).slow(ast.arguments_.amount);
+    /* case 'scale':
+      let [tonic, scale] = Scale.tokenize(ast.arguments_.scale);
+      const intervals = Scale.get(scale).intervals;
+      const pattern = patternifyAST(ast.source_);
+      tonic = tonic || 'C4';
+      // console.log('scale', ast, pattern, tonic, scale);
+      console.log('tonic', tonic);
+      return pattern.fmap((step: any) => {
+        step = Number(step);
+        if (isNaN(step)) {
+          console.warn(`scale step "${step}" not a number`);
+          return step;
+        }
+        const octaves = Math.floor(step / intervals.length);
+        const mod = (n: number, m: number): number => (n < 0 ? mod(n + m, m) : n % m);
+        const index = mod(step, intervals.length); // % with negative numbers. e.g. -1 % 3 = 2
+        const interval = Interval.add(intervals[index], Interval.fromSemitones(octaves * 12));
+        return Note.transpose(tonic, interval || '1P');
+      }); */
+    /* case 'struct':
+      // TODO:
+      return silence; */
+    default:
+      console.warn(`node type "${ast.type_}" not implemented -> returning silence`);
+      return silence;
+  }
+}
+
+// mini notation only (wraps in "")
+export const mini = (...strings) => {
+  const pats = strings.map((str) => {
+    const ast = krill.parse(`"${str}"`);
+    return patternifyAST(ast);
+  });
+  return sequence(...pats);
+};
+
+// includes haskell style (raw krill parsing)
+export const h = (string) => {
+  const ast = krill.parse(string);
+  // console.log('ast', ast);
+  return patternifyAST(ast);
+};
+
+// shorthand for mini
+Pattern.prototype.define('mini', mini, { composable: true });
+Pattern.prototype.define('m', mini, { composable: true });
+Pattern.prototype.define('h', h, { composable: true });
+
+// TODO: move this to strudel?
+export function reify(thing) {
+  if (thing?.constructor?.name === 'Pattern') {
+    return thing;
+  }
+  return pure(thing);
+}
+
+export function minify(thing) {
+  if (typeof thing === 'string') {
+    return mini(thing);
+  }
+  return reify(thing);
+}

packages/mini/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@strudel/mini",
+  "version": "0.0.1",
+  "description": "Mini notation for strudel",
+  "main": "mini.mjs",
+  "type": "module",
+  "scripts": {
+    "test": "mocha --colors"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tidalcycles/strudel.git"
+  },
+  "keywords": [
+    "tidalcycles",
+    "strudel",
+    "pattern",
+    "livecoding",
+    "algorave"
+  ],
+  "author": "Felix Roos <flix91@gmail.com>",
+  "license": "GPL-3.0-or-later",
+  "bugs": {
+    "url": "https://github.com/tidalcycles/strudel/issues"
+  },
+  "homepage": "https://github.com/tidalcycles/strudel#readme"
+}

packages/mini/test/mini.test.mjs

@@ -0,0 +1,12 @@
+import { strict as assert } from 'assert';
+import { mini } from '../mini.mjs';
+
+describe('mini', () => {
+  it('Should parse mini notation', () => {
+    const min = (v) => mini(v)._firstCycleValues;
+
+    assert.deepStrictEqual(min('c3'), ['c3']);
+    assert.deepStrictEqual(min('c3 d3'), ['c3', 'd3']);
+    assert.deepStrictEqual(min('<c3 d3>'), ['c3']);
+  });
+});