occam-verify-cli 1.0.438 → 1.0.448

package/src/element/term.js

@@ -3,9 +3,9 @@
 import { arrayUtilities } from "necessary";
 
 import Element from "../element";
-import verifyMixins from "../mixins/term/verify";
 
 import { define } from "../elements";
+import { validateTerms } from "../utilities/validation";
 import { instantiateTerm } from "../process/instantiate";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
 
@@ -30,10 +30,8 @@ export default define(class Term extends Element {
 
   isProvisional() { return this.type.isProvisional(); }
 
-  matchTermNode(termNode) { return this.node.match(termNode); }
-
-  isEqualToVariable(variable) {
-    let variableNodeMathces = false;
+  compareVariable(variable) {
+    let comparesToVaraible = false;
 
     const singular = this.isSingular();
 
@@ -45,19 +43,11 @@ export default define(class Term extends Element {
             matches = variableNodeA.match(variableNodeB);
 
       if (matches) {
-        variableNodeMathces = true;
+        comparesToVaraible = true;
       }
     }
 
-    return variableNodeMathces;
-  }
-
-  isEqualTo(term) {
-    const termNode = term.getNode(),
-          matches = this.node.match(termNode),
-          equalTo = matches;  ///
-
-    return equalTo;
+    return comparesToVaraible;
   }
 
   isGrounded(definedVariables, context) {
@@ -95,31 +85,31 @@ export default define(class Term extends Element {
     return implicitlyGrounded;
   }
 
-  verify(context, verifyAhead) {
-    let verifies;
+  validate(context, verifyAhead) {
+    let validates;
 
     const termString = this.string;  ///
 
-    context.trace(`Verifying the '${termString}' term...`);
+    context.trace(`Validating the '${termString}' term...`);
 
-    verifies = verifyMixins.some((verifyMixin) => {
+    validates = validateTerms.some((validateTerm) => {  ///
       const term = this, ///
-            verifies = verifyMixin(term, context, verifyAhead);
+            termValidates = validateTerm(term, context, verifyAhead);
 
-      if (verifies) {
+      if (termValidates) {
         return true;
       }
     });
 
-    if (verifies) {
+    if (validates) {
       const term = this;  ///
 
       context.addTerm(term);
 
-      context.debug(`...verified the '${termString}' term.`);
+      context.debug(`...validated the '${termString}' term.`);
     }
 
-    return verifies;
+    return validates;
   }
 
   verifyGivenType(type, generalContext, specificContext) {
@@ -128,10 +118,10 @@ export default define(class Term extends Element {
     const typeString = type.getString(),
           termString = this.getString();  ///
 
-    specificContext.trace(`Verifying the '${termString}' term given the '${typeString}' type...`);
+    specificContext.trace(`Validating the '${termString}' term given the '${typeString}' type...`);
 
     const context = specificContext, ///
-          verifies = this.verify(context, () => {
+          validates = this.validate(context, () => {
             let verifiesAhead;
 
             const typeEqualToOrSubTypeOfGivenTypeType = this.type.isEqualToOrSubTypeOf(type);
@@ -143,10 +133,10 @@ export default define(class Term extends Element {
             return verifiesAhead;
           });
 
-    verifiesGivenType = verifies; ///
+    verifiesGivenType = validates; ///
 
     if (verifiesGivenType) {
-      specificContext.debug(`...verified the '${termString}' term given the '${typeString}' type.`);
+      specificContext.debug(`...validated the '${termString}' term given the '${typeString}' type.`);
     }
 
     return verifiesGivenType;

package/src/element/type.js

@@ -5,13 +5,13 @@ import { arrayUtilities } from "necessary";
 import Element from "../element";
 
 import { define } from "../elements";
-import { BASE_TYPE_SYMBOL } from "../constants";
+import { baseTypeFromNothing } from "../types";
 import { typeStringFromTypeNameTypePrefixNameAndSuperTypes } from "../utilities/string";
 import { superTypesFromJSON, propertiesFromJSON, superTypesToSuperTypesJSON, propertiesToPropertiesJSON } from "../utilities/json";
 
 const { push, first } = arrayUtilities;
 
-class Type extends Element {
+export default define(class Type extends Element {
   constructor(context, string, node, name, prefixName, superTypes, properties, provisional) {
     super(context, string, node);
     this.name = name;
@@ -129,7 +129,8 @@ class Type extends Element {
 
     if (superTypesLength === 1) {
       const firstSuperType = first(this.superTypes),
-            superType = firstSuperType; ///
+            superType = firstSuperType, ///
+            baseType = baseTypeFromNothing();
 
       if (superType === baseType) {
         basic = true;
@@ -166,6 +167,8 @@ class Type extends Element {
   isSubTypeOf(type) {
     let subTypeOf;
 
+    const baseType = baseTypeFromNothing();
+
     if (this === baseType) {
       subTypeOf = false;
     } else {
@@ -217,15 +220,16 @@ class Type extends Element {
     return equalToOrSuperTypeOf;
   }
 
-  matchTypeName(typeName) {
+  compareTypeName(typeName) {
     const name = this.getName(),
-          typeNameMatches = (name === typeName);
+          nameTypeName = (name === typeName),
+          comparesToTypeName = nameTypeName;  ///
 
-    return typeNameMatches;
+    return comparesToTypeName;
   }
 
-  matchProvisional(provisional) {
-    let provisionalMatches;
+  compareProvisional(provisional) {
+    let comparesToProvisional;
 
     const provisionalA = provisional; ///
 
@@ -233,45 +237,54 @@ class Type extends Element {
 
     const provisionalB = provisional; ///
 
-    provisionalMatches = (provisionalA === provisionalB);
+    comparesToProvisional = (provisionalA === provisionalB);
 
-    return provisionalMatches;
+    return comparesToProvisional;
   }
 
-  matchPrefixedTypeName(prefixedTypeName) {
-    let prefixedTypeNameMatches = false;
+  comparePrefixedTypeName(prefixedTypeName) {
+    let comparesToPrefixedTypeName = false;
 
     const prefixed = this.isPrefixed();
 
     if (prefixed) {
-      const prefixedName = this.getPrefixedName();
+      const prefixedName = this.getPrefixedName(),
+            prefixedTypeNamePrefixedName = (prefixedTypeName === prefixedName);
 
-      prefixedTypeNameMatches = (prefixedTypeName === prefixedName);
+      if (prefixedTypeNamePrefixedName) {
+        comparesToPrefixedTypeName = true;
+      }
     }
 
-    return prefixedTypeNameMatches;
+    return comparesToPrefixedTypeName;
   }
 
-  matchNominalTypeName(nominalTypeName) {
-    let nominalTypeNameMatches = false;
+  compareNominalTypeName(nominalTypeName) {
+    let comparesToNominalTypeName = false;
 
-    if (!nominalTypeNameMatches) {
-      const name = this.getName();
+    if (!comparesToNominalTypeName) {
+      const name = this.getName(),
+            nominalTypeNameName = (nominalTypeName === name);
 
-      nominalTypeNameMatches = (nominalTypeName === name);
+      if (nominalTypeNameName) {
+        comparesToNominalTypeName = true;
+      }
     }
 
-    if (!nominalTypeNameMatches) {
+    if (!comparesToNominalTypeName) {
       const prefixed = this.isPrefixed();
 
       if (prefixed) {
-        const prefixedName = this.getPrefixedName();
+        const prefixedName = this.getPrefixedName(),
+              nominalTypeNamePrefixedName = (nominalTypeName === prefixedName);
 
-        nominalTypeNameMatches = (nominalTypeName === prefixedName);
+        if (nominalTypeNamePrefixedName) {
+          comparesToNominalTypeName = true;
+        }
       }
     }
 
-    return nominalTypeNameMatches;
+    return comparesToNominalTypeName;
   }
 
   toJSON() {
@@ -307,24 +320,17 @@ class Type extends Element {
 
     return type;
   }
-}
 
-export default define(Type);
-
-class BaseType extends Type {
-  static fromNothing() {
-    const name = BASE_TYPE_SYMBOL,  ///
-          context = null,
+  static fromName(name) {
+    const context = null,
           string = name,  ///
           node = null,
           prefixName = null,
           superTypes = [],
           properties = [],
           provisional = false,
-          baseType = new BaseType(context, string, node, name, prefixName, superTypes, properties, provisional);
+          type = new Type(context, string, node, name, prefixName, superTypes, properties, provisional);
 
-    return baseType;
+    return type;
   }
-}
-
-export const baseType = BaseType.fromNothing();
+});

package/src/element/typePrefix.js

@@ -15,10 +15,10 @@ export default define(class TypePrefix extends Element {
     return this.name;
   }
 
-  matchTypePrefixName(typePrefixName) {
-    const typePrefixNameMatches = (this.name === typePrefixName);
+  compareTypePrefixName(typePrefixName) {
+    const comparesToTypePrefixName = (this.name === typePrefixName);
 
-    return typePrefixNameMatches;
+    return comparesToTypePrefixName;
   }
 
   toJSON() {

package/src/element/variable.js

@@ -34,18 +34,18 @@ export default define(class Variable extends Element {
 
   getTypeString() { return this.type.getString(); }
 
-  matchParameter(parameter) {
+  compareParameter(parameter) {
     const parameterName = parameter.getName(),
-          parameterNameMatchesIdentifier = (parameterName === this.identifier),
-          parameterMatches = parameterNameMatchesIdentifier;  ///
+          identifierParamterName = (this.identifier === parameterName),
+          comparesToParamter = identifierParamterName;  ///
 
-    return parameterMatches;
+    return comparesToParamter;
   }
 
-  matchVariableIdentifier(variableIdentifier) {
-    const variableIdentifierMatches = (variableIdentifier === this.identifier);
+  compareVariableIdentifier(variableIdentifier) {
+    const comparesToVariablbeIdentifier = (this.identifier === variableIdentifier);
 
-    return variableIdentifierMatches;
+    return comparesToVariablbeIdentifier;
   }
 
   verify(context) {

package/src/element.js

@@ -31,7 +31,9 @@ export default class Element {
     this.node = node;
   }
 
-  isEQualTo(element) {
+  matchNode(node) { return this.node.match(node); }
+
+  isEqualTo(element) {
     const elementNode = element.getNode(),
           matches = this.node.match(elementNode),
           equalTo = matches;  ///

package/src/metaTypes.js

@@ -0,0 +1,55 @@
+"use strict";
+
+import elements from "./elements";
+
+import { FRAME_META_TYPE_NAME, REFERENCE_META_TYPE_NAME, STATEMENT_META_TYPE_NAME } from "./metaTypeNames";
+
+let frameMetaType = null,
+    referenceMetaType = null,
+    statementMetaType = null;
+
+export function getMetaTypes() {
+  const frameMetaType = frameMetaTypeFromNothing(),
+        referenceMetaType = referenceMetaTypeFromNothing(),
+        statementMetaType = statementMetaTypeFromNothing(),
+        metaTypes = [
+          frameMetaType,
+          referenceMetaType,
+          statementMetaType
+        ];
+
+  return metaTypes;
+}
+
+export function frameMetaTypeFromNothing() {
+  if (frameMetaType === null) {
+    const { MetaType } = elements,
+          name = FRAME_META_TYPE_NAME;  ///
+
+    frameMetaType = MetaType.fromName(name);
+  }
+
+  return frameMetaType;
+}
+
+export function statementMetaTypeFromNothing() {
+  if (statementMetaType === null) {
+    const { MetaType } = elements,
+          name = STATEMENT_META_TYPE_NAME;  ///
+
+    statementMetaType = MetaType.fromName(name);
+  }
+
+  return statementMetaType;
+}
+
+export function referenceMetaTypeFromNothing() {
+  if (referenceMetaType === null) {
+    const { MetaType } = elements,
+          name = REFERENCE_META_TYPE_NAME;  ///
+
+    referenceMetaType = MetaType.fromName(name);
+  }
+
+  return referenceMetaType;
+}

package/src/node/axiomLemmaTheoremConjecture.js

@@ -33,11 +33,11 @@ export default class AxiomLemmaTheoremConjectureNode extends NonTerminalNode {
     return labelNodes;
   }
 
-  getSuppositionNodes() {
+  getProofNode() {
     const bodyNode = this.getBodyNode(),
-          suppositionNodes = bodyNode.getSuppositionNodes();
+          proofNode = bodyNode.getProofNode();
 
-    return suppositionNodes;
+    return proofNode;
   }
 
   getDeductionNode() {
@@ -47,11 +47,11 @@ export default class AxiomLemmaTheoremConjectureNode extends NonTerminalNode {
     return deductionNode;
   }
 
-  getProofNode() {
+  getSuppositionNodes() {
     const bodyNode = this.getBodyNode(),
-          proofNode = bodyNode.getProofNode();
+          suppositionNodes = bodyNode.getSuppositionNodes();
 
-    return proofNode;
+    return suppositionNodes;
   }
 
   static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }

package/src/node/body/axiom.js

@@ -1,28 +1,7 @@
 "use strict";
 
 import BodyNode from "../../node/body";
-import { DEDUCTION_RULE_NAME, SUPPOSITION_RULE_NAME } from "../../ruleNames";
 
 export default class AxiomBodyNode extends BodyNode {
-  getProofNode() {
-    const proofNode = null;
-
-    return proofNode;
-  }
-
-  getDeductionNode() {
-    const ruleName = DEDUCTION_RULE_NAME,
-          deductionNode = this.getNodeByRuleName(ruleName);
-
-    return deductionNode;
-  }
-
-  getSuppositionNodes() {
-    const ruleName = SUPPOSITION_RULE_NAME,
-          suppositionNodes = this.getNodesByRuleName(ruleName);
-
-    return suppositionNodes;
-  }
-
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return BodyNode.fromRuleNameChildNodesOpacityAndPrecedence(AxiomBodyNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/body/conjecture.js

@@ -2,29 +2,6 @@
 
 import BodyNode from "../../node/body";
 
-import { PROOF_RULE_NAME, DEDUCTION_RULE_NAME, SUPPOSITION_RULE_NAME } from "../../ruleNames";
-
 export default class ConjectureBodyNode extends BodyNode {
-  getProofNode() {
-    const ruleName = PROOF_RULE_NAME,
-          proofNode = this.getNodeByRuleName(ruleName);
-
-    return proofNode;
-  }
-
-  getDeductionNode() {
-    const ruleName = DEDUCTION_RULE_NAME,
-          deductionNode = this.getNodeByRuleName(ruleName);
-
-    return deductionNode;
-  }
-
-  getSuppositionNodes() {
-    const ruleName = SUPPOSITION_RULE_NAME,
-          suppositionNodes = this.getNodesByRuleName(ruleName);
-
-    return suppositionNodes;
-  }
-
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return BodyNode.fromRuleNameChildNodesOpacityAndPrecedence(ConjectureBodyNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/body/lemma.js

@@ -2,29 +2,6 @@
 
 import BodyNode from "../../node/body";
 
-import { PROOF_RULE_NAME, DEDUCTION_RULE_NAME, SUPPOSITION_RULE_NAME } from "../../ruleNames";
-
 export default class LemmaBodyNode extends BodyNode {
-  getProofNode() {
-    const ruleName = PROOF_RULE_NAME,
-          proofNode = this.getNodeByRuleName(ruleName);
-
-    return proofNode;
-  }
-
-  getDeductionNode() {
-    const ruleName = DEDUCTION_RULE_NAME,
-          deductionNode = this.getNodeByRuleName(ruleName);
-
-    return deductionNode;
-  }
-
-  getSuppositionNodes() {
-    const ruleName = SUPPOSITION_RULE_NAME,
-          suppositionNodes = this.getNodesByRuleName(ruleName);
-
-    return suppositionNodes;
-  }
-
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return BodyNode.fromRuleNameChildNodesOpacityAndPrecedence(LemmaBodyNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/body/metaLemma.js

@@ -2,29 +2,6 @@
 
 import BodyNode from "../../node/body";
 
-import { PROOF_RULE_NAME, DEDUCTION_RULE_NAME, SUPPOSITION_RULE_NAME } from "../../ruleNames";
-
 export default class MetaLemmaBodyNode extends BodyNode {
-  getProofNode() {
-    const ruleName = PROOF_RULE_NAME,
-          proofNode = this.getNodeByRuleName(ruleName);
-
-    return proofNode;
-  }
-
-  getDeductionNode() {
-    const ruleName = DEDUCTION_RULE_NAME,
-          deductionNode = this.getNodeByRuleName(ruleName);
-
-    return deductionNode;
-  }
-
-  getSuppositionNodes() {
-    const ruleName = SUPPOSITION_RULE_NAME,
-          suppositionNodes = this.getNodesByRuleName(ruleName);
-
-    return suppositionNodes;
-  }
-
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return BodyNode.fromRuleNameChildNodesOpacityAndPrecedence(MetaLemmaBodyNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/body/metatheorem.js

@@ -2,29 +2,6 @@
 
 import BodyNode from "../../node/body";
 
-import { PROOF_RULE_NAME, DEDUCTION_RULE_NAME, SUPPOSITION_RULE_NAME } from "../../ruleNames";
-
 export default class MetatheoremBodyNode extends BodyNode {
-  getProofNode() {
-    const ruleName = PROOF_RULE_NAME,
-          proofNode = this.getNodeByRuleName(ruleName);
-
-    return proofNode;
-  }
-
-  getDeductionNode() {
-    const ruleName = DEDUCTION_RULE_NAME,
-          deductionNode = this.getNodeByRuleName(ruleName);
-
-    return deductionNode;
-  }
-
-  getSuppositionNodes() {
-    const ruleName = SUPPOSITION_RULE_NAME,
-          suppositionNodes = this.getNodesByRuleName(ruleName);
-
-    return suppositionNodes;
-  }
-
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return BodyNode.fromRuleNameChildNodesOpacityAndPrecedence(MetatheoremBodyNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/body/rule.js

@@ -26,5 +26,17 @@ export default class RuleBodyNode extends BodyNode {
     return conclusionNode;
   }
 
+  getDeductionNode() {
+    const deductionNode = null;
+
+    return deductionNode;
+  }
+
+  getSuppositionNodes() {
+    const suppositionNodes = null;
+
+    return suppositionNodes;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return BodyNode.fromRuleNameChildNodesOpacityAndPrecedence(RuleBodyNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/body/theorem.js

@@ -2,29 +2,6 @@
 
 import BodyNode from "../../node/body";
 
-import { PROOF_RULE_NAME, DEDUCTION_RULE_NAME, SUPPOSITION_RULE_NAME } from "../../ruleNames";
-
 export default class TheoremBodyNode extends BodyNode {
-  getProofNode() {
-    const ruleName = PROOF_RULE_NAME,
-          proofNode = this.getNodeByRuleName(ruleName);
-
-    return proofNode;
-  }
-
-  getDeductionNode() {
-    const ruleName = DEDUCTION_RULE_NAME,
-          deductionNode = this.getNodeByRuleName(ruleName);
-
-    return deductionNode;
-  }
-
-  getSuppositionNodes() {
-    const ruleName = SUPPOSITION_RULE_NAME,
-          suppositionNodes = this.getNodesByRuleName(ruleName);
-
-    return suppositionNodes;
-  }
-
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return BodyNode.fromRuleNameChildNodesOpacityAndPrecedence(TheoremBodyNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/body.js

@@ -2,6 +2,29 @@
 
 import NonTerminalNode from "../nonTerminalNode";
 
+import { PROOF_RULE_NAME, DEDUCTION_RULE_NAME, SUPPOSITION_RULE_NAME } from "../ruleNames";
+
 export default class BodyNode extends NonTerminalNode {
+  getProofNode() {
+    const ruleName = PROOF_RULE_NAME,
+          proofNode = this.getNodeByRuleName(ruleName);
+
+    return proofNode;
+  }
+
+  getDeductionNode() {
+    const ruleName = DEDUCTION_RULE_NAME,
+          deductionNode = this.getNodeByRuleName(ruleName);
+
+    return deductionNode;
+  }
+
+  getSuppositionNodes() {
+    const ruleName = SUPPOSITION_RULE_NAME,
+          suppositionNodes = this.getNodesByRuleName(ruleName);
+
+    return suppositionNodes;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/combinator.js

@@ -2,6 +2,15 @@
 
 import NonTerminalNode from "../nonTerminalNode";
 
+import { STATEMENT_RULE_NAME } from "../ruleNames";
+
 export default class CombinatorNode extends NonTerminalNode {
+  getStatementNode() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNode = this.getNodeByRuleName(ruleName);
+
+    return statementNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(CombinatorNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/constructor.js

@@ -2,6 +2,15 @@
 
 import NonTerminalNode from "../nonTerminalNode";
 
+import { TERM_RULE_NAME } from "../ruleNames";
+
 export default class ConstructorNode extends NonTerminalNode {
+  getTermNode() {
+    const ruleName = TERM_RULE_NAME,
+          termNode = this.getNodeByRuleName(ruleName);
+
+    return termNode;
+  }
+
   static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ConstructorNode, ruleName, childNodes, opacity, precedence); }
 }