src/complex/isReal.mjs

@@ -0,0 +1,7 @@
+import Returns from '../core/Returns.mjs'
+export * from './Types/Complex.mjs'
+
+export const isReal = {
+   'Complex<T>': ({'equal(T,T)': eq, 'add(T,T)': plus}) => Returns(
+      'boolean', z => eq(z.re, plus(z.re, z.im)))
+}

src/complex/native.mjs

@@ -18,5 +18,6 @@ export {quaternion} from './quaternion.mjs'
 export {quotient} from './quotient.mjs'
 export {roundquotient} from './roundquotient.mjs'
 export {sqrt} from './sqrt.mjs'
+export {sqrtc} from './sqrtc.mjs'
 export {zero} from './zero.mjs'
 

src/complex/polynomialRoot.mjs

@@ -0,0 +1,65 @@
+import Returns from '../core/Returns.mjs'
+export * from './Types/Complex.mjs'
+
+export const polynomialRoot = {
+   'Complex<T>,...Complex<T>': ({
+      T,
+      'tuple(...Complex<T>)': tupCplx,
+      'tuple(...T)': tupReal,
+      'isZero(Complex<T>)': zero,
+      'complex(T)': C,
+      'multiply(Complex<T>,Complex<T>)': mul,
+      'divide(Complex<T>,Complex<T>)': div,
+      'negate(Complex<T>)': neg,
+      'isReal(Complex<T>)': real,
+      'equalTT(Complex<T>, Complex<T>)': eq,
+      'subtract(Complex<T>, Complex<T>)': sub,
+      'sqrtc(Complex<T>)': sqt,
+   }) => Returns(`Tuple<${T}>|Tuple<Complex<${T}>>`, (constant, rest) => {
+      // helper to convert results to appropriate tuple type
+      const typedTup = arr => {
+         if (arr.every(real)) {
+            return tupReal.apply(tupReal, arr.map(z => z.re))
+         }
+         return tupCplx.apply(tupCplx, arr)
+      }
+
+      const coeffs = [constant, ...rest]
+      while (coeffs.length > 0 && zero(coeffs[coeffs.length - 1])) {
+         coeffs.pop()
+      }
+      if (coeffs.length < 2) {
+      }
+      switch (coeffs.length) {
+         case 0: case 1:
+            throw new RangeError(
+               `Polynomial [${constant}, ${rest}] must have at least one`
+                  + 'non-zero non-constant coefficient')
+         case 2: // linear
+            return typedTup([neg(div(coeffs[0], coeffs[1]))])
+         case 3: { // quadratic
+            const [c, b, a] = coeffs
+            console.log('solving', a, b, c)
+            const denom = mul(C(2), a)
+            const d1 = mul(b, b)
+            const d2 = mul(C(4), mul(a, c))
+            console.log('Whoa', denom, d1, d2)
+            if (eq(d1, d2)) {
+               console.log('Hello', b, denom, div(neg(b), denom))
+               return typedTup([div(neg(b), denom)])
+            }
+            let discriminant = sqt(sub(d1, d2))
+            console.log('Uhoh', discriminant)
+            console.log('Roots', div(sub(discriminant, b), denom), div(sub(neg(discriminant), b), denom))
+            return typedTup([
+               div(sub(discriminant, b), denom),
+               div(sub(neg(discriminant), b), denom)
+            ])
+         }
+         default:
+            throw new RangeError(
+               'only implemented for cubic or lower-order polynomials, '
+                  + `not ${JSON.stringify(coeffs)}`)
+      }
+   })
+}

src/complex/sqrt.mjs

