Merge pull request #15 from tidalcycles/apply-an--layer

add apply and layer, and missing div/mul methods

strudel.mjs

@@ -404,6 +404,14 @@ class Pattern {
         return this._opleft(other, a => b => a - b)
     }
     
+    mul(other) {
+        return this._opleft(other, a => b => a * b)
+    }
+
+    div(other) {
+        return this._opleft(other, a => b => a / b)
+    }
+
     union(other) {
         return this._opleft(other, a => b => Object.assign({}, a, b))
     }
@@ -460,6 +468,14 @@ class Pattern {
         return this.outerBind(id)
     }
 
+    _apply(func) {
+        return func(this)
+    }
+
+    layer(...funcs) {
+        return stack(...funcs.map(func => func(this)))
+    }
+
     _patternify(func) {
         const pat = this
         const patterned = function (...args) {
@@ -651,7 +667,7 @@ class Pattern {
 }
 
 // methods of Pattern that get callable factories
-Pattern.prototype.patternified = ['fast', 'slow', 'early', 'late'];
+Pattern.prototype.patternified = ['apply', 'fast', 'slow', 'early', 'late'];
 // methods that create patterns, which are added to patternified Pattern methods
 Pattern.prototype.factories = { pure, stack, slowcat, fastcat, cat, timeCat, sequence, polymeter, pm, polyrhythm, pr};
 // the magic happens in Pattern constructor. Keeping this in prototype enables adding methods from the outside (e.g. see tonal.ts)

test/pattern.test.mjs

@@ -329,4 +329,30 @@ describe('Pattern', function() {
       )
     })
   })
+  describe("apply", () => {
+    it('Can apply a function', () => {
+      assert.deepStrictEqual(
+        sequence("a", "b")._apply(fast(2)).firstCycle,
+        sequence("a", "b").fast(2).firstCycle
+      )
+    }),
+    it('Can apply a pattern of functions', () => {
+      assert.deepStrictEqual(
+        sequence("a", "b").apply(fast(2)).firstCycle,
+        sequence("a", "b").fast(2).firstCycle
+      )
+      assert.deepStrictEqual(
+        sequence("a", "b").apply(fast(2),fast(3)).firstCycle,
+        sequence("a", "b").fast(2,3).firstCycle
+      )
+    })
+  })
+  describe("layer", () => {
+    it('Can layer up multiple functions', () => {
+      assert.deepStrictEqual(
+        sequence(1,2,3).layer(fast(2), pat => pat.add(3,4)).firstCycle,
+        stack(sequence(1,2,3).fast(2), sequence(1,2,3).add(3,4)).firstCycle
+      )
+    })
+  })
 })