From d91924c72bb5208f08b248afffc9d10cc9728e62 Mon Sep 17 00:00:00 2001 From: Tony Garnock-Jones Date: Tue, 23 Mar 2021 11:37:22 +0100 Subject: [PATCH] Regenerate --- .../packages/schema/src/gen/schema.ts | 117 ++++++++++++++++++ 1 file changed, 117 insertions(+) diff --git a/implementations/javascript/packages/schema/src/gen/schema.ts b/implementations/javascript/packages/schema/src/gen/schema.ts index d96dc13..0df98d2 100644 --- a/implementations/javascript/packages/schema/src/gen/schema.ts +++ b/implementations/javascript/packages/schema/src/gen/schema.ts @@ -220,6 +220,21 @@ export function toSchema(v: _val): undefined | Schema { return result; } +export function fromSchema(v: Schema): _val { + return _.Record( + $schema, + [ + new _.Dictionary<_ptr>( + [ + [$version, fromVersion(v["version"])], + [$pointer, fromPointerName(v["pointer"])], + [$definitions, fromDefinitions(v["definitions"])] + ] + ) + ] + ); +} + export function asVersion(v: _val): Version { let result = toVersion(v); if (result === void 0) throw new TypeError(`Invalid Version: ${_.stringify(v)}`); @@ -234,6 +249,8 @@ export function toVersion(v: _val): undefined | Version { return result; } +export function fromVersion(v: Version): _val {return $1;} + export function asPointerName(v: _val): PointerName { let result = toPointerName(v); if (result === void 0) throw new TypeError(`Invalid PointerName: ${_.stringify(v)}`); @@ -253,6 +270,10 @@ export function toPointerName(v: _val): undefined | PointerName { return result; } +export function fromPointerName(v: PointerName): _val { + switch (v._variant) {case "Ref": {return fromRef(v.value);}; case "false": {return __lit5;};}; +} + export function asDefinitions(v: _val): Definitions { let result = toDefinitions(v); if (result === void 0) throw new TypeError(`Invalid Definitions: ${_.stringify(v)}`); @@ -280,6 +301,10 @@ export function toDefinitions(v: _val): undefined | Definitions { return result; } +export function fromDefinitions(v: Definitions): _val { + return new _.Dictionary<_ptr>(_.Array.from(v.entries()).map(([k, v]) => [k, fromDefinition(v)])); +} + export function asDefinition(v: _val): Definition { let result = toDefinition(v); if (result === void 0) throw new TypeError(`Invalid Definition: ${_.stringify(v)}`); @@ -318,6 +343,13 @@ export function toDefinition(v: _val): undefined | Definition { return result; } +export function fromDefinition(v: Definition): _val { + switch (v._variant) { + case "or": {return _.Record($or, [v["patterns"].map(v => fromNamedAlternative(v))]);}; + case "Alternative": {return fromAlternative(v.value);}; + }; +} + export function asNamedAlternative(v: _val): NamedAlternative { let result = toNamedAlternative(v); if (result === void 0) throw new TypeError(`Invalid NamedAlternative: ${_.stringify(v)}`); @@ -338,6 +370,8 @@ export function toNamedAlternative(v: _val): undefined | NamedAlternative { return result; } +export function fromNamedAlternative(v: NamedAlternative): _val {return [v["variantLabel"], fromAlternative(v["alternative"])];} + export function asAlternative(v: _val): Alternative { let result = toAlternative(v); if (result === void 0) throw new TypeError(`Invalid Alternative: ${_.stringify(v)}`); @@ -376,6 +410,13 @@ export function toAlternative(v: _val): undefined | Alternative { return result; } +export function fromAlternative(v: Alternative): _val { + switch (v._variant) { + case "and": {return _.Record($and, [v["patterns"].map(v => fromNamedPattern(v))]);}; + case "Pattern": {return fromPattern(v.value);}; + }; +} + export function asPattern(v: _val): Pattern { let result = toPattern(v); if (result === void 0) throw new TypeError(`Invalid Pattern: ${_.stringify(v)}`); @@ -395,6 +436,13 @@ export function toPattern(v: _val): undefined | Pattern { return result; } +export function fromPattern(v: Pattern): _val { + switch (v._variant) { + case "SimplePattern": {return fromSimplePattern(v.value);}; + case "CompoundPattern": {return fromCompoundPattern(v.value);}; + }; +} + export function asSimplePattern(v: _val): SimplePattern { let result = toSimplePattern(v); if (result === void 0) throw new TypeError(`Invalid SimplePattern: ${_.stringify(v)}`); @@ -443,6 +491,16 @@ export function toSimplePattern(v: _val): undefined | SimplePattern { return result; } +export function fromSimplePattern(v: SimplePattern): _val { + switch (v._variant) { + case "any": {return $any;}; + case "atom": {return _.Record($atom, [fromAtomKind(v["atomKind"])]);}; + case "pointer": {return _.Record($pointer, []);}; + case "lit": {return _.Record($lit, [v["value"]]);}; + case "Ref": {return fromRef(v.value);}; + }; +} + export function asCompoundPattern(v: _val): CompoundPattern { let result = toCompoundPattern(v); if (result === void 0) throw new TypeError(`Invalid CompoundPattern: ${_.stringify(v)}`); @@ -556,6 +614,29 @@ export function toCompoundPattern(v: _val): undefined | CompoundPattern { return result; } +export function fromCompoundPattern(v: CompoundPattern): _val { + switch (v._variant) { + case "rec": { + return _.Record($rec, [fromNamedPattern(v["label"]), fromNamedPattern(v["fields"])]); + }; + case "tuple": {return _.Record($tuple, [v["patterns"].map(v => fromNamedPattern(v))]);}; + case "tuple*": { + return _.Record( + $tuple$STAR$, + [ + v["fixed"].map(v => fromNamedPattern(v)), + fromNamedSimplePattern(v["variable"]) + ] + ); + }; + case "setof": {return _.Record($setof, [fromSimplePattern(v["pattern"])]);}; + case "dictof": { + return _.Record($dictof, [fromSimplePattern(v["key"]), fromSimplePattern(v["value"])]); + }; + case "dict": {return _.Record($dict, [fromDictionaryEntries(v["entries"])]);}; + }; +} + export function asDictionaryEntries(v: _val): DictionaryEntries { let result = toDictionaryEntries(v); if (result === void 0) throw new TypeError(`Invalid DictionaryEntries: ${_.stringify(v)}`); @@ -583,6 +664,10 @@ export function toDictionaryEntries(v: _val): undefined | DictionaryEntries { return result; } +export function fromDictionaryEntries(v: DictionaryEntries): _val { + return new _.Dictionary<_ptr>(_.Array.from(v.entries()).map(([k, v]) => [k, fromNamedSimplePattern(v)])); +} + export function asAtomKind(v: _val): AtomKind { let result = toAtomKind(v); if (result === void 0) throw new TypeError(`Invalid AtomKind: ${_.stringify(v)}`); @@ -627,6 +712,18 @@ export function toAtomKind(v: _val): undefined | AtomKind { return result; } +export function fromAtomKind(v: AtomKind): _val { + switch (v._variant) { + case "Boolean": {return $Boolean;}; + case "Float": {return $Float;}; + case "Double": {return $Double;}; + case "SignedInteger": {return $SignedInteger;}; + case "String": {return $String;}; + case "ByteString": {return $ByteString;}; + case "Symbol": {return $Symbol;}; + }; +} + export function asNamedSimplePattern(v: _val): NamedSimplePattern { let result = toNamedSimplePattern(v); if (result === void 0) throw new TypeError(`Invalid NamedSimplePattern: ${_.stringify(v)}`); @@ -646,6 +743,13 @@ export function toNamedSimplePattern(v: _val): undefined | NamedSimplePattern { return result; } +export function fromNamedSimplePattern(v: NamedSimplePattern): _val { + switch (v._variant) { + case "named": {return fromNamedSimplePattern_(v.value);}; + case "anonymous": {return fromSimplePattern(v.value);}; + }; +} + export function asNamedPattern(v: _val): NamedPattern { let result = toNamedPattern(v); if (result === void 0) throw new TypeError(`Invalid NamedPattern: ${_.stringify(v)}`); @@ -665,6 +769,13 @@ export function toNamedPattern(v: _val): undefined | NamedPattern { return result; } +export function fromNamedPattern(v: NamedPattern): _val { + switch (v._variant) { + case "named": {return fromNamedSimplePattern_(v.value);}; + case "anonymous": {return fromPattern(v.value);}; + }; +} + export function asNamedSimplePattern_(v: _val): NamedSimplePattern_ { let result = toNamedSimplePattern_(v); if (result === void 0) throw new TypeError(`Invalid NamedSimplePattern_: ${_.stringify(v)}`); @@ -689,6 +800,8 @@ export function toNamedSimplePattern_(v: _val): undefined | NamedSimplePattern_ return result; } +export function fromNamedSimplePattern_(v: NamedSimplePattern_): _val {return _.Record($named, [v["name"], fromSimplePattern(v["pattern"])]);} + export function asRef(v: _val): Ref { let result = toRef(v); if (result === void 0) throw new TypeError(`Invalid Ref: ${_.stringify(v)}`); @@ -713,6 +826,8 @@ export function toRef(v: _val): undefined | Ref { return result; } +export function fromRef(v: Ref): _val {return _.Record($ref, [fromModulePath(v["module"]), v["name"]]);} + export function asModulePath(v: _val): ModulePath { let result = toModulePath(v); if (result === void 0) throw new TypeError(`Invalid ModulePath: ${_.stringify(v)}`); @@ -736,3 +851,5 @@ export function toModulePath(v: _val): undefined | ModulePath { return result; } +export function fromModulePath(v: ModulePath): _val {return v.map(v => v);} +