occam-verify-cli 1.0.950 → 1.0.955

package/src/element/substitution/term.js

@@ -3,12 +3,12 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { stripBracketsFromTerm } from "../../utilities/brackets";
 import { breakPointFromJSON } from "../../utilities/breakPoint";
+import { stripBracketsFromTerm } from "../../utilities/brackets";
 import { instantiateTermSubstitution } from "../../process/instantiate";
 import { termSubstitutionFromTermSubstitutionNode } from "../../utilities/element";
 import { termSubstitutionStringFromTermAndVariable } from "../../utilities/string";
-import { ablate, ablates, manifest, attempts, descend, instantiate, unserialises } from "../../utilities/context";
+import { join, ablate, ablates, manifest, attempts, reconcile, sequester, instantiate, unserialises } from "../../utilities/context";
 
 export default define(class TermSubstitution extends Substitution {
   constructor(context, string, node, breakPoint, targetTerm, replacementTerm) {
@@ -139,7 +139,7 @@ export default define(class TermSubstitution extends Substitution {
 
     if (targetTermSingular) {
       manifest((context) => {
-        descend((context) => {
+        sequester((context) => {
           const targetTerm = this.targetTerm.validate(context, (targetTerm, context) => {
             const validatesForwards = true;
 
@@ -174,7 +174,7 @@ export default define(class TermSubstitution extends Substitution {
 
     context.trace(`Validating the '${termSubstitutionString}' term substitution's replacement term...`);
 
-    descend((context) => {
+    sequester((context) => {
       const replacementTerm = this.replacementTerm.validate(context, (replacementTerm, context) => {
         const validatesForwards = true;
 
@@ -195,6 +195,127 @@ export default define(class TermSubstitution extends Substitution {
     return replacementTermValidates;
   }
 
+  unifySubstitution(substitution, context) {
+    let substitutionUnifies = false;
+
+    const generalSubstitution = this, ///
+          specificSubstitution = substitution,
+          generalSubstitutionString = generalSubstitution.getString(),
+          specificSubstitutionString = specificSubstitution.getString();
+
+    context.trace(`Unifying the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution...`);
+
+    reconcile((context) => {
+      const replacementTermUnifies = this.unifyReplacementTerm(substitution, context);
+
+      if (replacementTermUnifies) {
+        const targetTermUnifies = this.unifyTargetTerm(substitution, context);
+
+        if (targetTermUnifies) {
+          context.commit();
+
+          substitutionUnifies = true;
+        }
+      }
+    }, context);
+
+    if (substitutionUnifies) {
+      context.debug(`...unified the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution.`);
+    }
+
+    return substitutionUnifies;
+  }
+
+  unifyTargetTerm(substitution, context) {
+    let targetTermUnifies = false;
+
+    const generalSubstitution = this, ///
+          specificSubstitution = substitution,
+          generalSubstitutionString = generalSubstitution.getString(),
+          specificSubstitutionString = specificSubstitution.getString();
+
+    context.trace(`Unifying the '${specificSubstitutionString}' substitution's target term with the '${generalSubstitutionString}' substitution's target term...`);
+
+    const generalSubstitutionGeneralContext = generalSubstitution.getGeneralContext(),
+          specificSubstitutionGeneralContext = specificSubstitution.getGeneralContext(),
+          generalSubstitutionTargetTerm = generalSubstitution.getTargetTerm(),
+          specificSubstitutionTargetTerm = specificSubstitution.getTargetTerm(),
+          generalContext = generalSubstitutionGeneralContext,  ///
+          specificContext = specificSubstitutionGeneralContext,  ///
+          generalTerm = generalSubstitutionTargetTerm, ///
+          specificTerm = specificSubstitutionTargetTerm; ///
+
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        const generalTermNode = generalTerm.getNode(),
+              generalVariable = variableFromTermNode(generalTermNode, generalContext);
+
+        if (generalVariable !== null) {
+          const term = specificTerm,  ///
+                variable = generalVariable, ///
+                termUnifies = variable.unifyTerm(term, generalContext, specificContext);
+
+          if (termUnifies) {
+            specificContext.commit(context);
+
+            targetTermUnifies = true;
+          }
+        }
+      }, specificContext);
+    }, specificContext, context);
+
+    if (targetTermUnifies) {
+      context.trace(`...unified the '${specificSubstitutionString}' substitution's target term with the '${generalSubstitutionString}' substitution's target term.`);
+    }
+
+    return targetTermUnifies;
+  }
+
+  unifyReplacementTerm(substitution, context) {
+    let replacementTermUnifies = false;
+
+    const generalSubstitution = this, ///
+          specificSubstitution = substitution,
+          generalSubstitutionString = generalSubstitution.getString(),
+          specificSubstitutionString = specificSubstitution.getString();
+
+    context.trace(`Unifying the '${specificSubstitutionString}' substitution's replacement term with the '${generalSubstitutionString}' substitution's replacement term...`);
+
+    const generalSubstitutionSpecificContext = generalSubstitution.getSpecificContext(),
+          specificSubstitutionSpecificContext = specificSubstitution.getSpecificContext(),
+          generalSubstitutionReplacementTerm = generalSubstitution.getReplacementTerm(),
+          specificSubstitutionReplacementTerm = specificSubstitution.getReplacementTerm(),
+          generalContext = generalSubstitutionSpecificContext,  ///
+          specificContext = specificSubstitutionSpecificContext,  ///
+          generalTerm = generalSubstitutionReplacementTerm, ///
+          specificTerm = specificSubstitutionReplacementTerm; ///
+
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        const generalTermNode = generalTerm.getNode(),
+              generalVariable = variableFromTermNode(generalTermNode, generalContext);
+
+        if (generalVariable !== null) {
+          const term = specificTerm,  ///
+                variable = generalVariable, ///
+                termUnifies = variable.unifyTerm(term, generalContext, specificContext);
+
+          if (termUnifies) {
+            specificContext.commit(context);
+
+            replacementTermUnifies = true;
+          }
+        }
+      }, specificContext);
+    }, specificContext, context);
+
+    if (replacementTermUnifies) {
+      context.trace(`...unified the '${specificSubstitutionString}' substitution's replacement term with the '${generalSubstitutionString}' substitution's replacement term.`);
+    }
+
+    return replacementTermUnifies;
+  }
+
   static name = "TermSubstitution";
 
   static fromJSON(json, context) {
@@ -268,6 +389,18 @@ export default define(class TermSubstitution extends Substitution {
   }
 });
 
+function variableFromTermNode(termNode, context) {
+  let variable = null;
+
+  const variableNode = termNode.getVariableNode();
+
+  if (variableNode !== null) {
+    variable = context.findVariableByVariableNode(variableNode);
+  }
+
+  return variable;
+}
+
 function targetTermFromTermSubstitutionNode(termSubstitutionNode, context) {
   const targetTermNode = termSubstitutionNode.getTargetTermNode(),
         targetTerm = context.findTermByTermNode(targetTermNode);

package/src/element/substitution.js

@@ -224,12 +224,6 @@ export default class Substitution extends Element {
     return validSubstitution;
   }
 
-  resolve(substitutions, generalContext, specificContext) {
-    const resolved = true;
-
-    return resolved;
-  }
-
   commit(generalContext, specificContext) {
     const contexts = [
       generalContext,

package/src/element/variable.js

@@ -8,8 +8,8 @@ import { define } from "../elements";
 import { instantiate } from "../utilities/context";
 import { instantiateVariable } from "../process/instantiate";
 import { provisionallyStringFromProvisional } from "../utilities/string";
-import { variableFromTermNode, identifierFromVariableNode } from "../utilities/element";
 import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
+import { variableFromTermNode, identifierFromVariableNode } from "../utilities/element";
 import { typeFromJSON, typeToTypeJSON, provisionalFromJSON, provisionalToProvisionalJSON } from "../utilities/json";
 
 export default define(class Variable extends Element {

package/src/process/unify.js

@@ -336,65 +336,6 @@ class MetavariablePass extends ZipPass {
   ];
 }
 
-class SubstitutionPass extends ZipPass {
-  static maps = [
-    {
-      generalNodeQuery: frameMetavariableNodeQuery,
-      specificNodeQuery: frameNodeQuery,
-      run: (generalFrameMetavariableNode, specificFrameNode, generalContext, specificContext) => {
-        let success = false;
-
-        const frameNode = specificFrameNode, ///
-              metavariableNode = generalFrameMetavariableNode;  ///
-
-        let context;
-
-        context = generalContext; ///
-
-        const metavariable = context.findMetavariableByMetavariableNode(metavariableNode);
-
-        context = specificContext;  ///
-
-        const frame = context.findFrameByFrameNode(frameNode),
-              frameUnifies = metavariable.unifyFrame(frame, generalContext, specificContext);
-
-        if (frameUnifies) {
-          success = true;
-        }
-
-        return success;
-      }
-    },
-    {
-      generalNodeQuery: termVariableNodeQuery,
-      specificNodeQuery: termNodeQuery,
-      run: (generalTermVariableNode, specificTermNode, generalContext, specificContext) => {
-        let success = false;
-
-        const termNode = specificTermNode, ///
-              variableNode = generalTermVariableNode; ///
-
-        let context;
-
-        context = generalContext; ///
-
-        const variable = context.findVariableByVariableNode(variableNode);
-
-        context = specificContext;  ///
-
-        const term = context.findTermByTermNode(termNode),
-              termUnifies = variable.unifyTerm(term, generalContext, specificContext);
-
-        if (termUnifies) {
-          success = true;
-        }
-
-        return success;
-      }
-    }
-  ];
-}
-
 class IntrinsicTermPass extends ZipPassBase {
   static maps = [
     {
@@ -463,7 +404,6 @@ const metaLevelPass = new MetaLevelPass(),
       combinatorPass = new CombinatorPass(),
       constructorPass = new ConstructorPass(),
       metavariablePass = new MetavariablePass(),
-      substitutionPass = new SubstitutionPass(),
       intrinsicTermPass = new IntrinsicTermPass(),
       intrinsicMetavariablePass = new IntrinsicMetavariablePass();
 
@@ -497,22 +437,6 @@ export function unifyMetavariable(generalMetavariable, specificMetavariable, gen
   return metavariableUnifies;
 }
 
-export function unifySubstitution(generalSubstitution, specificSubstitution, generalContext, specificContext) {
-  let substitutionUnifies = false;
-
-  const generalSubstitutionNode = generalSubstitution.getNode(),
-        specificSubstitutionNode = specificSubstitution.getNode(),
-        generalNode = generalSubstitutionNode, ///
-        specificNode = specificSubstitutionNode,  ///
-        success = substitutionPass.run(generalNode, specificNode, generalContext, specificContext);
-
-  if (success) {
-    substitutionUnifies = true;
-  }
-
-  return substitutionUnifies;
-}
-
 export function unifyTermWithConstructor(term, constructor, generalContext, specificContext) {
   let termUnifiesWithConstructor = false;
 

package/src/utilities/context.js

@@ -3,6 +3,7 @@
 import MenmicContext from "../context/mnemic";
 import NestedContext from "../context/nested";
 import TheticContext from "../context/thetic";
+import AphasicContext from "../context/aphasic";
 import BoundedContext from "../context/bounded";
 import NominalContext from "../context/nominal";
 import LiteralContext from "../context/literal";
@@ -10,6 +11,7 @@ import LiminalContext from "../context/liminal";
 import PhanericContext from "../context/phaneric";
 import SynopticContext from "../context/synoptic";
 import IllativeContext from "../context/illative";
+import EphemeralContext from "../context/ephemeral";
 import BranchingContext from "../context/branching";
 import NominalFileContext from "../context/file/nominal";
 
@@ -28,6 +30,14 @@ export function join(innerFunction, ...contexts) {
   return innerFunction(context);
 }
 
+export function posit(innerFunction, context) {
+  const ephemeralContext = EphemeralContext.fromNothing(context);
+
+  context = ephemeralContext;  ///
+
+  return innerFunction(context);
+}
+
 export function ground(innerFunction) {
   let context;
 
@@ -46,13 +56,7 @@ export function ablate(innerFunction, context) {
   const released = context.isReleased();
 
   if (!released) {
-    let contextExtraneousContext = isContextExtraneousContext(context);
-
-    while (contextExtraneousContext) {
-      context = context.getContext();
-
-      contextExtraneousContext = isContextExtraneousContext(context);
-    }
+    context = ablateContext(context);
   }
 
   return innerFunction(context);
@@ -131,6 +135,14 @@ export function reconcile(innerFunction, context) {
   return innerFunction(context);
 }
 
+export function sequester(innerFunction, context) {
+  const aphasicContext = AphasicContext.fromNothing(context);
+
+  context = aphasicContext;  ///
+
+  return innerFunction(context);
+}
+
 export function serialise(innerFunction, context) {
   const mnemicContext = context, ///
         mnemicContextJSON = mnemicContextToMnemicContextJSON(mnemicContext),
@@ -162,13 +174,7 @@ export function ablates(innerFunction, ...contexts) {
     const released = context.isReleased();
 
     if (!released) {
-      let contextExtraneousContext = isContextExtraneousContext(context);
-
-      while (contextExtraneousContext) {
-        context = context.getContext();
-
-        contextExtraneousContext = isContextExtraneousContext(context);
-      }
+      context = ablateContext(context);
     }
 
     return context;
@@ -216,10 +222,47 @@ export function evaluate(procedure, terms) {
   return procedure.call(terms, context);
 }
 
+function ablateContext(context) {
+  const stated = context.isStated();
+
+  let contextExtraneousContext = isContextExtraneousContext(context);
+
+  while (contextExtraneousContext) {
+    context = context.getContext();
+
+    contextExtraneousContext = isContextExtraneousContext(context);
+  }
+
+  const Context = stated ? TheticContext : IllativeContext;
+
+  context = augmentContext(context, Context);
+
+  return context;
+}
+
+function augmentContext(context, Context) {
+  const contextContext = (context instanceof Context);
+
+  if (!contextContext) {
+    context = Context.fromNothing(context);
+  }
+
+  return context;
+}
+
 function isContextExtraneousContext(context) {
-  const contextBoundedContext = (context instanceof BoundedContext),
-        contextNominalFileContext = (context instanceof NominalFileContext),
-        contextExtraneousContext = (!contextBoundedContext && !contextNominalFileContext);
+  const contextSubstantiveContext = isContextSubstantiveContext(context),
+        contextExtraneousContext = !contextSubstantiveContext;
 
   return contextExtraneousContext;
-}
+}
+
+function isContextSubstantiveContext(context) {
+  const contextTheticContext = (context instanceof TheticContext),
+        contextIllativeContext = (context instanceof IllativeContext),
+        contextBoundedContext = (context instanceof BoundedContext),
+        contextNominalFileContext = (context instanceof NominalFileContext),
+        contextSubstantiveContext = (contextTheticContext || contextIllativeContext || contextBoundedContext || contextNominalFileContext);
+
+  return contextSubstantiveContext;
+}