occam-verify-cli 1.0.635 → 1.0.641

package/src/element/assertion/type.js

@@ -28,28 +28,30 @@ export default define(class TypeAssertion extends Assertion {
     return typeAssertionNode;
   }
 
-  validate(assignments, stated, context) {
-    let validates = false;
+  validate(stated, context) {
+    let typeAssertion = null;
 
     const typeAssertionString = this.getString();  ///
 
     context.trace(`Validating the '${typeAssertionString}' type assertion...`);
 
-    const valid = this.isValid();
+    const validAssertion = this.findValidAssertion(context);
 
-    if (valid) {
-      validates = true;
+    if (validAssertion) {
+      typeAssertion = validAssertion; ///
 
       context.debug(`...the '${typeAssertionString}' type assertion is already valid.`);
     } else {
+      let validates = false;
+
       const typeValidates = this.validateType(context);
 
       if (typeValidates) {
         let validatesWhenStated = false,
-              validatesWhenDerived = false;
+            validatesWhenDerived = false;
 
         if (stated) {
-          validatesWhenStated = this.validateWhenStated(assignments, context);
+          validatesWhenStated = this.validateWhenStated(context);
         } else {
           validatesWhenDerived = this.validateWhenDerived(context);
         }
@@ -62,15 +64,17 @@ export default define(class TypeAssertion extends Assertion {
       if (validates) {
         const assertion = this; ///
 
-        context.addAssertion(assertion);
+        typeAssertion = assertion;  ///
 
-        this.assign(assignments, stated, context);
+        this.assign(stated, context);
+
+        context.addAssertion(assertion);
 
         context.debug(`...verified the '${typeAssertionString}' type assertion.`);
       }
     }
 
-    return validates;
+    return typeAssertion;
   }
 
   validateType(context) {
@@ -98,14 +102,14 @@ export default define(class TypeAssertion extends Assertion {
     return typeValidates;
   }
 
-  validateWhenStated(assignments, context) {
+  validateWhenStated(context) {
     let validatesWhenStated = false;
 
     const typeAssertionString = this.getString(); ///
 
     context.trace(`Validating the '${typeAssertionString}' stated type assertion...`);
 
-    const termValidates = this.term.validate(context, () => {
+    const term = this.term.validate(context, () => {
       let validatesForwards;
 
       const termType = this.term.getType(),
@@ -118,7 +122,9 @@ export default define(class TypeAssertion extends Assertion {
       return validatesForwards;
     });
 
-    if (termValidates) {
+    if (term !== null) {
+      this.term = term;
+
       validatesWhenStated = true;
     }
 
@@ -130,13 +136,13 @@ export default define(class TypeAssertion extends Assertion {
   }
 
   validateWhenDerived(context) {
-    let validatesWhenDerived;
+    let validatesWhenDerived = false;
 
     const typeAssertionString = this.getString(); ///
 
     context.trace(`Validating the '${typeAssertionString}' derived type assertion...`);
 
-    const termValidates = this.term.validate(context, () => {
+    const term = this.term.validate(context, () => {
       let validatesForwards = false;
 
       const termType = this.term.getType(),
@@ -153,7 +159,11 @@ export default define(class TypeAssertion extends Assertion {
       return validatesForwards;
     });
 
-    validatesWhenDerived = termValidates; ///
+    if (term !== null) {
+      this.term = term;
+
+      validatesWhenDerived = true;
+    }
 
     if (validatesWhenDerived) {
       context.debug(`...verified the '${typeAssertionString}' derived type assertion.`);
@@ -162,11 +172,7 @@ export default define(class TypeAssertion extends Assertion {
     return validatesWhenDerived;
   }
 
-  assign(assignments, stated, context) {
-    if (assignments === null) {
-      return;
-    }
-
+  assign(stated, context) {
     if (!stated) {
       return;
     }
@@ -175,7 +181,7 @@ export default define(class TypeAssertion extends Assertion {
           variableAssigment = variableAssignmentFromTypeAssertion(typeAssertion, context),
           assignment = variableAssigment;  ///
 
-    assignments.push(assignment);
+    context.addAassignment(assignment);
   }
 
   static name = "TypeAssertion";

package/src/element/assertion.js

@@ -22,12 +22,12 @@ export default class Assertion extends Element {
     return assertionNodeMatches;
   }
 
-  isValid(context) {
+  findValidAssertion(context) {
     const assertionNode = this.getAssertionNode(),
-          assertionPresent = context.isAssertionPresentByAssertionNode(assertionNode),
-          valid = assertionPresent;  ///
+          assertion = context.findAssertionByAssertionNode(assertionNode),
+          validAssertion = assertion;  ///
 
-    return valid;
+    return validAssertion;
   }
 
   isEqualTo(assertion) {

package/src/element/assumption.js

@@ -67,39 +67,41 @@ export default define(class Assumption extends Element {
     return comparesToSubstituion;
   }
 
-  isValid(context) {
+  findValidAssumption(context) {
     const assumptionNode = this.getAssumptionNode(),
-          assumptionPresent = context.isAssumptionPresentByAssumptionNode(assumptionNode),
-          valid = assumptionPresent;  ///
+          assumption = context.findAssumptionByAssumptionNode(assumptionNode),
+          validAssumption = assumption;  ///
 
-    return valid;
+    return validAssumption;
   }
 
-  validate(assignments, stated, context) {
-    let validates = false;
+  validate(stated, context) {
+    let assumption = null;
 
     const assumptionString = this.getString();  ///
 
     context.trace(`Validating the '${assumptionString}' assumption...`);
 
-    const valid = this.isValid(context);
+    const validAssumption = this.findValidAssumption(context);
 
-    if (valid) {
-      validates = true;
+    if (validAssumption) {
+      assumption = validAssumption; ///
 
       context.debug(`...the '${assumptionString}' assumption is already valid.`);
     } else {
-      const referenceValidates = this.validateReference(assignments, stated, context);
+      let validates = false;
+
+      const referenceValidates = this.validateReference(stated, context);
 
       if (referenceValidates) {
-        const statementValidates = this.validateStatement(assignments, stated, context);
+        const statementValidates = this.validateStatement(stated, context);
 
         if (statementValidates) {
           let validatesWhenStated = false,
               validatesWhenDerived = false;
 
           if (stated) {
-            validatesWhenStated = this.validateWhenStated(assignments, context);
+            validatesWhenStated = this.validateWhenStated(context);
           } else {
             validatesWhenDerived = this.validateWhenDerived(context);
           }
@@ -111,7 +113,7 @@ export default define(class Assumption extends Element {
       }
 
       if (validates) {
-        const assumption = this;  ///
+        assumption = this;  ///
 
         context.addAssumption(assumption);
 
@@ -119,18 +121,22 @@ export default define(class Assumption extends Element {
       }
     }
 
-    return validates;
+    return assumption;
   }
 
-  validateReference(assignments, stated, context) {
-    let referenceValidates;
+  validateReference(stated, context) {
+    let referenceValidates = false;
 
     const assumptionString = this.getString(),  ///
           referenceString = this.reference.getString();
 
     context.trace(`Validating the '${assumptionString}' assumption's '${referenceString}' reference...`);
 
-    referenceValidates = this.reference.validate(context);
+    const reference = this.reference.validate(context);
+
+    if (reference !== null) {
+      referenceValidates = true;
+    }
 
     if (referenceValidates) {
       context.debug(`...validated the '${assumptionString}' assumption's '${referenceString}' statement.`);
@@ -139,19 +145,21 @@ export default define(class Assumption extends Element {
     return referenceValidates;
   }
 
-  validateStatement(assignments, stated, context) {
-    let statementValidates;
+  validateStatement(stated, context) {
+    let statementValidates = false;
 
     const assumptionString = this.getString(),  ///
-          statementString = this.statement.getString();
+      statementString = this.statement.getString();
 
     context.trace(`Validating the '${assumptionString}' assumption's '${statementString}' statement...`);
 
     stated = true;  ///
 
-    assignments = null; ///
+    const statement = this.statement.validate(stated, context);
 
-    statementValidates = this.statement.validate(assignments, stated, context);
+    if (statement !== null) {
+      statementValidates = true;
+    }
 
     if (statementValidates) {
       context.debug(`...validated the '${assumptionString}' assumption's '${statementString}' statement.`);
@@ -160,7 +168,7 @@ export default define(class Assumption extends Element {
     return statementValidates;
   }
 
-  validateReferenceAsMetavariable(assignments, stated, context) {
+  validateReferenceAsMetavariable(stated, context) {
     let referenceValidatesAsMetavariable;
 
     const referenceString = this.reference.getString(),
@@ -177,7 +185,7 @@ export default define(class Assumption extends Element {
     return referenceValidatesAsMetavariable;
   }
 
-  validateWhenStated(assignments, context) {
+  validateWhenStated(context) {
     let validatesWhenStated;
 
     const assumptionString = this.getString();  ///

package/src/element/combinator/bracketed.js

@@ -12,14 +12,14 @@ export default define(class BracketedCombinator extends Combinator {
     return bracketedCombinatorNode;
   }
 
-  unifyStatement(statement, assignments, stated, context) {
+  unifyStatement(statement, stated, context) {
     let statementUnifies;
 
     const statementString = statement.getString();
 
     context.trace(`Unifying the '${statementString}' statement with the bracketed combinator...`);
 
-    statementUnifies = super.unifyStatement(statement, assignments, stated, context);
+    statementUnifies = super.unifyStatement(statement, stated, context);
 
     if (statementUnifies) {
       context.debug(`...unified the '${statementString}' statement with the bracketed combinator.`);

package/src/element/combinator.js

@@ -25,16 +25,15 @@ export default define(class Combinator extends Element {
     return combinatorNode;
   }
 
-  verify() {
+  verify(context) {
     let verifies;
 
-    const context = this.getContext(),
-          combinatorString = this.getString();  ///
+    const combinatorString = this.getString();  ///
 
     context.trace(`Verifying the '${combinatorString}' combinator...`);
 
     const combinator = this,  ///
-          combinatorVerifies = verifyCombinator(combinator, context);
+          combinatorVerifies = verifyCombinator(combinator);
 
     if (combinatorVerifies) {
       verifies = true;
@@ -47,7 +46,7 @@ export default define(class Combinator extends Element {
     return verifies;
   }
 
-  unifyStatement(statement, assignments, stated, context) {
+  unifyStatement(statement, stated, context) {
     let statementUnifies;
 
     const statementString = statement.getString(),
@@ -64,7 +63,7 @@ export default define(class Combinator extends Element {
     context = specifiContext; ///
 
     const combinator = this, ///
-          statementUnifiesWithCombinator = unifyStatementWithCombinator(statement, combinator, assignments, stated, generalContext, specifiContext);
+          statementUnifiesWithCombinator = unifyStatementWithCombinator(statement, combinator, stated, generalContext, specifiContext);
 
     statementUnifies = statementUnifiesWithCombinator; ///
 

package/src/element/conclusion.js

@@ -35,9 +35,14 @@ export  default define(class Conclusion extends Element {
 
     if (this.statement !== null) {
       attempt((context) => {
+        let statementValidates = false;
+
         const stated = true,
-              assignments = null,
-              statementValidates = this.statement.validate(assignments, stated, context);
+              statement = this.statement.validate(stated, context);
+
+        if (statement !== null) {
+          statementValidates = true;
+        }
 
         if (statementValidates) {
           this.setContext(context);

package/src/element/constructor/bracketed.js

@@ -32,7 +32,7 @@ export default define(class BracketedConstructor extends Constructor {
 
         term = termFromTermNode(termNode, context);
 
-        const termValidates = term.validate(context, () => {
+        term = term.validate(context, () => {
           let validatesForwards;
 
           const type = term.getType();
@@ -44,7 +44,9 @@ export default define(class BracketedConstructor extends Constructor {
           return validatesForwards;
         });
 
-        validatesForwards = termValidates;  ///
+        if (term !== null) {
+          validatesForwards = true;
+        }
       }
 
       return validatesForwards;

package/src/element/declaration/combinator.js

@@ -30,7 +30,7 @@ export default define(class CombinatorDeclaration extends Declaration {
 
     context.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`);
 
-    const combinatorVerifies = this.combinator.verify();
+    const combinatorVerifies = this.verifyCombinator();
 
     if (combinatorVerifies) {
       context.addCombinator(this.combinator);
@@ -45,5 +45,23 @@ export default define(class CombinatorDeclaration extends Declaration {
     return verifies;
   }
 
+  verifyCombinator() {
+    let combinatorVerifies;
+
+    const context = this.getContext(),
+          combinatorString = this.combinator.getString(),
+          combinatorDeclarationString = this.getString();  ///
+
+    context.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration's '${combinatorString}' combinator...`);
+
+    combinatorVerifies = this.combinator.verify(context);
+
+    if (combinatorVerifies) {
+      context.debug(`...verified the '${combinatorDeclarationString}' combinator declaration's '${combinatorString}' combinator.`);
+    }
+
+    return combinatorVerifies;
+  }
+
   static name = "CombinatorDeclaration";
 });

package/src/element/declaration/constructor.js

@@ -3,77 +3,81 @@
 import Declaration from "../declaration";
 
 import { define } from "../../elements";
-import { validateTerm } from "../../process/validate";
 
 export default define(class ConstructorDeclaration extends Declaration {
-  constructor(context, string, node, constructor) {
+  constructor(context, string, node, type, provisional, constructor) {
     super(context, string, node);
 
+    this.type = type;
+    this.provisional = provisional;
     this.constructor = constructor;
   }
 
+  getType() {
+    return this.type;
+  }
+
+  isProvisinal() {
+    return this.provisional;
+  }
+
   getConstructor() {
     return this.constructor;
   }
 
   getConstructorDeclarationNode() {
     const node = this.getNode(),
-          constructorDeclarationNode = node;  ///
+          constructorDeclarationNode = node; ///
 
     return constructorDeclarationNode;
   }
 
-  verifyConstructor() {
-    let constructorValidates = false;
+  async verify() {
+    let verifies = false;
 
     const context = this.getContext(),
-          constructorString = this.constructor.getString();
+          constructorDeclarationString = this.getString();  ///
+
+    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
 
-    context.trace(`Verifying the '${constructorString}' constructor...`);
+    const typeVerified = this.verifyType();
 
-    const term = this.constructor.getTerm(),
-          termNode = term.getNode(),
-          termValidates = validateTerm(termNode, context, () => {
-            const validatesFormards = true;
+    if (typeVerified) {
+      const constructorVerifies = this.verifyConstructor();
 
-            return validatesFormards;
-          });
+      if (constructorVerifies) {
+        const constructorTypeVerifies = this.verifyConstructorType();
 
-    if (termValidates) {
-      constructorValidates = true;
+        if (constructorTypeVerifies) {
+          context.addConstructor(this.constructor);
+
+          verifies = true;
+        }
+      }
     }
 
-    if (constructorValidates) {
-      context.debug(`...verified the '${constructorString}' constructor.`);
+    if (verifies) {
+      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
     }
 
-    return constructorValidates;
+    return verifies;
   }
 
-  verifyConstructorType() {
-    let constructorTypeVerifies = false;
-
-    const context = this.getContext();
-
-    let type;
+  verifyType() {
+    let typeVerifies = false;
 
-    type = this.constructor.getType();
-
-    const typeString = type.getString();
-
-    context.trace(`Verifying the '${typeString}' type...`);
-
-    const nominalTypeName = type.getNominalTypeName();
+    const context = this.getContext(),
+          typeString = this.type.getString(),
+          constructorDeclarationString = this.getString();  ///
 
-    type = context.findTypeByNominalTypeName(nominalTypeName);
+    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's '${typeString}' type...`);
 
-    const typePresent = (type !== null)
+    const nominalTypeName = this.type.getNominalTypeName(),
+          type = context.findTypeByNominalTypeName(nominalTypeName);
 
-    if (!typePresent) {
-      context.debug(`The '${typeString}' type is not present.`);
-    } else {
+    if (type !== null) {
       const includeSupertypes = false,
-            provisional = type.isProvisional(includeSupertypes),
+            provisional = this.isProvisional(includeSupertypes),
             typeComparesToProvisional = type.compareProvisional(provisional);
 
       if (!typeComparesToProvisional) {
@@ -81,45 +85,104 @@ export default define(class ConstructorDeclaration extends Declaration {
           context.debug(`The '${typeString}' type is present but not provisional.`) :
             context.debug(`The '${typeString}' type is present but provisional.`);
       } else {
-        this.constructor.setType(type);
+        this.type = type;
 
-        constructorTypeVerifies = true;
+        typeVerifies = true;
       }
+    } else {
+      context.debug(`The '${typeString}' type is not present.`);
     }
 
-    if (constructorTypeVerifies) {
-      context.debug(`...verified the '${typeString}' type.`);
+    if (typeVerifies) {
+      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's '${typeString}' type.`);
     }
 
-    return constructorTypeVerifies;
+    return typeVerifies;
   }
 
-  async verify() {
-    let verifies;
+  verifyConstructor() {
+    let constructorVerifies;
 
     const context = this.getContext(),
-          constructorDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration...`);
-
-    const constructorTypeVerifies = this.verifyConstructorType();
+          constructorString = this.constructor.getString(),
+          constructorDeclarationString = this.getString();  ///
 
-    if (constructorTypeVerifies) {
-      const constructorValidates = this.verifyConstructor();
+    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor...`);
 
-      if (constructorValidates) {
-        context.addConstructor(this.constructor);
+    constructorVerifies = this.constructor.verify(context);
 
-        verifies = true;
-      }
-    }
-
-    if (verifies) {
-      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration.`);
+    if (constructorVerifies) {
+      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor.`);
     }
 
-    return verifies;
+    return constructorVerifies;
   }
 
+  // verifyConstructorType() {
+  //   let constructorTypeVerifies = false;
+  //
+  //   const context = this.getContext(),
+  //         constructorType = this,
+  //         constructorTypeString = constructorType.getString(),
+  //         constructorDeclarationString = this.getString();  ///
+  //
+  //   context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's '${constructorTypeString}' type...`);
+  //
+  //   const nominalTypeName = this.type.getNominalTypeName(),
+  //     typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
+  //
+  //   if (!typePresent) {
+  //     context.debug(`The '${typeString}' type is not present.`);
+  //   } else {
+  //     const includeSupertypes = false,
+  //       provisional = type.isProvisional(includeSupertypes),
+  //       typeComparesToProvisional = type.compareProvisional(provisional);
+  //
+  //     if (!typeComparesToProvisional) {
+  //       provisional ?
+  //         context.debug(`The '${typeString}' type is present but not provisional.`) :
+  //         context.debug(`The '${typeString}' type is present but provisional.`);
+  //     } else {
+  //       this.constructor.setType(type);
+  //
+  //       constructorTypeVerifies = true;
+  //     }
+  //   }
+  //
+  //   if (constructorTypeVerifies) {
+  //     context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's '${typeString}' type.`);
+  //   }
+  //
+  //   return constructorTypeVerifies;
+  // }
+
   static name = "ConstructorDeclaration";
 });
+
+
+// verifyConstructor() {
+//   let constructorValidates = false;
+//
+//   const context = this.getContext(),
+//         constructorString = this.constructor.getString();
+//
+//   context.trace(`Verifying the '${constructorString}' constructor...`);
+//
+//   const term = this.constructor.getTerm(),
+//         termNode = term.getNode(),
+//         termValidates = validateTerm(termNode, context, () => {
+//           const validatesFormards = true;
+//
+//           return validatesFormards;
+//         });
+//
+//   if (termValidates) {
+//     constructorValidates = true;
+//   }
+//
+//   if (constructorValidates) {
+//     context.debug(`...verified the '${constructorString}' constructor.`);
+//   }
+//
+//   return constructorValidates;
+// }

package/src/element/deduction.js

@@ -35,9 +35,14 @@ export default define(class Deduction extends Element {
 
     if (this.statement !== null) {
       attempt((context) => {
+        let statementValidates = false;
+
         const stated = true,
-              assignments = null,
-              statementValidates = this.statement.validate(assignments, stated, context);
+              statement = this.statement.validate(stated, context);
+
+        if (statement !== null) {
+          statementValidates = true;
+        }
 
         if (statementValidates) {
           this.setContext(context);