occam-verify-cli 0.0.958 → 0.0.960

package/src/utilities/tokens.js

@@ -9,13 +9,6 @@ const { florenceLexerFromCombinedCustomGrammar } = lexersUtilities;
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       florenceLexer = florenceLexerFromCombinedCustomGrammar(combinedCustomGrammar);
 
-export function metavariableTokensFromMetavariableString(metavariableString, lexer) {
-  const metavariableContent = `${metavariableString}`,
-        metavariableTokens = tokensFromContentAndLexer(metavariableContent, lexer);
-
-  return metavariableTokens;
-}
-
 export function constructorDeclarationTokensFromTermString(termString, lexer) {
   const constructorDeclarationContent = `Constructor ${termString}
 `,
@@ -24,14 +17,6 @@ export function constructorDeclarationTokensFromTermString(termString, lexer) {
   return constructorDeclarationTokens;
 }
 
-export function variableDeclarationTokensFromVariableString(variableString, lexer) {
-  const variableDeclarationContent = `Variable ${variableString}
-`,
-        variableDeclarationTokens = tokensFromContentAndLexer(variableDeclarationContent, lexer);
-
-  return variableDeclarationTokens;
-}
-
 export function unqualifiedStatementTokensFromStatementString(statementString, lexer) {
   const unqualifiedStatementContent = `${statementString}
 `,

package/src/variable.js

@@ -1,8 +1,6 @@
 "use strict";
 
 import { nodeAsString } from "./utilities/string";
-import { typeFromJSONAndFileContext } from "./type";
-import { variableNodeFromVariableString } from "./utilities/node";
 
 export default class Variable {
   constructor(node, type) {
@@ -58,40 +56,6 @@ export default class Variable {
     return string;
   }
 
-  toJSON(tokens) {
-    const typeJSON = this.type.toJSON(tokens),
-          string = nodeAsString(this.node, tokens),
-          node = string,  //
-          type = typeJSON,  ///
-          json = {
-            node,
-            type
-          };
-
-    return json;
-  }
-
-  static fromJSONAndFileContext(json, fileContext) {
-    let { node } = json;
-
-    const lexer  = fileContext.getLexer(),
-          parser = fileContext.getParser(),
-          variableString = node,  ///
-          variableNode = variableNodeFromVariableString(variableString, lexer, parser);
-
-    node = variableNode;  ///
-
-    let { type } = json;
-
-    json = type;  ///
-
-    type = typeFromJSONAndFileContext(json, fileContext);
-
-    const variable = new Variable(node, type);
-
-    return variable;
-  }
-
   static fromVariableAndType(variable, type) {
     const node = variable.getNode();
 

package/src/verify/error.js

@@ -5,7 +5,7 @@ export default function verifyError(errorNode, fileContext) {
 
   const errorString = fileContext.nodeAsString(errorNode)
 
-  fileContext.debug(`The '${errorString}' cannot be verified.`, errorNode);
+  fileContext.debug(`The '${errorString}' error cannot be verified.`, errorNode);
 
   return errorVerified;
 }

package/src/verify/judgement.js

@@ -70,10 +70,10 @@ function verifyDerivedJudgement(judgementNode, assignments, derived, localContex
                   metaLemmaMetatheorem = (metaLemma || metatheorem);  ///
 
             if (metaLemmaMetatheorem !== null) {
-              const metaLemmaMetatheoremUnifiedAgainstDeclaration = declaration.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem),
-                    metaLemmaMetatheoremUnifiedAgainstJudgement = judgement.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem);
+              const metaLemmaMetatheoremUnifiedWithDeclaration = declaration.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem),
+                    metaLemmaMetatheoremUnifiedWithJudgement = judgement.unifyMetaLemmaOrMetaTheorem(metaLemmaMetatheorem);
 
-              derivedJudgementVerified = (metaLemmaMetatheoremUnifiedAgainstDeclaration && metaLemmaMetatheoremUnifiedAgainstJudgement);
+              derivedJudgementVerified = (metaLemmaMetatheoremUnifiedWithDeclaration && metaLemmaMetatheoremUnifiedWithJudgement);
             } else {
               const metavariableString = localContext.nodeAsString(metavariableNode);
 

package/src/verify/metavariable.js

@@ -1,8 +1,8 @@
 "use strict";
 
 import { nodeQuery } from "../utilities/query";
+import { unifyTermWithTermType } from "../metavariable";
 import { nameFromMetavariableNode } from "../utilities/name";
-import { unifyTermAgainstTermType } from "../metavariable";
 
 const termNodeQuery = nodeQuery("/metavariable/argument/term"),
       typeNodeQuery = nodeQuery("/metavariable/argument/type");
@@ -43,9 +43,9 @@ export default function verifyMetavariable(metavariableNode, localContext) {
 
         localContext.debug(`No term was found when the metavariable's term type is '${termTypeName}'.`, termNode);
       } else {
-        const termUnifiedAgainstTermType = unifyTermAgainstTermType(termNode, termType, localContext);
+        const termUnifiedWithTermType = unifyTermWithTermType(termNode, termType, localContext);
 
-        metavariableVerified = termUnifiedAgainstTermType; ///
+        metavariableVerified = termUnifiedWithTermType; ///
       }
     }
   }

package/src/verify/statement/qualified.js

@@ -3,7 +3,7 @@
 import verifyEquality from "../equality";
 import verifyJudgement from "../judgement";
 import verifyTypeAssertion from "../assertion/type";
-import unifyMetavariableAgainstStatement from "../../unify/metavariableAgainstStatement";
+import unifyMetavariableWithStatement from "../../unify/metavariableWithStatement";
 
 import { nodeQuery } from "../../utilities/query";
 
@@ -21,12 +21,12 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
   localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement...`, qualifiedStatementNode);
 
   const unifyQualifiedStatementFunctions = [
-    unifyQualifiedStatementAAgainstRule,
-    unifyQualifiedStatementAAgainstAxiom,
-    unifyQualifiedStatementAAgainstLemma,
-    unifyQualifiedStatementAAgainstTheorem,
-    unifyQualifiedStatementAAgainstConjecture,
-    unifyQualifiedStatementAAgainstReference
+    unifyQualifiedStatementAWithRule,
+    unifyQualifiedStatementAWithAxiom,
+    unifyQualifiedStatementAWithLemma,
+    unifyQualifiedStatementAWithTheorem,
+    unifyQualifiedStatementAWithConjecture,
+    unifyQualifiedStatementAWithReference
   ];
 
   const qualifiedStatementUnified = unifyQualifiedStatementFunctions.some((unifyQualifiedStatementFunction) => {  ///
@@ -52,8 +52,8 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, substit
   return qualifiedStatementVerified;
 }
 
-function unifyQualifiedStatementAAgainstRule(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstRule = false;
+function unifyQualifiedStatementAWithRule(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedWithRule = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         rule = localContext.findRuleByMetavariableNode(metavariableNode);
@@ -63,22 +63,22 @@ function unifyQualifiedStatementAAgainstRule(qualifiedStatementNode, substitutio
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' rule...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' rule...`, qualifiedStatementNode);
 
     const ruleMatchesStatement = rule.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementUnifiedAgainstRule = ruleMatchesStatement;  ///
+    qualifiedStatementUnifiedWithRule = ruleMatchesStatement;  ///
 
-    if (qualifiedStatementUnifiedAgainstRule) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' rule.`, qualifiedStatementNode);
+    if (qualifiedStatementUnifiedWithRule) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' rule.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementUnifiedAgainstRule;
+  return qualifiedStatementUnifiedWithRule;
 }
 
