occam-verify-cli 1.0.847 → 1.0.849

package/src/element/substitution/statement.js

@@ -101,7 +101,7 @@ export default define(class StatementSubstitution extends Substitution {
     return comparesToSubstitution;
   }
 
-  validate(generalContext, specificContext) {
+  validate(substitution, generalContext, specificContext) {
     let statementSubstitution = null;
 
     const context = specificContext,  ///
@@ -120,28 +120,29 @@ export default define(class StatementSubstitution extends Substitution {
     } else {
       const context = this.getContext();
 
-      join((context) => {
-        attempt((context) => {
-          const specificContext = context,  ///
-                targetStatementValidates = this.validateTargetStatement(generalContext, specificContext);
+      join((generalContext) => {
+        join((specificContext) => {
+          attempt((generalContext, specificContext) => {
+            const targetStatementValidates = this.validateTargetStatement(generalContext, specificContext);
 
-          if (targetStatementValidates) {
-            const replacementStatementValidates = this.validateReplacementStatement(generalContext, specificContext);
+            if (targetStatementValidates) {
+              const replacementStatementValidates = this.validateReplacementStatement(generalContext, specificContext);
 
-            if (replacementStatementValidates) {
-              const substitutionValidates = this.validateSubstitution(generalContext, specificContext);
+              if (replacementStatementValidates) {
+                const substitutionValidates = this.validateSubstitution(substitution, generalContext, specificContext);
 
-              if (substitutionValidates) {
-                validates = true;
+                if (substitutionValidates) {
+                  validates = true;
+                }
               }
             }
-          }
 
-          if (validates) {
-            context.commit(this);
-          }
-        }, context);
-      }, specificContext, context);
+            if (validates) {
+              this.setContexts(generalContext, specificContext);
+            }
+          }, generalContext, specificContext);
+        }, specificContext, context);
+      }, generalContext, context);
     }
 
     if (validates) {
@@ -151,35 +152,25 @@ export default define(class StatementSubstitution extends Substitution {
 
       context.addSubstitution(substitution);
 
-      this.setGeneralContext(generalContext);
-
       context.debug(`...validated the '${statementSubstitutionString}' statement substitution.`);
     }
 
     return statementSubstitution;
   }
 
-  validateSubstitution(generalContext, specificContext) {
+  validateSubstitution(substitution, generalContext, specificContext) {
     let substitutionValidates = true;
 
-    if (this.substitution !== null) {
+    if (substitution !== null) {
       const context = generalContext,  ///
             substitutionString = this.substitution.getString(),
             statementSubstitutionString = this.getString();
 
       context.trace(`Validating the '${statementSubstitutionString}' statement substitution's '${substitutionString}' substitution...`);
 
-      descend((context) => {
-        const generalContext = context, ///
-              specificContext = context,  ///
-              substitution = this.substitution.validate(generalContext, specificContext);
-
-        if (substitution !== null) {
-          this.substitution = substitution;
+      this.substitution = substitution;
 
-          substitutionValidates = true;
-        }
-      }, context);
+      substitutionValidates = true;
 
       if (substitutionValidates) {
         context.debug(`...validatewd the '${statementSubstitutionString}' statement substitution's '${substitutionString}' substitution.`);
@@ -251,12 +242,10 @@ export default define(class StatementSubstitution extends Substitution {
 
     context.trace(`Unifying the '${simpleSubstitutionString}' simple substitution with the '${substitutionString}' substitution...`);
 
-    const generalSubstitution = this.substitution,  ///
-          specificSubstitution = simpleSubstitution,  ///
-          generalSubstitutionGeneralContext = generalSubstitution.getGeneralContext(),
-          generalSubstitutionSpecificContext = generalSubstitution.getSpecificContext(),
-          specificSubstitutionGeneralContext = specificSubstitution.getGeneralContext(),
-          specificSubstitutionSpecificContext = specificSubstitution.getSpecificContext();
+    const specificSubstitution = simpleSubstitution,  ///
+          generalSubstitution = this.substitution, ///
+          specificContexts = specificSubstitution.getContexts(),  ///
+          generalContexts = generalSubstitution.getContexts();
 
     join((specificContext) => {
       join((generalContext) => {
@@ -267,8 +256,8 @@ export default define(class StatementSubstitution extends Substitution {
             specificContext.commit(context);
           }
         }, specificContext)
-      }, generalSubstitutionSpecificContext, generalSubstitutionGeneralContext);
-    }, specificSubstitutionSpecificContext, specificSubstitutionGeneralContext, context);
+      }, ...generalContexts);
+    }, ...specificContexts, context);
 
     if (simpleSubstitutionUnifies) {
       context.trace(`...unified the '${simpleSubstitutionString}' simple substitution with the '${substitutionString}' substitution.`);
@@ -311,7 +300,7 @@ export default define(class StatementSubstitution extends Substitution {
     }, specificContext);
 
     if (substitution !== null) {
-      substitution = substitution.validate(generalContext, specificContext);
+      substitution = substitution.validate(generalContext, specificContext);  ///
 
       simpleSubstitutionUnifies = true;
     }
@@ -378,21 +367,21 @@ export default define(class StatementSubstitution extends Substitution {
   static name = "StatementSubstitution";
 
   toJSON() {
-    const context = this.getContext();
+    const contexts = this.getContexts();
 
-    return serialise((context) => {
+    return serialise((...contexts) => {
       const { name } = this.constructor,
             string = this.getString(),
             lineIndex = this.getLineIndex(),
             json = {
               name,
-              context,
+              contexts,
               string,
               lineIndex
             };
 
       return json;
-    }, context);
+    }, ...contexts);
   }
 
   static fromJSON(json, context) {
@@ -401,12 +390,13 @@ export default define(class StatementSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      unserialise((json, context) => {
+      unserialise((json, generalContext, specificContext) => {
+        const context = specificContext;  ///
+
         instantiate((context) => {
           const { string, lineIndex } = json,
                 statementSubstitutionNode = instantiateStatementSubstitution(string, context),
                 node = statementSubstitutionNode, ///
-                generalContext = generalContextFromStatementSubstitutionNode(statementSubstitutionNode, context),
                 resolved = resolvedFromStatementSubstitutionNode(statementSubstitutionNode, context),
                 substitution = substitutionFromStatementSubstitutionNode(statementSubstitutionNode, context),
                 targetStatement = targetStatementFromStatementSubstitutionNode(statementSubstitutionNode, context),
@@ -483,9 +473,3 @@ function substitutionFromStatementSubstitutionNode(statementSubstitutionNode, co
 
   return substitution;
 }
-
-function generalContextFromStatementSubstitutionNode(statementSubstitutionNode, context) {
-  const generalContext = context; ///
-
-  return generalContext;
-}

package/src/element/substitution/term.js

@@ -92,24 +92,25 @@ export default define(class TermSubstitution extends Substitution {
     } else {
       const context = this.getContext();
 
-      join((context) => {
-        attempt((context) => {
-          const specificContext = context,  ///
-                targetTermValidates = this.validateTargetTerm(generalContext, specificContext);
+      join((generalContext) => {
+        join((specificContext) => {
+          attempt((generalContext, specificContext) => {
+            const targetTermValidates = this.validateTargetTerm(generalContext, specificContext);
 
-          if (targetTermValidates) {
-            const replacementTermValidates = this.validateReplacementTerm(generalContext, specificContext);
+            if (targetTermValidates) {
+              const replacementTermValidates = this.validateReplacementTerm(generalContext, specificContext);
 
-            if (replacementTermValidates) {
-              validates = true;
+              if (replacementTermValidates) {
+                validates = true;
+              }
             }
-          }
 
-          if (validates) {
-            context.commit(this);
-          }
-        }, context);
-      }, specificContext, context);
+            if (validates) {
+              this.setContexts(generalContext, specificContext);
+            }
+          }, generalContext, specificContext);
+        }, specificContext, context);
+      }, generalContext, context);
     }
 
     if (validates) {
@@ -119,8 +120,6 @@ export default define(class TermSubstitution extends Substitution {
 
       context.addSubstitution(substitution);
 
-      this.setGeneralContext(generalContext);
-
       context.debug(`...validated the '${termSubstitutionString}' term substitution.`);
     }
 
@@ -196,21 +195,21 @@ export default define(class TermSubstitution extends Substitution {
   static name = "TermSubstitution";
 
   toJSON() {
-    const context = this.getContext();
+    const contexts = this.getContexts();
 
-    return serialise((context) => {
+    return serialise((...contexts) => {
       const { name } = this.constructor,
             string = this.getString(),
             lineIndex = this.getLineIndex(),
             json = {
               name,
-              context,
+              contexts,
               string,
               lineIndex
             };
 
       return json;
-    }, context);
+    }, ...contexts);
   }
 
   static fromJSON(json, context) {
@@ -219,12 +218,13 @@ export default define(class TermSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      unserialise((json, context) => {
+      unserialise((json, generalContext, specificContext) => {
+        const context = specificContext;  ///
+
         instantiate((context) => {
           const { string, lineIndex } = json,
                 termSubstitutionNode = instantiateTermSubstitution(string, context),
                 node = termSubstitutionNode,  ///
-                generalContext = generalContextFromTermSubstitutionNode(termSubstitutionNode, context),
                 targetTerm = targetTermFromTermSubstitutionNode(termSubstitutionNode, context),
                 replacementTerm = replacementTermFromTermSubstitutionNode(termSubstitutionNode, context);
 
@@ -282,9 +282,3 @@ function replacementTermFromTermSubstitutionNode(termSubstitutionNode, context)
 
   return replacementTerm;
 }
-
-function generalContextFromTermSubstitutionNode(termSubstitutionNode, context) {
-  const generalContext = context; ///
-
-  return generalContext;
-}

package/src/element/substitution.js

@@ -39,10 +39,34 @@ export default class Substitution extends Element {
     return specificContext;
   }
 
+  getContexts() {
+    const generalContext = this.getGeneralContext(),
+          specificContext = this.getSpecificContext(),
+          contexts = [
+            generalContext,
+            specificContext
+          ];
+
+    return contexts;
+  }
+
   setGeneralContext(generalContext) {
     this.generalContext = generalContext;
   }
 
+  setSpecificContext(specifiContext) {
+    const context = specifiContext; ///
+
+    this.setContext(context);
+  }
+
+  setContexts(...contexts) {
+    const [ generalContext, specificContext ] = contexts;
+
+    this.setGeneralContext(generalContext);
+    this.setSpecificContext(specificContext);
+  }
+
   isEqualTo(substitution) {
     const substitutionNode = substitution.getNode(),
           substitutionNodeMatches = this.matchSubstitutionNode(substitutionNode),

package/src/utilities/context.js

@@ -12,7 +12,7 @@ import EphemeralContext from "../context/ephemeral";
 import BranchingContext from "../context/branching";
 import NominalFileContext from "../context/file/nominal";
 
-import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
+import { ephemeralContextsFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
 
 export function join(innerFunction, ...contexts) {
   const synopticContext = SynopticContext.fromContexts(...contexts),
@@ -71,20 +71,24 @@ export function declare(innerFunction, context) {
   return innerFunction(context);
 }
 
-export function attempt(innerFunction, context) {
-  const ephemeralContext = EphemeralContext.fromNothing(context);
+export function descend(innerFunction, context) {
+  const nestedContext = NestedContext.fromNothing(context);
 
-  context = ephemeralContext;  ///
+  context = nestedContext;  ///
 
   return innerFunction(context);
 }
 
-export function descend(innerFunction, context) {
-  const nestedContext = NestedContext.fromNothing(context);
+export function attempt(innerFunction, ...contexts) {
+  contexts = contexts.map((context) => {  ///
+    const ephemeralContext = EphemeralContext.fromNothing(context);
 
-  context = nestedContext;  ///
+    context = ephemeralContext;  ///
 
-  return innerFunction(context);
+    return context;
+  })
+
+  return innerFunction(...contexts);
 }
 
 export function enclose(innerFunction, metaLevelAssumptions, context) {
@@ -115,22 +119,25 @@ export function reconcile(innerFunction, context) {
   return innerFunction(context);
 }
 
-export function serialise(innerFunction, context) {
-  const ephemeralContext = context, ///
-        ephemeralContextJSON = ephemeralContextToEphemeralContextJSON(ephemeralContext),
-        contextJSON = ephemeralContextJSON; ///
+export function serialise(innerFunction, ...contexts) {
+  contexts = contexts.map((context) => {  ///
+    const ephemeralContext = context, ///
+          ephemeralContextJSON = ephemeralContextToEphemeralContextJSON(ephemeralContext),
+          contextJSON = ephemeralContextJSON; ///
 
-  context = contextJSON;  ///
+    context = contextJSON;  ///
 
-  return innerFunction(context);
+    return context;
+  });
+
+  return innerFunction(...contexts);
 }
 
 export function unserialise(innerFunction, json, context) {
-  const ephemeralContext = ephemeralContextFromJSON(json, context);
-
-  context = ephemeralContext; ///
+  const ephemeralContexts = ephemeralContextsFromJSON(json, context),
+        contexts = ephemeralContexts; ///
 
-  return innerFunction(json, context);
+  return innerFunction(json, ...contexts);
 }
 
 export function instantiate(innerFunction, context) {

package/src/utilities/json.js

@@ -659,18 +659,27 @@ export function metavariablesFromJSON(json, context) {
   return metavariables;
 }
 
-export function ephemeralContextFromJSON(json, context) {
-  const releaseContext = context;
+export function ephemeralContextsFromJSON(json, context) {
+  const releaseContext = context; ///
 
-  ({context} = json);
+  const { contexts = [] } = json;
 
-  json = context; ///
+  ({ context = null } = json);
 
-  context = releaseContext; ///
+  if (context !== null) {
+    contexts.push(context);
+  }
+
+  const contextsJSON = contexts,  ///
+        ephemeralContexts = contextsJSON.map((contextJSON) => {
+          const json = contextJSON, ///
+                context = releaseContext, ///
+                emphemeralContext = EphemeralContext.fromJSON(json, context);
 
-  const emphemeralContext = EphemeralContext.fromJSON(json, context);
+          return emphemeralContext;  ///
+        });
 
-  return emphemeralContext;
+  return ephemeralContexts;
 }
 
 export function declaredVariablesFromJSON(json, context) {