occam-verify-cli 1.0.747 → 1.0.757

package/src/element/procedureCall.js

@@ -4,7 +4,7 @@ import { Element } from "occam-languages";
 import { termsUtilities } from "occam-furtle";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { instantiateProcedureCall } from "../process/instantiate";
 import { parametersFromProcedureCallNode, procedureReferenceFromProcedureCallNode } from "../utilities/element";
 
@@ -125,7 +125,7 @@ export default define(class ProcedureCall extends Element {
   static name = "ProcedureCall";
 
   static fromJSON(json, context) {
-    const procedureCall = literally((context) => {
+    const procedureCall = instantiate((context) => {
       const { string } = json,
             procedureCallNode = instantiateProcedureCall(string, context),
             node = procedureCallNode,  ///

package/src/element/procedureReference.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { instantiateProcedureReference } from "../process/instantiate";
 import { nameFromProcedureReferenceNode } from "../utilities/element";
 
@@ -43,7 +43,7 @@ export default define(class ProcedureReference extends Element {
   static name = "ProcedureReference";
 
   static fromJSON(json, context) {
-    const procedureReference = literally((context) => {
+    const procedureReference = instantiate((context) => {
       const { string } = json,
             procedureReferenceNode = instantiateProcedureReference(string, context),
             node = procedureReferenceNode,  ///

package/src/element/proof.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { asyncScope } from "../utilities/context";
+import { asyncRestrict } from "../utilities/context";
 
 export default define(class Proof extends Element {
   constructor(context, string, node, derivation) {
@@ -23,12 +23,12 @@ export default define(class Proof extends Element {
     return proofNode;
   }
 
-  getLastProofAssertion() { return this.derivation.getLastProofAssertion(); }
+  getLastStep() { return this.derivation.getLastStep(); }
 
   getStatement() {
-    const lastProofAssertion = this.getLastProofAssertion(),
-          lastProofAssertionStatement = lastProofAssertion.getStatement(),
-          statement = lastProofAssertionStatement; ///
+    const lastStep = this.getLastStep(),
+          lastStepStatement = lastStep.getStatement(),
+          statement = lastStepStatement; ///
 
     return statement;
   }
@@ -36,13 +36,13 @@ export default define(class Proof extends Element {
   async verify(statement, context) {
     let verifies = false;
 
-    await asyncScope(async (context) => {
+    await asyncRestrict(async (context) => {
       const derivationVerifies = await this.derivation.verify(context);
 
       if (derivationVerifies) {
-        const lastProofAssertion = context.getLastProofAssertion();
+        const lastStep = context.getLastStep();
 
-        if (lastProofAssertion !== null) {
+        if (lastStep !== null) {
           const proof = this, ///
                 proofStatement = proof.getStatement(),
                 proofStatementEqualToStatement = proofStatement.isEqualTo(statement);

package/src/element/proofAssertion/premise.js

@@ -5,7 +5,7 @@ import ProofAssertion from "../proofAssertion";
 import { define } from "../../elements";
 import { instantiatePremise } from "../../process/instantiate";
 import { procedureCallFromPremiseNode } from "../../utilities/element";
-import { attempt, liminally, literally } from "../../utilities/context";
+import { attempt, reconcile, instantiate } from "../../utilities/context";
 import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../../utilities/json";
 
 export default define(class Premise extends ProofAssertion {
@@ -72,7 +72,7 @@ export default define(class Premise extends ProofAssertion {
         const statementValidates = this.validateStatement(context);
 
         if (statementValidates) {
-          this.setContext(context);
+          context.commit(this);
 
           validates = true;
         }
@@ -82,7 +82,7 @@ export default define(class Premise extends ProofAssertion {
         const procedureCallValidates = this.validateProcedureCall(context);
 
         if (procedureCallValidates) {
-          this.setContext(context);
+          context.commit(this);
 
           validates = true;
         }
@@ -167,21 +167,18 @@ export default define(class Premise extends ProofAssertion {
     const proofAssertionContext = proofAssertion.getContext(),
           premiseContext = this.getContext(), ///
           generalContext = premiseContext, ///
-          specificContext = proofAssertionContext,
-          statementUnifies = liminally((specificContext) => {
-            const statement = proofAssertion.getStatement(),
-                  statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
+          specificContext = proofAssertionContext;  ///
 
-            if (statementUnifies) {
-              specificContext.commit(context);
+    reconcile((specificContext) => {
+      const statement = proofAssertion.getStatement(),
+            statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
 
-              return true;
-            }
-          }, specificContext);
+      if (statementUnifies) {
+        specificContext.commit(context);
 
-    if (statementUnifies) {
-      proofAssertionUnifies = true;
-    }
+        proofAssertionUnifies = true;
+      }
+    }, specificContext);
 
     if (proofAssertionUnifies) {
       context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${premiseString}' premise.`);
@@ -193,19 +190,11 @@ export default define(class Premise extends ProofAssertion {
   unifySubproof(subproof, context) {
     let subproofUnifies = false;
 
-    const premiseString = this.getString(),
+    const premiseString = this.getString(), ///
           subproofString = subproof.getString();
 
     context.trace(`Unifying the '${subproofString}' subproof with the '${premiseString}' premise...`);
 
-    const specificContext = context;  ///
-
-    context = this.getContext();
-
-    const generalContext = context; ///
-
-    context = specificContext;  ///
-
     const statement = this.getStatement();
 
     if (statement !== null) {
@@ -213,15 +202,16 @@ export default define(class Premise extends ProofAssertion {
             subproofAssertionNode = statementNode.getSubproofAssertionNode();
 
       if (subproofAssertionNode !== null) {
-        const context = generalContext, ///
-              assertionNode = subproofAssertionNode,  ///
-              assertion = context.findAssertionByAssertionNode(assertionNode)
+        const specificContext = context;  ///
 
-        if (assertion !== null) {
-          const subproofAssertion = assertion;  ///
+        context = this.getContext();
 
-          subproofUnifies = subproofAssertion.unifySubproof(subproof, generalContext, specificContext);
-        }
+        const generalContext = context, ///
+              subproofAssertion = context.findAssertionByAssertionNode(subproofAssertionNode);
+
+        context = specificContext;  ///
+
+        subproofUnifies = subproofAssertion.unifySubproof(subproof, generalContext, specificContext);
       }
     }
 
@@ -300,7 +290,7 @@ export default define(class Premise extends ProofAssertion {
 
     context = ephemeralContext; ///
 
-    const premise = literally((context) => {
+    const premise = instantiate((context) => {
       const { string } = json,
             premiseNode = instantiatePremise(string, context),
             node = premiseNode,  ///

package/src/element/proofAssertion/step.js

@@ -6,7 +6,7 @@ import ProofAssertion from "../proofAssertion";
 
 import { define } from "../../elements";
 import { unifyStatements } from "../../utilities/unification";
-import { attempt, asyncLiminally } from "../../utilities/context";
+import { attempt, asyncReconcile } from "../../utilities/context";
 import { propertyAssertionFromStatement } from "../../utilities/statement";
 
 const { asyncSome } = asynchronousUtilities;
@@ -117,7 +117,7 @@ export default define(class Step extends ProofAssertion {
           const satisfiesAssertioValidates = this.validateSatisfiesAssertion(context);
 
           if (satisfiesAssertioValidates) {
-            this.setContext(context);
+            context.commit(this);
 
             validates = true;
           }
@@ -190,7 +190,7 @@ export default define(class Step extends ProofAssertion {
           reference = this.getReference(),
           satisfiesAssertion = this.getSatisfiesAssertion();
 
-    await asyncLiminally(async (context) => {
+    await asyncReconcile(async (context) => {
       await asyncSome(unifyStatements, async (unifyStatement) => {
         const statementUnifies = await unifyStatement(statement, reference, satisfiesAssertion, context);
 

package/src/element/proofAssertion/supposition.js

@@ -4,7 +4,7 @@ import ProofAssertion from "../proofAssertion";
 
 import { define } from "../../elements";
 import { instantiateSupposition} from "../../process/instantiate";
-import { attempt, liminally, literally } from "../../utilities/context";
+import { attempt, reconcile, instantiate } from "../../utilities/context";
 import { statementFromSuppositionNode, procedureCallFromSuppositionNode } from "../../utilities/element";
 import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../../utilities/json";
 
@@ -72,7 +72,7 @@ export default define(class Supposition extends ProofAssertion {
         const statementValidates = this.validateStatement(context);
 
         if (statementValidates) {
-          this.setContext(context);
+          context.commit(this);
 
           validates = true;
         }
@@ -82,7 +82,7 @@ export default define(class Supposition extends ProofAssertion {
         const procedureCallValidates = this.validateProcedureCall(context);
 
         if (procedureCallValidates) {
-          this.setContext(context);
+          context.commit(this);
 
           validates = true;
         }
@@ -121,14 +121,14 @@ export default define(class Supposition extends ProofAssertion {
     let suppositionUnifies;
 
     const context = specificContext,  ///
-      specificSupposition = supposition,  ///
-      generalSuppositionString = this.getString(), ///
-      specificSuppositionString = specificSupposition.getString();
+          specificSupposition = supposition,  ///
+          generalSuppositionString = this.getString(), ///
+          specificSuppositionString = specificSupposition.getString();
 
     context.trace(`Unifying the '${specificSuppositionString}' supposition with the '${generalSuppositionString}' supposition...`);
 
     const statement = specificSupposition.getStatement(),
-      statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
+          statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
 
     suppositionUnifies = statementUnifies;  ///
 
@@ -189,20 +189,18 @@ export default define(class Supposition extends ProofAssertion {
     const proofAssertionContext = proofAssertion.getContext(),
           suppositionContext = this.getContext(),
           generalContext = suppositionContext, ///
-          specificContext = proofAssertionContext,
-          statementUnifies = liminally((specificContext) => {
-            const statement = proofAssertion.getStatement(),
-                  statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
+          specificContext = proofAssertionContext;
 
-            if (statementUnifies) {specificContext.commit(context);
+    reconcile((specificContext) => {
+      const statement = proofAssertion.getStatement(),
+            statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
 
-              return true;
-            }
-          }, specificContext);
+      if (statementUnifies) {
+        specificContext.commit(context);
 
-    if (statementUnifies) {
-      proofAssertionUnifies = true;
-    }
+        proofAssertionUnifies = true;
+      }
+    }, specificContext);
 
     if (proofAssertionUnifies) {
       context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition.`);
@@ -214,19 +212,11 @@ export default define(class Supposition extends ProofAssertion {
   unifySubproof(subproof, context) {
     let subproofUnifies = false;
 
-    const suppositionString = this.getString(),
-          subproofString = subproof.getString();
+    const subproofString = subproof.getString(),
+          suppositionString = this.getString();
 
     context.trace(`Unifying the '${subproofString}' subproof with the '${suppositionString}' supposition...`);
 
-    const specificContext = context;  ///
-
-    context = this.getContext();
-
-    const generalContext = context; ///
-
-    context = specificContext;  ///
-
     const statement = this.getStatement();
 
     if (statement !== null) {
@@ -234,15 +224,16 @@ export default define(class Supposition extends ProofAssertion {
             subproofAssertionNode = statementNode.getSubproofAssertionNode();
 
       if (subproofAssertionNode !== null) {
-        const context = generalContext, ///
-              assertionNode = subproofAssertionNode,  ///
-              assertion = context.findAssertionByAssertionNode(assertionNode)
+        const specificContext = context;  ///
 
-        if (assertion !== null) {
-          const subproofAssertion = assertion;  ///
+        context = this.getContext();
 
-          subproofUnifies = subproofAssertion.unifySubproof(subproof, substitutions, generalContext, specificContext);
-        }
+        const generalContext = context, ///
+              subproofAssertion = context.findAssertionByAssertionNode(subproofAssertionNode);
+
+        context = specificContext;  ///
+
+        subproofUnifies = subproofAssertion.unifySubproof(subproof, generalContext, specificContext);
       }
     }
 
@@ -321,7 +312,7 @@ export default define(class Supposition extends ProofAssertion {
 
     context = ephemeralContext; ///
 
-    const supposition = literally((context) => {
+    const supposition = instantiate((context) => {
       const { string } = json,
             suppositionNode = instantiateSupposition(string, context),
             node = suppositionNode,  ///

package/src/element/property.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { instantiateProperty } from "../process/instantiate";
 import { nameFromPropertyNode } from "../utilities/element";
 import { nominalTypeNameFromJSON, nominalTypeNameToNominalTypeNameJSON } from "../utilities/json";
@@ -58,7 +58,7 @@ export default define(class Property extends Element {
   static name = "Property";
 
   static fromJSON(json, context) {
-    const property = literally((context) => {
+    const property = instantiate((context) => {
       const { string } = json,
             propertyNode = instantiateProperty(string, context),
             node = propertyNode,  ///

package/src/element/propertyRelation.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { instantiatePropertyRelation } from "../process/instantiate";
 import { propertyFromPropertyRelationNode } from "../utilities/element";
 
@@ -59,7 +59,7 @@ export default define(class PropertyRelation extends Element {
 
     context.trace(`Validating the '${termString}' term...`);
 
-    const term = this.term.validate(context, () => {
+    const term = this.term.validate(context, (term) => {
       const validatesForwards = true;
 
       return validatesForwards;
@@ -124,7 +124,7 @@ export default define(class PropertyRelation extends Element {
   }
 
   static fromJSON(json, context) {
-    const propertyRelation = literally((context) => {
+    const propertyRelation = instantiate((context) => {
       const { string } = json,
             propertyRelationNode = instantiatePropertyRelation(string, context),
             node = propertyRelationNode,  ///

package/src/element/reference.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { instantiateReference } from "../process/instantiate";
 import { REFERENCE_META_TYPE_NAME } from "../metaTypeNames";
 import { metavariableFromReferenceNode } from "../utilities/element";
@@ -249,25 +249,27 @@ export default define(class Reference extends Element {
     return metavariableUnifies;
   }
 
-  unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
-    let topLevelMetaAssertionUnifies;
+  compareTopLevelMetaAssertion(topLevelMetaAssertion, context) {
+    let topLevelMetaAssertionCompares = false;
 
     const reference = this, ///
           referenceString = reference.getString(),
           topLevelMetaAssertionString = topLevelMetaAssertion.getString();
 
-    context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference...`);
+    context.trace(`Comparing the '${topLevelMetaAssertionString}' top level meta-assertion to the '${referenceString}' reference...`);
 
     const label = topLevelMetaAssertion.getLabel(),
           labelUnifies = this.unifyLabel(label, context);
 
-    topLevelMetaAssertionUnifies = labelUnifies;  ///
+    if (labelUnifies) {
+      topLevelMetaAssertionCompares = true;
+    }
 
-    if (topLevelMetaAssertionUnifies) {
-      context.trace(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${referenceString}' reference.`);
+    if (topLevelMetaAssertionCompares) {
+      context.trace(`...compared the '${topLevelMetaAssertionString}' top level meta-assertion to the '${referenceString}' reference.`);
     }
 
-    return topLevelMetaAssertionUnifies;
+    return topLevelMetaAssertionCompares;
   }
 
   toJSON() {
@@ -282,7 +284,7 @@ export default define(class Reference extends Element {
   static name = "Reference";
 
   static fromJSON(json, context) {
-    const reference = literally((context) => {
+    const reference = instantiate((context) => {
       const { string } = json,
             referenceNode = instantiateReference(string, context),
             node = referenceNode,  ///

package/src/element/rule.js

@@ -4,7 +4,7 @@ import { arrayUtilities } from "necessary";
 import { Element, asynchronousUtilities } from "occam-languages";
 
 import { define } from "../elements";
-import { asyncScope } from "../utilities/context";
+import { asyncRestrict } from "../utilities/context";
 import { labelsFromJSON, premisesFromJSON, conclusionFromJSON, labelsToLabelsJSON, premisesToPremisesJSON, conclusionToConclusionJSON } from "../utilities/json";
 
 const { reverse, extract } = arrayUtilities,
@@ -88,7 +88,7 @@ export default define(class Rule extends Element {
 
     context.trace(`Verifying the '${ruleString}' rule...`);
 
-    await asyncScope(async (context) => {
+    await asyncRestrict(async (context) => {
       const labelsVerify = this.verifyLabels();
 
       if (labelsVerify) {

package/src/element/signature.js

@@ -4,7 +4,7 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { instantiateSignature } from "../process/instantiate";
 import { termsFromSignatureNode } from "../utilities/element";
 
@@ -79,7 +79,7 @@ export default define(class Signature extends Element {
 
     context.trace(`Validating the '${signatureString}' signature's '${termString}' term...`);
 
-    term = term.validate(context, () => { ///
+    term = term.validate(context, (term) => { ///
       const validatesForwards = true;
 
       return validatesForwards;
@@ -225,7 +225,7 @@ export default define(class Signature extends Element {
   static name = "Signature";
 
   static fromJSON(json, context) {
-    const signature = literally((context) => {
+    const signature = instantiate((context) => {
       const { string } = json,
             signatureNode = instantiateSignature(string, context),
             node = signatureNode,  ///