-function unifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstAxiom = false;
+function unifyQualifiedStatementAWithAxiom(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedWithAxiom = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         axiom = localContext.findAxiomByMetavariableNode(metavariableNode);
@@ -88,22 +88,22 @@ function unifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, substituti
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' axiom...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' axiom...`, qualifiedStatementNode);
 
     const axiomMatchesStatement = axiom.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementUnifiedAgainstAxiom = axiomMatchesStatement; ///
+    qualifiedStatementUnifiedWithAxiom = axiomMatchesStatement; ///
 
-    if (qualifiedStatementUnifiedAgainstAxiom) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' axiom.`, qualifiedStatementNode);
+    if (qualifiedStatementUnifiedWithAxiom) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' axiom.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementUnifiedAgainstAxiom;
+  return qualifiedStatementUnifiedWithAxiom;
 }
 
-function unifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstLemma = false;
+function unifyQualifiedStatementAWithLemma(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedWithLemma = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         lemma = localContext.findLemmaByMetavariableNode(metavariableNode);
@@ -113,22 +113,22 @@ function unifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, substituti
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' lemma...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' lemma...`, qualifiedStatementNode);
 
     const lemmaMatchesStatement = lemma.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementUnifiedAgainstLemma = lemmaMatchesStatement; ///
+    qualifiedStatementUnifiedWithLemma = lemmaMatchesStatement; ///
 
-    if (qualifiedStatementUnifiedAgainstLemma) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' lemma.`, qualifiedStatementNode);
+    if (qualifiedStatementUnifiedWithLemma) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' lemma.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementUnifiedAgainstLemma;
+  return qualifiedStatementUnifiedWithLemma;
 }
 
-function unifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstTheorem = false;
+function unifyQualifiedStatementAWithTheorem(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedWithTheorem = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         theorem = localContext.findTheoremByMetavariableNode(metavariableNode);
@@ -138,22 +138,22 @@ function unifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, substitu
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' theorem...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' theorem...`, qualifiedStatementNode);
 
     const theoremMatchesStatement = theorem.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementUnifiedAgainstTheorem = theoremMatchesStatement; ///
+    qualifiedStatementUnifiedWithTheorem = theoremMatchesStatement; ///
 
-    if (qualifiedStatementUnifiedAgainstTheorem) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' theorem.`, qualifiedStatementNode);
+    if (qualifiedStatementUnifiedWithTheorem) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' theorem.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementUnifiedAgainstTheorem;
+  return qualifiedStatementUnifiedWithTheorem;
 }
 
