89 lines
3.6 KiB
TypeScript
89 lines
3.6 KiB
TypeScript
import { is } from "./is";
|
|
import { DefaultPointer, Value } from "./values";
|
|
|
|
export type Tuple<T> = Array<T> | [T];
|
|
|
|
export type Record<LabelType extends Value<T>, FieldsType extends Tuple<Value<T>>, T extends object = DefaultPointer>
|
|
= FieldsType & { label: LabelType };
|
|
|
|
export type RecordGetters<Fs, R> = {
|
|
[K in string & keyof Fs]: (r: R) => Fs[K];
|
|
};
|
|
|
|
export type CtorTypes<Fs, Names extends Tuple<keyof Fs>> =
|
|
{ [K in keyof Names]: Fs[keyof Fs & Names[K]] } & any[];
|
|
|
|
export interface RecordConstructor<L extends Value<T>, Fs, Names extends Tuple<keyof Fs>, T extends object = DefaultPointer> {
|
|
(...fields: CtorTypes<Fs, Names>): Record<L, CtorTypes<Fs, Names>, T>;
|
|
constructorInfo: RecordConstructorInfo<L, T>;
|
|
isClassOf(v: any): v is Record<L, CtorTypes<Fs, Names>, T>;
|
|
_: RecordGetters<Fs, Record<L, CtorTypes<Fs, Names>, T>>;
|
|
};
|
|
|
|
export interface RecordConstructorInfo<L extends Value<T>, T extends object = DefaultPointer> {
|
|
label: L;
|
|
arity: number;
|
|
}
|
|
|
|
export function Record<L extends Value<T>, FieldsType extends Tuple<Value<T>>, T extends object = DefaultPointer>(
|
|
label: L, fields: FieldsType): Record<L, FieldsType, T>
|
|
{
|
|
(fields as any).label = label;
|
|
return fields as Record<L, FieldsType, T>;
|
|
}
|
|
|
|
export namespace Record {
|
|
export function isRecord<L extends Value<T>, FieldsType extends Tuple<Value<T>>, T extends object = DefaultPointer>(x: any): x is Record<L, FieldsType, T> {
|
|
return Array.isArray(x) && 'label' in x;
|
|
}
|
|
|
|
export function fallbackToString (_f: Value<any>): string {
|
|
return '<unprintable_preserves_field_value>';
|
|
}
|
|
|
|
export function constructorInfo<L extends Value<T>, FieldsType extends Tuple<Value<T>>, T extends object = DefaultPointer>(
|
|
r: Record<L, FieldsType, T>): RecordConstructorInfo<L, T>
|
|
{
|
|
return { label: r.label, arity: r.length };
|
|
}
|
|
|
|
export function isClassOf<L extends Value<T>, FieldsType extends Tuple<Value<T>>, T extends object = DefaultPointer>(
|
|
ci: RecordConstructorInfo<L, T>, v: any): v is Record<L, FieldsType, T>
|
|
{
|
|
return (Record.isRecord(v)) && is(ci.label, v.label) && (ci.arity === v.length);
|
|
}
|
|
|
|
export function makeConstructor<Fs, T extends object = DefaultPointer>()
|
|
: (<L extends Value<T>, Names extends Tuple<keyof Fs>>(label: L, fieldNames: Names) =>
|
|
RecordConstructor<L, Fs, Names, T>)
|
|
{
|
|
return <L extends Value<T>, Names extends Tuple<keyof Fs>>(label: L, fieldNames: Names) => {
|
|
const ctor: RecordConstructor<L, Fs, Names, T> =
|
|
((...fields: CtorTypes<Fs, Names>) =>
|
|
Record(label, fields)) as RecordConstructor<L, Fs, Names, T>;
|
|
const constructorInfo = { label, arity: fieldNames.length };
|
|
ctor.constructorInfo = constructorInfo;
|
|
ctor.isClassOf = (v: any): v is Record<L, CtorTypes<Fs, Names>, T> => Record.isClassOf(constructorInfo, v);
|
|
(ctor as any)._ = {};
|
|
fieldNames.forEach((name, i) => (ctor._ as any)[name] = (r: Record<L, CtorTypes<Fs, Names>, T>) => r[i]);
|
|
return ctor;
|
|
};
|
|
}
|
|
}
|
|
|
|
Array.prototype.asPreservesText = function (): string {
|
|
if ('label' in (this as any)) {
|
|
const r = this as Record<Value, Tuple<Value>, DefaultPointer>;
|
|
return '<' + r.label.asPreservesText() + (r.length > 0 ? ' ': '') +
|
|
r.map(f => {
|
|
try {
|
|
return f.asPreservesText();
|
|
} catch (e) {
|
|
return Record.fallbackToString(f);
|
|
}
|
|
}).join(' ') + '>';
|
|
} else {
|
|
return '[' + this.map(i => i.asPreservesText()).join(', ') + ']';
|
|
}
|
|
};
|