occam-verify-cli 0.0.932 → 0.0.933

package/src/unifier/metaLevel.js

@@ -0,0 +1,109 @@
+"use strict";
+
+import Unifier from "../unifier";
+import unifyVariableAgainstTerm from "../unify/variableAgainstTerm";
+import unifyMetavariableAgainstStatement from "../unify/metavariableAgainstStatement";
+
+import { unify } from "../unifier";
+import { nodeQuery } from "../utilities/query";
+
+const termNodeQuery = nodeQuery("/term!"),
+      statementNodeQuery = nodeQuery("/statement!"),
+      nonTerminalNodeQuery = nodeQuery("/*"),
+      termVariableNodeQuery = nodeQuery("/term/variable!"),
+      statementSubstitutionNodeQuery = nodeQuery("/statement/substitution!"),
+      statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
+
+class MetaLevelUnifier extends Unifier {
+  unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, unifyAhead) {
+    let nonTerminalNodeUnified;
+
+    const nodeQueryMaps = [
+      {
+        nodeQueryA: statementMetavariableNodeQuery,
+        nodeQueryB: statementNodeQuery,
+        unify: (nodeA, nodeB, substitutions, localContextA, localContextB, unifyAhead) => {
+          let nonTerminalNodeUnified;
+
+          const statementNodeA = nonTerminalNodeA,  ///
+                statementNodeB = nodeB, ///
+                statementMetavariableNodeA = nodeA, ///
+                statementSubstitutionNodeA = statementSubstitutionNodeQuery(statementNodeA),
+                metavariableNodeUnifiedAgainstStatementNode =
+
+                  this.unifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementSubstitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, unifyAhead);
+
+          nonTerminalNodeUnified = metavariableNodeUnifiedAgainstStatementNode;  ///
+
+          return nonTerminalNodeUnified;
+        }
+      },
+      {
+        nodeQueryA: termVariableNodeQuery,
+        nodeQueryB: termNodeQuery,
+        unify: (nodeA, nodeB, substitutions, localContextA, localContextB, unifyAhead) => {
+          let nonTerminalNodeUnified;
+
+          const termNodeB = nodeB,  ///
+                termVariableNodeA = nodeA,  ///
+                termVariableNodeUnifiedAgainstTermNode =
+
+                  this.unifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, unifyAhead);
+
+          nonTerminalNodeUnified = termVariableNodeUnifiedAgainstTermNode;  ///
+
+          return nonTerminalNodeUnified;
+        }
+      },
+      {
+        nodeQueryA: nonTerminalNodeQuery,
+        nodeQueryB: nonTerminalNodeQuery,
+        unify: (nodeA, nodeB, substitutions, localContextA, localContextB, unifyAhead) => {
+          let nonTerminalNodeUnified;
+
+          const nonTerminalNodeA = nodeA, ///
+                nonTerminalNodeB = nodeB; ///
+
+          nonTerminalNodeUnified =
+
+            super.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, unifyAhead);
+
+          return nonTerminalNodeUnified;
+        }
+      }
+    ];
+
+    const nodesUnified = unify(nodeQueryMaps, nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, unifyAhead);
+
+    nonTerminalNodeUnified = nodesUnified;  ///
+
+    return nonTerminalNodeUnified;
+  }
+
+  unifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementSubstitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, unifyAhead) {
+    let metavariableNodeUnifiedAgainstStatementNode;
+
+    const substitutionNode = statementSubstitutionNodeA,  ///
+          metavariableNodeA = statementMetavariableNodeA, ///
+          metavariableUnifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, unifyAhead);
+
+    metavariableNodeUnifiedAgainstStatementNode = metavariableUnifiedAgainstStatement;  ///
+
+    return metavariableNodeUnifiedAgainstStatementNode;
+  }
+
+  unifyTermVariableNodeAgainstTermNode(termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, unifyAhead) {
+    let termVariableNodeUnifiedAgainstTermNode;
+
+    const variableNodeA = termVariableNodeA, ///
+          termUnifiedAgainstVariable = unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, unifyAhead);
+
+    termVariableNodeUnifiedAgainstTermNode = termUnifiedAgainstVariable;  ///
+
+    return termVariableNodeUnifiedAgainstTermNode;
+  }
+}
+
+const metaLevelUnifier = new MetaLevelUnifier();
+
+export default metaLevelUnifier;

package/src/unifier/statementAgainstCombinator.js

@@ -0,0 +1,104 @@
+"use strict";
+
+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 } = this,
+          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,76 @@
+"use strict";
+
+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 } = this,
+          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;
 }