occam-verify-cli 0.0.932 → 0.0.934

package/src/unifier/statementAgainstCombinator.js

@@ -0,0 +1,105 @@
+"use strict";
+
+import shim from "../shim";
+import Unifier from "../unifier";
+import unifyArgumentAgainstArgument from "../unify/argumentAgainstArgument";
+import unifyStatementAgainstMetaType from "../unify/statementAgainstMetaType";
+
+import { unify } from "../unifier";
+import { nodeQuery } from "../utilities/query";
+
+const argumentNodeQuery = nodeQuery("/argument!"),
+      metaTypeNodeQuery = nodeQuery("/metaType!"),
+      statementNodeQuery = nodeQuery("/statement!"),
+      nonTerminalNodeQuery = nodeQuery("/*");
+
+class StatementAgainstCombinatorUnifier extends Unifier {
+  unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead) {
+    let nonTerminalNodeUnified;
+
+    const nodeQueryMaps = [
+      {
+        nodeQueryA: statementNodeQuery,
+        nodeQueryB: metaTypeNodeQuery,
+        unify: (nodeA, nodeB, localContext, unifyAhead) => {
+          let nonTerminalNodeUnified;
+
+          const metaTypeNodeB = nodeB,  ///
+                statementNodeA = nodeA, ///
+                statementUnifiedAgainstMetaType =
+
+                  this.unifyMetaArgumentStatementAgainstMetaType(statementNodeA, metaTypeNodeB, localContext, unifyAhead);
+
+          nonTerminalNodeUnified = statementUnifiedAgainstMetaType; ///
+
+          return nonTerminalNodeUnified;
+        }
+      },
+      {
+        nodeQueryA: argumentNodeQuery,
+        nodeQueryB: argumentNodeQuery,
+        unify: (nodeA, nodeB, localContext, unifyAhead) => {
+          let nonTerminalNodeUnified;
+
+          const argumentNodeA = nodeA,  ///
+                argumentNodeB = nodeB,  ///
+                argumentNodeUnifiedAgainstArgumentNode =
+
+                  this.unifyArgumentNodeAgainstArgumentNode(argumentNodeA, argumentNodeB, localContext, unifyAhead);
+
+          nonTerminalNodeUnified = argumentNodeUnifiedAgainstArgumentNode; ///
+
+          return nonTerminalNodeUnified;
+        }
+      },
+      {
+        nodeQueryA: nonTerminalNodeQuery,
+        nodeQueryB: nonTerminalNodeQuery,
+        unify: (nodeA, nodeB, localContext, unifyAhead) => {
+          let nonTerminalNodeUnified;
+
+          const nonTerminalNodeA = nodeA, ///
+                nonTerminalNodeB = nodeB; ///
+
+          nonTerminalNodeUnified =
+
+            super.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead);
+
+          return nonTerminalNodeUnified;
+        }
+      }
+    ];
+
+    const nodesUnified = unify(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead);
+
+    nonTerminalNodeUnified = nodesUnified;  ///
+
+    return nonTerminalNodeUnified;
+  }
+
+  unifyMetaArgumentStatementAgainstMetaType(statementNodeA, metaTypeNodeB, localContext, unifyAhead) {
+    let statementUnifiedAgainstMetaType;
+
+    const { verifyStatement } = shim,
+          metaTypeNode = metaTypeNodeB, ///
+          statementNode = statementNodeA;  ///
+
+    statementUnifiedAgainstMetaType = unifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext, unifyAhead, verifyStatement);
+
+    return statementUnifiedAgainstMetaType;
+  }
+
+  unifyArgumentNodeAgainstArgumentNode(argumentNodeA, argumentNodeB, localContext, unifyAhead) {
+    let argumentNodeUnifiedAgainstArgumentNode;
+
+    const argumentUnifiedAgainstArgument = unifyArgumentAgainstArgument(argumentNodeA, argumentNodeB, localContext, unifyAhead);
+
+    argumentNodeUnifiedAgainstArgumentNode = argumentUnifiedAgainstArgument; ///
+
+    return argumentNodeUnifiedAgainstArgumentNode;
+  }
+}
+
+const statementAgainstCombinatorUnifier = new StatementAgainstCombinatorUnifier();
+
+export default statementAgainstCombinatorUnifier;

