occam-verify-cli 0.0.869 → 0.0.871

package/src/verifier/nodes/equality.js

@@ -1,59 +1,54 @@
 "use strict";
 
 import NodesVerifier from "../../verifier/nodes";
+import verifyTermAgainstTerm from "../../verify/termAgainstTerm";
 
-import { TERM_RULE_NAME } from "../../ruleNames";
-import { areTermNodesEqual } from "../../utilities/equivalences";
+import { nodeQuery } from "../../utilities/query";
+import { verifyNodes } from "../../utilities/verifier";
 
-class EqualityNodesVerifier extends NodesVerifier {
-  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equivalences, localContext, verifyAhead) {
-    let nonTerminalNodeVerified = false;
+const termNodeQuery = nodeQuery("/term!");
 
-    const ruleNameA = nonTerminalNodeA.getRuleName(), ///
-          ruleNameB = nonTerminalNodeB.getRuleName(); ///
+class EqualityNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {
+    let nonTerminalNodeVerified;
 
-    if (ruleNameA === ruleNameB) {
-      switch (ruleNameA) {
-        case TERM_RULE_NAME: {
-          const termNodeA = nonTerminalNodeA, ///
-                termNodeB = nonTerminalNodeB, ///
-                termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, equivalences, localContext, verifyAhead);
+    const nodeQueryMaps = [
+      {
+        nodeQueryA: termNodeQuery,
+        nodeQueryB: termNodeQuery,
+        verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
 
-          nonTerminalNodeVerified = termNodeVerified;  ///
+          const termNodeA = nodeA,  ///
+                termNodeB = nodeB,  ///
+                termNodeVerifiedAgainstTermNode =
 
-          break;
-        }
+                  this.verifyTermNodeAgainstTermNode(termNodeA, termNodeB, localContext, verifyAhead);
 
-        default: {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equivalences, localContext, verifyAhead);
+          nonTerminalNodeVerified = termNodeVerifiedAgainstTermNode; ///
 
-          break;
+          return nonTerminalNodeVerified;
         }
       }
-    }
+    ];
 
-    return nonTerminalNodeVerified;
-  }
+    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
 
-  verifyTermNode(termNodeA, termNodeB, equivalences, localContext, verifyAhead) {
-    let termNodeVerified;
+    nonTerminalNodeVerified = nodesVerified ?
+                                 true :
+                                   super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
 
-    const leftTermNode = termNodeA, ///
-          rightTermNode = termNodeB, ///
-          termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, equivalences);
+    return nonTerminalNodeVerified;
+  }
 
-    if (termNodesEqual) {
-      const verifiedAhead = verifyAhead();
+  verifyTermNodeAgainstTermNode(termNodeA, termNodeB, localContext, verifyAhead) {
+    let termNodeVerifiedAgainstTermNode;
 
-      termNodeVerified = verifiedAhead;  ///
-    } else {
-      const nonTerminalNodeA = termNodeA, ///
-            nonTerminalNodeB = termNodeB; ///
+    const termVerifiedAgainstTerm = verifyTermAgainstTerm(termNodeA, termNodeB, localContext, verifyAhead);
 
-      termNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equivalences, localContext, verifyAhead);
-    }
+    termNodeVerifiedAgainstTermNode = termVerifiedAgainstTerm;  ///
 
-    return termNodeVerified;
+    return termNodeVerifiedAgainstTermNode;
   }
 }
 

package/src/verifier/nodes/intrinsicLevel.js

@@ -1,68 +1,60 @@
 "use strict";
 
 import NodesVerifier from "../../verifier/nodes";
-import intrinsicLevelNodesVerifierMixins from "../../mixins/nodesVerifier/intrinsiclevel";
+import verifyVariableAgainstTerm from "../../verify/variableAgainstTerm";
 
 import { nodeQuery } from "../../utilities/query";
-import { TERM_RULE_NAME } from "../../ruleNames";
+import { verifyNodes } from "../../utilities/verifier";
 
-const variableNodeQuery = nodeQuery("/term/variable!");
+const termNodeQuery = nodeQuery("/term!"),
+      termVariableNodeQuery = nodeQuery("/term/variable!");
 
 class IntrinsicLevelNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-    let nonTerminalNodeVerified = false;
+    let nonTerminalNodeVerified;
 
