occam-verify-cli 0.0.960 → 0.0.962

package/lib/verify/term.js

@@ -10,30 +10,37 @@ Object.defineProperty(exports, "default", {
 });
 var _shim = /*#__PURE__*/ _interop_require_default(require("../shim"));
 var _term = /*#__PURE__*/ _interop_require_default(require("../term"));
-var _bracketed = /*#__PURE__*/ _interop_require_default(require("../constructor/bracketed"));
-var _termWithConstructor = /*#__PURE__*/ _interop_require_default(require("../unifier/termWithConstructor"));
+var _termWithConstructors = /*#__PURE__*/ _interop_require_default(require("../unify/termWithConstructors"));
+var _termWithBracketedConstructor = /*#__PURE__*/ _interop_require_default(require("../unify/termWithBracketedConstructor"));
+var _array = require("../utilities/array");
 var _query = require("../utilities/query");
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj
     };
 }
-var termNodeQuery = (0, _query.nodeQuery)("/term/argument/term"), variableNodeQuery = (0, _query.nodeQuery)("/term/variable!");
+var variableNodeQuery = (0, _query.nodeQuery)("/term/variable!");
+var unifyTermFunctions = [
+    _termWithBracketedConstructor.default,
+    _termWithConstructors.default
+];
 function verifyTerm(termNode, terms, localContext, verifyAhead) {
-    var termVerified;
+    var termVerified = false;
     var termString = localContext.nodeAsString(termNode);
     localContext.trace("Verifying the '".concat(termString, "' term..."), termNode);
-    var verifyTermFunctions = [
-        verifyTermAsVariable,
-        unifyTermWithConstructors,
-        unifyTermWithBracketedConstructor
-    ];
-    termVerified = verifyTermFunctions.some(function(verifyTermFunction) {
-        var termVerified = verifyTermFunction(termNode, terms, localContext, verifyAhead);
-        if (termVerified) {
-            return true;
-        }
-    });
+    if (!termVerified) {
+        var termVerifiedAsVariable = verifyTermAsVariable(termNode, terms, localContext, verifyAhead);
+        termVerified = termVerifiedAsVariable; ///
+    }
+    if (!termVerified) {
+        var termUnified = unifyTermFunctions.some(function(unifyTermFunction) {
+            var termUnified = unifyTermFunction(termNode, terms, localContext, verifyAhead);
+            if (termUnified) {
+                return true;
+            }
+        });
+        termVerified = termUnified; ///
+    }
     if (termVerified) {
         localContext.debug("...verified the '".concat(termString, "' term."), termNode);
     }
@@ -49,10 +56,10 @@ function verifyTermAsVariable(termNode, terms, localContext, verifyAhead) {
     if (variableNode !== null) {
         var termString = localContext.nodeAsString(termNode);
         localContext.trace("Verifying the '".concat(termString, "' term as a variable..."), termNode);
-        var variable = localContext.findVariableByVariableNode(variableNode);
-        if (variable !== null) {
+        var variables = [], variableVerified = verifyVariable(variableNode, variables, localContext);
+        if (variableVerified) {
             var verifiedAhead;
-            var type = variable.getType(), term = _term.default.fromTermNodeAndType(termNode, type);
+            var firstVariable = (0, _array.first)(variables), variable = firstVariable, type = variable.getType(), term = _term.default.fromTermNodeAndType(termNode, type);
             terms.push(term);
             verifiedAhead = verifyAhead();
             terms.pop();
@@ -64,54 +71,21 @@ function verifyTermAsVariable(termNode, terms, localContext, verifyAhead) {
     }
     return termVerifiedAsVariable;
 }
-function unifyTermWithConstructors(termNode, terms, localContext, verifyAhead) {
-    var termUnifiedWithConstructors = false;
-    var variableNode = variableNodeQuery(termNode);
-    if (variableNode === null) {
-        var constructors = localContext.getConstructors();
-        termUnifiedWithConstructors = constructors.some(function(constructor) {
-            var termUnifiedWithConstructor = unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead);
-            if (termUnifiedWithConstructor) {
-                return true;
-            }
-        });
-    }
-    return termUnifiedWithConstructors;
-}
-function unifyTermWithBracketedConstructor(termNode, terms, localContext, verifyAhead) {
-    var termUnifiedWithBracketedConstructor;
-    var termString = localContext.nodeAsString(termNode), bracketedTerms = [];
-    localContext.trace("Unifying the '".concat(termString, "' term with the bracketed constructor..."), termNode);
-    termUnifiedWithBracketedConstructor = unifyTermWithConstructor(termNode, bracketedTerms, _bracketed.default, localContext, function() {
-        var verifiedAhead;
-        var bracketedTermNode = termNode; ///
-        termNode = termNodeQuery(bracketedTermNode); ///
-        var termVVerified = verifyTerm(termNode, terms, localContext, verifyAhead);
-        verifiedAhead = termVVerified; ///
-        return verifiedAhead;
-    });
-    if (termUnifiedWithBracketedConstructor) {
-        localContext.debug("...unified the '".concat(termString, "' term with the bracketed constructor."), termNode);
-    }
-    return termUnifiedWithBracketedConstructor;
-}
-function unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead) {
-    var termUnifiedWithConstructor = false;
-    var termString = localContext.nodeAsString(termNode), constructorString = constructor.getString(), constructorTermNode = constructor.getTermNode();
-    localContext.trace("Unifying the '".concat(termString, "' term with the '").concat(constructorString, "' constructor..."), termNode);
-    var termNodeA = termNode, constructorTermNodeB = constructorTermNode, unified = _termWithConstructor.default.unify(termNodeA, constructorTermNodeB, localContext);
-    if (unified) {
-        var verifiedAhead;
-        var type = constructor.getType(), term = _term.default.fromTermNodeAndType(termNode, type);
-        terms.push(term);
-        verifiedAhead = verifyAhead();
-        terms.pop();
-        termUnifiedWithConstructor = verifiedAhead; ///
+function verifyVariable(variableNode, variables, localContext) {
+    var variableVerified = false;
+    var variableString = localContext.nodeAsString(variableNode);
+    localContext.trace("Verifying the '".concat(variableString, "' variable..."), variableNode);
+    var variable = localContext.findVariableByVariableNode(variableNode);
+    if (variable === null) {
+        localContext.trace("The '".concat(variableString, "' variable is not present."), variableNode);
+    } else {
+        variables.push(variable);
+        variableVerified = true;
     }
-    if (termUnifiedWithConstructor) {
-        localContext.debug("...unified the '".concat(termString, "' term with the '").concat(constructorString, "' constructor."), termNode);
+    if (variableVerified) {
+        localContext.debug("...verified the '".concat(variableString, "' variable."), variableNode);
     }
-    return termUnifiedWithConstructor;
+    return variableVerified;
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/verify/term.js"],"sourcesContent":["\"use strict\";\n\nimport shim from \"../shim\";\nimport Term from \"../term\";\nimport bracketedConstructor from \"../constructor/bracketed\";\nimport termWithConstructorUnifier from \"../unifier/termWithConstructor\";\n\nimport { nodeQuery } from \"../utilities/query\";\n\nconst termNodeQuery = nodeQuery(\"/term/argument/term\"),\n      variableNodeQuery = nodeQuery(\"/term/variable!\");\n\nfunction verifyTerm(termNode, terms, localContext, verifyAhead) {\n  let termVerified;\n\n  const termString = localContext.nodeAsString(termNode);\n\n  localContext.trace(`Verifying the '${termString}' term...`, termNode);\n\n  const verifyTermFunctions = [\n    verifyTermAsVariable,\n    unifyTermWithConstructors,\n    unifyTermWithBracketedConstructor\n  ];\n\n  termVerified = verifyTermFunctions.some((verifyTermFunction) => {\n    const termVerified = verifyTermFunction(termNode, terms, localContext, verifyAhead);\n\n    if (termVerified) {\n      return true;\n    }\n  });\n\n  if (termVerified) {\n    localContext.debug(`...verified the '${termString}' term.`, termNode);\n  }\n\n  return termVerified;\n}\n\nObject.assign(shim, {\n  verifyTerm\n});\n\nexport default verifyTerm;\n\nfunction verifyTermAsVariable(termNode, terms, localContext, verifyAhead) {\n  let termVerifiedAsVariable = false;\n\n  const variableNode = variableNodeQuery(termNode);\n\n  if (variableNode !== null) {\n    const termString = localContext.nodeAsString(termNode);\n\n    localContext.trace(`Verifying the '${termString}' term as a variable...`, termNode);\n\n    const variable = localContext.findVariableByVariableNode(variableNode);\n\n    if (variable !== null) {\n      let verifiedAhead;\n\n      const type = variable.getType(),\n            term = Term.fromTermNodeAndType(termNode, type);\n\n      terms.push(term);\n\n      verifiedAhead = verifyAhead();\n\n      terms.pop();\n\n      termVerifiedAsVariable = verifiedAhead; ///\n    }\n\n    if (termVerifiedAsVariable) {\n      localContext.debug(`...verified the '${termString}' term as a variable.`, termNode);\n    }\n  }\n\n  return termVerifiedAsVariable;\n}\n\nfunction unifyTermWithConstructors(termNode, terms, localContext, verifyAhead) {\n  let termUnifiedWithConstructors = false;\n\n  const variableNode = variableNodeQuery(termNode);\n\n  if (variableNode === null) {\n    const constructors = localContext.getConstructors();\n\n    termUnifiedWithConstructors = constructors.some((constructor) => {\n      const termUnifiedWithConstructor = unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead);\n\n      if (termUnifiedWithConstructor) {\n        return true;\n      }\n    });\n  }\n\n  return termUnifiedWithConstructors;\n}\n\nfunction unifyTermWithBracketedConstructor(termNode, terms, localContext, verifyAhead) {\n  let termUnifiedWithBracketedConstructor;\n\n  const termString = localContext.nodeAsString(termNode),\n        bracketedTerms = [];\n\n  localContext.trace(`Unifying the '${termString}' term with the bracketed constructor...`, termNode);\n\n  termUnifiedWithBracketedConstructor = unifyTermWithConstructor(termNode, bracketedTerms, bracketedConstructor, localContext, () => {\n    let verifiedAhead;\n\n    const bracketedTermNode = termNode; ///\n\n    termNode = termNodeQuery(bracketedTermNode); ///\n\n    const termVVerified = verifyTerm(termNode, terms, localContext, verifyAhead);\n\n    verifiedAhead = termVVerified;  ///\n\n    return verifiedAhead;\n  });\n\n  if (termUnifiedWithBracketedConstructor) {\n    localContext.debug(`...unified the '${termString}' term with the bracketed constructor.`, termNode);\n  }\n\n  return termUnifiedWithBracketedConstructor;\n}\n\nfunction unifyTermWithConstructor(termNode, terms, constructor, localContext, verifyAhead) {\n  let termUnifiedWithConstructor = false;\n\n  const termString = localContext.nodeAsString(termNode),\n        constructorString = constructor.getString(),\n        constructorTermNode = constructor.getTermNode();\n\n  localContext.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`, termNode);\n\n  const termNodeA = termNode,  ///\n        constructorTermNodeB = constructorTermNode,  ///\n        unified = termWithConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext);\n\n  if (unified) {\n    let verifiedAhead;\n\n    const type = constructor.getType(),\n          term = Term.fromTermNodeAndType(termNode, type);\n\n    terms.push(term);\n\n    verifiedAhead = verifyAhead();\n\n    terms.pop();\n\n    termUnifiedWithConstructor = verifiedAhead;  ///\n  }\n\n  if (termUnifiedWithConstructor) {\n    localContext.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`, termNode);\n  }\n\n  return termUnifiedWithConstructor;\n}\n\n"],"names":["termNodeQuery","nodeQuery","variableNodeQuery","verifyTerm","termNode","terms","localContext","verifyAhead","termVerified","termString","nodeAsString","trace","verifyTermFunctions","verifyTermAsVariable","unifyTermWithConstructors","unifyTermWithBracketedConstructor","some","verifyTermFunction","debug","Object","assign","shim","termVerifiedAsVariable","variableNode","variable","findVariableByVariableNode","verifiedAhead","type","getType","term","Term","fromTermNodeAndType","push","pop","termUnifiedWithConstructors","constructors","getConstructors","constructor","termUnifiedWithConstructor","unifyTermWithConstructor","termUnifiedWithBracketedConstructor","bracketedTerms","bracketedConstructor","bracketedTermNode","termVVerified","constructorString","getString","constructorTermNode","getTermNode","termNodeA","constructorTermNodeB","unified","termWithConstructorUnifier","unify"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/verify/termAsConstructor.js

@@ -25,7 +25,7 @@ function verifyTermAsConstructor(termNode, typeNode, fileContext) {
     if (typeVerified) {
         var firstType = (0, _array.first)(types);
         type = firstType; ///
-        termVerifiedAsConstructor = _termAsConstructor.default.verify(termNode, fileContext);
+        termVerifiedAsConstructor = _termAsConstructor.default.verifyTerm(termNode, fileContext);
     }
     if (termVerifiedAsConstructor) {
         var tokens = fileContext.getTokens(), constructor = _constructor.default.fromTermNodeTypeAndTokens(termNode, type, tokens);
@@ -55,4 +55,4 @@ function verifyType(typeNode, types, fileContext) {
     return typeVerified;
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/verify/termGivenType.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return verifyTermGivenType;
+    }
+});
+var _shim = /*#__PURE__*/ _interop_require_default(require("../shim"));
+var _array = require("../utilities/array");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function verifyTermGivenType(termNode, type, localContext) {
+    var termVerifiedGivenType = false;
+    if (type !== null) {
+        var verifyTerm = _shim.default.verifyTerm, terms = [], termVerified = verifyTerm(termNode, terms, localContext, function() {
+            var verifiedAhead = false;
+            var firstTerm = (0, _array.first)(terms), term = firstTerm, termType = term.getType(), termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
+            if (termTypeEqualToOrSubTypeOfType) {
+                verifiedAhead = true;
+            }
+            return verifiedAhead;
+        });
+        termVerifiedGivenType = termVerified; ///
+    }
+    return termVerifiedGivenType;
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "0.0.960",
+  "version": "0.0.962",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",

package/src/context/local.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import Variable from "../variable";
 import Equivalence from "../equivalence";
 
 import { last, reverse } from "../utilities/array";
@@ -235,26 +234,18 @@ class LocalContext {
 
     proofSteps = reverse(proofSteps); ///
 
-    const localContextA = this,  ///
-          localContextB = localContext, ///
-          statementNodeAB = statementNode, ///
-          statementStringB = localContextA.nodeAsString(statementNodeAB);
-
-    localContextB.trace(`Unifying the '${statementStringB}' statement...`, statementNodeAB);
-
     const equivalences = this.getEquivalences(),
+          localContextA = this,  ///
+          localContextB = localContext, ///
+          statementNodeB = statementNode, ///
           statementUnified = proofSteps.some((proofStep) => {
-            const statementUnified = proofStep.unifyStatement(statementNode, equivalences, localContextA, localContextB);
+            const statementUnified = proofStep.unifyStatement(statementNodeB, equivalences, localContextA, localContextB);
 
             if (statementUnified) {
               return true;
             }
           });
 
-    if (statementUnified) {
-      localContextB.debug(`...unified the '${statementStringB}' statement.`, statementNodeAB);
-    }
-
     return statementUnified;
   }
 

package/src/proofStep.js

@@ -17,22 +17,27 @@ export default class ProofStep {
     return this.statementNode;
   }
 
-  unifyStatement(statementNode, equivalences, localContextA, localContextB) {
+  unifyStatement(statementNodeB, equivalences, localContextA, localContextB) {
     let statementUnified = false;
 
     if (this.statementNode !== null) {
       let statementUnifiedWithStatement = false;
 
       if (!statementUnifiedWithStatement) {
-        const statementNodeA = statementNode, ///
-              statementNodeB = this.statementNode;  ///
+        const statementNodeA = this.statementNode;  ///
 
         statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
       }
 
       if (!statementUnifiedWithStatement) {
-        const statementNodeA = statementNode, ///
-              statementNodeB = this.statementNode;  ///
+        const statementNodeA = statementNodeB,  ///
+              localContext = localContextA; ///
+
+        statementNodeB = this.statementNode;  ///
+
+        localContextA = localContextB;  ///
+
+        localContextB = localContext; ///
 
         statementUnifiedWithStatement = unifyStatementWithStatement(statementNodeA, statementNodeB, equivalences, localContextA, localContextB);
       }

package/src/substitution/termForVariable.js

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

package/src/unifier/statementWithCombinator.js

@@ -12,12 +12,12 @@ const termNodeQuery = nodeQuery("/term!"),
       statementNodeQuery = nodeQuery("/statement!");
 
 class StatementWithCombinatorUnifier extends Unifier {
-  unify(statementNode, combinatorStatementNode, localContext) {
+  unify(statementNode, combinatorStatementNode, assignments, derived, localContext) {
     let statementUnifiedWithCombinator;
 
     const nonTerminalNodeA = statementNode, ///
           nonTerminalNodeB = combinatorStatementNode, ///
-          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext);
+          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, assignments, derived, localContext);
 
     statementUnifiedWithCombinator = nonTerminalNodeUnified; ///
 
@@ -28,10 +28,10 @@ class StatementWithCombinatorUnifier extends Unifier {
     {
       nodeQueryA: statementNodeQuery,
       nodeQueryB: metaTypeNodeQuery,
-      unify: (statementNodeA, metaTypeNodeB, localContext) => {
+      unify: (statementNodeA, metaTypeNodeB, assignments, derived, localContext) => {
         const metaTypeNode = metaTypeNodeB, ///
               statementNode = statementNodeA, ///
-              statementUnifiedWithMetaType = unifyStatementWithMetaType(statementNode, metaTypeNode, localContext);
+              statementUnifiedWithMetaType = unifyStatementWithMetaType(statementNode, metaTypeNode, assignments, derived, localContext);
 
         return statementUnifiedWithMetaType;
       }
@@ -39,7 +39,7 @@ class StatementWithCombinatorUnifier extends Unifier {
     {
       nodeQueryA: termNodeQuery,
       nodeQueryB: typeNodeQuery,
-      unify: (termNodeA, typeNodeB, localContext) => {
+      unify: (termNodeA, typeNodeB, assignments, derived, localContext) => {
         const termNode = termNodeA, ///
               typeNode = typeNodeB, ///
               termUnifiedWithType = unifyTermWithType(termNode, typeNode, localContext);

package/src/unify/statementAtainstStatement.js

@@ -1,30 +1,30 @@
 "use strict";
 
+import Substitutions from "../substitutions";
 import metaLevelUnifier from "../unifier/metaLevel";
 import TermForVariableSubstitution from "../substitution/termForVariable";
 
 import { push } from "../utilities/array";
 
 export default function unifyStatementWithStatement(statementNodeA, statementNodeB, substitution, substitutions, localContextA, localContextB) {
-  let statementUnifiedWithtatement = false;
+  let statementUnifiedWithStatement = false;
 
-  const termForVariableSubstitution = TermForVariableSubstitution.fromSubstitutionAndSubstitutions(substitution, substitutions),
-        transformed = termForVariableSubstitution.isTransformed(substitution);
+  const transformedSubstitutions = Substitutions.fromNothing(),
+        transformedSubstitution = substitution.transformed(substitutions);
 
-  let substitutionsA = []; ///
-
-  if (transformed) {
-    const substitutionA = termForVariableSubstitution;  ///
-
-    substitutionsA.push(substitutionA);
+  if (transformedSubstitution !== null) {
+    transformedSubstitutions.addSubstitution(transformedSubstitution, localContextA, localContextB);
   }
 
   const nodeA = statementNodeA,  ///
         nodeB = statementNodeB,  ///
-        unified = metaLevelUnifier.unify(nodeA, nodeB, substitutionsA, localContextA, localContextB);
+        unified = metaLevelUnifier.unify(nodeA, nodeB, transformedSubstitutions, localContextA, localContextB);
 
   if (unified) {
-    if (!transformed) {
+    if (transformedSubstitution === null) {
+
+      debugger
+
       const substitutionB = termForVariableSubstitution,  ///
             substitutionsB = [
               substitutionB
@@ -35,10 +35,10 @@ export default function unifyStatementWithStatement(statementNodeA, statementNod
       push(substitutions, substitutionsA);
     }
 
-    statementUnifiedWithtatement = true;
+    statementUnifiedWithStatement = true;
   }
 
-  return statementUnifiedWithtatement;
+  return statementUnifiedWithStatement;
 }
 
 function transformSubstitutions(substitutionsA, substitutionsB) {

package/src/unify/statementWithBracketedCombinator.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import bracketedCombinator from "../ocmbinator/bracketed";
+import statementWithCombinatorUnifier from "../unifier/statementWithCombinator";
+
+export default function unifyStatementWithBracketedCombinator(statementNode, assignments, derived, localContext) {
+  let statementUnifiedWithBracketedCombinator;
+
+  const statementString = localContext.nodeAsString(statementNode);
+
+  localContext.trace(`Unifying the '${statementString}' statement with the bracketed combinator...`, statementNode);
+
+  const bracketedCombinatorStatementNode = bracketedCombinator.getStatementNode();
+
+  statementUnifiedWithBracketedCombinator = statementWithCombinatorUnifier.unify(statementNode, bracketedCombinatorStatementNode, assignments, derived, localContext);
+
+  if (statementUnifiedWithBracketedCombinator) {
+    localContext.debug(`...unified the '${statementString}' statement with the bracketed combinator.`, statementNode);
+  }
+
+  return statementUnifiedWithBracketedCombinator;
+}

package/src/unify/statementWithCombinators.js

@@ -0,0 +1,38 @@
+"use strict";
+
+import statementWithCombinatorUnifier from "../unifier/statementWithCombinator";
+
+export default function unifyStatementWithCombinators(statementNode, assignments, derived, localContext) {
+  let statementUnifiedWithCombinators;
+
+  const combinators = localContext.getCombinators();
+
+  statementUnifiedWithCombinators = combinators.some((combinator) => {
+    const statementUnifiedWithCombinator = unifyStatementWithCombinator(statementNode, combinator, assignments, derived, localContext);
+
+    if (statementUnifiedWithCombinator) {
+      return true;
+    }
+  });
+
+  return statementUnifiedWithCombinators;
+}
+
+function unifyStatementWithCombinator(statementNode, combinator, assignments, derived, localContext) {
+  let statementUnifiedWithCombinator;
+
+  const statementString = localContext.nodeAsString(statementNode),
+        combinatorString = combinator.getString();
+
+  localContext.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`, statementNode);
+
+  const combinatorStatementNode = combinator.getStatementNode();
+
+  statementUnifiedWithCombinator = statementWithCombinatorUnifier.unify(statementNode, combinatorStatementNode, assignments, derived, localContext);
+
+  if (statementUnifiedWithCombinator) {
+    localContext.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`, statementNode);
+  }
+
+  return statementUnifiedWithCombinator;
+}