occam-verify-cli 1.0.951 → 1.0.956

package/src/element/substitution/frame.js

@@ -7,7 +7,7 @@ import { breakPointFromJSON } from "../../utilities/breakPoint";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
 import { frameSubstitutionFromFrameSubstitutionNode } from "../../utilities/element";
 import { frameSubstitutionStringFromFrameAndMetavariable } 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 FrameSubstitution extends Substitution {
   constructor(contexts, string, node, breakPoint, targetFrame, replacementFrame) {
@@ -136,7 +136,7 @@ export default define(class FrameSubstitution extends Substitution {
 
     if (targetFrameSingular) {
       manifest((context) => {
-        descend((context) => {
+        sequester((context) => {
           const tragetFrame = this.targetFrame.validate(context);
 
           if (tragetFrame !== null) {
@@ -167,7 +167,7 @@ export default define(class FrameSubstitution extends Substitution {
 
     context.trace(`Validating the '${frameSubstitutionString}' frame substitution's replacement frame...`);
 
-    descend((context) => {
+    sequester((context) => {
       const replacementFrame = this.replacementFrame.validate(context);
 
       if (replacementFrame !== null) {
@@ -184,6 +184,127 @@ export default define(class FrameSubstitution extends Substitution {
     return replacementFrameValidates;
   }
 
+  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 replacementFrameUnifies = this.unifyReplacementFrame(substitution, context);
+
+      if (replacementFrameUnifies) {
+        const targetFrameUnifies = this.unifyTargetFrame(substitution, context);
+
+        if (targetFrameUnifies) {
+          context.commit();
+
+          substitutionUnifies = true;
+        }
+      }
+    }, context);
+
+    if (substitutionUnifies) {
+      context.debug(`...unified the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution.`);
+    }
+
+    return substitutionUnifies;
+  }
+
+  unifyTargetFrame(substitution, context) {
+    let targetFrameUnifies = false;
+
+    const generalSubstitution = this, ///
+          specificSubstitution = substitution,
+          generalSubstitutionString = generalSubstitution.getString(),
+          specificSubstitutionString = specificSubstitution.getString();
+
+    context.trace(`Unifying the '${specificSubstitutionString}' substitution's target frame with the '${generalSubstitutionString}' substitution's target frame...`);
+
+    const generalSubstitutionGeneralContext = generalSubstitution.getGeneralContext(),
+          specificSubstitutionGeneralContext = specificSubstitution.getGeneralContext(),
+          generalSubstitutionTargetFrame = generalSubstitution.getTargetFrame(),
+          specificSubstitutionTargetFrame = specificSubstitution.getTargetFrame(),
+          generalContext = generalSubstitutionGeneralContext,  ///
+          specificContext = specificSubstitutionGeneralContext,  ///
+          generalFrame = generalSubstitutionTargetFrame, ///
+          specificFrame = specificSubstitutionTargetFrame; ///
+
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        const generalFrameNode = generalFrame.getNode(),
+              generalMetavariable = metavariableFromFrameNode(generalFrameNode, generalContext);
+
+        if (generalMetavariable !== null) {
+          const frame = specificFrame,  ///
+                metavariable = generalMetavariable, ///
+                frameUnifies = metavariable.unifyFrame(frame, generalContext, specificContext);
+
+          if (frameUnifies) {
+            specificContext.commit(context);
+
+            targetFrameUnifies = true;
+          }
+        }
+      }, specificContext);
+    }, specificContext, context);
+
+    if (targetFrameUnifies) {
+      context.trace(`...unified the '${specificSubstitutionString}' substitution's target frame with the '${generalSubstitutionString}' substitution's target frame.`);
+    }
+
+    return targetFrameUnifies;
+  }
+
+  unifyReplacementFrame(substitution, context) {
+    let replacementFrameUnifies = false;
+
+    const generalSubstitution = this, ///
+          specificSubstitution = substitution,
+          generalSubstitutionString = generalSubstitution.getString(),
+          specificSubstitutionString = specificSubstitution.getString();
+
+    context.trace(`Unifying the '${specificSubstitutionString}' substitution's replacement frame with the '${generalSubstitutionString}' substitution's replacement frame...`);
+
+    const generalSubstitutionSpecificContext = generalSubstitution.getSpecificContext(),
+          specificSubstitutionSpecificContext = specificSubstitution.getSpecificContext(),
+          generalSubstitutionReplacementFrame = generalSubstitution.getReplacementFrame(),
+          specificSubstitutionReplacementFrame = specificSubstitution.getReplacementFrame(),
+          generalContext = generalSubstitutionSpecificContext,  ///
+          specificContext = specificSubstitutionSpecificContext,  ///
+          generalFrame = generalSubstitutionReplacementFrame, ///
+          specificFrame = specificSubstitutionReplacementFrame; ///
+
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        const generalFrameNode = generalFrame.getNode(),
+              generalMetavariable = metavariableFromFrameNode(generalFrameNode, generalContext);
+
+        if (generalMetavariable !== null) {
+          const frame = specificFrame,  ///
+                metavariable = generalMetavariable, ///
+                frameUnifies = metavariable.unifyFrame(frame, generalContext, specificContext);
+
+          if (frameUnifies) {
+            specificContext.commit(context);
+
+            replacementFrameUnifies = true;
+          }
+        }
+      }, specificContext);
+    }, specificContext, context);
+
+    if (replacementFrameUnifies) {
+      context.trace(`...unified the '${specificSubstitutionString}' substitution's replacement frame with the '${generalSubstitutionString}' substitution's replacement frame.`);
+    }
+
+    return replacementFrameUnifies;
+  }
+
   static name = "FrameSubstitution";
 
   static fromJSON(json, context) {
@@ -192,25 +313,29 @@ export default define(class FrameSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      unserialises((json, generalContext, specificContext) => {
-        const context = specificContext;  ///
-
-        instantiate((context) => {
-          const { string } = json,
-                frameSubstitutionNode = instantiateFrameSubstitution(string, context),
-                node = frameSubstitutionNode, ///
-                breakPoint = breakPointFromJSON(json),
-                targetFrame = targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context),
-                replacementFrame = replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, context),
-                specificContext = context,  ///
-                contexts = [
-                  generalContext,
-                  specificContext
-                ];
-
-          frameSubstitutionn = new FrameSubstitution(contexts, string, node, breakPoint, targetFrame, replacementFrame);
-        }, context);
-      }, json, context);
+      const forced = true;
+
+      ablate((context) => {
+        unserialises((json, generalContext, specificContext) => {
+          const context = specificContext;  ///
+
+          instantiate((context) => {
+            const { string } = json,
+                  frameSubstitutionNode = instantiateFrameSubstitution(string, context),
+                  node = frameSubstitutionNode, ///
+                  breakPoint = breakPointFromJSON(json),
+                  targetFrame = targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context),
+                  replacementFrame = replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, context),
+                  specificContext = context,  ///
+                  contexts = [
+                    generalContext,
+                    specificContext
+                  ];
+
+            frameSubstitutionn = new FrameSubstitution(contexts, string, node, breakPoint, targetFrame, replacementFrame);
+          }, context);
+        }, json, context);
+      }, forced, context);
     }
 
     return frameSubstitutionn;
@@ -253,6 +378,18 @@ export default define(class FrameSubstitution extends Substitution {
   }
 });
 
+function metavariableFromFrameNode(frameNode, context) {
+  let metavariable = null;
+
+  const metavariableNode = frameNode.getMetavariableNode();
+
+  if (metavariableNode !== null) {
+    metavariable = context.findMetavariableByMetavariableNode(metavariableNode);
+  }
+
+  return metavariable;
+}
+
 function targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
   const targetFrameNode = frameSubstitutionNode.getTargetFrameNode(),
         targetFrame = context.findFrameByFrameNode(targetFrameNode);

package/src/element/substitution/reference.js

@@ -7,7 +7,7 @@ import { breakPointFromJSON } from "../../utilities/breakPoint";
 import { instantiateReferenceSubstitution } from "../../process/instantiate";
 import { referenceSubstitutionFromReferenceSubstitutionNode } from "../../utilities/element";
 import { referenceSubstitutionStringFromReferenceAndMetavariable } from "../../utilities/string";
-import { ablates, manifest, attempts, descend, instantiate, unserialises } from "../../utilities/context";
+import { ablates, manifest, attempts, sequester, instantiate, unserialises } from "../../utilities/context";
 
 export default define(class ReferenceSubstitution extends Substitution {
   constructor(context, string, node, breakPoint, targetReference, replacementReference) {
@@ -150,7 +150,7 @@ export default define(class ReferenceSubstitution extends Substitution {
     context.trace(`Validating the '${referenceSubstitutionString}' reference substitution's target reference...`);
 
     manifest((context) => {
-      descend((context) => {
+      sequester((context) => {
         const targetReference = this.targetReference.validate(context);
 
         if (targetReference !== null) {
@@ -174,7 +174,7 @@ export default define(class ReferenceSubstitution extends Substitution {
 
     context.trace(`Validating the '${referenceSubstitutionString}' reference substitution's replacement reference...`);
 
-    descend((context) => {
+    sequester((context) => {
       const replacementReference = this.replacementReference.validate(context);
 
       if (replacementReference !== null) {

package/src/element/substitution/statement.js

@@ -3,12 +3,11 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { unifySubstitution } from "../../process/unify";
-import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { breakPointFromJSON } from "../../utilities/breakPoint";
+import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { instantiateStatementSubstitution } from "../../process/instantiate";
 import { statementSubstitutionFromStatementSubstitutionNode } from "../../utilities/element";
-import { join, ablates, manifest, attempts, descend, reconcile, instantiate, unserialises } from "../../utilities/context";
+import { join, ablates, manifest, attempts, sequester, reconcile, instantiate, unserialises } from "../../utilities/context";
 import { statementSubstitutionStringFromStatementAndMetavariable, statementSubstitutionStringFromStatementMetavariableAndSubstitution } from "../../utilities/string";
 
 export default define(class StatementSubstitution extends Substitution {
@@ -174,7 +173,7 @@ export default define(class StatementSubstitution extends Substitution {
 
     if (targetStatementSingular) {
       manifest((context) => {
-        descend((context) => {
+        sequester((context) => {
           const targetStatement = this.targetStatement.validate(context);
 
           if (targetStatement !== null) {
@@ -203,7 +202,7 @@ export default define(class StatementSubstitution extends Substitution {
 
     context.trace(`Validating the '${statementSubstitutionString}' statement substitution's replacement statement...`);
 
-    descend((context) => {
+    sequester((context) => {
       const replacementStatement = this.replacementStatement.validate(context);
 
       if (replacementStatement !== null) {
@@ -218,132 +217,134 @@ export default define(class StatementSubstitution extends Substitution {
     return replacementStatementValidates;
   }
 
-  unifySimpleSubstitution(simpleSubstitution, context) {
-    let simpleSubstitutionUnifies;
+  unifyTargetStatement(substitution, context) {
+    let targetStatemnentUnifies = false;
 
-    const substitutionString = this.substitution.getString(),
-          simpleSubstitutionString = simpleSubstitution.getString();
+    const generalSubstitution = this, ///
+          specificSubstitution = substitution,
+          generalSubstitutionString = generalSubstitution.getString(),
+          specificSubstitutionString = specificSubstitution.getString();
 
-    context.trace(`Unifying the '${simpleSubstitutionString}' simple substitution with the '${substitutionString}' substitution...`);
+    context.trace(`Unifying the '${specificSubstitutionString}' substitution's target statement with the '${generalSubstitutionString}' substitution's target statement...`);
 
-    const specificSubstitution = simpleSubstitution,  ///
-          generalSubstitution = this.substitution, ///
-          specificContexts = specificSubstitution.getContexts(),  ///
-          generalContexts = generalSubstitution.getContexts();
+    const generalSubstitutionGeneralContext = generalSubstitution.getGeneralContext(),
+          specificSubstitutionGeneralContext = specificSubstitution.getGeneralContext(),
+          generalSubstitutionTargetStatement = generalSubstitution.getTargetStatement(),
+          specificSubstitutionTargetStatement = specificSubstitution.getTargetStatement(),
+          generalContext = generalSubstitutionGeneralContext,  ///
+          specificContext = specificSubstitutionGeneralContext,  ///
+          generalStatement = generalSubstitutionTargetStatement, ///
+          specificStatement = specificSubstitutionTargetStatement; ///
 
     join((specificContext) => {
-      join((generalContext) => {
-        reconcile((specificContext) => {
-          simpleSubstitutionUnifies = unifySubstitution(generalSubstitution, specificSubstitution, generalContext, specificContext);
+      reconcile((specificContext) => {
+        const statementUnifies = generalStatement.unifyStatement(specificStatement, generalContext, specificContext);
 
-          if (simpleSubstitutionUnifies) {
-            specificContext.commit(context);
-          }
-        }, specificContext)
-      }, ...generalContexts);
-    }, ...specificContexts, context);
+        if (statementUnifies) {
+          specificContext.commit(context);
 
-    if (simpleSubstitutionUnifies) {
-      context.trace(`...unified the '${simpleSubstitutionString}' simple substitution with the '${substitutionString}' substitution.`);
+          targetStatemnentUnifies = true;
+        }
+      }, specificContext);
+    }, specificContext, context);
+
+    if (targetStatemnentUnifies) {
+      context.trace(`...unified the '${specificSubstitutionString}' substitution's target statement with the '${generalSubstitutionString}' substitution's target statement.`);
     }
 
-    return simpleSubstitutionUnifies;
+    return targetStatemnentUnifies;
   }
 
-  unifyComplexSubstitution(complexSubstitution, context) {
-    let substitution = null;
-
-    const simpleSubstitutionString = this.getString(),  ///
-          complexSubstitutionString = complexSubstitution.getString();  ///
-
-    context.trace(`Unifying the '${complexSubstitutionString}' complex substitution with the '${simpleSubstitutionString}' simple substitution...`);
+  unifyReplacementStatement(substitution, context) {
+    let replacementStatemnentUnifies = false;
 
-    const simpleSubstitution = this,  ///
-          simpleSubstitutionGSpecificContext = simpleSubstitution.getSpecificContext(),
-          complexSubstitutionGSpecificContext = complexSubstitution.getSpecificContext(),
-          generalContext = simpleSubstitutionGSpecificContext,  ///
-          specificContext = complexSubstitutionGSpecificContext;  ///
+    const generalSubstitution = this, ///
+          specificSubstitution = substitution,
+          generalSubstitutionString = generalSubstitution.getString(),
+          specificSubstitutionString = specificSubstitution.getString();
 
-    let simpleSubstitutionUnifies = false;
+    context.trace(`Unifying the '${specificSubstitutionString}' substitution's replacement statement with the '${generalSubstitutionString}' substitution's replacement statement...`);
 
-    join((context) => {
-      const specificContext = context;  ///
+    const generalSubstitutionSpecificContext = generalSubstitution.getSpecificContext(),
+          specificSubstitutionSpecificContext = specificSubstitution.getSpecificContext(),
+          generalSubstitutionReplacementStatement = generalSubstitution.getReplacementStatement(),
+          specificSubstitutionReplacementStatement = specificSubstitution.getReplacementStatement(),
+          generalContext = generalSubstitutionSpecificContext,  ///
+          specificContext = specificSubstitutionSpecificContext,  ///
+          generalStatement = generalSubstitutionReplacementStatement, ///
+          specificStatement = specificSubstitutionReplacementStatement; ///
 
+    join((specificContext) => {
       reconcile((specificContext) => {
-        const replacementStatement = complexSubstitution.getReplacementStatement(),
-              replacementStatementUnifies = this.unifyReplacementStatement(replacementStatement, generalContext, specificContext);
+        const statementUnifies = generalStatement.unifyStatement(specificStatement, generalContext, specificContext);
 
-        if (replacementStatementUnifies) {
-          const context = specificContext,  ///
-                soleNonTrivialDerivedSubstitution = context.getSoleNonTrivialDerivedSubstitution();
+        if (statementUnifies) {
+          specificContext.commit(context);
 
-          substitution = soleNonTrivialDerivedSubstitution;  ///
+          replacementStatemnentUnifies = true;
         }
       }, specificContext);
     }, specificContext, context);
 
-    if (substitution !== null) {
-      substitution = substitution.validate(context);  ///
-
-      simpleSubstitutionUnifies = true;
-    }
-
-    if (simpleSubstitutionUnifies) {
-      context.debug(`...unified the '${complexSubstitutionString}' complex substitution with the '${simpleSubstitutionString}' simple substitution.`);
+    if (replacementStatemnentUnifies) {
+      context.trace(`...unified the '${specificSubstitutionString}' substitution's replacement statement with the '${generalSubstitutionString}' substitution's replacement statement.`);
     }
 
-    return substitution;
+    return replacementStatemnentUnifies;
   }
 
-  unifyReplacementStatement(replacementStatement, generalContext, specificContext) {
-    let replacementStatemnentUnifies = false;
+  unifyComplexSubstitution(complexSubstitution, context) {
+    let substitution = null;
 
-    const context = specificContext,  ///
-          replacementStatementString = replacementStatement.getString(),
-          substitutionReplacementStatementString = this.replacementStatement.getString();  ///
+    const simpleSubstitution = this,  ///
+          simpleSubstitutionString = simpleSubstitution.getString(),  ///
+          complexSubstitutionString = complexSubstitution.getString();  ///
+
+    context.trace(`Unifying the '${complexSubstitutionString}' complex substitution with the '${simpleSubstitutionString}' simple substitution...`);
+
+    let simpleSubstitutionUnifies = false;
 
-    context.trace(`Unifying the '${replacementStatementString}' replacement statement with the '${substitutionReplacementStatementString}' replacement statement...`);
+    reconcile((context) => {
+      const replacementStatementUnifies = this.unifyReplacementStatement(complexSubstitution, context);
 
-    const statementUnifies = this.replacementStatement.unifyStatement(replacementStatement, generalContext, specificContext);
+      if (replacementStatementUnifies) {
+        const soleNonTrivialDerivedSubstitution = context.getSoleNonTrivialDerivedSubstitution();
 
-    if (statementUnifies) {
-      replacementStatemnentUnifies = true;
+        substitution = soleNonTrivialDerivedSubstitution;  ///
+      }
+    }, context);
+
+    if (substitution !== null) {
+      simpleSubstitutionUnifies = true;
     }
 
-    if (replacementStatemnentUnifies) {
-      context.debug(`...unified the '${replacementStatementString}' replacement statement with the '${substitutionReplacementStatementString}' replacement statement.`);
+    if (simpleSubstitutionUnifies) {
+      context.debug(`...unified the '${complexSubstitutionString}' complex substitution with the '${simpleSubstitutionString}' simple substitution.`);
     }
 
-    return replacementStatemnentUnifies;
+    return substitution;
   }
 
   resolve(context) {
-    let resolved = false;
-
     const metavariableNode = this.getMetavariableNode(),
-          simpleDerivedSubstitution = context.findSimpleDerivedSubstitutionByMetavariableNode(metavariableNode), ///
-          complexSubstitution = this,
-          simpleSubstitution = simpleDerivedSubstitution; ///
+          simpleDerivedSubstitution = context.findSimpleDerivedSubstitutionByMetavariableNode(metavariableNode);
 
-    if (simpleSubstitution !== null) {
-      const substitutionString = this.getString(); ///
+    if (simpleDerivedSubstitution !== null) {
+      const simpleSubstitution = simpleDerivedSubstitution, ///
+            complexSubstitution = this, ///
+            complexSubstitutionString = complexSubstitution.getString();
 
-      context.trace(`Resolving the ${substitutionString} substitution...`);
+      context.trace(`Resolving the ${complexSubstitutionString}' complex substitution...`);
 
       const substitution = simpleSubstitution.unifyComplexSubstitution(complexSubstitution, context);
 
       if (substitution !== null) {
-        const simpleSubstitution = substitution,  ///
-              simpleSubstitutionUnifies = complexSubstitution.unifySimpleSubstitution(simpleSubstitution, context);
+        const simpleSubstitutionUnifies = this.substitution.unifySubstitution(substitution, context);
 
         if (simpleSubstitutionUnifies) {
-          resolved = true;
-        }
-
-        if (resolved) {
           this.resolved = true;
 
-          context.debug(`...resolved the '${substitutionString}' substitution.`);
+          context.debug(`...resolved the '${complexSubstitutionString}' complex substitution.`);
         }
       }
     }