occam-verify-cli 1.0.768 → 1.0.776

package/src/element/substitution/metaLevel.js

@@ -4,10 +4,9 @@ import Substitution from "../substitution";
 
 import { define } from "../../elements";
 import { instantiateMetaLevelSubstitution } from "../../process/instantiate";
-import { instantiate, sanitisedContextFromContext } from "../../utilities/context";
 import { metaLevelSubstitutionFromMetaLevelSubstitutionNode } from "../../utilities/element";
 import { metaLevelSubstitutionStringFromStatementAndReference } from "../../utilities/string";
-import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../../utilities/json";
+import { descend, simplify, serialise, unserialise, instantiate } from "../../utilities/context";
 
 export default define(class MetaLevelSubstitution extends Substitution {
   constructor(context, string, node, targetReference, replacementStatement) {
@@ -132,12 +131,13 @@ export default define(class MetaLevelSubstitution extends Substitution {
 
     context.trace(`Validating the '${metaLevelSubstitutionString}' meta-level substitution's '${replacementStatementString}' replacement statement...`);
 
-    const stated = true,
-      replacementStatement = this.replacementStatement.validate(stated, context);
+    descend((context) => {
+      const replacementStatement = this.replacementStatement.validate(context);
 
-    if (replacementStatement !== null) {
-      replacementStatementValidates = true;
-    }
+      if (replacementStatement !== null) {
+        replacementStatementValidates = true;
+      }
+    }, context);
 
     if (replacementStatementValidates) {
       context.debug(`...validated the '${metaLevelSubstitutionString}' meta-level substitution's '${replacementStatementString}' replacement statement.`);
@@ -147,57 +147,53 @@ export default define(class MetaLevelSubstitution extends Substitution {
   }
 
   toJSON() {
-    let context;
-
-    context = this.getContext();
-
-    const ephemeralContext = context, ///
-          ephemeralContextJSON = ephemeralContextToEphemeralContextJSON(ephemeralContext),
-          contextJSON = ephemeralContextJSON; ///
-
-    context = contextJSON;  ///
+    const context = this.getContext();
 
-    const string = this.getString(),
-          json = {
-            context,
-            string
-          };
+    return serialise((context) => {
+      const string = this.getString(),
+            json = {
+              context,
+              string
+            };
 
-    return json;
+      return json;
+    }, context);
   }
 
   static name = "MetaLevelSubstitution";
 
   static fromJSON(json, context) {
-    const ephemeralContext = ephemeralContextFromJSON(json, context);
+    let metaLevelSubstitution;
 
-    context = ephemeralContext; ///
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string } = json,
+              metaLevelSubstitutionNode = instantiateMetaLevelSubstitution(string, context),
+              node = metaLevelSubstitutionNode, ///
+              targetReference = targetReferenceFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context),
+              replacementStatement = replacementStatementFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context);
 
-    return instantiate((context) => {
-      const { string } = json,
-            metaLevelSubstitutionNode = instantiateMetaLevelSubstitution(string, context),
-            node = metaLevelSubstitutionNode, ///
-            targetReference = targetReferenceFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context),
-            replacementStatement = replacementStatementFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context),
-            metaLevelSubstitution = new MetaLevelSubstitution(context, string, node, targetReference, replacementStatement);
+        metaLevelSubstitution = new MetaLevelSubstitution(context, string, node, targetReference, replacementStatement);
+      }, context);
+    }, json, context);
 
-      return metaLevelSubstitution;
-    }, context);
+    return metaLevelSubstitution;
   }
 
   static fromStatementAndReference(statement, reference, context) {
-    const santisedContext = sanitisedContextFromContext(context);
+    let metaLevelSubstitution;
 
-    context = santisedContext;  ///
+    simplify((context) => {
+      instantiate((context) => {
+        const metaLevelSubstitutionString = metaLevelSubstitutionStringFromStatementAndReference(statement, reference),
+              string = metaLevelSubstitutionString,  ///
+              metaLevelSubstitutionNode = instantiateMetaLevelSubstitution(string, context);
 
-    return instantiate((context) => {
-      const metaLevelSubstitutionString = metaLevelSubstitutionStringFromStatementAndReference(statement, reference),
-            string = metaLevelSubstitutionString,  ///
-            metaLevelSubstitutionNode = instantiateMetaLevelSubstitution(string, context),
-            metaLevelSubstitution = metaLevelSubstitutionFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context);
-
-      return metaLevelSubstitution;
+        metaLevelSubstitution = metaLevelSubstitutionFromMetaLevelSubstitutionNode(metaLevelSubstitutionNode, context);
+      }, context);
     }, context);
+
+    return metaLevelSubstitution;
   }
 });
 

