occam-verify-cli 0.0.972 → 0.0.975

package/src/resolve/substitutions.js

@@ -1,8 +1,7 @@
 "use strict";
 
 import LocalContext from "../context/local";
-import Substitutions from "../substitutions";
-import metaLevelUnifier from "../unifier/metaLevel";
+import resolveSubstitution from "../resolve/substitution";
 
 export default function resolveSubstitutions(substitutions, fileContextA, localContextB) {
   let substitutionsResolved = substitutions.areResolved();
@@ -13,7 +12,14 @@ export default function resolveSubstitutions(substitutions, fileContextA, localC
 
     substitutionsResolved = metavariableNodes.every((metavariableNode) => {
       const complexSubstitutions = substitutions.findComplexSubstitutionsByMetavariableNode(metavariableNode),
-            complexSubstitutionsResolved = resolveComplexSubstitutions(complexSubstitutions, substitutions, localContextA, localContextB);
+            complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
+              const substitution = complexSubstitution, ///
+                    complexSubstitutionResolved = resolveSubstitution(substitution, substitutions, localContextA, localContextB);
+
+              if (complexSubstitutionResolved) {
+                return true;
+              }
+            });
 
       if (complexSubstitutionsResolved) {
         return true;
@@ -23,112 +29,3 @@ export default function resolveSubstitutions(substitutions, fileContextA, localC
 
   return substitutionsResolved;
 }
-
-function resolveComplexSubstitution(complexSubstitution, substitutions, localContextA, localContextB) {
-  let complexSubstitutionResolved = false;
-
-  const metavariableNode = complexSubstitution.getMetavariableNode(),
-        simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNode);
-
-  if (simpleSubstitution !== null) {
-    const complexSubstitutionResolvedAgainstSimpleSubstitution = resolveComplexSubstitutionAgainstSimpleSubstitution(complexSubstitution, simpleSubstitution, substitutions, localContextA, localContextB);
-
-    complexSubstitutionResolved = complexSubstitutionResolvedAgainstSimpleSubstitution; ///
-  }
-
-  return complexSubstitutionResolved;
-}
-
-function resolveComplexSubstitutions(complexSubstitutions, substitutions, localContextA, localContextB) {
-  const complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
-    const complexSubstitutionResolved = resolveComplexSubstitution(complexSubstitution, substitutions, localContextA, localContextB);
-
-    if (complexSubstitutionResolved) {
-      return true;
-    }
-  });
-
-  return complexSubstitutionsResolved;
-}
-
-function resolveComplexSubstitutionAgainstSimpleSubstitution(complexSubstitution, simpleSubstitution, substitutions, localContextA, localContextB) {
-  let complexSubstitutionResolvedAgainstSimpleSubstitution = false;
-
-  const statementNode = complexSubstitution.getStatementNode(),
-        simpleSubstitutionString = simpleSubstitution.asString(localContextA, localContextB),
-        complexSubstitutionString = complexSubstitution.asString(localContextA, localContextB);
-
-  localContextB.trace(`Resolving the complex ${complexSubstitutionString} substitution against the simple ${simpleSubstitutionString} substitution...`, statementNode);
-
-  const transformedSubstitution = transformedSubstitutionFromComplexSubstitutionSimpleSubstitutionAndSubstitutions(complexSubstitution, simpleSubstitution, substitutions, localContextA, localContextB);
-
-  if (transformedSubstitution !== null) {
-    const variableNode = transformedSubstitution.getVariableNode(),
-          substitution = substitutions.findSubstitutionByVariableNode(variableNode);
-
-    if (substitution === null) {
-      simpleSubstitution = transformedSubstitution; ///
-
-      substitutions.addSubstitution(simpleSubstitution, localContextA, localContextB);
-
-      substitutions.removeSubstitution(complexSubstitution, localContextA, localContextB);
-
-      complexSubstitutionResolvedAgainstSimpleSubstitution = true;
-    } else {
-      const termNode = transformedSubstitution.getTermNode(),
-            termNodeMatches = substitution.matchTermNode(termNode);
-
-      if (termNodeMatches) {
-        substitutions.removeSubstitution(complexSubstitution, localContextA, localContextB);
-
-        complexSubstitutionResolvedAgainstSimpleSubstitution = true;
-      }
-    }
-  }
-
-  if (complexSubstitutionResolvedAgainstSimpleSubstitution) {
-    localContextB.debug(`...resolved the complex ${complexSubstitutionString} substitution against the simple ${simpleSubstitutionString} substitution.`, statementNode);
-  }
-
-  return complexSubstitutionResolvedAgainstSimpleSubstitution;
-}
-
-function unifyComplexSubstitutionStatementWithSimpleSubstitutionStatement(complexSubstitutionStatementNode, simpleSubstitutionStatementNode, substitutions, localContextA, localContextB) {
-  let complexSubstitutionStatementWithSimpleSubstitutionStatement;
-
-  const nodeA = complexSubstitutionStatementNode,  ///
-        nodeB = simpleSubstitutionStatementNode;  ///
-
-  localContextA = localContextB;  ///
-
-  const unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
-
-  complexSubstitutionStatementWithSimpleSubstitutionStatement = unified;  ///
-
-  return complexSubstitutionStatementWithSimpleSubstitutionStatement;
-}
-
-function transformedSubstitutionFromComplexSubstitutionSimpleSubstitutionAndSubstitutions(complexSubstitution, simpleSubstitution, substitutions, localContextA, localContextB) {
-  let transformedSubstitution;
-
-  const substitution = complexSubstitution.getSubstitution();
-
-  transformedSubstitution = substitution.transformed(substitutions);
-
-  if (transformedSubstitution !== null) {
-    const simpleSubstitutionStatementNode = simpleSubstitution.getStatementNode(),
-          complexSubstitutionStatementNode = complexSubstitution.getStatementNode();
-
-    substitutions = Substitutions.fromNothing();  ///
-
-    const complexSubstitutionStatementWithSimpleSubstitutionStatement = unifyComplexSubstitutionStatementWithSimpleSubstitutionStatement(complexSubstitutionStatementNode, simpleSubstitutionStatementNode, substitutions, localContextA, localContextB);
-
-    if (complexSubstitutionStatementWithSimpleSubstitutionStatement) {
-      const substitution = transformedSubstitution; ///
-
-      transformedSubstitution = substitution.transformed(substitutions);
-    }
-  }
-
-  return transformedSubstitution;
-}

