occam-verify-cli 0.0.936 → 0.0.938

package/src/verify/statement/qualified.js

@@ -65,7 +65,7 @@ function verifyQualifiedStatementAAgainstRule(qualifiedStatementNode, substituti
 
     localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' rule...`, qualifiedStatementNode);
 
-    const ruleMatchesStatement = rule.matchStatement(statementNode, localContext);
+    const ruleMatchesStatement = rule.unifyStatement(statementNode, localContext);
 
     qualifiedStatementVerifiedAgainstRule = ruleMatchesStatement;  ///
 
@@ -90,7 +90,7 @@ function verifyQualifiedStatementAAgainstAxiom(qualifiedStatementNode, substitut
 
     localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' axiom...`, qualifiedStatementNode);
 
-    const axiomMatchesStatement = axiom.matchStatement(statementNode, localContext);
+    const axiomMatchesStatement = axiom.unifyStatement(statementNode, localContext);
 
     qualifiedStatementVerifiedAgainstAxiom = axiomMatchesStatement; ///
 
@@ -115,7 +115,7 @@ function verifyQualifiedStatementAAgainstLemma(qualifiedStatementNode, substitut
 
     localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' lemma...`, qualifiedStatementNode);
 
-    const lemmaMatchesStatement = lemma.matchStatement(statementNode, localContext);
+    const lemmaMatchesStatement = lemma.unifyStatement(statementNode, localContext);
 
     qualifiedStatementVerifiedAgainstLemma = lemmaMatchesStatement; ///
 
@@ -140,7 +140,7 @@ function verifyQualifiedStatementAAgainstTheorem(qualifiedStatementNode, substit
 
     localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' theorem...`, qualifiedStatementNode);
 
-    const theoremMatchesStatement = theorem.matchStatement(statementNode, localContext);
+    const theoremMatchesStatement = theorem.unifyStatement(statementNode, localContext);
 
     qualifiedStatementVerifiedAgainstTheorem = theoremMatchesStatement; ///
 
@@ -165,7 +165,7 @@ function verifyQualifiedStatementAAgainstConjecture(qualifiedStatementNode, subs
 
     localContext.trace(`Verifying the '${qualifiedStatementString}' qualified statement against the '${metavariableString}' conjecture...`, qualifiedStatementNode);
 
-    const conjectureMatchesStatement = conjecture.matchStatement(statementNode, localContext);
+    const conjectureMatchesStatement = conjecture.unifyStatement(statementNode, localContext);
 
     qualifiedStatementVerifiedAgainstConjecture = conjectureMatchesStatement; ///
 
@@ -192,9 +192,9 @@ function verifyQualifiedStatementAAgainstReference(qualifiedStatementNode, subst
           localContextA = null,
           localContextB = localContext, ///
           statementNodeB = statementNode, ///
-          substitutionNode = null,
+          substitutionNodeA = null,
           metavariableNodeA = metavariableNode, ///
-          metavariableVerifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNode, substitutions, localContextA, localContextB, () => {
+          metavariableVerifiedAgainstStatement = unifyMetavariableAgainstStatement(metavariableNodeA, statementNodeB, substitutionNodeA, substitutions, localContextA, localContextB, () => {
             const verifiedAhead = true;
 
             return verifiedAhead;

package/src/verify/statement.js

@@ -3,6 +3,7 @@
 import shim from "../shim";
 import verifyEquality from "../verify/equality";
 import verifyJudgement from "../verify/judgement";
+import metaLevelVerifier from "../verifier/metaLevel";
 import bracketedCombinator from "../ocmbinator/bracketed";
 import verifyTypeAssertion from "../verify/assertion/type";
 import verifyDefinedAssertion from "../verify/assertion/defined";
@@ -11,15 +12,11 @@ import verifyContainedAssertion from "../verify/assertion/contained";
 import statementAgainstCombinatorUnifier from "../unifier/statementAgainstCombinator";
 
 import { nodeQuery } from "../utilities/query";
-import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 
-const variableNodeQuery = nodeQuery("/substitution/variable!"),
-      equalityNodeQuery = nodeQuery("/statement/equality!"),
+const equalityNodeQuery = nodeQuery("/statement/equality!"),
       judgementNodeQuery = nodeQuery("/statement/judgement!"),
-      metavariableNodeQuery = nodeQuery("/statement/metavariable!"),
-      substitutionNodeQuery = nodeQuery("/statement/substitution!"),
+      metavariableNodeQuery = nodeQuery("/*/metavariable!"),
       typeAssertionNodeQuery = nodeQuery("/statement/typeAssertion!"),
-      termVariableNodeQuery = nodeQuery("/substitution/term/variable!"),
       definedAssertionNodeQuery = nodeQuery("/statement/definedAssertion!"),
       subproofAssertionNodeQuery = nodeQuery("/statement/subproofAssertion!"),
       containedAssertionNodeQuery = nodeQuery("/statement/containedAssertion!");
@@ -98,16 +95,9 @@ function verifyStatementAsMetavariable(statementNode, assignments, derived, loca
 
     localContext.trace(`Verifying the '${statementString}' statement as a metavariable...`, statementNode);
 
-    const metavariableVerified = verifyMetavariable(metavariableNode, localContext);
+    const verified = metaLevelVerifier.verify(statementNode, localContext);
 
-    if (metavariableVerified) {
-      const substitutionNode = substitutionNodeQuery(statementNode),
-            substitutionVerified = verifySubstitution(substitutionNode, localContext);
-
-      if (substitutionVerified) {
-        statementVerifiedAsMetavariable = true;
-      }
-    }
+    statementVerifiedAsMetavariable = verified; ///
 
     if (statementVerifiedAsMetavariable) {
       localContext.debug(`...verified the '${statementString}' statement as a metavariable.`, statementNode);
@@ -197,11 +187,7 @@ function verifyStatementAsDefinedAssertion(statementNode, assignments, derived,
 
     localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, statementNode);
 
-    const definedAssertionVerified = verifyDefinedAssertion(definedAssertionNode, assignments, derived, localContext, () => {
-      const verifiedAhead = true;
-
-      return verifiedAhead;
-    });
+    const definedAssertionVerified = verifyDefinedAssertion(definedAssertionNode, assignments, derived, localContext);
 
     statementVerifiedAsDefinedAssertion = definedAssertionVerified; ///
 
@@ -223,11 +209,7 @@ function verifyStatementAsSubproofAssertion(statementNode, assignments, derived,
 
     localContext.trace(`Verifying the '${statementString}' statement as a subproof assertion...`, statementNode);
 
-    const subproofAssertionVerified = verifySubproofAssertion(subproofAssertionNode, assignments, derived, localContext, () => {
-      const verifiedAhead = true;
-
-      return verifiedAhead;
-    });
+    const subproofAssertionVerified = verifySubproofAssertion(subproofAssertionNode, assignments, derived, localContext);
 
     statementVerifiedAsSubproofAssertion = subproofAssertionVerified; ///
 
@@ -249,11 +231,7 @@ function verifyStatementAsContainedAssertion(statementNode, assignments, derived
 
     localContext.trace(`Verifying the '${statementString}' statement as a defined assertion...`, statementNode);
 
-    const containedAssertionVerified = verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext, () => {
-      const verifiedAhead = true;
-
-      return verifiedAhead;
-    });
+    const containedAssertionVerified = verifyContainedAssertion(containedAssertionNode, assignments, derived, localContext);
 
     statementVerifiedAsContainedAssertion = containedAssertionVerified; ///
 
@@ -311,16 +289,9 @@ function verifyStatementAgainstCombinator(statementNode, combinator, localContex
 
   localContext.trace(`Verifying the '${statementString}' statement against the '${combinatorString}' combinator...`, statementNode);
 
-  const combinatorStatementNode = combinator.getStatementNode(),
-        nonTerminalNodeA = statementNode, ///
-        nonTerminalNodeB = combinatorStatementNode, ///
-        nonTerminalNodeUnify = statementAgainstCombinatorUnifier.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, () => {
-          const verifiedAhead = true;
+  const combinatorStatementNode = combinator.getStatementNode();
 
-          return verifiedAhead;
-        });
-
-  statementVerifiedAgainstCombinator = nonTerminalNodeUnify;  ///
+  statementVerifiedAgainstCombinator = statementAgainstCombinatorUnifier.unify(statementNode, combinatorStatementNode, localContext);
 
   if (statementVerifiedAgainstCombinator) {
     localContext.debug(`...verified the '${statementString}' statement against the '${combinatorString}' combinator.`, statementNode);
@@ -328,42 +299,3 @@ function verifyStatementAgainstCombinator(statementNode, combinator, localContex
 
   return statementVerifiedAgainstCombinator;
 }
-
-function verifyMetavariable(metavariableNode, localContext) {
-  let metavariableVerified = false;
-
-  const metavariable = localContext.findMetavariableByMetavariableNode(metavariableNode);
-
-  if (metavariable !== null) {
-    const metaTypeName  = metavariable.getMetaTypeName();
-
-    if (metaTypeName === STATEMENT_META_TYPE_NAME) {
-      metavariableVerified = true;
-    }
-  }
-
-  return metavariableVerified;
-}
-
-function verifySubstitution(substitutionNode, localContext) {
-  let substitutionVerified = false;
-
-  if (substitutionNode === null) {
-    substitutionVerified = true;
-  } else {
-    const variableNode = variableNodeQuery(substitutionNode),
-          variablePresent = localContext.isVariablePresentByVariableNode(variableNode);
-
-    if (variablePresent) {
-      const termVariableNode = termVariableNodeQuery(substitutionNode);
-
-      if (termVariableNode !== null) {
-        const termVariablePresent = localContext.isVariablePresentByVariableNode(termVariableNode);
-
-        substitutionVerified = termVariablePresent; ///
-      }
-    }
-  }
-
-  return substitutionVerified;
-}

package/src/verify/statementAsCombinator.js

@@ -4,27 +4,19 @@ import Combinator from "../combinator";
 import statementAsCombinatorVerifier from "../verifier/statementAsCombinator";
 
 export default function verifyStatementAsCombinator(statementNode, fileContext) {
-  let statementVerifiedAsCombinator = false;
+  let statementVerifiedAsCombinator;
 
   const statementString = fileContext.nodeAsString(statementNode);
 
   fileContext.trace(`Verifying the '${statementString}' statement as a combinator....`, statementNode);
 
-  const nonTerminalNode = statementNode, ///
-        childNodes = nonTerminalNode.getChildNodes(),
-        childNodesVerified = statementAsCombinatorVerifier.verifyChildNodes(childNodes, fileContext, () => {
-          const verifiedAhead = true;
+  statementVerifiedAsCombinator = statementAsCombinatorVerifier.verify(statementNode, fileContext);
 
-          return verifiedAhead;
-        });
-
-  if (childNodesVerified) {
+  if (statementVerifiedAsCombinator) {
     const tokens = fileContext.getTokens(),
           combinator = Combinator.fromStatementNodeAndTokens(statementNode, tokens);
 
     fileContext.addCombinator(combinator);
-
-    statementVerifiedAsCombinator = true;
   }
 
   if (statementVerifiedAsCombinator) {

package/src/verify/term.js

@@ -130,9 +130,9 @@ function verifyTermAgainstBracketedConstructor(termNode, terms, localContext, ve
   localContext.trace(`Verifying the '${termString}' term against the '${bracketedConstructorString}' bracketed constructor...`, termNode);
 
   const bracketedConstructorTermNode = bracketedConstructor.getTermNode(),
-        nonTerminalNNdeA = termNode,  ///
-        nonTerminalNodeB = bracketedConstructorTermNode,  ///
-        nodeUnified = termAgainstConstructorUnifier.unifyNonTerminalNode(nonTerminalNNdeA, nonTerminalNodeB, localContext, () => {
+        termNodeA = termNode,  ///
+        constructorTermNodeB = bracketedConstructorTermNode,  ///
+        unified = termAgainstConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext, () => {
           let verifiedAhead;
 
           const bracketedTermNode = termNode; ///
@@ -175,7 +175,7 @@ function verifyTermAgainstBracketedConstructor(termNode, terms, localContext, ve
           return verifiedAhead;
         });
 
-  termVerifiedAgainstBracketedConstructor = nodeUnified;  ///
+  termVerifiedAgainstBracketedConstructor = unified;  ///
 
   if (termVerifiedAgainstBracketedConstructor) {
     localContext.debug(`...verified the '${termString}' term against the '${bracketedConstructorString}' constructor.`, termNode);
@@ -193,9 +193,9 @@ function verifyTermAgainstConstructor(termNode, terms, constructor, localContext
   localContext.trace(`Verifying the '${termString}' term against the '${constructorString}' constructor...`, termNode);
 
   const constructorTermNode = constructor.getTermNode(),
-        nonTerminalNNdeA = termNode,  ///
-        nonTerminalNodeB = constructorTermNode,  ///
-        nodeUnify = termAgainstConstructorUnifier.unifyNonTerminalNode(nonTerminalNNdeA, nonTerminalNodeB, localContext, () => {
+        termNodeA = termNode,  ///
+        constructorTermNodeB = constructorTermNode,  ///
+        unified = termAgainstConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext, () => {
           let verifiedAhead;
 
           const type = constructor.getType(),
@@ -212,7 +212,7 @@ function verifyTermAgainstConstructor(termNode, terms, constructor, localContext
           return verifiedAhead;
         });
 
-  termVerifiedAgainstConstructor = nodeUnify;  ///
+  termVerifiedAgainstConstructor = unified;  ///
 
   if (termVerifiedAgainstConstructor) {
     localContext.debug(`...verified the '${termString}' term against the '${constructorString}' constructor.`, termNode);

package/src/verify/termAsConstructor.js

@@ -1,9 +1,10 @@
 "use strict";
 
 import Constructor from "../constructor";
-import LocalContext from "../context/local";
 import termAsConstructorVerifier from "../verifier/termAsConstructor";
 
+import { first } from "../utilities/array";
+
 export default function verifyTermAsConstructor(termNode, typeNode, fileContext) {
   let termVerifiedAsConstructor = false;
 
@@ -11,38 +12,24 @@ export default function verifyTermAsConstructor(termNode, typeNode, fileContext)
 
   fileContext.debug(`Verifying the '${termString}' term as a constructor...`, termNode);
 
-  const localContext = LocalContext.fromFileContext(fileContext),
-        nonTerminalNode = termNode, ///
-        childNodes = nonTerminalNode.getChildNodes(),
-        childNodesVerified = termAsConstructorVerifier.verifyChildNodes(childNodes, localContext, () => {
-          const verifiedAhead = true;
-
-          return verifiedAhead;
-        });
+  const types = [],
+        typeVerified = verifyType(typeNode, types, fileContext);
 
-  if (childNodesVerified) {
-    let type = null;
+  let type;
 
-    if (typeNode === null) {
-      termVerifiedAsConstructor = true;
-    } else {
-      type = fileContext.findTypeByTypeNode(typeNode);
+  if (typeVerified) {
+    const firstType = first(types);
 
-      if (type !== null) {
-        termVerifiedAsConstructor = true;
-      } else {
-        const typeString = fileContext.nodeAsString(typeNode);
+    type = firstType; ///
 
-        fileContext.debug(`The '${termString}' constructor's '${typeString}' type is not present.`, termNode);
-      }
-    }
+    termVerifiedAsConstructor = termAsConstructorVerifier.verify(termNode, fileContext);
+  }
 
-    if (termVerifiedAsConstructor) {
-      const tokens = fileContext.getTokens(),
-            constructor = Constructor.fromTermNodeTypeAndTokens(termNode, type, tokens);
+  if (termVerifiedAsConstructor) {
+    const tokens = fileContext.getTokens(),
+          constructor = Constructor.fromTermNodeTypeAndTokens(termNode, type, tokens);
 
-      fileContext.addConstructor(constructor);
-    }
+    fileContext.addConstructor(constructor);
   }
 
   if (termVerifiedAsConstructor) {
@@ -51,3 +38,29 @@ export default function verifyTermAsConstructor(termNode, typeNode, fileContext)
 
   return termVerifiedAsConstructor;
 }
+
+function verifyType(typeNode, types, fileContext) {
+  let typeVerified = false;
+
+  if (typeNode === null) {
+    const type = null;
+
+    types.push(type);
+
+    typeVerified = true;
+  } else {
+    const type = fileContext.findTypeByTypeNode(typeNode);
+
+    if (type !== null) {
+      types.push(type);
+
+      typeVerified = true;
+    } else {
+      const typeString = fileContext.nodeAsString(typeNode);
+
+      fileContext.debug(`The '${typeString}' type is not present.`, typeNode);
+    }
+  }
+
+  return typeVerified;
+}

package/lib/unify/argumentAgainstArgument.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "default", {
-    enumerable: true,
-    get: function() {
-        return unifyArgumentAgainstArgument;
-    }
-});
-var _termAgainstConstructor = /*#__PURE__*/ _interop_require_default(require("../unifier/termAgainstConstructor"));
-function _interop_require_default(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function unifyArgumentAgainstArgument(argumentNodeA, argumentNodeB, localContext, unifyAhead) {
-    var argumentUnifiedAgainstArgument;
-    var nonTerminalNodeA = argumentNodeA, nonTerminalNodeB = argumentNodeB, nonTerminalNodeVerified = _termAgainstConstructor.default.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead);
-    argumentUnifiedAgainstArgument = nonTerminalNodeVerified; ///
-    return argumentUnifiedAgainstArgument;
-}
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy91bmlmeS9hcmd1bWVudEFnYWluc3RBcmd1bWVudC5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuaW1wb3J0IHRlcm1BZ2FpbnN0Q29uc3RydWN0b3JVbmlmaWVyIGZyb20gXCIuLi91bmlmaWVyL3Rlcm1BZ2FpbnN0Q29uc3RydWN0b3JcIjtcblxuZXhwb3J0IGRlZmF1bHQgZnVuY3Rpb24gdW5pZnlBcmd1bWVudEFnYWluc3RBcmd1bWVudChhcmd1bWVudE5vZGVBLCBhcmd1bWVudE5vZGVCLCBsb2NhbENvbnRleHQsIHVuaWZ5QWhlYWQpIHtcbiAgbGV0IGFyZ3VtZW50VW5pZmllZEFnYWluc3RBcmd1bWVudDtcblxuICBjb25zdCBub25UZXJtaW5hbE5vZGVBID0gYXJndW1lbnROb2RlQSwgLy8vXG4gICAgICAgIG5vblRlcm1pbmFsTm9kZUIgPSBhcmd1bWVudE5vZGVCLCAvLy9cbiAgICAgICAgbm9uVGVybWluYWxOb2RlVmVyaWZpZWQgPSB0ZXJtQWdhaW5zdENvbnN0cnVjdG9yVW5pZmllci51bmlmeU5vblRlcm1pbmFsTm9kZShub25UZXJtaW5hbE5vZGVBLCBub25UZXJtaW5hbE5vZGVCLCBsb2NhbENvbnRleHQsIHVuaWZ5QWhlYWQpO1xuXG4gIGFyZ3VtZW50VW5pZmllZEFnYWluc3RBcmd1bWVudCA9IG5vblRlcm1pbmFsTm9kZVZlcmlmaWVkOyAvLy9cblxuICByZXR1cm4gYXJndW1lbnRVbmlmaWVkQWdhaW5zdEFyZ3VtZW50O1xufVxuIl0sIm5hbWVzIjpbInVuaWZ5QXJndW1lbnRBZ2FpbnN0QXJndW1lbnQiLCJhcmd1bWVudE5vZGVBIiwiYXJndW1lbnROb2RlQiIsImxvY2FsQ29udGV4dCIsInVuaWZ5QWhlYWQiLCJhcmd1bWVudFVuaWZpZWRBZ2FpbnN0QXJndW1lbnQiLCJub25UZXJtaW5hbE5vZGVBIiwibm9uVGVybWluYWxOb2RlQiIsIm5vblRlcm1pbmFsTm9kZVZlcmlmaWVkIiwidGVybUFnYWluc3RDb25zdHJ1Y3RvclVuaWZpZXIiLCJ1bmlmeU5vblRlcm1pbmFsTm9kZSJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7K0JBSUE7OztlQUF3QkE7Ozs2RUFGa0I7Ozs7OztBQUUzQixTQUFTQSw2QkFBNkJDLGFBQWEsRUFBRUMsYUFBYSxFQUFFQyxZQUFZLEVBQUVDLFVBQVU7SUFDekcsSUFBSUM7SUFFSixJQUFNQyxtQkFBbUJMLGVBQ25CTSxtQkFBbUJMLGVBQ25CTSwwQkFBMEJDLCtCQUE2QixDQUFDQyxvQkFBb0IsQ0FBQ0osa0JBQWtCQyxrQkFBa0JKLGNBQWNDO0lBRXJJQyxpQ0FBaUNHLHlCQUF5QixHQUFHO0lBRTdELE9BQU9IO0FBQ1QifQ==

package/lib/utilities/terminalNodes.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    areTerminalNodeMapsEqual: function() {
-        return areTerminalNodeMapsEqual;
-    },
-    terminalNodeMapFromNodes: function() {
-        return terminalNodeMapFromNodes;
-    }
-});
-var _array = require("../utilities/array");
-function terminalNodeMapFromNodes(nodes) {
-    var terminalNodeMap = {};
-    nodes.forEach(function(node, index) {
-        var nodeTerminalNode = node.isTerminalNode();
-        if (nodeTerminalNode) {
-            var terminalNode = node; //
-            terminalNodeMap[index] = terminalNode;
-        }
-    });
-    return terminalNodeMap;
-}
-function areTerminalNodeMapsEqual(terminalNodeMapA, terminalNodeMapB) {
-    var terminalNodeMapsEqual = false;
-    var indexesA = Object.keys(terminalNodeMapA), indexesB = Object.keys(terminalNodeMapB), terminalNodeMapKeysMatch = (0, _array.match)(indexesA, indexesB, function(indexA, indexB) {
-        var matches = indexA === indexB;
-        if (matches) {
-            return true;
-        }
-    });
-    if (terminalNodeMapKeysMatch) {
-        var terminalNodesA = Object.values(terminalNodeMapA), terminalNodesB = Object.values(terminalNodeMapB), terminalNodeMapValuesMatch = (0, _array.match)(terminalNodesA, terminalNodesB, function(terminalNodeA, terminalNodeB) {
-            var matches = terminalNodeA.match(terminalNodeB);
-            if (matches) {
-                return true;
-            }
-        });
-        terminalNodeMapsEqual = terminalNodeMapValuesMatch; ///
-    }
-    return terminalNodeMapsEqual;
-}
-
-//# sourceMappingURL=data:application/json;base64,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

package/src/unify/argumentAgainstArgument.js

@@ -1,15 +0,0 @@
-"use strict";
-
-import termAgainstConstructorUnifier from "../unifier/termAgainstConstructor";
-
-export default function unifyArgumentAgainstArgument(argumentNodeA, argumentNodeB, localContext, unifyAhead) {
-  let argumentUnifiedAgainstArgument;
-
-  const nonTerminalNodeA = argumentNodeA, ///
-        nonTerminalNodeB = argumentNodeB, ///
-        nonTerminalNodeVerified = termAgainstConstructorUnifier.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext, unifyAhead);
-
-  argumentUnifiedAgainstArgument = nonTerminalNodeVerified; ///
-
-  return argumentUnifiedAgainstArgument;
-}