-function unifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstConjecture = false;
+function unifyQualifiedStatementAWithConjecture(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedWithConjecture = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         conjecture = localContext.findConjectureByMetavariableNode(metavariableNode);
@@ -163,29 +163,29 @@ function unifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, subst
           metavariableString = localContext.nodeAsString(metavariableNode),
           qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' conjecture...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' conjecture...`, qualifiedStatementNode);
 
     const conjectureMatchesStatement = conjecture.unifyStatement(statementNode, localContext);
 
-    qualifiedStatementUnifiedAgainstConjecture = conjectureMatchesStatement; ///
+    qualifiedStatementUnifiedWithConjecture = conjectureMatchesStatement; ///
 
-    if (qualifiedStatementUnifiedAgainstConjecture) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' conjecture.`, qualifiedStatementNode);
+    if (qualifiedStatementUnifiedWithConjecture) {
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' conjecture.`, qualifiedStatementNode);
     }
   }
 
-  return qualifiedStatementUnifiedAgainstConjecture;
+  return qualifiedStatementUnifiedWithConjecture;
 }
 
-function unifyQualifiedStatementAAgainstReference(qualifiedStatementNode, substitutions, localContext) {
-  let qualifiedStatementUnifiedAgainstReference = false;
+function unifyQualifiedStatementAWithReference(qualifiedStatementNode, substitutions, localContext) {
+  let qualifiedStatementUnifiedWithReference = false;
 
   const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
         metavariableString = localContext.nodeAsString(metavariableNode),
         metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode),
         qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
 
-  localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' reference...`, qualifiedStatementNode);
+  localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' reference...`, qualifiedStatementNode);
 
   if (metavariablePresent) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
@@ -194,20 +194,20 @@ function unifyQualifiedStatementAAgainstReference(qualifiedStatementNode, substi
           statementNodeB = statementNode, ///
           substitutionNodeA = null,
           metavariableNodeA = metavariableNode, ///
-          metavariableUnifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB, () => {
+          metavariableUnifiedWithStatement = unifyMetavariableWithStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;
           });
 
-    qualifiedStatementUnifiedAgainstReference = metavariableUnifiedAgainstStatement; ///
+    qualifiedStatementUnifiedWithReference = metavariableUnifiedWithStatement; ///
   }
 
