occam-verify-cli 1.0.421 → 1.0.428

package/src/ontology/constructor.js

@@ -1,105 +0,0 @@
-"use strict";
-
-import ontology from "../ontology";
-
-import { define } from "../ontology";
-import { baseType } from ".//type";
-import { unifyTermWithConstructor } from "../process/unify";
-import { termFromJSON, termToTermJSON } from "../utilities/json";
-
-export default define(class Constructor {
-  constructor(string, term) {
-    this.string = string;
-    this.term = term;
-  }
-
-  getString() {
-    return this.string;
-  }
-
-  getTerm() {
-    return this.term;
-  }
-
-  getType() { return this.term.getType(); }
-
-  isProvisional() { return this.term.isProvisional(); }
-
-  setType(type) { this.term.setType(type); }
-
-  unifyTerm(term, context, verifyAhead) {
-    let termUnifies = false;
-
-    const constructor = this, ///
-          termString = term.getString(),
-          constructorString = constructor.getString();
-
-    context.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`);
-
-    const termUnifiesWithConstructor = unifyTermWithConstructor(term, constructor, context);
-
-    if (termUnifiesWithConstructor) {
-      let verifiesAhead;
-
-      const type = constructor.getType();
-
-      term.setType(type);
-
-      verifiesAhead = verifyAhead();
-
-      termUnifies = verifiesAhead;  ///
-    }
-
-    if (termUnifies) {
-      context.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`);
-    }
-
-    return termUnifies;
-  }
-
-  toJSON() {
-    const termJSON = termToTermJSON(this.term),
-          term = termJSON,  ///
-          json = {
-            term
-          };
-
-    return json;
-  }
-
-  static name = "Constructor";
-
-  static fromJSON(json, context) {
-    const term = termFromJSON(json, context),
-          string = stringFromTerm(term),
-          constructor = new Constructor(string, term);
-
-    return constructor;
-  }
-
-  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {
-    const { Term } = ontology,
-          term = Term.fromConstructorDeclarationNode(constructorDeclarationNode, context),
-          string = stringFromTerm(term),
-          constructor = new Constructor(string, term);
-
-    return constructor;
-  }
-});
-
-function stringFromTerm(term) {
-  let string;
-
-  const termString = term.getString(),
-        type = term.getType();
-
-  if (type === baseType) {
-    string = termString;  ///
-  } else {
-    const typeString = type.getString();
-
-    string = `${termString}:${typeString}`;
-  }
-
-  return string;
-}

package/src/ontology.js

@@ -1,13 +0,0 @@
-"use strict";
-
-const ontology = {};
-
-export function define(Class) {
-  const { name } = Class;
-
-  ontology[name] = Class;
-
-  return Class;
-}
-
-export default ontology;

package/src/utilities/assignments.js

@@ -1,11 +0,0 @@
-"use strict";
-
-export function assignAssignments(assignments, context) {
-  const assignmentsAssigned = assignments.every((assigment) => {
-    const assignmentAssigned = assigment.assign(context);
-
-    return assignmentAssigned
-  });
-
-  return assignmentsAssigned;
-}

package/src/utilities/subproof.js

@@ -1,56 +0,0 @@
-"use strict";
-
-export function subproofStringFromSubproofNode(subproofNode, context) {
-  const suppositionStatementsOrNonsenseString = suppositionStatementOrNonsenseStringFromSubproofNode(subproofNode, context),
-        lastStatementOrNonsenseString = lastStatementOrNonsenseStringFromSubproofNode(subproofNode, context),
-        subproofString = `[${suppositionStatementsOrNonsenseString}] ... ${lastStatementOrNonsenseString}`;
-
-  return subproofString;
-}
-
-function suppositionStatementOrNonsenseStringFromSubproofNode(subproofNode, context) {
-  const suppositionNodes = subproofNode.getSuppositionNodes(),
-        suppositionStatementsOrNonsenseString = suppositionNodes.reduce((suppositionStatementsOrNonsenseString, suppositionNode) => {
-          const suppositionOrStepNode = suppositionNode,  ///
-                statementOrNonsenseString = statementOrNonsenseStringFromSuppositionOrStepNode(suppositionOrStepNode, context),
-                suppositionStatementOrNonsenseString = statementOrNonsenseString; ///
-
-          suppositionStatementsOrNonsenseString = (suppositionStatementsOrNonsenseString !== null) ?
-                                                    `${suppositionStatementsOrNonsenseString}, ${suppositionStatementOrNonsenseString}` :
-                                                      suppositionStatementOrNonsenseString; ///
-
-          return suppositionStatementsOrNonsenseString;
-        }, null);
-
-  return suppositionStatementsOrNonsenseString;
-}
-
-function lastStatementOrNonsenseStringFromSubproofNode(subproofNode, context) {
-  const lastStepNode = subproofNode.getLastStepNode(),
-        suppositionOrStepNode = lastStepNode, ///
-        statementOrNonsenseString = statementOrNonsenseStringFromSuppositionOrStepNode(suppositionOrStepNode, context),
-        lastStatementOrNonsenseString = statementOrNonsenseString; ///
-
-  return lastStatementOrNonsenseString;
-}
-
-function statementOrNonsenseStringFromSuppositionOrStepNode(suppositionOrStepNode, context) {
-  let statementOrNonsenseString;
-
-  const nonsenseNode = suppositionOrStepNode.getNonsenseNode(),
-        statementNode = suppositionOrStepNode.getStatementNode();
-
-  if (false) {
-    ///
-  } else if (nonsenseNode !== null) {
-    const nonsenseString = context.nodeAsString(nonsenseNode);
-
-    statementOrNonsenseString = nonsenseString; ///
-  } else if (statementNode !== null) {
-    const statementString = context.nodeAsString(statementNode);
-
-    statementOrNonsenseString = statementString;  ///
-  }
-
-  return statementOrNonsenseString;
-}

package/src/utilities/type.js

@@ -1,35 +0,0 @@
-"use strict";
-
-import { baseType } from "../ontology/type";
-
-export function stringFromTypeNameTypePrefixNameAndSuperTypes(typeName, typePrefixName, superTypes) {
-  let string;
-
-  string = (typePrefixName !== null) ?
-             `${typePrefixName}${typeName}`:
-               typeName;
-
-  const superTypesString = superTypesStringFromSuperTypes(superTypes);
-
-  if (superTypesString !== null) {
-    string = `${string}:${superTypesString}`;
-  }
-
-  return string;
-}
-
-export function superTypesStringFromSuperTypes(superTypes) {
-  const superTypesString = superTypes.reduce((superTypesString, superType) => {
-    if (superType !== baseType) {
-      const superTypeString = superType.getString();
-
-      superTypesString = (superTypesString === null) ?
-                           `'${superTypeString}'` :
-                             `${superTypesString}, '${superTypeString}'`;
-    }
-
-    return superTypesString;
-  }, null);
-
-  return superTypesString;
-}