occam-verify-cli 1.0.220 → 1.0.224

package/src/utilities/unification.js

@@ -1,28 +1,14 @@
 "use string";
 
 import LocalContext from "../context/local";
-import equalityUnifier from "../unifier/equality";
 import metaLevelUnifier from "../unifier/metaLevel";
 import metavariableUnifier from "../unifier/metavariable";
 import intrinsicLevelUnifier from "../unifier/intrinsicLevel";
 import termWithConstructorUnifier from "../unifier/termWithConstructor";
 import statementWithCombinatorUnifier from "../unifier/statementWithCombinator";
 
-export function unifyEquality(equality, context) {
-  let equalityUnified;
-
-  const leftTerm = equality.getLeftTerm(),
-        rightTerm = equality.getRightTerm(),
-        leftTermNode = leftTerm.getNode(),
-        rightTermNode = rightTerm.getNode();
-
-  equalityUnified = equalityUnifier.unify(leftTermNode, rightTermNode, context);
-
-  return equalityUnified;
-}
-
 export function unifyStatement(generalStatement, specificStatement, substitutions, generalContext, specificContext) {
-  let statementUnified;
+  let statementUnifies = false;
 
   const generalStatementNode = generalStatement.getNode(),
         specificStatementNode = specificStatement.getNode(),
@@ -35,15 +21,17 @@ export function unifyStatement(generalStatement, specificStatement, substitution
 
   const generalNonTerminalNode = generalStatementNode, ///
         specificNonTerminalNode = specificStatementNode,  ///
-        unifiedAtMetaLevel = metaLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
+        unifiesAtMetaLevel = metaLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
 
-  statementUnified = unifiedAtMetaLevel; ///
+  if (unifiesAtMetaLevel) {
+    statementUnifies = true;
+  }
 
-  return statementUnified;
+  return statementUnifies;
 }
 
 export function unifySubstitution(generalSubstitution, specificSubstitution, substitutions, generalContext, specificContext) {
-  let substitutionUnified;
+  let substitutionUnifies = false;
 
   const generalSubstitutionNode = generalSubstitution.getNode(),
         specificSubstitutionNode = specificSubstitution.getNode(),
@@ -56,15 +44,17 @@ export function unifySubstitution(generalSubstitution, specificSubstitution, sub
 
   const generalNonTerminalNode = generalSubstitutionNode, ///
         specificNonTerminalNode = specificSubstitutionNode,
-        unifiedAtMetaLevel = metaLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
+        unifiesAtMetaLevel = metaLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
 
-  substitutionUnified = unifiedAtMetaLevel; ///
+  if (unifiesAtMetaLevel) {
+    substitutionUnifies = true;
+  }
 
-  return substitutionUnified;
+  return substitutionUnifies;
 }
 
 export function unifyMetavariable(generalMetavariable, specificMetavariable, generalContext, specificContext) {
-  let metavariableUnified;
+  let metavariableUnifies;
 
   const generalMetavariableNode = generalMetavariable.getNode(),
         specificMetavariableNode = specificMetavariable.getNode(),
@@ -75,25 +65,25 @@ export function unifyMetavariable(generalMetavariable, specificMetavariable, gen
 
   specificContext = contextFromTokens(specificMetavariableTokens, specificContext); ///
 
-  metavariableUnified = metavariableUnifier.unify(generalMetavariableNode, specificMetavariableNode, generalContext, specificContext);
+  metavariableUnifies = metavariableUnifier.unify(generalMetavariableNode, specificMetavariableNode, generalContext, specificContext);
 
-  return metavariableUnified;
+  return metavariableUnifies;
 }
 
 export function unifyTermWithConstructor(term, constructor, context) {
-  let termUnifiedWithConstructor;
+  let termUnifiesWithConstructor;
 
   const termNode = term.getNode(),
         constructorTerm = constructor.getTerm(),
         constructorTermNode = constructorTerm.getNode();
 
-  termUnifiedWithConstructor = termWithConstructorUnifier.unify(constructorTermNode, termNode, context);
+  termUnifiesWithConstructor = termWithConstructorUnifier.unify(constructorTermNode, termNode, context);
 
-  return termUnifiedWithConstructor;
+  return termUnifiesWithConstructor;
 }
 
 export function unifyStatementIntrinsically(generalStatement, specificStatement, substitutions, generalContext, specificContext) {
-  let metavariableUnifiedIntrinsically;
+  let metavariableUnifiesIntrinsically;
 
   const generalStatementNode = generalStatement.getNode(),
         specificStatementNode = specificStatement.getNode(),
@@ -107,13 +97,13 @@ export function unifyStatementIntrinsically(generalStatement, specificStatement,
   const generalNonTerminalNode = generalStatementNode, ///
         specificNonTerminalNode = specificStatementNode; ///
 
-  metavariableUnifiedIntrinsically = intrinsicLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
+  metavariableUnifiesIntrinsically = intrinsicLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
 
-  return metavariableUnifiedIntrinsically;
+  return metavariableUnifiesIntrinsically;
 }
 
 export function unifyStatementWithCombinator(statement, combinator, assignments, stated, context) {
-  let statementUnifiedWithCombinator;
+  let statementUnifiesWithCombinator;
 
   const statementNode = statement.getNode(),
         statementTokens = statement.getTokens(),
@@ -128,13 +118,13 @@ export function unifyStatementWithCombinator(statement, combinator, assignments,
 
   specificContext = contextFromTokens(statementTokens, specificContext);  ///
 
-  statementUnifiedWithCombinator = statementWithCombinatorUnifier.unify(combinatorStatementNode, statementNode, assignments, stated, generalContext, specificContext);
+  statementUnifiesWithCombinator = statementWithCombinatorUnifier.unify(combinatorStatementNode, statementNode, assignments, stated, generalContext, specificContext);
 
-  return statementUnifiedWithCombinator;
+  return statementUnifiesWithCombinator;
 }
 
 export function unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, substitutions, generalContext, specificContext) {
-  let metavariableUnifiedIntrinsically;
+  let metavariableUnifiesIntrinsically;
 
   const generalMetavariableNode = generalMetavariable.getNode(),
         specificMetavariableNode = specificMetavariable.getNode(),
@@ -148,9 +138,9 @@ export function unifyMetavariableIntrinsically(generalMetavariable, specificMeta
   const generalNonTerminalNode = generalMetavariableNode, ///
         specificNonTerminalNode = specificMetavariableNode; ///
 
-  metavariableUnifiedIntrinsically = intrinsicLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
+  metavariableUnifiesIntrinsically = intrinsicLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
 
-  return metavariableUnifiedIntrinsically;
+  return metavariableUnifiesIntrinsically;
 }
 
 function contextFromTokens(tokens, context) {

package/src/verifier/combinator.js

@@ -12,15 +12,15 @@ const termNodeQuery = nodeQuery("/term"),
 
 class CombinatorVerifier extends Verifier {
   verifyStatement(statementNode, fileContext) {
-    let statementVerifiedAsCombinator;
+    let statementVerifiesAsCombinator;
 
     const nonTerminalNode = statementNode, ///
           childNodes = nonTerminalNode.getChildNodes(),
-          childNodesVerified = this.verifyChildNodes(childNodes, fileContext);
+          childNodesVerify = this.verifyChildNodes(childNodes, fileContext);
 
-    statementVerifiedAsCombinator = childNodesVerified;  ///
+    statementVerifiesAsCombinator = childNodesVerify;  ///
 
-    return statementVerifiedAsCombinator;
+    return statementVerifiesAsCombinator;
   }
 
   static maps = [
@@ -33,9 +33,9 @@ class CombinatorVerifier extends Verifier {
               statement = Statement.fromStatementNode(statementNode, context),
               assignments = null,
               stated = false,
-              statementVerified = statement.verify(assignments, stated, context);
+              statementVerifies = statement.verify(assignments, stated, context);
 
-        return statementVerified;
+        return statementVerifies;
       }
     },
     {
@@ -45,28 +45,28 @@ class CombinatorVerifier extends Verifier {
               localContext = LocalContext.fromFileContext(fileContext),
               context = localContext, ///
               term = Term.fromTermNode(termNode, context),
-              termVerified = term.verify(context, () => {
-                const verifiedAhead = true;
+              termVerifies = term.verify(context, () => {
+                const verifiesAhead = true;
 
-                return verifiedAhead;
+                return verifiesAhead;
               });
 
-        return termVerified;
+        return termVerifies;
       }
     },
     {
       nodeQuery: typeNodeQuery,
       verify: (typeNode, fileContext) => {
-        let typeVerified = false;
+        let typeVerifies = false;
 
         const typeName = typeNode.getTypeName(),
               typePresent = fileContext.isTypePresentByTypeName(typeName);
 
         if (typePresent) {
-          typeVerified = true;
+          typeVerifies = true;
         }
 
-        return typeVerified;
+        return typeVerifies;
       }
     }
   ];

package/src/verifier/constructor.js

@@ -16,23 +16,23 @@ const termNodeQuery = nodeQuery("/term"),
 
 class ConstructorVerifier extends Verifier {
   verifyTerm(termNode, fileContext) {
-    let termVerifiedAsConstructor;
+    let termVerifiesAsConstructor;
 
     const nonTerminalNode = termNode, ///
           childNodes = nonTerminalNode.getChildNodes(),
-          childNodesVerified = this.verifyChildNodes(childNodes, fileContext, () => {
-            const verifiedAhead = true;
+          childNodesVerify = this.verifyChildNodes(childNodes, fileContext, () => {
+            const verifiesAhead = true;
 
-            return verifiedAhead;
+            return verifiesAhead;
           });
 
-    termVerifiedAsConstructor = childNodesVerified;  ///
+    termVerifiesAsConstructor = childNodesVerify;  ///
 
-    return termVerifiedAsConstructor;
+    return termVerifiesAsConstructor;
   }
 
   verifyTerminalNode(terminalNode, ...remainingArguments) {
-    let terminalNodeVerified;
+    let terminalNodeVerifies;
 
     const type = terminalNode.getType();
 
@@ -45,14 +45,14 @@ class ConstructorVerifier extends Verifier {
 
       fileContext.debug(`The '${typeString}' type is present in the constructor but has not been declared beforehand.`);
 
-      terminalNodeVerified = false;
+      terminalNodeVerifies = false;
 
       remainingArguments.push(verifyAhead);
     } else {
-      terminalNodeVerified = super.verifyTerminalNode(terminalNode, ...remainingArguments);
+      terminalNodeVerifies = super.verifyTerminalNode(terminalNode, ...remainingArguments);
     }
 
-    return terminalNodeVerified;
+    return terminalNodeVerifies;
   }
 
   static maps = [
@@ -63,32 +63,32 @@ class ConstructorVerifier extends Verifier {
               localContext = LocalContext.fromFileContext(fileContext),
               context = localContext, ///
               term = Term.fromTermNode(termNode, context),
-              termVerified = term.verify(localContext, verifyAhead);
+              termVerifies = term.verify(localContext, verifyAhead);
 
-        return termVerified;
+        return termVerifies;
       }
     },
     {
       nodeQuery: typeNodeQuery,
       verify: (typeNode, fileContext, verifyAhead) => {
-        let typeVerified;
+        let typeVerifies;
 
         const typeName = typeNode.getTypeName(),
               typePresent = fileContext.isTypePresentByTypeName(typeName);
 
         if (typePresent) {
-          const verifiedAhead = verifyAhead();
+          const verifiesAhead = verifyAhead();
 
-          typeVerified = verifiedAhead; ///
+          typeVerifies = verifiesAhead; ///
         } else {
           const typeString = typeName;  ///
 
           fileContext.debug(`The '${typeString}' type is not present.`);
 
-          typeVerified = false;
+          typeVerifies = false;
         }
 
-        return typeVerified;
+        return typeVerifies;
       }
     }
   ];

package/src/verifier/topLevel.js

@@ -13,23 +13,23 @@ const errorNodeQuery = nodeQuery("/error"),
       metaLemmaNodeQuery = nodeQuery("/metaLemma"),
       conjectureNodeQuery = nodeQuery("/conjecture"),
       metatheoremNodeQuery = nodeQuery("/metatheorem"),
-      typeDeclarationNodeQuery = nodeQuery("/typeDeclaration"),
       variableDeclarationNodeQuery = nodeQuery("/variableDeclaration"),
       combinatorDeclarationNodeQuery = nodeQuery("/combinatorDeclaration"),
+      simpleTypeDeclarationNodeQuery = nodeQuery("/simpleTypeDeclaration"),
       constructorDeclarationNodeQuery = nodeQuery("/constructorDeclaration"),
       complexTypeDeclarationNodeQuery = nodeQuery("/complexTypeDeclaration"),
       metavariableDeclarationNodeQuery = nodeQuery("/metavariableDeclaration");
 
 class TopLevelVerifier extends Verifier {
   verify(node, fileContext) {
-    let verifiedAtTopLevel;
+    let verifiesAtTopLevel;
 
     const nonTerminalNode = node, ///
-          nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNode, fileContext);
+          nonTerminalNodeVerifies = this.verifyNonTerminalNode(nonTerminalNode, fileContext);
 
-    verifiedAtTopLevel = nonTerminalNodeVerified;  ///
+    verifiesAtTopLevel = nonTerminalNodeVerifies;  ///
 
-    return verifiedAtTopLevel;
+    return verifiesAtTopLevel;
   }
 
   static maps = [
@@ -38,9 +38,9 @@ class TopLevelVerifier extends Verifier {
       verify: (errorNode, fileContext) => {
         const { Error } = dom,
               error = Error.fromErrorNode(errorNode, fileContext),
-              errorVerified = error.verify();
+              errorVerifies = error.verify();
 
-        return errorVerified;
+        return errorVerifies;
       }
     },
     {
@@ -48,9 +48,9 @@ class TopLevelVerifier extends Verifier {
       verify: (ruleNode, fileContext) => {
         const { Rule } = dom,
               rule = Rule.fromRuleNode(ruleNode, fileContext),
-              ruleVerified = rule.verify();
+              ruleVerifies = rule.verify();
 
-        return ruleVerified;
+        return ruleVerifies;
       }
     },
     {
@@ -58,9 +58,9 @@ class TopLevelVerifier extends Verifier {
       verify: (axiomNode, fileContext) => {
         const { Axiom } = dom,
               axiom = Axiom.fromAxiomNode(axiomNode, fileContext),
-              axiomVerified = axiom.verify();
+              axiomVerifies = axiom.verify();
 
-        return axiomVerified;
+        return axiomVerifies;
       }
     },
     {
@@ -68,9 +68,9 @@ class TopLevelVerifier extends Verifier {
       verify: (lemmaNode, fileContext) => {
         const { Lemma } = dom,
               lemma = Lemma.fromLemmaNode(lemmaNode, fileContext),
-              lemmaVerified = lemma.verify();
+              lemmaVerifies = lemma.verify();
 
-        return lemmaVerified;
+        return lemmaVerifies;
       }
     },
     {
@@ -78,9 +78,9 @@ class TopLevelVerifier extends Verifier {
       verify: (theoremNode, fileContext) => {
         const { Theorem } = dom,
               theorem = Theorem.fromTheoremNode(theoremNode, fileContext),
-              theoremVerified = theorem.verify();
+              theoremVerifies = theorem.verify();
 
-        return theoremVerified;
+        return theoremVerifies;
       }
     },
     {
@@ -88,9 +88,9 @@ class TopLevelVerifier extends Verifier {
       verify: (metaLemmaNode, fileContext) => {
         const { MetaLemma } = dom,
               metaLemma = MetaLemma.fromMetaLemmaNode(metaLemmaNode, fileContext),
-              metaLemmaVerified = metaLemma.verify();
+              metaLemmaVerifies = metaLemma.verify();
 
-        return metaLemmaVerified;
+        return metaLemmaVerifies;
       }
     },
     {
@@ -98,9 +98,9 @@ class TopLevelVerifier extends Verifier {
       verify: (conjectureNode, fileContext) => {
         const { Conjecture } = dom,
               conjecture = Conjecture.fromConjectureNode(conjectureNode, fileContext),
-              conjectureVerified = conjecture.verify();
+              conjectureVerifies = conjecture.verify();
 
-        return conjectureVerified;
+        return conjectureVerifies;
       }
     },
     {
@@ -108,19 +108,9 @@ class TopLevelVerifier extends Verifier {
       verify: (metatheoremNode, fileContext) => {
         const { Metatheorem } = dom,
               metatheorem = Metatheorem.fromMetatheoremNode(metatheoremNode, fileContext),
-              metatheoremVerified = metatheorem.verify();
+              metatheoremVerifies = metatheorem.verify();
 
-        return metatheoremVerified;
-      }
-    },
-    {
-      nodeQuery: typeDeclarationNodeQuery,
-      verify: (typeDeclarationNode, fileContext) => {
-        const { TypeDeclaration } = dom,
-              typeDeclaration = TypeDeclaration.fromTypeDeclarationNode(typeDeclarationNode, fileContext),
-              typeDeclarationVerified = typeDeclaration.verify();
-
-        return typeDeclarationVerified;
+        return metatheoremVerifies;
       }
     },
     {
@@ -128,9 +118,19 @@ class TopLevelVerifier extends Verifier {
       verify: (variableDeclarationNode, fileContext) => {
         const { VariableDeclaration } = dom,
               variableDeclaration = VariableDeclaration.fromVariableDeclarationNode(variableDeclarationNode, fileContext),
-              variableDeclarationVerified = variableDeclaration.verify();
+              variableDeclarationVerifies = variableDeclaration.verify();
+
+        return variableDeclarationVerifies;
+      }
+    },
+    {
+      nodeQuery: simpleTypeDeclarationNodeQuery,
+      verify: (simpleTypeDeclarationNode, fileContext) => {
+        const { SimpleTypeDeclaration } = dom,
+              simpleTypeDeclaration = SimpleTypeDeclaration.fromSimpleTypeDeclarationNode(simpleTypeDeclarationNode, fileContext),
+              simpleTypeDeclarationVerifies = simpleTypeDeclaration.verify();
 
-        return variableDeclarationVerified;
+        return simpleTypeDeclarationVerifies;
       }
     },
     {
@@ -138,9 +138,9 @@ class TopLevelVerifier extends Verifier {
       verify: (combinatorDeclarationNode, fileContext) => {
         const { CombinatorDeclaration } = dom,
               combinatorDeclaration = CombinatorDeclaration.fromCombinatorDeclarationNode(combinatorDeclarationNode, fileContext),
-              combinatorDeclarationVerified = combinatorDeclaration.verify();
+              combinatorDeclarationVerifies = combinatorDeclaration.verify();
 
-        return combinatorDeclarationVerified;
+        return combinatorDeclarationVerifies;
       }
     },
     {
@@ -148,9 +148,9 @@ class TopLevelVerifier extends Verifier {
       verify: (constructorDeclarationNode, fileContext) => {
         const { ConstructorDeclaration } = dom,
               constructorDeclaration = ConstructorDeclaration.fromConstructorDeclarationNode(constructorDeclarationNode, fileContext),
-              constructorDeclarationVerified = constructorDeclaration.verify();
+              constructorDeclarationVerifies = constructorDeclaration.verify();
 
-        return constructorDeclarationVerified;
+        return constructorDeclarationVerifies;
       }
     },
     {
@@ -158,9 +158,9 @@ class TopLevelVerifier extends Verifier {
       verify: (complexTypeDeclarationNode, fileContext) => {
         const { ComplexTypeDeclaration } = dom,
               complexTypeDeclaration = ComplexTypeDeclaration.fromComplexTypeDeclarationNode(complexTypeDeclarationNode, fileContext),
-              complexTypeDeclarationVerified = complexTypeDeclaration.verify();
+              complexTypeDeclarationVerifies = complexTypeDeclaration.verify();
 
-        return complexTypeDeclarationVerified;
+        return complexTypeDeclarationVerifies;
       }
     },
     {
@@ -168,9 +168,9 @@ class TopLevelVerifier extends Verifier {
       verify: (metavariableDeclarationNode, fileContext) => {
         const { MetavariableDeclaration } = dom,
               metavariableDeclaration = MetavariableDeclaration.fromMetavariableDeclarationNode(metavariableDeclarationNode, fileContext),
-              metavariableDeclarationVerified = metavariableDeclaration.verify();
+              metavariableDeclarationVerifies = metavariableDeclaration.verify();
 
-        return metavariableDeclarationVerified;
+        return metavariableDeclarationVerifies;
       }
     }
   ];

package/src/verifier.js

@@ -7,33 +7,33 @@ const nonTerminalNodeQuery = nodeQuery("/*");
 
 export default class Verifier {
   verify(node, ...remainingArguments) {
-    let verified;
+    let verifies;
 
-    const nodeVerified = this.verifyNode(node, ...remainingArguments);
+    const nodeVerifies = this.verifyNode(node, ...remainingArguments);
 
-    verified = nodeVerified;  ///
+    verifies = nodeVerifies;  ///
 
-    return verified;
+    return verifies;
   }
 
   verifyNode(node, ...remainingArguments) {
-    let nodeVerified;
+    let nodeVerifies;
 
     const nodeTerminalNode = node.isTerminalNode();
 
     if (nodeTerminalNode) {
       const terminalNode = node,  ///
-            terminalNodeVerified = this.verifyTerminalNode(terminalNode, ...remainingArguments);
+            terminalNodeVerifies = this.verifyTerminalNode(terminalNode, ...remainingArguments);
 
-      nodeVerified = terminalNodeVerified;  ///
+      nodeVerifies = terminalNodeVerifies;  ///
     } else {
       const nonTerminalNode = node,  ///
-            nonTerminalNodeVerified = this.verifyNonTerminalNode(nonTerminalNode, ...remainingArguments);
+            nonTerminalNodeVerifies = this.verifyNonTerminalNode(nonTerminalNode, ...remainingArguments);
 
-      nodeVerified = nonTerminalNodeVerified; ///
+      nodeVerifies = nonTerminalNodeVerifies; ///
     }
 
-    return nodeVerified;
+    return nodeVerifies;
   }
 
   verifyChildNodes(childNodes, ...remainingArguments) {
@@ -49,9 +49,9 @@ export default class Verifier {
     } else {
       childNodesVerify = childNodes.every((childNode) => {
         const node = childNode, ///
-              nodeVerified = this.verifyNode(node, ...remainingArguments);
+              nodeVerifies = this.verifyNode(node, ...remainingArguments);
 
-        if (nodeVerified) {
+        if (nodeVerifies) {
           return true;
         }
       });
@@ -61,26 +61,26 @@ export default class Verifier {
   }
 
   verifyTerminalNode(terminalNode, ...remainingArguments) {
-    let terminalNodeVerified;
+    let terminalNodeVerifies;
 
     const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
 
     if (lastRemainingArgumentFunction) {
       const verifyAhead = remainingArguments.pop(), ///
-            verifiedAhead = verifyAhead();
+            verifiesAhead = verifyAhead();
 
-      terminalNodeVerified = verifiedAhead; ///
+      terminalNodeVerifies = verifiesAhead; ///
 
       remainingArguments.push(verifyAhead);
     } else {
-      terminalNodeVerified = true;
+      terminalNodeVerifies = true;
     }
 
-    return terminalNodeVerified;
+    return terminalNodeVerifies;
   }
 
   verifyNonTerminalNode(nonTerminalNode, ...remainingArguments) {
-    let nonTerminalNodeVerified;
+    let nonTerminalNodeVerifies;
 
     let { maps } = this.constructor;
 
@@ -89,19 +89,19 @@ export default class Verifier {
       {
         nodeQuery: nonTerminalNodeQuery,
         verify: (node, ...remainingArguments) => {
-          let nonTerminalNodeVerified;
+          let nonTerminalNodeVerifies;
 
           const childNodes = nonTerminalNode.getChildNodes(), ///
                 childNodesVerify = this.verifyChildNodes(childNodes, ...remainingArguments);
 
-          nonTerminalNodeVerified = childNodesVerify; ///
+          nonTerminalNodeVerifies = childNodesVerify; ///
 
-          return nonTerminalNodeVerified;
+          return nonTerminalNodeVerifies;
         }
       }
     ]
 
-    let nodeVerified = false;
+    let nodeVerifies = false;
 
     maps.some((map) => {
       const { nodeQuery, verify } = map;
@@ -109,15 +109,15 @@ export default class Verifier {
       const node = nodeQuery(nonTerminalNode);
 
       if (node !== null) {
-        nodeVerified = verify(node, ...remainingArguments);
+        nodeVerifies = verify(node, ...remainingArguments);
 
         return true;
       }
     });
 
-    nonTerminalNodeVerified = nodeVerified; ///
+    nonTerminalNodeVerifies = nodeVerifies; ///
 
-    return nonTerminalNodeVerified;
+    return nonTerminalNodeVerifies;
   }
 
   verifyChildNodesAhead(index, childNodes, ...remainingArguments) {
@@ -127,13 +127,13 @@ export default class Verifier {
           childNodesLength = childNodes.length;
 
     if (index === childNodesLength) {
-      const verifiedAhead = verifyAhead();
+      const verifiesAhead = verifyAhead();
 
-      childNodesVerify = verifiedAhead; ///
+      childNodesVerify = verifiesAhead; ///
     } else {
       const childNode = childNodes[index],
             node = childNode, ///
-            nodeVerified = this.verifyNode(node, ...remainingArguments, () => {
+            nodeVerifies = this.verifyNode(node, ...remainingArguments, () => {
               remainingArguments.push(verifyAhead);
 
               const aheadIndex = index + 1,
@@ -142,7 +142,7 @@ export default class Verifier {
               return childNodesVerifyAhead;
             });
 
-      childNodesVerify = nodeVerified;  ///
+      childNodesVerify = nodeVerifies;  ///
     }
 
     return childNodesVerify;