-    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
-          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
+    const nodeQueryMaps = [
+      {
+        nodeQueryA: termVariableNodeQuery,
+        nodeQueryB: termNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
 
-    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
-      const ruleName = nonTerminalNodeARuleName;  ///
+          const termNodeB = nodeB,  ///
+                termVariableNodeA = nodeA,  ///
+                termVariableNodeVerifiedAgainstTermNode =
 
-      switch (ruleName) {
-        case TERM_RULE_NAME: {
-          const termNodeA = nonTerminalNodeA,  ///
-                termNodeB = nonTerminalNodeB,  ///
-                termNodeVerified = this.verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
+                  this.verifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
-          nonTerminalNodeVerified = termNodeVerified;  ///
+          nonTerminalNodeVerified = termVariableNodeVerifiedAgainstTermNode;  ///
 
-          break;
+          return nonTerminalNodeVerified;
         }
+      }
+    ];
 
-        default: {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
-          break;
-        }
-      }
-    }
+    nonTerminalNodeVerified = nodesVerified ?
+                                true :
+                                  super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
 
     return nonTerminalNodeVerified;
   }
 
-  verifyTermNode(termNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-    let termNodeVerified;
+  verifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let termVariableNodeVerifiedAgainstTermNode;
 
-    const variableNodeA = variableNodeQuery(termNodeA);
+    const termNode = termNodeB, ///
+          variableNode = termVariableNodeA, ///
+          termVerifiedAgainstVariable = verifyVariableAgainstTerm(variableNode, termNode, substitutions, localContextA, localContextB, verifyAhead);
 
-    if (variableNodeA !== null) {
-      const variableNodeVerified = this.verifyVariableNode(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
+    termVariableNodeVerifiedAgainstTermNode = termVerifiedAgainstVariable;  ///
 
-      termNodeVerified = variableNodeVerified; ///
-    } else {
-      const nonTerminalNodeA = termNodeA, ///
-            nonTerminalNodeB = termNodeB, ///
-            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
-
-      termNodeVerified = nonTerminalNodeVerified; ///
-    }
-
-    return termNodeVerified;
+    return termVariableNodeVerifiedAgainstTermNode;
   }
 }
 
-Object.assign(IntrinsicLevelNodesVerifier.prototype, intrinsicLevelNodesVerifierMixins);
-
 const intrinsicLevelNodesVerifier = new IntrinsicLevelNodesVerifier();
 
 export default intrinsicLevelNodesVerifier;

package/src/verifier/nodes/intrinsicLevelAgainstMetaLevel.js

