occam-verify-cli 0.0.700 → 0.0.704

package/src/verify/statement/qualified.js

@@ -1,9 +1,14 @@
 "use strict";
 
+import verifyEquality from "../equality";
+import verifyTypeAssertion from "../typeAssertion";
+
 import { nodeQuery, referenceNameFromReferenceNode } from "../../utilities/query";
 
-const referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
-      statementNodeQuery = nodeQuery("/qualifiedStatement/statement!");
+const equalityNodeQuery = nodeQuery("/qualifiedStatement/statement/equality!"),
+      referenceNodeQuery = nodeQuery("/qualifiedStatement/qualification!/reference!"),
+      statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
+      typeAssertionNodeQuery = nodeQuery("/qualifiedStatement/statement/typeAssertion!");
 
 export default function verifyQualifiedStatement(qualifiedStatementNode, assignments, derived, localContext) {
   let qualifiedStatementVerified = false;
@@ -11,68 +16,218 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, assignm
   const statementNode = statementNodeQuery(qualifiedStatementNode);
 
   if (statementNode !== null) {
-    const statementString = localContext.nodeAsString(statementNode),
-          statementLocalContext = localContext; ///
+    const qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Verifying the '${statementString}' qualified statement...`, qualifiedStatementNode);
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
 
     const referenceNode = referenceNodeQuery(qualifiedStatementNode),
-          referenceName = referenceNameFromReferenceNode(referenceNode);
+          referenceName = referenceNameFromReferenceNode(referenceNode),
+          verifyQualifiedStatementFunctions = [
+            verifyQualifiedStatementAAgainstRule,
+            verifyQualifiedStatementAAgainstAxiom,
+            verifyQualifiedStatementAAgainstLemma,
+            verifyQualifiedStatementAAgainstTheorem,
+            verifyQualifiedStatementAAgainstConjecture
+          ];
+
+    qualifiedStatementVerified = verifyQualifiedStatementFunctions.some((verifyQualifiedStatementFunction) => {  ///
+      const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, referenceName, localContext);
+
+      if (qualifiedStatementVerified) {
+        return true;
+      }
+    });
 
-    if (!qualifiedStatementVerified) {
-      const rule = localContext.findRuleByReferenceName(referenceName);
+    if (qualifiedStatementVerified) {
+      derived = false;  ///
 
-      if (rule !== null) {
-        const ruleMatchesStatement = rule.matchStatement(statementNode, statementLocalContext);
+      const context = localContext, ///
+            verifyQualifiedStatementFunctions = [
+              verifyQualifiedStatementAsEquality,
+              verifyQualifiedStatementAsTypeAssertion
+            ];
 
-        qualifiedStatementVerified = ruleMatchesStatement;  ///
-      }
+      qualifiedStatementVerified = verifyQualifiedStatementFunctions.every((verifyQualifiedStatementFunction) => { ///
+        const qualifiedStatementVerified = verifyQualifiedStatementFunction(qualifiedStatementNode, assignments, derived, context, () => {
+          const verifiedAhead = true;
+
+          return verifiedAhead;
+        });
+
+        if (qualifiedStatementVerified) {
+          return true;
+        }
+      });
     }
 
-    if (!qualifiedStatementVerified) {
-      const axiom = localContext.findAxiomByReferenceName(referenceName);
+    if (qualifiedStatementVerified) {
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement.`, qualifiedStatementNode);
+    }
+  }
 
-      if (axiom !== null) {
-        const axiomMatchesStatement = axiom.matchStatement(statementNode, statementLocalContext);
+  return qualifiedStatementVerified;
+}
 
-        qualifiedStatementVerified = axiomMatchesStatement; ///
-      }
+function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, referenceName, localContext) {
+  let qualifiedStatementVerifiedAgainstRule = false;
+
+  const rule = localContext.findRuleByReferenceName(referenceName);
+
+  if (rule !== null) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          statementLocalContext = localContext, ///
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceName}' rule...`, statementNode);
+
+    const ruleMatchesStatement = rule.matchStatement(statementNode, statementLocalContext);
+
+    qualifiedStatementVerifiedAgainstRule = ruleMatchesStatement;  ///
+
+    if (qualifiedStatementVerifiedAgainstRule) {
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceName}' rule.`, statementNode);
     }
+  }
 
-    if (!qualifiedStatementVerified) {
-      const lemma = localContext.findLemmaByReferenceName(referenceName);
+  return qualifiedStatementVerifiedAgainstRule;
+}
 
