occam-verify-cli 0.0.698 → 0.0.702

package/src/premise.js

@@ -1,7 +1,7 @@
 "use strict";
 
-import premiseStatementForMetavariableNodesVerifier from "./verifier/nodes/statementForMetavariable/premise";
-import premiseMetastatementForMetavariableNodesVerifier from "./verifier/nodes/metastatementForMetavariable/premise";
+import statementForMetavariableNodesVerifier from "./verifier/nodes/statementForMetavariable";
+import metastatementForMetavariableNodesVerifier from "./verifier/nodes/metastatementForMetavariable";
 
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
@@ -46,7 +46,7 @@ export default class Premise {
                 nonTerminalNodeB = subproofStatementNode, ///
                 fileContextA = fileContext, ///
                 localContextB = statementLocalContext,  ///
-                nonTerminalNodeVerified = premiseStatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
+                nonTerminalNodeVerified = statementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -67,7 +67,7 @@ export default class Premise {
           nonTerminalNodeB = statementNode,  ///
           fileContextA = fileContext, ///
           localContextB = statementLocalContext,  ///
-          nonTerminalNodeVerified = premiseStatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
+          nonTerminalNodeVerified = statementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
@@ -77,7 +77,7 @@ export default class Premise {
     return statementNodeMatches;
   }
 
-  matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, metastatementMetalocalContext) {
+  matchRuleSubproofNode(ruleSubproofNode, substitutions, fileContext, metastatementLocalMetaContext) {
     let ruleSubproofNodeMatches = false;
 
     const ruleSubproofAssertionNode = ruleSubproofAssertionNodeQuery(this.metastatementNode);
@@ -99,8 +99,8 @@ export default class Premise {
                 nonTerminalNodeA = ruleSubproofAssertionMetastatementNode,  ///
                 nonTerminalNodeB = ruleSubproofMetastatementNode, ///
                 fileContextA = fileContext, ///
-                metalocalContextB = metastatementMetalocalContext,  ///
-                nonTerminalNodeVerified = premiseMetastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metalocalContextB, () => {
+                localMetaContextB = metastatementLocalMetaContext,  ///
+                nonTerminalNodeVerified = metastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -116,12 +116,12 @@ export default class Premise {
     return ruleSubproofNodeMatches;
   }
 
-  matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementMetalocalContext) {
+  matchMetastatementNode(metastatementNode, substitutions, fileContext, metastatementLocalMetaContext) {
     const nonTerminalNodeA = this.metastatementNode,  ///
           nonTerminalNodeB = metastatementNode,  ///
           fileContextA = fileContext, ///
-          metalocalContextB = metastatementMetalocalContext,  ///
-          nonTerminalNodeVerified = premiseMetastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, metalocalContextB, () => {
+          localMetaContextB = metastatementLocalMetaContext,  ///
+          nonTerminalNodeVerified = metastatementForMetavariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/ruleNames.js

@@ -13,7 +13,9 @@ export const METASTATEMENT_RULE_NAME = "metastatement";
 export const RULE_SUBPROOF_RULE_NAME = "ruleSubproof";
 export const META_ARGUMENT_RULE_NAME = "metaArgument";
 export const QUALIFIED_STATEMENT_RULE_NAME = "qualifiedStatement";
+export const VARIABLE_DECLARATION_RULE_NAME = "variableDeclaration";
 export const UNQUALIFIED_STATEMENT_RULE_NAME = "unqualifiedStatement";
 export const CONSTRUCTOR_DECLARATION_RULE_NAME = "constructorDeclaration";
 export const QUALIFIED_METASTATEMENT_RULE_NAME = "qualifiedMetastatement";
+export const METAVARIABLE_DECLARATION_RULE_NAME = "metavariableDeclaration";
 export const UNQUALIFIED_METASTATEMENT_RULE_NAME = "unqualifiedMetastatement";

package/src/supposition.js

@@ -1,6 +1,6 @@
 "use strict";
 
-import suppositionTermForVariableNodesVerifier from "./verifier/nodes/termForVariable/supposition";
+import termForVariableNodesVerifier from "./verifier/nodes/termForVariable";
 
 import { nodeAsString } from "./utilities/string";
 import { nodeQuery, nodesQuery } from "./utilities/query";
@@ -43,7 +43,7 @@ export default class Supposition {
                 nonTerminalNodeB = subproofStatementNode, ///
                 localContextA = localContext, ///
                 localContextB = statementLocalContext,  ///
-                nonTerminalNodeVerified = suppositionTermForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+                nonTerminalNodeVerified = termForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
                   const verifiedAhead = true;
 
                   return verifiedAhead;
@@ -64,7 +64,7 @@ export default class Supposition {
           nonTerminalNodeB = statementNode,  ///
           localContextA = localContext, ///
           localContextB = statementLocalContext,  ///
-          nonTerminalNodeVerified = suppositionTermForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+          nonTerminalNodeVerified = termForVariableNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/type.js

@@ -58,29 +58,29 @@ export default class Type {
     return superTypeOf;
   }
 
-  isEqualToOrSubTypeOf(type) {
+  isComparableTo(type) {
     const equalTo = this.isEqualTo(type),
           subTypeOf = this.isSubTypeOf(type),
-          equalToOrSubTypeOf = (equalTo || subTypeOf);
+          superTypeOf = this.isSuperTypeOf(type),
+          comparableTo = equalTo || subTypeOf || superTypeOf;
 
-    return equalToOrSubTypeOf;
+    return comparableTo;
   }
 
-  isEqualToOrSuperTypeOf(type) {
+  isEqualToOrSubTypeOf(type) {
     const equalTo = this.isEqualTo(type),
-          superTypeOf = this.isSuperTypeOf(type),
-          equalToOrSuperTypeOf = (equalTo || superTypeOf);
+          subTypeOf = this.isSubTypeOf(type),
+          equalToOrSubTypeOf = equalTo || subTypeOf;
 
-    return equalToOrSuperTypeOf;
+    return equalToOrSubTypeOf;
   }
 
-  isEqualToSubTypeOfOrSuperTypeOf(type) {
+  isEqualToOrSuperTypeOf(type) {
     const equalTo = this.isEqualTo(type),
-          subTypeOf = this.isSubTypeOf(type),
           superTypeOf = this.isSuperTypeOf(type),
-          equalToOrSubTypeOfSuperTypeOf = (equalTo || subTypeOf || superTypeOf);
+          equalToOrSuperTypeOf = equalTo || superTypeOf;
 
-    return equalToOrSubTypeOfSuperTypeOf;
+    return equalToOrSuperTypeOf;
   }
 
   match(type) {
@@ -101,7 +101,7 @@ export default class Type {
     return typeNameMatches;
   }
 
-  asString(tokens, noSuperType) {
+  asString(tokens, noSuperType = false) {
     let string;
 
     if (noSuperType) {
@@ -135,22 +135,6 @@ export default class Type {
     return type;
   }
 
-  static fromJSONAndFileContext(json, fileContext) {
-    let type;
-
-    let { superType } = json;
-
-    const superTypeJSON = superType;  ///
-
-    superType = superTypeFromSuperTypeJSONAndFileContext(superTypeJSON, fileContext);
-
-    const { name } = json;
-
-    type = new Type(name, superType);
-
-    return type;
-  }
-
   static fromTypeNameAndSuperType(typeName, superType) {
     const name = typeName,  ///
           type = new Type(name, superType);
@@ -182,19 +166,23 @@ class ObjectType extends Type {
 
 export const objectType = ObjectType.fromNothing();
 
-function superTypeFromSuperTypeJSONAndFileContext(superTypeJSON, fileContext) {
-  let superType = null;
+export function typeFromJSONAndFileContext(json, fileContext) {
+  let type;
+
+  const { name } = json,
+        typeName = name;  ///
 
-  if (superTypeJSON !== null) {
-    const json = superTypeJSON, ///
-          { name } = json,
-          typeName = name,  ///
-          type = fileContext.findTypeByTypeName(typeName);
+  type = fileContext.findTypeByTypeName(typeName);
+
+  if (type === null) {
+    let { superType } = json;
 
-      superType = (type !== null) ?
-                    type :  ///
-                      Type.fromJSONAndFileContext(json, fileContext);  ///
+    const superJSON = superType;  ///
+
+    superType = typeFromJSONAndFileContext(superJSON, fileContext);
+
+    type = new Type(name, superType);
   }
 
-  return superType;
+  return type;
 }

package/src/utilities/collection.js

@@ -2,9 +2,29 @@
 
 import { compress } from "../utilities/array";
 
-export function mergeCollections(collectionsA, collectionsB) {
-  const typesA = typesFromCollections(collectionsA),
-        typesB = typesFromCollections(collectionsB),
+export function areTermNodesEqual(leftTermNode, rightTermNode, collections) {
+  let termNodesEqual;
+
+  const leftTermNodeMatchesRightTermNode = leftTermNode.match(rightTermNode);
+
+  if (leftTermNodeMatchesRightTermNode) {
+    termNodesEqual = true;
+  } else {
+    const termNodes = [
+            leftTermNode,
+            rightTermNode
+          ],
+          collection = findCollectionByTermNodes(collections, termNodes);
+
+    termNodesEqual = (collection !== null);
+  }
+
+  return termNodesEqual;
+}
+
+export function mergeCollections(collectionsA, collectionsB, localContext) {
+  const typesA = typesFromCollections(collectionsA, localContext),
+        typesB = typesFromCollections(collectionsB, localContext),
         types = [
           ...typesA,
           ...typesB
@@ -19,8 +39,8 @@ export function mergeCollections(collectionsA, collectionsB) {
   const collections = types.map((type) => {
     let collection;
 
-    const collectionA = findCollectionByType(collectionsA, type),
-          collectionB = findCollectionByType(collectionsB, type);
+    const collectionA = findCollectionByType(collectionsA, type, localContext),
+          collectionB = findCollectionByType(collectionsB, type, localContext);
 
     if ((collectionA !== null) && (collectionB !== null)) {
       collection = Collection.fromCollections(collectionA, collectionB);
@@ -36,9 +56,9 @@ export function mergeCollections(collectionsA, collectionsB) {
   return collections;
 }
 
-export function findCollectionByType(collections, type) {
+export function findCollectionByType(collections, type, localContext) {
   const collection = collections.find((collection) => {
-    const collectionMatchesType = collection.matchType(type);
+    const collectionMatchesType = collection.matchType(type, localContext);
 
     if (collectionMatchesType) {
       return true;
@@ -60,9 +80,9 @@ export function findCollectionByTerm(collections, term) {
   return collection;
 }
 
-export function findCollectionByTerms(collections, terms) {
+function findCollectionByTermNodes(collections, termNodes) {
   const collection = collections.find((collection) => {
-    const collectionMatchesTerms = collection.matchTerms(terms);
+    const collectionMatchesTerms = collection.matchTermNodes(termNodes);
 
     if (collectionMatchesTerms) {
       return true;
@@ -72,9 +92,9 @@ export function findCollectionByTerms(collections, terms) {
   return collection;
 }
 
-function typesFromCollections(collections) {
+function typesFromCollections(collections, localContext) {
   const types = collections.map((collection) => {
-    const type = collection.getType();
+    const type = collection.getType(localContext);
 
     return type;
   });

package/src/utilities/node.js

@@ -4,19 +4,14 @@ import { parsersUtilities } from "occam-custom-grammars";
 
 import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
-import { TYPE_RULE_NAME,
-         LABEL_RULE_NAME,
-         VARIABLE_RULE_NAME,
-         META_TYPE_RULE_NAME,
-         METAVARIABLE_RULE_NAME,
+import { LABEL_RULE_NAME,
+         VARIABLE_DECLARATION_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
          CONSTRUCTOR_DECLARATION_RULE_NAME,
          UNQUALIFIED_METASTATEMENT_RULE_NAME } from "../ruleNames";
 import { labelTokensFromLabelString,
-         constructorDeclarationTokensFromTermString,
          variableDeclarationTokensFromVariableString,
          unqualifiedStatementTokensFromStatementString,
-         metavariableDeclarationTokensFromMetavariableString,
          unqualifiedMetastatementTokensFromMetastatementString } from "../utilities/tokens";
 
 const { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
@@ -25,20 +20,10 @@ const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
 const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
-      typeNodeQuery = nodeQuery("/variableDeclaration/type!"),
       variableNodeQuery = nodeQuery("/variableDeclaration/variable!"),
-      metaTypeNodeQuery = nodeQuery("/metavariableDeclaration/metaType!"),
       statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!"),
-      metavariableNodeQuery = nodeQuery("/metavariableDeclaration/metavariable!"),
       metastatementNodeQuery = nodeQuery("/unqualifiedMetastatement/metastatement!");
 
-export function termNodeFromTermString(termString, lexer, parser) {
-  const constructorDeclarationTokens = constructorDeclarationTokensFromTermString(termString, parser),
-        termNode = termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser);
-
-  return termNode;
-}
-
 export function labelNodeFromLabelString(labelString, lexer, parser) {
   const labelTokens = labelTokensFromLabelString(labelString, lexer),
         labelNode = labelNodeFromLabelTokens(labelTokens, parser);
@@ -46,13 +31,6 @@ export function labelNodeFromLabelString(labelString, lexer, parser) {
   return labelNode;
 }
 
-export function typeNodeFromVariableString(variableString, lexer, parser) {
-  const variableDeclarationTokens = variableDeclarationTokensFromVariableString(variableString, lexer),
-        typeNode = typeNodeFromVariableVariableDeclarationTokens(variableDeclarationTokens, parser);
-
-  return typeNode;
-}
-
 export function variableNodeFromVariableString(variableString, lexer, parser) {
   const variableTDeclarationTokens = variableDeclarationTokensFromVariableString(variableString, lexer),
         variableNode = variableNodeFromVariableVariableTDeclarationTokens(variableTDeclarationTokens, parser);
@@ -67,20 +45,6 @@ export function statementNodeFromStatementString(statementString, lexer, parser)
   return statementNode;
 }
 
-export function metaTypeNodeFromMetavariableString(metavariableString, lexer, parser) {
-  const metavariableDeclarationTokens = metavariableDeclarationTokensFromMetavariableString(metavariableString, lexer),
-        metaTypeNode = metaTypeNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser);
-
-  return metaTypeNode;
-}
-
-export function metavariableNodeFromMetavariableString(metavariableString, lexer, parser) {
-  const metavariableDeclarationTokens = metavariableDeclarationTokensFromMetavariableString(metavariableString, lexer),
-        metavariableNode = metavariableNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser);
-
-  return metavariableNode;
-}
-
 export function metastatementNodeFromMetastatementString(metastatementString, lexer, parser) {
   const unqualifiedMetastatementTokens = unqualifiedMetastatementTokensFromMetastatementString(metastatementString, lexer),
         metastatementNode = metastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser);
@@ -102,27 +66,6 @@ export function statementNodeFromUnqualifiedStatementTokens(unqualifiedStatement
   return statementNode;
 }
 
-export function typeNodeFromVariableVariableDeclarationTokens(variableDeclarationTokens, parser) {
-  const typeDeclarationNode = typeDeclarationNodeFromVariableDeclarationTokens(variableDeclarationTokens, parser),
-        typeNode = typeNodeQuery(typeDeclarationNode);
-
-  return typeNode;
-}
-
-export function metaTypeNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser) {
-  const metaTypeDeclarationNode = metaTypeDeclarationNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser),
-        metaTypeNode = metaTypeNodeQuery(metaTypeDeclarationNode);
-
-  return metaTypeNode;
-}
-
-export function metavariableNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser) {
-  const metavariableDeclarationNode = metavariableDeclarationNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser),
-        metavariableNode = metavariableNodeQuery(metavariableDeclarationNode);
-
-  return metavariableNode;
-}
-
 export function variableNodeFromVariableVariableTDeclarationTokens(variableTDeclarationTokens, parser) {
   const variableDeclarationNode = variableDeclarationNodeFromVariableTDeclarationTokens(variableTDeclarationTokens, parser),
         variableNode = variableNodeQuery(variableDeclarationNode);
@@ -144,15 +87,8 @@ export function labelNodeFromLabelTokens(labelTokens, parser) {
   return labelNode;
 }
 
-export function typeDeclarationNodeFromVariableDeclarationTokens(variableDeclarationTokens, parser) {
-  const ruleName = TYPE_RULE_NAME,
-        typeDeclarationNode = nodeFromTokensRuleNameAndParser(variableDeclarationTokens, ruleName, parser);
-
-  return typeDeclarationNode;
-}
-
 export function variableDeclarationNodeFromVariableTDeclarationTokens(variableTDeclarationTokens, parser) {
-  const ruleName = VARIABLE_RULE_NAME,
+  const ruleName = VARIABLE_DECLARATION_RULE_NAME,
         variableDeclarationNode = nodeFromTokensRuleNameAndParser(variableTDeclarationTokens, ruleName, parser);
 
   return variableDeclarationNode;
@@ -165,13 +101,6 @@ export function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifi
   return unqualifiedStatementNode;
 }
 
-export function metaTypeDeclarationNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser) {
-  const ruleName = META_TYPE_RULE_NAME,
-        metaTypeDeclarationNode = nodeFromTokensRuleNameAndParser(metavariableDeclarationTokens, ruleName, parser);
-
-  return metaTypeDeclarationNode;
-}
-
 export function constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
   const ruleName = CONSTRUCTOR_DECLARATION_RULE_NAME,
         constructorDeclarationNode = nodeFromTokensRuleNameAndParser(constructorDeclarationTokens, ruleName, parser);
@@ -179,13 +108,6 @@ export function constructorDeclarationNodeFromConstructorDeclarationTokens(const
   return constructorDeclarationNode;
 }
 
-export function metavariableDeclarationNodeFromMetavariableDeclarationTokens(metavariableDeclarationTokens, parser) {
-  const ruleName = METAVARIABLE_RULE_NAME,
-        metavariableDeclarationNode = nodeFromTokensRuleNameAndParser(metavariableDeclarationTokens, ruleName, parser);
-
-  return metavariableDeclarationNode;
-}
-
 export function unqualifiedMetastatementNodeFromUnqualifiedMetastatementTokens(unqualifiedMetastatementTokens, parser) {
   const ruleName = UNQUALIFIED_METASTATEMENT_RULE_NAME,
         unqualifiedMetastatementNode = nodeFromTokensRuleNameAndParser(unqualifiedMetastatementTokens, ruleName, parser);

package/src/utilities/tokens.js

@@ -40,14 +40,6 @@ export function unqualifiedStatementTokensFromStatementString(statementString, l
   return unqualifiedStatementTokens;
 }
 
-export function metavariableDeclarationTokensFromMetavariableString(metavariableString, lexer) {
-  const metavariableDeclarationContent = `Metavariable ${metavariableString}
-`,
-        metavariableDeclarationTokens = tokensFromContentAndLexer(metavariableDeclarationContent, lexer);
-
-  return metavariableDeclarationTokens;
-}
-
 export function unqualifiedMetastatementTokensFromMetastatementString(metastatementString, lexer) {
   const unqualifiedMetastatementContent = `${metastatementString}
 `,

package/src/variable.js

@@ -1,8 +1,7 @@
 "use strict";
 
-import Type from "./type";
-
 import { nodeAsString } from "./utilities/string";
+import { typeFromJSONAndFileContext } from "./type";
 import { variableNodeFromVariableString } from "./utilities/node";
 
 export default class Variable {
@@ -86,13 +85,17 @@ export default class Variable {
 
     json = type;  ///
 
-    type = Type.fromJSONAndFileContext(json, fileContext);
+    type = typeFromJSONAndFileContext(json, fileContext);
+
+    const variable = new Variable(node, type);
 
-    const typeName = type.getName();
+    return variable;
+  }
 
-    type = fileContext.findTypeByTypeName(typeName); ///
+  static fromVariableAndType(variable, type) {
+    const node = variable.getNode();
 
-    const variable = new Variable(node, type);
+    variable = new Variable(node, type);  ///
 
     return variable;
   }

package/src/verifier/node/statementAsCombinator.js

@@ -3,7 +3,7 @@
 import NodeVerifier from "../../verifier/node";
 import verifyStatement from "../../verify/statement";
 
-import { verifyStandaloneTerm, verifyType } from "./../../verifier/node/termAsConstructor";
+import { verifyType, verifyStandaloneTerm } from "./../../verifier/node/termAsConstructor";
 import { TYPE_RULE_NAME, TERM_RULE_NAME, STATEMENT_RULE_NAME } from "../../ruleNames";
 
 class StatementAsCombinatorNodeVerifier extends NodeVerifier {
@@ -14,6 +14,8 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
 
     switch (ruleName) {
       case TYPE_RULE_NAME: {
+        debugger
+
         const typeNode = nonTerminalNode, ///
               typeVerified = verifyType(typeNode, fileContext, verifyAhead),
               typeNodeVerified = typeVerified;  ///
@@ -24,6 +26,8 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       }
 
       case TERM_RULE_NAME: {
+        debugger
+
         const termNode = nonTerminalNode, ///
               standaloneTermVerified = verifyStandaloneTerm(termNode, fileContext, verifyAhead),
               termNodeVerified = standaloneTermVerified;  ///
@@ -34,6 +38,8 @@ class StatementAsCombinatorNodeVerifier extends NodeVerifier {
       }
 
       case STATEMENT_RULE_NAME: {
+        debugger
+
         const statementNode = nonTerminalNode, ///
               standaloneStatementVerified = verifyStandaloneStatement(statementNode, fileContext, verifyAhead),
               statementNodeVerified = standaloneStatementVerified; ///

package/src/verifier/node/termAsConstructor.js

@@ -2,8 +2,9 @@
 
 import verifyTerm from "../../verify/term";
 import NodeVerifier from "../../verifier/node";
+import verifyGivenType from "../../verify/givenType";
 
-import { nodeQuery, typeNameFromTypeNode } from "../../utilities/query";
+import { nodeQuery } from "../../utilities/query";
 import { TERM_RULE_NAME, ARGUMENT_RULE_NAME } from "../../ruleNames";
 
 const typeNodeQuery = nodeQuery("/argument/type"),
@@ -71,29 +72,6 @@ export function verifyStandaloneTerm(termNode, fileContext, verifyAhead) {
   return standaloneTermVerified;
 }
 
-export function verifyType(typeNode, fileContext, verifyAhead) {
-  let typeVerified = false;
-
-  const typeString = fileContext.nodeAsString(typeNode);
-
-  fileContext.trace(`Verifying the '${typeString}' type...`, typeNode);
-
-  const typeName = typeNameFromTypeNode(typeNode),
-        typePresent = fileContext.isTypePresentByTypeName(typeName);
-
-  if (!typePresent) {
-    fileContext.debug(`The type '${typeName}' is not present.`, typeNode);
-  } else {
-    fileContext.debug(`...verified the '${typeString}' type.`, typeNode);
-
-    const verifiedAhead = verifyAhead();
-
-    typeVerified = verifiedAhead; ///
-  }
-
-  return typeVerified;
-}
-
 function verifyArgument(argumentNode, fileContext, verifyAhead) {
   let argumentVerified;
 
@@ -105,9 +83,10 @@ function verifyArgument(argumentNode, fileContext, verifyAhead) {
         termNode = termNodeQuery(argumentNode);
 
   if (typeNode !== null) {
-    const typeVerified = verifyType(typeNode, fileContext, verifyAhead);
+    const types = [], ///
+          givenTypeVerified = verifyGivenType(typeNode, types, fileContext, verifyAhead);
 
-    argumentVerified = typeVerified; ///
+    argumentVerified = givenTypeVerified; ///
   }
 
   if (termNode !== null) {

package/src/verifier/nodes/equality.js

@@ -0,0 +1,47 @@
+"use strict";
+
+import NodesVerifier from "../../verifier/nodes";
+
+import { TERM_RULE_NAME } from "../../ruleNames";
+import { areTermNodesEqual } from "../../utilities/collection";
+
+class EqualityNodesVerifier extends NodesVerifier {
+  verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, collections, localContext, verifyAhead) {
+    let nonTerminalNodeVerified = false;
+
+    const ruleNameA = nonTerminalNodeA.getRuleName(), ///
+          ruleNameB = nonTerminalNodeB.getRuleName(); ///
+
+    if (ruleNameA === ruleNameB) {
+      switch (ruleNameA) {
+        case TERM_RULE_NAME: {
+          const leftTermNode = nonTerminalNodeA, ///
+                rightTermNode = nonTerminalNodeB, ///
+                termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, collections);
+
+          if (termNodesEqual) {
+            const verifiedAhead = verifyAhead();
+
+            nonTerminalNodeVerified = verifiedAhead;  ///
+          } else {
+            nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, collections, localContext, verifyAhead);
+          }
+
+          break;
+        }
+
+        default: {
+          nonTerminalNodeVerified = super.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, collections, localContext, verifyAhead);
+
+          break;
+        }
+      }
+    }
+
+    return nonTerminalNodeVerified;
+  }
+}
+
+const equalityNodesVerifier = new EqualityNodesVerifier();
+
+export default equalityNodesVerifier;

package/src/verifier/nodes/metastatementForMetavariable.js

@@ -8,7 +8,7 @@ import { METASTATEMENT_RULE_NAME } from "../../ruleNames";
 
 const metavariableNodeQuery = nodeQuery('/metastatement/metavariable!');
 
-export default class MetastatementForMetavariableNodesVerifier extends NodesVerifier {
+class MetastatementForMetavariableNodesVerifier extends NodesVerifier {
   verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, fileContextA, localMetaContextB, verifyAhead) {
     let nonTerminalNodeVerified = false;
 
@@ -68,16 +68,12 @@ export default class MetastatementForMetavariableNodesVerifier extends NodesVeri
 
       metavariableNodeVerified = metastatementNodeMatches;  ///
     } else {
-      const { createSubstitutions } = this.constructor;
+      const metavariableNode = metavariableNodeA, ///
+            metastatementNode = metastatementNodeB, ///
+            metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode),
+            substitution = metastatementForMetavariableSubstitution;  ///
 
-      if (createSubstitutions) {
-        const metavariableNode = metavariableNodeA, ///
-              metastatementNode = metastatementNodeB, ///
-              metastatementForMetavariableSubstitution = MetastatementForMetavariableSubstitution.fromMetavariableNodeAndMetastatementNode(metavariableNode, metastatementNode),
-              substitution = metastatementForMetavariableSubstitution;  ///
-
-        substitutions.push(substitution);
-      }
+      substitutions.push(substitution);
 
       metavariableNodeVerified = true;
     }
@@ -85,3 +81,7 @@ export default class MetastatementForMetavariableNodesVerifier extends NodesVeri
     return metavariableNodeVerified;
   }
 }
+
+const metastatementForMetavariableNodesVerifier = new MetastatementForMetavariableNodesVerifier();
+
+export default metastatementForMetavariableNodesVerifier;