package/src/unifier/termAgainstConstructor.js

@@ -0,0 +1,77 @@
+"use strict";
+
+import shim from "../shim";
+import Unifier from "../unifier";
+import unifyTermAgainstType from "../unify/termAgainstType";
+
+import { unify } from "../unifier";
+import { nodeQuery } from "../utilities/query";
+
+const termNodeQuery = nodeQuery("/argument/term!"),
+      typeNodeQuery = nodeQuery("/argument/type!"),
+      nonTerminalNodeQuery = nodeQuery("/*");
+
+class TermAgainstConstructorUnifier extends Unifier {
+  unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead) {
+    let nonTerminalNodUnified;
+
+    const nodeQueryMaps = [
+      {
+        nodeQueryA: termNodeQuery,
+        nodeQueryB: typeNodeQuery,
+        unify: (nodeA, nodeB, localContext, unifyAhead) => {
+          let nonTerminalNodUnified;
+
+          const termNodeA = nodeA,  ///
+                typeNodeB = nodeB,  ///
+                termNodUnifiedAgainstTypeNode =
+
+                  this.unifyTermNodeAgainstTypeNode(termNodeA, typeNodeB, localContext, unifyAhead);
+
+          nonTerminalNodUnified = termNodUnifiedAgainstTypeNode;  ///
+
+          return nonTerminalNodUnified;
+        }
+      },
+      {
+        nodeQueryA: nonTerminalNodeQuery,
+        nodeQueryB: nonTerminalNodeQuery,
+        unify: (nodeA, nodeB, localContext, unifyAhead) => {
+          let nonTerminalNodUnified;
+
+          const nonTerminalNodeA = nodeA, ///
+                nonTerminalNodeB = nodeB; ///
+
+          nonTerminalNodUnified =
+
+            super.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead);
+
+          return nonTerminalNodUnified;
+        }
+      }
+    ];
+
+    const nodesVerified = unify(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead);
+
+    nonTerminalNodUnified = nodesVerified;  ///
+
+    return nonTerminalNodUnified;
+  }
+
+  unifyTermNodeAgainstTypeNode(termNodeA, typeNodeB, localContext, unifyAhead) {
+    let termNodUnifiedAgainstTypeNode;
+
+    const { verifyTerm } = shim,
+          termNode = termNodeA, ///
+          typeNode = typeNodeB, ///
+          typeUnifiedAgainstTerm = unifyTermAgainstType(termNode, typeNode, localContext, unifyAhead, verifyTerm);
+
+    termNodUnifiedAgainstTypeNode = typeUnifiedAgainstTerm; ///
+
+    return termNodUnifiedAgainstTypeNode;
+  }
+}
+
+const termAgainstConstructorUnifier = new TermAgainstConstructorUnifier();
+
+export default termAgainstConstructorUnifier;

package/src/unifier.js

