occam-verify-cli 0.0.869 → 0.0.870

package/lib/verify/variableAgainstTerm.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return verifyVariableAgainstTerm;
+    }
+});
+var _term = /*#__PURE__*/ _interop_require_default(require("../verify/term"));
+var _termForVariable = /*#__PURE__*/ _interop_require_default(require("../substitution/termForVariable"));
+var _array = require("../utilities/array");
+var _query = require("../utilities/query");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+var variableNodeQuery = (0, _query.nodeQuery)("/term/variable");
+function verifyVariableAgainstTerm(variableNode, termNode, substitutions, localContextA, localContextB, verifyAhead) {
+    var variableVerifiedAgainstTerm = false;
+    var substitution = substitutions.find(function(substitution) {
+        var substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNode);
+        if (substitutionMatchesVariableNodeA) {
+            return true;
+        }
+    }) || null;
+    if (substitution !== null) {
+        var termNodeMatches = substitution.matchTermNode(termNode);
+        if (termNodeMatches) {
+            var verifiedAhead = verifyAhead();
+            variableVerifiedAgainstTerm = verifiedAhead; ///
+        }
+    } else {
+        var variableA = localContextA.findVariableByVariableNode(variableNode);
+        if (variableA !== null) {
+            var terms = [], termVerified = (0, _term.default)(termNode, terms, localContextB, function() {
+                var verifiedAhead = false;
+                var firstTerm = (0, _array.first)(terms), termB = firstTerm, variableB = variableFromTerm(termB, localContextB);
+                if (variableA === variableB) {
+                    verifiedAhead = verifyAhead();
+                } else {
+                    var term = termB, variable = variableA, termType = term.getType(), variableType = variable.getType(), variableTypeEqualToOrSuperTypeOfTermType = variableType.isEqualToOrSuperTypeOf(termType);
+                    if (variableTypeEqualToOrSuperTypeOfTermType) {
+                        var termForVariableSubstitution = _termForVariable.default.fromVariableNodeAndTermNode(variableNode, termNode), substitution = termForVariableSubstitution; ///
+                        substitutions.push(substitution);
+                        verifiedAhead = verifyAhead();
+                        if (!verifiedAhead) {
+                            substitutions.pop();
+                        }
+                    }
+                }
+                return verifiedAhead;
+            });
+            variableVerifiedAgainstTerm = termVerified; ///
+        }
+    }
+    return variableVerifiedAgainstTerm;
+}
+function variableFromTerm(term, localContext) {
+    var variable = null;
+    var termNode = term.getNode(), variableNode = variableNodeQuery(termNode);
+    if (variableNode !== null) {
+        variable = localContext.findVariableByVariableNode(variableNode);
+    }
+    return variable;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.869",
+  "version": "0.0.870",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,9 +12,9 @@
   "dependencies": {
     "argumentative": "^2.0.28",
     "necessary": "^14.0.1",
-    "occam-custom-grammars": "^5.0.776",
-    "occam-entities": "^1.0.133",
-    "occam-file-system": "^6.0.175",
+    "occam-custom-grammars": "^5.0.777",
+    "occam-entities": "^1.0.134",
+    "occam-file-system": "^6.0.176",
     "occam-grammar-utilities": "^8.0.205",
     "occam-query": "^3.1.174"
   },

package/src/conclusion.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
-import metaLevelToIntrinsicLevelNodesVerifier from "./verifier/nodes/metaLevelToIntrinsicLevel";
+import intrinsicLevelAgainstMetaLevelNodesVerifier from "./verifier/nodes/intrinsicLevelAgainstMetaLevel";
 
 import { nodeAsString } from "./utilities/string";
 import { metastatementNodeFromMetastatementString } from "./utilities/node";
@@ -20,7 +20,7 @@ export default class Conclusion {
           nonTerminalNodeB = statementNode,  ///
           localContextA = localContext, ///
           localContextB = statementLocalContext,  ///
-          nonTerminalNodeVerified = metaLevelToIntrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+          nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
             const verifyAhead = true;
 
             return verifyAhead;

package/src/equality.js

@@ -29,17 +29,11 @@ export default class Equality {
   }
 
   isEqual(localContext) {
-    const leftTerm = this.getLeftTerm(),
-          rightTerm = this.getRightTerm(),
-          leftTermNode = leftTerm.getNode(),
-          rightTermNode = rightTerm.getNode(),
+    const leftTermNode = this.leftTerm.getNode(),
+          rightTermNode = this.rightTerm.getNode(),
           nonTerminalNodeA = leftTermNode,  ///
           nonTerminalNodeB = rightTermNode, ///
-          equivalences = localContext.getEquivalences();
-
-    localContext = this;  ///
-
-    const nonTerminalNodeVerified = equalityNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, equivalences, localContext, () => {
+          nonTerminalNodeVerified = equalityNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/equivalence.js

@@ -102,7 +102,7 @@ export default class Equivalence {
       if (termNodeMatches) {
         return true;
       }
-    })
+    });
 
     return termNodesMatch;
   }

