occam-verify-cli 1.0.983 → 1.0.985

package/src/element/equality.js

@@ -1,325 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-
-import { define } from "../elements";
-import { equateTerms } from "../process/equate";
-import { instantiate } from "../utilities/context";
-import { instantiateEquality } from "../process/instantiate";
-import { equalityFromStatementNode } from "../utilities/element";
-import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-import { equalityAssignmentFromEquality, leftVariableAssignmentFromEquality, rightVariableAssignmentFromEquality } from "../process/assign";
-
-export default define(class Equality extends Element {
-  constructor(context, string, node, breakPoint, leftTerm, rightTerm) {
-    super(context, string, node, breakPoint);
-
-    this.leftTerm = leftTerm;
-    this.rightTerm = rightTerm;
-  }
-
-  getLeftTerm() {
-    return this.leftTerm;
-  }
-
-  getRightTerm() {
-    return this.rightTerm;
-  }
-
-  getEqualityNode() {
-    const node = this.getNode(),
-          equalityNde = node; ///
-
-    return equalityNde;
-  }
-
-  getLeftTermNode() {
-    const leftTermNode = this.leftTerm.getNode();
-
-    return leftTermNode;
-  }
-
-  getRightTermNode() {
-    const rightTermNode = this.rightTerm.getNode();
-
-    return rightTermNode;
-  }
-
-  getType() {
-    let type;
-
-    const leftTermType = this.leftTerm.getType(),
-          rightTermType = this.rightTerm.getType(),
-          leftTermTypeEqualToOrSubTypeOfRightTermType = leftTermType.isEqualToOrSubTypeOf(rightTermType),
-          rightTermTypeEqualToOrSubTypeOfLeftTermType = rightTermType.isEqualToOrSubTypeOf(leftTermType);
-
-    if (leftTermTypeEqualToOrSubTypeOfRightTermType) {
-      type = leftTermType;  ///
-    }
-
-    if (rightTermTypeEqualToOrSubTypeOfLeftTermType) {
-      type = rightTermType; ///
-    }
-
-    return type;
-  }
-
-  getTerms() {
-    const terms = [
-      this.leftTerm,
-      this.rightTerm
-    ];
-
-    return terms;
-  }
-
-  matchEqualityNode(equalityNode) {
-    const node = equalityNode, ///
-          nodeMatches = this.matchNode(node),
-          equalityNodeMatches = nodeMatches; ///
-
-    return equalityNodeMatches;
-  }
-
-  isReflexive() {
-    const leftTermString = this.leftTerm.getString(),
-          rightTermString = this.rightTerm.getString(),
-          reflexive = (leftTermString === rightTermString);
-
-    return reflexive;
-  }
-
-  isEqualTo(equality) {
-    const equalityNode = equality.getNode(),
-          equalityNodeMatches = this.matchEqualityNode(equalityNode),
-          equalTo = equalityNodeMatches;  ///
-
-    return equalTo;
-  }
-
-  isEqual(context) {
-    let equal = false;
-
-    const termsEquate = equateTerms(this.leftTerm, this.rightTerm, context);
-
-    if (termsEquate) {
-      equal = true;
-    }
-
-    return equal;
-  }
-
-  findValidEquality(context) {
-    const equalityNode = this.getEqualityNode(),
-          equality = context.findEqualityByEqualityNode(equalityNode),
-          validEquality = equality;  ///
-
-    return validEquality;
-  }
-
-  validate(context) {
-    let equality = null;
-
-    const equalityString = this.getString(); ///
-
-    context.trace(`Validating the '${equalityString}' equality...`);
-
-    let validates = false;
-
-    const validEquality = this.findValidEquality(context);
-
-    if (validEquality !== null) {
-      validates = true;
-
-      equality = validEquality; ///
-
-      context.debug(`...the '${equalityString}' equality is already valid.`);
-    } else {
-      const termsValidate = this.validateTerms(context);
-
-      if (termsValidate) {
-        const stated = context.isStated();
-
-        let validatesWhenStated = false,
-            validatesWhenDerived = false;
-
-        if (stated) {
-          validatesWhenStated = this.validateWhenStated(context);
-        } else {
-          validatesWhenDerived = this.validateWhenDerived(context);
-        }
-
-        if (validatesWhenStated || validatesWhenDerived) {
-          validates = true;
-        }
-      }
-
-      if (validates) {
-        equality = this;  ///
-
-        this.assign(context);
-
-        context.addEquality(equality);
-      }
-    }
-
-    if (validates) {
-      context.debug(`...validated the '${equalityString}' equality.`);
-    }
-
-    return equality;
-  }
-
-  validateTerms(context) {
-    let termsValidate = false;
-
-    const equalityString = this.getString(); ///
-
-    context.trace(`Validating the '${equalityString}' equality's terms...`);
-
-    let leftTerm,
-        rightTerm;
-
-    leftTerm = this.leftTerm.validate(context, (leftTerm, context) => {
-        let validatesForwards = false;
-
-        rightTerm = this.rightTerm.validate(context, (rightTerm, context) => {
-          let validatesForwards = false;
-
-          const leftTermType = leftTerm.getType(),
-                rightTermType = rightTerm.getType(),
-                leftTermTypeEqualToSubTypeOrSuperTypeOfRightTermType = leftTermType.isEqualToSubTypeOrSuperTypeOf(rightTermType);
-
-          if (leftTermTypeEqualToSubTypeOrSuperTypeOfRightTermType) {
-            validatesForwards = true;
-          }
-
-          return validatesForwards;
-        });
-
-        if (rightTerm !== null) {
-          validatesForwards = true;
-        }
-
-        return validatesForwards;
-      });
-
-    if (leftTerm !== null) {
-      this.leftTerm = leftTerm;
-
-      this.rightTerm = rightTerm;
-
-      termsValidate = true;
-    }
-
-    if (termsValidate) {
-      context.debug(`...validated the '${equalityString}' equality's terms.`);
-    }
-
-    return termsValidate;
-  }
-
-  validateWhenStated(context) {
-    let validatesWhenStated;
-
-    const equalityString = this.getString(); ///
-
-    context.trace(`Validating the '${equalityString}' stated equality...`);
-
-    validatesWhenStated = true;
-
-    if (validatesWhenStated) {
-      context.debug(`...validated the '${equalityString}' stated equality.`);
-    }
-
-    return validatesWhenStated;
-  }
-
-  validateWhenDerived(context) {
-    let validatesWhenDerived;
-
-    const equalityString = this.getString(); ///
-
-    context.trace(`Validating the '${equalityString}' derived equality...`);
-
-    validatesWhenDerived = true;  ///
-
-    if (validatesWhenDerived) {
-      context.debug(`...validated the '${equalityString}' derived equality.`);
-    }
-
-    return validatesWhenDerived;
-  }
-
-  assign(context) {
-    const equality = this,  ///
-          equalityAssignment = equalityAssignmentFromEquality(equality, context),
-          leftVariableAssignment = leftVariableAssignmentFromEquality(equality, context),
-          rightVariableAssignment = rightVariableAssignmentFromEquality(equality, context);
-
-    context.addAssignment(equalityAssignment);
-
-    context.addAssignment(leftVariableAssignment);
-
-    context.addAssignment(rightVariableAssignment);
-  }
-
-  toJSON() {
-    const string = this.getString();
-
-    let breakPoint;
-
-    breakPoint = this.getBreakPoint();
-
-    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
-
-    breakPoint = breakPointJSON;  ///
-
-    const json = {
-      string,
-      breakPoint
-    };
-
-    return json;
-  }
-
-  static name = "Equality";
-
-  static fromJSON(json, context) {
-    return instantiate((context) => {
-      const { string } = json,
-            equalityNode = instantiateEquality(string, context),
-            node = equalityNode,  ///
-            breakPoint = breakPointFromJSON(json),
-            leftTerm = leftTermFromEqualityNode(equalityNode, context),
-            rightTerm = rightTermFromEqualityNode(equalityNode, context);
-
-      context = null;
-
-      const equality = new Equality(context, string, node, breakPoint, leftTerm, rightTerm);
-
-      return equality;
-    }, context);
-  }
-
-  static fromStatement(statement, context) {
-    const statementNode = statement.getNode(),
-          equality = equalityFromStatementNode(statementNode, 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/equivalence.js

@@ -1,276 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-import { arrayUtilities } from "necessary";
-
-import { define } from "../elements";
-import { ablate, instantiate } from "../utilities/context";
-import { instantiateEquivalence } from "../process/instantiate";
-import { stripBracketsFromTermNode } from "../utilities/brackets";
-import { equivalenceStringFromTerms } from "../utilities/string";
-import { equivalenceFromEquivalenceNode } from "../utilities/element";
-
-const { compress } = arrayUtilities;
-
-export default define(class Equivalence extends Element {
-  constructor(context, string, node, breakPoint, type, terms) {
-    super(context, string, node, breakPoint);
-
-    this.type = type;
-    this.terms = terms;
-  }
-
-  getType() {
-    return this.type;
-  }
-
-  getTerms() {
-    return this.terms;
-  }
-
-  setType(type) {
-    this.type = type;
-  }
-
-  setTerms(terms) {
-    this.terms = terms;
-  }
-
-  getEquivalenceNode() {
-    const node = this.getNode(),
-          equivalenceNode = node; ///
-
-    return equivalenceNode;
-  }
-
-  getGroundedTerms(definedVariables, groundedTerms, context) {
-    this.terms.forEach((term) => {
-      const termGrounded = term.isGrounded(definedVariables, context);
-
-      if (termGrounded) {
-        const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
-          const groundedTermNode = groundedTerm.getNode(),
-                groundedTermNodeMatches = term.matchTermNode(groundedTermNode);
-
-          if (groundedTermNodeMatches) {
-            return true;
-          }
-        })
-
-        if (!termMatchesGroundedTerm) {
-          const groundedTerm = term;
-
-          groundedTerms.push(groundedTerm);
-        }
-      }
-    });
-  }
-
-  getInitiallyGroundedTerms(context) {
-    const initiallyGroundedTerms = this.terms.reduce((initiallyGroundedTerms, term) => {
-      const termInitiallyGrounded = term.isInitiallyGrounded(context);
-
-      if (termInitiallyGrounded) {
-        const initiallyGroundedTerm = term; ///
-
-        initiallyGroundedTerms.push(initiallyGroundedTerm);
-      }
-
-      return initiallyGroundedTerms;
-    }, []);
-
-    return initiallyGroundedTerms;
-  }
-
-  getImplicitlyGroundedTerms(definedVariables, context) {
-    const implicitlyGroundedTerms = this.terms.reduce((implicitlyGroundedTerms, term) => {
-      const termImplicitlyGrounded = term.isImplicitlyGrounded(definedVariables, context);
-
-      if (termImplicitlyGrounded) {
-        const implicitlyGroundedTerm = term; ///
-
-        implicitlyGroundedTerms.push(implicitlyGroundedTerm);
-      }
-
-      return implicitlyGroundedTerms;
-    }, []);
-
-    return implicitlyGroundedTerms;
-  }
-
-  isDisjointFrom(equivalence) {
-    const disjointFrom = equivalence.everyTerm((term) => {
-      const comparesToTerm = this.compareTerm(term);
-
-      if (!comparesToTerm) {
-        return true;
-      }
-    });
-
-    return disjointFrom;
-  }
-
-  isInitiallyGrounded(context) {
-    const initiallyGroundedTerms = this.getInitiallyGroundedTerms(context),
-          initiallyGroundedTermsLength = initiallyGroundedTerms.length,
-          initiallyGrounded = (initiallyGroundedTermsLength > 0);
-
-    return initiallyGrounded;
-  }
-
-  isImplicitlyGrounded(definedVariables, context) {
-    const implicitlyGroundedTerms = this.getImplicitlyGroundedTerms(definedVariables, context),
-          implicitlyGroundedTermsLength = implicitlyGroundedTerms.length,
-          implicitlyGrounded = (implicitlyGroundedTermsLength > 0);
-
-    return implicitlyGrounded;
-  }
-
-  matchTermNode(termNode) {
-    termNode = stripBracketsFromTermNode(termNode); ///
-
-    const termNodeMatches = this.someTerm((term) => {
-      const termNodeMatches = term.matchTermNode(termNode);
-
-      if (termNodeMatches) {
-        return true;
-      }
-    });
-
-    return termNodeMatches;
-  }
-
-  matchTermNodes(termNodes) {
-    const termNodesMatch = termNodes.every((termNode) => {
-      const termNodeMatches = this.matchTermNode(termNode);
-
-      if (termNodeMatches) {
-        return true;
-      }
-    });
-
-    return termNodesMatch;
-  }
-
-  someTerm(callback) { return this.terms.some(callback); }
-
-  everyTerm(callback) { return this.terms.every(callback); }
-
-  compareTerm(term) {
-    const termA = term, ///
-          comparesToTerm = this.someTerm((term) => {
-            const termB = term, ///
-                  termAEqualToTermB = termA.isEqualTo(termB);
-
-            if (termAEqualToTermB) {
-              return true;
-            }
-          });
-
-    return comparesToTerm;
-  }
-
-  someOtherTerm(term, callback) {
-    const termA = term, ///
-          terms = this.terms.filter((term) => {
-            const termB = term, ///
-                  termAEqualToTermB = termA.isEqualTo(termB);
-
-            if (!termAEqualToTermB) {
-              return true;
-            }
-          }),
-          result = terms.some(callback);
-
-    return result;
-  }
-
-  combineTerms(terms) {
-    const combinedTerms = [
-      ...this.terms,
-      ...terms
-    ];
-
-    compress(combinedTerms, (combinedTermA, combinedTermB) => {
-      const combinedTermEqualToToCombinedTermB = combinedTermA.isEqualTo(combinedTermB);
-
-      if (!combinedTermEqualToToCombinedTermB) {
-        return true;
-      }
-    });
-
-    return combinedTerms;
-  }
-
-  mergedWith(equivalence, context) {
-    let type;
-
-    type = equivalence.getType();
-
-    const types = [
-            this.type,
-            type
-          ],
-          terms = equivalence.getTerms(),
-          combinedType = combinedTypeFromTypes(types),
-          combinedTerms = this.combineTerms(terms);
-
-    type = combinedType;  ///
-
-    ablate((context) => {
-      instantiate((context) => {
-        const terms = combinedTerms,  ///
-              equivalenceString = equivalenceStringFromTerms(terms),
-              string = equivalenceString,  ///
-              equivalenceNode = instantiateEquivalence(string, context);
-
-        equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
-      }, context);
-    }, context);
-
-    equivalence.setType(type);
-
-    return equivalence;
-  }
-
-  static name = "Equivalence";
-
-  static fromEquality(equality, context) {
-    let equivalence;
-
-    const type = equality.getType();
-
-    ablate((context) => {
-      instantiate((context) => {
-        const terms = equality.getTerms(),
-              equivalenceString = equivalenceStringFromTerms(terms),
-              string = equivalenceString,  ///
-              equivalenceNode = instantiateEquivalence(string, context);
-
-        equivalence = equivalenceFromEquivalenceNode(equivalenceNode, context);
-      }, context);
-    }, context);
-
-    equivalence.setType(type);
-
-    return equivalence;
-  }
-});
-
-function combinedTypeFromTypes(types) {
-  const combinedType = types.reduce((combinedType, type) => {
-    if (combinedType === null) {
-      combinedType = type;  ///
-    } else {
-      const typeSubTypeOfCombinedType = type.isSubTypeOf(combinedType);
-
-      if (typeSubTypeOfCombinedType) {
-        combinedType = type;  ///
-      }
-    }
-
-    return combinedType;
-  }, null);
-
-  return combinedType;
-}

package/src/element/error.js

@@ -1,26 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-
-import { define } from "../elements";
-
-export default define(class Error extends Element {
-  getErrorNode() {
-    const node = this.getNode(),
-          errorNode = node; ///
-
-    return errorNode;
-  }
-
-  async verify(context) {
-    let verifies = false;
-
-    const errorString = this.getString();  ///
-
-    context.warning(`The '${errorString}' error cannot be verified.`);
-
-    return verifies;
-  }
-
-  static name = "Error";
-});