occam-verify-cli 0.0.958 → 0.0.960

package/src/unifier/metaLevel.js

@@ -2,8 +2,8 @@
 
 import shim from "../shim";
 import Unifier from "../unifier";
-import unifyVariableAgainstTerm from "../unify/variableAgainstTerm";
-import unifyMetavariableAgainstStatement from "../unify/metavariableAgainstStatement";
+import unifyVariableWithTerm from "../unify/variableWithTerm";
+import unifyMetavariableWithStatement from "../unify/metavariableWithStatement";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -31,15 +31,15 @@ class MetaLevelUnifier extends Unifier {
       nodeQueryA: statementNodeQuery,
       nodeQueryB: statementNodeQuery,
       unify: (statementNodeA, statementNodeB, substitutions, localContextA, localContextB) => {
-        let statementUnifiedAgainstStatement;
+        let statementUnifiedWithStatement;
 
         const metavariableNodeA = metavariableNodeQuery(statementNodeA);
 
         if (metavariableNodeA !== null) {
           const substitutionNodeA = substitutionNodeQuery(statementNodeA),
-                metavariableUnifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB);
+                metavariableUnifiedWithStatement = unifyMetavariableWithStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB);
 
-          statementUnifiedAgainstStatement = metavariableUnifiedAgainstStatement;  ///
+          statementUnifiedWithStatement = metavariableUnifiedWithStatement;  ///
         } else {
           const nonTerminalNodeA = statementNodeA, ///
                 nonTerminalNodeB = statementNodeB, ///
@@ -49,10 +49,10 @@ class MetaLevelUnifier extends Unifier {
                 childNodesB = nonTerminalNodeBChildNodes, ///
                 childNodesVerified = metaLevelUnifier.unifyChildNodes(childNodesA, childNodesB, substitutions, localContextA, localContextB);
 
-          statementUnifiedAgainstStatement = childNodesVerified; ///
+          statementUnifiedWithStatement = childNodesVerified; ///
         }
 
-        return statementUnifiedAgainstStatement;
+        return statementUnifiedWithStatement;
       }
     },
     {
@@ -60,9 +60,9 @@ class MetaLevelUnifier 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;
       }
     }
   ];

package/src/unifier/{statementAgainstCombinator.js → statementWithCombinator.js}

@@ -1,8 +1,8 @@
 "use strict";
 
 import Unifier from "../unifier";
-import unifyTermAgainstType from "../unify/termAgainstType";
-import unifyStatementAgainstMetaType from "../unify/statementAgainstMetaType";
+import unifyTermWithType from "../unify/termWithType";
+import unifyStatementWithMetaType from "../unify/statementWithMetaType";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -11,17 +11,17 @@ const termNodeQuery = nodeQuery("/term!"),
       metaTypeNodeQuery = nodeQuery("/metaType!"),
       statementNodeQuery = nodeQuery("/statement!");
 
-class StatementAgainstCombinatorUnifier extends Unifier {
+class StatementWithCombinatorUnifier extends Unifier {
   unify(statementNode, combinatorStatementNode, localContext) {
-    let statementUnifiedAgainstCombinator;
+    let statementUnifiedWithCombinator;
 
     const nonTerminalNodeA = statementNode, ///
           nonTerminalNodeB = combinatorStatementNode, ///
           nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext);
 
-    statementUnifiedAgainstCombinator = nonTerminalNodeUnified; ///
+    statementUnifiedWithCombinator = nonTerminalNodeUnified; ///
 
-    return statementUnifiedAgainstCombinator;
+    return statementUnifiedWithCombinator;
   };
 
   static maps = [
@@ -31,9 +31,9 @@ class StatementAgainstCombinatorUnifier extends Unifier {
       unify: (statementNodeA, metaTypeNodeB, localContext) => {
         const metaTypeNode = metaTypeNodeB, ///
               statementNode = statementNodeA, ///
-              statementUnifiedAgainstMetaType = unifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext);
+              statementUnifiedWithMetaType = unifyStatementWithMetaType(statementNode, metaTypeNode, localContext);
 
-        return statementUnifiedAgainstMetaType;
+        return statementUnifiedWithMetaType;
       }
     },
     {
@@ -42,14 +42,14 @@ class StatementAgainstCombinatorUnifier extends Unifier {
       unify: (termNodeA, typeNodeB, localContext) => {
         const termNode = termNodeA, ///
               typeNode = typeNodeB, ///
-              termUnifiedAgainstType = unifyTermAgainstType(termNode, typeNode, localContext);
+              termUnifiedWithType = unifyTermWithType(termNode, typeNode, localContext);
 
-        return termUnifiedAgainstType;
+        return termUnifiedWithType;
       }
     }
   ];
 }
 