package/src/premise.js

@@ -2,7 +2,7 @@
 
 import LocalContext from "./context/local";
 import metaLevelNodesVerifier from "./verifier/nodes/metaLevel";
-import metaLevelToIntrinsicLevelNodesVerifier from "./verifier/nodes/metaLevelToIntrinsicLevel";
+import intrinsicLevelAgainstMetaLevelNodesVerifier from "./verifier/nodes/intrinsicLevelAgainstMetaLevel";
 
 import { match } from "./utilities/array";
 import { nodeAsString } from "./utilities/string";
@@ -48,7 +48,7 @@ export default class Premise {
                 fileContextA = fileContext, ///
                 localContextA = LocalContext.fromFileContext(fileContextA),
                 localContextB = statementLocalContext,  ///
-                nonTerminalNodeVerified = metaLevelToIntrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+                nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -70,7 +70,7 @@ export default class Premise {
           fileContextA = fileContext, ///
           localContextA = LocalContext.fromFileContext(fileContextA),
           localContextB = statementLocalContext,  ///
-          nonTerminalNodeVerified = metaLevelToIntrinsicLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+          nonTerminalNodeVerified = intrinsicLevelAgainstMetaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/ruleNames.js

@@ -1,14 +1,7 @@
 "use strict";
 
-export const TERM_RULE_NAME = "term";
-export const TYPE_RULE_NAME = "type";
 export const LABEL_RULE_NAME = "label";
-export const VARIABLE_RULE_NAME = "variable";
-export const ARGUMENT_RULE_NAME = "argument";
 export const SUBPROOF_RULE_NAME = "subproof";
-export const STATEMENT_RULE_NAME = "statement";
-export const METAVARIABLE_RULE_NAME = "metavariable";
-export const METASTATEMENT_RULE_NAME = "metastatement";
 export const RULE_SUBPROOF_RULE_NAME = "ruleSubproof";
 export const META_SUBPROOF_RULE_NAME = "metaSubproof";
 export const META_ARGUMENT_RULE_NAME = "metaArgument";

package/src/substitution/metastatementForMetavariable.js

@@ -45,7 +45,9 @@ export default class MetastatementForMetavariableSubstitution extends Substituti
   }
 
   static fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode) {
-    let metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableNode, metastatementNode);
+    let metastatementForMetavariableSubstitution;
+
+    metastatementForMetavariableSubstitution = new MetastatementForMetavariableSubstitution(metavariableNode, metastatementNode);
 
     const bracketedMetastatementChildNode = bracketedMetastatementChildNodeFromMetastatementNode(metastatementNode);
 

package/src/substitution/statementForMetavariable.js

@@ -1,12 +1,9 @@
 "use strict";
 
 import Substitution from "../substitution";
-
-import substitutionNodesVerifier from "../verifier/nodes/substitution";
 import TermForVariableSubstitution from "./termForVariable";
-import intrinsicLevelNodesVerifier from "../verifier/nodes/intrinsicLevel";
+import verifyStatementAgainstStatement from "../verify/statementAtainstStatement";
 
