occam-verify-cli 1.0.768 → 1.0.776

package/src/element/assertion/property.js

@@ -57,7 +57,7 @@ export default define(class PropertyAssertion extends Assertion {
     return comparesToTermAndPropertyRelation;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let propertyAssertion = null;
 
     const propertyAssertionString = this.getString(); ///
@@ -73,12 +73,14 @@ export default define(class PropertyAssertion extends Assertion {
     } else {
       let validates = false;
 
-      const termValidates = this.validateTerm(stated, context);
+      const termValidates = this.validateTerm(context);
 
       if (termValidates) {
-        const propertyRelationVerifies = this.validatePropertyRelation(stated, context);
+        const propertyRelationVerifies = this.validatePropertyRelation(context);
 
         if (propertyRelationVerifies) {
+          const stated = context.isStated();
+
           let validatesWhenStated = false,
               validatesWhenDerived = false;
 
@@ -99,7 +101,7 @@ export default define(class PropertyAssertion extends Assertion {
 
         propertyAssertion = assertion;  ///
 
-        this.assign(stated, context);
+        this.assign(context);
 
         context.addAssertion(assertion);
 
@@ -110,7 +112,7 @@ export default define(class PropertyAssertion extends Assertion {
     return propertyAssertion;
   }
 
-  validateTerm(stated, context) {
+  validateTerm(context) {
     let termValidates = false;
 
     const termString = this.term.getString();
@@ -136,7 +138,7 @@ export default define(class PropertyAssertion extends Assertion {
     return termValidates;
   }
 
-  validatePropertyRelation(stated, context) {
+  validatePropertyRelation(context) {
     let propertyRelationValidates = false;
 
     const propertyRelationString = this.propertyRelation.getString();
@@ -188,16 +190,17 @@ export default define(class PropertyAssertion extends Assertion {
     return validatesWhenDerived;
   }
 
-  assign(stated, context) {
+  assign(context) {
+    const stated = context.isStated();
+
     if (!stated) {
       return;
     }
 
     const propertyAssertion = this, ///
-          variableAssigment = variableAssignmentFromPrepertyAssertion(propertyAssertion, context),
-          assignment = variableAssigment; ///
+          variableAssigment = variableAssignmentFromPrepertyAssertion(propertyAssertion, context);
 
-    context.addAssignment(assignment);
+    context.addAssignment(variableAssigment);
   }
 
   static name = "PropertyAssertion";
@@ -208,7 +211,7 @@ export default define(class PropertyAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      propertyAssertion = instantiate((context) => {
+      instantiate((context) => {
         const { string } = json,
               propertyAssertionNode = instantiatePropertyAssertion(string, context),
               node = propertyAssertionNode,  ///
@@ -217,9 +220,7 @@ export default define(class PropertyAssertion extends Assertion {
 
         context = null;
 
-        const propertyAssertion = new PropertyAssertion(context, string, node, term, propertyRelation);
-
-        return propertyAssertion;
+        propertyAssertion = new PropertyAssertion(context, string, node, term, propertyRelation);
       }, context);
     }
 

package/src/element/assertion/satisfies.js

@@ -34,7 +34,7 @@ export default define(class SatisfiesAssertion extends Assertion {
 
   correlateSubstitutions(substitutions, context) { return this.signature.correlateSubstitutions(substitutions, context); }
 
-  validate(stated, context) {
+  validate(context) {
     let satisfiesAssertion = null;
 
     const satisfiesAssertionString = this.getString(); ///
@@ -50,10 +50,10 @@ export default define(class SatisfiesAssertion extends Assertion {
     } else {
       let validates = true;
 
-      const signatureVerifies = this.validateSignature(stated, context);
+      const signatureVerifies = this.validateSignature(context);
 
       if (signatureVerifies) {
-        const referenceVerifies = this.validateReference(stated, context);
+        const referenceVerifies = this.validateReference(context);
 
         if (referenceVerifies) {
           validates = true;
@@ -76,7 +76,7 @@ export default define(class SatisfiesAssertion extends Assertion {
     return satisfiesAssertion;
   }
 
-  validateSignature(stated, context) {
+  validateSignature(context) {
     let signatureValidates = false;
 
     const signature = this.signature.validate(context);
@@ -88,7 +88,7 @@ export default define(class SatisfiesAssertion extends Assertion {
     return signatureValidates;
   }
 
-  validateReference(stated, context) {
+  validateReference(context) {
     let referenceVerifies = false;
 
     const referenceString = this.reference.getString(),
@@ -165,7 +165,7 @@ export default define(class SatisfiesAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      satisfiesAssertion = instantiate((context) => {const { string } = json,
+      instantiate((context) => {const { string } = json,
               definedAssertionNode = instantiateSatisfiesAssertion(string, context),
               node = definedAssertionNode,  ///
               signature = signatureFromJSatisfiesAssertionNode(definedAssertionNode, context),
@@ -173,9 +173,7 @@ export default define(class SatisfiesAssertion extends Assertion {
 
         context = null;
 
-        const satisfiesAssertion = new SatisfiesAssertion(context, string, node, signature, reference);
-
-        return satisfiesAssertion;
+        satisfiesAssertion = new SatisfiesAssertion(context, string, node, signature, reference);
       }, context);
     }
 

package/src/element/assertion/subproof.js

@@ -6,7 +6,7 @@ import Assertion from "../assertion";
 
 import { define } from "../../elements";
 import { reconcile } from "../../utilities/context";
-import { join, instantiate } from "../../utilities/context";
+import { join, descend, instantiate } from "../../utilities/context";
 import { instantiateSubproofAssertion } from "../../process/instantiate";
 
 const { last, front, backwardsEvery } = arrayUtilities;
@@ -49,7 +49,7 @@ export default define(class SubproofAssertion extends Assertion {
     return subproofAssertionNode;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let subproofAssertion = null;
 
     const subproofAssertionString = this.getString();  ///
@@ -65,7 +65,7 @@ export default define(class SubproofAssertion extends Assertion {
     } else {
       let validates = false;
 
-      const statementsValidate = this.validateStatements(stated, context);
+      const statementsValidate = this.validateStatements(context);
 
       if (statementsValidate) {
         validates = true;
@@ -85,17 +85,17 @@ export default define(class SubproofAssertion extends Assertion {
     return subproofAssertion;
   }
 
-  validateStatements(stated, context) {
-    stated = true;  ///
-
-    const statementsValidate = this.statements.map((statement) => {
+  validateStatements(context) {
+    const statementsValidate = this.statements.every((statement) => {
       let statementValidates = false;
 
-      statement = statement.validate(stated, context);  ///
+      descend((context) => {
+        statement = statement.validate(context);  ///
 
-      if (statement !== null) {
-        statementValidates = true;
-      }
+        if (statement !== null) {
+          statementValidates = true;
+        }
+      }, context);
 
       if (statementValidates) {
         return true;
@@ -239,7 +239,7 @@ export default define(class SubproofAssertion extends Assertion {
     return suppositionUnifies;
   }
 
-  unifySuppositions(suppositions, generalContext, specificContext) {
+  unifySuppositions(suppositions, generalContxt, spsecificContext) {
     let suppositionsUnify = false;
 
     const supposedStatements = this.getSupposedStatements(),
@@ -248,7 +248,7 @@ export default define(class SubproofAssertion extends Assertion {
 
     if (suppositionsLength === supposedStatementsLength) {
       suppositionsUnify = backwardsEvery(suppositions, (supposition, index) => {
-        const suppositionUnifies = this.unifySupposition(supposition, index, generalContext, specificContext);
+        const suppositionUnifies = this.unifySupposition(supposition, index, generalContxt, spsecificContext);
 
         if (suppositionUnifies) {
           return true;
@@ -259,30 +259,27 @@ export default define(class SubproofAssertion extends Assertion {
     return suppositionsUnify;
   }
 
-  unifyTopLevelMetaAssertion(topLevelMetaAssertion, generalContext, specificContext) {
+  unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
     let topLevelMetaAssertionUnifies = false;
 
-    const context = specificContext,  ///
+    const generalContext = context, ///
+          specificContext = context,  ///
           subproofAssertionString = this.getString(),  ///
           topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
     context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${subproofAssertionString}' subproof assertion...`);
 
-    reconcile((specificContext) => {
-      const deduction = topLevelMetaAssertion.getDeduction(),
-            deductionUnifies = this.unifyDeduction(deduction, generalContext, specificContext);
-
-      if (deductionUnifies) {
-        const suppositions = topLevelMetaAssertion.getSuppositions(),
-              suppositionsUnify = this.unifySuppositions(suppositions, generalContext, specificContext);
+    const deduction = topLevelMetaAssertion.getDeduction(),
+          deductionUnifies = this.unifyDeduction(deduction, generalContext, specificContext);
 
-        if (suppositionsUnify) {
-          specificContext.commit();
+    if (deductionUnifies) {
+      const suppositions = topLevelMetaAssertion.getSuppositions(),
+            suppositionsUnify = this.unifySuppositions(suppositions, generalContext, specificContext);
 
-          topLevelMetaAssertionUnifies = true;
-        }
+      if (suppositionsUnify) {
+        topLevelMetaAssertionUnifies = true;
       }
-    }, specificContext);
+    }
 
     if (topLevelMetaAssertionUnifies) {
       context.debug(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${subproofAssertionString}' subproof assertion.`);
@@ -299,7 +296,7 @@ export default define(class SubproofAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      subproorAssertion = instantiate((context) => {
+      instantiate((context) => {
         const { string } = json,
               subproofAssertionNode = instantiateSubproofAssertion(string, context),
               statements = statementsFromSubproofAssertionNode(subproofAssertionNode, context),
@@ -307,9 +304,7 @@ export default define(class SubproofAssertion extends Assertion {
 
         context = null;
 
-        const subproorAssertion = new SubproofAssertion(context, string, node, statements);
-
-        return subproorAssertion;
+        subproorAssertion = new SubproofAssertion(context, string, node, statements);
       }, context);
     }
 

package/src/element/assertion/type.js

@@ -32,7 +32,7 @@ export default define(class TypeAssertion extends Assertion {
     return typeAssertionNode;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let typeAssertion = null;
 
     const typeAssertionString = this.getString();  ///
@@ -51,6 +51,8 @@ export default define(class TypeAssertion extends Assertion {
       const typeValidates = this.validateType(context);
 
       if (typeValidates) {
+        const stated = context.isStated();
+
         let validatesWhenStated = false,
             validatesWhenDerived = false;
 
@@ -70,7 +72,7 @@ export default define(class TypeAssertion extends Assertion {
 
         typeAssertion = assertion;  ///
 
-        this.assign(stated, context);
+        this.assign(context);
 
         context.addAssertion(assertion);
 
@@ -177,7 +179,9 @@ export default define(class TypeAssertion extends Assertion {
     return validatesWhenDerived;
   }
 
-  assign(stated, context) {
+  assign(context) {
+    const stated = context.isStated();
+
     if (!stated) {
       return;
     }
@@ -185,11 +189,7 @@ export default define(class TypeAssertion extends Assertion {
     const typeAssertion = this, ///
           variableAssigment = variableAssignmentFromTypeAssertion(typeAssertion, context);
 
-    if (variableAssigment !== null) {
-      const assignment = variableAssigment;  ///
-
-      context.addAssignment(assignment);
-    }
+    context.addAssignment(variableAssigment);
   }
 
   toJSON() {
@@ -214,7 +214,7 @@ export default define(class TypeAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      typeAssertion = instantiate((context) => {
+      instantiate((context) => {
         const { string } = json,
               typeAssertionNode = instantiateTypeAssertion(string, context),
               term = termFromTypeAssertionNode(typeAssertionNode, context),
@@ -223,9 +223,7 @@ export default define(class TypeAssertion extends Assertion {
 
         context = null;
 
-        const typeAssertion = new TypeAssertion(context, string, node, term, type);
-
-        return typeAssertion;
+        typeAssertion = new TypeAssertion(context, string, node, term, type);
       }, context);
     }
 

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),
@@ -71,7 +73,7 @@ export default define(class Assumption extends Element {
     return validAssumption;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let assumption = null;
 
     const assumptionString = this.getString();  ///
@@ -87,12 +89,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 +124,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 +141,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 +157,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 +171,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 +203,19 @@ 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...`);
 
-    validatesWhenDerived = true;
+    const topLevelMetaAssertion = this.getTopLevelMetaAssertion();
+
+    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 +224,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;
   }
 });