-const statementAgainstCombinatorUnifier = new StatementAgainstCombinatorUnifier();
+const statementWithCombinatorUnifier = new StatementWithCombinatorUnifier();
 
-export default statementAgainstCombinatorUnifier;
+export default statementWithCombinatorUnifier;

package/src/unifier/{termAgainstConstructor.js → termWithConstructor.js}

@@ -1,24 +1,24 @@
 "use strict";
 
 import Unifier from "../unifier";
-import unifyTermAgainstType from "../unify/termAgainstType";
+import unifyTermWithType from "../unify/termWithType";
 
 import { nodeQuery } from "../utilities/query";
 
 const termNodeQuery = nodeQuery("/term"),
       typeNodeQuery = nodeQuery("/type");
 
-class TermAgainstConstructorUnifier extends Unifier {
+class TermWithConstructorUnifier extends Unifier {
   unify(termNode, constructorTermNode, localContext) {
-    let termUnifiedAgainstConstructor;
+    let termUnifiedWithConstructor;
 
     const nonTerminalNodeA = termNode, ///
           nonTerminalNodeB = constructorTermNode, ///
           nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext);
 
-    termUnifiedAgainstConstructor = nonTerminalNodeUnified; ///
+    termUnifiedWithConstructor = nonTerminalNodeUnified; ///
 
-    return termUnifiedAgainstConstructor;
+    return termUnifiedWithConstructor;
   };
 
   static maps = [
@@ -28,14 +28,14 @@ class TermAgainstConstructorUnifier extends Unifier {
       unify: (termNodeA, typeNodeB, localContext) => {
         const termNode = termNodeA, ///
               typeNode = typeNodeB, ///
-              termUnifiedAgainstType = unifyTermAgainstType(termNode, typeNode, localContext);
+              termUnifiedWithType = unifyTermWithType(termNode, typeNode, localContext);
 
-        return termUnifiedAgainstType;
+        return termUnifiedWithType;
       }
     }
   ];
 }
 
-const termAgainstConstructorUnifier = new TermAgainstConstructorUnifier();
+const termWithConstructorUnifier = new TermWithConstructorUnifier();
 
-export default termAgainstConstructorUnifier;
+export default termWithConstructorUnifier;

package/src/unify/{conclusionAgainstStatement.js → conclusionWithStatement.js}

@@ -2,7 +2,7 @@
 
 import LocalContext from "../context/local";
 
