refactor: Demonstrate macro generating a generic implementations interface

I swapped in the new macro in source files numbers/predicate.ts,
  Complex/arithmetic.ts, and Complex/predicate.ts. Note that you have
  to specify whether you are reflecting the generic or concrete
  implementations, which in some cases will mean two separate macro calls
  (as in Complex/predicate.ts).

  Also tried out the $$typeMetadata macro in Complex/all.ts; you can see the
  result by building and looking at build/Complex/all.js. It splits things
  up somewhat but we would still need to do a bunch of parsing, so probably
  not worth switching.

src/Complex/all.ts

@@ -1,6 +1,9 @@
 import * as Complex from './native.js'
 import * as complex from './arithmetic.js'
+import {$$typeMetadata} from 'ts-macros'
 
 export { complex }
 
 export {Complex}
+
+const tryit = $$typeMetadata!<typeof complex>(true, true)

src/Complex/arithmetic.ts

@@ -2,7 +2,7 @@ import {Complex} from './type.js'
 import type {
    Dependencies, Signature, Returns, RealType, AliasOf
 } from '../interfaces/type.js'
-import {$reflect} from '../interfaces/type.js'
+import {$reflectGen, GENERIC} from '../interfaces/type.js'
 
 declare module "../interfaces/type" {
    interface Signatures<T> {
@@ -98,7 +98,11 @@ export const sqrt =
       return dep.divideReal(num, denom)
    }
 
-$reflect!([
+export interface GenericImplementations<T> {
+   kilroy: "was here"
+}
+
+$reflectGen!(GENERIC, [
    add, addReal, unaryMinus, conj, subtract, multiply, absquare, divideReal,
    reciprocal, divide, sqrt
 ])

src/Complex/predicate.ts

@@ -1,6 +1,6 @@
 import {Complex} from './type.js'
 import type {Dependencies, Signature} from '../interfaces/type.js'
-import {$reflect} from '../interfaces/type.js'
+import {$reflectGen, GENERIC, CONCRETE} from '../interfaces/type.js'
 
 export const isReal =
    <T>(dep: Dependencies<'add' | 'equal' | 'isReal', T>):
@@ -10,4 +10,5 @@ export const isReal =
 export const isSquare = (): Signature<'isSquare', Complex<unknown>> =>
    z => true // FIXME: not correct for Complex<bigint> once we get there
 
-$reflect!([isReal, isSquare])
+$reflectGen!(GENERIC, [isReal])
+$reflectGen!(CONCRETE, [isSquare])

src/core/Dispatcher.ts

@@ -6,6 +6,7 @@
  */
 
 import {parseReflectedType, ImplementationDef} from './parseReflectedType.js'
+import type {ValueIntersectionByKeyUnion} from '../interfaces/type.js'
 
 // First helper types and functions for the Dispatcher
 
@@ -35,50 +36,103 @@ type TypeSpecification = {
    infer?: (d: DependenciesType) => (z: unknown) => TypeName
 }
 
-type SpecObject = Record<string, Function | TypeSpecification>
+type Callable = (...args: any) => any
+type SpecObject = Record<string, Callable | TypeSpecification>
 type SpecificationsGroup = Record<string, SpecObject>
 
-export class Dispatcher {
+// Find all of the keys of an object that are functions but not aliases
-   installSpecification(
+// to another operation
-      name: string,
+type BaseOperations<Obj extends SpecObject> =
-      defn: ImplementationDef,
+   {[K in keyof Obj]:
-      behavior: Function // possible todo: constrain this type based
+    Obj[K] extends Callable
-      // on the signature, return type, and dependencies. Not sure if
+       ? ReturnType<Obj[K]>['aliasOf'] extends (string | undefined)
-      // that's really possible, though.
+          ? never
-   ) {
+          : K extends string ? K : never
-      console.log('Pretending to install', name, 'with signatures')
+       : never
-      for (const signature of defn.fn.signatures) {
+   }[keyof Obj]
-         console.log('   ', signature.args, '=>', signature.returns)
+// Gather all of the operations specified in a SpecificationsGroup
-      }
+type DispatcherOperations<G extends SpecificationsGroup> =
-      if (defn.fn.aliasOf) {
+   {[K in keyof G]: BaseOperations<G[K]>}[keyof G]
-         console.log('   As an alias of', defn.fn.aliasOf)
+// Get the type of a given operation in a SpecObject:
-      }
+type BaseOperationSignature<
-      //TODO: implement me
+   Obj extends SpecObject,
-   }
+   Name extends BaseOperations<Obj>
-   installType(name: TypeName, typespec: TypeSpecification) {
+> = ValueIntersectionByKeyUnion<
-      console.log('Pretending to install type', name, typespec)
+   {[K in keyof Obj]:
-      //TODO: implement me
+    Obj[K] extends Callable
-   }
+       ? K extends Name
-   constructor(collection: SpecificationsGroup) {
+         ? ReturnType<Obj[K]>
-      const implementations = []
+         : ReturnType<Obj[K]>['aliasOf'] extends (Name | undefined)
-      for (const key in collection) {
+             ? ReturnType<Obj[K]> : unknown
-         console.log('Working on', key)
+       : unknown
-         for (const identifier in collection[key]) {
+   },
-            const item = collection[key][identifier]
+   keyof Obj>
-            if (typeof item === 'function') {
+// Get the type of a given operation in a SpecificationsGroup
-               implementations.push([key, identifier, item])
+type OperationSignature<
-            } else {
+   G extends SpecificationsGroup,
-               console.log('Handling type', key, ':', identifier)
+   Name extends DispatcherOperations<G>
-               this.installType(
+> = ValueIntersectionByKeyUnion<
-                  item.name, collection[key][identifier] as TypeSpecification)
+   {[K in keyof G]:
-            }
+    Name extends BaseOperations<G[K]>
+       ? BaseOperationSignature<G[K], Name>
+       : unknown},
+   keyof G>
+// Put it all together into the typing of the dispatcher
+type DispatcherInterface<G extends SpecificationsGroup> =
+   {[Op in DispatcherOperations<G>]: OperationSignature<G, Op>}
+
+export function createDispatcher<G extends SpecificationsGroup>(
+   collection: G): DispatcherInterface<G>
+{
+   const implementations = []
+   const types = {} // who knows what the type of this will be
+   const behaviors = {} // ditto
+   for (const key in collection) {
+      console.log('Working on', key)
+      for (const identifier in collection[key]) {
+         const item = collection[key][identifier]
+         if (typeof item === 'function') {
+            implementations.push([key, identifier, item])
+         } else {
+            console.log('Handling type', key, ':', identifier)
+            installType( // In this design, installType would modify
+               // types by side effect; maybe Jos prefers some other
+               // factoring of this?
+               types, item.name,
+               collection[key][identifier] as TypeSpecification)
          }
       }
-      for (const trio of implementations) {
-         const [k, id, imp] = trio
-         console.log('Handling implementation', id, 'from', k)
-         this.installSpecification(
-            id, parseReflectedType(id, imp.reflectedType), imp)
-      }
    }
+   for (const trio of implementations) {
+      const [k, id, imp] = trio
+      console.log('Handling implementation', id, 'from', k)
+      installSpecification(
+         behaviors, id, parseReflectedType(id, imp.reflectedType), imp)
+   }
+   return {} as DispatcherInterface<G>
+}
+
+function installType(
+   types: Object, name: TypeName, typespec: TypeSpecification)
+{
+   console.log('Pretending to install type', name, typespec)
+   //TODO: implement me
+}
+
+function installSpecification(
+   behaviors: Object, // Same issue as mentioned above with side effects...
+   name: string,
+   defn: ImplementationDef,
+   specification: Function // possible todo: constrain this type based
+   // on the signature, return type, and dependencies. Not sure if
+   // that's really possible, though.
+) {
+   console.log('Pretending to install', name, 'with signatures')
+   for (const signature of defn.fn.signatures) {
+      console.log('   ', signature.args, '=>', signature.returns)
+   }
+   if (defn.fn.aliasOf) {
+      console.log('   As an alias of', defn.fn.aliasOf)
+   }
+   //TODO: implement me
 }

src/index.ts

@@ -1,8 +1,12 @@
 import {inspect} from 'node:util'
-import {Dispatcher} from './core/Dispatcher.js'
+import {createDispatcher} from './core/Dispatcher.js'
 import * as Specifications from './all.js'
 
-export default new Dispatcher(Specifications)
+export Specifications
+const math = createDispatcher(Specifications)
+export default math
+
+console.log('Made', math.add}
 
 import {Complex} from './Complex/type.js'
 import {absquare as absquare_complex} from './Complex/arithmetic.js'

src/interfaces/type.ts

@@ -15,7 +15,7 @@ import {$$typeToString} from 'ts-macros'
  * but that's OK, the generic parameter doesn't hurt in those cases.
  ****/
 
-type ValueIntersectionByKeyUnion<T,  TKey extends keyof T> = {
+export type ValueIntersectionByKeyUnion<T,  TKey extends keyof T> = {
   [P in TKey]: (k: T[P])=>void
 } [TKey] extends ((k: infer I)=>void) ? I : never
 
@@ -77,7 +77,7 @@ type SignatureKey<T> = keyof Signatures<T>
 export type Signature<Name extends SignatureKey<T>, T> = Signatures<T>[Name]
 export type Returns<Name extends SignatureKey<T>, T> =
    ReturnType<Signatures<T>[Name]>
-type Deps<T> =  T extends unknown ? { [K in keyof T]: T[K] } : never;
+export type Deps<T> =  T extends unknown ? { [K in keyof T]: T[K] } : never;
 export type Dependencies<Name extends SignatureKey<T>, T> =
    Deps<{[K in Name]: Signature<K, T>}>
 
@@ -88,3 +88,34 @@ export function $reflect<ImplTuple>(tup: ImplTuple) {
    +[[tup], <T>(elt: T) =>
      elt.reflectedType = $$typeToString!<T>(true, false, true)]
 }
+export function $genImps<ImplTuple>(tup: ImplTuple) {
+   +[[tup], <U>(elt: U) => {
+      export interface GenericImplementations<T> {
+         [$$text!(elt)]: typeof elt
+      }
+   }]
+}
+
+export function $genImpsT<ImplTuple>(tup: ImplTuple) {
+   +[[tup], <U>(elt: U) => {
+      export interface GenericImplementations<T> {
+         [$$text!(elt)]: typeof elt<T>
+      }
+   }]
+}
+export const GENERIC = true
+export const CONCRETE = false
+export function $reflectGen<ImplTuple>(generic: boolean, tup: ImplTuple) {
+   +[[tup], <T>(elt: T) => {
+      elt.reflectedType = $$typeToString!<T>(true, false, true)
+      if (generic) {
+         export interface GenericImplementations<T> {
+            [$$text!(elt)]: typeof elt<T>
+         }
+      } else {
+         export interface GenericImplementations<T> {
+            [$$text!(elt)]: typeof elt
+         }
+      }
+   }]
+}

src/numbers/native.ts

@@ -1,4 +1,9 @@
+import {GenericImplementations} from './predicate.js'
+import {$$typeToString} from 'ts-macros'
 export * from './type.js'
 export * from './arithmetic.js'
 export * from './predicate.js'
 export * from './relational.js'
+
+const test: ReturnType<GenericImplementations<unknown>['isReal']> =
+   (a: number) => true // = "oops" would fail as desired.

src/numbers/predicate.ts

@@ -1,7 +1,11 @@
 import type {Signature} from '../interfaces/type.js'
-import {$reflect} from '../interfaces/type.js'
+import {$reflectGen, CONCRETE} from '../interfaces/type.js'
-
+import {$$typeToString} from 'ts-macros'
 export const isReal =   (): Signature<'isReal',   number> => (a) => true
 export const isSquare = (): Signature<'isSquare', number> => (a) => a >= 0
 
-$reflect!([isReal, isSquare])
+export interface GenericImplementations<T> {
+   kilroy: "was here"
+}
+
+$reflectGen!(CONCRETE, [isReal, isSquare])

tsconfig.json

@@ -4,6 +4,7 @@
         "rootDir": "./src",
         "outDir": "./build",
         "moduleResolution": "nodenext",
+        "declaration": true,
         "plugins": [ {
             "transform": "ts-macros/dist/type-resolve",
             "transformProgram": true