322 lines
12 KiB
TypeScript
322 lines
12 KiB
TypeScript
import {inspect} from 'node:util'
|
|
import type {AnyFunc, CommonSignature, GenSigs} from '@/interfaces/type'
|
|
|
|
// A base type that roughly describes the dependencies of a single factory
|
|
// for implementations of one operation. It is an object whose keys are the
|
|
// identifiers are dependencies, and whose values describe that dependency.
|
|
// In the value for a given key, the 'is' property gives the name of the
|
|
// operation that dependency should be an instance of, defaulting to the key
|
|
// itself when not present, and the 'sig' property gives the desired
|
|
// signature for that operation. When the 'sig' property is not present,
|
|
// the signature will default to some ambient ensemble of signatures.
|
|
export type RawDependencies = Record<string, {is?: string, sig?: AnyFunc}>
|
|
|
|
// The following type transform fills in any unspecified signatures in RD
|
|
// with the corresponding signatures from SomeSigs:
|
|
type PatchedDepSpec<RD extends RawDependencies, SomeSigs extends GenSigs> = {
|
|
[K in keyof RD]: RD[K] extends {sig: AnyFunc}
|
|
? RD[K]
|
|
: K extends keyof SomeSigs ? (RD[K] & {sig: SomeSigs[K]}) : RD[K]
|
|
}
|
|
|
|
// A factory for building dependency specifications from the ensemble of
|
|
// common signatures for a specific type (and perhaps auxiliary type). This
|
|
// is typically used when describing implementation factories for one type
|
|
// that depend on the common signatures for a *different* type.
|
|
export function commonSpecs<
|
|
T,
|
|
Aux = T,
|
|
CommonSigs extends GenSigs = CommonSignature<T, Aux>
|
|
>() {
|
|
return <RD extends RawDependencies>(
|
|
rd: RD
|
|
): PatchedDepSpec<RD, CommonSigs> => Object.fromEntries(
|
|
Object.keys(rd).map(k => [
|
|
k, 'sig' in rd[k] ? rd[k]
|
|
: {...rd[k], sig: (() => undefined)}
|
|
])
|
|
) as PatchedDepSpec<RD, CommonSigs>
|
|
}
|
|
|
|
// Further constraint on a dependency specification that means it is ready
|
|
// to use with a given set of signatures:
|
|
type DepSpec<Signatures extends GenSigs, Needs extends string>
|
|
= {
|
|
[K in Needs]: K extends keyof Signatures
|
|
? {sig?: AnyFunc}
|
|
: {is: keyof Signatures, sig: AnyFunc}
|
|
}
|
|
|
|
// Just checks if an RawDependencies is really a DepSpec, and blanks it out if not
|
|
type DepCheck<
|
|
RD extends RawDependencies,
|
|
Signatures extends GenSigs,
|
|
Needs extends string = keyof RD & string
|
|
> = RD extends DepSpec<Signatures, Needs> ? RD
|
|
: {
|
|
[K in Needs]: K extends keyof Signatures ? {}
|
|
: {is: never, sig: (q: boolean) => void}
|
|
}
|
|
|
|
// The actual type of a dependency, given a dependency specification
|
|
type DepType<
|
|
Signatures extends GenSigs,
|
|
DS extends DepSpec<Signatures, (keyof DS & string)>
|
|
> = {[K in keyof DS]: DS[K] extends {sig: AnyFunc}
|
|
? DS[K]['sig']
|
|
: K extends keyof Signatures ? Signatures[K] : never
|
|
}
|
|
|
|
// A collection of dependency specifications for some of the operations in
|
|
// an ensemble of Signatures:
|
|
type Specifications<
|
|
Signatures extends GenSigs,
|
|
NeedKeys extends keyof Signatures & string,
|
|
NeedList extends Record<NeedKeys, string>
|
|
> = {[K in NeedKeys]: DepSpec<Signatures, NeedList[K]>}
|
|
|
|
// The type of a factory function for implementations of a dependent operation,
|
|
// given a dependency specification:
|
|
type FactoryType<
|
|
Signatures extends GenSigs,
|
|
K extends (keyof Signatures) & string,
|
|
DS extends DepSpec<Signatures, (keyof DS & string)>
|
|
> = (dep: DepType<Signatures, DS>) => Signatures[K]
|
|
|
|
// The type of an implementation specification for an operation given its
|
|
// dependency specification: either directly the implementation if there
|
|
// are actually no dependencies, or a factory function and collection of
|
|
// dependency names otherwise:
|
|
type ImpType<
|
|
Signatures extends GenSigs,
|
|
K extends (keyof Signatures) & string,
|
|
DS extends DepSpec<Signatures, (keyof DS & string)>
|
|
> = DS extends null ? {implementation: Signatures[K]}
|
|
: {factory: FactoryType<Signatures, K, DS>, dependencies: DS}
|
|
|
|
// A collection of implementations for some operations of an ensemble of
|
|
// Signatures, matching a given collection of dependency specifications
|
|
type Implementations<
|
|
Signatures extends GenSigs,
|
|
NeedKeys extends keyof Signatures & string,
|
|
NeedList extends Record<NeedKeys, string>,
|
|
Specs extends Specifications<Signatures, NeedKeys, NeedList>
|
|
> = {[K in NeedKeys]: ImpType<Signatures, K, Specs[K]>}
|
|
|
|
// The builder interface that lets us assemble narrowly-typed Implementations:
|
|
interface ImplementationBuilder<
|
|
Signatures extends GenSigs,
|
|
NeedKeys extends keyof Signatures & string,
|
|
NeedList extends Record<NeedKeys, string>,
|
|
Specs extends Specifications<Signatures, NeedKeys, NeedList>
|
|
> {
|
|
independent<NewKeys extends (keyof Signatures) & string>(
|
|
independentImps: {[K in NewKeys]: Signatures[K]}
|
|
): ImplementationBuilder<
|
|
Signatures,
|
|
NeedKeys | NewKeys,
|
|
NeedList & {[K in NewKeys]: never},
|
|
Specs & {[K in NewKeys]: null}
|
|
>
|
|
|
|
dependent<
|
|
RD extends RawDependencies, // Easier to infer
|
|
NewKeys extends (keyof Signatures) & string,
|
|
DepKeys extends string = keyof RD & string
|
|
>(
|
|
depSpec: RD,
|
|
imps: {
|
|
[K in NewKeys]:
|
|
FactoryType<Signatures, K, DepCheck<RD, Signatures>>
|
|
}
|
|
): ImplementationBuilder<
|
|
Signatures,
|
|
NeedKeys | NewKeys,
|
|
NeedList & {[K in NewKeys]: DepKeys},
|
|
Specs & {[K in NewKeys]: DepCheck<RD, Signatures>}
|
|
>
|
|
|
|
done(): Implementations<Signatures, NeedKeys, NeedList, Specs>
|
|
}
|
|
|
|
// And a function that actually provides the builder interface:
|
|
function impBuilder<
|
|
Signatures extends GenSigs,
|
|
NeedKeys extends keyof Signatures & string,
|
|
NeedList extends Record<NeedKeys, string>,
|
|
Specs extends Specifications<Signatures, NeedKeys, NeedList>
|
|
>(
|
|
sofar: Implementations<Signatures, NeedKeys, NeedList, Specs>
|
|
): ImplementationBuilder<Signatures, NeedKeys, NeedList, Specs> {
|
|
return {
|
|
independent<NewKeys extends (keyof Signatures) & string>(
|
|
imps: {[K in NewKeys]: Signatures[K]}) {
|
|
return impBuilder({
|
|
...sofar,
|
|
...Object.fromEntries(Object.keys(imps).map(k => [k, {
|
|
implementation: imps[k]
|
|
}]))
|
|
} as Implementations<
|
|
Signatures,
|
|
NeedKeys | NewKeys,
|
|
NeedList & {[K in NewKeys]: never},
|
|
Specs & {[K in NewKeys]: null}
|
|
>)
|
|
},
|
|
|
|
dependent<
|
|
RD extends RawDependencies,
|
|
NewKeys extends (keyof Signatures) & string,
|
|
DepKeys extends string = keyof RD & string
|
|
>(
|
|
depSpec: RD,
|
|
imps: {
|
|
[K in NewKeys]:
|
|
FactoryType<Signatures, K, DepCheck<RD, Signatures, DepKeys>>
|
|
}
|
|
) {
|
|
return impBuilder({
|
|
...sofar,
|
|
...Object.fromEntries(Object.keys(imps).map(k => [k, {
|
|
factory: imps[k],
|
|
dependencies: depSpec
|
|
}]))
|
|
}) as unknown as ImplementationBuilder<
|
|
Signatures,
|
|
NeedKeys | NewKeys,
|
|
NeedList & {[K in NewKeys]: DepKeys},
|
|
Specs & {[K in NewKeys]: DepCheck<RD, Signatures, DepKeys>}
|
|
>
|
|
},
|
|
done() {
|
|
return sofar
|
|
}
|
|
}
|
|
}
|
|
|
|
// A convenience function that gives you an implementation builder:
|
|
export function implementations<Signatures extends GenSigs>(
|
|
): ImplementationBuilder<Signatures, never, {}, {}> {
|
|
return impBuilder({})
|
|
}
|
|
|
|
// Now we turn to creating a Dispatcher itself. For this we use loose types,
|
|
// and rely on the type annotations from our special build for runtime type
|
|
// identification.
|
|
|
|
type Callable = (...args: any) => any
|
|
type Implementation = {implementation: Callable}
|
|
type Factory = {factory: Callable, dependencies: Record<string, any>}
|
|
type Reflected = {_reflectedType5: any}
|
|
type TypeSpec = {
|
|
name: string,
|
|
before?: string[],
|
|
test: Callable,
|
|
from: Record<string, Callable>,
|
|
infer?: Callable
|
|
}
|
|
type ImpItem = Implementation | Factory
|
|
type ImpGroup = Record<string, ImpItem>
|
|
|
|
// When this is being compiled, TypeScript can't tell that the
|
|
// ImpSpecification entities will have been reflected:
|
|
type ImpSpecification = (ImpGroup | (() => ImpGroup) | TypeSpec) // & Reflected
|
|
|
|
interface ImpSpecs extends Record<string, ImpSpecification | ImpSpecs> {}
|
|
|
|
type ImpHolder = {
|
|
implementations: Record<string, Callable>, // Key is a signature
|
|
factories: Record<string, Factory>
|
|
}
|
|
|
|
type DispatcherInstance = {
|
|
implementationData: Record<string, ImpHolder>, // Key is an operation name
|
|
types: TypeSpec[], // Order is order to try types in
|
|
behaviors: Record<string, Callable>, // Key is opname; actually executable!
|
|
}
|
|
|
|
function newDispatcherInstance(): DispatcherInstance {
|
|
return {
|
|
implementationData: {},
|
|
types: [],
|
|
behaviors: {}
|
|
}
|
|
}
|
|
|
|
function isTypeSpec(spec: ImpSpecification | ImpSpecs): spec is TypeSpec {
|
|
if ('name' in spec
|
|
&& typeof spec.name === 'string'
|
|
&& 'test' in spec
|
|
&& 'from' in spec
|
|
) {
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// The assemble function creates a dispatcher from a mess of specifications
|
|
export function assemble(specifications: ImpSpecs, into?: DispatcherInstance ) {
|
|
if (into === undefined) {
|
|
into = newDispatcherInstance()
|
|
const show = inspect(specifications, {depth: 18, colors: true})
|
|
console.log('Specifications are', show)
|
|
}
|
|
for (const specName in specifications) {
|
|
console.log('Processing', specName)
|
|
const spec = specifications[specName]
|
|
if ('_reflectedType5' in spec) {
|
|
if (isTypeSpec(spec)) {
|
|
registerTypeSpec(spec, into)
|
|
continue
|
|
}
|
|
// implementations that we need to deal with
|
|
console.log('Need to incorporate', Object.keys(spec))
|
|
} else {
|
|
// Just another layer of specification
|
|
assemble(spec as ImpSpecs, into)
|
|
}
|
|
}
|
|
into.behaviors.typeOf = (a: unknown) => whichType(a, into.types)
|
|
return into.behaviors
|
|
}
|
|
|
|
function registerTypeSpec(typeSpec: TypeSpec, into: DispatcherInstance) {
|
|
let position = into.types.length
|
|
if ('before' in typeSpec) {
|
|
for (const typeName of typeSpec.before) {
|
|
const typeIndex = into.types.findIndex(t => t.name = typeName)
|
|
if (typeIndex >= 0 && typeIndex < position) position = typeIndex
|
|
}
|
|
}
|
|
into.types.splice(position, 0, typeSpec)
|
|
// likely there will be more to do in the long run
|
|
}
|
|
|
|
// Returns the string name of the type of _a_ per the type specifications
|
|
// in _types_, or 'unknown' if no type matches
|
|
function whichType(a: unknown, types: TypeSpec[]) {
|
|
for (const typeSpec of types) {
|
|
const typeName = typeSpec.name
|
|
// First check if this is a ground type or a generic:
|
|
const typeSpecType = (typeSpec as TypeSpec & Reflected)._reflectedType5
|
|
if (!('_typeParameters' in typeSpecType.test)) {
|
|
// ground type, just test it
|
|
if (typeSpec.test(a)) return typeName
|
|
continue
|
|
}
|
|
// Generic type. In this case, the test will be a factory, dependent
|
|
// on a test for each of the type parameters. So assemble those
|
|
// dependencies:
|
|
const typePars = typeSpecType.test._typeParameters
|
|
const permissiveTests = Object.fromEntries(typePars.map(k =>
|
|
[`test${k}`, x => true]))
|
|
const testAllUnknown = typeSpec.test(permissiveTests)
|
|
if (!testAllUnknown(a)) continue
|
|
// Here, a seems to be in some instantiation of this generic type.
|
|
// Need to infer which instantiation
|
|
const thisInfer = typeSpec.infer({typeOf: x => whichType(x, types)})
|
|
const typeArguments = thisInfer(a)
|
|
return `${typeName}<${typePars.map(k => typeArguments[k]).join(',')}>`
|
|
}
|
|
return 'unknown'
|
|
}
|