occam-verify-cli 1.0.695 → 1.0.702

package/src/element/statement.js

@@ -350,8 +350,11 @@ export default define(class Statement extends Element {
     const statement = literally((context) => {
       const { string } = json,
             statementNode = instantiateStatement(string, context),
-            node = statementNode, ///
-            statement = new Statement(context, string, node);
+            node = statementNode; ///
+
+      context = null;
+
+      const statement = new Statement(context, string, node);
 
       return statement;
     }, context);

package/src/element/substitution/frame.js

@@ -4,7 +4,6 @@ import Substitution from "../substitution";
 
 import { define } from "../../elements";
 import { literally } from "../../utilities/context";
-import { frameToFrameJSON } from "../../utilities/json";
 import { instantiateFrameSubstitution } from "../../process/instantiate";
 import { frameSubstitutionStringFromFrameAndMetavariable } from "../../utilities/string";
 import { frameSubstitutionFromStatementNode, frameSubstitutionFromFrameSubstitutionNode } from "../../utilities/element";
@@ -173,16 +172,10 @@ export default define(class FrameSubstitution extends Substitution {
 
   toJSON() {
     const { name } = this.constructor,
-          targetFrameJSON = frameToFrameJSON(this.targetFrame),
-          replacementFrameJSON = frameToFrameJSON(this.replacementFrame),
-          targetFrame = targetFrameJSON,  ///
-          replacementFrame = replacementFrameJSON,  ///
           string = this.getString(),
           json = {
             name,
-            string,
-            targetFrame,
-            replacementFrame
+            string
           };
 
     return json;
@@ -196,7 +189,17 @@ export default define(class FrameSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      debugger
+      literally((context) => {
+        const { string } = json,
+              frameSubstitutionNode = instantiateFrameSubstitution(string, context),
+              node = frameSubstitutionNode,  ///
+              targetFrame = targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context),
+              replacementFrame = replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, context);
+
+        context = null;
+
+        frameSubstitutionn = new FrameSubstitution(context, string, node, targetFrame, replacementFrame);
+      }, context);
     }
 
     return frameSubstitutionn;
@@ -220,3 +223,17 @@ export default define(class FrameSubstitution extends Substitution {
     }, context);
   }
 });
+
+function targetFrameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
+  const targetFrameNode = frameSubstitutionNode.getTargetFrameNode(),
+        targetFrame = context.findFrameByFrameNode(targetFrameNode);
+
+  return targetFrame;
+}
+
+function replacementFrameFromFrameSubstitutionNode(frameSubstitutionNode, context) {
+  const replacementFrameNode = frameSubstitutionNode.getReplacementFrameNode(),
+        replacementFrame = context.findFrameByFrameNode(replacementFrameNode);
+
+  return replacementFrame;
+}

package/src/element/substitution/reference.js

@@ -4,7 +4,6 @@ import Substitution from "../substitution";
 
 import { define } from "../../elements";
 import { literally } from "../../utilities/context";
-import { statementToStatementJSON } from "../../utilities/json";
 import { instantiateReferenceSubstitution } from "../../process/instantiate";
 import { referenceSubstitutionFromReferenceSubstitutionNode } from "../../utilities/element";
 import { referenceSubstitutionStringFromReferenceAndMetavariable } from "../../utilities/string";
