occam-verify-cli 0.0.869 → 0.0.871

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/name.js

@@ -3,8 +3,8 @@
 import { nodeQuery } from "../utilities/query";
 
 const typeTerminalNodeQuery = nodeQuery("/type/@type"),
-      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type"),
-      labelNameTerminalNodeQuery = nodeQuery("/label/@name");
+      nameTerminalNodeQuery = nodeQuery("/metavariable/@name"),
+      metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type");
 
 export function typeNameFromTypeNode(typeNode) {
   let typeName = null;
@@ -19,12 +19,12 @@ export function typeNameFromTypeNode(typeNode) {
   return typeName;
 }
 
-export function labelNameFromLabelNode(labelNode) {
-  const labelNameTerminalNode = labelNameTerminalNodeQuery(labelNode),
-        labelNameTerminalNodeContent = labelNameTerminalNode.getContent(),
-        labelName = labelNameTerminalNodeContent; ///
+export function nameFromMetavariableNode(metavariableNode) {
+  const nameTerminalNode = nameTerminalNodeQuery(metavariableNode),
+        nameTerminalNodeContent = nameTerminalNode.getContent(),
+        name = nameTerminalNodeContent; ///
 
-  return labelName;
+  return name;
 }
 
 export function metaTypeNameFromMetaTypeNode(metaTypeNode) {

package/src/utilities/node.js

@@ -4,12 +4,12 @@ import { parsersUtilities } from "occam-custom-grammars";
 
 import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
-import { LABEL_RULE_NAME,
+import { METAVARIABLE_RULE_NAME,
          VARIABLE_DECLARATION_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
          CONSTRUCTOR_DECLARATION_RULE_NAME,
          UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
-import { labelTokensFromLabelString,
+import { metavariableTokensFromMetavariableString,
          variableDeclarationTokensFromVariableString,
          unqualifiedStatementTokensFromStatementString,
          unqualifiedMetastatementTokensFromMetastatementString } from "../utilities/tokens";
@@ -24,13 +24,6 @@ const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
       statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
       metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
-export function labelNodeFromLabelString(labelString, lexer, parser) {
-  const labelTokens = labelTokensFromLabelString(labelString, lexer),
-        labelNode = labelNodeFromLabelTokens(labelTokens, parser);
-
-  return labelNode;
-}
-
 export function variableNodeFromVariableString(variableString, lexer, parser) {
   const variableTDeclarationTokens = variableDeclarationTokensFromVariableString(variableString, lexer),
         variableNode = variableNodeFromVariableVariableTDeclarationTokens(variableTDeclarationTokens, parser);
@@ -45,6 +38,13 @@ export function statementNodeFromStatementString(statementString, lexer, parser)
   return statementNode;
 }
 
+export function metavariableNodeFromMetavariableString(metavariableString, lexer, parser) {
+  const metavariableTokens = metavariableTokensFromMetavariableString(metavariableString, lexer),
+        metavariableNode = metavariableNodeFromMetavariableTokens(metavariableTokens, parser);
+
+  return metavariableNode;
+}
+
 export function metastatementNodeFromMetastatementString(metastatementString, lexer, parser) {
   const unqualifiedMetastatementTokens = unqualifiedMetastatementTokensFromMetastatementString(metastatementString, lexer),
         metastatementNode = metastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser);
@@ -80,11 +80,11 @@ export function metastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedM
   return metastatementNode;
 }
 
-export function labelNodeFromLabelTokens(labelTokens, parser) {
-  const ruleName = LABEL_RULE_NAME,
-        labelNode = nodeFromTokensRuleNameAndParser(labelTokens, ruleName, parser);
+export function metavariableNodeFromMetavariableTokens(metavariableTokens, parser) {
+  const ruleName = METAVARIABLE_RULE_NAME,
+        metavariableNode = nodeFromTokensRuleNameAndParser(metavariableTokens, ruleName, parser);
 
-  return labelNode;
+  return metavariableNode;
 }
 
 export function variableDeclarationNodeFromVariableTDeclarationTokens(variableTDeclarationTokens, parser) {

package/src/utilities/query.js

@@ -6,11 +6,9 @@ export function nodeQuery(expression) {
   const query = Query.fromExpression(expression);
 
   return function(node) {
-    if (node !== null) {
-      const nodes = query.execute(node);
+    const nodes = query.execute(node);
 
-      node = nodes.shift() || null; ///
-    }
+    node = nodes.shift() || null; ///
 
     return node;
   };
@@ -20,11 +18,7 @@ export function nodesQuery(expression) {
   const query = Query.fromExpression(expression);
 
   return function(node) {
-    let nodes = null;
-
-    if (node !== null) {
-      nodes = query.execute(node);
-    }
+    const nodes = query.execute(node);
 
     return nodes;
   };

package/src/utilities/tokens.js

@@ -9,11 +9,11 @@ const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities;
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
 
-export function labelTokensFromLabelString(labelString, lexer) {
-  const labelContent = `${labelString}`,
-        labelTokens = tokensFromContentAndLexer(labelContent, lexer);
+export function metavariableTokensFromMetavariableString(metavariableString, lexer) {
+  const metavariableContent = `${metavariableString}`,
+        metavariableTokens = tokensFromContentAndLexer(metavariableContent, lexer);
 
-  return labelTokens;
+  return metavariableTokens;
 }
 
 export function constructorDeclarationTokensFromTermString(termString, lexer) {

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;
   }
 }
 

package/src/verifier/node/termAsConstructor.js

@@ -2,45 +2,50 @@
 
 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 { TERM_RULE_NAME, TYPE_RULE_NAME } from "../../ruleNames";
+
+const termNodeQuery = nodeQuery("/term!"),
+      typeNodeQuery = nodeQuery("/type!");
 
 class TermAsConstructorNodeVerifier extends NodeVerifier {
   verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
-    const ruleName = nonTerminalNode.getRuleName();
-
-    switch (ruleName) {
-      case TERM_RULE_NAME: {
-        const termNode = nonTerminalNode, ///
-              standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
-              termNodeVerified = standaloneTermVerified;  ///
-
-        nonTerminalNodeVerified = termNodeVerified; ///
-
-        break;
+    const nodeQueryMaps = [
+      {
+        nodeQuery: termNodeQuery,
+        verifyNode: this.verifyTermNode
+      },
+      {
+        nodeQuery: typeNodeQuery,
+        verifyNode: this.verifyTypeNode
       }
+    ];
 
-      case TYPE_RULE_NAME: {
-        const typeNode = nonTerminalNode, ///
-              standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
-              typeNodeVerified = standaloneTypeVerified;  ///
+    const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
 
-        nonTerminalNodeVerified = typeNodeVerified; ///
+    nonTerminalNodeVerified = nodeVerified ?
+                                true :
+                                  super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
 
-        break;
-      }
+    return nonTerminalNodeVerified;
+  }
 
-      default: {
-        nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead);
+  verifyTermNode(termNode, localContext, verifyAhead) {
+    const standaloneTermVerified = verifyStandaloneTerm(termNode, localContext, verifyAhead),
+          termNodeVerified = standaloneTermVerified;  ///
 
-        break;
-      }
-    }
+    return termNodeVerified;
+  }
 
-    return nonTerminalNodeVerified;
+  verifyTypeNode(typeNode, localContext, verifyAhead) {
+    const standaloneTypeVerified = verifyStandaloneType(typeNode, localContext, verifyAhead),
+          typeNodeVerified = standaloneTypeVerified;  ///
+
+    return typeNodeVerified;
   }
 }