-import { push } from "../utilities/array";
 import { bracketedStatementChildNodeFromStatementNode } from "../utilities/proof";
 
 export default class StatementForMetavariableSubstitution extends Substitution {
@@ -33,37 +30,25 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   matchStatementNode(statementNode, substitutions, localContextA, localContextB) {
     let statementNodeMatches;
 
-    statementNodeMatches = this.matchStatementNodeEx(statementNode, substitutions, localContextA, localContextB);
+    const substitution = this.substitution, ///
+          statementNodeA = statementNode,  ///
+          statementNodeB = this.statementNode; ///
+
+    statementNodeMatches = matchStatementNode(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
 
     if (!statementNodeMatches) {
       const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
 
       if (bracketedStatementChildNode !== null) {
-        const statementNode = bracketedStatementChildNode; ///
+        const statementNodeA = bracketedStatementChildNode; ///
 
-        statementNodeMatches = this.matchStatementNodeEx(statementNode, substitutions, localContextA, localContextB);
+        statementNodeMatches = matchStatementNode(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
       }
     }
 
     return statementNodeMatches;
   }
 
-  matchStatementNodeEx(statementNode, substitutions, localContextA, localContextB) {
-    let statementNodeMatches;
-
-    if (this.substitution === null) {
-      statementNodeMatches = this.statementNode.match(statementNode);
-    } else {
-      const substitution = this.substitution, ///
-            statementNodeA = statementNode,  ///
-            statementNodeB = this.statementNode; ///
-
-      statementNodeMatches = matchStatementNode(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
-    }
-
-    return statementNodeMatches;
-  }
-
   matchMetavariableNode(metavariableNode) {
     const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
 
@@ -71,9 +56,11 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   }
 
   static fromMetavariableNodeAndStatementNode(metavariableNode, statementNode) {
+    let statementForMetavariableSubstitution;
+
     const substitution = null;
 
-    let statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode, substitution);
+    statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode, substitution);
 
     const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
 
@@ -86,8 +73,18 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return statementForMetavariableSubstitution;
   }
 
-  static fromMetavariableNodeStatementNodeAndSubstitution(metavariableNode, statementNode, substitution) {
-    let statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode, substitution);
+  static fromMetavariableNodeStatementNodeAndSubstitutionNode(metavariableNode, statementNode, substitutionNode) {
+    let statementForMetavariableSubstitution;
+
+    let substitution = null;
+
+    if (substitutionNode !== null) {
+      const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionNode(substitutionNode);
+
+      substitution = termForVariableSubstitution; ///
+    }
+
+    statementForMetavariableSubstitution = new StatementForMetavariableSubstitution(metavariableNode, statementNode, substitution);
 
     const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
 
@@ -101,56 +98,17 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   }
 }
 
-function transformSubstitutions(substitutionsA, substitutionsB) {
-  substitutionsA = substitutionsA.map((substitutionA) => {
-    const substitution = substitutionA,  ///
-          substitutions = substitutionsB,
-          termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionAndSubstitutions(substitution, substitutions);
-
-    substitutionA = termForVariableSubstitution; ///
+function matchStatementNode(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB) {
+  let statementNodeMatches;
 
-    return substitutionA;
-  });
+  if (substitution === null) {
+    statementNodeMatches = statementNodeB.match(statementNodeA);
+  } else {
+    const statementVerifiedAgainstStatement = verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
 
-  return substitutionsA;
-}
-
-export function matchStatementNode(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB) {
-  let statementNodeMatches = false;
-
-  const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionAndSubstitutions(substitution, substitutions),
-        intrinsic = termForVariableSubstitution.isIntrinsic(substitution);
-
-  let substitutionsA = []; ///
-
-  if (intrinsic) {
-    const substitutionA = termForVariableSubstitution;  ///
-
-    substitutionsA.push(substitutionA);
-  }
-
-  const nonTerminalNodeA = statementNodeA,  ///
-        nonTerminalNodeB = statementNodeB,  ///
-        nonTerminalNodeVerified = substitutionNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutionsA, localContextA, localContextB, () => {
-          const verifiedAhead = true;
-
-          return verifiedAhead;
-        });
-
-  if (nonTerminalNodeVerified) {
-    if (!intrinsic) {
-      const substitutionB = termForVariableSubstitution,  ///
-            substitutionsB = [
-              substitutionB
-            ];
-
-      substitutionsA = transformSubstitutions(substitutionsA, substitutionsB);
-
-      push(substitutions, substitutionsA);
-    }
-
-    statementNodeMatches = true;
+    statementNodeMatches = statementVerifiedAgainstStatement; ///
   }
 
   return statementNodeMatches;
-}
+
+}

package/src/substitution/termForVariable.js

@@ -23,14 +23,14 @@ export default class TermForVariableSubstitution extends Substitution {
     return this.termNode;
   }
 
-  isIntrinsic(substitution) {
+  isTransformed(substitution) {
     const termNod = substitution.getTermNode(),
           variableNode = substitution.getVariableNode(),
           termNodeMatches = this.termNode.match(termNod),
           variableNodeMatches = this.variableNode.match(variableNode),
-          intrinsic = ((!termNodeMatches) && (!variableNodeMatches));
+          transformed = ((!termNodeMatches) && (!variableNodeMatches));
 
-    return intrinsic;
+    return transformed;
   }
 
   matchTermNode(termNode) {

package/src/utilities/verifier.js

@@ -0,0 +1,46 @@
+"use strict";
+
+export function verifyNode(nodeQueryMaps, nonTerminalNode, ...remainingArguments) {
+  let nodeVerified;
+
+  nodeVerified = nodeQueryMaps.some((nodeQueryMap) => {
+    let nodeVerified = false;
+
+    const { nodeQuery, verifyNode } = nodeQueryMap;
+
+    const node = nodeQuery(nonTerminalNode);
+
+    if (node !== null) {
+      nodeVerified = verifyNode(node, ...remainingArguments);
+    }
+
+    if (nodeVerified) {
+      return true;
+    }
+  });
+
+  return nodeVerified;
+}
+
+export function verifyNodes(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
+  let nodesVerified;
+
+  nodesVerified = nodeQueryMaps.some((nodeQueryMap) => {
+    let nodesVerified = false;
+
+    const { nodeQueryA, nodeQueryB, verifyNodes } = nodeQueryMap;
+
+    const nodeA = nodeQueryA(nonTerminalNodeA),  ///
+          nodeB = nodeQueryB(nonTerminalNodeB);  ///
+
+    if ((nodeA !== null) && (nodeB !== null)) {
+      nodesVerified = verifyNodes(nodeA, nodeB, ...remainingArguments);
+    }
+
+    if (nodesVerified) {
+      return true;
+    }
+  });
+
+  return nodesVerified;
+}

package/src/verifier/node/metastatement.js

@@ -3,58 +3,65 @@
 import LocalContext from "../../context/local";
 import NodeVerifier from "../../verifier/node";
 
+import { nodeQuery } from "../../utilities/query";
+import { verifyNode } from "../../utilities/verifier";
 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";
+
+const termNodeQuery = nodeQuery("/term!"),
+      variableNodeQuery = nodeQuery("/variable!"),
+      metavariableNodeQuery = nodeQuery("/metavariable!");
 
 class MetastatementNodeVerifier extends NodeVerifier {
   verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
-    const ruleName = nonTerminalNode.getRuleName(); ///
-
-    switch (ruleName) {
-      case METAVARIABLE_RULE_NAME: {
-        const metavariableNode = nonTerminalNode, ///
-              standaloneMetavariableVerified = verifyStandaloneMetavariable(metavariableNode, localMetaContext, verifyAhead),
-              metavariableNodeVerified = standaloneMetavariableVerified;  ///
-
-        nonTerminalNodeVerified = metavariableNodeVerified; ///
-
-        break;
+    const nodeQueryMaps = [
+      {
+        nodeQuery: termNodeQuery,
+        verifyNode: this.verifyTermNode
+      },
+      {
+        nodeQuery: variableNodeQuery,
+        verifyNode: this.verifyVariableNode
+      },
+      {
+        nodeQuery: metavariableNodeQuery,
+        verifyNode: this.verifyMetavariableNode
       }
+    ];
 
-      case VARIABLE_RULE_NAME: {
-        const variableNode = nonTerminalNode, ///
-              localContext = LocalContext.fromLocalMetaContext(localMetaContext),
-              standaloneVariableVerified = verifyStandaloneVariable(variableNode, localContext, verifyAhead),
-              variableNodeVerified = standaloneVariableVerified;  ///
+    const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localMetaContext, verifyAhead);
 
-        nonTerminalNodeVerified = variableNodeVerified; ///
+    nonTerminalNodeVerified = nodeVerified ?
+                                true :
+                                  super.verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead);
 
-        break;
-      }
+    return nonTerminalNodeVerified;
+  }
 
-      case TERM_RULE_NAME: {
-        const termNode = nonTerminalNode, ///
-              localContext = LocalContext.fromLocalMetaContext(localMetaContext),
-              standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
-              termNodeVerified = standaloneTermVerified;  ///
+  verifyMetavariableNode(metavariableNode, localMetaContext, verifyAhead) {
+    const standaloneMetavariableVerified = verifyStandaloneMetavariable(metavariableNode, localMetaContext, verifyAhead),
+          metavariableNodeVerified = standaloneMetavariableVerified;  ///
 
-        nonTerminalNodeVerified = termNodeVerified; ///
+    return metavariableNodeVerified;
+  }
 
-        break;
-      }
+  verifyVariableNode(variableNode, localMetaContext, verifyAhead) {
+    const localContext = LocalContext.fromLocalMetaContext(localMetaContext),
+          standaloneVariableVerified = verifyStandaloneVariable(variableNode, localContext, verifyAhead),
+          variableNodeVerified = standaloneVariableVerified;  ///
 
-      default: {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, localMetaContext, verifyAhead);
+    return variableNodeVerified;
+  }
 
-        break;
-      }
-    }
+  verifyTermNode(termNode, localMetaContext, verifyAhead) {
+    const localContext = LocalContext.fromLocalMetaContext(localMetaContext),
+          standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
+          termNodeVerified = standaloneTermVerified;  ///
 
-    return nonTerminalNodeVerified;
+    return termNodeVerified;
   }
 }
 

