occam-verify-cli 0.0.682 → 0.0.684

package/src/verify/proof.js

@@ -1,28 +1,31 @@
 "use strict";
 
-import ProofContext from "../context/proof";
+import LocalContext from "../context/local";
 import verifyDerivation from "../verify/derivation";
 
 import { nodeQuery } from "../utilities/query";
 
 const derivationNodeQuery = nodeQuery("/proof/derivation!");
 
-export default function verifyProof(proofNode, conclusion, proofContext) {
+export default function verifyProof(proofNode, conclusion, localContext) {
   let proofVerified = false;
 
-  proofContext = ProofContext.fromProofContext(proofContext); ///
+  localContext = LocalContext.fromLocalContext(localContext); ///
 
   const derivationNode = derivationNodeQuery(proofNode),
-        derivationVerified = verifyDerivation(derivationNode, proofContext);
+        derivationVerified = verifyDerivation(derivationNode, localContext);
 
   if (derivationVerified) {
-    const lastProofStep = proofContext.getLastProofStep(),
-          proofStep = lastProofStep, ///
-          statementNode = proofStep.getStatementNode(),
-          conclusionStatementNode = conclusion.getStatementNode(),
-          statementNodeMatchConclusionStatementNode = statementNode.match(conclusionStatementNode);
+    const lastProofStep = localContext.getLastProofStep();
 
-    proofVerified = statementNodeMatchConclusionStatementNode;  ///
+    if (lastProofStep !== null) {
+      const proofStep = lastProofStep, ///
+            statementNode = proofStep.getStatementNode(),
+            conclusionStatementNode = conclusion.getStatementNode(),
+            statementNodeMatchConclusionStatementNode = statementNode.match(conclusionStatementNode);
+
+      proofVerified = statementNodeMatchConclusionStatementNode;  ///
+    }
   }
 
   return proofVerified;

package/src/verify/rule.js

@@ -4,7 +4,7 @@ import Rule from "../rule";
 import verifyLabels from "../verify/labels";
 import verifyPremise from "../verify/premise";
 import verifyRuleProof from "../verify/ruleProof";
-import MetaproofContext from "../context/metaproof";
+import LocalMetaContext from "../context/localMeta";
 import verifyConclusion from "../verify/conclusion";
 
 import { first } from "../utilities/array";
@@ -20,7 +20,7 @@ export default function verifyRule(ruleNode, fileContext) {
 
   const labelNodes = labelNodesQuery(ruleNode),
         labelsString = fileContext.nodesAsString(labelNodes),
-        metaProofContext = MetaproofContext.fromFileContext(fileContext);
+        localMetaContext = LocalMetaContext.fromFileContext(fileContext);
 
   fileContext.trace(`Verifying the '${labelsString}' rule...`, ruleNode);
 
@@ -31,7 +31,7 @@ export default function verifyRule(ruleNode, fileContext) {
     const premises = [],
           premiseNodes = premisesNodeQuery(ruleNode),
           premisesVerified = premiseNodes.every((premiseNode) => {
-            const premiseVerified = verifyPremise(premiseNode, premises, metaProofContext);
+            const premiseVerified = verifyPremise(premiseNode, premises, localMetaContext);
 
             if (premiseVerified) {
               return true;
@@ -41,7 +41,7 @@ export default function verifyRule(ruleNode, fileContext) {
     if (premisesVerified) {
       const conclusions = [],
             conclusionNode = conclusionNodeQuery(ruleNode),
-            conclusionVerified = verifyConclusion(conclusionNode, conclusions, metaProofContext);
+            conclusionVerified = verifyConclusion(conclusionNode, conclusions, localMetaContext);
 
       if (conclusionVerified) {
         const ruleProofNode = ruleProofNodeQuery(ruleNode),
@@ -51,7 +51,7 @@ export default function verifyRule(ruleNode, fileContext) {
         let ruleProofVerified = true; ///
 
         if (ruleProofNode !== null) {
-          ruleProofVerified = verifyRuleProof(ruleProofNode, conclusion, metaProofContext);
+          ruleProofVerified = verifyRuleProof(ruleProofNode, conclusion, localMetaContext);
         }
 
         if (ruleProofVerified) {

package/src/verify/ruleDerivation.js

@@ -2,7 +2,7 @@
 
 import MetaproofStep from "../step/metaproof";
 import verifyPremise from "../verify/premise";
-import MetaproofContext from "../context/metaproof";
+import LocalMetaContext from "../context/localMeta";
 import verifyQualifiedMetastatement from "../verify/metastatement/qualified";
 import verifyUnqualifiedMetastatement from "../verify/metastatement/unqualified";
 
@@ -14,13 +14,13 @@ const childNodesQuery = nodesQuery("/ruleDerivation|ruleSubDerivation/*"),
       metastatementNodeQuery = nodeQuery("/qualifiedMetastatement|unqualifiedMetastatement/metastatement!"),
       ruleSubDerivationNodeQuery = nodeQuery("/ruleSubproof/ruleSubDerivation");
 
-export default function verifyRuleDerivation(ruleDerivationNode, metaproofContext) {
+export default function verifyRuleDerivation(ruleDerivationNode, localMetaContext) {
   let ruleDerivationVerified;
 
   const childNodes = childNodesQuery(ruleDerivationNode);
 
   ruleDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, metaproofContext);
+    const childVerified = verifyChild(childNode, localMetaContext);
 
     if (childVerified) {
       return true;
@@ -30,13 +30,13 @@ export default function verifyRuleDerivation(ruleDerivationNode, metaproofContex
   return ruleDerivationVerified;
 }
 
-function verifyRuleSubDerivation(ruleSubDerivationNode, metaproofContext) {
+function verifyRuleSubDerivation(ruleSubDerivationNode, localMetaContext) {
   let ruleSubDerivationVerified;
 
   const childNodes = childNodesQuery(ruleSubDerivationNode);
 
   ruleSubDerivationVerified = childNodes.every((childNode) => {
-    const childVerified = verifyChild(childNode, metaproofContext);
+    const childVerified = verifyChild(childNode, localMetaContext);
 
     if (childVerified) {
       return true;
@@ -46,15 +46,15 @@ function verifyRuleSubDerivation(ruleSubDerivationNode, metaproofContext) {
   return ruleSubDerivationVerified;
 }
 
-function verifyRuleSubproof(ruleSubproofNode, metaproofContext) {
+function verifyRuleSubproof(ruleSubproofNode, localMetaContext) {
   let ruleSubproofVerified = false;
 
-  metaproofContext = MetaproofContext.fromMetaproofContext(metaproofContext); ///
+  localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
 
   const premises = [],
         premiseNodes = premiseNodesQuery(ruleSubproofNode),
         premisesVerified = premiseNodes.every((premiseNode) => {
-          const premiseVerified = verifyPremise(premiseNode, premises, metaproofContext);
+          const premiseVerified = verifyPremise(premiseNode, premises, localMetaContext);
 
           if (premiseVerified) {
             return true;
@@ -63,7 +63,7 @@ function verifyRuleSubproof(ruleSubproofNode, metaproofContext) {
 
   if (premisesVerified) {
     const ruleSubDerivationNode = ruleSubDerivationNodeQuery(ruleSubproofNode),
-          ruleSubDerivationVerified = verifyRuleSubDerivation(ruleSubDerivationNode, metaproofContext);
+          ruleSubDerivationVerified = verifyRuleSubDerivation(ruleSubDerivationNode, localMetaContext);
 
     if (ruleSubDerivationVerified) {
       ruleSubproofVerified = true;
@@ -73,7 +73,7 @@ function verifyRuleSubproof(ruleSubproofNode, metaproofContext) {
   return ruleSubproofVerified;
 }
 
-function verifyChild(childNode, metaproofContext) {
+function verifyChild(childNode, localMetaContext) {
   let childVerified;
 
   const childNodeRuleName = childNode.getRuleName();
@@ -81,12 +81,12 @@ function verifyChild(childNode, metaproofContext) {
   switch (childNodeRuleName) {
     case RULE_SUBPROOF_RULE_NAME: {
       const ruleSubproofNode = childNode,  ///
-            ruleSubproofVerified = verifyRuleSubproof(ruleSubproofNode, metaproofContext);
+            ruleSubproofVerified = verifyRuleSubproof(ruleSubproofNode, localMetaContext);
 
       if (ruleSubproofVerified) {
         const metaproofStep = MetaproofStep.fromRuleSubproofNode(ruleSubproofNode);
 
-        metaproofContext.addMetaproofStep(metaproofStep);
+        localMetaContext.addMetaproofStep(metaproofStep);
 
         childVerified = true;
       }
@@ -98,13 +98,13 @@ function verifyChild(childNode, metaproofContext) {
       const derived = true,
             assignments = [],
             qualifiedMetastatementNode = childNode,  ///
-            qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, assignments, derived, metaproofContext);
+            qualifiedMetastatementVerified = verifyQualifiedMetastatement(qualifiedMetastatementNode, assignments, derived, localMetaContext);
 
       if (qualifiedMetastatementVerified) {
         const metastatementNode = metastatementNodeQuery(qualifiedMetastatementNode),
               metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
 
-        metaproofContext.addMetaproofStep(metaproofStep);
+        localMetaContext.addMetaproofStep(metaproofStep);
 
         childVerified = qualifiedMetastatementVerified; ///
       }
@@ -115,13 +115,13 @@ function verifyChild(childNode, metaproofContext) {
     case UNQUALIFIED_METASTATEMENT_RULE_NAME: {
       const derived = true,
             unqualifiedMetastatementNode = childNode,  ///
-            unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, derived, metaproofContext);
+            unqualifiedMetastatementVerified = verifyUnqualifiedMetastatement(unqualifiedMetastatementNode, derived, localMetaContext);
 
       if (unqualifiedMetastatementVerified) {
         const metastatementNode = metastatementNodeQuery(unqualifiedMetastatementNode),
               metaproofStep = MetaproofStep.fromMetastatementNode(metastatementNode);
 
-        metaproofContext.addMetaproofStep(metaproofStep);
+        localMetaContext.addMetaproofStep(metaproofStep);
 
         childVerified = true;
       }

package/src/verify/ruleProof.js

@@ -1,22 +1,22 @@
 "use strict";
 
-import MetaproofContext from "../context/metaproof";
+import LocalMetaContext from "../context/localMeta";
 import verifyRuleDerivation from "../verify/ruleDerivation";
 
 import { nodeQuery } from "../utilities/query";
 
 const ruleDerivationNodeQuery = nodeQuery("/ruleProof/ruleDerivation!");
 
-export default function verifyRuleProof(ruleProofNode, conclusion, metaproofContext) {
+export default function verifyRuleProof(ruleProofNode, conclusion, localMetaContext) {
   let ruleProofVerified = false;
 
-  metaproofContext = MetaproofContext.fromMetaproofContext(metaproofContext); ///
+  localMetaContext = LocalMetaContext.fromLocalMetaContext(localMetaContext); ///
 
   const ruleDerivationNode = ruleDerivationNodeQuery(ruleProofNode),
-        ruleDerivationVerified = verifyRuleDerivation(ruleDerivationNode, metaproofContext);
+        ruleDerivationVerified = verifyRuleDerivation(ruleDerivationNode, localMetaContext);
 
   if (ruleDerivationVerified) {
-    const lastMetaproofStep = metaproofContext.getLastMetaproofStep(),
+    const lastMetaproofStep = localMetaContext.getLastMetaproofStep(),
           metaproofStep = lastMetaproofStep, ///
           metastatementNode = metaproofStep.getMetastatementNode(),
           conclusionMetastatementNode = conclusion.getMetastatementNode(),

package/src/verify/statement/qualified.js

@@ -5,72 +5,72 @@ import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query
 const referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
       statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
 
-export default function verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, proofContext) {
+export default function verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, localContext) {
   let qualifiedStatementVerified = false;
 
   const statementNode = statementNodeQuery(qualifiedStatementNode);
 
   if (statementNode !== null) {
-    const statementString = proofContext.nodeAsString(statementNode),
-          statementProofContext = proofContext; ///
+    const statementString = localContext.nodeAsString(statementNode),
+          statementLocalContext = localContext; ///
 
-    proofContext.trace(`Verifying the '${statementString}' qualified statement...`, qualifiedStatementNode);
+    localContext.trace(`Verifying the '${statementString}' qualified statement...`, qualifiedStatementNode);
 
     const referenceNode = referenceNodeQuery(qualifiedStatementNode),
           referenceName = referenceNameFromReferenceNode(referenceNode);
 
     if (!qualifiedStatementVerified) {
-      const rule = proofContext.findRuleByReferenceName(referenceName);
+      const rule = localContext.findRuleByReferenceName(referenceName);
 
       if (rule !== null) {
-        const ruleMatchesStatement = rule.matchStatement(statementNode, statementProofContext);
+        const ruleMatchesStatement = rule.matchStatement(statementNode, statementLocalContext);
 
         qualifiedStatementVerified = ruleMatchesStatement;  ///
       }
     }
 
     if (!qualifiedStatementVerified) {
-      const axiom = proofContext.findAxiomByReferenceName(referenceName);
+      const axiom = localContext.findAxiomByReferenceName(referenceName);
 
       if (axiom !== null) {
-        const axiomMatchesStatement = axiom.matchStatement(statementNode, statementProofContext);
+        const axiomMatchesStatement = axiom.matchStatement(statementNode, statementLocalContext);
 
         qualifiedStatementVerified = axiomMatchesStatement; ///
       }
     }
 
     if (!qualifiedStatementVerified) {
-      const lemma = proofContext.findLemmaByReferenceName(referenceName);
+      const lemma = localContext.findLemmaByReferenceName(referenceName);
 
       if (lemma !== null) {
-        const lemmaMatchesStatement = lemma.matchStatement(statementNode, statementProofContext);
+        const lemmaMatchesStatement = lemma.matchStatement(statementNode, statementLocalContext);
 
         qualifiedStatementVerified = lemmaMatchesStatement; ///
       }
     }
 
     if (!qualifiedStatementVerified) {
-      const theorem = proofContext.findTheoremByReferenceName(referenceName);
+      const theorem = localContext.findTheoremByReferenceName(referenceName);
 
       if (theorem !== null) {
-        const theoremMatchesStatement = theorem.matchStatement(statementNode, statementProofContext);
+        const theoremMatchesStatement = theorem.matchStatement(statementNode, statementLocalContext);
 
         qualifiedStatementVerified = theoremMatchesStatement; ///
       }
     }
 
     if (!qualifiedStatementVerified) {
-      const conjecture = proofContext.findConjectureByReferenceName(referenceName);
+      const conjecture = localContext.findConjectureByReferenceName(referenceName);
 
       if (conjecture !== null) {
-        const conjectureMatchesStatement = conjecture.matchStatement(statementNode, statementProofContext);
+        const conjectureMatchesStatement = conjecture.matchStatement(statementNode, statementLocalContext);
 
         qualifiedStatementVerified = conjectureMatchesStatement; ///
       }
     }
 
     if (qualifiedStatementVerified) {
-      proofContext.debug(`...verified the '${statementString}' qualified statement.`, qualifiedStatementNode);
+      localContext.debug(`...verified the '${statementString}' qualified statement.`, qualifiedStatementNode);
     }
   }
 

package/src/verify/statement/unqualified.js

@@ -6,24 +6,24 @@ import { nodeQuery } from "../../utilities/query";
 
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
-export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, proofContext) {
+export default function verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext) {
   let unqualifiedStatementVerified = false;
 
   const statementNode = statementNodeQuery(unqualifiedStatementNode);
 
   if (statementNode !== null) {
-    const statementString = proofContext.nodeAsString(statementNode);
+    const statementString = localContext.nodeAsString(statementNode);
 
-    proofContext.trace(`Verifying the '${statementString}' unqualified statement...`, unqualifiedStatementNode);
+    localContext.trace(`Verifying the '${statementString}' unqualified statement...`, unqualifiedStatementNode);
 
     if (derived) {
-      const statementMatches = proofContext.matchStatement(statementNode);
+      const statementMatches = localContext.matchStatement(statementNode);
 
       unqualifiedStatementVerified = statementMatches;  ///
     }
 
     if (!unqualifiedStatementVerified) {
-      const context = proofContext, ///
+      const context = localContext, ///
             statementVerified = verifyStatement(statementNode, assignments, derived, context, () => {
               const verifiedAhead = true;
 
@@ -34,7 +34,7 @@ export default function verifyUnqualifiedStatement(unqualifiedStatementNode, ass
     }
 
     if (unqualifiedStatementVerified) {
-      proofContext.debug(`...verified the '${statementString}' unqualified statement.`, unqualifiedStatementNode);
+      localContext.debug(`...verified the '${statementString}' unqualified statement.`, unqualifiedStatementNode);
     }
   }
 

package/src/verify/supposition.js

@@ -9,17 +9,17 @@ import { nodeQuery } from "../utilities/query";
 const statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       unqualifiedStatementNodeQuery = nodeQuery("/supposition/unqualifiedStatement!");
 
-export default function verifySupposition(suppositionNode, suppositions, proofContext) {
+export default function verifySupposition(suppositionNode, suppositions, localContext) {
   let suppositionVerified;
 
-  const suppositionString = proofContext.nodeAsString(suppositionNode);
+  const suppositionString = localContext.nodeAsString(suppositionNode);
 
-  proofContext.trace(`Verifying the '${suppositionString}' supposition...`, suppositionNode);
+  localContext.trace(`Verifying the '${suppositionString}' supposition...`, suppositionNode);
 
   const derived = false,
         assignments = [],
         unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
-        unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, proofContext);
+        unqualifiedStatementVerified = verifyUnqualifiedStatement(unqualifiedStatementNode, assignments, derived, localContext);
 
   if (unqualifiedStatementVerified) {
     const statementNode = statementNodeQuery(unqualifiedStatementNode),
@@ -28,17 +28,17 @@ export default function verifySupposition(suppositionNode, suppositions, proofCo
 
     suppositions.push(supposition);
 
-    proofContext.addProofStep(proofStep);
+    localContext.addProofStep(proofStep);
 
     assignments.forEach((assignment) => {
-      assignment.assign(proofContext);
+      assignment.assign(localContext);
     });
 
     suppositionVerified = true;
   }
 
   if (suppositionVerified) {
-    proofContext.debug(`...verified the '${suppositionString}' supposition.`, suppositionNode);
+    localContext.debug(`...verified the '${suppositionString}' supposition.`, suppositionNode);
   }
 
   return suppositionVerified;

package/src/verify/term.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import Term from "../term";
 import termNodesVerifier from "../verifier/nodes/term";
 
 import { first } from "../utilities/array";
@@ -7,7 +8,7 @@ import { nodeQuery, variableNameFromVariableNode } from "../utilities/query";
 
 const variableNodeQuery = nodeQuery("/term/variable!");
 
-function verifyTerm(termNode, types, context, verifyAhead) {
+function verifyTerm(termNode, terms, context, verifyAhead) {
   let termVerified;
 
   const termString = context.nodeAsString(termNode);
@@ -20,7 +21,7 @@ function verifyTerm(termNode, types, context, verifyAhead) {
   ];
 
   termVerified = verifyTermFunctions.some((verifyTermFunction) => {
-    const termVerified = verifyTermFunction(termNode, types, context, verifyAhead);
+    const termVerified = verifyTermFunction(termNode, terms, context, verifyAhead);
 
     if (termVerified) {
       return true;
@@ -40,13 +41,13 @@ Object.assign(termNodesVerifier, {
 
 export default verifyTerm;
 
-export function verifyTermAgainstConstructors(termNode, types, context, verifyAhead) {
+export function verifyTermAgainstConstructors(termNode, terms, context, verifyAhead) {
   let termVerifiedAgainstConstructors;
 
   const constructors = context.getConstructors();
 
   termVerifiedAgainstConstructors = constructors.some((constructor) => {
-    const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, types, constructor, context, verifyAhead);
+    const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, terms, constructor, context, verifyAhead);
 
     if (termVerifiedAgainstConstructor) {
       return true;
@@ -93,73 +94,75 @@ export function verifyTermAsVariable(termNode, variables, context, verifyAhead)
   return termVerifiedAsVariable;
 }
 
-function verifyTermAgainstConstructor(termNode, types, constructor, context, verifyAhead) {
-  let termVerifiedAgainstConstructor;
+function verifyTermAsStandaloneVariable(termNode, terms, context, verifyAhead) {
+  let termVerifiedAsStandaloneVariable;
 
-  const termString = context.nodeAsString(termNode),
-        constructorString = constructor.getString();
+  const termString = context.nodeAsString(termNode);
 
-  context.trace(`Verifying the '${termString}' term against the '${constructorString}' constructor...`, termNode);
+  context.trace(`Verifying the '${termString}' term as a standalone variable...`, termNode);
 
-  const constructorTermNode = constructor.getTermNode(),
-        nonTerminalNNdeA = termNode,  ///
-        nonTerminalNodeB = constructorTermNode,  ///
-        nodeVerified = termNodesVerifier.verifyNonTerminalNode(nonTerminalNNdeA, nonTerminalNodeB, context, () => {
+  const variables = [],
+        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context, () => {
           let verifiedAhead;
 
-          const type = constructor.getType();
+          const firstVariable = first(variables),
+                variable = firstVariable, ///
+                type = variable.getType(),
+                term = Term.fromTermNodeAndType(termNode, type);
 
-          types.push(type);
+          terms.push(term);
 
           verifiedAhead = verifyAhead();
 
           if (!verifiedAhead) {
-            types.pop();
+            terms.pop();
           }
 
           return verifiedAhead;
         });
 
-  termVerifiedAgainstConstructor = nodeVerified;  ///
+  termVerifiedAsStandaloneVariable = termVerifiedAsVariable;  ///
 
-  if (termVerifiedAgainstConstructor) {
-    context.debug(`...verified the '${termString}' term against the '${constructorString}' constructor.`, termNode);
+  if (termVerifiedAsStandaloneVariable) {
+    context.debug(`...verified the '${termString}' term as a standalone variable.`, termNode);
   }
 
-  return termVerifiedAgainstConstructor;
+  return termVerifiedAsStandaloneVariable;
 }
 
-function verifyTermAsStandaloneVariable(termNode, types, context, verifyAhead) {
-  let termVerifiedAsStandaloneVariable;
+function verifyTermAgainstConstructor(termNode, terms, constructor, context, verifyAhead) {
+  let termVerifiedAgainstConstructor;
 
-  const termString = context.nodeAsString(termNode);
+  const termString = context.nodeAsString(termNode),
+        constructorString = constructor.getString();
 
-  context.trace(`Verifying the '${termString}' term as a standalone variable...`, termNode);
+  context.trace(`Verifying the '${termString}' term against the '${constructorString}' constructor...`, termNode);
 
-  const variables = [],
-        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context, () => {
+  const constructorTermNode = constructor.getTermNode(),
+        nonTerminalNNdeA = termNode,  ///
+        nonTerminalNodeB = constructorTermNode,  ///
+        nodeVerified = termNodesVerifier.verifyNonTerminalNode(nonTerminalNNdeA, nonTerminalNodeB, context, () => {
           let verifiedAhead;
 
-          const firstVariable = first(variables),
-                variable = firstVariable, ///
-                type = variable.getType();
+          const type = constructor.getType(),
+                term = Term.fromTermNodeAndType(termNode, type);
 
-          types.push(type);
+          terms.push(term);
 
           verifiedAhead = verifyAhead();
 
           if (!verifiedAhead) {
-            types.pop();
+            terms.pop();
           }
 
           return verifiedAhead;
         });
 
-  termVerifiedAsStandaloneVariable = termVerifiedAsVariable;  ///
+  termVerifiedAgainstConstructor = nodeVerified;  ///
 
-  if (termVerifiedAsStandaloneVariable) {
-    context.debug(`...verified the '${termString}' term as a standalone variable.`, termNode);
+  if (termVerifiedAgainstConstructor) {
+    context.debug(`...verified the '${termString}' term against the '${constructorString}' constructor.`, termNode);
   }
 
-  return termVerifiedAsStandaloneVariable;
+  return termVerifiedAgainstConstructor;
 }

package/src/verify/terms.js

@@ -4,51 +4,37 @@ import verifyTerm from "../verify/term";
 
 import { first, second } from "../utilities/array";
 
-export default function verifyTerms(leftTermNode, rightTermNode, context, verifyAhead) {
+export default function verifyTerms(termNodes, terms, context, verifyAhead) {
   let termsVerified;
 
-  const leftTermString = context.nodeAsString(leftTermNode),
-        rightTermString = context.nodeAsString(rightTermNode);
+  const firstTermNode = first(termNodes),
+        secondTermNode = second(termNodes),
+        firstTermString = context.nodeAsString(firstTermNode),
+        secondTermString = context.nodeAsString(secondTermNode);
 
-  context.trace(`Verifying the '${leftTermString}' and '${rightTermString}' terms...`, leftTermNode);
+  context.trace(`Verifying the '${firstTermString}' and '${secondTermString}' terms...`, firstTermNode);
 
-  const types = [],
-        leftTermVerified = verifyTerm(leftTermNode, types, context, () => {
+  const firstTermVerified = verifyTerm(firstTermNode, terms, context, () => {
           let verifiedAhead;
 
-          const rightTermVerified = verifyTerm(rightTermNode, types, context, () => {
-            let verifiedAhead = false;
+          const secondTermVerified = verifyTerm(secondTermNode, terms, context, () => {
+            let verifiedAhead;
 
-            const firstType = first(types),
-                  secondType = second(types),
-                  leftType = firstType, ///
-                  rightType = secondType, ///
-                  leftTypeEqualToOrSubTypeOfOfSuperTypeOfRightType = leftType.isEqualToOrSubTypeOfOfSuperTypeOf(rightType);
-
-            if (!leftTypeEqualToOrSubTypeOfOfSuperTypeOfRightType) {
-              const leftTypeName = leftType.getName(),
-                    rightTypeName = rightType.getName(),
-                    leftTermString = context.nodeAsString(leftTermNode),
-                    rightTermString = context.nodeAsString(rightTermNode);
-
-              context.debug(`The left '${leftTermString}' term's '${leftTypeName}' type is not equal to, a sub-type of nor a super-type of the right '${rightTermString}' term's '${rightTypeName}' type.`, statementNode);
-            } else {
-              verifiedAhead = verifyAhead();
-            }
+            verifiedAhead = verifyAhead();
 
             return verifiedAhead;
           });
 
-          verifiedAhead = rightTermVerified;  ///
+          verifiedAhead = secondTermVerified;  ///
 
           return verifiedAhead;
         });
 
+  termsVerified = firstTermVerified; ///
+
   if (termsVerified) {
-    context.debug(`...verified the '${leftTermString}' and '${rightTermString}' terms.`, leftTermNode);
+    context.debug(`...verified the '${firstTermString}' and '${secondTermString}' terms.`, firstTermNode);
   }
 
-  termsVerified = leftTermVerified; ///
-
   return termsVerified
 }