occam-verify-cli 0.0.909 → 0.0.911

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.909",
+  "version": "0.0.911",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -12,7 +12,7 @@
   "dependencies": {
     "argumentative": "^2.0.28",
     "necessary": "^14.0.1",
-    "occam-custom-grammars": "^5.0.809",
+    "occam-custom-grammars": "^5.0.811",
     "occam-entities": "^1.0.146",
     "occam-file-system": "^6.0.187",
     "occam-grammar-utilities": "^8.0.207",

package/src/axiomLemmaTheoremConjecture.js

@@ -48,7 +48,7 @@ export default class AxiomLemmaTheoremConjecture {
   }
 
   matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.labels.some((label) => {
+    const matchesMetavariableNode = this.labels.some((label) => {
       const labelMatchesMetavariableNode = label.matchMetavariableNode(metavariableNode);
 
       if (labelMatchesMetavariableNode) {
@@ -56,7 +56,7 @@ export default class AxiomLemmaTheoremConjecture {
       }
     });
 
-    return metavariableNodeMatches;
+    return matchesMetavariableNode;
   }
 
   toJSON(tokens) {
@@ -149,17 +149,17 @@ function matchSupposition(supposition, proofStep, substitutions, localContext, s
   const statementNode = proofStep.getStatementNode();
 
   if (statementNode !== null) {
-    const statementMatches = supposition.matchStatementNode(statementNode, substitutions, localContext, statementLocalContext);
+    const suppositionMatchesStatementNode = supposition.matchStatementNode(statementNode, substitutions, localContext, statementLocalContext);
 
-    suppositionMatches = statementMatches;  ///
+    suppositionMatches = suppositionMatchesStatementNode;  ///
   }
 
   return suppositionMatches;
 }
 
 function matchConsequent(consequent, statementNode, substitutions, localContext, statementLocalContext) {
-  const nonTerminalNodeMatches = consequent.matchStatementNode(statementNode, substitutions, localContext, statementLocalContext),
-        consequentMatches = nonTerminalNodeMatches; ///
+  const consequentMatchesStatementNode = consequent.matchStatementNode(statementNode, substitutions, localContext, statementLocalContext),
+        consequentMatches = consequentMatchesStatementNode; ///
 
   return consequentMatches;
 }

package/src/conclusion.js

@@ -22,7 +22,7 @@ export default class Conclusion {
   }
 
   matchStatementNode(statementNode, substitutions, localContext, statementLocalContext) {
-    let statementNodeMatches = false;
+    let matchesStatementNose = false;
 
     if (this.metastatementNode !== null) {
       const nonTerminalNodeA = this.metastatementNode,  ///
@@ -35,14 +35,14 @@ export default class Conclusion {
               return verifiedAhead;
             });
 
-      statementNodeMatches = nonTerminalNodeVerified; ///
+      matchesStatementNose = nonTerminalNodeVerified; ///
     }
 
-    return statementNodeMatches;
+    return matchesStatementNose;
   }
 
   matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
-    let metastatementNodeMatches = false;
+    let matchesMetastatementNode = false;
 
     if (this.metastatementNode !== null) {
       const nonTerminalNodeA = this.metastatementNode,  ///
@@ -56,10 +56,10 @@ export default class Conclusion {
               return verifiedAhead;
             });
 
-      metastatementNodeMatches = nonTerminalNodeVerified; ///
+      matchesMetastatementNode = nonTerminalNodeVerified; ///
     }
 
-    return metastatementNodeMatches;
+    return matchesMetastatementNode;
   }
 
   toJSON(tokens) {

package/src/consequent.js

@@ -24,9 +24,9 @@ export default class Consequent {
 
             return verifiedAhead;
           }),
-          statementNodeMatches = nonTerminalNodeVerified; ///
+          matchesStatementNode = nonTerminalNodeVerified; ///
 
-    return statementNodeMatches;
+    return matchesStatementNode;
   }
 
   toJSON(tokens) {

package/src/context/file.js

@@ -337,9 +337,9 @@ export default class FileContext {
     const node = variableNode,  ///
           variables = this.getVariables(),
           variable = variables.find((variable) => {
-            const nodeMatches = variable.matchNode(node);
+            const variableMatchesNode = variable.matchNode(node);
 
-            if (nodeMatches) {
+            if (variableMatchesNode) {
               return true;
             }
           }) || null;
@@ -520,30 +520,6 @@ export default class FileContext {
     return metavariablePresent;
   }
 
-  isTermGrounded(term) {
-    const termGrounded = false; ///
-
-    return termGrounded;
-  }
-
-  isVariableDefined(variable) {
-    const variableDefined = false;  ///
-
-    return variableDefined;
-  }
-
-  matchStatement(statementNode) {
-    const statementMatches = false;
-
-    return statementMatches;
-  }
-
-  matchMetastatement(metastatementNode) {
-    const metastatementMatches = false;
-
-    return metastatementMatches;
-  }
-
   nodeAsString(node) {
     const string = nodeAsString(node, this.tokens);
 
@@ -581,9 +557,9 @@ export default class FileContext {
 
     const node = variable.getNode(),
           variablePresent = this.variables.some((variable) => {
-            const nodeMatches = variable.matchNode(node);
+            const variableMatchesNode = variable.matchNode(node);
 
-            if (nodeMatches) {
+            if (variableMatchesNode) {
               return true;
             }
           });
@@ -622,9 +598,9 @@ export default class FileContext {
 
     const name = metavariable.getName(),
           metavariablePresent = this.metavariables.some((metavariable) => {
-            const nodeMatches = metavariable.matchName(name);
+            const metavariableMatchesNode = metavariable.matchName(name);
 
-            if (nodeMatches) {
+            if (metavariableMatchesNode) {
               return true;
             }
           });

package/src/context/local.js

@@ -4,7 +4,7 @@ import Variable from "../variable";
 import Equivalence from "../equivalence";
 import contextMixins from "../mixins/context";
 
-import { last } from "../utilities/array";
+import { last, reverse } from "../utilities/array";
 import { mergeEquivalences, findEquivalenceByTerm, groundedTermsAndDefinedVariablesFromFromEquivalences } from "../utilities/equivalences";
 
 class LocalContext {
@@ -183,9 +183,9 @@ class LocalContext {
 
     const node = variable.getNode(),
           variablePresent = this.variables.some((variable) => {
-            const nodeMatches = variable.matchNode(node);
+            const variableMatchesNode = variable.matchNode(node);
 
-            if (nodeMatches) {
+            if (variableMatchesNode) {
               return true;
             }
           });
@@ -215,26 +215,20 @@ class LocalContext {
     this.equivalences.splice(start, deleteCount);
   }
 
-  matchStatement(statementNode) {
-    let statementMatches = false;
+  matchStatementNode(statementNode) {
+    let proofSteps = this.getProofSteps();
 
-    if (!statementMatches) {
-      const proofStepMatchesStatement = this.proofSteps.some((proofStep) => {
-        const proofStepMatchesStatement = proofStep.match(statementNode);
+    proofSteps = reverse(proofSteps); ///
 
-        if (proofStepMatchesStatement) {
-          return true;
-        }
-      });
-
-      statementMatches = proofStepMatchesStatement; ///
-    }
+    const matchesStatementNode = proofSteps.some((proofStep) => {
+      const proofStepMatchesStatementNode = proofStep.matchStatementNode(statementNode);
 
-    if (!statementMatches) {
-      statementMatches = this.context.matchStatement(statementNode);
-    }
+      if (proofStepMatchesStatementNode) {
+        return true;
+      }
+    });
 
-    return statementMatches;
+    return matchesStatementNode;
   }
 
   findVariableByVariableNode(variableNode) {

package/src/context/localMeta.js

@@ -2,7 +2,7 @@
 
 import LocalContext from "../context/local";
 
-import { last } from "../utilities/array";
+import { last, reverse } from "../utilities/array";
 
 class LocalMetaContext extends LocalContext {
   constructor(context, variables, proofSteps, equivalences, metavariables, metaproofSteps, frameAssertions) {
@@ -78,9 +78,9 @@ class LocalMetaContext extends LocalContext {
 
     const node = metavariable.getName(),
           metavariablePresent = this.metavariables.some((metavariable) => {
-            const nodeMatches = metavariable.matchNode(node);
+            const metavariableMatchesNode = metavariable.matchNode(node);
 
-            if (nodeMatches) {
+            if (metavariableMatchesNode) {
               return true;
             }
           });
@@ -98,26 +98,20 @@ class LocalMetaContext extends LocalContext {
     this.metaproofSteps.push(metaproofStep);
   }
 
-  matchMetastatement(metastatementNode) {
-    let metastatementMatches = false;
+  matchMetastatementNode(metastatementNode) {
+    let metaproofSteps = this.getMetaproofSteps();
 
-    if (!metastatementMatches) {
-      const proofStepMatchesMetastatement = this.metaproofSteps.some((metaproofStep) => {
-        const proofStepMatchesMetastatement = metaproofStep.match(metastatementNode);
+    metaproofSteps = reverse(metaproofSteps); ///
 
-        if (proofStepMatchesMetastatement) {
-          return true;
-        }
-      });
+    const matchesMetastatementNode = metaproofSteps.some((metaproofStep) => {
+      const metaproofStepMatchesMetastatementNode = metaproofStep.matchMetastatementNode(metastatementNode);
 
-      metastatementMatches = proofStepMatchesMetastatement; ///
-    }
-
-    if (!metastatementMatches) {
-      metastatementMatches = this.context.matchMetastatement(metastatementNode);
-    }
+      if (metaproofStepMatchesMetastatementNode) {
+        return true;
+      }
+    });
 
-    return metastatementMatches;
+    return matchesMetastatementNode;
   }
 
   findMetavariableByMetavariableNode(metavariableNode, localMetaContext) {
@@ -137,9 +131,9 @@ class LocalMetaContext extends LocalContext {
   findFrameAssertionByMetavariableNode(metavariableNode) {
     const frameAssertions = this.getFrameAssertions(),
           frameAssertion = frameAssertions.find((frameAssertion) => {
-            const metavariableMatches = frameAssertion.matchMetavariableNode(metavariableNode);
+            const frameAssertionMatchesMetavariableNode = frameAssertion.matchMetavariableNode(metavariableNode);
 
-            if (metavariableMatches) {
+            if (frameAssertionMatchesMetavariableNode) {
               return true;
             }
           }) || null;

package/src/declaration.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import { matchMetastatement } from "./utilities/metaproof";
+import { matchMetastatementModuloBrackets } from "./utilities/match";
 
 export default class Declaration {
   constructor(metavariableNode, metastatementNode) {
@@ -19,35 +19,35 @@ export default class Declaration {
   matchSubstitution(substitution) {
     const metavariableNode = substitution.getMetavariableNode(),
           metastatementNode = substitution.getMetastatementNode(),
-          metavariableNodeMatches = this.matchMetavariableNode(metavariableNode),
-          metastatementNodeMatches = this.matchMetastatementNode(metastatementNode),
-          substitutionMatches = (metavariableNodeMatches && metastatementNodeMatches);
+          matchesMetavariableNode = this.matchMetavariableNode(metavariableNode),
+          matchesMetastatementNode = this.matchMetastatementNode(metastatementNode),
+          matchesSubstitution = (matchesMetavariableNode && matchesMetastatementNode);
 
-    return substitutionMatches;
+    return matchesSubstitution;
   }
 
   matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+    const matchesMetavariableNode = this.metavariableNode.match(metavariableNode);
 
-    return metavariableNodeMatches;
+    return matchesMetavariableNode;
   }
 
   matchMetastatementNode(metastatementNode) {
     const metastatementNodeA = metastatementNode, ///
           metastatementNodeB = this.metastatementNode,  ///
-          metastatementMatches = matchMetastatement(metastatementNodeA, metastatementNodeB),
-          metastatementNodeMatches = metastatementMatches;  ///
+          metastatementMatches = matchMetastatementModuloBrackets(metastatementNodeA, metastatementNodeB),
+          matchesMetastatementNode = metastatementMatches;  ///
 
-    return metastatementNodeMatches;
+    return matchesMetastatementNode;
   }
 
   matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) {
     const metaConsequent = metaLemmaMetatheorem.getMetaConsequent(),
           metastatementNode = metaConsequent.getMetastatementNode(),
           matches = this.metastatementNode.match(metastatementNode),
-          metaLemmaOrMetaTheoremMatches = matches;  ///
+          matchesMetaLemmaOrMetaTheorem = matches;  ///
 
-    return metaLemmaOrMetaTheoremMatches;
+    return matchesMetaLemmaOrMetaTheorem;
   }
 
   static fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode) {

package/src/equivalence.js

@@ -49,14 +49,14 @@ export default class Equivalence {
     const typeB = type; ///
 
     const typeAEqualToTypeB = typeA.isEqualTo(typeB),
-          typeMatches = typeAEqualToTypeB;  ///
+          matchesType = typeAEqualToTypeB;  ///
 
-    return typeMatches;
+    return matchesType;
   }
 
   matchTerm(term) {
     const termA = term, ///
-          termMatches = this.terms.some((term) => {
+          matchesTerm = this.terms.some((term) => {
             const termB = term, ///
                   termAMatchesTermB = termA.match(termB);
 
@@ -65,24 +65,24 @@ export default class Equivalence {
             }
           });
 
-    return termMatches;
+    return matchesTerm;
   }
 
   matchTerms(terms) {
-    const termsMatch = terms.every((term) => {
-      const termMatches = this.matchTerm(term);
+    const matchesTerms = terms.every((term) => {
+      const matchesTerm = this.matchTerm(term);
 
-      if (termMatches) {
+      if (matchesTerm) {
         return true;
       }
     })
 
-    return termsMatch;
+    return matchesTerms;
   }
 
   matchTermNode(termNode) {
     const termNodeA = termNode, ///
-          termNodeMatches = this.terms.some((term) => {
+          matchesTermNode = this.terms.some((term) => {
             const termNode = term.getNode(),
                   termNodeB = termNode, ///
                   termNodeAMatchesTermB = termNodeA.match(termNodeB);
@@ -92,19 +92,19 @@ export default class Equivalence {
             }
           });
 
-    return termNodeMatches;
+    return matchesTermNode;
   }
 
   matchTermNodes(termNodes) {
-    const termNodesMatch = termNodes.every((termNode) => {
-      const termNodeMatches = this.matchTermNode(termNode);
+    const matchesTermNodes = termNodes.every((termNode) => {
+      const matchesTermNode = this.matchTermNode(termNode);
 
-      if (termNodeMatches) {
+      if (matchesTermNode) {
         return true;
       }
     });
 
-    return termNodesMatch;
+    return matchesTermNodes;
   }
 
   getGroundedTerms(definedVariables, groundedTerms, localContext) {

package/src/frame.js

@@ -37,7 +37,7 @@ export default class Frame {
   }
 
   matchSubstitution(substitution) {
-    const substitutionMatches = this.declarations.some((declaration) => {
+    const matchesSubstitution = this.declarations.some((declaration) => {
       const declarationMatchesSubstitution = declaration.matchSubstitution(substitution);
 
       if (declarationMatchesSubstitution) {
@@ -45,12 +45,12 @@ export default class Frame {
       }
     });
 
-    return substitutionMatches;
+    return matchesSubstitution;
   }
 
   matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) {
     const substitutions = metaLemmaMetatheorem.getSubstitutions(),
-          metaLemmaOrMetaTheoremMatches = substitutions.every((substitution) => {
+          matchesMetaLemmaOrMetaTheorem = substitutions.every((substitution) => {
             const frameMatchesSubstitution = this.matchSubstitution(substitution);
 
             if (frameMatchesSubstitution) {
@@ -58,7 +58,7 @@ export default class Frame {
             }
           });
 
-    return metaLemmaOrMetaTheoremMatches;
+    return matchesMetaLemmaOrMetaTheorem;
   }
 
   static fromDeclarations(declarations) {

package/src/frameAssertion.js

@@ -22,9 +22,9 @@ export default class FrameAssertion {
   getDeclarations() { return this.frame.getDeclarations(); }
 
   matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.metavariableNode.match(metavariableNode);
+    const matchesMetavariableNode = this.metavariableNode.match(metavariableNode);
 
-    return metavariableNodeMatches;
+    return matchesMetavariableNode;
   }
 
   matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem) { return this.frame.matchMetaLemmaOrMetaTheorem(metaLemmaMetatheorem); }

package/src/metaConsequent.js

@@ -21,7 +21,7 @@ export default class MetaConsequent {
   }
 
   matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
-    let metastatementNodeMatches = false;
+    let matchesMetastatementNode = false;
 
     if (this.metastatementNode !== null) {
       const nonTerminalNodeA = this.metastatementNode,  ///
@@ -35,10 +35,10 @@ export default class MetaConsequent {
               return verifiedAhead;
             });
 
-      metastatementNodeMatches = nonTerminalNodeVerified; ///
+      matchesMetastatementNode = nonTerminalNodeVerified; ///
     }
 
-    return metastatementNodeMatches;
+    return matchesMetastatementNode;
   }
 
   toJSON(tokens) {

package/src/metaLemmaMetatheorem.js

@@ -53,7 +53,7 @@ export default class MetaLemmaMetatheorem {
   }
 
   matchMetavariableNode(metavariableNode) {
-    const metavariableNodeMatches = this.labels.some((label) => {
+    const matchesMetavariableNode = this.labels.some((label) => {
       const labelMatchesMetavariableNode = label.matchMetavariableNode(metavariableNode);
 
       if (labelMatchesMetavariableNode) {
@@ -61,7 +61,7 @@ export default class MetaLemmaMetatheorem {
       }
     });
 
-    return metavariableNodeMatches;
+    return matchesMetavariableNode;
   }
 
   toJSON(tokens) {
@@ -160,29 +160,29 @@ function matchMetaSuppositions(metaSuppositions, metaproofSteps, substitutions,
 }
 
 function matchMetaSupposition(metaSupposition, metaproofStep, substitutions, fileContext, localMetaContext) {
-  let suppositionMatches = false;
+  let matchesMetaSupposition = false;
 
   const metaSubproofNode = metaproofStep.getMetaSubproofNode(),
         metastatementNode = metaproofStep.getMetastatementNode();
 
   if (metaSubproofNode !== null) {
-    const metaSubProofMatches = metaSupposition.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
+    const metaSuppositionMatchesMetaSubproofNode = metaSupposition.matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext);
 
-    suppositionMatches - metaSubProofMatches; ///
+    matchesMetaSupposition - metaSuppositionMatchesMetaSubproofNode; ///
   }
 
   if (metastatementNode !== null) {
-    const metastatementMatches = metaSupposition.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
+    const metaSuppositionMatchesMetastatementNode = metaSupposition.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext);
 
-    suppositionMatches - metastatementMatches; ///
+    matchesMetaSupposition - metaSuppositionMatchesMetastatementNode; ///
   }
 
-  return suppositionMatches;
+  return matchesMetaSupposition;
 }
 
 function matchMetaConsequent(metaConsequent, metastatementNode, substitutions, fileContext, localMetaContext) {
-  const nonTerminalNodeMatches = metaConsequent.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext),
-        metaConsequentMatches = nonTerminalNodeMatches; ///
+  const metaConsequentMatchesMetastatementNode = metaConsequent.matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext),
+        metaConsequentMatches = metaConsequentMatchesMetastatementNode; ///
 
   return metaConsequentMatches;
 }

package/src/metaSupposition.js

@@ -11,7 +11,7 @@ import { statementNodeFromStatementString, metastatementNodeFromMetastatementStr
 const subproofAssertionNodeQuery = nodeQuery("/metastatement/subproofAssertion!"),
       subproofAssertionMetastatementNodesQuery = nodesQuery("/subproofAssertion/metastatement"),
       metaSubproofMetaSuppositionMetastatementNodesQuery = nodesQuery("/metaSubproof/metaSupposition/unqualifiedMetastatement/metastatement!"),
-      metaSubproofLastMetaProofStepMetastatementNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation/lastMetaProofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!");
+      metaSubproofLastMetpProofStepMetastatementNodeQuery = nodeQuery("/metaSubproof/metaSubDerivation/lastMetpProofStep/unqualifiedMetastatement|qualifiedMetastatement/metastatement!");
 
 export default class MetaSupposition {
   constructor(metastatementNode, statementNode) {
@@ -28,21 +28,21 @@ export default class MetaSupposition {
   }
 
   matchMetaSubproofNode(metaSubproofNode, substitutions, fileContext, localMetaContext) {
-    let metaSubproofNodeMatches = false;
+    let matchesMetaSubproofNode = false;
 
     if (this.metastatementNode !== null) {
       const subproofAssertionNode = subproofAssertionNodeQuery(this.metastatementNode);
 
       if (subproofAssertionNode !== null) {
         const metaSubproofMetaSuppositionMetastatementNodes = metaSubproofMetaSuppositionMetastatementNodesQuery(metaSubproofNode),
-              metaSubproofLastMetaProofStepMetastatementNode = metaSubproofLastMetaProofStepMetastatementNodeQuery(metaSubproofNode),
+              metaSubproofLastMetpProofStepMetastatementNode = metaSubproofLastMetpProofStepMetastatementNodeQuery(metaSubproofNode),
               metaSubproofMetastatementNodes = [
                 ...metaSubproofMetaSuppositionMetastatementNodes,
-                metaSubproofLastMetaProofStepMetastatementNode
+                metaSubproofLastMetpProofStepMetastatementNode
               ],
               subproofAssertionMetastatementNodes = subproofAssertionMetastatementNodesQuery(subproofAssertionNode);
 
-        metaSubproofNodeMatches = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
+        matchesMetaSubproofNode = match(subproofAssertionMetastatementNodes, metaSubproofMetastatementNodes, (subproofAssertionMetastatementNode, ruleSubproofMetastatementNode) => {
           const nonTerminalNodeA = subproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
                 fileContextA = fileContext, ///
@@ -61,11 +61,11 @@ export default class MetaSupposition {
       }
     }
 
-    return metaSubproofNodeMatches;
+    return matchesMetaSubproofNode;
   }
 
   matchMetastatementNode(metastatementNode, substitutions, fileContext, localMetaContext) {
-    let metastatementNodeMatches = false;
+    let matchesMetastatementNode = false;
 
     if (this.metastatementNode !== null) {
       const nonTerminalNodeA = this.metastatementNode,  ///
@@ -79,10 +79,10 @@ export default class MetaSupposition {
               return verifiedAhead;
             });
 
-      metastatementNodeMatches = nonTerminalNodeVerified; ///
+      matchesMetastatementNode = nonTerminalNodeVerified; ///
     }
 
-    return metastatementNodeMatches;
+    return matchesMetastatementNode;
   }
 
   toJSON(tokens) {

package/src/metaType.js

@@ -25,23 +25,23 @@ export default class MetaType {
   }
 
   matchName(name) {
-    const nameMatches = (this.name === name);
+    const matchesName = (this.name === name);
 
-    return nameMatches;
+    return matchesName;
   }
 
   matchMetaTypeName(metaTypeName) {
-    const metaTypeNameMatches = (this.name === metaTypeName);
+    const matchesMetaTypeName = (this.name === metaTypeName);
 
-    return metaTypeNameMatches;
+    return matchesMetaTypeName;
   }
 
   matchMetaTypeNode(metaTypeNode) {
     const metaTypeName = metaTypeNameFromMetaTypeNode(metaTypeNode),
-          metaTypeNameMatches = this.matchMetaTypeName(metaTypeName),
-          metaTypeNodeMatches = metaTypeNameMatches;  ///
+          matchesMetaTypeName = this.matchMetaTypeName(metaTypeName),
+          matchesMetaTypeNode = matchesMetaTypeName;  ///
 
-    return metaTypeNodeMatches;
+    return matchesMetaTypeNode;
   }
 
   asString(tokens) {