occam-verify-cli 1.0.438 → 1.0.448

package/src/element/{statement/combinator → combinator}/bracketed.js

@@ -1,11 +1,11 @@
 "use strict";
 
-import CombinatorStatement from "../../statement/combinator";
+import Combinator from "../combinator";
 
-import { define } from "../../../elements";
-import { bracketedCombinatorStatementFromNothing } from "../../../utilities/instance";
+import { define } from "../../elements";
+import { bracketedCombinatorFromNothing } from "../../utilities/instance";
 
-export default define(class BracketedCombinatorStatement extends CombinatorStatement {
+export default define(class BracketedCombinator extends Combinator {
   unifyStatement(statement, assignments, stated, context) {
     let statementUnifies;
 
@@ -22,11 +22,11 @@ export default define(class BracketedCombinatorStatement extends CombinatorState
     return statementUnifies;
   }
 
-  static name = "BracketedCombinatorStatement";
+  static name = "BracketedCombinator";
 
   static fromNothing() {
-    const bracketedCombinatorStatement = bracketedCombinatorStatementFromNothing();
+    const bracketedCombinator = bracketedCombinatorFromNothing();
 
-    return bracketedCombinatorStatement;
+    return bracketedCombinator;
   }
 });

package/src/element/combinator.js

@@ -0,0 +1,90 @@
+"use strict";
+
+import Element from "../element";
+
+import { define } from "../elements";
+import { verifyCombinator } from "../process/verify";
+import { unifyStatementWithCombinator } from "../process/unify";
+import { statementFromJSON, statementToStatementJSON } from "../utilities/json";
+
+export default define(class Combinator extends Element {
+  constructor(context, string, node, statement) {
+    super(context, string, node)
+
+    this.statement = statement;
+  }
+
+  getStatement() {
+    return this.statement;
+  }
+
+  verify() {
+    let verifies;
+
+    const node = this.getNode(),
+          context = this.getContext(),
+          combinatorString = this.getString();  ///
+
+    context.trace(`Verifying the '${combinatorString}' combinator...`, node);
+
+    const combinator = this,  ///
+          combinatorVerifies = verifyCombinator(combinator, context);
+
+    if (combinatorVerifies) {
+      verifies = true;
+    }
+
+    if (verifies) {
+      context.debug(`...verified the '${combinatorString}' combinator.`, node);
+    }
+
+    return verifies;
+  }
+
+  unifyStatement(statement, assignments, stated, context) {
+    let statementUnifies;
+
+    const statementString = statement.getString(),
+          combinatorString = this.getString();  ///
+
+    context.trace(`Unifying the '${statementString}' statement with the '${combinatorString}' combinator...`);
+
+    const specifiContext = context; ///
+
+    context = this.getContext();
+
+    const generalContext = context; ///
+
+    context = specifiContext; ///
+
+    const combinator = this, ///
+          statementUnifiesWithCombinator = unifyStatementWithCombinator(statement, combinator, assignments, stated, generalContext, specifiContext);
+
+    statementUnifies = statementUnifiesWithCombinator; ///
+
+    if (statementUnifies) {
+      context.debug(`...unified the '${statementString}' statement with the '${combinatorString}' combinator.`);
+    }
+
+    return statementUnifies;
+  }
+
+  toJSON() {
+    const statementJSON = statementToStatementJSON(this.statement),
+          statement = statementJSON,  ///
+          json = {
+            statement,
+          };
+
+    return json;
+  }
+
+  static name = "Combinator";
+
+  static fromJSON(json, context) {
+    const statement = statementFromJSON(json, context),
+          combinator = new Combinator(statement);
+
+    return combinator;
+  }
+});

package/src/element/conclusion.js

@@ -24,25 +24,27 @@ export  default define(class Conclusion extends Element {
 
     context = temporaryContext; ///
 
-    const conclusionString = this.string;  ///
+    const node = this.getNode(),
+          conclusionString = this.getString();  ///
 
-    context.trace(`Verifying the '${conclusionString}' conclusion...`, this.node);
+    context.trace(`Verifying the '${conclusionString}' conclusion...`, node);
 
-    if (this.statement !== null) {
+    if (this.statement === null) {
+      context.debug(`Unable to verify the '${conclusionString}' conclusion because it is nonsense.`, node);
+    } else {
       const stated = true,
             assignments = null,
-            statementVerifies = this.statement.verify(assignments, stated, context);
-
-      verifies = statementVerifies; ///
+            statementValidates = this.statement.validate(assignments, stated, context);
 
-    } else {
-      context.debug(`Unable to verify the '${conclusionString}' conclusion because it is nonsense.`, this.node);
+      if (statementValidates) {
+        verifies = true;
+      }
     }
 
     if (verifies) {
-      this.context = context;
+      this.setContext(context);
 
-      context.debug(`...verified the '${conclusionString}' conclusion.`, this.node);
+      context.debug(`...verified the '${conclusionString}' conclusion.`, node);
     }
 
     return verifies;

package/src/element/{term/constructor → constructor}/bracketed.js

@@ -1,10 +1,10 @@
 "use strict";
 
-import elements from "../../../elements";
+import elements from "../../elements";
 import Constructor from "../constructor";
 
-import { define } from "../../../elements";
-import { bracketedConstructorTermFromNothing } from "../../../utilities/instance";
+import { define } from "../../elements";
+import { bracketedConstructorFromNothing } from "../../utilities/instance";
 
 export default define(class BracketedConstructor extends Constructor {
   unifyTerm(term, context, verifyAhead) {
@@ -55,8 +55,8 @@ export default define(class BracketedConstructor extends Constructor {
   static name = "BracketedConstructor";
 
   static fromNothing() {
-    const bracketedConstructorTerm = bracketedConstructorTermFromNothing();
+    const bracketedConstructor = bracketedConstructorFromNothing();
 
-    return bracketedConstructorTerm;
+    return bracketedConstructor;
   }
 });

package/src/element/{term/constructor.js → constructor.js}

@@ -1,13 +1,15 @@
 "use strict";
 
-import elements from "../../elements";
+import Element from "../element";
 
-import { define } from "../../elements";
-import { unifyTermWithConstructorTerm } from "../../process/unify";
-import { termFromJSON, termToTermJSON } from "../../utilities/json";
+import { define } from "../elements";
+import { unifyTermWithConstructor } from "../process/unify";
+import { termFromJSON, termToTermJSON } from "../utilities/json";
+
+export default define(class Constructor extends Element {
+  constructor(context, string, node, term) {
+    super(context, string, node);
 
-export default define(class ConstructorTerm {
-  constructor(term) {
     this.term = term;
   }
 
@@ -15,24 +17,22 @@ export default define(class ConstructorTerm {
     return this.term;
   }
 
-  getType() { return this.term.getType(); }
-
-  getString() { return this.term.getString(); }
-
   isProvisional() { return this.term.isProvisional(); }
 
+  getType() { return this.term.getType(); }
+
   setType(type) { this.term.setType(type); }
 
   unifyTerm(term, context, verifyAhead) {
     let termUnifies = false;
 
     const termString = term.getString(),
-          constructorTermString = this.getString();
+          constructorString = this.getString();
 
-    context.trace(`Unifying the '${termString}' term with the '${constructorTermString}' constructor's term...`);
+    context.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`);
 
-    const constructorTerm = this, ///
-          termUnifiesWithConstructor = unifyTermWithConstructorTerm(term, constructorTerm, context);
+    const constructor = this, ///
+          termUnifiesWithConstructor = unifyTermWithConstructor(term, constructor, context);
 
     if (termUnifiesWithConstructor) {
       let verifiesAhead;
@@ -47,7 +47,7 @@ export default define(class ConstructorTerm {
     }
 
     if (termUnifies) {
-      context.debug(`...unified the '${termString}' term with the '${constructorTermString}' constructor's term.`);
+      context.debug(`...unified the '${termString}' term with the '${constructorString}' constructor.`);
     }
 
     return termUnifies;
@@ -63,19 +63,11 @@ export default define(class ConstructorTerm {
     return json;
   }
 
-  static name = "ConstructorTerm";
+  static name = "Constructor";
 
   static fromJSON(json, context) {
     const term = termFromJSON(json, context),
-          constructor = new ConstructorTerm(term);
-
-    return constructor;
-  }
-
-  static fromConstructorDeclarationNode(constructorDeclarationNode, context) {
-    const { Term } = elements,
-          term = Term.fromConstructorDeclarationNode(constructorDeclarationNode, context),
-          constructor = new ConstructorTerm(term);
+          constructor = new Constructor(term);
 
     return constructor;
   }

package/src/element/declaration/combinator.js

@@ -25,7 +25,7 @@ export default define(class CombinatorDeclaration extends Declaration {
 
     context.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`, node);
 
-    const combinatorVerifies = this.verifyCombinator();
+    const combinatorVerifies = this.combinator.verify();
 
     if (combinatorVerifies) {
       context.addCombinator(this.combinator);
@@ -40,26 +40,5 @@ export default define(class CombinatorDeclaration extends Declaration {
     return verifies;
   }
 
-  verifyCombinator() {
-    let statementVerifies;
-
-    const node = this.getNode(),
-          context = this.getContext(),
-          combinatorString = this.combinator.getString();
-
-    context.trace(`Verifying the '${combinatorString}' combinator...`, node);
-
-    const statement = this.combinator.getStatement(),
-          statementNode = statement.getNode();
-
-    statementVerifies = verifyStatement(statementNode, context);
-
-    if (statementVerifies) {
-      context.debug(`...verified the '${combinatorString}' combinator.`, node);
-    }
-
-    return statementVerifies;
-  }
-
   static name = "CombinatorDeclaration";
 });

package/src/element/declaration/complexType.js

@@ -112,10 +112,10 @@ export default define(class ComplexTypeDeclaration extends Declaration {
 
     const nominalTypeName = superType.getNominalTypeName(),
           typeName = nominalTypeName, ///
-          typeNameMatches = this.type.matchTypeName(typeName);
+          typeComparesToTypeName = this.type.compareTypeName(typeName);
 
-    if (typeNameMatches) {
-      context.trace(`The super-type's name matches the ${typeName}' complex type's name.`, node);
+    if (typeComparesToTypeName) {
+      context.trace(`The super-type's name compares to the ${typeName}' complex type's name.`, node);
     } else {
       const oldSuperType = superType;
 
@@ -237,9 +237,9 @@ export default define(class ComplexTypeDeclaration extends Declaration {
 
     const propertyName = property.getName(),
           count = properties.reduce((count, property) => {
-            const propertyNameMatches = property.matchPropertyName(propertyName);
+            const propertyComparesToPropertyName = property.comparePropertyName(propertyName);
 
-            if (propertyNameMatches) {
+            if (propertyComparesToPropertyName) {
               count++;
             }
 
@@ -252,15 +252,15 @@ export default define(class ComplexTypeDeclaration extends Declaration {
       const superTypes = this.type.getSuperTypes(),
             superType = superTypes.find((superType) => {
               const superTypeProperties = superType.getProperties(),
-                    propertyNameMatches = superTypeProperties.some((superTypeProperty) => {
-                      const propertyNameMatches = superTypeProperty.matchPropertyName(propertyName);
+                    superTypePropertyComparesToPropertyName = superTypeProperties.some((superTypeProperty) => {
+                      const superTypePropertyComparesToPropertyName = superTypeProperty.comparePropertyName(propertyName);
 
-                      if (propertyNameMatches) {
+                      if (superTypePropertyComparesToPropertyName) {
                         return true;
                       }
                     });
 
-              if (propertyNameMatches) {
+              if (superTypePropertyComparesToPropertyName) {
                 return true;
               }
             }) || null;
@@ -291,9 +291,9 @@ export default define(class ComplexTypeDeclaration extends Declaration {
 
     context.trace(`Verifying the '${propertyString}' property's '${nominalTypeName}' nominal type name...`, node);
 
-    const nominalTypeNameMatches = this.type.matchNominalTypeName(nominalTypeName);
+    const typeComparesToNominalTypeName = this.type.compareNominalTypeName(nominalTypeName);
 
-    if (nominalTypeNameMatches) {
+    if (typeComparesToNominalTypeName) {
       propertyNominalTypeNameVerifies = true;
     } else {
       const typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);

package/src/element/declaration/constructor.js

@@ -3,7 +3,7 @@
 import Declaration from "../declaration";
 
 import { define } from "../../elements";
-import { verifyTerm } from "../../process/verify";
+import { validateTerm } from "../../process/validate";
 
 export default define(class ConstructorDeclaration extends Declaration {
   constructor(context, string, node, constructor) {
@@ -28,9 +28,9 @@ export default define(class ConstructorDeclaration extends Declaration {
     const constructorTypeVerifies = this.verifyConstructorType();
 
     if (constructorTypeVerifies) {
-      const constructorVerifies = this.verifyConstructor();
+      const constructorValidates = this.verifyConstructor();
 
-      if (constructorVerifies) {
+      if (constructorValidates) {
         context.addConstructor(this.constructor);
 
         verifies = true;
@@ -45,7 +45,7 @@ export default define(class ConstructorDeclaration extends Declaration {
   }
 
   verifyConstructor() {
-    let constructorVerifies;
+    let constructorValidates = false;
 
     const node = this.getNode(),
           context = this.getContext(),
@@ -54,15 +54,18 @@ export default define(class ConstructorDeclaration extends Declaration {
     context.trace(`Verifying the '${constructorString}' constructor...`, node);
 
     const term = this.constructor.getTerm(),
-          termNode = term.getNode();
+          termNode = term.getNode(),
+          termValidates = validateTerm(termNode, context);
 
-    constructorVerifies = verifyTerm(termNode, context);
+    if (termValidates) {
+      constructorValidates = true;
+    }
 
-    if (constructorVerifies) {
+    if (constructorValidates) {
       context.debug(`...verified the '${constructorString}' constructor.`, node);
     }
 
-    return constructorVerifies;
+    return constructorValidates;
   }
 
   verifyConstructorType() {
@@ -90,9 +93,9 @@ export default define(class ConstructorDeclaration extends Declaration {
     } else {
       const includeSupertypes = false,
             provisional = type.isProvisional(includeSupertypes),
-            provisionalMatches = type.matchProvisional(provisional);
+            typeComparesToProvisional = type.compareProvisional(provisional);
 
-      if (!provisionalMatches) {
+      if (!typeComparesToProvisional) {
         provisional ?
           context.debug(`The '${typeString}' type is present but not provisional.`, node) :
             context.debug(`The '${typeString}' type is present but provisional.`, node);

package/src/element/declaration/simpleType.js

@@ -108,10 +108,10 @@ export default define(class SimpleTypeDeclaration extends Declaration {
 
     const nominalTypeName = superType.getNominalTypeName(),
           typeName = nominalTypeName, ///
-          typeNameMatches = this.type.matchTypeName(typeName);
+          typeComparesToTypeName = this.type.compareTypeName(typeName);
 
-    if (typeNameMatches) {
-      context.trace(`The super-type's name matches the ${typeName}' simple type's name.`, node);
+    if (typeComparesToTypeName) {
+      context.trace(`The super-type's name compares to the ${typeName}' simple type's name.`, node);
     } else {
       const oldSuperType = superType;
 

package/src/element/declaration/typePrefix.js

@@ -30,7 +30,7 @@ export default define(class TypePrefixDeclaration extends Declaration {
           typesLength = types.length;
 
     if (typesLength > 0) {
-      context.debug(`Cannot verify the '${typePrefixDeclarationString}' type prefix declaration because types have already been declared.`, node);
+      context.debug(`Unable to verify the '${typePrefixDeclarationString}' type prefix declaration because types have already been declared.`, node);
     } else {
       const typePrefixVerifies = this.verifyTypePrefix();
 

package/src/element/declaration/variable.js

@@ -93,9 +93,9 @@ export default define(class VariableDeclaration extends Declaration {
     } else {
       const includeSupertypes = false,
             provisional = type.isProvisional(includeSupertypes),
-            provisionalMatches = type.matchProvisional(provisional);
+            typeComparesToProvisional = type.compareProvisional(provisional);
 
-      if (!provisionalMatches) {
+      if (!typeComparesToProvisional) {
         provisional ?
           context.debug(`The '${typeString}' type is present but not provisional.`, node) :
             context.debug(`The '${typeString}' type is present but provisional.`, node);

package/src/element/deduction.js

@@ -24,24 +24,27 @@ export default define(class Deduction extends Element {
 
     context = temporaryContext; ///
 
-    const deductionString = this.string;  ///
+    const node = this.getNode(),
+          deductionString = this.getString();  ///
 
-    context.trace(`Verifying the '${deductionString}' deduction...`, this.node);
+    context.trace(`Verifying the '${deductionString}' deduction...`, node);
 
-    if (this.statement !== null) {
+    if (this.statement === null) {
+      context.debug(`Unable to verify the '${deductionString}' deduction because it is nonsense.`, node);
+    } else {
       const stated = true,
             assignments = null,
-            statementVerifies = this.statement.verify(assignments, stated, context);
+            statementVealidates = this.statement.validate(assignments, stated, context);
 
-      verifies = statementVerifies; ///
-    } else {
-      context.debug(`Unable to verify the '${deductionString}' deduction because it is nonsense.`, this.node);
+      if (statementVealidates) {
+        verifies = true;
+      }
     }
 
     if (verifies) {
-      this.context = context;
+      this.setContext(context);
 
-      context.debug(`...verified the '${deductionString}' deduction.`, this.node);
+      context.debug(`...verified the '${deductionString}' deduction.`, node);
     }
 
     return verifies;

package/src/element/derivation.js

@@ -10,41 +10,37 @@ import { define } from "../elements";
 const { last } = arrayUtilities;
 
 export default define(class Derivation extends Element {
-  constructor(context, string, node, stepsOrSubproofs) {
+  constructor(context, string, node, subproofOrProofAssertions) {
     super(context, string, node);
 
-    this.stepsOrSubproofs = stepsOrSubproofs;
+    this.subproofOrProofAssertions = subproofOrProofAssertions;
   }
 
-  getStepsOrSubproofs() {
-    return this.stepsOrSubproofs;
+  getSubproofOrProofAssertions() {
+    return this.subproofOrProofAssertions;
   }
 
-  getLastStep() {
-    const lastStepOrSubproof = last(this.stepsOrSubproofs),
-          lastStep = lastStepOrSubproof;  ///
+  getLastProofAssertion() {
+    const lastSubproofOrProofAssertion = last(this.subproofOrProofAssertions),
+          lastProofAssertion = lastSubproofOrProofAssertion;  ///
 
-    return lastStep;
+    return lastProofAssertion;
   }
 
   verify(substitutions, context) {
     let verifies;
 
-    verifies = this.stepsOrSubproofs.every((stepOrSubproof) => { ///
+    verifies = this.subproofOrProofAssertions.every((subproofOrProofAssertion) => { ///
       const assignments = [],
-            stepOrSubproofValidates = stepOrSubproof.validate(substitutions, assignments, context);
+            subproofOrProofAssertionVerifies = subproofOrProofAssertion.verify(substitutions, assignments, context);
 
-      if (stepOrSubproofValidates) {
-        const stepOrSubproofUnifies = stepOrSubproof.unify(substitutions, context);
+      if (subproofOrProofAssertionVerifies) {
+        const assignmentsAssigned = assignAssignments(assignments, context);
 
-        if (stepOrSubproofUnifies) {
-          const assignmentsAssigned = assignAssignments(assignments, context);
+        if (assignmentsAssigned) {
+          context.addSubproofOrProofAssertion(subproofOrProofAssertion);
 
-          if (assignmentsAssigned) {
-            context.addStepOrSubproof(stepOrSubproof);
-
-            return true;
-          }
+          return true;
         }
       }
     });

package/src/element/equivalence.js

@@ -26,7 +26,7 @@ export default define(class Equivalence extends Element {
     const termString = term.getString(),
           equivalenceString = this.asString(); ///
 
-    context.trace(`Adding the '${termString}' term to the '${equivalenceString}' equivalence....`);
+    context.trace(`Adding the '${termString}' term to the '${equivalenceString}' equivalence...`);
 
     const termA = term, ///
           termPresent = this.someTerm((term) => {
@@ -76,9 +76,9 @@ export default define(class Equivalence extends Element {
     return type;
   }
 
-  equateTerm(term) {
+  compareTerm(term) {
     const termA = term, ///
-          termEquates = this.someTerm((term) => {
+          comparesToTerm = this.someTerm((term) => {
             const termB = term, ///
                   termAEqualToTermB = termA.isEqualTo(termB);
 
@@ -87,14 +87,14 @@ export default define(class Equivalence extends Element {
             }
           });
 
-    return termEquates;
+    return comparesToTerm;
   }
 
   matchTermNode(termNode) {
     termNode = stripBracketsFromTermNode(termNode); ///
 
     const termNodeMatches = this.someTerm((term) => {
-      const termNodeMatches = term.matchTermNode(termNode);
+      const termNodeMatches = term.matchNode(termNode);
 
       if (termNodeMatches) {
         return true;
@@ -137,9 +137,9 @@ export default define(class Equivalence extends Element {
 
   isDisjointFrom(equivalence) {
     const disjointFrom = equivalence.everyTerm((term) => {
-      const termEquates = this.equateTerm(term);
+      const comparesToTerm = this.compareTerm(term);
 
-      if (!termEquates) {
+      if (!comparesToTerm) {
         return true;
       }
     });
@@ -196,7 +196,7 @@ export default define(class Equivalence extends Element {
       if (termGrounded) {
         const termMatchesGroundedTerm = groundedTerms.some((groundedTerm) => {
           const groundedTermNode = groundedTerm.getNode(),
-                groundedTermNodeMatches = term.matchTermNode(groundedTermNode);
+                groundedTermNodeMatches = term.matchNode(groundedTermNode);
 
           if (groundedTermNodeMatches) {
             return true;

package/src/element/equivalences.js

@@ -51,9 +51,9 @@ export default define(class Equivalences extends Element {
 
   findEquivalenceByTerm(term) {
     const equivalence = this.array.find((equivalence) => {
-      const termEquates = equivalence.equateTerm(term);
+      const equivalenceComparesToTerm = equivalence.compareTerm(term);
 
-      if (termEquates) {
+      if (equivalenceComparesToTerm) {
         return true;
       }
     }) || null;
@@ -63,9 +63,9 @@ export default define(class Equivalences extends Element {
 
   findEquivalenceByTermNodes(termNodes) {
     const equivalence = this.array.find((equivalence) => {
-      const equivalenceMatchesTerms = equivalence.matchTermNodes(termNodes);
+      const termNodeMatches = equivalence.matchTermNodes(termNodes);
 
-      if (equivalenceMatchesTerms) {
+      if (termNodeMatches) {
         return true;
       }
     }) || null;