occam-verify-cli 1.0.708 → 1.0.713

package/src/element/reference.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { attempt, literally } from "../utilities/context";
+import { literally } from "../utilities/context";
 import { instantiateReference } from "../process/instantiate";
 import { REFERENCE_META_TYPE_NAME } from "../metaTypeNames";
 import { metavariableFromReferenceNode } from "../utilities/element";
@@ -160,7 +160,7 @@ export default define(class Reference extends Element {
     const referenceString = this.getString(), ///
           metavariableString = this.metavariable.getString();
 
-    context.trace(`Validating the '${referenceString}' reference's '${metavariableString}' metavariable....'`);
+    context.trace(`Validating the '${referenceString}' reference's '${metavariableString}' metavariable...'`);
 
     const metaTypeName = REFERENCE_META_TYPE_NAME,
           referenceMetaType = context.findMetaTypeByMetaTypeName(metaTypeName),
@@ -249,13 +249,9 @@ export default define(class Reference extends Element {
 
     context.trace(`Unifying the '${metavariableString}' metavariable with the '${referenceString}' reference...`);
 
-    const metavariableUnifiesIntrinsically = attempt((specificContext) => {
-      const generalMetavariable = this.metavariable,  ///
-            specificMetavariable = metavariable, ///
-            metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
-
-      return metavariableUnifiesIntrinsically;
-    }, specificContext);
+    const generalMetavariable = this.metavariable,  ///
+          specificMetavariable = metavariable, ///
+          metavariableUnifiesIntrinsically = unifyMetavariableIntrinsically(generalMetavariable, specificMetavariable, generalContext, specificContext);
 
     if (metavariableUnifiesIntrinsically) {
       metavariableUnifies = true;

package/src/element/rule.js

@@ -109,7 +109,7 @@ export default define(class Rule extends Element {
     }, context);
 
     if (verifies) {
-      const rule = this;
+      const rule = this;  ///
 
       context.addRule(rule);
 

package/src/element/signature.js

@@ -35,9 +35,9 @@ export default define(class Signature extends Element {
 
     context.trace(`Verifying the '${signatureString}' signature...`);
 
-    const validates = this.validate(context);
+    const signature = this.validate(context);
 
-    if (validates) {
+    if (signature !== null) {
       verifies = true;
     }
 
@@ -49,7 +49,7 @@ export default define(class Signature extends Element {
   }
 
   validate(context) {
-    let validates = false;
+    let signature = null;
 
     const signatureString = this.getString();  ///
 
@@ -61,14 +61,14 @@ export default define(class Signature extends Element {
     if (termsValidate) {
       this.terms = terms;
 
-      validates = true;
+      signature = this; ///
     }
 
-    if (validates) {
+    if (signature) {
       context.debug(`...validated the '${signatureString}' signature.`);
     }
 
-    return validates
+    return signature
   }
 
   validateTerm(term, terms, context) {

package/src/element/statement.js

@@ -220,9 +220,11 @@ export default define(class Statement extends Element {
     const metaTypeName = metaType.getName();
 
     if (metaTypeName === STATEMENT_META_TYPE_NAME) {
-      const validates = this.validate(stated, context)
+      const statement = this.validate(stated, context)
 
-      validatesGivenMetaType = validates; ///
+      if (statement !== null) {
+        validatesGivenMetaType = true;
+      }
     }
 
     if (validatesGivenMetaType) {

package/src/element/term.js

@@ -199,20 +199,19 @@ export default define(class Term extends Element {
 
     context.trace(`Validating the '${termString}' term given the '${typeString}' type...`);
 
-    const validates = this.validate(context, () => {
-      let validatesForwards;
-
-      const typeEqualToOrSubTypeOfGivenTypeType = this.type.isEqualToOrSubTypeOf(type);
-
-      if (typeEqualToOrSubTypeOfGivenTypeType) {
-        validatesForwards = true;
-      }
+    const term = this.validate(context, () => {
+      const validatesForwards = true;
 
       return validatesForwards;
     });
 
-    if (validates) {
-      validatesGivenType = true;
+    if (term !== null) {
+      const termType = term.getType(),
+            termTypeEqualToOrSubTypeOfGivenTypeType = termType.isEqualToOrSubTypeOf(type);
+
+      if (termTypeEqualToOrSubTypeOfGivenTypeType) {
+        validatesGivenType = true;
+      }
     }
 
     if (validatesGivenType) {

package/src/pass/zip.js

@@ -0,0 +1,19 @@
+"use strict";
+
+import { ZipPass as ZipPassBase } from "occam-languages";
+
+export default class ZipPass extends ZipPassBase {
+  run(generalNonTerminalNode, specificNonTerminalNode, ...remainingArguments) {
+    let success = false;
+
+    const specificChildNodes = specificNonTerminalNode.getChildNodes(), ///
+          generalChildNodes = generalNonTerminalNode.getChildNodes(), ///
+          descended = this.descend(generalChildNodes, specificChildNodes, ...remainingArguments);
+
+    if (descended) {
+      success = true;
+    }
+
+    return success;
+  }
+}

package/src/process/unify.js

@@ -1,6 +1,8 @@
 "use strict";
 
-import { ZipPass, queryUtilities } from "occam-languages";
+import { queryUtilities, ZipPass as ZipPassBase } from "occam-languages";
+
+import ZipPass from "../pass/zip";
 
 import { termFromTermNode, frameFromFrameNode, statementFromStatementNode } from "../utilities/element";
 
@@ -16,7 +18,7 @@ const typeNodeQuery = nodeQuery("/type"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!"),
       assumptionMetavariableNodeQuery = nodeQuery("/assumption/metavariable!");
 
-class MetaLevelPass extends ZipPass {
+class MetaLevelPass extends ZipPassBase {
   static maps = [
     {
       generalNodeQuery: assumptionMetavariableNodeQuery,
@@ -145,22 +147,6 @@ class MetaLevelPass extends ZipPass {
 }
 
 class CombinatorPass extends ZipPass {
-  run(combinatorStatementNode, statementNode, stated, generalContext, specificContext) {
-    let success = false;
-
-    const specificnonTerminalNode = statementNode,  ///
-          generalcnonTerminalNode = combinatorStatementNode,  ///
-          specificChildNodes = specificnonTerminalNode.getChildNodes(), ///
-          generalcChildNodes = generalcnonTerminalNode.getChildNodes(), ///
-          descended = this.descend(generalcChildNodes, specificChildNodes, stated, generalContext, specificContext);
-
-    if (descended) {
-      success = true;
-    }
-
-    return success;
-  }
-
   static maps = [
     {
       generalNodeQuery: metaTypeNodeQuery,
@@ -250,22 +236,6 @@ class CombinatorPass extends ZipPass {
 }
 
 class ConstructorPass extends ZipPass {
-  run(constructorTermNode, termNode, generalContext, specificContext) {
-    let success = false;
-
-    const specificnonTerminalNode = termNode,  ///
-          generalcnonTerminalNode = constructorTermNode,  ///
-          specificChildNodes = specificnonTerminalNode.getChildNodes(), ///
-          generalcChildNodes = generalcnonTerminalNode.getChildNodes(), ///
-          descended = this.descend(generalcChildNodes, specificChildNodes, generalContext, specificContext);
-
-    if (descended) {
-      success = true;
-    }
-
-    return success;
-  }
-
   static maps = [
     {
       generalNodeQuery: typeNodeQuery,

package/src/process/validate.js

@@ -149,8 +149,142 @@ class StatementPass extends SimplePass {
   ];
 }
 
+class ConbinatorPass extends SimplePass {
+  run(statementNode, context) {
+    let success = false;
+
+    const nonTerminalNode = statementNode,  ///
+          childNodes = nonTerminalNode.getChildNodes(), ///
+          descended = this.descend(childNodes, context);
+
+    if (descended) {
+      success = true;
+    }
+
+    return success;
+  }
+
+  static maps = [
+    {
+      nodeQuery: statementNodeQuery,
+      run: (statementNode, context) => {
+        let success = false;
+
+        let statement;
+
+        const stated = true;
+
+        statement = statementFromStatementNode(statementNode, context);
+
+        statement = statement.validate(stated, context);
+
+        if (statement !== null) {
+          success = true;
+        }
+
+        return success;
+      }
+    },
+    {
+      nodeQuery: termNodeQuery,
+      run: (termNode, context) => {
+        let success = false;
+
+        let term;
+
+        term = termFromTermNode(termNode, context);
+
+        term = term.validate(context, () => { ///
+          const validatesForwards = true;
+
+          return validatesForwards;
+        });
+
+        if (term !== null) {
+          success = true;
+        }
+
+        return success;
+      }
+    },
+    {
+      nodeQuery: typeNodeQuery,
+      run: (typeNode, context) => {
+        let success = false;
+
+        const nominalTypeName = typeNode.getNominalTypeName(),
+              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
+
+        if (typePresent) {
+          success = true;
+        }
+
+        return success;
+      }
+    }
+  ];
+}
+
+class ConstructorPass extends SimplePass {
+  run(termNode, context) {
+    let success = false;
+
+    const nonTerminalNode = termNode,  ///
+          childNodes = nonTerminalNode.getChildNodes(), ///
+          descended = this.descend(childNodes, context);
+
+    if (descended) {
+      success = true;
+    }
+
+    return success;
+  }
+
+  static maps = [
+    {
+      nodeQuery: termNodeQuery,
+      run: (termNode, context) => {
+        let success = false;
+
+        let term;
+
+        term = termFromTermNode(termNode, context);
+
+        term = term.validate(context, () => { ///
+          const validatesForwards = true;
+
+          return validatesForwards;
+        });
+
+        if (term !== null) {
+          success = true;
+        }
+
+        return success;
+      }
+    },
+    {
+      nodeQuery: typeNodeQuery,
+      run: (typeNode, context) => {
+        let success = false;
+
+        const nominalTypeName = typeNode.getNominalTypeName(),
+              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
+
+        if (typePresent) {
+          success = true;
+        }
+
+        return success;
+      }
+    }
+  ];
+}
+
 const termPass = new TermPass(),
-      statementPass = new StatementPass();
+      statementPass = new StatementPass(),
+      combinatorPass = new ConbinatorPass(),
+      constructorPass = new ConstructorPass();
 
 export function validateTerm(termNode, context, validateForwards) {
   let termValidates = false;
@@ -177,3 +311,29 @@ export function validateStatement(statementNode, context) {
 
   return statementValidates;
 }
+
+export function validateTermAsConstructor(term, context) {
+  let termValidatesAsConstructor = false;
+
+  const termNode = term.getNode(),
+        success = constructorPass.run(termNode, context);
+
+  if (success) {
+    termValidatesAsConstructor = true;
+  }
+
+  return termValidatesAsConstructor;
+}
+
+export function validateStatementAsCombinator(statement, context) {
+  let statementValidatesAsCombinator = false;
+
+  const statementNode = statement.getNode(),
+        success = combinatorPass.run(statementNode, context);
+
+  if (success) {
+    statementValidatesAsCombinator = true;
+  }
+
+  return statementValidatesAsCombinator;
+}

package/src/process/verify.js

@@ -1,8 +1,7 @@
 "use strict";
 
-import { AsyncPass, SimplePass, queryUtilities } from "occam-languages"
+import { AsyncPass, queryUtilities } from "occam-languages"
 
-import { termFromTermNode, statementFromStatementNode } from "../utilities/element";
 import { ruleFromRuleNode,
          errorFromErrorNode,
          axiomFromAxiomNode,
@@ -23,15 +22,12 @@ import { ruleFromRuleNode,
 const { nodeQuery } = queryUtilities;
 
 const ruleNodeQuery = nodeQuery("/rule"),
-      termNodeQuery = nodeQuery("/term"),
-      typeNodeQuery = nodeQuery("/type"),
       errorNodeQuery = nodeQuery("/error"),
       axiomNodeQuery = nodeQuery("/axiom"),
       lemmaNodeQuery = nodeQuery("/lemma"),
       sectionNodeQuery = nodeQuery("/section"),
       theoremNodeQuery = nodeQuery("/theorem"),
       metaLemmaNodeQuery = nodeQuery("/metaLemma"),
-      statementNodeQuery = nodeQuery("/statement"),
       conjectureNodeQuery = nodeQuery("/conjecture"),
       metatheoremNodeQuery = nodeQuery("/metatheorem"),
       variableDeclarationNodeQuery = nodeQuery("/variableDeclaration"),
@@ -287,141 +283,7 @@ class TopLevelPass extends AsyncPass {
   ];
 }
 
-class ConbinatorPass extends SimplePass {
-  run(statementNode, context) {
-    let success = false;
-
-    const nonTerminalNode = statementNode,  ///
-          childNodes = nonTerminalNode.getChildNodes(), ///
-          descended = this.descend(childNodes, context);
-
-    if (descended) {
-      success = true;
-    }
-
-    return success;
-  }
-
-  static maps = [
-    {
-      nodeQuery: statementNodeQuery,
-      run: (statementNode, context) => {
-        let success = false;
-
-        let statement;
-
-        const stated = true;
-
-        statement = statementFromStatementNode(statementNode, context);
-
-        statement = statement.validate(stated, context);
-
-        if (statement !== null) {
-          success = true;
-        }
-
-        return success;
-      }
-    },
-    {
-      nodeQuery: termNodeQuery,
-      run: (termNode, context) => {
-        let success = false;
-
-        let term;
-
-        term = termFromTermNode(termNode, context);
-
-        term = term.validate(context, () => { ///
-          const validatesForwards = true;
-
-          return validatesForwards;
-        });
-
-        if (term !== null) {
-          success = true;
-        }
-
-        return success;
-      }
-    },
-    {
-      nodeQuery: typeNodeQuery,
-      run: (typeNode, context) => {
-        let success = false;
-
-        const nominalTypeName = typeNode.getNominalTypeName(),
-              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
-
-        if (typePresent) {
-          success = true;
-        }
-
-        return success;
-      }
-    }
-  ];
-}
-
-class ConstructorPass extends SimplePass {
-  run(termNode, context) {
-    let success = false;
-
-    const nonTerminalNode = termNode,  ///
-          childNodes = nonTerminalNode.getChildNodes(), ///
-          descended = this.descend(childNodes, context);
-
-    if (descended) {
-      success = true;
-    }
-
-    return success;
-  }
-
-  static maps = [
-    {
-      nodeQuery: termNodeQuery,
-      run: (termNode, context) => {
-        let success = false;
-
-        let term;
-
-        term = termFromTermNode(termNode, context);
-
-        term = term.validate(context, () => { ///
-          const validatesForwards = true;
-
-          return validatesForwards;
-        });
-
-        if (term !== null) {
-          success = true;
-        }
-
-        return success;
-      }
-    },
-    {
-      nodeQuery: typeNodeQuery,
-      run: (typeNode, context) => {
-        let success = false;
-
-        const nominalTypeName = typeNode.getNominalTypeName(),
-              typePresent = context.isTypePresentByNominalTypeName(nominalTypeName);
-
-        if (typePresent) {
-          success = true;
-        }
-
-        return success;
-      }
-    }
-  ];
-}
-
-const topLevelPass = new TopLevelPass(),
-      combinatorPass = new ConbinatorPass(),
-      constructorPass = new ConstructorPass();
+const topLevelPass = new TopLevelPass();
 
 export async function verifyFile(fileNode, context) {
   let fileVerifies = false;
@@ -435,29 +297,3 @@ export async function verifyFile(fileNode, context) {
 
   return fileVerifies;
 }
-
-export function verifyTermAsConstructor(term, context) {
-  let termVerifiesAsConstructor = false;
-
-  const termNode = term.getNode(),
-        success = constructorPass.run(termNode, context);
-
-  if (success) {
-    termVerifiesAsConstructor = true;
-  }
-
-  return termVerifiesAsConstructor;
-}
-
-export function verifyStatementAsCombinator(statement, context) {
-  let statementVerifiesAsCombinator = false;
-
-  const statementNode = statement.getNode(),
-        success = combinatorPass.run(statementNode, context);
-
-  if (success) {
-    statementVerifiesAsCombinator = true;
-  }
-
-  return statementVerifiesAsCombinator;
-}

package/src/utilities/context.js

@@ -46,14 +46,6 @@ export async function asyncScope(innerFunction, context) {
   return await innerFunction(context);
 }
 
-export async function asyncAttempt(innerFunction, context) {
-  const ephemeralContext = EphemeralContext.fromNothing(context);
-
-  context = ephemeralContext;  ///
-
-  return await innerFunction(context);
-}
-
 export async function asyncLiminally(innerFunction, context) {
   const liminalContext = LiminalContext.fromNothing(context);
 
@@ -61,4 +53,3 @@ export async function asyncLiminally(innerFunction, context) {
 
   return await innerFunction(context);
 }
-

package/src/utilities/validation.js

@@ -73,7 +73,7 @@ function unifyTermWithBracketedConstructor(term, context, validateForwards) {
 }
 
 function validateStatementAsMetavariable(statement, stated, context) {
-  let statementValidatesAsMetavariableAndSubstitution = false;
+  let statementValidatesAsMetavariable = false;
 
   const statementNode = statement.getNode(),
         metavariableNode = statementNode.getMetavariableNode();
@@ -87,7 +87,7 @@ function validateStatementAsMetavariable(statement, stated, context) {
           metavariable = context.findMetavariableByMetavariableName(metavariableName);
 
     if (metavariable !== null) {
-      statementValidatesAsMetavariableAndSubstitution = true;
+      statementValidatesAsMetavariable = true;
 
       const { TermSubstitution, FrameSubstitution } = elements,
             frameSubstitution = FrameSubstitution.fromStatement(statement, context),
@@ -104,17 +104,17 @@ function validateStatementAsMetavariable(statement, stated, context) {
         substitution = substitution.validate(generalContext, specificContext);
 
         if (substitution === null) {
-          statementValidatesAsMetavariableAndSubstitution = false;
+          statementValidatesAsMetavariable = false;
         }
       }
     }
 
-    if (statementValidatesAsMetavariableAndSubstitution) {
+    if (statementValidatesAsMetavariable) {
       context.debug(`...validated the '${statementString}' statement as a metavariable.`);
     }
   }
 
-  return statementValidatesAsMetavariableAndSubstitution;
+  return statementValidatesAsMetavariable;
 }
 
 function unifyStatementWithCombinators(statement, stated, context) {