occam-verify-cli 1.0.768 → 1.0.781

package/src/element/assumption.js

@@ -3,8 +3,8 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
+import { descend, instantiate } from "../utilities/context";
 import { instantiateAssumption } from "../process/instantiate";
-import { instantiate, reconcile } from "../utilities/context";
 
 export default define(class Assumption extends Element {
   constructor(context, string, node, reference, statement) {
@@ -31,6 +31,8 @@ export default define(class Assumption extends Element {
 
   getMetavariable() { return this.reference.getMetavariable(); }
 
+  getTopLevelMetaAssertion() { return this.reference.getTopLevelMetaAssertion(); }
+
   matchAssumptionNode(assumptionNode) {
     const node = assumptionNode, ///
           nodeMatches = this.matchNode(node),
@@ -39,28 +41,21 @@ export default define(class Assumption extends Element {
     return assumptionNodeMatches;
   }
 
-  compareSubstitution(substitution, context) {
-    let comparesToSubstituion = false;
+  compareMetaLevelSubstitution(metaLevelSubstitution, context) {
+    let comparesToMetaLevelSubstitution = false;
 
     const assumptionString = this.getString(),  ///
-          substitutionString = substitution.getString();
-
-    context.trace(`Comparing the '${assumptionString}' assumption to the '${substitutionString}' substitution...`);
+          metaLevelSubstitutionString = metaLevelSubstitution.getString();
 
-    const statement = substitution.getStatement(),
-          metavariableName = substitution.getMetavariableName(),
-          statementEqualToStatement = this.statement.isEqualTo(statement),
-          referenceMetavariableComparesToMetavariable = this.reference.compareMetavariableName(metavariableName);
+    context.trace(`Comparing the '${assumptionString}' assumption to the '${metaLevelSubstitutionString}' meta-level substitution...`);
 
-    if (statementEqualToStatement && referenceMetavariableComparesToMetavariable) {
-      comparesToSubstituion = true;
-    }
+    debugger
 
-    if (comparesToSubstituion) {
-      context.debug(`...compared the '${substitutionString}' assumption to the '${assumptionString}' substitution.`);
+    if (comparesToMetaLevelSubstitution) {
+      context.debug(`...compared the '${assumptionString}' assumption to the '${metaLevelSubstitutionString}' meta-level substitution.`);
     }
 
-    return comparesToSubstituion;
+    return comparesToMetaLevelSubstitution;
   }
 
   findValidAssumption(context) {
@@ -71,7 +66,7 @@ export default define(class Assumption extends Element {
     return validAssumption;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let assumption = null;
 
     const assumptionString = this.getString();  ///
@@ -87,12 +82,14 @@ export default define(class Assumption extends Element {
     } else {
       let validates = false;
 
-      const statementValidates = this.validateStatement(stated, context);
+      const statementValidates = this.validateStatement(context);
 
       if (statementValidates) {
-        const referenceValidates = this.validateReference(stated, context);
+        const referenceValidates = this.validateReference(context);
 
         if (referenceValidates) {
+          const stated = context.isStated();
+
           let validatesWhenStated = false,
               validatesWhenDerived = false;
 
@@ -120,11 +117,11 @@ export default define(class Assumption extends Element {
     return assumption;
   }
 
-  validateReference(stated, context) {
+  validateReference(context) {
     let referenceValidates = false;
 
-    const assumptionString = this.getString(),  ///
-          referenceString = this.reference.getString();
+    const referenceString = this.reference.getString(),
+          assumptionString = this.getString();  ///
 
     context.trace(`Validating the '${assumptionString}' assumption's '${referenceString}' reference...`);
 
@@ -137,7 +134,7 @@ export default define(class Assumption extends Element {
       if (metavariablePresent) {
         referenceValidates = true;
       } else {
-        const topLevelMetaAssertions = context.findTopLevelMetaAssertionsByReference(this.reference, context),
+        const topLevelMetaAssertions = context.findTopLevelMetaAssertionsByReference(this.reference),
               topLevelMetaAssertionsCompare = topLevelMetaAssertions.some((topLevelMetaAssertion) => {
                 const topLevelMetaAssertionUnifies = this.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
 
@@ -153,13 +150,13 @@ export default define(class Assumption extends Element {
     }
 
     if (referenceValidates) {
-      context.debug(`...validated the '${assumptionString}' assumption's '${referenceString}' statement.`);
+      context.debug(`...validated the '${assumptionString}' assumption's '${referenceString}' reference.`);
     }
 
     return referenceValidates;
   }
 
-  validateStatement(stated, context) {
+  validateStatement(context) {
     let statementValidates = false;
 
     const assumptionString = this.getString(),  ///
@@ -167,13 +164,13 @@ export default define(class Assumption extends Element {
 
     context.trace(`Validating the '${assumptionString}' assumption's '${statementString}' statement...`);
 
-    stated = true;  ///
-
-    const statement = this.statement.validate(stated, context);
+    descend((context) => {
+      const statement = this.statement.validate(context);
 
-    if (statement !== null) {
-      statementValidates = true;
-    }
+      if (statement !== null) {
+        statementValidates = true;
+      }
+    }, context);
 
     if (statementValidates) {
       context.debug(`...validated the '${assumptionString}' assumption's '${statementString}' statement.`);
@@ -199,13 +196,18 @@ export default define(class Assumption extends Element {
   }
 
   validateWhenDerived(context) {
-    let validatesWhenDerived;
+    let validatesWhenDerived = false;
 
     const assumptionString = this.getString();  ///
 
     context.trace(`Validating the '${assumptionString}' derived assumption...`);
+    const topLevelMetaAssertion = this.getTopLevelMetaAssertion();
 
-    validatesWhenDerived = true;
+    if (topLevelMetaAssertion !== null) {
+      validatesWhenDerived = true;
+    } else {
+      context.debug(`The '${assumptionString}' asumption did not unify a top level meta-assumption.`);
+    }
 
     if (validatesWhenDerived) {
       context.debug(`...validated the '${assumptionString}' derived assumption.`);
@@ -214,50 +216,19 @@ export default define(class Assumption extends Element {
     return validatesWhenDerived;
   }
 
-  unifyLabel(label, generalContext, specificContext) {
-    let labelUnifiesWithReference;
-
-    const context = generalContext, ///
-          labelString = label.getString(),
-          assumptionString = this.getString();  //;/
-
-    context.trace(`Unifying the '${labelString}' label with the '${assumptionString}' assumption...`);
-
-    const labelUnifies = this.reference.unifyLabel(label, context);
-
-    labelUnifiesWithReference = labelUnifies; ///
-
-    if (labelUnifiesWithReference) {
-      context.debug(`...unified the '${labelString}' label with the '${assumptionString}' assumption.`);
-    }
-
-    return labelUnifiesWithReference;
-  }
-
   unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
-    let topLevelMetaAssertionUnifies = false;
+    let topLevelMetaAssertionUnifies;
 
     const assumptionString = this.getString(),  ///
           topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
     context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${assumptionString}' assumption...`);
 
-    const generalContext = context; ///
-
-    context = topLevelMetaAssertion.getContext();  ///
+    topLevelMetaAssertionUnifies = this.reference.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
 
-    const specificContext = context;  ///
-
-    reconcile((specificContext) => {
-      const label = topLevelMetaAssertion.getLabel(),
-            labelUnifies = this.unifyLabel(label, generalContext, specificContext);
-
-      if (labelUnifies) {
-        topLevelMetaAssertionUnifies = this.statement.unifyTopLevelMetaAssertion(topLevelMetaAssertion, generalContext, specificContext);
-
-        specificContext.commit(context);
-      }
-    }, specificContext);
+    if (topLevelMetaAssertionUnifies) {
+      topLevelMetaAssertionUnifies = this.statement.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
+    }
 
     if (topLevelMetaAssertionUnifies) {
       context.trace(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${assumptionString}' assumption...`);

package/src/element/combinator/bracketed.js

@@ -12,14 +12,14 @@ export default define(class BracketedCombinator extends Combinator {
     return bracketedCombinatorNode;
   }
 
-  unifyStatement(statement, stated, context) {
+  unifyStatement(statement, context) {
     let statementUnifies;
 
     const statementString = statement.getString();
 
     context.trace(`Unifying the '${statementString}' statement with the bracketed combinator...`);
 
-    statementUnifies = super.unifyStatement(statement, stated, context);
+    statementUnifies = super.unifyStatement(statement, context);
 
     if (statementUnifies) {
       context.debug(`...unified the '${statementString}' statement with the bracketed combinator.`);

package/src/element/combinator.js

@@ -3,12 +3,11 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { attempt, instantiate } from "../utilities/context";
 import { instantiateCombinator } from "../process/instantiate";
 import { statementFromCombinatorNode } from "../utilities/element";
 import { unifyStatementWithCombinator } from "../process/unify";
 import { validateStatementAsCombinator } from "../process/validate";
-import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
+import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Combinator extends Element {
   constructor(context, string, node, statement) {
@@ -73,7 +72,7 @@ export default define(class Combinator extends Element {
     return statementValidates;
   }
 
-  unifyStatement(statement, stated, context) {
+  unifyStatement(statement, context) {
     let statementUnifies;
 
     const statementString = statement.getString(),
@@ -90,7 +89,7 @@ export default define(class Combinator extends Element {
     context = specifiContext; ///
 
     const combinator = this, ///
-          statementUnifiesWithCombinator = unifyStatementWithCombinator(statement, combinator, stated, generalContext, specifiContext);
+          statementUnifiesWithCombinator = unifyStatementWithCombinator(statement, combinator, generalContext, specifiContext);
 
     statementUnifies = statementUnifiesWithCombinator; ///
 
@@ -102,40 +101,35 @@ export default define(class Combinator extends Element {
   }
 
   toJSON() {
-    let context;
+    const context = this.getContext();
 
-    context = this.getContext();
-
-    const ephemeralContext = context, ///
-          ephemeralContextJSON = ephemeralContextToEphemeralContextJSON(ephemeralContext),
-          contextJSON = ephemeralContextJSON; ///
-
-    context = contextJSON;  ///
+    return serialise((context) => {
+      const string = this.getString(),
+            json = {
+              context,
+              string
+            };
 
-    const string = this.getString(),
-          json = {
-            context,
-            string
-          };
-
-    return json;
+      return json;
+    }, context);
   }
 
   static name = "Combinator";
 
   static fromJSON(json, context) {
-    const ephemeralContext = ephemeralContextFromJSON(json, context);
+    let combinator;
 
-    context = ephemeralContext; ///
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string } = json,
+              combinatorNode = instantiateCombinator(string, context),
+              node = combinatorNode,  ///
+              statement = statementFromCombinatorNode(combinatorNode, context);
 
-    return instantiate((context) => {
-      const { string } = json,
-            combinatorNode = instantiateCombinator(string, context),
-            node = combinatorNode,  ///
-            statement = statementFromCombinatorNode(combinatorNode, context),
-            combinator = new Combinator(context, string, node, statement);
+        combinator = new Combinator(context, string, node, statement);
+      }, context);
+    }, json, context);
 
-      return combinator;
-    }, context);
+    return combinator;
   }
 });

package/src/element/conclusion.js

@@ -3,11 +3,10 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { attempt, instantiate } from "../utilities/context";
 import { instantiateConclusion } from "../process/instantiate";
-import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
+import { declare, attempt, descend, serialise, unserialise, instantiate } from "../utilities/context";
 
-export  default define(class Conclusion extends Element {
+export default define(class Conclusion extends Element {
   constructor(context, string, node, statement) {
     super(context, string, node);
 
@@ -58,14 +57,16 @@ export  default define(class Conclusion extends Element {
 
     context.trace(`Validating the '${conclusionString}' conclusion...`);
 
-    attempt((context) => {
-      const statementValidates = this.validateStatement(context);
+    declare((context) => {
+      attempt((context) => {
+        const statementValidates = this.validateStatement(context);
 
-      if (statementValidates) {
-        context.commit(this);
+        if (statementValidates) {
+          context.commit(this);
 
-        validates = true;
-      }
+          validates = true;
+        }
+      }, context);
     }, context);
 
     if (validates) {
@@ -76,19 +77,20 @@ export  default define(class Conclusion extends Element {
   }
 
   validateStatement(context) {
-    let statementValidates;
+    let statementValidates = false;
 
     const statementString = this.statement.getString(),
           conclusionString = this.getString();  ///
 
     context.trace(`Validating the '${conclusionString}' conclusion's '${statementString}' statement...`);
 
-    const stated = true,
-          statement = this.statement.validate(stated, context);
+    descend((context) => {
+      const statement = this.statement.validate(context);
 
-    if (statement !== null) {
-      statementValidates = true;
-    }
+      if (statement !== null) {
+        statementValidates = true;
+      }
+    }, context);
 
     if (statementValidates) {
       context.trace(`...validated the '${conclusionString}' conclusion's '${statementString}' statement.`);
@@ -123,41 +125,36 @@ export  default define(class Conclusion extends Element {
   }
 
   toJSON() {
-    let context;
-
-    context = this.getContext();
-
-    const ephemeralContext = context, ///
-          ephemeralContextJSON = ephemeralContextToEphemeralContextJSON(ephemeralContext),
-          contextJSON = ephemeralContextJSON; ///
-
-    context = contextJSON;  ///
+    const context = this.getContext();
 
-    const string = this.getString(),
-          json = {
-            context,
-            string
-          };
+    return serialise((context) => {
+      const string = this.getString(),
+            json = {
+              context,
+              string
+            };
 
-    return json;
+      return json;
+    }, context);
   }
 
   static name = "Conclusion";
 
   static fromJSON(json, context) {
-    const ephemeralContext = ephemeralContextFromJSON(json, context);
+    let conclusion;
 
-    context = ephemeralContext; ///
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string } = json,
+              conclusionNode = instantiateConclusion(string, context),
+              node = conclusionNode,  ///
+              statement = statementFromConclusionNode(conclusionNode, context);
 
-    return instantiate((context) => {
-      const { string } = json,
-            conclusionNode = instantiateConclusion(string, context),
-            node = conclusionNode,  ///
-            statement = statementFromConclusionNode(conclusionNode, context),
-            conclusion = new Conclusion(context, string, node, statement);
+        conclusion = new Conclusion(context, string, node, statement);
+      }, context);
+    }, json, context);
 
-      return conclusion;
-    }, context);
+    return conclusion;
   }
 });
 

package/src/element/constructor.js

@@ -3,12 +3,12 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { attempt, instantiate } from "../utilities/context";
 import { instantiateConstructor } from "../process/instantiate";
 import { termFromConstructorNode } from "../utilities/element";
 import { unifyTermWithConstructor } from "../process/unify";
 import { validateTermAsConstructor } from "../process/validate";
-import { typeFromJSON, typeToTypeJSON, ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
+import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
+import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Constructor extends Element {
   constructor(context, string, node, term, type) {
@@ -143,45 +143,40 @@ export default define(class Constructor extends Element {
   }
 
   toJSON() {
-    let context;
-
-    context = this.getContext();
-
-    const ephemeralContext = context, ///
-          ephemeralContextJSON = ephemeralContextToEphemeralContextJSON(ephemeralContext),
-          contextJSON = ephemeralContextJSON; ///
-
-    context = contextJSON;  ///
-
-    const includeType = false,
-          typeJSON = typeToTypeJSON(this.type),
-          string = this.getString(includeType),
-          type = typeJSON,  ///
-          json = {
-            context,
-            string,
-            type
-          };
-
-    return json;
+    const context = this.getContext();
+
+    return serialise((context) => {
+      const includeType = false,
+            typeJSON = typeToTypeJSON(this.type),
+            string = this.getString(includeType),
+            type = typeJSON,  ///
+            json = {
+              context,
+              string,
+              type
+            };
+
+      return json;
+    }, context);
   }
 
   static name = "Constructor";
 
   static fromJSON(json, context) {
-    const ephemeralContext = ephemeralContextFromJSON(json, context);
+    let constructor;
 
-    context = ephemeralContext; ///
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string } = json,
+              constructorNode = instantiateConstructor(string, context),
+              node = constructorNode, ///
+              term = termFromConstructorNode(constructorNode, context),
+              type = typeFromJSON(json, context);
 
-    return instantiate((context) => {
-      const { string } = json,
-            constructorNode = instantiateConstructor(string, context),
-            node = constructorNode, ///
-            term = termFromConstructorNode(constructorNode, context),
-            type = typeFromJSON(json, context),
-            constructor = new Constructor(context, string, node, term, type);
+        constructor = new Constructor(context, string, node, term, type);
+      }, context);
+    }, json, context);
 
-      return constructor;
-    }, context);
+    return constructor;
   }
 });

package/src/element/deduction.js

@@ -3,9 +3,8 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { attempt, instantiate } from "../utilities/context";
 import { instantiateDeduction } from "../process/instantiate";
-import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
+import { declare, attempt, descend, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Deduction extends Element {
   constructor(context, string, node, statement) {
@@ -58,14 +57,16 @@ export default define(class Deduction extends Element {
 
     context.trace(`Validating the '${deductionString}' deduction...`);
 
-    attempt((context) => {
-      const statementValidates = this.validateStatement(context);
+    declare((context) => {
+      attempt((context) => {
+        const statementValidates = this.validateStatement(context);
 
-      if (statementValidates) {
-        context.commit(this);
+        if (statementValidates) {
+          context.commit(this);
 
-        validates = true;
-      }
+          validates = true;
+        }
+      }, context);
     }, context);
 
     if (validates) {
@@ -76,19 +77,20 @@ export default define(class Deduction extends Element {
   }
 
   validateStatement(context) {
-    let statementValidates;
+    let statementValidates = false;
 
     const statementString = this.statement.getString(),
           deductionnString = this.getString();  ///
 
     context.trace(`Validating the '${deductionnString}' deductionn's '${statementString}' statement...`);
 
-    const stated = true,
-          statement = this.statement.validate(stated, context);
+    descend((context) => {
+      const statement = this.statement.validate(context);
 
-    if (statement !== null) {
-      statementValidates = true;
-    }
+      if (statement !== null) {
+        statementValidates = true;
+      }
+    }, context);
 
     if (statementValidates) {
       context.trace(`...validated the '${deductionnString}' deductionn's '${statementString}' statement.`);
@@ -148,41 +150,36 @@ export default define(class Deduction extends Element {
   }
 
   toJSON() {
-    let context;
-
-    context = this.getContext();
-
-    const ephemeralContext = context, ///
-          ephemeralContextJSON = ephemeralContextToEphemeralContextJSON(ephemeralContext),
-          contextJSON = ephemeralContextJSON; ///
-
-    context = contextJSON;  ///
+    const context = this.getContext();
 
-    const string = this.getString(),
-          json = {
-            context,
-            string
-          };
+    return serialise((context) => {
+      const string = this.getString(),
+            json = {
+              context,
+              string
+            };
 
-    return json;
+      return json;
+    }, context);
   }
 
   static name = "Deduction";
 
   static fromJSON(json, context) {
-    const ephemeralContext = ephemeralContextFromJSON(json, context);
+    let deduction;
 
-    context = ephemeralContext; ///
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string } = json,
+              deductionNode = instantiateDeduction(string, context),
+              node = deductionNode,  ///
+              statement = statementFromDeductionNode(deductionNode, context);
 
-    return instantiate((context) => {
-      const { string } = json,
-            deductionNode = instantiateDeduction(string, context),
-            node = deductionNode,  ///
-            statement = statementFromDeductionNode(deductionNode, context),
-            deduction = new Deduction(context, string, node, statement);
+        deduction = new Deduction(context, string, node, statement);
+      }, context);
+    }, json, context);
 
-      return deduction;
-    }, context);
+    return deduction;
   }
 });