@@ -0,0 +1,222 @@
+"use strict";
+
+import NodesVerifier from "../../verifier/nodes";
+import verifyVariableAgainstTerm from "../../verify/variableAgainstTerm";
+import verifyMetavariableAgainstStatement from "../../verify/metavariableAgainstStatement";
+
+import { nodeQuery } from "../../utilities/query";
+import { verifyNodes } from "../../utilities/verifier";
+
+const termNodeQuery = nodeQuery("/term!"),
+      statementNodeQuery = nodeQuery("/statement!"),
+      termVariableNodeQuery = nodeQuery("/term/variable!"),
+      metastatementNodeQuery = nodeQuery("/metastatement!"),
+      metaArgumentStatementNodeQuery = nodeQuery("/metaArgument/statement!"),
+      metastatementStatementNodeQuery = nodeQuery("/metastatement/statement!"),
+      metastatementMetavariableNodeQuery = nodeQuery("/metastatement/metavariable!"),
+      metastatementSubstitutionNodeQuery = nodeQuery("/metastatement/substitution");
+
+class IntrinsicLevelAgainstMetaLevelNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let nonTerminalNodeVerified;
+
+    const nodeQueryMaps = [
+      {
+        nodeQueryA: metastatementMetavariableNodeQuery,
+        nodeQueryB: metastatementStatementNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const metastatementStatementNodeB = nodeB,  ///
+                metastatementMetavariableNodeA = nodeA, ///
+                metastatementSubstitutionNodeA = metastatementSubstitutionNodeQuery(nonTerminalNodeA),
+                metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode =
+
+                  this.verifyMetastatementMetavariableNodeAgainstMetastatementStatementNode(metastatementMetavariableNodeA, metastatementStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead);
+
+          nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode;  ///
+
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: metastatementMetavariableNodeQuery,
+        nodeQueryB: metaArgumentStatementNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const metaArgumentStatementNodeB = nodeB,  ///
+                metastatementMetavariableNodeA = nodeA, ///
+                metastatementSubstitutionNodeA = metastatementSubstitutionNodeQuery(nonTerminalNodeA),
+                metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode =
+
+                  this.verifyMetastatementMetavariableNodeAgainstMetaArgumentStatementNode(metastatementMetavariableNodeA, metaArgumentStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead);
+
+          nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;  ///
+
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: metastatementMetavariableNodeQuery,
+        nodeQueryB: statementNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const statementNodeB = nodeB,  ///
+                metastatementMetavariableNodeA = nodeA, ///
+                metastatementSubstitutionNodeA = metastatementSubstitutionNodeQuery(nonTerminalNodeA),
+                metastatementMetavariableNodeVerifiedAgainstStatementNode =
+
+                  this.verifyMetastatementMetavariableNodeAgainstStatementNode(metastatementMetavariableNodeA, statementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead);
+
+          nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstStatementNode;  ///
+
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: metastatementStatementNodeQuery,
+        nodeQueryB: statementNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const statementNodeB = nodeB, ///
+                metastatementStatementNodeA = nodeA,  ///
+                metastatementStatementNodeVerifiedAgainstStatementNode =
+
+                  this.verifyMetastatementStatementNodeAgainstStatementNode(metastatementStatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+          nonTerminalNodeVerified = metastatementStatementNodeVerifiedAgainstStatementNode; ///
+
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: metastatementNodeQuery,
+        nodeQueryB: statementNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const statementNodeB = nodeB,  ///
+                metastatementNodeA = nodeA, ///
+                metastatementNodeVerifiedAgainstStatementNode =
+
+                  this.verifyMetastatementNodeAgainstStatementNode(metastatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+          nonTerminalNodeVerified = metastatementNodeVerifiedAgainstStatementNode;  ///
+
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: termVariableNodeQuery,
+        nodeQueryB: termNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
+
+          const termNodeB = nodeB,  ///
+                termVariableNodeA = nodeA,  ///
+                variableNodeVerifiedAgainstTermNode =
+
+                  this.verifyVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+          nonTerminalNodeVerified = variableNodeVerifiedAgainstTermNode; ///
+
+          return nonTerminalNodeVerified;
+        }
+      }
+    ];
+
+    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+    nonTerminalNodeVerified = nodesVerified ?
+                                true :
+                                  super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+    return nonTerminalNodeVerified;
+  }
+
+  verifyMetastatementMetavariableNodeAgainstMetastatementStatementNode(metastatementMetavariableNodeA, metastatementStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
+    let metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode;
+
+    const statementNode = metastatementStatementNodeB, ///
+          metavariableNode = metastatementMetavariableNodeA,  ///
+          substitutionNode = metastatementSubstitutionNodeA,  ///
+          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutionNode, substitutions, localContextA, localContextB, verifyAhead)
+
+    metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode = metavariableVerifiedAgainstStatement; ///
+
+    return metastatementMetavariableNodeVerifiedAgainstMetastatementStatementNode;
+  }
+
+  verifyMetastatementMetavariableNodeAgainstMetaArgumentStatementNode(metastatementMetavariableNodeA, metaArgumentStatementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
+    let metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;
+
+    const statementNode = metaArgumentStatementNodeB, ///
+          metavariableNode = metastatementMetavariableNodeA,  ///
+          substitutionNode = metastatementSubstitutionNodeA,  ///
+          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutionNode, substitutions, localContextA, localContextB, verifyAhead)
+
+    metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode = metavariableVerifiedAgainstStatement; ///
+
+    return metastatementMetavariableNodeVerifiedAgainstMetaArgumentStatementNode;
+  }
+
+  verifyMetastatementMetavariableNodeAgainstStatementNode(metastatementMetavariableNodeA, statementNodeB, metastatementSubstitutionNodeA, substitutions, localContextA, localContextB, verifyAhead) {
+    let metastatementMetavariableNodeVerifiedAgainstStatementNode;
+
+    const statementNode = statementNodeB, ///
+          metavariableNode = metastatementMetavariableNodeA,  ///
+          substitutionNode = metastatementSubstitutionNodeA,  ///
+          metavariableVerifiedAgainstStatement = verifyMetavariableAgainstStatement(metavariableNode, statementNode, substitutionNode, substitutions, localContextA, localContextB, verifyAhead)
+
+    metastatementMetavariableNodeVerifiedAgainstStatementNode = metavariableVerifiedAgainstStatement; ///
+
+    return metastatementMetavariableNodeVerifiedAgainstStatementNode;
+  }
+
+  verifyMetastatementStatementNodeAgainstStatementNode(metastatementStatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let metastatementStatementNodeVerifiedAgainstStatementNode;
+
+    const nonTerminalNodeA = metastatementStatementNodeA, ///
+          nonTerminalNodeB = statementNodeB,  ///
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, verifyAhead);
+
+    metastatementStatementNodeVerifiedAgainstStatementNode = nonTerminalNodeVerified; ///
+
+    return metastatementStatementNodeVerifiedAgainstStatementNode;
+  }
+
+  verifyMetastatementNodeAgainstStatementNode(metastatementNodeA, statementNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let metastatementNodeVerifiedAgainstStatementNode;
+
+    const nonTerminalNodeA = metastatementNodeA,  ///
+          nonTerminalNodeB = statementNodeB,  ///
+          nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+          nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+          childNodesA = nonTerminalNodeAChildNodes, ///
+          childNodesB = nonTerminalNodeBChildNodes, ///
+          childNodesVerified = this.verifyChildNodes(childNodesA, childNodesB, substitutions, localContextA, localContextB, verifyAhead);
+
+    metastatementNodeVerifiedAgainstStatementNode = childNodesVerified; ///
+
+    return metastatementNodeVerifiedAgainstStatementNode;
+  }
+
+  verifyVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+    let variableNodeVerifiedAgainstTermNode;
+
+    const termNode = termNodeB, ///
+          variableNode = termVariableNodeA, ///
+          variableVerifiedAgainstTerm = verifyVariableAgainstTerm(variableNode, termNode, substitutions, localContextA, localContextB, verifyAhead);
+
+    variableNodeVerifiedAgainstTermNode = variableVerifiedAgainstTerm;  ///
+
+    return variableNodeVerifiedAgainstTermNode;
+  }
+}
+
+const intrinsicLevelAgainstMetaLevelNodesVerifier = new IntrinsicLevelAgainstMetaLevelNodesVerifier();
+
+export default intrinsicLevelAgainstMetaLevelNodesVerifier;

