feat: Allow nonrecursive whole-function dependencies and use to subtract

PocomathInstance.mjs

@@ -74,17 +74,38 @@ export default class PocomathInstance {
          throw new SyntaxError(`No implementations for ${name}`)
       }
       const tf_imps = {}
-      // TODO: handle nonempty dependencies
       for (const signature in imps) {
          const [deps, imp] = imps[signature]
          if (deps.length === 0) {
             tf_imps[signature] = imp
          } else {
-            throw new Error('Unimplemented')
+            const refs = {}
+            for (const dep of deps) {
+               // TODO: handle self dependencies
+               if (dep.slice(0,4) === 'self') {
+                  throw new Error('self-reference unimplemented')
+               }
+               // TODO: handle signature-specific dependencies
+               if (dep.includes('(')) {
+                  throw new Error('signature specific reference unimplemented')
+               }
+               refs[dep] = this._ensureBundle(dep) // just assume acyclic for now
+            }
+            tf_imps[signature] = imp(refs)
          }
       }
       const tf = typed(name, tf_imps)
       this[name] = tf
       return tf
    }
+
+   /**
+    * Ensure that the generated typed function is assigned to the given
+    * name and return it
+    */
+   _ensureBundle(name) {
+      const maybe = this[name]
+      if (typed.isTypedFunction(maybe)) return maybe
+      return this._bundle(name)
+   }
 }

generic/subtract.mjs

@@ -0,0 +1,3 @@
+export const subtract = {
+   'any,any': [['add', 'negate'], ref => (x,y) => ref.add(x, ref.negate(y))]
+} 

number/all.mjs

@@ -1,2 +1,3 @@
 export {add} from './add.mjs'
 export {negate} from './negate.mjs'
+export {subtract} from '../generic/subtract.mjs'

test/_pocomath.mjs

@@ -2,11 +2,16 @@ import assert from 'assert'
 import math from '../pocomath.mjs'
 
 describe('The default full pocomath instance "math"', () => {
+   it('can subtract numbers', () => {
+      assert.strictEqual(math.subtract(12, 5), 7)
+   })
+
    it('can add numbers', () => {
       assert.strictEqual(math.add(3, 4), 7)
       assert.strictEqual(math.add(1.5, 2.5, 3.5), 7.5)
       assert.strictEqual(math.add(Infinity), Infinity)
    })
+
    it('can negate numbers', () => {
       assert.strictEqual(math.negate(-1), 1)
       assert.strictEqual(math.add(10, math.negate(3)), 7)