occam-verify-cli 1.0.635 → 1.0.638

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,23 @@ 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;
+      term = validTerm; ///
 
       context.debug(`...the '${termString}' term is already valid.`);
     } else {
-      const term = this;  ///
-
-      validates = validateTerms.some((validateTerm) => {  ///
-        const termValidates = validateTerm(term, context, validateForwards);
+      const validates = validateTerms.some((validateTerm) => {  ///
+        const term = this,  ///
+              termValidates = validateTerm(term, context, validateForwards);
 
         if (termValidates) {
           return true;
@@ -173,7 +173,7 @@ export default define(class Term extends Element {
       });
 
       if (validates) {
-        const term = this;  ///
+        term = null;  ///
 
         context.addTerm(term);
 
@@ -181,7 +181,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;
         }
 

package/src/utilities/unification.js

@@ -86,10 +86,9 @@ async function unifyStatementAsSatisfiesAssertion(statement, reference, satisfie
 
     context.trace(`Unifying the '${statementString}' statement as a satisfies assertion...`);
 
-    const stated = true,
-          assignments = null;
+    const stated = true;
 
-    satisfiesAssertion.verifySignature(assignments, stated, context);
+    satisfiesAssertion.verifySignature(stated, context);
 
     if (reference === null) {
       const subproofOrProofAssertions = context.getSubproofOrProofAssertions();
@@ -181,7 +180,7 @@ async function unifyStatementWithTopLevelAssertion(statement, reference, satisfi
   return statementUnifiesWithTopLevelAssertion;
 }
 
-async function unifyStatementAEquality(statement, reference, satisfiesAssertion, context) {
+async function unifyStatementAsEquality(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesAEquality = false;
 
   if (reference === null) {
@@ -339,7 +338,7 @@ export const unifyStatements = [
   unifyStatementWithReference,
   unifyStatementAsSatisfiesAssertion,
   unifyStatementWithTopLevelAssertion,
-  unifyStatementAEquality,
+  unifyStatementAsEquality,
   unifyStatementAsJudgement,
   unifyStatementAsTypeAssertion,
   unifyStatementAsPropertyAssertion,