occam-verify-cli 1.0.695 → 1.0.702

package/src/element/assertion/satisfies.js

@@ -3,6 +3,9 @@
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
+import { literally } from "../../utilities/context";
+import { instantiateSatisfiesAssertion } from "../../process/instantiate";
+import { signatureFromJSatisfiesAssertionNode, referenceFromJSatisfiesAssertionNode } from "../../utilities/element";
 
 export default define(class SatisfiesAssertion extends Assertion {
   constructor(context, string, node, signature, reference) {
@@ -155,8 +158,6 @@ export default define(class SatisfiesAssertion extends Assertion {
   }
 
   toJSON() {
-    debugger
-
     const { name } = this.constructor,
           string = this.getString(),
           json = {
@@ -175,7 +176,17 @@ export default define(class SatisfiesAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      debugger
+      literally((context) => {
+        const { string } = json,
+              definedAssertionNode = instantiateSatisfiesAssertion(string, context),
+              node = definedAssertionNode,  ///
+              signature = signatureFromJSatisfiesAssertionNode(definedAssertionNode, context),
+              reference = referenceFromJSatisfiesAssertionNode(definedAssertionNode, context);
+
+        context = null;
+
+        satisfiesAssertion = new SatisfiesAssertion(context, string, node, signature, reference);
+      }, context);
     }
 
     return satisfiesAssertion;

package/src/element/assertion/subproof.js

@@ -7,7 +7,6 @@ import Assertion from "../assertion";
 import { define } from "../../elements";
 import { literally } from "../../utilities/context";
 import { unifyStatement } from "../../process/unify";
-import { statementsToStatementsJSON } from "../../utilities/json";
 import { instantiateSubproofAssertion } from "../../process/instantiate";
 
 const { match } = arrayUtilities;
@@ -116,13 +115,10 @@ export default define(class SubproofAssertion extends Assertion {
 
   toJSON() {
     const { name } = this.constructor,
-          statementJSON = statementsToStatementsJSON(this.statements),
-          statements = statementJSON, ///
           string = this.getString(),
           json = {
             name,
-            string,
-            statements
+            string
           };
 
     return json;
@@ -142,6 +138,8 @@ export default define(class SubproofAssertion extends Assertion {
               statements = statementsFromSubproofAssertionNode(subproofAssertionNode, context),
               node = subproofAssertionNode; ///
 
+        context = null;
+
         subproorAssertion = new SubproofAssertion(context, string, node, statements);
       }, context);
     }

package/src/element/assertion/type.js

@@ -3,8 +3,11 @@
 import Assertion from "../assertion";
 
 import { define } from "../../elements";
+import { literally } from "../../utilities/context";
+import { typeFromJSON } from "../../utilities/json";
+import { termFromTypeAssertionNode } from "../../utilities/element";
+import { instantiateSubproofAssertion } from "../../process/instantiate";
 import { variableAssignmentFromTypeAssertion } from "../../process/assign";
-import {termToTermJSON} from "../../utilities/json";
 
 export default define(class TypeAssertion extends Assertion {
   constructor(context, string, node, term, type) {
@@ -190,18 +193,13 @@ export default define(class TypeAssertion extends Assertion {
   }
 
   toJSON() {
-    debugger
-
     const { name } = this.constructor,
-          termJSON = termToTermJSON(this.term),
           typeJSON = typeToTypeJSON(this.type),
-          term = termJSON,  ///
           type = typeJSON,  ///
           string = this.getString(),
           json = {
-            string,
             name,
-            term,
+            string,
             type
           };
 
@@ -216,7 +214,17 @@ export default define(class TypeAssertion extends Assertion {
     const { name } = json;
 
     if (this.name === name) {
-      debugger
+      literally((context) => {
+        const { string } = json,
+              typeAssertionNode = instantiateSubproofAssertion(string, context),
+              term = termFromTypeAssertionNode(typeAssertionNode, context),
+              type = typeFromJSON(json, context),
+              node = typeAssertionNode; ///
+
+        context = null;
+
+        typeAssertion = new TypeAssertion(context, string, node, term, type);
+      }, context);
     }
 
     return typeAssertion;

package/src/element/assumption.js

@@ -3,8 +3,9 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
+import { literally } from "../utilities/context";
+import { instantiateAssumption } from "../process/instantiate";
 import { unifyStatementIntrinsically } from "../process/unify";
-import { referenceFromJSON, referenceToReferenceJSON } from "../utilities/json";
 
 export default define(class Assumption extends Element {
   constructor(context, string, node, reference, statement) {
@@ -319,12 +320,45 @@ export default define(class Assumption extends Element {
   }
 
   toJSON() {
-    debugger
+    const string = this.getString(),
+          json = {
+            string
+          };
+
+    return json;
   }
 
   static name = "Assumption";
 
   static fromJSON(json, context) {
-    debugger
+    const assumption = literally((context) => {
+      const { string } = json,
+            assumptionNode = instantiateAssumption(string, context),
+            node = assumptionNode,  ///
+            reference = referenceFromAssumptionNode(assumptionNode, context),
+            statement = statementFromAssumptionNode(assumptionNode, context);
+
+      context = null; ///
+
+      const assumption = new Assumption(context, string, node, reference, statement);
+
+      return assumption;
+    }, context);
+
+    return assumption;
   }
 });
+
+function referenceFromAssumptionNode(assumptionNode, context) {
+  const metavariableNode = assumptionNode.getMetavariableNode(context),
+        reference = context.findReferenceByMetavariableNode(metavariableNode);
+
+  return reference;
+}
+
+function statementFromAssumptionNode(assumptionNode, context) {
+  const statementNode = assumptionNode.getStatementNode(),
+        statement = context.findStatementByStatementNode(statementNode);
+
+  return statement;
+}

package/src/element/combinator.js

@@ -5,18 +5,14 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { attempt, literally } from "../utilities/context";
 import { instantiateCombinator } from "../process/instantiate";
+import { ephemeralContextFromJSON } from "../utilities/json";
 import { verifyStatementAsCombinator } from "../process/verify";
+import { statementFromCombinatorNode } from "../utilities/element";
 import { unifyStatementWithCombinator } from "../process/unify";
-import {
-  statementFromJSON,
-  ephemeralContextFromJSON,
-  statementToStatementJSON,
-  procedureCallToProcedureCallJSON
-} from "../utilities/json";
 
 export default define(class Combinator extends Element {
   constructor(context, string, node, statement) {
-    super(context, string, node)
+    super(context, string, node);
 
     this.statement = statement;
   }
@@ -93,13 +89,10 @@ export default define(class Combinator extends Element {
 
     context = contextJSON;  ///
 
-    const statementJSON = statementToStatementJSON(this.statement),
-          statement = statementJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
             context,
-            string,
-            statement
+            string
           };
 
     return json;
@@ -112,7 +105,7 @@ export default define(class Combinator extends Element {
       const { string } = json,
             combinatorNode = instantiateCombinator(string, context),
             node = combinatorNode,  ///
-            statement = statementFromJSON(json, context),
+            statement = statementFromCombinatorNode(combinatorNode, context),
             ephemeralContext = ephemeralContextFromJSON(json, context);
 
       context = ephemeralContext; ///

package/src/element/conclusion.js

@@ -5,7 +5,8 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { attempt, literally } from "../utilities/context";
 import { instantiateConclusion } from "../process/instantiate";
-import { statementFromJSON, ephemeralContextFromJSON, statementToStatementJSON } from "../utilities/json";
+import { statementFromConclusionNode } from "../utilities/element";
+import { ephemeralContextFromJSON, statementToStatementJSON } from "../utilities/json";
 
 export  default define(class Conclusion extends Element {
   constructor(context, string, node, statement) {
@@ -131,13 +132,10 @@ export  default define(class Conclusion extends Element {
 
     context = contextJSON;  ///
 
-    const statementJSON = statementToStatementJSON(this.statement),
-          statement = statementJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
             context,
-            string,
-            statement
+            string
           };
 
     return json;
@@ -150,7 +148,7 @@ export  default define(class Conclusion extends Element {
       const { string } = json,
             conclusionNode = instantiateConclusion(string, context),
             node = conclusionNode,  ///
-            statement = statementFromJSON(json, context),
+            statement = statementFromConclusionNode(conclusionNode, context),
             ephemeralContext = ephemeralContextFromJSON(json, context);
 
       context = ephemeralContext; ///

package/src/element/constructor.js

@@ -6,8 +6,9 @@ import { define } from "../elements";
 import { attempt, literally } from "../utilities/context";
 import { instantiateConstructor } from "../process/instantiate";
 import { verifyTermAsConstructor } from "../process/verify";
+import { termFromConstructorNode } from "../utilities/element";
 import { unifyTermWithConstructor } from "../process/unify";
-import { termFromJSON, termToTermJSON, ephemeralContextFromJSON } from "../utilities/json";
+import { ephemeralContextFromJSON } from "../utilities/json";
 
 export default define(class Constructor extends Element {
   constructor(context, string, node, term) {
@@ -113,11 +114,17 @@ export default define(class Constructor extends Element {
   }
 
   toJSON() {
-    const termJSON = termToTermJSON(this.term),
-          string = this.getString(),
-          term = termJSON,  ///
+    let context;
+
+    context = this.getContext();
+
+    const contextJSON = context.toJSON();
+
+    context = contextJSON;  ///
+
+    const string = this.getString(),
           json = {
-            term,
+            context,
             string
           };
 
@@ -131,7 +138,7 @@ export default define(class Constructor extends Element {
       const { string } = json,
             constructorNode = instantiateConstructor(string, context),
             node = constructorNode, ///
-            term = termFromJSON(json, context),
+            term = termFromConstructorNode(constructorNode, context),
             ephemeralContext = ephemeralContextFromJSON(json, context);
 
       context = ephemeralContext; ///

package/src/element/deduction.js

@@ -5,7 +5,8 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { attempt, literally } from "../utilities/context";
 import { instantiateDeduction } from "../process/instantiate";
-import { statementToStatementJSON, ephemeralContextFromJSON } from "../utilities/json";
+import { ephemeralContextFromJSON } from "../utilities/json";
+import { statementFromDeductionNode } from "../utilities/element";
 
 export default define(class Deduction extends Element {
   constructor(context, string, node, statement) {
@@ -156,13 +157,10 @@ export default define(class Deduction extends Element {
 
     context = contextJSON;  ///
 
-    const statementJSON = statementToStatementJSON(this.statement),
-          statement = statementJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
             context,
-            string,
-            statement
+            string
           };
 
     return json;
@@ -173,9 +171,9 @@ export default define(class Deduction extends Element {
   static fromJSON(json, context) {
     const duduction = literally((context) => {
       const { string } = json,
-            duductionNode = instantiateDeduction(string, context),
-            node = duductionNode,  ///
-            statement = statementFromJSON(json, context),
+            deductionNode = instantiateDeduction(string, context),
+            node = deductionNode,  ///
+            statement = statementFromDeductionNode(deductionNode, context),
             ephemeralContext = ephemeralContextFromJSON(json, context);
 
       context = ephemeralContext; ///

package/src/element/equality.js

@@ -3,7 +3,9 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
+import { literally } from "../utilities/context";
 import { equateTerms } from "../process/equate";
+import { instantiateEquality } from "../process/instantiate";
 import { equalityAssignmentFromEquality, leftVariableAssignmentFromEquality, rightVariableAssignmentFromEquality } from "../process/assign";
 
 export default define(class Equality extends Element {
@@ -271,4 +273,45 @@ export default define(class Equality extends Element {
   }
 
   static name = "Equality";
+
+  toJSON() {
+    const string = this.getString(),
+          json = {
+            string
+          };
+
+    return json;
+  }
+
+  static fromJSON(json, context) {
+    const equality = literally((context) => {
+      const { string } = json,
+            equalityNode = instantiateEquality(string, context),
+            node = equalityNode,  ///
+            leftTerm = leftTermFromEqualityNode(equalityNode, context),
+            rightTerm = rightTermFromEqualityNode(equalityNode, context);
+
+      context = null;
+
+      const equality = new Equality(context, string, node, leftTerm, rightTerm);
+
+      return equality;
+    }, context);
+
+    return equality;
+  }
 });
+
+function leftTermFromEqualityNode(equalityNode, context) {
+  const leftTermNode = equalityNode.getLeftTermNode(),
+        leftTerm = context.findTermByTermNode(leftTermNode);
+
+  return leftTerm;
+}
+
+function rightTermFromEqualityNode(equalityNode, context) {
+  const rightTermNode = equalityNode.getLeftTermNode(),
+        rightTerm = context.findTermByTermNode(rightTermNode);
+
+  return rightTerm;
+}

package/src/element/frame.js

@@ -6,8 +6,8 @@ import { define } from "../elements";
 import { literally } from "../utilities/context";
 import { instantiateFrame } from "../process/instantiate";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
+import { metavariableFromFrameNode } from "../utilities/element";
 import { assumptionsStringFromAssumptions } from "../utilities/string";
-import { assumptionsFromJSON, metavariableFromJSON, assumptionsToAssumptionsJSON, metavariableToMetavariableJSON } from "../utilities/json";
 
 export default define(class Frame extends Element {
   constructor(context, string, node, assumptions, metavariable) {
@@ -348,15 +348,9 @@ export default define(class Frame extends Element {
   }
 
   toJSON() {
-    const metavariableJSON = metavariableToMetavariableJSON(this.metavariable),
-          assumptionsJSON = assumptionsToAssumptionsJSON(this.assumptions),
-          metavariable = metavariableJSON,  ///
-          assumptions = assumptionsJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
-            string,
-            assumptions,
-            metavariable
+            string
           };
 
     return json;
@@ -369,9 +363,12 @@ export default define(class Frame extends Element {
       const { string } = json,
             frameNode = instantiateFrame(string, context),
             node = frameNode,  ///
-            assumptions = assumptionsFromJSON(json, context),
-            metavariable = metavariableFromJSON(json, context),
-            frame = new Frame(context, string, node, assumptions, metavariable);
+            assumptions = assumptionsFromFrameNode(frameNode, context),
+            metavariable = metavariableFromFrameNode(frameNode, context);
+
+      context = null;
+
+      const frame = new Frame(context, string, node, assumptions, metavariable);
 
       return frame;
     }, context);
@@ -379,3 +376,15 @@ export default define(class Frame extends Element {
     return frame;
   }
 });
+
+function assumptionsFromFrameNode(frameNode, context) {
+  const assumptionNodes = frameNode.getAssumptionNodes(),
+        assumptions = assumptionNodes.map((assumptionNode) => {
+          const assumption = context.findAssumptionByAssumptionNode(assumptionNode);
+
+          return assumption;
+        });
+
+  return assumptions;
+}
+

package/src/element/hypothesis.js

@@ -3,7 +3,9 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
+import {literally} from "../utilities/context";
+import { instantiateHypothesis } from "../process/instantiate";
+import { statementFromHypothesisNode } from "../utilities/element";
 
 export default define(class Hypothesis extends Element {
   constructor(context, string, node, statement) {
@@ -87,12 +89,9 @@ export default define(class Hypothesis extends Element {
   }
 
   toJSON() {
-    const statementJSON = statementToStatementJSON(this.statement),
-          statement = statementJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
-            string,
-            statement
+            string
           };
 
     return json;
@@ -101,6 +100,19 @@ export default define(class Hypothesis extends Element {
   static name = "Hypothesis";
 
   static fromJSON(json, context) {
-    debugger
+    const hypothesis = literally((context) => {
+      const { string } = json,
+            hypothesisNode = instantiateHypothesis(string, context),
+            node = hypothesisNode,  ///
+            statement = statementFromHypothesisNode(hypothesisNode, context);
+
+      context = null;
+
+      const hypothesis = new Hypothesis(context, string, node, statement);
+
+      return hypothesis;
+    }, context);
+
+    return hypothesis;
   }
 });

package/src/element/judgement.js

@@ -2,7 +2,11 @@
 
 import { Element } from "occam-languages";
 
+import elements from "../elements";
+
 import { define } from "../elements";
+import { literally } from "../utilities/context";
+import { instantiateJudgement } from "../process/instantiate";
 import { judgementAssignmentFromJudgement } from "../process/assign";
 
 export default define(class Judgement extends Element {
@@ -206,9 +210,50 @@ export default define(class Judgement extends Element {
     context.addAssignment(assignment);
   }
 
+  toJSON() {
+    const string = this.getString(),
+          json = {
+            string
+          };
+
+    return json;
+  }
+
   static name = "Judgement";
+
+  static fromJSON(json, context) {
+    const judgement = literally((context) => {
+      const { string } = json,
+            judgementNode = instantiateJudgement(string, context),
+            node = judgementNode,  ///
+            frame = frameFromJudgementNode(judgementNode, context),
+            assumption = assumptionFromJudgementNode(judgementNode, context);
+
+      context = null;
+
+      const judgement = new Judgement(context, string, node, frame, assumption);
+
+      return judgement;
+    }, context);
+
+    return judgement;
+  }
 });
 
+function frameFromJudgementNode(judgementNode, context) {
+  const frameNode = judgementNode.getFrameNode(),
+        frame = context.findFrameByFrameNode(frameNode);
+
+  return frame;
+}
+
+function assumptionFromJudgementNode(judgementNode, context) {
+  const assumptionNode = judgementNode.getAssumptionNode(),
+        assumption = context.findAssumptionByAssumptionNode(assumptionNode);
+
+  return assumption;
+}
+
 function referenceFromMetavariable(metavariable, context) {
   const { Reference } = elements,
         metavariableNode = metavariable.getNode(),

package/src/element/label.js

@@ -5,8 +5,7 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { literally } from "../utilities/context";
 import { instantiateLabel } from "../process/instantiate";
-import { metavariableToMetavariableJSON } from "../utilities/json";
-import { metavariableFromMetavariableNode } from "../utilities/element";
+import { metavariableFromLabelNode } from "../utilities/element";
 
 export default define(class Label extends Element {
   constructor(context, string, node, metavariable) {
@@ -42,7 +41,7 @@ export default define(class Label extends Element {
     return comparesToReference;
   }
 
-  verify(nameOnly) {
+  verify() {
     let verifies = false;
 
     const context = this.getContext(),
@@ -50,38 +49,55 @@ export default define(class Label extends Element {
 
     context.trace(`Verifying the '${labelString}' label...`);
 
-    let labelPresent;
+    const metavariableVerifies = this.verifyMetavariable();
 
-    if (nameOnly) {
-      const metavariableName = this.getMetavariableName();
+    if (metavariableVerifies) {
+      const metavariableName = this.getMetavariableName(),
+            labelPresent = context.isLabelPresentByMetavariableName(metavariableName);
 
-      labelPresent = context.isLabelPresentByMetavariableName(metavariableName);
-    } else {
-      const metavariable = this.getMetavariable();
+      if (!labelPresent) {
+        verifies = true;
+      } else {
+        context.debug(`The '${labelString}' label is already present.`);
+      }
+    }
 
-      labelPresent = context.isLabelPresentByMetavariable(metavariable);
+    if (verifies) {
+      context.debug(`...verified the '${labelString}' label.`);
     }
 
-    if (labelPresent) {
-      context.debug(`The '${labelString}' label is already present.`);
-    } else {
+    return verifies;
+  }
+
+  verifyMetavariable() {
+    let verifies = false;
+
+    const context = this.getContext(),
+          labelString = this.getString(), ///
+          metavariableString = this.metavariable.getString();
+
+    context.trace(`Verifying the '${labelString}' label's '${metavariableString}' metavariable...`);
+
+    const metavariableName = this.getMetavariableName(),
+          metavariablePresent = context.isMetavariablePresentByMetavariableName(metavariableName);
+
+    if (!metavariablePresent) {
       verifies = true;
+    } else {
+      context.debug(`The '${metavariableString}' metavariable is already present.`);
     }
 
     if (verifies) {
-      context.debug(`...verified the '${labelString}' label.`);
+      context.debug(`...verified the '${labelString}' label's '${metavariableString}' metavariable.`);
     }
 
     return verifies;
   }
 
   toJSON() {
-    const metavariableJSON = metavariableToMetavariableJSON(this.metavariable),
-          metavariable = metavariableJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
-            string,
-            metavariable
+            string
           };
 
     return json;
@@ -103,10 +119,3 @@ export default define(class Label extends Element {
     return label;
   }
 });
-
-function metavariableFromLabelNode(labelNode, context) {
-  const metavariableNode = labelNode.getMetavariableNode(),
-        metavariable = metavariableFromMetavariableNode(metavariableNode, context);
-
-  return metavariable;
-}

package/src/element/metaType.js

@@ -58,7 +58,7 @@ export default define(class MetaType extends Element {
   }
 
   static fromName(name, context) {
-    const string = name,
+    const string = name,  ///
           node = null,
           metaType = new MetaType(context, string, node, name);