@@ -0,0 +1,133 @@
+"use strict";
+
+import { terminalNodeMapFromNodes, areTerminalNodeMapsEqual } from "./utilities/terminalNodes";
+
+export default class Unifier {
+  unifyNode(nodeA, nodeB, ...remainingArguments) {
+    let nodeUnified = false;
+
+    const nodeATerminalNode = nodeA.isTerminalNode(),
+          nodeBTerminalNode = nodeB.isTerminalNode(),
+          nodeANonTerminalNode = nodeA.isNonTerminalNode(),
+          nodeBNonTerminalNode = nodeB.isNonTerminalNode();
+
+    if (false) {
+      ///
+    } else if (nodeATerminalNode && nodeBTerminalNode) {
+      const terminalNodeA = nodeA,  ///
+            terminalNodeB = nodeB,  ///
+            terminalNodeUnified = this.unifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments);
+
+      nodeUnified = terminalNodeUnified;  ///
+    } else if (nodeANonTerminalNode && nodeBNonTerminalNode) {
+      const nonTerminalNodeA = nodeA,  ///
+            nonTerminalNodeB = nodeB, ///
+            nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments);
+
+      nodeUnified = nonTerminalNodeUnified; ///
+    }
+
+    return nodeUnified;
+  }
+
+  unifyChildNodes(childNodesA, childNodesB, ...remainingArguments) {
+    let childNodesUnified = false;
+
+    const childNodesALength = childNodesA.length,
+          childNodesBLength = childNodesB.length;
+
+    if (childNodesALength === childNodesBLength) {
+      const childTerminalNodeMapA = terminalNodeMapFromNodes(childNodesA),
+            childTerminalNodeMapB = terminalNodeMapFromNodes(childNodesB),
+            terminalNodeMapsEqual = areTerminalNodeMapsEqual(childTerminalNodeMapA, childTerminalNodeMapB);
+
+      if (terminalNodeMapsEqual) {
+        const index = 0,
+              childNodesVerifyAhead = this.unifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments);
+
+        childNodesUnified = childNodesVerifyAhead; ///
+      }
+    }
+
+    return childNodesUnified;
+  }
+
+  unifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) { ///
+    let terminalNodeUnified;
+
+    const unifyAhead = remainingArguments.pop(),
+          unifyiedAhead = unifyAhead();
+
+    terminalNodeUnified = unifyiedAhead;  ///
+
+    return terminalNodeUnified;
+  }
+
+  unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
+    let nonTerminalNodeUnified = false;
+
+    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
+          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
+
+    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
+      const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+            childNodesA = nonTerminalNodeAChildNodes, ///
+            childNodesB = nonTerminalNodeBChildNodes, ///
+            childNodesUnified = this.unifyChildNodes(childNodesA, childNodesB, ...remainingArguments);
+
+      nonTerminalNodeUnified = childNodesUnified; ///
+    }
+
+    return nonTerminalNodeUnified;
+  }
+
+  unifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments) {
+    let childNodesUnified;
+
+    const unifyAhead = remainingArguments.pop(), ///
+          childNodesALength = childNodesA.length;
+
+    if (index === childNodesALength) {
+      const unifyiedAhead = unifyAhead();
+
+      childNodesUnified = unifyiedAhead; ///
+    } else {
+      const childNodeA = childNodesA[index],
+            childNodeB = childNodesB[index],
+            nodeA = childNodeA, ///
+            nodeB = childNodeB, ///
+            nodeUnified = this.unifyNode(nodeA, nodeB, ...remainingArguments, () => {
+              remainingArguments.push(unifyAhead); ///
+
+              const aheadIndex = index + 1,
+                    childNodesVerifyAhead = this.unifyChildNodesAhead(aheadIndex, childNodesA, childNodesB, ...remainingArguments);
+
+              return childNodesVerifyAhead;
+            });
+
+      childNodesUnified = nodeUnified;  ///
+    }
+
+    return childNodesUnified;
+  }
+}
+
+export function unify(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
+  let unified = false;
+
+  nodeQueryMaps.some((nodeQueryMap) => {
+    const { nodeQueryA, nodeQueryB, unify } = nodeQueryMap;
+
+    const nodeA = nodeQueryA(nonTerminalNodeA),  ///
+          nodeB = nodeQueryB(nonTerminalNodeB);  ///
+
+    if ((nodeA !== null) && (nodeB !== null)) {
+      unified = unify(nodeA, nodeB, ...remainingArguments);
+
+      return true;
+    }
+  });
+
+  return unified;
+}

package/src/unify/argumentAgainstArgument.js

@@ -0,0 +1,15 @@
+"use strict";
+
+import termAgainstConstructorUnifier from "../unifier/termAgainstConstructor";
+
+export default function unifyArgumentAgainstArgument(argumentNodeA, argumentNodeB, localContext, unifyAhead) {
+  let argumentUnifiedAgainstArgument;
+
+  const nonTerminalNodeA = argumentNodeA, ///
+        nonTerminalNodeB = argumentNodeB, ///
+        nonTerminalNodeVerified = termAgainstConstructorUnifier.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead);
+
+  argumentUnifiedAgainstArgument = nonTerminalNodeVerified; ///
+
+  return argumentUnifiedAgainstArgument;
+}

package/src/{verify → unify}/metavariableAgainstStatement.js

