occam-verify-cli 1.0.708 → 1.0.713

package/src/element/conclusion.js

@@ -35,15 +35,15 @@ export  default define(class Conclusion extends Element {
 
     context.trace(`Verifying the '${conclusionString}' conclusion...`);
 
-    attempt((context) => {
+    if (this.statement !== null) {
       const validates = this.validate(context);
 
       if (validates) {
-        this.setContext(context);
-
         verifies = true;
       }
-    }, context);
+    } else {
+      context.debug(`Unable to verify the '${conclusionString}' conclusion because it is nonsense.`);
+    }
 
     if (verifies) {
       context.debug(`...verified the '${conclusionString}' conclusion.`);
@@ -59,15 +59,15 @@ export  default define(class Conclusion extends Element {
 
     context.trace(`Validating the '${conclusionString}' conclusion...`);
 
-    if (this.statement !== null) {
+    attempt((context) => {
       const statementValidates = this.validateStatement(context);
 
       if (statementValidates) {
+        this.setContext(context);
+
         validates = true;
       }
-    } else {
-      context.debug(`Unable to verify the '${conclusionString}' conclusion because it is nonsense.`);
-    }
+    }, context);
 
     if (validates) {
       context.debug(`...validated the '${conclusionString}' conclusion.`);

package/src/element/constructor.js

@@ -5,9 +5,9 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { attempt, literally } from "../utilities/context";
 import { instantiateConstructor } from "../process/instantiate";
-import { verifyTermAsConstructor } from "../process/verify";
 import { termFromConstructorNode } from "../utilities/element";
 import { unifyTermWithConstructor } from "../process/unify";
+import { validateTermAsConstructor } from "../process/validate";
 import { typeFromJSON, termToTermJSON, typeToTypeJSON, ephemeralContextFromJSON } from "../utilities/json";
 
 export default define(class Constructor extends Element {
@@ -52,58 +52,59 @@ export default define(class Constructor extends Element {
     this.type = type;
   }
 
-  verify(context) {
-    let verifies = false;
+  validate(context) {
+    let validates = false;
 
     const includeType = false,
           constructorString = this.getString(includeType);
 
-    context.trace(`Verifying the '${constructorString}' constructor...`);
+    context.trace(`Validating the '${constructorString}' constructor...`);
 
     attempt((context) => {
-      const termVerifies = this.verifyTerm(context);
+      const termValidates = this.validateTerm(context);
 
-      if (termVerifies) {
+      if (termValidates) {
         this.setContext(context);
 
-        verifies = true;
+        validates = true;
       }
     }, context);
 
-    if (verifies) {
-      context.debug(`...verified the '${constructorString}' constructor.`);
+    if (validates) {
+      context.debug(`...validated the '${constructorString}' constructor.`);
     }
 
-    return verifies;
+    return validates;
   }
 
-  verifyTerm(context) {
-    let termVerifies = false;
+  validateTerm(context) {
+    let termValidates = false;
 
     const termString = this.term.getString(),
           includeType = false,
           constructorString = this.getString(includeType);
 
-    context.trace(`Verifying the '${constructorString}' constructor's '${termString}' term...`);
+    context.trace(`Validating the '${constructorString}' constructor's '${termString}' term...`);
 
-    const termVerifiesAsConstructor = verifyTermAsConstructor(this.term, context);
+    const termValidatesAsConstructor = validateTermAsConstructor(this.term, context);
 
-    if (termVerifiesAsConstructor) {
-      termVerifies = true;
+    if (termValidatesAsConstructor) {
+      termValidates = true;
     }
 
-    if (termVerifies) {
-      context.debug(`...verified the '${constructorString}' constructor's '${termString}' term.`);
+    if (termValidates) {
+      context.debug(`...validated the '${constructorString}' constructor's '${termString}' term.`);
     }
 
-    return termVerifies;
+    return termValidates;
   }
 
   unifyTerm(term, context, validateForwards) {
     let termUnifies = false;
 
     const termString = term.getString(),
-          constructorString = this.getString(); ///
+          includeType = false,
+          constructorString = this.getString(includeType);
 
     context.trace(`Unifying the '${termString}' term with the '${constructorString}' constructor...`);
 

package/src/element/declaration/combinator.js

@@ -33,9 +33,9 @@ export default define(class CombinatorDeclaration extends Declaration {
 
     context.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration...`);
 
-    const combinatorVerifies = this.verifyCombinator();
+    const combinatorValidates = this.validateCombinator();
 
-    if (combinatorVerifies) {
+    if (combinatorValidates) {
       context.addCombinator(this.combinator);
 
       verifies = true;
@@ -48,22 +48,22 @@ export default define(class CombinatorDeclaration extends Declaration {
     return verifies;
   }
 
-  verifyCombinator() {
-    let combinatorVerifies;
+  validateCombinator() {
+    let combinatorValidates;
 
     const context = this.getContext(),
           combinatorString = this.combinator.getString(),
           combinatorDeclarationString = this.getString();  ///
 
-    context.trace(`Verifying the '${combinatorDeclarationString}' combinator declaration's '${combinatorString}' combinator...`);
+    context.trace(`Validating the '${combinatorDeclarationString}' combinator declaration's '${combinatorString}' combinator...`);
 
-    combinatorVerifies = this.combinator.verify(context);
+    combinatorValidates = this.combinator.validate(context);
 
-    if (combinatorVerifies) {
-      context.debug(`...verified the '${combinatorDeclarationString}' combinator declaration's '${combinatorString}' combinator.`);
+    if (combinatorValidates) {
+      context.debug(`...validated the '${combinatorDeclarationString}' combinator declaration's '${combinatorString}' combinator.`);
     }
 
-    return combinatorVerifies;
+    return combinatorValidates;
   }
 
   static name = "CombinatorDeclaration";

package/src/element/declaration/constructor.js

@@ -46,9 +46,9 @@ export default define(class ConstructorDeclaration extends Declaration {
     const typeVerified = this.verifyType();
 
     if (typeVerified) {
-      const constructorVerifies = this.verifyConstructor();
+      const constructorValidates = this.validateConstructor();
 
-      if (constructorVerifies) {
+      if (constructorValidates) {
         this.constructor.setType(this.type);
 
         context.addConstructor(this.constructor);
@@ -100,23 +100,23 @@ export default define(class ConstructorDeclaration extends Declaration {
     return typeVerifies;
   }
 
-  verifyConstructor() {
-    let constructorVerifies;
+  validateConstructor() {
+    let constructorValidates;
 
     const context = this.getContext(),
           includeType = false,
           constructorString = this.constructor.getString(includeType),
           constructorDeclarationString = this.getString();  ///
 
-    context.trace(`Verifying the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor...`);
+    context.trace(`Validating the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor...`);
 
-    constructorVerifies = this.constructor.verify(context);
+    constructorValidates = this.constructor.validate(context);
 
-    if (constructorVerifies) {
-      context.debug(`...verified the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor.`);
+    if (constructorValidates) {
+      context.debug(`...validated the '${constructorDeclarationString}' constructor declaration's '${constructorString}' constructor.`);
     }
 
-    return constructorVerifies;
+    return constructorValidates;
   }
 
   static name = "ConstructorDeclaration";

package/src/element/deduction.js

@@ -35,15 +35,15 @@ export default define(class Deduction extends Element {
 
     context.trace(`Verifying the '${duductionString}' duduction...`);
 
-    attempt((context) => {
+    if (this.statement !== null) {
       const validates = this.validate(context);
 
       if (validates) {
-        this.setContext(context);
-
         verifies = true;
       }
-    }, context);
+    } else {
+      context.debug(`Unable to verify the '${duductionString}' duduction because it is nonsense.`);
+    }
 
     if (verifies) {
       context.debug(`...verified the '${duductionString}' duduction.`);
@@ -59,15 +59,15 @@ export default define(class Deduction extends Element {
 
     context.trace(`Validating the '${duductionString}' duduction...`);
 
-    if (this.statement !== null) {
+    attempt((context) => {
       const statementValidates = this.validateStatement(context);
 
       if (statementValidates) {
+        this.setContext(context);
+
         validates = true;
       }
-    } else {
-      context.debug(`Unable to verify the '${duductionString}' duduction because it is nonsense.`);
-    }
+    }, context);
 
     if (validates) {
       context.debug(`...validated the '${duductionString}' duduction.`);

package/src/element/frame.js

@@ -252,6 +252,25 @@ export default define(class Frame extends Element {
     return validatesWhenDerived;
   }
 
+  validateAssumption(assumption, context) {
+    let assumptionValidates;
+
+    const frameString = this.getString(), ///
+          assumptionstring = assumption.getString();
+
+    context.trace(`Validating the '${frameString}' frame's '${assumptionstring}' assumption.`);
+
+    const stated = true;  ///
+
+    assumptionValidates = assumption.validate(stated, context);
+
+    if (assumptionValidates) {
+      context.debug(`...validated the '${frameString}' frame's '${assumptionstring}' assumption.`);
+    }
+
+    return assumptionValidates;
+  }
+
   validateAssumptions(stated, context) {
     let assumptionsValidate;
 
@@ -261,14 +280,12 @@ export default define(class Frame extends Element {
       const frameString = this.getString(), ///
             assumptionsString = assumptionsStringFromAssumptions(this.assumptions);
 
-      context.trace(`Validating the '${assumptionsString}' assumptions of the '${frameString}' frame...`);
-
-      stated = true;  ///
+      context.trace(`Validating the '${frameString}' frame's '${assumptionsString}' assumptions...`);
 
       const assumptions = [];
 
       assumptionsValidate = this.assumptions.every((assumption) => {
-        const assumptionValidates = assumption.validate(stated, context);
+        const assumptionValidates = this.validateAssumption(assumption, context);
 
         if (assumptionValidates) {
           assumptions.push(assumption);
@@ -280,7 +297,7 @@ export default define(class Frame extends Element {
       if (assumptionsValidate) {
         this.assumptions = assumptions;
 
-        context.debug(`...validated the '${assumptionsString}' assumptions of the '${frameString}' frame.`);
+        context.debug(`...validated the '${frameString}' frame's '${assumptionsString}' assumptions.`);
       }
     } else {
       assumptionsValidate = true;
@@ -335,9 +352,11 @@ export default define(class Frame extends Element {
     const metaTypeName = metaType.getName();
 
     if (metaTypeName === FRAME_META_TYPE_NAME) {
-      const validates = this.validate(stated, context)
+      const frame = this.validate(stated, context);
 
-      validatesGivenMetaType = validates; ///
+      if (frame !== null) {
+        validatesGivenMetaType = true;
+      }
     }
 
     if (validatesGivenMetaType) {

package/src/element/metavariable.js

@@ -284,7 +284,6 @@ export default define(class Metavariable extends Element {
 
         if (referenceSubstitution !== null) {
           referenceUnifies = true;
-
         }
       }
     }

package/src/element/proofAssertion/premise.js

@@ -41,18 +41,17 @@ export default define(class Premise extends ProofAssertion {
 
     context.trace(`Verifying the '${premiseString}' premise...`);
 
-    attempt((context) => {
+    const statement = this.getStatement(),
+          procedureCall = this.getProcedureCall();
+
+    if ((statement !== null) || (procedureCall !== null)) {
       const validates = this.validate(context);
 
       if (validates) {
-        this.setContext(context);
-
         verifies = true;
       }
-    }, context);
-
-    if (verifies) {
-      context.debug(`...verified the '${premiseString}' premise.`);
+    } else {
+      context.debug(`Unable to validate the '${premiseString}' premise because it is nonsense.`);
     }
 
     return verifies;
@@ -65,26 +64,30 @@ export default define(class Premise extends ProofAssertion {
 
     context.trace(`Validatting the '${premiseString}' premise...`);
 
-    const statement = this.getStatement(),
-          procedureCall = this.getProcedureCall();
+    attempt((context) => {
+      const statement = this.getStatement(),
+            procedureCall = this.getProcedureCall();
+
+      if (statement !== null) {
+        const statementValidates = this.validateStatement(context);
 
-    if (false) {
-      ///
-    } else if (statement !== null) {
-      const statementValidates = this.validateStatement(context);
+        if (statementValidates) {
+          this.setContext(context);
 
-      if (statementValidates) {
-        validates = true;
+          validates = true;
+        }
       }
-    } else if (procedureCall !== null) {
-      const procedureCallValidates = this.validateProcedureCall(context);
 
-      if (procedureCallValidates) {
-        validates = true;
+      if (procedureCall !== null) {
+        const procedureCallValidates = this.validateProcedureCall(context);
+
+        if (procedureCallValidates) {
+          this.setContext(context);
+
+          validates = true;
+        }
       }
-    } else {
-      context.debug(`Unable to validate the '${premiseString}' premise because it is nonsense.`);
-    }
+    }, context);
 
     if (validates) {
       context.debug(`...validated the '${premiseString}' premise.`);
@@ -101,7 +104,11 @@ export default define(class Premise extends ProofAssertion {
 
     context.trace(`Validatting the '${premiseString}' premise's '${procedureCallString}' procedure call...`);
 
-    procedureCallValidates = this.procedureCall.validate(context);
+    const procedureCall = this.procedureCall.validate(context);
+
+    if (procedureCall !== null) {
+      procedureCallValidates = true;
+    }
 
     if (procedureCallValidates) {
       context.debug(`...validated the '${premiseString}' premise's '${procedureCallString}' procedure call.`);
@@ -150,7 +157,7 @@ export default define(class Premise extends ProofAssertion {
   }
 
   unifyProofAssertion(proofAssertion, context) {
-    let proofAssertionUnifies;
+    let proofAssertionUnifies = false;
 
     const premiseString = this.getString(), ///
           proofAssertionString = proofAssertion.getString();
@@ -160,18 +167,21 @@ export default define(class Premise extends ProofAssertion {
     const proofAssertionContext = proofAssertion.getContext(),
           premiseContext = this.getContext(),
           generalContext = premiseContext, ///
-          specificContext = proofAssertionContext; ///
+          specificContext = proofAssertionContext,
+          statementUnifies = liminally((specificContext) => {
+            const statement = proofAssertion.getStatement(),
+                  statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
 
-    proofAssertionUnifies = liminally((specificContext) => {
-      const statement = proofAssertion.getStatement(),
-            statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
+            if (statementUnifies) {
+              specificContext.commit(context);
 
-      if (statementUnifies) {
-        specificContext.commit(context);
+              return true;
+            }
+          }, specificContext);
 
-        return true;
-      }
-    }, specificContext);
+    if (statementUnifies) {
+      proofAssertionUnifies = true;
+    }
 
     if (proofAssertionUnifies) {
       context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${premiseString}' premise.`);

package/src/element/proofAssertion/step.js

@@ -6,7 +6,7 @@ import ProofAssertion from "../proofAssertion";
 
 import { define } from "../../elements";
 import { unifyStatements } from "../../utilities/unification";
-import { asyncAttempt, asyncLiminally } from "../../utilities/context";
+import { attempt, asyncLiminally } from "../../utilities/context";
 import { propertyAssertionFromStatement } from "../../utilities/statement";
 
 const { asyncSome } = asynchronousUtilities;
@@ -75,19 +75,23 @@ export default define(class Step extends ProofAssertion {
 
     context.trace(`Verifying the '${stepString}' step...`);
 
-    await asyncAttempt(async (context) => {
+    const statement = this.getStatement();
+
+    if (statement !== null) {
       const validates = this.validate(context);
 
       if (validates) {
-        const unifies = await this.unify(context);
+        context = this.getContext();
 
-        if (unifies) {
-          this.setContext(context);
+        const unifiies = await this.unify(context);
 
+        if (unifiies) {
           verifies = true;
         }
       }
-    }, context);
+    } else {
+      context.debug(`Unable to verify the '${stepString}' step because it is nonsense.`);
+    }
 
     if (verifies) {
       context.debug(`...verified the '${stepString}' step.`);
@@ -103,9 +107,7 @@ export default define(class Step extends ProofAssertion {
 
     context.trace(`Validating the '${stepString}' step...`);
 
-    const statement = this.getStatement();
-
-    if (statement !== null) {
+    attempt((context) => {
       const referenceValidates = this.validateReference(context);
 
       if (referenceValidates) {
@@ -115,16 +117,16 @@ export default define(class Step extends ProofAssertion {
           const statementValidates = this.validateStatement(context);
 
           if (statementValidates) {
+            this.setContext(context);
+
             validates = true;
           }
         }
       }
-    } else {
-      context.debug(`Unable to validate the '${stepString}' step because it is nonsense.`);
-    }
+    }, context);
 
     if (validates) {
-      context.debug(`...validate the '${stepString}' step.`);
+      context.debug(`...validated the '${stepString}' step.`);
     }
 
     return validates;

package/src/element/proofAssertion/supposition.js

@@ -37,22 +37,21 @@ export default define(class Supposition extends ProofAssertion {
 
     await this.break(context);
 
-    const suppositionString = this.getString(); ///
+    const suppositionString = this.getString();
 
     context.trace(`Verifying the '${suppositionString}' supposition...`);
 
-    attempt((context) => {
+    const statement = this.getStatement(),
+          procedureCall = this.getProcedureCall();
+
+    if ((statement !== null) || (procedureCall !== null)) {
       const validates = this.validate(context);
 
       if (validates) {
-        this.setContext(context);
-
         verifies = true;
       }
-    }, context);
-
-    if (verifies) {
-      context.debug(`...verified the '${suppositionString}' supposition.`);
+    } else {
+      context.debug(`Unable to validate the '${suppositionString}' supposition because it is nonsense.`);
     }
 
     return verifies;
@@ -65,26 +64,30 @@ export default define(class Supposition extends ProofAssertion {
 
     context.trace(`Validatting the '${suppositionString}' supposition...`);
 
-    const statement = this.getStatement(),
-          procedureCall = this.getProcedureCall();
+    attempt((context) => {
+      const statement = this.getStatement(),
+            procedureCall = this.getProcedureCall();
+
+      if (statement !== null) {
+        const statementValidates = this.validateStatement(context);
 
-    if (false) {
-      ///
-    } else if (statement !== null) {
-      const statementValidates = this.validateStatement(context);
+        if (statementValidates) {
+          this.setContext(context);
 
-      if (statementValidates) {
-        validates = true;
+          validates = true;
+        }
       }
-    } else if (procedureCall !== null) {
-      const procedureCallValidates = this.validateProcedureCall(context);
 
-      if (procedureCallValidates) {
-        validates = true;
+      if (procedureCall !== null) {
+        const procedureCallValidates = this.validateProcedureCall(context);
+
+        if (procedureCallValidates) {
+          this.setContext(context);
+
+          validates = true;
+        }
       }
-    } else {
-      context.debug(`Unable to validate the '${suppositionString}' supposition because it is nonsense.`);
-    }
+    }, context);
 
     if (validates) {
       context.debug(`...validated the '${suppositionString}' supposition.`);
@@ -101,7 +104,11 @@ export default define(class Supposition extends ProofAssertion {
 
     context.trace(`Validatting the '${suppositionString}' supposition's '${procedureCallString}' procedure call...`);
 
-    procedureCallValidates = this.procedureCall.validate(context);
+    const procedureCall = this.procedureCall.validate(context);
+
+    if (procedureCall !== null) {
+      procedureCallValidates =true;
+    }
 
     if (procedureCallValidates) {
       context.debug(`...validated the '${suppositionString}' supposition's '${procedureCallString}' procedure call.`);
@@ -172,7 +179,7 @@ export default define(class Supposition extends ProofAssertion {
   }
 
   unifyProofAssertion(proofAssertion, context) {
-    let proofAssertionUnifies;
+    let proofAssertionUnifies = false;
 
     const suppositionString = this.getString(), ///
           proofAssertionString = proofAssertion.getString();
@@ -182,18 +189,21 @@ export default define(class Supposition extends ProofAssertion {
     const proofAssertionContext = proofAssertion.getContext(),
           suppositionContext = this.getContext(),
           generalContext = suppositionContext, ///
-          specificContext = proofAssertionContext; ///
+          specificContext = proofAssertionContext,
+          statementUnifies = liminally((specificContext) => {
+            const statement = proofAssertion.getStatement(),
+              statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
 
-    proofAssertionUnifies = liminally((specificContext) => {
-      const statement = proofAssertion.getStatement(),
-            statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
+            if (statementUnifies) {
+              specificContext.commit(context);
 
-      if (statementUnifies) {
-        specificContext.commit(context);
+              return true;
+            }
+          }, specificContext);
 
-        return true;
-      }
-    }, specificContext);
+    if (statementUnifies) {
+      proofAssertionUnifies = true;
+    }
 
     if (proofAssertionUnifies) {
       context.debug(`...unified the '${proofAssertionString}' proof assertion with the '${suppositionString}' supposition.`);