occam-verify-cli 0.0.935 → 0.0.937

package/src/unifier/metaLevel.js

@@ -5,104 +5,71 @@ 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!");
+      substitutionNodeQuery = nodeQuery("/statement/substitution!"),
+      metavariableNodeQuery = nodeQuery("/statement/metavariable!");
 
 class MetaLevelUnifier extends Unifier {
-  unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, unifyAhead) {
-    let nonTerminalNodeUnified;
+  unify(nodeA, nodeB, substitutions, localContextA, localContextB) {
+    let unified;
 
-    const nodeQueryMaps = [
-      {
-        nodeQueryA: statementMetavariableNodeQuery,
-        nodeQueryB: statementNodeQuery,
-        unify: (nodeA, nodeB, substitutions, localContextA, localContextB, unifyAhead) => {
-          let nonTerminalNodeUnified;
+    const nonTerminalNodeA = nodeA, ///
+          nonTerminalNodeB = nodeB, ///
+          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB, () => {
+            const unifiedAhead = true;
 
-          const statementNodeA = nonTerminalNodeA,  ///
-                statementNodeB = nodeB, ///
-                statementMetavariableNodeA = nodeA, ///
-                statementSubstitutionNodeA = statementSubstitutionNodeQuery(statementNodeA),
-                metavariableNodeUnifiedAgainstStatementNode =
+            return unifiedAhead;
+          });
 
-                  this.unifyStatementMetavariableNodeAgainstStatementNode(statementMetavariableNodeA, statementSubstitutionNodeA, statementNodeB, substitutions, localContextA, localContextB, unifyAhead);
+    unified = nonTerminalNodeUnified; ///
 
-          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 unified;
+  }
 
-          return nonTerminalNodeUnified;
+  static maps = [
+    {
+      nodeQueryA: statementNodeQuery,
+      nodeQueryB: statementNodeQuery,
+      unify: (statementNodeA, statementNodeB, substitutions, localContextA, localContextB, unifyAhead) => {
+        let statementVerifiedAgainstStatement;
+
+        const metavariableNodeA = metavariableNodeQuery(statementNodeA);
+
+        if (metavariableNodeA !== null) {
+          const substitutionNodeA = substitutionNodeQuery(statementNodeA),
+                metavariableUnifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB, unifyAhead);
+
+          statementVerifiedAgainstStatement = metavariableUnifiedAgainstStatement;  ///
+        } else {
+          const nonTerminalNodeA = statementNodeA, ///
+                nonTerminalNodeB = statementNodeB, ///
+                nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
+                nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
+                childNodesA = nonTerminalNodeAChildNodes, ///
+                childNodesB = nonTerminalNodeBChildNodes, ///
+                childNodesVerified = metaLevelUnifier.unifyChildNodes(childNodesA, childNodesB, substitutions, localContextA, localContextB, unifyAhead);
+
+          statementVerifiedAgainstStatement = childNodesVerified; ///
         }
-      },
-      {
-        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;
-        }
+        return statementVerifiedAgainstStatement;
       }
-    ];
-
-    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;
-  }
+    },
+    {
+      nodeQueryA: termVariableNodeQuery,
+      nodeQueryB: termNodeQuery,
+      unify: (termVariableNodeA, termNodeB, substitutions, localContextA, localContextB, unifyAhead) => {
+        const variableNodeA = termVariableNodeA, ///
+              variableUnifiedAgainstTerm = unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB, unifyAhead);
+
+        return variableUnifiedAgainstTerm;
+      }
+    }
+  ];
 }
 
 const metaLevelUnifier = new MetaLevelUnifier();

package/src/unifier/statementAgainstCombinator.js

@@ -1,103 +1,53 @@
 "use strict";
 
-import shim from "../shim";
 import Unifier from "../unifier";
-import unifyArgumentAgainstArgument from "../unify/argumentAgainstArgument";
+import unifyTermAgainstType from "../unify/termAgainstType";
 import unifyStatementAgainstMetaType from "../unify/statementAgainstMetaType";
 
