occam-verify-cli 0.0.543 → 0.0.544

package/src/context/file.js

@@ -16,16 +16,6 @@ import Metavariable from "../metavariable";
 import { push, filter } from "../utilities/array";
 import { statementMetaType } from "../metaType";
 import { nodeAsString, nodesAsString } from "../utilities/string";
-import { TYPE_KIND,
-         RULE_KIND,
-         AXIOM_KIND,
-         LEMMA_KIND,
-         THEOREM_KIND,
-         VARIABLE_KIND,
-         CONJECTURE_KIND,
-         COMBINATOR_KIND,
-         CONSTRUCTOR_KIND,
-         METAVARIABLE_KIND } from "../kinds";
 
 const metaTypes = [
   statementMetaType
@@ -502,159 +492,185 @@ export default class FileContext {
   fatal(message, node) { this.releaseContext.fatal(message, node, this.tokens, this.filePath); }
 
   toJSON() {
-    const json = [];
+    const filePath =  this.filePath,
+          types = this.types.map((type) => {
+            const typeJSON = type.toJSON(this.tokens);
 
-    this.types.forEach((type) => {
-      const typeJSON = type.toJSON(this.tokens);
+            type = typeJSON; ///
 
-      json.push(typeJSON);
-    });
+            return type;
+          }),
+          rules = this.rules.map((rule) => {
+            const ruleJSON = rule.toJSON(this.tokens);
 
-    this.rules.forEach((rule) => {
-      const ruleJSON = rule.toJSON(this.tokens);
+            rule = ruleJSON; ///
 
-      json.push(ruleJSON);
-    });
+            return rule;
+          }),
+          axioms = this.axioms.map((axiom) => {
+            const axiomJSON = axiom.toJSON(this.tokens);
 
-    this.axioms.forEach((axiom) => {
-      const axiomJSON = axiom.toJSON(this.tokens);
+            axiom = axiomJSON; ///
 
-      json.push(axiomJSON);
-    });
+            return axiom;
+          }),
+          lemmas = this.lemmas.map((lemma) => {
+            const lemmaJSON = lemma.toJSON(this.tokens);
 
-    this.lemmas.forEach((lemma) => {
-      const lemmaJSON = lemma.toJSON(this.tokens);
+            lemma = lemmaJSON; ///
 
-      json.push(lemmaJSON);
-    });
+            return lemma;
+          }),
+          theorems = this.theorems.map((theorem) => {
+            const theoremJSON = theorem.toJSON(this.tokens);
 
-    this.theorems.forEach((theorem) => {
-      const theoremJSON = theorem.toJSON(this.tokens);
+            theorem = theoremJSON; ///
 
-      json.push(theoremJSON);
-    });
+            return theorem;
+          }),
+          variables = this.variables.map((variable) => {
+            const variableJSON = variable.toJSON(this.tokens);
 
-    this.variables.forEach((variable) => {
-      const variableJSON = variable.toJSON(this.tokens);
+            variable = variableJSON;  ///
 
-      json.push(variableJSON)
-    });
+            return variable;
+          }),
+          conjectures = this.conjectures.map((conjecture) => {
+            const conjectureJSON = conjecture.toJSON(this.tokens);
 
-    this.conjectures.forEach((conjecture) => {
-      const conjectureJSON = conjecture.toJSON(this.tokens);
+            conjecture = conjectureJSON; ///
 
-      json.push(conjectureJSON);
-    });
+            return conjecture;
+          }),
+          combinators = this.combinators.map((combinator) => {
+            const combinatorJSON = combinator.toJSON(this.tokens);
 
-    this.combinators.forEach((combinator) => {
-      const combinatorJSON = combinator.toJSON(this.tokens);
+            combinator = combinatorJSON; ///
 
-      json.push(combinatorJSON);
-    });
+            return combinator;
+          }),
+          constructors = this.constructors.map((constructor) => {
+            const constructorJSON = constructor.toJSON(this.tokens);
 
-    this.constructors.forEach((constructor) => {
-      const constructorJSON = constructor.toJSON(this.tokens);
+            constructor = constructorJSON;  ///
 
-      json.push(constructorJSON)
-    });
+            return constructor;
+          }),
+          metavariables = this.metavariables.map((metavariable) => {
+            const metavariableJSON = metavariable.toJSON(this.tokens);
 
-    this.metavariables.forEach((metavariable) => {
-      const metavariableJSON = metavariable.toJSON(this.tokens);
+            metavariable = metavariableJSON;  ///
 
-      json.push(metavariableJSON)
-    });
+            return metavariable;
+          }),
+          json = {
+            filePath,
+            types,
+            rules,
+            axioms,
+            lemmas,
+            theorems,
+            variables,
+            conjectures,
+            combinators,
+            constructors,
+            metavariables
+          };
 
     return json;
   }
 
   initialise(json) {
-    const jsonArray = json, ///
-          fileContext = this; ///
-
-    jsonArray.forEach((json) => {
-      const { kind } = json;
-
-      switch (kind) {
-        case TYPE_KIND: {
-          const type = Type.fromJSONAndFileContext(json, fileContext);
-
-          this.types.push(type);
-
-          break;
-        }
-
-        case RULE_KIND: {
-          const rule = Rule.fromJSONAndFileContext(json, fileContext);
-
-          this.rules.push(rule);
-
-          break;
-        }
-
-        case AXIOM_KIND: {
-          const axiom = Axiom.fromJSONAndFileContext(json, fileContext);
-
-          this.axioms.push(axiom);
-
-          break;
-        }
-
-        case LEMMA_KIND: {
-          const lemma = Lemma.fromJSONAndFileContext(json, fileContext);
-
-          this.lemmas.push(lemma);
-
-          break;
-        }
+    const fileContext = this, ///
+          { types,
+            rules,
+            axioms,
+            lemmas,
+            theorems,
+            variables,
+            conjectures,
+            combinators,
+            constructors,
+            metavariables } = json,
+          typesJSON = types,
+          rulesJSON = rules,
+          axiomsJSON = axioms,
+          lemmasJSON = lemmas,
+          theoremsJSON = theorems,
+          variablesJSON = variables,
+          conjecturesJSON = conjectures,
+          combinatorsJSON = combinators,
+          constructorsJSON = constructors,
+          metavariablesJSON = metavariables;
+
+    typesJSON.forEach((typeJSON) => {
+      const json = typeJSON,  ///
+            type = Type.fromJSONAndFileContext(json, fileContext);
+
+      this.types.push(type);
+    });
 
-        case THEOREM_KIND: {
-          const theorem = Theorem.fromJSONAndFileContext(json, fileContext);
+    rulesJSON.forEach((ruleJSON) => {
+      const json = ruleJSON,  ///
+            rule = Rule.fromJSONAndFileContext(json, fileContext);
 
-          this.theorems.push(theorem);
+      this.rules.push(rule);
+    });
 
-          break;
-        }
+    axiomsJSON.forEach((axiomJSON) => {
+      const json = axiomJSON,  ///
+            axiom = Axiom.fromJSONAndFileContext(json, fileContext);
 
-        case VARIABLE_KIND: {
-          const variable = Variable.fromJSONAndFileContext(json, fileContext);
+      this.axioms.push(axiom);
+    });
 
-          this.variables.push(variable);
+    lemmasJSON.forEach((lemmaJSON) => {
+      const json = lemmaJSON,  ///
+            lemma = Lemma.fromJSONAndFileContext(json, fileContext);
 
-          break;
-        }
+      this.lemmas.push(lemma);
+    });
 
-        case CONJECTURE_KIND: {
-          const conjecture = Conjecture.fromJSONAndFileContext(json, fileContext);
+    theoremsJSON.forEach((theoremJSON) => {
+      const json = theoremJSON,  ///
+            theorem = Theorem.fromJSONAndFileContext(json, fileContext);
 
-          this.conjectures.push(conjecture);
+      this.theorems.push(theorem);
+    });
 
-          break;
-        }
+    variablesJSON.forEach((variableJSON) => {
+      const json = variableJSON,  ///
+            variable = Variable.fromJSONAndFileContext(json, fileContext);
 
-        case COMBINATOR_KIND: {
-          const combinator = Combinator.fromJSONAndFileContext(json, fileContext);
+      this.variables.push(variable);
+    });
 
-          this.combinators.push(combinator);
+    conjecturesJSON.forEach((conjectureJSON) => {
+      const json = conjectureJSON,  ///
+            conjecture = Conjecture.fromJSONAndFileContext(json, fileContext);
 
-          break;
-        }
+      this.conjectures.push(conjecture);
+    });
 
-        case CONSTRUCTOR_KIND: {
-          const constructor = Constructor.fromJSONAndFileContext(json, fileContext);
+    combinatorsJSON.forEach((combinatorJSON) => {
+      const json = combinatorJSON,  ///
+            combinator = Combinator.fromJSONAndFileContext(json, fileContext);
 
-          this.constructors.push(constructor);
+      this.combinators.push(combinator);
+    });
 
-          break;
-        }
+    constructorsJSON.forEach((constructorJSON) => {
+      const json = constructorJSON,  ///
+            constructor = Constructor.fromJSONAndFileContext(json, fileContext);
 
-        case METAVARIABLE_KIND: {
-          const metavariable = Metavariable.fromJSONAndFileContext(json, fileContext);
+      this.constructors.push(constructor);
+    });
 
-          this.metavariables.push(metavariable);
+    metavariablesJSON.forEach((metavariableJSON) => {
+      const json = metavariableJSON,  ///
+            metavariable = Metavariable.fromJSONAndFileContext(json, fileContext);
 
-          break;
-        }
-      }
+      this.metavariables.push(metavariable);
     });
   }
 

package/src/lemma.js

@@ -2,11 +2,7 @@
 
 import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
 
-import { LEMMA_KIND } from "./kinds";
-
 export default class Lemma extends AxiomLemmaTheoremConjecture {
-  static kind = LEMMA_KIND;
-
   static fromJSONAndFileContext(json, fileContext) { return AxiomLemmaTheoremConjecture.fromJSONAndFileContext(Lemma,json, fileContext); }
 
   static fromLabelsSuppositionsConsequenceAndProofContext(labels, suppositions, consequence, proofContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequenceAndProofContext(Lemma, labels, suppositions, consequence, proofContext); }

package/src/metaType.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import { META_TYPE_KIND } from "./kinds";
 import { STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
 
 export default class MetaType {
@@ -44,10 +43,8 @@ export default class MetaType {
   }
 
   toJSON(tokens) {
-    const kind = META_TYPE_KIND,
-          name = this.name,
+    const name = this.name,
           json = {
-            kind,
             name
           };
 

package/src/metavariable.js

@@ -2,8 +2,6 @@
 
 import MetaType from "./metaType";
 
-import { METAVARIABLE_KIND } from "./kinds";
-
 export default class Metavariable {
   constructor(name, metaType) {
     this.name = name;
@@ -26,11 +24,9 @@ export default class Metavariable {
 
   toJSON(tokens) {
     const metaTypeJSON = this.metaType.toJSON(tokens),
-          kind = METAVARIABLE_KIND,
           name = this.name, ///
           metaType = metaTypeJSON,  ///
           json = {
-            kind,
             name,
             metaType
           };

package/src/rule.js

@@ -5,7 +5,6 @@ import Premise from "./premise";
 import Conclusion from "./conclusion";
 
 import { prune } from "./utilities/array";
-import { RULE_KIND } from "./kinds";
 import { someSubArray } from "./utilities/array";
 
 export default class Rule {
@@ -125,12 +124,10 @@ export default class Rule {
             return premiseJSON;
           }),
           conclusionJSON = this.conclusion.toJSON(tokens),
-          kind = RULE_KIND,
           labels = labelsJSON,  ///
           premises = premisesJSON,  ///
           conclusion = conclusionJSON,  ///
           json = {
-            kind,
             labels,
             premises,
             conclusion

package/src/theorem.js

@@ -2,11 +2,7 @@
 
 import AxiomLemmaTheoremConjecture from "./axiomLemmaTheoremConjecture";
 
-import { THEOREM_KIND } from "./kinds";
-
 export default class Theorem extends AxiomLemmaTheoremConjecture {
-  static kind = THEOREM_KIND;
-
   static fromJSONAndFileContext(json, fileContext) { return AxiomLemmaTheoremConjecture.fromJSONAndFileContext(Theorem, json, fileContext); }
 
   static fromLabelsSuppositionsConsequenceAndProofContext(labels, suppositions, consequence, proofContext) { return AxiomLemmaTheoremConjecture.fromLabelsSuppositionsConsequenceAndProofContext(Theorem, labels, suppositions, consequence, proofContext); }

package/src/type.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import { TYPE_KIND } from "./kinds";
 import { OBJECT_TYPE_NAME } from "./typeNames";
 
 export default class Type {
@@ -121,11 +120,9 @@ export default class Type {
 
   toJSON(tokens) {
     const superTypeJSON = this.superType.toJSON(tokens),
-          kind = TYPE_KIND,
           name = this.name,
           superType = superTypeJSON,  ///
           json = {
-            kind,
             name,
             superType
           };
@@ -167,11 +164,9 @@ export default class Type {
 
 class ObjectType extends Type {
   toJSON(tokens) {
-    const kind = TYPE_KIND,
-          name = this.name,
+    const name = this.name,
           superType = null,  ///
           json = {
-            kind,
             name,
             superType
           };

package/src/variable.js

@@ -2,8 +2,6 @@
 
 import Type from "./type";
 
-import { VARIABLE_KIND } from "./kinds";
-
 export default class Variable {
   constructor(name, type) {
     this.name = name;
@@ -33,11 +31,9 @@ export default class Variable {
 
   toJSON(tokens) {
     const typeJSON = this.type.toJSON(tokens),
-          kind = VARIABLE_KIND,
           name = this.name, ///
           type = typeJSON,  ///
           json = {
-            kind,
             name,
             type
           };

package/lib/kinds.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    TYPE_KIND: function() {
-        return TYPE_KIND;
-    },
-    RULE_KIND: function() {
-        return RULE_KIND;
-    },
-    AXIOM_KIND: function() {
-        return AXIOM_KIND;
-    },
-    LEMMA_KIND: function() {
-        return LEMMA_KIND;
-    },
-    THEOREM_KIND: function() {
-        return THEOREM_KIND;
-    },
-    VARIABLE_KIND: function() {
-        return VARIABLE_KIND;
-    },
-    META_TYPE_KIND: function() {
-        return META_TYPE_KIND;
-    },
-    CONJECTURE_KIND: function() {
-        return CONJECTURE_KIND;
-    },
-    COMBINATOR_KIND: function() {
-        return COMBINATOR_KIND;
-    },
-    CONSTRUCTOR_KIND: function() {
-        return CONSTRUCTOR_KIND;
-    },
-    METAVARIABLE_KIND: function() {
-        return METAVARIABLE_KIND;
-    }
-});
-var TYPE_KIND = "type";
-var RULE_KIND = "rule";
-var AXIOM_KIND = "axiom";
-var LEMMA_KIND = "lemma";
-var THEOREM_KIND = "theorem";
-var VARIABLE_KIND = "variable";
-var META_TYPE_KIND = "meta-type";
-var CONJECTURE_KIND = "conjecture";
-var COMBINATOR_KIND = "combinator";
-var CONSTRUCTOR_KIND = "constructor";
-var METAVARIABLE_KIND = "metavariable";
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uL3NyYy9raW5kcy5qcyJdLCJzb3VyY2VzQ29udGVudCI6WyJcInVzZSBzdHJpY3RcIjtcblxuZXhwb3J0IGNvbnN0IFRZUEVfS0lORCA9IFwidHlwZVwiO1xuZXhwb3J0IGNvbnN0IFJVTEVfS0lORCA9IFwicnVsZVwiO1xuZXhwb3J0IGNvbnN0IEFYSU9NX0tJTkQgPSBcImF4aW9tXCI7XG5leHBvcnQgY29uc3QgTEVNTUFfS0lORCA9IFwibGVtbWFcIjtcbmV4cG9ydCBjb25zdCBUSEVPUkVNX0tJTkQgPSBcInRoZW9yZW1cIjtcbmV4cG9ydCBjb25zdCBWQVJJQUJMRV9LSU5EID0gXCJ2YXJpYWJsZVwiO1xuZXhwb3J0IGNvbnN0IE1FVEFfVFlQRV9LSU5EID0gXCJtZXRhLXR5cGVcIjtcbmV4cG9ydCBjb25zdCBDT05KRUNUVVJFX0tJTkQgPSBcImNvbmplY3R1cmVcIjtcbmV4cG9ydCBjb25zdCBDT01CSU5BVE9SX0tJTkQgPSBcImNvbWJpbmF0b3JcIjtcbmV4cG9ydCBjb25zdCBDT05TVFJVQ1RPUl9LSU5EID0gXCJjb25zdHJ1Y3RvclwiO1xuZXhwb3J0IGNvbnN0IE1FVEFWQVJJQUJMRV9LSU5EID0gXCJtZXRhdmFyaWFibGVcIjtcbiJdLCJuYW1lcyI6WyJUWVBFX0tJTkQiLCJSVUxFX0tJTkQiLCJBWElPTV9LSU5EIiwiTEVNTUFfS0lORCIsIlRIRU9SRU1fS0lORCIsIlZBUklBQkxFX0tJTkQiLCJNRVRBX1RZUEVfS0lORCIsIkNPTkpFQ1RVUkVfS0lORCIsIkNPTUJJTkFUT1JfS0lORCIsIkNPTlNUUlVDVE9SX0tJTkQiLCJNRVRBVkFSSUFCTEVfS0lORCJdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7O0lBRWFBLFNBQVM7ZUFBVEE7O0lBQ0FDLFNBQVM7ZUFBVEE7O0lBQ0FDLFVBQVU7ZUFBVkE7O0lBQ0FDLFVBQVU7ZUFBVkE7O0lBQ0FDLFlBQVk7ZUFBWkE7O0lBQ0FDLGFBQWE7ZUFBYkE7O0lBQ0FDLGNBQWM7ZUFBZEE7O0lBQ0FDLGVBQWU7ZUFBZkE7O0lBQ0FDLGVBQWU7ZUFBZkE7O0lBQ0FDLGdCQUFnQjtlQUFoQkE7O0lBQ0FDLGlCQUFpQjtlQUFqQkE7OztBQVZOLElBQU1WLFlBQVk7QUFDbEIsSUFBTUMsWUFBWTtBQUNsQixJQUFNQyxhQUFhO0FBQ25CLElBQU1DLGFBQWE7QUFDbkIsSUFBTUMsZUFBZTtBQUNyQixJQUFNQyxnQkFBZ0I7QUFDdEIsSUFBTUMsaUJBQWlCO0FBQ3ZCLElBQU1DLGtCQUFrQjtBQUN4QixJQUFNQyxrQkFBa0I7QUFDeEIsSUFBTUMsbUJBQW1CO0FBQ3pCLElBQU1DLG9CQUFvQiJ9

package/src/kinds.js

@@ -1,13 +0,0 @@
-"use strict";
-
-export const TYPE_KIND = "type";
-export const RULE_KIND = "rule";
-export const AXIOM_KIND = "axiom";
-export const LEMMA_KIND = "lemma";
-export const THEOREM_KIND = "theorem";
-export const VARIABLE_KIND = "variable";
-export const META_TYPE_KIND = "meta-type";
-export const CONJECTURE_KIND = "conjecture";
-export const COMBINATOR_KIND = "combinator";
-export const CONSTRUCTOR_KIND = "constructor";
-export const METAVARIABLE_KIND = "metavariable";