syndicate-lang
/
preserves
mirror of https://gitlab.com/preserves/preserves.git
1
0
Fork 1
Code Releases Activity

Update schema

This commit is contained in:
Tony Garnock-Jones 2024-03-12 20:41:47 +01:00
parent 0726684ab5
commit aeacce22fc
9 changed files with 187 additions and 164 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
implementations/javascript/packages/schema/src/compiler/context.ts
View File

@ -158,7 +158,7 @@ export class ModuleContext {
}
genericParameters(): Item {
return anglebrackets(seq('_embedded = ', this.embeddedType));
return anglebrackets(seq('_embedded extends _.Embeddable = ', this.embeddedType));
}
genericParametersFor(t: Type): Item {

2
implementations/javascript/packages/schema/src/compiler/genconverter.ts
View File

@ -163,7 +163,7 @@ export function converterForSimple(
return [seq(`${dest} = `, test, ` ? `, valexp, ` : void 0`)];
}
case 'embedded':
return [`${dest} = _.isEmbedded<_embedded>(${src}) ? ${src}.embeddedValue : void 0`];
return [`${dest} = _.isEmbedded<_embedded>(${src}) ? ${src} : void 0`];
case 'lit':
return [`${dest} = _.is(${src}, ${ctx.mod.literal(p.value)}) ? {} : void 0`];

2
implementations/javascript/packages/schema/src/compiler/genunconverter.ts
View File

@ -46,7 +46,7 @@ function unconverterFor(ctx: FunctionContext, p: M.Pattern, src: string): Item {
case 'lit':
return ctx.mod.literal(p.value);
case 'embedded':
return `_.embed(${src})`;
return `${src}`;
case 'seqof':
return seq(`${src}.map(v => `,
unconverterFor(ctx, M.Pattern.SimplePattern(p.pattern), 'v'),

4
implementations/javascript/packages/schema/src/compiler/value.ts
View File

@ -1,4 +1,4 @@
import { Annotated, Bytes, Set, Dictionary, Fold, fold, Record, Tuple, Value, stringify, Embedded } from "@preserves/core";
import { Annotated, Bytes, Set, Dictionary, Fold, fold, Record, Tuple, Value, stringify } from "@preserves/core";
import { brackets, Item, parens, seq } from "./block";
import * as M from '../meta';
@ -31,7 +31,7 @@ export function sourceCodeFor(v: Value<M.InputEmbedded>): Item {
return seq('_.annotate<_embedded>', parens(k(a.item), ... a.annotations.map(k)));
},
embedded(t: Embedded<M.InputEmbedded>, _k: Fold<M.InputEmbedded, Item>): Item {
embedded(t: M.InputEmbedded, _k: Fold<M.InputEmbedded, Item>): Item {
throw new Error(`Cannot emit source code for construction of embedded ${stringify(t)}`);
},
});

60
implementations/javascript/packages/schema/src/gen/host.ts
View File

@ -30,14 +30,18 @@ export type Definition = (
) &
_.Preservable<any> &
_.PreserveWritable<any> &
{__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}
{
__as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>
}
);
export type Variant = (
{"label": symbol, "type": Simple} &
_.Preservable<any> &
_.PreserveWritable<any> &
{__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}
{
__as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>
}
);
export type Simple = (
@ -47,21 +51,27 @@ export type Simple = (
) &
_.Preservable<any> &
_.PreserveWritable<any> &
{__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}
{
__as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>
}
);
export type Record = (
{"fields": Array<NamedField>} &
_.Preservable<any> &
_.PreserveWritable<any> &
{__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}
{
__as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>
}
);
export type NamedField = (
{"name": symbol, "type": Field} &
_.Preservable<any> &
_.PreserveWritable<any> &
{__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}
{
__as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>
}
);
export type Field = (
@ -77,7 +87,9 @@ export type Field = (
) &
_.Preservable<any> &
_.PreserveWritable<any> &
{__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}
{
__as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>
}
);
@ -337,13 +349,13 @@ export namespace Field {
};
}
export function asDefinition<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Definition {
export function asDefinition<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Definition {
let result = toDefinition(v);
if (result === void 0) throw new TypeError(`Invalid Definition: ${_.stringify(v)}`);
return result;
}
export function toDefinition<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Definition {
export function toDefinition<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Definition {
let result: undefined | Definition;
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
let _tmp0: ({}) | undefined;
@ -390,20 +402,20 @@ export function toDefinition<_embedded = _.GenericEmbedded>(v: _.Value<_embedded
export namespace Definition {export const __from_preserve__ = toDefinition;}
export function fromDefinition<_embedded = _.GenericEmbedded>(_v: Definition): _.Value<_embedded> {
export function fromDefinition<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Definition): _.Value<_embedded> {
switch (_v._variant) {
case "union": {return _.Record($union, [_v["variants"].map(v => fromVariant<_embedded>(v))]);};
case "Simple": {return fromSimple<_embedded>(_v.value);};
};
}
export function asVariant<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Variant {
export function asVariant<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Variant {
let result = toVariant(v);
if (result === void 0) throw new TypeError(`Invalid Variant: ${_.stringify(v)}`);
return result;
}
export function toVariant<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Variant {
export function toVariant<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Variant {
let result: undefined | Variant;
if (_.isSequence(v) && v.length === 2) {
let _tmp0: (symbol) | undefined;
@ -427,15 +439,15 @@ export function toVariant<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>):
Variant.__from_preserve__ = toVariant;
export function fromVariant<_embedded = _.GenericEmbedded>(_v: Variant): _.Value<_embedded> {return [_v["label"], fromSimple<_embedded>(_v["type"])];}
export function fromVariant<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Variant): _.Value<_embedded> {return [_v["label"], fromSimple<_embedded>(_v["type"])];}
export function asSimple<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Simple {
export function asSimple<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Simple {
let result = toSimple(v);
if (result === void 0) throw new TypeError(`Invalid Simple: ${_.stringify(v)}`);
return result;
}
export function toSimple<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Simple {
export function toSimple<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Simple {
let _tmp0: (Field) | undefined;
let result: undefined | Simple;
_tmp0 = toField(v);
@ -466,20 +478,20 @@ export function toSimple<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>):
export namespace Simple {export const __from_preserve__ = toSimple;}
export function fromSimple<_embedded = _.GenericEmbedded>(_v: Simple): _.Value<_embedded> {
export function fromSimple<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Simple): _.Value<_embedded> {
switch (_v._variant) {
case "Field": {return fromField<_embedded>(_v.value);};
case "Record": {return fromRecord<_embedded>(_v.value);};
};
}
export function asRecord<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Record {
export function asRecord<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Record {
let result = toRecord(v);
if (result === void 0) throw new TypeError(`Invalid Record: ${_.stringify(v)}`);
return result;
}
export function toRecord<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Record {
export function toRecord<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Record {
let result: undefined | Record;
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
let _tmp0: ({}) | undefined;
@ -512,15 +524,15 @@ export function toRecord<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>):
Record.__from_preserve__ = toRecord;
export function fromRecord<_embedded = _.GenericEmbedded>(_v: Record): _.Value<_embedded> {return _.Record($rec, [_v["fields"].map(v => fromNamedField<_embedded>(v))]);}
export function fromRecord<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Record): _.Value<_embedded> {return _.Record($rec, [_v["fields"].map(v => fromNamedField<_embedded>(v))]);}
export function asNamedField<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): NamedField {
export function asNamedField<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): NamedField {
let result = toNamedField(v);
if (result === void 0) throw new TypeError(`Invalid NamedField: ${_.stringify(v)}`);
return result;
}
export function toNamedField<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | NamedField {
export function toNamedField<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | NamedField {
let result: undefined | NamedField;
if (_.isSequence(v) && v.length === 2) {
let _tmp0: (symbol) | undefined;
@ -544,15 +556,15 @@ export function toNamedField<_embedded = _.GenericEmbedded>(v: _.Value<_embedded
NamedField.__from_preserve__ = toNamedField;
export function fromNamedField<_embedded = _.GenericEmbedded>(_v: NamedField): _.Value<_embedded> {return [_v["name"], fromField<_embedded>(_v["type"])];}
export function fromNamedField<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: NamedField): _.Value<_embedded> {return [_v["name"], fromField<_embedded>(_v["type"])];}
export function asField<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Field {
export function asField<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Field {
let result = toField(v);
if (result === void 0) throw new TypeError(`Invalid Field: ${_.stringify(v)}`);
return result;
}
export function toField<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Field {
export function toField<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Field {
let _tmp0: ({}) | undefined;
let result: undefined | Field;
_tmp0 = _.is(v, $unit) ? {} : void 0;
@ -687,7 +699,7 @@ export function toField<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): u
export namespace Field {export const __from_preserve__ = toField;}
export function fromField<_embedded = _.GenericEmbedded>(_v: Field): _.Value<_embedded> {
export function fromField<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Field): _.Value<_embedded> {
switch (_v._variant) {
case "unit": {return $unit;};
case "any": {return $any;};

206
implementations/javascript/packages/schema/src/gen/schema.ts
View File

@ -41,16 +41,16 @@ export function _schema() {
export const _imports = {}
export type Bundle<_embedded = _.GenericEmbedded> = (
export type Bundle<_embedded extends _.Embeddable = _.GenericEmbedded> = (
{"modules": Modules<_embedded>} &
_.Preservable<_embedded> &
_.PreserveWritable<_embedded> &
{__as_preserve__(): _.Value<_embedded>}
);
export type Modules<_embedded = _.GenericEmbedded> = _.EncodableDictionary<ModulePath, Schema<_embedded>, _embedded>;
export type Modules<_embedded extends _.Embeddable = _.GenericEmbedded> = _.EncodableDictionary<ModulePath, Schema<_embedded>, _embedded>;
export type Schema<_embedded = _.GenericEmbedded> = (
export type Schema<_embedded extends _.Embeddable = _.GenericEmbedded> = (
{
"version": Version,
"embeddedType": EmbeddedTypeName,
@ -65,19 +65,23 @@ export type Version = (
{} &
_.Preservable<any> &
_.PreserveWritable<any> &
{__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}
{
__as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>
}
);
export type EmbeddedTypeName = (
({"_variant": "false"} | {"_variant": "Ref", "value": Ref}) &
_.Preservable<any> &
_.PreserveWritable<any> &
{__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}
{
__as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>
}
);
export type Definitions<_embedded = _.GenericEmbedded> = _.EncodableDictionary<symbol, Definition<_embedded>, _embedded>;
export type Definitions<_embedded extends _.Embeddable = _.GenericEmbedded> = _.EncodableDictionary<symbol, Definition<_embedded>, _embedded>;
export type Definition<_embedded = _.GenericEmbedded> = (
export type Definition<_embedded extends _.Embeddable = _.GenericEmbedded> = (
(
{
"_variant": "or",
@ -98,7 +102,7 @@ export type Definition<_embedded = _.GenericEmbedded> = (
{__as_preserve__(): _.Value<_embedded>}
);
export type Pattern<_embedded = _.GenericEmbedded> = (
export type Pattern<_embedded extends _.Embeddable = _.GenericEmbedded> = (
(
{"_variant": "SimplePattern", "value": SimplePattern<_embedded>} |
{"_variant": "CompoundPattern", "value": CompoundPattern<_embedded>}
@ -108,7 +112,7 @@ export type Pattern<_embedded = _.GenericEmbedded> = (
{__as_preserve__(): _.Value<_embedded>}
);
export type SimplePattern<_embedded = _.GenericEmbedded> = (
export type SimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded> = (
(
{"_variant": "any"} |
{"_variant": "atom", "atomKind": AtomKind} |
@ -128,7 +132,7 @@ export type SimplePattern<_embedded = _.GenericEmbedded> = (
{__as_preserve__(): _.Value<_embedded>}
);
export type CompoundPattern<_embedded = _.GenericEmbedded> = (
export type CompoundPattern<_embedded extends _.Embeddable = _.GenericEmbedded> = (
(
{
"_variant": "rec",
@ -148,7 +152,7 @@ export type CompoundPattern<_embedded = _.GenericEmbedded> = (
{__as_preserve__(): _.Value<_embedded>}
);
export type DictionaryEntries<_embedded = _.GenericEmbedded> = _.EncodableDictionary<_.Value<_embedded>, NamedSimplePattern<_embedded>, _embedded>;
export type DictionaryEntries<_embedded extends _.Embeddable = _.GenericEmbedded> = _.EncodableDictionary<_.Value<_embedded>, NamedSimplePattern<_embedded>, _embedded>;
export type AtomKind = (
(
@ -161,17 +165,19 @@ export type AtomKind = (
) &
_.Preservable<any> &
_.PreserveWritable<any> &
{__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}
{
__as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>
}
);
export type NamedAlternative<_embedded = _.GenericEmbedded> = (
export type NamedAlternative<_embedded extends _.Embeddable = _.GenericEmbedded> = (
{"variantLabel": string, "pattern": Pattern<_embedded>} &
_.Preservable<_embedded> &
_.PreserveWritable<_embedded> &
{__as_preserve__(): _.Value<_embedded>}
);
export type NamedSimplePattern<_embedded = _.GenericEmbedded> = (
export type NamedSimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded> = (
(
{"_variant": "named", "value": Binding<_embedded>} |
{"_variant": "anonymous", "value": SimplePattern<_embedded>}
@ -181,7 +187,7 @@ export type NamedSimplePattern<_embedded = _.GenericEmbedded> = (
{__as_preserve__(): _.Value<_embedded>}
);
export type NamedPattern<_embedded = _.GenericEmbedded> = (
export type NamedPattern<_embedded extends _.Embeddable = _.GenericEmbedded> = (
(
{"_variant": "named", "value": Binding<_embedded>} |
{"_variant": "anonymous", "value": Pattern<_embedded>}
@ -191,7 +197,7 @@ export type NamedPattern<_embedded = _.GenericEmbedded> = (
{__as_preserve__(): _.Value<_embedded>}
);
export type Binding<_embedded = _.GenericEmbedded> = (
export type Binding<_embedded extends _.Embeddable = _.GenericEmbedded> = (
{"name": symbol, "pattern": SimplePattern<_embedded>} &
_.Preservable<_embedded> &
_.PreserveWritable<_embedded> &
@ -202,13 +208,15 @@ export type Ref = (
{"module": ModulePath, "name": symbol} &
_.Preservable<any> &
_.PreserveWritable<any> &
{__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}
{
__as_preserve__<_embedded extends _.Embeddable = _.GenericEmbedded>(): _.Value<_embedded>
}
);
export type ModulePath = Array<symbol>;
export function Bundle<_embedded = _.GenericEmbedded>(modules: Modules<_embedded>): Bundle<_embedded> {
export function Bundle<_embedded extends _.Embeddable = _.GenericEmbedded>(modules: Modules<_embedded>): Bundle<_embedded> {
return {
"modules": modules,
__as_preserve__() {return fromBundle(this);},
@ -221,13 +229,13 @@ Bundle.schema = function () {
return {schema: _schema(), imports: _imports, definitionName: _.Symbol.for("Bundle")};
}
export function Modules<_embedded = _.GenericEmbedded>(value: _.EncodableDictionary<ModulePath, Schema<_embedded>, _embedded>): Modules<_embedded> {return value;}
export function Modules<_embedded extends _.Embeddable = _.GenericEmbedded>(value: _.EncodableDictionary<ModulePath, Schema<_embedded>, _embedded>): Modules<_embedded> {return value;}
Modules.schema = function () {
return {schema: _schema(), imports: _imports, definitionName: _.Symbol.for("Modules")};
}
export function Schema<_embedded = _.GenericEmbedded>(
export function Schema<_embedded extends _.Embeddable = _.GenericEmbedded>(
{version, embeddedType, definitions}: {
version: Version,
embeddedType: EmbeddedTypeName,
@ -296,7 +304,7 @@ export namespace EmbeddedTypeName {
};
}
export function Definitions<_embedded = _.GenericEmbedded>(value: _.EncodableDictionary<symbol, Definition<_embedded>, _embedded>): Definitions<_embedded> {return value;}
export function Definitions<_embedded extends _.Embeddable = _.GenericEmbedded>(value: _.EncodableDictionary<symbol, Definition<_embedded>, _embedded>): Definitions<_embedded> {return value;}
Definitions.schema = function () {
return {
@ -307,7 +315,7 @@ Definitions.schema = function () {
}
export namespace Definition {
export function or<_embedded = _.GenericEmbedded>(
export function or<_embedded extends _.Embeddable = _.GenericEmbedded>(
{pattern0, pattern1, patternN}: {
pattern0: NamedAlternative<_embedded>,
pattern1: NamedAlternative<_embedded>,
@ -332,7 +340,7 @@ export namespace Definition {
variant: _.Symbol.for("or")
};
};
export function and<_embedded = _.GenericEmbedded>(
export function and<_embedded extends _.Embeddable = _.GenericEmbedded>(
{pattern0, pattern1, patternN}: {
pattern0: NamedPattern<_embedded>,
pattern1: NamedPattern<_embedded>,
@ -357,7 +365,7 @@ export namespace Definition {
variant: _.Symbol.for("and")
};
};
export function Pattern<_embedded = _.GenericEmbedded>(value: Pattern<_embedded>): Definition<_embedded> {
export function Pattern<_embedded extends _.Embeddable = _.GenericEmbedded>(value: Pattern<_embedded>): Definition<_embedded> {
return {
"_variant": "Pattern",
"value": value,
@ -377,7 +385,7 @@ export namespace Definition {
}
export namespace Pattern {
export function SimplePattern<_embedded = _.GenericEmbedded>(value: SimplePattern<_embedded>): Pattern<_embedded> {
export function SimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded>(value: SimplePattern<_embedded>): Pattern<_embedded> {
return {
"_variant": "SimplePattern",
"value": value,
@ -394,7 +402,7 @@ export namespace Pattern {
variant: _.Symbol.for("SimplePattern")
};
};
export function CompoundPattern<_embedded = _.GenericEmbedded>(value: CompoundPattern<_embedded>): Pattern<_embedded> {
export function CompoundPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(value: CompoundPattern<_embedded>): Pattern<_embedded> {
return {
"_variant": "CompoundPattern",
"value": value,
@ -414,7 +422,7 @@ export namespace Pattern {
}
export namespace SimplePattern {
export function any<_embedded = _.GenericEmbedded>(): SimplePattern<_embedded> {
export function any<_embedded extends _.Embeddable = _.GenericEmbedded>(): SimplePattern<_embedded> {
return {
"_variant": "any",
__as_preserve__() {return fromSimplePattern(this);},
@ -430,7 +438,7 @@ export namespace SimplePattern {
variant: _.Symbol.for("any")
};
};
export function atom<_embedded = _.GenericEmbedded>(atomKind: AtomKind): SimplePattern<_embedded> {
export function atom<_embedded extends _.Embeddable = _.GenericEmbedded>(atomKind: AtomKind): SimplePattern<_embedded> {
return {
"_variant": "atom",
"atomKind": atomKind,
@ -447,7 +455,7 @@ export namespace SimplePattern {
variant: _.Symbol.for("atom")
};
};
export function embedded<_embedded = _.GenericEmbedded>($interface: SimplePattern<_embedded>): SimplePattern<_embedded> {
export function embedded<_embedded extends _.Embeddable = _.GenericEmbedded>($interface: SimplePattern<_embedded>): SimplePattern<_embedded> {
return {
"_variant": "embedded",
"interface": $interface,
@ -464,7 +472,7 @@ export namespace SimplePattern {
variant: _.Symbol.for("embedded")
};
};
export function lit<_embedded = _.GenericEmbedded>(value: _.Value<_embedded>): SimplePattern<_embedded> {
export function lit<_embedded extends _.Embeddable = _.GenericEmbedded>(value: _.Value<_embedded>): SimplePattern<_embedded> {
return {
"_variant": "lit",
"value": value,
@ -481,7 +489,7 @@ export namespace SimplePattern {
variant: _.Symbol.for("lit")
};
};
export function seqof<_embedded = _.GenericEmbedded>(pattern: SimplePattern<_embedded>): SimplePattern<_embedded> {
export function seqof<_embedded extends _.Embeddable = _.GenericEmbedded>(pattern: SimplePattern<_embedded>): SimplePattern<_embedded> {
return {
"_variant": "seqof",
"pattern": pattern,
@ -498,7 +506,7 @@ export namespace SimplePattern {
variant: _.Symbol.for("seqof")
};
};
export function setof<_embedded = _.GenericEmbedded>(pattern: SimplePattern<_embedded>): SimplePattern<_embedded> {
export function setof<_embedded extends _.Embeddable = _.GenericEmbedded>(pattern: SimplePattern<_embedded>): SimplePattern<_embedded> {
return {
"_variant": "setof",
"pattern": pattern,
@ -515,7 +523,7 @@ export namespace SimplePattern {
variant: _.Symbol.for("setof")
};
};
export function dictof<_embedded = _.GenericEmbedded>({key, value}: {key: SimplePattern<_embedded>, value: SimplePattern<_embedded>}): SimplePattern<_embedded> {
export function dictof<_embedded extends _.Embeddable = _.GenericEmbedded>({key, value}: {key: SimplePattern<_embedded>, value: SimplePattern<_embedded>}): SimplePattern<_embedded> {
return {
"_variant": "dictof",
"key": key,
@ -533,7 +541,7 @@ export namespace SimplePattern {
variant: _.Symbol.for("dictof")
};
};
export function Ref<_embedded = _.GenericEmbedded>(value: Ref): SimplePattern<_embedded> {
export function Ref<_embedded extends _.Embeddable = _.GenericEmbedded>(value: Ref): SimplePattern<_embedded> {
return {
"_variant": "Ref",
"value": value,
@ -553,7 +561,7 @@ export namespace SimplePattern {
}
export namespace CompoundPattern {
export function rec<_embedded = _.GenericEmbedded>(
export function rec<_embedded extends _.Embeddable = _.GenericEmbedded>(
{label, fields}: {label: NamedPattern<_embedded>, fields: NamedPattern<_embedded>}
): CompoundPattern<_embedded> {
return {
@ -573,7 +581,7 @@ export namespace CompoundPattern {
variant: _.Symbol.for("rec")
};
};
export function tuple<_embedded = _.GenericEmbedded>(patterns: Array<NamedPattern<_embedded>>): CompoundPattern<_embedded> {
export function tuple<_embedded extends _.Embeddable = _.GenericEmbedded>(patterns: Array<NamedPattern<_embedded>>): CompoundPattern<_embedded> {
return {
"_variant": "tuple",
"patterns": patterns,
@ -590,7 +598,7 @@ export namespace CompoundPattern {
variant: _.Symbol.for("tuple")
};
};
export function tuplePrefix<_embedded = _.GenericEmbedded>(
export function tuplePrefix<_embedded extends _.Embeddable = _.GenericEmbedded>(
{fixed, variable}: {fixed: Array<NamedPattern<_embedded>>, variable: NamedSimplePattern<_embedded>}
): CompoundPattern<_embedded> {
return {
@ -610,7 +618,7 @@ export namespace CompoundPattern {
variant: _.Symbol.for("tuplePrefix")
};
};
export function dict<_embedded = _.GenericEmbedded>(entries: DictionaryEntries<_embedded>): CompoundPattern<_embedded> {
export function dict<_embedded extends _.Embeddable = _.GenericEmbedded>(entries: DictionaryEntries<_embedded>): CompoundPattern<_embedded> {
return {
"_variant": "dict",
"entries": entries,
@ -629,7 +637,7 @@ export namespace CompoundPattern {
};
}
export function DictionaryEntries<_embedded = _.GenericEmbedded>(
export function DictionaryEntries<_embedded extends _.Embeddable = _.GenericEmbedded>(
value: _.EncodableDictionary<_.Value<_embedded>, NamedSimplePattern<_embedded>, _embedded>
): DictionaryEntries<_embedded> {return value;}
@ -740,7 +748,7 @@ export namespace AtomKind {
};
}
export function NamedAlternative<_embedded = _.GenericEmbedded>({variantLabel, pattern}: {variantLabel: string, pattern: Pattern<_embedded>}): NamedAlternative<_embedded> {
export function NamedAlternative<_embedded extends _.Embeddable = _.GenericEmbedded>({variantLabel, pattern}: {variantLabel: string, pattern: Pattern<_embedded>}): NamedAlternative<_embedded> {
return {
"variantLabel": variantLabel,
"pattern": pattern,
@ -759,7 +767,7 @@ NamedAlternative.schema = function () {
}
export namespace NamedSimplePattern {
export function named<_embedded = _.GenericEmbedded>(value: Binding<_embedded>): NamedSimplePattern<_embedded> {
export function named<_embedded extends _.Embeddable = _.GenericEmbedded>(value: Binding<_embedded>): NamedSimplePattern<_embedded> {
return {
"_variant": "named",
"value": value,
@ -776,7 +784,7 @@ export namespace NamedSimplePattern {
variant: _.Symbol.for("named")
};
};
export function anonymous<_embedded = _.GenericEmbedded>(value: SimplePattern<_embedded>): NamedSimplePattern<_embedded> {
export function anonymous<_embedded extends _.Embeddable = _.GenericEmbedded>(value: SimplePattern<_embedded>): NamedSimplePattern<_embedded> {
return {
"_variant": "anonymous",
"value": value,
@ -796,7 +804,7 @@ export namespace NamedSimplePattern {
}
export namespace NamedPattern {
export function named<_embedded = _.GenericEmbedded>(value: Binding<_embedded>): NamedPattern<_embedded> {
export function named<_embedded extends _.Embeddable = _.GenericEmbedded>(value: Binding<_embedded>): NamedPattern<_embedded> {
return {
"_variant": "named",
"value": value,
@ -813,7 +821,7 @@ export namespace NamedPattern {
variant: _.Symbol.for("named")
};
};
export function anonymous<_embedded = _.GenericEmbedded>(value: Pattern<_embedded>): NamedPattern<_embedded> {
export function anonymous<_embedded extends _.Embeddable = _.GenericEmbedded>(value: Pattern<_embedded>): NamedPattern<_embedded> {
return {
"_variant": "anonymous",
"value": value,
@ -832,7 +840,7 @@ export namespace NamedPattern {
};
}
export function Binding<_embedded = _.GenericEmbedded>({name, pattern}: {name: symbol, pattern: SimplePattern<_embedded>}): Binding<_embedded> {
export function Binding<_embedded extends _.Embeddable = _.GenericEmbedded>({name, pattern}: {name: symbol, pattern: SimplePattern<_embedded>}): Binding<_embedded> {
return {
"name": name,
"pattern": pattern,
@ -870,13 +878,13 @@ ModulePath.schema = function () {
};
}
export function asBundle<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Bundle<_embedded> {
export function asBundle<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Bundle<_embedded> {
let result = toBundle(v);
if (result === void 0) throw new TypeError(`Invalid Bundle: ${_.stringify(v)}`);
return result;
}
export function toBundle<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Bundle<_embedded> {
export function toBundle<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Bundle<_embedded> {
let result: undefined | Bundle<_embedded>;
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
let _tmp0: ({}) | undefined;
@ -899,15 +907,15 @@ export function toBundle<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>):
Bundle.__from_preserve__ = toBundle;
export function fromBundle<_embedded = _.GenericEmbedded>(_v: Bundle<_embedded>): _.Value<_embedded> {return _.Record($bundle, [fromModules<_embedded>(_v["modules"])]);}
export function fromBundle<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Bundle<_embedded>): _.Value<_embedded> {return _.Record($bundle, [fromModules<_embedded>(_v["modules"])]);}
export function asModules<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Modules<_embedded> {
export function asModules<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Modules<_embedded> {
let result = toModules(v);
if (result === void 0) throw new TypeError(`Invalid Modules: ${_.stringify(v)}`);
return result;
}
export function toModules<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Modules<_embedded> {
export function toModules<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Modules<_embedded> {
let _tmp0: (_.EncodableDictionary<ModulePath, Schema<_embedded>, _embedded>) | undefined;
let result: undefined | Modules<_embedded>;
_tmp0 = void 0;
@ -931,19 +939,19 @@ export function toModules<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>):
Modules.__from_preserve__ = toModules;
export function fromModules<_embedded = _.GenericEmbedded>(_v: Modules<_embedded>): _.Value<_embedded> {
export function fromModules<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Modules<_embedded>): _.Value<_embedded> {
return new _.Dictionary<_embedded>(
_.Array.from(_v.entries()).map(([k, v]) => [fromModulePath<_embedded>(k), fromSchema<_embedded>(v)])
);
}
export function asSchema<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Schema<_embedded> {
export function asSchema<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Schema<_embedded> {
let result = toSchema(v);
if (result === void 0) throw new TypeError(`Invalid Schema: ${_.stringify(v)}`);
return result;
}
export function toSchema<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Schema<_embedded> {
export function toSchema<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Schema<_embedded> {
let result: undefined | Schema<_embedded>;
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
let _tmp0: ({}) | undefined;
@ -987,7 +995,7 @@ export function toSchema<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>):
Schema.__from_preserve__ = toSchema;
export function fromSchema<_embedded = _.GenericEmbedded>(_v: Schema<_embedded>): _.Value<_embedded> {
export function fromSchema<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Schema<_embedded>): _.Value<_embedded> {
return _.Record(
$schema,
[
@ -1002,13 +1010,13 @@ export function fromSchema<_embedded = _.GenericEmbedded>(_v: Schema<_embedded>)
);
}
export function asVersion<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Version {
export function asVersion<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Version {
let result = toVersion(v);
if (result === void 0) throw new TypeError(`Invalid Version: ${_.stringify(v)}`);
return result;
}
export function toVersion<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Version {
export function toVersion<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Version {
let _tmp0: ({}) | undefined;
let result: undefined | Version;
_tmp0 = _.is(v, $1) ? {} : void 0;
@ -1024,15 +1032,15 @@ export function toVersion<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>):
Version.__from_preserve__ = toVersion;
export function fromVersion<_embedded = _.GenericEmbedded>(_v: Version): _.Value<_embedded> {return $1;}
export function fromVersion<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Version): _.Value<_embedded> {return $1;}
export function asEmbeddedTypeName<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): EmbeddedTypeName {
export function asEmbeddedTypeName<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): EmbeddedTypeName {
let result = toEmbeddedTypeName(v);
if (result === void 0) throw new TypeError(`Invalid EmbeddedTypeName: ${_.stringify(v)}`);
return result;
}
export function toEmbeddedTypeName<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | EmbeddedTypeName {
export function toEmbeddedTypeName<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | EmbeddedTypeName {
let _tmp0: ({}) | undefined;
let result: undefined | EmbeddedTypeName;
_tmp0 = _.is(v, __lit6) ? {} : void 0;
@ -1062,20 +1070,20 @@ export function toEmbeddedTypeName<_embedded = _.GenericEmbedded>(v: _.Value<_em
export namespace EmbeddedTypeName {export const __from_preserve__ = toEmbeddedTypeName;}
export function fromEmbeddedTypeName<_embedded = _.GenericEmbedded>(_v: EmbeddedTypeName): _.Value<_embedded> {
export function fromEmbeddedTypeName<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: EmbeddedTypeName): _.Value<_embedded> {
switch (_v._variant) {
case "false": {return __lit6;};
case "Ref": {return fromRef<_embedded>(_v.value);};
};
}
export function asDefinitions<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Definitions<_embedded> {
export function asDefinitions<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Definitions<_embedded> {
let result = toDefinitions(v);
if (result === void 0) throw new TypeError(`Invalid Definitions: ${_.stringify(v)}`);
return result;
}
export function toDefinitions<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Definitions<_embedded> {
export function toDefinitions<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Definitions<_embedded> {
let _tmp0: (_.EncodableDictionary<symbol, Definition<_embedded>, _embedded>) | undefined;
let result: undefined | Definitions<_embedded>;
_tmp0 = void 0;
@ -1099,17 +1107,17 @@ export function toDefinitions<_embedded = _.GenericEmbedded>(v: _.Value<_embedde
Definitions.__from_preserve__ = toDefinitions;
export function fromDefinitions<_embedded = _.GenericEmbedded>(_v: Definitions<_embedded>): _.Value<_embedded> {
export function fromDefinitions<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Definitions<_embedded>): _.Value<_embedded> {
return new _.Dictionary<_embedded>(_.Array.from(_v.entries()).map(([k, v]) => [k, fromDefinition<_embedded>(v)]));
}
export function asDefinition<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Definition<_embedded> {
export function asDefinition<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Definition<_embedded> {
let result = toDefinition(v);
if (result === void 0) throw new TypeError(`Invalid Definition: ${_.stringify(v)}`);
return result;
}
export function toDefinition<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Definition<_embedded> {
export function toDefinition<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Definition<_embedded> {
let result: undefined | Definition<_embedded>;
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
let _tmp0: ({}) | undefined;
@ -1207,7 +1215,7 @@ export function toDefinition<_embedded = _.GenericEmbedded>(v: _.Value<_embedded
export namespace Definition {export const __from_preserve__ = toDefinition;}
export function fromDefinition<_embedded = _.GenericEmbedded>(_v: Definition<_embedded>): _.Value<_embedded> {
export function fromDefinition<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Definition<_embedded>): _.Value<_embedded> {
switch (_v._variant) {
case "or": {
return _.Record(
@ -1237,13 +1245,13 @@ export function fromDefinition<_embedded = _.GenericEmbedded>(_v: Definition<_em
};
}
export function asPattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Pattern<_embedded> {
export function asPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(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 = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Pattern<_embedded> {
export function toPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Pattern<_embedded> {
let _tmp0: (SimplePattern<_embedded>) | undefined;
let result: undefined | Pattern<_embedded>;
_tmp0 = toSimplePattern(v);
@ -1274,20 +1282,20 @@ export function toPattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>):
export namespace Pattern {export const __from_preserve__ = toPattern;}
export function fromPattern<_embedded = _.GenericEmbedded>(_v: Pattern<_embedded>): _.Value<_embedded> {
export function fromPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Pattern<_embedded>): _.Value<_embedded> {
switch (_v._variant) {
case "SimplePattern": {return fromSimplePattern<_embedded>(_v.value);};
case "CompoundPattern": {return fromCompoundPattern<_embedded>(_v.value);};
};
}
export function asSimplePattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): SimplePattern<_embedded> {
export function asSimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): SimplePattern<_embedded> {
let result = toSimplePattern(v);
if (result === void 0) throw new TypeError(`Invalid SimplePattern: ${_.stringify(v)}`);
return result;
}
export function toSimplePattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | SimplePattern<_embedded> {
export function toSimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | SimplePattern<_embedded> {
let _tmp0: ({}) | undefined;
let result: undefined | SimplePattern<_embedded>;
_tmp0 = _.is(v, $any) ? {} : void 0;
@ -1436,7 +1444,7 @@ export function toSimplePattern<_embedded = _.GenericEmbedded>(v: _.Value<_embed
export namespace SimplePattern {export const __from_preserve__ = toSimplePattern;}
export function fromSimplePattern<_embedded = _.GenericEmbedded>(_v: SimplePattern<_embedded>): _.Value<_embedded> {
export function fromSimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: SimplePattern<_embedded>): _.Value<_embedded> {
switch (_v._variant) {
case "any": {return $any;};
case "atom": {return _.Record($atom, [fromAtomKind<_embedded>(_v["atomKind"])]);};
@ -1457,13 +1465,13 @@ export function fromSimplePattern<_embedded = _.GenericEmbedded>(_v: SimplePatte
};
}
export function asCompoundPattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): CompoundPattern<_embedded> {
export function asCompoundPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): CompoundPattern<_embedded> {
let result = toCompoundPattern(v);
if (result === void 0) throw new TypeError(`Invalid CompoundPattern: ${_.stringify(v)}`);
return result;
}
export function toCompoundPattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | CompoundPattern<_embedded> {
export function toCompoundPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | CompoundPattern<_embedded> {
let result: undefined | CompoundPattern<_embedded>;
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
let _tmp0: ({}) | undefined;
@ -1574,7 +1582,7 @@ export function toCompoundPattern<_embedded = _.GenericEmbedded>(v: _.Value<_emb
export namespace CompoundPattern {export const __from_preserve__ = toCompoundPattern;}
export function fromCompoundPattern<_embedded = _.GenericEmbedded>(_v: CompoundPattern<_embedded>): _.Value<_embedded> {
export function fromCompoundPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: CompoundPattern<_embedded>): _.Value<_embedded> {
switch (_v._variant) {
case "rec": {
return _.Record(
@ -1601,13 +1609,13 @@ export function fromCompoundPattern<_embedded = _.GenericEmbedded>(_v: CompoundP
};
}
export function asDictionaryEntries<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): DictionaryEntries<_embedded> {
export function asDictionaryEntries<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): DictionaryEntries<_embedded> {
let result = toDictionaryEntries(v);
if (result === void 0) throw new TypeError(`Invalid DictionaryEntries: ${_.stringify(v)}`);
return result;
}
export function toDictionaryEntries<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | DictionaryEntries<_embedded> {
export function toDictionaryEntries<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | DictionaryEntries<_embedded> {
let _tmp0: (_.EncodableDictionary<_.Value<_embedded>, NamedSimplePattern<_embedded>, _embedded>) | undefined;
let result: undefined | DictionaryEntries<_embedded>;
_tmp0 = void 0;
@ -1631,19 +1639,19 @@ export function toDictionaryEntries<_embedded = _.GenericEmbedded>(v: _.Value<_e
DictionaryEntries.__from_preserve__ = toDictionaryEntries;
export function fromDictionaryEntries<_embedded = _.GenericEmbedded>(_v: DictionaryEntries<_embedded>): _.Value<_embedded> {
export function fromDictionaryEntries<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: DictionaryEntries<_embedded>): _.Value<_embedded> {
return new _.Dictionary<_embedded>(
_.Array.from(_v.entries()).map(([k, v]) => [k, fromNamedSimplePattern<_embedded>(v)])
);
}
export function asAtomKind<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): AtomKind {
export function asAtomKind<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): AtomKind {
let result = toAtomKind(v);
if (result === void 0) throw new TypeError(`Invalid AtomKind: ${_.stringify(v)}`);
return result;
}
export function toAtomKind<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | AtomKind {
export function toAtomKind<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | AtomKind {
let _tmp0: ({}) | undefined;
let result: undefined | AtomKind;
_tmp0 = _.is(v, $Boolean) ? {} : void 0;
@ -1720,7 +1728,7 @@ export function toAtomKind<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>)
export namespace AtomKind {export const __from_preserve__ = toAtomKind;}
export function fromAtomKind<_embedded = _.GenericEmbedded>(_v: AtomKind): _.Value<_embedded> {
export function fromAtomKind<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: AtomKind): _.Value<_embedded> {
switch (_v._variant) {
case "Boolean": {return $Boolean;};
case "Double": {return $Double;};
@ -1731,13 +1739,13 @@ export function fromAtomKind<_embedded = _.GenericEmbedded>(_v: AtomKind): _.Val
};
}
export function asNamedAlternative<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): NamedAlternative<_embedded> {
export function asNamedAlternative<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): NamedAlternative<_embedded> {
let result = toNamedAlternative(v);
if (result === void 0) throw new TypeError(`Invalid NamedAlternative: ${_.stringify(v)}`);
return result;
}
export function toNamedAlternative<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | NamedAlternative<_embedded> {
export function toNamedAlternative<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | NamedAlternative<_embedded> {
let result: undefined | NamedAlternative<_embedded>;
if (_.isSequence(v) && v.length === 2) {
let _tmp0: (string) | undefined;
@ -1761,15 +1769,15 @@ export function toNamedAlternative<_embedded = _.GenericEmbedded>(v: _.Value<_em
NamedAlternative.__from_preserve__ = toNamedAlternative;
export function fromNamedAlternative<_embedded = _.GenericEmbedded>(_v: NamedAlternative<_embedded>): _.Value<_embedded> {return [_v["variantLabel"], fromPattern<_embedded>(_v["pattern"])];}
export function fromNamedAlternative<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: NamedAlternative<_embedded>): _.Value<_embedded> {return [_v["variantLabel"], fromPattern<_embedded>(_v["pattern"])];}
export function asNamedSimplePattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): NamedSimplePattern<_embedded> {
export function asNamedSimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): NamedSimplePattern<_embedded> {
let result = toNamedSimplePattern(v);
if (result === void 0) throw new TypeError(`Invalid NamedSimplePattern: ${_.stringify(v)}`);
return result;
}
export function toNamedSimplePattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | NamedSimplePattern<_embedded> {
export function toNamedSimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | NamedSimplePattern<_embedded> {
let _tmp0: (Binding<_embedded>) | undefined;
let result: undefined | NamedSimplePattern<_embedded>;
_tmp0 = toBinding(v);
@ -1800,20 +1808,20 @@ export function toNamedSimplePattern<_embedded = _.GenericEmbedded>(v: _.Value<_
export namespace NamedSimplePattern {export const __from_preserve__ = toNamedSimplePattern;}
export function fromNamedSimplePattern<_embedded = _.GenericEmbedded>(_v: NamedSimplePattern<_embedded>): _.Value<_embedded> {
export function fromNamedSimplePattern<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: NamedSimplePattern<_embedded>): _.Value<_embedded> {
switch (_v._variant) {
case "named": {return fromBinding<_embedded>(_v.value);};
case "anonymous": {return fromSimplePattern<_embedded>(_v.value);};
};
}
export function asNamedPattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): NamedPattern<_embedded> {
export function asNamedPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): NamedPattern<_embedded> {
let result = toNamedPattern(v);
if (result === void 0) throw new TypeError(`Invalid NamedPattern: ${_.stringify(v)}`);
return result;
}
export function toNamedPattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | NamedPattern<_embedded> {
export function toNamedPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | NamedPattern<_embedded> {
let _tmp0: (Binding<_embedded>) | undefined;
let result: undefined | NamedPattern<_embedded>;
_tmp0 = toBinding(v);
@ -1844,20 +1852,20 @@ export function toNamedPattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedd
export namespace NamedPattern {export const __from_preserve__ = toNamedPattern;}
export function fromNamedPattern<_embedded = _.GenericEmbedded>(_v: NamedPattern<_embedded>): _.Value<_embedded> {
export function fromNamedPattern<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: NamedPattern<_embedded>): _.Value<_embedded> {
switch (_v._variant) {
case "named": {return fromBinding<_embedded>(_v.value);};
case "anonymous": {return fromPattern<_embedded>(_v.value);};
};
}
export function asBinding<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Binding<_embedded> {
export function asBinding<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Binding<_embedded> {
let result = toBinding(v);
if (result === void 0) throw new TypeError(`Invalid Binding: ${_.stringify(v)}`);
return result;
}
export function toBinding<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Binding<_embedded> {
export function toBinding<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Binding<_embedded> {
let result: undefined | Binding<_embedded>;
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
let _tmp0: ({}) | undefined;
@ -1885,17 +1893,17 @@ export function toBinding<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>):
Binding.__from_preserve__ = toBinding;
export function fromBinding<_embedded = _.GenericEmbedded>(_v: Binding<_embedded>): _.Value<_embedded> {
export function fromBinding<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Binding<_embedded>): _.Value<_embedded> {
return _.Record($named, [_v["name"], fromSimplePattern<_embedded>(_v["pattern"])]);
}
export function asRef<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Ref {
export function asRef<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): Ref {
let result = toRef(v);
if (result === void 0) throw new TypeError(`Invalid Ref: ${_.stringify(v)}`);
return result;
}
export function toRef<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Ref {
export function toRef<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | Ref {
let result: undefined | Ref;
if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
let _tmp0: ({}) | undefined;
@ -1923,15 +1931,15 @@ export function toRef<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): und
Ref.__from_preserve__ = toRef;
export function fromRef<_embedded = _.GenericEmbedded>(_v: Ref): _.Value<_embedded> {return _.Record($ref, [fromModulePath<_embedded>(_v["module"]), _v["name"]]);}
export function fromRef<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: Ref): _.Value<_embedded> {return _.Record($ref, [fromModulePath<_embedded>(_v["module"]), _v["name"]]);}
export function asModulePath<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): ModulePath {
export function asModulePath<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): ModulePath {
let result = toModulePath(v);
if (result === void 0) throw new TypeError(`Invalid ModulePath: ${_.stringify(v)}`);
return result;
}
export function toModulePath<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | ModulePath {
export function toModulePath<_embedded extends _.Embeddable = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | ModulePath {
let _tmp0: (Array<symbol>) | undefined;
let result: undefined | ModulePath;
_tmp0 = void 0;
@ -1951,5 +1959,5 @@ export function toModulePath<_embedded = _.GenericEmbedded>(v: _.Value<_embedded
ModulePath.__from_preserve__ = toModulePath;
export function fromModulePath<_embedded = _.GenericEmbedded>(_v: ModulePath): _.Value<_embedded> {return _v.map(v => v);}
export function fromModulePath<_embedded extends _.Embeddable = _.GenericEmbedded>(_v: ModulePath): _.Value<_embedded> {return _v.map(v => v);}

14
implementations/javascript/packages/schema/src/host.ts
View File

@ -1,11 +1,11 @@
import { compare } from '@preserves/core';
import { compare, Embeddable } from '@preserves/core';
import * as M from './meta';
import * as H from './gen/host';
export * from './gen/host';
export function definitionType<V>(p: M.Definition<V>): H.Definition {
export function definitionType<V extends Embeddable>(p: M.Definition<V>): H.Definition {
switch (p._variant) {
case 'or': return H.Definition.union([p.pattern0, p.pattern1, ... p.patternN].map(p =>
H.Variant({ label: Symbol.for(p.variantLabel), type: patternType(p.pattern) })));
@ -16,7 +16,7 @@ export function definitionType<V>(p: M.Definition<V>): H.Definition {
}
}
export function patternType<V>(p: M.Pattern<V>): H.Simple {
export function patternType<V extends Embeddable>(p: M.Pattern<V>): H.Simple {
switch (p._variant) {
case 'SimplePattern':
return H.Simple.Field(fieldType(p.value));
@ -25,7 +25,7 @@ export function patternType<V>(p: M.Pattern<V>): H.Simple {
}
}
export function fieldType<V>(p: M.SimplePattern<V>): H.Field {
export function fieldType<V extends Embeddable>(p: M.SimplePattern<V>): H.Field {
switch (p._variant) {
case 'any': return H.Field.any();
case 'atom': return H.Field.AtomKind(p.atomKind);
@ -38,19 +38,19 @@ export function fieldType<V>(p: M.SimplePattern<V>): H.Field {
}
}
export function productType<V>(ps: M.NamedPattern<V>[]): H.Simple {
export function productType<V extends Embeddable>(ps: M.NamedPattern<V>[]): H.Simple {
const gathered: H.NamedField[] = [];
ps.forEach(p => gather(p, gathered));
if (gathered.length === 0) return H.Simple.Field(H.Field.unit());
return H.Simple.Record(H.Record(gathered));
}
function promote<V>(p: M.NamedSimplePattern<V>): M.NamedPattern<V> {
function promote<V extends Embeddable>(p: M.NamedSimplePattern<V>): M.NamedPattern<V> {
if (p._variant === 'named') return p;
return M.NamedPattern.anonymous(M.Pattern.SimplePattern(p.value));
}
function gather<V>(p: M.NamedPattern<V>, into: H.NamedField[]) {
function gather<V extends Embeddable>(p: M.NamedPattern<V>, into: H.NamedField[]) {
switch (p._variant) {
case 'named': {
const t = fieldType(p.value.pattern);

57
implementations/javascript/packages/schema/src/interpreter.ts
View File

@ -1,35 +1,38 @@
import { EncodableDictionary, KeyedDictionary, Dictionary, Value, is, Record, Float, Bytes, isEmbedded, isSequence, Set, Atom, Embedded, merge as plainMerge, Preservable, PreserveWritable, _iterMap, stringify, fromJS } from '@preserves/core';
import { EncodableDictionary, KeyedDictionary, Dictionary, Value, is, Record, Float, Bytes, isEmbedded, isSequence, Set, Atom, merge as plainMerge, Preservable, PreserveWritable, _iterMap, stringify, fromJS, Embeddable } from '@preserves/core';
import { SchemaDefinition } from './reflection';
import * as M from './meta';
import * as H from './host';
export const UNIT: true = true;
export type Parsed<V> = Atom | V | Parsed<V>[] | DictOf<V> | Bindings<V>;
export type TopParsed<V> = Atom | V | Parsed<V>[] | DictOf<V> | TopBindings<V>;
export type Parsed<V extends Embeddable> = Atom | V | Parsed<V>[] | DictOf<V> | Bindings<V>;
export type TopParsed<V extends Embeddable> = Atom | V | Parsed<V>[] | DictOf<V> | TopBindings<V>;
export type Top<V> = Preservable<V> & PreserveWritable<V> & { __as_preserve__(): Value<V> };
export type Top<V extends Embeddable> =
& Preservable<V>
& PreserveWritable<V>
& { __as_preserve__(): Value<V> };
export type DictOf<V> = EncodableDictionary<Parsed<V>, Parsed<V>, V>;
export type DictOf<V extends Embeddable> = EncodableDictionary<Parsed<V>, Parsed<V>, V>;
export type BindingName = string;
export type Bindings<V> = { [key: BindingName]: Parsed<V> };
export type TopBindings<V> = Bindings<V> & Top<V>;
export type Bindings<V extends Embeddable> = { [key: BindingName]: Parsed<V> };
export type TopBindings<V extends Embeddable> = Bindings<V> & Top<V>;
export type SingleConstructor<V> = ((input: any) => Parsed<V>) & { schema(): SchemaDefinition };
export type MultipleConstructors<V> = { [key: string]: SingleConstructor<V> };
export type DefinitionConstructors<V> = SingleConstructor<V> | MultipleConstructors<V>;
export type SingleConstructor<V extends Embeddable> = ((input: any) => Parsed<V>) & { schema(): SchemaDefinition };
export type MultipleConstructors<V extends Embeddable> = { [key: string]: SingleConstructor<V> };
export type DefinitionConstructors<V extends Embeddable> = SingleConstructor<V> | MultipleConstructors<V>;
export namespace Bindings {
export function empty<V>(): Bindings<V> {
export function empty<V extends Embeddable>(): Bindings<V> {
return {};
}
export function single<V>(k: BindingName, v: Parsed<V>): Bindings<V> {
export function single<V extends Embeddable>(k: BindingName, v: Parsed<V>): Bindings<V> {
const bs = empty<V>();
bs[k] = v;
return bs;
}
export function merge<V>(... vs: Bindings<V>[]): Bindings<V> {
export function merge<V extends Embeddable>(... vs: Bindings<V>[]): Bindings<V> {
const acc = empty<V>();
for (const v of vs) {
Object.entries(v).forEach(([kw, vw]) => acc[kw] = vw);
@ -38,29 +41,29 @@ export namespace Bindings {
}
}
export type DynField<V> =
export type DynField<V extends Embeddable> =
| { type: 'simple', value: Parsed<V> }
| { type: 'compound', values: Bindings<V> }
;
export namespace DynField {
export function unwrap<V>(f: DynField<V>): Parsed<V> {
export function unwrap<V extends Embeddable>(f: DynField<V>): Parsed<V> {
if (f.type === 'simple') return f.value;
return f.values;
}
export function unwrap_compound<V>(f: DynField<V>): Bindings<V> {
export function unwrap_compound<V extends Embeddable>(f: DynField<V>): Bindings<V> {
if (f.type === 'simple') throw new Error("Cannot unwrap DynField.simple to compound fields");
return f.values;
}
export function simple<V>(value: Parsed<V>): DynField<V> {
export function simple<V extends Embeddable>(value: Parsed<V>): DynField<V> {
return { type: 'simple', value };
}
export function maybeSimple<V>(value: Parsed<V> | null): DynField<V> {
export function maybeSimple<V extends Embeddable>(value: Parsed<V> | null): DynField<V> {
return value === null ? compound(Bindings.empty()) : simple(value);
}
export function compound<V>(values: Bindings<V>): DynField<V> {
export function compound<V extends Embeddable>(values: Bindings<V>): DynField<V> {
return { type: 'compound', values };
}
export function promote<V>(f: DynField<V>, key?: symbol): Bindings<V> {
export function promote<V extends Embeddable>(f: DynField<V>, key?: symbol): Bindings<V> {
if (f.type === 'compound') return f.values;
return key ? Bindings.single(M.jsId(key.description!), f.value) : Bindings.empty();
}
@ -71,11 +74,11 @@ function optmap<A,B>(a: A | undefined, f: (a: A) => B): B | undefined {
return f(a);
}
export type Unparseable<V> = TopParsed<V>;
export type Unparser<V> = (v: Parsed<V>) => Value<V>;
export type UnparserCompound<V> = (v: Bindings<V>) => Value<V>;
export type Unparseable<V extends Embeddable> = TopParsed<V>;
export type Unparser<V extends Embeddable> = (v: Parsed<V>) => Value<V>;
export type UnparserCompound<V extends Embeddable> = (v: Bindings<V>) => Value<V>;
export class SchemaInterpreter<V> {
export class SchemaInterpreter<V extends Embeddable> {
activeModule: M.ModulePath = [];
unparserCache: { [key: string]: [Unparser<V>] } = {};
@ -298,7 +301,7 @@ export class SchemaInterpreter<V> {
case 'ByteString': return inputIf(Bytes.isBytes(input));
case 'Symbol': return inputIf(typeof input === 'symbol');
}
case 'embedded': return isEmbedded(input) ? input.embeddedValue : void 0;
case 'embedded': return isEmbedded(input) ? input : void 0;
case 'lit': return is(input, p.value) ? null : void 0;
case 'seqof': {
if (!isSequence(input)) return void 0;
@ -474,7 +477,7 @@ export class SchemaInterpreter<V> {
switch (p._variant) {
case 'any': return v => v as Value<V>; // ?!
case 'atom': return v => v as Atom;
case 'embedded': return v => new Embedded(v as V);
case 'embedded': return v => v as V;
case 'lit': return _v => p.value;
case 'seqof': {
const up = this.unparserSimplePattern(p.pattern);
@ -543,7 +546,7 @@ export class SchemaInterpreter<V> {
const schema = this.env.get(modulePath);
if (schema === void 0) return void 0;
const mod: { [key: string]: any } = {};
schema.definitions.forEach((d, n) => {
schema.definitions.forEach((_d, n) => {
const definitionName = n.description!;
const definitionId = M.jsId(definitionName);
mod[`${definitionId}`] = this.definitionConstructor(modulePath, n);

4
implementations/javascript/packages/schema/src/reader.ts
View File

@ -232,7 +232,7 @@ function parsePattern(name: symbol, body0: Array<Input>): Pattern {
case 'symbol': return ks(M.SimplePattern.atom(M.AtomKind.Symbol()));
default: {
if (str[0] === '=') {
return ks(M.SimplePattern.lit(Symbol.for(str.slice(1))));
return ks(M.SimplePattern.lit<GenericEmbedded>(Symbol.for(str.slice(1))));
} else if (M.isValidQid(str)) {
return ks(M.SimplePattern.Ref(parseRef(str, pos)));
} else {
@ -271,7 +271,7 @@ function parsePattern(name: symbol, body0: Array<Input>): Pattern {
} else if (isCompound(item)) {
return kf();
} else if (isEmbedded(item)) {
return ks(M.SimplePattern.embedded(walkSimple(item.embeddedValue.generic)));
return ks(M.SimplePattern.embedded(walkSimple(item.generic)));
} else {
return ks(M.SimplePattern.lit(strip(item)));
}