88 lines
3.4 KiB
TypeScript
88 lines
3.4 KiB
TypeScript
import {
|
|
joinTypes, typeOfDependency, Dependency, BBinary, ImpType, ImpReturns
|
|
} from '../core/Dispatcher.js'
|
|
|
|
export type Complex<T> = {re: T; im: T;}
|
|
|
|
export type UnderlyingReal<T> =
|
|
T extends Complex<infer U> ? UnderlyingReal<U> : T
|
|
|
|
export const Complex_type = {
|
|
test: <T>(dep: {testT: (z: unknown) => z is T}) =>
|
|
(z: unknown): z is Complex<T> =>
|
|
typeof z === 'object' && 're' in z && 'im' in z
|
|
&& dep.testT(z.re) && dep.testT(z.im),
|
|
infer: (dep: typeOfDependency) =>
|
|
(z: Complex<unknown>) => joinTypes(dep.typeOf(z.re), dep.typeOf(z.im)),
|
|
from: {
|
|
T: <T>(dep: Dependency<'zero', [T]>) => (t: T) =>
|
|
({re: t, im: dep.zero(t)}),
|
|
Complex: <U,T>(dep: {convert: (from: U) => T}) =>
|
|
(z: Complex<U>) => ({re: dep.convert(z.re), im: dep.convert(z.im)})
|
|
}
|
|
}
|
|
|
|
export interface ComplexReturn<Params> {
|
|
// Sadly, I can't think of a way to make some nice abbreviation operators
|
|
// for these generic type specifications because TypeScript generics
|
|
// can't take and use generic parameters, only fully instantiated types.
|
|
complex: Params extends [infer U] ? Complex<U> // unary case
|
|
: Params extends BBinary<infer B> ? Complex<B> // binary case
|
|
: never
|
|
|
|
// alternatively if it seems better; each definition is simpler, but at
|
|
// the cost of having two keys here:
|
|
// complex_unary: Params extends [infer R] ? Complex<R> : never
|
|
// complex_binary: Params extends BBinary<infer R> ? Complex<R> : never
|
|
|
|
// There is actually a subtlety here that complex_unary really only works
|
|
// on real types that include their own zero value, so it should really be
|
|
// complex_unary: Params extends [infer R]
|
|
// ? ImpReturns<'zero', [R]> extends R ? Complex<R> : never
|
|
// : never
|
|
// and that might actually simplify some of the typings of other operations,
|
|
// but we'll leave such fine tuning til later, if we adopt this scheme
|
|
|
|
zero: Params extends [infer Z] // unary
|
|
? Z extends Complex<infer T> // of a Complex parameter
|
|
? ImpReturns<'zero', T> extends T ? Z : never // that has its real 0
|
|
: never
|
|
: never
|
|
one: Params extends [infer Z] // unary
|
|
? Z extends Complex<infer T> // of a Complex parameter
|
|
? ImpReturns<'one'|'zero', T> extends T ? Z : never // has real 1, 0
|
|
: never
|
|
: never
|
|
nan: Params extends [infer Z] // unary
|
|
? Z extends Complex<infer T> // of a Complex parameter
|
|
? ImpReturns<'nan', T> extends T ? Z : never // has real NaN
|
|
: never
|
|
: never
|
|
re: Params extends [infer Z]
|
|
? Z extends Complex<infer T> ? UnderlyingReal<T> : never
|
|
: never
|
|
}
|
|
|
|
export const complex_unary =
|
|
<T>(dep: Dependency<'zero', [T]>): ImpType<'complex', [T]> =>
|
|
t => ({re: t, im: dep.zero(t)})
|
|
export const complex_binary = <T>(t: T, u: T): ImpReturns<'complex', [T,T]> =>
|
|
({re: t, im: u})
|
|
|
|
export const zero =
|
|
<T>(dep: Dependency<'zero', [T]>): ImpType<'zero', [Complex<T>]> =>
|
|
z => complex_binary(dep.zero(z.re), dep.zero(z.im))
|
|
|
|
export const one =
|
|
<T>(dep: Dependency<'zero' | 'one', [T]>): ImpType<'one', [Complex<T>]> =>
|
|
z => // Must provide parameter T, else TS narrows to return type of dep.one
|
|
complex_binary<T>(dep.one(z.re), dep.zero(z.im))
|
|
|
|
export const nan =
|
|
<T>(dep: Dependency<'nan', [T]>): ImpType<'nan', [Complex<T>]> =>
|
|
z => complex_binary(dep.nan(z.re), dep.nan(z.im))
|
|
|
|
export const re =
|
|
<T>(dep: Dependency<'re', [T]>): ImpType<'re', [Complex<T>]> =>
|
|
z => dep.re(z.re)
|