occam-verify-cli 1.0.758 → 1.0.762

package/src/element/assertion/subproof.js

@@ -6,7 +6,7 @@ import Assertion from "../assertion";
 
 import { define } from "../../elements";
 import { reconcile } from "../../utilities/context";
-import { instantiate } from "../../utilities/context";
+import { join, instantiate } from "../../utilities/context";
 import { instantiateSubproofAssertion } from "../../process/instantiate";
 
 const { last, front, backwardsEvery } = arrayUtilities;
@@ -114,17 +114,21 @@ export default define(class SubproofAssertion extends Assertion {
 
     context.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
 
-    const lastStep = subproof.getLastStep(),
-          lastStepUnifies = this.unifyLastStep(lastStep, generalContext, specificContext);
+    reconcile((specificContext) => {
+      const lastStep = subproof.getLastStep(),
+            lastStepUnifies = this.unifyLastStep(lastStep, generalContext, specificContext);
 
-    if (lastStepUnifies) {
-      const suppositions = subproof.getSuppositions(),
-            suppositionsUnify = this.unifySuppositions(suppositions, generalContext, specificContext);
+      if (lastStepUnifies) {
+        const suppositions = subproof.getSuppositions(),
+              suppositionsUnify = this.unifySuppositions(suppositions, generalContext, specificContext);
 
-      if (suppositionsUnify) {
-        subproofUnifies = true;
+        if (suppositionsUnify) {
+          specificContext.commit();
+
+          subproofUnifies = true;
+        }
       }
-    }
+    }, specificContext);
 
     if (subproofUnifies) {
       context.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
@@ -136,33 +140,32 @@ export default define(class SubproofAssertion extends Assertion {
   unifyLastStep(lastStep, generalContext, specificContext) {
     let lastStepUnifies = false;
 
-    const lastStatement = this.getLastStatement(),
+    const context = specificContext,  ///
+          lastStatement = this.getLastStatement(),
           lastStepString = lastStep.getString(),
-          lastStepStatement = lastStep.getStatement(),
-          lastStatementString = lastStatement.getString(),
-          subproofAssertionString = this.getString(), ///
-          lastStepStatementString = lastStepStatement.getString();
-
-    let context;
+          lastStatementString = lastStatement.getString();
 
-    context = specificContext;  ///
+    context.trace(`Unifying the '${lastStepString}' last step with the '${lastStatementString}' last statement...`)
 
-    context.trace(`Unifying the '${lastStepString}' last step's '${lastStepStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${lastStatementString}' last statement...`)
+    const lastStepContext = lastStep.getContext(),
+          lastStepStatement = lastStep.getStatement();
 
-    context = lastStep.getContext();
+    specificContext = lastStepContext;  ///
 
-    specificContext = context;  ///
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        const lastStepStatementUnifies = lastStatement.unifyStatement(lastStepStatement, generalContext, specificContext);
 
-    reconcile((specificContext) => {
-      const lastStepStatementUnifies = lastStatement.unifyStatement(lastStepStatement, generalContext, specificContext);
+        if (lastStepStatementUnifies) {
+          specificContext.commit(context);
 
-      if (lastStepStatementUnifies) {
-        lastStepUnifies = true;
-      }
-    }, specificContext);
+          lastStepUnifies = true;
+        }
+      }, specificContext);
+    }, specificContext, context);
 
     if (lastStepUnifies) {
-      context.debug(`...unified the '${lastStepString}' last step's '${lastStepStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${lastStatementString}' last statement.`)
+      context.debug(`...unified the '${lastStepString}' last step with the '${lastStatementString}' last statement.`)
     }
 
     return lastStepUnifies;
@@ -171,33 +174,32 @@ export default define(class SubproofAssertion extends Assertion {
   unifyDeduction(deduction, generalContext, specificContext) {
     let deductionUnifies = false;
 
-    const lastStatement = this.getLastStatement(),
+    const context = specificContext,  ///
+          lastStatement = this.getLastStatement(),
           deductionString = deduction.getString(),
-          deductionStatement = deduction.getStatement(),
-          lastStatementString = lastStatement.getString(),
-          subproofAssertionString = this.getString(), ///
-          deductionStatementString = deductionStatement.getString();
-
-    let context;
+          lastStatementString = lastStatement.getString();
 
-    context = specificContext;  ///
+    context.trace(`Unifying the '${deductionString}' deduction with the '${lastStatementString}' last statement...`)
 
-    context.trace(`Unifying the '${deductionString}' deduction's '${deductionStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${lastStatementString}' last statement...`)
+    const deductionContext = deduction.getContext(),
+          deductionStatement = deduction.getStatement();
 
-    context = deduction.getContext();
+    specificContext = deductionContext;  ///
 
-    specificContext = context;  ///
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        const deductionStatementUnifies = lastStatement.unifyStatement(deductionStatement, generalContext, specificContext);
 
-    reconcile((specificContext) => {
-      const deductionStatementUnifies = lastStatement.unifyStatement(deductionStatement, generalContext, specificContext);
+        if (deductionStatementUnifies) {
+          specificContext.commit(context);
 
-      if (deductionStatementUnifies) {
-        deductionUnifies = true;
-      }
-    }, specificContext);
+          deductionUnifies = true;
+        }
+      }, specificContext);
+    }, specificContext, context);
 
     if (deductionUnifies) {
-      context.debug(`...unified the '${deductionString}' deduction's '${deductionStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${lastStatementString}' last statement.`)
+      context.debug(`...unified the '${deductionString}' deduction with the '${lastStatementString}' last statement.`)
     }
 
     return deductionUnifies;
@@ -206,33 +208,32 @@ export default define(class SubproofAssertion extends Assertion {
   unifySupposition(supposition, index, generalContext, specificContext) {
     let suppositionUnifies = false;
 
-    const supposedStatement = this.getSupposedStatement(index),
+    const context = specificContext,  ///
+          supposedStatement = this.getSupposedStatement(index),
           suppositionString = supposition.getString(),
-          suppositionStatement = supposition.getStatement(),
-          subproofAssertionString = this.getString(), ///
-          supposedStatementString = supposedStatement.getString(),
-          suppositionStatementString = suppositionStatement.getString();  ///
-
-    let context;
+          supposedStatementString = supposedStatement.getString();
 
-    context = specificContext;  ///
+    context.trace(`Unifying the '${suppositionString}' supposition with the '${supposedStatementString}' supposed statement...`)
 
-    context.trace(`Unifying the '${suppositionString}' supposition's '${suppositionStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${supposedStatementString}' supposed statement...`)
+    const suppositionContext = supposition.getContext(),
+          suppositionStatement = supposition.getStatement();
 
-    context = supposition.getContext();
+    specificContext = suppositionContext;  ///
 
-    specificContext = context;  ///
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        const suppositionStatementUnifies = supposedStatement.unifyStatement(suppositionStatement, generalContext, specificContext);
 
-    reconcile((specificContext) => {
-      const suppositionStatementUnifies = supposedStatement.unifyStatement(suppositionStatement, generalContext, specificContext);
+        if (suppositionStatementUnifies) {
+          specificContext.commit(context);
 
-      if (suppositionStatementUnifies) {
-        suppositionUnifies = true;
-      }
-    }, specificContext);
+          suppositionUnifies = true;
+        }
+      }, specificContext);
+    }, specificContext, context);
 
     if (suppositionUnifies) {
-      context.debug(`...unified the '${suppositionString}' supposition's '${suppositionStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${supposedStatementString}' supposed statement.`)
+      context.debug(`...unified the '${suppositionString}' supposition with the '${supposedStatementString}' supposed statement.`)
     }
 
     return suppositionUnifies;
@@ -267,17 +268,21 @@ export default define(class SubproofAssertion extends Assertion {
 
     context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${subproofAssertionString}' subproof assertion...`);
 
-    const deduction = topLevelMetaAssertion.getDeduction(),
-          deductionUnifies = this.unifyDeduction(deduction, generalContext, specificContext);
+    reconcile((specificContext) => {
+      const deduction = topLevelMetaAssertion.getDeduction(),
+            deductionUnifies = this.unifyDeduction(deduction, generalContext, specificContext);
 
-    if (deductionUnifies) {
-      const suppositions = topLevelMetaAssertion.getSuppositions(),
-            suppositionsUnify = this.unifySuppositions(suppositions, generalContext, specificContext);
+      if (deductionUnifies) {
+        const suppositions = topLevelMetaAssertion.getSuppositions(),
+              suppositionsUnify = this.unifySuppositions(suppositions, generalContext, specificContext);
 
-      if (suppositionsUnify) {
-        topLevelMetaAssertionUnifies = true;
+        if (suppositionsUnify) {
+          specificContext.commit();
+
+          topLevelMetaAssertionUnifies = true;
+        }
       }
-    }
+    }, specificContext);
 
     if (topLevelMetaAssertionUnifies) {
       context.debug(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${subproofAssertionString}' subproof assertion.`);
@@ -294,7 +299,7 @@ export default define(class SubproofAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      instantiate((context) => {
+      subproorAssertion = instantiate((context) => {
         const { string } = json,
               subproofAssertionNode = instantiateSubproofAssertion(string, context),
               statements = statementsFromSubproofAssertionNode(subproofAssertionNode, context),
@@ -302,7 +307,9 @@ export default define(class SubproofAssertion extends Assertion {
 
         context = null;
 
-        subproorAssertion = new SubproofAssertion(context, string, node, statements);
+        const subproorAssertion = new SubproofAssertion(context, string, node, statements);
+
+        return subproorAssertion;
       }, context);
     }
 

package/src/element/assertion/type.js

@@ -214,7 +214,7 @@ export default define(class TypeAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      instantiate((context) => {
+      typeAssertion = instantiate((context) => {
         const { string } = json,
               typeAssertionNode = instantiateTypeAssertion(string, context),
               term = termFromTypeAssertionNode(typeAssertionNode, context),
@@ -223,7 +223,9 @@ export default define(class TypeAssertion extends Assertion {
 
         context = null;
 
-        typeAssertion = new TypeAssertion(context, string, node, term, type);
+        const typeAssertion = new TypeAssertion(context, string, node, term, type);
+
+        return typeAssertion;
       }, context);
     }
 

package/src/element/combinator.js

@@ -128,7 +128,7 @@ export default define(class Combinator extends Element {
 
     context = ephemeralContext; ///
 
-    const combinator = instantiate((context) => {
+    return instantiate((context) => {
       const { string } = json,
             combinatorNode = instantiateCombinator(string, context),
             node = combinatorNode,  ///
@@ -137,7 +137,5 @@ export default define(class Combinator extends Element {
 
       return combinator;
     }, context);
-
-    return combinator;
   }
 });

package/src/element/conclusion.js

@@ -150,7 +150,7 @@ export  default define(class Conclusion extends Element {
 
     context = ephemeralContext; ///
 
-    const conclusion = instantiate((context) => {
+    return instantiate((context) => {
       const { string } = json,
             conclusionNode = instantiateConclusion(string, context),
             node = conclusionNode,  ///
@@ -159,7 +159,5 @@ export  default define(class Conclusion extends Element {
 
       return conclusion;
     }, context);
-
-    return conclusion;
   }
 });

package/src/element/constructor.js

@@ -173,7 +173,7 @@ export default define(class Constructor extends Element {
 
     context = ephemeralContext; ///
 
-    const constructor = instantiate((context) => {
+    return instantiate((context) => {
       const { string } = json,
             constructorNode = instantiateConstructor(string, context),
             node = constructorNode, ///
@@ -183,7 +183,5 @@ export default define(class Constructor extends Element {
 
       return constructor;
     }, context);
-
-    return constructor;
   }
 });

package/src/element/deduction.js

@@ -175,7 +175,7 @@ export default define(class Deduction extends Element {
 
     context = ephemeralContext; ///
 
-    const deduction = instantiate((context) => {
+    return instantiate((context) => {
       const { string } = json,
             deductionNode = instantiateDeduction(string, context),
             node = deductionNode,  ///
@@ -184,7 +184,5 @@ export default define(class Deduction extends Element {
 
       return deduction;
     }, context);
-
-    return deduction;
   }
 });

package/src/element/equality.js

@@ -280,7 +280,7 @@ export default define(class Equality extends Element {
   }
 
   static fromJSON(json, context) {
-    const equality = instantiate((context) => {
+    return instantiate((context) => {
       const { string } = json,
             equalityNode = instantiateEquality(string, context),
             node = equalityNode,  ///
@@ -293,8 +293,6 @@ export default define(class Equality extends Element {
 
       return equality;
     }, context);
-
-    return equality;
   }
 });
 

package/src/element/frame.js

@@ -343,7 +343,7 @@ export default define(class Frame extends Element {
   static name = "Frame";
 
   static fromJSON(json, context) {
-    const frame = instantiate((context) => {
+    return instantiate((context) => {
       const { string } = json,
             frameNode = instantiateFrame(string, context),
             node = frameNode, ///
@@ -356,8 +356,6 @@ export default define(class Frame extends Element {
 
       return frame;
     }, context);
-
-    return frame;
   }
 });
 

package/src/element/hypothesis.js

@@ -100,7 +100,7 @@ export default define(class Hypothesis extends Element {
   static name = "Hypothesis";
 
   static fromJSON(json, context) {
-    const hypothesis = instantiate((context) => {
+    return instantiate((context) => {
       const { string } = json,
             hypothesisNode = instantiateHypothesis(string, context),
             node = hypothesisNode,  ///
@@ -112,7 +112,5 @@ export default define(class Hypothesis extends Element {
 
       return hypothesis;
     }, context);
-
-    return hypothesis;
   }
 });

package/src/element/judgement.js

@@ -218,7 +218,7 @@ export default define(class Judgement extends Element {
   static name = "Judgement";
 
   static fromJSON(json, context) {
-    const judgement = instantiate((context) => {
+    return instantiate((context) => {
       const { string } = json,
             judgementNode = instantiateJudgement(string, context),
             node = judgementNode,  ///
@@ -231,8 +231,6 @@ export default define(class Judgement extends Element {
 
       return judgement;
     }, context);
-
-    return judgement;
   }
 });
 

package/src/element/label.js

@@ -153,7 +153,7 @@ export default define(class Label extends Element {
 
     context = ephemeralContext; ///
 
-    const label = instantiate((context) => {
+    return instantiate((context) => {
       const { string } = json,
             labelNode = instantiateLabel(string, context),
             metavariable = metavariableFromLabelNode(labelNode, context),
@@ -162,7 +162,5 @@ export default define(class Label extends Element {
 
       return label;
     }, context);
-
-    return label;
   }
 });

package/src/element/metavariable.js

@@ -305,19 +305,13 @@ export default define(class Metavariable extends Element {
           frameUnifies = true;
         }
       } else {
-        const { FrameSubstitution } = elements;
+        const { FrameSubstitution } = elements,
+              metavariable = this,  ///
+              frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context);
 
-        let frameSubstitution;
+        frameSubstitution.validate(generalContext, specificContext);
 
-        const metavariable = this;  ///
-
-        frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, context);
-
-        frameSubstitution = frameSubstitution.validate(generalContext, specificContext);
-
-        if (frameSubstitution !== null) {
-          frameUnifies = true;
-        }
+        frameUnifies = true;
       }
     }
 
@@ -367,13 +361,10 @@ export default define(class Metavariable extends Element {
           statementUnifies = true;
         }
       } else {
-        const { StatementSubstitution } = elements;
-
-        let statementSubstitution;
-
-        statementSubstitution = (substitution !== null) ?
-                                  StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) :
-                                    StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context);
+        const { StatementSubstitution } = elements,
+              statementSubstitution = (substitution !== null) ?
+                                        StatementSubstitution.fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) :
+                                          StatementSubstitution.fromStatementAndMetavariable(statement, metavariable, context);
 
         if (substitution !== null) {
           const context = generalContext; ///
@@ -383,11 +374,9 @@ export default define(class Metavariable extends Element {
           substitution.setContext(context);
         }
 
-        statementSubstitution = statementSubstitution.validate(generalContext, specificContext);
+        statementSubstitution.validate(generalContext, specificContext);
 
-        if (statementSubstitution !== null) {
-          statementUnifies = true;
-        }
+        statementUnifies = true;
       }
     }
 
@@ -429,19 +418,13 @@ export default define(class Metavariable extends Element {
           referenceUnifies = true;
         }
       } else {
-        const { ReferenceSubstitution } = elements;
-
-        let referenceSubstitution;
-
-        const metavariable = this;
-
-        referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context);
+        const { ReferenceSubstitution } = elements,
+              metavariable = this,  ///
+              referenceSubstitution = ReferenceSubstitution.fromReferenceAndMetavariable(reference, metavariable, context);
 
-        referenceSubstitution = referenceSubstitution.validate(generalContext, specificContext);  ///
+        referenceSubstitution.validate(generalContext, specificContext);
 
-        if (referenceSubstitution !== null) {
-          referenceUnifies = true;
-        }
+        referenceUnifies = true;
       }
     }
 
@@ -609,7 +592,7 @@ export default define(class Metavariable extends Element {
   static name = "Metavariable";
 
   static fromJSON(json, context) {
-    const metavariable = instantiate((context) => {
+    return instantiate((context) => {
       const { string } = json,
             metavariableNode = instantiateMetavariable(string, context),
             node = metavariableNode,  ///
@@ -621,7 +604,5 @@ export default define(class Metavariable extends Element {
 
       return metavariable;
     }, context);
-
-    return metavariable;
   }
 });

package/src/element/parameter.js

@@ -61,7 +61,7 @@ export default define(class Parameter extends Element {
   static name = "Parameter";
 
   static fromJSON(json, context) {
-    const parameter = instantiate((context) => {
+    return instantiate((context) => {
       const { string } = json,
             parameterNode = instantiateParameter(string, context),
             node = parameterNode,  ///
@@ -74,7 +74,5 @@ export default define(class Parameter extends Element {
 
       return parameter;
     }, context);
-
-    return parameter;
   }
 });

package/src/element/procedureCall.js

@@ -125,7 +125,7 @@ export default define(class ProcedureCall extends Element {
   static name = "ProcedureCall";
 
   static fromJSON(json, context) {
-    const procedureCall = instantiate((context) => {
+    return instantiate((context) => {
       const { string } = json,
             procedureCallNode = instantiateProcedureCall(string, context),
             node = procedureCallNode,  ///
@@ -138,7 +138,5 @@ export default define(class ProcedureCall extends Element {
 
       return procedureCall;
     }, context);
-
-    return procedureCall;
   }
 });

package/src/element/procedureReference.js

@@ -43,7 +43,7 @@ export default define(class ProcedureReference extends Element {
   static name = "ProcedureReference";
 
   static fromJSON(json, context) {
-    const procedureReference = instantiate((context) => {
+    return instantiate((context) => {
       const { string } = json,
             procedureReferenceNode = instantiateProcedureReference(string, context),
             node = procedureReferenceNode,  ///
@@ -55,7 +55,5 @@ export default define(class ProcedureReference extends Element {
 
       return procedureReference;
     }, context);
-
-    return procedureReference;
   }
 });

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, reconcile, instantiate } from "../../utilities/context";
+import { join, attempt, reconcile, instantiate } from "../../utilities/context";
 import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../../utilities/json";
 
 export default define(class Premise extends ProofAssertion {
@@ -169,16 +169,18 @@ export default define(class Premise extends ProofAssertion {
           generalContext = premiseContext, ///
           specificContext = proofAssertionContext;  ///
 
-    reconcile((specificContext) => {
-      const statement = proofAssertion.getStatement(),
-            statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        const statement = proofAssertion.getStatement(),
+              statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
 
-      if (statementUnifies) {
-        specificContext.commit(context);
+        if (statementUnifies) {
+          specificContext.commit(context);
 
-        proofAssertionUnifies = true;
-      }
-    }, specificContext);
+          proofAssertionUnifies = true;
+        }
+      }, specificContext);
+    }, specificContext, context);
 
     if (proofAssertionUnifies) {
       context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${premiseString}' premise.`);
@@ -290,7 +292,7 @@ export default define(class Premise extends ProofAssertion {
 
     context = ephemeralContext; ///
 
-    const premise = instantiate((context) => {
+    return instantiate((context) => {
       const { string } = json,
             premiseNode = instantiatePremise(string, context),
             node = premiseNode,  ///
@@ -300,8 +302,6 @@ export default define(class Premise extends ProofAssertion {
 
       return premise;
     }, context);
-
-    return premise;
   }
 });
 

package/src/element/proofAssertion/step.js

@@ -190,17 +190,19 @@ export default define(class Step extends ProofAssertion {
           reference = this.getReference(),
           satisfiesAssertion = this.getSatisfiesAssertion();
 
-    await asyncReconcile(async (context) => {
-      await asyncSome(unifyStatements, async (unifyStatement) => {
-        const statementUnifies = await unifyStatement(statement, reference, satisfiesAssertion, context);
+    await asyncSome(unifyStatements, async (unifyStatement) => {
+      let statementUnifies;
 
-        if (statementUnifies) {
-          unifies = true;
+      await asyncReconcile(async (context) => {
+        statementUnifies = await unifyStatement(statement, reference, satisfiesAssertion, context);
+      }, context);
 
-          return true;
-        }
-      });
-    }, context);
+      if (statementUnifies) {
+        unifies = true;
+
+        return true;
+      }
+    });
 
     if (unifies) {
       context.debug(`...unified the '${stepString}' step.`);