Host types

implementations/javascript/packages/schema/package.json

@@ -13,14 +13,14 @@
   "types": "lib/index.d.ts",
   "author": "Tony Garnock-Jones <tonyg@leastfixedpoint.com>",
   "scripts": {
-    "regenerate": "rm -rf ./src/gen && yarn copy-schema && ../schema-cli/bin/preserves-schema-ts.js --output ./src/gen ./dist:schema.prs",
+    "regenerate": "rm -rf ./src/gen && yarn copy-schema && ../schema-cli/bin/preserves-schema-ts.js --output ./src/gen ./dist:*.prs",
     "clean": "rm -rf lib dist",
     "prepare": "yarn compile && yarn rollup && yarn copy-schema",
     "compile": "tsc",
     "compile:watch": "yarn compile -w",
     "rollup": "rollup -c",
     "rollup:watch": "yarn rollup -w",
-    "copy-schema": "mkdir -p ./dist && cp -a ../../../../schema/schema.prs ./dist",
+    "copy-schema": "mkdir -p ./dist && cp -a ../../../../schema/*.prs ./dist",
     "test": "jest",
     "test:watch": "jest --watch",
     "veryclean": "yarn run clean && rm -rf node_modules"

implementations/javascript/packages/schema/src/gen/host.ts

@@ -0,0 +1,704 @@
+import * as _ from "@preserves/core";
+import * as _i_schema from "./schema";
+
+export const $any = _.Symbol.for("any");
+export const $array = _.Symbol.for("array");
+export const $embedded = _.Symbol.for("embedded");
+export const $map = _.Symbol.for("map");
+export const $rec = _.Symbol.for("rec");
+export const $ref = _.Symbol.for("ref");
+export const $set = _.Symbol.for("set");
+export const $union = _.Symbol.for("union");
+export const $unit = _.Symbol.for("unit");
+
+let __schema: _.Value | null = null;
+
+export function _schema() {
+    if (__schema === null) {
+        __schema = _.decode<_.GenericEmbedded>(_.Bytes.fromHex("b4b306736368656d61b7b30776657273696f6eb00101b30b646566696e6974696f6e73b7b3054669656c64b4b3026f72b5b5b104756e6974b4b3036c6974b304756e69748484b5b103616e79b4b3036c6974b303616e798484b5b108656d626564646564b4b3036c6974b308656d6265646465648484b5b1056172726179b4b303726563b4b3036c6974b305617272617984b4b3057475706c65b5b4b3056e616d6564b307656c656d656e74b4b303726566b584b3054669656c64848484848484b5b103736574b4b303726563b4b3036c6974b30373657484b4b3057475706c65b5b4b3056e616d6564b307656c656d656e74b4b303726566b584b3054669656c64848484848484b5b1036d6170b4b303726563b4b3036c6974b3036d617084b4b3057475706c65b5b4b3056e616d6564b3036b6579b4b303726566b584b3054669656c648484b4b3056e616d6564b30576616c7565b4b303726566b584b3054669656c64848484848484b5b103726566b4b303726563b4b3036c6974b30372656684b4b3057475706c65b5b4b3056e616d6564b3046e616d65b4b303726566b5b306736368656d6184b303526566848484848484b5b10841746f6d4b696e64b4b303726566b5b306736368656d6184b30841746f6d4b696e6484848484b3065265636f7264b4b303726563b4b3036c6974b30372656384b4b3057475706c65b5b4b3056e616d6564b3066669656c6473b4b3057365716f66b4b303726566b584b30a4e616d65644669656c64848484848484b30653696d706c65b4b3026f72b5b5b1054669656c64b4b303726566b584b3054669656c648484b5b1065265636f7264b4b303726566b584b3065265636f726484848484b30756617269616e74b4b3057475706c65b5b4b3056e616d6564b3056c6162656cb4b30461746f6db30653796d626f6c8484b4b3056e616d6564b30474797065b4b303726566b584b30653696d706c6584848484b30a446566696e6974696f6eb4b3026f72b5b5b105756e696f6eb4b303726563b4b3036c6974b305756e696f6e84b4b3057475706c65b5b4b3056e616d6564b30876617269616e7473b4b3057365716f66b4b303726566b584b30756617269616e7484848484848484b5b10653696d706c65b4b303726566b584b30653696d706c6584848484b30a4e616d65644669656c64b4b3057475706c65b5b4b3056e616d6564b3046e616d65b4b30461746f6db30653796d626f6c8484b4b3056e616d6564b30474797065b4b303726566b584b3054669656c648484848484b30c656d62656464656454797065808484"));
+    };
+    return __schema;
+}
+
+export const _imports = {"schema": _i_schema}
+
+
+export type Definition = (
+    (
+        {"_variant": "union", "variants": Array<Variant>} |
+        {"_variant": "Simple", "value": Simple}
+    ) &
+    _.Preservable<any> &
+    _.PreserveWritable<any> &
+    {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}
+);
+
+export type Variant = (
+    {"label": symbol, "type": Simple} &
+    _.Preservable<any> &
+    _.PreserveWritable<any> &
+    {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}
+);
+
+export type Simple = (
+    (
+        {"_variant": "Field", "value": Field} |
+        {"_variant": "Record", "value": Record}
+    ) &
+    _.Preservable<any> &
+    _.PreserveWritable<any> &
+    {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}
+);
+
+export type Record = (
+    {"fields": Array<NamedField>} &
+    _.Preservable<any> &
+    _.PreserveWritable<any> &
+    {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}
+);
+
+export type NamedField = (
+    {"name": symbol, "type": Field} &
+    _.Preservable<any> &
+    _.PreserveWritable<any> &
+    {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}
+);
+
+export type Field = (
+    (
+        {"_variant": "unit"} |
+        {"_variant": "any"} |
+        {"_variant": "embedded"} |
+        {"_variant": "array", "element": Field} |
+        {"_variant": "set", "element": Field} |
+        {"_variant": "map", "key": Field, "value": Field} |
+        {"_variant": "ref", "name": _i_schema.Ref} |
+        {"_variant": "AtomKind", "value": _i_schema.AtomKind}
+    ) &
+    _.Preservable<any> &
+    _.PreserveWritable<any> &
+    {__as_preserve__<_embedded = _.GenericEmbedded>(): _.Value<_embedded>}
+);
+
+
+export namespace Definition {
+    export function union(variants: Array<Variant>): Definition {
+        return {
+            "_variant": "union",
+            "variants": variants,
+            __as_preserve__() {return fromDefinition(this);},
+            __preserve_on__(e) { e.push(fromDefinition(this)); },
+            __preserve_text_on__(w) { w.push(fromDefinition(this)); }
+        };
+    };
+    union.schema = function () {
+        return {
+            schema: _schema(),
+            imports: _imports,
+            definitionName: _.Symbol.for("Definition"),
+            variant: _.Symbol.for("union")
+        };
+    };
+    export function Simple(value: Simple): Definition {
+        return {
+            "_variant": "Simple",
+            "value": value,
+            __as_preserve__() {return fromDefinition(this);},
+            __preserve_on__(e) { e.push(fromDefinition(this)); },
+            __preserve_text_on__(w) { w.push(fromDefinition(this)); }
+        };
+    };
+    Simple.schema = function () {
+        return {
+            schema: _schema(),
+            imports: _imports,
+            definitionName: _.Symbol.for("Definition"),
+            variant: _.Symbol.for("Simple")
+        };
+    };
+}
+
+export function Variant({label, type}: {label: symbol, type: Simple}): Variant {
+    return {
+        "label": label,
+        "type": type,
+        __as_preserve__() {return fromVariant(this);},
+        __preserve_on__(e) { e.push(fromVariant(this)); },
+        __preserve_text_on__(w) { w.push(fromVariant(this)); }
+    };
+}
+
+Variant.schema = function () {
+    return {schema: _schema(), imports: _imports, definitionName: _.Symbol.for("Variant")};
+}
+
+export namespace Simple {
+    export function Field(value: Field): Simple {
+        return {
+            "_variant": "Field",
+            "value": value,
+            __as_preserve__() {return fromSimple(this);},
+            __preserve_on__(e) { e.push(fromSimple(this)); },
+            __preserve_text_on__(w) { w.push(fromSimple(this)); }
+        };
+    };
+    Field.schema = function () {
+        return {
+            schema: _schema(),
+            imports: _imports,
+            definitionName: _.Symbol.for("Simple"),
+            variant: _.Symbol.for("Field")
+        };
+    };
+    export function Record(value: Record): Simple {
+        return {
+            "_variant": "Record",
+            "value": value,
+            __as_preserve__() {return fromSimple(this);},
+            __preserve_on__(e) { e.push(fromSimple(this)); },
+            __preserve_text_on__(w) { w.push(fromSimple(this)); }
+        };
+    };
+    Record.schema = function () {
+        return {
+            schema: _schema(),
+            imports: _imports,
+            definitionName: _.Symbol.for("Simple"),
+            variant: _.Symbol.for("Record")
+        };
+    };
+}
+
+export function Record(fields: Array<NamedField>): Record {
+    return {
+        "fields": fields,
+        __as_preserve__() {return fromRecord(this);},
+        __preserve_on__(e) { e.push(fromRecord(this)); },
+        __preserve_text_on__(w) { w.push(fromRecord(this)); }
+    };
+}
+
+Record.schema = function () {
+    return {schema: _schema(), imports: _imports, definitionName: _.Symbol.for("Record")};
+}
+
+export function NamedField({name, type}: {name: symbol, type: Field}): NamedField {
+    return {
+        "name": name,
+        "type": type,
+        __as_preserve__() {return fromNamedField(this);},
+        __preserve_on__(e) { e.push(fromNamedField(this)); },
+        __preserve_text_on__(w) { w.push(fromNamedField(this)); }
+    };
+}
+
+NamedField.schema = function () {
+    return {
+        schema: _schema(),
+        imports: _imports,
+        definitionName: _.Symbol.for("NamedField")
+    };
+}
+
+export namespace Field {
+    export function unit(): Field {
+        return {
+            "_variant": "unit",
+            __as_preserve__() {return fromField(this);},
+            __preserve_on__(e) { e.push(fromField(this)); },
+            __preserve_text_on__(w) { w.push(fromField(this)); }
+        };
+    };
+    unit.schema = function () {
+        return {
+            schema: _schema(),
+            imports: _imports,
+            definitionName: _.Symbol.for("Field"),
+            variant: _.Symbol.for("unit")
+        };
+    };
+    export function any(): Field {
+        return {
+            "_variant": "any",
+            __as_preserve__() {return fromField(this);},
+            __preserve_on__(e) { e.push(fromField(this)); },
+            __preserve_text_on__(w) { w.push(fromField(this)); }
+        };
+    };
+    any.schema = function () {
+        return {
+            schema: _schema(),
+            imports: _imports,
+            definitionName: _.Symbol.for("Field"),
+            variant: _.Symbol.for("any")
+        };
+    };
+    export function embedded(): Field {
+        return {
+            "_variant": "embedded",
+            __as_preserve__() {return fromField(this);},
+            __preserve_on__(e) { e.push(fromField(this)); },
+            __preserve_text_on__(w) { w.push(fromField(this)); }
+        };
+    };
+    embedded.schema = function () {
+        return {
+            schema: _schema(),
+            imports: _imports,
+            definitionName: _.Symbol.for("Field"),
+            variant: _.Symbol.for("embedded")
+        };
+    };
+    export function array(element: Field): Field {
+        return {
+            "_variant": "array",
+            "element": element,
+            __as_preserve__() {return fromField(this);},
+            __preserve_on__(e) { e.push(fromField(this)); },
+            __preserve_text_on__(w) { w.push(fromField(this)); }
+        };
+    };
+    array.schema = function () {
+        return {
+            schema: _schema(),
+            imports: _imports,
+            definitionName: _.Symbol.for("Field"),
+            variant: _.Symbol.for("array")
+        };
+    };
+    export function set(element: Field): Field {
+        return {
+            "_variant": "set",
+            "element": element,
+            __as_preserve__() {return fromField(this);},
+            __preserve_on__(e) { e.push(fromField(this)); },
+            __preserve_text_on__(w) { w.push(fromField(this)); }
+        };
+    };
+    set.schema = function () {
+        return {
+            schema: _schema(),
+            imports: _imports,
+            definitionName: _.Symbol.for("Field"),
+            variant: _.Symbol.for("set")
+        };
+    };
+    export function map({key, value}: {key: Field, value: Field}): Field {
+        return {
+            "_variant": "map",
+            "key": key,
+            "value": value,
+            __as_preserve__() {return fromField(this);},
+            __preserve_on__(e) { e.push(fromField(this)); },
+            __preserve_text_on__(w) { w.push(fromField(this)); }
+        };
+    };
+    map.schema = function () {
+        return {
+            schema: _schema(),
+            imports: _imports,
+            definitionName: _.Symbol.for("Field"),
+            variant: _.Symbol.for("map")
+        };
+    };
+    export function ref(name: _i_schema.Ref): Field {
+        return {
+            "_variant": "ref",
+            "name": name,
+            __as_preserve__() {return fromField(this);},
+            __preserve_on__(e) { e.push(fromField(this)); },
+            __preserve_text_on__(w) { w.push(fromField(this)); }
+        };
+    };
+    ref.schema = function () {
+        return {
+            schema: _schema(),
+            imports: _imports,
+            definitionName: _.Symbol.for("Field"),
+            variant: _.Symbol.for("ref")
+        };
+    };
+    export function AtomKind(value: _i_schema.AtomKind): Field {
+        return {
+            "_variant": "AtomKind",
+            "value": value,
+            __as_preserve__() {return fromField(this);},
+            __preserve_on__(e) { e.push(fromField(this)); },
+            __preserve_text_on__(w) { w.push(fromField(this)); }
+        };
+    };
+    AtomKind.schema = function () {
+        return {
+            schema: _schema(),
+            imports: _imports,
+            definitionName: _.Symbol.for("Field"),
+            variant: _.Symbol.for("AtomKind")
+        };
+    };
+}
+
+export function asDefinition<_embedded = _.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 {
+    let result: undefined | Definition;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: ({}) | undefined;
+        _tmp0 = _.is(v.label, $union) ? {} : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (Array<Variant>) | undefined;
+            _tmp1 = void 0;
+            if (_.isSequence(v[0])) {
+                _tmp1 = [];
+                for (const _tmp2 of v[0]) {
+                    let _tmp3: (Variant) | undefined;
+                    _tmp3 = toVariant(_tmp2);
+                    if (_tmp3 !== void 0) {_tmp1.push(_tmp3); continue;};
+                    _tmp1 = void 0;
+                    break;
+                };
+            };
+            if (_tmp1 !== void 0) {
+                result = {
+                    "_variant": "union",
+                    "variants": _tmp1,
+                    __as_preserve__() {return fromDefinition(this);},
+                    __preserve_on__(e) { e.push(fromDefinition(this)); },
+                    __preserve_text_on__(w) { w.push(fromDefinition(this)); }
+                };
+            };
+        };
+    };
+    if (result === void 0) {
+        let _tmp4: (Simple) | undefined;
+        _tmp4 = toSimple(v);
+        if (_tmp4 !== void 0) {
+            result = {
+                "_variant": "Simple",
+                "value": _tmp4,
+                __as_preserve__() {return fromDefinition(this);},
+                __preserve_on__(e) { e.push(fromDefinition(this)); },
+                __preserve_text_on__(w) { w.push(fromDefinition(this)); }
+            };
+        };
+    };
+    return result;
+}
+
+export namespace Definition {export const __from_preserve__ = toDefinition;}
+
+export function fromDefinition<_embedded = _.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 {
+    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 {
+    let result: undefined | Variant;
+    if (_.isSequence(v) && v.length === 2) {
+        let _tmp0: (symbol) | undefined;
+        _tmp0 = typeof v[0] === 'symbol' ? v[0] : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (Simple) | undefined;
+            _tmp1 = toSimple(v[1]);
+            if (_tmp1 !== void 0) {
+                result = {
+                    "label": _tmp0,
+                    "type": _tmp1,
+                    __as_preserve__() {return fromVariant(this);},
+                    __preserve_on__(e) { e.push(fromVariant(this)); },
+                    __preserve_text_on__(w) { w.push(fromVariant(this)); }
+                };
+            };
+        };
+    };
+    return result;
+}
+
+Variant.__from_preserve__ = toVariant;
+
+export function fromVariant<_embedded = _.GenericEmbedded>(_v: Variant): _.Value<_embedded> {return [_v["label"], fromSimple<_embedded>(_v["type"])];}
+
+export function asSimple<_embedded = _.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 {
+    let _tmp0: (Field) | undefined;
+    let result: undefined | Simple;
+    _tmp0 = toField(v);
+    if (_tmp0 !== void 0) {
+        result = {
+            "_variant": "Field",
+            "value": _tmp0,
+            __as_preserve__() {return fromSimple(this);},
+            __preserve_on__(e) { e.push(fromSimple(this)); },
+            __preserve_text_on__(w) { w.push(fromSimple(this)); }
+        };
+    };
+    if (result === void 0) {
+        let _tmp1: (Record) | undefined;
+        _tmp1 = toRecord(v);
+        if (_tmp1 !== void 0) {
+            result = {
+                "_variant": "Record",
+                "value": _tmp1,
+                __as_preserve__() {return fromSimple(this);},
+                __preserve_on__(e) { e.push(fromSimple(this)); },
+                __preserve_text_on__(w) { w.push(fromSimple(this)); }
+            };
+        };
+    };
+    return result;
+}
+
+export namespace Simple {export const __from_preserve__ = toSimple;}
+
+export function fromSimple<_embedded = _.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 {
+    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 {
+    let result: undefined | Record;
+    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+        let _tmp0: ({}) | undefined;
+        _tmp0 = _.is(v.label, $rec) ? {} : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (Array<NamedField>) | undefined;
+            _tmp1 = void 0;
+            if (_.isSequence(v[0])) {
+                _tmp1 = [];
+                for (const _tmp2 of v[0]) {
+                    let _tmp3: (NamedField) | undefined;
+                    _tmp3 = toNamedField(_tmp2);
+                    if (_tmp3 !== void 0) {_tmp1.push(_tmp3); continue;};
+                    _tmp1 = void 0;
+                    break;
+                };
+            };
+            if (_tmp1 !== void 0) {
+                result = {
+                    "fields": _tmp1,
+                    __as_preserve__() {return fromRecord(this);},
+                    __preserve_on__(e) { e.push(fromRecord(this)); },
+                    __preserve_text_on__(w) { w.push(fromRecord(this)); }
+                };
+            };
+        };
+    };
+    return result;
+}
+
+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 asNamedField<_embedded = _.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 {
+    let result: undefined | NamedField;
+    if (_.isSequence(v) && v.length === 2) {
+        let _tmp0: (symbol) | undefined;
+        _tmp0 = typeof v[0] === 'symbol' ? v[0] : void 0;
+        if (_tmp0 !== void 0) {
+            let _tmp1: (Field) | undefined;
+            _tmp1 = toField(v[1]);
+            if (_tmp1 !== void 0) {
+                result = {
+                    "name": _tmp0,
+                    "type": _tmp1,
+                    __as_preserve__() {return fromNamedField(this);},
+                    __preserve_on__(e) { e.push(fromNamedField(this)); },
+                    __preserve_text_on__(w) { w.push(fromNamedField(this)); }
+                };
+            };
+        };
+    };
+    return result;
+}
+
+NamedField.__from_preserve__ = toNamedField;
+
+export function fromNamedField<_embedded = _.GenericEmbedded>(_v: NamedField): _.Value<_embedded> {return [_v["name"], fromField<_embedded>(_v["type"])];}
+
+export function asField<_embedded = _.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 {
+    let _tmp0: ({}) | undefined;
+    let result: undefined | Field;
+    _tmp0 = _.is(v, $unit) ? {} : void 0;
+    if (_tmp0 !== void 0) {
+        result = {
+            "_variant": "unit",
+            __as_preserve__() {return fromField(this);},
+            __preserve_on__(e) { e.push(fromField(this)); },
+            __preserve_text_on__(w) { w.push(fromField(this)); }
+        };
+    };
+    if (result === void 0) {
+        let _tmp1: ({}) | undefined;
+        _tmp1 = _.is(v, $any) ? {} : void 0;
+        if (_tmp1 !== void 0) {
+            result = {
+                "_variant": "any",
+                __as_preserve__() {return fromField(this);},
+                __preserve_on__(e) { e.push(fromField(this)); },
+                __preserve_text_on__(w) { w.push(fromField(this)); }
+            };
+        };
+        if (result === void 0) {
+            let _tmp2: ({}) | undefined;
+            _tmp2 = _.is(v, $embedded) ? {} : void 0;
+            if (_tmp2 !== void 0) {
+                result = {
+                    "_variant": "embedded",
+                    __as_preserve__() {return fromField(this);},
+                    __preserve_on__(e) { e.push(fromField(this)); },
+                    __preserve_text_on__(w) { w.push(fromField(this)); }
+                };
+            };
+            if (result === void 0) {
+                if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+                    let _tmp3: ({}) | undefined;
+                    _tmp3 = _.is(v.label, $array) ? {} : void 0;
+                    if (_tmp3 !== void 0) {
+                        let _tmp4: (Field) | undefined;
+                        _tmp4 = toField(v[0]);
+                        if (_tmp4 !== void 0) {
+                            result = {
+                                "_variant": "array",
+                                "element": _tmp4,
+                                __as_preserve__() {return fromField(this);},
+                                __preserve_on__(e) { e.push(fromField(this)); },
+                                __preserve_text_on__(w) { w.push(fromField(this)); }
+                            };
+                        };
+                    };
+                };
+                if (result === void 0) {
+                    if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+                        let _tmp5: ({}) | undefined;
+                        _tmp5 = _.is(v.label, $set) ? {} : void 0;
+                        if (_tmp5 !== void 0) {
+                            let _tmp6: (Field) | undefined;
+                            _tmp6 = toField(v[0]);
+                            if (_tmp6 !== void 0) {
+                                result = {
+                                    "_variant": "set",
+                                    "element": _tmp6,
+                                    __as_preserve__() {return fromField(this);},
+                                    __preserve_on__(e) { e.push(fromField(this)); },
+                                    __preserve_text_on__(w) { w.push(fromField(this)); }
+                                };
+                            };
+                        };
+                    };
+                    if (result === void 0) {
+                        if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+                            let _tmp7: ({}) | undefined;
+                            _tmp7 = _.is(v.label, $map) ? {} : void 0;
+                            if (_tmp7 !== void 0) {
+                                let _tmp8: (Field) | undefined;
+                                _tmp8 = toField(v[0]);
+                                if (_tmp8 !== void 0) {
+                                    let _tmp9: (Field) | undefined;
+                                    _tmp9 = toField(v[1]);
+                                    if (_tmp9 !== void 0) {
+                                        result = {
+                                            "_variant": "map",
+                                            "key": _tmp8,
+                                            "value": _tmp9,
+                                            __as_preserve__() {return fromField(this);},
+                                            __preserve_on__(e) { e.push(fromField(this)); },
+                                            __preserve_text_on__(w) { w.push(fromField(this)); }
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                        if (result === void 0) {
+                            if (_.Record.isRecord<_.Value<_embedded>, _.Tuple<_.Value<_embedded>>, _embedded>(v)) {
+                                let _tmp10: ({}) | undefined;
+                                _tmp10 = _.is(v.label, $ref) ? {} : void 0;
+                                if (_tmp10 !== void 0) {
+                                    let _tmp11: (_i_schema.Ref) | undefined;
+                                    _tmp11 = _i_schema.toRef<_embedded>(v[0]);
+                                    if (_tmp11 !== void 0) {
+                                        result = {
+                                            "_variant": "ref",
+                                            "name": _tmp11,
+                                            __as_preserve__() {return fromField(this);},
+                                            __preserve_on__(e) { e.push(fromField(this)); },
+                                            __preserve_text_on__(w) { w.push(fromField(this)); }
+                                        };
+                                    };
+                                };
+                            };
+                            if (result === void 0) {
+                                let _tmp12: (_i_schema.AtomKind) | undefined;
+                                _tmp12 = _i_schema.toAtomKind<_embedded>(v);
+                                if (_tmp12 !== void 0) {
+                                    result = {
+                                        "_variant": "AtomKind",
+                                        "value": _tmp12,
+                                        __as_preserve__() {return fromField(this);},
+                                        __preserve_on__(e) { e.push(fromField(this)); },
+                                        __preserve_text_on__(w) { w.push(fromField(this)); }
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+    return result;
+}
+
+export namespace Field {export const __from_preserve__ = toField;}
+
+export function fromField<_embedded = _.GenericEmbedded>(_v: Field): _.Value<_embedded> {
+    switch (_v._variant) {
+        case "unit": {return $unit;};
+        case "any": {return $any;};
+        case "embedded": {return $embedded;};
+        case "array": {return _.Record($array, [fromField<_embedded>(_v["element"])]);};
+        case "set": {return _.Record($set, [fromField<_embedded>(_v["element"])]);};
+        case "map": {
+            return _.Record($map, [fromField<_embedded>(_v["key"]), fromField<_embedded>(_v["value"])]);
+        };
+        case "ref": {return _.Record($ref, [_i_schema.fromRef<_embedded>(_v["name"])]);};
+        case "AtomKind": {return _i_schema.fromAtomKind<_embedded>(_v.value);};
+    };
+}
+

implementations/javascript/packages/schema/src/host.ts

@@ -0,0 +1,83 @@
+import { compare } 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 {
+    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) })));
+        case 'and':
+            return H.Definition.Simple(productType([p.pattern0, p.pattern1, ... p.patternN]));
+        case 'Pattern':
+            return H.Definition.Simple(patternType(p.value));
+    }
+}
+
+export function patternType<V>(p: M.Pattern<V>): H.Simple {
+    switch (p._variant) {
+        case 'SimplePattern':
+            return H.Simple.Field(fieldType(p.value));
+        case 'CompoundPattern':
+            return productType([M.NamedPattern.anonymous(p)]);
+    }
+}
+
+export function fieldType<V>(p: M.SimplePattern<V>): H.Field {
+    switch (p._variant) {
+        case 'any': return H.Field.any();
+        case 'atom': return H.Field.AtomKind(p.atomKind);
+        case 'embedded': return H.Field.embedded();
+        case 'lit': return H.Field.unit();
+        case 'seqof': return H.Field.array(fieldType(p.pattern));
+        case 'setof': return H.Field.set(fieldType(p.pattern));
+        case 'dictof': return H.Field.map({ key: fieldType(p.key), value: fieldType(p.value) });
+        case 'Ref': return H.Field.ref(p.value);
+    }
+}
+
+export function productType<V>(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> {
+    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[]) {
+    switch (p._variant) {
+        case 'named': {
+            const t = fieldType(p.value.pattern);
+            if (t._variant !== 'unit') into.push(H.NamedField({ name: p.value.name, type: t }));
+            break;
+        }
+        case 'anonymous': {
+            if (p.value._variant === 'SimplePattern') return;
+            const q = p.value.value;
+            switch (q._variant) {
+                case 'rec':
+                    gather(q.label, into);
+                    gather(q.fields, into);
+                    break;
+                case 'tuple':
+                    q.patterns.forEach(p => gather(p, into));
+                    break;
+                case 'tuplePrefix':
+                    q.fixed.forEach(p => gather(p, into));
+                    gather(promote(q.variable), into);
+                    break;
+                case 'dict': {
+                    const items = Array.from(q.entries.entries()).sort((a, b) => compare(a[0], b[0]));
+                    items.forEach(([_key, p]) => gather(promote(p), into));
+                    break;
+                }
+            }
+        }
+    }
+}

implementations/javascript/packages/schema/src/index.ts

@@ -3,6 +3,8 @@ export * from './error';
 export * from './reader';
 export * from './compiler';
 export * from './reflection';
+
+export * as Host from './host';
 export * as Meta from './meta';
 export * as Type from './compiler/type';
 export * as GenType from './compiler/gentype';