package/src/rule.js

@@ -29,6 +29,16 @@ export default class Rule {
     return this.fileContext;
   }
 
+  getLabelMetavariableNodes() {
+    const labelMetavariableNodes = this.labels.map((label) => {
+      const labelMetavariableNode = label.getMetavariableNode();
+
+      return labelMetavariableNode;
+    });
+
+    return labelMetavariableNodes;
+  }
+
   unifyStatement(statementNode, localContext) {
     let statementUnified = false;
 

package/src/substitution/statementForMetavariable.js

@@ -163,7 +163,7 @@ function transformStatementNode(statementNode, substitutions) {
 
   if (metavariableNode !== null) {
     substitutions.someSubstitution((substitution) => {
-      const substitutionMatchesVariableNode = substitution.matchVariableNode(metavariableNode);
+      const substitutionMatchesVariableNode = substitution.matchMetavariableNode(metavariableNode);
 
       if (substitutionMatchesVariableNode) {
         const statementNode = substitution.getStatementNode();

package/src/substitution.js

@@ -21,6 +21,12 @@ export default class Substitution {
     return resolved;
   }
 
+  getVariableNode() {
+    const variableNode = null;
+
+    return variableNode;
+  }
+
   getMetavariableNode() {
     const metavariableNode = null;
 

package/src/substitutions.js

@@ -87,9 +87,9 @@ export default class Substitutions {
 
   findSubstitutionByVariableNode(variableNode) {
     const substitution = this.findSubstitution((substitution) => {
-      const substitutionMatchesVariableNode = substitution.matchVariableNode(variableNode);
+      const variableNodeMatches = substitution.matchVariableNode(variableNode);
 
-      if (substitutionMatchesVariableNode) {
+      if (variableNodeMatches) {
         return true;
       }
     });
@@ -97,11 +97,22 @@ export default class Substitutions {
     return substitution;
   }
 
+  findSubstitutionByMetavariableNode(metavariableNode) {
+    const substitution = this.findSubstitution((substitution) => {
+      const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
+
+      if (metavariableNodeMatches) {
+        return true;
+      }
+    });
+
+    return substitution;
+  }
   findSubstitutionsByMetavariableNode(metavariableNode) {
     const substitutions = this.findSubstitutions((substitution) => {
-      const substitutionMatchesMetavariableNode = substitution.matchMetavariableNode(metavariableNode);
+      const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
 
-      if (substitutionMatchesMetavariableNode) {
+      if (metavariableNodeMatches) {
         return true;
       }
     });
@@ -139,9 +150,9 @@ export default class Substitutions {
 
   findSubstitutionsByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
     const substitutions = this.findSubstitutions((substitution) => {
-      const substitutionMatchesMetavariableNodeAndSubstitutionNode = substitution.matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
+      const metavariableNodeAndSubstitutionNodeMatch = substitution.matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
 
-      if (substitutionMatchesMetavariableNodeAndSubstitutionNode) {
+      if (metavariableNodeAndSubstitutionNodeMatch) {
         return true;
       }
     });

package/src/topLevelAssertion.js

@@ -34,6 +34,16 @@ export default class TopLevelAssertion {
     return this.fileContext;
   }
 
+  getLabelMetavariableNodes() {
+    const labelMetavariableNodes = this.labels.map((label) => {
+      const labelMetavariableNode = label.getMetavariableNode();
+
+      return labelMetavariableNode;
+    });
+
+    return labelMetavariableNodes;
+  }
+
   unifyStatement(statementNode, localContext) {
     let statementUnified = false;
 

package/src/type.js

@@ -105,10 +105,10 @@ export default class Type {
 
   matchTypeNode(typeNode) {
     const typeName = typeNameFromTypeNode(typeNode),
-          matchesTypeName = this.matchTypeName(typeName),
-          matchesTypeNode = matchesTypeName;  ///
+          typeNameMatches = this.matchTypeName(typeName),
+          typeNodeMatches = typeNameMatches;  ///
 
-    return matchesTypeNode;
+    return typeNodeMatches;
   }
 
   asString(tokens, noSuperType = false) {

package/src/unifier/metavariable.js

@@ -0,0 +1,46 @@
+"use strict";
+
+import shim from "../shim";
+import Unifier from "../unifier";
+
+import { nodeQuery } from "../utilities/query";
+import unifyTermWithType from "../unify/termWithType";
+
+const typeNodeQuery = nodeQuery("/type!"),
+      termNodeQuery = nodeQuery("/term!");
+
+class MetavariableUnifier extends Unifier {
+  unify(metavariableNodeA, metavariableNodeB, localContext) {
+    let unified;
+
+    const nonTerminalNodeA = metavariableNodeA, ///
+          nonTerminalNodeB = metavariableNodeB, ///
+          nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext);
+
+    unified = nonTerminalNodeUnified; ///
+
+    return unified;
+  }
+
+  static maps = [
+    {
+      nodeQueryA: termNodeQuery,
+      nodeQueryB: typeNodeQuery,
+      unify: (termNodeA, typeNodeB, localContext) => {
+        const termNode = termNodeA, ///
+              typeNode = typeNodeB, ///
+              termUnifiedWithType = unifyTermWithType(termNode, typeNode, localContext);
+
+        return termUnifiedWithType;
+      }
+    }
+  ];
+}
+
+const metavariableUnifier = new MetavariableUnifier();
+
+Object.assign(shim, {
+  metavariableUnifier
+});
+
+export default metavariableUnifier;

package/src/unify/complexSubstitutionStatementWithSimpleSubstitutionStatement.js

@@ -0,0 +1,18 @@
+"use strict";
+
+import metaLevelUnifier from "../unifier/metaLevel";
+
+export default function unifyComplexSubstitutionStatementWithSimpleSubstitutionStatement(complexSubstitutionStatementNode, simpleSubstitutionStatementNode, substitutions, localContextA, localContextB) {
+  let complexSubstitutionStatementWithSimpleSubstitutionStatement;
+
+  const nodeA = complexSubstitutionStatementNode,  ///
+        nodeB = simpleSubstitutionStatementNode;  ///
+
+  localContextA = localContextB;  ///
+
+  const unified = metaLevelUnifier.unify(nodeA, nodeB, substitutions, localContextA, localContextB);
+
+  complexSubstitutionStatementWithSimpleSubstitutionStatement = unified;  ///
+
+  return complexSubstitutionStatementWithSimpleSubstitutionStatement;
+}

package/src/unify/{statement/qualified.js → qualifiedStatement.js}

@@ -1,6 +1,10 @@
 "use strict";
 
-import { nodeQuery } from "../../utilities/query";
+import metavariableUnifier from "../unifier/metavariable";
+import StatementForMetavariableSubstitution from "../substitution/statementForMetavariable";
+
+import { nodeQuery } from "../utilities/query";
+import { metavariableNameFromMetavariableNode } from "../utilities/name";
 
 const statementNodeQuery = nodeQuery("/qualifiedStatement/statement!"),
       metavariableNodeQuery = nodeQuery("/qualifiedStatement/reference/metavariable!");
@@ -42,17 +46,18 @@ function unifyQualifiedStatementAWithRule(qualifiedStatementNode, substitutions,
 
   if (rule !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+          labelMetavariableNodes = rule.getLabelMetavariableNodes(),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
+          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' rule...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' rule...`, qualifiedStatementNode);
 
     const statementUnified = rule.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithRule = statementUnified;  ///
 
     if (qualifiedStatementUnifiedWithRule) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' rule.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' rule.`, qualifiedStatementNode);
     }
   }
 
@@ -67,17 +72,18 @@ function unifyQualifiedStatementAWithAxiom(qualifiedStatementNode, substitutions
 
   if (axiom !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+          labelMetavariableNodes = axiom.getLabelMetavariableNodes(),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
+          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' axiom...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' axiom...`, qualifiedStatementNode);
 
     const statementUnified = axiom.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithAxiom = statementUnified; ///
 
     if (qualifiedStatementUnifiedWithAxiom) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' axiom.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' axiom.`, qualifiedStatementNode);
     }
   }
 
@@ -92,17 +98,18 @@ function unifyQualifiedStatementAWithLemma(qualifiedStatementNode, substitutions
 
   if (lemma !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+          labelMetavariableNodes = lemma.getLabelMetavariableNodes(),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
+          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' lemma...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' lemma...`, qualifiedStatementNode);
 
     const statementUnified = lemma.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithLemma = statementUnified; ///
 
     if (qualifiedStatementUnifiedWithLemma) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' lemma.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' lemma.`, qualifiedStatementNode);
     }
   }
 
@@ -117,17 +124,18 @@ function unifyQualifiedStatementAWithTheorem(qualifiedStatementNode, substitutio
 
   if (theorem !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+          labelMetavariableNodes = theorem.getLabelMetavariableNodes(),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
+          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' theorem...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' theorem...`, qualifiedStatementNode);
 
     const statementUnified = theorem.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithTheorem = statementUnified; ///
 
     if (qualifiedStatementUnifiedWithTheorem) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' theorem.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' theorem.`, qualifiedStatementNode);
     }
   }
 
@@ -142,17 +150,18 @@ function unifyQualifiedStatementAWithConjecture(qualifiedStatementNode, substitu
 
   if (conjecture !== null) {
     const statementNode = statementNodeQuery(qualifiedStatementNode),
-          metavariableString = localContext.nodeAsString(metavariableNode),
-          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+          labelMetavariableNodes = conjecture.getLabelMetavariableNodes(),
+          qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode),
+          labelMetavariableNodesString = localContext.nodesAsString(labelMetavariableNodes);
 
-    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' conjecture...`, qualifiedStatementNode);
+    localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' conjecture...`, qualifiedStatementNode);
 
     const statementUnified = conjecture.unifyStatement(statementNode, localContext);
 
     qualifiedStatementUnifiedWithConjecture = statementUnified; ///
 
     if (qualifiedStatementUnifiedWithConjecture) {
-      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' conjecture.`, qualifiedStatementNode);
+      localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${labelMetavariableNodesString}' conjecture.`, qualifiedStatementNode);
     }
   }
 
@@ -162,21 +171,42 @@ function unifyQualifiedStatementAWithConjecture(qualifiedStatementNode, substitu
 function unifyQualifiedStatementAWithReference(qualifiedStatementNode, substitutions, localContext) {
   let qualifiedStatementUnifiedWithReference = false;
 
-  const metavariableNode = metavariableNodeQuery(qualifiedStatementNode),
-        metavariableString = localContext.nodeAsString(metavariableNode),
-        metavariablePresent = localContext.isMetavariablePresentByMetavariableNode(metavariableNode),
-        qualifiedStatementString = localContext.nodeAsString(qualifiedStatementNode);
+  let metavariableNode = metavariableNodeQuery(qualifiedStatementNode);
 
-  localContext.trace(`Unifying the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' reference...`, qualifiedStatementNode);
+  const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+        metavariable = localContext.findMetavariableByMetavariableName(metavariableName);
 
-  if (metavariablePresent) {
+  if (metavariable !== null) {
+    const statementNode = statementNodeQuery(qualifiedStatementNode),
+          statementString = localContext.nodeAsString(statementNode),
+          metavariableString = localContext.nodeAsString(metavariableNode);
 
-    debugger
+    localContext.trace(`Unifying the '${statementString}' qualified statement with the '${metavariableString}' reference...`, qualifiedStatementNode);
 
-  }
+    const metavariableNodeA = metavariableNode; ///
+
+    metavariableNode = metavariable.getNode();
+
+    const metavariableNodeB = metavariableNode; ///
+
+    const unified = metavariableUnifier.unify(metavariableNodeA, metavariableNodeB, localContext);
 
-  if (qualifiedStatementUnifiedWithReference) {
-    localContext.debug(`...unified the '${qualifiedStatementString}' qualified statement with the '${metavariableString}' reference.`, qualifiedStatementNode);
+    if (unified) {
+      metavariableNode = metavariableNodeA; ///
+
+      const statementForMetavariableSubstitution = StatementForMetavariableSubstitution.fromStatementNodeAndMetavariableNode(statementNode, metavariableNode),
+            substitution = statementForMetavariableSubstitution, ///
+            localContextA = localContext, ///
+            localContextB = localContext; ///
+
+      substitutions.addSubstitution(substitution, localContextA, localContextB);
+
+      qualifiedStatementUnifiedWithReference = true;
+    }
+
+    if (qualifiedStatementUnifiedWithReference) {
+      localContext.debug(`...unified the '${statementString}' qualified statement with the '${metavariableString}' reference.`, qualifiedStatementNode);
+    }
   }
 
   return qualifiedStatementUnifiedWithReference;

package/src/unify/statementWithCombinator.js

@@ -0,0 +1,22 @@
+"use strict";
+
+import statementWithCombinatorUnifier from "../unifier/statementWithCombinator";
+
+export default function unifyStatementWithCombinator(statementNode, combinator, assignments, stated, 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, stated, localContext);
+
+  if (statementUnifiedWithCombinator) {
+    localContext.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`, statementNode);
+  }
+
+  return statementUnifiedWithCombinator;
+}

package/src/unify/statementWithCombinators.js

@@ -1,12 +1,16 @@
 "use strict";
 
-import statementWithCombinatorUnifier from "../unifier/statementWithCombinator";
+import unifyStatementWithCombinator from "../unify/statementWithCombinator";
 
 export default function unifyStatementWithCombinators(statementNode, assignments, stated, localContext) {
   let statementUnifiedWithCombinators;
 
   const combinators = localContext.getCombinators();
 
+  assignments = null; ///
+
+  stated = true;  ///
+
   statementUnifiedWithCombinators = combinators.some((combinator) => {
     const statementUnifiedWithCombinator = unifyStatementWithCombinator(statementNode, combinator, assignments, stated, localContext);
 
@@ -17,22 +21,3 @@ export default function unifyStatementWithCombinators(statementNode, assignments
 
   return statementUnifiedWithCombinators;
 }
-
-function unifyStatementWithCombinator(statementNode, combinator, assignments, stated, 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, stated, localContext);
-
-  if (statementUnifiedWithCombinator) {
-    localContext.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`, statementNode);
-  }
-
-  return statementUnifiedWithCombinator;
-}

package/src/unify/termWithBracketedConstructor.js

@@ -2,9 +2,9 @@
 
 import shim from "../shim";
 import bracketedConstructor from "../constructor/bracketed";
+import unifyTermWithConstructor from "../unify/termWithConstructor";
 
 import { nodeQuery } from "../utilities/query";
-import { unifyTermWithConstructor } from "../unify/termWithConstructors";
 
 const termNodeQuery = nodeQuery("/term/argument/term");
 

package/src/unify/termWithConstructor.js

@@ -0,0 +1,39 @@
+"use strict";
+
+import Term from "../term";
+import termWithConstructorUnifier from "../unifier/termWithConstructor";
+
+export default 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 with the '${constructorString}' constructor...`, termNode);
+
+  const termNodeA = termNode,  ///
+        constructorTermNodeB = constructorTermNode,  ///
+        unified = termWithConstructorUnifier.unify(termNodeA, constructorTermNodeB, localContext);
+
+  if (unified) {
+    let verifiedAhead;
+
+    const type = constructor.getType(),
+          term = Term.fromTermNodeAndType(termNode, type);
+
+    terms.push(term);
+
+    verifiedAhead = verifyAhead();
+
+    terms.pop();
+
+    termUnifiedWithConstructor = verifiedAhead;  ///
+  }
+
+  if (termUnifiedWithConstructor) {
+    localContext.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`, termNode);
+  }
+
+  return termUnifiedWithConstructor;
+}