occam-verify-cli 1.0.768 → 1.0.776

package/src/element/conclusion.js

@@ -3,11 +3,10 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { attempt, instantiate } from "../utilities/context";
 import { instantiateConclusion } from "../process/instantiate";
-import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
+import { declare, attempt, descend, serialise, unserialise, instantiate } from "../utilities/context";
 
-export  default define(class Conclusion extends Element {
+export default define(class Conclusion extends Element {
   constructor(context, string, node, statement) {
     super(context, string, node);
 
@@ -58,14 +57,16 @@ export  default define(class Conclusion extends Element {
 
     context.trace(`Validating the '${conclusionString}' conclusion...`);
 
-    attempt((context) => {
-      const statementValidates = this.validateStatement(context);
+    declare((context) => {
+      attempt((context) => {
+        const statementValidates = this.validateStatement(context);
 
-      if (statementValidates) {
-        context.commit(this);
+        if (statementValidates) {
+          context.commit(this);
 
-        validates = true;
-      }
+          validates = true;
+        }
+      }, context);
     }, context);
 
     if (validates) {
@@ -76,19 +77,20 @@ export  default define(class Conclusion extends Element {
   }
 
   validateStatement(context) {
-    let statementValidates;
+    let statementValidates = false;
 
     const statementString = this.statement.getString(),
           conclusionString = this.getString();  ///
 
     context.trace(`Validating the '${conclusionString}' conclusion's '${statementString}' statement...`);
 
-    const stated = true,
-          statement = this.statement.validate(stated, context);
+    descend((context) => {
+      const statement = this.statement.validate(context);
 
-    if (statement !== null) {
-      statementValidates = true;
-    }
+      if (statement !== null) {
+        statementValidates = true;
+      }
+    }, context);
 
     if (statementValidates) {
       context.trace(`...validated the '${conclusionString}' conclusion's '${statementString}' statement.`);
@@ -123,41 +125,36 @@ export  default define(class Conclusion extends Element {
   }
 
   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 = "Conclusion";
 
   static fromJSON(json, context) {
-    const ephemeralContext = ephemeralContextFromJSON(json, context);
+    let conclusion;
 
-    context = ephemeralContext; ///
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string } = json,
+              conclusionNode = instantiateConclusion(string, context),
+              node = conclusionNode,  ///
+              statement = statementFromConclusionNode(conclusionNode, context);
 
-    return instantiate((context) => {
-      const { string } = json,
-            conclusionNode = instantiateConclusion(string, context),
-            node = conclusionNode,  ///
-            statement = statementFromConclusionNode(conclusionNode, context),
-            conclusion = new Conclusion(context, string, node, statement);
+        conclusion = new Conclusion(context, string, node, statement);
+      }, context);
+    }, json, context);
 
-      return conclusion;
-    }, context);
+    return conclusion;
   }
 });
 

package/src/element/constructor.js

@@ -3,12 +3,12 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { attempt, instantiate } from "../utilities/context";
 import { instantiateConstructor } from "../process/instantiate";
 import { termFromConstructorNode } from "../utilities/element";
 import { unifyTermWithConstructor } from "../process/unify";
 import { validateTermAsConstructor } from "../process/validate";
-import { typeFromJSON, typeToTypeJSON, ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
+import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
+import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Constructor extends Element {
   constructor(context, string, node, term, type) {
@@ -143,45 +143,40 @@ export default define(class Constructor extends Element {
   }
 
   toJSON() {
-    let context;
-
-    context = this.getContext();
-
-    const ephemeralContext = context, ///
-          ephemeralContextJSON = ephemeralContextToEphemeralContextJSON(ephemeralContext),
-          contextJSON = ephemeralContextJSON; ///
-
-    context = contextJSON;  ///
-
-    const includeType = false,
-          typeJSON = typeToTypeJSON(this.type),
-          string = this.getString(includeType),
-          type = typeJSON,  ///
-          json = {
-            context,
-            string,
-            type
-          };
-
-    return json;
+    const context = this.getContext();
+
+    return serialise((context) => {
+      const includeType = false,
+            typeJSON = typeToTypeJSON(this.type),
+            string = this.getString(includeType),
+            type = typeJSON,  ///
+            json = {
+              context,
+              string,
+              type
+            };
+
+      return json;
+    }, context);
   }
 
   static name = "Constructor";
 
   static fromJSON(json, context) {
-    const ephemeralContext = ephemeralContextFromJSON(json, context);
+    let constructor;
 
-    context = ephemeralContext; ///
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string } = json,
+              constructorNode = instantiateConstructor(string, context),
+              node = constructorNode, ///
+              term = termFromConstructorNode(constructorNode, context),
+              type = typeFromJSON(json, context);
 
-    return instantiate((context) => {
-      const { string } = json,
-            constructorNode = instantiateConstructor(string, context),
-            node = constructorNode, ///
-            term = termFromConstructorNode(constructorNode, context),
-            type = typeFromJSON(json, context),
-            constructor = new Constructor(context, string, node, term, type);
+        constructor = new Constructor(context, string, node, term, type);
+      }, context);
+    }, json, context);
 
-      return constructor;
-    }, context);
+    return constructor;
   }
 });

package/src/element/deduction.js

@@ -3,9 +3,8 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { attempt, instantiate } from "../utilities/context";
 import { instantiateDeduction } from "../process/instantiate";
-import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
+import { declare, attempt, descend, serialise, unserialise, instantiate } from "../utilities/context";
 
 export default define(class Deduction extends Element {
   constructor(context, string, node, statement) {
@@ -58,14 +57,16 @@ export default define(class Deduction extends Element {
 
     context.trace(`Validating the '${deductionString}' deduction...`);
 
-    attempt((context) => {
-      const statementValidates = this.validateStatement(context);
+    declare((context) => {
+      attempt((context) => {
+        const statementValidates = this.validateStatement(context);
 
-      if (statementValidates) {
-        context.commit(this);
+        if (statementValidates) {
+          context.commit(this);
 
-        validates = true;
-      }
+          validates = true;
+        }
+      }, context);
     }, context);
 
     if (validates) {
@@ -76,19 +77,20 @@ export default define(class Deduction extends Element {
   }
 
   validateStatement(context) {
-    let statementValidates;
+    let statementValidates = false;
 
     const statementString = this.statement.getString(),
           deductionnString = this.getString();  ///
 
     context.trace(`Validating the '${deductionnString}' deductionn's '${statementString}' statement...`);
 
-    const stated = true,
-          statement = this.statement.validate(stated, context);
+    descend((context) => {
+      const statement = this.statement.validate(context);
 
-    if (statement !== null) {
-      statementValidates = true;
-    }
+      if (statement !== null) {
+        statementValidates = true;
+      }
+    }, context);
 
     if (statementValidates) {
       context.trace(`...validated the '${deductionnString}' deductionn's '${statementString}' statement.`);
@@ -148,41 +150,36 @@ export default define(class Deduction extends Element {
   }
 
   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 = "Deduction";
 
   static fromJSON(json, context) {
-    const ephemeralContext = ephemeralContextFromJSON(json, context);
+    let deduction;
 
-    context = ephemeralContext; ///
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string } = json,
+              deductionNode = instantiateDeduction(string, context),
+              node = deductionNode,  ///
+              statement = statementFromDeductionNode(deductionNode, context);
 
-    return instantiate((context) => {
-      const { string } = json,
-            deductionNode = instantiateDeduction(string, context),
-            node = deductionNode,  ///
-            statement = statementFromDeductionNode(deductionNode, context),
-            deduction = new Deduction(context, string, node, statement);
+        deduction = new Deduction(context, string, node, statement);
+      }, context);
+    }, json, context);
 
-      return deduction;
-    }, context);
+    return deduction;
   }
 });
 

package/src/element/equality.js

@@ -6,6 +6,7 @@ import { define } from "../elements";
 import { instantiate } from "../utilities/context";
 import { equateTerms } from "../process/equate";
 import { instantiateEquality } from "../process/instantiate";
+import { equalityFromStatementNode } from "../utilities/element";
 import { equalityAssignmentFromEquality, leftVariableAssignmentFromEquality, rightVariableAssignmentFromEquality } from "../process/assign";
 
 export default define(class Equality extends Element {
@@ -115,7 +116,7 @@ export default define(class Equality extends Element {
     return validEquality;
   }
 
-  validate(stated, context) {
+  validate(context) {
     let equality = null;
 
     const equalityString = this.getString(); ///
@@ -134,6 +135,8 @@ export default define(class Equality extends Element {
       const termsValidate = this.validateTerms(context);
 
       if (termsValidate) {
+        const stated = context.isStated();
+
         let validatesWhenStated = false,
             validatesWhenDerived = false;
 
@@ -151,7 +154,7 @@ export default define(class Equality extends Element {
       if (validates) {
         equality = this;  ///
 
-        this.assign(stated, context);
+        this.assign(context);
 
         context.addEquality(equality);
 
@@ -243,29 +246,17 @@ export default define(class Equality extends Element {
     return validatesWhenDerived;
   }
 
-  assign(stated, context) {
+  assign(context) {
     const equality = this,  ///
           equalityAssignment = equalityAssignmentFromEquality(equality, context),
           leftVariableAssignment = leftVariableAssignmentFromEquality(equality, context),
           rightVariableAssignment = rightVariableAssignmentFromEquality(equality, context);
 
-    let assignment;
-
-    assignment = equalityAssignment; ///
-
-    context.addAssignment(assignment);
-
-    if (leftVariableAssignment !== null) {
-      assignment = leftVariableAssignment;  ///
-
-      context.addAssignment(assignment);
-    }
+    context.addAssignment(equalityAssignment);
 
-    if (rightVariableAssignment !== null) {
-      assignment = rightVariableAssignment;  ///
+    context.addAssignment(leftVariableAssignment);
 
-      context.addAssignment(assignment);
-    }
+    context.addAssignment(rightVariableAssignment);
   }
 
   static name = "Equality";
@@ -294,6 +285,13 @@ export default define(class Equality extends Element {
       return equality;
     }, context);
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          equality = equalityFromStatementNode(statementNode, context);
+
+    return equality;
+  }
 });
 
 function leftTermFromEqualityNode(equalityNode, context) {

package/src/element/equivalence.js

@@ -4,25 +4,38 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
+import { instantiate } from "../utilities/context";
 import { instantiateEquivalence } from "../process/instantiate";
 import { stripBracketsFromTermNode } from "../utilities/brackets";
 import { equivalenceStringFromTerms } from "../utilities/string";
 import { equivalenceFromEquivalenceNode } from "../utilities/element";
-import { instantiate, sanitisedContextFromContext } from "../utilities/context";
 
 const { compress } = arrayUtilities;
 
 export default define(class Equivalence extends Element {
-  constructor(context, string, node, terms) {
+  constructor(context, string, node, type, terms) {
     super(context, string, node);
 
+    this.type = type;
     this.terms = terms;
   }
 
+  getType() {
+    return this.type;
+  }
+
   getTerms() {
     return this.terms;
   }
 
+  setType(type) {
+    this.type = type;
+  }
+
+  setTerms(terms) {
+    this.terms = terms;
+  }
+
   getEquivalenceNode() {
     const node = this.getNode(),
           equivalenceNode = node; ///
@@ -30,26 +43,6 @@ export default define(class Equivalence extends Element {
     return equivalenceNode;
   }
 
-  getType() {
-    const type = this.terms.reduce((type, term) => {
-      const termType = term.getType();
-
-      if (type === null) {
-        type = termType;  ///
-      } else {
-        const termTypeSubTypeOfType = termType.isSubTypeOf(type);
-
-        if (termTypeSubTypeOfType) {
-          type = termType;  ///
-        }
-      }
-
-      return type;
-    }, null);
-
-    return type;
-  }
-
   getGroundedTerms(definedVariables, groundedTerms, context) {
     this.terms.forEach((term) => {
       const termGrounded = term.isGrounded(definedVariables, context);
@@ -133,20 +126,6 @@ export default define(class Equivalence extends Element {
     return implicitlyGrounded;
   }
 
-  compareTerm(term) {
-    const termA = term, ///
-          comparesToTerm = this.someTerm((term) => {
-            const termB = term, ///
-                  termAEqualToTermB = termA.isEqualTo(termB);
-
-            if (termAEqualToTermB) {
-              return true;
-            }
-          });
-
-    return comparesToTerm;
-  }
-
   matchTermNode(termNode) {
     termNode = stripBracketsFromTermNode(termNode); ///
 
@@ -173,36 +152,31 @@ export default define(class Equivalence extends Element {
     return termNodesMatch;
   }
 
-  matchVariableNode(variableNode) {
-    const variableNodeA = variableNode, ///
-          variableNodeMatches = this.someTerm((term) => {
-            const termNode = term.getNode(),
-                  singularVariableNode = termNode.getSingularVariableNode();
+  someTerm(callback) { return this.terms.some(callback); }
 
-            if (singularVariableNode !== null) {
-              const variableNodeB = singularVariableNode, ///
-                    variableNodeAMatchesVariableNodeB = variableNodeA.match(variableNodeB);
+  everyTerm(callback) { return this.terms.every(callback); }
+
+  compareTerm(term) {
+    const termA = term, ///
+          comparesToTerm = this.someTerm((term) => {
+            const termB = term, ///
+                  termAComparesToTermB = termA.compareTerm(termB);
 
-              if (variableNodeAMatchesVariableNodeB) {
-                return true;
-              }
+            if (termAComparesToTermB) {
+              return true;
             }
           });
 
-    return variableNodeMatches;
+    return comparesToTerm;
   }
 
-  someTerm(callback) { return this.terms.some(callback); }
-
-  everyTerm(callback) { return this.terms.every(callback); }
-
   someOtherTerm(term, callback) {
     const termA = term, ///
           terms = this.terms.filter((term) => {
             const termB = term, ///
-                  termAEqualToTermB = termA.isEqualTo(termB);
+                  termAComparesToTermB = termA.compareTerm(termB);
 
-            if (!termAEqualToTermB) {
+            if (!termAComparesToTermB) {
               return true;
             }
           }),
@@ -218,9 +192,9 @@ export default define(class Equivalence extends Element {
     ];
 
     compress(combinedTerms, (combinedTermA, combinedTermB) => {
-      const combinedTermAEqualToCombinedTermB = combinedTermA.isEqualTo(combinedTermB);
+      const combinedTermAComparesToCombinedTermB = combinedTermA.compareTerm(combinedTermB);
 
-      if (!combinedTermAEqualToCombinedTermB) {
+      if (!combinedTermAComparesToCombinedTermB) {
         return true;
       }
     });
@@ -229,35 +203,70 @@ export default define(class Equivalence extends Element {
   }
 
   mergedWith(equivalence, context) {
-    const terms = equivalence.getTerms(),
+    let type;
+
+    type = equivalence.getType();
+
+    const types = [
+            this.type,
+            type
+          ],
+          terms = equivalence.getTerms(),
+          combinedType = combinedTypeFromTypes(types),
           combinedTerms = this.combineTerms(terms);
 
-    return instantiate((context) => {
+    type = combinedType;  ///
+
+    instantiate((context) => {
       const terms = combinedTerms,  ///
             equivalenceString = equivalenceStringFromTerms(terms),
             string = equivalenceString,  ///
-            equivalenceNode = instantiateEquivalence(string, context),
-            equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
+            equivalenceNode = instantiateEquivalence(string, context);
 
-      return equivalence;
+      equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
     }, context);
+
+    equivalence.setType(type);
+
+    return equivalence;
   }
 
   static name = "Equivalence";
 
   static fromEquality(equality, context) {
-    const santisedContext = sanitisedContextFromContext(context);
+    let equivalence;
 
-    context = santisedContext;  ///
+    const type = equality.getType();
 
-    return instantiate((context) => {
+    instantiate((context) => {
       const terms = equality.getTerms(),
             equivalenceString = equivalenceStringFromTerms(terms),
             string = equivalenceString,  ///
-            equivalenceNode = instantiateEquivalence(string, context),
-            equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
+            equivalenceNode = instantiateEquivalence(string, context);
 
-      return equivalence;
+      equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
     }, context);
+
+    equivalence.setType(type);
+
+    return equivalence;
   }
 });
+
+function combinedTypeFromTypes(types) {
+  const combinedType = types.reduce((combinedType, type) => {
+    if (combinedType === null) {
+      combinedType = type;  ///
+    } else {
+      const typeSubTypeOfCombinedType = type.isSubTypeOf(combinedType);
+
+      if (typeSubTypeOfCombinedType) {
+        combinedType = type;  ///
+      }
+    }
+
+    return combinedType;
+  }, null);
+
+  return combinedType;
+}