occam-verify-cli 0.0.837 → 0.0.839

package/src/utilities/equivalences.js

@@ -0,0 +1,152 @@
+"use strict";
+
+import { push, filter, compress, separate } from "../utilities/array";
+
+export function areTermNodesEqual(leftTermNode, rightTermNode, equivalences) {
+  let termNodesEqual;
+
+  const leftTermNodeMatchesRightTermNode = leftTermNode.match(rightTermNode);
+
+  if (leftTermNodeMatchesRightTermNode) {
+    termNodesEqual = true;
+  } else {
+    const termNodes = [
+            leftTermNode,
+            rightTermNode
+          ],
+          equivalence = findEquivalenceByTermNodes(equivalences, termNodes);
+
+    termNodesEqual = (equivalence !== null);
+  }
+
+  return termNodesEqual;
+}
+
+export function findEquivalenceByType(equivalences, type, localContext) {
+  const equivalence = equivalences.find((equivalence) => {
+    const equivalenceMatchesType = equivalence.matchType(type, localContext);
+
+    if (equivalenceMatchesType) {
+      return true;
+    }
+  }) || null;
+
+  return equivalence;
+}
+
+export function findEquivalenceByTerm(equivalences, term) {
+  const equivalence = equivalences.find((equivalence) => {
+    const equivalenceMatchesTerm = equivalence.matchTerm(term);
+
+    if (equivalenceMatchesTerm) {
+      return true;
+    }
+  }) || null;
+
+  return equivalence;
+}
+
+export function mergeEquivalences(equivalencesA, equivalencesB, localContext) {
+  const typesA = typesFromEquivalences(equivalencesA, localContext),
+        typesB = typesFromEquivalences(equivalencesB, localContext),
+        types = [
+          ...typesA,
+          ...typesB
+        ];
+
+  compress(types, (typeA, typeB) => {
+    if (typeA === typeB) {
+      return true;
+    }
+  });
+
+  const equivalences = types.map((type) => {
+    let equivalence;
+
+    const equivalenceA = findEquivalenceByType(equivalencesA, type, localContext),
+          equivalenceB = findEquivalenceByType(equivalencesB, type, localContext);
+
+    if ((equivalenceA !== null) && (equivalenceB !== null)) {
+      const leftEquivalence = equivalenceA, ///
+            rightEquivalence = equivalenceB;  ///
+
+      equivalence = Equivalence.merge(leftEquivalence, rightEquivalence);
+    } else if (equivalenceA !== null) {
+      equivalence = equivalenceA; ///
+    } else if (equivalenceB !== null) {
+      equivalence = equivalenceB; ///
+    }
+
+    return equivalence;
+  });
+
+  return equivalences;
+}
+
+export function separateEquivalences(equivalences, remainingEquivalences, initiallyGroundedEquivalences) {
+  separate(equivalences, remainingEquivalences, initiallyGroundedEquivalences, (equivalence) => {
+    const equivalenceInitiallyGrounded = equivalence.isInitiallyGrounded();
+
+    if (!equivalenceInitiallyGrounded) {
+      return true;
+    }
+  });
+}
+
+export function compressDefinedVariables(definedVariables) {
+  compress(definedVariables, (definedVariableA, definedVariableB) => {
+    if (definedVariableA === definedVariableB) {
+      return true;
+    }
+  });
+}
+
+export function definedVariablesFromGroundedEquivalences(groundedEquivalences, definedVariables, context) {
+  groundedEquivalences.forEach((groundedEquivalence) => {
+    const variables = groundedEquivalence.getVariables(context);
+
+    push(definedVariables, variables);
+  });
+}
+
+export function implicitlyGroundedEquivalencesFromRemainingEquivalencesAndDefinedVariables(remainingEquivalences, definedVariables) {
+  const implicitlyGroundedEquivalences = [];
+
+  filter(remainingEquivalences, (remainingEquivalence) => {
+    const remainingEquivalenceImplicitlyGrounded = remainingEquivalence.isImplicitlyGrounded(definedVariables);
+
+    if (remainingEquivalenceImplicitlyGrounded) {
+      const implicitlyGroundedEquivalence = remainingEquivalence; ///
+
+      implicitlyGroundedEquivalences.push(implicitlyGroundedEquivalence);
+    }
+
+    if (!remainingEquivalenceImplicitlyGrounded) {
+      return true;
+    }
+  });
+
+  return implicitlyGroundedEquivalences;
+}
+
+function findEquivalenceByTermNodes(equivalences, termNodes) {
+  const equivalence = equivalences.find((equivalence) => {
+    const equivalenceMatchesTerms = equivalence.matchTermNodes(termNodes);
+
+    if (equivalenceMatchesTerms) {
+      return true;
+    }
+  }) || null;
+
+  return equivalence;
+}
+
+function typesFromEquivalences(equivalences, localContext) {
+  const types = equivalences.map((equivalence) => {
+    const type = equivalence.getType(localContext);
+
+    return type;
+  });
+
+  return types;
+}