-import { unify } from "../unifier";
 import { nodeQuery } from "../utilities/query";
 
-const argumentNodeQuery = nodeQuery("/argument!"),
+const termNodeQuery = nodeQuery("/term!"),
+      typeNodeQuery = nodeQuery("/type!"),
       metaTypeNodeQuery = nodeQuery("/metaType!"),
-      statementNodeQuery = nodeQuery("/statement!"),
-      nonTerminalNodeQuery = nodeQuery("/*");
+      statementNodeQuery = nodeQuery("/statement!");
 
 class StatementAgainstCombinatorUnifier extends Unifier {
-  unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead) {
-    let nonTerminalNodeUnified;
+  unify(statementNode, combinatorStatementNode, localContext) {
+    let statementUnifiedAgainstCombinator;
 
-    const nodeQueryMaps = [
-      {
-        nodeQueryA: statementNodeQuery,
-        nodeQueryB: metaTypeNodeQuery,
-        unify: (nodeA, nodeB, localContext, unifyAhead) => {
-          let nonTerminalNodeUnified;
+    const nonTerminalNodeA = statementNode, ///
+          nonTerminalNodeB = combinatorStatementNode, ///
+          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, () => {
+            const unifiedAhead = true;
 
-          const metaTypeNodeB = nodeB,  ///
-                statementNodeA = nodeA, ///
-                statementUnifiedAgainstMetaType =
+            return unifiedAhead;
+          });
 
-                  this.unifyMetaArgumentStatementAgainstMetaType(statementNodeA, metaTypeNodeB, localContext, unifyAhead);
+    statementUnifiedAgainstCombinator = nonTerminalNodeUnified; ///
 
-          nonTerminalNodeUnified = statementUnifiedAgainstMetaType; ///
+    return statementUnifiedAgainstCombinator;
+  };
 
-          return nonTerminalNodeUnified;
-        }
-      },
-      {
-        nodeQueryA: argumentNodeQuery,
-        nodeQueryB: argumentNodeQuery,
-        unify: (nodeA, nodeB, localContext, unifyAhead) => {
-          let nonTerminalNodeUnified;
+  static maps = [
+    {
+      nodeQueryA: statementNodeQuery,
+      nodeQueryB: metaTypeNodeQuery,
+      unify: (statementNodeA, metaTypeNodeB, localContext, unifyAhead) => {
+        const statementUnifiedAgainstMetaType = unifyStatementAgainstMetaType(statementNodeA, metaTypeNodeB, localContext, unifyAhead);
 
-          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;
-        }
+        return statementUnifiedAgainstMetaType;
       }
-    ];
-
-    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;
-  }
+    },
+    {
+      nodeQueryA: termNodeQuery,
+      nodeQueryB: typeNodeQuery,
+      unify: (termNodeA, typeNodeB, localContext, unifyAhead) => {
+        const termUnifiedAgainstType = unifyTermAgainstType(termNodeA, typeNodeB, localContext, unifyAhead);
+
+        return termUnifiedAgainstType;
+      }
+    }
+  ];
 }
 
 const statementAgainstCombinatorUnifier = new StatementAgainstCombinatorUnifier();

package/src/unifier/termAgainstConstructor.js

