occam-verify-cli 1.0.747 → 1.0.757

package/src/element/assertion/contained.js

@@ -3,7 +3,7 @@
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { literally } from "../../utilities/context";
+import { instantiate } from "../../utilities/context";
 import { instantiateContainedAssertion } from "../../process/instantiate";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions, statementFromStatementAndSubstitutions } from "../../utilities/substitutions";
 import { termFromContainedAssertionNode, frameFromContainedAssertionNode, negatedFromContainedAssertionNode, statementFromContainedAssertionNode } from "../../utilities/element";
@@ -97,14 +97,14 @@ export default define(class ContainedAssertion extends Assertion {
       const termString = this.term.getString(),
             containedAssertionString = this.getString(); ///
 
-      context.trace(`Validating the '${containedAssertionString}' contained assertino's '${termString}' term...`);
+      context.trace(`Validating the '${containedAssertionString}' contained assertion's '${termString}' term...`);
 
       const termSingular = this.term.isSingular();
 
       if (!termSingular) {
         context.debug(`The '${termString}' term is not singular.`);
       } else {
-        const term = this.term.validate(context, () => {
+        const term = this.term.validate(context, (term) => {
           const validatesForwards = true;
 
           return validatesForwards;
@@ -117,7 +117,7 @@ export default define(class ContainedAssertion extends Assertion {
         }
 
         if (termValidates) {
-          context.debug(`...validated the '${containedAssertionString}' contained assertino's '${termString}' term.`);
+          context.debug(`...validated the '${containedAssertionString}' contained assertion's '${termString}' term.`);
         }
       }
     }
@@ -132,7 +132,7 @@ export default define(class ContainedAssertion extends Assertion {
       const frameString = this.frame.getString(),
             containedAssertionString = this.getString(); ///
 
-      context.trace(`Validating the '${containedAssertionString}' contained assertino's '${frameString}' frame...`);
+      context.trace(`Validating the '${containedAssertionString}' contained assertion's '${frameString}' frame...`);
 
       const frameSingular = this.frame.isSingular();
 
@@ -151,7 +151,7 @@ export default define(class ContainedAssertion extends Assertion {
       }
 
       if (frameValidates) {
-        context.debug(`...validated the '${containedAssertionString}' contained assertino's '${frameString}' frame.`);
+        context.debug(`...validated the '${containedAssertionString}' contained assertion's '${frameString}' frame.`);
       }
     }
 
@@ -206,7 +206,7 @@ export default define(class ContainedAssertion extends Assertion {
     context.trace(`Validating the '${containedAssertionString}' derived contained assertion...`);
 
     const generalCotnext = null,
-          specificContext = context; ///
+          specificContext = context;  ///
 
     validatesWhenDerived = validateWhenDerived(this.term, this.frame, this.statement, this.negated, generalCotnext, specificContext);
 
@@ -247,7 +247,7 @@ export default define(class ContainedAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      literally((context) => {
+      instantiate((context) => {
         const { string } = json,
               containedAssertionNode = instantiateContainedAssertion(string, context),
               node = containedAssertionNode,  ///

package/src/element/assertion/defined.js

@@ -3,7 +3,7 @@
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { literally } from "../../utilities/context";
+import { instantiate } from "../../utilities/context";
 import { instantiateDefinedAssertion } from "../../process/instantiate";
 import { termFromTermAndSubstitutions, frameFromFrameAndSubstitutions } from "../../utilities/substitutions";
 import { termFromJDefinedAssertionNode, frameFromJDefinedAssertionNode, negatedFromJDefinedAssertionNode } from "../../utilities/element";
@@ -91,14 +91,14 @@ export default define(class DefinedAssertion extends Assertion {
       const termString = this.term.getString(), ///
             definedAssertionString = this.getString();  ///
 
-      context.trace(`Validating the '${definedAssertionString}' defined assertino's '${termString}' term...`);
+      context.trace(`Validating the '${definedAssertionString}' defined assertion's '${termString}' term...`);
 
       const termSingular = this.term.isSingular();
 
       if (!termSingular) {
         context.debug(`The '${termString}' term is not singular.`);
       } else {
-        const term = this.term.validate(context, () => {
+        const term = this.term.validate(context, (term) => {
                 const validatesForwards = true;
 
                 return validatesForwards;
@@ -111,7 +111,7 @@ export default define(class DefinedAssertion extends Assertion {
         }
 
         if (termValidates) {
-          context.debug(`...validates the'${definedAssertionString}' defined assertino's '${termString}' term.`);
+          context.debug(`...validates the'${definedAssertionString}' defined assertion's '${termString}' term.`);
         }
       }
     }
@@ -126,7 +126,7 @@ export default define(class DefinedAssertion extends Assertion {
       const frameString = this.frame.getString(), ///
             definedAssertionString = this.getString();  ///
 
-      context.trace(`Validating the'${definedAssertionString}' defined assertino's '${frameString}' frame...`);
+      context.trace(`Validating the'${definedAssertionString}' defined assertion's '${frameString}' frame...`);
 
       const frameSingular = this.frame.isSingular();
 
@@ -144,7 +144,7 @@ export default define(class DefinedAssertion extends Assertion {
         }
 
         if (frameValidates) {
-          context.debug(`...validates the'${definedAssertionString}' defined assertino's '${frameString}' frame.`);
+          context.debug(`...validates the'${definedAssertionString}' defined assertion's '${frameString}' frame.`);
         }
       }
     }
@@ -216,7 +216,7 @@ export default define(class DefinedAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      literally((context) => {
+      instantiate((context) => {
         const { string } = json,
               definedAssertionNode = instantiateDefinedAssertion(string, context),
               node = definedAssertionNode,  ///

package/src/element/assertion/property.js

@@ -3,7 +3,7 @@
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { literally } from "../../utilities/context";
+import { instantiate } from "../../utilities/context";
 import { instantiatePropertyAssertion } from "../../process/instantiate";
 import { variableAssignmentFromPrepertyAssertion } from "../../process/assign";
 import { termFromPropertyAssertionNode, propertyRelationFromPropertyAssertionNode } from "../../utilities/element";
@@ -117,13 +117,13 @@ export default define(class PropertyAssertion extends Assertion {
 
     context.trace(`Validating the '${termString}' term...`);
 
-    const term = this.term.validate(context, () => {
+    const term = this.term.validate(context, (term) => {
       const validatesForwards = true;
 
       return validatesForwards;
     });
 
-    if ((term !== null)) {
+    if (term !== null) {
       this.term = term;
 
       termValidates = true;
@@ -208,7 +208,7 @@ export default define(class PropertyAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      literally((context) => {
+      instantiate((context) => {
         const { string } = json,
               propertyAssertionNode = instantiatePropertyAssertion(string, context),
               node = propertyAssertionNode,  ///

package/src/element/assertion/satisfies.js

@@ -3,7 +3,7 @@
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { literally } from "../../utilities/context";
+import { instantiate } from "../../utilities/context";
 import { instantiateSatisfiesAssertion } from "../../process/instantiate";
 import { signatureFromJSatisfiesAssertionNode, referenceFromJSatisfiesAssertionNode } from "../../utilities/element";
 
@@ -165,7 +165,7 @@ export default define(class SatisfiesAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      literally((context) => {const { string } = json,
+      instantiate((context) => {const { string } = json,
               definedAssertionNode = instantiateSatisfiesAssertion(string, context),
               node = definedAssertionNode,  ///
               signature = signatureFromJSatisfiesAssertionNode(definedAssertionNode, context),

package/src/element/assertion/subproof.js

@@ -5,11 +5,11 @@ import { arrayUtilities } from "necessary";
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { literally } from "../../utilities/context";
-import { unifyStatement } from "../../process/unify";
+import { reconcile } from "../../utilities/context";
+import { instantiate } from "../../utilities/context";
 import { instantiateSubproofAssertion } from "../../process/instantiate";
 
-const { match } = arrayUtilities;
+const { last, front, backwardsEvery } = arrayUtilities;
 
 export default define(class SubproofAssertion extends Assertion {
   constructor(context, string, node, statements) {
@@ -22,6 +22,26 @@ export default define(class SubproofAssertion extends Assertion {
     return this.statements;
   }
 
+  getLastStatement() {
+    const lastStatement = last(this.statements);
+
+    return lastStatement;
+  }
+
+  getSupposedStatement(index) {
+    const statement = this.statements[index],
+          supposedStatement = statement;  ///
+
+    return supposedStatement;
+  }
+
+  getSupposedStatements() {
+    const frontStatements = front(this.statements),
+          supposedStatements = frontStatements;  ///
+
+    return supposedStatements;
+  }
+
   getSubproofAssertionNode() {
     const node = this.getNode(),
           subproofAssertionNode = node; ///
@@ -86,33 +106,186 @@ export default define(class SubproofAssertion extends Assertion {
   }
 
   unifySubproof(subproof, generalContext, specificContext) {
-    let subproofUnifies;
+    let subproofUnifies = false;
 
-    const subproofString = subproof.getString(),
-          subproofAssertionString = this.getString();  ///
+    const context = specificContext,  ///
+          subproofString = subproof.getString(),
+          subproofAssertionString = this.getString(); ///
 
-    specificContext.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
+    context.trace(`Unifying the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion...`);
 
-    const subproofStatements = subproof.getStatements(),
-          subproofAssertionStatements = this.statements;  ///
+    const lastStep = subproof.getLastStep(),
+          lastStepUnifies = this.unifyLastStep(lastStep, generalContext, specificContext);
 
-    subproofUnifies = match(subproofAssertionStatements, subproofStatements, (subproofAssertionStatement, subproofStatement) => {
-      const generalStatement = subproofAssertionStatement,  ///
-            specificStatement = subproofStatement,  ///
-            statementUnifies = unifyStatement(generalStatement, specificStatement, generalContext, specificContext);
+    if (lastStepUnifies) {
+      const suppositions = subproof.getSuppositions(),
+            suppositionsUnify = this.unifySuppositions(suppositions, generalContext, specificContext);
 
-      if (statementUnifies) {
-        return true;
+      if (suppositionsUnify) {
+        subproofUnifies = true;
       }
-    });
+    }
 
     if (subproofUnifies) {
-      specificContext.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
+      context.debug(`...unified the '${subproofString}' subproof with the '${subproofAssertionString}' subproof assertion.`);
     }
 
     return subproofUnifies;
   }
 
+  unifyLastStep(lastStep, generalContext, specificContext) {
+    let lastStepUnifies = false;
+
+    const lastStatement = this.getLastStatement(),
+          lastStepString = lastStep.getString(),
+          lastStepStatement = lastStep.getStatement(),
+          lastStatementString = lastStatement.getString(),
+          subproofAssertionString = this.getString(), ///
+          lastStepStatementString = lastStepStatement.getString();
+
+    let context;
+
+    context = specificContext;  ///
+
+    context.trace(`Unifying the '${lastStepString}' last step's '${lastStepStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${lastStatementString}' last statement...`)
+
+    context = lastStep.getContext();
+
+    specificContext = context;  ///
+
+    reconcile((specificContext) => {
+      const lastStepStatementUnifies = lastStatement.unifyStatement(lastStepStatement, generalContext, specificContext);
+
+      if (lastStepStatementUnifies) {
+        lastStepUnifies = true;
+      }
+    }, specificContext);
+
+    if (lastStepUnifies) {
+      context.debug(`...unified the '${lastStepString}' last step's '${lastStepStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${lastStatementString}' last statement.`)
+    }
+
+    return lastStepUnifies;
+  }
+
+  unifyDeduction(deduction, generalContext, specificContext) {
+    let deductionUnifies = false;
+
+    const lastStatement = this.getLastStatement(),
+          deductionString = deduction.getString(),
+          deductionStatement = deduction.getStatement(),
+          lastStatementString = lastStatement.getString(),
+          subproofAssertionString = this.getString(), ///
+          deductionStatementString = deductionStatement.getString();
+
+    let context;
+
+    context = specificContext;  ///
+
+    context.trace(`Unifying the '${deductionString}' deduction's '${deductionStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${lastStatementString}' last statement...`)
+
+    context = deduction.getContext();
+
+    specificContext = context;  ///
+
+    reconcile((specificContext) => {
+      const deductionStatementUnifies = lastStatement.unifyStatement(deductionStatement, generalContext, specificContext);
+
+      if (deductionStatementUnifies) {
+        deductionUnifies = true;
+      }
+    }, specificContext);
+
+    if (deductionUnifies) {
+      context.debug(`...unified the '${deductionString}' deduction's '${deductionStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${lastStatementString}' last statement.`)
+    }
+
+    return deductionUnifies;
+  }
+
+  unifySupposition(supposition, index, generalContext, specificContext) {
+    let suppositionUnifies = false;
+
+    const supposedStatement = this.getSupposedStatement(index),
+          suppositionString = supposition.getString(),
+          suppositionStatement = supposition.getStatement(),
+          subproofAssertionString = this.getString(), ///
+          supposedStatementString = supposedStatement.getString(),
+          suppositionStatementString = suppositionStatement.getString();  ///
+
+    let context;
+
+    context = specificContext;  ///
+
+    context.trace(`Unifying the '${suppositionString}' supposition's '${suppositionStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${supposedStatementString}' supposed statement...`)
+
+    context = supposition.getContext();
+
+    specificContext = context;  ///
+
+    reconcile((specificContext) => {
+      const suppositionStatementUnifies = supposedStatement.unifyStatement(suppositionStatement, generalContext, specificContext);
+
+      if (suppositionStatementUnifies) {
+        suppositionUnifies = true;
+      }
+    }, specificContext);
+
+    if (suppositionUnifies) {
+      context.debug(`...unified the '${suppositionString}' supposition's '${suppositionStatementString}' statement with the '${subproofAssertionString}' subproof assertion's '${supposedStatementString}' supposed statement.`)
+    }
+
+    return suppositionUnifies;
+  }
+
+  unifySuppositions(suppositions, generalContext, specificContext) {
+    let suppositionsUnify = false;
+
+    const supposedStatements = this.getSupposedStatements(),
+          suppositionsLength = suppositions.length,
+          supposedStatementsLength = supposedStatements.length;
+
+    if (suppositionsLength === supposedStatementsLength) {
+      suppositionsUnify = backwardsEvery(suppositions, (supposition, index) => {
+        const suppositionUnifies = this.unifySupposition(supposition, index, generalContext, specificContext);
+
+        if (suppositionUnifies) {
+          return true;
+        }
+      });
+    }
+
+    return suppositionsUnify;
+  }
+
+  unifyTopLevelMetaAssertion(topLevelMetaAssertion, generalContext, specificContext) {
+    let topLevelMetaAssertionUnifies = false;
+
+    const context = specificContext,  ///
+          subproofAssertionString = this.getString(),  ///
+          topLevelMetaAssertionString = topLevelMetaAssertion.getString();
+
+    context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${subproofAssertionString}' subproof assertion...`);
+
+    const deduction = topLevelMetaAssertion.getDeduction(),
+          deductionUnifies = this.unifyDeduction(deduction, generalContext, specificContext);
+
+    if (deductionUnifies) {
+      const suppositions = topLevelMetaAssertion.getSuppositions(),
+            suppositionsUnify = this.unifySuppositions(suppositions, generalContext, specificContext);
+
+      if (suppositionsUnify) {
+        topLevelMetaAssertionUnifies = true;
+      }
+    }
+
+    if (topLevelMetaAssertionUnifies) {
+      context.debug(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${subproofAssertionString}' subproof assertion.`);
+    }
+
+    return topLevelMetaAssertionUnifies;
+  }
+
   static name = "SubproofAssertion";
 
   static fromJSON(json, context) {
@@ -121,7 +294,7 @@ export default define(class SubproofAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      literally((context) => {
+      instantiate((context) => {
         const { string } = json,
               subproofAssertionNode = instantiateSubproofAssertion(string, context),
               statements = statementsFromSubproofAssertionNode(subproofAssertionNode, context),

package/src/element/assertion/type.js

@@ -3,7 +3,7 @@
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
-import { literally } from "../../utilities/context";
+import { instantiate } from "../../utilities/context";
 import { instantiateTypeAssertion } from "../../process/instantiate";
 import { termFromTypeAssertionNode } from "../../utilities/element";
 import { typeFromJSON, typeToTypeJSON } from "../../utilities/json";
@@ -114,10 +114,10 @@ export default define(class TypeAssertion extends Assertion {
 
     context.trace(`Validating the '${typeAssertionString}' stated type assertion...`);
 
-    const term = this.term.validate(context, () => {
-      let validatesForwards;
+    const term = this.term.validate(context, (term) => {
+      let validatesForwards = false;
 
-      const termType = this.term.getType(),
+      const termType = term.getType(),
             typeEqualToOrSubTypeOfTermType = this.type.isEqualToOrSubTypeOf(termType);
 
       if (typeEqualToOrSubTypeOfTermType) {
@@ -147,10 +147,10 @@ export default define(class TypeAssertion extends Assertion {
 
     context.trace(`Validating the '${typeAssertionString}' derived type assertion...`);
 
-    const term = this.term.validate(context, () => {
+    const term = this.term.validate(context, (term) => {
       let validatesForwards = false;
 
-      const termType = this.term.getType(),
+      const termType = term.getType(),
             termTypeProvisional = termType.isProvisional();
 
       if (!termTypeProvisional) {
@@ -214,7 +214,7 @@ export default define(class TypeAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      literally((context) => {
+      instantiate((context) => {
         const { string } = json,
               typeAssertionNode = instantiateTypeAssertion(string, context),
               term = termFromTypeAssertionNode(typeAssertionNode, context),

package/src/element/assumption.js

@@ -3,16 +3,15 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
 import { instantiateAssumption } from "../process/instantiate";
-import { unifyStatementIntrinsically } from "../process/unify";
+import { instantiate, reconcile } from "../utilities/context";
 
 export default define(class Assumption extends Element {
   constructor(context, string, node, reference, statement) {
     super(context, string, node);
 
-    this.statement = statement;
     this.reference = reference;
+    this.statement = statement;
   }
 
   getReference() {
@@ -166,7 +165,7 @@ export default define(class Assumption extends Element {
   }
 
   validateWhenStated(context) {
-    let validatesWhenStated;
+    let validatesWhenStated = false;
 
     const assumptionString = this.getString();  ///
 
@@ -179,15 +178,17 @@ export default define(class Assumption extends Element {
       validatesWhenStated = true;
     } else {
       const topLevelMetaAssertions = context.findTopLevelMetaAssertionsByReference(this.reference),
-            topLevelMetaAssertionsUnify = topLevelMetaAssertions.every((topLevelMetaAssertion) => {
-              const topLevelMetaAssertionUnifies = this.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
+            topLevelMetaAssertionsCompare = topLevelMetaAssertions.some((topLevelMetaAssertion) => {
+              const topLevelMetaAssertionCompares = this.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
 
-              if (topLevelMetaAssertionUnifies) {
+              if (topLevelMetaAssertionCompares) {
                 return true;
               }
             });
 
-      validatesWhenStated = topLevelMetaAssertionsUnify; ///
+      if (topLevelMetaAssertionsCompare) {
+        validatesWhenStated = true;
+      }
     }
 
     if (validatesWhenStated) {
@@ -198,7 +199,7 @@ export default define(class Assumption extends Element {
   }
 
   validateWhenDerived(context) {
-    let validatesWhenDerived;
+    let validatesWhenDerived = false;
 
     const assumptionString = this.getString();  ///
 
@@ -206,7 +207,9 @@ export default define(class Assumption extends Element {
 
     const topLevelMetaAssertionPresent = context.isTopLevelMetaAssertionPresentByReference(this.reference);
 
-    validatesWhenDerived = topLevelMetaAssertionPresent; ///
+    if (topLevelMetaAssertionPresent) {
+      validatesWhenDerived = true;
+    }
 
     if (validatesWhenDerived) {
       context.debug(`...validated the '${assumptionString}' derived assumption.`);
@@ -215,28 +218,6 @@ export default define(class Assumption extends Element {
     return validatesWhenDerived;
   }
 
-  unifyStatement(statement, substitutions, generalContext, specificContext) {
-    let statementUnifies;
-
-    const context = generalContext,  ///
-          statementString = statement.getString(),
-          assumptionStatementString = this.statement.getString();
-
-    context.trace(`Unifying the '${statementString}' statement with the '${assumptionStatementString}' statement...`);
-
-    const generalStatement = this.statement,
-          specificStatement = statement,  ///
-          statementUUnifiesIntrinsically = unifyStatementIntrinsically(generalStatement, specificStatement, substitutions, generalContext, specificContext);
-
-    statementUnifies = statementUUnifiesIntrinsically;  ///
-
-    if (statementUnifies) {
-      context.debug(`...unified the '${statementString}' statement with the '${assumptionStatementString}' statement.`);
-    }
-
-    return statementUnifies;
-  }
-
   unifyLabel(label, generalContext, specificContext) {
     let labelUnifiesWithReference;
 
@@ -269,30 +250,18 @@ export default define(class Assumption extends Element {
 
     context = topLevelMetaAssertion.getContext();  ///
 
-    const specificContext = context,  ///
-          labelSubstitutions = [],
-          label = topLevelMetaAssertion.getLabel(),
-          substitutions = labelSubstitutions, ///
-          labelUnifies = this.unifyLabel(label, substitutions, generalContext, specificContext);
+    const specificContext = context;  ///
 
-    if (labelUnifies) {
-      const statementSubstitutions = [],
-            statement = topLevelMetaAssertion.getStatement(),
-            substitutions = statementSubstitutions, ///
-            statementUUnifies = this.unifyStatement(statement, substitutions, generalContext, specificContext);
+    reconcile((specificContext) => {
+      const label = topLevelMetaAssertion.getLabel(),
+            labelUnifies = this.unifyLabel(label, generalContext, specificContext);
 
-      if (statementUUnifies) {
-        const labelSubstitutionsCorrelateStatementSubstitutions = labelSubstitutions.correlateSubstitutions(statementSubstitutions);
-
-        if (labelSubstitutionsCorrelateStatementSubstitutions) {
-          topLevelMetaAssertionUnifies = true; ///
-        }
+      if (labelUnifies) {
+        topLevelMetaAssertionUnifies = this.statement.unifyTopLevelMetaAssertion(topLevelMetaAssertion, generalContext, specificContext);
       }
-    }
+    }, specificContext);
 
     if (topLevelMetaAssertionUnifies) {
-      context = generalContext; ///
-
       context.trace(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${assumptionString}' assumption...`);
     }
 
@@ -311,7 +280,7 @@ export default define(class Assumption extends Element {
   static name = "Assumption";
 
   static fromJSON(json, context) {
-    const assumption = literally((context) => {
+    const assumption = instantiate((context) => {
       const { string } = json,
             assumptionNode = instantiateAssumption(string, context),
             node = assumptionNode,  ///

package/src/element/combinator.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { attempt, literally } from "../utilities/context";
+import { attempt, instantiate } from "../utilities/context";
 import { instantiateCombinator } from "../process/instantiate";
 import { statementFromCombinatorNode } from "../utilities/element";
 import { unifyStatementWithCombinator } from "../process/unify";
@@ -21,7 +21,7 @@ export default define(class Combinator extends Element {
     return this.statement;
   }
 
-  getConbinatorNode() {
+  getCombinatoryNode() {
     const node = this.getNode(),
           combinatorNode = node;  ///
 
@@ -39,7 +39,7 @@ export default define(class Combinator extends Element {
       const statementValidates = this.validateStatement(context);
 
       if (statementValidates) {
-        this.setContext(context);
+        context.commit(this);
 
         validates = true;
       }
@@ -128,7 +128,7 @@ export default define(class Combinator extends Element {
 
     context = ephemeralContext; ///
 
-    const combinator = literally((context) => {
+    const combinator = instantiate((context) => {
       const { string } = json,
             combinatorNode = instantiateCombinator(string, context),
             node = combinatorNode,  ///