occam-verify-cli 1.0.764 → 1.0.776

package/src/element/label.js

@@ -4,9 +4,8 @@ import { Element } from "occam-languages";
 
 import { define } from "../elements";
 import { instantiateLabel } from "../process/instantiate";
-import { attempt, instantiate } from "../utilities/context";
 import { metavariableFromLabelNode } from "../utilities/element";
-import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
+import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Label extends Element {
   constructor(context, string, node, metavariable) {
@@ -38,10 +37,6 @@ export default define(class Label extends Element {
     return labelNodeMatches;
   }
 
-  compareMetavariable(metavariable) { return this.metavariable.compare(metavariable); }
-
-  compareMetavariableName(metavariableName) { return this.metavariable.compareMetavariableName(metavariableName); }
-
   compareReference(reference) {
     const metavariable = reference.getMetavariable(),
           metavariableComparesToMetavariable = this.compareMetavariable(metavariable),
@@ -50,6 +45,10 @@ export default define(class Label extends Element {
     return comparesToReference;
   }
 
+  compareMetavariable(metavariable) { return this.metavariable.compare(metavariable); }
+
+  compareMetavariableName(metavariableName) { return this.metavariable.compareMetavariableName(metavariableName); }
+
   verify() {
     let verifies = false;
 
@@ -127,40 +126,35 @@ export default define(class Label extends Element {
   }
 
   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 = "Label";
 
   static fromJSON(json, context) {
-    const ephemeralContext = ephemeralContextFromJSON(json, context);
+    let label;
 
-    context = ephemeralContext; ///
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string } = json,
+              labelNode = instantiateLabel(string, context),
+              node = labelNode, ///
+              metavariable = metavariableFromLabelNode(labelNode, context);
 
-    return instantiate((context) => {
-      const { string } = json,
-            labelNode = instantiateLabel(string, context),
-            node = labelNode, ///
-            metavariable = metavariableFromLabelNode(labelNode, context),
-            label = new Label(context, string, node, metavariable);
+        label = new Label(context, string, node, metavariable);
+      }, context);
+    }, json, context);
 
-      return label;
-    }, context);
+    return label;
   }
 });

package/src/element/metavariable.js

@@ -486,11 +486,11 @@ export default define(class Metavariable extends Element {
         if (frameSingular) {
           const frameMetavariableName = frame.getMetavariableName(),
                 frameMetavariable = context.findMetavariableByMetavariableName(frameMetavariableName),
-                generalMetavariable = this, ///
-                specificMetavariable = frameMetavariable, ///
-                metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
+                frameMetavariableUnifiesIntrinsically = this.unifyMetavariableIntrinsically(frameMetavariable, generalContext, specificContext);
 
-          frameMetavariableUnifies = metavariableUnifiesIntrinsically; ///
+          if (frameMetavariableUnifiesIntrinsically) {
+            frameMetavariableUnifies = true;
+          }
         }
       }
     }
@@ -522,11 +522,11 @@ export default define(class Metavariable extends Element {
         referenceMetavariableUnifies = true;
       } else {
         const referenceMetavariable = reference.getMetavariable(),
-              generalMetavariable = this, ///
-              specificMetavariable = referenceMetavariable, ///
-              metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
+              referenceMetavariableUnifiesIntrinsically = this.unifyMetavariableIntrinsically(referenceMetavariable, generalContext, specificContext);
 
-        referenceMetavariableUnifies = metavariableUnifiesIntrinsically; ///
+        if (referenceMetavariableUnifiesIntrinsically) {
+          referenceMetavariableUnifies = true;
+        }
       }
     }
 
@@ -561,11 +561,11 @@ export default define(class Metavariable extends Element {
         if (statementSingular) {
           const statementMetavariableName = statement.getMetavariableName(),
                 statementMetavariable = context.findMetavariableByMetavariableName(statementMetavariableName),
-                generalMetavariable = this, ///
-                specificMetavariable = statementMetavariable, ///
-                metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
+                statementMetavariableUnifiesIntrinsically = this.unifyMetavariableIntrinsically(statementMetavariable, generalContext, specificContext);
 
-          statementMetavariableUnifies = metavariableUnifiesIntrinsically; ///
+          if (statementMetavariableUnifiesIntrinsically) {
+            statementMetavariableUnifies = true;
+          }
         }
       }
     }
@@ -577,6 +577,26 @@ export default define(class Metavariable extends Element {
     return statementMetavariableUnifies;
   }
 
+  unifyMetavariableIntrinsically(metavariable, generalContext, specificContext) {
+    let metavariableUnifiesIntrinsically;
+
+    const context = specificContext,  ///
+          generalMetavariable = this, ///
+          specificMetavariable = metavariable,
+          generalMetavariableString = generalMetavariable.getString(),  ///
+          specificMetavariableString = specificMetavariable.getString();
+
+    context.trace(`Unifying the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable intrinsically...`);
+
+    metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
+
+    if (metavariableUnifiesIntrinsically) {
+      context.debug(`...unified the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable intrinsically.`);
+    }
+
+    return metavariableUnifiesIntrinsically;
+  }
+
   toJSON() {
     const metaTypeJSON = metaTypeToMetaTypeJSON(this.metaType),
           metaType = metaTypeJSON,  ///

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;