occam-verify-cli 1.0.582 → 1.0.583

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.582",
+  "version": "1.0.583",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",
@@ -13,12 +13,12 @@
     "argumentative": "^2.0.36",
     "necessary": "^17.0.9",
     "occam-file-system": "^6.0.505",
-    "occam-furtle": "^3.0.94",
+    "occam-furtle": "^3.0.95",
     "occam-grammars": "^1.3.510",
-    "occam-languages": "^0.0.67",
+    "occam-languages": "^0.0.69",
     "occam-lexers": "^23.1.34",
     "occam-model": "^1.0.494",
-    "occam-nominal": "^1.0.32",
+    "occam-nominal": "^1.0.33",
     "occam-parsers": "^23.1.37"
   },
   "devDependencies": {

package/src/element/derivation.js

@@ -1,13 +1,14 @@
 "use strict";
 
-import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
+import { Element, asynchronousUtilities } from "occam-languages";
 
 import assignAssignments from "../process/assign";
 
 import { define } from "../elements";
 
-const { last } = arrayUtilities;
+const { last } = arrayUtilities,
+      { asyncEvery } = asynchronousUtilities;
 
 export default define(class Derivation extends Element {
   constructor(context, string, node, subproofOrProofAssertions) {
@@ -27,12 +28,12 @@ export default define(class Derivation extends Element {
     return lastProofAssertion;
   }
 
-  verify(context) {
+  async verify(context) {
     let verifies;
 
-    verifies = this.subproofOrProofAssertions.every((subproofOrProofAssertion) => { ///
+    verifies = await asyncEvery(this.subproofOrProofAssertions, async (subproofOrProofAssertion) => { ///
       const assignments = [],
-            subproofOrProofAssertionVerifies = subproofOrProofAssertion.verify(assignments, context);
+            subproofOrProofAssertionVerifies = await subproofOrProofAssertion.verify(assignments, context);
 
       if (subproofOrProofAssertionVerifies) {
         const assignmentsAssigned = assignAssignments(assignments, context);

package/src/element/procedureCall.js

@@ -66,7 +66,7 @@ export default define(class ProcedureCall extends Element {
     return validates;
   }
 
-  unifyIndependently(context) {
+  async unifyIndependently(context) {
     let unifiesIndependently = false;
 
     const procedureCallString = this.getString(); ///
@@ -80,9 +80,17 @@ export default define(class ProcedureCall extends Element {
 
     try {
       const term = procedure.call(terms, context),
-            boolean = term.isBoolean();
+            boolean = await term.isBoolean();
 
-      unifiesIndependently = boolean; ///
+      if (!boolean) {
+        context.info(`The '${procedureCallString}' procedure call did not return a boolean.`);
+      } else {
+        const primitiveValue = term.getPrimitiveValue();
+
+        if (primitiveValue) {
+          unifiesIndependently = true;
+        }
+      }
     } catch (exception) {
       const message = exception.getMessage();
 

package/src/element/proof.js

@@ -2,8 +2,8 @@
 
 import { Element } from "occam-languages";
 
-import { scope } from "../utilities/context";
 import { define } from "../elements";
+import { asyncScope } from "../utilities/context";
 
 export default define(class Proof extends Element {
   constructor(context, string, node, derivation) {
@@ -26,11 +26,11 @@ export default define(class Proof extends Element {
     return statement;
   }
 
-  verify(conclusion, context) {
+  async verify(conclusion, context) {
     let verifies = false;
 
-    scope((context) => {
-      const derivationVerifies = this.derivation.verify(context);
+    asyncScope(async (context) => {
+      const derivationVerifies = await this.derivation.verify(context);
 
       if (derivationVerifies) {
         const lastProofAssertion = context.getLastProofAssertion();

package/src/element/proofAssertion/premise.js

@@ -24,10 +24,10 @@ export default define(class Premise extends ProofAssertion {
     return stated;
   }
 
-  verify(context) {
+  async verify(context) {
     let verifies = false;
 
-    this.break(context);
+    await this.break(context);
 
     const premiseString = this.getString(); ///
 
@@ -78,7 +78,7 @@ export default define(class Premise extends ProofAssertion {
     return verifies;
   }
 
-  unifyIndependently(context) {
+  async unifyIndependently(context) {
     let unifiesIndependently = false;
 
     const premiseString = this.getString(); ///
@@ -96,7 +96,7 @@ export default define(class Premise extends ProofAssertion {
     }
 
     if (this.procedureCall !== null) {
-      const procedureCallResolvedIndependently = this.procedureCall.unifyIndependently(context);
+      const procedureCallResolvedIndependently = await this.procedureCall.unifyIndependently(context);
 
       if (procedureCallResolvedIndependently) {
         unifiesIndependently = true;

package/src/element/proofAssertion/step.js

@@ -3,8 +3,7 @@
 import ProofAssertion from "../proofAssertion";
 
 import { define } from "../../elements";
-import { unifyStatements } from "../../utilities/unification";
-import { attempt, liminally } from "../../utilities/context";
+import { asyncAttempt, asyncLiminally } from "../../utilities/context";
 import { propertyAssertionFromStatement } from "../../utilities/statement";
 
 export default define(class Step extends ProofAssertion {
@@ -55,10 +54,10 @@ export default define(class Step extends ProofAssertion {
     return comparesToTermAndPropertyRelation;
   }
 
-  verify(assignments, context) {
+  async verify(assignments, context) {
     let verifies = false;
 
-    this.break(context);
+    await this.break(context);
 
     const stepString = this.getString(); ///
 
@@ -67,7 +66,7 @@ export default define(class Step extends ProofAssertion {
     const statement = this.getStatement();
 
     if (statement !== null) {
-      attempt((context) => {
+      asyncAttempt(async (context) => {
         const referenceValidates = this.validateReference(context);
 
         if (referenceValidates) {
@@ -79,9 +78,9 @@ export default define(class Step extends ProofAssertion {
             if (statementValidates) {
               const reference = this.getReference(),
                     satisfiesAssertion = this.getSatisfiesAssertion(),
-                    statementUnifies = liminally((context) => {
-                      const statementUnifies = unifyStatements.some((unifyStatement) => {
-                        const statementUnifies = unifyStatement(statement, reference, satisfiesAssertion, context);
+                    statementUnifies = await asyncLiminally(async (context) => {
+                      const statementUnifies = await asyncSome(async (unifyStatement) => {
+                        const statementUnifies = await unifyStatement(statement, reference, satisfiesAssertion, context);
 
                         if (statementUnifies) {
                           this.setContext(context);

package/src/element/proofAssertion/supposition.js

@@ -27,7 +27,7 @@ export default define(class Supposition extends ProofAssertion {
   async verify(context) {
     let verifies = false;
 
-    this.break(context);
+    await this.break(context);
 
     const suppositionString = this.getString(); ///
 

package/src/element/rule.js

@@ -1,9 +1,8 @@
 "use strict";
 
-import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
+import { Element, asynchronousUtilities } from "occam-languages";
 
-import { scope } from "../utilities/context";
 import { define } from "../elements";
 import { labelsFromJSON,
          premisesFromJSON,
@@ -11,9 +10,9 @@ import { labelsFromJSON,
          labelsToLabelsJSON,
          premisesToPremisesJSON,
          conclusionToConclusionJSON } from "../utilities/json";
-import { subproofOrProofAssertionsStringFromSubproofOrProofAssertions } from "../utilities/string";
 
-const { reverse, extract, backwardsEvery } = arrayUtilities;
+const { reverse, extract } = arrayUtilities,
+      { asyncBackwardsEvery } = asynchronousUtilities;
 
 export default define(class Rule extends Element {
   constructor(context, string, node, proof, labels, premises, conclusion) {
@@ -126,13 +125,13 @@ export default define(class Rule extends Element {
     return statementUnifiesWithConclusion;
   }
 
-  unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context) {
+  async unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context) {
     let statementAndSubproofOrProofAssertionsUnify = false;
 
     const statementUnifiesWithConclusion = this.unifyStatementWithConclusion(statement, context);
 
     if (statementUnifiesWithConclusion) {
-      const subproofOrProofAssertionsUnifiesWithPremises = this.unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, context);
+      const subproofOrProofAssertionsUnifiesWithPremises = await this.unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, context);
 
       if (subproofOrProofAssertionsUnifiesWithPremises) {
         const substitutionsResolved = context.areSubstitutionsResolved();
@@ -146,13 +145,13 @@ export default define(class Rule extends Element {
     return statementAndSubproofOrProofAssertionsUnify;
   }
 
-  unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, context) {
+  async unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, context) {
     let subproofOrProofAssertionsUnifiesWithPremises;
 
     subproofOrProofAssertions = reverse(subproofOrProofAssertions); ///
 
-    subproofOrProofAssertionsUnifiesWithPremises = backwardsEvery(this.premises, (premise) => {
-      const stepUnifiesWithPremise = this.unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, context);
+    subproofOrProofAssertionsUnifiesWithPremises = asyncBackwardsEvery(this.premises, async (premise) => {
+      const stepUnifiesWithPremise = await this.unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, context);
 
       if (stepUnifiesWithPremise) {
         return true;
@@ -162,7 +161,7 @@ export default define(class Rule extends Element {
     return subproofOrProofAssertionsUnifiesWithPremises;
   }
 
-  unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, context) {
+  async unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, context) {
     let subproofOrProofAssertionsUnifiesWithPremise = false;
 
     if (!subproofOrProofAssertionsUnifiesWithPremise) {
@@ -180,7 +179,7 @@ export default define(class Rule extends Element {
     }
 
     if (!subproofOrProofAssertionsUnifiesWithPremise) {
-      const premiseUnifiesIndependently = premise.unifyIndependently(context);
+      const premiseUnifiesIndependently = await premise.unifyIndependently(context);
 
       if (premiseUnifiesIndependently) {
         subproofOrProofAssertionsUnifiesWithPremise = true;
@@ -195,7 +194,7 @@ export default define(class Rule extends Element {
 
     const context = this.getContext();
 
-    this.break(context);
+    await this.break(context);
 
     const ruleString = this.getString(); ///
 

package/src/element/topLevelMetaAssertion/metaLemma.js

@@ -10,7 +10,7 @@ export default define(class MetaLemma extends TopLevelMetaAssertion {
 
     const context = this.getContext();
 
-    this.break(context);
+    await this.break(context);
 
     const metaLemmaString = this.getString(); ///
 

package/src/element/topLevelMetaAssertion/metatheorem.js

@@ -10,7 +10,7 @@ export default define(class Metatheorem extends TopLevelMetaAssertion {
 
     const context = this.getContext();
 
-    this.break(context);
+    await this.break(context);
 
     const metaLemmaString = this.getString(); ///
 

package/src/utilities/context.js

@@ -37,6 +37,14 @@ export function literally(innerFunction, context) {
   return innerFunction(context);
 }
 
+export async function asyncScope(innerFunction, context) {
+  const scopedContext = ScopedContext.fromNothing(context);
+
+  context = scopedContext;  ///
+
+  return await innerFunction(context);
+}
+
 export async function asyncAttempt(innerFunction, context) {
   const ephemeralContext = EphemeralContext.fromNothing(context);
 
@@ -45,10 +53,18 @@ export async function asyncAttempt(innerFunction, context) {
   return await innerFunction(context);
 }
 
-export async function asyncScope(innerFunction, context) {
-  const scopedContext = ScopedContext.fromNothing(context);
+export async function asyncLiminally(innerFunction, context) {
+  const liminalContext = LiminalContext.fromNothing(context);
 
-  context = scopedContext;  ///
+  context = liminalContext;  ///
+
+  return await innerFunction(context);
+}
+
+export async function asyncLiterally(innerFunction, context) {
+  const literalContext = LiteralContext.fromNothing(context);
+
+  context = literalContext;  ///
 
   return await innerFunction(context);
 }

package/src/utilities/unification.js

@@ -12,7 +12,7 @@ import { equalityFromStatement,
 
 const { backwardsSome } = arrayUtilities;
 
-function unifyStatementWithRule(statement, reference, satisfiesAssertion, context) {
+async function unifyStatementWithRule(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesWithRule = false;
 
   if (reference !== null) {
@@ -25,7 +25,7 @@ function unifyStatementWithRule(statement, reference, satisfiesAssertion, contex
       context.trace(`Unifying the '${statementString}' statement with the '${ruleString}' rule...`);
 
       const subproofOrProofAssertions = context.getSubproofOrProofAssertions(),
-            statementAndSubproofOrProofAssertionsUnify = rule.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context);
+            statementAndSubproofOrProofAssertionsUnify = await rule.unifyStatementAndSubproofOrProofAssertions(statement, subproofOrProofAssertions, context);
 
       if (statementAndSubproofOrProofAssertionsUnify) {
         statementUnifiesWithRule = true;
@@ -40,7 +40,7 @@ function unifyStatementWithRule(statement, reference, satisfiesAssertion, contex
   return statementUnifiesWithRule;
 }
 
-function unifyStatementWithReference(statement, reference, satisfiesAssertion, context) {
+async function unifyStatementWithReference(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesWithReference = false;
 
   if (reference !== null) {
@@ -74,7 +74,7 @@ function unifyStatementWithReference(statement, reference, satisfiesAssertion, c
   return statementUnifiesWithReference;
 }
 
-function unifyStatementAsSatisfiesAssertion(statement, reference, satisfiesAssertion, context) {
+async function unifyStatementAsSatisfiesAssertion(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesAsSatisfiesAssertion = false;
 
   satisfiesAssertion = satisfiesAssertionFromStatement(statement, context);
@@ -138,7 +138,7 @@ function unifyStatementAsSatisfiesAssertion(statement, reference, satisfiesAsser
   return statementUnifiesAsSatisfiesAssertion;
 }
 
-function unifyStatementWithTopLevelAssertion(statement, reference, satisfiesAssertion, context) {
+async function unifyStatementWithTopLevelAssertion(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesWithTopLevelAssertion = false;
 
   if (reference !== null) {
@@ -179,7 +179,7 @@ function unifyStatementWithTopLevelAssertion(statement, reference, satisfiesAsse
   return statementUnifiesWithTopLevelAssertion;
 }
 
-function unifyStatementAEquality(statement, reference, satisfiesAssertion, context) {
+async function unifyStatementAEquality(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesAEquality = false;
 
   if (reference === null) {
@@ -205,7 +205,7 @@ function unifyStatementAEquality(statement, reference, satisfiesAssertion, conte
   return statementUnifiesAEquality;
 }
 
-function unifyStatementAsJudgement(statement, reference, satisfiesAssertion, context) {
+async function unifyStatementAsJudgement(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesAsJudgement = false;
 
   if (reference === null) {
@@ -227,7 +227,7 @@ function unifyStatementAsJudgement(statement, reference, satisfiesAssertion, con
   return statementUnifiesAsJudgement;
 }
 
-function unifyStatementAsTypeAssertion(statement, reference, satisfiesAssertion, context) {
+async function unifyStatementAsTypeAssertion(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesAsTypeAssertion = false;
 
   if (reference === null) {
@@ -247,7 +247,7 @@ function unifyStatementAsTypeAssertion(statement, reference, satisfiesAssertion,
   return statementUnifiesAsTypeAssertion;
 }
 
-function unifyStatementAsPropertyAssertion(statement, reference, satisfiesAssertion, context) {
+async function unifyStatementAsPropertyAssertion(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesAsPropertyAssertion = false;
 
   if (reference === null) {
@@ -285,7 +285,7 @@ function unifyStatementAsPropertyAssertion(statement, reference, satisfiesAssert
   return statementUnifiesAsPropertyAssertion;
 }
 
-function unifyStatementWithSatisfiesAssertion(statement, reference, satisfiesAssertion, context) {
+async function unifyStatementWithSatisfiesAssertion(statement, reference, satisfiesAssertion, context) {
   let statementUnifiesWithSatisfiesAssertion = false;
 
   if (satisfiesAssertion !== null) {
@@ -309,7 +309,7 @@ function unifyStatementWithSatisfiesAssertion(statement, reference, satisfiesAss
   return statementUnifiesWithSatisfiesAssertion;
 }
 
-function compareStatementWithSubproofOrProofAssertions(statement, reference, satisfiesAssertion, context) {
+async function compareStatementWithSubproofOrProofAssertions(statement, reference, satisfiesAssertion, context) {
   let statementEquatesWithStepOrSubproofs = false;
 
   if (reference === null) {