-      if (lemma !== null) {
-        const lemmaMatchesStatement = lemma.matchStatement(statementNode, statementLocalContext);
+function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, referenceName, localContext) {
+  let qualifiedStatementVerifiedAgainstAxiom = false;
 
-        qualifiedStatementVerified = lemmaMatchesStatement; ///
-      }
+  const axiom = localContext.findAxiomByReferenceName(referenceName);
+
+  if (axiom !== null) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          statementLocalContext = localContext, ///
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceName}' axiom...`, statementNode);
+
+    const axiomMatchesStatement = axiom.matchStatement(statementNode, statementLocalContext);
+
+    qualifiedStatementVerifiedAgainstAxiom = axiomMatchesStatement; ///
+
+    if (qualifiedStatementVerifiedAgainstAxiom) {
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceName}' axiom.`, statementNode);
     }
+  }
 
-    if (!qualifiedStatementVerified) {
-      const theorem = localContext.findTheoremByReferenceName(referenceName);
+  return qualifiedStatementVerifiedAgainstAxiom;
+}
 
-      if (theorem !== null) {
-        const theoremMatchesStatement = theorem.matchStatement(statementNode, statementLocalContext);
+function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, referenceName, localContext) {
+  let qualifiedStatementVerifiedAgainstLemma = false;
 
-        qualifiedStatementVerified = theoremMatchesStatement; ///
-      }
+  const lemma = localContext.findLemmaByReferenceName(referenceName);
+
+  if (lemma !== null) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          statementLocalContext = localContext, ///
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceName}' lemma...`, statementNode);
+
+    const lemmaMatchesStatement = lemma.matchStatement(statementNode, statementLocalContext);
+
+    qualifiedStatementVerifiedAgainstLemma = lemmaMatchesStatement; ///
+
+    if (qualifiedStatementVerifiedAgainstLemma) {
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceName}' lemma.`, statementNode);
     }
+  }
+
+  return qualifiedStatementVerifiedAgainstLemma;
+}
 
-    if (!qualifiedStatementVerified) {
-      const conjecture = localContext.findConjectureByReferenceName(referenceName);
+function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, referenceName, localContext) {
+  let qualifiedStatementVerifiedAgainstTheorem = false;
 
-      if (conjecture !== null) {
-        const conjectureMatchesStatement = conjecture.matchStatement(statementNode, statementLocalContext);
+  const theorem = localContext.findTheoremByReferenceName(referenceName);
 
-        qualifiedStatementVerified = conjectureMatchesStatement; ///
-      }
+  if (theorem !== null) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          statementLocalContext = localContext, ///
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceName}' theorem...`, statementNode);
+
+    const theoremMatchesStatement = theorem.matchStatement(statementNode, statementLocalContext);
+
+    qualifiedStatementVerifiedAgainstTheorem = theoremMatchesStatement; ///
+
+    if (qualifiedStatementVerifiedAgainstTheorem) {
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceName}' theorem.`, statementNode);
     }
+  }
 
-    if (qualifiedStatementVerified) {
-      localContext.debug(`...verified the '${statementString}' qualified statement.`, qualifiedStatementNode);
+  return qualifiedStatementVerifiedAgainstTheorem;
+}
+
+function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, referenceName, localContext) {
+  let qualifiedStatementVerifiedAgainstConjecture = false;
+
+  const conjecture = localContext.findConjectureByReferenceName(referenceName);
+
+  if (conjecture !== null) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          statementLocalContext = localContext, ///
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+
+    localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${referenceName}' conjecture...`, statementNode);
+
+    const conjectureMatchesStatement = conjecture.matchStatement(statementNode, statementLocalContext);
+
+    qualifiedStatementVerifiedAgainstConjecture = conjectureMatchesStatement; ///
+
+    if (qualifiedStatementVerifiedAgainstConjecture) {
+      localContext.debug(`...verified the '${qualifiedStatementString}' qualified statement against the '${referenceName}' conjecture.`, statementNode);
     }
   }
 