@@ -1,75 +1,37 @@
 "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("/*");
+const termNodeQuery = nodeQuery("/term"),
+      typeNodeQuery = nodeQuery("/type");
 
 class TermAgainstConstructorUnifier extends Unifier {
-  unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead) {
-    let nonTerminalNodUnified;
+  unify(termNode, constructorTermNode, localContext, unifyAhead) {
+    let termUnifiedAgainstConstructor;
 
-    const nodeQueryMaps = [
-      {
-        nodeQueryA: termNodeQuery,
-        nodeQueryB: typeNodeQuery,
-        unify: (nodeA, nodeB, localContext, unifyAhead) => {
-          let nonTerminalNodUnified;
+    const nonTerminalNodeA = termNode, ///
+          nonTerminalNodeB = constructorTermNode, ///
+          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead);
 
-          const termNodeA = nodeA,  ///
-                typeNodeB = nodeB,  ///
-                termNodUnifiedAgainstTypeNode =
+    termUnifiedAgainstConstructor = nonTerminalNodeUnified; ///
 
-                  this.unifyTermNodeAgainstTypeNode(termNodeA, typeNodeB, localContext, unifyAhead);
+    return termUnifiedAgainstConstructor;
+  };
 
-          nonTerminalNodUnified = termNodUnifiedAgainstTypeNode;  ///
+  static maps = [
+    {
+      nodeQueryA: termNodeQuery,
+      nodeQueryB: typeNodeQuery,
+      unify: (termNodeA, typeNodeB, localContext, unifyAhead) => {
+        const termUnifiedAgainstType = unifyTermAgainstType(termNodeA, typeNodeB, localContext, unifyAhead);
 
-          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;
-        }
+        return termUnifiedAgainstType;
       }
-    ];
-
-    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();

package/src/unifier.js

@@ -1,8 +1,21 @@
 "use strict";
 
-import { terminalNodeMapFromNodes, areTerminalNodeMapsEqual } from "./utilities/terminalNodes";
+import { nodeQuery } from "./utilities/query";
+import { terminalNodeMapFromNodes, areTerminalNodeMapsEqual } from "./utilities/unifier";
+
+const nonTerminalNodeQuery = nodeQuery("/*");
 
 export default class Unifier {
+  unify(nodeA, nodeB, ...remainingArguments) {
+    let unified;
+
+    const nodeUnified = this.unifyNode(nodeA, nodeB, ...remainingArguments);
+
+    unified = nodeUnified;  ///
+
+    return unified;
+  }
+
   unifyNode(nodeA, nodeB, ...remainingArguments) {
     let nodeUnified = false;
 
@@ -64,20 +77,52 @@ export default class Unifier {
   }
 
   unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
-    let nonTerminalNodeUnified = false;
+    let nonTerminalNodeUnified;
 
-    const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
-          nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
+    let { maps } = this.constructor;
 
-    if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
-      const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
-            nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
-            childNodesA = nonTerminalNodeAChildNodes, ///
-            childNodesB = nonTerminalNodeBChildNodes, ///
-            childNodesUnified = this.unifyChildNodes(childNodesA, childNodesB, ...remainingArguments);
+    maps = [ ///
+      ...maps,
+      {
+        nodeQueryA: nonTerminalNodeQuery,
+        nodeQueryB: nonTerminalNodeQuery,
+        unify: (nodeA, nobeB, ...remainingArguments) => {
+          let nonTerminalNodeUnified;
 
-      nonTerminalNodeUnified = childNodesUnified; ///
-    }
+          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;
+        }
+      }
+    ]
+
+    let nodeUnified = false;
+
+    maps.some((map) => {
+      const { nodeQueryA, nodeQueryB, unify } = map;
+
+      const nodeA = nodeQueryA(nonTerminalNodeA),  ///
+            nodeB = nodeQueryB(nonTerminalNodeB);  ///
+
+      if ((nodeA !== null) && (nodeB !== null)) {
+        nodeUnified = unify(nodeA, nodeB, ...remainingArguments);
+
+        return true;
+      }
+    });
+
+    nonTerminalNodeUnified = nodeUnified; ///
 
     return nonTerminalNodeUnified;
   }
@@ -112,22 +157,3 @@ export default class Unifier {
     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/metavariableAgainstStatement.js

@@ -4,7 +4,7 @@ import TermForVariableSubstitution from "../substitution/termForVariable";
 import unifyStatementAgainstStatement from "../unify/statementAtainstStatement";
 import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
 
-export default function unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, unifyAhead) {
+export default function unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB, unifyAhead) {
   let metavariableUnifiedAgainstStatement = false;
 
   const substitution = substitutions.find((substitution) => {
@@ -18,8 +18,9 @@ export default function unifyMetavariableAgainstStatement(metavariableNodeA, sta
   if (substitution !== null) {
     const substitutionStatementNode = substitution.getStatementNode();
 
-    if (substitutionNode !== null) {
-      const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionNode(substitutionNode),
+    if (substitutionNodeA !== null) {
+      const substitutionNode = substitutionNodeA, ///
+            termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionNode(substitutionNode),
             localContext = localContextB,  ///
             substitution = termForVariableSubstitution, ///
             statementNodeA = substitutionStatementNode, ///
@@ -61,6 +62,7 @@ export default function unifyMetavariableAgainstStatement(metavariableNodeA, sta
     let unifiedAhead;
 
     const statementNode = statementNodeB, ///
+          substitutionNode = substitutionNodeA, ///
           metavariableNode = metavariableNodeA, ///
           statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromMetavariableNodeStatementNodeAndSubstitutionNode(metavariableNode, statementNode, substitutionNode),
           substitution = statementForMetavariableSubstitution;  ///

package/src/unify/statementAgainstMetaType.js

@@ -1,21 +1,26 @@
 "use strict";
 
+import shim from "../shim";
+
 import { nodeQuery } from "../utilities/query";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
 const metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type!");
 
-export default function unifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext, unifyAhead, verifyStatement) {
+export default function unifyStatementAgainstMetaType(statementNodeA, metaTypeNodeB, localContext, unifyAhead) {
   let statementVerifiedAgainstMetaType = false;
 
-  const metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
+  const metaTypeNode = metaTypeNodeB, ///
+        metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
         content = metaTypeTerminalNode.getContent();
 
   if (content === STATEMENT_META_TYPE_NAME) {
     let unifiedAhead = false;
 
-    const derived = false,
+    const { verifyStatement } = shim,
+          derived = false,
           assignments = [],
+          statementNode = statementNodeA, ///
           statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
     if (statementVerified) {

package/src/unify/statementAtainstStatement.js

@@ -19,15 +19,11 @@ export default function unifyStatementAgainstStatement(statementNodeA, statement
     substitutionsA.push(substitutionA);
   }
 
-  const nonTerminalNodeA = statementNodeA,  ///
-        nonTerminalNodeB = statementNodeB,  ///
-        nonTerminalNodeUnified = metaLevelUnifier.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutionsA, localContextA, localContextB, () => {
-          const verifiedAhead = true;
+  const nodeA = statementNodeA,  ///
+        nodeB = statementNodeB,  ///
+        unified = metaLevelUnifier.unify(nodeA, nodeB, substitutionsA, localContextA, localContextB);
 
-          return verifiedAhead;
-        });
-
-  if (nonTerminalNodeUnified) {
+  if (unified) {
     if (!transformed) {
       const substitutionB = termForVariableSubstitution,  ///
             substitutionsB = [

package/src/unify/termAgainstTerm.js

@@ -6,7 +6,7 @@ export default function unifyTermAgainstTerm(termNodeA, termNodeB, localContext,
   let termUnifiedAgainstTerm = false;
 
   const leftTermNode = termNodeA, ///
-        rightTermNode = termNodeB, ///
+        rightTermNode = termNodeB,  ///
         equivalences = localContext.getEquivalences(),
         termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, equivalences);
 

package/src/unify/termAgainstType.js

@@ -1,17 +1,21 @@
 "use strict";
 
+import shim from "../shim";
+
 import { first } from "../utilities/array";
 
-export default function unifyTermAgainstType(termNode, typeNode, localContext, unifyAhead, verifyTerm) {
+export default function unifyTermAgainstType(termNodeA, typeNodeB, localContext, unifyAhead) {
   let termUnifiedAgainstType;
 
-  const terms = [],
-        termVerified = verifyTerm(termNode, terms, localContext, () => {
+  const { verifyTerm } = shim,
+        terms = [],
+        termVerified = verifyTerm(termNodeA, terms, localContext, () => {
           let unifiedAhead = false;
 
           const firstTerm = first(terms),
                 term = firstTerm, ///
                 termType = term.getType(),
+                typeNode = typeNodeB, ///
                 type = localContext.findTypeByTypeNode(typeNode),
                 termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);