package/src/verifier/nodes/metaLevel.js

@@ -1,68 +1,60 @@
 "use strict";
 
 import NodesVerifier from "../../verifier/nodes";
-import metaLevelNodesVerifierMixins from "../../mixins/nodesVerifier/metaLevel";
+import verifyMetavariableAgainstMetastatement from "../../verify/metavariableAgainstMetastatement";
 
 import { nodeQuery } from "../../utilities/query";
-import { METASTATEMENT_RULE_NAME } from "../../ruleNames";
+import { verifyNodes } from "../../utilities/verifier";
 
-const metavariableNodeQuery = nodeQuery("/metastatement/metavariable!");
+const metastatementNodeQuery = nodeQuery("/metastatement!"),
+      metastatementMetavariableNodeQuery = nodeQuery("/metastatement/metavariable!");
 
 class MetaLevelNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
-    let nonTerminalNodeVerified = false;
+    let nonTerminalNodeVerified;
 
-    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(),
-          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName();
+    const nodeQueryMaps = [
+      {
+        nodeQueryA: metastatementMetavariableNodeQuery,
+        nodeQueryB: metastatementNodeQuery,
+        verifyNodes: (nodeA, nodeB, substitutions, localContextA, localMetaContextB, verifyAhead) => {
+          let nonTerminalNodeVerified;
 
-    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
-      const ruleName = nonTerminalNodeARuleName;  ///
+          const metastatementNodeB = nodeB, ///
+                metastatementMetavariableNodeA = nodeA, ///
+                metastatementMetavariableNodeVerifiedAgainstMetastatementNode =
 
-      switch (ruleName) {
-        case METASTATEMENT_RULE_NAME: {
-          const metastatementNodeA = nonTerminalNodeA,  ///
-                metastatementNodeB = nonTerminalNodeB,  ///
-                metastatementNodeVerified = this.verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
+                  this.verifyMetastatementMetavariableNodeAgainstMetastatementNode(metastatementMetavariableNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
 
-          nonTerminalNodeVerified = metastatementNodeVerified;  ///
+          nonTerminalNodeVerified = metastatementMetavariableNodeVerifiedAgainstMetastatementNode;  ///
 
-          break;
+          return nonTerminalNodeVerified;
         }
+      }
+    ];
 
-        default: {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
+    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
 
-          break;
-        }
-      }
-    }
+    nonTerminalNodeVerified = nodesVerified ?
+                                true :
+                                  super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
 
     return nonTerminalNodeVerified;
   }
 