-  if (qualifiedStatementUnifiedAgainstReference) {
-    localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' reference.`, qualifiedStatementNode);
+  if (qualifiedStatementUnifiedWithReference) {
+    localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' reference.`, qualifiedStatementNode);
   }
 
-  return qualifiedStatementUnifiedAgainstReference;
+  return qualifiedStatementUnifiedWithReference;
 }
 
 function verifyStatedStatement(statementNode, assignments, derived, localContext) {

package/src/verify/statement.js

@@ -9,7 +9,7 @@ import verifyTypeAssertion from "../verify/assertion/type";
 import verifyDefinedAssertion from "../verify/assertion/defined";
 import verifySubproofAssertion from "../verify/assertion/subproof";
 import verifyContainedAssertion from "../verify/assertion/contained";
-import statementAgainstCombinatorUnifier from "../unifier/statementAgainstCombinator";
+import statementWithCombinatorUnifier from "../unifier/statementWithCombinator";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -28,9 +28,9 @@ function verifyStatement(statementNode, assignments, derived, localContext) {
 
   localContext.trace(`Verifying the '${statementString}' statement...`, statementNode);
 
-  const statementUnifiedAgainstCombinators = unifyStatementAgainstCombinators(statementNode, assignments, derived, localContext);
+  const statementUnifiedWithCombinators = unifyStatementWithCombinators(statementNode, assignments, derived, localContext);
 
-  if (statementUnifiedAgainstCombinators) {
+  if (statementUnifiedWithCombinators) {
     statementVerified = true;
   } else {
     const verifyStatementFunctions = [
@@ -41,7 +41,7 @@ function verifyStatement(statementNode, assignments, derived, localContext) {
       verifyStatementAsDefinedAssertion,
       verifyStatementAsSubproofAssertion,
       verifyStatementAsContainedAssertion,
-      unifyStatementAgainstCombinators
+      unifyStatementWithCombinators
     ];
 
     statementVerified = verifyStatementFunctions.some((verifyStatementFunction) => {
@@ -220,8 +220,8 @@ function verifyStatementAsContainedAssertion(statementNode, assignments, derived
   return statementVerifiedAsContainedAssertion;
 }
 
-function unifyStatementAgainstCombinators(statementNode, assignments, derived, localContext) {
-  let statementUnifiedAgainstCombinators = false;
+function unifyStatementWithCombinators(statementNode, assignments, derived, localContext) {
+  let statementUnifiedWithCombinators = false;
 
   const equalityNode = equalityNodeQuery(statementNode),
         judgementNode = judgementNodeQuery(statementNode),
@@ -246,33 +246,33 @@ function unifyStatementAgainstCombinators(statementNode, assignments, derived, l
       ...combinators
     ];
 
-    statementUnifiedAgainstCombinators = combinators.some((combinator) => {
-      const statementUnifiedAgainstCombinator = unifyStatementAgainstCombinator(statementNode, combinator, localContext);
+    statementUnifiedWithCombinators = combinators.some((combinator) => {
+      const statementUnifiedWithCombinator = unifyStatementWithCombinator(statementNode, combinator, localContext);
 
-      if (statementUnifiedAgainstCombinator) {
+      if (statementUnifiedWithCombinator) {
         return true;
       }
     });
   }
 
-  return statementUnifiedAgainstCombinators;
+  return statementUnifiedWithCombinators;
 }
 
-function unifyStatementAgainstCombinator(statementNode, combinator, localContext) {
-  let statementUnifiedAgainstCombinator;
+function unifyStatementWithCombinator(statementNode, combinator, localContext) {
+  let statementUnifiedWithCombinator;
 
   const statementString = localContext.nodeAsString(statementNode),
         combinatorString = combinator.getString();
 
-  localContext.trace(`Unifying the '${statementString}' statement against the '${combinatorString}' combinator...`, statementNode);
+  localContext.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`, statementNode);
 
   const combinatorStatementNode = combinator.getStatementNode();
 
-  statementUnifiedAgainstCombinator = statementAgainstCombinatorUnifier.unify(statementNode, combinatorStatementNode, localContext);
+  statementUnifiedWithCombinator = statementWithCombinatorUnifier.unify(statementNode, combinatorStatementNode, localContext);
 
-  if (statementUnifiedAgainstCombinator) {
-    localContext.debug(`...unified the '${statementString}' statement against the '${combinatorString}' combinator.`, statementNode);
+  if (statementUnifiedWithCombinator) {
+    localContext.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`, statementNode);
   }
 
-  return statementUnifiedAgainstCombinator;
+  return statementUnifiedWithCombinator;
 }

package/src/verify/statementAsCombinator.js

@@ -8,7 +8,7 @@ export default function verifyStatementAsCombinator(statementNode, fileContext)
 
   const statementString = fileContext.nodeAsString(statementNode);
 
-  fileContext.trace(`Verifying the '${statementString}' statement as a combinator....`, statementNode);
+  fileContext.trace(`Verifying the '${statementString}' statement as a combinator...`, statementNode);
 
   statementVerifiedAsCombinator = statementAsCombinatorVerifier.verify(statementNode, fileContext);
 

package/src/verify/term.js

@@ -3,7 +3,7 @@
 import shim from "../shim";
 import Term from "../term";
 import bracketedConstructor from "../constructor/bracketed";
-import termAgainstConstructorUnifier from "../unifier/termAgainstConstructor";
+import termWithConstructorUnifier from "../unifier/termWithConstructor";
 
 import { nodeQuery } from "../utilities/query";
 
@@ -19,8 +19,8 @@ function verifyTerm(termNode, terms, localContext, verifyAhead) {
 
   const verifyTermFunctions = [
     verifyTermAsVariable,
-    unifyTermAgainstConstructors,
-    unifyTermAgainstBracketedConstructor
+    unifyTermWithConstructors,
+    unifyTermWithBracketedConstructor
   ];
 
   termVerified = verifyTermFunctions.some((verifyTermFunction) => {
@@ -79,35 +79,35 @@ function verifyTermAsVariable(termNode, terms, localContext, verifyAhead) {
   return termVerifiedAsVariable;
 }
 
-function unifyTermAgainstConstructors(termNode, terms, localContext, verifyAhead) {
-  let termUnifiedAgainstConstructors = false;
+function unifyTermWithConstructors(termNode, terms, localContext, verifyAhead) {
+  let termUnifiedWithConstructors = false;
 
   const variableNode = variableNodeQuery(termNode);
 
   if (variableNode === null) {
     const constructors = localContext.getConstructors();
 
-    termUnifiedAgainstConstructors = constructors.some((constructor) => {
-      const termUnifiedAgainstConstructor = unifyTermAgainstConstructor(termNode, terms, constructor, localContext, verifyAhead);
+    termUnifiedWithConstructors = constructors.some((constructor) => {
+      const termUnifiedWithConstructor = unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead);
 
-      if (termUnifiedAgainstConstructor) {
+      if (termUnifiedWithConstructor) {
         return true;
       }
     });
   }
 
-  return termUnifiedAgainstConstructors;
+  return termUnifiedWithConstructors;
 }
 
-function unifyTermAgainstBracketedConstructor(termNode, terms, localContext, verifyAhead) {
-  let termUnifiedAgainstBracketedConstructor;
+function unifyTermWithBracketedConstructor(termNode, terms, localContext, verifyAhead) {
+  let termUnifiedWithBracketedConstructor;
 
   const termString = localContext.nodeAsString(termNode),
         bracketedTerms = [];
 
-  localContext.trace(`Unifying the '${termString}' term against the bracketed constructor...`, termNode);
+  localContext.trace(`Unifying the '${termString}' term with the bracketed constructor...`, termNode);
 
-  termUnifiedAgainstBracketedConstructor = unifyTermAgainstConstructor(termNode, bracketedTerms, bracketedConstructor, localContext, () => {
+  termUnifiedWithBracketedConstructor = unifyTermWithConstructor(termNode, bracketedTerms, bracketedConstructor, localContext, () => {
     let verifiedAhead;
 
     const bracketedTermNode = termNode; ///
@@ -121,25 +121,25 @@ function unifyTermAgainstBracketedConstructor(termNode, terms, localContext, ver
     return verifiedAhead;
   });
 
-  if (termUnifiedAgainstBracketedConstructor) {
-    localContext.debug(`...unified the '${termString}' term against the bracketed constructor.`, termNode);
+  if (termUnifiedWithBracketedConstructor) {
+    localContext.debug(`...unified the '${termString}' term with the bracketed constructor.`, termNode);
   }
 
-  return termUnifiedAgainstBracketedConstructor;
+  return termUnifiedWithBracketedConstructor;
 }
 
-function unifyTermAgainstConstructor(termNode, terms, constructor, localContext, verifyAhead) {
-  let termUnifiedAgainstConstructor = false;
+function unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead) {
+  let termUnifiedWithConstructor = false;
 
   const termString = localContext.nodeAsString(termNode),
         constructorString = constructor.getString(),
         constructorTermNode = constructor.getTermNode();
 
-  localContext.trace(`Unifying the '${termString}' term against the '${constructorString}' constructor...`, termNode);
+  localContext.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`, termNode);
 
   const termNodeA = termNode,  ///
         constructorTermNodeB = constructorTermNode,  ///
-        unified = termAgainstConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext);
+        unified = termWithConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext);
 
   if (unified) {
     let verifiedAhead;
@@ -153,13 +153,13 @@ function unifyTermAgainstConstructor(termNode, terms, constructor, localContext,
 
     terms.pop();
 
-    termUnifiedAgainstConstructor = verifiedAhead;  ///
+    termUnifiedWithConstructor = verifiedAhead;  ///
   }
 
-  if (termUnifiedAgainstConstructor) {
-    localContext.debug(`...unified the '${termString}' term against the '${constructorString}' constructor.`, termNode);
+  if (termUnifiedWithConstructor) {
+    localContext.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`, termNode);
   }
 
-  return termUnifiedAgainstConstructor;
+  return termUnifiedWithConstructor;
 }
 

package/lib/releaseContext/verify.js

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return verifyReleaseContext;
-    }
-});
-function verifyReleaseContext(dependency, dependentName, dependentReleased, context) {
-    var releaseContextVerified = false;
-    var releaseContextMap = context.releaseContextMap, dependencyName = dependency.getName(), releaseName = dependencyName, releaseContext = releaseContextMap[releaseName] || null;
-    if (releaseContext === null) {
-        var log = context.log;
-        log.error("Unable to verify the '".concat(dependencyName, "' dependency's context because it has not been created."));
-    } else {
-        var verified = releaseContext.isVerified();
-        if (verified) {
-            releaseContextVerified = true;
-        } else {
-            var released = releaseContext.isReleased();
-            if (!released && dependentReleased) {
-                var log1 = context.log;
-                log1.error("Unable to verify the '".concat(dependencyName, "' dependency's context because its '").concat(dependentName, "' dependent is a package."));
-            } else {
-                var dependencies = releaseContext.getDependencies();
-                dependentName = dependencyName; ///
-                dependentReleased = released; ///
-                releaseContextVerified = dependencies.everyDependency(function(dependency) {
-                    var releaseContextVerified = verifyReleaseContext(dependency, dependentName, dependentReleased, context);
-                    if (releaseContextVerified) {
-                        return true;
-                    }
-                });
-                if (releaseContextVerified) {
-                    var releaseContexts = retrieveReleaseContexts(releaseContext, releaseContextMap);
-                    releaseContext.verify(releaseContexts);
-                }
-            }
-        }
-    }
-    return releaseContextVerified;
-}
-function retrieveReleaseContexts(releaseContext, releaseContextMap) {
-    var releaseContexts = [], remainingReleaseContext = releaseContext, remainingReleaseContexts = [
-        remainingReleaseContext
-    ];
-    var remainingReleaseContextsLength = remainingReleaseContexts.length;
-    while(remainingReleaseContextsLength > 0){
-        var remainingReleaseContext1 = remainingReleaseContexts.shift(), _$releaseContext = remainingReleaseContext1; ///
-        releaseContexts.push(_$releaseContext);
-        var dependencies = _$releaseContext.getDependencies();
-        dependencies.forEachDependency(function(dependency) {
-            var dependencyName = dependency.getName(), releaseName = dependencyName, _$releaseContext = releaseContextMap[releaseName], releaseContextsIncludesReleaseContext = releaseContexts.includes(_$releaseContext), remainingReleaseContextsIncludesReleaseContext = remainingReleaseContexts.includes(_$releaseContext);
-            if (!releaseContextsIncludesReleaseContext && !remainingReleaseContextsIncludesReleaseContext) {
-                var remainingReleaseContext = _$releaseContext; ///
-                remainingReleaseContexts.push(remainingReleaseContext);
-            }
-        });
-        remainingReleaseContextsLength = remainingReleaseContexts.length;
-    }
-    return releaseContexts;
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9yZWxlYXNlQ29udGV4dC92ZXJpZnkuanMiXSwic291cmNlc0NvbnRlbnQiOlsiXCJ1c2Ugc3RyaWN0XCI7XG5cbmV4cG9ydCBkZWZhdWx0IGZ1bmN0aW9uIHZlcmlmeVJlbGVhc2VDb250ZXh0KGRlcGVuZGVuY3ksIGRlcGVuZGVudE5hbWUsIGRlcGVuZGVudFJlbGVhc2VkLCBjb250ZXh0KSB7XG4gIGxldCByZWxlYXNlQ29udGV4dFZlcmlmaWVkID0gZmFsc2U7XG5cbiAgY29uc3QgeyByZWxlYXNlQ29udGV4dE1hcCB9ID0gY29udGV4dCxcbiAgICAgICAgZGVwZW5kZW5jeU5hbWUgPSBkZXBlbmRlbmN5LmdldE5hbWUoKSxcbiAgICAgICAgcmVsZWFzZU5hbWUgPSBkZXBlbmRlbmN5TmFtZSwgLy8vXG4gICAgICAgIHJlbGVhc2VDb250ZXh0ID0gcmVsZWFzZUNvbnRleHRNYXBbcmVsZWFzZU5hbWVdIHx8IG51bGw7XG5cbiAgaWYgKHJlbGVhc2VDb250ZXh0ID09PSBudWxsKSB7XG4gICAgY29uc3QgeyBsb2cgfSA9IGNvbnRleHQ7XG5cbiAgICBsb2cuZXJyb3IoYFVuYWJsZSB0byB2ZXJpZnkgdGhlICcke2RlcGVuZGVuY3lOYW1lfScgZGVwZW5kZW5jeSdzIGNvbnRleHQgYmVjYXVzZSBpdCBoYXMgbm90IGJlZW4gY3JlYXRlZC5gKTtcbiAgfSBlbHNlIHtcbiAgICBjb25zdCB2ZXJpZmllZCA9IHJlbGVhc2VDb250ZXh0LmlzVmVyaWZpZWQoKTtcblxuICAgIGlmICh2ZXJpZmllZCkge1xuICAgICAgcmVsZWFzZUNvbnRleHRWZXJpZmllZCA9IHRydWU7XG4gICAgfSBlbHNlIHtcbiAgICAgIGNvbnN0IHJlbGVhc2VkID0gcmVsZWFzZUNvbnRleHQuaXNSZWxlYXNlZCgpO1xuXG4gICAgICBpZiAoIXJlbGVhc2VkICYmIGRlcGVuZGVudFJlbGVhc2VkKSB7XG4gICAgICAgIGNvbnN0IHsgbG9nIH0gPSBjb250ZXh0O1xuXG4gICAgICAgIGxvZy5lcnJvcihgVW5hYmxlIHRvIHZlcmlmeSB0aGUgJyR7ZGVwZW5kZW5jeU5hbWV9JyBkZXBlbmRlbmN5J3MgY29udGV4dCBiZWNhdXNlIGl0cyAnJHtkZXBlbmRlbnROYW1lfScgZGVwZW5kZW50IGlzIGEgcGFja2FnZS5gKTtcbiAgICAgIH0gZWxzZSB7XG4gICAgICAgIGNvbnN0IGRlcGVuZGVuY2llcyA9IHJlbGVhc2VDb250ZXh0LmdldERlcGVuZGVuY2llcygpO1xuXG4gICAgICAgIGRlcGVuZGVudE5hbWUgPSBkZXBlbmRlbmN5TmFtZTsgIC8vL1xuXG4gICAgICAgIGRlcGVuZGVudFJlbGVhc2VkID0gcmVsZWFzZWQ7ICAvLy9cblxuICAgICAgICByZWxlYXNlQ29udGV4dFZlcmlmaWVkID0gZGVwZW5kZW5jaWVzLmV2ZXJ5RGVwZW5kZW5jeSgoZGVwZW5kZW5jeSkgPT4geyAgLy8vXG4gICAgICAgICAgY29uc3QgcmVsZWFzZUNvbnRleHRWZXJpZmllZCA9IHZlcmlmeVJlbGVhc2VDb250ZXh0KGRlcGVuZGVuY3ksIGRlcGVuZGVudE5hbWUsIGRlcGVuZGVudFJlbGVhc2VkLCBjb250ZXh0KTtcblxuICAgICAgICAgIGlmIChyZWxlYXNlQ29udGV4dFZlcmlmaWVkKSB7XG4gICAgICAgICAgICByZXR1cm4gdHJ1ZTtcbiAgICAgICAgICB9XG4gICAgICAgIH0pO1xuXG4gICAgICAgIGlmIChyZWxlYXNlQ29udGV4dFZlcmlmaWVkKSB7XG4gICAgICAgICAgY29uc3QgcmVsZWFzZUNvbnRleHRzID0gcmV0cmlldmVSZWxlYXNlQ29udGV4dHMocmVsZWFzZUNvbnRleHQsIHJlbGVhc2VDb250ZXh0TWFwKTtcblxuICAgICAgICAgIHJlbGVhc2VDb250ZXh0LnZlcmlmeShyZWxlYXNlQ29udGV4dHMpO1xuICAgICAgICB9XG4gICAgICB9XG4gICAgfVxuICB9XG5cbiAgcmV0dXJuIHJlbGVhc2VDb250ZXh0VmVyaWZpZWQ7XG59XG5cbmZ1bmN0aW9uIHJldHJpZXZlUmVsZWFzZUNvbnRleHRzKHJlbGVhc2VDb250ZXh0LCByZWxlYXNlQ29udGV4dE1hcCkge1xuICBjb25zdCByZWxlYXNlQ29udGV4dHMgPSBbXSxcbiAgICAgICAgcmVtYWluaW5nUmVsZWFzZUNvbnRleHQgPSByZWxlYXNlQ29udGV4dCwgIC8vL1xuICAgICAgICByZW1haW5pbmdSZWxlYXNlQ29udGV4dHMgPSBbXG4gICAgICAgICAgcmVtYWluaW5nUmVsZWFzZUNvbnRleHRcbiAgICAgICAgXTtcblxuICBsZXQgcmVtYWluaW5nUmVsZWFzZUNvbnRleHRzTGVuZ3RoID0gcmVtYWluaW5nUmVsZWFzZUNvbnRleHRzLmxlbmd0aDtcblxuICB3aGlsZSAocmVtYWluaW5nUmVsZWFzZUNvbnRleHRzTGVuZ3RoID4gMCkge1xuICAgIGNvbnN0IHJlbWFpbmluZ1JlbGVhc2VDb250ZXh0ID0gcmVtYWluaW5nUmVsZWFzZUNvbnRleHRzLnNoaWZ0KCksXG4gICAgICAgICAgcmVsZWFzZUNvbnRleHQgPSByZW1haW5pbmdSZWxlYXNlQ29udGV4dDsgIC8vL1xuXG4gICAgcmVsZWFzZUNvbnRleHRzLnB1c2gocmVsZWFzZUNvbnRleHQpO1xuXG4gICAgY29uc3QgZGVwZW5kZW5jaWVzID0gcmVsZWFzZUNvbnRleHQuZ2V0RGVwZW5kZW5jaWVzKCk7XG5cbiAgICBkZXBlbmRlbmNpZXMuZm9yRWFjaERlcGVuZGVuY3koKGRlcGVuZGVuY3kpID0+IHtcbiAgICAgIGNvbnN0IGRlcGVuZGVuY3lOYW1lID0gZGVwZW5kZW5jeS5nZXROYW1lKCksXG4gICAgICAgICAgICByZWxlYXNlTmFtZSA9IGRlcGVuZGVuY3lOYW1lLCAvLy9cbiAgICAgICAgICAgIHJlbGVhc2VDb250ZXh0ID0gcmVsZWFzZUNvbnRleHRNYXBbcmVsZWFzZU5hbWVdLFxuICAgICAgICAgICAgcmVsZWFzZUNvbnRleHRzSW5jbHVkZXNSZWxlYXNlQ29udGV4dCA9IHJlbGVhc2VDb250ZXh0cy5pbmNsdWRlcyhyZWxlYXNlQ29udGV4dCksXG4gICAgICAgICAgICByZW1haW5pbmdSZWxlYXNlQ29udGV4dHNJbmNsdWRlc1JlbGVhc2VDb250ZXh0ID0gcmVtYWluaW5nUmVsZWFzZUNvbnRleHRzLmluY2x1ZGVzKHJlbGVhc2VDb250ZXh0KTtcblxuICAgICAgaWYgKCFyZWxlYXNlQ29udGV4dHNJbmNsdWRlc1JlbGVhc2VDb250ZXh0ICYmICFyZW1haW5pbmdSZWxlYXNlQ29udGV4dHNJbmNsdWRlc1JlbGVhc2VDb250ZXh0KSB7XG4gICAgICAgIGNvbnN0IHJlbWFpbmluZ1JlbGVhc2VDb250ZXh0ID0gcmVsZWFzZUNvbnRleHQ7IC8vL1xuXG4gICAgICAgIHJlbWFpbmluZ1JlbGVhc2VDb250ZXh0cy5wdXNoKHJlbWFpbmluZ1JlbGVhc2VDb250ZXh0KTtcbiAgICAgIH1cbiAgICB9KTtcblxuICAgIHJlbWFpbmluZ1JlbGVhc2VDb250ZXh0c0xlbmd0aCA9IHJlbWFpbmluZ1JlbGVhc2VDb250ZXh0cy5sZW5ndGg7XG4gIH1cblxuICByZXR1cm4gcmVsZWFzZUNvbnRleHRzO1xufVxuIl0sIm5hbWVzIjpbInZlcmlmeVJlbGVhc2VDb250ZXh0IiwiZGVwZW5kZW5jeSIsImRlcGVuZGVudE5hbWUiLCJkZXBlbmRlbnRSZWxlYXNlZCIsImNvbnRleHQiLCJyZWxlYXNlQ29udGV4dFZlcmlmaWVkIiwicmVsZWFzZUNvbnRleHRNYXAiLCJkZXBlbmRlbmN5TmFtZSIsImdldE5hbWUiLCJyZWxlYXNlTmFtZSIsInJlbGVhc2VDb250ZXh0IiwibG9nIiwiZXJyb3IiLCJ2ZXJpZmllZCIsImlzVmVyaWZpZWQiLCJyZWxlYXNlZCIsImlzUmVsZWFzZWQiLCJkZXBlbmRlbmNpZXMiLCJnZXREZXBlbmRlbmNpZXMiLCJldmVyeURlcGVuZGVuY3kiLCJyZWxlYXNlQ29udGV4dHMiLCJyZXRyaWV2ZVJlbGVhc2VDb250ZXh0cyIsInZlcmlmeSIsInJlbWFpbmluZ1JlbGVhc2VDb250ZXh0IiwicmVtYWluaW5nUmVsZWFzZUNvbnRleHRzIiwicmVtYWluaW5nUmVsZWFzZUNvbnRleHRzTGVuZ3RoIiwibGVuZ3RoIiwic2hpZnQiLCJwdXNoIiwiZm9yRWFjaERlcGVuZGVuY3kiLCJyZWxlYXNlQ29udGV4dHNJbmNsdWRlc1JlbGVhc2VDb250ZXh0IiwiaW5jbHVkZXMiLCJyZW1haW5pbmdSZWxlYXNlQ29udGV4dHNJbmNsdWRlc1JlbGVhc2VDb250ZXh0Il0sIm1hcHBpbmdzIjoiQUFBQTs7OzsrQkFFQTs7O2VBQXdCQTs7O0FBQVQsU0FBU0EscUJBQXFCQyxVQUFVLEVBQUVDLGFBQWEsRUFBRUMsaUJBQWlCLEVBQUVDLE9BQU87SUFDaEcsSUFBSUMseUJBQXlCO0lBRTdCLElBQU0sQUFBRUMsb0JBQXNCRixRQUF0QkUsbUJBQ0ZDLGlCQUFpQk4sV0FBV08sT0FBTyxJQUNuQ0MsY0FBY0YsZ0JBQ2RHLGlCQUFpQkosaUJBQWlCLENBQUNHLFlBQVksSUFBSTtJQUV6RCxJQUFJQyxtQkFBbUIsTUFBTTtRQUMzQixJQUFNLEFBQUVDLE1BQVFQLFFBQVJPO1FBRVJBLElBQUlDLEtBQUssQ0FBQyxBQUFDLHlCQUF1QyxPQUFmTCxnQkFBZTtJQUNwRCxPQUFPO1FBQ0wsSUFBTU0sV0FBV0gsZUFBZUksVUFBVTtRQUUxQyxJQUFJRCxVQUFVO1lBQ1pSLHlCQUF5QjtRQUMzQixPQUFPO1lBQ0wsSUFBTVUsV0FBV0wsZUFBZU0sVUFBVTtZQUUxQyxJQUFJLENBQUNELFlBQVlaLG1CQUFtQjtnQkFDbEMsSUFBTSxBQUFFUSxPQUFRUCxRQUFSTztnQkFFUkEsS0FBSUMsS0FBSyxDQUFDLEFBQUMseUJBQTZFVixPQUFyREssZ0JBQWUsd0NBQW9ELE9BQWRMLGVBQWM7WUFDeEcsT0FBTztnQkFDTCxJQUFNZSxlQUFlUCxlQUFlUSxlQUFlO2dCQUVuRGhCLGdCQUFnQkssZ0JBQWlCLEdBQUc7Z0JBRXBDSixvQkFBb0JZLFVBQVcsR0FBRztnQkFFbENWLHlCQUF5QlksYUFBYUUsZUFBZSxDQUFDLFNBQUNsQjtvQkFDckQsSUFBTUkseUJBQXlCTCxxQkFBcUJDLFlBQVlDLGVBQWVDLG1CQUFtQkM7b0JBRWxHLElBQUlDLHdCQUF3Qjt3QkFDMUIsT0FBTztvQkFDVDtnQkFDRjtnQkFFQSxJQUFJQSx3QkFBd0I7b0JBQzFCLElBQU1lLGtCQUFrQkMsd0JBQXdCWCxnQkFBZ0JKO29CQUVoRUksZUFBZVksTUFBTSxDQUFDRjtnQkFDeEI7WUFDRjtRQUNGO0lBQ0Y7SUFFQSxPQUFPZjtBQUNUO0FBRUEsU0FBU2dCLHdCQUF3QlgsY0FBYyxFQUFFSixpQkFBaUI7SUFDaEUsSUFBTWMsa0JBQWtCLEVBQUUsRUFDcEJHLDBCQUEwQmIsZ0JBQzFCYywyQkFBMkI7UUFDekJEO0tBQ0Q7SUFFUCxJQUFJRSxpQ0FBaUNELHlCQUF5QkUsTUFBTTtJQUVwRSxNQUFPRCxpQ0FBaUMsRUFBRztRQUN6QyxJQUFNRiwyQkFBMEJDLHlCQUF5QkcsS0FBSyxJQUN4RGpCLG1CQUFpQmEsMEJBQTBCLEdBQUc7UUFFcERILGdCQUFnQlEsSUFBSSxDQUFDbEI7UUFFckIsSUFBTU8sZUFBZVAsaUJBQWVRLGVBQWU7UUFFbkRELGFBQWFZLGlCQUFpQixDQUFDLFNBQUM1QjtZQUM5QixJQUFNTSxpQkFBaUJOLFdBQVdPLE9BQU8sSUFDbkNDLGNBQWNGLGdCQUNkRyxtQkFBaUJKLGlCQUFpQixDQUFDRyxZQUFZLEVBQy9DcUIsd0NBQXdDVixnQkFBZ0JXLFFBQVEsQ0FBQ3JCLG1CQUNqRXNCLGlEQUFpRFIseUJBQXlCTyxRQUFRLENBQUNyQjtZQUV6RixJQUFJLENBQUNvQix5Q0FBeUMsQ0FBQ0UsZ0RBQWdEO2dCQUM3RixJQUFNVCwwQkFBMEJiLGtCQUFnQixHQUFHO2dCQUVuRGMseUJBQXlCSSxJQUFJLENBQUNMO1lBQ2hDO1FBQ0Y7UUFFQUUsaUNBQWlDRCx5QkFBeUJFLE1BQU07SUFDbEU7SUFFQSxPQUFPTjtBQUNUIn0=