occam-verify-cli 1.0.387 → 1.0.396

package/src/ontology/variable.js

@@ -127,13 +127,12 @@ export default define(class Variable {
 
     variable = this; ///
 
-    const substitutionPresent = substitutions.isSubstitutionPresentByVariable(variable);
+    const substitution = substitutions.findSubstitutionByVariable(variable);
 
-    if (substitutionPresent) {
+    if (substitution !== null) {
       context = specificContext;  ///
 
-      const substitution = substitutions.findSubstitutionByVariable(variable),
-            substitutionTermEqualToTerm = substitution.isTermEqualTo(term, context);
+      const substitutionTermEqualToTerm = substitution.isTermEqualToTerm(term, context);
 
       if (substitutionTermEqualToTerm) {
         termUnifies = true;
@@ -147,26 +146,20 @@ export default define(class Variable {
 
       context = specificContext;  ///
 
-      const termVerifies = term.verify(context, () => {
-        let verifiesAhead = false;
+      const termNode = term.getNode();
 
-        const termType = term.getType(),
-              variableType = variable.getType(),
-              termTypeEqualToOrSubTypeOfVariableType = termType.isEqualToOrSubTypeOf(variableType);
+      term = context.findTermByTermNode(termNode);
 
-        if (termTypeEqualToOrSubTypeOfVariableType) {
-          verifiesAhead = true;
-        }
+      const termType = term.getType(),
+            variableType = variable.getType(),
+            termTypeEqualToOrSubTypeOfVariableType = termType.isEqualToOrSubTypeOf(variableType);
 
-        return verifiesAhead;
-      });
-
-      if (termVerifies) {
+      if (termTypeEqualToOrSubTypeOfVariableType) {
         const { TermSubstitution } = ontology,
               termSubstitution = TermSubstitution.fromTernAndVariable(term, variable, context),
               substitution = termSubstitution;  ///
 
-        substitutions.addSubstitution(substitution, specificContext);
+        substitutions.addSubstitution(substitution, context);
 
         termUnifies = true;
       }
@@ -179,6 +172,60 @@ export default define(class Variable {
     return termUnifies;
   }
 
+  unifyTermVariable(termVariable, substitutions, generalContext, specificContext) {
+    let termVariableUnifies = false;
+
+    const variableString = this.string, ///
+          termVariableString = termVariable.getString();
+
+    specificContext.trace(`Unifying the '${termVariableString}' term variable with the '${variableString}' variable...`);
+
+    let context,
+        variable;
+
+    variable = this; ///
+
+    const substitution = substitutions.findSubstitutionByVariable(variable);
+
+    if (substitution !== null) {
+      context = specificContext;  ///
+
+      const substitutionTermVariableEqualToTerm = substitution.isTermVariableEqualToTerm(termVariable, context);
+
+      if (substitutionTermVariableEqualToTerm) {
+        termVariableUnifies = true;
+      }
+    } else {
+      context = generalContext;  ///
+
+      const variableIdentifier = variable.getIdentifier();
+
+      variable = context.findVariableByVariableIdentifier(variableIdentifier);
+
+      context = specificContext;  ///
+
+      const variableType = variable.getType(),
+            termVariableType = termVariable.getType(),
+            termVariableTypeEqualToOrSubTypeOfVariableType = termVariableType.isEqualToOrSubTypeOf(variableType);
+
+      if (termVariableTypeEqualToOrSubTypeOfVariableType) {
+        const { TermSubstitution } = ontology,
+              termSubstitution = TermSubstitution.fromTernVariableAndVariable(termVariable, variable, context),
+              substitution = termSubstitution;  ///
+
+        substitutions.addSubstitution(substitution, context);
+
+        termVariableUnifies = true;
+      }
+    }
+
+    if (termVariableUnifies) {
+      specificContext.debug(`...unified the '${termVariableString}' term variable with the '${variableString}' variable.`);
+    }
+
+    return termVariableUnifies;
+  }
+
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
           string = this.string, ///

package/src/substitutions.js

@@ -22,18 +22,6 @@ export default class Substitutions {
 
   getLength() { return this.array.length; }
 
-  getFirstSubstitution() {
-    let firstSubstitution = null;
-
-    const length = this.getLength();
-
-    if (length > 0) {
-      firstSubstitution = first(this.array);
-    }
-
-    return firstSubstitution;
-  }
-
   getMetavariables() {
     const metavariables = [];
 
@@ -70,6 +58,18 @@ export default class Substitutions {
     return nonTrivialLength;
   }
 
+  getFirstSubstitution() {
+    let firstSubstitution = null;
+
+    const length = this.getLength();
+
+    if (length > 0) {
+      firstSubstitution = first(this.array);
+    }
+
+    return firstSubstitution;
+  }
+
   mapSubstitution(callback) { return this.array.map(callback); }
 
   findSubstitution(callback) { return this.array.find(callback) || null; }  ///
@@ -107,7 +107,7 @@ export default class Substitutions {
 
   findSubstitutionsByMetavariable(metavariable) {
     const substitutions = this.findSubstitutions((substitution) => {
-      const substitutionMetavariableEqualToMetavariable = substitution.isMetavariableEqualTo(metavariable);
+      const substitutionMetavariableEqualToMetavariable = substitution.isMetavariableEqualToMetavariable(metavariable);
 
       if (substitutionMetavariableEqualToMetavariable) {
         return true;
@@ -123,7 +123,7 @@ export default class Substitutions {
 
       if (substitutionSimple) {
         const simpleSubstitution = substitution,  ///
-              simpleSubstitutionMetavariableEqualToMetavariable = simpleSubstitution.isMetavariableEqualTo(metavariable);
+              simpleSubstitutionMetavariableEqualToMetavariable = simpleSubstitution.isMetavariableEqualToMetavariable(metavariable);
 
         if (simpleSubstitutionMetavariableEqualToMetavariable) {
           return true;
@@ -140,7 +140,7 @@ export default class Substitutions {
 
       if (substitutionComplex) {
         const complexSubstitution = substitution, ///
-              complexSubstitutionMetavariableEqualToMetavariable = complexSubstitution.isMetavariableEqualTo(metavariable);
+              complexSubstitutionMetavariableEqualToMetavariable = complexSubstitution.isMetavariableEqualToMetavariable(metavariable);
 
         if (complexSubstitutionMetavariableEqualToMetavariable) {
           return true;
@@ -155,11 +155,11 @@ export default class Substitutions {
     const substitutionA = substitution; ///
 
     substitution = this.findSubstitution((substitution) => {  ///
-      const substitutionMetavariableEqualToMetavariable = substitution.isMetavariableEqualTo(metavariable);
+      const substitutionMetavariableEqualToMetavariable = substitution.isMetavariableEqualToMetavariable(metavariable);
 
       if (substitutionMetavariableEqualToMetavariable) {
         const substitutionB = substitution, ///
-              substitutionBSubstitutionEqualToSubstitutionA = substitutionB.isSubstitutionEqualTo(substitutionA);
+              substitutionBSubstitutionEqualToSubstitutionA = substitutionB.isSubstitutionEqualToSubstitution(substitutionA);
 
         if (substitutionBSubstitutionEqualToSubstitutionA) {
           return true;
@@ -192,15 +192,15 @@ export default class Substitutions {
     return substitutionPresent;
   }
 
-  addSubstitution(substitution, specificContext) {
+  addSubstitution(substitution, context) {
     this.array.push(substitution);
 
     const substitutionString = substitution.getString();
 
-    specificContext.trace(`Added the ${substitutionString} substitution.`);
+    context.trace(`Added the ${substitutionString} substitution.`);
   }
 
-  removeSubstitution(substitution, specificContext) {
+  removeSubstitution(substitution, context) {
     const substitutionA = substitution; ///
 
     prune(this.array, (substitution) => {
@@ -213,7 +213,7 @@ export default class Substitutions {
 
     const substitutionString = substitution.getString();
 
-    specificContext.trace(`Removed the ${substitutionString} substitution.`);
+    context.trace(`Removed the ${substitutionString} substitution.`);
   }
 
   correlateSubstitutions(substitutions) {
@@ -247,7 +247,7 @@ export default class Substitutions {
     this.savedArray = null;
   }
 
-  resolve(generalContext, specificContext) {
+  resolve(context) {
     const metavariables = this.getMetavariables();
 
     metavariables.forEach((metavariable) => {
@@ -261,7 +261,7 @@ export default class Substitutions {
               resolved = substitution.isResolved();
 
               if (!resolved) {
-                substitution.resolve(substitutions, generalContext, specificContext);
+                substitution.resolve(substitutions, context);
               }
             });
 
@@ -297,7 +297,7 @@ export default class Substitutions {
     ];
   }
 
-  rollback(specificContext) {
+  rollback(context) {
     const array = [
       ...this.array
     ];
@@ -305,7 +305,7 @@ export default class Substitutions {
     leftDifference(array, this.savedArray);
 
     array.forEach((substitution) => {
-      this.removeSubstitution(substitution, specificContext);
+      this.removeSubstitution(substitution, context);
     });
 
     this.array = [

package/src/unifier/intrinsicLevel.js

@@ -1,9 +1,9 @@
 "use strict";
 
-import ontology from "../ontology";
 import Unifier from "../unifier";
 
 import { nodeQuery } from "../utilities/query";
+import { variableIdentifierFromVariableNode, termVariableIdentifierFromTermNode } from "../utilities/variable";
 
 const termNodeQuery = nodeQuery("/term"),
       termVariableNodeQuery = nodeQuery("/term/variable!");
@@ -24,23 +24,33 @@ class IntrinsicLevelUnifier extends Unifier {
       generalNodeQuery: termVariableNodeQuery,
       specificNodeQuery: termNodeQuery,
       unify: (generalTermVariableNode, specificTermNode, substitutions, generalContext, specificContext) => {
-        let termUnifies;
+        let termUnifies = false;
 
-        const { Term, Variable } = ontology,
-              termNode = specificTermNode, ///
-              variableNode = generalTermVariableNode; ///
+        const termNode = specificTermNode, ///
+              variableNode = generalTermVariableNode, ///
+              variableIdentifier = variableIdentifierFromVariableNode(variableNode);
 
         let context;
 
         context = generalContext; ///
 
-        const variable = Variable.fromVariableNode(variableNode, context);
+        const variable = context.findVariableByVariableIdentifier(variableIdentifier);
 
         context = specificContext;  ///
 
-        const term = Term.fromTermNode(termNode, context);
+        const term = context.findTermByTermNode(termNode);
 
-        termUnifies = variable.unifyTerm(term, substitutions, generalContext, specificContext);
+        if (term !== null) {
+          termUnifies = variable.unifyTerm(term, substitutions, generalContext, specificContext);
+        } else {
+          const termVariaibleIdentifer = termVariableIdentifierFromTermNode(termNode),
+                termVariable = context.findVariableByVariableIdentifier(termVariaibleIdentifer),
+                termVariableUnifies = variable.unifyTermVariable(termVariable, substitutions, generalContext, specificContext);
+
+          if (termVariableUnifies) {
+            termUnifies = true;
+          }
+        }
 
         return termUnifies;
       }

package/src/unifier/metaLevel.js

@@ -4,7 +4,8 @@ import ontology from "../ontology";
 import Unifier from "../unifier";
 
 import { nodeQuery } from "../utilities/query";
-import Metavariable from "./metavariable";
+import { metavariableNameFromMetavariableNode } from "../utilities/metavariable";
+import { variableIdentifierFromVariableNode, termVariableIdentifierFromTermNode } from "../utilities/variable";
 
 const termNodeQuery = nodeQuery("/term"),
       frameNodeQuery = nodeQuery("/frame"),
@@ -32,30 +33,32 @@ class MetaLevelUnifier extends Unifier {
       unify: (generalStatementMetavariableNode, specificStatementNode, substitutions, generalContext, specificContext) => {
         let statementUnifies;
 
-        const { Metavariable, Statement } = ontology; ///
-
         let context,
+            statement,
             statementNode;
 
         context = generalContext; ///
 
         const metavariableNode = generalStatementMetavariableNode,  ///
-              metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);
+              metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+              metavariable = context.findMetavariableByMetavariableName(metavariableName);
 
         const metavariableNodeParentNode = metavariableNode.getParentNode();
 
         statementNode = metavariableNodeParentNode; ///
 
+        statement = context.findStatementByStatementNode(statementNode);
+
         const { TermSubstitution, FrameSubstitution } = ontology,
-              frameSubstitution = FrameSubstitution.fromStatementNode(statementNode, context),
-              termSubstitution = TermSubstitution.fromStatementNode(statementNode, context),
+              frameSubstitution = FrameSubstitution.fromStatement(statement, context),
+              termSubstitution = TermSubstitution.fromStatement(statement, context),
               substitution = (frameSubstitution || termSubstitution);
 
         context = specificContext; ///
 
         statementNode = specificStatementNode;  ///
 
-        const statement = Statement.fromStatementNode(statementNode, context);
+        statement = context.findStatementByStatementNode(statementNode);
 
         statementUnifies = metavariable.unifyStatement(statement, substitution, substitutions, generalContext, specificContext);
 
@@ -68,19 +71,19 @@ class MetaLevelUnifier extends Unifier {
       unify: (generalFrameDeclarationMetavariableNode, specificFrameNode, substitutions, generalContext, specificContext) => {
         let frameUnifies;
 
-        const { Frame, Metavariable } = ontology,
-              frameNode = specificFrameNode, ///
-              metavariableNode = generalFrameDeclarationMetavariableNode;  ///
+        const frameNode = specificFrameNode, ///
+              metavariableNode = generalFrameDeclarationMetavariableNode,  ///
+              metavariableName = metavariableNameFromMetavariableNode(metavariableNode);
 
         let context;
 
         context = generalContext; ///
 
-        const metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);
+        const metavariable = context.findMetavariableByMetavariableName(metavariableName);
 
         context = specificContext;  ///
 
-        const frame = Frame.fromFrameNode(frameNode, context);
+        const frame = context.findFrameByFrameNode(frameNode);
 
         frameUnifies = metavariable.unifyFrame(frame, substitutions, generalContext, specificContext);
 
@@ -91,23 +94,33 @@ class MetaLevelUnifier extends Unifier {
       generalNodeQuery: termVariableNodeQuery,
       specificNodeQuery: termNodeQuery,
       unify: (generalTermVariableNode, specificTermNode, substitutions, generalContext, specificContext) => {
-        let termUnifies;
+        let termUnifies = false;
 
-        const { Term, Variable } = ontology,
-              termNode = specificTermNode, ///
-              variableNode = generalTermVariableNode; ///
+        const termNode = specificTermNode, ///
+              variableNode = generalTermVariableNode, ///
+              variableIdentifier = variableIdentifierFromVariableNode(variableNode);
 
         let context;
 
         context = generalContext; ///
 
-        const variable = Variable.fromVariableNode(variableNode, context);
+        const variable = context.findVariableByVariableIdentifier(variableIdentifier);
 
         context = specificContext;  ///
 
-        const term = Term.fromTermNode(termNode, context);
+        const term = context.findTermByTermNode(termNode);
+
+        if (term !== null) {
+          termUnifies = variable.unifyTerm(term, substitutions, generalContext, specificContext);
+        } else {
+          const termVariaibleIdentifer = termVariableIdentifierFromTermNode(termNode),
+                termVariable = context.findVariableByVariableIdentifier(termVariaibleIdentifer),
+                termVariableUnifies = variable.unifyTermVariable(termVariable, substitutions, generalContext, specificContext);
 
-        termUnifies = variable.unifyTerm(term, substitutions, generalContext, specificContext);
+          if (termVariableUnifies) {
+           termUnifies = true;
+          }
+        }
 
         return termUnifies;
       }
@@ -118,7 +131,7 @@ class MetaLevelUnifier extends Unifier {
       unify: (generalDeclarationMetavariableNode, specificDeclarationMetavariableNode, substitutions, generalContext, specificContext) => {
         let referenceUnifies;
 
-        const { Metavariable, Reference } = ontology;
+        const { Reference } = ontology;
 
         let context,
             metavariableNode;
@@ -127,7 +140,8 @@ class MetaLevelUnifier extends Unifier {
 
         metavariableNode = generalDeclarationMetavariableNode;  ///
 
-        const metavariable = Metavariable.fromMetavariableNode(metavariableNode, context);  ///
+        const metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
+              metavariable = context.findMetavariableByMetavariableName(metavariableName);
 
         context = specificContext;  ///
 

package/src/utilities/brackets.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import ontology from "../ontology";
-import LocalContext from "../context/local";
+import TemporaryContext from "../context/temporary";
 import combinatorBracketedContext from "../context/bracketed/combinator";
 import constructorBracketedContext from "../context/bracketed/constructor";
 
@@ -21,22 +21,6 @@ export function stripBracketsFromTerm(term, context) {
   return term;
 }
 
-export function stripBracketsFromReference(reference, context) {
-  const referenceNode = reference.getNode(),
-    bracketedReferenceChildNode = bracketedReferenceChildNodeFromReferenceNode(referenceNode);
-
-  if (bracketedReferenceChildNode !== null) {
-    context = contextFromReference(reference, context); ///
-
-    const { Reference } = ontology,
-          referenceNode = bracketedReferenceChildNode;  ///
-
-    reference = Reference.fromReferenceNode(referenceNode, context);
-  }
-
-  return reference;
-}
-
 export function stripBracketsFromStatement(statement, context) {
   const statementNode = statement.getNode(),
         bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
@@ -105,22 +89,12 @@ export function bracketedStatementChildNodeFromStatementNode(statementNode) {
   return bracketedStatementChildNode;
 }
 
-function contextFromReference(reference, context) {
-  const referenceTokens = reference.getTokens(),
-        tokens = referenceTokens, ///
-        localContext = LocalContext.fromContextAndTokens(context, tokens);
-
-  context = localContext; ///
-
-  return context;
-}
-
 function contextFromStatement(statement, context) {
   const statementTokens = statement.getTokens(),
         tokens = statementTokens, ///
-        localContext = LocalContext.fromContextAndTokens(context, tokens);
+        temporaryContext = TemporaryContext.fromContextAndTokens(context, tokens);
 
-  context = localContext; ///
+  context = temporaryContext; ///
 
   return context;
 }

package/src/utilities/context.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import ontology from "../ontology";
-import LocalContext from "../context/local";
+import TemporaryContext from "../context/temporary";
 
 export function metavariableFromFrame(frame, context) {
   context = contextFromFrame(frame, context); ///
@@ -106,9 +106,9 @@ export function satisfiesAssertionFromStatement(statement, context) {
 function contextFromFrame(frame, context) {
   const frameTokens = frame.getTokens(),
         tokens = frameTokens, ///
-        localContext = LocalContext.fromContextAndTokens(context, tokens);
+        temporaryContext = TemporaryContext.fromContextAndTokens(context, tokens);
 
-  context = localContext; ///
+  context = temporaryContext; ///
 
   return context;
 }
@@ -116,9 +116,9 @@ function contextFromFrame(frame, context) {
 function contextFromStatement(statement, context) {
   const statementTokens = statement.getTokens(),
         tokens = statementTokens, ///
-        localContext = LocalContext.fromContextAndTokens(context, tokens);
+        temporaryContext = TemporaryContext.fromContextAndTokens(context, tokens);
 
-  context = localContext; ///
+  context = temporaryContext; ///
 
   return context;
 }

package/src/utilities/json.js

@@ -203,6 +203,22 @@ export function labelFromJSON(json, context) {
   return label;
 }
 
+export function framesFromJSON(json, context) {
+  let { frames } = json;
+
+  const { Frame } = ontology,
+        framesJSON = frames; ///
+
+  frames = framesJSON.map((frameJSON) => {
+    const json = frameJSON,  ///
+          frame = Frame.fromJSON(json, context);
+
+    return frame;
+  });
+
+  return frames;
+}
+
 export function labelsFromJSON(json, context) {
   let { labels } = json;
 
@@ -600,6 +616,18 @@ export function rulesToRulesJSON(rules) {
   return rulesJSON;
 }
 
+export function framesToFramesJSON(frames) {
+  const framesJSON = frames.map((frame) => {
+    const frameJSON = frame.toJSON();
+
+    frame = frameJSON; ///
+
+    return frame;
+  });
+
+  return framesJSON;
+}
+
 export function labelsToLabelsJSON(labels) {
   const labelsJSON = labels.map((label) => {
     const labelJSON = label.toJSON();

package/src/utilities/metavariable.js

@@ -0,0 +1,13 @@
+"use strict";
+
+import { nodeQuery } from "../utilities/query";
+
+const metavariableNameNodeQuery = nodeQuery("/metavariable/@name!");
+
+export function metavariableNameFromMetavariableNode(metavariableNode) {
+  const metavariableNameTerminalNode = metavariableNameNodeQuery(metavariableNode),
+        metavariableNameTerminalNodeContent = metavariableNameTerminalNode.getContent(),
+        metavariableName = metavariableNameTerminalNodeContent; ///
+
+  return metavariableName;
+}

package/src/utilities/substitutions.js

@@ -55,11 +55,9 @@ export function statementFromStatementAndSubstitutions(statement, substitutions,
     if (metavariable !== null) {
       let substitution;
 
-      const { TermSubstitution, FrameSubstitution } = ontology,
-            termSubstitution = TermSubstitution.fromStatementNode(statementNode, context),
-            frameSubstitution = FrameSubstitution.fromStatementNode(statementNode, context);
+      const { TermSubstitution, FrameSubstitution } = ontology;
 
-      substitution = (termSubstitution || frameSubstitution);
+      substitution = TermSubstitution.fromStatement(statement, context) || FrameSubstitution.fromStatement(statement, context);
 
       substitution = substitutions.findSubstitutionByMetavariableAndSubstitution(metavariable, substitution); ///
 

package/src/utilities/unification.js

@@ -1,6 +1,6 @@
 "use string";
 
-import LocalContext from "../context/local";
+import TemporaryContext from "../context/temporary";
 import metaLevelUnifier from "../unifier/metaLevel";
 import metavariableUnifier from "../unifier/metavariable";
 import intrinsicLevelUnifier from "../unifier/intrinsicLevel";
@@ -12,14 +12,7 @@ export function unifyStatement(generalStatement, specificStatement, substitution
 
   const generalStatementNode = generalStatement.getNode(),
         specificStatementNode = specificStatement.getNode(),
-        generalStatementTokens = generalStatement.getTokens(),
-        specificStatementTokens = specificStatement.getTokens();
-
-  generalContext = contextFromTokens(generalStatementTokens, generalContext); ///
-
-  specificContext = contextFromTokens(specificStatementTokens, specificContext);  ///
-
-  const generalNonTerminalNode = generalStatementNode, ///
+        generalNonTerminalNode = generalStatementNode, ///
         specificNonTerminalNode = specificStatementNode,  ///
         unifiesAtMetaLevel = metaLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
 
@@ -35,14 +28,7 @@ export function unifySubstitution(generalSubstitution, specificSubstitution, sub
 
   const generalSubstitutionNode = generalSubstitution.getNode(),
         specificSubstitutionNode = specificSubstitution.getNode(),
-        generalSubstitutionTokens = generalSubstitution.getTokens(),
-        specificSubstitutionTokens = specificSubstitution.getTokens();
-
-  generalContext = contextFromTokens(generalSubstitutionTokens, generalContext); ///
-
-  specificContext = contextFromTokens(specificSubstitutionTokens, specificContext);  ///
-
-  const generalNonTerminalNode = generalSubstitutionNode, ///
+        generalNonTerminalNode = generalSubstitutionNode, ///
         specificNonTerminalNode = specificSubstitutionNode,
         unifiesAtMetaLevel = metaLevelUnifier.unify(generalNonTerminalNode, specificNonTerminalNode, substitutions, generalContext, specificContext);
 
@@ -106,17 +92,15 @@ export function unifyStatementWithCombinator(statement, combinator, assignments,
   let statementUnifiesWithCombinator;
 
   const statementNode = statement.getNode(),
-        statementTokens = statement.getTokens(),
         combinatorStatement = combinator.getStatement(),
         combinatorStatementNode = combinatorStatement.getNode(),
         combinatorStatementTokens = combinatorStatement.getTokens();
 
-  let generalContext = context, ///
-      specificContext = context;  ///
+  const specificContext = context;  ///
 
-  generalContext = contextFromTokens(combinatorStatementTokens, generalContext);  ///
+  context = contextFromTokens(combinatorStatementTokens, context);  ///
 
-  specificContext = contextFromTokens(statementTokens, specificContext);  ///
+  const generalContext = context; ///
 
   statementUnifiesWithCombinator = statementWithCombinatorUnifier.unify(combinatorStatementNode, statementNode, assignments, stated, generalContext, specificContext);
 
@@ -144,9 +128,9 @@ export function unifyMetavariableIntrinsically(generalMetavariable, specificMeta
 }
 
 function contextFromTokens(tokens, context) {
-  const localContext = LocalContext.fromContextAndTokens(context, tokens);
+  const temporaryContext = TemporaryContext.fromContextAndTokens(context, tokens);
 
-  context = localContext;  ///
+  context = temporaryContext;  ///
 
   return context;
 }