@@ -1,11 +1,11 @@
 "use strict";
 
 import TermForVariableSubstitution from "../substitution/termForVariable";
-import verifyStatementAgainstStatement from "../verify/statementAtainstStatement";
+import unifyStatementAgainstStatement from "../unify/statementAtainstStatement";
 import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
 
-export default function verifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, verifyAhead) {
-  let metavariableVerifiedAgainstStatement = false;
+export default function unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, unifyAhead) {
+  let metavariableUnifiedAgainstStatement = false;
 
   const substitution = substitutions.find((substitution) => {
     const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
@@ -23,12 +23,12 @@ export default function verifyMetavariableAgainstStatement(metavariableNodeA, st
             localContext = localContextB,  ///
             substitution = termForVariableSubstitution, ///
             statementNodeA = substitutionStatementNode, ///
-            statementVerifiedAgainstStatement = verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
+            statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
 
-      if (statementVerifiedAgainstStatement) {
-        const verifiedAhead = verifyAhead();
+      if (statementUnifiedAgainstStatement) {
+        const unifiedAhead = unifyAhead();
 
-        metavariableVerifiedAgainstStatement = verifiedAhead;  ///
+        metavariableUnifiedAgainstStatement = unifiedAhead;  ///
       }
     } else {
       const substitutionSubstitution = substitution.getSubstitution();
@@ -40,25 +40,25 @@ export default function verifyMetavariableAgainstStatement(metavariableNodeA, st
 
         const localContext = localContextB,  ///
               substitution = substitutionSubstitution,
-              statementVerifiedAgainstStatement = verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
+              statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
 
-        if (statementVerifiedAgainstStatement) {
-          const verifiedAhead = verifyAhead();
+        if (statementUnifiedAgainstStatement) {
+          const unifiedAhead = unifyAhead();
 
-          metavariableVerifiedAgainstStatement = verifiedAhead;  ///
+          metavariableUnifiedAgainstStatement = unifiedAhead;  ///
         }
       } else {
         const substitutionMatchesStatementNodeB = substitution.matchStatementNode(statementNodeB);
 
         if (substitutionMatchesStatementNodeB) {
-          const verifiedAhead = verifyAhead();
+          const unifiedAhead = unifyAhead();
 
-          metavariableVerifiedAgainstStatement = verifiedAhead;  ///
+          metavariableUnifiedAgainstStatement = unifiedAhead;  ///
         }
       }
     }
   } else {
-    let verifiedAhead;
+    let unifiedAhead;
 
     const statementNode = statementNodeB, ///
           metavariableNode = metavariableNodeA, ///
@@ -67,14 +67,14 @@ export default function verifyMetavariableAgainstStatement(metavariableNodeA, st
 
     substitutions.push(substitution);
 
-    verifiedAhead = verifyAhead();
+    unifiedAhead = unifyAhead();
 
-    if (!verifiedAhead) {
+    if (!unifiedAhead) {
       substitutions.pop();
     }
 
-    metavariableVerifiedAgainstStatement = verifiedAhead;  ///
+    metavariableUnifiedAgainstStatement = unifiedAhead;  ///
   }
 
-  return metavariableVerifiedAgainstStatement;
+  return metavariableUnifiedAgainstStatement;
 }

package/src/{verify → unify}/statementAgainstMetaType.js

@@ -5,24 +5,24 @@ import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 const metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type!");
 
-export default function verifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext, verifyAhead, verifyStatement) {
+export default function unifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext, unifyAhead, verifyStatement) {
   let statementVerifiedAgainstMetaType = false;
 
   const metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
         content = metaTypeTerminalNode.getContent();
 
   if (content === STATEMENT_META_TYPE_NAME) {
-    let verifiedAhead = false;
+    let unifiedAhead = false;
 
     const derived = false,
           assignments = [],
           statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
     if (statementVerified) {
-      verifiedAhead = verifyAhead();
+      unifiedAhead = unifyAhead();
     }
 
-    statementVerifiedAgainstMetaType = verifiedAhead; ///
+    statementVerifiedAgainstMetaType = unifiedAhead; ///
   }
 
   return statementVerifiedAgainstMetaType;

package/src/{verify → unify}/statementAtainstStatement.js

@@ -1,12 +1,12 @@
 "use strict";
 
-import metaLevelNodesVerifier from "../verifier/nodes/metaLevel";
+import metaLevelUnifier from "../unifier/metaLevel";
 import TermForVariableSubstitution from "../substitution/termForVariable";
 
 import { push } from "../utilities/array";
 
-export default function verifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB) {
-  let statementVerifiedAgainstStatement = false;
+export default function unifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB) {
+  let statementUnifiedAgainstStatement = false;
 
   const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionAndSubstitutions(substitution, substitutions),
         transformed = termForVariableSubstitution.isTransformed(substitution);
@@ -21,13 +21,13 @@ export default function verifyStatementAgainstStatement(statementNodeA, statemen
 
   const nonTerminalNodeA = statementNodeA,  ///
         nonTerminalNodeB = statementNodeB,  ///
-        nonTerminalNodeVerified = metaLevelNodesVerifier.verifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutionsA, localContextA, localContextB, () => {
+        nonTerminalNodeUnified = metaLevelUnifier.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutionsA, localContextA, localContextB, () => {
           const verifiedAhead = true;
 
           return verifiedAhead;
         });
 
-  if (nonTerminalNodeVerified) {
+  if (nonTerminalNodeUnified) {
     if (!transformed) {
       const substitutionB = termForVariableSubstitution,  ///
             substitutionsB = [
@@ -39,10 +39,10 @@ export default function verifyStatementAgainstStatement(statementNodeA, statemen
       push(substitutions, substitutionsA);
     }
 
-    statementVerifiedAgainstStatement = true;
+    statementUnifiedAgainstStatement = true;
   }
 
-  return statementVerifiedAgainstStatement;
+  return statementUnifiedAgainstStatement;
 }
 
 function transformSubstitutions(substitutionsA, substitutionsB) {

package/src/{verify → unify}/termAgainstTerm.js

@@ -2,8 +2,8 @@
 
 import { areTermNodesEqual } from "../utilities/equivalences";
 
-export default function verifyTermAgainstTerm(termNodeA, termNodeB, localContext, verifyAhead) {
-  let termVerifiedAgainstTerm = false;
+export default function unifyTermAgainstTerm(termNodeA, termNodeB, localContext, unifyAhead) {
+  let termUnifiedAgainstTerm = false;
 
   const leftTermNode = termNodeA, ///
         rightTermNode = termNodeB, ///
@@ -11,10 +11,10 @@ export default function verifyTermAgainstTerm(termNodeA, termNodeB, localContext
         termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, equivalences);
 
   if (termNodesEqual) {
-    const verifiedAhead = verifyAhead();
+    const unifiedAhead = unifyAhead();
 
-    termVerifiedAgainstTerm = verifiedAhead;  ///
+    termUnifiedAgainstTerm = unifiedAhead;  ///
   }
 
-  return termVerifiedAgainstTerm;
+  return termUnifiedAgainstTerm;
 }

package/src/{verify → unify}/termAgainstType.js

@@ -2,12 +2,12 @@
 
 import { first } from "../utilities/array";
 
-export default function verifyTermAgainstType(termNode, typeNode, localContext, verifyAhead, verifyTerm) {
-  let termVerifiedAgainstType;
+export default function unifyTermAgainstType(termNode, typeNode, localContext, unifyAhead, verifyTerm) {
+  let termUnifiedAgainstType;
 
   const terms = [],
         termVerified = verifyTerm(termNode, terms, localContext, () => {
-          let verifiedAhead = false;
+          let unifiedAhead = false;
 
           const firstTerm = first(terms),
                 term = firstTerm, ///
@@ -16,13 +16,13 @@ export default function verifyTermAgainstType(termNode, typeNode, localContext,
                 termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
 
           if (termTypeEqualToOrSubTypeOfType) {
-            verifiedAhead = verifyAhead();
+            unifiedAhead = unifyAhead();
           }
 
-          return verifiedAhead;
+          return unifiedAhead;
         });
 
-  termVerifiedAgainstType = termVerified; ///
+  termUnifiedAgainstType = termVerified; ///
 
-  return termVerifiedAgainstType;
+  return termUnifiedAgainstType;
 }

package/src/{verify → unify}/variableAgainstTerm.js

@@ -8,8 +8,8 @@ import { nodeQuery } from "../utilities/query";
 
 const variableNodeQuery = nodeQuery("/term/variable");
 
-export default function verifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
-  let variableVerifiedAgainstTerm = false;
+export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, verifyAhead) {
+  let variableUnifiedAgainstTerm = false;
 
   const substitution = substitutions.find((substitution) => {
     const substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNodeA);
@@ -25,14 +25,14 @@ export default function verifyVariableAgainstTerm(variableNodeA, termNodeB, subs
     if (substitutionMatchesTermNodeB) {
       const verifiedAhead = verifyAhead();
 
-      variableVerifiedAgainstTerm = verifiedAhead;  ///
+      variableUnifiedAgainstTerm = verifiedAhead;  ///
     }
   } else {
     const variableA = localContextA.findVariableByVariableNode(variableNodeA);
 
     if (variableA !== null) {
       const terms = [],
-            termVerified = verifyTerm(termNodeB, terms, localContextB, () => {
+            termUnified = verifyTerm(termNodeB, terms, localContextB, () => {
               let verifiedAhead = false;
 
               const firstTerm = first(terms),
@@ -67,11 +67,11 @@ export default function verifyVariableAgainstTerm(variableNodeA, termNodeB, subs
               return verifiedAhead;
             });
 
-      variableVerifiedAgainstTerm = termVerified;  ///
+      variableUnifiedAgainstTerm = termUnified;  ///
     }
   }
 
-  return variableVerifiedAgainstTerm;
+  return variableUnifiedAgainstTerm;
 }
 
 function variableFromTerm(term, localContext) {

package/src/verifier/{node/metaLevel.js → metaLevel.js}

@@ -1,26 +1,26 @@
 "use strict";
 
-import NodeVerifier from "../../verifier/node";
+import Verifier from "../verifier";
 
-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 { verify } from "../verifier";
+import { nodeQuery } from "../utilities/query";
+import { verifyStandaloneTerm } from "../verify/term";
+import { verifyStandaloneVariable } from "../verify/variable";
+import { verifyStandaloneMetavariable } from "../verify/metavariable";
 
 const termNodeQuery = nodeQuery("/term!"),
       variableNodeQuery = nodeQuery("/variable!"),
       nonTerminalNodeQuery = nodeQuery("/*"),
       metavariableNodeQuery = nodeQuery("/metavariable!");
 
-class MetaLevelNodeVerifier extends NodeVerifier {
+class MetaLevelVerifier extends Verifier {
   verifyNonTerminalNode(nonTerminalNode, localContext, verifyAhead) {
     let nonTerminalNodeVerified;
 
     const nodeQueryMaps = [
       {
         nodeQuery: termNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const termNode = node, ///
@@ -33,7 +33,7 @@ class MetaLevelNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: variableNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const variableNode = node, ///
@@ -46,7 +46,7 @@ class MetaLevelNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: metavariableNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const metavariableNode = node, ///
@@ -59,7 +59,7 @@ class MetaLevelNodeVerifier extends NodeVerifier {
       },
       {
         nodeQuery: nonTerminalNodeQuery,
-        verifyNode: (node, localContext, verifyAhead) => {
+        verify: (node, localContext, verifyAhead) => {
           let nonTerminalNodeVerified;
 
           const nonTerminalNode = node; ///
@@ -73,7 +73,7 @@ class MetaLevelNodeVerifier extends NodeVerifier {
       }
     ];
 
-    const nodeVerified = verifyNode(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
+    const nodeVerified = verify(nodeQueryMaps, nonTerminalNode, localContext, verifyAhead);
 
     nonTerminalNodeVerified = nodeVerified; ///
 
@@ -102,6 +102,6 @@ class MetaLevelNodeVerifier extends NodeVerifier {
   }
 }
 
-const metaLevelNodeVerifier = new MetaLevelNodeVerifier();
+const metaLevelVerifier = new MetaLevelVerifier();
 
-export default metaLevelNodeVerifier;
+export default metaLevelVerifier;