diff --git a/implementations/javascript/packages/schema/src/compiler.ts b/implementations/javascript/packages/schema/src/compiler.ts index 084fe42..0ecc0d2 100644 --- a/implementations/javascript/packages/schema/src/compiler.ts +++ b/implementations/javascript/packages/schema/src/compiler.ts @@ -1,7 +1,7 @@ import { encode, stringify } from "@preserves/core"; import * as M from "./meta"; import { CompilerOptions, ModuleContext } from "./compiler/context"; -import { Formatter, block, seq, braces } from "./compiler/block"; +import { Formatter, block, seq, braces, opseq } from "./compiler/block"; import { typeForDefinition } from "./compiler/gentype"; import { converterForDefinition } from "./compiler/genconverter"; import { renderType } from "./compiler/rendertype"; @@ -32,19 +32,19 @@ export function compile( for (const [name, def] of schema.definitions) { const t = typeForDefinition(mod.resolver(), def); const nameStr = stringify(name); - const resultTypeItem = nameStr + mod.genericArgsFor(t); + const resultTypeItem = mod.withAsPreserveMixinType(nameStr, t); mod.defineType(seq(`export type ${nameStr}`, mod.genericParametersFor(t), ` = `, renderType(mod, t), `;`)); if (t.kind === 'union') { - mod.defineFunctions(_ctx => + mod.defineFunctions(nameStr, _ctx => [seq(`export namespace ${nameStr} `, block( ... Array.from(t.variants).flatMap(([vn, vt]) => genConstructor(mod, nameStr, vn, vn, vt, t, resultTypeItem)) ))]); } else { - mod.defineFunctions(_ctx => + mod.defineFunctions(nameStr, _ctx => genConstructor(mod, nameStr, nameStr, void 0, t, t, resultTypeItem)); } } @@ -52,24 +52,30 @@ export function compile( for (const [name0, def] of schema.definitions) { const t = typeForDefinition(mod.resolver(), def); const name = name0 as symbol; + const nameStr = name0.description!; + const resultTypeItem = mod.withAsPreserveMixinType(nameStr, t); - mod.defineFunctions(ctx => + mod.defineFunctions(nameStr, ctx => [seq(`export function as${name.description!}`, mod.genericParameters(), - `(v: _.Value<_embedded>): `, name.description!, mod.genericArgsFor(t), ` `, + `(v: _.Value<_embedded>): `, resultTypeItem, ` `, ctx.block(() => [ seq(`let result = to${name.description!}(v)`), seq(`if (result === void 0) `, `throw new TypeError(\`Invalid ${name.description!}: \${_.stringify(v)}\`)`), seq(`return result`)]))]); - mod.defineFunctions(ctx => + mod.defineFunctions(nameStr, ctx => [seq(`export function to${name.description!}`, mod.genericParameters(), - `(v: _.Value<_embedded>): undefined | `, name.description!, mod.genericArgsFor(t), ` `, - ctx.block(() => [seq(`let result: undefined | `, name.description!, mod.genericArgsFor(t)), + `(v: _.Value<_embedded>): undefined | `, resultTypeItem, ` `, + ctx.block(() => [seq(`let result: undefined | `, resultTypeItem), ... converterForDefinition(ctx, def, `v`, `result`), - seq(`return result`)]))]); + seq(`return result`)])), + (t.kind === 'union') + ? seq(`export namespace ${M.jsId(name.description!)} `, block( + seq(`export const __from_preserve__ = to${name.description!}`))) + : seq(`${M.jsId(name.description!)}.__from_preserve__ = to${name.description!};`)]); - mod.defineFunctions(ctx => + mod.defineFunctions(nameStr, ctx => [seq(`export function from${name.description!}`, mod.genericParameters(), `(_v: `, name.description!, mod.genericArgsFor(t), `): _.Value<_embedded> `, ctx.block(() => unconverterForDefinition(ctx, def, `_v`)))]); diff --git a/implementations/javascript/packages/schema/src/compiler/context.ts b/implementations/javascript/packages/schema/src/compiler/context.ts index d5f77be..839ed1a 100644 --- a/implementations/javascript/packages/schema/src/compiler/context.ts +++ b/implementations/javascript/packages/schema/src/compiler/context.ts @@ -1,7 +1,7 @@ import { Dictionary, KeyedSet, FlexSet, Position, stringify, is } from "@preserves/core"; import { refPosition } from "../reader"; import * as M from "../meta"; -import { anglebrackets, block, braces, commas, formatItems, Item, keyvalue, seq } from "./block"; +import { anglebrackets, block, braces, commas, formatItems, Item, keyvalue, seq, opseq } from "./block"; import { ANY_TYPE, RefType, Type } from "./type"; import { renderType, variantInitFor } from "./rendertype"; import { typeForDefinition } from "./gentype"; @@ -89,8 +89,8 @@ export class ModuleContext { this.typedefs.push(f); } - defineFunctions(f: (ctx: FunctionContext) => Item[]): void { - this.functiondefs.push(... f(new FunctionContext(this))); + defineFunctions(definitionName: string, f: (ctx: FunctionContext) => Item[]): void { + this.functiondefs.push(... f(new FunctionContext(this, definitionName))); } resolver(modulePath?: M.ModulePath): (ref: M.Ref) => RefType { @@ -209,10 +209,24 @@ export class ModuleContext { return walk(t); } + + withAsPreserveMixinType(name: string, t: Type): Item { + if (t.kind === 'unit' || t.kind === 'record' || t.kind === 'union') { + return opseq('any', ' & ', + seq(name, this.genericArgsFor(t)), + braces(seq('__as_preserve__', + this.hasEmbedded(t) ? '' : this.genericParameters(), + '()', + ': _.Value', this.genericArgs()))); + } else { + return seq(name, this.genericArgsFor(t)); + } + } } export class FunctionContext { readonly mod: ModuleContext; + readonly definitionName: string; tempCounter = 0; temps: Map = new Map(); @@ -220,8 +234,9 @@ export class FunctionContext { captures: Capture[] = []; variantName: string | undefined = void 0; - constructor(mod: ModuleContext) { + constructor(mod: ModuleContext, definitionName: string) { this.mod = mod; + this.definitionName = definitionName; } gentempname(): string { @@ -273,9 +288,10 @@ export class FunctionContext { const fields = [ ... variantInitFor(this.variantName), ... this.captures.map(({ fieldName, sourceExpr }) => - keyvalue(fieldName, sourceExpr)) + keyvalue(fieldName, sourceExpr)), + seq(`__as_preserve__() `, block(`return from${this.definitionName}(this)`)) ]; - return seq(`${dest} = `, fields.length === 0 ? `null` : braces(... fields)); + return seq(`${dest} = `, braces(... fields)); } } diff --git a/implementations/javascript/packages/schema/src/compiler/genconverter.ts b/implementations/javascript/packages/schema/src/compiler/genconverter.ts index 11b146a..0c809bf 100644 --- a/implementations/javascript/packages/schema/src/compiler/genconverter.ts +++ b/implementations/javascript/packages/schema/src/compiler/genconverter.ts @@ -55,7 +55,11 @@ function converterForPattern( () => ctx.buildCapturedCompound(dest))]; } } else { - return [`${dest} = ${simpleValue}`]; + if (typeFor(ctx.mod.resolver(), p).kind === 'unit') { + return [ctx.buildCapturedCompound(dest)]; + } else { + return [`${dest} = ${simpleValue}`]; + } } }); } @@ -136,7 +140,7 @@ export function converterForSimple( case 'embedded': return [`${dest} = _.isEmbedded<_embedded>(${src}) ? ${src}.embeddedValue : void 0`]; case 'lit': - return [`${dest} = _.is(${src}, ${ctx.mod.literal(p.value)}) ? null : void 0`]; + return [`${dest} = _.is(${src}, ${ctx.mod.literal(p.value)}) ? {} : void 0`]; case 'seqof': { const kKnownArray = () => { diff --git a/implementations/javascript/packages/schema/src/compiler/genctor.ts b/implementations/javascript/packages/schema/src/compiler/genctor.ts index b8b55a8..9bc3261 100644 --- a/implementations/javascript/packages/schema/src/compiler/genctor.ts +++ b/implementations/javascript/packages/schema/src/compiler/genctor.ts @@ -26,7 +26,7 @@ export function genConstructor( arg.fields.forEach(examine); } else { examine(arg, 'value'); - simpleValue = variant === void 0; + simpleValue = (variant === void 0) && (arg.kind !== 'unit'); } const initializers: Item[] = (variant !== void 0) @@ -34,6 +34,8 @@ export function genConstructor( : []; formals.forEach(([n, _t]) => initializers.push(seq(JSON.stringify(n), ': ', M.jsId(n)))); + initializers.push(seq(`__as_preserve__() `, block(`return from${M.jsId(definitionName)}(this)`))); + const declArgs: Array = (formals.length > 1) ? [seq(braces(...formals.map(f => M.jsId(f[0]))), ': ', braces(...formals.map(f => seq(M.jsId(f[0]), ': ', renderType(mod, f[1])))))] @@ -44,20 +46,15 @@ export function genConstructor( parens(...declArgs), ': ', resultTypeItem, ' ', block( seq(`return `, - ((arg.kind === 'unit' && initializers.length === 0) - ? 'null' - : (simpleValue - ? 'value' - : braces(...initializers)))))), + (simpleValue + ? 'value' + : braces(...initializers))))), seq(`${M.jsId(name)}.schema = function () `, block( seq(`return `, braces( `schema: _schema()`, `imports: _imports`, `definitionName: _.Symbol.for(${JSON.stringify(definitionName)})`, ... (variant === void 0) ? [] : [`variant: _.Symbol.for(${JSON.stringify(variant)})`], - `unparse: from${definitionName}`, - `parse: to${definitionName}`, - `cast: as${definitionName}`, )))), ]; } diff --git a/implementations/javascript/packages/schema/src/compiler/rendertype.ts b/implementations/javascript/packages/schema/src/compiler/rendertype.ts index 927201e..fc0adcc 100644 --- a/implementations/javascript/packages/schema/src/compiler/rendertype.ts +++ b/implementations/javascript/packages/schema/src/compiler/rendertype.ts @@ -10,33 +10,37 @@ export function variantFor(variantName: string): Item { return keyvalue('_variant', JSON.stringify(variantName)); } -export function renderVariant(ctxt: ModuleContext, [variantName, t]: [string, SimpleType]): Item { - let fields: Item[]; +function simpleTypeFields(ctxt: ModuleContext, baseType: Type, t: SimpleType): Item[] { switch (t.kind) { case 'unit': - fields = []; - break; + return []; case 'ref': case 'set': case 'dictionary': case 'array': - fields = [keyvalue('value', renderType(ctxt, t))]; - break; + return [keyvalue('value', renderType(ctxt, t))]; case 'record': - fields = Array.from(t.fields).map(([nn, tt]) => keyvalue(nn, renderType(ctxt, tt))); - break; + return Array.from(t.fields).map(([nn, tt]) => keyvalue(nn, renderType(ctxt, tt))); default: ((_: never) => {})(t); throw new Error("Unreachable"); } +} + +export function renderVariant( + ctxt: ModuleContext, + baseType: Type, + [variantName, t]: [string, SimpleType], +): Item { + let fields = simpleTypeFields(ctxt, baseType, t); return braces(variantFor(variantName), ... fields); } export function renderType(ctxt: ModuleContext, t: Type): Item { switch (t.kind) { case 'union': return opseq('never', ' | ', ... - Array.from(t.variants).flatMap(entry => renderVariant(ctxt, entry))); - case 'unit': return 'null'; + Array.from(t.variants).flatMap(entry => renderVariant(ctxt, t, entry))); + case 'unit': return braces(... simpleTypeFields(ctxt, t, t)); case 'ref': if (t.ref === null && t.typeName === '_embedded') { return t.typeName; @@ -51,8 +55,7 @@ export function renderType(ctxt: ModuleContext, t: Type): Item { renderType(ctxt, t.value), '_embedded')); case 'array': return seq('Array', anglebrackets(renderType(ctxt, t.type))); - case 'record': return braces(... Array.from(t.fields).map(([nn, tt]) => - keyvalue(nn, renderType(ctxt, tt)))); + case 'record': return braces(... simpleTypeFields(ctxt, t, t)); default: ((_: never) => {})(t); throw new Error("Unreachable"); diff --git a/implementations/javascript/packages/schema/src/gen/schema.ts b/implementations/javascript/packages/schema/src/gen/schema.ts index 6715e60..181a450 100644 --- a/implementations/javascript/packages/schema/src/gen/schema.ts +++ b/implementations/javascript/packages/schema/src/gen/schema.ts @@ -52,7 +52,7 @@ export type Schema<_embedded = _.GenericEmbedded> = { "definitions": Definitions<_embedded> }; -export type Version = null; +export type Version = {}; export type EmbeddedTypeName = ({"_variant": "Ref", "value": Ref} | {"_variant": "false"}); @@ -140,30 +140,16 @@ export type Ref = {"module": ModulePath, "name": symbol}; export type ModulePath = Array; -export function Bundle<_embedded = _.GenericEmbedded>(modules: Modules<_embedded>): Bundle<_embedded> {return {"modules": modules};} +export function Bundle<_embedded = _.GenericEmbedded>(modules: Modules<_embedded>): (Bundle<_embedded> & {__as_preserve__(): _.Value<_embedded>}) {return {"modules": modules, __as_preserve__() {return fromBundle(this);}};} Bundle.schema = function () { - return { - schema: _schema(), - imports: _imports, - definitionName: _.Symbol.for("Bundle"), - unparse: fromBundle, - parse: toBundle, - cast: asBundle - }; + return {schema: _schema(), imports: _imports, definitionName: _.Symbol.for("Bundle")}; } export function Modules<_embedded = _.GenericEmbedded>(value: _.KeyedDictionary, _embedded>): Modules<_embedded> {return value;} Modules.schema = function () { - return { - schema: _schema(), - imports: _imports, - definitionName: _.Symbol.for("Modules"), - unparse: fromModules, - parse: toModules, - cast: asModules - }; + return {schema: _schema(), imports: _imports, definitionName: _.Symbol.for("Modules")}; } export function Schema<_embedded = _.GenericEmbedded>( @@ -172,57 +158,59 @@ export function Schema<_embedded = _.GenericEmbedded>( embeddedType: EmbeddedTypeName, definitions: Definitions<_embedded> } -): Schema<_embedded> { - return {"version": version, "embeddedType": embeddedType, "definitions": definitions}; +): (Schema<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "version": version, + "embeddedType": embeddedType, + "definitions": definitions, + __as_preserve__() {return fromSchema(this);} + }; } Schema.schema = function () { - return { - schema: _schema(), - imports: _imports, - definitionName: _.Symbol.for("Schema"), - unparse: fromSchema, - parse: toSchema, - cast: asSchema - }; + return {schema: _schema(), imports: _imports, definitionName: _.Symbol.for("Schema")}; } -export function Version(): Version {return null;} +export function Version(): ( + Version & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} +) {return {__as_preserve__() {return fromVersion(this);}};} Version.schema = function () { - return { - schema: _schema(), - imports: _imports, - definitionName: _.Symbol.for("Version"), - unparse: fromVersion, - parse: toVersion, - cast: asVersion - }; + return {schema: _schema(), imports: _imports, definitionName: _.Symbol.for("Version")}; } export namespace EmbeddedTypeName { - export function Ref(value: Ref): EmbeddedTypeName {return {"_variant": "Ref", "value": value};}; + export function Ref(value: Ref): ( + EmbeddedTypeName & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} + ) { + return { + "_variant": "Ref", + "value": value, + __as_preserve__() {return fromEmbeddedTypeName(this);} + }; + }; Ref.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("EmbeddedTypeName"), - variant: _.Symbol.for("Ref"), - unparse: fromEmbeddedTypeName, - parse: toEmbeddedTypeName, - cast: asEmbeddedTypeName + variant: _.Symbol.for("Ref") }; }; - export function $false(): EmbeddedTypeName {return {"_variant": "false"};}; + export function $false(): ( + EmbeddedTypeName & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} + ) { + return {"_variant": "false", __as_preserve__() {return fromEmbeddedTypeName(this);}}; + }; $false.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("EmbeddedTypeName"), - variant: _.Symbol.for("false"), - unparse: fromEmbeddedTypeName, - parse: toEmbeddedTypeName, - cast: asEmbeddedTypeName + variant: _.Symbol.for("false") }; }; } @@ -233,10 +221,7 @@ Definitions.schema = function () { return { schema: _schema(), imports: _imports, - definitionName: _.Symbol.for("Definitions"), - unparse: fromDefinitions, - parse: toDefinitions, - cast: asDefinitions + definitionName: _.Symbol.for("Definitions") }; } @@ -247,12 +232,13 @@ export namespace Definition { pattern1: NamedAlternative<_embedded>, patternN: Array> } - ): Definition<_embedded> { + ): (Definition<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { return { "_variant": "or", "pattern0": pattern0, "pattern1": pattern1, - "patternN": patternN + "patternN": patternN, + __as_preserve__() {return fromDefinition(this);} }; }; or.schema = function () { @@ -260,10 +246,7 @@ export namespace Definition { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("Definition"), - variant: _.Symbol.for("or"), - unparse: fromDefinition, - parse: toDefinition, - cast: asDefinition + variant: _.Symbol.for("or") }; }; export function and<_embedded = _.GenericEmbedded>( @@ -272,12 +255,13 @@ export namespace Definition { pattern1: NamedPattern<_embedded>, patternN: Array> } - ): Definition<_embedded> { + ): (Definition<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { return { "_variant": "and", "pattern0": pattern0, "pattern1": pattern1, - "patternN": patternN + "patternN": patternN, + __as_preserve__() {return fromDefinition(this);} }; }; and.schema = function () { @@ -285,148 +269,175 @@ export namespace Definition { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("Definition"), - variant: _.Symbol.for("and"), - unparse: fromDefinition, - parse: toDefinition, - cast: asDefinition + variant: _.Symbol.for("and") + }; + }; + export function Pattern<_embedded = _.GenericEmbedded>(value: Pattern<_embedded>): (Definition<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "Pattern", + "value": value, + __as_preserve__() {return fromDefinition(this);} }; }; - export function Pattern<_embedded = _.GenericEmbedded>(value: Pattern<_embedded>): Definition<_embedded> {return {"_variant": "Pattern", "value": value};}; Pattern.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("Definition"), - variant: _.Symbol.for("Pattern"), - unparse: fromDefinition, - parse: toDefinition, - cast: asDefinition + variant: _.Symbol.for("Pattern") }; }; } export namespace Pattern { - export function SimplePattern<_embedded = _.GenericEmbedded>(value: SimplePattern<_embedded>): Pattern<_embedded> {return {"_variant": "SimplePattern", "value": value};}; + export function SimplePattern<_embedded = _.GenericEmbedded>(value: SimplePattern<_embedded>): (Pattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "SimplePattern", + "value": value, + __as_preserve__() {return fromPattern(this);} + }; + }; SimplePattern.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("Pattern"), - variant: _.Symbol.for("SimplePattern"), - unparse: fromPattern, - parse: toPattern, - cast: asPattern + variant: _.Symbol.for("SimplePattern") + }; + }; + export function CompoundPattern<_embedded = _.GenericEmbedded>(value: CompoundPattern<_embedded>): (Pattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "CompoundPattern", + "value": value, + __as_preserve__() {return fromPattern(this);} }; }; - export function CompoundPattern<_embedded = _.GenericEmbedded>(value: CompoundPattern<_embedded>): Pattern<_embedded> {return {"_variant": "CompoundPattern", "value": value};}; CompoundPattern.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("Pattern"), - variant: _.Symbol.for("CompoundPattern"), - unparse: fromPattern, - parse: toPattern, - cast: asPattern + variant: _.Symbol.for("CompoundPattern") }; }; } export namespace SimplePattern { - export function any<_embedded = _.GenericEmbedded>(): SimplePattern<_embedded> {return {"_variant": "any"};}; + export function any<_embedded = _.GenericEmbedded>(): (SimplePattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return {"_variant": "any", __as_preserve__() {return fromSimplePattern(this);}}; + }; any.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("SimplePattern"), - variant: _.Symbol.for("any"), - unparse: fromSimplePattern, - parse: toSimplePattern, - cast: asSimplePattern + variant: _.Symbol.for("any") + }; + }; + export function atom<_embedded = _.GenericEmbedded>(atomKind: AtomKind): (SimplePattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "atom", + "atomKind": atomKind, + __as_preserve__() {return fromSimplePattern(this);} }; }; - export function atom<_embedded = _.GenericEmbedded>(atomKind: AtomKind): SimplePattern<_embedded> {return {"_variant": "atom", "atomKind": atomKind};}; atom.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("SimplePattern"), - variant: _.Symbol.for("atom"), - unparse: fromSimplePattern, - parse: toSimplePattern, - cast: asSimplePattern + variant: _.Symbol.for("atom") + }; + }; + export function embedded<_embedded = _.GenericEmbedded>($interface: SimplePattern<_embedded>): (SimplePattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "embedded", + "interface": $interface, + __as_preserve__() {return fromSimplePattern(this);} }; }; - export function embedded<_embedded = _.GenericEmbedded>($interface: SimplePattern<_embedded>): SimplePattern<_embedded> {return {"_variant": "embedded", "interface": $interface};}; embedded.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("SimplePattern"), - variant: _.Symbol.for("embedded"), - unparse: fromSimplePattern, - parse: toSimplePattern, - cast: asSimplePattern + variant: _.Symbol.for("embedded") + }; + }; + export function lit<_embedded = _.GenericEmbedded>(value: _.Value<_embedded>): (SimplePattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "lit", + "value": value, + __as_preserve__() {return fromSimplePattern(this);} }; }; - export function lit<_embedded = _.GenericEmbedded>(value: _.Value<_embedded>): SimplePattern<_embedded> {return {"_variant": "lit", "value": value};}; lit.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("SimplePattern"), - variant: _.Symbol.for("lit"), - unparse: fromSimplePattern, - parse: toSimplePattern, - cast: asSimplePattern + variant: _.Symbol.for("lit") + }; + }; + export function seqof<_embedded = _.GenericEmbedded>(pattern: SimplePattern<_embedded>): (SimplePattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "seqof", + "pattern": pattern, + __as_preserve__() {return fromSimplePattern(this);} }; }; - export function seqof<_embedded = _.GenericEmbedded>(pattern: SimplePattern<_embedded>): SimplePattern<_embedded> {return {"_variant": "seqof", "pattern": pattern};}; seqof.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("SimplePattern"), - variant: _.Symbol.for("seqof"), - unparse: fromSimplePattern, - parse: toSimplePattern, - cast: asSimplePattern + variant: _.Symbol.for("seqof") + }; + }; + export function setof<_embedded = _.GenericEmbedded>(pattern: SimplePattern<_embedded>): (SimplePattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "setof", + "pattern": pattern, + __as_preserve__() {return fromSimplePattern(this);} }; }; - export function setof<_embedded = _.GenericEmbedded>(pattern: SimplePattern<_embedded>): SimplePattern<_embedded> {return {"_variant": "setof", "pattern": pattern};}; setof.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("SimplePattern"), - variant: _.Symbol.for("setof"), - unparse: fromSimplePattern, - parse: toSimplePattern, - cast: asSimplePattern + variant: _.Symbol.for("setof") + }; + }; + export function dictof<_embedded = _.GenericEmbedded>({key, value}: {key: SimplePattern<_embedded>, value: SimplePattern<_embedded>}): (SimplePattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "dictof", + "key": key, + "value": value, + __as_preserve__() {return fromSimplePattern(this);} }; }; - export function dictof<_embedded = _.GenericEmbedded>({key, value}: {key: SimplePattern<_embedded>, value: SimplePattern<_embedded>}): SimplePattern<_embedded> {return {"_variant": "dictof", "key": key, "value": value};}; dictof.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("SimplePattern"), - variant: _.Symbol.for("dictof"), - unparse: fromSimplePattern, - parse: toSimplePattern, - cast: asSimplePattern + variant: _.Symbol.for("dictof") + }; + }; + export function Ref<_embedded = _.GenericEmbedded>(value: Ref): (SimplePattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "Ref", + "value": value, + __as_preserve__() {return fromSimplePattern(this);} }; }; - export function Ref<_embedded = _.GenericEmbedded>(value: Ref): SimplePattern<_embedded> {return {"_variant": "Ref", "value": value};}; Ref.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("SimplePattern"), - variant: _.Symbol.for("Ref"), - unparse: fromSimplePattern, - parse: toSimplePattern, - cast: asSimplePattern + variant: _.Symbol.for("Ref") }; }; } @@ -434,54 +445,68 @@ export namespace SimplePattern { export namespace CompoundPattern { export function rec<_embedded = _.GenericEmbedded>( {label, fields}: {label: NamedPattern<_embedded>, fields: NamedPattern<_embedded>} - ): CompoundPattern<_embedded> {return {"_variant": "rec", "label": label, "fields": fields};}; + ): (CompoundPattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "rec", + "label": label, + "fields": fields, + __as_preserve__() {return fromCompoundPattern(this);} + }; + }; rec.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("CompoundPattern"), - variant: _.Symbol.for("rec"), - unparse: fromCompoundPattern, - parse: toCompoundPattern, - cast: asCompoundPattern + variant: _.Symbol.for("rec") + }; + }; + export function tuple<_embedded = _.GenericEmbedded>(patterns: Array>): (CompoundPattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "tuple", + "patterns": patterns, + __as_preserve__() {return fromCompoundPattern(this);} }; }; - export function tuple<_embedded = _.GenericEmbedded>(patterns: Array>): CompoundPattern<_embedded> {return {"_variant": "tuple", "patterns": patterns};}; tuple.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("CompoundPattern"), - variant: _.Symbol.for("tuple"), - unparse: fromCompoundPattern, - parse: toCompoundPattern, - cast: asCompoundPattern + variant: _.Symbol.for("tuple") }; }; export function tuplePrefix<_embedded = _.GenericEmbedded>( {fixed, variable}: {fixed: Array>, variable: NamedSimplePattern<_embedded>} - ): CompoundPattern<_embedded> {return {"_variant": "tuplePrefix", "fixed": fixed, "variable": variable};}; + ): (CompoundPattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "tuplePrefix", + "fixed": fixed, + "variable": variable, + __as_preserve__() {return fromCompoundPattern(this);} + }; + }; tuplePrefix.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("CompoundPattern"), - variant: _.Symbol.for("tuplePrefix"), - unparse: fromCompoundPattern, - parse: toCompoundPattern, - cast: asCompoundPattern + variant: _.Symbol.for("tuplePrefix") + }; + }; + export function dict<_embedded = _.GenericEmbedded>(entries: DictionaryEntries<_embedded>): (CompoundPattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "dict", + "entries": entries, + __as_preserve__() {return fromCompoundPattern(this);} }; }; - export function dict<_embedded = _.GenericEmbedded>(entries: DictionaryEntries<_embedded>): CompoundPattern<_embedded> {return {"_variant": "dict", "entries": entries};}; dict.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("CompoundPattern"), - variant: _.Symbol.for("dict"), - unparse: fromCompoundPattern, - parse: toCompoundPattern, - cast: asCompoundPattern + variant: _.Symbol.for("dict") }; }; } @@ -494,191 +519,203 @@ DictionaryEntries.schema = function () { return { schema: _schema(), imports: _imports, - definitionName: _.Symbol.for("DictionaryEntries"), - unparse: fromDictionaryEntries, - parse: toDictionaryEntries, - cast: asDictionaryEntries + definitionName: _.Symbol.for("DictionaryEntries") }; } export namespace AtomKind { - export function Boolean(): AtomKind {return {"_variant": "Boolean"};}; + export function Boolean(): ( + AtomKind & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} + ) { + return {"_variant": "Boolean", __as_preserve__() {return fromAtomKind(this);}}; + }; Boolean.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("AtomKind"), - variant: _.Symbol.for("Boolean"), - unparse: fromAtomKind, - parse: toAtomKind, - cast: asAtomKind + variant: _.Symbol.for("Boolean") }; }; - export function Float(): AtomKind {return {"_variant": "Float"};}; + export function Float(): ( + AtomKind & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} + ) {return {"_variant": "Float", __as_preserve__() {return fromAtomKind(this);}};}; Float.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("AtomKind"), - variant: _.Symbol.for("Float"), - unparse: fromAtomKind, - parse: toAtomKind, - cast: asAtomKind + variant: _.Symbol.for("Float") }; }; - export function Double(): AtomKind {return {"_variant": "Double"};}; + export function Double(): ( + AtomKind & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} + ) {return {"_variant": "Double", __as_preserve__() {return fromAtomKind(this);}};}; Double.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("AtomKind"), - variant: _.Symbol.for("Double"), - unparse: fromAtomKind, - parse: toAtomKind, - cast: asAtomKind + variant: _.Symbol.for("Double") }; }; - export function SignedInteger(): AtomKind {return {"_variant": "SignedInteger"};}; + export function SignedInteger(): ( + AtomKind & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} + ) { + return {"_variant": "SignedInteger", __as_preserve__() {return fromAtomKind(this);}}; + }; SignedInteger.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("AtomKind"), - variant: _.Symbol.for("SignedInteger"), - unparse: fromAtomKind, - parse: toAtomKind, - cast: asAtomKind + variant: _.Symbol.for("SignedInteger") }; }; - export function String(): AtomKind {return {"_variant": "String"};}; + export function String(): ( + AtomKind & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} + ) {return {"_variant": "String", __as_preserve__() {return fromAtomKind(this);}};}; String.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("AtomKind"), - variant: _.Symbol.for("String"), - unparse: fromAtomKind, - parse: toAtomKind, - cast: asAtomKind + variant: _.Symbol.for("String") }; }; - export function ByteString(): AtomKind {return {"_variant": "ByteString"};}; + export function ByteString(): ( + AtomKind & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} + ) { + return {"_variant": "ByteString", __as_preserve__() {return fromAtomKind(this);}}; + }; ByteString.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("AtomKind"), - variant: _.Symbol.for("ByteString"), - unparse: fromAtomKind, - parse: toAtomKind, - cast: asAtomKind + variant: _.Symbol.for("ByteString") }; }; - export function Symbol(): AtomKind {return {"_variant": "Symbol"};}; + export function Symbol(): ( + AtomKind & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} + ) {return {"_variant": "Symbol", __as_preserve__() {return fromAtomKind(this);}};}; Symbol.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("AtomKind"), - variant: _.Symbol.for("Symbol"), - unparse: fromAtomKind, - parse: toAtomKind, - cast: asAtomKind + variant: _.Symbol.for("Symbol") }; }; } -export function NamedAlternative<_embedded = _.GenericEmbedded>({variantLabel, pattern}: {variantLabel: string, pattern: Pattern<_embedded>}): NamedAlternative<_embedded> {return {"variantLabel": variantLabel, "pattern": pattern};} +export function NamedAlternative<_embedded = _.GenericEmbedded>({variantLabel, pattern}: {variantLabel: string, pattern: Pattern<_embedded>}): (NamedAlternative<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "variantLabel": variantLabel, + "pattern": pattern, + __as_preserve__() {return fromNamedAlternative(this);} + }; +} NamedAlternative.schema = function () { return { schema: _schema(), imports: _imports, - definitionName: _.Symbol.for("NamedAlternative"), - unparse: fromNamedAlternative, - parse: toNamedAlternative, - cast: asNamedAlternative + definitionName: _.Symbol.for("NamedAlternative") }; } export namespace NamedSimplePattern { - export function named<_embedded = _.GenericEmbedded>(value: Binding<_embedded>): NamedSimplePattern<_embedded> {return {"_variant": "named", "value": value};}; + export function named<_embedded = _.GenericEmbedded>(value: Binding<_embedded>): (NamedSimplePattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "named", + "value": value, + __as_preserve__() {return fromNamedSimplePattern(this);} + }; + }; named.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("NamedSimplePattern"), - variant: _.Symbol.for("named"), - unparse: fromNamedSimplePattern, - parse: toNamedSimplePattern, - cast: asNamedSimplePattern + variant: _.Symbol.for("named") + }; + }; + export function anonymous<_embedded = _.GenericEmbedded>(value: SimplePattern<_embedded>): (NamedSimplePattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "anonymous", + "value": value, + __as_preserve__() {return fromNamedSimplePattern(this);} }; }; - export function anonymous<_embedded = _.GenericEmbedded>(value: SimplePattern<_embedded>): NamedSimplePattern<_embedded> {return {"_variant": "anonymous", "value": value};}; anonymous.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("NamedSimplePattern"), - variant: _.Symbol.for("anonymous"), - unparse: fromNamedSimplePattern, - parse: toNamedSimplePattern, - cast: asNamedSimplePattern + variant: _.Symbol.for("anonymous") }; }; } export namespace NamedPattern { - export function named<_embedded = _.GenericEmbedded>(value: Binding<_embedded>): NamedPattern<_embedded> {return {"_variant": "named", "value": value};}; + export function named<_embedded = _.GenericEmbedded>(value: Binding<_embedded>): (NamedPattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "named", + "value": value, + __as_preserve__() {return fromNamedPattern(this);} + }; + }; named.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("NamedPattern"), - variant: _.Symbol.for("named"), - unparse: fromNamedPattern, - parse: toNamedPattern, - cast: asNamedPattern + variant: _.Symbol.for("named") + }; + }; + export function anonymous<_embedded = _.GenericEmbedded>(value: Pattern<_embedded>): (NamedPattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + return { + "_variant": "anonymous", + "value": value, + __as_preserve__() {return fromNamedPattern(this);} }; }; - export function anonymous<_embedded = _.GenericEmbedded>(value: Pattern<_embedded>): NamedPattern<_embedded> {return {"_variant": "anonymous", "value": value};}; anonymous.schema = function () { return { schema: _schema(), imports: _imports, definitionName: _.Symbol.for("NamedPattern"), - variant: _.Symbol.for("anonymous"), - unparse: fromNamedPattern, - parse: toNamedPattern, - cast: asNamedPattern + variant: _.Symbol.for("anonymous") }; }; } -export function Binding<_embedded = _.GenericEmbedded>({name, pattern}: {name: symbol, pattern: SimplePattern<_embedded>}): Binding<_embedded> {return {"name": name, "pattern": pattern};} - -Binding.schema = function () { +export function Binding<_embedded = _.GenericEmbedded>({name, pattern}: {name: symbol, pattern: SimplePattern<_embedded>}): (Binding<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { return { - schema: _schema(), - imports: _imports, - definitionName: _.Symbol.for("Binding"), - unparse: fromBinding, - parse: toBinding, - cast: asBinding + "name": name, + "pattern": pattern, + __as_preserve__() {return fromBinding(this);} }; } -export function Ref({module, name}: {module: ModulePath, name: symbol}): Ref {return {"module": module, "name": name};} +Binding.schema = function () { + return {schema: _schema(), imports: _imports, definitionName: _.Symbol.for("Binding")}; +} + +export function Ref({module, name}: {module: ModulePath, name: symbol}): (Ref & {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}) { + return {"module": module, "name": name, __as_preserve__() {return fromRef(this);}}; +} Ref.schema = function () { - return { - schema: _schema(), - imports: _imports, - definitionName: _.Symbol.for("Ref"), - unparse: fromRef, - parse: toRef, - cast: asRef - }; + return {schema: _schema(), imports: _imports, definitionName: _.Symbol.for("Ref")}; } export function ModulePath(value: Array): ModulePath {return value;} @@ -687,33 +724,32 @@ ModulePath.schema = function () { return { schema: _schema(), imports: _imports, - definitionName: _.Symbol.for("ModulePath"), - unparse: fromModulePath, - parse: toModulePath, - cast: asModulePath + definitionName: _.Symbol.for("ModulePath") }; } -export function asBundle<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Bundle<_embedded> { +export function asBundle<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): (Bundle<_embedded> & {__as_preserve__(): _.Value<_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> { - let result: undefined | Bundle<_embedded>; +export function toBundle<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | (Bundle<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + let result: undefined | (Bundle<_embedded> & {__as_preserve__(): _.Value<_embedded>}); if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { - let _tmp0: (null) | undefined; - _tmp0 = _.is(v.label, $bundle) ? null : void 0; + let _tmp0: ({}) | undefined; + _tmp0 = _.is(v.label, $bundle) ? {} : void 0; if (_tmp0 !== void 0) { let _tmp1: (Modules<_embedded>) | undefined; _tmp1 = toModules(v[0]); - if (_tmp1 !== void 0) {result = {"modules": _tmp1};}; + if (_tmp1 !== void 0) {result = {"modules": _tmp1, __as_preserve__() {return fromBundle(this);}};}; }; }; return result; } +Bundle.__from_preserve__ = toBundle; + export function fromBundle<_embedded = _.GenericEmbedded>(_v: Bundle<_embedded>): _.Value<_embedded> {return _.Record($bundle, [fromModules<_embedded>(_v["modules"])]);} export function asModules<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Modules<_embedded> { @@ -744,23 +780,25 @@ export function toModules<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): return result; } +Modules.__from_preserve__ = toModules; + export function fromModules<_embedded = _.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 = _.GenericEmbedded>(v: _.Value<_embedded>): (Schema<_embedded> & {__as_preserve__(): _.Value<_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> { - let result: undefined | Schema<_embedded>; +export function toSchema<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | (Schema<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + let result: undefined | (Schema<_embedded> & {__as_preserve__(): _.Value<_embedded>}); if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { - let _tmp0: (null) | undefined; - _tmp0 = _.is(v.label, $schema) ? null : void 0; + let _tmp0: ({}) | undefined; + _tmp0 = _.is(v.label, $schema) ? {} : void 0; if (_tmp0 !== void 0) { if (_.Dictionary.isDictionary<_embedded>(v[0])) { let _tmp1: (_.Value<_embedded>) | undefined; @@ -777,7 +815,14 @@ export function toSchema<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): if ((_tmp5 = v[0].get($definitions)) !== void 0) { let _tmp6: (Definitions<_embedded>) | undefined; _tmp6 = toDefinitions(_tmp5); - if (_tmp6 !== void 0) {result = {"version": _tmp2, "embeddedType": _tmp4, "definitions": _tmp6};}; + if (_tmp6 !== void 0) { + result = { + "version": _tmp2, + "embeddedType": _tmp4, + "definitions": _tmp6, + __as_preserve__() {return fromSchema(this);} + }; + }; }; }; }; @@ -789,6 +834,8 @@ export function toSchema<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): return result; } +Schema.__from_preserve__ = toSchema; + export function fromSchema<_embedded = _.GenericEmbedded>(_v: Schema<_embedded>): _.Value<_embedded> { return _.Record( $schema, @@ -804,41 +851,71 @@ export function fromSchema<_embedded = _.GenericEmbedded>(_v: Schema<_embedded>) ); } -export function asVersion<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Version { +export function asVersion<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): ( + Version & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} +) { 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 { - let _tmp0: (null) | undefined; - let result: undefined | Version; - _tmp0 = _.is(v, $1) ? null : void 0; - if (_tmp0 !== void 0) {result = _tmp0;}; +export function toVersion<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | ( + Version & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} +) { + let _tmp0: ({}) | undefined; + let result: undefined | ( + Version & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} + ); + _tmp0 = _.is(v, $1) ? {} : void 0; + if (_tmp0 !== void 0) {result = {__as_preserve__() {return fromVersion(this);}};}; return result; } +Version.__from_preserve__ = toVersion; + export function fromVersion<_embedded = _.GenericEmbedded>(_v: Version): _.Value<_embedded> {return $1;} -export function asEmbeddedTypeName<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): EmbeddedTypeName { +export function asEmbeddedTypeName<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): ( + EmbeddedTypeName & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} +) { 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 = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | ( + EmbeddedTypeName & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} +) { let _tmp0: (Ref) | undefined; - let result: undefined | EmbeddedTypeName; + let result: undefined | ( + EmbeddedTypeName & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} + ); _tmp0 = toRef(v); - if (_tmp0 !== void 0) {result = {"_variant": "Ref", "value": _tmp0};}; + if (_tmp0 !== void 0) { + result = { + "_variant": "Ref", + "value": _tmp0, + __as_preserve__() {return fromEmbeddedTypeName(this);} + }; + }; if (result === void 0) { - let _tmp1: (null) | undefined; - _tmp1 = _.is(v, __lit6) ? null : void 0; - if (_tmp1 !== void 0) {result = {"_variant": "false"};}; + let _tmp1: ({}) | undefined; + _tmp1 = _.is(v, __lit6) ? {} : void 0; + if (_tmp1 !== void 0) { + result = {"_variant": "false", __as_preserve__() {return fromEmbeddedTypeName(this);}}; + }; }; return result; } +export namespace EmbeddedTypeName {export const __from_preserve__ = toEmbeddedTypeName;} + export function fromEmbeddedTypeName<_embedded = _.GenericEmbedded>(_v: EmbeddedTypeName): _.Value<_embedded> { switch (_v._variant) { case "Ref": {return fromRef<_embedded>(_v.value);}; @@ -874,21 +951,23 @@ export function toDefinitions<_embedded = _.GenericEmbedded>(v: _.Value<_embedde return result; } +Definitions.__from_preserve__ = toDefinitions; + export function fromDefinitions<_embedded = _.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 = _.GenericEmbedded>(v: _.Value<_embedded>): (Definition<_embedded> & {__as_preserve__(): _.Value<_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> { - let result: undefined | Definition<_embedded>; +export function toDefinition<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | (Definition<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + let result: undefined | (Definition<_embedded> & {__as_preserve__(): _.Value<_embedded>}); if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { - let _tmp0: (null) | undefined; - _tmp0 = _.is(v.label, $or) ? null : void 0; + let _tmp0: ({}) | undefined; + _tmp0 = _.is(v.label, $or) ? {} : void 0; if (_tmp0 !== void 0) { if (_.Array.isArray(v[0]) && v[0].length >= 2) { let _tmp1: (NamedAlternative<_embedded>) | undefined; @@ -909,7 +988,13 @@ export function toDefinition<_embedded = _.GenericEmbedded>(v: _.Value<_embedded break; }; if (_tmp4 !== void 0) { - result = {"_variant": "or", "pattern0": _tmp1, "pattern1": _tmp2, "patternN": _tmp4}; + result = { + "_variant": "or", + "pattern0": _tmp1, + "pattern1": _tmp2, + "patternN": _tmp4, + __as_preserve__() {return fromDefinition(this);} + }; }; }; }; @@ -918,8 +1003,8 @@ export function toDefinition<_embedded = _.GenericEmbedded>(v: _.Value<_embedded }; if (result === void 0) { if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { - let _tmp7: (null) | undefined; - _tmp7 = _.is(v.label, $and) ? null : void 0; + let _tmp7: ({}) | undefined; + _tmp7 = _.is(v.label, $and) ? {} : void 0; if (_tmp7 !== void 0) { if (_.Array.isArray(v[0]) && v[0].length >= 2) { let _tmp8: (NamedPattern<_embedded>) | undefined; @@ -940,7 +1025,13 @@ export function toDefinition<_embedded = _.GenericEmbedded>(v: _.Value<_embedded break; }; if (_tmp11 !== void 0) { - result = {"_variant": "and", "pattern0": _tmp8, "pattern1": _tmp9, "patternN": _tmp11}; + result = { + "_variant": "and", + "pattern0": _tmp8, + "pattern1": _tmp9, + "patternN": _tmp11, + __as_preserve__() {return fromDefinition(this);} + }; }; }; }; @@ -950,12 +1041,20 @@ export function toDefinition<_embedded = _.GenericEmbedded>(v: _.Value<_embedded if (result === void 0) { let _tmp14: (Pattern<_embedded>) | undefined; _tmp14 = toPattern(v); - if (_tmp14 !== void 0) {result = {"_variant": "Pattern", "value": _tmp14};}; + if (_tmp14 !== void 0) { + result = { + "_variant": "Pattern", + "value": _tmp14, + __as_preserve__() {return fromDefinition(this);} + }; + }; }; }; return result; } +export namespace Definition {export const __from_preserve__ = toDefinition;} + export function fromDefinition<_embedded = _.GenericEmbedded>(_v: Definition<_embedded>): _.Value<_embedded> { switch (_v._variant) { case "or": { @@ -986,25 +1085,39 @@ export function fromDefinition<_embedded = _.GenericEmbedded>(_v: Definition<_em }; } -export function asPattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Pattern<_embedded> { +export function asPattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): (Pattern<_embedded> & {__as_preserve__(): _.Value<_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 = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | (Pattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { let _tmp0: (SimplePattern<_embedded>) | undefined; - let result: undefined | Pattern<_embedded>; + let result: undefined | (Pattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}); _tmp0 = toSimplePattern(v); - if (_tmp0 !== void 0) {result = {"_variant": "SimplePattern", "value": _tmp0};}; + if (_tmp0 !== void 0) { + result = { + "_variant": "SimplePattern", + "value": _tmp0, + __as_preserve__() {return fromPattern(this);} + }; + }; if (result === void 0) { let _tmp1: (CompoundPattern<_embedded>) | undefined; _tmp1 = toCompoundPattern(v); - if (_tmp1 !== void 0) {result = {"_variant": "CompoundPattern", "value": _tmp1};}; + if (_tmp1 !== void 0) { + result = { + "_variant": "CompoundPattern", + "value": _tmp1, + __as_preserve__() {return fromPattern(this);} + }; + }; }; return result; } +export namespace Pattern {export const __from_preserve__ = toPattern;} + export function fromPattern<_embedded = _.GenericEmbedded>(_v: Pattern<_embedded>): _.Value<_embedded> { switch (_v._variant) { case "SimplePattern": {return fromSimplePattern<_embedded>(_v.value);}; @@ -1012,85 +1125,130 @@ export function fromPattern<_embedded = _.GenericEmbedded>(_v: Pattern<_embedded }; } -export function asSimplePattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): SimplePattern<_embedded> { +export function asSimplePattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): (SimplePattern<_embedded> & {__as_preserve__(): _.Value<_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> { - let _tmp0: (null) | undefined; - let result: undefined | SimplePattern<_embedded>; - _tmp0 = _.is(v, $any) ? null : void 0; - if (_tmp0 !== void 0) {result = {"_variant": "any"};}; +export function toSimplePattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | (SimplePattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + let _tmp0: ({}) | undefined; + let result: undefined | (SimplePattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}); + _tmp0 = _.is(v, $any) ? {} : void 0; + if (_tmp0 !== void 0) { + result = {"_variant": "any", __as_preserve__() {return fromSimplePattern(this);}}; + }; if (result === void 0) { if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { - let _tmp1: (null) | undefined; - _tmp1 = _.is(v.label, $atom) ? null : void 0; + let _tmp1: ({}) | undefined; + _tmp1 = _.is(v.label, $atom) ? {} : void 0; if (_tmp1 !== void 0) { let _tmp2: (AtomKind) | undefined; _tmp2 = toAtomKind(v[0]); - if (_tmp2 !== void 0) {result = {"_variant": "atom", "atomKind": _tmp2};}; + if (_tmp2 !== void 0) { + result = { + "_variant": "atom", + "atomKind": _tmp2, + __as_preserve__() {return fromSimplePattern(this);} + }; + }; }; }; if (result === void 0) { if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { - let _tmp3: (null) | undefined; - _tmp3 = _.is(v.label, $embedded) ? null : void 0; + let _tmp3: ({}) | undefined; + _tmp3 = _.is(v.label, $embedded) ? {} : void 0; if (_tmp3 !== void 0) { let _tmp4: (SimplePattern<_embedded>) | undefined; _tmp4 = toSimplePattern(v[0]); - if (_tmp4 !== void 0) {result = {"_variant": "embedded", "interface": _tmp4};}; + if (_tmp4 !== void 0) { + result = { + "_variant": "embedded", + "interface": _tmp4, + __as_preserve__() {return fromSimplePattern(this);} + }; + }; }; }; if (result === void 0) { if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { - let _tmp5: (null) | undefined; - _tmp5 = _.is(v.label, $lit) ? null : void 0; + let _tmp5: ({}) | undefined; + _tmp5 = _.is(v.label, $lit) ? {} : void 0; if (_tmp5 !== void 0) { let _tmp6: (_.Value<_embedded>) | undefined; _tmp6 = v[0]; - if (_tmp6 !== void 0) {result = {"_variant": "lit", "value": _tmp6};}; + if (_tmp6 !== void 0) { + result = { + "_variant": "lit", + "value": _tmp6, + __as_preserve__() {return fromSimplePattern(this);} + }; + }; }; }; if (result === void 0) { if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { - let _tmp7: (null) | undefined; - _tmp7 = _.is(v.label, $seqof) ? null : void 0; + let _tmp7: ({}) | undefined; + _tmp7 = _.is(v.label, $seqof) ? {} : void 0; if (_tmp7 !== void 0) { let _tmp8: (SimplePattern<_embedded>) | undefined; _tmp8 = toSimplePattern(v[0]); - if (_tmp8 !== void 0) {result = {"_variant": "seqof", "pattern": _tmp8};}; + if (_tmp8 !== void 0) { + result = { + "_variant": "seqof", + "pattern": _tmp8, + __as_preserve__() {return fromSimplePattern(this);} + }; + }; }; }; if (result === void 0) { if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { - let _tmp9: (null) | undefined; - _tmp9 = _.is(v.label, $setof) ? null : void 0; + let _tmp9: ({}) | undefined; + _tmp9 = _.is(v.label, $setof) ? {} : void 0; if (_tmp9 !== void 0) { let _tmp10: (SimplePattern<_embedded>) | undefined; _tmp10 = toSimplePattern(v[0]); - if (_tmp10 !== void 0) {result = {"_variant": "setof", "pattern": _tmp10};}; + if (_tmp10 !== void 0) { + result = { + "_variant": "setof", + "pattern": _tmp10, + __as_preserve__() {return fromSimplePattern(this);} + }; + }; }; }; if (result === void 0) { if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { - let _tmp11: (null) | undefined; - _tmp11 = _.is(v.label, $dictof) ? null : void 0; + let _tmp11: ({}) | undefined; + _tmp11 = _.is(v.label, $dictof) ? {} : void 0; if (_tmp11 !== void 0) { let _tmp12: (SimplePattern<_embedded>) | undefined; _tmp12 = toSimplePattern(v[0]); if (_tmp12 !== void 0) { let _tmp13: (SimplePattern<_embedded>) | undefined; _tmp13 = toSimplePattern(v[1]); - if (_tmp13 !== void 0) {result = {"_variant": "dictof", "key": _tmp12, "value": _tmp13};}; + if (_tmp13 !== void 0) { + result = { + "_variant": "dictof", + "key": _tmp12, + "value": _tmp13, + __as_preserve__() {return fromSimplePattern(this);} + }; + }; }; }; }; if (result === void 0) { let _tmp14: (Ref) | undefined; _tmp14 = toRef(v); - if (_tmp14 !== void 0) {result = {"_variant": "Ref", "value": _tmp14};}; + if (_tmp14 !== void 0) { + result = { + "_variant": "Ref", + "value": _tmp14, + __as_preserve__() {return fromSimplePattern(this);} + }; + }; }; }; }; @@ -1101,6 +1259,8 @@ export function toSimplePattern<_embedded = _.GenericEmbedded>(v: _.Value<_embed return result; } +export namespace SimplePattern {export const __from_preserve__ = toSimplePattern;} + export function fromSimplePattern<_embedded = _.GenericEmbedded>(_v: SimplePattern<_embedded>): _.Value<_embedded> { switch (_v._variant) { case "any": {return $any;}; @@ -1122,31 +1282,38 @@ export function fromSimplePattern<_embedded = _.GenericEmbedded>(_v: SimplePatte }; } -export function asCompoundPattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): CompoundPattern<_embedded> { +export function asCompoundPattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): (CompoundPattern<_embedded> & {__as_preserve__(): _.Value<_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> { - let result: undefined | CompoundPattern<_embedded>; +export function toCompoundPattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | (CompoundPattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + let result: undefined | (CompoundPattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}); if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { - let _tmp0: (null) | undefined; - _tmp0 = _.is(v.label, $rec) ? null : void 0; + let _tmp0: ({}) | undefined; + _tmp0 = _.is(v.label, $rec) ? {} : void 0; if (_tmp0 !== void 0) { let _tmp1: (NamedPattern<_embedded>) | undefined; _tmp1 = toNamedPattern(v[0]); if (_tmp1 !== void 0) { let _tmp2: (NamedPattern<_embedded>) | undefined; _tmp2 = toNamedPattern(v[1]); - if (_tmp2 !== void 0) {result = {"_variant": "rec", "label": _tmp1, "fields": _tmp2};}; + if (_tmp2 !== void 0) { + result = { + "_variant": "rec", + "label": _tmp1, + "fields": _tmp2, + __as_preserve__() {return fromCompoundPattern(this);} + }; + }; }; }; }; if (result === void 0) { if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { - let _tmp3: (null) | undefined; - _tmp3 = _.is(v.label, $tuple) ? null : void 0; + let _tmp3: ({}) | undefined; + _tmp3 = _.is(v.label, $tuple) ? {} : void 0; if (_tmp3 !== void 0) { let _tmp4: (Array>) | undefined; _tmp4 = void 0; @@ -1160,13 +1327,19 @@ export function toCompoundPattern<_embedded = _.GenericEmbedded>(v: _.Value<_emb break; }; }; - if (_tmp4 !== void 0) {result = {"_variant": "tuple", "patterns": _tmp4};}; + if (_tmp4 !== void 0) { + result = { + "_variant": "tuple", + "patterns": _tmp4, + __as_preserve__() {return fromCompoundPattern(this);} + }; + }; }; }; if (result === void 0) { if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { - let _tmp7: (null) | undefined; - _tmp7 = _.is(v.label, $tuplePrefix) ? null : void 0; + let _tmp7: ({}) | undefined; + _tmp7 = _.is(v.label, $tuplePrefix) ? {} : void 0; if (_tmp7 !== void 0) { let _tmp8: (Array>) | undefined; _tmp8 = void 0; @@ -1183,18 +1356,31 @@ export function toCompoundPattern<_embedded = _.GenericEmbedded>(v: _.Value<_emb if (_tmp8 !== void 0) { let _tmp11: (NamedSimplePattern<_embedded>) | undefined; _tmp11 = toNamedSimplePattern(v[1]); - if (_tmp11 !== void 0) {result = {"_variant": "tuplePrefix", "fixed": _tmp8, "variable": _tmp11};}; + if (_tmp11 !== void 0) { + result = { + "_variant": "tuplePrefix", + "fixed": _tmp8, + "variable": _tmp11, + __as_preserve__() {return fromCompoundPattern(this);} + }; + }; }; }; }; if (result === void 0) { if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { - let _tmp12: (null) | undefined; - _tmp12 = _.is(v.label, $dict) ? null : void 0; + let _tmp12: ({}) | undefined; + _tmp12 = _.is(v.label, $dict) ? {} : void 0; if (_tmp12 !== void 0) { let _tmp13: (DictionaryEntries<_embedded>) | undefined; _tmp13 = toDictionaryEntries(v[0]); - if (_tmp13 !== void 0) {result = {"_variant": "dict", "entries": _tmp13};}; + if (_tmp13 !== void 0) { + result = { + "_variant": "dict", + "entries": _tmp13, + __as_preserve__() {return fromCompoundPattern(this);} + }; + }; }; }; }; @@ -1203,6 +1389,8 @@ export function toCompoundPattern<_embedded = _.GenericEmbedded>(v: _.Value<_emb return result; } +export namespace CompoundPattern {export const __from_preserve__ = toCompoundPattern;} + export function fromCompoundPattern<_embedded = _.GenericEmbedded>(_v: CompoundPattern<_embedded>): _.Value<_embedded> { switch (_v._variant) { case "rec": { @@ -1258,47 +1446,72 @@ export function toDictionaryEntries<_embedded = _.GenericEmbedded>(v: _.Value<_e return result; } +DictionaryEntries.__from_preserve__ = toDictionaryEntries; + export function fromDictionaryEntries<_embedded = _.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 = _.GenericEmbedded>(v: _.Value<_embedded>): ( + AtomKind & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} +) { 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 { - let _tmp0: (null) | undefined; - let result: undefined | AtomKind; - _tmp0 = _.is(v, $Boolean) ? null : void 0; - if (_tmp0 !== void 0) {result = {"_variant": "Boolean"};}; +export function toAtomKind<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | ( + AtomKind & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} +) { + let _tmp0: ({}) | undefined; + let result: undefined | ( + AtomKind & + {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>} + ); + _tmp0 = _.is(v, $Boolean) ? {} : void 0; + if (_tmp0 !== void 0) { + result = {"_variant": "Boolean", __as_preserve__() {return fromAtomKind(this);}}; + }; if (result === void 0) { - let _tmp1: (null) | undefined; - _tmp1 = _.is(v, $Float) ? null : void 0; - if (_tmp1 !== void 0) {result = {"_variant": "Float"};}; + let _tmp1: ({}) | undefined; + _tmp1 = _.is(v, $Float) ? {} : void 0; + if (_tmp1 !== void 0) { + result = {"_variant": "Float", __as_preserve__() {return fromAtomKind(this);}}; + }; if (result === void 0) { - let _tmp2: (null) | undefined; - _tmp2 = _.is(v, $Double) ? null : void 0; - if (_tmp2 !== void 0) {result = {"_variant": "Double"};}; + let _tmp2: ({}) | undefined; + _tmp2 = _.is(v, $Double) ? {} : void 0; + if (_tmp2 !== void 0) { + result = {"_variant": "Double", __as_preserve__() {return fromAtomKind(this);}}; + }; if (result === void 0) { - let _tmp3: (null) | undefined; - _tmp3 = _.is(v, $SignedInteger) ? null : void 0; - if (_tmp3 !== void 0) {result = {"_variant": "SignedInteger"};}; + let _tmp3: ({}) | undefined; + _tmp3 = _.is(v, $SignedInteger) ? {} : void 0; + if (_tmp3 !== void 0) { + result = {"_variant": "SignedInteger", __as_preserve__() {return fromAtomKind(this);}}; + }; if (result === void 0) { - let _tmp4: (null) | undefined; - _tmp4 = _.is(v, $String) ? null : void 0; - if (_tmp4 !== void 0) {result = {"_variant": "String"};}; + let _tmp4: ({}) | undefined; + _tmp4 = _.is(v, $String) ? {} : void 0; + if (_tmp4 !== void 0) { + result = {"_variant": "String", __as_preserve__() {return fromAtomKind(this);}}; + }; if (result === void 0) { - let _tmp5: (null) | undefined; - _tmp5 = _.is(v, $ByteString) ? null : void 0; - if (_tmp5 !== void 0) {result = {"_variant": "ByteString"};}; + let _tmp5: ({}) | undefined; + _tmp5 = _.is(v, $ByteString) ? {} : void 0; + if (_tmp5 !== void 0) { + result = {"_variant": "ByteString", __as_preserve__() {return fromAtomKind(this);}}; + }; if (result === void 0) { - let _tmp6: (null) | undefined; - _tmp6 = _.is(v, $Symbol) ? null : void 0; - if (_tmp6 !== void 0) {result = {"_variant": "Symbol"};}; + let _tmp6: ({}) | undefined; + _tmp6 = _.is(v, $Symbol) ? {} : void 0; + if (_tmp6 !== void 0) { + result = {"_variant": "Symbol", __as_preserve__() {return fromAtomKind(this);}}; + }; }; }; }; @@ -1308,6 +1521,8 @@ export function toAtomKind<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>) return result; } +export namespace AtomKind {export const __from_preserve__ = toAtomKind;} + export function fromAtomKind<_embedded = _.GenericEmbedded>(_v: AtomKind): _.Value<_embedded> { switch (_v._variant) { case "Boolean": {return $Boolean;}; @@ -1320,47 +1535,69 @@ export function fromAtomKind<_embedded = _.GenericEmbedded>(_v: AtomKind): _.Val }; } -export function asNamedAlternative<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): NamedAlternative<_embedded> { +export function asNamedAlternative<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): (NamedAlternative<_embedded> & {__as_preserve__(): _.Value<_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> { - let result: undefined | NamedAlternative<_embedded>; +export function toNamedAlternative<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | (NamedAlternative<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + let result: undefined | (NamedAlternative<_embedded> & {__as_preserve__(): _.Value<_embedded>}); if (_.Array.isArray(v) && v.length === 2) { let _tmp0: (string) | undefined; _tmp0 = typeof v[0] === 'string' ? v[0] : void 0; if (_tmp0 !== void 0) { let _tmp1: (Pattern<_embedded>) | undefined; _tmp1 = toPattern(v[1]); - if (_tmp1 !== void 0) {result = {"variantLabel": _tmp0, "pattern": _tmp1};}; + if (_tmp1 !== void 0) { + result = { + "variantLabel": _tmp0, + "pattern": _tmp1, + __as_preserve__() {return fromNamedAlternative(this);} + }; + }; }; }; return result; } +NamedAlternative.__from_preserve__ = toNamedAlternative; + export function fromNamedAlternative<_embedded = _.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 = _.GenericEmbedded>(v: _.Value<_embedded>): (NamedSimplePattern<_embedded> & {__as_preserve__(): _.Value<_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 = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | (NamedSimplePattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { let _tmp0: (Binding<_embedded>) | undefined; - let result: undefined | NamedSimplePattern<_embedded>; + let result: undefined | (NamedSimplePattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}); _tmp0 = toBinding(v); - if (_tmp0 !== void 0) {result = {"_variant": "named", "value": _tmp0};}; + if (_tmp0 !== void 0) { + result = { + "_variant": "named", + "value": _tmp0, + __as_preserve__() {return fromNamedSimplePattern(this);} + }; + }; if (result === void 0) { let _tmp1: (SimplePattern<_embedded>) | undefined; _tmp1 = toSimplePattern(v); - if (_tmp1 !== void 0) {result = {"_variant": "anonymous", "value": _tmp1};}; + if (_tmp1 !== void 0) { + result = { + "_variant": "anonymous", + "value": _tmp1, + __as_preserve__() {return fromNamedSimplePattern(this);} + }; + }; }; return result; } +export namespace NamedSimplePattern {export const __from_preserve__ = toNamedSimplePattern;} + export function fromNamedSimplePattern<_embedded = _.GenericEmbedded>(_v: NamedSimplePattern<_embedded>): _.Value<_embedded> { switch (_v._variant) { case "named": {return fromBinding<_embedded>(_v.value);}; @@ -1368,25 +1605,39 @@ export function fromNamedSimplePattern<_embedded = _.GenericEmbedded>(_v: NamedS }; } -export function asNamedPattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): NamedPattern<_embedded> { +export function asNamedPattern<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): (NamedPattern<_embedded> & {__as_preserve__(): _.Value<_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 = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | (NamedPattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { let _tmp0: (Binding<_embedded>) | undefined; - let result: undefined | NamedPattern<_embedded>; + let result: undefined | (NamedPattern<_embedded> & {__as_preserve__(): _.Value<_embedded>}); _tmp0 = toBinding(v); - if (_tmp0 !== void 0) {result = {"_variant": "named", "value": _tmp0};}; + if (_tmp0 !== void 0) { + result = { + "_variant": "named", + "value": _tmp0, + __as_preserve__() {return fromNamedPattern(this);} + }; + }; if (result === void 0) { let _tmp1: (Pattern<_embedded>) | undefined; _tmp1 = toPattern(v); - if (_tmp1 !== void 0) {result = {"_variant": "anonymous", "value": _tmp1};}; + if (_tmp1 !== void 0) { + result = { + "_variant": "anonymous", + "value": _tmp1, + __as_preserve__() {return fromNamedPattern(this);} + }; + }; }; return result; } +export namespace NamedPattern {export const __from_preserve__ = toNamedPattern;} + export function fromNamedPattern<_embedded = _.GenericEmbedded>(_v: NamedPattern<_embedded>): _.Value<_embedded> { switch (_v._variant) { case "named": {return fromBinding<_embedded>(_v.value);}; @@ -1394,58 +1645,66 @@ export function fromNamedPattern<_embedded = _.GenericEmbedded>(_v: NamedPattern }; } -export function asBinding<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): Binding<_embedded> { +export function asBinding<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): (Binding<_embedded> & {__as_preserve__(): _.Value<_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> { - let result: undefined | Binding<_embedded>; +export function toBinding<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | (Binding<_embedded> & {__as_preserve__(): _.Value<_embedded>}) { + let result: undefined | (Binding<_embedded> & {__as_preserve__(): _.Value<_embedded>}); if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { - let _tmp0: (null) | undefined; - _tmp0 = _.is(v.label, $named) ? null : void 0; + let _tmp0: ({}) | undefined; + _tmp0 = _.is(v.label, $named) ? {} : 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: (SimplePattern<_embedded>) | undefined; _tmp2 = toSimplePattern(v[1]); - if (_tmp2 !== void 0) {result = {"name": _tmp1, "pattern": _tmp2};}; + if (_tmp2 !== void 0) { + result = {"name": _tmp1, "pattern": _tmp2, __as_preserve__() {return fromBinding(this);}}; + }; }; }; }; return result; } +Binding.__from_preserve__ = toBinding; + export function fromBinding<_embedded = _.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 = _.GenericEmbedded>(v: _.Value<_embedded>): (Ref & {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}) { 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 { - let result: undefined | Ref; +export function toRef<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): undefined | (Ref & {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}) { + let result: undefined | (Ref & {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}); if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) { - let _tmp0: (null) | undefined; - _tmp0 = _.is(v.label, $ref) ? null : void 0; + let _tmp0: ({}) | undefined; + _tmp0 = _.is(v.label, $ref) ? {} : void 0; if (_tmp0 !== void 0) { let _tmp1: (ModulePath) | undefined; _tmp1 = toModulePath(v[0]); if (_tmp1 !== void 0) { let _tmp2: (symbol) | undefined; _tmp2 = typeof v[1] === 'symbol' ? v[1] : void 0; - if (_tmp2 !== void 0) {result = {"module": _tmp1, "name": _tmp2};}; + if (_tmp2 !== void 0) { + result = {"module": _tmp1, "name": _tmp2, __as_preserve__() {return fromRef(this);}}; + }; }; }; }; return result; } +Ref.__from_preserve__ = toRef; + export function fromRef<_embedded = _.GenericEmbedded>(_v: Ref): _.Value<_embedded> {return _.Record($ref, [fromModulePath<_embedded>(_v["module"]), _v["name"]]);} export function asModulePath<_embedded = _.GenericEmbedded>(v: _.Value<_embedded>): ModulePath { @@ -1472,5 +1731,7 @@ export function toModulePath<_embedded = _.GenericEmbedded>(v: _.Value<_embedded return result; } +ModulePath.__from_preserve__ = toModulePath; + export function fromModulePath<_embedded = _.GenericEmbedded>(_v: ModulePath): _.Value<_embedded> {return _v.map(v => v);} diff --git a/implementations/javascript/packages/schema/src/reflection.ts b/implementations/javascript/packages/schema/src/reflection.ts new file mode 100644 index 0000000..d8e5590 --- /dev/null +++ b/implementations/javascript/packages/schema/src/reflection.ts @@ -0,0 +1,10 @@ +import type { Value } from '@preserves/core'; + +export type Imports = { [modulePath: string]: any }; // TODO: better than any + +export interface SchemaDefinition { + schema: Value, + imports: Imports, + definitionName: symbol, + variant: symbol | undefined, +}