occam-verify-cli 1.0.747 → 1.0.757

package/src/element/conclusion.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { attempt, literally } from "../utilities/context";
+import { attempt, instantiate } from "../utilities/context";
 import { instantiateConclusion } from "../process/instantiate";
 import { statementFromConclusionNode } from "../utilities/element";
 import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
@@ -63,7 +63,7 @@ export  default define(class Conclusion extends Element {
       const statementValidates = this.validateStatement(context);
 
       if (statementValidates) {
-        this.setContext(context);
+        context.commit(this);
 
         validates = true;
       }
@@ -150,7 +150,7 @@ export  default define(class Conclusion extends Element {
 
     context = ephemeralContext; ///
 
-    const conclusion = literally((context) => {
+    const conclusion = instantiate((context) => {
       const { string } = json,
             conclusionNode = instantiateConclusion(string, context),
             node = conclusionNode,  ///
@@ -163,10 +163,3 @@ export  default define(class Conclusion extends Element {
     return conclusion;
   }
 });
-
-function statementFromConclusionNode(conclusionNode, context) {
-  const statementNode = conclusionNode.getStatementNode(),
-        statement = context.findStatementByStatementNode(statementNode);
-
-  return statement;
-}

package/src/element/constructor/bracketed.js

@@ -20,7 +20,7 @@ export default define(class BracketedConstructor extends Constructor {
 
     context.trace(`Unifying the '${termString}' term with the bracketed constructor...`);
 
-    termUnifies = super.unifyTerm(term, context, () => {
+    termUnifies = super.unifyTerm(term, context, (term) => {
       let validatesForwards = false;
 
       const bracketedTerm = term, ///
@@ -28,23 +28,25 @@ export default define(class BracketedConstructor extends Constructor {
             singularTermNode = bracketedTermNode.getSingularTermNode();
 
       if (singularTermNode !== null) {
-        const termNode = singularTermNode;  ///
+        const bracketlessTermNode = singularTermNode; ///
 
-        term = termFromTermNode(termNode, context);
+        let bracketlessTerm;
 
-        term = term.validate(context, () => {
+        bracketlessTerm = termFromTermNode(bracketlessTermNode, context);
+
+        bracketlessTerm = bracketlessTerm.validate(context, (bracketlessTerm) => {  ///
           let validatesForwards;
 
-          const type = term.getType();
+          const type = bracketlessTerm.getType();
 
           bracketedTerm.setType(type);
 
-          validatesForwards = validateForwards();
+          validatesForwards = validateForwards(bracketedTerm);
 
           return validatesForwards;
         });
 
-        if (term !== null) {
+        if (bracketlessTerm !== null) {
           validatesForwards = true;
         }
       }

package/src/element/constructor.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { attempt, literally } from "../utilities/context";
+import { attempt, instantiate } from "../utilities/context";
 import { instantiateConstructor } from "../process/instantiate";
 import { termFromConstructorNode } from "../utilities/element";
 import { unifyTermWithConstructor } from "../process/unify";
@@ -64,7 +64,7 @@ export default define(class Constructor extends Element {
       const termValidates = this.validateTerm(context);
 
       if (termValidates) {
-        this.setContext(context);
+        context.commit(this);
 
         validates = true;
       }
@@ -122,11 +122,17 @@ export default define(class Constructor extends Element {
     if (termUnifiesWithConstructor) {
       let validatesForwards;
 
+      const typeString = this.type.getString();
+
+      context.trace(`Setting the '${termString}' term's type to the '${constructorString}' constructor's '${typeString}' type.`);
+
       term.setType(this.type);
 
-      validatesForwards = validateForwards();
+      validatesForwards = validateForwards(term);
 
-      termUnifies = validatesForwards;  ///
+      if (validatesForwards) {
+        termUnifies = true;
+      }
     }
 
     if (termUnifies) {
@@ -167,7 +173,7 @@ export default define(class Constructor extends Element {
 
     context = ephemeralContext; ///
 
-    const constructor = literally((context) => {
+    const constructor = instantiate((context) => {
       const { string } = json,
             constructorNode = instantiateConstructor(string, context),
             node = constructorNode, ///

package/src/element/deduction.js

@@ -3,8 +3,9 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { attempt, literally } from "../utilities/context";
+import { attempt, instantiate } from "../utilities/context";
 import { instantiateDeduction } from "../process/instantiate";
+import { statementFromDeductionNode } from "../utilities/element";
 import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
 
 export default define(class Deduction extends Element {
@@ -30,9 +31,9 @@ export default define(class Deduction extends Element {
 
     await this.break(context);
 
-    const duductionString = this.getString();  ///
+    const deductionString = this.getString();  ///
 
-    context.trace(`Verifying the '${duductionString}' duduction...`);
+    context.trace(`Verifying the '${deductionString}' deduction...`);
 
     if (this.statement !== null) {
       const validates = this.validate(context);
@@ -41,11 +42,11 @@ export default define(class Deduction extends Element {
         verifies = true;
       }
     } else {
-      context.debug(`Unable to verify the '${duductionString}' duduction because it is nonsense.`);
+      context.debug(`Unable to verify the '${deductionString}' deduction because it is nonsense.`);
     }
 
     if (verifies) {
-      context.debug(`...verified the '${duductionString}' duduction.`);
+      context.debug(`...verified the '${deductionString}' deduction.`);
     }
 
     return verifies;
@@ -54,22 +55,22 @@ export default define(class Deduction extends Element {
   validate(context) {
     let validates = false;
 
-    const duductionString = this.getString();  ///
+    const deductionString = this.getString();  ///
 
-    context.trace(`Validating the '${duductionString}' duduction...`);
+    context.trace(`Validating the '${deductionString}' deduction...`);
 
     attempt((context) => {
       const statementValidates = this.validateStatement(context);
 
       if (statementValidates) {
-        this.setContext(context);
+        context.commit(this);
 
         validates = true;
       }
     }, context);
 
     if (validates) {
-      context.debug(`...validated the '${duductionString}' duduction.`);
+      context.debug(`...validated the '${deductionString}' deduction.`);
     }
 
     return validates;
@@ -79,9 +80,9 @@ export default define(class Deduction extends Element {
     let statementValidates;
 
     const statementString = this.statement.getString(),
-          duductionnString = this.getString();  ///
+          deductionnString = this.getString();  ///
 
-    context.trace(`Validating the '${duductionnString}' duductionn's '${statementString}' statement...`);
+    context.trace(`Validating the '${deductionnString}' deductionn's '${statementString}' statement...`);
 
     const stated = true,
           statement = this.statement.validate(stated, context);
@@ -91,7 +92,7 @@ export default define(class Deduction extends Element {
     }
 
     if (statementValidates) {
-      context.trace(`...validated the '${duductionnString}' duductionn's '${statementString}' statement.`);
+      context.trace(`...validated the '${deductionnString}' deductionn's '${statementString}' statement.`);
     }
 
     return statementValidates;
@@ -174,23 +175,16 @@ export default define(class Deduction extends Element {
 
     context = ephemeralContext; ///
 
-    const duduction = literally((context) => {
+    const deduction = instantiate((context) => {
       const { string } = json,
             deductionNode = instantiateDeduction(string, context),
             node = deductionNode,  ///
             statement = statementFromDeductionNode(deductionNode, context),
-            duduction = new Deduction(context, string, node, statement);
+            deduction = new Deduction(context, string, node, statement);
 
-      return duduction;
+      return deduction;
     }, context);
 
-    return duduction;
+    return deduction;
   }
 });
-
-function statementFromDeductionNode(deductionNode, context) {
-  const statementNode = deductionNode.getStatementNode(),
-        statement = context.findStatementByStatementNode(statementNode);
-
-  return statement;
-}

package/src/element/derivation.js

@@ -28,11 +28,12 @@ export default define(class Derivation extends Element {
     return derivationNode;
   }
 
-  getLastProofAssertion() {
+  getLastStep() {
     const lastSubproofOrProofAssertion = last(this.subproofOrProofAssertions),
-          lastProofAssertion = lastSubproofOrProofAssertion;  ///
+          lastProofAssertion = lastSubproofOrProofAssertion,  ///
+          lastStep = lastProofAssertion;  ///
 
-    return lastProofAssertion;
+    return lastStep;
   }
 
   async verify(context) {

package/src/element/equality.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { equateTerms } from "../process/equate";
 import { instantiateEquality } from "../process/instantiate";
 import { equalityAssignmentFromEquality, leftVariableAssignmentFromEquality, rightVariableAssignmentFromEquality } from "../process/assign";
@@ -172,11 +172,19 @@ export default define(class Equality extends Element {
     let leftTerm,
         rightTerm;
 
-    leftTerm = this.leftTerm.validate(context, () => {
+    leftTerm = this.leftTerm.validate(context, (leftTerm) => {
         let validatesForwards = false;
 
-        rightTerm = this.rightTerm.validate(context, () => {
-          const validatesForwards = true;
+        rightTerm = this.rightTerm.validate(context, (rightTerm) => {
+          let validatesForwards = false;
+
+          const leftTermType = leftTerm.getType(),
+                rightTermType = rightTerm.getType(),
+                leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
+
+          if (leftTermTypeComparableToRightTermType) {
+            validatesForwards = true;
+          }
 
           return validatesForwards;
         });
@@ -189,17 +197,11 @@ export default define(class Equality extends Element {
       });
 
     if (leftTerm !== null) {
-      const leftTermType = leftTerm.getType(),
-            rightTermType = rightTerm.getType(),
-            leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
+      this.leftTerm = leftTerm;
 
-      if (leftTermTypeComparableToRightTermType) {
-        this.leftTerm = leftTerm;
+      this.rightTerm = rightTerm;
 
-        this.rightTerm = rightTerm;
-
-        termsValidate = true;
-      }
+      termsValidate = true;
     }
 
     if (termsValidate) {
@@ -278,7 +280,7 @@ export default define(class Equality extends Element {
   }
 
   static fromJSON(json, context) {
-    const equality = literally((context) => {
+    const equality = instantiate((context) => {
       const { string } = json,
             equalityNode = instantiateEquality(string, context),
             node = equalityNode,  ///

package/src/element/equivalence.js

@@ -4,7 +4,7 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { instantiateEquivalence } from "../process/instantiate";
 import { stripBracketsFromTermNode } from "../utilities/brackets";
 import { equivalenceStringFromTerms } from "../utilities/string";
@@ -232,7 +232,7 @@ export default define(class Equivalence extends Element {
     const terms = equivalence.getTerms(),
           combinedTerms = this.combineTerms(terms);
 
-    return literally((context) => {
+    return instantiate((context) => {
       const terms = combinedTerms,  ///
             equivalenceString = equivalenceStringFromTerms(terms),
             string = equivalenceString,  ///
@@ -246,7 +246,7 @@ export default define(class Equivalence extends Element {
   static name = "Equivalence";
 
   static fromEquality(equality, context) {
-    return literally((context) => {
+    return instantiate((context) => {
       const terms = equality.getTerms(),
             equivalenceString = equivalenceStringFromTerms(terms),
             string = equivalenceString,  ///

package/src/element/frame.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { instantiateFrame } from "../process/instantiate";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
 import { metavariableFromFrameNode } from "../utilities/element";
@@ -343,7 +343,7 @@ export default define(class Frame extends Element {
   static name = "Frame";
 
   static fromJSON(json, context) {
-    const frame = literally((context) => {
+    const frame = instantiate((context) => {
       const { string } = json,
             frameNode = instantiateFrame(string, context),
             node = frameNode, ///

package/src/element/hypothesis.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import {literally} from "../utilities/context";
+import {instantiate} from "../utilities/context";
 import { instantiateHypothesis } from "../process/instantiate";
 import { statementFromHypothesisNode } from "../utilities/element";
 
@@ -100,7 +100,7 @@ export default define(class Hypothesis extends Element {
   static name = "Hypothesis";
 
   static fromJSON(json, context) {
-    const hypothesis = literally((context) => {
+    const hypothesis = instantiate((context) => {
       const { string } = json,
             hypothesisNode = instantiateHypothesis(string, context),
             node = hypothesisNode,  ///

package/src/element/judgement.js

@@ -5,7 +5,7 @@ import { Element } from "occam-languages";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { instantiateJudgement } from "../process/instantiate";
 import { judgementAssignmentFromJudgement } from "../process/assign";
 
@@ -218,7 +218,7 @@ export default define(class Judgement extends Element {
   static name = "Judgement";
 
   static fromJSON(json, context) {
-    const judgement = literally((context) => {
+    const judgement = instantiate((context) => {
       const { string } = json,
             judgementNode = instantiateJudgement(string, context),
             node = judgementNode,  ///

package/src/element/label.js

@@ -4,7 +4,7 @@ import { Element } from "occam-languages";
 
 import { define } from "../elements";
 import { instantiateLabel } from "../process/instantiate";
-import { attempt, literally } from "../utilities/context";
+import { attempt, instantiate } from "../utilities/context";
 import { metavariableFromLabelNode } from "../utilities/element";
 import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
 
@@ -90,7 +90,7 @@ export default define(class Label extends Element {
       const metavariableValidates = this.validateMetavariable(context);
 
       if (metavariableValidates) {
-        this.setContext(context);
+        context.commit(this);
 
         validates = true;
       }
@@ -109,7 +109,7 @@ export default define(class Label extends Element {
     const labelString = this.getString(), ///
           metavariableString = this.metavariable.getString();
 
-    context.trace(`Validating the '${labelString}' label's '${metavariableString}' metavariable...'`);
+    context.trace(`Validating the '${labelString}' label's '${metavariableString}' metavariable...`);
 
     const metavariable = this.metavariable.validate(context);
 
@@ -153,7 +153,7 @@ export default define(class Label extends Element {
 
     context = ephemeralContext; ///
 
-    const label = literally((context) => {
+    const label = instantiate((context) => {
       const { string } = json,
             labelNode = instantiateLabel(string, context),
             metavariable = metavariableFromLabelNode(labelNode, context),

package/src/element/metavariable.js

@@ -5,7 +5,7 @@ import { Element } from "occam-languages";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { EMPTY_STRING } from "../constants";
 import { instantiateMetavariable } from "../process/instantiate";
 import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "../utilities/json";
@@ -130,10 +130,12 @@ export default define(class Metavariable extends Element {
       context.trace(`Verifying the '${metavariableString}' metavariable's '${typeString}' type...`);
 
       const typeName = this.type.getName(),
-            typePresent = context.isTypePresentByTypeName(typeName);
+            type = context.findTypeByTypeName(typeName);
 
-      if (!typePresent) {
-        typeVerifies = false;
+      if (type !== null) {
+        this.type = type;
+
+        typeVerifies = true;
 
         context.error(`Type '${typeName}' is not present.`);
       }
@@ -155,25 +157,17 @@ export default define(class Metavariable extends Element {
 
     let validates = false;
 
-    const termValidates = this.validateTerm(context);
-
-    if (termValidates) {
-      const typeValidates = this.validateType(context);
-
-      if (typeValidates) {
-        let metavariable;
-
-        metavariable = this;  ///
+    const typeValidates = this.validateType(context);
 
-        metavariable = context.findMetavariable(metavariable, context);  ///
+    if (typeValidates) {
+      const termValidates = this.validateTerm(context);
 
-        if (metavariable !== null) {
-          const metaType = metavariable.getMetaType();
+      if (termValidates) {
+        const nameValidates = this.validateName(context);
 
-          this.metaType = metaType;
+        if (nameValidates) {
+          validates = true;
         }
-
-        validates = true;
       }
     }
 
@@ -187,19 +181,43 @@ export default define(class Metavariable extends Element {
   }
 
   validateTerm(context) {
-    let termValidates = true;
+    let termValidates = true; ///
 
     if (this.term !== null) {
+      termValidates = false;
+
       const termString = this.term.getString(),
             metavariableString = this.getString();
 
       context.trace(`Validating the '${metavariableString}' metavariable's '${termString}' term...`);
 
-      termValidates = this.term.validate(context, () => {
-        const validatesForwards = true;
+      const metavariableName = this.getMetavariableName(),
+            metavariable = context.findMetavariableByMetavariableName(metavariableName);
+
+      let term = null;
+
+      if (metavariable !== null) {
+        const type = metavariable.getType(),
+              metavariableString = metavariable.getString();
+
+        if (type !== null) {
+          term = this.term.validateGivenType(type, context);
+        } else {
+          context.trace(`The '${metavariableString}' metavariable does not have a type`);
+        }
+      } else {
+        term = this.term.validate(context, (term) => {
+          const validatesForwards = true;
+
+          return validatesForwards;
+        });
+      }
+
+      if (term !== null) {
+        this.term = term;
 
-        return validatesForwards;
-      });
+        termValidates = true;
+      }
 
       if (termValidates) {
         context.debug(`...validated the '${metavariableString}' metavariable's '${termString}' term.`);
@@ -209,18 +227,51 @@ export default define(class Metavariable extends Element {
     return termValidates;
   }
 
+  validateName(context) {
+    let termValidates = true; ///
+
+    const metavariableName = this.getMetavariableName(),  ///
+          metavariableString = this.getString();  ///
+
+    context.trace(`Validating the '${metavariableString}' metavariable's '${metavariableName}' name...`);
+
+    const metavariable = context.findMetavariableByMetavariableName(metavariableName);
+
+    if (metavariable !== null) {
+      const metaType = metavariable.getMetaType(),
+            metaTypeSTring = metaType.getString();
+
+      this.metaType = metaType;
+
+      context.trace(`Setting the '${metavariableString}' metavariable's meta-type to the '${metaTypeSTring}' meta-type.`);
+    }
+
+    if (termValidates) {
+      context.debug(`...validated the '${metavariableString}' metavariable's '${metavariableName}' name.`);
+    }
+
+    return termValidates;
+  }
+
   validateType(context) {
-    let typeValidates = true;  ///
+    let typeValidates = false;
 
-    if (this.type !== null) {
-      const typeString = this.type.getString(),
-            metavariableString = this.getString();
+    const metavariableString = this.getString();  ///
 
-      typeValidates = false;
+    context.trace(`Validating  the '${metavariableString}' metavariable's type...`);
+
+    if (this.type === null) {
+      typeValidates = true;
+    } else {
+      const typeString = this.type.getString();
 
       context.trace(`A '${typeString}' type is present in the '${metavariableString}' metavariable.`);
     }
 
+    if (typeValidates) {
+      context.trace(`...validated  the '${metavariableString}' metavariable's type.`);
+    }
+
     return typeValidates;
   }
 
@@ -246,6 +297,11 @@ export default define(class Metavariable extends Element {
               substitutionFrameComparesToFrame = substitution.compareFrame(frame, context);
 
         if (substitutionFrameComparesToFrame) {
+          const frameSubstitution = substitution, ///
+                frameSubstitutionString = frameSubstitution.getString();
+
+          context.trace(`The '${frameSubstitutionString}' frame substitution is already present.`);
+
           frameUnifies = true;
         }
       } else {
@@ -282,8 +338,6 @@ export default define(class Metavariable extends Element {
                                   substitution.getString() :
                                     EMPTY_STRING;
 
-
-
     context.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
 
     const metavariable = this, ///
@@ -305,6 +359,11 @@ export default define(class Metavariable extends Element {
         const substitutionComparesToStatement = substitution.compareStatement(statement, context);
 
         if (substitutionComparesToStatement) {
+          const statementSubstitution = substitution, //
+                statementSubstitutionString = statementSubstitution.getString();
+
+          context.trace(`The '${statementSubstitutionString}' statement substitution is already present.`);
+
           statementUnifies = true;
         }
       } else {
@@ -362,6 +421,11 @@ export default define(class Metavariable extends Element {
               substitutionReferenceComparesToReference = substitution.compareReference(reference, context);
 
         if (substitutionReferenceComparesToReference) {
+          const referenceSubstitution = substitution, ///
+                referenceSubstitutionString = referenceSubstitution.getString();
+
+          context.trace(`The '${referenceSubstitutionString}' reference substitution is already present.`);
+
           referenceUnifies = true;
         }
       } else {
@@ -545,7 +609,7 @@ export default define(class Metavariable extends Element {
   static name = "Metavariable";
 
   static fromJSON(json, context) {
-    const metavariable = literally((context) => {
+    const metavariable = instantiate((context) => {
       const { string } = json,
             metavariableNode = instantiateMetavariable(string, context),
             node = metavariableNode,  ///

package/src/element/parameter.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { instantiateParameter } from "../process/instantiate";
 import { nameFromParaneterNode, identifierFromParameterNode } from "../utilities/element";
 
@@ -61,7 +61,7 @@ export default define(class Parameter extends Element {
   static name = "Parameter";
 
   static fromJSON(json, context) {
-    const parameter = literally((context) => {
+    const parameter = instantiate((context) => {
       const { string } = json,
             parameterNode = instantiateParameter(string, context),
             node = parameterNode,  ///