package/src/verifier/node/metastatement.js

@@ -2,7 +2,10 @@
 
 import NodeVerifier from "../../verifier/node";
 
-import { VARIABLE_RULE_NAME, METAVARIABLE_RULE_NAME } from "../../ruleNames";
+import { verifyStandaloneTerm } from "../../verify/term";
+import { verifyStandaloneVariable } from "../../verify/variable";
+import { verifyStandaloneMetavariable } from "../../verify/metavariable";
+import { TERM_RULE_NAME, VARIABLE_RULE_NAME, METAVARIABLE_RULE_NAME } from "../../ruleNames";
 
 class MetastatementNodeVerifier extends NodeVerifier {
   verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead) {
@@ -12,9 +15,10 @@ class MetastatementNodeVerifier extends NodeVerifier {
 
     switch (ruleName) {
       case METAVARIABLE_RULE_NAME: {
-        const metavariableNode = nonTerminalNode, ///
-              metavariableVerified = verifyMetavariable(metavariableNode, localMetaContext, verifyAhead),
-              metavariableNodeVerified = metavariableVerified;  ///
+        const context = localMetaContext, ///
+              metavariableNode = nonTerminalNode, ///
+              standaloneMetavariableVerified = verifyStandaloneMetavariable(metavariableNode, context, verifyAhead),
+              metavariableNodeVerified = standaloneMetavariableVerified;  ///
 
         nonTerminalNodeVerified = metavariableNodeVerified; ///
 
@@ -22,15 +26,27 @@ class MetastatementNodeVerifier extends NodeVerifier {
       }
 
       case VARIABLE_RULE_NAME: {
-        const variableNode = nonTerminalNode, ///
-              variableVerified = verifyVariable(variableNode, localMetaContext, verifyAhead),
-              variableNodeVerified = variableVerified;  ///
+        const context = localMetaContext, ///
+              variableNode = nonTerminalNode, ///
+              standaloneVariableVerified = verifyStandaloneVariable(variableNode, context, verifyAhead),
+              variableNodeVerified = standaloneVariableVerified;  ///
 
         nonTerminalNodeVerified = variableNodeVerified; ///
 
         break;
       }
 
+      case TERM_RULE_NAME: {
+        const context = localMetaContext, ///
+              termNode = nonTerminalNode, ///
+              standaloneTermVerified = verifyStandaloneTerm(termNode, context, verifyAhead),
+              termNodeVerified = standaloneTermVerified;  ///
+
+        nonTerminalNodeVerified = termNodeVerified; ///
+
+        break;
+      }
+
       default: {
         nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead);
 
@@ -45,47 +61,3 @@ class MetastatementNodeVerifier extends NodeVerifier {
 const metastatementNodeVerifier = new MetastatementNodeVerifier();
 
 export default metastatementNodeVerifier;
-
-function verifyMetavariable(metavariableNode, localMetaContext, verifyAhead) {
-  let metavariableVerified;
-
-  const metavariableString = localMetaContext.nodeAsString(metavariableNode);
-
-  localMetaContext.trace(`Verifying the '${metavariableString}' metavariable...`, metavariableNode);
-
-  const metavariablePresent = localMetaContext.isMetavariablePresentByMetavariableNode(metavariableNode);
-
-  if (metavariablePresent) {
-    const verifiedAhead = verifyAhead();
-
-    metavariableVerified = verifiedAhead; ///
-  }
-
-  if (metavariableVerified) {
-    localMetaContext.debug(`...verified the '${metavariableString}' metavariable.`, metavariableNode);
-  }
-
-  return metavariableVerified;
-}
-
-function verifyVariable(variableNode, localMetaContext, verifyAhead) {
-  let variableVerified;
-
-  const variableString = localMetaContext.nodeAsString(variableNode);
-
-  localMetaContext.trace(`Verifying the '${variableString}' variable...`, variableNode);
-
-  const variablePresent = localMetaContext.isVariablePresentByVariableNode(variableNode);
-
-  if (variablePresent) {
-    const verifiedAhead = verifyAhead();
-
-    variableVerified = verifiedAhead; ///
-  }
-
-  if (variableVerified) {
-    localMetaContext.debug(`...verified the '${variableString}' variable.`, variableNode);
-  }
-
-  return variableVerified;
-}

package/src/verifier/node/statementAsCombinator.js

@@ -15,8 +15,9 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
 
     switch (ruleName) {
       case STATEMENT_RULE_NAME: {
-        const statementNode = nonTerminalNode, ///
-              standaloneStatementVerified = verifyStandaloneStatement(statementNode, fileContext, verifyAhead),
+        const context = fileContext,  ///
+              statementNode = nonTerminalNode, ///
+              standaloneStatementVerified = verifyStandaloneStatement(statementNode, context, verifyAhead),
               statementNodeVerified = standaloneStatementVerified; ///
 
         nonTerminalNodeVerified = statementNodeVerified; ///
@@ -25,8 +26,9 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       }
 
       case TERM_RULE_NAME: {
-        const termNode = nonTerminalNode, ///
-              standaloneTermVerified = verifyStandaloneTerm(termNode, fileContext, verifyAhead),
+        const context = fileContext,  ///
+              termNode = nonTerminalNode, ///
+              standaloneTermVerified = verifyStandaloneTerm(termNode, context, verifyAhead),
               termNodeVerified = standaloneTermVerified;  ///
 
         nonTerminalNodeVerified = termNodeVerified; ///
@@ -35,8 +37,9 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       }
 
       case TYPE_RULE_NAME: {
-        const typeNode = nonTerminalNode, ///
-              standaloneTypeVerified = verifyStandaloneType(typeNode, fileContext, verifyAhead),
+        const context = fileContext,  ///
+              typeNode = nonTerminalNode, ///
+              standaloneTypeVerified = verifyStandaloneType(typeNode, context, verifyAhead),
               typeNodeVerified = standaloneTypeVerified;  ///
 
         nonTerminalNodeVerified = typeNodeVerified; ///

package/src/verifier/node/termAsConstructor.js

@@ -2,13 +2,9 @@
 
 import NodeVerifier from "../../verifier/node";
 
-import { nodeQuery } from "../../utilities/query";
 import { verifyStandaloneType } from "../../verify/type";
 import { verifyStandaloneTerm } from "../../verify/term";
-import { TERM_RULE_NAME, ARGUMENT_RULE_NAME } from "../../ruleNames";
-
-const typeNodeQuery = nodeQuery("/argument/type"),
-      termNodeQuery = nodeQuery("/argument/term");
+import { TERM_RULE_NAME, TYPE_RULE_NAME } from "../../ruleNames";
 
 class TermAsConstructorNodeVerifier extends NodeVerifier {
   verifyNonTerminalNode(nonTerminalNode, fileContext, verifyAhead) {
@@ -17,22 +13,24 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
     const ruleName = nonTerminalNode.getRuleName();
 
     switch (ruleName) {
-      case ARGUMENT_RULE_NAME: {
-        const argumentNode = nonTerminalNode, ///
-              argumentVerified = verifyArgument(argumentNode, fileContext, verifyAhead),
-              argumentNodeVerified = argumentVerified;  ///
+      case TERM_RULE_NAME: {
+        const context = fileContext,  ///
+              termNode = nonTerminalNode, ///
+              standaloneTermVerified = verifyStandaloneTerm(termNode, context, verifyAhead),
+              termNodeVerified = standaloneTermVerified;  ///
 
-        nonTerminalNodeVerified = argumentNodeVerified; ///
+        nonTerminalNodeVerified = termNodeVerified; ///
 
         break;
       }
 
-      case TERM_RULE_NAME: {
-        const termNode = nonTerminalNode, ///
-              standaloneTermVerified = verifyStandaloneTerm(termNode, fileContext, verifyAhead),
-              termNodeVerified = standaloneTermVerified;  ///
+      case TYPE_RULE_NAME: {
+        const context = fileContext,  ///
+              typeNode = nonTerminalNode, ///
+              standaloneTypeVerified = verifyStandaloneType(typeNode, context, verifyAhead),
+              typeNodeVerified = standaloneTypeVerified;  ///
 
-        nonTerminalNodeVerified = termNodeVerified; ///
+        nonTerminalNodeVerified = typeNodeVerified; ///
 
         break;
       }
@@ -51,32 +49,3 @@ class TermAsConstructorNodeVerifier extends NodeVerifier {
 const termAsConstructorNodeVerifier = new TermAsConstructorNodeVerifier();
 
 export default termAsConstructorNodeVerifier;
-
-function verifyArgument(argumentNode, fileContext, verifyAhead) {
-  let argumentVerified;
-
-  const argumentString = fileContext.nodeAsString(argumentNode);
-
-  fileContext.trace(`Verifying the '${argumentString}' argument...`, argumentNode);
-
-  const typeNode = typeNodeQuery(argumentNode),
-        termNode = termNodeQuery(argumentNode);
-
-  if (typeNode !== null) {
-    const standaloneTypeVerified = verifyStandaloneType(typeNode, fileContext, verifyAhead);
-
-    argumentVerified = standaloneTypeVerified; ///
-  }
-
-  if (termNode !== null) {
-    const standaloneTermVerified = verifyStandaloneTerm(termNode, fileContext, verifyAhead);
-
-    argumentVerified = standaloneTermVerified;  ///
-  }
-
-  if (argumentVerified) {
-    fileContext.debug(`...verified the '${argumentString}' argument.`, argumentNode);
-  }
-
-  return argumentVerified;
-}

package/src/verifier/nodes/equality.js

@@ -3,10 +3,10 @@
 import NodesVerifier from "../../verifier/nodes";
 
 import { TERM_RULE_NAME } from "../../ruleNames";
-import { areTermNodesEqual } from "../../utilities/collection";
+import { areTermNodesEqual } from "../../utilities/equivalences";
 
 class EqualityNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, collections, localContext, verifyAhead) {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equivalences, localContext, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
     const ruleNameA = nonTerminalNodeA.getRuleName(), ///
@@ -17,7 +17,7 @@ class EqualityNodesVerifier extends NodesVerifier {
         case TERM_RULE_NAME: {
           const termNodeA = nonTerminalNodeA, ///
                 termNodeB = nonTerminalNodeB, ///
-                termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, collections, localContext, verifyAhead);
+                termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, equivalences, localContext, verifyAhead);
 
           nonTerminalNodeVerified = termNodeVerified;  ///
 
@@ -25,7 +25,7 @@ class EqualityNodesVerifier extends NodesVerifier {
         }
 
         default: {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, collections, localContext, verifyAhead);
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equivalences, localContext, verifyAhead);
 
           break;
         }
@@ -35,12 +35,12 @@ class EqualityNodesVerifier extends NodesVerifier {
     return nonTerminalNodeVerified;
   }
 
-  verifyTermNode(termNodeA, termNodeB, collections, localContext, verifyAhead) {
+  verifyTermNode(termNodeA, termNodeB, equivalences, localContext, verifyAhead) {
     let termNodeVerified;
 
     const leftTermNode = termNodeA, ///
           rightTermNode = termNodeB, ///
-          termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, collections);
+          termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, equivalences);
 
     if (termNodesEqual) {
       const verifiedAhead = verifyAhead();
@@ -50,7 +50,7 @@ class EqualityNodesVerifier extends NodesVerifier {
       const nonTerminalNodeA = termNodeA, ///
             nonTerminalNodeB = termNodeB; ///
 
-      termNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, collections, localContext, verifyAhead);
+      termNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equivalences, localContext, verifyAhead);
     }
 
     return termNodeVerified;

package/src/verifier/nodes/metaLevelToIntrinsicLevel.js

@@ -2,15 +2,18 @@
 
 import LocalContext from "../../context/local";
 import NodesVerifier from "../../verifier/nodes";
+import TermForVariableSubstitution from "../../substitution/termForVariable";
 import intrinsicLevelNodesVerifierMixins from "../../mixins/nodesVerifier/intrinsiclevel";
 import StatementForMetavariableSubstitution from "../../substitution/statementForMetavariable";
 
 import { nodeQuery } from "../../utilities/query";
 import { TERM_RULE_NAME, STATEMENT_RULE_NAME, METASTATEMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../../ruleNames";
 
-const variableNodeQuery = nodeQuery("/term/variable!"),
+const termNodeQuery = nodeQuery("/substitution/term!"),
+      variableNodeQuery = nodeQuery("/*/variable!"),
       statementNodeQuery = nodeQuery("/metaArgument/statement"),
-      metavariableNodeQuery = nodeQuery("/metastatement/metavariable!");
+      metavariableNodeQuery = nodeQuery("/metastatement/metavariable!"),
+      substitutionNodeQuery = nodeQuery("/metastatement/substitution!");
 
 class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
@@ -80,9 +83,24 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
           metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
 
     if ((metavariableNodeA !== null) && (statementNodeB !== null)) {
-      const metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead);
+      const substitutionNode = substitutionNodeQuery(metastatementNodeA);
+
+      if (substitutionNode !== null) {
+        const variableNode = variableNodeQuery(substitutionNode),
+              variable = fileContextA.findVariableByVariableNode(variableNode);
+
+        if (variable !== null) {
+          const termNode = termNodeQuery(substitutionNode);
+
+          debugger
+
+
+        }
+      } else {
+        const metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead);
 
-      metaArgumentNodeVerified = metavariableNodeVerified;  ///
+        metaArgumentNodeVerified = metavariableNodeVerified;  ///
+      }
     }
 
     return metaArgumentNodeVerified;
@@ -121,15 +139,23 @@ class MetaLevelToIntrinsicLevelNodesVerifier extends NodesVerifier {
   verifyStatementNode(metastatementNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead) {
     let statementNodeVerified;
 
-    const nonTerminalNodeA = metastatementNodeA,  ///
-          nonTerminalNodeB = statementNodeB,  ///
-          nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
-          nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
-          childNodesA = nonTerminalNodeAChildNodes, ///
-          childNodesB = nonTerminalNodeBChildNodes, ///
-          childNodesVerified = super.verifyChildNodes(childNodesA, childNodesB, substitutions, fileContextA, localContextB, verifyAhead);
+    const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
+
+    if (metavariableNodeA !== null) {
+      const metavariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, statementNodeB, substitutions, fileContextA, localContextB, verifyAhead);
 
-    statementNodeVerified = childNodesVerified;  ///
+      statementNodeVerified = metavariableNodeVerified;  ///
+    } else {
+      const nonTerminalNodeA = metastatementNodeA,  ///
+            nonTerminalNodeB = statementNodeB,  ///
+            nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+            childNodesA = nonTerminalNodeAChildNodes, ///
+            childNodesB = nonTerminalNodeBChildNodes, ///
+            childNodesVerified = super.verifyChildNodes(childNodesA, childNodesB, substitutions, fileContextA, localContextB, verifyAhead);
+
+      statementNodeVerified = childNodesVerified;  ///
+    }
 
     return statementNodeVerified;
   }

package/src/verify/containment.js

@@ -1,37 +1,48 @@
 "use strict";
 
-import { third } from "../utilities/array";
+import { second } from "../utilities/array";
 import { CONTAINED } from "../constants";
 import { nodeQuery, nodesQuery } from "../utilities/query";
 
-const statementVariableNodesQuery = nodesQuery("/statement//variable"),
-      containmentVariableNodeQuery = nodeQuery("/containment/argument/term/variable!");
+const variableNodesQuery = nodesQuery("/metaArgument//variable"),
+      containmentVariableNodeQuery = nodeQuery("/argument/term/variable!");
 
-export default function verifyContainment(containmentNode, statementNode) {
+export default function verifyContainment(argumentNode, containmentNode, metaArgumentNode, context) {
   let containmentVerified = false;
 
-  const contained = containedFromContainmendNode(containmentNode),
-        statementVariableNodes = statementVariableNodesQuery(statementNode),
-        containmentVariableNode = containmentVariableNodeQuery(containmentNode),
-        containmentVariableNodeMatchesStatementVariableNode = statementVariableNodes.some((statementVariableNode) => {
-          const containmentVariableNodeMatchesStatementVariableNode = containmentVariableNode.match(statementVariableNode);
-
-          if (containmentVariableNodeMatchesStatementVariableNode) {
-            return true;
-          }
-        });
-
-  if (contained === containmentVariableNodeMatchesStatementVariableNode) {
-    containmentVerified = true;
+  const containmentVariableNode = containmentVariableNodeQuery(argumentNode);
+
+  if (containmentVariableNode !== null) {
+    const contained = containedFromContainmentNode(containmentNode),
+          variableNodes = variableNodesQuery(metaArgumentNode),
+          containmentVariableNodeMatchesStatementVariableNode = variableNodes.some((statementVariableNode) => {
+            const containmentVariableNodeMatchesStatementVariableNode = containmentVariableNode.match(statementVariableNode);
+
+            if (containmentVariableNodeMatchesStatementVariableNode) {
+              return true;
+            }
+          });
+
+    if (contained) {
+      if (containmentVariableNodeMatchesStatementVariableNode) {
+        containmentVerified = true;
+      }
+    }
+
+    if (!contained) {
+      if (!containmentVariableNodeMatchesStatementVariableNode) {
+        containmentVerified = true;
+      }
+    }
   }
 
   return containmentVerified;
 }
 
-function containedFromContainmendNode(containmentNode) {
+function containedFromContainmentNode(containmentNode) {
   const childNodes = containmentNode.getChildNodes(),
-        thirdChildNode = third(childNodes),
-        terminalNode = thirdChildNode,  ///
+        secondChildNode = second(childNodes),
+        terminalNode = secondChildNode,  ///
         content = terminalNode.getContent(),
         contained = (content === CONTAINED);
 

package/src/verify/defining.js

@@ -0,0 +1,43 @@
+"use strict";
+
+import { second } from "../utilities/array";
+import { DEFINED } from "../constants";
+import { nodeQuery } from "../utilities/query";
+
+const definedVariableNodeQuery = nodeQuery("/argument/term/variable!");
+
+export default function verifyDefining(argumentNode, definingNode, context) {
+  let definingVerified = false;
+
+  const definedVariableNode = definedVariableNodeQuery(argumentNode);
+
+  if (definedVariableNode !== null) {
+    const defined = definedFromDefiningNode(definingNode),
+          variableNode = definedVariableNode, ///
+          variableDefined = context.isVariableDefined(variableNode);
+
+    if (defined) {
+      if (variableDefined) {
+        definingVerified = true;
+      }
+    }
+
+    if (!defined) {
+      if (!variableDefined) {
+        definingVerified = true;
+      }
+    }
+  }
+
+  return definingVerified;
+}
+
+function definedFromDefiningNode(definingNode) {
+  const childNodes = definingNode.getChildNodes(),
+        secondChildNode = second(childNodes),
+        terminalNode = secondChildNode,  ///
+        content = terminalNode.getContent(),
+        defined = (content === DEFINED);
+
+  return defined;
+}

package/src/verify/metavariable.js

@@ -34,3 +34,25 @@ export default function verifyMetavariable(metavariableNode, metaTypeNode, fileC
 
   return metavariableVerified;
 }
+
+export function verifyStandaloneMetavariable(metavariableNode, contexct, verifyAhead) {
+  let standaloneMetavariableVerified = false;
+
+  const metavariableString = contexct.nodeAsString(metavariableNode);
+
+  contexct.trace(`Verifying the '${metavariableString}' standalone metavariable...`, metavariableNode);
+
+  const metavariablePresent = contexct.isMetavariablePresentByMetavariableNode(metavariableNode);
+
+  if (metavariablePresent) {
+    const verifiedAhead = verifyAhead();
+
+    standaloneMetavariableVerified = verifiedAhead; ///
+  }
+
+  if (standaloneMetavariableVerified) {
+    contexct.debug(`...verified the '${metavariableString}' standalone metavariable.`, metavariableNode);
+  }
+
+  return standaloneMetavariableVerified;
+}