occam-verify-cli 1.0.768 → 1.0.776

package/src/element/proofAssertion/premise.js

@@ -5,8 +5,7 @@ import ProofAssertion from "../proofAssertion";
 import { define } from "../../elements";
 import { instantiatePremise } from "../../process/instantiate";
 import { procedureCallFromPremiseNode } from "../../utilities/element";
-import { join, attempt, reconcile, instantiate } from "../../utilities/context";
-import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../../utilities/json";
+import { join, declare, attempt, reconcile, serialise, unserialise, instantiate } from "../../utilities/context";
 
 export default define(class Premise extends ProofAssertion {
   constructor(context, string, node, statement, procedureCall) {
@@ -26,12 +25,6 @@ export default define(class Premise extends ProofAssertion {
     return premiseNode;
   }
 
-  isStated() {
-    const stated = true; ///
-
-    return stated;
-  }
-
   async verify(context) {
     let verifies = false;
 
@@ -64,29 +57,31 @@ export default define(class Premise extends ProofAssertion {
 
     context.trace(`Validatting the '${premiseString}' premise...`);
 
-    attempt((context) => {
-      const statement = this.getStatement(),
-            procedureCall = this.getProcedureCall();
+    declare((context) => {
+      attempt((context) => {
+        const statement = this.getStatement(),
+              procedureCall = this.getProcedureCall();
 
-      if (statement !== null) {
-        const statementValidates = this.validateStatement(context);
+        if (statement !== null) {
+          const statementValidates = this.validateStatement(context);
 
-        if (statementValidates) {
-          context.commit(this);
+          if (statementValidates) {
+            context.commit(this);
 
-          validates = true;
+            validates = true;
+          }
         }
-      }
 
-      if (procedureCall !== null) {
-        const procedureCallValidates = this.validateProcedureCall(context);
+        if (procedureCall !== null) {
+          const procedureCallValidates = this.validateProcedureCall(context);
 
-        if (procedureCallValidates) {
-          context.commit(this);
+          if (procedureCallValidates) {
+            context.commit(this);
 
-          validates = true;
+            validates = true;
+          }
         }
-      }
+      }, context);
     }, context);
 
     if (validates) {
@@ -96,6 +91,30 @@ export default define(class Premise extends ProofAssertion {
     return validates;
   }
 
+  validateStatement(context) {
+    let statementValidates = false;
+
+    const premiseString = this.getString();
+
+    context.trace(`Validating the '${premiseString}' premise's statsement... `);
+
+    let statement;
+
+    statement = this.getStatement();
+
+    statement = statement.validate(context);  ///
+
+    if (statement !== null) {
+      statementValidates = true;
+    }
+
+    if (statementValidates) {
+      context.debug(`...validated the '${premiseString}' premise's statement. `);
+    }
+
+    return statementValidates;
+  }
+
   validateProcedureCall(context) {
     let procedureCallValidates = false;
 
@@ -266,42 +285,37 @@ export default define(class Premise extends ProofAssertion {
   }
 
   toJSON() {
-    let context;
-
-    context = this.getContext();
-
-    const ephemeralContext = context, ///
-          ephemeralContextJSON = ephemeralContextToEphemeralContextJSON(ephemeralContext),
-          contextJSON = ephemeralContextJSON; ///
+    const context = this.getContext();
 
-    context = contextJSON;  ///
+    return serialise((context) => {
+      const string = this.getString(),
+            json = {
+              context,
+              string
+            };
 
-    const string = this.getString(),
-          json = {
-            context,
-            string
-          };
-
-    return json;
+      return json;
+    }, context);
   }
 
   static name = "Premise";
 
   static fromJSON(json, context) {
-    const ephemeralContext = ephemeralContextFromJSON(json, context);
+    let premise;
 
-    context = ephemeralContext; ///
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string } = json,
+              premiseNode = instantiatePremise(string, context),
+              node = premiseNode,  ///
+              statement = statementFromPremiseNode(premiseNode, context),
+              procedureCall = procedureCallFromPremiseNode(premiseNode, context);
 
-    return instantiate((context) => {
-      const { string } = json,
-            premiseNode = instantiatePremise(string, context),
-            node = premiseNode,  ///
-            statement = statementFromPremiseNode(premiseNode, context),
-            procedureCall = procedureCallFromPremiseNode(premiseNode, context),
-            premise = new Premise(context, string, node, statement, procedureCall);
+        premise = new Premise(context, string, node, statement, procedureCall);
+      }, context);
+    }, json, context);
 
-      return premise;
-    }, context);
+    return premise;
   }
 });
 

package/src/element/proofAssertion/step.js

@@ -6,8 +6,8 @@ import ProofAssertion from "../proofAssertion";
 
 import { define } from "../../elements";
 import { unifyStatements } from "../../utilities/unification";
-import { attempt, asyncReconcile } from "../../utilities/context";
 import { propertyAssertionFromStatement } from "../../utilities/statement";
+import { derive, attempt, descend, asyncReconcile } from "../../utilities/context";
 
 const { asyncSome } = asynchronousUtilities;
 
@@ -46,13 +46,6 @@ export default define(class Step extends ProofAssertion {
     return qualified;
   }
 
-  isStated() {
-    const qualified = this.isQualified(),
-          stated = qualified; ///
-
-    return stated;
-  }
-
   compareTermAndPropertyRelation(term, propertyRelation, context) {
     let comparesToTermAndPropertyRelation = false;
 
@@ -107,22 +100,24 @@ export default define(class Step extends ProofAssertion {
 
     context.trace(`Validating the '${stepString}' step...`);
 
-    attempt((context) => {
-      const statementValidates = this.validateStatement(context);
+    derive((context) => {
+      attempt((context) => {
+        const statementValidates = this.validateStatement(context);
 
-      if (statementValidates) {
-        const referenceValidates = this.validateReference(context);
+        if (statementValidates) {
+          const referenceValidates = this.validateReference(context);
 
-        if (referenceValidates) {
-          const satisfiesAssertioValidates = this.validateSatisfiesAssertion(context);
+          if (referenceValidates) {
+            const satisfiesAssertioValidates = this.validateSatisfiesAssertion(context);
 
-          if (satisfiesAssertioValidates) {
-            context.commit(this);
+            if (satisfiesAssertioValidates) {
+              context.commit(this);
 
-            validates = true;
+              validates = true;
+            }
           }
         }
-      }
+      }, context);
     }, context);
 
     if (validates) {
@@ -155,6 +150,30 @@ export default define(class Step extends ProofAssertion {
     return referenceValidates;
   }
 
+  validateStatement(context) {
+    let statementValidates = false;
+
+    const stepString = this.getString();
+
+    context.trace(`Validating the '${stepString}' step's statement... `);
+
+    let statement;
+
+    statement = this.getStatement();
+
+    statement = statement.validate(context);  ///
+
+    if (statement !== null) {
+      statementValidates = true;
+    }
+
+    if (statementValidates) {
+      context.debug(`...validated the '${stepString}' step statement. `);
+    }
+
+    return statementValidates;
+  }
+
   validateSatisfiesAssertion(context) {
     let satisfiesAssertionValidates = true;  ///
 
@@ -164,12 +183,13 @@ export default define(class Step extends ProofAssertion {
 
       context.trace(`Validating the '${stepString}' step's '${satisfiesAssertionString}' satisfies assertion... `);
 
-      const stated = true,
-            satisfiesAssertion = this.satisfiesAssertion.validate(stated, context);
+      descend((context) => {
+        const satisfiesAssertion = this.satisfiesAssertion.validate(context);
 
-      if (satisfiesAssertion === null) {
-        satisfiesAssertionValidates = false;
-      }
+        if (satisfiesAssertion === null) {
+          satisfiesAssertionValidates = false;
+        }
+      }, context);
 
       if (satisfiesAssertionValidates) {
         context.debug(`...validating the '${stepString}' step's '${satisfiesAssertionString}' satisfies assertion. `);

package/src/element/proofAssertion/supposition.js

@@ -5,8 +5,7 @@ import ProofAssertion from "../proofAssertion";
 import { define } from "../../elements";
 import { instantiateSupposition} from "../../process/instantiate";
 import { procedureCallFromSuppositionNode } from "../../utilities/element";
-import { join, attempt, reconcile, instantiate } from "../../utilities/context";
-import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../../utilities/json";
+import { join, declare, attempt, reconcile, serialise, unserialise, instantiate } from "../../utilities/context";
 
 export default define(class Supposition extends ProofAssertion {
   constructor(context, string, node, statement, procedureCall) {
@@ -26,12 +25,6 @@ export default define(class Supposition extends ProofAssertion {
     return suppositionNode;
   }
 
-  isStated() {
-    const stated = true; ///
-
-    return stated;
-  }
-
   async verify(context) {
     let verifies = false;
 
@@ -64,29 +57,31 @@ export default define(class Supposition extends ProofAssertion {
 
     context.trace(`Validatting the '${suppositionString}' supposition...`);
 
-    attempt((context) => {
-      const statement = this.getStatement(),
-            procedureCall = this.getProcedureCall();
-
-      if (statement !== null) {
-        const statementValidates = this.validateStatement(context);
+    declare((context) => {
+      attempt((context) => {
+        const statement = this.getStatement(),
+              procedureCall = this.getProcedureCall();
 
-        if (statementValidates) {
-          context.commit(this);
+        if (statement !== null) {
+          const statementValidates = this.validateStatement(context);
 
-          validates = true;
+          if (statementValidates) {
+            validates = true;
+          }
         }
-      }
 
-      if (procedureCall !== null) {
-        const procedureCallValidates = this.validateProcedureCall(context);
+        if (procedureCall !== null) {
+          const procedureCallValidates = this.validateProcedureCall(context);
 
-        if (procedureCallValidates) {
-          context.commit(this);
+          if (procedureCallValidates) {
+            validates = true;
+          }
+        }
 
-          validates = true;
+        if (validates) {
+          context.commit(this);
         }
-      }
+      }, context);
     }, context);
 
     if (validates) {
@@ -96,6 +91,30 @@ export default define(class Supposition extends ProofAssertion {
     return validates;
   }
 
+  validateStatement(context) {
+    let statementValidates = false;
+
+    const suppositionString = this.getString();
+
+    context.trace(`Validating the '${suppositionString}' supposition's statement... `);
+
+    let statement;
+
+    statement = this.getStatement();
+
+    statement = statement.validate(context);  ///
+
+    if (statement !== null) {
+      statementValidates = true;
+    }
+
+    if (statementValidates) {
+      context.debug(`...validated the '${suppositionString}' supposition statement. `);
+    }
+
+    return statementValidates;
+  }
+
   validateProcedureCall(context) {
     let procedureCallValidates = false;
 
@@ -288,42 +307,37 @@ export default define(class Supposition extends ProofAssertion {
   }
 
   toJSON() {
-    let context;
-
-    context = this.getContext();
-
-    const ephemeralContext = context, ///
-          ephemeralContextJSON = ephemeralContextToEphemeralContextJSON(ephemeralContext),
-          contextJSON = ephemeralContextJSON; ///
+    const context = this.getContext();
 
-    context = contextJSON;  ///
+    return serialise((context) => {
+      const string = this.getString(),
+            json = {
+              context,
+              string
+            };
 
-    const string = this.getString(),
-          json = {
-            context,
-            string
-          };
-
-    return json;
+      return json;
+    }, context);
   }
 
   static name = "Supposition";
 
   static fromJSON(json, context) {
-    const ephemeralContext = ephemeralContextFromJSON(json, context);
+    let supposition;
 
-    context = ephemeralContext; ///
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string } = json,
+              suppositionNode = instantiateSupposition(string, context),
+              node = suppositionNode,  ///
+              statement = statementFromSuppositionNode(suppositionNode, context),
+              procedureCall = procedureCallFromSuppositionNode(suppositionNode, context);
 
-    return instantiate((context) => {
-      const { string } = json,
-            suppositionNode = instantiateSupposition(string, context),
-            node = suppositionNode,  ///
-            statement = statementFromSuppositionNode(suppositionNode, context),
-            procedureCall = procedureCallFromSuppositionNode(suppositionNode, context),
-            supposition = new Supposition(context, string, node, statement, procedureCall);
+        supposition = new Supposition(context, string, node, statement, procedureCall);
+      }, context);
+    }, json, context);
 
-      return supposition;
-    }, context);
+    return supposition;
   }
 });
 

package/src/element/proofAssertion.js

@@ -51,28 +51,6 @@ export default class ProofAssertion extends Element {
     return comparesToStatement;
   }
 
-  validateStatement(context) {
-    let statementValidates = false;
-
-    const statementString = this.statement.getString(),
-          proofAssertionString = this.getString();  ///
-
-    context.trace(`Validating the '${proofAssertionString}' proof assertion's '${statementString}' statement... `);
-
-    const stated = this.isStated(),
-          statement = this.statement.validate(stated, context);
-
-    if (statement !== null) {
-      statementValidates = true;
-    }
-
-    if (statementValidates) {
-      context.debug(`...validated the '${proofAssertionString}' proof assertion's '${statementString}' statement. `);
-    }
-
-    return statementValidates;
-  }
-
   unifyStatement(statement, generalContext, specificContext) {
     let statementUnifies = false;