src/bigint/add.mjs

@@ -1,6 +1,5 @@
-import {use} from '../core/PocomathInstance.mjs'
 export {Types} from './Types/bigint.mjs'
 
 export const add = {
-   '...bigint': use([], addends => addends.reduce((x,y) => x+y, 0n))
+   '...bigint': () => addends => addends.reduce((x,y) => x+y, 0n)
 }

src/bigint/negate.mjs

@@ -1,4 +1,3 @@
-import {use} from '../core/PocomathInstance.mjs'
 export {Types} from './Types/bigint.mjs'
 
-export const negate = {bigint: use([], b => -b)}
+export const negate = {bigint: () => b => -b}

src/complex/add.mjs

@@ -1,13 +1,10 @@
 export {Types} from './Types/Complex.mjs'
 
 export const add = {
-   '...Complex': {
-      uses: ['self'],
-      does: ref => addends => {
+   '...Complex': ({self}) => addends => {
       if (addends.length === 0) return {re:0, im:0}
       const seed = addends.shift()
-         return addends.reduce((w,z) =>
-            ({re: ref.self(w.re, z.re), im: ref.self(w.im, z.im)}), seed)
-      }
+      return addends.reduce(
+         (w,z) => ({re: self(w.re, z.re), im: self(w.im, z.im)}), seed)
    }
 }

src/complex/complex.mjs

@@ -5,7 +5,7 @@ export const complex = {
     * have a numeric/scalar type, e.g. by implementing subtypes in
     * typed-function
     */
-   'any, any': {does: (x, y) => ({re: x, im: y})},
+   'any, any': () => (x, y) => ({re: x, im: y}),
    /* Take advantage of conversions in typed-function */
-   Complex: {does: z => z}
+   Complex: () => z => z
 }

src/complex/negate.mjs

@@ -1,10 +1,5 @@
 export {Types} from './Types/Complex.mjs'
 
 export const negate = {
-   Complex: {
-      uses: ['self'],
-      does: ref => z => {
-         return {re: ref.self(z.re), im: ref.self(z.im)}
-      }
-   }
+   Complex: ({self}) => z => ({re: self(z.re), im: self(z.im)})
 }

src/core/PocomathInstance.mjs

@@ -1,9 +1,6 @@
 /* Core of pocomath: create an instance */
 import typed from 'typed-function'
-
-export function use(dependencies, implementation) {
-   return [dependencies, implementation]
-}
+import dependencyExtractor from './dependencyExtractor.mjs'
 
 export default class PocomathInstance {
    /* Disallowed names for ops; beware, this is slightly non-DRY
@@ -25,50 +22,35 @@ export default class PocomathInstance {
    /**
     * (Partially) define one or more operations of the instance:
     *
-    * @param {Object<string, Object<Signature, [string[], function]>>} ops
+    * @param {Object<string, Object<Signature, ({deps})=> implementation>>} ops
     *    The only parameter ops gives the semantics of the operations to install.
     *    The keys are operation names. The value for a key is an object
-    *    mapping (typed-function) signature strings to specifications of
-    *    of dependency lists and implementation functions.
+    *    mapping each desired (typed-function) signature to a function taking
+    *    a dependency object to an implementation.
     *
-    *    A dependency list is a list of strings. Each string can either be the
-    *    name of a function that the corresponding implementation has to call,
-    *    or a specification of a particular signature of a function that it has
-    *    to call, in the form 'FN(SIGNATURE)' [not implemented yet].
-    *    Note the function name can be the special value 'self' to indicate a
-    *    recursive call to the given operation (either with or without a
-    *    particular signature.
+    *    For more detail, such functions should have the format
+    *    ```
+    *    ({depA, depB, depC: aliasC, ...}) => (opArg1, opArg2) => <result>
+    *    ```
+    *    where the `depA`, `depB` etc. are the names of the
+    *    operations this implementation depends on; those operations can
+    *    then be referred to directly by the identifiers `depA` and `depB`
+    *    in the code for the '<result>`, or when an alias has been given
+    *    as in the case of `depC`, by the identifier `aliasC`.
+    *    Given an object that has these dependencies with these keys, the
+    *    function returns a function taking the operation arguments to the
+    *    desired result of the operation.
     *
-    *    There are two cases for the implementation function. If the dependency
-    *    list is empty, it should be a function taking the arguments specified
-    *    by the signature and returning the value. Otherwise, it should be
-    *    a function taking an object with the dependency lists as keys and the
-    *    requested functions as values, to a function taking the arguments
-    *    specified by the signature and returning the value.
+    *    You can specify that an operation depends on itself by using the
+    *    special dependency identifier 'self'.
     *
-    *    There are various specifications currently allowed for the
-    *    dependency list and implementation function:
-    *
-    *    1) Just a function. Then the dependency list is assumed to be empty.
-    *
-    *    2) A pair (= Array with two entries) of a dependency list and the
-    *        implementation function.
-    *
-    *    3) An object whose property named 'does' gives the implementation
-    *        function and whose property named 'uses', if present, gives the
-    *        dependency list (which is assumed to be empty if the property is
-    *        not present).
-    *
-    *    4) A call to the 'use' function exported from the this module, with
-    *        first argument the dependencies and second argument the
-    *        implementation.
-    *
-    *    For a visual comparison of the options, this proof-of-concept uses
-    *    option (1) when possible for the 'number' type, (3) for the 'Complex'
-    *    type, (4) for the 'bigint' type, and (2) under any other circumstances.
-    *    Likely a fleshed-out version of this scheme would settle on just one
-    *    or two of these options or variants thereof, rather than providing so
-    *    many different ones.
+    *    You can specify that an implementation depends on just a specific
+    *    signature of the given operation by suffixing the dependency name
+    *    with the signature in parentheses, e.g. `add(number,number)` to
+    *    refer to just adding two numbers. In this case, it is of course
+    *    necessary to specify an alias to be able to refer to the supplied
+    *    operation in the body of the implementation. [NOTE: this signature-
+    *    specific reference is not yet implemented.]
     *
     *    Note that the "operation" named `Types` is special: it gives
     *    types that must be installed in the instance. In this case, the keys
@@ -94,13 +76,8 @@ export default class PocomathInstance {
          /* Grab all of the known deps */
          for (const func in this._imps) {
             if (func === 'Types') continue
-            for (const definition of Object.values(this._imps[func])) {
-               let deps = []
-               if (Array.isArray(definition)) deps = definition[0]
-               else if (typeof definition === 'object') {
-                  deps = definition.uses || deps
-               }
-               for (const dependency of deps) {
+            for (const {uses} of Object.values(this._imps[func])) {
+               for (const dependency of uses) {
                   const depName = dependency.split('(',1)[0]
                   if (doneSet.has(depName)) continue
                   requiredSet.add(depName)
@@ -137,14 +114,32 @@ export default class PocomathInstance {
       // new implementations, so set the op up to lazily recreate itself
       this._invalidate(name)
       const opImps = this._imps[name]
-      for (const signature in implementations) {
+      for (const [signature, does] of Object.entries(implementations)) {
+         if (name === 'Types') {
             if (signature in opImps) {
-            if (implementations[signature] === opImps[signature]) continue
+               if (does != opImps[signature]) {
+                  throw newSyntaxError(
+                     `Conflicting definitions of type ${signature}`)
+               }
+            } else {
+               opImps[signature] = does
+            }
+            continue
+         }
+         if (signature in opImps) {
+            if (does !== opImps[signature].does) {
                throw new SyntaxError(
                   `Conflicting definitions of ${signature} for ${name}`)
+            }
          } else {
-            opImps[signature] = implementations[signature]
-            for (const dep of implementations[signature][0] || []) {
+            if (name === 'Types') {
+               opImps[signature] = does
+               continue
+            }
+            const uses = new Set()
+            does(dependencyExtractor(uses))
+            opImps[signature] = {uses, does}
+            for (const dep of uses) {
                const depname = dep.split('(', 1)[0]
                if (depname === 'self') continue
                if (!(depname in this._affects)) {
@@ -187,27 +182,13 @@ export default class PocomathInstance {
       }
       this._ensureTypes()
       const tf_imps = {}
-      for (const signature in imps) {
-         const specifier = imps[signature]
-         let deps = []
-         let imp
-         if (typeof specifier === 'function') {
-            imp = specifier
-         } else if (Array.isArray(specifier)) {
-            [deps, imp] = specifier
-         } else if (typeof specifier === 'object') {
-            deps = specifier.uses || deps
-            imp = specifier.does
-         } else {
-            throw new SyntaxError(
-               `Cannot interpret signature definition ${specifier}`)
-         }
-         if (deps.length === 0) {
-            tf_imps[signature] = imp
+      for (const [signature, {uses, does}] of Object.entries(imps)) {
+         if (uses.length === 0) {
+            tf_imps[signature] = does()
          } else {
             const refs = {}
             let self_referential = false
-            for (const dep of deps) {
+            for (const dep of uses) {
                // TODO: handle signature-specific dependencies
                if (dep.includes('(')) {
                   throw new Error('signature specific reference unimplemented')
@@ -221,10 +202,10 @@ export default class PocomathInstance {
             if (self_referential) {
                tf_imps[signature] = this._typed.referToSelf(self => {
                   refs.self = self
-                  return imp(refs)
+                  return does(refs)
                })
             } else {
-               tf_imps[signature] = imp(refs)
+               tf_imps[signature] = does(refs)
             }
          }
       }

src/core/dependencyExtractor.mjs

@@ -0,0 +1,9 @@
+/* Call this with an empty Set object S, and it returns an entity E
+ * from which properties can be extracted, and at any time S will
+ * contain all of the property names that have been extracted from E.
+ */
+export default function dependencyExtractor(destinationSet) {
+   return new Proxy({}, {
+      get: (target, property) => { destinationSet.add(property) }
+   })
+}

src/generic/subtract.mjs

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

src/number/add.mjs

@@ -1,5 +1,5 @@
 export {Types} from './Types/number.mjs'
 
 export const add = {
-   '...number': addends => addends.reduce((x,y) => x+y, 0),
+   '...number': () => addends => addends.reduce((x,y) => x+y, 0),
 }

src/number/negate.mjs

@@ -1,3 +1,3 @@
 export { Types } from './Types/number.mjs'
 
-export const negate = {number: n => -n}
+export const negate = {number: () => n => -n}

test/_pocomath.mjs

@@ -19,7 +19,7 @@ describe('The default full pocomath instance "math"', () => {
 
    it('can be extended', () => {
       math.install({'add': {
-         '...string': [[], addends => addends.reduce((x,y) => x+y, '')]
+         '...string': () => addends => addends.reduce((x,y) => x+y, '')
       }})
       assert.strictEqual(math.add('Kilroy',' is here'), 'Kilroy is here')
    })

test/core/_PocomathInstance.mjs

@@ -4,7 +4,7 @@ import PocomathInstance from '../../src/core/PocomathInstance.mjs'
 const pi = new PocomathInstance('dummy')
 describe('PocomathInstance', () => {
    it('creates an instance that can define typed-functions', () => {
-      pi.install({add: {'any,any': [[], (a,b) => a+b]}})
+      pi.install({add: {'any,any': () => (a,b) => a+b}})
       assert.strictEqual(pi.add(2,2), 4)
       assert.strictEqual(pi.add('Kilroy', 17), 'Kilroy17')
       assert.strictEqual(pi.add(1, undefined), NaN)

test/core/_dependencyExtractor.mjs

@@ -0,0 +1,22 @@
+import assert from 'assert'
+import dependencyExtractor from '../../src/core/dependencyExtractor.mjs'
+
+describe('dependencyExtractor', () => {
+   it('will record the keys of a destructuring function', () => {
+      const myfunc = ({a, 'b(x)': b, c: alias}) => 0
+      const params = new Set()
+      myfunc(dependencyExtractor(params))
+      assert.ok(params.has('a'))
+      assert.ok(params.has('b(x)'))
+      assert.ok(params.has('c'))
+      assert.ok(params.size === 3)
+   })
+
+   it('does not pick up anything from a regular function', () => {
+      const myfunc = arg => 0
+      const params = new Set()
+      myfunc(dependencyExtractor(params))
+      assert.ok(params.size === 0)
+   })
+
+})