-  verifyMetastatementNode(metastatementNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
-    let metastatementNodeVerified;
+  verifyMetastatementMetavariableNodeAgainstMetastatementNode(metastatementMetavariableNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead) {
+    let metastatementMetavariableNodeVerifiedAgainstMetastatementNode;
 
-    const metavariableNodeA = metavariableNodeQuery(metastatementNodeA);
+    const metavariableNode = metastatementMetavariableNodeA, ///
+          metastatementNode = metastatementNodeB, ///
+          metavariableVerifiedAgainstMetastatement = verifyMetavariableAgainstMetastatement(metavariableNode, metastatementNode, substitutions, localContextA, localMetaContextB, verifyAhead);
 
-    if (metavariableNodeA !== null) {
-      const metaVariableNodeVerified = this.verifyMetavariableNode(metavariableNodeA, metastatementNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
+    metastatementMetavariableNodeVerifiedAgainstMetastatementNode = metavariableVerifiedAgainstMetastatement;  ///
 
-      metastatementNodeVerified = metaVariableNodeVerified; ///
-    } else {
-      const nonTerminalNodeA = metastatementNodeA,  ///
-            nonTerminalNodeB = metastatementNodeB, ///
-            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localMetaContextB, verifyAhead);
-
-      metastatementNodeVerified = nonTerminalNodeVerified;  ///
-    }
-
-    return metastatementNodeVerified;
+    return metastatementMetavariableNodeVerifiedAgainstMetastatementNode;
   }
 }
 
-Object.assign(MetaLevelNodesVerifier.prototype, metaLevelNodesVerifierMixins);
-
 const metaLevelNodesVerifier = new MetaLevelNodesVerifier();
 
 export default metaLevelNodesVerifier;

package/src/verifier/nodes/statementAgainstCombinator.js

@@ -1,89 +1,86 @@
 "use strict";
 
 import NodesVerifier from "../../verifier/nodes";
-import termAgainstConstructorNodesVerifier from "../../verifier/nodes/termAgainstConstructor";
+import verifyArgumentAgainstArgument from "../../verify/argumentAgainstArgument";
+import verifyStatementAgainstMetaType from "../../verify/statementAgainstMetaType";
 
 import { nodeQuery } from "../../utilities/query";
-import { STATEMENT_META_TYPE_NAME } from "../../metaTypeNames";
-import { ARGUMENT_RULE_NAME, META_ARGUMENT_RULE_NAME } from "../../ruleNames";
+import { verifyNodes } from "../../utilities/verifier";
 
-const metaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
-      statementNodeQuery = nodeQuery("/metaArgument/statement!"),
-      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type");
+const argumentNodeQuery = nodeQuery("/argument!"),
+      metaArgumentMetaTypeNodeQuery = nodeQuery("/metaArgument/metaType!"),
+      metaArgumentStatementNodeQuery = nodeQuery("/metaArgument/statement!");
 
 class StatementAgainstCombinatorNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead) {
-    let nonTerminalNodeVerified = false;
+    let nonTerminalNodeVerified;
 
-    const nonTerminalNode = nonTerminalNodeA, ///
-          combinatorNonTerminalNode = nonTerminalNodeB, ///
-          ruleName = nonTerminalNode.getRuleName(), ///
-          combinatorRuleName = combinatorNonTerminalNode.getRuleName(); ///
+    const nodeQueryMaps = [
+      {
+        nodeQueryA: metaArgumentStatementNodeQuery,
+        nodeQueryB: metaArgumentMetaTypeNodeQuery,
+        verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
 
-    if (ruleName === combinatorRuleName) {
-      switch (ruleName) {
-        case META_ARGUMENT_RULE_NAME: {
-          const metaArgumentNode = nonTerminalNode, ///
-                combinatorMetaargumentNode = combinatorNonTerminalNode, ///
-                metaArgumentNodeVerified = this.verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, localContext, verifyAhead);
+          const metaArgumentMetaTypeNodeB = nodeB,  ///
+                metaArgumentStatementNodeA = nodeA, ///
+                metaArgumentStatementVerifiedAgainstMetaArgumentMetaType =
 
-          nonTerminalNodeVerified = metaArgumentNodeVerified; ///
+                  this.verifyMetaArgumentStatementAgainstMetaArgumentMetaType(metaArgumentStatementNodeA, metaArgumentMetaTypeNodeB, localContext, verifyAhead);
 
-          break;
-        }
+          nonTerminalNodeVerified = metaArgumentStatementVerifiedAgainstMetaArgumentMetaType; ///
 
-        case ARGUMENT_RULE_NAME: {
-          const argumentNode = nonTerminalNode, ///
-                constructorArgumentNode = combinatorNonTerminalNode, ///
-                argumentNodeVerified = termAgainstConstructorNodesVerifier.verifyArgumentNode(argumentNode, constructorArgumentNode, localContext, verifyAhead);
+          return nonTerminalNodeVerified;
+        }
+      },
+      {
+        nodeQueryA: argumentNodeQuery,
+        nodeQueryB: argumentNodeQuery,
+        verifyNodes: (nodeA, nodeB, localContext, verifyAhead) => {
+          let nonTerminalNodeVerified;
 
-          nonTerminalNodeVerified = argumentNodeVerified; ///
+          const argumentNodeA = nodeA,  ///
+                argumentNodeB = nodeB,  ///
+                argumentNodeVerifiedAgainstArgumentNode =
 
-          break;
-        }
+                  this.verifyArgumentNodeAgainstArgumentNode(argumentNodeA, argumentNodeB, localContext, verifyAhead);
 
-        default: {
-          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
+          nonTerminalNodeVerified = argumentNodeVerifiedAgainstArgumentNode; ///
 
-          break;
+          return nonTerminalNodeVerified;
         }
       }
-    }
+    ];
+
+    const nodesVerified = verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
+
+    nonTerminalNodeVerified = nodesVerified ?
+                                true :
+                                  super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, verifyAhead);
 
     return nonTerminalNodeVerified;
   }
 