@@ -167,34 +166,39 @@ export default define(class ReferenceSubstitution extends Substitution {
 
   toJSON() {
     const { name } = this.constructor,
-          targetStatementJSON = statementToStatementJSON(this.targetStatement),
-          replacementStatementJSON = statementToStatementJSON(this.replacementStatement),
-          targetStatement = targetStatementJSON,  ///
-          replacementStatement = replacementStatementJSON,  ///
           string = this.getString(),
           json = {
             name,
-            string,
-            targetStatement,
-            replacementStatement
+            string
           };
 
     return json;
   }
+
+  static name = "ReferenceSubstitution";
+
   static fromJSON(json, context) {
     let referenceSubstitutionn = null;
 
     const { name } = json;
 
     if (this.name === name) {
-      debugger
+      literally((context) => {
+        const { string } = json,
+              referenceSubstitutionNode = instantiateReferenceSubstitution(string, context),
+              node = referenceSubstitutionNode,  ///
+              targetReference = targetReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
+              replacementReference = replacementReferenceFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
+
+        context = null;
+
+        referenceSubstitutionn = new ReferenceSubstitution(context, string, node, targetReference, replacementReference);
+      }, context);
     }
 
     return referenceSubstitutionn;
   }
 
-  static name = "ReferenceSubstitution";
-
   static fromReferenceAndMetavariable(reference, metavariable, context) {
     return literally((context) => {
       const referenceSubstitutionString = referenceSubstitutionStringFromReferenceAndMetavariable(reference, metavariable),
@@ -206,3 +210,17 @@ export default define(class ReferenceSubstitution extends Substitution {
     }, context);
   }
 });
+
+function targetReferenceFromReferenceSubstitutionNode(frameSubstitutionNode, context) {
+  const targetReferenceNode = frameSubstitutionNode.getTargetReferenceNode(),
+        targetReference = context.findReferenceByReferenceNode(targetReferenceNode);
+
+  return targetReference;
+}
+
+function replacementReferenceFromReferenceSubstitutionNode(frameSubstitutionNode, context) {
+  const replacementReferenceNode = frameSubstitutionNode.getReplacementReferenceNode(),
+        replacementReference = context.findReferenceByReferenceNode(replacementReferenceNode);
+
+  return replacementReference;
+}

package/src/element/substitution/statement.js

@@ -4,11 +4,10 @@ import Substitution from "../substitution";
 
 import { define } from "../../elements";
 import { unifySubstitution } from "../../process/unify";
-import { statementToStatementJSON } from "../../utilities/json";
 import { stripBracketsFromStatement } from "../../utilities/brackets";
-import { instantiateStatementSubstitution } from "../../process/instantiate";
 import { liminally, literally, synthetically } from "../../utilities/context";
 import { statementSubstitutionFromStatementSubstitutionNode } from "../../utilities/element";
+import { instantiateReferenceSubstitution, instantiateStatementSubstitution } from "../../process/instantiate";
 import { statementSubstitutionStringFromStatementAndMetavariable, statementSubstitutionStringFromStatementMetavariableAndSubstitution } from "../../utilities/string";
 
 export default define(class StatementSubstitution extends Substitution {
@@ -322,16 +321,10 @@ export default define(class StatementSubstitution extends Substitution {
 
   toJSON() {
     const { name } = this.constructor,
-          targetStatementJSON = statementToStatementJSON(this.targetStatement),
-          replacementStatementJSON = statementToStatementJSON(this.replacementStatement),
-          targetStatement = targetStatementJSON,  ///
-          replacementStatement = replacementStatementJSON,  ///
           string = this.getString(),
           json = {
             name,
-            string,
-            targetStatement,
-            replacementStatement
+            string
           };
 
     return json;
@@ -345,7 +338,17 @@ export default define(class StatementSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      debugger
+      literally((context) => {
+        const { string } = json,
+              referenceSubstitutionNode = instantiateReferenceSubstitution(string, context),
+              node = referenceSubstitutionNode,  ///
+              targetStatement = targetStatementFromReferenceSubstitutionNode(referenceSubstitutionNode, context),
+              replacementStatement = replacementStatementFromReferenceSubstitutionNode(referenceSubstitutionNode, context);
+
+        context = null;
+
+        statementSubstitutionn = new StatementSubstitution(context, string, node, targetStatement, replacementStatement);
+      }, context);
     }
 
     return statementSubstitutionn;
@@ -377,3 +380,17 @@ export default define(class StatementSubstitution extends Substitution {
     }, context);
   }
 });
+
+function targetStatementFromReferenceSubstitutionNode(frameSubstitutionNode, context) {
+  const targetStatementNode = frameSubstitutionNode.getTargetReferenceNode(),
+        targetStatement = context.findReferenceByReferenceNode(targetStatementNode);
+
+  return targetStatement;
+}
+
+function replacementStatementFromReferenceSubstitutionNode(frameSubstitutionNode, context) {
+  const replacementStatementNode = frameSubstitutionNode.getReplacementReferenceNode(),
+        replacementStatement = context.findReferenceByReferenceNode(replacementStatementNode);
+
+  return replacementStatement;
+}

package/src/element/substitution/term.js

@@ -4,10 +4,9 @@ import Substitution from "../substitution";
 
 import { define } from "../../elements";
 import { literally } from "../../utilities/context";
-import { termToTermJSON } from "../../utilities/json";
 import { stripBracketsFromTerm } from "../../utilities/brackets";
-import { instantiateTermSubstitution } from "../../process/instantiate";
 import { termSubstitutionStringFromTermAndVariable } from "../../utilities/string";
+import { instantiateFrameSubstitution, instantiateTermSubstitution } from "../../process/instantiate";
 import { termSubstitutionFromStatementNode, termSubstitutionFromTermSubstitutionNode } from "../../utilities/element";
 
 export default define(class TermSubstitution extends Substitution {
@@ -182,16 +181,10 @@ export default define(class TermSubstitution extends Substitution {
 
   toJSON() {
     const { name } = this.constructor,
-          targetTermJSON = termToTermJSON(this.targetTerm),
-          replacementTermJSON = termToTermJSON(this.replacementTerm),
-          targetTerm = targetTermJSON,  ///
-          replacementTerm = replacementTermJSON,  ///
           string = this.getString(),
           json = {
             name,
-            string,
-            targetTerm,
-            replacementTerm
+            string
           };
 
     return json;
@@ -205,7 +198,17 @@ export default define(class TermSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      debugger
+      literally((context) => {
+        const { string } = json,
+              frameSubstitutionNode = instantiateFrameSubstitution(string, context),
+              node = frameSubstitutionNode,  ///
+              targetTerm = targetTermFromFrameSubstitutionNode(frameSubstitutionNode, context),
+              replacementTerm = replacementTermFromFrameSubstitutionNode(frameSubstitutionNode, context);
+
+        context = null;
+
+        termSubstitutionn = new TermSubstitution(context, string, node, targetTerm, replacementTerm);
+      }, context);
     }
 
     return termSubstitutionn;
@@ -231,3 +234,17 @@ export default define(class TermSubstitution extends Substitution {
     }, context);
   }
 });
+
+function targetTermFromFrameSubstitutionNode(frameSubstitutionNode, context) {
+  const targetTermNode = frameSubstitutionNode.getTargetFrameNode(),
+        targetTerm = context.findFrameByFrameNode(targetTermNode);
+
+  return targetTerm;
+}
+
+function replacementTermFromFrameSubstitutionNode(frameSubstitutionNode, context) {
+  const replacementTermNode = frameSubstitutionNode.getReplacementFrameNode(),
+        replacementTerm = context.findFrameByFrameNode(replacementTermNode);
+
+  return replacementTerm;
+}

package/src/element/term.js

@@ -241,8 +241,11 @@ export default define(class Term extends Element {
       const { string } = json,
             termNode = instantiateTerm(string, context),
             node = termNode,  ///
-            type = typeFromJSON(json, context),
-            term = new Term(context, string, node, type);
+            type = typeFromJSON(json, context);
+
+      context = null;
+
+      const term = new Term(context, string, node, type);
 
       return term;
     }, context);

package/src/element/topLevelAssertion.js

@@ -5,6 +5,7 @@ import { arrayUtilities } from "necessary";
 import { asynchronousUtilities } from "occam-languages";
 
 import { asyncScope } from "../utilities/context";
+import { topLevelAssertionStringFromLabelsSuppositionsAndDeduction } from "../utilities/string";
 import { labelsFromJSON,
          deductionFromJSON,
          signatureFromJSON,
@@ -122,30 +123,6 @@ export default class TopLevelAssertion extends Element {
     return correlatesToHypotheses;
   }
 
-  verifyLabels() {
-    let labelsVerify;
-
-    const context = this.getContext(),
-          topLevelAssertionString = this.getString();
-
-    context.trace(`Verifying the '${topLevelAssertionString}' top level assertion's labels...`);
-
-    labelsVerify = this.labels.every((label) => {
-      const nameOnly = true,
-            labelVerifies = label.verify(nameOnly);
-
-      if (labelVerifies) {
-        return true;
-      }
-    });
-
-    if (labelsVerify) {
-      context.debug(`...verified the '${topLevelAssertionString}' top level assertion's labels.`);
-    }
-
-    return labelsVerify;
-  }
-
   unifyStatementWithDeduction(statement, context) {
     let statementUnifiesWithDeduction = false;
 
@@ -203,6 +180,47 @@ export default class TopLevelAssertion extends Element {
     return verifies;
   }
 
+  verifyLabels() {
+    let labelsVerify;
+
+    const context = this.getContext(),
+          topLevelAssertionString = this.getString();  ///
+
+    context.trace(`Verifying the '${topLevelAssertionString}' top level assertion's labels...`);
+
+    labelsVerify = this.labels.every((label) => {
+      const labelVerifies = this.verifyLabel(label);
+
+      if (labelVerifies) {
+        return true;
+      }
+    });
+
+    if (labelsVerify) {
+      context.debug(`...verified the '${topLevelAssertionString}' top level assertion's labels.`);
+    }
+
+    return labelsVerify;
+  }
+
+  verifyLabel(label) {
+    let labelVerifies;
+
+    const context = this.getContext(),
+          labelString = label.getString(),
+          topLevelAssertionString = this.getString(); ///
+
+    context.trace(`Verifying the '${topLevelAssertionString}' top level assertion's '${labelString}' label...`);
+
+    labelVerifies = label.verify();
+
+    if (labelVerifies) {
+      context.debug(`...verified the '${topLevelAssertionString}' top level assertion's '${labelString}' label.`);
+    }
+
+    return labelVerifies;
+  }
+
   async verifyProof(context) {
     let proofVerifies;
 
@@ -375,9 +393,10 @@ export default class TopLevelAssertion extends Element {
           suppositions = suppositionsFromJSON(json, context),
           signature = signatureFromJSON(json, context),
           hypotheses = hypothesesFromJSON(json, context),
+          topLevelAssertionString = topLevelAssertionStringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
           node = null,
           proof = null,
-          string = stringFromLabelsSuppositionsAndDeduction(labels, suppositions, deduction),
+          string = topLevelAssertionString, ///
           topLevelAssertion = new Class(context, string, node, labels, suppositions, deduction, proof, signature, hypotheses);
 
     return topLevelAssertion;

package/src/element/topLevelMetaAssertion.js

@@ -92,16 +92,15 @@ export default class TopLevelMetaAssertion extends Element {
     let labelVerifies;
 
     const context = this.getContext(),
-          topLevelMetaAssertionString = this.getString(); ///
-
-    context.trace(`Verifiesing the '${topLevelMetaAssertionString}' top level meta assertion's label...`);
+          topLevelMetaAssertionString = this.getString(),  ///
+          labelString = this.label.getString();
 
-    const nameOnly = true;
+    context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta-assertion's '${labelString}' label...`);
 
-    labelVerifies = this.label.verify(nameOnly);
+    labelVerifies = this.label.verify();
 
     if (labelVerifies) {
-      context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta assertion's label.`);
+      context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta-assertion's '${labelString}' label.`);
     }
 
     return labelVerifies;
@@ -115,14 +114,14 @@ export default class TopLevelMetaAssertion extends Element {
     } else {
       const topLevelMetaAssertionString = this.getString();  ///
 
-      context.trace(`Verifying the '${topLevelMetaAssertionString}' top meta level assertion's proof...`);
+      context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta-assertion's proof...`);
 
       const statement = this.deduction.getStatement();
 
       proofVerifies = this.proof.verify(statement, context);
 
       if (proofVerifies) {
-        context.debug(`...verified the '${topLevelMetaAssertionString}' top meta level assertion's proof.`);
+        context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta-assertion's proof.`);
       }
     }
 

package/src/element/type.js

@@ -4,8 +4,11 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
+import { literally } from "../utilities/context";
+import { instantiateType } from "../process/instantiate";
 import { baseTypeFromNothing } from "../utilities/type";
-import { nameToNameJSON, superTypesToSuperTypesJSON, propertiesToPropertiesJSON, provisionalToProvisionalJSON } from "../utilities/json";
+import { superTypesFromJSON, superTypesToSuperTypesJSON } from "../utilities/json";
+import { nameFromTypeNode, prefixNameFromTypeNode, propertiesFromTypeNode, provisionalFromTypeNode } from "../utilities/element";
 
 const { push, first } = arrayUtilities;
 
@@ -292,24 +295,12 @@ export default define(class Type extends Element {
   }
 
   toJSON() {
-    const nameJSON = nameToNameJSON(this.name),
-          prefixNameJSON = nameToNameJSON(this.prefixName),
-          propertiesJSON = propertiesToPropertiesJSON(this.properties),
-          superTypesJSON = superTypesToSuperTypesJSON(this.superTypes),
-          provisionalJSON = provisionalToProvisionalJSON(this.provisional),
-          name = nameJSON,  ///
-          prefixName = prefixNameJSON,  ///
-          properties = propertiesJSON,  ///
-          superTypes = superTypesJSON,  ///
-          provisional = provisionalJSON,  ///
+    const superTypesJSON = superTypesToSuperTypesJSON(this.superTypes),
+          superTypes = superTypesJSON,
           string = this.getString(),
           json = {
             string,
-            name,
-            prefixName,
-            properties,
-            superTypes,
-            provisional
+            superTypes
           };
 
     return json;
@@ -318,7 +309,24 @@ export default define(class Type extends Element {
   static name = "Type";
 
   static fromJSON(json, context) {
-    debugger
+    const type = literally((context) => {
+      const { string } = json,
+            typeNode = instantiateType(string, context),
+            node = typeNode, ///
+            name = nameFromTypeNode(typeNode, context),
+            prefixName = prefixNameFromTypeNode(typeNode, context),
+            superTypes = superTypesFromJSON(json, context),
+            properties = propertiesFromTypeNode(typeNode, context),
+            provisional = provisionalFromTypeNode(typeNode, context);
+
+      context = null; ///
+
+      const type = new Type(context, string, node, name, prefixName, superTypes, properties, provisional);
+
+      return type;
+    }, context);
+
+    return type;
   }
 
   static fromName(name, context) {
@@ -327,8 +335,11 @@ export default define(class Type extends Element {
           prefixName = null,
           superTypes = [],
           properties = [],
-          provisional = false,
-          type = new Type(context, string, node, name, prefixName, superTypes, properties, provisional);
+          provisional = false;
+
+    context = null;
+
+    const type = new Type(context, string, node, name, prefixName, superTypes, properties, provisional);
 
     return type;
   }

package/src/element/typePrefix.js

@@ -3,7 +3,9 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import {nameToNameJSON} from "../utilities/json";
+import { literally } from "../utilities/context";
+import { instantiateTypePrefix } from "../process/instantiate";
+import { nameFromTypePrefixNode } from "../utilities/element";
 
 export default define(class TypePrefix extends Element {
   constructor(context, string, node, name) {
@@ -30,12 +32,9 @@ export default define(class TypePrefix extends Element {
   }
 
   toJSON() {
-    const nameJSON = nameToNameJSON(this.name),
-          name = nameJSON,  ///
-          string = this.getString(),
+    const string = this.getString(),
           json = {
-            string,
-            name
+            string
           };
 
     return json;
@@ -44,6 +43,19 @@ export default define(class TypePrefix extends Element {
   static name = "TypePrefix";
 
   static fromJSON(json, context) {
-    debugger
+    const typePrefix = literally((context) => {
+      const { string } = json,
+            typePrefixNode = instantiateTypePrefix(string, context),
+            node = typePrefixNode, ///
+            name = nameFromTypePrefixNode(typePrefixNode, context);
+
+      context = null; ///
+
+      const typePrefix = new TypePrefix(context, string, node, name);
+
+      return typePrefix;
+    }, context);
+
+    return typePrefix;
   }
 });

package/src/element/variable.js

@@ -7,20 +7,15 @@ import elements from "../elements";
 import { define } from "../elements";
 import { literally } from "../utilities/context";
 import { instantiateVariable } from "../process/instantiate";
-import { typeFromJSON,
-         typeToTypeJSON,
-         identifierFromJSON,
-         propertyRelationsFromJSON,
-         identifierToIdentifierJSON,
-         propertyRelationsToPropertyRelationsJSON } from "../utilities/json";
+import { identifierFromVarialbeNode } from "../utilities/element";
+import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
 export default define(class Variable extends Element {
-  constructor(context, string, node, type, identifier, propertyRelations) {
+  constructor(context, string, node, type, identifier) {
     super(context, string, node);
 
     this.type = type;
     this.identifier = identifier;
-    this.propertyRelations = propertyRelations;
   }
 
   getIdentifier() {
@@ -31,10 +26,6 @@ export default define(class Variable extends Element {
     return this.type;
   }
 
-  getPropertyRelations() {
-    return this.propertyRelations;
-  }
-
   setType(type) {
     this.type = type;
   }
@@ -196,17 +187,11 @@ export default define(class Variable extends Element {
 
   toJSON() {
     const typeJSON = typeToTypeJSON(this.type),
-          identifierJSON = identifierToIdentifierJSON(this.identifier),
-          propertyRelationsJSON = propertyRelationsToPropertyRelationsJSON(this.propertyRelations),
           type = typeJSON,  ///
-          identifier = identifierJSON,  ///
-          propertyRelations = propertyRelationsJSON,  ///
           string = this.getString(), ///
           json = {
             string,
-            type,
-            identifier,
-            propertyRelations
+            type
           };
 
     return json;
@@ -220,9 +205,11 @@ export default define(class Variable extends Element {
             variableNode = instantiateVariable(string, context),
             node = variableNode,  ///
             type = typeFromJSON(json, context),
-            identifier = identifierFromJSON(json, context),
-            propertyRelations = propertyRelationsFromJSON(json, context),
-            variable = new Variable(context, string, node, type, identifier, propertyRelations);
+            identifier = identifierFromVarialbeNode(variableNode, context);
+
+      context = null;
+
+      const variable = new Variable(context, string, node, type, identifier);
 
       return variable;
     }, context);