occam-verify-cli 1.0.635 → 1.0.641

package/src/element/substitution/statement.js

@@ -107,7 +107,7 @@ export default define(class StatementSubstitution extends Substitution {
   compareMetavariable(metavariable) { return this.targetStatement.compareMetavariable(metavariable); }
 
   validate(generalContext, specificContext) {
-    let validates = false;
+    let statementSubstitution = null;
 
     const context = this.getContext();
 
@@ -117,13 +117,15 @@ export default define(class StatementSubstitution extends Substitution {
 
     context.trace(`Validating the '${statementSubstitutionString}' statement substitution...`);
 
-    const valid = this.isValid(context);
+    const validSubstitution = this.findValidSubstiution(context);
 
-    if (valid) {
-      validates = true;
+    if (validSubstitution) {
+      statementSubstitution = validSubstitution;  ///
 
       context.debug(`...the '${statementSubstitutionString}' statement substitution is already valid.`);
     } else {
+      let validates = false;
+
       const targetStatementValidates = this.validateTargetStatement(generalContext, specificContext);
 
       if (targetStatementValidates) {
@@ -137,13 +139,15 @@ export default define(class StatementSubstitution extends Substitution {
       if (validates) {
         const substitution = this;  ///
 
+        statementSubstitution = substitution; ///
+
         context.addSubstitution(substitution);
 
         context.debug(`...validated the '${statementSubstitutionString}' statement substitution.`);
       }
     }
 
-    return validates;
+    return statementSubstitution;
   }
 
   validateTargetStatement(generalContext, specificContext) {
@@ -159,9 +163,11 @@ export default define(class StatementSubstitution extends Substitution {
 
     if (targetStatementSingular) {
       const stated = true,
-            assignments = null;
+            targetStatement = this.targetStatement.validate(stated, context);
 
-      targetStatementValidates = this.targetStatement.validate(assignments, stated, context);
+      if (targetStatement !== null) {
+        targetStatementValidates = true;
+      }
     } else {
       context.debug(`The '${statementSubstitutionString}' statement subtitution's '${targetStatementString}' target statement is not singular.`);
     }
@@ -183,9 +189,11 @@ export default define(class StatementSubstitution extends Substitution {
     context.trace(`Validating the '${statementSubstitutionString}' statement subtitution's '${replacementStatementString}' replacement statement...`);
 
     const stated = true,
-          assignments = null;
+          replacementStatement = this.replacementStatement.validate(stated, context);
 
-    replacementStatementValidates = this.replacementStatement.validate(assignments, stated, context);
+    if (replacementStatement !== null) {
+      replacementStatementValidates = true;
+    }
 
     if (replacementStatementValidates) {
       context.debug(`...validated the '${statementSubstitutionString}' statement subtitution's '${replacementStatementString}' replacement statement.`);

package/src/element/substitution/term.js

@@ -74,7 +74,7 @@ export default define(class TermSubstitution extends Substitution {
   }
 
   validate(generalContext, specificContext) {
-    let validates = false;
+    let termSubstitution = null;
 
     const context = this.getContext();
 
@@ -84,13 +84,15 @@ export default define(class TermSubstitution extends Substitution {
 
     context.trace(`Validating the '${termSubstitutionString}' term substitution...`);
 
-    const valid = this.isValid(context);
+    const validSubstitution = this.findValidSubstiution(context);
 
-    if (valid) {
-      validates = true;
+    if (validSubstitution) {
+      termSubstitution = validSubstitution; ///
 
       context.debug(`...the '${termSubstitutionString}' term substitution is alrady valid.`);
     } else {
+      let validates = false;
+
       const targetTermValidates = this.validateTargetTerm(generalContext, specificContext);
 
       if (targetTermValidates) {
@@ -104,13 +106,15 @@ export default define(class TermSubstitution extends Substitution {
       if (validates) {
         const substitution = this;  ///
 
+        termSubstitution = substitution;  ///
+
         context.addSubstitution(substitution);
 
         context.debug(`...validated the '${termSubstitutionString}' term substitution.`);
       }
     }
 
-    return validates;
+    return termSubstitution;
   }
 
   validateTargetTerm(generalContext, specificContext) {
@@ -125,11 +129,17 @@ export default define(class TermSubstitution extends Substitution {
     const targetTermSingular = this.targetTerm.isSingular();
 
     if (targetTermSingular) {
-      targetTermValidates = this.targetTerm.validate(context, () => {
+      const targetTerm = this.targetTerm.validate(context, () => {
         const validatesForwards = true;
 
         return validatesForwards;
       });
+
+      if (targetTerm !== null) {
+        this.targetTerm = targetTerm;
+
+        targetTermValidates = true;
+      }
     } else {
       context.debug(`The '${termSubstitutionString}' term subtitution's '${targetTermString}' target term is not singular.`);
     }
@@ -142,7 +152,7 @@ export default define(class TermSubstitution extends Substitution {
   }
 
   validateReplacementTerm(generalContext, specificContext) {
-    let replacementTermValidates;
+    let replacementTermValidates = false;
 
     const context = specificContext,  ///
           replacementTermString = this.replacementTerm.getString(),
@@ -150,12 +160,18 @@ export default define(class TermSubstitution extends Substitution {
 
     context.trace(`Validating the '${termSubstitutionString}' term subtitution's '${replacementTermString}' replacement term...`);
 
-    replacementTermValidates = this.replacementTerm.validate(context, () => {
+    const replacementTerm = this.replacementTerm.validate(context, () => {
       const validatesForwards = true;
 
       return validatesForwards;
     });
 
+    if (replacementTerm !== null) {
+      this.replacementTerm = replacementTerm;
+
+      replacementTermValidates = true;
+    }
+
     if (replacementTermValidates) {
       context.debug(`...validated the '${termSubstitutionString}' term subtitution's '${replacementTermString}' replacement term...`);
     }

package/src/element/substitution.js

@@ -34,12 +34,12 @@ export default class Substitution extends Element {
     return equalTo;
   }
 
-  isValid(context) {
+  findValidSubstiution(context) {
     const substitutionNode = this.getSubstitutionNode(),
-          substitutionPresent = context.isSubstitutionPresentBySubstitutionNode(substitutionNode),
-          valid = substitutionPresent;  ///
+          substitution = context.findSubstitutionBySubstitutionNode(substitutionNode),
+          validSubstitution = substitution;  ///
 
-    return valid;
+    return validSubstitution;
   }
 
   isEqualTo(substitution) {

package/src/element/term.js

@@ -68,12 +68,12 @@ export default define(class Term extends Element {
     return comparesToVariableIdentifier;
   }
 
-  isValid(context) {
+  findValidTerm(context) {
     const termNode = this.getTermNode(),
-          termPresent = context.isTermPresentByTermNode(termNode),
-          valid = termPresent;  ///
+          term = context.findTermByTermNode(termNode),
+          validTerm = term; ///
 
-    return valid;
+    return validTerm;
   }
 
   isEqualTo(term) {
@@ -149,23 +149,27 @@ export default define(class Term extends Element {
   }
 
   validate(context, validateForwards) {
-    let validates;
+    let term = null;
 
     const termString = this.getString();  ///
 
     context.trace(`Validating the '${termString}' term...`);
 
-    const valid = this.isValid(context);
+    const validTerm = this.findValidTerm(context),
+          valid = (validTerm !== null);
 
     if (valid) {
-      validates = true;
+      const validatesForward = validateForwards();
 
-      context.debug(`...the '${termString}' term is already valid.`);
-    } else {
-      const term = this;  ///
+      if (validatesForward) {
+        term = validTerm; ///
 
-      validates = validateTerms.some((validateTerm) => {  ///
-        const termValidates = validateTerm(term, context, validateForwards);
+        context.debug(`...the '${termString}' term is already valid.`);
+      }
+    } else {
+      const validates = validateTerms.some((validateTerm) => {  ///
+        const term = this,  ///
+              termValidates = validateTerm(term, context, validateForwards);
 
         if (termValidates) {
           return true;
@@ -173,7 +177,7 @@ export default define(class Term extends Element {
       });
 
       if (validates) {
-        const term = this;  ///
+        term = this;  ///
 
         context.addTerm(term);
 
@@ -181,7 +185,7 @@ export default define(class Term extends Element {
       }
     }
 
-    return validates;
+    return term;
   }
 
   validateGivenType(type, context) {

package/src/element/topLevelAssertion.js

@@ -4,8 +4,6 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 import { asynchronousUtilities } from "occam-languages";
 
-import assignAssignments from "../process/assign";
-
 import { asyncScope } from "../utilities/context";
 import { labelsFromJSON,
          deductionFromJSON,
@@ -251,14 +249,13 @@ export default class TopLevelAssertion extends Element {
     context.trace(`Verifying the '${topLevelAssertionString}' top level assertion's suppositions...`);
 
     suppositionsVerify = await asyncForwardsEvery(this.suppositions, async (supposition) => {
-      const assignments = [],
-            suppositionVerifies = await supposition.verify(assignments, context)
+      const suppositionVerifies = await supposition.verify(context)
 
       if (suppositionVerifies) {
-        assignAssignments(assignments, context);
-
         const subproofOrProofAssertion = supposition;  ////
 
+        context.assignAssignments();
+
         context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
         return true;

package/src/element/topLevelMetaAssertion.js

@@ -2,8 +2,6 @@
 
 import { Element } from "occam-languages";
 
-import assignAssignments from "../process/assign";
-
 import { asyncScope } from "../utilities/context";
 import { labelFromJSON,
          labelToLabelJSON,
@@ -155,14 +153,13 @@ export default class TopLevelMetaAssertion extends Element {
     context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta assertion's suppositions...`);
 
     suppositionsVerify = await asyncForwardsEvery(this.suppositions, async (supposition) => {
-      const assignments = [],
-            suppositionVerifies = await supposition.verify(assignments, context)
+      const suppositionVerifies = await supposition.verify(context)
 
       if (suppositionVerifies) {
-        assignAssignments(assignments, context);
-
         const subproofOrProofAssertion = supposition;  ////
 
+        context.assignAssignments();
+
         context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
         return true;

package/src/element/variable.js

@@ -166,11 +166,15 @@ export default define(class Variable extends Element {
             termTypeEqualToOrSubTypeOfVariableType = termType.isEqualToOrSubTypeOf(variableType);
 
       if (termTypeEqualToOrSubTypeOfVariableType) {
-        const { TermSubstitution } = elements,
-              termSubstitution = TermSubstitution.fromTermAndVariable(term, variable, context),
-              termSubstitutionValidates = termSubstitution.validate(generalContext, specificContext);
+        const { TermSubstitution } = elements;
 
-        if (termSubstitutionValidates) {
+        let termSubstitution;
+
+        termSubstitution = TermSubstitution.fromTermAndVariable(term, variable, context);
+
+        termSubstitution = termSubstitution.validate(generalContext, specificContext);  ///
+
+        if (termSubstitution !== null) {
           termUnifies = true;
         }
       }

package/src/process/assign.js

@@ -105,12 +105,6 @@ export function variableAssignmentFromPrepertyAssertion(propertyAssertion, conte
 
   }
 
-export default function assignAssignments(assignments, context) {
-  assignments.forEach((assignment) => {
-    assignment(context);
-  });
-}
-
 function variableAssignmentFromVariableNodeAndType(variableNode, type, context) {
   const variable = variableFromVariableNode(variableNode, context);
 

package/src/process/unify.js

@@ -149,7 +149,7 @@ class CombinatorPass extends ZipPass {
     {
       generalNodeQuery: metaTypeNodeQuery,
       specificNodeQuery: statementNodeQuery,
-      run: (generalMetaTypeNode, specificStatementNode, assignments, stated, generalContext, specificContext) => {
+      run: (generalMetaTypeNode, specificStatementNode, stated, generalContext, specificContext) => {
         let success = false;
 
         const metaTypeNode = generalMetaTypeNode, ///
@@ -165,7 +165,7 @@ class CombinatorPass extends ZipPass {
         context = specificContext;  ///
 
         const statement = statementFromStatementNode(statementNode, context),
-              statementValidatesGivenType = statement.validateGivenMetaType(metaType, assignments, stated, context);
+              statementValidatesGivenType = statement.validateGivenMetaType(metaType, stated, context);
 
         if (statementValidatesGivenType) {
           success = true;
@@ -177,7 +177,7 @@ class CombinatorPass extends ZipPass {
     {
       generalNodeQuery: metaTypeNodeQuery,
       specificNodeQuery: frameNodeQuery,
-      run: (generalMetaTypeNode, specificFrameNode, assignments, stated, generalContext, specificContext) => {
+      run: (generalMetaTypeNode, specificFrameNode, stated, generalContext, specificContext) => {
         let success = false;
 
         const metaTypeNode = generalMetaTypeNode, ///
@@ -193,7 +193,7 @@ class CombinatorPass extends ZipPass {
         context = specificContext;  ///
 
         const frame = frameFromFrameNode(frameNode, context),
-              frameValidatesGivenMetaType = frame.validateGivenMetaType(metaType, assignments, stated, context);
+              frameValidatesGivenMetaType = frame.validateGivenMetaType(metaType, stated, context);
 
         if (frameValidatesGivenMetaType) {
           success = true;
@@ -205,7 +205,7 @@ class CombinatorPass extends ZipPass {
     {
       generalNodeQuery: typeNodeQuery,
       specificNodeQuery: termNodeQuery,
-      run: (generalTypeNode, specificTermNode, assignments, stated, generalContext, specificContext) => {
+      run: (generalTypeNode, specificTermNode, stated, generalContext, specificContext) => {
         let success = false;
 
         const typeNode = generalTypeNode, ///
@@ -412,13 +412,13 @@ export function unifyStatementIntrinsically(generalStatement, specificStatement,
   return statementUnifiesIntrinsically;
 }
 
-export function unifyStatementWithCombinator(statement, combinator, assignments, stated, generalContext, specificContext) {
+export function unifyStatementWithCombinator(statement, combinator, stated, generalContext, specificContext) {
   let statementUnifiesWithCombinator = false;
 
   const statementNode = statement.getNode(),
         combinatorStatement = combinator.getStatement(),
         combinatorStatementNode = combinatorStatement.getNode(),
-        success = combinatorPass.run(combinatorStatementNode, statementNode, assignments, stated, generalContext, specificContext);
+        success = combinatorPass.run(combinatorStatementNode, statementNode, stated, generalContext, specificContext);
 
   if (success) {
     statementUnifiesWithCombinator = true;

package/src/process/validate.js

@@ -32,10 +32,13 @@ class TermPass extends ForwardPass {
       run: (termNode, context, validateForwards) => {
         let success = false;
 
-        const term = termFromTermNode(termNode, context),
-              termValidates = term.validate(context, validateForwards);
+        let term;
 
-        if (termValidates) {
+        term = termFromTermNode(termNode, context);
+
+        term = term.validate(context, validateForwards);  ///
+
+        if (term !== null) {
           success = true;
         }
 
@@ -91,12 +94,15 @@ class StatementPass extends SimplePass {
       run: (statementNode, context) => {
         let success = false;
 
-        const statement = statementFromStatementNode(statementNode, context),
-              stated = false,
-              assignments = null,
-              statementValidates = statement.validate(assignments, stated, context);
+        let statement;
+
+        const stated = true;
+
+        statement = statementFromStatementNode(statementNode, context);
 
-        if (statementValidates) {
+        statement = statement.validate(stated, context);  ///
+
+        if (statement !== null) {
           success = true;
         }
 
@@ -108,14 +114,17 @@ class StatementPass extends SimplePass {
       run: (termNode, context) => {
         let success = false;
 
-        const term = termFromTermNode(termNode, context),
-              termValidates = term.validate(context, () => {
-                const validatesForwards = true;
+        let term;
+
+        term = termFromTermNode(termNode, context);
+
+        term = term.validate(context, () => { ///
+          const validatesForwards = true;
 
-                return validatesForwards;
-              });
+          return validatesForwards;
+        });
 
-        if (termValidates) {
+        if (term !== null) {
           success = true;
         }
 

package/src/process/verify.js

@@ -294,12 +294,15 @@ class ConbinatorPass extends SimplePass {
       run: (statementNode, context) => {
         let success = false;
 
-        const statement = statementFromStatementNode(statementNode, context),
-              stated = false,
-              assignments = null,
-              statementValidates = statement.validate(assignments, stated, context);
+        let statement;
 
-        if (statementValidates) {
+        const stated = true;
+
+        statement = statementFromStatementNode(statementNode, context);
+
+        statement = statement.validate(stated, context);
+
+        if (statement !== null) {
           success = true;
         }
 
@@ -311,14 +314,17 @@ class ConbinatorPass extends SimplePass {
       run: (termNode, context) => {
         let success = false;
 
-        const term = termFromTermNode(termNode, context),
-              termValidates = term.validate(context, () => {
-                const validatesForwards = true;
+        let term;
+
+        term = termFromTermNode(termNode, context);
 
-                return validatesForwards;
-              });
+        term = term.validate(context, () => { ///
+          const validatesForwards = true;
 
-        if (termValidates) {
+          return validatesForwards;
+        });
+
+        if (term !== null) {
           success = true;
         }
 
@@ -350,14 +356,17 @@ class ConstructorPass extends SimplePass {
       run: (termNode, context) => {
         let success = false;
 
-        const term = termFromTermNode(termNode, context),
-              termValidates = term.validate(context, () => {
-                const validatesForwards = true;
+        let term;
+
+        term = termFromTermNode(termNode, context);
+
+        term = term.validate(context, () => { ///
+          const validatesForwards = true;
 
-                return validatesForwards;
-              });
+          return validatesForwards;
+        });
 
-        if (termValidates) {
+        if (term !== null) {
           success = true;
         }