package/src/verifier/node/statementAsCombinator.js

@@ -2,56 +2,63 @@
 
 import NodeVerifier from "../../verifier/node";
 
+import { nodeQuery } from "../../utilities/query";
+import { verifyNode } from "../../utilities/verifier";
 import { verifyStandaloneType } from "./../../verify/type";
 import { verifyStandaloneTerm } from "./../../verify/term";
 import { verifyStandaloneStatement } from "../../verify/statement";
-import { TYPE_RULE_NAME, TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../../ruleNames";
+
+const termNodeQuery = nodeQuery("/term!"),
+      typeNodeQuery = nodeQuery("/type!"),
+      statementNodeQuery = nodeQuery("/statement!");
 
 class StatementAsCombinatorNodeVerifier extends NodeVerifier {
   verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
-    const ruleName = nonTerminalNode.getRuleName();
-
-    switch (ruleName) {
-      case STATEMENT_RULE_NAME: {
-        const statementNode = nonTerminalNode, ///
-              standaloneStatementVerified = verifyStandaloneStatement(statementNode, localContext, verifyAhead),
-              statementNodeVerified = standaloneStatementVerified; ///
-
-        nonTerminalNodeVerified = statementNodeVerified; ///
-
-        break;
+    const nodeQueryMaps = [
+      {
+        nodeQuery: termNodeQuery,
+        verifyNode: this.verifyTermNode
+      },
+      {
+        nodeQuery: typeNodeQuery,
+        verifyNode: this.verifyTypeNode
+      },
+      {
+        nodeQuery: statementNodeQuery,
+        verifyNode: this.verifyStatementNode
       }
+    ];
 
-      case TERM_RULE_NAME: {
-        const termNode = nonTerminalNode, ///
-              standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
-              termNodeVerified = standaloneTermVerified;  ///
+    const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
 
-        nonTerminalNodeVerified = termNodeVerified; ///
+    nonTerminalNodeVerified = nodeVerified ?
+                                true :
+                                  super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
 
-        break;
-      }
+    return nonTerminalNodeVerified;
+  }
 
-      case TYPE_RULE_NAME: {
-        const typeNode = nonTerminalNode, ///
-              standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
-              typeNodeVerified = standaloneTypeVerified;  ///
+  verifyStatementNode(statementNode, localContext, verifyAhead) {
+    const standaloneStatementVerified = verifyStandaloneStatement(statementNode, localContext, verifyAhead),
+          statementNodeVerified = standaloneStatementVerified; ///
 
-        nonTerminalNodeVerified = typeNodeVerified; ///
+    return statementNodeVerified;
+  }
 
-        break;
-      }
+  verifyTermNode(termNode, localContext, verifyAhead) {
+    const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
+      termNodeVerified = standaloneTermVerified;  ///
 
-      default: {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead); ///
+    return termNodeVerified;
+  }
 
-        break;
-      }
-    }
+  verifyTypeNode(typeNode, localContext, verifyAhead) {
+    const standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
+      typeNodeVerified = standaloneTypeVerified;  ///
 
-    return nonTerminalNodeVerified;
+    return typeNodeVerified;
   }
 }