-export default function unifyConclusionAgainstStatement(conclusionA, statementNodeB, substitutions, fileContextA, localContextB) {
+export default function unifyConclusionWithStatement(conclusionA, statementNodeB, substitutions, fileContextA, localContextB) {
   let conclusionUnified = false;
 
   const conclusionAStatementNode = conclusionA.getStatementNode();
@@ -15,7 +15,7 @@ export default function unifyConclusionAgainstStatement(conclusionA, statementNo
 
     substitutions.snapshot();
 
-    localContextB.trace(`Unifying the '${statementStringB}' statement against the conclusion's '${statementStringA}' statement...`, statementNodeB);
+    localContextB.trace(`Unifying the '${statementStringB}' statement with the conclusion's '${statementStringA}' statement...`, statementNodeB);
 
     const statementUnified = conclusionA.unifyStatement(statementNodeB, substitutions, localContextA, localContextB);
 
@@ -26,7 +26,7 @@ export default function unifyConclusionAgainstStatement(conclusionA, statementNo
         substitutions.rollback(localContextA, localContextB);
 
     if (conclusionUnified) {
-      localContextB.debug(`...unified the '${statementStringB}' statement against the conclusion's '${statementStringA}' statement.`, statementNodeB);
+      localContextB.debug(`...unified the '${statementStringB}' statement with the conclusion's '${statementStringA}' statement.`, statementNodeB);
     }
   }
 

package/src/unify/{consequentAgainstStatement.js → consequentWithStatement.js}

@@ -2,7 +2,7 @@
 
 import LocalContext from "../context/local";
 
-export default function unifyConsequentAgainstStatement(consequentA, statementNodeB, substitutions, fileContextA, localContextB) {
+export default function unifyConsequentWithStatement(consequentA, statementNodeB, substitutions, fileContextA, localContextB) {
   let consequentUnified = false;
 
   const consequentAStatementNode = consequentA.getStatementNode();
@@ -15,7 +15,7 @@ export default function unifyConsequentAgainstStatement(consequentA, statementNo
 
     substitutions.snapshot();
 
-    localContextB.trace(`Unifying the '${statementStringB}' statement against the consequent's '${statementStringA}' statement...`, statementNodeB);
+    localContextB.trace(`Unifying the '${statementStringB}' statement with the consequent's '${statementStringA}' statement...`, statementNodeB);
 
     const statementUnified = consequentA.unifyStatement(statementNodeB, substitutions, localContextA, localContextB);
 
@@ -26,7 +26,7 @@ export default function unifyConsequentAgainstStatement(consequentA, statementNo
         substitutions.rollback(localContextA, localContextB);
 
     if (consequentUnified) {
-      localContextB.debug(`...unified the '${statementStringB}' statement against the consequent's '${statementStringA}' statement.`, statementNodeB);
+      localContextB.debug(`...unified the '${statementStringB}' statement with the consequent's '${statementStringA}' statement.`, statementNodeB);
     }
   }
 

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

@@ -1,15 +1,15 @@
 "use strict";
 
 import TermForVariableSubstitution from "../substitution/termForVariable";
-import unifyStatementAgainstStatement from "../unify/statementAtainstStatement";
+import unifyStatementWithStatement from "../unify/statementAtainstStatement";
 import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
 
 import { nodeQuery } from "../utilities/query";
 
 const metavariableNodeQuery = nodeQuery("/statement/metavariable");
 
-export default function unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB) {
-  let metavariableUnifiedAgainstStatement = false;
+export default function unifyMetavariableWithStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB) {
+  let metavariableUnifiedWithStatement = false;
 
   const substitution = substitutions.findSubstitution((substitution) => {
     const substitutionMatchesMetavariableNodeA = substitution.matchMetavariableNode(metavariableNodeA);
@@ -28,10 +28,10 @@ export default function unifyMetavariableAgainstStatement(metavariableNodeA, sta
             localContext = localContextB,  ///
             substitution = termForVariableSubstitution, ///
             statementNodeA = substitutionStatementNode, ///
-            statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
+            statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
 
-      if (statementUnifiedAgainstStatement) {
-        metavariableUnifiedAgainstStatement = true;
+      if (statementUnifiedWithStatement) {
+        metavariableUnifiedWithStatement = true;
       }
     } else {
       const substitutionSubstitution = substitution.getSubstitution();
@@ -43,16 +43,16 @@ export default function unifyMetavariableAgainstStatement(metavariableNodeA, sta
 
         const localContext = localContextB,  ///
               substitution = substitutionSubstitution,
-              statementUnifiedAgainstStatement = unifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
+              statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, substitution, substitutions, localContext, localContext);
 
-        if (statementUnifiedAgainstStatement) {
-          metavariableUnifiedAgainstStatement = true;
+        if (statementUnifiedWithStatement) {
+          metavariableUnifiedWithStatement = true;
         }
       } else {
         const substitutionMatchesStatementNodeB = substitution.matchStatementNode(statementNodeB);
 
         if (substitutionMatchesStatementNodeB) {
-          metavariableUnifiedAgainstStatement = true;
+          metavariableUnifiedWithStatement = true;
         }
       }
     }
@@ -72,11 +72,11 @@ export default function unifyMetavariableAgainstStatement(metavariableNodeA, sta
         substitutions.addSubstitution(substitution, localContextA, localContextB);
       }
 
-      metavariableUnifiedAgainstStatement = true;
+      metavariableUnifiedWithStatement = true;
     }
   }
 
-  return metavariableUnifiedAgainstStatement;
+  return metavariableUnifiedWithStatement;
 }
 
 function metavariableFromStatementNode(statementNode, localContext) {

package/src/unify/{premiseAgainstProofStep.js → premiseWithProofStep.js}

@@ -2,7 +2,7 @@
 
 import { subproofNodeAsSubproofString } from "../utilities/unify";
 
-export default function unifyPremiseAgainstProofStep(premiseA, proofStepB, substitutions, localContextA, localContextB) {
+export default function unifyPremiseWithProofStep(premiseA, proofStepB, substitutions, localContextA, localContextB) {
   let premiseUnified = false;
 
   const premiseAStatementNode = premiseA.getStatementNode();
@@ -20,12 +20,12 @@ export default function unifyPremiseAgainstProofStep(premiseA, proofStepB, subst
     if (subproofNodeB !== null) {
       const subproofStringB = subproofNodeAsSubproofString(subproofNodeB, localContextB);
 
-      localContextB.trace(`Unifying the '${subproofStringB}' subproof against the premise's '${statementStringA}' statement...`, subproofNodeB);
+      localContextB.trace(`Unifying the '${subproofStringB}' subproof with the premise's '${statementStringA}' statement...`, subproofNodeB);
 
       const subproofUnified = premiseA.unifySubproof(subproofNodeB, substitutions, localContextA, localContextB);
 
       if (subproofUnified) {
-        localContextB.debug(`...unified the '${subproofStringB}' subproof against the premise's '${statementStringA}' statement.`, subproofNodeB);
+        localContextB.debug(`...unified the '${subproofStringB}' subproof with the premise's '${statementStringA}' statement.`, subproofNodeB);
 
         premiseUnified = true;
       }
@@ -34,12 +34,12 @@ export default function unifyPremiseAgainstProofStep(premiseA, proofStepB, subst
     if (statementNodeB !== null) {
       const statementStringB = localContextB.nodeAsString(statementNodeB);
 
-      localContextB.trace(`Unifying the '${statementStringB}' statement against the premise's '${statementStringA}' statement...`, statementNodeB);
+      localContextB.trace(`Unifying the '${statementStringB}' statement with the premise's '${statementStringA}' statement...`, statementNodeB);
 
       const statementUnified = premiseA.unifyStatement(statementNodeB, substitutions, localContextA, localContextB);
 
       if (statementUnified) {
-        localContextB.debug(`...unified the '${statementStringB}' statement against the premise's '${statementStringA}' statement.`, statementNodeB);
+        localContextB.debug(`...unified the '${statementStringB}' statement with the premise's '${statementStringA}' statement.`, statementNodeB);
 
         premiseUnified = true;
       }

package/src/unify/{premisesAgainstProofSteps.js → premisesWithProofSteps.js}

@@ -1,18 +1,18 @@
 "use strict";
 
 import LocalContext from "../context/local";
-import unifyPremiseAgainstProofStep from "../unify/premiseAgainstProofStep";
+import unifyPremiseWithProofStep from "../unify/premiseWithProofStep";
 
 import { reverse, correlate } from "../utilities/array";
 
-export default function unifyPremisesAgainstProofSteps(premisesA, proofStepsB, substitutions, fileContextA, localContextB) {
+export default function unifyPremisesWithProofSteps(premisesA, proofStepsB, substitutions, fileContextA, localContextB) {
   premisesA = reverse(premisesA); ///
 
   proofStepsB = reverse(proofStepsB); ///
 
   const premisesUnified = correlate(premisesA, proofStepsB, (premiseA, proofStepB) => {
     const localContextA = LocalContext.fromFileContext(fileContextA),
-          premiseUnified = unifyPremiseAgainstProofStep(premiseA, proofStepB, substitutions, localContextA, localContextB);
+          premiseUnified = unifyPremiseWithProofStep(premiseA, proofStepB, substitutions, localContextA, localContextB);
 
     if (premiseUnified) {
       return true;

package/src/unify/statementAtainstStatement.js

@@ -5,8 +5,8 @@ import TermForVariableSubstitution from "../substitution/termForVariable";
 
 import { push } from "../utilities/array";
 
-export default function unifyStatementAgainstStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB) {
-  let statementUnifiedAgainstStatement = false;
+export default function unifyStatementWithStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB) {
+  let statementUnifiedWithtatement = false;
 
   const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionAndSubstitutions(substitution, substitutions),
         transformed = termForVariableSubstitution.isTransformed(substitution);
@@ -35,10 +35,10 @@ export default function unifyStatementAgainstStatement(statementNodeA, statement
       push(substitutions, substitutionsA);
     }
 
-    statementUnifiedAgainstStatement = true;
+    statementUnifiedWithtatement = true;
   }
 
-  return statementUnifiedAgainstStatement;
+  return statementUnifiedWithtatement;
 }
 
 function transformSubstitutions(substitutionsA, substitutionsB) {

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

@@ -8,8 +8,8 @@ import { FRAME_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "../metaTypeNames
 const metavariableNodeQuery = nodeQuery("/statement/metavariable"),
       metaTypeTerminalNodeQuery = nodeQuery("/metaType/@meta-type!");
 
-export default function unifyStatementAgainstMetaType(statementNode, metaTypeNode, localContext) {
-  let statementUnifiedAgainstMetaType = false;
+export default function unifyStatementWithMetaType(statementNode, metaTypeNode, localContext) {
+  let statementUnifiedWithMetaType = false;
 
   const metaTypeTerminalNode = metaTypeTerminalNodeQuery(metaTypeNode),
         metaTypeTerminalNodeContent = metaTypeTerminalNode.getContent(),
@@ -26,7 +26,7 @@ export default function unifyStatementAgainstMetaType(statementNode, metaTypeNod
           const metavariableMetaTypeName = metavariable.getMetaTypeName();
 
           if (metavariableMetaTypeName === metaTypeName) {
-            statementUnifiedAgainstMetaType = true;
+            statementUnifiedWithMetaType = true;
           }
         }
       }
@@ -40,11 +40,11 @@ export default function unifyStatementAgainstMetaType(statementNode, metaTypeNod
             assignments = [],
             statementVerified = verifyStatement(statementNode, assignments, derived, localContext);
 
-      statementUnifiedAgainstMetaType = statementVerified;
+      statementUnifiedWithMetaType = statementVerified;
 
       break;
     }
   }
 
-  return statementUnifiedAgainstMetaType;
+  return statementUnifiedWithMetaType;
 }

package/src/unify/{suppositionAgainstProofStep.js → suppositionWithProffStep.js}

@@ -2,7 +2,7 @@
 
 import { subproofNodeAsSubproofString } from "../utilities/unify";
 
-export default function unifySuppositionAgainstProofStep(suppositionA, proofStepB, substitutions, localContextA, localContextB) {
+export default function unifySuppositionWithProofStep(suppositionA, proofStepB, substitutions, localContextA, localContextB) {
   let suppositionUnified = false;
 
   const suppositionAStatementNode = suppositionA.getStatementNode();
@@ -20,12 +20,12 @@ export default function unifySuppositionAgainstProofStep(suppositionA, proofStep
     if (subproofNodeB !== null) {
       const subproofStringB = subproofNodeAsSubproofString(subproofNodeB, localContextB);
 
-      localContextB.trace(`Unifying the '${subproofStringB}' subproof against the supposition's '${statementStringA}' statement...`, subproofNodeB);
+      localContextB.trace(`Unifying the '${subproofStringB}' subproof with the supposition's '${statementStringA}' statement...`, subproofNodeB);
 
       const subproofUnified = suppositionA.unifySubproof(subproofNodeB, substitutions, localContextA, localContextB);
 
       if (subproofUnified) {
-        localContextB.debug(`...unified the '${subproofStringB}' subproof against the supposition's '${statementStringA}' statement.`, subproofNodeB);
+        localContextB.debug(`...unified the '${subproofStringB}' subproof with the supposition's '${statementStringA}' statement.`, subproofNodeB);
 
         suppositionUnified = true;
       }
@@ -34,12 +34,12 @@ export default function unifySuppositionAgainstProofStep(suppositionA, proofStep
     if (statementNodeB !== null) {
       const statementStringB = localContextB.nodeAsString(statementNodeB);
 
-      localContextB.trace(`Unifying the '${statementStringB}' statement against the supposition's '${statementStringA}' statement...`, statementNodeB);
+      localContextB.trace(`Unifying the '${statementStringB}' statement with the supposition's '${statementStringA}' statement...`, statementNodeB);
 
       const statementUnified = suppositionA.unifyStatement(statementNodeB, substitutions, localContextA, localContextB);
 
       if (statementUnified) {
-        localContextB.debug(`...unified the '${statementStringB}' statement against the supposition's '${statementStringA}' statement.`, statementNodeB);
+        localContextB.debug(`...unified the '${statementStringB}' statement with the supposition's '${statementStringA}' statement.`, statementNodeB);
 
         suppositionUnified = true;
       }

package/src/unify/{suppositionsAgainstProofSteps.js → suppositionsWithProofSteps.js}

@@ -1,18 +1,18 @@
 "use strict";
 
 import LocalContext from "../context/local";
-import unifySuppositionAgainstProofStep from "./suppositionAgainstProofStep";
+import unifySuppositionWithProofStep from "./suppositionWithProffStep";
 
 import { reverse, correlate } from "../utilities/array";
 
-export default function unifySuppositionsAgainstProofSteps(suppositionsA, proofStepsB, substitutions, fileContextA, localContextB) {
+export default function unifySuppositionsWithProofSteps(suppositionsA, proofStepsB, substitutions, fileContextA, localContextB) {
   suppositionsA = reverse(suppositionsA); ///
 
   proofStepsB = reverse(proofStepsB); ///
 
   const suppositionsUnified = correlate(suppositionsA, proofStepsB, (suppositionA, proofStepB) => {
     const localContextA = LocalContext.fromFileContext(fileContextA),
-          suppositionUnified = unifySuppositionAgainstProofStep(suppositionA, proofStepB, substitutions, localContextA, localContextB);
+          suppositionUnified = unifySuppositionWithProofStep(suppositionA, proofStepB, substitutions, localContextA, localContextB);
 
     if (suppositionUnified) {
       return true;

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

@@ -2,15 +2,15 @@
 
 import { areTermNodesEqual } from "../utilities/equivalences";
 
-export default function unifyTermAgainstTerm(leftTermNode, rightTermNode, localContext) {
-  let termUnifiedAgainstTerm = false;
+export default function unifyTermWithTerm(leftTermNode, rightTermNode, localContext) {
+  let termUnifiedWithTerm = false;
 
   const equivalences = localContext.getEquivalences(),
         termNodesEqual = areTermNodesEqual(leftTermNode, rightTermNode, equivalences);
 
   if (termNodesEqual) {
-    termUnifiedAgainstTerm = true;
+    termUnifiedWithTerm = true;
   }
 
-  return termUnifiedAgainstTerm;
+  return termUnifiedWithTerm;
 }

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

@@ -4,8 +4,8 @@ import shim from "../shim";
 
 import { first } from "../utilities/array";
 
-export default function unifyTermAgainstType(termNode, typeNode, localContext) {
-  let termUnifiedAgainstType;
+export default function unifyTermWithType(termNode, typeNode, localContext) {
+  let termUnifiedWithType;
 
   const { verifyTerm } = shim,
         terms = [],
@@ -25,7 +25,7 @@ export default function unifyTermAgainstType(termNode, typeNode, localContext) {
           return verifiedAhead;
         });
 
-  termUnifiedAgainstType = termVerified; ///
+  termUnifiedWithType = termVerified; ///
 
-  return termUnifiedAgainstType;
+  return termUnifiedWithType;
 }

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

@@ -6,8 +6,8 @@ import { nodeQuery } from "../utilities/query";
 
 const variableNodeQuery = nodeQuery("/term/variable");
 
-export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB) {
-  let variableUnifiedAgainstTerm = false;
+export default function unifyVariableWithTerm(variableNodeA, termNodeB, substitutions, localContextA, localContextB) {
+  let variableUnifiedWithTerm = false;
 
   const substitution = substitutions.findSubstitution((substitution) => {
     const substitutionMatchesVariableNodeA = substitution.matchVariableNode(variableNodeA);
@@ -21,7 +21,7 @@ export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, subst
     const substitutionMatchesTermNodeB = substitution.matchTermNode(termNodeB);
 
     if (substitutionMatchesTermNodeB) {
-      variableUnifiedAgainstTerm = true;
+      variableUnifiedWithTerm = true;
     }
   } else {
     const variableA = localContextA.findVariableByVariableNode(variableNodeA);
@@ -38,11 +38,11 @@ export default function unifyVariableAgainstTerm(variableNodeA, termNodeB, subst
         substitutions.addSubstitution(substitution, localContextA, localContextB);
       }
 
-      variableUnifiedAgainstTerm = true;
+      variableUnifiedWithTerm = true;
     }
   }
 
-  return variableUnifiedAgainstTerm;
+  return variableUnifiedWithTerm;
 }
 
 function variableFromTermNode(termNode, localContext) {

package/src/utilities/node.js

@@ -4,13 +4,8 @@ import { parsersUtilities } from "occam-custom-grammars";
 
 import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
-import { METAVARIABLE_RULE_NAME,
-         VARIABLE_DECLARATION_RULE_NAME,
-         UNQUALIFIED_STATEMENT_RULE_NAME,
-         CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
-import { metavariableTokensFromMetavariableString,
-         variableDeclarationTokensFromVariableString,
-         unqualifiedStatementTokensFromStatementString } from "../utilities/tokens";
+import { unqualifiedStatementTokensFromStatementString } from "../utilities/tokens";
+import { UNQUALIFIED_STATEMENT_RULE_NAME, CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
 
 const { florenceParserFromCombinedCustomGrammar } = parsersUtilities;
 
@@ -18,16 +13,8 @@ const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       florenceParser = florenceParserFromCombinedCustomGrammar(combinedCustomGrammar);
 
 const termNodeQuery = nodeQuery("/constructorDeclaration/term!"),
-      variableNodeQuery = nodeQuery("/variableDeclaration/variable!"),
       statementNodeQuery = nodeQuery("/unqualifiedStatement/statement!");
 
-export function variableNodeFromVariableString(variableString, lexer, parser) {
-  const variableTDeclarationTokens = variableDeclarationTokensFromVariableString(variableString, lexer),
-        variableNode = variableNodeFromVariableVariableTDeclarationTokens(variableTDeclarationTokens, parser);
-
-  return variableNode;
-}
-
 export function statementNodeFromStatementString(statementString, lexer, parser) {
   const unqualifiedStatementTokens = unqualifiedStatementTokensFromStatementString(statementString, lexer),
         statementNode = statementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser);
@@ -35,13 +22,6 @@ export function statementNodeFromStatementString(statementString, lexer, parser)
   return statementNode;
 }
 
-export function metavariableNodeFromMetavariableString(metavariableString, lexer, parser) {
-  const metavariableTokens = metavariableTokensFromMetavariableString(metavariableString, lexer),
-        metavariableNode = metavariableNodeFromMetavariableTokens(metavariableTokens, parser);
-
-  return metavariableNode;
-}
-
 export function termNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser) {
   let termNode = null;
 
@@ -66,32 +46,6 @@ export function statementNodeFromUnqualifiedStatementTokens(unqualifiedStatement
   return statementNode;
 }
 
-export function variableNodeFromVariableVariableTDeclarationTokens(variableTDeclarationTokens, parser) {
-  let variableNode = null;
-
-  const variableDeclarationNode = variableDeclarationNodeFromVariableTDeclarationTokens(variableTDeclarationTokens, parser);
-
-  if (variableDeclarationNode !== null) {
-    variableNode = variableNodeQuery(variableDeclarationNode);
-  }
-
-  return variableNode;
-}
-
-export function metavariableNodeFromMetavariableTokens(metavariableTokens, parser) {
-  const ruleName = METAVARIABLE_RULE_NAME,
-        metavariableNode = nodeFromTokensRuleNameAndParser(metavariableTokens, ruleName, parser);
-
-  return metavariableNode;
-}
-
-export function variableDeclarationNodeFromVariableTDeclarationTokens(variableTDeclarationTokens, parser) {
-  const ruleName = VARIABLE_DECLARATION_RULE_NAME,
-        variableDeclarationNode = nodeFromTokensRuleNameAndParser(variableTDeclarationTokens, ruleName, parser);
-
-  return variableDeclarationNode;
-}
-
 export function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
   const ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,
         unqualifiedStatementNode = nodeFromTokensRuleNameAndParser(unqualifiedStatementTokens, ruleName, parser);