-  return qualifiedStatementVerified;
+  return qualifiedStatementVerifiedAgainstConjecture;
+}
+
+function verifyQualifiedStatementAsEquality(qualifiedStatementNode, assignments, derived, context, verifyAhead) {
+  let statementVerifiedAsEquality = true; ///
+
+  const equalityNode = equalityNodeQuery(qualifiedStatementNode);
+
+  if (equalityNode !== null) {
+    const qualifiedStatementString = context.nodeAsString(qualifiedStatementNode);
+
+    context.trace(`Verifying the '${qualifiedStatementString}' qualified statement as an equality...`, qualifiedStatementNode);
+
+    const equalityVerified = verifyEquality(equalityNode, assignments, derived, context, verifyAhead);
+
+    statementVerifiedAsEquality = equalityVerified; ///
+
+    if (statementVerifiedAsEquality) {
+      context.debug(`...verified the '${qualifiedStatementString}' qualified statement as an equality.`, qualifiedStatementNode);
+    }
+  }
+
+  return statementVerifiedAsEquality;
+}
+
+function verifyQualifiedStatementAsTypeAssertion(qualifiedStatementNode, assignments, derived, context, verifyAhead) {
+  let statementVerifiedAsTypeAssertion = true;  ///
+
+  const typeAssertionNode = typeAssertionNodeQuery(qualifiedStatementNode);
+
+  if (typeAssertionNode !== null) {
+    const qualifiedStatementString = context.nodeAsString(qualifiedStatementNode);
+
+    context.trace(`Verifying the '${qualifiedStatementString}' qualified statement as a type assertion...`, qualifiedStatementNode);
+
+    const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, assignments, derived, context, verifyAhead);
+
+    statementVerifiedAsTypeAssertion = typeAssertionVerified; ///
+
+    if (statementVerifiedAsTypeAssertion) {
+      context.debug(`...verified the '${qualifiedStatementString}' qualified statement as a type assertion.`, qualifiedStatementNode);
+    }
+  }
+
+  return statementVerifiedAsTypeAssertion;
 }

package/src/verify/statement.js

@@ -38,53 +38,53 @@ function verifyStatement(statementNode, assignments, derived, context, verifyAhe
   return statementVerified;
 }
 
-Object.assign(verifyStatement, {
-  statementNodesVerifier
-});
-
-export default verifyStatement;
+export function verifyStandaloneStatement(statementNode, fileContext, verifyAhead) {
+  let standaloneStatementVerified;
 
-export function verifyStatementAgainstCombinators(statementNode, assignments, derived, context, verifyAhead) {
-  let statementVerifiedAgainstCombinators;
+  const statementString = fileContext.nodeAsString(statementNode);
 
-  let combinators = context.getCombinators();
+  fileContext.trace(`Verifying the '${statementString}' standalone statement...`, statementNode);
 
-  combinators = [ ///
-    bracketedCombinator,
-    ...combinators
-  ];
+  const context = fileContext,  ///
+        derived = false,
+        assignments = [],
+        statementVerified = verifyStatement(statementNode, assignments, derived, context, verifyAhead);
 
-  statementVerifiedAgainstCombinators = combinators.some((combinator) => {
-    const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context, verifyAhead);
+  standaloneStatementVerified = statementVerified;  ///
 
-    if (statementVerifiedAgainstCombinator) {
-      return true;
-    }
-  });
+  if (standaloneStatementVerified) {
+    fileContext.debug(`...verified the '${statementString}' standalone statement.`, statementNode);
+  }
 
-  return statementVerifiedAgainstCombinators;
+  return standaloneStatementVerified;
 }
 
