occam-verify-cli 1.0.984 → 1.0.986

package/src/element/topLevelMetaAssertion.js

@@ -1,276 +0,0 @@
-"use strict";
-
-import { Element, asynchronousUtilities } from "occam-languages";
-
-import { encapsulate } from "../utilities/context";
-import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-import { topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction } from "../utilities/string";
-import { labelFromJSON,
-         labelToLabelJSON,
-         deductionFromJSON,
-         suppositionsFromJSON,
-         deductionToDeductionJSON,
-         metaLevelAssumptionsFromJSON,
-         suppositionsToSuppositionsJSON,
-         metaLevelAssumptionsToMetaLevelAssumptionsJSON } from "../utilities/json";
-
-const { asyncForwardsEvery } = asynchronousUtilities;
-
-export default class TopLevelMetaAssertion extends Element {
-  constructor(context, string, node, breakPoint, label, suppositions, deduction, proof, metaLevelAssumptions) {
-    super(context, string, node, breakPoint);
-
-    this.label = label;
-    this.suppositions = suppositions;
-    this.deduction = deduction;
-    this.proof = proof;
-    this.metaLevelAssumptions = metaLevelAssumptions;
-  }
-
-  getLabel() {
-    return this.label;
-  }
-
-  getSuppositions() {
-    return this.suppositions;
-  }
-
-  getDeduction() {
-    return this.deduction;
-  }
-
-  getProof() {
-    return this.proof;
-  }
-
-  getMetaLevelAssumptions() {
-    return this.metaLevelAssumptions;
-  }
-
-  getStatement() {
-    let statement = null;
-
-    const unconditional = this.isUnconditional();
-
-    if (unconditional) {
-      statement = this.deduction.getStatement();
-    }
-
-    return statement;
-  }
-
-  getStatements() {
-    let statements = null;
-
-    const unconditional = this.isUnconditional();
-
-    if (!unconditional) {
-      const suppositionStatements = this.suppositions.map((supposition) => {
-              const suppositionStatement = supposition.getStatement();
-
-              return suppositionStatement;
-            }),
-            deductionStatement = this.deduction.getStatement();
-
-      statements = [
-        ...suppositionStatements,
-        deductionStatement
-      ];
-    }
-
-    return statements;
-  }
-
-  isUnconditional() {
-    const suppositionsLength = this.suppositions.length,
-          unconditional = (suppositionsLength === 0);
-
-    return unconditional;
-  }
-
-  compareReference(reference) {
-    const label = this.getLabel(),
-          labelComparesToRefference = label.compareReference(reference),
-          comparesToReference = labelComparesToRefference;  ///
-
-    return comparesToReference;
-  }
-
-  async verify(context) {
-    let verifies = false;
-
-    const topLevelMetaAssertionString = this.getString(); ///
-
-    context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta assertion...`);
-
-    await encapsulate(async (context) => {
-      const labelVerifies = this.verifyLabel(context);
-
-      if (labelVerifies) {
-        const suppositionsVerify = await this.verifySuppositions(context);
-
-        if (suppositionsVerify) {
-          const deductionVerifies = await this.verifyDeduction(context);
-
-          if (deductionVerifies) {
-            const proofVerifies = await this.verifyProof(context);
-
-            if (proofVerifies) {
-              verifies = true;
-            }
-          }
-        }
-      }
-    }, this.metaLevelAssumptions, context);
-
-    if (verifies) {
-      context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta assertion.`);
-    }
-
-    return verifies;
-  }
-
-  verifyLabel(context) {
-    let labelVerifies;
-
-    const topLevelMetaAssertionString = this.getString(),  ///
-          labelString = this.label.getString();
-
-    context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta-assertion's '${labelString}' label...`);
-
-    labelVerifies = this.label.verify();
-
-    if (labelVerifies) {
-      context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta-assertion's '${labelString}' label.`);
-    }
-
-    return labelVerifies;
-  }
-
-  async verifyProof(context) {
-    let proofVerifies;
-
-    const topLevelMetaAssertionString = this.getString();  ///
-
-    context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta-assertion's proof...`);
-
-    const statement = this.deduction.getStatement();
-
-    proofVerifies = await this.proof.verify(statement, context);
-
-    if (proofVerifies) {
-      context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta-assertion's proof.`);
-    }
-
-    return proofVerifies;
-  }
-
-  async verifyDeduction(context) {
-    let deductionVerifies;
-
-    const deductionString = this.deduction.getString(),
-          topLevelMetaAssertionString = this.getString(); ///
-
-    context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta assertion's '${deductionString}' deduction...`);
-
-    deductionVerifies = await this.deduction.verify(context);
-
-    if (deductionVerifies) {
-      context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta assertion's '${deductionString}' deduction.`);
-    }
-
-    return deductionVerifies;
-  }
-
-  async verifySupposition(supposition, context) {
-    let suppositionVerifies;
-
-    const suppositionString = supposition.getString(),
-          topLevelMetaAssertionString = this.getString();  ///
-
-    context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta-assertion's '${suppositionString}' supposition...`);
-
-    suppositionVerifies = await supposition.verify(context)
-
-    if (suppositionVerifies) {
-      const subproofOrProofAssertion = supposition;  ////
-
-      context.assignAssignments();
-
-      context.addSubproofOrProofAssertion(subproofOrProofAssertion);
-    }
-
-    if (suppositionVerifies) {
-      context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta-assertion's '${suppositionString}' supposition.`);
-    }
-
-    return suppositionVerifies;
-  }
-
-  async verifySuppositions(context) {
-    let suppositionsVerify;
-
-    const topLevelMetaAssertionString = this.getString();  ///
-
-    context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta-assertion's suppositions...`);
-
-    suppositionsVerify = await asyncForwardsEvery(this.suppositions, async (supposition) => {
-      const suppositionVerifies = await this.verifySupposition(supposition, context);
-
-      if (suppositionVerifies) {
-        return true;
-      }
-    });
-
-    if (suppositionsVerify) {
-      context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta-assertion's suppositions.`);
-    }
-
-    return suppositionsVerify;
-  }
-
-  toJSON() {
-    const labelJSON = labelToLabelJSON(this.label),
-          deductionJSON = deductionToDeductionJSON(this.deduction),
-          suppositionsJSON = suppositionsToSuppositionsJSON(this.suppositions),
-          metaLevelAssumptionsJSON = metaLevelAssumptionsToMetaLevelAssumptionsJSON(this.metaLevelAssumptions),
-          string = this.getString();
-
-    let breakPoint;
-
-    breakPoint = this.getBreakPoint();
-
-    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
-
-    breakPoint = breakPointJSON;  ///
-
-    const label = labelJSON,  ///
-          deduction = deductionJSON,  ///
-          suppositions = suppositionsJSON,  ///
-          metaLevelAssumptions = metaLevelAssumptionsJSON,  ///
-          json = {
-            string,
-            breakPoint,
-            label,
-            deduction,
-            suppositions,
-            metaLevelAssumptions
-          };
-
-    return json;
-  }
-
-  static fromJSON(Class, json, context) {
-    const label = labelFromJSON(json, context),
-          deduction = deductionFromJSON(json, context),
-          suppositions = suppositionsFromJSON(json, context),
-          metaLevelAssumptions = metaLevelAssumptionsFromJSON(json, context),
-          string = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
-          node = null,
-          breakPoint = breakPointFromJSON(json),
-          proof = null,
-          topLevelMetaAssertion = new Class(context, string, node, breakPoint, label, suppositions, deduction, proof, metaLevelAssumptions);
-
-    return topLevelMetaAssertion;
-  }
-}

