393 lines
17 KiB
TypeScript
393 lines
17 KiB
TypeScript
import * as _ from "@preserves/core";
|
|
import * as _i_EntityRef from "../runtime/actor";
|
|
|
|
export const $_ = Symbol.for("_");
|
|
export const $arr = Symbol.for("arr");
|
|
export const $bind = Symbol.for("bind");
|
|
export const $compound = Symbol.for("compound");
|
|
export const $dict = Symbol.for("dict");
|
|
export const $lit = Symbol.for("lit");
|
|
export const $rec = Symbol.for("rec");
|
|
|
|
export type _embedded = _i_EntityRef.Ref;
|
|
|
|
export type Pattern<_embedded = _i_EntityRef.Ref> = (
|
|
{"_variant": "DDiscard", "value": DDiscard} |
|
|
{"_variant": "DBind", "value": DBind<_embedded>} |
|
|
{"_variant": "DLit", "value": DLit<_embedded>} |
|
|
{"_variant": "DCompound", "value": DCompound<_embedded>}
|
|
);
|
|
|
|
export type DDiscard = null;
|
|
|
|
export type DBind<_embedded = _i_EntityRef.Ref> = {"name": symbol, "pattern": Pattern<_embedded>};
|
|
|
|
export type DLit<_embedded = _i_EntityRef.Ref> = {"value": _.Value<_embedded>};
|
|
|
|
export type DCompound<_embedded = _i_EntityRef.Ref> = (
|
|
{
|
|
"_variant": "rec",
|
|
"ctor": CRec<_embedded>,
|
|
"members": _.KeyedDictionary<number, Pattern<_embedded>, _embedded>
|
|
} |
|
|
{
|
|
"_variant": "arr",
|
|
"ctor": CArr,
|
|
"members": _.KeyedDictionary<number, Pattern<_embedded>, _embedded>
|
|
} |
|
|
{
|
|
"_variant": "dict",
|
|
"ctor": CDict,
|
|
"members": _.KeyedDictionary<_.Value<_embedded>, Pattern<_embedded>, _embedded>
|
|
}
|
|
);
|
|
|
|
export type CRec<_embedded = _i_EntityRef.Ref> = {"label": _.Value<_embedded>, "arity": number};
|
|
|
|
export type CArr = {"arity": number};
|
|
|
|
export type CDict = null;
|
|
|
|
|
|
export namespace Pattern {
|
|
export function DDiscard<_embedded = _i_EntityRef.Ref>(value: DDiscard): Pattern<_embedded> {return {"_variant": "DDiscard", "value": value};};
|
|
export function DBind<_embedded = _i_EntityRef.Ref>(value: DBind<_embedded>): Pattern<_embedded> {return {"_variant": "DBind", "value": value};};
|
|
export function DLit<_embedded = _i_EntityRef.Ref>(value: DLit<_embedded>): Pattern<_embedded> {return {"_variant": "DLit", "value": value};};
|
|
export function DCompound<_embedded = _i_EntityRef.Ref>(value: DCompound<_embedded>): Pattern<_embedded> {return {"_variant": "DCompound", "value": value};};
|
|
}
|
|
|
|
export function DDiscard(): DDiscard {return null;}
|
|
|
|
export function DBind<_embedded = _i_EntityRef.Ref>({name, pattern}: {name: symbol, pattern: Pattern<_embedded>}): DBind<_embedded> {return {"name": name, "pattern": pattern};}
|
|
|
|
export function DLit<_embedded = _i_EntityRef.Ref>(value: _.Value<_embedded>): DLit<_embedded> {return {"value": value};}
|
|
|
|
export namespace DCompound {
|
|
export function rec<_embedded = _i_EntityRef.Ref>(
|
|
{ctor, members}: {
|
|
ctor: CRec<_embedded>,
|
|
members: _.KeyedDictionary<number, Pattern<_embedded>, _embedded>
|
|
}
|
|
): DCompound<_embedded> {return {"_variant": "rec", "ctor": ctor, "members": members};};
|
|
export function arr<_embedded = _i_EntityRef.Ref>(
|
|
{ctor, members}: {ctor: CArr, members: _.KeyedDictionary<number, Pattern<_embedded>, _embedded>}
|
|
): DCompound<_embedded> {return {"_variant": "arr", "ctor": ctor, "members": members};};
|
|
export function dict<_embedded = _i_EntityRef.Ref>(
|
|
{ctor, members}: {
|
|
ctor: CDict,
|
|
members: _.KeyedDictionary<_.Value<_embedded>, Pattern<_embedded>, _embedded>
|
|
}
|
|
): DCompound<_embedded> {return {"_variant": "dict", "ctor": ctor, "members": members};};
|
|
}
|
|
|
|
export function CRec<_embedded = _i_EntityRef.Ref>({label, arity}: {label: _.Value<_embedded>, arity: number}): CRec<_embedded> {return {"label": label, "arity": arity};}
|
|
|
|
export function CArr(arity: number): CArr {return {"arity": arity};}
|
|
|
|
export function CDict(): CDict {return null;}
|
|
|
|
export function asPattern<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): Pattern<_embedded> {
|
|
let result = toPattern(v);
|
|
if (result === void 0) throw new TypeError(`Invalid Pattern: ${_.stringify(v)}`);
|
|
return result;
|
|
}
|
|
|
|
export function toPattern<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | Pattern<_embedded> {
|
|
let _tmp0: (DDiscard) | undefined;
|
|
let result: undefined | Pattern<_embedded>;
|
|
_tmp0 = toDDiscard(v);
|
|
if (_tmp0 !== void 0) {result = {"_variant": "DDiscard", "value": _tmp0};};
|
|
if (result === void 0) {
|
|
let _tmp1: (DBind<_embedded>) | undefined;
|
|
_tmp1 = toDBind(v);
|
|
if (_tmp1 !== void 0) {result = {"_variant": "DBind", "value": _tmp1};};
|
|
if (result === void 0) {
|
|
let _tmp2: (DLit<_embedded>) | undefined;
|
|
_tmp2 = toDLit(v);
|
|
if (_tmp2 !== void 0) {result = {"_variant": "DLit", "value": _tmp2};};
|
|
if (result === void 0) {
|
|
let _tmp3: (DCompound<_embedded>) | undefined;
|
|
_tmp3 = toDCompound(v);
|
|
if (_tmp3 !== void 0) {result = {"_variant": "DCompound", "value": _tmp3};};
|
|
};
|
|
};
|
|
};
|
|
return result;
|
|
}
|
|
|
|
export function fromPattern<_embedded = _i_EntityRef.Ref>(_v: Pattern<_embedded>): _.Value<_embedded> {
|
|
switch (_v._variant) {
|
|
case "DDiscard": {return fromDDiscard<_embedded>(_v.value);};
|
|
case "DBind": {return fromDBind<_embedded>(_v.value);};
|
|
case "DLit": {return fromDLit<_embedded>(_v.value);};
|
|
case "DCompound": {return fromDCompound<_embedded>(_v.value);};
|
|
};
|
|
}
|
|
|
|
export function asDDiscard<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): DDiscard {
|
|
let result = toDDiscard(v);
|
|
if (result === void 0) throw new TypeError(`Invalid DDiscard: ${_.stringify(v)}`);
|
|
return result;
|
|
}
|
|
|
|
export function toDDiscard<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | DDiscard {
|
|
let result: undefined | DDiscard;
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp0: (null) | undefined;
|
|
_tmp0 = _.is(v.label, $_) ? null : void 0;
|
|
if (_tmp0 !== void 0) {result = null;};
|
|
};
|
|
return result;
|
|
}
|
|
|
|
export function fromDDiscard<_embedded = _i_EntityRef.Ref>(_v: DDiscard): _.Value<_embedded> {return _.Record($_, []);}
|
|
|
|
export function asDBind<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): DBind<_embedded> {
|
|
let result = toDBind(v);
|
|
if (result === void 0) throw new TypeError(`Invalid DBind: ${_.stringify(v)}`);
|
|
return result;
|
|
}
|
|
|
|
export function toDBind<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | DBind<_embedded> {
|
|
let result: undefined | DBind<_embedded>;
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp0: (null) | undefined;
|
|
_tmp0 = _.is(v.label, $bind) ? null : void 0;
|
|
if (_tmp0 !== void 0) {
|
|
let _tmp1: (symbol) | undefined;
|
|
_tmp1 = typeof v[0] === 'symbol' ? v[0] : void 0;
|
|
if (_tmp1 !== void 0) {
|
|
let _tmp2: (Pattern<_embedded>) | undefined;
|
|
_tmp2 = toPattern(v[1]);
|
|
if (_tmp2 !== void 0) {result = {"name": _tmp1, "pattern": _tmp2};};
|
|
};
|
|
};
|
|
};
|
|
return result;
|
|
}
|
|
|
|
export function fromDBind<_embedded = _i_EntityRef.Ref>(_v: DBind<_embedded>): _.Value<_embedded> {return _.Record($bind, [_v["name"], fromPattern<_embedded>(_v["pattern"])]);}
|
|
|
|
export function asDLit<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): DLit<_embedded> {
|
|
let result = toDLit(v);
|
|
if (result === void 0) throw new TypeError(`Invalid DLit: ${_.stringify(v)}`);
|
|
return result;
|
|
}
|
|
|
|
export function toDLit<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | DLit<_embedded> {
|
|
let result: undefined | DLit<_embedded>;
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp0: (null) | undefined;
|
|
_tmp0 = _.is(v.label, $lit) ? null : void 0;
|
|
if (_tmp0 !== void 0) {
|
|
let _tmp1: (_.Value<_embedded>) | undefined;
|
|
_tmp1 = v[0];
|
|
if (_tmp1 !== void 0) {result = {"value": _tmp1};};
|
|
};
|
|
};
|
|
return result;
|
|
}
|
|
|
|
export function fromDLit<_embedded = _i_EntityRef.Ref>(_v: DLit<_embedded>): _.Value<_embedded> {return _.Record($lit, [_v["value"]]);}
|
|
|
|
export function asDCompound<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): DCompound<_embedded> {
|
|
let result = toDCompound(v);
|
|
if (result === void 0) throw new TypeError(`Invalid DCompound: ${_.stringify(v)}`);
|
|
return result;
|
|
}
|
|
|
|
export function toDCompound<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | DCompound<_embedded> {
|
|
let result: undefined | DCompound<_embedded>;
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp0: (null) | undefined;
|
|
_tmp0 = _.is(v.label, $compound) ? null : void 0;
|
|
if (_tmp0 !== void 0) {
|
|
let _tmp1: (CRec<_embedded>) | undefined;
|
|
_tmp1 = toCRec(v[0]);
|
|
if (_tmp1 !== void 0) {
|
|
let _tmp2: (_.KeyedDictionary<number, Pattern<_embedded>, _embedded>) | undefined;
|
|
_tmp2 = void 0;
|
|
if (_.Dictionary.isDictionary<_embedded>(v[1])) {
|
|
_tmp2 = new _.KeyedDictionary();
|
|
for (const [_tmp4, _tmp3] of v[1]) {
|
|
let _tmp5: (number) | undefined;
|
|
_tmp5 = typeof _tmp4 === 'number' ? _tmp4 : void 0;
|
|
if (_tmp5 !== void 0) {
|
|
let _tmp6: (Pattern<_embedded>) | undefined;
|
|
_tmp6 = toPattern(_tmp3);
|
|
if (_tmp6 !== void 0) {_tmp2.set(_tmp5, _tmp6); continue;};
|
|
};
|
|
_tmp2 = void 0;
|
|
break;
|
|
};
|
|
};
|
|
if (_tmp2 !== void 0) {result = {"_variant": "rec", "ctor": _tmp1, "members": _tmp2};};
|
|
};
|
|
};
|
|
};
|
|
if (result === void 0) {
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp7: (null) | undefined;
|
|
_tmp7 = _.is(v.label, $compound) ? null : void 0;
|
|
if (_tmp7 !== void 0) {
|
|
let _tmp8: (CArr) | undefined;
|
|
_tmp8 = toCArr(v[0]);
|
|
if (_tmp8 !== void 0) {
|
|
let _tmp9: (_.KeyedDictionary<number, Pattern<_embedded>, _embedded>) | undefined;
|
|
_tmp9 = void 0;
|
|
if (_.Dictionary.isDictionary<_embedded>(v[1])) {
|
|
_tmp9 = new _.KeyedDictionary();
|
|
for (const [_tmp11, _tmp10] of v[1]) {
|
|
let _tmp12: (number) | undefined;
|
|
_tmp12 = typeof _tmp11 === 'number' ? _tmp11 : void 0;
|
|
if (_tmp12 !== void 0) {
|
|
let _tmp13: (Pattern<_embedded>) | undefined;
|
|
_tmp13 = toPattern(_tmp10);
|
|
if (_tmp13 !== void 0) {_tmp9.set(_tmp12, _tmp13); continue;};
|
|
};
|
|
_tmp9 = void 0;
|
|
break;
|
|
};
|
|
};
|
|
if (_tmp9 !== void 0) {result = {"_variant": "arr", "ctor": _tmp8, "members": _tmp9};};
|
|
};
|
|
};
|
|
};
|
|
if (result === void 0) {
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp14: (null) | undefined;
|
|
_tmp14 = _.is(v.label, $compound) ? null : void 0;
|
|
if (_tmp14 !== void 0) {
|
|
let _tmp15: (CDict) | undefined;
|
|
_tmp15 = toCDict(v[0]);
|
|
if (_tmp15 !== void 0) {
|
|
let _tmp16: (_.KeyedDictionary<_.Value<_embedded>, Pattern<_embedded>, _embedded>) | undefined;
|
|
_tmp16 = void 0;
|
|
if (_.Dictionary.isDictionary<_embedded>(v[1])) {
|
|
_tmp16 = new _.KeyedDictionary();
|
|
for (const [_tmp18, _tmp17] of v[1]) {
|
|
let _tmp19: (_.Value<_embedded>) | undefined;
|
|
_tmp19 = _tmp18;
|
|
if (_tmp19 !== void 0) {
|
|
let _tmp20: (Pattern<_embedded>) | undefined;
|
|
_tmp20 = toPattern(_tmp17);
|
|
if (_tmp20 !== void 0) {_tmp16.set(_tmp19, _tmp20); continue;};
|
|
};
|
|
_tmp16 = void 0;
|
|
break;
|
|
};
|
|
};
|
|
if (_tmp16 !== void 0) {result = {"_variant": "dict", "ctor": _tmp15, "members": _tmp16};};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
};
|
|
return result;
|
|
}
|
|
|
|
export function fromDCompound<_embedded = _i_EntityRef.Ref>(_v: DCompound<_embedded>): _.Value<_embedded> {
|
|
switch (_v._variant) {
|
|
case "rec": {
|
|
return _.Record(
|
|
$compound,
|
|
[
|
|
fromCRec<_embedded>(_v["ctor"]),
|
|
new _.Dictionary<_embedded>(
|
|
_.Array.from(_v["members"].entries()).map(([k, v]) => [k, fromPattern<_embedded>(v)])
|
|
)
|
|
]
|
|
);
|
|
};
|
|
case "arr": {
|
|
return _.Record(
|
|
$compound,
|
|
[
|
|
fromCArr<_embedded>(_v["ctor"]),
|
|
new _.Dictionary<_embedded>(
|
|
_.Array.from(_v["members"].entries()).map(([k, v]) => [k, fromPattern<_embedded>(v)])
|
|
)
|
|
]
|
|
);
|
|
};
|
|
case "dict": {
|
|
return _.Record(
|
|
$compound,
|
|
[
|
|
fromCDict<_embedded>(_v["ctor"]),
|
|
new _.Dictionary<_embedded>(
|
|
_.Array.from(_v["members"].entries()).map(([k, v]) => [k, fromPattern<_embedded>(v)])
|
|
)
|
|
]
|
|
);
|
|
};
|
|
};
|
|
}
|
|
|
|
export function asCRec<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): CRec<_embedded> {
|
|
let result = toCRec(v);
|
|
if (result === void 0) throw new TypeError(`Invalid CRec: ${_.stringify(v)}`);
|
|
return result;
|
|
}
|
|
|
|
export function toCRec<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | CRec<_embedded> {
|
|
let result: undefined | CRec<_embedded>;
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp0: (null) | undefined;
|
|
_tmp0 = _.is(v.label, $rec) ? null : void 0;
|
|
if (_tmp0 !== void 0) {
|
|
let _tmp1: (_.Value<_embedded>) | undefined;
|
|
_tmp1 = v[0];
|
|
if (_tmp1 !== void 0) {
|
|
let _tmp2: (number) | undefined;
|
|
_tmp2 = typeof v[1] === 'number' ? v[1] : void 0;
|
|
if (_tmp2 !== void 0) {result = {"label": _tmp1, "arity": _tmp2};};
|
|
};
|
|
};
|
|
};
|
|
return result;
|
|
}
|
|
|
|
export function fromCRec<_embedded = _i_EntityRef.Ref>(_v: CRec<_embedded>): _.Value<_embedded> {return _.Record($rec, [_v["label"], _v["arity"]]);}
|
|
|
|
export function asCArr<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): CArr {
|
|
let result = toCArr(v);
|
|
if (result === void 0) throw new TypeError(`Invalid CArr: ${_.stringify(v)}`);
|
|
return result;
|
|
}
|
|
|
|
export function toCArr<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | CArr {
|
|
let result: undefined | CArr;
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp0: (null) | undefined;
|
|
_tmp0 = _.is(v.label, $arr) ? null : void 0;
|
|
if (_tmp0 !== void 0) {
|
|
let _tmp1: (number) | undefined;
|
|
_tmp1 = typeof v[0] === 'number' ? v[0] : void 0;
|
|
if (_tmp1 !== void 0) {result = {"arity": _tmp1};};
|
|
};
|
|
};
|
|
return result;
|
|
}
|
|
|
|
export function fromCArr<_embedded = _i_EntityRef.Ref>(_v: CArr): _.Value<_embedded> {return _.Record($arr, [_v["arity"]]);}
|
|
|
|
export function asCDict<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): CDict {
|
|
let result = toCDict(v);
|
|
if (result === void 0) throw new TypeError(`Invalid CDict: ${_.stringify(v)}`);
|
|
return result;
|
|
}
|
|
|
|
export function toCDict<_embedded = _i_EntityRef.Ref>(v: _.Value<_embedded>): undefined | CDict {
|
|
let result: undefined | CDict;
|
|
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
|
|
let _tmp0: (null) | undefined;
|
|
_tmp0 = _.is(v.label, $dict) ? null : void 0;
|
|
if (_tmp0 !== void 0) {result = null;};
|
|
};
|
|
return result;
|
|
}
|
|
|
|
export function fromCDict<_embedded = _i_EntityRef.Ref>(_v: CDict): _.Value<_embedded> {return _.Record($dict, []);}
|
|
|