occam-verify-cli 0.0.1089 → 0.0.1091

package/src/unifier/metaLevel.js

@@ -16,12 +16,12 @@ const termNodeQuery = nodeQuery("/term"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
 
 class MetaLevelUnifier extends Unifier {
-  unify(nodeA, nodeB, substitutions, localContextA, localContextB) {
+  unify(generalNode, specificNode, substitutions, generalContext, specificContext) {
     let unifiedAtMetaLevel;
 
-    const nonTerminalNodeA = nodeA, ///
-          nonTerminalNodeB = nodeB, ///
-          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, substitutions, localContextA, localContextB);
+    const generalNonTerminalNode = generalNode, ///
+          specificNonTerminalNode = specificNode, ///
+          nonTerminalNodeUnified = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
 
     unifiedAtMetaLevel = nonTerminalNodeUnified; ///
 
@@ -30,43 +30,43 @@ class MetaLevelUnifier extends Unifier {
 
   static maps = [
     {
-      nodeQueryA: statementNodeQuery,
-      nodeQueryB: statementNodeQuery,
-      unify: (statementNodeA, statementNodeB, substitutions, localContextA, localContextB) => {
+      generalNodeQuery: statementNodeQuery,
+      specificNodeQuery: statementNodeQuery,
+      unify: (generalStatementNode, specificStatementNode, substitutions, generalContext, specificContext) => {
         let statementUnified;
 
-        const matches = statementNodeA.match(statementNodeB);
+        const matches = generalStatementNode.match(specificStatementNode);
 
         if (matches) {
           statementUnified = true;
         } else {
-          let localContext,
+          let context,
               statementNode;
 
-          localContext = localContextA; ///
+          context = generalContext; ///
 
-          statementNode = statementNodeA; ///
+          statementNode = generalStatementNode; ///
 
           const statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
 
           if (statementMetavariableNode !== null) {
-            const substitution = FrameForMetavariableSubstitution.fromStatementNode(statementNode, localContext) ||
-                                   TermForVariableSubstitution.fromStatementNode(statementNode, localContext) ||
+            const substitution = FrameForMetavariableSubstitution.fromStatementNode(statementNode, context) ||
+                                   TermForVariableSubstitution.fromStatementNode(statementNode, context) ||
                                      null;
 
             const { Statement } = shim,
                   metavariableNode = statementMetavariableNode, ///
-                  metavariable = localContextA.findMetavariableByMetavariableNode(metavariableNode, localContextB);
+                  metavariable = generalContext.findMetavariableByMetavariableNode(metavariableNode, specificContext);
 
-            localContext = localContextB; ///
+            context = specificContext; ///
 
-            statementNode = statementNodeB; ///
+            statementNode = specificStatementNode; ///
 
-            const statement = Statement.fromStatementNode(statementNode, localContext);
+            const statement = Statement.fromStatementNode(statementNode, context);
 
-            statementUnified = metavariable.unifyStatement(statement, substitution, substitutions, localContext);
+            statementUnified = metavariable.unifyStatement(statement, substitution, substitutions, generalContext, specificContext);
           } else {
-            statementUnified = unifyChildNodes(statementNodeA, statementNodeB, substitutions, localContextA, localContextB);
+            statementUnified = unifyChildNodes(generalStatementNode, specificStatementNode, substitutions, generalContext, specificContext);
           }
         }
 
@@ -74,45 +74,59 @@ class MetaLevelUnifier extends Unifier {
       }
     },
     {
-      nodeQueryA: frameMetavariableNodeQuery,
-      nodeQueryB: frameNodeQuery,
-      unify: (frameMetavariableNodeA, frameNodeB, substitutions, localContextA, localContextB) => {
+      generalNodeQuery: frameMetavariableNodeQuery,
+      specificNodeQuery: frameNodeQuery,
+      unify: (generalFrameMetavariableNode, specificFrameNode, substitutions, generalContext, specificContext) => {
         let frameUnified = false;
 
-        const metavariableNode = frameMetavariableNodeA,  ///
-              metavariablePresent = localContextA.isMetavariablePresentByMetavariableNode(metavariableNode, localContextB);
+        const metavariableNode = generalFrameMetavariableNode,  ///
+              metavariablePresent = generalContext.isMetavariablePresentByMetavariableNode(metavariableNode, generalContext, specificContext);
 
         if (metavariablePresent) {
+          let context;
+
           const { Frame, Metavariable } = shim,
-                localContext = localContextB, ///
-                frameNode = frameNodeB, ///
-                metavariable = Metavariable.fromMetavariableNode(metavariableNode, localContextA),
-                frame = Frame.fromFrameNode(frameNode, localContextB);
+                frameNode = specificFrameNode; ///
+
+          context = generalContext; ///
+
+          const metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);
+
+          context = specificContext;  ///
+
+          const frame = Frame.fromFrameNode(frameNode, context);
 
-          frameUnified = metavariable.unifyFrame(frame, substitutions, localContext);
+          frameUnified = metavariable.unifyFrame(frame, substitutions, generalContext, specificContext);
         }
 
         return frameUnified;
       }
     },
     {
-      nodeQueryA: termVariableNodeQuery,
-      nodeQueryB: termNodeQuery,
-      unify: (termVariableNodeA, termNodeB, substitutions, localContextA, localContextB) => {
+      generalNodeQuery: termVariableNodeQuery,
+      specificNodeQuery: termNodeQuery,
+      unify: (termVariableNodeA, termNodeB, substitutions, generalContext, specificContext) => {
         let termUnified = false;
 
         const variableNode = termVariableNodeA, ///
               variableName = variableNameFromVariableNode(variableNode),
-              variablePresent = localContextA.isVariablePresentByVariableName(variableName);
+              variablePresent = generalContext.isVariablePresentByVariableName(variableName);
 
         if (variablePresent) {
+          let context;
+
           const { Term, Variable } = shim,
-                localContext = localContextB, ///
-                termNode = termNodeB, ///
-                variable = Variable.fromVariableNode(variableNode, localContextA),
-                term = Term.fromTermNode(termNode, localContextB);
+                termNode = termNodeB; ///
+
+          context = generalContext; ///
+
+          const variable = Variable.fromVariableNode(variableNode, context);
+
+          context = specificContext;  ///
+
+          const term = Term.fromTermNode(termNode, context);
 
-          termUnified = variable.unifyTerm(term, substitutions, localContext);
+          termUnified = variable.unifyTerm(term, substitutions, generalContext, specificContext);
         }
 
         return termUnified;
@@ -125,14 +139,14 @@ const metaLevelUnifier = new MetaLevelUnifier();
 
 export default metaLevelUnifier;
 
-function unifyChildNodes(statementNodeA, statementNodeB, substitutions, localContextA, localContextB) {
-  const nonTerminalNodeA = statementNodeA, ///
-        nonTerminalNodeB = statementNodeB, ///
-        nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
-        nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
-        childNodesA = nonTerminalNodeAChildNodes, ///
-        childNodesB = nonTerminalNodeBChildNodes, ///
-        childNodesVerified = metaLevelUnifier.unifyChildNodes(childNodesA, childNodesB, substitutions, localContextA, localContextB),
+function unifyChildNodes(generalStatementNode, specificStatementNode, substitutions, generalContext, specificContext) {
+  const generalNonTerminalNode = generalStatementNode, ///
+        specificNonTerminalNode = specificStatementNode, ///
+        generalNonTerminalNodeChildNodes = generalNonTerminalNode.getChildNodes(),
+        specificNonTerminalNodeChildNodes = specificNonTerminalNode.getChildNodes(),
+        generalChildNodes = generalNonTerminalNodeChildNodes, ///
+        specificChildNodes = specificNonTerminalNodeChildNodes, ///
+        childNodesVerified = metaLevelUnifier.unifyChildNodes(generalChildNodes, specificChildNodes, substitutions, generalContext, specificContext),
         statementUnified = childNodesVerified; ///
 
   return statementUnified;

package/src/unifier/metavariable.js

@@ -10,12 +10,12 @@ const typeNodeQuery = nodeQuery("/type"),
       termNodeQuery = nodeQuery("/term");
 
 class MetavariableUnifier extends Unifier {
-  unify(metavariableNodeA, metavariableNodeB, localContext) {
+  unify(generalMetavariableNode, specificMetavariableNode, generalContext, specificContext) {
     let metavariableUnified;
 
-    const nonTerminalNodeA = metavariableNodeA, ///
-          nonTerminalNodeB = metavariableNodeB, ///
-          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext);
+    const generalNonTerminalNode = generalMetavariableNode, ///
+          specificNonTerminalNode = specificMetavariableNode, ///
+          nonTerminalNodeUnified = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, generalContext, specificContext);
 
     metavariableUnified = nonTerminalNodeUnified; ///
 
@@ -24,20 +24,29 @@ class MetavariableUnifier extends Unifier {
 
   static maps = [
     {
-      nodeQueryA: typeNodeQuery,
-      nodeQueryB: termNodeQuery,
-      unify: (typeNodeA, termNodeB, localContext) => {
+      generalNodeQuery: typeNodeQuery,
+      specificNodeQuery: termNodeQuery,
+      unify: (generalTypeNode, specificTermNode, generalContext, specificContext) => {
         let termUnified = false;
 
         const { Term } = shim,
-              typeNode = typeNodeA, ///
-              typeName = typeNameFromTypeNode(typeNode),
-              type = localContext.findTypeByTypeName(typeName);
+              typeNode = generalTypeNode, ///
+              typeName = typeNameFromTypeNode(typeNode);
+
+        const type = generalContext.findTypeByTypeName(typeName);
 
         if (type !== null) {
-          const termNode = termNodeB, ///
-                term = Term.fromTermNode(termNode, localContext),
-                termVerifiedGivenType = term.verifyGivenType(type, localContext);
+          let context;
+
+          const termNode = specificTermNode; ///
+
+          context = generalContext; ///
+
+          const term = Term.fromTermNode(termNode, context);
+
+          context = specificContext; ///
+
+          const termVerifiedGivenType = term.verifyGivenType(type, context);
 
           if (termVerifiedGivenType) {
             termUnified = true;

package/src/unifier/statementWithCombinator.js

@@ -13,12 +13,12 @@ const termNodeQuery = nodeQuery("/term"),
       statementNodeQuery = nodeQuery("/statement");
 
 class StatementWithCombinatorUnifier extends Unifier {
-  unify(combinatorStatementNode, statementNode, assignments, stated, localContext) {
+  unify(combinatorStatementNode, statementNode, assignments, stated, context) {
     let statementUnifiedWithCombinator;
 
-    const nonTerminalNodeA = combinatorStatementNode, ///
-          nonTerminalNodeB = statementNode, ///
-          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, assignments, stated, localContext);
+    const generalNonTerminalNode = combinatorStatementNode, ///
+          specificNonTerminalNode = statementNode, ///
+          nonTerminalNodeUnified = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, assignments, stated, context);
 
     statementUnifiedWithCombinator = nonTerminalNodeUnified; ///
 
@@ -27,17 +27,17 @@ class StatementWithCombinatorUnifier extends Unifier {
 
   static maps = [
     {
-      nodeQueryA: metaTypeNodeQuery,
-      nodeQueryB: statementNodeQuery,
-      unify: (metaTypeNodeA, statementNodeB, assignments, stated, localContext) => {
+      generalNodeQuery: metaTypeNodeQuery,
+      specificNodeQuery: statementNodeQuery,
+      unify: (generalMetaTypeNode, specificStatementNode, assignments, stated, context) => {
         let unified;
 
         const { Statement, MetaType } = shim,
-              metaTypeNode = metaTypeNodeA, ///
-              statementNode = statementNodeB, ///
-              metaType = MetaType.fromMetaTypeNode(metaTypeNode, localContext),
-              statement = Statement.fromStatementNode(statementNode, localContext),
-              statementVerifiedGivenType = statement.verifyGivenMetaType(metaType, assignments, stated, localContext);
+              metaTypeNode = generalMetaTypeNode, ///
+              statementNode = specificStatementNode, ///
+              metaType = MetaType.fromMetaTypeNode(metaTypeNode, context),
+              statement = Statement.fromStatementNode(statementNode, context),
+              statementVerifiedGivenType = statement.verifyGivenMetaType(metaType, assignments, stated, context);
 
         unified = statementVerifiedGivenType;
 
@@ -45,17 +45,17 @@ class StatementWithCombinatorUnifier extends Unifier {
       }
     },
     {
-      nodeQueryA: metaTypeNodeQuery,
-      nodeQueryB: frameNodeQuery,
-      unify: (metaTypeNodeA, frameNodeB, assignments, stated, localContext) => {
+      generalNodeQuery: metaTypeNodeQuery,
+      specificNodeQuery: frameNodeQuery,
+      unify: (generalMetaTypeNode, specificFrameNode, assignments, stated, context) => {
         let unified;
 
         const { Frame, MetaType } = shim,
-              metaTypeNode = metaTypeNodeA, ///
-              frameNode = frameNodeB, ///
-              metaType = MetaType.fromMetaTypeNode(metaTypeNode, localContext),
-              frame = Frame.fromFrameNode(frameNode, localContext),
-              frameVerifiedGivenType = frame.verifyGivenMetaType(metaType, assignments, stated, localContext);
+              metaTypeNode = generalMetaTypeNode, ///
+              frameNode = specificFrameNode, ///
+              metaType = MetaType.fromMetaTypeNode(metaTypeNode, context),
+              frame = Frame.fromFrameNode(frameNode, context),
+              frameVerifiedGivenType = frame.verifyGivenMetaType(metaType, assignments, stated, context);
 
         unified = frameVerifiedGivenType;
 
@@ -63,20 +63,20 @@ class StatementWithCombinatorUnifier extends Unifier {
       }
     },
     {
-      nodeQueryA: typeNodeQuery,
-      nodeQueryB: termNodeQuery,
-      unify: (typeNodeA, termNodeB, assignments, stated, localContext) => {
+      generalNodeQuery: typeNodeQuery,
+      specificNodeQuery: termNodeQuery,
+      unify: (generalTypeNode, specificTermNode, assignments, stated, context) => {
         let unified = false;
 
         const { Term } = shim,
-              typeNode = typeNodeA, ///
+              typeNode = generalTypeNode, ///
               typeName = typeNameFromTypeNode(typeNode),
-              type = localContext.findTypeByTypeName(typeName);
+              type = context.findTypeByTypeName(typeName);
 
         if (type !== null) {
-          const termNode = termNodeB, ///
-                term = Term.fromTermNode(termNode, localContext),
-                termVerifiedGivenType = term.verifyGivenType(type, localContext);
+          const termNode = specificTermNode, ///
+                term = Term.fromTermNode(termNode, context),
+                termVerifiedGivenType = term.verifyGivenType(type, context);
 
           if (termVerifiedGivenType) {
             unified = true;

package/src/unifier/termWithConstructor.js

@@ -10,12 +10,12 @@ const termNodeQuery = nodeQuery("/term"),
       typeNodeQuery = nodeQuery("/type");
 
 class TermWithConstructorUnifier extends Unifier {
-  unify(constructorTermNode, termNode, localContext) {
+  unify(constructorTermNode, termNode, context) {
     let termUnifiedWithConstructor;
 
-    const nonTerminalNodeA = constructorTermNode, ///
-          nonTerminalNodeB = termNode, ///
-          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext);
+    const generalNonTerminalNode = constructorTermNode, ///
+          specificNonTerminalNode = termNode, ///
+          nonTerminalNodeUnified = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, context);
 
     termUnifiedWithConstructor = nonTerminalNodeUnified; ///
 
@@ -26,18 +26,18 @@ class TermWithConstructorUnifier extends Unifier {
     {
       nodeQueryA: typeNodeQuery,
       nodeQueryB: termNodeQuery,
-      unify: (typeNodeB, termNodeB, localContext) => {
+      unify: (typeNodeB, termNodeB, context) => {
         let unified = false;
 
         const { Term } = shim,
               typeNode = typeNodeB, ///
               typeName = typeNameFromTypeNode(typeNode),
-              type = localContext.findTypeByTypeName(typeName);
+              type = context.findTypeByTypeName(typeName);
 
         if (type !== null) {
           const termNode = termNodeB, ///
-                term = Term.fromTermNode(termNode, localContext),
-                termVerifiedGivenType = term.verifyGivenType(type, localContext);
+                term = Term.fromTermNode(termNode, context),
+                termVerifiedGivenType = term.verifyGivenType(type, context);
 
           if (termVerifiedGivenType) {
             unified = true;

package/src/unifier.js

@@ -7,36 +7,36 @@ import { terminalNodeMapFromNodes, areTerminalNodeMapsEqual } from "./utilities/
 const nonTerminalNodeQuery = nodeQuery("/*");
 
 export default class Unifier {
-  unify(nodeA, nodeB, ...remainingArguments) {
+  unify(generalNode, specificNode, ...remainingArguments) {
     let unified;
 
-    const nodeUnified = this.unifyNode(nodeA, nodeB, ...remainingArguments);
+    const nodeUnified = this.unifyNode(generalNode, specificNode, ...remainingArguments);
 
     unified = nodeUnified;  ///
 
     return unified;
   }
 
-  unifyNode(nodeA, nodeB, ...remainingArguments) {
+  unifyNode(generalNode, specificNode, ...remainingArguments) {
     let nodeUnified = false;
 
-    const nodeATerminalNode = nodeA.isTerminalNode(),
-          nodeBTerminalNode = nodeB.isTerminalNode(),
-          nodeANonTerminalNode = nodeA.isNonTerminalNode(),
-          nodeBNonTerminalNode = nodeB.isNonTerminalNode();
+    const generalNodeTerminalNode = generalNode.isTerminalNode(),
+          specificNodeTerminalNode = specificNode.isTerminalNode(),
+          generalNodeNonTerminalNode = generalNode.isNonTerminalNode(),
+          specificNodeNonTerminalNode = specificNode.isNonTerminalNode();
 
     if (false) {
       ///
-    } else if (nodeATerminalNode && nodeBTerminalNode) {
-      const terminalNodeA = nodeA,  ///
-            terminalNodeB = nodeB,  ///
-            terminalNodeUnified = this.unifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments);
+    } else if (generalNodeTerminalNode && specificNodeTerminalNode) {
+      const generalTerminalNode = generalNode,  ///
+            specificTerminalNode = specificNode,  ///
+            terminalNodeUnified = this.unifyTerminalNode(generalTerminalNode, specificTerminalNode, ...remainingArguments);
 
       nodeUnified = terminalNodeUnified;  ///
-    } else if (nodeANonTerminalNode && nodeBNonTerminalNode) {
-      const nonTerminalNodeA = nodeA,  ///
-            nonTerminalNodeB = nodeB, ///
-            nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments);
+    } else if (generalNodeNonTerminalNode && specificNodeNonTerminalNode) {
+      const generalNonTerminalNode = generalNode,  ///
+            specificNonTerminalNode = specificNode, ///
+            nonTerminalNodeUnified = this.unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, ...remainingArguments);
 
       nodeUnified = nonTerminalNodeUnified; ///
     }
@@ -44,31 +44,31 @@ export default class Unifier {
     return nodeUnified;
   }
 
-  unifyChildNodes(childNodesA, childNodesB, ...remainingArguments) {
+  unifyChildNodes(generalChildNodes, specificChildNodes, ...remainingArguments) {
     let childNodesUnified = false;
 
-    const childNodesALength = childNodesA.length,
-          childNodesBLength = childNodesB.length;
+    const generalChildNodesLength = generalChildNodes.length,
+          specificChildNodesLength = specificChildNodes.length;
 
-    if (childNodesALength === childNodesBLength) {
-      const childTerminalNodeMapA = terminalNodeMapFromNodes(childNodesA),
-            childTerminalNodeMapB = terminalNodeMapFromNodes(childNodesB),
-            terminalNodeMapsEqual = areTerminalNodeMapsEqual(childTerminalNodeMapA, childTerminalNodeMapB);
+    if (generalChildNodesLength === specificChildNodesLength) {
+      const specificTerminalNodeMap = terminalNodeMapFromNodes(specificChildNodes),
+            generalTerminalNodeMap = terminalNodeMapFromNodes(generalChildNodes),
+            terminalNodeMapsEqual = areTerminalNodeMapsEqual(generalTerminalNodeMap, specificTerminalNodeMap);
 
       if (terminalNodeMapsEqual) {
         const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
 
         if (lastRemainingArgumentFunction) {
           const index = 0,
-                childNodesUnifiedAhead = this.unifyChildNodesAhead(index, childNodesA, childNodesB,...remainingArguments);
+                childNodesUnifiedAhead = this.unifyChildNodesAhead(index, generalChildNodes, specificChildNodes,...remainingArguments);
 
           childNodesUnified = childNodesUnifiedAhead; ///
         } else {
-          childNodesUnified = childNodesA.every((childNodeA, index) => {
-            const childNodeB = childNodesB[index],
-                  nodeA = childNodeA, ///
-                  nodeB = childNodeB, ///
-                  nodeUnified = this.unifyNode(nodeA, nodeB, ...remainingArguments);
+          childNodesUnified = generalChildNodes.every((generalChildNode, index) => {
+            const specificChildNode = specificChildNodes[index],
+                  specificNode = specificChildNode, ///
+                  generalNode = generalChildNode, ///
+                  nodeUnified = this.unifyNode(generalNode, specificNode, ...remainingArguments);
 
             if (nodeUnified) {
               return true;
@@ -81,7 +81,7 @@ export default class Unifier {
     return childNodesUnified;
   }
 
-  unifyTerminalNode(terminalNodeA, terminalNodeB, ...remainingArguments) { ///
+  unifyTerminalNode(generalTerminalNode, specificTerminalNode, ...remainingArguments) { ///
     let terminalNodeUnified;
 
     const lastRemainingArgumentFunction = isLastRemainingArgumentFunction(remainingArguments);
@@ -100,7 +100,7 @@ export default class Unifier {
     return terminalNodeUnified;
   }
 
-  unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, ...remainingArguments) {
+  unifyNonTerminalNode(generalNonTerminalNode, specificNonTerminalNode, ...remainingArguments) {
     let nonTerminalNodeUnified;
 
     let { maps } = this.constructor;
@@ -108,20 +108,20 @@ export default class Unifier {
     maps = [ ///
       ...maps,
       {
-        nodeQueryA: nonTerminalNodeQuery,
-        nodeQueryB: nonTerminalNodeQuery,
-        unify: (nodeA, nobeB, ...remainingArguments) => {
+        generalNodeQuery: nonTerminalNodeQuery,
+        specificNodeQuery: nonTerminalNodeQuery,
+        unify: (generalNode, specificNode, ...remainingArguments) => {
           let nonTerminalNodeUnified;
 
-          const nonTerminalNodeARuleName = nonTerminalNodeA.getRuleName(), ///
-                nonTerminalNodeBRuleName = nonTerminalNodeB.getRuleName(); ///
+          const generalNonTerminalNodeRuleName = generalNonTerminalNode.getRuleName(), ///
+                specificNonTerminalNodeBRuleNam = specificNonTerminalNode.getRuleName(); ///
 
-          if (nonTerminalNodeARuleName === nonTerminalNodeBRuleName) {
-            const nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
-                  nonTerminalNodeBChildNodes = nonTerminalNodeB.getChildNodes(),
-                  childNodesA = nonTerminalNodeAChildNodes, ///
-                  childNodesB = nonTerminalNodeBChildNodes, ///
-                  childNodesUnified = this.unifyChildNodes(childNodesA, childNodesB, ...remainingArguments);
+          if (generalNonTerminalNodeRuleName === specificNonTerminalNodeBRuleNam) {
+            const generalNonTerminalNodeChildNodes = generalNonTerminalNode.getChildNodes(),
+                  specificNonTerminalNodeBChildNode = specificNonTerminalNode.getChildNodes(),
+                  generalChildNodes = generalNonTerminalNodeChildNodes, ///
+                  specificChildNodes = specificNonTerminalNodeBChildNode, ///
+                  childNodesUnified = this.unifyChildNodes(generalChildNodes, specificChildNodes, ...remainingArguments);
 
             nonTerminalNodeUnified = childNodesUnified; ///
           }
@@ -134,13 +134,13 @@ export default class Unifier {
     let nodeUnified = false;
 
     maps.some((map) => {
-      const { nodeQueryA, nodeQueryB, unify } = map;
+      const { generalNodeQuery, specificNodeQuery, unify } = map;
 
-      const nodeA = nodeQueryA(nonTerminalNodeA),  ///
-            nodeB = nodeQueryB(nonTerminalNodeB);  ///
+      const generalNode = generalNodeQuery(generalNonTerminalNode),  ///
+            specificNode = specificNodeQuery(specificNonTerminalNode);  ///
 
-      if ((nodeA !== null) && (nodeB !== null)) {
-        nodeUnified = unify(nodeA, nodeB, ...remainingArguments);
+      if ((generalNode !== null) && (specificNode !== null)) {
+        nodeUnified = unify(generalNode, specificNode, ...remainingArguments);
 
         return true;
       }
@@ -151,26 +151,26 @@ export default class Unifier {
     return nonTerminalNodeUnified;
   }
 
-  unifyChildNodesAhead(index, childNodesA, childNodesB, ...remainingArguments) {
+  unifyChildNodesAhead(index, generalChildNodes, specificChildNodes, ...remainingArguments) {
     let childNodesUnified;
 
     const unifyAhead = remainingArguments.pop(), ///
-          childNodesALength = childNodesA.length;
+          generalChildNodesLength = generalChildNodes.length;
 
-    if (index === childNodesALength) {
+    if (index === generalChildNodesLength) {
       const unifiedAhead = unifyAhead();
 
       childNodesUnified = unifiedAhead; ///
     } else {
-      const childNodeA = childNodesA[index],
-            childNodeB = childNodesB[index],
-            nodeA = childNodeA, ///
-            nodeB = childNodeB, ///
-            nodeUnified = this.unifyNode(nodeA, nodeB, ...remainingArguments, () => {
+      const generalChildNode = generalChildNodes[index],
+            specificChildNode = specificChildNodes[index],
+            generalNode = generalChildNode, ///
+            specificNode = specificChildNode, ///
+            nodeUnified = this.unifyNode(generalNode, specificNode, ...remainingArguments, () => {
               remainingArguments.push(unifyAhead); ///
 
               const aheadIndex = index + 1,
-                    childNodesUnifiedAhead = this.unifyChildNodesAhead(aheadIndex, childNodesA, childNodesB, ...remainingArguments);
+                    childNodesUnifiedAhead = this.unifyChildNodesAhead(aheadIndex, generalChildNodes, specificChildNodes, ...remainingArguments);
 
               return childNodesUnifiedAhead;
             });

package/src/utilities/assignments.js

@@ -1,8 +1,8 @@
 "use strict";
 
-export function assignAssignments(assignments, localContext) {
+export function assignAssignments(assignments, context) {
   const assignmentsAssigned = assignments.every((assigment) => {
-    const assignmentAssigned = assigment.assign(localContext);
+    const assignmentAssigned = assigment.assign(context);
 
     return assignmentAssigned
   });