package/src/element/type.js

@@ -1,374 +0,0 @@
-"use strict";
-
-import { Element } from "occam-languages";
-import { arrayUtilities } from "necessary";
-
-import { define } from "../elements";
-import { instantiate } from "../utilities/context";
-import { instantiateType } from "../process/instantiate";
-import { nameFromTypeNode } from "../utilities/element";
-import { baseTypeFromNothing } from "../utilities/type";
-import { breakPointFromJSON, breakPointToBreakPointJSON } from "../utilities/breakPoint";
-import { propertiesFromJSON,
-         prefixNameFromJSON,
-         superTypesFromJSON,
-         provisionalFromJSON,
-         prefixnameToPrevixNameJSON,
-         superTypesToSuperTypesJSON,
-         propertiesToPropertiesJSON,
-         provisionalToProvisionalJSON } from "../utilities/json";
-
-const { push, first } = arrayUtilities;
-
-export default define(class Type extends Element {
-  constructor(context, string, node, breakPoint, name, prefixName, superTypes, properties, provisional) {
-    super(context, string, node, breakPoint);
-
-    this.name = name;
-    this.prefixName = prefixName;
-    this.superTypes = superTypes;
-    this.properties = properties;
-    this.provisional = provisional;
-  }
-
-  getName() {
-    return this.name;
-  }
-
-  getPrefixName() {
-    return this.prefixName;
-  }
-
-  getSuperTypes() {
-    return this.superTypes;
-  }
-
-  getTypeNode() {
-    const node = this.getNode(),
-          typeNode = node;  ///
-
-    return typeNode;
-  }
-
-  getProperties(includeSuperTypes = true) {
-    const properties = [];
-
-    push(properties, this.properties);
-
-    if (includeSuperTypes) {
-      this.superTypes.forEach((superType) => {
-        const superTypeProperties = superType.getProperties();
-
-        push(properties, superTypeProperties);
-      });
-    }
-
-    return properties;
-  }
-
-  isProvisional(includeSuperTypes = true) {
-    let provisional = this.provisional;
-
-    if (includeSuperTypes) {
-      if (!provisional) {
-        provisional = this.superTypes.some((superType) => {
-          const superTypeProvisional = superType.isProvisional();
-
-          if (superTypeProvisional) {
-            return true;
-          }
-        });
-      }
-    }
-
-    return provisional;
-  }
-
-  setName(name) {
-    this.name = name;
-  }
-
-  setPrefixName(prefixName) {
-    this.prefixName = prefixName;
-  }
-
-  setSuperTypes(superTypes) {
-    this.superTypes = superTypes;
-  }
-
-  setProperties(properties) {
-    this.properties = properties;
-  }
-
-  setProvisional(provisional) {
-    this.provisional = provisional;
-  }
-
-  isEstablished(includeSuperTypes = true) {
-    const provisional = this.isProvisional(includeSuperTypes),
-          established = !provisional;
-
-    return established;
-  }
-
-  isPrefixed() {
-    const prefixed = (this.prefixName !== null);
-
-    return prefixed;
-  }
-
-  getPrefixedName() {
-    let prefixedName = null;
-
-    const prefixed = this.isPrefixed();
-
-    if (prefixed) {
-      prefixedName = `${this.prefixName}${this.name}`;
-    }
-
-    return prefixedName;
-  }
-
-  getNominalTypeName() {
-    const prefixed = this.isPrefixed(),
-          nominalTypeName = prefixed ?
-                             `${this.prefixName}${this.name}` :
-                                this.name;
-
-    return nominalTypeName;
-  }
-
-  isBasic() {
-    let basic = false;
-
-    const superTypesLength = this.superTypes.length;
-
-    if (superTypesLength === 1) {
-      const firstSuperType = first(this.superTypes),
-            superType = firstSuperType, ///
-            baseType = baseTypeFromNothing();
-
-      if (superType === baseType) {
-        basic = true;
-      }
-    }
-
-    return basic;
-  }
-
-  isRefined() {
-    let refined = false;
-
-    const superTypesLength = this.superTypes.length;
-
-    if (superTypesLength === 1) {
-      const firstSuperType = first(this.superTypes),
-            superType = firstSuperType, ///
-            superTypeName = superType.getName();
-
-      if (superTypeName === this.name) {
-        refined = true;
-      }
-    }
-
-    return refined;
-  }
-
-  isEqualTo(type) {
-    const equalTo = (this === type);
-
-    return equalTo;
-  }
-
-  isSubTypeOf(type) {
-    let subTypeOf;
-
-    const baseType = baseTypeFromNothing();
-
-    if (this === baseType) {
-      subTypeOf = false;
-    } else {
-      subTypeOf = this.superTypes.some((superType) => { ///
-        if (superType === type) {
-          return true;
-        }
-
-        const superTypeSubTypeOfType = superType.isSubTypeOf(type);
-
-        if (superTypeSubTypeOfType) {
-          return true;
-        }
-      })
-    }
-
-    return subTypeOf;
-  }
-
-  isSuperTypeOf(type) {
-    const subTypeOf = type.isSubTypeOf(this),
-          superTypeOf = subTypeOf;  ///
-
-    return superTypeOf;
-  }
-
-  isEqualToOrSubTypeOf(type) {
-    const equalTo = this.isEqualTo(type),
-          subTypeOf = this.isSubTypeOf(type),
-          equalToOrSubTypeOf = (equalTo || subTypeOf);
-
-    return equalToOrSubTypeOf;
-  }
-
-  isEqualToOrSuperTypeOf(type) {
-    const equalTo = this.isEqualTo(type),
-          superTypeOf = this.isSuperTypeOf(type),
-          equalToOrSuperTypeOf = (equalTo || superTypeOf);
-
-    return equalToOrSuperTypeOf;
-  }
-
-  isEqualToSubTypeOrSuperTypeOf(type) {
-    const equalTo = this.isEqualTo(type),
-          subTypeOf = this.isSubTypeOf(type),
-          superTypeOf = this.isSuperTypeOf(type),
-          equalToSubTypeOrSuperTypeOf = (equalTo || subTypeOf || superTypeOf);
-
-    return equalToSubTypeOrSuperTypeOf;
-  }
-
-  compareTypeName(typeName) {
-    const nameTypeName = (this.name === typeName),
-          comparesToTypeName = nameTypeName;  ///
-
-    return comparesToTypeName;
-  }
-
-  compareProvisional(provisional, includeSupertypes = true) {
-    let comparesToProvisional;
-
-    const provisionalA = provisional; ///
-
-    provisional = this.isProvisional(includeSupertypes);
-
-    const provisionalB = provisional; ///
-
-    comparesToProvisional = (provisionalA === provisionalB);
-
-    return comparesToProvisional;
-  }
-
-  compareNominalTypeName(nominalTypeName) {
-    let comparesToNominalTypeName = false;
-
-    const nameNominalTypeName = (this.name === nominalTypeName);
-
-    if (nameNominalTypeName) {
-      comparesToNominalTypeName = true;
-    } else {
-      const prefixed = this.isPrefixed();
-
-      if (prefixed) {
-        const prefixedName = this.getPrefixedName(),
-              prefixedNameNominalTypeName = (prefixedName === nominalTypeName);
-
-        if (prefixedNameNominalTypeName) {
-          comparesToNominalTypeName = true;
-        }
-      }
-    }
-
-    return comparesToNominalTypeName;
-  }
-
-  comparePrefixedTypeName(prefixedTypeName) {
-    let comparesToPrefixedTypeName = false;
-
-    const prefixed = this.isPrefixed();
-
-    if (prefixed) {
-      const prefixedName = this.getPrefixedName(),
-            prefixedTypeNamePrefixedName = (prefixedTypeName === prefixedName);
-
-      if (prefixedTypeNamePrefixedName) {
-        comparesToPrefixedTypeName = true;
-      }
-    }
-
-    return comparesToPrefixedTypeName;
-  }
-
-  toJSON(abridged = false) {
-    const string = this.getString();
-
-    let breakPoint;
-
-    breakPoint = this.getBreakPoint();
-
-    const breakPointJSON = breakPointToBreakPointJSON(breakPoint);
-
-    breakPoint = breakPointJSON;  ///
-
-    const json = {
-      string,
-      breakPoint
-    };
-
-    if (!abridged) {
-      const prefixNameJSON = prefixnameToPrevixNameJSON(this.prefixName),
-            superTypesJSON = superTypesToSuperTypesJSON(this.superTypes),
-            propertiesJSON = propertiesToPropertiesJSON(this.properties),
-            provisinoalJSOM = provisionalToProvisionalJSON(this.provisional),
-            prefixName = prefixNameJSON,  ///
-            superTypes = superTypesJSON,  ///
-            properties = propertiesJSON,  ///
-            provisional = provisinoalJSOM;  ///
-
-      Object.assign(json, {
-        prefixName,
-        superTypes,
-        properties,
-        provisional
-      });
-    }
-
-    return json;
-  }
-
-  static name = "Type";
-
-  static fromJSON(json, context) {
-    return instantiate((context) => {
-      const { string } = json,
-            typeNode = instantiateType(string, context),
-            node = typeNode, ///
-            breakPoint = breakPointFromJSON(json),
-            name = nameFromTypeNode(typeNode, context),
-            prefixName = prefixNameFromJSON(json, context),
-            superTypes = superTypesFromJSON(json, context),
-            properties = propertiesFromJSON(json, context),
-            provisional = provisionalFromJSON(json);
-
-      context = null; ///
-
-      const type = new Type(context, string, node, breakPoint, name, prefixName, superTypes, properties, provisional);
-
-      return type;
-    }, context);
-  }
-
-  static fromName(name, context) {
-    const string = name,  ///
-          node = null,
-          breakPoint = null,
-          prefixName = null,
-          superTypes = [],
-          properties = [],
-          provisional = false;
-
-    context = null;
-
-    const type = new Type(context, string, node, breakPoint, name, prefixName, superTypes, properties, provisional);
-
-    return type;
-  }
-});