occam-verify-cli 1.0.955 → 1.0.972

package/src/element/signature.js

@@ -4,9 +4,10 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
+import { instantiateSignature } from "../process/instantiate";
 import { signatureFromSignatureNode } from "../utilities/element";
 import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-import { join, posit, ablate, attempt, reconcile, serialise, unserialise, instantiate } from "../utilities/context";
+import { ablate, attempt, reconcile, serialise, unserialise, instantiate } from "../utilities/context";
 
 const { match } = arrayUtilities;
 
@@ -72,16 +73,18 @@ export default define(class Signature extends Element {
 
     context.trace(`Verifying the '${signatureString}' signature...`);
 
-    attempt((context) => {
-      const termsValidate = this.validateTerms(context);
+    ablate((context) => {
+      attempt((context) => {
+        const termsValidate = this.validateTerms(context);
 
-      if (termsValidate !== null) {
-        verifies = true;
-      }
+        if (termsValidate !== null) {
+          verifies = true;
+        }
 
-      if (verifies) {
-        this.commit(context);
-      }
+        if (verifies) {
+          this.commit(context);
+        }
+      }, context);
     }, context);
 
     if (verifies) {
@@ -109,7 +112,7 @@ export default define(class Signature extends Element {
 
       context.debug(`...the '${signatureString}' signature is already valid.`);
     } else {
-      const specificContext = context;  ///
+      const temporaryContext = context; ///
 
       context = this.getContext();
 
@@ -125,7 +128,7 @@ export default define(class Signature extends Element {
         }
       }, context);
 
-      context = specificContext;  ///
+      context = temporaryContext; ///
 
       if (validates) {
         signature = this; ///
@@ -175,11 +178,10 @@ export default define(class Signature extends Element {
     return termsValidate
   }
 
-  unifySignature(signature, generalContext, specificContext) {
+  unifySignature(signature, context) {
     let signatureUnifies;
 
-    const context = specificContext,  ///
-          generalSignature = this,
+    const generalSignature = this,
           specificSignature = signature,  ///
           generalSignatureString = generalSignature.getString(),
           specificSignatureString = specificSignature.getString();
@@ -192,35 +194,24 @@ export default define(class Signature extends Element {
           specificSignatureContext = specificSignature.getContext(),
           generalTerms = generalSignatureTerms,  ///
           specificTerms = specificSignatureTerms, ///
-          generalContexts = [
-            generalSignatureContext,
-            generalContext
-          ],
-          specificContexts = [
-            specificSignatureContext,
-            specificContext
-          ];
-
-    join((generalContext) => {
-      join((specificContext) => {
-        signatureUnifies = match(generalTerms, specificTerms, (generalTerm, specificTerm) => {
-          let termUnifies;
-
-          reconcile((specificContext) => {
-            termUnifies = generalTerm.unifyTerm(specificTerm, generalContext, specificContext);
-
-            if (termUnifies) {
-              specificContext.commit();
-            }
-          }, specificContext);
-
-          if (termUnifies) {
-            return true;
-          }
-        });
-      }, ...specificContexts);
-    }, ...generalContexts);
+          generalContext = generalSignatureContext, ///
+          specificContext = specificSignatureContext;  ///
 
+    reconcile((specificContext) => {
+      signatureUnifies = match(generalTerms, specificTerms, (generalTerm, specificTerm) => {
+        let termUnifies;
+
+        termUnifies = generalTerm.unifyTerm(specificTerm, generalContext, specificContext);
+
+        if (termUnifies) {
+          return true;
+        }
+      });
+
+      if (signatureUnifies) {
+        specificContext.commit(context);
+      }
+    }, specificContext);
 
     if (signatureUnifies) {
       context.debug(`...unified the '${specificSignatureString}' signature with the '${generalSignatureString}' signature.`);
@@ -258,8 +249,8 @@ export default define(class Signature extends Element {
   static fromJSON(json, context) {
     let signature;
 
-    unserialise((json, context) => {
-      instantiate((context) => {
+    instantiate((context) => {
+      unserialise((json, context) => {
         const { string } = json,
               signatureNode = instantiateSignature(string, context),
               node = signatureNode,  ///
@@ -267,8 +258,8 @@ export default define(class Signature extends Element {
               terms = termsFromSignatureNode(signatureNode, context);
 
         signature = new Signature(context, string, node, breakPoint, terms);
-      }, context);
-    }, json, context);
+      }, json, context);
+    }, context);
 
     return signature;
   }
@@ -276,14 +267,12 @@ export default define(class Signature extends Element {
   static fromSignatureString(signatureString, context) {
     let signature;
 
-    posit((context) => {
-      ablate((context) => {
-        instantiate((context) => {
-          const string = signatureString,  ///
-                signatureNode = instantiateSignature(string, context);
+    ablate((context) => {
+      instantiate((context) => {
+        const string = signatureString,  ///
+              signatureNode = instantiateSignature(string, context);
 
-          signature = signatureFromSignatureNode(signatureNode, context);
-        }, context);
+        signature = signatureFromSignatureNode(signatureNode, context);
       }, context);
     }, context);
 

package/src/element/statement.js

@@ -3,9 +3,10 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
+import { instantiate } from "../utilities/context";
 import { unifyStatement } from "../process/unify";
-import { validateStatements } from "../utilities/validation";
-import { reconcile, instantiate } from "../utilities/context";
+import { validateStatements } from "../process/validation";
+import { dischargeStatements } from "../process/discharge";
 import { instantiateStatement } from "../process/instantiate";
 import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
 
@@ -125,7 +126,7 @@ export default define(class Statement extends Element {
     return comparesToParamter;
   }
 
-  findValidStatment(context) {
+  findValidStatement(context) {
     const statementNode = this.getStatementNode(),
           statement = context.findStatementByStatementNode(statementNode),
           validStatement = statement;  ///
@@ -194,7 +195,7 @@ export default define(class Statement extends Element {
 
     let validates;
 
-    const validStatement = this.findValidStatment(context);
+    const validStatement = this.findValidStatement(context);
 
     if (validStatement !== null) {
       validates = true;
@@ -226,56 +227,27 @@ export default define(class Statement extends Element {
     return statement;
   }
 
-  unifySubproof(subproof, generalContext, specificContext) {
-    let subproofUnifies = false;
+  discharge(context) {
+    let discharges;
 
-    const statementNode = this.getStatementNode(),
-          subproofAssertionNode = statementNode.getSubproofAssertionNode();
-
-    if (subproofAssertionNode !== null) {
-      const context = generalContext, ///
-            subproofString = subproof.getString(),
-            statementString = this.getString(); ///
-
-      context.trace(`Unifying the '${subproofString}' subproof with the '${statementString}' statement...`);
-
-      const subproofAssertion = context.findAssertionByAssertionNode(subproofAssertionNode);
-
-      subproofUnifies = subproofAssertion.unifySubproof(subproof, generalContext, specificContext);
-
-      if (subproofUnifies) {
-        context.debug(`...unified the '${subproofString}' subproof with the '${statementString}' statement.`);
-      }
-    }
-
-    return subproofUnifies;
-  }
-
-  unifyDeduction(deduction, generalContext, specificContext) {
-    let deductionUnifies = false;
-
-    const context = generalContext, ///
-          statementString = this.getString(),  ///
-          deductionString = deduction.getString(),
-          deductionStatement = deduction.getStatement();
-
-    context.trace(`Unifying the '${deductionString}' deduction with the '${statementString}' statement...`);
+    const statementString = this.getString();  ///
 
-    reconcile((specificContext) => {
-      const deductionStatementUnifies = this.unifyStatement(deductionStatement, generalContext, specificContext);
+    context.trace(`Dicharging the '${statementString}' statement...`);
 
-      if (deductionStatementUnifies) {
-        specificContext.commit(context);
+    discharges = dischargeStatements.some((dischargeStatement) => {
+      const statement = this, ///
+            statementDischarged = dischargeStatement(statement, context);
 
-        deductionUnifies = true;
+      if (statementDischarged) {
+        return true;
       }
-    }, specificContext);
+    });
 
-    if (deductionUnifies) {
-      context.debug(`...unified the '${deductionString}' deduction with the '${statementString}' statement.`);
+    if (discharges) {
+      context.debug(`...discharged the '${statementString}' statement.`);
     }
 
-    return deductionUnifies;
+    return discharges;
   }
 
   unifyStatement(statement, generalContext, specificContext) {
@@ -348,49 +320,6 @@ export default define(class Statement extends Element {
     return unifiesIndependently;
   }
 
-  unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
-    let topLevelAssertionUnifies = false;
-
-    const statementString = this.getString(), ///
-          topLevelMetaAssertionString = topLevelMetaAssertion.getString();
-
-    context.trace(`Unifying the '${topLevelMetaAssertionString}' top level meta-assertion with the '${statementString}' statement...`);
-
-    const unconditional = topLevelMetaAssertion.isUnconditional();
-
-    if (unconditional) {
-      const deduction = topLevelMetaAssertion.getDeduction(),
-            generalContext = context; ///
-
-      context = deduction.getContext();
-
-      const specificContext = context;  ///
-
-      context = generalContext; ///
-
-      const deductionUnifies = this.unifyDeduction(deduction, generalContext, specificContext);
-
-      if (deductionUnifies) {
-        topLevelAssertionUnifies = true;
-      }
-    } else {
-      const statementNode = this.getStatementNode(),
-            subproofAssertionNode = statementNode.getSubproofAssertionNode();
-
-      if (subproofAssertionNode !== null) {
-        const subproofAssertion = context.findAssertionByAssertionNode(subproofAssertionNode);
-
-        topLevelAssertionUnifies = subproofAssertion.unifyTopLevelMetaAssertion(topLevelMetaAssertion, context);
-      }
-    }
-
-    if (topLevelAssertionUnifies) {
-      context.debug(`...unified the '${topLevelMetaAssertionString}' top level meta-assertion with the '${statementString}' statement.`);
-    }
-
-    return topLevelAssertionUnifies;
-  }
-
   static name = "Statement";
 
   toJSON() {

package/src/element/substitution/frame.js

@@ -3,12 +3,11 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { join, reconcile } from "../../utilities/context";
 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, sequester, instantiate, unserialises } from "../../utilities/context";
+import { elide, ablate, ablates, manifest, attempts, reconcile, instantiate, unserialises } from "../../utilities/context";
 
 export default define(class FrameSubstitution extends Substitution {
   constructor(contexts, string, node, breakPoint, targetFrame, replacementFrame) {
@@ -137,7 +136,7 @@ export default define(class FrameSubstitution extends Substitution {
 
     if (targetFrameSingular) {
       manifest((context) => {
-        sequester((context) => {
+        elide((context) => {
           const tragetFrame = this.targetFrame.validate(context);
 
           if (tragetFrame !== null) {
@@ -168,7 +167,7 @@ export default define(class FrameSubstitution extends Substitution {
 
     context.trace(`Validating the '${frameSubstitutionString}' frame substitution's replacement frame...`);
 
-    sequester((context) => {
+    elide((context) => {
       const replacementFrame = this.replacementFrame.validate(context);
 
       if (replacementFrame !== null) {
@@ -235,24 +234,21 @@ export default define(class FrameSubstitution extends Substitution {
           generalFrame = generalSubstitutionTargetFrame, ///
           specificFrame = specificSubstitutionTargetFrame; ///
 
-    join((specificContext) => {
-      reconcile((specificContext) => {
-        const generalFrameNode = generalFrame.getNode(),
-              generalMetavariable = metavariableFromFrameNode(generalFrameNode, generalContext);
+    reconcile((specificContext) => {
+      const frameNode = generalFrame.getFrameNode(),
+            metavariable = metavariableFromFrameNode(frameNode, generalContext);
 
-        if (generalMetavariable !== null) {
-          const frame = specificFrame,  ///
-                metavariable = generalMetavariable, ///
-                frameUnifies = metavariable.unifyFrame(frame, generalContext, specificContext);
+      if (metavariable !== null) {
+        const frame = specificFrame,  ///
+              frameUnifies = metavariable.unifyFrame(frame, generalContext, specificContext);
 
-          if (frameUnifies) {
-            specificContext.commit(context);
+        if (frameUnifies) {
+          specificContext.commit(context);
 
-            targetFrameUnifies = true;
-          }
+          targetFrameUnifies = true;
         }
-      }, specificContext);
-    }, specificContext, context);
+      }
+    }, specificContext);
 
     if (targetFrameUnifies) {
       context.trace(`...unified the '${specificSubstitutionString}' substitution's target frame with the '${generalSubstitutionString}' substitution's target frame.`);
@@ -280,24 +276,21 @@ export default define(class FrameSubstitution extends Substitution {
           generalFrame = generalSubstitutionReplacementFrame, ///
           specificFrame = specificSubstitutionReplacementFrame; ///
 
-    join((specificContext) => {
-      reconcile((specificContext) => {
-        const generalFrameNode = generalFrame.getNode(),
-              generalMetavariable = metavariableFromFrameNode(generalFrameNode, generalContext);
+    reconcile((specificContext) => {
+      const frameNode = generalFrame.getNode(),
+            metavariable = metavariableFromFrameNode(frameNode, generalContext);
 
-        if (generalMetavariable !== null) {
-          const frame = specificFrame,  ///
-                metavariable = generalMetavariable, ///
-                frameUnifies = metavariable.unifyFrame(frame, generalContext, specificContext);
+      if (metavariable !== null) {
+        const frame = specificFrame,  ///
+              frameUnifies = metavariable.unifyFrame(frame, generalContext, specificContext);
 
-          if (frameUnifies) {
-            specificContext.commit(context);
+        if (frameUnifies) {
+          specificContext.commit(context);
 
-            replacementFrameUnifies = true;
-          }
+          replacementFrameUnifies = true;
         }
-      }, specificContext);
-    }, specificContext, context);
+      }
+    }, specificContext);
 
     if (replacementFrameUnifies) {
       context.trace(`...unified the '${specificSubstitutionString}' substitution's replacement frame with the '${generalSubstitutionString}' substitution's replacement frame.`);
@@ -314,25 +307,22 @@ export default define(class FrameSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      unserialises((json, generalContext, specificContext) => {
-        const context = specificContext;  ///
-
-        instantiate((context) => {
+      instantiate((context) => {
+        unserialises((json, generalContext, specificContext) => {
           const { string } = json,
                 frameSubstitutionNode = instantiateFrameSubstitution(string, context),
                 node = frameSubstitutionNode, ///
                 breakPoint = breakPointFromJSON(json),
-                targetFrame = targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context),
-                replacementFrame = replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, context),
-                specificContext = context,  ///
+                targetFrame = targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, generalContext),
+                replacementFrame = replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, specificContext),
                 contexts = [
                   generalContext,
                   specificContext
                 ];
 
           frameSubstitutionn = new FrameSubstitution(contexts, string, node, breakPoint, targetFrame, replacementFrame);
-        }, context);
-      }, json, context);
+        }, json, context);
+      }, context);
     }
 
     return frameSubstitutionn;
@@ -375,28 +365,28 @@ export default define(class FrameSubstitution extends Substitution {
   }
 });
 
-function metavariableFromFrameNode(frameNode, context) {
+function metavariableFromFrameNode(frameNode, generalContext) {
   let metavariable = null;
 
   const metavariableNode = frameNode.getMetavariableNode();
 
   if (metavariableNode !== null) {
-    metavariable = context.findMetavariableByMetavariableNode(metavariableNode);
+    metavariable = generalContext.findMetavariableByMetavariableNode(metavariableNode);
   }
 
   return metavariable;
 }
 
-function targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
+function targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, generalContext) {
   const targetFrameNode = frameSubstitutionNode.getTargetFrameNode(),
-        targetFrame = context.findFrameByFrameNode(targetFrameNode);
+        targetFrame = generalContext.findFrameByFrameNode(targetFrameNode);
 
   return targetFrame;
 }
 
-function replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
+function replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, specificContext) {
   const replacementFrameNode = frameSubstitutionNode.getReplacementFrameNode(),
-        replacementFrame = context.findFrameByFrameNode(replacementFrameNode);
+        replacementFrame = specificContext.findFrameByFrameNode(replacementFrameNode);
 
   return replacementFrame;
 }

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, sequester, instantiate, unserialises } from "../../utilities/context";
+import { elide, ablates, manifest, attempts, 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) => {
-      sequester((context) => {
+      elide((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...`);
 
-    sequester((context) => {
+    elide((context) => {
       const replacementReference = this.replacementReference.validate(context);
 
       if (replacementReference !== null) {
@@ -197,25 +197,22 @@ export default define(class ReferenceSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      unserialises((json, generalContext, specificContext) => {
-        const context = specificContext;  ///
-
-        instantiate((context) => {
+      instantiate((context) => {
+        unserialises((json, generalContext, specificContext) => {
           const { string } = json,
                 referenceSubstitutionNode = instantiateReferenceSubstitution(string, context),
                 node = referenceSubstitutionNode, ///
                 breakPoint = breakPointFromJSON(json),
-                targetReference = targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
-                replacementReference = replacementReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
-                specificContext = context,  ///
+                targetReference = targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, generalContext),
+                replacementReference = replacementReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, specificContext),
                 contexts = [
                   generalContext,
                   specificContext
                 ];
 
           referenceSubstitutionn = new ReferenceSubstitution(contexts, string, node, breakPoint, targetReference, replacementReference);
-        }, context);
-      }, json, context);
+        }, json, context);
+      }, context);
     }
 
     return referenceSubstitutionn;
@@ -262,16 +259,16 @@ export default define(class ReferenceSubstitution extends Substitution {
   }
 });
 
-function targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
+function targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, generalContext) {
   const targetReferenceNode = referenceSubstitutionNode.getTargetReferenceNode(),
-        targetReference = context.findReferenceByReferenceNode(targetReferenceNode);
+        targetReference = generalContext.findReferenceByReferenceNode(targetReferenceNode);
 
   return targetReference;
 }
 
-function replacementReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context) {
+function replacementReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, specificContext) {
   const replacementReferenceNode = referenceSubstitutionNode.getReplacementReferenceNode(),
-        replacementReference = context.findReferenceByReferenceNode(replacementReferenceNode);
+        replacementReference = specificContext.findReferenceByReferenceNode(replacementReferenceNode);
 
   return replacementReference;
 }