occam-verify-cli 1.0.746 → 1.0.753

package/src/element/combinator.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 { instantiateCombinator } from "../process/instantiate";
 import { statementFromCombinatorNode } from "../utilities/element";
 import { unifyStatementWithCombinator } from "../process/unify";
@@ -21,7 +21,7 @@ export default define(class Combinator extends Element {
     return this.statement;
   }
 
-  getConbinatorNode() {
+  getCombinatoryNode() {
     const node = this.getNode(),
           combinatorNode = node;  ///
 
@@ -39,7 +39,7 @@ export default define(class Combinator extends Element {
       const statementValidates = this.validateStatement(context);
 
       if (statementValidates) {
-        this.setContext(context);
+        context.commit(this);
 
         validates = true;
       }
@@ -128,7 +128,7 @@ export default define(class Combinator extends Element {
 
     context = ephemeralContext; ///
 
-    const combinator = literally((context) => {
+    const combinator = instantiate((context) => {
       const { string } = json,
             combinatorNode = instantiateCombinator(string, context),
             node = combinatorNode,  ///

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,  ///

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,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 { instantiateDeduction } from "../process/instantiate";
 import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../utilities/json";
 
@@ -62,7 +62,7 @@ export default define(class Deduction extends Element {
       const statementValidates = this.validateStatement(context);
 
       if (statementValidates) {
-        this.setContext(context);
+        context.commit(this);
 
         validates = true;
       }
@@ -174,7 +174,7 @@ export default define(class Deduction extends Element {
 
     context = ephemeralContext; ///
 
-    const duduction = literally((context) => {
+    const duduction = instantiate((context) => {
       const { string } = json,
             deductionNode = instantiateDeduction(string, context),
             node = deductionNode,  ///

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;
 
-        return validatesForwards;
-      });
+      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;
+
+        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();  ///
+
+    context.trace(`Validating  the '${metavariableString}' metavariable's type...`);
 
-      typeValidates = false;
+    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;
   }
 
@@ -545,7 +596,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,  ///

package/src/element/procedureCall.js

@@ -4,7 +4,7 @@ import { Element } from "occam-languages";
 import { termsUtilities } from "occam-furtle";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { instantiateProcedureCall } from "../process/instantiate";
 import { parametersFromProcedureCallNode, procedureReferenceFromProcedureCallNode } from "../utilities/element";
 
@@ -125,7 +125,7 @@ export default define(class ProcedureCall extends Element {
   static name = "ProcedureCall";
 
   static fromJSON(json, context) {
-    const procedureCall = literally((context) => {
+    const procedureCall = instantiate((context) => {
       const { string } = json,
             procedureCallNode = instantiateProcedureCall(string, context),
             node = procedureCallNode,  ///

package/src/element/procedureReference.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 { instantiateProcedureReference } from "../process/instantiate";
 import { nameFromProcedureReferenceNode } from "../utilities/element";
 
@@ -43,7 +43,7 @@ export default define(class ProcedureReference extends Element {
   static name = "ProcedureReference";
 
   static fromJSON(json, context) {
-    const procedureReference = literally((context) => {
+    const procedureReference = instantiate((context) => {
       const { string } = json,
             procedureReferenceNode = instantiateProcedureReference(string, context),
             node = procedureReferenceNode,  ///

package/src/element/proof.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { asyncScope } from "../utilities/context";
+import { asyncRestrict } from "../utilities/context";
 
 export default define(class Proof extends Element {
   constructor(context, string, node, derivation) {
@@ -36,7 +36,7 @@ export default define(class Proof extends Element {
   async verify(statement, context) {
     let verifies = false;
 
-    await asyncScope(async (context) => {
+    await asyncRestrict(async (context) => {
       const derivationVerifies = await this.derivation.verify(context);
 
       if (derivationVerifies) {

package/src/element/proofAssertion/premise.js

@@ -5,7 +5,7 @@ import ProofAssertion from "../proofAssertion";
 import { define } from "../../elements";
 import { instantiatePremise } from "../../process/instantiate";
 import { procedureCallFromPremiseNode } from "../../utilities/element";
-import { attempt, liminally, literally } from "../../utilities/context";
+import { attempt, reconcile, instantiate } from "../../utilities/context";
 import { ephemeralContextFromJSON, ephemeralContextToEphemeralContextJSON } from "../../utilities/json";
 
 export default define(class Premise extends ProofAssertion {
@@ -72,7 +72,7 @@ export default define(class Premise extends ProofAssertion {
         const statementValidates = this.validateStatement(context);
 
         if (statementValidates) {
-          this.setContext(context);
+          context.commit(this);
 
           validates = true;
         }
@@ -82,7 +82,7 @@ export default define(class Premise extends ProofAssertion {
         const procedureCallValidates = this.validateProcedureCall(context);
 
         if (procedureCallValidates) {
-          this.setContext(context);
+          context.commit(this);
 
           validates = true;
         }
@@ -168,7 +168,7 @@ export default define(class Premise extends ProofAssertion {
           premiseContext = this.getContext(), ///
           generalContext = premiseContext, ///
           specificContext = proofAssertionContext,
-          statementUnifies = liminally((specificContext) => {
+          statementUnifies = reconcile((specificContext) => {
             const statement = proofAssertion.getStatement(),
                   statementUnifies = this.unifyStatement(statement, generalContext, specificContext);
 
@@ -300,7 +300,7 @@ export default define(class Premise extends ProofAssertion {
 
     context = ephemeralContext; ///
 
-    const premise = literally((context) => {
+    const premise = instantiate((context) => {
       const { string } = json,
             premiseNode = instantiatePremise(string, context),
             node = premiseNode,  ///