Combinator helpers

lib/method-combinators.coffee

@@ -117,4 +117,32 @@ this.async = do (async = undefined) ->
             callback()
         async_predicate.apply(this, argv.concat(decorated_base))
 
-  async
+  async
+
+# ## Combinator Helpers
+this.helpers = do (helpers = {}, combinators = this, resolveFunction = undefined)->
+
+  resolveFunction = (func)->
+    if typeof func is "string"
+      helpers.my func
+    else
+      func
+
+  # Sugar to reference instance methods by name.
+  helpers.my =
+    (name)->
+      (args...)->
+        func = this[name]
+        func.apply this, args
+
+  # Similar to composition & threading macros
+  helpers.pipe  =
+    (functions...)->
+      (args...)->
+        result = undefined
+        for func in functions
+          result = resolveFunction(func).apply this, args
+          args = [result]
+        result
+
+  helpers

spec/method-combinators.spec.coffee

@@ -468,3 +468,63 @@ describe "Asynchronous Method Combinators", ->
         decorate(base) 'no', ->
 
         expect(a).toEqual([])
+describe "helpers", ->
+
+  describe "my", ->
+
+    it "should reference instance method", ->
+
+      addFunction = C.helpers.my "add"
+
+      repeatArg = (func)->
+        (firstArg)->
+          func.apply this, [firstArg, firstArg]
+
+      class MyClass
+        double:
+          repeatArg \
+          addFunction
+
+        add: (x,y)-> x + y
+
+      eg = new MyClass()
+      expect(eg.double 4).toBe 8
+
+  describe "pipe", ->
+
+    it "should thread functions", ->
+
+      add = (x,y)-> x + y
+      square = (n)-> n*n
+      addAndSquareFunction = C.helpers.pipe add, square
+
+      repeatArg = (func)->
+        (firstArg)->
+          func.apply this, [firstArg, firstArg]
+
+      class PipeClass
+        doubleAndSquare:
+          repeatArg \
+          addAndSquareFunction
+
+      eg = new PipeClass()
+      expect(eg.doubleAndSquare 4).toBe 64
+
+    it "should thread named methods", ->
+
+      addAndSquareFunction = C.helpers.pipe "add", "square"
+
+      repeatArg = (func)->
+        (firstArg)->
+          func.apply this, [firstArg, firstArg]
+
+      class PipeClass
+        doubleAndSquare:
+          repeatArg \
+          addAndSquareFunction
+
+        add: (x,y)-> x + y
+        square: (n)-> n*n
+
+      eg = new PipeClass()
+      expect(eg.doubleAndSquare 4).toBe 64