npm - occam-nominal - Versions diffs - 1.0.323 → 1.0.324 - Mend

occam-nominal 1.0.323 → 1.0.324

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/lib/element/constructor.js +66 -43
package/lib/element/declaration/constructor.js +26 -24
package/lib/element/declaration/type.js +60 -63
package/package.json +1 -1
package/src/element/constructor.js +81 -46
package/src/element/declaration/constructor.js +28 -29
package/src/element/declaration/type.js +80 -86

package/lib/element/constructor.js CHANGED Viewed

@@ -10,6 +10,7 @@ Object.defineProperty(exports, "default", {
 });
 const _occamlanguages = require("occam-languages");
 const _elements = require("../elements");
+const _continuation = require("../utilities/continuation");
 const _type = require("../utilities/type");
 const _instantiate = require("../process/instantiate");
 const _validation = require("../process/validation");
@@ -59,64 +60,86 @@ const _default = (0, _elements.define)(class Constructor extends _occamlanguages
     setType(type) {
         this.type = type;
     }
-    async verify(context) {
+    verify(context, continuation) {
         let verifies = false;
         const includeType = false, constructorString = this.getString(includeType);
         context.trace(`Verifying the '${constructorString}' constructor...`);
-        await (0, _context.attempt)(async (context)=>{
-            const termValidates = await this.validateTerm(context);
-            if (termValidates) {
-                verifies = true;
-            }
-            if (verifies) {
-                this.commit(context);
-            }
+        (0, _context.attempt)((context)=>{
+            this.validateTerm(context, (termValidates)=>{
+                if (termValidates) {
+                    verifies = true;
+                }
+                if (verifies) {
+                    this.commit(context);
+                }
+                if (verifies) {
+                    context.debug(`...verified the '${constructorString}' constructor.`);
+                }
+                return continuation(verifies);
+            });
         }, context);
-        if (verifies) {
-            context.debug(`...verified the '${constructorString}' constructor.`);
-        }
-        return verifies;
     }
-    async validateTerm(context) {
-        let termValidates = false;
+    validateTerm(context, continuation) {
         const includeType = false, constructorString = this.getString(includeType);
         context.trace(`Validating the '${constructorString}' constructor's term...`);
+        const validateTermAsVariable = this.validateTermAsVariable.bind(this), validateTermAsConstructor = this.validateTermAsConstructor.bind(this);
+        return (0, _continuation.exists)([
+            validateTermAsVariable,
+            validateTermAsConstructor
+        ], context, (termValidates)=>{
+            if (termValidates) {
+                context.debug(`...validated the '${constructorString}' constructor's term.`);
+            }
+            return continuation(termValidates);
+        });
+    }
+    validateTermAsVariable(context, continuation) {
         const hypothtical = this.isHypothetical();
-        if (hypothtical) {
-            const termValidatesAsVariable = await (0, _validation.validateTermAsVariable)(this.term, context, async (term, context)=>{
-                let validatesForwards = false;
-                const type = term.getType(), baseType = (0, _type.baseTypeFromNothing)();
-                if (type === baseType) {
-                    validatesForwards = true;
-                }
-                return validatesForwards;
-            });
+        if (!hypothtical) {
+            const termValidatesAsVariable = false;
+            return continuation(termValidatesAsVariable);
+        }
+        const includeType = false, constructorString = this.getString(includeType);
+        context.trace(`Validating the '${constructorString}' constructor's term...`);
+        (0, _validation.validateTermAsVariable)(this.term, context, (term, context)=>{
+            let termValidatesAsVariable = false;
+            const type = term.getType(), baseType = (0, _type.baseTypeFromNothing)();
+            if (type === baseType) {
+                termValidatesAsVariable = true;
+            }
             if (termValidatesAsVariable) {
-                termValidates = true;
+                context.debug(`...validated the '${constructorString}' constructor's term.`);
             }
-        } else {
-            const termValidatesAsConstructor = await (0, _validate.validateTermAsConstructor)(this.term, context);
+            return continuation(termValidatesAsVariable);
+        });
+    }
+    validateTermAsConstructor(context, continuation) {
+        const hypothtical = this.isHypothetical();
+        if (hypothtical) {
+            const termValidatesAsConstructor = false;
+            return continuation(termValidatesAsConstructor);
+        }
+        const includeType = false, constructorString = this.getString(includeType);
+        context.trace(`Validating the '${constructorString}' constructor's term...`);
+        (0, _validate.validateTermAsConstructor)(this.term, context, (termValidatesAsConstructor)=>{
             if (termValidatesAsConstructor) {
-                termValidates = true;
+                context.debug(`...validated the '${constructorString}' constructor's term.`);
             }
-        }
-        if (termValidates) {
-            context.debug(`...validated the '${constructorString}' constructor's term.`);
-        }
-        return termValidates;
+            return continuation(termValidatesAsConstructor);
+        });
     }
-    async unifyTerm(term, context, validateForwards) {
+    unifyTerm(term, context, continuation) {
         let termUnifies = false;
         const termString = term.getString(), includeType = true, constructorString = this.getString(includeType); ///
         context.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`);
-        const hypothesesDiscardedGivenTerm = await this.dischargeHypothesesGivenTerm(term, context);
+        const hypothesesDiscardedGivenTerm = this.dischargeHypothesesGivenTerm(term, context);
         if (hypothesesDiscardedGivenTerm) {
             const constructor = this, constructorContext = constructor.getContext(), generalContext = constructorContext, specifiContext = context, termUnifiesWithConstructor = (0, _unify.unifyTermWithConstructor)(term, constructor, generalContext, specifiContext);
             if (termUnifiesWithConstructor) {
                 const provisional = this.type.isProvisional();
                 term.setType(this.type);
                 term.setProvisional(provisional);
-                const validatesForwards = await validateForwards(term, context);
+                const validatesForwards = validateForwards(term, context);
                 if (validatesForwards) {
                     termUnifies = true;
                 }
@@ -127,23 +150,23 @@ const _default = (0, _elements.define)(class Constructor extends _occamlanguages
         }
         return termUnifies;
     }
-    async dischargeHypothesisGivenTerm(hypothesis, term, context) {
+    dischargeHypothesisGivenTerm(hypothesis, term, context) {
         let hypothesisDischargesGivenTerm;
-        await this.break(context);
+        this.break(context);
         const termString = term.getString(), hypothesisString = hypothesis.getString(), constructorString = this.getString(); ///
         context.trace(`Discharding the '${constructorString}' constructor's '${hypothesisString}' hypothesis given the '${termString}' term...`);
-        hypothesisDischargesGivenTerm = await hypothesis.dischargeGivenTerm(term, context);
+        hypothesisDischargesGivenTerm = hypothesis.dischargeGivenTerm(term, context);
         if (hypothesisDischargesGivenTerm) {
             context.trace(`...discharges the '${constructorString}' constructor's '${hypothesisString}' hypothesis given the '${termString}' term.`);
         }
         return hypothesisDischargesGivenTerm;
     }
-    async dischargeHypothesesGivenTerm(term, context) {
+    dischargeHypothesesGivenTerm(term, context) {
         let hypothesesDischargesGivenTerm = true; ///
         const hypothetical = this.isHypothetical();
         if (hypothetical) {
-            hypothesesDischargesGivenTerm = await every(this.hypotheses, async (hypothesis)=>{
-                const hypothesisDischarges = await this.dischargeHypothesisGivenTerm(hypothesis, term, context);
+            hypothesesDischargesGivenTerm = every(this.hypotheses, (hypothesis)=>{
+                const hypothesisDischarges = this.dischargeHypothesisGivenTerm(hypothesis, term, context);
                 if (hypothesisDischarges) {
                     return true;
                 }
@@ -181,4 +204,4 @@ const _default = (0, _elements.define)(class Constructor extends _occamlanguages
     }
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/element/constructor.js"],"sourcesContent":["\"use strict\";\n\nimport { Element, breakPointUtilities, continuationUtilities } from \"occam-languages\";\n\nimport { define } from \"../elements\";\nimport { baseTypeFromNothing } from \"../utilities/type\";\nimport { instantiateConstructor } from \"../process/instantiate\";\nimport { validateTermAsVariable } from \"../process/validation\";\nimport { termFromConstructorNode } from \"../utilities/element\";\nimport { unifyTermWithConstructor } from \"../process/unify\";\nimport { validateTermAsConstructor } from \"../process/validate\";\nimport { typeFromJSON, typeToTypeJSON } from \"../utilities/json\";\nimport { attempt, serialise, unserialise, instantiate } from \"../utilities/context\";\n\nconst { every } = continuationUtilities,\n      { breakPointFromJSON, breakPointToBreakPointJSON } = breakPointUtilities;\n\nexport default define(class Constructor extends Element {\n  constructor(context, string, node, breakPoint, term, type, hypotheses) {\n    super(context, string, node, breakPoint);\n\n    this.term = term;\n    this.type = type;\n    this.hypotheses = hypotheses;\n  }\n\n  getTerm() {\n    return this.term;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  getHypotheses() {\n    return this.hypotheses;\n  }\n\n  setHypotheses(hypotheses) {\n    this.hypotheses = hypotheses;\n  }\n\n  isHypothetical() {\n    const hypothesesLength = this.hypotheses.length,\n          hypothetical = (hypothesesLength > 0);\n\n    return hypothetical;\n  }\n\n  getConstructorNode() {\n    const node = this.getNode(),\n          constructorNode = node;  ///\n\n    return constructorNode;\n  }\n\n  getString(includeType = true) {\n    let string;\n\n    if (includeType) {\n      const termString = this.term.getString(),\n            typeString = this.type.getString();\n\n      string = `${termString}.${typeString}`;\n    } else {\n      string = super.getString();\n    }\n\n    return string;\n  }\n\n  setType(type) {\n    this.type = type;\n  }\n\n  async verify(context) {\n    let verifies = false;\n\n    const includeType = false,\n          constructorString = this.getString(includeType);\n\n    context.trace(`Verifying the '${constructorString}' constructor...`);\n\n    await attempt(async (context) => {\n      const termValidates = await this.validateTerm(context);\n\n      if (termValidates) {\n        verifies = true;\n      }\n\n      if (verifies) {\n        this.commit(context);\n      }\n    }, context);\n\n    if (verifies) {\n      context.debug(`...verified the '${constructorString}' constructor.`);\n    }\n\n    return verifies;\n  }\n\n  async validateTerm(context) {\n    let termValidates = false;\n\n    const includeType = false,\n          constructorString = this.getString(includeType);\n\n    context.trace(`Validating the '${constructorString}' constructor's term...`);\n\n    const hypothtical = this.isHypothetical();\n\n    if (hypothtical) {\n      const termValidatesAsVariable = await validateTermAsVariable(this.term, context, async (term, context) => { ///\n        let validatesForwards = false;\n\n        const type = term.getType(),\n              baseType = baseTypeFromNothing();\n\n        if (type === baseType) {\n          validatesForwards = true;\n        }\n\n        return validatesForwards;\n      });\n\n      if (termValidatesAsVariable) {\n        termValidates = true;\n      }\n    } else {\n      const termValidatesAsConstructor = await validateTermAsConstructor(this.term, context);\n\n      if (termValidatesAsConstructor) {\n        termValidates = true;\n      }\n    }\n\n    if (termValidates) {\n      context.debug(`...validated the '${constructorString}' constructor's term.`);\n    }\n\n    return termValidates;\n  }\n\n  async unifyTerm(term, context, validateForwards) {\n    let termUnifies = false;\n\n    const termString = term.getString(),\n          includeType = true,\n          constructorString = this.getString(includeType);  ///\n\n    context.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`);\n\n    const hypothesesDiscardedGivenTerm = await this.dischargeHypothesesGivenTerm(term, context);\n\n    if (hypothesesDiscardedGivenTerm) {\n      const constructor = this, ///\n            constructorContext = constructor.getContext(),\n            generalContext = constructorContext,  ///\n            specifiContext = context, ///\n            termUnifiesWithConstructor = unifyTermWithConstructor(term, constructor, generalContext, specifiContext);\n\n      if (termUnifiesWithConstructor) {\n        const provisional = this.type.isProvisional();\n\n        term.setType(this.type);\n\n        term.setProvisional(provisional);\n\n        const validatesForwards = await validateForwards(term, context);\n\n        if (validatesForwards) {\n          termUnifies = true;\n        }\n      }\n    }\n\n    if (termUnifies) {\n      context.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`);\n    }\n\n    return termUnifies;\n  }\n\n  async dischargeHypothesisGivenTerm(hypothesis, term, context) {\n    let hypothesisDischargesGivenTerm;\n\n    await this.break(context);\n\n    const termString = term.getString(),\n          hypothesisString = hypothesis.getString(),\n          constructorString = this.getString(); ///\n\n    context.trace(`Discharding the '${constructorString}' constructor's '${hypothesisString}' hypothesis given the '${termString}' term...`);\n\n    hypothesisDischargesGivenTerm = await hypothesis.dischargeGivenTerm(term, context);\n\n    if (hypothesisDischargesGivenTerm) {\n      context.trace(`...discharges the '${constructorString}' constructor's '${hypothesisString}' hypothesis given the '${termString}' term.`);\n    }\n\n    return hypothesisDischargesGivenTerm;\n  }\n\n  async dischargeHypothesesGivenTerm(term, context) {\n    let hypothesesDischargesGivenTerm = true;  ///\n\n    const hypothetical = this.isHypothetical();\n\n    if (hypothetical) {\n      hypothesesDischargesGivenTerm = await every(this.hypotheses, async (hypothesis) => {\n        const hypothesisDischarges = await this.dischargeHypothesisGivenTerm(hypothesis, term, context);\n\n        if (hypothesisDischarges) {\n          return true;\n        }\n      });\n    }\n\n    return hypothesesDischargesGivenTerm;\n  }\n\n  toJSON() {\n    const context = this.getContext();\n\n    return serialise((context) => {\n      const includeType = false,\n            typeJSON = typeToTypeJSON(this.type),\n            string = this.getString(includeType);\n\n      let breakPoint;\n\n      breakPoint = this.getBreakPoint();\n\n      const breakPointJSON = breakPointToBreakPointJSON(breakPoint);\n\n      breakPoint = breakPointJSON;  ///\n\n      const type = typeJSON,  ///\n            json = {\n              context,\n              string,\n              breakPoint,\n              type\n            };\n\n      return json;\n    }, context);\n  }\n\n  static name = \"Constructor\";\n\n  static fromJSON(json, context) {\n    let constructor;\n\n    instantiate((context) => {\n      unserialise((json, context) => {\n        const { string } = json,\n              constructorNode = instantiateConstructor(string, context),\n              node = constructorNode, ///\n              breakPoint = breakPointFromJSON(json),\n              term = termFromConstructorNode(constructorNode, context),\n              type = typeFromJSON(json, context);\n\n        constructor = new Constructor(context, string, node, breakPoint, term, type);\n      }, json, context);\n    }, context);\n\n    return constructor;\n  }\n});\n"],"names":["every","continuationUtilities","breakPointFromJSON","breakPointToBreakPointJSON","breakPointUtilities","define","Constructor","Element","context","string","node","breakPoint","term","type","hypotheses","getTerm","getType","getHypotheses","setHypotheses","isHypothetical","hypothesesLength","length","hypothetical","getConstructorNode","getNode","constructorNode","getString","includeType","termString","typeString","setType","verify","verifies","constructorString","trace","attempt","termValidates","validateTerm","commit","debug","hypothtical","termValidatesAsVariable","validateTermAsVariable","validatesForwards","baseType","baseTypeFromNothing","termValidatesAsConstructor","validateTermAsConstructor","unifyTerm","validateForwards","termUnifies","hypothesesDiscardedGivenTerm","dischargeHypothesesGivenTerm","constructor","constructorContext","getContext","generalContext","specifiContext","termUnifiesWithConstructor","unifyTermWithConstructor","provisional","isProvisional","setProvisional","dischargeHypothesisGivenTerm","hypothesis","hypothesisDischargesGivenTerm","break","hypothesisString","dischargeGivenTerm","hypothesesDischargesGivenTerm","hypothesisDischarges","toJSON","serialise","typeJSON","typeToTypeJSON","getBreakPoint","breakPointJSON","json","name","fromJSON","instantiate","unserialise","instantiateConstructor","termFromConstructorNode","typeFromJSON"],"mappings":"AAAA;;;;+BAiBA;;;eAAA;;;gCAfoE;0BAE7C;sBACa;6BACG;4BACA;yBACC;uBACC;0BACC;sBACG;yBACgB;AAE7D,MAAM,EAAEA,KAAK,EAAE,GAAGC,qCAAqB,EACjC,EAAEC,kBAAkB,EAAEC,0BAA0B,EAAE,GAAGC,mCAAmB;MAE9E,WAAeC,IAAAA,gBAAM,EAAC,MAAMC,oBAAoBC,uBAAO;IACrD,YAAYC,OAAO,EAAEC,MAAM,EAAEC,IAAI,EAAEC,UAAU,EAAEC,IAAI,EAAEC,IAAI,EAAEC,UAAU,CAAE;QACrE,KAAK,CAACN,SAASC,QAAQC,MAAMC;QAE7B,IAAI,CAACC,IAAI,GAAGA;QACZ,IAAI,CAACC,IAAI,GAAGA;QACZ,IAAI,CAACC,UAAU,GAAGA;IACpB;IAEAC,UAAU;QACR,OAAO,IAAI,CAACH,IAAI;IAClB;IAEAI,UAAU;QACR,OAAO,IAAI,CAACH,IAAI;IAClB;IAEAI,gBAAgB;QACd,OAAO,IAAI,CAACH,UAAU;IACxB;IAEAI,cAAcJ,UAAU,EAAE;QACxB,IAAI,CAACA,UAAU,GAAGA;IACpB;IAEAK,iBAAiB;QACf,MAAMC,mBAAmB,IAAI,CAACN,UAAU,CAACO,MAAM,EACzCC,eAAgBF,mBAAmB;QAEzC,OAAOE;IACT;IAEAC,qBAAqB;QACnB,MAAMb,OAAO,IAAI,CAACc,OAAO,IACnBC,kBAAkBf,MAAO,GAAG;QAElC,OAAOe;IACT;IAEAC,UAAUC,cAAc,IAAI,EAAE;QAC5B,IAAIlB;QAEJ,IAAIkB,aAAa;YACf,MAAMC,aAAa,IAAI,CAAChB,IAAI,CAACc,SAAS,IAChCG,aAAa,IAAI,CAAChB,IAAI,CAACa,SAAS;YAEtCjB,SAAS,GAAGmB,WAAW,CAAC,EAAEC,YAAY;QACxC,OAAO;YACLpB,SAAS,KAAK,CAACiB;QACjB;QAEA,OAAOjB;IACT;IAEAqB,QAAQjB,IAAI,EAAE;QACZ,IAAI,CAACA,IAAI,GAAGA;IACd;IAEA,MAAMkB,OAAOvB,OAAO,EAAE;QACpB,IAAIwB,WAAW;QAEf,MAAML,cAAc,OACdM,oBAAoB,IAAI,CAACP,SAAS,CAACC;QAEzCnB,QAAQ0B,KAAK,CAAC,CAAC,eAAe,EAAED,kBAAkB,gBAAgB,CAAC;QAEnE,MAAME,IAAAA,gBAAO,EAAC,OAAO3B;YACnB,MAAM4B,gBAAgB,MAAM,IAAI,CAACC,YAAY,CAAC7B;YAE9C,IAAI4B,eAAe;gBACjBJ,WAAW;YACb;YAEA,IAAIA,UAAU;gBACZ,IAAI,CAACM,MAAM,CAAC9B;YACd;QACF,GAAGA;QAEH,IAAIwB,UAAU;YACZxB,QAAQ+B,KAAK,CAAC,CAAC,iBAAiB,EAAEN,kBAAkB,cAAc,CAAC;QACrE;QAEA,OAAOD;IACT;IAEA,MAAMK,aAAa7B,OAAO,EAAE;QAC1B,IAAI4B,gBAAgB;QAEpB,MAAMT,cAAc,OACdM,oBAAoB,IAAI,CAACP,SAAS,CAACC;QAEzCnB,QAAQ0B,KAAK,CAAC,CAAC,gBAAgB,EAAED,kBAAkB,uBAAuB,CAAC;QAE3E,MAAMO,cAAc,IAAI,CAACrB,cAAc;QAEvC,IAAIqB,aAAa;YACf,MAAMC,0BAA0B,MAAMC,IAAAA,kCAAsB,EAAC,IAAI,CAAC9B,IAAI,EAAEJ,SAAS,OAAOI,MAAMJ;gBAC5F,IAAImC,oBAAoB;gBAExB,MAAM9B,OAAOD,KAAKI,OAAO,IACnB4B,WAAWC,IAAAA,yBAAmB;gBAEpC,IAAIhC,SAAS+B,UAAU;oBACrBD,oBAAoB;gBACtB;gBAEA,OAAOA;YACT;YAEA,IAAIF,yBAAyB;gBAC3BL,gBAAgB;YAClB;QACF,OAAO;YACL,MAAMU,6BAA6B,MAAMC,IAAAA,mCAAyB,EAAC,IAAI,CAACnC,IAAI,EAAEJ;YAE9E,IAAIsC,4BAA4B;gBAC9BV,gBAAgB;YAClB;QACF;QAEA,IAAIA,eAAe;YACjB5B,QAAQ+B,KAAK,CAAC,CAAC,kBAAkB,EAAEN,kBAAkB,qBAAqB,CAAC;QAC7E;QAEA,OAAOG;IACT;IAEA,MAAMY,UAAUpC,IAAI,EAAEJ,OAAO,EAAEyC,gBAAgB,EAAE;QAC/C,IAAIC,cAAc;QAElB,MAAMtB,aAAahB,KAAKc,SAAS,IAC3BC,cAAc,MACdM,oBAAoB,IAAI,CAACP,SAAS,CAACC,cAAe,GAAG;QAE3DnB,QAAQ0B,KAAK,CAAC,CAAC,cAAc,EAAEN,WAAW,iBAAiB,EAAEK,kBAAkB,gBAAgB,CAAC;QAEhG,MAAMkB,+BAA+B,MAAM,IAAI,CAACC,4BAA4B,CAACxC,MAAMJ;QAEnF,IAAI2C,8BAA8B;YAChC,MAAME,cAAc,IAAI,EAClBC,qBAAqBD,YAAYE,UAAU,IAC3CC,iBAAiBF,oBACjBG,iBAAiBjD,SACjBkD,6BAA6BC,IAAAA,+BAAwB,EAAC/C,MAAMyC,aAAaG,gBAAgBC;YAE/F,IAAIC,4BAA4B;gBAC9B,MAAME,cAAc,IAAI,CAAC/C,IAAI,CAACgD,aAAa;gBAE3CjD,KAAKkB,OAAO,CAAC,IAAI,CAACjB,IAAI;gBAEtBD,KAAKkD,cAAc,CAACF;gBAEpB,MAAMjB,oBAAoB,MAAMM,iBAAiBrC,MAAMJ;gBAEvD,IAAImC,mBAAmB;oBACrBO,cAAc;gBAChB;YACF;QACF;QAEA,IAAIA,aAAa;YACf1C,QAAQ+B,KAAK,CAAC,CAAC,gBAAgB,EAAEX,WAAW,iBAAiB,EAAEK,kBAAkB,cAAc,CAAC;QAClG;QAEA,OAAOiB;IACT;IAEA,MAAMa,6BAA6BC,UAAU,EAAEpD,IAAI,EAAEJ,OAAO,EAAE;QAC5D,IAAIyD;QAEJ,MAAM,IAAI,CAACC,KAAK,CAAC1D;QAEjB,MAAMoB,aAAahB,KAAKc,SAAS,IAC3ByC,mBAAmBH,WAAWtC,SAAS,IACvCO,oBAAoB,IAAI,CAACP,SAAS,IAAI,GAAG;QAE/ClB,QAAQ0B,KAAK,CAAC,CAAC,iBAAiB,EAAED,kBAAkB,iBAAiB,EAAEkC,iBAAiB,wBAAwB,EAAEvC,WAAW,SAAS,CAAC;QAEvIqC,gCAAgC,MAAMD,WAAWI,kBAAkB,CAACxD,MAAMJ;QAE1E,IAAIyD,+BAA+B;YACjCzD,QAAQ0B,KAAK,CAAC,CAAC,mBAAmB,EAAED,kBAAkB,iBAAiB,EAAEkC,iBAAiB,wBAAwB,EAAEvC,WAAW,OAAO,CAAC;QACzI;QAEA,OAAOqC;IACT;IAEA,MAAMb,6BAA6BxC,IAAI,EAAEJ,OAAO,EAAE;QAChD,IAAI6D,gCAAgC,MAAO,GAAG;QAE9C,MAAM/C,eAAe,IAAI,CAACH,cAAc;QAExC,IAAIG,cAAc;YAChB+C,gCAAgC,MAAMrE,MAAM,IAAI,CAACc,UAAU,EAAE,OAAOkD;gBAClE,MAAMM,uBAAuB,MAAM,IAAI,CAACP,4BAA4B,CAACC,YAAYpD,MAAMJ;gBAEvF,IAAI8D,sBAAsB;oBACxB,OAAO;gBACT;YACF;QACF;QAEA,OAAOD;IACT;IAEAE,SAAS;QACP,MAAM/D,UAAU,IAAI,CAAC+C,UAAU;QAE/B,OAAOiB,IAAAA,kBAAS,EAAC,CAAChE;YAChB,MAAMmB,cAAc,OACd8C,WAAWC,IAAAA,oBAAc,EAAC,IAAI,CAAC7D,IAAI,GACnCJ,SAAS,IAAI,CAACiB,SAAS,CAACC;YAE9B,IAAIhB;YAEJA,aAAa,IAAI,CAACgE,aAAa;YAE/B,MAAMC,iBAAiBzE,2BAA2BQ;YAElDA,aAAaiE,gBAAiB,GAAG;YAEjC,MAAM/D,OAAO4D,UACPI,OAAO;gBACLrE;gBACAC;gBACAE;gBACAE;YACF;YAEN,OAAOgE;QACT,GAAGrE;IACL;IAEA,OAAOsE,OAAO,cAAc;IAE5B,OAAOC,SAASF,IAAI,EAAErE,OAAO,EAAE;QAC7B,IAAI6C;QAEJ2B,IAAAA,oBAAW,EAAC,CAACxE;YACXyE,IAAAA,oBAAW,EAAC,CAACJ,MAAMrE;gBACjB,MAAM,EAAEC,MAAM,EAAE,GAAGoE,MACbpD,kBAAkByD,IAAAA,mCAAsB,EAACzE,QAAQD,UACjDE,OAAOe,iBACPd,aAAaT,mBAAmB2E,OAChCjE,OAAOuE,IAAAA,gCAAuB,EAAC1D,iBAAiBjB,UAChDK,OAAOuE,IAAAA,kBAAY,EAACP,MAAMrE;gBAEhC6C,cAAc,IAAI/C,YAAYE,SAASC,QAAQC,MAAMC,YAAYC,MAAMC;YACzE,GAAGgE,MAAMrE;QACX,GAAGA;QAEH,OAAO6C;IACT;AACF"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/element/constructor.js"],"sourcesContent":["\"use strict\";\n\nimport { Element, breakPointUtilities, continuationUtilities } from \"occam-languages\";\n\nimport { define } from \"../elements\";\nimport { exists } from \"../utilities/continuation\";\nimport { baseTypeFromNothing } from \"../utilities/type\";\nimport { instantiateConstructor } from \"../process/instantiate\";\nimport { validateTermAsVariable } from \"../process/validation\";\nimport { termFromConstructorNode } from \"../utilities/element\";\nimport { unifyTermWithConstructor } from \"../process/unify\";\nimport { validateTermAsConstructor } from \"../process/validate\";\nimport { typeFromJSON, typeToTypeJSON } from \"../utilities/json\";\nimport { attempt, serialise, unserialise, instantiate } from \"../utilities/context\";\n\nconst { every } = continuationUtilities,\n      { breakPointFromJSON, breakPointToBreakPointJSON } = breakPointUtilities;\n\nexport default define(class Constructor extends Element {\n  constructor(context, string, node, breakPoint, term, type, hypotheses) {\n    super(context, string, node, breakPoint);\n\n    this.term = term;\n    this.type = type;\n    this.hypotheses = hypotheses;\n  }\n\n  getTerm() {\n    return this.term;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  getHypotheses() {\n    return this.hypotheses;\n  }\n\n  setHypotheses(hypotheses) {\n    this.hypotheses = hypotheses;\n  }\n\n  isHypothetical() {\n    const hypothesesLength = this.hypotheses.length,\n          hypothetical = (hypothesesLength > 0);\n\n    return hypothetical;\n  }\n\n  getConstructorNode() {\n    const node = this.getNode(),\n          constructorNode = node;  ///\n\n    return constructorNode;\n  }\n\n  getString(includeType = true) {\n    let string;\n\n    if (includeType) {\n      const termString = this.term.getString(),\n            typeString = this.type.getString();\n\n      string = `${termString}.${typeString}`;\n    } else {\n      string = super.getString();\n    }\n\n    return string;\n  }\n\n  setType(type) {\n    this.type = type;\n  }\n\n  verify(context, continuation) {\n    let verifies = false;\n\n    const includeType = false,\n          constructorString = this.getString(includeType);\n\n    context.trace(`Verifying the '${constructorString}' constructor...`);\n\n    attempt((context) => {\n      this.validateTerm(context, (termValidates) => {\n        if (termValidates) {\n          verifies = true;\n        }\n\n        if (verifies) {\n          this.commit(context);\n        }\n\n        if (verifies) {\n          context.debug(`...verified the '${constructorString}' constructor.`);\n        }\n\n        return continuation(verifies);\n      });\n    }, context);\n  }\n\n  validateTerm(context, continuation) {\n    const includeType = false,\n          constructorString = this.getString(includeType);\n\n    context.trace(`Validating the '${constructorString}' constructor's term...`);\n\n    const validateTermAsVariable = this.validateTermAsVariable.bind(this),\n          validateTermAsConstructor = this.validateTermAsConstructor.bind(this);\n\n    return exists([\n      validateTermAsVariable,\n      validateTermAsConstructor\n    ], context, (termValidates) => {\n      if (termValidates) {\n        context.debug(`...validated the '${constructorString}' constructor's term.`);\n      }\n\n      return continuation(termValidates);\n    });\n  }\n\n  validateTermAsVariable(context, continuation) {\n    const hypothtical = this.isHypothetical();\n\n    if (!hypothtical) {\n      const termValidatesAsVariable = false;\n\n      return continuation(termValidatesAsVariable);\n    }\n\n    const includeType = false,\n          constructorString = this.getString(includeType);\n\n    context.trace(`Validating the '${constructorString}' constructor's term...`);\n\n    validateTermAsVariable(this.term, context, (term, context) => {\n      let termValidatesAsVariable = false;\n\n      const type = term.getType(),\n            baseType = baseTypeFromNothing();\n\n      if (type === baseType) {\n        termValidatesAsVariable = true;\n      }\n\n      if (termValidatesAsVariable) {\n        context.debug(`...validated the '${constructorString}' constructor's term.`);\n      }\n\n      return continuation(termValidatesAsVariable);\n    });\n  }\n\n  validateTermAsConstructor(context, continuation) {\n    const hypothtical = this.isHypothetical();\n\n    if (hypothtical) {\n      const termValidatesAsConstructor = false;\n\n      return continuation(termValidatesAsConstructor);\n    }\n\n    const includeType = false,\n          constructorString = this.getString(includeType);\n\n    context.trace(`Validating the '${constructorString}' constructor's term...`);\n\n    validateTermAsConstructor(this.term, context, (termValidatesAsConstructor) => {\n      if (termValidatesAsConstructor) {\n        context.debug(`...validated the '${constructorString}' constructor's term.`);\n      }\n\n      return continuation(termValidatesAsConstructor);\n    });\n  }\n\n  unifyTerm(term, context, continuation) {\n    let termUnifies = false;\n\n    const termString = term.getString(),\n          includeType = true,\n          constructorString = this.getString(includeType);  ///\n\n    context.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`);\n\n    const hypothesesDiscardedGivenTerm = this.dischargeHypothesesGivenTerm(term, context);\n\n    if (hypothesesDiscardedGivenTerm) {\n      const constructor = this, ///\n            constructorContext = constructor.getContext(),\n            generalContext = constructorContext,  ///\n            specifiContext = context, ///\n            termUnifiesWithConstructor = unifyTermWithConstructor(term, constructor, generalContext, specifiContext);\n\n      if (termUnifiesWithConstructor) {\n        const provisional = this.type.isProvisional();\n\n        term.setType(this.type);\n\n        term.setProvisional(provisional);\n\n        const validatesForwards = validateForwards(term, context);\n\n        if (validatesForwards) {\n          termUnifies = true;\n        }\n      }\n    }\n\n    if (termUnifies) {\n      context.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`);\n    }\n\n    return termUnifies;\n  }\n\n  dischargeHypothesisGivenTerm(hypothesis, term, context) {\n    let hypothesisDischargesGivenTerm;\n\n    this.break(context);\n\n    const termString = term.getString(),\n          hypothesisString = hypothesis.getString(),\n          constructorString = this.getString(); ///\n\n    context.trace(`Discharding the '${constructorString}' constructor's '${hypothesisString}' hypothesis given the '${termString}' term...`);\n\n    hypothesisDischargesGivenTerm = hypothesis.dischargeGivenTerm(term, context);\n\n    if (hypothesisDischargesGivenTerm) {\n      context.trace(`...discharges the '${constructorString}' constructor's '${hypothesisString}' hypothesis given the '${termString}' term.`);\n    }\n\n    return hypothesisDischargesGivenTerm;\n  }\n\n  dischargeHypothesesGivenTerm(term, context) {\n    let hypothesesDischargesGivenTerm = true;  ///\n\n    const hypothetical = this.isHypothetical();\n\n    if (hypothetical) {\n      hypothesesDischargesGivenTerm = every(this.hypotheses, (hypothesis) => {\n        const hypothesisDischarges = this.dischargeHypothesisGivenTerm(hypothesis, term, context);\n\n        if (hypothesisDischarges) {\n          return true;\n        }\n      });\n    }\n\n    return hypothesesDischargesGivenTerm;\n  }\n\n  toJSON() {\n    const context = this.getContext();\n\n    return serialise((context) => {\n      const includeType = false,\n            typeJSON = typeToTypeJSON(this.type),\n            string = this.getString(includeType);\n\n      let breakPoint;\n\n      breakPoint = this.getBreakPoint();\n\n      const breakPointJSON = breakPointToBreakPointJSON(breakPoint);\n\n      breakPoint = breakPointJSON;  ///\n\n      const type = typeJSON,  ///\n            json = {\n              context,\n              string,\n              breakPoint,\n              type\n            };\n\n      return json;\n    }, context);\n  }\n\n  static name = \"Constructor\";\n\n  static fromJSON(json, context) {\n    let constructor;\n\n    instantiate((context) => {\n      unserialise((json, context) => {\n        const { string } = json,\n              constructorNode = instantiateConstructor(string, context),\n              node = constructorNode, ///\n              breakPoint = breakPointFromJSON(json),\n              term = termFromConstructorNode(constructorNode, context),\n              type = typeFromJSON(json, context);\n\n        constructor = new Constructor(context, string, node, breakPoint, term, type);\n      }, json, context);\n    }, context);\n\n    return constructor;\n  }\n});\n"],"names":["every","continuationUtilities","breakPointFromJSON","breakPointToBreakPointJSON","breakPointUtilities","define","Constructor","Element","context","string","node","breakPoint","term","type","hypotheses","getTerm","getType","getHypotheses","setHypotheses","isHypothetical","hypothesesLength","length","hypothetical","getConstructorNode","getNode","constructorNode","getString","includeType","termString","typeString","setType","verify","continuation","verifies","constructorString","trace","attempt","validateTerm","termValidates","commit","debug","validateTermAsVariable","bind","validateTermAsConstructor","exists","hypothtical","termValidatesAsVariable","baseType","baseTypeFromNothing","termValidatesAsConstructor","unifyTerm","termUnifies","hypothesesDiscardedGivenTerm","dischargeHypothesesGivenTerm","constructor","constructorContext","getContext","generalContext","specifiContext","termUnifiesWithConstructor","unifyTermWithConstructor","provisional","isProvisional","setProvisional","validatesForwards","validateForwards","dischargeHypothesisGivenTerm","hypothesis","hypothesisDischargesGivenTerm","break","hypothesisString","dischargeGivenTerm","hypothesesDischargesGivenTerm","hypothesisDischarges","toJSON","serialise","typeJSON","typeToTypeJSON","getBreakPoint","breakPointJSON","json","name","fromJSON","instantiate","unserialise","instantiateConstructor","termFromConstructorNode","typeFromJSON"],"mappings":"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"}

package/lib/element/declaration/constructor.js CHANGED Viewed

@@ -8,13 +8,16 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
+const _occamlanguages = require("occam-languages");
 const _declaration = /*#__PURE__*/ _interop_require_default(require("../declaration"));
+const _continuation = require("../../utilities/continuation");
 const _elements = require("../../elements");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
+const { breakable } = _occamlanguages.breakPointUtilities;
 const _default = (0, _elements.define)(class ConstructorDeclaration extends _declaration.default {
     constructor(context, string, node, breakPoint, type, provisional, constructor){
         super(context, string, node, breakPoint);
@@ -38,26 +41,25 @@ const _default = (0, _elements.define)(class ConstructorDeclaration extends _dec
     setHypotheses(hypotheses) {
         this.constructor.setHypotheses(hypotheses);
     }
-    async verify(context) {
-        let verifies = false;
-        await this.break(context);
+    verify = breakable(function(context, continuation) {
         const constructorDeclarationString = this.getString(); ///
         context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
-        const typeVerified = this.verifyType(context);
-        if (typeVerified) {
-            const constructorVerifies = this.verifyConstructor(context);
-            if (constructorVerifies) {
+        const verifyType = this.verifyType.bind(this), verifyConstructor = this.verifyConstructor.bind(this);
+        return (0, _continuation.all)([
+            verifyType,
+            verifyConstructor
+        ], context, (verifies)=>{
+            if (verifies) {
                 this.constructor.setType(this.type);
                 context.addConstructor(this.constructor);
-                verifies = true;
             }
-        }
-        if (verifies) {
-            context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
-        }
-        return verifies;
-    }
-    verifyType(context) {
+            if (verifies) {
+                context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
+            }
+            return continuation(verifies);
+        });
+    });
+    verifyType(context, continuation) {
         let typeVerifies = false;
         const constructorDeclarationString = this.getString(); ///
         context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's type...`);
@@ -81,19 +83,19 @@ const _default = (0, _elements.define)(class ConstructorDeclaration extends _dec
         if (typeVerifies) {
             context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's type.`);
         }
-        return typeVerifies;
+        return continuation(typeVerifies);
     }
-    verifyConstructor(context) {
-        let constructorVerifies;
+    verifyConstructor(context, continuation) {
         const includeType = false, constructorString = this.constructor.getString(includeType), constructorDeclarationString = this.getString(); ///
         context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor...`);
-        constructorVerifies = this.constructor.verify(context);
-        if (constructorVerifies) {
-            context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor.`);
-        }
-        return constructorVerifies;
+        this.constructor.verify(context, (constructorVerifies)=>{
+            if (constructorVerifies) {
+                context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor.`);
+            }
+            return continuation(constructorVerifies);
+        });
     }
     static name = "ConstructorDeclaration";
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/declaration/constructor.js"],"sourcesContent":["\"use strict\";\n\nimport Declaration from \"../declaration\";\n\nimport { define } from \"../../elements\";\n\nexport default define(class ConstructorDeclaration extends Declaration {\n  constructor(context, string, node, breakPoint, type, provisional, constructor) {\n    super(context, string, node, breakPoint);\n\n    this.type = type;\n    this.provisional = provisional;\n    this.constructor = constructor;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  isProvisional() {\n    return this.provisional;\n  }\n\n  getConstructor() {\n    return this.constructor;\n  }\n\n  getConstructorDeclarationNode() {\n    const node = this.getNode(),\n          constructorDeclarationNode = node; ///\n\n    return constructorDeclarationNode;\n  }\n\n  setHypotheses(hypotheses) { this.constructor.setHypotheses(hypotheses); }\n\n  async verify(context) {\n    let verifies = false;\n\n    await this.break(context);\n\n    const constructorDeclarationString = this.getString();  ///\n\n    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);\n\n    const typeVerified = this.verifyType(context);\n\n    if (typeVerified) {\n      const constructorVerifies = this.verifyConstructor(context);\n\n      if (constructorVerifies) {\n        this.constructor.setType(this.type);\n\n        context.addConstructor(this.constructor);\n\n        verifies = true;\n      }\n    }\n\n    if (verifies) {\n      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);\n    }\n\n    return verifies;\n  }\n\n  verifyType(context) {\n    let typeVerifies = false;\n\n    const constructorDeclarationString = this.getString();  ///\n\n    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's type...`);\n\n    const nominalTypeName = this.type.getNominalTypeName(),\n          typeString = this.type.getString(),\n          type = context.findTypeByNominalTypeName(nominalTypeName);\n\n    if (type !== null) {\n      const typeCotype = type.isCotype();\n\n      if (!typeCotype) {\n        const provisional = this.isProvisional(),\n              typeComparesToProvisional = type.compareProvisional(provisional);\n\n        if (!typeComparesToProvisional) {\n          provisional ?\n            context.debug(`The '${typeString}' type is present but not provisional.`) :\n              context.debug(`The '${typeString}' type is present but provisional.`);\n        } else {\n          this.type = type;\n\n          typeVerifies = true;\n        }\n      } else {\n        context.debug(`The '${typeString}' type is a cotype.`);\n      }\n    } else {\n      context.debug(`The '${typeString}' type is not present.`);\n    }\n\n    if (typeVerifies) {\n      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's type.`);\n    }\n\n    return typeVerifies;\n  }\n\n  verifyConstructor(context) {\n    let constructorVerifies;\n\n    const includeType = false,\n          constructorString = this.constructor.getString(includeType),\n          constructorDeclarationString = this.getString();  ///\n\n    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor...`);\n\n    constructorVerifies = this.constructor.verify(context);\n\n    if (constructorVerifies) {\n      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor.`);\n    }\n\n    return constructorVerifies;\n  }\n\n  static name = \"ConstructorDeclaration\";\n});\n"],"names":["define","ConstructorDeclaration","Declaration","context","string","node","breakPoint","type","provisional","constructor","getType","isProvisional","getConstructor","getConstructorDeclarationNode","getNode","constructorDeclarationNode","setHypotheses","hypotheses","verify","verifies","break","constructorDeclarationString","getString","trace","typeVerified","verifyType","constructorVerifies","verifyConstructor","setType","addConstructor","debug","typeVerifies","nominalTypeName","getNominalTypeName","typeString","findTypeByNominalTypeName","typeCotype","isCotype","typeComparesToProvisional","compareProvisional","includeType","constructorString","name"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/declaration/constructor.js"],"sourcesContent":["\"use strict\";\n\nimport { breakPointUtilities } from \"occam-languages\";\n\nimport Declaration from \"../declaration\";\n\nimport { all } from \"../../utilities/continuation\";\nimport { define } from \"../../elements\";\n\nconst { breakable } = breakPointUtilities;\n\nexport default define(class ConstructorDeclaration extends Declaration {\n  constructor(context, string, node, breakPoint, type, provisional, constructor) {\n    super(context, string, node, breakPoint);\n\n    this.type = type;\n    this.provisional = provisional;\n    this.constructor = constructor;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  isProvisional() {\n    return this.provisional;\n  }\n\n  getConstructor() {\n    return this.constructor;\n  }\n\n  getConstructorDeclarationNode() {\n    const node = this.getNode(),\n          constructorDeclarationNode = node; ///\n\n    return constructorDeclarationNode;\n  }\n\n  setHypotheses(hypotheses) { this.constructor.setHypotheses(hypotheses); }\n\n  verify = breakable(function (context, continuation) {\n    const constructorDeclarationString = this.getString();  ///\n\n    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);\n\n    const verifyType = this.verifyType.bind(this),\n          verifyConstructor = this.verifyConstructor.bind(this);\n\n    return all([\n      verifyType,\n      verifyConstructor\n    ], context, (verifies) => {\n      if (verifies) {\n        this.constructor.setType(this.type);\n\n        context.addConstructor(this.constructor);\n      }\n\n      if (verifies) {\n        context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);\n      }\n\n      return continuation(verifies);\n    });\n  });\n\n  verifyType(context, continuation) {\n    let typeVerifies = false;\n\n    const constructorDeclarationString = this.getString();  ///\n\n    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's type...`);\n\n    const nominalTypeName = this.type.getNominalTypeName(),\n          typeString = this.type.getString(),\n          type = context.findTypeByNominalTypeName(nominalTypeName);\n\n    if (type !== null) {\n      const typeCotype = type.isCotype();\n\n      if (!typeCotype) {\n        const provisional = this.isProvisional(),\n              typeComparesToProvisional = type.compareProvisional(provisional);\n\n        if (!typeComparesToProvisional) {\n          provisional ?\n            context.debug(`The '${typeString}' type is present but not provisional.`) :\n              context.debug(`The '${typeString}' type is present but provisional.`);\n        } else {\n          this.type = type;\n\n          typeVerifies = true;\n        }\n      } else {\n        context.debug(`The '${typeString}' type is a cotype.`);\n      }\n    } else {\n      context.debug(`The '${typeString}' type is not present.`);\n    }\n\n    if (typeVerifies) {\n      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's type.`);\n    }\n\n    return continuation(typeVerifies);\n  }\n\n  verifyConstructor(context, continuation) {\n    const includeType = false,\n          constructorString = this.constructor.getString(includeType),\n          constructorDeclarationString = this.getString();  ///\n\n    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor...`);\n\n    this.constructor.verify(context, (constructorVerifies) => {\n      if (constructorVerifies) {\n        context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor.`);\n      }\n\n      return continuation(constructorVerifies);\n    });\n  }\n\n  static name = \"ConstructorDeclaration\";\n});\n"],"names":["breakable","breakPointUtilities","define","ConstructorDeclaration","Declaration","context","string","node","breakPoint","type","provisional","constructor","getType","isProvisional","getConstructor","getConstructorDeclarationNode","getNode","constructorDeclarationNode","setHypotheses","hypotheses","verify","continuation","constructorDeclarationString","getString","trace","verifyType","bind","verifyConstructor","all","verifies","setType","addConstructor","debug","typeVerifies","nominalTypeName","getNominalTypeName","typeString","findTypeByNominalTypeName","typeCotype","isCotype","typeComparesToProvisional","compareProvisional","includeType","constructorString","constructorVerifies","name"],"mappings":"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"}

package/lib/element/declaration/type.js CHANGED Viewed

@@ -8,7 +8,9 @@ Object.defineProperty(exports, "default", {
         return _default;
     }
 });
+const _occamlanguages = require("occam-languages");
 const _declaration = /*#__PURE__*/ _interop_require_default(require("../declaration"));
+const _continuation = require("../../utilities/continuation");
 const _elements = require("../../elements");
 const _type = require("../../utilities/type");
 function _interop_require_default(obj) {
@@ -16,6 +18,7 @@ function _interop_require_default(obj) {
         default: obj
     };
 }
+const { every } = _occamlanguages.continuationUtilities, { breakable } = _occamlanguages.breakPointUtilities;
 const _default = (0, _elements.define)(class TypeDeclaration extends _declaration.default {
     constructor(context, string, node, breakPoint, type, superTypes, provisional){
         super(context, string, node, breakPoint);
@@ -40,32 +43,29 @@ const _default = (0, _elements.define)(class TypeDeclaration extends _declaratio
         const properties = [];
         return properties;
     }
-    async verify(context) {
-        let verifies = false;
-        await this.break(context);
+    verify = breakable(function(context, continuation) {
         const typeDeclarationString = this.getString(); ///
         context.trace(`Verifying the '${typeDeclarationString}' type declaration...`);
-        const typeVerifies = this.verifyType(context);
-        if (typeVerifies) {
-            const superTypesVerify = this.verifySuperTypes(context);
-            if (superTypesVerify) {
-                const typePrefixVerifies = this.verifyTypePrefix(context);
-                if (typePrefixVerifies) {
-                    const properties = this.getProperties(), typePrefix = context.getTypePrefix(), prefixName = typePrefix !== null ? typePrefix.getPrefixName() : null;
-                    this.type.setProvisional(this.provisional);
-                    this.type.setProperties(properties);
-                    this.type.setPrefixName(prefixName);
-                    context.addType(this.type);
-                    verifies = true;
-                }
+        const verifyType = this.verifyType.bind(this), verifySuperTypes = this.verifySuperTypes.bind(this), verifyTypePrefix = this.verifyTypePrefix.bind(this);
+        return (0, _continuation.all)([
+            verifyType,
+            verifySuperTypes,
+            verifyTypePrefix
+        ], context, (verifies)=>{
+            if (verifies) {
+                const properties = this.getProperties(), typePrefix = context.getTypePrefix(), prefixName = typePrefix !== null ? typePrefix.getPrefixName() : null;
+                this.type.setProvisional(this.provisional);
+                this.type.setProperties(properties);
+                this.type.setPrefixName(prefixName);
+                context.addType(this.type);
             }
-        }
-        if (verifies) {
-            context.debug(`...verified the '${typeDeclarationString}' type declaration.`);
-        }
-        return verifies;
-    }
-    verifyType(context) {
+            if (verifies) {
+                context.debug(`...verified the '${typeDeclarationString}' type declaration.`);
+            }
+            return continuation(verifies);
+        });
+    });
+    verifyType(context, continuation) {
         let typeVerifies = false;
         const typeString = this.type.getString(), typeDeclarationString = this.getString(); ///
         context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${typeString}' type...`);
@@ -83,9 +83,42 @@ const _default = (0, _elements.define)(class TypeDeclaration extends _declaratio
         if (typeVerifies) {
             context.debug(`...verified the '${typeDeclarationString}' type declaration's '${typeString}' type`);
         }
-        return typeVerifies;
+        return continuation(typeVerifies);
+    }
+    verifyTypePrefix(context, continuation) {
+        let typePrefixVerifies = false;
+        const typeString = this.type.getString(), typeDeclarationString = this.getString(); ///
+        context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${typeString}' type's prefix...`);
+        const typePrefixed = this.type.isPrefixed();
+        if (!typePrefixed) {
+            typePrefixVerifies = true;
+        } else {
+            context.debug(`The '${typeDeclarationString}' type declaration's '${typeString}' type is prefixed.`);
+        }
+        if (typePrefixVerifies) {
+            context.debug(`...verified the '${typeDeclarationString}' type declaration's '${typeString}' type's prefix.`);
+        }
+        return continuation(typePrefixVerifies);
+    }
+    verifySuperTypes(context, continuation) {
+        const superTypes = [], typeDeclarationString = this.getString(); ///
+        context.trace(`Verifying the '${typeDeclarationString}' type declaration's super-types...`);
+        every(this.superTypes, (superType, continuation)=>{
+            this.verifySuperType(superType, superTypes, context, continuation);
+        }, (superTypesVerify)=>{
+            if (superTypesVerify) {
+                const superTypesLength = superTypes.length;
+                if (superTypesLength === 0) {
+                    const baseType = (0, _type.baseTypeFromNothing)(), superTyupe = baseType; ///
+                    superTypes.push(superTyupe);
+                }
+                this.type.setSuperTypes(superTypes);
+                context.debug(`...verified the '${typeDeclarationString}' type declaration's super-types.`);
+            }
+            return continuation(superTypesVerify);
+        });
     }
-    verifySuperType(superType, superTypes, context) {
+    verifySuperType(superType, superTypes, context, continuation) {
         let superTypeVerifies = false;
         const superTypeString = superType.getString(), typeDeclarationString = this.getString(); ///
         context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${superTypeString}' super-type...`);
@@ -104,45 +137,9 @@ const _default = (0, _elements.define)(class TypeDeclaration extends _declaratio
         if (superTypeVerifies) {
             context.debug(`...verified the '${typeDeclarationString}' type declaration's '${superTypeString}' super-type.`);
         }
-        return superTypeVerifies;
-    }
-    verifySuperTypes(context) {
-        let superTypesVerify;
-        const superTypes = [], typeDeclarationString = this.getString(); ///
-        context.trace(`Verifying the '${typeDeclarationString}' type declaration's super-types...`);
-        superTypesVerify = this.superTypes.every((superType)=>{
-            const superTypeVerifies = this.verifySuperType(superType, superTypes, context);
-            if (superTypeVerifies) {
-                return true;
-            }
-        });
-        if (superTypesVerify) {
-            const superTypesLength = superTypes.length;
-            if (superTypesLength === 0) {
-                const baseType = (0, _type.baseTypeFromNothing)(), superTyupe = baseType; ///
-                superTypes.push(superTyupe);
-            }
-            this.type.setSuperTypes(superTypes);
-            context.debug(`...verified the '${typeDeclarationString}' type declaration's super-types.`);
-        }
-        return superTypesVerify;
-    }
-    verifyTypePrefix(context) {
-        let typePrefixVerifies = false;
-        const typeString = this.type.getString(), typeDeclarationString = this.getString(); ///
-        context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${typeString}' type's prefix...`);
-        const typePrefixed = this.type.isPrefixed();
-        if (!typePrefixed) {
-            typePrefixVerifies = true;
-        } else {
-            context.debug(`The '${typeDeclarationString}' type declaration's '${typeString}' type is prefixed.`);
-        }
-        if (typePrefixVerifies) {
-            context.debug(`...verified the '${typeDeclarationString}' type declaration's '${typeString}' type's prefix.`);
-        }
-        return typePrefixVerifies;
+        return continuation(superTypeVerifies);
     }
     static name = "TypeDeclaration";
 });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/declaration/type.js"],"sourcesContent":["\"use strict\";\n\nimport Declaration from \"../declaration\";\n\nimport { define } from \"../../elements\";\nimport { baseTypeFromNothing } from \"../../utilities/type\";\n\nexport default define(class TypeDeclaration extends Declaration {\n  constructor(context, string, node, breakPoint, type, superTypes, provisional) {\n    super(context, string, node, breakPoint);\n\n    this.type = type;\n    this.superTypes = superTypes;\n    this.provisional = provisional;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  getSuperTypes() {\n    return this.superTypes;\n  }\n\n  isProvisional() {\n    return this.provisional;\n  }\n\n  gettypeDeclarationNode() {\n    const node = this.getNode(),\n          typeDeclarationNode = node; ///\n\n    return typeDeclarationNode;\n  }\n\n  getProperties() {\n    const properties = [];\n\n    return properties;\n  }\n\n  async verify(context) {\n    let verifies = false;\n\n    await this.break(context);\n\n    const typeDeclarationString = this.getString();  ///\n\n    context.trace(`Verifying the '${typeDeclarationString}' type declaration...`);\n\n    const typeVerifies = this.verifyType(context);\n\n    if (typeVerifies) {\n      const superTypesVerify = this.verifySuperTypes(context);\n\n      if (superTypesVerify) {\n        const typePrefixVerifies = this.verifyTypePrefix(context);\n\n        if (typePrefixVerifies) {\n          const properties = this.getProperties(),\n                typePrefix = context.getTypePrefix(),\n                prefixName = (typePrefix !== null) ?\n                               typePrefix.getPrefixName() :\n                                 null;\n\n          this.type.setProvisional(this.provisional);\n\n          this.type.setProperties(properties);\n\n          this.type.setPrefixName(prefixName);\n\n          context.addType(this.type);\n\n          verifies = true;\n        }\n      }\n    }\n\n    if (verifies) {\n      context.debug(`...verified the '${typeDeclarationString}' type declaration.`);\n    }\n\n    return verifies;\n  }\n\n  verifyType(context) {\n    let typeVerifies = false;\n\n    const typeString = this.type.getString(),\n          typeDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${typeString}' type...`);\n\n    const typeName = this.type.getName(),\n          includeRelease = false,\n          typePresent = context.isTypePresentByTypeName(typeName, includeRelease);\n\n    if (!typePresent) {\n      const prefixedTypeName = typeName, ///\n            typePresent = context.isTypePresentByPrefixedTypeName(prefixedTypeName);\n\n      if (!typePresent) {\n        typeVerifies = true;\n      } else {\n        context.debug(`The '${typeString}' type is already present.`);\n      }\n    } else {\n      context.debug(`The '${typeString}' type is already present.`);\n    }\n\n    if (typeVerifies) {\n      context.debug(`...verified the '${typeDeclarationString}' type declaration's '${typeString}' type`);\n    }\n\n    return typeVerifies;\n  }\n\n  verifySuperType(superType, superTypes, context) {\n    let superTypeVerifies = false;\n\n    const superTypeString = superType.getString(),\n          typeDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${superTypeString}' super-type...`);\n\n    const nominalTypeName = superType.getNominalTypeName(),\n          typeName = nominalTypeName, ///\n          typeComparesToTypeName = this.type.compareTypeName(typeName);\n\n    if (!typeComparesToTypeName) {\n      superType = context.findTypeByNominalTypeName(nominalTypeName);\n\n      if (superType !== null) {\n        superTypes.push(superType);\n\n        superTypeVerifies = true;\n      } else {\n        context.debug(`The '${superTypeString}' super-type is not present.`);\n      }\n    } else {\n      context.debug(`The '${superTypeString}' super-type's name compares to the ${typeName}' type's name.`);\n    }\n\n    if (superTypeVerifies) {\n      context.debug(`...verified the '${typeDeclarationString}' type declaration's '${superTypeString}' super-type.`);\n    }\n\n    return superTypeVerifies;\n  }\n\n  verifySuperTypes(context) {\n    let superTypesVerify;\n\n    const superTypes = [],\n          typeDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${typeDeclarationString}' type declaration's super-types...`);\n\n    superTypesVerify = this.superTypes.every((superType) => {\n      const superTypeVerifies = this.verifySuperType(superType, superTypes, context);\n\n      if (superTypeVerifies) {\n        return true;\n      }\n    });\n\n    if (superTypesVerify) {\n      const superTypesLength = superTypes.length;\n\n      if (superTypesLength === 0) {\n        const baseType = baseTypeFromNothing(),\n              superTyupe = baseType;  ///\n\n        superTypes.push(superTyupe);\n      }\n\n      this.type.setSuperTypes(superTypes);\n\n      context.debug(`...verified the '${typeDeclarationString}' type declaration's super-types.`);\n    }\n\n    return superTypesVerify;\n  }\n\n  verifyTypePrefix(context) {\n    let typePrefixVerifies = false;\n\n    const typeString = this.type.getString(),\n          typeDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${typeString}' type's prefix...`);\n\n    const typePrefixed = this.type.isPrefixed();\n\n    if (!typePrefixed) {\n      typePrefixVerifies = true;\n    } else {\n      context.debug(`The '${typeDeclarationString}' type declaration's '${typeString}' type is prefixed.`);\n    }\n\n    if (typePrefixVerifies) {\n      context.debug(`...verified the '${typeDeclarationString}' type declaration's '${typeString}' type's prefix.`);\n    }\n\n    return typePrefixVerifies;\n  }\n\n  static name = \"TypeDeclaration\";\n});\n"],"names":["define","TypeDeclaration","Declaration","context","string","node","breakPoint","type","superTypes","provisional","getType","getSuperTypes","isProvisional","gettypeDeclarationNode","getNode","typeDeclarationNode","getProperties","properties","verify","verifies","break","typeDeclarationString","getString","trace","typeVerifies","verifyType","superTypesVerify","verifySuperTypes","typePrefixVerifies","verifyTypePrefix","typePrefix","getTypePrefix","prefixName","getPrefixName","setProvisional","setProperties","setPrefixName","addType","debug","typeString","typeName","getName","includeRelease","typePresent","isTypePresentByTypeName","prefixedTypeName","isTypePresentByPrefixedTypeName","verifySuperType","superType","superTypeVerifies","superTypeString","nominalTypeName","getNominalTypeName","typeComparesToTypeName","compareTypeName","findTypeByNominalTypeName","push","every","superTypesLength","length","baseType","baseTypeFromNothing","superTyupe","setSuperTypes","typePrefixed","isPrefixed","name"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/element/declaration/type.js"],"sourcesContent":["\"use strict\";\n\nimport { breakPointUtilities, continuationUtilities } from \"occam-languages\";\n\nimport Declaration from \"../declaration\";\n\nimport { all } from \"../../utilities/continuation\";\nimport { define } from \"../../elements\";\nimport { baseTypeFromNothing } from \"../../utilities/type\";\n\nconst { every } = continuationUtilities,\n      { breakable } = breakPointUtilities;\n\nexport default define(class TypeDeclaration extends Declaration {\n  constructor(context, string, node, breakPoint, type, superTypes, provisional) {\n    super(context, string, node, breakPoint);\n\n    this.type = type;\n    this.superTypes = superTypes;\n    this.provisional = provisional;\n  }\n\n  getType() {\n    return this.type;\n  }\n\n  getSuperTypes() {\n    return this.superTypes;\n  }\n\n  isProvisional() {\n    return this.provisional;\n  }\n\n  gettypeDeclarationNode() {\n    const node = this.getNode(),\n          typeDeclarationNode = node; ///\n\n    return typeDeclarationNode;\n  }\n\n  getProperties() {\n    const properties = [];\n\n    return properties;\n  }\n\n  verify = breakable(function (context, continuation) {\n    const typeDeclarationString = this.getString();  ///\n\n    context.trace(`Verifying the '${typeDeclarationString}' type declaration...`);\n\n    const verifyType = this.verifyType.bind(this),\n          verifySuperTypes = this.verifySuperTypes.bind(this),\n          verifyTypePrefix = this.verifyTypePrefix.bind(this);\n\n    return all([\n      verifyType,\n      verifySuperTypes,\n      verifyTypePrefix\n    ], context, (verifies) => {\n      if (verifies) {\n        const properties = this.getProperties(),\n              typePrefix = context.getTypePrefix(),\n              prefixName = (typePrefix !== null) ?\n                             typePrefix.getPrefixName() :\n                               null;\n\n        this.type.setProvisional(this.provisional);\n\n        this.type.setProperties(properties);\n\n        this.type.setPrefixName(prefixName);\n\n        context.addType(this.type);\n      }\n\n      if (verifies) {\n        context.debug(`...verified the '${typeDeclarationString}' type declaration.`);\n      }\n\n      return continuation(verifies);\n    });\n  });\n\n  verifyType(context, continuation) {\n    let typeVerifies = false;\n\n    const typeString = this.type.getString(),\n          typeDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${typeString}' type...`);\n\n    const typeName = this.type.getName(),\n          includeRelease = false,\n          typePresent = context.isTypePresentByTypeName(typeName, includeRelease);\n\n    if (!typePresent) {\n      const prefixedTypeName = typeName, ///\n            typePresent = context.isTypePresentByPrefixedTypeName(prefixedTypeName);\n\n      if (!typePresent) {\n        typeVerifies = true;\n      } else {\n        context.debug(`The '${typeString}' type is already present.`);\n      }\n    } else {\n      context.debug(`The '${typeString}' type is already present.`);\n    }\n\n    if (typeVerifies) {\n      context.debug(`...verified the '${typeDeclarationString}' type declaration's '${typeString}' type`);\n    }\n\n    return continuation(typeVerifies);\n  }\n\n  verifyTypePrefix(context, continuation) {\n    let typePrefixVerifies = false;\n\n    const typeString = this.type.getString(),\n          typeDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${typeString}' type's prefix...`);\n\n    const typePrefixed = this.type.isPrefixed();\n\n    if (!typePrefixed) {\n      typePrefixVerifies = true;\n    } else {\n      context.debug(`The '${typeDeclarationString}' type declaration's '${typeString}' type is prefixed.`);\n    }\n\n    if (typePrefixVerifies) {\n      context.debug(`...verified the '${typeDeclarationString}' type declaration's '${typeString}' type's prefix.`);\n    }\n\n    return continuation(typePrefixVerifies);\n  }\n\n  verifySuperTypes(context, continuation) {\n    const superTypes = [],\n          typeDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${typeDeclarationString}' type declaration's super-types...`);\n\n    every(this.superTypes, (superType, continuation) => {\n      this.verifySuperType(superType, superTypes, context, continuation);\n    }, (superTypesVerify) => {\n      if (superTypesVerify) {\n        const superTypesLength = superTypes.length;\n\n        if (superTypesLength === 0) {\n          const baseType = baseTypeFromNothing(),\n                superTyupe = baseType;  ///\n\n          superTypes.push(superTyupe);\n        }\n\n        this.type.setSuperTypes(superTypes);\n\n        context.debug(`...verified the '${typeDeclarationString}' type declaration's super-types.`);\n      }\n\n      return continuation(superTypesVerify);\n    });\n  }\n\n  verifySuperType(superType, superTypes, context, continuation) {\n    let superTypeVerifies = false;\n\n    const superTypeString = superType.getString(),\n          typeDeclarationString = this.getString(); ///\n\n    context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${superTypeString}' super-type...`);\n\n    const nominalTypeName = superType.getNominalTypeName(),\n          typeName = nominalTypeName, ///\n          typeComparesToTypeName = this.type.compareTypeName(typeName);\n\n    if (!typeComparesToTypeName) {\n      superType = context.findTypeByNominalTypeName(nominalTypeName);\n\n      if (superType !== null) {\n        superTypes.push(superType);\n\n        superTypeVerifies = true;\n      } else {\n        context.debug(`The '${superTypeString}' super-type is not present.`);\n      }\n    } else {\n      context.debug(`The '${superTypeString}' super-type's name compares to the ${typeName}' type's name.`);\n    }\n\n    if (superTypeVerifies) {\n      context.debug(`...verified the '${typeDeclarationString}' type declaration's '${superTypeString}' super-type.`);\n    }\n\n    return continuation(superTypeVerifies);\n  }\n\n  static name = \"TypeDeclaration\";\n});\n"],"names":["every","continuationUtilities","breakable","breakPointUtilities","define","TypeDeclaration","Declaration","context","string","node","breakPoint","type","superTypes","provisional","getType","getSuperTypes","isProvisional","gettypeDeclarationNode","getNode","typeDeclarationNode","getProperties","properties","verify","continuation","typeDeclarationString","getString","trace","verifyType","bind","verifySuperTypes","verifyTypePrefix","all","verifies","typePrefix","getTypePrefix","prefixName","getPrefixName","setProvisional","setProperties","setPrefixName","addType","debug","typeVerifies","typeString","typeName","getName","includeRelease","typePresent","isTypePresentByTypeName","prefixedTypeName","isTypePresentByPrefixedTypeName","typePrefixVerifies","typePrefixed","isPrefixed","superType","verifySuperType","superTypesVerify","superTypesLength","length","baseType","baseTypeFromNothing","superTyupe","push","setSuperTypes","superTypeVerifies","superTypeString","nominalTypeName","getNominalTypeName","typeComparesToTypeName","compareTypeName","findTypeByNominalTypeName","name"],"mappings":"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"}

package/package.json CHANGED Viewed

@@ -1,7 +1,7 @@
 {
   "name": "occam-nominal",
   "author": "James Smith",
-  "version": "1.0.323",
+  "version": "1.0.324",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-nominal",
   "description": "Occam's Nominal language.",

package/src/element/constructor.js CHANGED Viewed

@@ -3,6 +3,7 @@
 import { Element, breakPointUtilities, continuationUtilities } from "occam-languages";
 import { define } from "../elements";
+import { exists } from "../utilities/continuation";
 import { baseTypeFromNothing } from "../utilities/type";
 import { instantiateConstructor } from "../process/instantiate";
 import { validateTermAsVariable } from "../process/validation";
@@ -73,7 +74,7 @@ export default define(class Constructor extends Element {
     this.type = type;
   }
-  async verify(context) {
+  verify(context, continuation) {
     let verifies = false;
     const includeType = false,
@@ -81,68 +82,102 @@ export default define(class Constructor extends Element {
     context.trace(`Verifying the '${constructorString}' constructor...`);
-    await attempt(async (context) => {
-      const termValidates = await this.validateTerm(context);
+    attempt((context) => {
+      this.validateTerm(context, (termValidates) => {
+        if (termValidates) {
+          verifies = true;
+        }
-      if (termValidates) {
-        verifies = true;
-      }
+        if (verifies) {
+          this.commit(context);
+        }
-      if (verifies) {
-        this.commit(context);
-      }
+        if (verifies) {
+          context.debug(`...verified the '${constructorString}' constructor.`);
+        }
+        return continuation(verifies);
+      });
     }, context);
+  }
-    if (verifies) {
-      context.debug(`...verified the '${constructorString}' constructor.`);
-    }
+  validateTerm(context, continuation) {
+    const includeType = false,
+          constructorString = this.getString(includeType);
+    context.trace(`Validating the '${constructorString}' constructor's term...`);
-    return verifies;
+    const validateTermAsVariable = this.validateTermAsVariable.bind(this),
+          validateTermAsConstructor = this.validateTermAsConstructor.bind(this);
+    return exists([
+      validateTermAsVariable,
+      validateTermAsConstructor
+    ], context, (termValidates) => {
+      if (termValidates) {
+        context.debug(`...validated the '${constructorString}' constructor's term.`);
+      }
+      return continuation(termValidates);
+    });
   }
-  async validateTerm(context) {
-    let termValidates = false;
+  validateTermAsVariable(context, continuation) {
+    const hypothtical = this.isHypothetical();
+    if (!hypothtical) {
+      const termValidatesAsVariable = false;
+      return continuation(termValidatesAsVariable);
+    }
     const includeType = false,
           constructorString = this.getString(includeType);
     context.trace(`Validating the '${constructorString}' constructor's term...`);
+    validateTermAsVariable(this.term, context, (term, context) => {
+      let termValidatesAsVariable = false;
+      const type = term.getType(),
+            baseType = baseTypeFromNothing();
+      if (type === baseType) {
+        termValidatesAsVariable = true;
+      }
+      if (termValidatesAsVariable) {
+        context.debug(`...validated the '${constructorString}' constructor's term.`);
+      }
+      return continuation(termValidatesAsVariable);
+    });
+  }
+  validateTermAsConstructor(context, continuation) {
     const hypothtical = this.isHypothetical();
     if (hypothtical) {
-      const termValidatesAsVariable = await validateTermAsVariable(this.term, context, async (term, context) => { ///
-        let validatesForwards = false;
+      const termValidatesAsConstructor = false;
-        const type = term.getType(),
-              baseType = baseTypeFromNothing();
-        if (type === baseType) {
-          validatesForwards = true;
-        }
+      return continuation(termValidatesAsConstructor);
+    }
-        return validatesForwards;
-      });
+    const includeType = false,
+          constructorString = this.getString(includeType);
-      if (termValidatesAsVariable) {
-        termValidates = true;
-      }
-    } else {
-      const termValidatesAsConstructor = await validateTermAsConstructor(this.term, context);
+    context.trace(`Validating the '${constructorString}' constructor's term...`);
+    validateTermAsConstructor(this.term, context, (termValidatesAsConstructor) => {
       if (termValidatesAsConstructor) {
-        termValidates = true;
+        context.debug(`...validated the '${constructorString}' constructor's term.`);
       }
-    }
-    if (termValidates) {
-      context.debug(`...validated the '${constructorString}' constructor's term.`);
-    }
-    return termValidates;
+      return continuation(termValidatesAsConstructor);
+    });
   }
-  async unifyTerm(term, context, validateForwards) {
+  unifyTerm(term, context, continuation) {
     let termUnifies = false;
     const termString = term.getString(),
@@ -151,7 +186,7 @@ export default define(class Constructor extends Element {
     context.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`);
-    const hypothesesDiscardedGivenTerm = await this.dischargeHypothesesGivenTerm(term, context);
+    const hypothesesDiscardedGivenTerm = this.dischargeHypothesesGivenTerm(term, context);
     if (hypothesesDiscardedGivenTerm) {
       const constructor = this, ///
@@ -167,7 +202,7 @@ export default define(class Constructor extends Element {
         term.setProvisional(provisional);
-        const validatesForwards = await validateForwards(term, context);
+        const validatesForwards = validateForwards(term, context);
         if (validatesForwards) {
           termUnifies = true;
@@ -182,10 +217,10 @@ export default define(class Constructor extends Element {
     return termUnifies;
   }
-  async dischargeHypothesisGivenTerm(hypothesis, term, context) {
+  dischargeHypothesisGivenTerm(hypothesis, term, context) {
     let hypothesisDischargesGivenTerm;
-    await this.break(context);
+    this.break(context);
     const termString = term.getString(),
           hypothesisString = hypothesis.getString(),
@@ -193,7 +228,7 @@ export default define(class Constructor extends Element {
     context.trace(`Discharding the '${constructorString}' constructor's '${hypothesisString}' hypothesis given the '${termString}' term...`);
-    hypothesisDischargesGivenTerm = await hypothesis.dischargeGivenTerm(term, context);
+    hypothesisDischargesGivenTerm = hypothesis.dischargeGivenTerm(term, context);
     if (hypothesisDischargesGivenTerm) {
       context.trace(`...discharges the '${constructorString}' constructor's '${hypothesisString}' hypothesis given the '${termString}' term.`);
@@ -202,14 +237,14 @@ export default define(class Constructor extends Element {
     return hypothesisDischargesGivenTerm;
   }
-  async dischargeHypothesesGivenTerm(term, context) {
+  dischargeHypothesesGivenTerm(term, context) {
     let hypothesesDischargesGivenTerm = true;  ///
     const hypothetical = this.isHypothetical();
     if (hypothetical) {
-      hypothesesDischargesGivenTerm = await every(this.hypotheses, async (hypothesis) => {
-        const hypothesisDischarges = await this.dischargeHypothesisGivenTerm(hypothesis, term, context);
+      hypothesesDischargesGivenTerm = every(this.hypotheses, (hypothesis) => {
+        const hypothesisDischarges = this.dischargeHypothesisGivenTerm(hypothesis, term, context);
         if (hypothesisDischarges) {
           return true;

package/src/element/declaration/constructor.js CHANGED Viewed

@@ -1,9 +1,14 @@
 "use strict";
+import { breakPointUtilities } from "occam-languages";
 import Declaration from "../declaration";
+import { all } from "../../utilities/continuation";
 import { define } from "../../elements";
+const { breakable } = breakPointUtilities;
 export default define(class ConstructorDeclaration extends Declaration {
   constructor(context, string, node, breakPoint, type, provisional, constructor) {
     super(context, string, node, breakPoint);
@@ -34,37 +39,33 @@ export default define(class ConstructorDeclaration extends Declaration {
   setHypotheses(hypotheses) { this.constructor.setHypotheses(hypotheses); }
-  async verify(context) {
-    let verifies = false;
-    await this.break(context);
+  verify = breakable(function (context, continuation) {
     const constructorDeclarationString = this.getString();  ///
     context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
-    const typeVerified = this.verifyType(context);
+    const verifyType = this.verifyType.bind(this),
+          verifyConstructor = this.verifyConstructor.bind(this);
-    if (typeVerified) {
-      const constructorVerifies = this.verifyConstructor(context);
-      if (constructorVerifies) {
+    return all([
+      verifyType,
+      verifyConstructor
+    ], context, (verifies) => {
+      if (verifies) {
         this.constructor.setType(this.type);
         context.addConstructor(this.constructor);
-        verifies = true;
       }
-    }
-    if (verifies) {
-      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
-    }
+      if (verifies) {
+        context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
+      }
-    return verifies;
-  }
+      return continuation(verifies);
+    });
+  });
-  verifyType(context) {
+  verifyType(context, continuation) {
     let typeVerifies = false;
     const constructorDeclarationString = this.getString();  ///
@@ -102,25 +103,23 @@ export default define(class ConstructorDeclaration extends Declaration {
       context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's type.`);
     }
-    return typeVerifies;
+    return continuation(typeVerifies);
   }
-  verifyConstructor(context) {
-    let constructorVerifies;
+  verifyConstructor(context, continuation) {
     const includeType = false,
           constructorString = this.constructor.getString(includeType),
           constructorDeclarationString = this.getString();  ///
     context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor...`);
-    constructorVerifies = this.constructor.verify(context);
-    if (constructorVerifies) {
-      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor.`);
-    }
+    this.constructor.verify(context, (constructorVerifies) => {
+      if (constructorVerifies) {
+        context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor.`);
+      }
-    return constructorVerifies;
+      return continuation(constructorVerifies);
+    });
   }
   static name = "ConstructorDeclaration";

package/src/element/declaration/type.js CHANGED Viewed

@@ -1,10 +1,16 @@
 "use strict";
+import { breakPointUtilities, continuationUtilities } from "occam-languages";
 import Declaration from "../declaration";
+import { all } from "../../utilities/continuation";
 import { define } from "../../elements";
 import { baseTypeFromNothing } from "../../utilities/type";
+const { every } = continuationUtilities,
+      { breakable } = breakPointUtilities;
 export default define(class TypeDeclaration extends Declaration {
   constructor(context, string, node, breakPoint, type, superTypes, provisional) {
     super(context, string, node, breakPoint);
@@ -39,51 +45,45 @@ export default define(class TypeDeclaration extends Declaration {
     return properties;
   }
-  async verify(context) {
-    let verifies = false;
-    await this.break(context);
+  verify = breakable(function (context, continuation) {
     const typeDeclarationString = this.getString();  ///
     context.trace(`Verifying the '${typeDeclarationString}' type declaration...`);
-    const typeVerifies = this.verifyType(context);
-    if (typeVerifies) {
-      const superTypesVerify = this.verifySuperTypes(context);
-      if (superTypesVerify) {
-        const typePrefixVerifies = this.verifyTypePrefix(context);
+    const verifyType = this.verifyType.bind(this),
+          verifySuperTypes = this.verifySuperTypes.bind(this),
+          verifyTypePrefix = this.verifyTypePrefix.bind(this);
-        if (typePrefixVerifies) {
-          const properties = this.getProperties(),
-                typePrefix = context.getTypePrefix(),
-                prefixName = (typePrefix !== null) ?
-                               typePrefix.getPrefixName() :
-                                 null;
+    return all([
+      verifyType,
+      verifySuperTypes,
+      verifyTypePrefix
+    ], context, (verifies) => {
+      if (verifies) {
+        const properties = this.getProperties(),
+              typePrefix = context.getTypePrefix(),
+              prefixName = (typePrefix !== null) ?
+                             typePrefix.getPrefixName() :
+                               null;
-          this.type.setProvisional(this.provisional);
+        this.type.setProvisional(this.provisional);
-          this.type.setProperties(properties);
+        this.type.setProperties(properties);
-          this.type.setPrefixName(prefixName);
+        this.type.setPrefixName(prefixName);
-          context.addType(this.type);
-          verifies = true;
-        }
+        context.addType(this.type);
       }
-    }
-    if (verifies) {
-      context.debug(`...verified the '${typeDeclarationString}' type declaration.`);
-    }
+      if (verifies) {
+        context.debug(`...verified the '${typeDeclarationString}' type declaration.`);
+      }
-    return verifies;
-  }
+      return continuation(verifies);
+    });
+  });
-  verifyType(context) {
+  verifyType(context, continuation) {
     let typeVerifies = false;
     const typeString = this.type.getString(),
@@ -112,97 +112,91 @@ export default define(class TypeDeclaration extends Declaration {
       context.debug(`...verified the '${typeDeclarationString}' type declaration's '${typeString}' type`);
     }
-    return typeVerifies;
+    return continuation(typeVerifies);
   }
-  verifySuperType(superType, superTypes, context) {
-    let superTypeVerifies = false;
+  verifyTypePrefix(context, continuation) {
+    let typePrefixVerifies = false;
-    const superTypeString = superType.getString(),
+    const typeString = this.type.getString(),
           typeDeclarationString = this.getString(); ///
-    context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${superTypeString}' super-type...`);
-    const nominalTypeName = superType.getNominalTypeName(),
-          typeName = nominalTypeName, ///
-          typeComparesToTypeName = this.type.compareTypeName(typeName);
-    if (!typeComparesToTypeName) {
-      superType = context.findTypeByNominalTypeName(nominalTypeName);
+    context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${typeString}' type's prefix...`);
-      if (superType !== null) {
-        superTypes.push(superType);
+    const typePrefixed = this.type.isPrefixed();
-        superTypeVerifies = true;
-      } else {
-        context.debug(`The '${superTypeString}' super-type is not present.`);
-      }
+    if (!typePrefixed) {
+      typePrefixVerifies = true;
     } else {
-      context.debug(`The '${superTypeString}' super-type's name compares to the ${typeName}' type's name.`);
+      context.debug(`The '${typeDeclarationString}' type declaration's '${typeString}' type is prefixed.`);
     }
-    if (superTypeVerifies) {
-      context.debug(`...verified the '${typeDeclarationString}' type declaration's '${superTypeString}' super-type.`);
+    if (typePrefixVerifies) {
+      context.debug(`...verified the '${typeDeclarationString}' type declaration's '${typeString}' type's prefix.`);
     }
-    return superTypeVerifies;
+    return continuation(typePrefixVerifies);
   }
-  verifySuperTypes(context) {
-    let superTypesVerify;
+  verifySuperTypes(context, continuation) {
     const superTypes = [],
           typeDeclarationString = this.getString(); ///
     context.trace(`Verifying the '${typeDeclarationString}' type declaration's super-types...`);
-    superTypesVerify = this.superTypes.every((superType) => {
-      const superTypeVerifies = this.verifySuperType(superType, superTypes, context);
+    every(this.superTypes, (superType, continuation) => {
+      this.verifySuperType(superType, superTypes, context, continuation);
+    }, (superTypesVerify) => {
+      if (superTypesVerify) {
+        const superTypesLength = superTypes.length;
-      if (superTypeVerifies) {
-        return true;
-      }
-    });
+        if (superTypesLength === 0) {
+          const baseType = baseTypeFromNothing(),
+                superTyupe = baseType;  ///
-    if (superTypesVerify) {
-      const superTypesLength = superTypes.length;
+          superTypes.push(superTyupe);
+        }
-      if (superTypesLength === 0) {
-        const baseType = baseTypeFromNothing(),
-              superTyupe = baseType;  ///
+        this.type.setSuperTypes(superTypes);
-        superTypes.push(superTyupe);
+        context.debug(`...verified the '${typeDeclarationString}' type declaration's super-types.`);
       }
-      this.type.setSuperTypes(superTypes);
-      context.debug(`...verified the '${typeDeclarationString}' type declaration's super-types.`);
-    }
-    return superTypesVerify;
+      return continuation(superTypesVerify);
+    });
   }
-  verifyTypePrefix(context) {
-    let typePrefixVerifies = false;
+  verifySuperType(superType, superTypes, context, continuation) {
+    let superTypeVerifies = false;
-    const typeString = this.type.getString(),
+    const superTypeString = superType.getString(),
           typeDeclarationString = this.getString(); ///
-    context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${typeString}' type's prefix...`);
+    context.trace(`Verifying the '${typeDeclarationString}' type declaration's '${superTypeString}' super-type...`);
-    const typePrefixed = this.type.isPrefixed();
+    const nominalTypeName = superType.getNominalTypeName(),
+          typeName = nominalTypeName, ///
+          typeComparesToTypeName = this.type.compareTypeName(typeName);
-    if (!typePrefixed) {
-      typePrefixVerifies = true;
+    if (!typeComparesToTypeName) {
+      superType = context.findTypeByNominalTypeName(nominalTypeName);
+      if (superType !== null) {
+        superTypes.push(superType);
+        superTypeVerifies = true;
+      } else {
+        context.debug(`The '${superTypeString}' super-type is not present.`);
+      }
     } else {
-      context.debug(`The '${typeDeclarationString}' type declaration's '${typeString}' type is prefixed.`);
+      context.debug(`The '${superTypeString}' super-type's name compares to the ${typeName}' type's name.`);
     }
-    if (typePrefixVerifies) {
-      context.debug(`...verified the '${typeDeclarationString}' type declaration's '${typeString}' type's prefix.`);
+    if (superTypeVerifies) {
+      context.debug(`...verified the '${typeDeclarationString}' type declaration's '${superTypeString}' super-type.`);
     }
-    return typePrefixVerifies;
+    return continuation(superTypeVerifies);
   }
   static name = "TypeDeclaration";