package/src/element/substitution/reference.js

@@ -3,8 +3,8 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
+import { simplify, instantiate } from "../../utilities/context";
 import { instantiateReferenceSubstitution } from "../../process/instantiate";
-import { instantiate, sanitisedContextFromContext } from "../../utilities/context";
 import { referenceSubstitutionFromReferenceSubstitutionNode } from "../../utilities/element";
 import { referenceSubstitutionStringFromReferenceAndMetavariable } from "../../utilities/string";
 
@@ -163,7 +163,7 @@ export default define(class ReferenceSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      referenceSubstitutionn = instantiate((context) => {
+      instantiate((context) => {
         const { string } = json,
               referenceSubstitutionNode = instantiateReferenceSubstitution(string, context),
               node = referenceSubstitutionNode,  ///
@@ -172,9 +172,7 @@ export default define(class ReferenceSubstitution extends Substitution {
 
         context = null;
 
-        const referenceSubstitutionn = new ReferenceSubstitution(context, string, node, targetReference, replacementReference);
-
-        return referenceSubstitutionn;
+        referenceSubstitutionn = new ReferenceSubstitution(context, string, node, targetReference, replacementReference);
       }, context);
     }
 
@@ -182,18 +180,19 @@ export default define(class ReferenceSubstitution extends Substitution {
   }
 
   static fromReferenceAndMetavariable(reference, metavariable, context) {
-    const santisedContext = sanitisedContextFromContext(context);
-
-    context = santisedContext;  ///
+    let referenceSubstitution;
 
-    return instantiate((context) => {
-      const referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
-            string = referenceSubstitutionString,  ///
-            referenceSubstitutionNode = instantiateReferenceSubstitution(string, context),
-            referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
+    simplify((context) => {
+      instantiate((context) => {
+        const referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
+              string = referenceSubstitutionString,  ///
+              referenceSubstitutionNode = instantiateReferenceSubstitution(string, context);
 
-      return referenceSubstitution;
+        referenceSubstitution = referenceSubstitutionFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
+      }, context);
     }, context);
+
+    return referenceSubstitution;
   }
 });
 

package/src/element/substitution/statement.js

@@ -6,8 +6,8 @@ import { define } from "../../elements";
 import { unifySubstitution } from "../../process/unify";
 import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { instantiateStatementSubstitution } from "../../process/instantiate";
+import { join, simplify, descend, reconcile, instantiate } from "../../utilities/context";
 import { statementSubstitutionFromStatementSubstitutionNode } from "../../utilities/element";
-import { join, reconcile, instantiate, sanitisedContextFromContext } from "../../utilities/context";
 import { statementSubstitutionStringFromStatementAndMetavariable, statementSubstitutionStringFromStatementMetavariableAndSubstitution } from "../../utilities/string";
 
 export default define(class StatementSubstitution extends Substitution {
@@ -158,12 +158,13 @@ export default define(class StatementSubstitution extends Substitution {
     const targetStatementSingular = this.targetStatement.isSingular();
 
     if (targetStatementSingular) {
-      const stated = true,
-            targetStatement = this.targetStatement.validate(stated, context);
+      descend((context) => {
+        const targetStatement = this.targetStatement.validate(context);
 
-      if (targetStatement !== null) {
-        targetStatementValidates = true;
-      }
+        if (targetStatement !== null) {
+          targetStatementValidates = true;
+        }
+      }, context);
     } else {
       context.debug(`The '${statementSubstitutionString}' statement substitution's '${targetStatementString}' target statement is not singular.`);
     }
@@ -184,12 +185,13 @@ export default define(class StatementSubstitution extends Substitution {
 
     context.trace(`Validating the '${statementSubstitutionString}' statement substitution's '${replacementStatementString}' replacement statement...`);
 
-    const stated = true,
-          replacementStatement = this.replacementStatement.validate(stated, context);
+    descend((context) => {
+      const replacementStatement = this.replacementStatement.validate(context);
 
-    if (replacementStatement !== null) {
-      replacementStatementValidates = true;
-    }
+      if (replacementStatement !== null) {
+        replacementStatementValidates = true;
+      }
+    }, context);
 
     if (replacementStatementValidates) {
       context.debug(`...validated the '${statementSubstitutionString}' statement substitution's '${replacementStatementString}' replacement statement.`);
@@ -344,7 +346,7 @@ export default define(class StatementSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      statementSubstitutionn = instantiate((context) => {
+      instantiate((context) => {
         const { string } = json,
               statementSubstitutionNode = instantiateStatementSubstitution(string, context),
               node = statementSubstitutionNode,  ///
@@ -353,9 +355,7 @@ export default define(class StatementSubstitution extends Substitution {
 
         context = null;
 
-        const statementSubstitutionn = new StatementSubstitution(context, string, node, targetStatement, replacementStatement);
-
-        return statementSubstitutionn;
+        statementSubstitutionn = new StatementSubstitution(context, string, node, targetStatement, replacementStatement);
       }, context);
     }
 
@@ -365,35 +365,37 @@ export default define(class StatementSubstitution extends Substitution {
   static fromStatementAndMetavariable(statement, metavariable, context) {
     statement = stripBracketsFromStatement(statement, context); ///
 
-    const santisedContext = sanitisedContextFromContext(context);
-
-    context = santisedContext;  ///
+    let statementSubstitution;
 
-    return instantiate((context) => {
-      const statementSubstitutionString = statementSubstitutionStringFromStatementAndMetavariable(statement, metavariable, context),
-            string = statementSubstitutionString, ///
-            statementSubstitutionNode = instantiateStatementSubstitution(string, context),
-            statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
+    simplify((context) => {
+      instantiate((context) => {
+        const statementSubstitutionString = statementSubstitutionStringFromStatementAndMetavariable(statement, metavariable, context),
+              string = statementSubstitutionString, ///
+              statementSubstitutionNode = instantiateStatementSubstitution(string, context);
 
-      return statementSubstitution;
+        statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
+      }, context);
     }, context);
+
+    return statementSubstitution;
   }
 
   static fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) {
     statement = stripBracketsFromStatement(statement, context); ///
 
-    const santisedContext = sanitisedContextFromContext(context);
-
-    context = santisedContext;  ///
+    let statementSubstitution;
 
-    return instantiate((context) => {
-      const statementSubstitutionString = statementSubstitutionStringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution),
-            string = statementSubstitutionString, ///
-            statementSubstitutionNode = instantiateStatementSubstitution(string, context),
-            statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
+    simplify((context) => {
+      instantiate((context) => {
+        const statementSubstitutionString = statementSubstitutionStringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution),
+              string = statementSubstitutionString, ///
+              statementSubstitutionNode = instantiateStatementSubstitution(string, context);
 
-      return statementSubstitution;
+        statementSubstitution = statementSubstitutionFromStatementSubstitutionNode(statementSubstitutionNode, context);
+      }, context);
     }, context);
+
+    return statementSubstitution;
   }
 });
 

package/src/element/substitution/term.js

@@ -3,9 +3,9 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
+import { simplify, instantiate } from "../../utilities/context";
 import { stripBracketsFromTerm } from "../../utilities/brackets";
 import { instantiateTermSubstitution } from "../../process/instantiate";
-import { instantiate, sanitisedContextFromContext } from "../../utilities/context";
 import { termSubstitutionStringFromTermAndVariable } from "../../utilities/string";
 import { termSubstitutionFromStatementNode, termSubstitutionFromTermSubstitutionNode } from "../../utilities/element";
 
@@ -184,7 +184,7 @@ export default define(class TermSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      termSubstitutionn = instantiate((context) => {
+      instantiate((context) => {
         const { string } = json,
               termSubstitutionNode = instantiateTermSubstitution(string, context),
               node = termSubstitutionNode,  ///
@@ -193,9 +193,7 @@ export default define(class TermSubstitution extends Substitution {
 
         context = null;
 
-        const termSubstitutionn = new TermSubstitution(context, string, node, targetTerm, replacementTerm);
-
-        return termSubstitutionn;
+        termSubstitutionn = new TermSubstitution(context, string, node, targetTerm, replacementTerm);
       }, context);
     }
 
@@ -212,18 +210,19 @@ export default define(class TermSubstitution extends Substitution {
   static fromTermAndVariable(term, variable, context) {
     term = stripBracketsFromTerm(term, context); ///
 
-    const santisedContext = sanitisedContextFromContext(context);
-
-    context = santisedContext;  ///
+    let termSubstitution;
 
-    return instantiate((context) => {
-      const termSubstitutionString = termSubstitutionStringFromTermAndVariable(term, variable),
-            string = termSubstitutionString,  ///
-            termSubstitutionNode = instantiateTermSubstitution(string, context),
-            termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, context);
+    simplify((context) => {
+      instantiate((context) => {
+        const termSubstitutionString = termSubstitutionStringFromTermAndVariable(term, variable),
+              string = termSubstitutionString,  ///
+              termSubstitutionNode = instantiateTermSubstitution(string, context);
 
-      return termSubstitution;
+        termSubstitution = termSubstitutionFromTermSubstitutionNode(termSubstitutionNode, context);
+      }, context);
     }, context);
+
+    return termSubstitution;
   }
 });
 

package/src/element/term.js

@@ -41,40 +41,6 @@ export default define(class Term extends Element {
     return variableIdentifier;
   }
 
-  matchTermNode(termNode) {
-    const node = termNode, ///
-          nodeMatches = this.matchNode(node),
-          termNodeMatches = nodeMatches; ///
-
-    return termNodeMatches;
-  }
-
-  compareVariableIdentifier(variableIdentifier) {
-    let comparesToVariableIdentifier = false;
-
-    const singular = this.isSingular();
-
-    if (singular) {
-      const variableIdentifierA = variableIdentifier; ///
-
-      variableIdentifier = this.getVariableIdentifier();
-
-      const variableIdentifierB = variableIdentifier;
-
-      comparesToVariableIdentifier = (variableIdentifierA === variableIdentifierB);
-    }
-
-    return comparesToVariableIdentifier;
-  }
-
-  findValidTerm(context) {
-    const termNode = this.getTermNode(),
-          term = context.findTermByTermNode(termNode),
-          validTerm = term; ///
-
-    return validTerm;
-  }
-
   isEqualTo(term) {
     const termNode = term.getNode(),
           termNodeMatches = this.matchTermNode(termNode),
@@ -127,6 +93,22 @@ export default define(class Term extends Element {
     return implicitlyGrounded;
   }
 
+  matchTermNode(termNode) {
+    const node = termNode, ///
+          nodeMatches = this.matchNode(node),
+          termNodeMatches = nodeMatches; ///
+
+    return termNodeMatches;
+  }
+
+  compareTerm(term) {
+    const termNode = term.getNode(),
+          termNodeMatches = this.matchNode(termNode),
+          comparesTo = termNodeMatches; ///
+
+    return comparesTo;
+  }
+
   compareParameter(parameter) {
     let comparesToParamter = false;
 
@@ -147,6 +129,32 @@ export default define(class Term extends Element {
     return comparesToParamter;
   }
 
+  compareVariableIdentifier(variableIdentifier) {
+    let comparesToVariableIdentifier = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      const variableIdentifierA = variableIdentifier; ///
+
+      variableIdentifier = this.getVariableIdentifier();
+
+      const variableIdentifierB = variableIdentifier;
+
+      comparesToVariableIdentifier = (variableIdentifierA === variableIdentifierB);
+    }
+
+    return comparesToVariableIdentifier;
+  }
+
+  findValidTerm(context) {
+    const termNode = this.getTermNode(),
+          term = context.findTermByTermNode(termNode),
+          validTerm = term; ///
+
+    return validTerm;
+  }
+
   validate(context, validateForwards) {
     let term = null;
 

package/src/element/topLevelMetaAssertion.js

@@ -42,7 +42,7 @@ export default class TopLevelMetaAssertion extends Element {
     return this.proof;
   }
 
-  getSubstitutions() {
+  getMetaLevelSubstitutions() {
     return this.metaLevelSubstitutions;
   }
 

package/src/element/variable.js

@@ -7,8 +7,8 @@ import elements from "../elements";
 import { define } from "../elements";
 import { instantiate } from "../utilities/context";
 import { instantiateVariable } from "../process/instantiate";
-import {identifierFromVarialbeNode, variableFromVariableNode} from "../utilities/element";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
+import { variableFromTermNode, identifierFromVarialbeNode } from "../utilities/element";
 
 export default define(class Variable extends Element {
   constructor(context, string, node, type, identifier) {
@@ -198,4 +198,11 @@ export default define(class Variable extends Element {
       return variable;
     }, context);
   }
+
+  static fromTerm(term, context) {
+    const termNode = term.getNode(),
+          variable = variableFromTermNode(termNode, context);
+
+    return variable;
+  }
 });

package/src/process/assign.js

@@ -23,7 +23,9 @@ export function judgementAssignmentFromJudgement(judgement, context) {
 }
 
 export function leftVariableAssignmentFromEquality(equality, context) {
-  let leftVariableAssignment = null;
+  let leftVariableAssignment = (contxt) => {
+    ///
+  };
 
   const leftTermNode = equality.getLeftTermNode(),
         singularVariableNode = leftTermNode.getSingularVariableNode();
@@ -39,7 +41,9 @@ export function leftVariableAssignmentFromEquality(equality, context) {
 }
 
 export function rightVariableAssignmentFromEquality(equality, context) {
-  let rightVariableAssignment = null;
+  let rightVariableAssignment = (context) => {
+    ///
+  };
 
   const rightTermNode = equality.getRightTermNode(),
         singularVariableNode = rightTermNode.getSingularVariableNode();
@@ -55,7 +59,9 @@ export function rightVariableAssignmentFromEquality(equality, context) {
 }
 
 export function variableAssignmentFromTypeAssertion(typeAssertion, context) {
-  let variableAssignment = null;
+  let variableAssignment = (context) => {
+    ///
+  };
 
   const term = typeAssertion.getTerm(),
         termSingular = term.isSingular();

package/src/process/unify.js

@@ -152,7 +152,7 @@ class CombinatorPass extends ZipPass {
     {
       generalNodeQuery: metaTypeNodeQuery,
       specificNodeQuery: statementNodeQuery,
-      run: (generalMetaTypeNode, specificStatementNode, stated, generalContext, specificContext) => {
+      run: (generalMetaTypeNode, specificStatementNode, generalContext, specificContext) => {
         let success = false;
 
         const metaTypeNode = generalMetaTypeNode, ///
@@ -167,7 +167,7 @@ class CombinatorPass extends ZipPass {
 
           statement = statementFromStatementNode(statementNode, context);
 
-          statement = statement.validate(stated, context);  ///
+          statement = statement.validate(context);  ///
 
           if (statement !== null) {
             success = true;
@@ -180,7 +180,7 @@ class CombinatorPass extends ZipPass {
     {
       generalNodeQuery: metaTypeNodeQuery,
       specificNodeQuery: frameNodeQuery,
-      run: (generalMetaTypeNode, specificFrameNode, stated, generalContext, specificContext) => {
+      run: (generalMetaTypeNode, specificFrameNode, generalContext, specificContext) => {
         let success = false;
 
         const metaTypeNode = generalMetaTypeNode, ///
@@ -195,7 +195,7 @@ class CombinatorPass extends ZipPass {
 
           frame = frameFromFrameNode(frameNode, context);
 
-          frame = frame.validate(stated, context);  ///
+          frame = frame.validate(context);  ///
 
           if (frame !== null) {
             success = true;
@@ -208,7 +208,7 @@ class CombinatorPass extends ZipPass {
     {
       generalNodeQuery: typeNodeQuery,
       specificNodeQuery: termNodeQuery,
-      run: (generalTypeNode, specificTermNode, stated, generalContext, specificContext) => {
+      run: (generalTypeNode, specificTermNode, generalContext, specificContext) => {
         let success = false;
 
         const typeNode = generalTypeNode, ///
@@ -466,13 +466,13 @@ export function unifyTermWithConstructor(term, constructor, generalContext, spec
   return termUnifiesWithConstructor;
 }
 
-export function unifyStatementWithCombinator(statement, combinator, stated, generalContext, specificContext) {
+export function unifyStatementWithCombinator(statement, combinator, generalContext, specificContext) {
   let statementUnifiesWithCombinator = false;
 
   const statementNode = statement.getNode(),
         combinatorStatement = combinator.getStatement(),
         combinatorStatementNode = combinatorStatement.getNode(),
-        success = combinatorPass.run(combinatorStatementNode, statementNode, stated, generalContext, specificContext);
+        success = combinatorPass.run(combinatorStatementNode, statementNode, generalContext, specificContext);
 
   if (success) {
     statementUnifiesWithCombinator = true;

package/src/process/validate.js

@@ -4,6 +4,7 @@ import { SimplePass } from "occam-languages";
 import { queryUtilities } from "occam-languages";
 
 import { termFromTermNode, statementFromStatementNode } from "../utilities/element";
+import {descend} from "../utilities/context";
 
 const { nodeQuery } = queryUtilities;
 
@@ -32,17 +33,17 @@ class CombinatorPass extends SimplePass {
       run: (statementNode, context) => {
         let success = false;
 
-        let statement;
+        descend((context) => {
+          let statement;
 
-        const stated = true;
+          statement = statementFromStatementNode(statementNode, context);
 
-        statement = statementFromStatementNode(statementNode, context);
+          statement = statement.validate(context);  ///
 
-        statement = statement.validate(stated, context);
-
-        if (statement !== null) {
-          success = true;
-        }
+          if (statement !== null) {
+            success = true;
+          }
+        }, context);
 
         return success;
       }