@@ -4,49 +4,30 @@ export * from './Types/Complex.mjs'
 export const sqrt = {
    'Complex<T>': ({
       config,
+      'sqrtc(Complex<T>)': predictableSqrt,
       'isZero(T)': isZ,
-      'sign(T)': sgn,
-      'one(T)': uno,
-      'add(T,T)': plus,
-      'complex(T)': cplxU,
-      'complex(T,T)': cplxB,
-      'multiply(T,T)': mult,
-      'self(T)': me,
-      'divide(T,T)': div,
-      'absquare(Complex<T>)': absqC,
-      'subtract(T,T)': sub
    }) => {
-      let baseReturns = returnTypeOf(me)
+      if (config.checkingDependency) return undefined
-      if (baseReturns.includes('|')) {
+      const complexReturns = returnTypeOf(predictableSqrt)
-         // Bit of a hack, because it is relying on other implementations
+      const baseReturns = complexReturns.slice(8, -1); // Complex<WhatWeWant>
-         // to list the "typical" value of sqrt first
-         baseReturns = baseReturns.split('|', 1)[0]
-      }
-
       if (config.predictable) {
-         return Returns(`Complex<${baseReturns}>`, z => {
+         return Returns(complexReturns, z => predictableSqrt(z))
-            const reOne = uno(z.re)
-            if (isZ(z.im) && sgn(z.re) === reOne) return cplxU(me(z.re))
-            const reTwo = plus(reOne, reOne)
-            const myabs = me(absqC(z))
-            return cplxB(
-               mult(sgn(z.im), me(div(plus(myabs, z.re), reTwo))),
-               me(div(sub(myabs, z.re), reTwo))
-            )
-         })
       }
 
       return Returns(
          `Complex<${baseReturns}>|${baseReturns}|undefined`,
          z => {
-            const reOne = uno(z.re)
+            let complexSqrt
-            if (isZ(z.im) && sgn(z.re) === reOne) return me(z.re)
+            try {
-            const reTwo = plus(reOne, reOne)
+               complexSqrt = predictableSqrt(z)
-            const myabs = me(absqC(z))
+            } catch (e) {
-            const reSqrt = me(div(plus(myabs, z.re), reTwo))
+               return undefined
-            const imSqrt = me(div(sub(myabs, z.re), reTwo))
+            }
-            if (reSqrt === undefined || imSqrt === undefined) return undefined
+            if (complexSqrt.re === undefined || complexSqrt.im === undefined) {
-            return cplxB(mult(sgn(z.im), reSqrt), imSqrt)
+               return undefined
+            }
+            if (isZ(complexSqrt.im)) return complexSqrt.re
+            return complexSqrt
          }
       )
    }

src/complex/sqrtc.mjs

@@ -0,0 +1,42 @@
+import {Returns, returnTypeOf} from '../core/Returns.mjs'
+export * from './Types/Complex.mjs'
+
+export const sqrtc = {
+   'Complex<T>': ({
+      T,
+      'isZero(T)': isZ,
+      'sign(T)': sgn,
+      'one(T)': uno,
+      'add(T,T)': plus,
+      'complex(T)': cplxU,
+      'complex(T,T)': cplxB,
+      'multiply(T,T)': mult,
+      'sqrt(T)': sqt,
+      'divide(T,T)': div,
+      'absquare(Complex<T>)': absqC,
+      'subtract(T,T)': sub
+   }) => {
+      if (isZ.checkingDependency) return undefined
+      let baseReturns = returnTypeOf(sqt)
+      if (baseReturns.includes('|')) {
+         // Bit of a hack, because it is relying on other implementations
+         // to list the "typical" value of sqrt first
+         baseReturns = baseReturns.split('|', 1)[0]
+      }
+      return Returns(`Complex<${baseReturns}>`, z => {
+         const reOne = uno(z.re)
+         if (isZ(z.im) && sgn(z.re) === reOne) return cplxU(sqt(z.re))
+         const myabs = sqt(absqC(z))
+         const reTwo = plus(reOne, reOne)
+         const reQuot = div(plus(myabs, z.re), reTwo)
+         const imQuot = div(sub(myabs, z.re), reTwo)
+         if (reQuot === undefined || imQuot === undefined) {
+            throw new TypeError(`Cannot compute sqrt of ${z.re} + {z.im}i`)
+         }
+         return cplxB(
+            mult(sgn(z.im), sqt(div(plus(myabs, z.re), reTwo))),
+            sqt(div(sub(myabs, z.re), reTwo))
+         )
+      })
+   }
+}

src/core/PocomathInstance.mjs

@@ -7,6 +7,12 @@ import {typeListOfSignature, typesOfSignature, subsetOfKeys} from './utils.mjs'
 
 const anySpec = {} // fixed dummy specification of 'any' type
 
+/* Like `.some(predicate)` but for collections */
+function exists(collection, predicate) {
+   for (const item of collection) if (predicate(item)) return true;
+   return false;
+}
+
 /* Template/signature parsing stuff; should probably be moved to a
  * separate file, but it's a bit interleaved at the moment
  */
@@ -98,6 +104,7 @@ export default class PocomathInstance {
    static reserved = new Set([
       'chain',
       'config',
+      'convert',
       'importDependencies',
       'install',
       'installType',
@@ -138,8 +145,21 @@ export default class PocomathInstance {
       const me = this
       this._typed.onMismatch = (name, args, sigs) => {
          if (me._invalid.has(name)) {
+            if (this._fixing === name) {
+               this._fixingCount += 1
+               if (this._fixingCount > this._maxDepthSeen + 2) {
+                  throw new ReferenceError(
+                     `Infinite descent rebuilding ${name} on ${args}`)
+               }
+            } else {
+               this._fixingCount = 0
+            }
             // rebuild implementation and try again
-            return me[name](...args)
+            const lastFixing = this._fixing
+            this._fixing = name
+            const value = me[name](...args)
+            this._fix = lastFixing
+            return value
          }
          const metaversion = me._meta[name]
          if (metaversion) {
@@ -185,6 +205,8 @@ export default class PocomathInstance {
       this._plainFunctions = new Set() // the names of the plain functions
       this._chainRepository = {} // place to store chainified functions
       this.joinTypes = this.joinTypes.bind(me)
+      // Provide access to typed function conversion:
+      this.convert = this._typed.convert.bind(this._typed)
    }
 
    /**
@@ -763,45 +785,39 @@ export default class PocomathInstance {
    /**
     * Reset an operation to require creation of typed-function,
     * and if it has no implementations so far, set them up.
+    * name is the name of the operation, badType is a type that has been
+    * invalidated, and reasons is a set of specific operations/signatures
+    * that have been invalidated
     */
-   _invalidate(name, reason) {
+   _invalidate(name, badType = '', reasons = new Set()) {
       if (!(name in this._imps)) {
          this._imps[name] = {}
          this._TFimps[name] = {}
          this._metaTFimps[name] = {}
       }
-      if (reason) {
+      // Go through each TF imp and invalidate it if need be
-         // Make sure no TF imps that depend on reason remain:
+      for (const [signature, imp] of Object.entries(this._TFimps[name])) {
-         for (const [signature, behavior] of Object.entries(this._imps[name])) {
+         if (imp.deferred
-            let invalidated = false
+             || (badType && signature.includes(badType))
-            if (reason.charAt(0) === ':') {
+             || exists(imp.uses, dep => {
-               const badType = reason.slice(1)
+                const [func, sig] = dep.split(/[()]/)
-               if (signature.includes(badType)) invalidated = true
+                return reasons.has(dep)
+                   || (reasons.has(func) && !(sig in this._TFimps[func]))
+             })) {
+            // Invalidate this implementation:
+            delete this._TFimps[name][signature]
+            const behavior = imp.fromBehavior
+            if (behavior.explicit) {
+               behavior.resolved = false
             } else {
-               for (const dep of behavior.uses) {
+               delete behavior.hasInstantiations[imp.instance]
-                  if (dep.includes(reason)) {
-                     invalidated = true
-                     break
-                  }
-               }
-            }
-            if (invalidated) {
-               if (behavior.explicit) {
-                  if (behavior.resolved) delete this._TFimps[signature]
-                  behavior.resolved = false
-               } else {
-                  for (const fullSig
-                       of Object.values(behavior.hasInstantiations)) {
-                     delete this._TFimps[fullSig]
-                  }
-                  behavior.hasInstantiations = {}
-               }
             }
+            reasons.add(`${name}(${signature})`)
          }
       }
       if (this._invalid.has(name)) return
       this._invalid.add(name)
-      this._invalidateDependents(name)
+      this._invalidateDependents(name, badType, reasons)
       const self = this
       Object.defineProperty(this, name, {
          configurable: true,
@@ -815,11 +831,14 @@ export default class PocomathInstance {
 
    /**
     * Invalidate all the dependents of a given property of the instance
+    * reasons is a set of invalidated signatures
     */
-   _invalidateDependents(name) {
+   _invalidateDependents(name, badType, reasons = new Set()) {
+      if (name.charAt(0) === ':') badType = name.slice(1)
+      else reasons.add(name)
       if (name in this._affects) {
          for (const ancestor of this._affects[name]) {
-            this._invalidate(ancestor, name)
+            this._invalidate(ancestor, badType, reasons)
          }
       }
    }
@@ -860,7 +879,7 @@ export default class PocomathInstance {
       for (const [rawSignature, behavior] of usableEntries) {
          if (behavior.explicit) {
             if (!(behavior.resolved)) {
-               this._addTFimplementation(tf_imps, rawSignature, behavior)
+               this._addTFimplementation(name, tf_imps, rawSignature, behavior)
                tf_imps[rawSignature]._pocoSignature = rawSignature
                behavior.resolved = true
             }
@@ -880,11 +899,18 @@ export default class PocomathInstance {
          }
          /* First, add the known instantiations, gathering all types needed */
          if (ubType) behavior.needsInstantiations.add(ubType)
+         const nargs = typeListOfSignature(rawSignature).length
          let instantiationSet = new Set()
          const ubTypes = new Set()
          if (!ubType) {
             // Collect all upper-bound types for this signature
             for (const othersig in imps) {
+               const otherNargs = typeListOfSignature(othersig).length
+               if (nargs !== otherNargs) {
+                  // crude criterion that it won't match, that ignores
+                  // rest args, but hopefully OK for prototype
+                  continue
+               }
                const thisUB = upperBounds.exec(othersig)
                if (thisUB) ubTypes.add(thisUB[2])
                let basesig = othersig.replaceAll(templateCall, '')
@@ -907,14 +933,13 @@ export default class PocomathInstance {
          for (const instType of behavior.needsInstantiations) {
             instantiationSet.add(instType)
             const otherTypes =
-                  ubType ? this.subtypesOf(instType) : this._priorTypes[instType]
+               ubType ? this.subtypesOf(instType) : this._priorTypes[instType]
             for (const other of otherTypes) {
                if (!(this._atOrBelowSomeType(other, ubTypes))) {
                   instantiationSet.add(other)
                }
             }
          }
-
          /* Prevent other existing signatures from blocking use of top-level
           * templates via conversions:
           */
@@ -953,7 +978,8 @@ export default class PocomathInstance {
             }
          }
          for (const instType of instantiationSet) {
-            this._instantiateTemplateImplementation(name, rawSignature, instType)
+            this._instantiateTemplateImplementation(
+               name, rawSignature, instType)
          }
          /* Now add the catchall signature */
          /* (Not needed if if it's a bounded template) */
@@ -1008,6 +1034,7 @@ export default class PocomathInstance {
                            `Type inference failed for argument ${j} of ${name}`)
                      }
                      if (argType === 'any') {
+                        console.log('INCOMPATIBLE ARGUMENTS are', args)
                         throw TypeError(
                            `In call to ${name}, `
                               + 'incompatible template arguments:'
@@ -1065,12 +1092,19 @@ export default class PocomathInstance {
                // But possibly since this resolution was grabbed, the proper
                // instantiation has been added (like if there are multiple
                // uses in the implementation of another method.
-               if (!(behavior.needsInstantiations.has(instantiateFor))) {
+               let whatToDo
-                  behavior.needsInstantiations.add(instantiateFor)
+               if (!(instantiateFor in behavior.hasInstantiations)) {
+                  const newImp = self._instantiateTemplateImplementation(
+                     name, rawSignature, instantiateFor)
+                  if (newImp) {
+                     whatToDo = {fn: newImp, implementation: newImp}
+                  }
                   self._invalidate(name)
                }
                const brandNewMe = self[name]
-               const whatToDo = self._typed.resolve(brandNewMe, args)
+               const betterToDo = self._typed.resolve(brandNewMe, args)
+               whatToDo = betterToDo || whatToDo
+
                // We can access return type information here
                // And in particular, if it might be a template, we should try to
                // instantiate it:
@@ -1084,8 +1118,13 @@ export default class PocomathInstance {
                }
                if (whatToDo === lastWhatToDo) {
                   throw new Error(
-                     `Infinite recursion in resolving $name called on`
+                     `Infinite recursion in resolving ${name} called on `
-                        + args.map(x => x.toString()).join(','))
+                        + args.map(x =>
+                           (typeof x === 'object'
+                            ? JSON.stringify(x)
+                            : x.toString())
+                        ).join(', ')
+                        + ` inferred to be ${wantSig}`)
                }
                lastWhatToDo = whatToDo
                const retval = whatToDo.implementation(...args)
@@ -1103,7 +1142,9 @@ export default class PocomathInstance {
          // correct return type a priori. Deferring because unclear what
          // aspects will be merged into typed-function.
          this._addTFimplementation(
-            meta_imps, signature, {uses: new Set(), does: patch})
+            name, meta_imps, signature,
+            {uses: new Set(), does: patch},
+            behavior)
          behavior.resolved = true
       }
       this._correctPartialSelfRefs(name, tf_imps)
@@ -1112,6 +1153,9 @@ export default class PocomathInstance {
       // ditch the signature:
       const badSigs = new Set()
       for (const sig in tf_imps) {
+         if (!tf_imps[sig].uses) {
+            throw new ReferenceError(`MONKEY WRENCH: ${name} ${sig}`)
+         }
          for (const type of typeListOfSignature(sig)) {
             if (this._maybeInstantiate(type) === undefined) {
                badSigs.add(sig)
@@ -1232,10 +1276,12 @@ export default class PocomathInstance {
          return behavior.does(innerRefs)
       }
       const tf_imps = this._TFimps[name]
-      this._addTFimplementation(tf_imps, signature, {uses, does: patch})
+      this._addTFimplementation(
+         name, tf_imps, signature, {uses, does: patch}, behavior, instanceType)
       tf_imps[signature]._pocoSignature = templateSignature
       tf_imps[signature]._pocoInstance = instanceType
       behavior.hasInstantiations[instanceType] = signature
+      behavior.needsInstantiations.add(instanceType) // once we have it, keep it
       return tf_imps[signature]
    }
 
@@ -1243,10 +1289,17 @@ export default class PocomathInstance {
     * to typed-function implementations and inserts the result into plain
     * object imps
     */
-   _addTFimplementation(imps, signature, behavior) {
+   _addTFimplementation(
-      const {uses, does} = behavior
+      name, imps, signature, specificBehavior, fromImp, asInstance)
+   {
+      if (!fromImp) fromImp = specificBehavior
+      const {uses, does} = specificBehavior
       if (uses.length === 0) {
          const implementation = does()
+         implementation.uses = uses
+         implementation.fromInstance = this
+         implementation.fromBehavior = fromImp
+         implementation.instance = asInstance
          // could do something with return type information here
          imps[signature] = implementation
          return
@@ -1274,18 +1327,25 @@ export default class PocomathInstance {
                 */
                if (needsig in imps && typeof imps[needsig] == 'function') {
                   refs[dep] = imps[needsig]
+                  continue
+               }
+               if (full_self_referential) {
+                  throw new SyntaxError(
+                     'typed-function does not support mixed full and '
+                        + 'partial self-reference')
+               }
+               const needTypes = typesOfSignature(needsig)
+               const mergedTypes = Object.assign(
+                  {}, this.Types, this.Templates)
+               if (subsetOfKeys(needTypes, mergedTypes)) {
+                  func = name // just resolve it in limbo
                } else {
-                  if (full_self_referential) {
+                  // uses an unknown type, so will get an undefined impl
-                     throw new SyntaxError(
+                  console.log(
-                        'typed-function does not support mixed full and '
+                     'WARNING: partial self-reference for', name, 'to',
-                           + 'partial self-reference')
+                     needsig, 'uses an unknown type')
-                  }
+                  refs[dep] = undefined
-                  const needTypes = typesOfSignature(needsig)
+                  continue
-                  const mergedTypes = Object.assign(
-                     {}, this.Types, this.Templates)
-                  if (subsetOfKeys(needTypes, mergedTypes)) {
-                     part_self_references.push(needsig)
-                  }
                }
             } else {
                if (part_self_references.length) {
@@ -1294,65 +1354,49 @@ export default class PocomathInstance {
                         + 'partial self-reference')
                }
                full_self_referential = true
-            }
+               continue
-         } else {
-            if (this[func] === 'limbo') {
-               /* We are in the midst of bundling func */
-               let fallback =  true
-               /* So the first thing we can do is try the tf_imps we are
-                * accumulating:
-                */
-               if (needsig) {
-                  let typedUniverse
-                  let tempTF
-                  if (Object.keys(this._TFimps[func]).length > 0) {
-                     typedUniverse = this._typed
-                     tempTF = typedUniverse('dummy_' + func, this._TFimps[func])
-                  } else {
-                     typedUniverse = this._metaTyped
-                     tempTF = typedUniverse(
-                        'dummy_' + func, this._metaTFimps[func])
-                  }
-                  let result = undefined
-                  try {
-                     result = typedUniverse.find(tempTF, needsig, {exact: true})
-                  } catch {}
-                  if (result) {
-                     refs[dep] = result
-                     fallback = false
-                  }
-               }
-               if (fallback) {
-                  /* Either we need the whole function or the signature
-                   * we need is not available yet, so we have to use
-                   * an indirect reference to func. And given that, there's
-                   * really no helpful way to extract a specific signature
-                   */
-                  const self = this
-                  const redirect = function () { // is this the most efficient?
-                     return self[func].apply(this, arguments)
-                  }
-                  Object.defineProperty(redirect, 'name', {value: func})
-                  Object.defineProperty(redirect, 'fromInstance', {value: this})
-                  refs[dep] = redirect
-               }
-            } else {
-               // can bundle up func, and grab its signature if need be
-               let destination = this[func]
-               if (destination && needsig) {
-                  destination = this.resolve(func, needsig)
-               }
-               if (!destination) {
-                  // Unresolved reference. This is allowed so that
-                  // you can bundle up just some portions of the library,
-                  // but let's warn.
-                  console.log(
-                     'WARNING: No definition found for dependency',
-                     dep, 'needed by a function with signature', signature)
-               }
-               refs[dep] = destination
             }
          }
+         if (this[func] === 'limbo') {
+            /* We are in the midst of bundling func (which may be ourself) */
+            /* So the first thing we can do is try the tf_imps we are
+             * accumulating:
+             */
+            if (needsig) {
+               const candidate = this.resolve(func, needsig)
+               if (typeof candidate === 'function') {
+                  refs[dep] = candidate
+                  continue
+               }
+            }
+            /* Either we need the whole function or the signature
+             * we need is not available yet, so we have to use
+             * an indirect reference to func. And given that, there's
+             * really no helpful way to extract a specific signature
+             */
+            const self = this
+            const redirect = function () { // is this the most efficient?
+               return self[func].apply(this, arguments)
+            }
+            Object.defineProperty(redirect, 'name', {value: func})
+            Object.defineProperty(redirect, 'fromInstance', {value: this})
+            refs[dep] = redirect
+            continue
+         }
+         // can bundle up func, and grab its signature if need be
+         let destination = this[func]
+         if (needsig) {
+            destination = this.resolve(func, needsig)
+         }
+         if (!destination) {
+            // Unresolved reference. This is allowed so that
+            // you can bundle up just some portions of the library,
+            // but let's warn.
+            console.log(
+               'WARNING: No definition found for dependency',
+               dep, 'needed by', name, '(', signature, ')')
+         }
+         refs[dep] = destination
       }
       if (full_self_referential) {
          imps[signature] = this._typed.referToSelf(self => {
@@ -1360,9 +1404,19 @@ export default class PocomathInstance {
             const implementation = does(refs)
             Object.defineProperty(implementation, 'name', {value: does.name})
             implementation.fromInstance = this
+            implementation.uses = uses
+            implementation.instance = asInstance
+            implementation.fromBehavior = fromImp
             // What are we going to do with the return type info in here?
             return implementation
          })
+         imps[signature].uses = uses
+         if (!uses) {
+            throw new ReferenceError(`NANH uses for ${signature} from ${fromImp}`)
+         }
+         imps[signature].fromInstance = this
+         imps[signature].instance = asInstance
+         imps[signature].fromBehavior = fromImp
          return
       }
       if (part_self_references.length) {
@@ -1377,13 +1431,19 @@ export default class PocomathInstance {
             deferred: true,
             builtRefs: refs,
             sigDoes: does,
+            sigUses: uses,
             fromInstance: this,
+            fromBehavior: fromImp,
+            instance: asInstance,
             psr: part_self_references
          }
          return
       }
       const implementation = does(refs)
       implementation.fromInstance = this
+      implementation.fromBehavior = fromImp
+      implementation.instance = asInstance
+      implementation.uses = uses
       // could do something with return type information here?
       imps[signature] = implementation
    }
@@ -1457,6 +1517,10 @@ export default class PocomathInstance {
                         refs[`self(${remaining_self_references[i]})`] = impls[i]
                      }
                      const implementation = does(refs)
+                     implementation.fromInstance = deferral.fromInstance
+                     implementation.fromBehavior = deferral.fromBehavior
+                     implementation.instance = deferral.instance
+                     implementation.uses = deferral.sigUses
                      // What will we do with the return type info in here?
                      return implementation
                   }
@@ -1467,6 +1531,9 @@ export default class PocomathInstance {
             imps[aSignature]._pocoSignature = deferral._pocoSignature
             imps[aSignature]._pocoInstance = deferral._pocoInstance
             imps[aSignature].fromInstance = deferral.fromInstance
+            imps[aSignature].fromBehavior = deferral.fromBehavior
+            imps[aSignature].instance = deferral.instance
+            imps[aSignature].uses = deferral.sigUses
          }
       }
    }
@@ -1576,7 +1643,8 @@ export default class PocomathInstance {
       return wantsType
    })
 
-   _findSubtypeImpl(name, imps, neededSig) {
+   _findSubtypeImpl(name, imps, neededSig, raw = false) {
+      const detemplate = !raw
       if (neededSig in imps) return neededSig
       let foundSig = false
       const typeList = typeListOfSignature(neededSig)
@@ -1589,16 +1657,16 @@ export default class PocomathInstance {
             let myType = typeList[k]
             let otherType = otherTypeList[k]
             if (otherType === theTemplateParam) {
-               otherTypeList[k] = paramBound
+               if (detemplate) otherTypeList[k] = paramBound
                otherType = paramBound
             }
             if (otherType === restTemplateParam) {
-               otherTypeList[k] = `...${paramBound}`
+               if (detemplate) otherTypeList[k] = `...${paramBound}`
                otherType = paramBound
             }
             const adjustedOtherType = otherType.replaceAll(templateCall, '')
             if (adjustedOtherType !== otherType) {
-               otherTypeList[k] = adjustedOtherType
+               if (detemplate) otherTypeList[k] = adjustedOtherType
                otherType = adjustedOtherType
             }
             if (myType.slice(0,3) === '...') myType = myType.slice(3)
@@ -1607,8 +1675,10 @@ export default class PocomathInstance {
             if (otherBound) {
                paramBound = otherBound[2]
                otherType = paramBound
-               otherTypeList[k] = otherBound[1].replaceAll(
+               if (detemplate) {
-                  theTemplateParam, paramBound)
+                  otherTypeList[k] = otherBound[1].replaceAll(
+                     theTemplateParam, paramBound)
+               }
             }
             if (otherType === 'any') continue
             if (otherType === UniversalType) continue
@@ -1619,7 +1689,7 @@ export default class PocomathInstance {
                if (this.instantiateTemplate(otherType, myType)) {
                   let dummy
                   dummy = this[name] // for side effects
-                  return this._findSubtypeImpl(name, this._imps[name], neededSig)
+                  return this._findSubtypeImpl(name, this._imps[name], neededSig, raw)
                }
             }
             if (!(otherType in this.Types)) {
@@ -1643,7 +1713,7 @@ export default class PocomathInstance {
          typedFunction = this[name]
       }
       const haveTF = this._typed.isTypedFunction(typedFunction)
-                     && !(typedFunction.isMeta)
+         && !(typedFunction.isMeta)
       if (haveTF) {
          // First try a direct match
          let result
@@ -1658,6 +1728,10 @@ export default class PocomathInstance {
               of typedFunction._typedFunctionData.signatureMap) {
             let allMatched = true
             const implTypes = typeListOfSignature(implSig)
+            if (implTypes.length > wantTypes.length) {
+               // Not enough arguments for that implementation
+               continue
+            }
             for (let i = 0; i < wantTypes.length; ++i) {
                const implIndex = Math.min(i, implTypes.length - 1)
                let implType = implTypes[implIndex]
@@ -1682,7 +1756,7 @@ export default class PocomathInstance {
          }
       }
       if (!(this._imps[name])) return undefined
-      const foundsig = this._findSubtypeImpl(name, this._imps[name], sig)
+      const foundsig = this._findSubtypeImpl(name, this._imps[name], sig, 'raw')
       if (foundsig) {
          if (haveTF) {
             try {
@@ -1690,19 +1764,74 @@ export default class PocomathInstance {
             } catch {
             }
          }
-         try {
+         const instantiationMatcher =
-            return this._metaTyped.findSignature(this._meta[name], foundsig)
+            '^'
-         } catch {
+            + substituteInSignature(foundsig, theTemplateParam, '(.*)')
+               .replaceAll(UniversalType, '(.*)')
+            + '$'
+         const instanceMatch = sig.match(instantiationMatcher)
+         let possibleInstantiator = false
+         if (instanceMatch) {
+            possibleInstantiator = instanceMatch[1]
+            for (let i = 2; i < instanceMatch.length; ++i) {
+               if (possibleInstantiator !== instanceMatch[i]) {
+                  possibleInstantiator = false
+                  break
+               }
+            }
+         }
+         if (possibleInstantiator) {
+            const behavior = this._imps[name][foundsig]
+            let newInstance
+            if (behavior) {
+               if (!(possibleInstantiator in behavior.hasInstantiations)) {
+                  newInstance = this._instantiateTemplateImplementation(
+                     name, foundsig, possibleInstantiator)
+               } else {
+                  // OK, so we actually have the instantiation. Let's get it
+                  newInstance = this._TFimps[name][sig]
+               }
+               // But we may not have taken advantage of conversions
+               this._invalidate(name)
+               const tryAgain = this[name]
+               let betterInstance
+               if (this._typed.isTypedFunction(tryAgain)) {
+                  betterInstance = this._typed.findSignature(tryAgain, sig)
+               }
+               if (betterInstance) {
+                  newInstance = betterInstance
+               } else {
+                  newInstance = {
+                     fn: newInstance,
+                     implementation: newInstance
+                  }
+               }
+               if (newInstance) return newInstance
+            }
+         }
+         const catchallSig = this._findSubtypeImpl(name, this._imps[name], sig)
+         if (catchallSig !== foundsig) {
+            try {
+               return this._metaTyped.findSignature(
+                  this._meta[name], catchallSig)
+            } catch {
+            }
          }
          // We have an implementation but not a typed function. Do the best
          // we can:
-         const foundImpl = this._imps[name][foundsig]
+         const restoredSig = foundsig.replaceAll('ground', theTemplateParam)
+         const foundImpl = this._imps[name][restoredSig]
          const needs = {}
          for (const dep of foundImpl.uses) {
-            const [base, sig] = dep.split('()')
+            const [base, sig] = dep.split(/[()]/)
-            needs[dep] = this.resolve(base, sig)
+            if (sig) {
+               needs[dep] = this.resolve(base, sig)
+            } else {
+               needs[dep] = this[dep]
+            }
          }
          const pseudoImpl = foundImpl.does(needs)
+         pseudoImpl.fromInstance = this
          return {fn: pseudoImpl, implementation: pseudoImpl}
       }
       // Hmm, no luck. Make sure bundle is up-to-date and retry:

src/core/extractors.mjs

@@ -6,7 +6,7 @@ export function dependencyExtractor(destinationSet) {
    return new Proxy({}, {
       get: (target, property) => {
          destinationSet.add(property)
-         return {}
+         return {checkingDependency: true}
       }
    })
 }

src/number/add.mjs

@@ -4,5 +4,5 @@ export * from './Types/number.mjs'
 export const add = {
     // Note the below assumes that all subtypes of number that will be defined
     // are closed under addition!
-    'T:number, T': ({T}) => Returns(T, (m,n) => m+n)
+    'T:number,T': ({T}) => Returns(T, (m,n) => m+n)
 }

test/complex/_polynomialRoot.mjs

@@ -0,0 +1,34 @@
+import assert from 'assert'
+import math from '../../src/pocomath.mjs'
+
+describe('polynomialRoot', () => {
+   it('should solve a linear equation with real coefficients', function () {
+      assert.deepEqual(math.polynomialRoot(6, 3), math.tuple(-2))
+      assert.deepEqual(
+         math.polynomialRoot(math.complex(-3, 2), 2),
+         math.tuple(math.complex(1.5, -1)))
+      assert.deepEqual(
+         math.polynomialRoot(math.complex(3, 1), math.complex(-1, -1)),
+         math.tuple(math.complex(2, -1)))
+   })
+   // Should be safe now to capture the functions:
+   const complex = math.complex
+   const pRoot = math.polynomialRoot
+   const tup = math.tuple
+   it('should solve a quadratic equation with a double root', function () {
+      assert.deepEqual(pRoot(4, 4, 1), tup(-2))
+      assert.deepEqual(
+         pRoot(complex(0, 2), complex(2, 2), 1), tup(complex(-1, -1)))
+   })
+   it('should solve a quadratic with two distinct roots', function () {
+      assert.deepEqual(pRoot(-3, 2, 1), tup(1, -3))
+      assert.deepEqual(pRoot(-2, 0, 1), tup(math.sqrt(2), -math.sqrt(2)))
+      assert.deepEqual(
+         pRoot(4, 2, 1),
+         tup(complex(-1, math.sqrt(3)), complex(-1, -math.sqrt(3))))
+      assert.deepEqual(
+         pRoot(complex(3, 1), -3, 1), tup(complex(1, 1), complex(2, -1)))
+   })
+
+
+})