occam-verify-cli 0.0.959 → 0.0.961

package/src/index.js

@@ -4,6 +4,6 @@ export { default as Log } from "./log";
 export { default as verifyRelease } from "./verify/release";
 export { default as ReleaseContext } from "./context/release";
 export { default as createReleaseContext } from "./releaseContext/create";
-export { default as verifyReleaseContext } from "./releaseContext/verify";
 export { default as customGrammarUtilities } from "./utilities/customGrammar";
+export { default as initialiseReleaseContext } from "./releaseContext/initialise";
 

package/src/metavariable.js

@@ -63,9 +63,9 @@ export default class Metavariable {
         } else if ((termNode === null) && (this.termType === null)) {
           matchesNode = true;
         } else if ((termNode !== null) && (this.termType !== null)) {
-          const termUnifiedAgainstTermType = unifyTermAgainstTermType(termNode, this.termType, localContext);
+          const termUnifiedWithTermType = unifyTermWithTermType(termNode, this.termType, localContext);
 
-          matchesNode = termUnifiedAgainstTermType;  ///
+          matchesNode = termUnifiedWithTermType;  ///
         }
       }
     }
@@ -90,8 +90,8 @@ export default class Metavariable {
   }
 }
 
-export function unifyTermAgainstTermType(termNode, termType, localContext) {
-  let termUnifiedAgainstTermType;
+export function unifyTermWithTermType(termNode, termType, localContext) {
+  let termUnifiedWithTermType;
 
   const type = termType,  ///
         terms = [],
@@ -110,9 +110,9 @@ export function unifyTermAgainstTermType(termNode, termType, localContext) {
           return verifiedAhead;
         });
 
-  termUnifiedAgainstTermType = termVerified;  ///
+  termUnifiedWithTermType = termVerified;  ///
 
-  return termUnifiedAgainstTermType;
+  return termUnifiedWithTermType;
 }
 
 function termTypeFromMetavariableNode(metavariableNode, fileContext) {

package/src/proofStep.js

@@ -17,27 +17,32 @@ export default class ProofStep {
     return this.statementNode;
   }
 
-  unifyStatement(statementNode, equivalences, localContextA, localContextB) {
+  unifyStatement(statementNodeB, equivalences, localContextA, localContextB) {
     let statementUnified = false;
 
     if (this.statementNode !== null) {
-      let statementUnifiedAgainstStatement = false;
+      let statementUnifiedWithStatement = false;
 
-      if (!statementUnifiedAgainstStatement) {
-        const statementNodeA = statementNode, ///
-              statementNodeB = this.statementNode;  ///
+      if (!statementUnifiedWithStatement) {
+        const statementNodeA = this.statementNode;  ///
 
-        statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
+        statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
       }
 
-      if (!statementUnifiedAgainstStatement) {
-        const statementNodeA = statementNode, ///
-              statementNodeB = this.statementNode;  ///
+      if (!statementUnifiedWithStatement) {
+        const statementNodeA = statementNodeB,  ///
+              localContext = localContextA; ///
 
-        statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
+        statementNodeB = this.statementNode;  ///
+
+        localContextA = localContextB;  ///
+
+        localContextB = localContext; ///
+
+        statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
       }
 
-      statementUnified = statementUnifiedAgainstStatement;  ///
+      statementUnified = statementUnifiedWithStatement;  ///
     }
 
     return statementUnified;
@@ -58,13 +63,13 @@ export default class ProofStep {
   }
 }
 
-function unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB) {
-  let statementUnifiedAgainstStatement = false;
+function unifyStatementWithStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB) {
+  let statementUnifiedWithStatement = false;
 
   const statementStringA = localContextA.nodeAsString(statementNodeA),
         statementStringB = localContextB.nodeAsString(statementNodeB);
 
-  localContextB.trace(`Unifying the '${statementStringB}' statement against the '${statementStringA}' statement...`, statementNodeB);
+  localContextB.trace(`Unifying the '${statementStringB}' statement with the '${statementStringA}' statement...`, statementNodeB);
 
   const substitutions = Substitutions.fromNothing(),
         nodeA = statementNodeA,  ///
@@ -72,14 +77,14 @@ function unifyStatementAgainstStatement(statementNodeA, statementNodeB, equivale
         unified = intrinsicLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
   if (unified) {
-    const substitutionsUnifiedAgainstEquivalences = substitutions.unifyAgainstEquivalences(equivalences, localContextA, localContextB);
+    const substitutionsUnifiedWithEquivalences = substitutions.unifyWithEquivalences(equivalences, localContextA, localContextB);
 
-    statementUnifiedAgainstStatement = substitutionsUnifiedAgainstEquivalences;  ///
+    statementUnifiedWithStatement = substitutionsUnifiedWithEquivalences;  ///
   }
 
-  if (statementUnifiedAgainstStatement) {
-    localContextB.debug(`...unified the '${statementStringB}' statement against the '${statementStringA}' statement.`, statementNodeB);
+  if (statementUnifiedWithStatement) {
+    localContextB.debug(`...unified the '${statementStringB}' statement with the '${statementStringA}' statement.`, statementNodeB);
   }
 
-  return statementUnifiedAgainstStatement;
+  return statementUnifiedWithStatement;
 }

package/src/releaseContext/create.js

@@ -12,11 +12,9 @@ export default function createReleaseContext(dependency, dependentNames, context
   log.debug(`Creating the '${releaseName}' context given the '${dependencyString}' dependency...`);
 
   if (releaseContext !== null) {
-    const error = null,
-          version = releaseContext.getVersion(),
-          versionString = version.toString();
+    const error = null;
 
-    log.debug(`...already created the '${releaseName}:${versionString}' context.`);
+    log.debug(`...already created the '${releaseName}' context.`);
 
     callback(error);
 
@@ -52,20 +50,17 @@ export default function createReleaseContext(dependency, dependentNames, context
       return;
     }
 
-    const version = releaseContext.getVersion(),
-          versionString = version.toString();
-
     releaseContextMap[releaseName] = releaseContext;
 
-    createDependencyReleaseContexts(dependency, dependentNames, context, (error) => {
+    log.info(`...created the '${releaseName}' context.`);
+
+    createDependencyReleaseContexts(dependency, releaseContext, dependentNames, context, (error) => {
       if (error) {
         callback(error);
 
         return;
       }
 
-      log.info(`...created the '${releaseName}@${versionString}' context.`);
-
       callback(error);
     });
   }, context);
@@ -122,7 +117,7 @@ function checkReleaseMatchesDependency(releaseContext, dependency, dependentName
             versionString = version.toString(),
             dependencyString = dependency.asString();
 
-      log.error(`Version mismatch: '${dependentName}' requires the '${dependencyString}' dependency but a context with version '${versionString}' was created.`);
+      log.warning(`Version mismatch: The '${dependentName}' dependent requires the '${dependencyString}' dependency but a context with version '${versionString}' was provided.`);
 
       releaseMatchesDependency = false;
     }
@@ -131,11 +126,8 @@ function checkReleaseMatchesDependency(releaseContext, dependency, dependentName
   return releaseMatchesDependency;
 }
 
-function createDependencyReleaseContexts(dependency, dependentNames, context, callback) {
-  const { releaseContextMap } = context,
-        dependencyName = dependency.getName(),
-        releaseName = dependencyName, ///
-        releaseContext = releaseContextMap[releaseName],
+function createDependencyReleaseContexts(dependency, releaseContext, dependentNames, context, callback) {
+  const dependencyName = dependency.getName(),
         dependencies = releaseContext.getDependencies();
 
   dependentNames = [ ...dependentNames, dependencyName ];  ///

package/src/releaseContext/{verify.js → initialise.js}

@@ -1,7 +1,7 @@
 "use strict";
 
-export default function verifyReleaseContext(dependency, dependentName, dependentReleased, context) {
-  let releaseContextVerified = false;
+export default function initialiseReleaseContext(dependency, dependentName, dependentReleased, context) {
+  let releaseContextInitialised = false;
 
   const { releaseContextMap } = context,
         dependencyName = dependency.getName(),
@@ -11,44 +11,37 @@ export default function verifyReleaseContext(dependency, dependentName, dependen
   if (releaseContext === null) {
     const { log } = context;
 
-    log.error(`Unable to verify the '${dependencyName}' dependency's context because it has not been created.`);
+    log.warning(`Unable to initialise the '${dependencyName}' ontext because it has not been created.`);
   } else {
-    const verified = releaseContext.isVerified();
+    releaseContextInitialised = releaseContext.isInitialised();
 
-    if (verified) {
-      releaseContextVerified = true;
-    } else {
+    if (!releaseContextInitialised) {
       const released = releaseContext.isReleased();
 
       if (!released && dependentReleased) {
         const { log } = context;
 
-        log.error(`Unable to verify the '${dependencyName}' dependency's context because its '${dependentName}' dependent is a package.`);
+        log.warning(`Unable to initialise the '${dependencyName}' dependency's context because its '${dependentName}' dependent is a package.`);
       } else {
-        const dependencies = releaseContext.getDependencies();
+        const dependencyReleaseContextsInitialised = initialiseDependencyReleaseContexts(dependency, releaseContext, released, context);
 
-        dependentName = dependencyName;  ///
+        if (dependencyReleaseContextsInitialised) {
+          const { log } = context,
+                releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap);
 
-        dependentReleased = released;  ///
+          log.debug(`Initialising the '${dependencyName}' context...`);
 
-        releaseContextVerified = dependencies.everyDependency((dependency) => {  ///
-          const releaseContextVerified = verifyReleaseContext(dependency, dependentName, dependentReleased, context);
+          releaseContextInitialised = releaseContext.initialise(releaseContexts);
 
-          if (releaseContextVerified) {
-            return true;
-          }
-        });
-
-        if (releaseContextVerified) {
-          const releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap);
-
-          releaseContext.verify(releaseContexts);
+          releaseContextInitialised ?
+            log.info(`...initialised the '${dependencyName}' context.`) :
+              log.warning(`...unable to initialise the '${dependencyName}' context.`);
         }
       }
     }
   }
 
-  return releaseContextVerified;
+  return releaseContextInitialised;
 }
 
 function retrieveReleaseContexts(releaseContext, releaseContextMap) {
@@ -87,3 +80,19 @@ function retrieveReleaseContexts(releaseContext, releaseContextMap) {
 
   return releaseContexts;
 }
+
+function initialiseDependencyReleaseContexts(dependency, releaseContext, released, context) {
+  const dependencyName = dependency.getName(),
+        dependentName = dependencyName,  ///
+        dependencies = releaseContext.getDependencies(),
+        dependentReleased = released,  ///
+        dependencyReleaseContextsInitialised = dependencies.everyDependency((dependency) => {  ///
+          const releaseContextInitialised = initialiseReleaseContext(dependency, dependentName, dependentReleased, context);
+
+          if (releaseContextInitialised) {
+            return true;
+          }
+        });
+
+  return dependencyReleaseContextsInitialised;
+}

package/src/rule.js

@@ -1,8 +1,8 @@
 "use strict";
 
 import Substitutions from "./substitutions";
-import unifyPremisesAgainstProofSteps from "./unify/premisesAgainstProofSteps";
-import unifyConclusionAgainstStatement from "./unify/conclusionAgainstStatement";
+import unifyPremisesWithProofSteps from "./unify/premisesWithProofSteps";
+import unifyConclusionWithStatement from "./unify/conclusionWithStatement";
 
 export default class Rule {
   constructor(labels, premises, conclusion, fileContext) {
@@ -37,11 +37,11 @@ export default class Rule {
           proofStepsB = proofSteps, ///
           fileContextA = this.fileContext,  ///
           localContextB = localContext, ///
-          premisesUnified = unifyPremisesAgainstProofSteps(premisesA, proofStepsB, substitutions, fileContextA, localContextB);
+          premisesUnified = unifyPremisesWithProofSteps(premisesA, proofStepsB, substitutions, fileContextA, localContextB);
 
     if (premisesUnified) {
       const conclusionA = this.conclusion,  ///
-            conclusionUnified = unifyConclusionAgainstStatement(conclusionA, statementNode, substitutions, fileContextA, localContextB);
+            conclusionUnified = unifyConclusionWithStatement(conclusionA, statementNode, substitutions, fileContextA, localContextB);
 
       statementUnified = conclusionUnified;  ///
     }

package/src/substitution/statementForMetavariable.js

@@ -3,7 +3,7 @@
 import shim from "../shim";
 import Substitution from "../substitution";
 import TermForVariableSubstitution from "./termForVariable";
-import unifyStatementAgainstStatement from "../unify/statementAtainstStatement";
+import unifyStatementWithStatement from "../unify/statementAtainstStatement";
 
 import { nodeQuery } from "../utilities/query";
 import { matchStatementModuloBrackets, bracketedStatementChildNodeFromStatementNode } from "../utilities/match";
@@ -74,8 +74,8 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return statementNodeMatches;
   }
 
-  unifyAgainstEquivalence(equivalence, substitutions, localContextA, localContextB) {
-    let unifiedAgainstEquivalence = false;  ///
+  unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {
+    let unifiedWithEquivalence = false;  ///
 
     const metavariableNode = metavariableNodeQuery(this.statementNode);
 
@@ -89,10 +89,10 @@ export default class StatementForMetavariableSubstitution extends Substitution {
             nodeB = metavariableNode, ///
             unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
 
-      unifiedAgainstEquivalence = unified; ///
+      unifiedWithEquivalence = unified; ///
     }
 
-    return unifiedAgainstEquivalence;
+    return unifiedWithEquivalence;
   }
 
   asString(localContextA, localContextB) {
@@ -156,9 +156,9 @@ function unifyStatement(statementNodeA, statementNodeB, substitution, substituti
 
     statementUnified = statementNodeAMatchesStatementNodeB; ///
   } else {
-    const statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
+    const statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB);
 
-    statementUnified = statementUnifiedAgainstStatement; ///
+    statementUnified = statementUnifiedWithStatement; ///
   }
 
   return statementUnified;

package/src/substitution/termForVariable.js

@@ -29,14 +29,21 @@ export default class TermForVariableSubstitution extends Substitution {
     return node;
   }
 
-  isTransformed(substitution) {
-    const termNod = substitution.getTermNode(),
-          variableNode = substitution.getVariableNode(),
-          termNodeMatches = this.termNode.match(termNod),
-          variableNodeMatches = this.variableNode.match(variableNode),
-          transformed = ((!termNodeMatches) && (!variableNodeMatches));
-
-    return transformed;
+  transformed(substitutions) {
+    let transformedSubstitution = null;
+
+    const transformedTermNode = transformTermNode(this.termNode, substitutions),
+          transformedVariableNode = transformVariableNode(this.variableNode, substitutions);
+
+    if ((transformedTermNode !== null) && (transformedVariableNode !== null)) {
+      const termNode = transformedTermNode, ///
+            variableNode = transformedVariableNode,
+            termForVariableSubstitution = new TermForVariableSubstitution(termNode, variableNode);
+
+      transformedSubstitution = termForVariableSubstitution;  ///
+    }
+
+    return transformedSubstitution;
   }
 
   matchTermNode(termNode) {
@@ -51,8 +58,8 @@ export default class TermForVariableSubstitution extends Substitution {
     return matchesVariableNode;
   }
 
-  unifyAgainstEquivalence(equivalence, substitutions, localContextA, localContextB) {
-    let unifiedAgainstEquivalence;
+  unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {
+    let unifiedWithEquivalence;
 
     const equivalenceMatchesVariableNode = equivalence.matchVariableNode(this.variableNode);
 
@@ -60,11 +67,11 @@ export default class TermForVariableSubstitution extends Substitution {
       const equivalenceMatchesTermNode = equivalence.matchTermNode(this.termNode);
 
       if (equivalenceMatchesTermNode) {
-        unifiedAgainstEquivalence = true;
+        unifiedWithEquivalence = true;
       }
     }
 
-    return unifiedAgainstEquivalence;
+    return unifiedWithEquivalence;
   }
 
   asString(localContextA, localContextB) {
@@ -95,22 +102,12 @@ export default class TermForVariableSubstitution extends Substitution {
     let termNode = substitution.getTermNode(),
         variableNode = substitution.getVariableNode();
 
-    termNode = substituteTermNode(termNode, substitutions); ///
+    const transformedTermNode = transformTermNode(termNode, substitutions),
+          transformedVariableNode = transformVariableNode(variableNode, substitutions); ///
 
-    variableNode = substituteVariableNode(variableNode, substitutions); ///
+    termNode = transformedTermNode; ///
 
-    const termForVariableSubstitution = new TermForVariableSubstitution(variableNode, termNode);
-
-    return termForVariableSubstitution;
-  }
-
-  static fromSubstitutionNodeAndSubstitutions(substitutionNode, substitutions) {
-    let termNode = termNodeQuery(substitutionNode),
-        variableNode = variableNodeQuery(substitutionNode);
-
-    termNode = substituteTermNode(termNode, substitutions); ///
-
-    variableNode = substituteVariableNode(variableNode, substitutions); ///
+    variableNode = transformedVariableNode; ///
 
     const termForVariableSubstitution = new TermForVariableSubstitution(variableNode, termNode);
 
@@ -118,7 +115,9 @@ export default class TermForVariableSubstitution extends Substitution {
   }
 }
 
-function substituteTermNode(termNode, substitutions) {
+function transformTermNode(termNode, substitutions) {
+  let transformedTermNode = null;
+
   const termVariableNode = variableNodeQuery(termNode);
 
   if (termVariableNode !== null) {
@@ -126,31 +125,35 @@ function substituteTermNode(termNode, substitutions) {
       const substitutionMatchesVariableNode = substitution.matchVariableNode(termVariableNode);
 
       if (substitutionMatchesVariableNode) {
-        termNode = substitution.getTermNode();  ///
+        const termNode = substitution.getTermNode();
+
+        transformedTermNode = termNode; ////
 
         return true;
       }
     });
   }
 
-  return termNode;
+  return transformedTermNode;
 }
 
-function substituteVariableNode(variableNode, substitutions) {
+function transformVariableNode(variableNode, substitutions) {
+  let transformedVariableNode = null;
+
   substitutions.someSubstitution((substitution) => {
     const substitutionMatchesVariableNode = substitution.matchVariableNode(variableNode);
 
     if (substitutionMatchesVariableNode) {
       const termNode = substitution.getTermNode(),
-            termVariableNode = variableNodeQuery(termNode);
+            variableNode = variableNodeQuery(termNode);
 
-      if (termVariableNode !== null) {
-        variableNode = termVariableNode;  ///
+      if (variableNode !== null) {
+        transformedVariableNode = variableNode;  ///
 
         return true;
       }
     }
   });
 
-  return variableNode;
+  return transformedVariableNode;
 }

package/src/substitution.js

@@ -25,15 +25,15 @@ export default class Substitution {
     return matchesMetavariableNode;
   }
 
-  unifyAgainstEquivalences(equivalences, substitutions, localContextA, localContextB) {
-    const unifiedAgainstEquivalences = equivalences.some((equivalence) => {
-      const substitutionUnifiedAgainstEquivalence = this.unifyAgainstEquivalence(equivalence, substitutions, localContextA, localContextB);
+  unifyWithEquivalences(equivalences, substitutions, localContextA, localContextB) {
+    const unifiedWithEquivalences = equivalences.some((equivalence) => {
+      const substitutionUnifiedWithEquivalence = this.unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB);
 
-      if (substitutionUnifiedAgainstEquivalence) {
+      if (substitutionUnifiedWithEquivalence) {
         return true;
       }
     });
 
-    return unifiedAgainstEquivalences;
+    return unifiedWithEquivalences;
   }
 }

package/src/substitutions.js

@@ -55,17 +55,17 @@ export default class Substitutions {
     localContextB.trace(`Removed the '${substitutionString}' substitution.`, substitutionNode);
   }
 
-  unifyAgainstEquivalences(equivalences, localContextA, localContextB) {
-    const unifiedAgainstEquivalences = this.everySubstitution((substitution) => {
+  unifyWithEquivalences(equivalences, localContextA, localContextB) {
+    const unifiedWithEquivalences = this.everySubstitution((substitution) => {
       const substitutions = this, ///
-            substitutionUnifiedAgainstEquivalence = substitution.unifyAgainstEquivalences(equivalences, substitutions, localContextA, localContextB);
+            substitutionUnifiedWithEquivalence = substitution.unifyWithEquivalences(equivalences, substitutions, localContextA, localContextB);
 
-      if (substitutionUnifiedAgainstEquivalence) {
+      if (substitutionUnifiedWithEquivalence) {
         return true;
       }
     });
 
-    return unifiedAgainstEquivalences;
+    return unifiedWithEquivalences;
   }
 
   snapshot() {

package/src/topLevelAssertion.js

@@ -1,8 +1,8 @@
 "use strict";
 
 import Substitutions from "./substitutions";
-import unifyConsequentAgainstStatement from "./unify/consequentAgainstStatement";
-import unifySuppositionsAgainstProofSteps from "./unify/suppositionsAgainstProofSteps";
+import unifyConsequentWithStatement from "./unify/consequentWithStatement";
+import unifySuppositionsWithProofSteps from "./unify/suppositionsWithProofSteps";
 
 export default class TopLevelAssertion {
   constructor(labels, suppositions, consequent, substitutions, fileContext) {
@@ -42,11 +42,11 @@ export default class TopLevelAssertion {
           fileContextA = this.fileContext,  ///
           suppositionsA = this.suppositions,  ///
           localContextB = localContext, ///
-          suppositionsUnified = unifySuppositionsAgainstProofSteps(suppositionsA, proofStepsB, substitutions, fileContextA, localContextB);
+          suppositionsUnified = unifySuppositionsWithProofSteps(suppositionsA, proofStepsB, substitutions, fileContextA, localContextB);
 
     if (suppositionsUnified) {
       const consequentA = this.consequent,  ///
-            consequentUnified = unifyConsequentAgainstStatement(consequentA, statementNode, substitutions, fileContextA, localContext);
+            consequentUnified = unifyConsequentWithStatement(consequentA, statementNode, substitutions, fileContextA, localContext);
 
       statementUnified = consequentUnified;  ///
     }

package/src/unifier/equality.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import Unifier from "../unifier";
-import unifyTermAgainstTerm from "../unify/termAgainstTerm";
+import unifyTermWithTerm from "../unify/termWithTerm";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -25,14 +25,14 @@ class EqualityUnifier extends Unifier {
       nodeQueryA: termNodeQuery,
       nodeQueryB: termNodeQuery,
       unify: (termNodeA, termNodeB, localContext) => {
-        let termUnifiedAgainstTerm;
+        let termUnifiedWithTerm;
 
         const leftTermNode = termNodeA, ///
               rightTermNode = termNodeB;  ///
 
-        termUnifiedAgainstTerm = unifyTermAgainstTerm(leftTermNode, rightTermNode, localContext);
+        termUnifiedWithTerm = unifyTermWithTerm(leftTermNode, rightTermNode, localContext);
 
-        if (!termUnifiedAgainstTerm) {
+        if (!termUnifiedWithTerm) {
           const nonTerminalNodeA = termNodeA, ///
                 nonTerminalNodeB = termNodeB, ///
                 nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),
@@ -41,10 +41,10 @@ class EqualityUnifier extends Unifier {
                 childNodesB = nonTerminalNodeBChildNodes, ///
                 childNodesVerified = equalityUnifier.unifyChildNodes(childNodesA, childNodesB, localContext);
 
-          termUnifiedAgainstTerm = childNodesVerified; ///
+          termUnifiedWithTerm = childNodesVerified; ///
         }
 
-        return termUnifiedAgainstTerm;
+        return termUnifiedWithTerm;
       }
     }
   ];

package/src/unifier/intrinsicLevel.js

@@ -2,7 +2,7 @@
 
 import shim from "../shim";
 import Unifier from "../unifier";
-import unifyVariableAgainstTerm from "../unify/variableAgainstTerm";
+import unifyVariableWithTerm from "../unify/variableWithTerm";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -28,9 +28,9 @@ class IntrinsicLevelUnifier extends Unifier {
       nodeQueryB: termNodeQuery,
       unify: (termVariableNodeA, termNodeB, substitutions, localContextA, localContextB) => {
         const variableNodeA = termVariableNodeA, ///
-              variableUnifiedAgainstTerm = unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB);
+              variableUnifiedWithTerm = unifyVariableWithTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB);
 
-        return variableUnifiedAgainstTerm;
+        return variableUnifiedWithTerm;
       }
     }
   ];