occam-verify-cli 0.0.1068 → 0.0.1069

package/src/theorem.js

@@ -1,5 +1,6 @@
 "use strict";
 
+import shim from "./shim";
 import Label from "./label";
 import Proof from "./proof";
 import Consequent from "./consequent";
@@ -8,21 +9,21 @@ import LocalContext from "./context/local";
 import Substitutions from "./substitutions";
 import TopLevelAssertion from "./topLevelAssertion";
 
+import { stringFromLabels } from "./topLevelAssertion";
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import { labelsStringFromLabels } from "./topLevelAssertion";
 
 const proofNodeQuery = nodeQuery("/theorem/proof"),
       labelNodesQuery = nodesQuery("/theorem/label"),
       consequentNodeQuery = nodeQuery("/theorem/consequent"),
       suppositionNodesQuery = nodesQuery("/theorem/supposition");
 
-export default class Theorem extends TopLevelAssertion {
+class Theorem extends TopLevelAssertion {
   verify() {
     let verified = false;
 
-    const labelsString = labelsStringFromLabels(this.labels);
+    const theoremString = this.string;  ///
 
-    this.fileContext.trace(`Verifying the '${labelsString}' theorem...`);
+    this.fileContext.trace(`Verifying the '${theoremString}' theorem...`);
 
     const labelsVerifiedAtTopLevel = this.labels.every((label) => {
       const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
@@ -61,7 +62,7 @@ export default class Theorem extends TopLevelAssertion {
     }
 
     if (verified) {
-      this.fileContext.debug(`...verified the '${labelsString}' theorem.`);
+      this.fileContext.debug(`...verified the '${theoremString}' theorem.`);
     }
 
     return verified;
@@ -85,9 +86,16 @@ export default class Theorem extends TopLevelAssertion {
             return supposition;
           }),
           consequent = Consequent.fromConsequentNode(consequentNode, fileContext),
+          string = stringFromLabels(labels),
           proof = Proof.fromProofNode(proofNode, fileContext),
-          theorem = new Theorem(fileContext, labels, suppositions, consequent, proof);
+          theorem = new Theorem(fileContext, string, labels, suppositions, consequent, proof);
 
     return theorem;
   }
 }
+
+Object.assign(shim, {
+  Theorem
+});
+
+export default Theorem;

package/src/topLevelAssertion.js

@@ -2,16 +2,22 @@
 
 import { arrayUtilities } from "necessary";
 
-import Label from "./label";
-import Consequent from "./consequent";
-import Supposition from "./supposition";
 import Substitutions from "./substitutions";
 
+import { EMPTY_STRING } from "./constants";
+import { labelsFromJSON,
+         labelsToLabelsJSON,
+         consequentFromJSON,
+         suppositionsFromJSON,
+         consequentToConsequentJSON,
+         suppositionsToSuppositionsJSON } from "./utilities/json";
+
 const { reverse, correlate } = arrayUtilities;
 
 export default class TopLevelAssertion {
-  constructor(fileContext, labels, suppositions, consequent, proof) {
+  constructor(fileContext, string, labels, suppositions, consequent, proof) {
     this.fileContext = fileContext;
+    this.string = string;
     this.labels = labels;
     this.suppositions = suppositions;
     this.consequent = consequent;
@@ -22,6 +28,10 @@ export default class TopLevelAssertion {
     return this.fileContext;
   }
 
+  getString() {
+    return this.string;
+  }
+
   getLabels() {
     return this.labels;
   }
@@ -85,80 +95,44 @@ export default class TopLevelAssertion {
   }
 
   toJSON() {
-    const labelsJSON = this.labels.map((label) => {
-            const labelJSON = label.toJSON();
-
-            return labelJSON;
-          }),
-          suppositionsJSON = this.suppositions.map((supposition) => {
-            const suppositionJSON = supposition.toJSON();
-
-            return suppositionJSON;
-          }),
-          consequentJSON = this.consequent.toJSON(),
+    const labelsJSON = labelsToLabelsJSON(this.labels),
+          consequentJSON = consequentToConsequentJSON(this.consequent),
+          suppositionsJSON = suppositionsToSuppositionsJSON(this.suppositions),
           labels = labelsJSON,  ///
-          suppositions = suppositionsJSON,  ///
           consequent = consequentJSON,  ///
+          suppositions = suppositionsJSON,  ///
           json = {
             labels,
-            suppositions,
-            consequent
+            consequent,
+            suppositions
           };
 
     return json;
   }
 
   static fromJSON(Class, json, fileContext) {
-    let rule;
-
-    let { labels } = json;
-
-    const labelsJSON = labels;  ///
-
-    labels = labelsJSON.map((labelJSON) => {
-      const json = labelJSON, ///
-            label = Label.fromJSON(json, fileContext);
-
-      return label;
-    });
-
-    let { suppositions } = json;
-
-    const suppositionsJSON = suppositions;  ///
-
-    suppositions = suppositionsJSON.map((suppositionJSON) => {
-      const json = suppositionJSON, ///
-            supposition = Supposition.fromJSON(json, fileContext);
-
-      return supposition;
-    });
-
-    let { consequent } = json;
-
-    const consequentJSON = consequent;  ///
-
-    json = consequentJSON;  ///
-
-    consequent = Consequent.fromJSON(json, fileContext);
-
-    const proof = null;
-
-    rule = new Class(fileContext, labels, suppositions, consequent, proof);
-
-    return rule;
+    const labels = labelsFromJSON(json, fileContext),
+          consequent = consequentFromJSON(json, fileContext),
+          suppositions = suppositionsFromJSON(json, fileContext),
+          string = stringFromLabels(labels),
+          proof = null,
+          topLevelAssertion = new Class(fileContext, string, labels, suppositions, consequent, proof);
+
+    return topLevelAssertion;
   }
 }
 
-export function labelsStringFromLabels(labels) {
-  const labelsString = labels.reduce((labelsString, label) => {
+export function stringFromLabels(labels) {
+  const string = labels.reduce((string, label) => {
     const labelString = label.getString();
 
-    labelsString = (labelsString === null) ?
-                     labelString: ///
-                       `${labelString}, ${labelString}`;
+    string = (string === EMPTY_STRING) ?
+               labelString: ///
+                 `${labelString}, ${labelString}`;
+
+    return string;
+  }, EMPTY_STRING);
 
-    return labelsString;
-  }, null);
+  return string;
+}
 
-  return labelsString;
-}

package/src/type.js

@@ -5,6 +5,7 @@ import shim from "./shim";
 import { nodeQuery } from "./utilities/query";
 import { OBJECT_TYPE_NAME } from "./typeNames";
 import { typeNameFromTypeNode } from "./utilities/name";
+import { superTypeFromJSON, superTypeToSuperTypeJSON } from "./utilities/json";
 
 const typeNodeQuery = nodeQuery("/typeDeclaration/type[0]"),
       superTypeNodeQuery = nodeQuery("/typeDeclaration/type[1]");
@@ -155,9 +156,9 @@ class Type {
   }
 
   toJSON() {
-    const superTypeJSON = this.superType.toJSON(),
-          name = this.name,
+    const superTypeJSON = superTypeToSuperTypeJSON(this.superType),
           superType = superTypeJSON,  ///
+          name = this.name,
           json = {
             name,
             superType
@@ -229,8 +230,8 @@ export default Type;
 
 class ObjectType extends Type {
   toJSON() {
-    const name = this.name,
-          superType = null,
+    const superType = null,
+          name = this.name,
           json = {
             name,
             superType
@@ -250,19 +251,3 @@ class ObjectType extends Type {
 }
 
 export const objectType = ObjectType.fromNothing();
-
-function superTypeFromJSON(json, fileContext) {
-  let { superType } = json;
-
-  const superTypeJSON = superType;  ///
-
-  json = superTypeJSON; ///
-
-  const { name } = json,
-        typeName = name,  ///
-        type = fileContext.findTypeByTypeName(typeName);
-
-  superType = type; ///
-
-  return superType;
-}

package/src/unifier/metaLevel.js

@@ -82,7 +82,7 @@ class MetaLevelUnifier extends Unifier {
 
         const metavariableNode = frameMetavariableNodeA,  ///
               metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-              metavariablePresent = localContextA.findMetavariableByMetavariableName(metavariableName);
+              metavariablePresent = localContextA.isMetavariablePresentByMetavariableName(metavariableName);
 
         if (metavariablePresent) {
           const { Frame, Metavariable } = shim,
@@ -107,7 +107,7 @@ class MetaLevelUnifier extends Unifier {
               variableName = variableNameFromVariableNode(variableNode),
               variablePresent = localContextA.isVariablePresentByVariableName(variableName);
 
-        if (variablePresent !== null) {
+        if (variablePresent) {
           const { Term, Variable } = shim,
                 localContext = localContextB, ///
                 termNode = termNodeB, ///

package/src/unifier/metavariable.js

@@ -24,18 +24,18 @@ class MetavariableUnifier extends Unifier {
 
   static maps = [
     {
-      nodeQueryA: termNodeQuery,
-      nodeQueryB: typeNodeQuery,
-      unify: (termNodeA, typeNodeB, localContext) => {
+      nodeQueryA: typeNodeQuery,
+      nodeQueryB: termNodeQuery,
+      unify: (typeNodeA, termNodeB, localContext) => {
         let unified = false;
 
         const { Term } = shim,
-              typeNode = typeNodeB, ///
+              typeNode = typeNodeA, ///
               typeName = typeNameFromTypeNode(typeNode),
               type = localContext.findTypeByTypeName(typeName);
 
         if (type !== null) {
-          const termNode = termNodeA, ///
+          const termNode = termNodeB, ///
                 term = Term.fromTermNode(termNode, localContext),
                 termVerifiedGivenType = term.verifyGivenType(type, localContext);
 

package/src/unifier/statementWithCombinator.js

@@ -13,11 +13,11 @@ const termNodeQuery = nodeQuery("/term!"),
       statementNodeQuery = nodeQuery("/statement!");
 
 class StatementWithCombinatorUnifier extends Unifier {
-  unify(statementNode, combinatorStatementNode, assignments, stated, localContext) {
+  unify(combinatorStatementNode, statementNode, assignments, stated, localContext) {
     let statementUnifiedWithCombinator;
 
-    const nonTerminalNodeA = statementNode, ///
-          nonTerminalNodeB = combinatorStatementNode, ///
+    const nonTerminalNodeA = combinatorStatementNode, ///
+          nonTerminalNodeB = statementNode, ///
           nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, assignments, stated, localContext);
 
     statementUnifiedWithCombinator = nonTerminalNodeUnified; ///
@@ -27,14 +27,14 @@ class StatementWithCombinatorUnifier extends Unifier {
 
   static maps = [
     {
-      nodeQueryA: statementNodeQuery,
-      nodeQueryB: metaTypeNodeQuery,
-      unify: (statementNodeA, metaTypeNodeB, assignments, stated, localContext) => {
+      nodeQueryA: metaTypeNodeQuery,
+      nodeQueryB: statementNodeQuery,
+      unify: (metaTypeNodeA, statementNodeB, assignments, stated, localContext) => {
         let unified;
 
         const { Statement, MetaType } = shim,
-              metaTypeNode = metaTypeNodeB, ///
-              statementNode = statementNodeA, ///
+              metaTypeNode = metaTypeNodeA, ///
+              statementNode = statementNodeB, ///
               metaType = MetaType.fromMetaTypeNode(metaTypeNode, localContext),
               statement = Statement.fromStatementNode(statementNode, localContext),
               statementVerifiedGivenType = statement.verifyGivenMetaType(metaType, assignments, stated, localContext);
@@ -45,14 +45,14 @@ class StatementWithCombinatorUnifier extends Unifier {
       }
     },
     {
-      nodeQueryA: frameNodeQuery,
-      nodeQueryB: metaTypeNodeQuery,
-      unify: (frameNodeA, metaTypeNodeB, assignments, stated, localContext) => {
+      nodeQueryA: metaTypeNodeQuery,
+      nodeQueryB: frameNodeQuery,
+      unify: (metaTypeNodeA, frameNodeB, assignments, stated, localContext) => {
         let unified;
 
         const { Frame, MetaType } = shim,
-              metaTypeNode = metaTypeNodeB, ///
-              frameNode = frameNodeA, ///
+              metaTypeNode = metaTypeNodeA, ///
+              frameNode = frameNodeB, ///
               metaType = MetaType.fromMetaTypeNode(metaTypeNode, localContext),
               frame = Frame.fromFrameNode(frameNode, localContext),
               frameVerifiedGivenType = frame.verifyGivenMetaType(metaType, assignments, stated, localContext);
@@ -63,18 +63,18 @@ class StatementWithCombinatorUnifier extends Unifier {
       }
     },
     {
-      nodeQueryA: termNodeQuery,
-      nodeQueryB: typeNodeQuery,
-      unify: (termNodeA, typeNodeB, assignments, stated, localContext) => {
+      nodeQueryA: typeNodeQuery,
+      nodeQueryB: termNodeQuery,
+      unify: (typeNodeA, termNodeB, assignments, stated, localContext) => {
         let unified = false;
 
         const { Term } = shim,
-              typeNode = typeNodeB, ///
+              typeNode = typeNodeA, ///
               typeName = typeNameFromTypeNode(typeNode),
               type = localContext.findTypeByTypeName(typeName);
 
         if (type !== null) {
-          const termNode = termNodeA, ///
+          const termNode = termNodeB, ///
                 term = Term.fromTermNode(termNode, localContext),
                 termVerifiedGivenType = term.verifyGivenType(type, localContext);
 

package/src/unifier/termWithConstructor.js

@@ -10,11 +10,11 @@ const termNodeQuery = nodeQuery("/term"),
       typeNodeQuery = nodeQuery("/type");
 
 class TermWithConstructorUnifier extends Unifier {
-  unify(termNode, constructorTermNode, localContext) {
+  unify(constructorTermNode, termNode, localContext) {
     let termUnifiedWithConstructor;
 
-    const nonTerminalNodeA = termNode, ///
-          nonTerminalNodeB = constructorTermNode, ///
+    const nonTerminalNodeA = constructorTermNode, ///
+          nonTerminalNodeB = termNode, ///
           nonTerminalNodeUnified = this.unifyNonTerminalNode(nonTerminalNodeA, nonTerminalNodeB, localContext);
 
     termUnifiedWithConstructor = nonTerminalNodeUnified; ///
@@ -24,9 +24,9 @@ class TermWithConstructorUnifier extends Unifier {
 
   static maps = [
     {
-      nodeQueryA: termNodeQuery,
-      nodeQueryB: typeNodeQuery,
-      unify: (termNodeA, typeNodeB, localContext) => {
+      nodeQueryA: typeNodeQuery,
+      nodeQueryB: termNodeQuery,
+      unify: (typeNodeB, termNodeB, localContext) => {
         let unified = false;
 
         const { Term } = shim,
@@ -35,7 +35,7 @@ class TermWithConstructorUnifier extends Unifier {
               type = localContext.findTypeByTypeName(typeName);
 
         if (type !== null) {
-          const termNode = termNodeA, ///
+          const termNode = termNodeB, ///
                 term = Term.fromTermNode(termNode, localContext),
                 termVerifiedGivenType = term.verifyGivenType(type, localContext);
 

package/src/utilities/brackets.js

@@ -8,17 +8,17 @@ import { BRACKETED_TERM_DEPTH, BRACKETED_STATEMENT_DEPTH } from "../constants";
 const bracketedTermChildNodeQuery = nodeQuery("/term/argument/term!"),
       bracketedStatementChildNodeQuery = nodeQuery("/statement/metaArgument/statement!");
 
-export function stripBracketsFromTerm(statementNode) {
-  const bracketedTermChildNode = bracketedTermChildNodeFromTermNode(statementNode);
+export function stripBracketsFromTermNode(termNode) {
+  const bracketedTermChildNode = bracketedTermChildNodeFromTermNode(termNode);
 
   if (bracketedTermChildNode !== null) {
-    statementNode = bracketedTermChildNode;  ///
+    termNode = bracketedTermChildNode;  ///
   }
 
-  return statementNode;
+  return termNode;
 }
 
-export function stripBracketsFromStatement(statementNode) {
+export function stripBracketsFromStatementNode(statementNode) {
   const bracketedStatementChildNode = bracketedStatementChildNodeFromStatementNode(statementNode);
 
   if (bracketedStatementChildNode !== null) {