-function verifyStatementAgainstCombinator(statementNode, combinator, context, verifyAhead) {
-  let statementVerifiedAgainstCombinator;
+Object.assign(statementNodesVerifier, {
+  verifyStatement
+});
 
-  const statementString = context.nodeAsString(statementNode),
-        combinatorString = combinator.getString();
+export default verifyStatement;
 
-  context.trace(`Verifying the '${statementString}' statement against the '${combinatorString}' combinator...`, statementNode);
+function verifyStatementAsEquality(statementNode, assignments, derived, context, verifyAhead) {
+  let statementVerifiedAsEquality = false;
 
-  const combinatorStatementNode = combinator.getStatementNode(),
-        nonTerminalNodeA = statementNode, ///
-        nonTerminalNodeB = combinatorStatementNode, ///
-        nonTerminalNodeVerified = statementNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead);
+  const equalityNode = equalityNodeQuery(statementNode);
 
-  statementVerifiedAgainstCombinator = nonTerminalNodeVerified;  ///
+  if (equalityNode !== null) {
+    const statementString = context.nodeAsString(statementNode);
 
-  if (statementVerifiedAgainstCombinator) {
-    context.debug(`...verified the '${statementString}' statement against the '${combinatorString}' combinator.`, statementNode);
+    context.trace(`Verifying the '${statementString}' statement as an equality...`, statementNode);
+
+    const equalityVerified = verifyEquality(equalityNode, assignments, derived, context, verifyAhead);
+
+    statementVerifiedAsEquality = equalityVerified; ///
+
+    if (statementVerifiedAsEquality) {
+      context.debug(`...verified the '${statementString}' statement as an equality.`, statementNode);
+    }
   }
 
-  return statementVerifiedAgainstCombinator;
+  return statementVerifiedAsEquality;
 }
 
 function verifyStatementAsTypeAssertion(statementNode, assignments, derived, context, verifyAhead) {
@@ -109,24 +109,45 @@ function verifyStatementAsTypeAssertion(statementNode, assignments, derived, con
   return statementVerifiedAsTypeAssertion;
 }
 
-function verifyStatementAsEquality(statementNode, assignments, derived, context, verifyAhead) {
-  let statementVerifiedAsEquality = false;
+function verifyStatementAgainstCombinators(statementNode, assignments, derived, context, verifyAhead) {
+  let statementVerifiedAgainstCombinators;
 
-  const equalityNode = equalityNodeQuery(statementNode);
+  let combinators = context.getCombinators();
 
-  if (equalityNode !== null) {
-    const statementString = context.nodeAsString(statementNode);
+  combinators = [ ///
+    bracketedCombinator,
+    ...combinators
+  ];
 
-    context.trace(`Verifying the '${statementString}' statement as an equality...`, statementNode);
+  statementVerifiedAgainstCombinators = combinators.some((combinator) => {
+    const statementVerifiedAgainstCombinator = verifyStatementAgainstCombinator(statementNode, combinator, context, verifyAhead);
 
-    const equalityVerified = verifyEquality(equalityNode, assignments, derived, context, verifyAhead);
+    if (statementVerifiedAgainstCombinator) {
+      return true;
+    }
+  });
 
-    statementVerifiedAsEquality = equalityVerified; ///
+  return statementVerifiedAgainstCombinators;
+}
 
-    if (statementVerifiedAsEquality) {
-      context.debug(`...verified the '${statementString}' statement as an equality.`, statementNode);
-    }
+function verifyStatementAgainstCombinator(statementNode, combinator, context, verifyAhead) {
+  let statementVerifiedAgainstCombinator;
+
+  const statementString = context.nodeAsString(statementNode),
+        combinatorString = combinator.getString();
+
+  context.trace(`Verifying the '${statementString}' statement against the '${combinatorString}' combinator...`, statementNode);
+
+  const combinatorStatementNode = combinator.getStatementNode(),
+        nonTerminalNodeA = statementNode, ///
+        nonTerminalNodeB = combinatorStatementNode, ///
+        nonTerminalNodeVerified = statementNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, context, verifyAhead);
+
+  statementVerifiedAgainstCombinator = nonTerminalNodeVerified;  ///
+
+  if (statementVerifiedAgainstCombinator) {
+    context.debug(`...verified the '${statementString}' statement against the '${combinatorString}' combinator.`, statementNode);
   }
 
-  return statementVerifiedAsEquality;
+  return statementVerifiedAgainstCombinator;
 }

package/src/verify/supposition.js

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

package/src/verify/suppositions.js

@@ -5,25 +5,13 @@ import verifySupposition from "../verify/supposition";
 export default function verifySuppositions(suppositionNodes, suppositions, localContext) {
   let suppositionsVerified;
 
-  const assignments = [];
-
   suppositionsVerified = suppositionNodes.every((suppositionNode) => {
-    const suppositionVerified = verifySupposition(suppositionNode, suppositions, assignments, localContext);
+    const suppositionVerified = verifySupposition(suppositionNode, suppositions, localContext);
 
     if (suppositionVerified) {
       return true;
     }
   });
 
-  if (suppositionsVerified) {
-    suppositionsVerified = assignments.every((assignment) => {  ///
-      const assigned = assignment.assign(localContext);
-
-      if (assigned) {
-        return true;
-      }
-    });
-  }
-
   return suppositionsVerified;
 }

package/src/verify/term.js

@@ -2,11 +2,9 @@
 
 import Term from "../term";
 import termNodesVerifier from "../verifier/nodes/term";
+import verifyTermAsGivenVariable from "../verify/termAsGivenVariable";
 
 import { first } from "../utilities/array";
-import { nodeQuery } from "../utilities/query";
-
-const variableNodeQuery = nodeQuery("/term/variable!");
 
 function verifyTerm(termNode, terms, context, verifyAhead) {
   let termVerified;
@@ -16,7 +14,7 @@ function verifyTerm(termNode, terms, context, verifyAhead) {
   context.trace(`Verifying the '${termString}' term...`, termNode);
 
   const verifyTermFunctions = [
-    verifyTermAsStandaloneVariable,
+    verifyTermAsVariable,
     verifyTermAgainstConstructors
   ];
 
@@ -35,71 +33,41 @@ function verifyTerm(termNode, terms, context, verifyAhead) {
   return termVerified;
 }
 
-Object.assign(termNodesVerifier, {
-  verifyTerm
-});
+export function verifyStandaloneTerm(termNode, fileContext, verifyAhead) {
+  let standaloneTermVerified;
 
-export default verifyTerm;
+  const termString = fileContext.nodeAsString(termNode);
 
-export function verifyTermAgainstConstructors(termNode, terms, context, verifyAhead) {
-  let termVerifiedAgainstConstructors;
+  fileContext.trace(`Verifying the '${termString}' standalone term...`, termNode);
 
-  const constructors = context.getConstructors();
+  const terms = [],
+        context = fileContext,  ///
+        termVerified = verifyTerm(termNode, terms, context, verifyAhead);
 
-  termVerifiedAgainstConstructors = constructors.some((constructor) => {
-    const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, terms, constructor, context, verifyAhead);
+  standaloneTermVerified = termVerified;  ///
 
-    if (termVerifiedAgainstConstructor) {
-      return true;
-    }
-  });
+  if (standaloneTermVerified) {
+    fileContext.debug(`...verified the '${termString}' standalone term.`, termNode);
+  }
 
-  return termVerifiedAgainstConstructors;
+  return standaloneTermVerified;
 }
 
-export function verifyTermAsVariable(termNode, variables, context, verifyAhead) {
-  let termVerifiedAsVariable = false;
-
-  const variableNode = variableNodeQuery(termNode);
-
-  if (variableNode !== null) {
-    const termString = context.nodeAsString(termNode);
-
-    context.trace(`Verifying the '${termString}' term as a variable...`, termNode);
-
-    const variable = context.findVariableByVariableNode(variableNode);
-
-    if (variable !== null) {
-      let verifiedAhead;
-
-      variables.push(variable);
-
-      verifiedAhead = verifyAhead();
-
-      if (!verifiedAhead) {
-        variables.pop();
-      }
-
-      termVerifiedAsVariable = verifiedAhead; ///
-    }
-
-    if (termVerifiedAsVariable) {
-      context.debug(`...verified the '${termString}' term as a variable.`, termNode);
-    }
-  }
+Object.assign(termNodesVerifier, {
+  verifyTerm
+});
 
-  return termVerifiedAsVariable;
-}
+export default verifyTerm;
 
-function verifyTermAsStandaloneVariable(termNode, terms, context, verifyAhead) {
-  let termVerifiedAsStandaloneVariable;
+function verifyTermAsVariable(termNode, terms, context, verifyAhead) {
+  let termVerifiedAsVariable;
 
   const termString = context.nodeAsString(termNode);
 
-  context.trace(`Verifying the '${termString}' term as a standalone variable...`, termNode);
+  context.trace(`Verifying the '${termString}' term as a variable...`, termNode);
 
   const variables = [],
-        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, context, () => {
+        termVerifiedAsGivenVariable = verifyTermAsGivenVariable(termNode, variables, context, () => {
           let verifiedAhead;
 
           const firstVariable = first(variables),
@@ -118,13 +86,29 @@ function verifyTermAsStandaloneVariable(termNode, terms, context, verifyAhead) {
           return verifiedAhead;
         });
 
-  termVerifiedAsStandaloneVariable = termVerifiedAsVariable;  ///
+  termVerifiedAsVariable = termVerifiedAsGivenVariable;  ///
 
-  if (termVerifiedAsStandaloneVariable) {
-    context.debug(`...verified the '${termString}' term as a standalone variable.`, termNode);
+  if (termVerifiedAsVariable) {
+    context.debug(`...verified the '${termString}' term as a variable.`, termNode);
   }
 
-  return termVerifiedAsStandaloneVariable;
+  return termVerifiedAsVariable;
+}
+
+function verifyTermAgainstConstructors(termNode, terms, context, verifyAhead) {
+  let termVerifiedAgainstConstructors;
+
+  const constructors = context.getConstructors();
+
+  termVerifiedAgainstConstructors = constructors.some((constructor) => {
+    const termVerifiedAgainstConstructor = verifyTermAgainstConstructor(termNode, terms, constructor, context, verifyAhead);
+
+    if (termVerifiedAgainstConstructor) {
+      return true;
+    }
+  });
+
+  return termVerifiedAgainstConstructors;
 }
 
 function verifyTermAgainstConstructor(termNode, terms, constructor, context, verifyAhead) {