occam-nominal 1.0.307 → 1.0.310

package/src/element/metavariable.js

@@ -106,14 +106,14 @@ export default define(class Metavariable extends Element {
     return comparesToMetavariableName;
   }
 
-  async verify(context) {
+  verify(context) {
     let verifies = false;
 
     const metavariableString = this.getString();  ///
 
     context.trace(`Verifying the '${metavariableString}' metavariable...`);
 
-    const termVerifies = await this.verifyTerm(context);
+    const termVerifies = this.verifyTerm(context);
 
     if (termVerifies) {
       const typeVerifies = this.verifyType(context);
@@ -328,56 +328,61 @@ export default define(class Metavariable extends Element {
     continuation(typeValidates);
   }
 
-  unifyFrame(frame, generalContext, specificContext) {
-    let frameUnifies = false;
-
+  unifyFrame(frame, generalContext, specificContext, continuation) {
     const context = specificContext,  ///
           frameString = frame.getString(),
           metavariableString = this.getString(); ///
 
     context.trace(`Unifying the '${frameString}' frame with the '${metavariableString}' metavariable...`);
 
+    const frameMetavariablCompares = this.compareFraemMetavaraible(frame, generalContext, specificContext);
+
+    if (frameMetavariablCompares) {
+      const frameUnifies = true;
+
+      return continuation(frameUnifies);
+    }
+
     const metavariable = this,  ///
-          frameMetavariableUnifies = this.unifyFrameMetavariable(frame, generalContext, specificContext);
+          metavariableNode = metavariable.getNode(),
+          derivedSubstitution = context.findDerivedSubstitutionByMetavariableNode(metavariableNode);
 
-    if (frameMetavariableUnifies) {
-      frameUnifies = true;
-    } else {
-      const metavariableNode = metavariable.getNode(),
-            derivedSubstitution = context.findDerivedSubstitutionByMetavariableNode(metavariableNode);
+    if (derivedSubstitution !== null) {
+      let frameUnifies = false;
 
-      if (derivedSubstitution !== null) {
-        const derivedSubstitutionFrameComparesToFrame = derivedSubstitution.compareFrame(frame, context);
+      const derivedSubstitutionFrameComparesToFrame = derivedSubstitution.compareFrame(frame, context);
 
-        if (derivedSubstitutionFrameComparesToFrame) {
-          const derivedSubstitutionString = derivedSubstitution.getString();
+      if (derivedSubstitutionFrameComparesToFrame) {
+        const derivedSubstitutionString = derivedSubstitution.getString();
 
-          context.trace(`The '${derivedSubstitutionString}' derived substitution is already present.`);
+        context.trace(`The '${derivedSubstitutionString}' derived substitution is already present.`);
 
-          frameUnifies = true;
-        }
-      } else {
-        const { FrameSubstitution } = elements;
+        frameUnifies = true;
+      }
 
-        let frameSubstitution;
+      return continuation(frameUnifies);
+    }
 
-        frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, generalContext, specificContext);
+    const { FrameSubstitution } = elements,
+          frameSubstitution = FrameSubstitution.fromFrameAndMetavariable(frame, metavariable, generalContext, specificContext);
 
-        frameSubstitution = frameSubstitution.validate(context);  ///
+    frameSubstitution.validate(context, (frameSubstitution) => {
+      let frameUnifies = false;
 
+      if (frameSubstitution !== null) {
         const derivedSubstitution = frameSubstitution;  ///
 
         context.addDerivedSubstitution(derivedSubstitution);
 
         frameUnifies = true;
       }
-    }
 
-    if (frameUnifies) {
-      context.debug(`...unified the '${frameString}' frame with the '${metavariableString}' metavariable.`);
-    }
+      if (frameUnifies) {
+        context.debug(`...unified the '${frameString}' frame with the '${metavariableString}' metavariable.`);
+      }
 
-    return frameUnifies;
+      return continuation(frameUnifies);
+    });
   }
 
   unifyStatement(statement, substitution, generalContext, specificContext, continuation) {
@@ -390,13 +395,11 @@ export default define(class Metavariable extends Element {
 
     context.trace(`Unifying the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable...`);
 
-    this.unifyStatementMetavariable(statement, generalContext, specificContext, (statementMetavariableUnifies) => {
-      if (statementMetavariableUnifies) {
+    this.compareStatementMetavariable(statement, generalContext, specificContext, (statementMetavariableCompares) => {
+      if (statementMetavariableCompares) {
         const statementUnifies = true;
 
-        continuation(statementUnifies);
-
-        return;
+        return continuation(statementUnifies);
       }
 
       const metavariable = this,  ///
@@ -418,9 +421,7 @@ export default define(class Metavariable extends Element {
           statementUnifies = true;
         }
 
-        continuation(statementUnifies);
-
-        return;
+        return continuation(statementUnifies);
       }
 
       const { StatementSubstitution } = elements,
@@ -439,7 +440,7 @@ export default define(class Metavariable extends Element {
           context.debug(`...unified the '${statementString}' statement with the '${metavariableString}${substitutionString}' metavariable.`);
         }
 
-        continuation(statementUnifies);
+        return continuation(statementUnifies);
       });
     });
   }
@@ -454,9 +455,9 @@ export default define(class Metavariable extends Element {
     context.trace(`Unifying the '${referenceString}' reference with the '${metavariableString}' metavariable...`);
 
     const metavariable = this,  ///
-          referenceMetavariableUnifies = this.unifyReferenceMetavariable(reference, generalContext, specificContext);
+          referenceMetavariableCompares = this.compareReferenceMetavariable(reference, generalContext, specificContext);
 
-    if (referenceMetavariableUnifies) {
+    if (referenceMetavariableCompares) {
       referenceUnifies = true;
     } else {
       const metavariableNode = metavariable.getNode(),
@@ -517,14 +518,32 @@ export default define(class Metavariable extends Element {
     return metavariableUnifies;
   }
 
-  unifyFrameMetavariable(frame, generalContext, specificContext) {
-    let frameMetavariableUnifies = false;
+  unifyMetavariableIntrinsically(metavariable, generalContext, specificContext, continuation) {
+    const context = specificContext,  ///
+          generalMetavariable = this, ///
+          specificMetavariable = metavariable,
+          generalMetavariableString = generalMetavariable.getString(),  ///
+          specificMetavariableString = specificMetavariable.getString();
+
+    context.trace(`Unifying the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable intrinsically...`);
+
+    unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext, (metavariableUnifiesIntrinsically) => {
+      if (metavariableUnifiesIntrinsically) {
+        context.debug(`...unified the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable intrinsically.`);
+      }
+
+      return continuation(metavariableUnifiesIntrinsically);
+    });
+  }
+
+  compareFraemMetavaraible(frame, generalContext, specificContext) {
+    let frameMetavariablCompares = false;
 
     const context = specificContext,  ///
           frameString = frame.getString(),
           metavariableString = this.getString();  ///
 
-    context.trace(`Unifying the '${frameString}' frame's metavariable with the '${metavariableString}' metavariable...`);
+    context.trace(`Comparing the '${frameString}' frame's metavariable to the '${metavariableString}' metavariable...`);
 
     const generalContextFilePath = generalContext.getFilePath(),
           specificContextFilePath = specificContext.getFilePath();
@@ -534,25 +553,25 @@ export default define(class Metavariable extends Element {
             metavariableNodeMatches = frame.matchMetavariableNode(metavariableNode);
 
       if (metavariableNodeMatches) {
-        frameMetavariableUnifies = true;
+        frameMetavariablCompares = true;
       }
     }
 
-    if (frameMetavariableUnifies) {
-      context.debug(`...unified the '${frameString}' frame's metavariable with the '${metavariableString}' metavariable.`);
+    if (frameMetavariablCompares) {
+      context.debug(`...compared the '${frameString}' frame's metavariable to the '${metavariableString}' metavariable.`);
     }
 
-    return frameMetavariableUnifies;
+    return frameMetavariablCompares;
   }
 
-  unifyReferenceMetavariable(reference, generalContext, specificContext) {
-    let referenceMetavariableUnifies = false;
+  compareReferenceMetavariable(reference, generalContext, specificContext) {
+    let referenceMetavariableCompares = false;
 
     const context = specificContext,  ///
           referenceString = reference.getString(),
           metavariableString = this.getString();
 
-    context.trace(`Unifying the '${referenceString}' reference's metavariable with the '${metavariableString}' metavariable...`);
+    context.trace(`Comparing the '${referenceString}' reference's metavariable to the '${metavariableString}' metavariable...`);
 
     const generalContextFilePath = generalContext.getFilePath(),
           specificContextFilePath = specificContext.getFilePath();
@@ -562,25 +581,25 @@ export default define(class Metavariable extends Element {
             metavariableNodeMatches = reference.matchMetavariableNode(metavariableNode);
 
       if (metavariableNodeMatches) {
-        referenceMetavariableUnifies = true;
+        referenceMetavariableCompares = true;
       }
     }
 
-    if (referenceMetavariableUnifies) {
-      context.trace(`...unified the '${referenceString}' reference's metavariable with the '${metavariableString}' metavariable.`);
+    if (referenceMetavariableCompares) {
+      context.trace(`...compared the '${referenceString}' reference's metavariable to the '${metavariableString}' metavariable.`);
     }
 
-    return referenceMetavariableUnifies;
+    return referenceMetavariableCompares;
   }
 
-  unifyStatementMetavariable(statement, generalContext, specificContext, continuation) {
-    let statementMetavariableUnifies = false;
+  compareStatementMetavariable(statement, generalContext, specificContext, continuation) {
+    let statementMetavariableCompares = false;
 
     const context = specificContext,  ///
           statementString = statement.getString(),
           metavariableString = this.getString();  ///
 
-    context.trace(`Unifying the '${statementString}' statement's metavariable with the '${metavariableString}' metavariable...`);
+    context.trace(`Compares the '${statementString}' statement's metavariable to the '${metavariableString}' metavariable...`);
 
     const generalContextFilePath = generalContext.getFilePath(),
           specificContextFilePath = specificContext.getFilePath();
@@ -590,35 +609,15 @@ export default define(class Metavariable extends Element {
             metavariableNodeMatches = statement.matchMetavariableNode(metavariableNode);
 
       if (metavariableNodeMatches) {
-        statementMetavariableUnifies = true;
+        statementMetavariableCompares = true;
       }
     }
 
-    if (statementMetavariableUnifies) {
-      context.debug(`...unified the '${statementString}' statement's metavariable with the '${metavariableString}' metavariable.`);
-    }
-
-    continuation(statementMetavariableUnifies);
-  }
-
-  unifyMetavariableIntrinsically(metavariable, generalContext, specificContext) {
-    let metavariableUnifiesIntrinsically;
-
-    const context = specificContext,  ///
-          generalMetavariable = this, ///
-          specificMetavariable = metavariable,
-          generalMetavariableString = generalMetavariable.getString(),  ///
-          specificMetavariableString = specificMetavariable.getString();
-
-    context.trace(`Unifying the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable intrinsically...`);
-
-    metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
-
-    if (metavariableUnifiesIntrinsically) {
-      context.debug(`...unified the '${specificMetavariableString}' metavariable with the '${generalMetavariableString}' metavariable intrinsically.`);
+    if (statementMetavariableCompares) {
+      context.debug(`...compared the '${statementString}' statement's metavariable to the '${metavariableString}' metavariable.`);
     }
 
-    return metavariableUnifiesIntrinsically;
+    continuation(statementMetavariableCompares);
   }
 
   toJSON() {

package/src/element/procedureCall.js

@@ -9,7 +9,7 @@ import { instantiate } from "../utilities/context";
 import { instantiateProcedureCall } from "../process/instantiate";
 import { parametersFromProcedureCallNode, procedureReferenceFromProcedureCallNode } from "../utilities/element";
 
-const { breakPointFromJSON, breakPointToBreakPointJSON } = breakPointUtilities;
+const { breakable, breakPointFromJSON, breakPointToBreakPointJSON } = breakPointUtilities;
 
 export default define(class ProcedureCall extends Element {
   constructor(context, string, node, breakPoint, parameters, procedureReference) {
@@ -44,7 +44,8 @@ export default define(class ProcedureCall extends Element {
   }
 
   findValues(context) {
-    const substitutions = context.getSubstitutions(),
+    const derivedSubstitutions = context.getDerivedSubstitutions(),
+          substitutions = derivedSubstitutions, ///
           values = this.parameters.map((parameter) => {
             const value = parameter.findValue(substitutions);
 
@@ -83,9 +84,7 @@ export default define(class ProcedureCall extends Element {
     continuation(validates);
   }
 
-  async unifyIndependently(context) {
-    let unifiesIndependently = false;
-
+  unifyIndependently = breakable(function (context, continuation) {
     const procedureCallString = this.getString(); ///
 
     context.trace(`Unifying the '${procedureCallString}' procedure call independently...`);
@@ -94,38 +93,38 @@ export default define(class ProcedureCall extends Element {
           procedure = context.findProcedureByProcedureName(procedureName),
           values = this.findValues(context);
 
-    let term = null;
-
     try {
-      term = await procedure.callNominally(values);
-    } catch (exception) {
-      const message = exception.getMessage();
+      return procedure.callNominally(values, (term) => {
+        let unifiesIndependently = false;
 
-      context.info(message);
-    }
+        if (term !== null) {
+          const boolean = term.isBoolean();
 
-    if (term !== null) {
-      const boolean = term.isBoolean();
+          if (!boolean) {
+            context.info(`The '${procedureCallString}' procedure call did not return a boolean.`);
+          } else {
+            const primitiveValue = term.getPrimitiveValue();
 
-      if (!boolean) {
-        context.info(`The '${procedureCallString}' procedure call did not return a boolean.`);
-      } else {
-        const primitiveValue = term.getPrimitiveValue();
+            if (primitiveValue) {
+              unifiesIndependently = true;
+            }
+          }
+        }
 
-        if (primitiveValue) {
-          unifiesIndependently = true;
+        if (unifiesIndependently) {
+          context.debug(`...unified the '${procedureCallString}' procedure call independently.`);
         }
-      }
-    }
 
-    if (unifiesIndependently) {
-      context.debug(`...unified the '${procedureCallString}' procedure call independently.`);
-    }
+        return continuation(unifiesIndependently);
+      });
+    } catch (exception) {
+      const message = exception.getMessage();
 
-    return unifiesIndependently;
-  }
+      context.info(message);
+    }
+  });
 
-  async dischargeGivenTerm(term, context) {
+  dischargeGivenTerm(term, context) {
     let dischargedGivenTerm = false;
 
     const termString = term.getString(),
@@ -146,7 +145,7 @@ export default define(class ProcedureCall extends Element {
       term = null;
 
       try {
-        term = await procedure.callNominally(values);
+        term = procedure.callNominally(values);
       } catch (exception) {
         const message = exception.getMessage();
 

package/src/element/proofAssertion/premise.js

@@ -177,9 +177,7 @@ export default define(class Premise extends ProofAssertion {
     });
   }
 
-  unifyIndependently(context) {
-    let unifiesIndependently = false;
-
+  unifyIndependently(context, continuation) {
     const premiseString = this.getString(); ///
 
     context.trace(`Unifying the '${premiseString}' premise independently...`);
@@ -191,28 +189,39 @@ export default define(class Premise extends ProofAssertion {
       if (statement !== null) {
         const premiseContext = this.getContext(), ///
               generalContext = premiseContext,  ///
-              specificContext = context,  ///
-              statementUnifiesIndependently = statement.unifyIndependently(generalContext, specificContext);
+              specificContext = context;  ///
 
-        if (statementUnifiesIndependently) {
-          unifiesIndependently = true;
-        }
+        return statement.unifyIndependently(generalContext, specificContext, (statementUnifiesIndependently) => {
+          let unifiesIndependently = false;
+
+          if (statementUnifiesIndependently) {
+            unifiesIndependently = true;
+          }
+
+          if (unifiesIndependently) {
+            context.debug(`...unified the '${premiseString}' premise independently.`);
+          }
+
+          return continuation(unifiesIndependently);
+        });
       }
 
       if (procedureCall !== null) {
-        const procedureCallResolvedIndependently = procedureCall.unifyIndependently(context);
+        return procedureCall.unifyIndependently(context, (procedureCallResolvedIndependently) => {
+          let unifiesIndependently = false;
 
-        if (procedureCallResolvedIndependently) {
-          unifiesIndependently = true;
-        }
-      }
-    }, context);
+          if (procedureCallResolvedIndependently) {
+            unifiesIndependently = true;
+          }
 
-    if (unifiesIndependently) {
-      context.debug(`...unified the '${premiseString}' premise independently.`);
-    }
+          if (unifiesIndependently) {
+            context.debug(`...unified the '${premiseString}' premise independently.`);
+          }
 
-    return unifiesIndependently;
+          return continuation(unifiesIndependently);
+        });
+      }
+    }, context);
   }
 
   unifySubproof(subproof, context, continuation) {
@@ -288,12 +297,12 @@ export default define(class Premise extends ProofAssertion {
     if (subproofOrProofAssertionProofAssertion) {
       const proofAssertion = subproofOrProofAssertion;  ///
 
-      this.unifyProofAssertion(proofAssertion, context, continuation);
-    } else {
-      const subproof = subproofOrProofAssertion;  ///
-
-      this.unifySubproof(subproof, context, continuation);
+      return this.unifyProofAssertion(proofAssertion, context, continuation);
     }
+
+    const subproof = subproofOrProofAssertion;  ///
+
+    return this.unifySubproof(subproof, context, continuation);
   }
 
   toJSON() {

package/src/element/proofAssertion/step.js

@@ -140,8 +140,8 @@ export default define(class Step extends ProofAssertion {
           stated = qualified; ///
 
     (stated ? declare : derive)((context) => {
-      const validate = this.validate.bind(this),
-            unify = this.unify.bind(this);
+      const unify = this.unify.bind(this),
+            validate = this.validate.bind(this);
 
       all([
         validate,
@@ -275,16 +275,16 @@ export default define(class Step extends ProofAssertion {
 
     const step = this;  ///
 
-    some(unifySteps, (unifyStep, continuation) => {
+    return some(unifySteps, (unifyStep, continuation) => {
       reconcile((context) => {
-        unifyStep(step, context, continuation);
+        return unifyStep(step, context, continuation);
       }, context);
     }, (unifies) => {
       if (unifies) {
         context.debug(`...unified the '${stepString}' step.`);
       }
 
-      continuation(unifies);
+      return continuation(unifies);
     });
   }
 

package/src/element/proofAssertion/supposition.js

@@ -288,12 +288,12 @@ export default define(class Supposition extends ProofAssertion {
     if (subproofOrProofAssertionProofAssertion) {
       const proofAssertion = subproofOrProofAssertion;  ///
 
-      this.unifyProofAssertion(proofAssertion, context, continuation);
-    } else {
-      const subproof = subproofOrProofAssertion;  ///
-
-      this.unifySubproof(subproof, context, continuation);
+      return this.unifyProofAssertion(proofAssertion, context, continuation);
     }
+
+    const subproof = subproofOrProofAssertion;  ///
+
+    return this.unifySubproof(subproof, context, continuation);
   }
 
   toJSON() {

package/src/element/proofAssertion.js

@@ -34,12 +34,6 @@ export default class ProofAssertion extends Element {
     return step;
   }
 
-  isNonsensical() {
-    const nonsensical = (this.statement === null);
-
-    return nonsensical;
-  }
-
   compareStep(step, context) {
     let comparesToStep = false;
 
@@ -86,30 +80,24 @@ export default class ProofAssertion extends Element {
   }
 
   unifyStatement(statement, generalContext, specificContext, continuation) {
+    if (this.statement === null) {
+      const statementUnifies = false;
+
+      return continuation(statementUnifies);
+    }
+
     const context = specificContext, ///
           statementString = statement.getString(),
           proofAssertionString = this.getString();  ///
 
     context.trace(`Unifying the '${statementString}' statement with the '${proofAssertionString}' proof assertion's statement...`);
 
-    const nonsensical = this.isNonsensical();
-
-    if (nonsensical) {
-      const statementUnifies = false;
-
-      context.debug(`Unable to unify the '${statementString}' statement with the '${proofAssertionString}' proof assertion because it is nonsense.`);
-
-      continuation(statementUnifies);
-
-      return;
-    }
-
     this.statement.unifyStatement(statement, generalContext, specificContext, (statementUnifies) => {
       if (statementUnifies) {
         context.debug(`...unified the '${statementString}' statement with the '${proofAssertionString}' proof assertion's statement.`);
       }
 
-      continuation(statementUnifies);
+      return continuation(statementUnifies);
     });
   }
 }

package/src/element/rule.js

@@ -129,14 +129,14 @@ export default define(class Rule extends Element {
 
     context.trace(`Verifying the '${ruleString}' rule's labels...`);
 
-    every(this.labels, (label, continuation) => {
-      this.verifyLabel(label, context, continuation);
+    return every(this.labels, (label, continuation) => {
+      return this.verifyLabel(label, context, continuation);
     }, (labelsVerify) => {
       if (labelsVerify) {
         context.debug(`...verified the '${ruleString}' rule's labels.`);
       }
 
-      conntinuation(labelsVerify);
+      return conntinuation(labelsVerify);
     });
   }
 
@@ -168,8 +168,8 @@ export default define(class Rule extends Element {
 
     context.trace(`Verifying the '${ruleString}' rule's premises...`);
 
-    forwardsEvery(this.premises, (premise, continuation) => {
-      this.verifyPremise(premise, context, continuation);
+    return forwardsEvery(this.premises, (premise, continuation) => {
+      return this.verifyPremise(premise, context, continuation);
     }, (premisesVerify) => {
       if (premisesVerify) {
         context.debug(`...verified the '${ruleString}' rule's premises.`);
@@ -194,7 +194,7 @@ export default define(class Rule extends Element {
     });
   }
 
-  unifyStepWithConclusion = breakable(function (step, context, continuation) {
+  unifyStepWithConclusion(step, context, continuation) {
     const ruleString = this.getString(),
           stepString = step.getString(),
           conclusionString = this.conclusion.getString();
@@ -214,7 +214,7 @@ export default define(class Rule extends Element {
 
       return continuation(stepUnifiesWithConclusion);
     });
-  });
+  }
 
   unifyStepAndSubproofOrProofAssertions(step, subproofOrProofAssertions, context, continuation) {
     this.unifyStepWithConclusion(step, context, (statementUnifiesWithConclusion) => {
@@ -241,24 +241,24 @@ export default define(class Rule extends Element {
   }
 
   unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, context, continuation) {
-    extract(subproofOrProofAssertions, (subproofOrProofAssertion, continuation) => {
+    return extract(subproofOrProofAssertions, (subproofOrProofAssertion, continuation) => {
       premise.unifySubproofOrProofAssertion(subproofOrProofAssertion, context, continuation);
-    }, (subproofOrProofAssertion) => {
+    }, (subproofOrProofAssertion = null) => {
       if (subproofOrProofAssertion !== null) {
         const subproofOrProofAssertionsUnifiesWithPremise = true;
 
         return continuation(subproofOrProofAssertionsUnifiesWithPremise);
       }
 
-      premise.unifyIndependently(context, continuation);
+      return premise.unifyIndependently(context, continuation);
     });
   }
 
   unifySubproofOrProofAssertionsWithPremises(subproofOrProofAssertions, context, continuation) {
     subproofOrProofAssertions = reverse(subproofOrProofAssertions); ///
 
-    backwardsEvery(this.premises, (premise, continuation) => {
-      this.unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, context, continuation);
+    return backwardsEvery(this.premises, (premise, continuation) => {
+      return this.unifySubproofOrProofAssertionsWithPremise(subproofOrProofAssertions, premise, context, continuation);
     }, continuation);
   }