-  verifyMetaargumentNode(metaArgumentNode, combinatorMetaargumentNode, localContext, verifyAhead) {
-    let metaArgumentNodeVerified = false;
+  verifyMetaArgumentStatementAgainstMetaArgumentMetaType(metaArgumentStatementNodeA, metaArgumentMetaTypeNodeB, localContext, verifyAhead) {
+    let metaArgumentStatementVerifiedAgainstMetaArgumentMetaType = false;
 
-    const metaArgumentString = localContext.nodeAsString(metaArgumentNode);
+    const metaTypeNode = metaArgumentMetaTypeNodeB, ///
+          statementNode = metaArgumentStatementNodeA,  ///
+          statementVerifiedAgainstMetaType = verifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext, verifyAhead);
 
-    const statementNode = statementNodeQuery(metaArgumentNode),
-          combinatorMetaTYpeNode = metaTypeNodeQuery(combinatorMetaargumentNode);
+    metaArgumentStatementVerifiedAgainstMetaArgumentMetaType = statementVerifiedAgainstMetaType; ///
 
-    if (statementNode === null) {
-      localContext.debug(`Expected a statement but got a '${metaArgumentString}' meta-type.`, metaArgumentNode);
-    } else {
-      if (combinatorMetaTYpeNode === null) {
-        const combinatorMetaargumentString = localContext.nodeAsString(combinatorMetaargumentNode);
+    return metaArgumentStatementVerifiedAgainstMetaArgumentMetaType;
+  }
 
-        localContext.debug(`Expected a meta-type but got a '${combinatorMetaargumentString}' statement.`, metaArgumentNode);
-      } else {
-        const combinatorMetaTypeTerminalNode = metaTypeTerminalNodeQuery(combinatorMetaTYpeNode),
-              content = combinatorMetaTypeTerminalNode.getContent(),
-              contentStatementMetaType = (content === STATEMENT_META_TYPE_NAME);
+  verifyArgumentNodeAgainstArgumentNode(argumentNodeA, argumentNodeB, localContext, verifyAhead) {
+    let argumentNodeVerifiedAgainstArgumentNode;
 
-        if (!contentStatementMetaType) {
-          localContext.debug(`Expected the meta-type of the combinator to be '${STATEMENT_META_TYPE_NAME}' but got '${content}' instead.`, metaArgumentNode);
-        } else {
-          const verifiedAhead = verifyAhead();
+    const argumentVerifiedAgainstArgument = verifyArgumentAgainstArgument(argumentNodeA, argumentNodeB, localContext, verifyAhead);
 
-          metaArgumentNodeVerified = verifiedAhead; ///
-        }
-      }
-    }
+    argumentNodeVerifiedAgainstArgumentNode = argumentVerifiedAgainstArgument; ///
 
-    return metaArgumentNodeVerified;
+    return argumentNodeVerifiedAgainstArgumentNode;
   }
 }