occam-verify-cli 0.0.1074 → 0.0.1075

package/src/subproof.js

@@ -1,16 +1,16 @@
 "use strict";
 
-import Supposition from "./supposition";
+import shim from "./shim";
+
 import LocalContext from "./context/local";
-import SubDerivation from "./subDerivation";
 
 import { nodeQuery, nodesQuery } from "./utilities/query";
-import {subproofNodeAsSubproofString, subproofStringFromSubproofNode} from "./utilities/subproof";
+import { subproofStringFromSubproofNode } from "./utilities/subproof";
 
 const suppositionNodesQuery = nodesQuery("/subproof/supposition"),
       subDerivationNodeQuery = nodeQuery("/subproof/subDerivation");
 
-export default class Subproof {
+class Subproof {
   constructor(string, suppositions, subDerivation) {
     this.string = string;
     this.suppositions = suppositions;
@@ -79,7 +79,8 @@ export default class Subproof {
     let subproof = null;
 
     if (subproofNode !== null) {
-      const subproofString = subproofStringFromSubproofNode(subproofNode, fileContext),
+      const { Supposition, SubDerivation } = shim,
+            subproofString = subproofStringFromSubproofNode(subproofNode, fileContext),
             suppositionNodes = suppositionNodesQuery(subproofNode),
             subDerivationNode = subDerivationNodeQuery(subproofNode),
             string = subproofString,  ///
@@ -96,3 +97,9 @@ export default class Subproof {
     return subproof;
   }
 }
+
+Object.assign(shim, {
+  Subproof
+});
+
+export default Subproof;

package/src/substitution/statementForMetavariable.js

@@ -3,7 +3,6 @@
 import shim from "../shim";
 import Substitution from "../substitution";
 import LocalContext from "../context/local";
-import Substitutions from "../substitutions";
 import metaLevelUnifier from "../unifier/metaLevel";
 
 import { stripBracketsFromStatementNode } from "../utilities/brackets";
@@ -30,10 +29,10 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return this.substitution;
   }
 
-  getMetavariableName() {
-    const metavariableName = this.metavariable.getName();
+  getMetavariableNode() {
+    const metavariableNode = this.metavariable.getNode();
 
-    return metavariableName;
+    return metavariableNode;
   }
 
   isSimple() {
@@ -49,8 +48,8 @@ export default class StatementForMetavariableSubstitution extends Substitution {
 
     localContextB.trace(`Resolving the ${substitutionString} substitution...`);
 
-    const metavariableName = this.getMetavariableName(),
-          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableName(metavariableName);
+    const metavariableNode = this.getMetavariableNode(),
+          simpleSubstitution = substitutions.findSimpleSubstitutionByMetavariableNode(metavariableNode);
 
     if (simpleSubstitution !== null) {
       const substitution = simpleSubstitution,  ///
@@ -104,7 +103,8 @@ export default class StatementForMetavariableSubstitution extends Substitution {
   unifyStatement(statement, localContextA, localContextB) {
     let substitution = null;
 
-    const substitutions = Substitutions.fromNothing(),
+    const { Substitutions } = shim,
+          substitutions = Substitutions.fromNothing(),
           statementUnified = this.statement.unifyStatement(statement, substitutions, localContextA, localContextB);
 
     if (statementUnified) {
@@ -128,7 +128,7 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return statementNodeMatches;
   }
 
-  matchMetavariableName(metavariableName) { return this.metavariable.matchMetavariableName(metavariableName); }
+  matchMetavariableNode(metavariableNode) { return this.metavariable.matchMetavariableNode(metavariableNode); }
 
   matchSubstitutionNode(substitutionNode) {
     let substitutionNodeMatches;
@@ -146,12 +146,12 @@ export default class StatementForMetavariableSubstitution extends Substitution {
     return substitutionNodeMatches;
   }
 
-  matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
-    const metavariableNameMatches = this.matchMetavariableName(metavariableName),
+  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const metavariableNodeMatches = this.matchMetavariableNode(metavariableNode),
           substitutionNodeMatches = this.matchSubstitutionNode(substitutionNode),
-          metavariableNameAndSubstitutionNodeMatches = (metavariableNameMatches && substitutionNodeMatches);
+          metavariableNodeAndSubstitutionNodeMatches = (metavariableNodeMatches && substitutionNodeMatches);
 
-    return metavariableNameAndSubstitutionNodeMatches;
+    return metavariableNodeAndSubstitutionNodeMatches;
   }
 
   toJSON() {

package/src/substitution.js

@@ -35,10 +35,10 @@ class Substitution {
     return substitutionNode;
   }
 
-  getMetavariableName() {
-    const metavariableName = null;
+  getMetavariableNode() {
+    const metavariableNode = null;
 
-    return metavariableName;
+    return metavariableNode;
   }
 
   isSimple() {
@@ -90,16 +90,16 @@ class Substitution {
     return variableNameMatches;
   }
 
-  matchMetavariableName(metavariableName) {
-    const metavariableNameMatches = false;
+  matchMetavariableNode(metavariableNode) {
+    const metavariableNodeMatches = false;
 
-    return metavariableNameMatches;
+    return metavariableNodeMatches;
   }
 
-  matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
-    const metavariableNameAndSubstitutionNodeMatches = false;
+  matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const metavariableNodeAndSubstitutionNodeMatches = false;
 
-    return metavariableNameAndSubstitutionNodeMatches;
+    return metavariableNodeAndSubstitutionNodeMatches;
   }
 
   unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {

package/src/substitutions.js

@@ -1,12 +1,14 @@
 "use strict";
 
+import shim from "./shim";
+
 import { arrayUtilities } from "necessary";
 
 import { EMPTY_STRING } from "./constants";
 
 const { find, first, prune, filter, compress } = arrayUtilities;
 
-export default class Substitutions {
+class Substitutions {
   constructor(array, savedArray) {
     this.array = array;
     this.savedArray = savedArray;
@@ -34,24 +36,26 @@ export default class Substitutions {
     return firstSubstitution;
   }
 
-  getMetavariableNames() {
-    const metavariableNames = [];
+  getMetavariableNodes() {
+    const metavariableNodes = [];
 
     this.forEachSubstitution((substitution) => {
-      const metavariableName = substitution.getMetavariableName();
+      const metavariableNode = substitution.getMetavariableNode();
 
-      if (metavariableName !== null) {
-        metavariableNames.push(metavariableName);
+      if (metavariableNode !== null) {
+        metavariableNodes.push(metavariableNode);
       }
     });
 
-    compress(metavariableNames, (metavariableNameA, metavariableNameB) => {
-      if (metavariableNameA === metavariableNameB) {
+    compress(metavariableNodes, (metavariableNodeA, metavariableNodeB) => {
+      const metavariableNodeAMatchesMetavariableNodeB = metavariableNodeB.match(metavariableNodeA);
+
+      if (metavariableNodeAMatchesMetavariableNodeB) {
         return true;
       }
     });
 
-    return metavariableNames;
+    return metavariableNodes;
   }
 
   mapSubstitution(callback) { return this.array.map(callback); }
@@ -102,11 +106,11 @@ export default class Substitutions {
     return substitution;
   }
 
-  findSubstitutionByMetavariableName(metavariableName) {
+  findSubstitutionByMetavariableNode(metavariableNode) {
     const substitution = this.findSubstitution((substitution) => {
-      const metavariableNameMatches = substitution.matchMetavariableName(metavariableName);
+      const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
 
-      if (metavariableNameMatches) {
+      if (metavariableNodeMatches) {
         return true;
       }
     });
@@ -114,11 +118,11 @@ export default class Substitutions {
     return substitution;
   }
 
-  findSubstitutionsByMetavariableName(metavariableName) {
+  findSubstitutionsByMetavariableNode(metavariableNode) {
     const substitutions = this.findSubstitutions((substitution) => {
-      const metavariableNameMatches = substitution.matchMetavariableName(metavariableName);
+      const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
 
-      if (metavariableNameMatches) {
+      if (metavariableNodeMatches) {
         return true;
       }
     });
@@ -126,8 +130,8 @@ export default class Substitutions {
     return substitutions;
   }
 
-  findSimpleSubstitutionByMetavariableName(metavariableName) {
-    const substitutions = this.findSubstitutionsByMetavariableName(metavariableName),
+  findSimpleSubstitutionByMetavariableNode(metavariableNode) {
+    const substitutions = this.findSubstitutionsByMetavariableNode(metavariableNode),
           simpleSubstitutions = substitutions.filterSubstitution((substitution) => {
             const substitutionSimple = substitution.isSimple();
 
@@ -141,8 +145,8 @@ export default class Substitutions {
     return simpleSubstitution;
   }
 
-  findComplexSubstitutionsByMetavariableName(metavariableName) {
-    const substitutions = this.findSubstitutionsByMetavariableName(metavariableName),
+  findComplexSubstitutionsByMetavariableNode(metavariableNode) {
+    const substitutions = this.findSubstitutionsByMetavariableNode(metavariableNode),
           complexSubstitutions = substitutions.filterSubstitution((substitution) => {
             const substitutionComplex = substitution.isComplex();
 
@@ -154,11 +158,11 @@ export default class Substitutions {
     return complexSubstitutions;
   }
 
-  findSubstitutionByMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
+  findSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
     const substitutions = this.findSubstitutions((substitution) => {
-            const metavariableNameAndSubstitutionNodeMatch = substitution.matchMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode);
+            const metavariableNodeAndSubstitutionNodeMatch = substitution.matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
 
-            if (metavariableNameAndSubstitutionNodeMatch) {
+            if (metavariableNodeAndSubstitutionNodeMatch) {
               return true;
             }
           }),
@@ -168,15 +172,15 @@ export default class Substitutions {
     return substitution;
   }
 
-  isSimpleSubstitutionPresentByMetavariableName(metavariableName) {
-    const simpleSubstitution = this.findSimpleSubstitutionByMetavariableName(metavariableName),
+  isSimpleSubstitutionPresentByMetavariableNode(metavariableNode) {
+    const simpleSubstitution = this.findSimpleSubstitutionByMetavariableNode(metavariableNode),
           simpleSubstitutionPresent = (simpleSubstitution !== null);
 
     return simpleSubstitutionPresent;
   }
 
-  isSubstitutionPresentByMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode) {
-    const substitution = this.findSubstitutionByMetavariableNameAndSubstitutionNode(metavariableName, substitutionNode),
+  isSubstitutionPresentByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const substitution = this.findSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode),
           substitutionPresent = (substitution !== null);
 
     return substitutionPresent;
@@ -220,9 +224,9 @@ export default class Substitutions {
   }
 
   resolve(localContextA, localContextB) {
-    const metavariableNames = this.getMetavariableNames(),
-          resolved = metavariableNames.every((metavariableName) => {
-                        const complexSubstitutions = this.findComplexSubstitutionsByMetavariableName(metavariableName),
+    const metavariableNodes = this.getMetavariableNodes(),
+          resolved = metavariableNodes.every((metavariableNode) => {
+                        const complexSubstitutions = this.findComplexSubstitutionsByMetavariableNode(metavariableNode),
                               complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
                                 const substitution = complexSubstitution, ///
                                       substitutions = this, ///
@@ -252,7 +256,7 @@ export default class Substitutions {
       ...this.array
     ];
 
-    rightDifference(this.savedArray, array);
+    leftDifference(array, this.savedArray);
 
     array.forEach((substitution) => {
       this.removeSubstitution(substitution, localContext);
@@ -303,11 +307,15 @@ export default class Substitutions {
   }
 }
 
-function rightDifference(arrayA, arrayB) {
-  filter(arrayB, (elementB) => {
-    const arrayAIncludesElementB = arrayA.includes(elementB);
+Object.assign(shim, {
+  Substitutions
+});
+
+function leftDifference(arrayA, arrayB) {
+  filter(arrayA, (elementA) => {
+    const arrayBIncludesElementA = arrayB.includes(elementA);
 
-    if (!arrayAIncludesElementB) {
+    if (!arrayBIncludesElementA) {
       return true;
     }
   });

package/src/supposition.js

@@ -3,7 +3,6 @@
 import shim from "./shim";
 import LocalContext from "./context/local";
 import SubproofAssertion from "./assertion/subproof";
-import UnqualifiedStatement from "./statement/unqualified";
 
 import { nodeQuery } from "./utilities/query";
 import { assignAssignments } from "./utilities/assignments";
@@ -155,7 +154,8 @@ class Supposition {
   }
 
   static fromSuppositionNode(suppositionNode, fileContext) {
-    const unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
+    const { UnqualifiedStatement } = shim,
+          unqualifiedStatementNode = unqualifiedStatementNodeQuery(suppositionNode),
           unqualifiedStatement = UnqualifiedStatement.fromUnqualifiedStatementNode(unqualifiedStatementNode, fileContext),
           supposition = new Supposition(fileContext, unqualifiedStatement);
 

package/src/term.js

@@ -213,12 +213,12 @@ class Term {
     return verifiedGivenType;
   }
 
-  verifyAtTopLevel(fileContext) {
+  verifyWhenDeclared(fileContext) {
     let verifiedAtTopLevel;
 
     const termString = this.string;  ///
 
-    fileContext.trace(`Verifying the '${termString}' term at top level...`);
+    fileContext.trace(`Verifying the '${termString}' term when declared...`);
 
     const termNode = this.node, ///
           termVerifiedAsConstructor = termAsConstructorVerifier.verifyTerm(termNode, fileContext);
@@ -230,7 +230,7 @@ class Term {
     }
 
     if (verifiedAtTopLevel) {
-      fileContext.debug(`...verified the '${termString}' term at top level.`);
+      fileContext.debug(`...verified the '${termString}' term when declared.`);
     }
 
     return verifiedAtTopLevel;

package/src/theorem.js

@@ -1,12 +1,7 @@
 "use strict";
 
 import shim from "./shim";
-import Label from "./label";
-import Proof from "./proof";
-import Consequent from "./consequent";
-import Supposition from "./supposition";
 import LocalContext from "./context/local";
-import Substitutions from "./substitutions";
 import TopLevelAssertion from "./topLevelAssertion";
 
 import { stringFromLabels } from "./topLevelAssertion";
@@ -25,15 +20,15 @@ class Theorem extends TopLevelAssertion {
 
     this.fileContext.trace(`Verifying the '${theoremString}' theorem...`);
 
-    const labelsVerifiedAtTopLevel = this.labels.every((label) => {
-      const labelVVerifiedAtTopLevel = label.verifyAtTopLevel(this.fileContext);
+    const labelsVerifiedWhenDeclared = this.labels.every((label) => {
+      const labelVVerifiedWhenDeclared = label.verifyWhenDeclared(this.fileContext);
 
-      if (labelVVerifiedAtTopLevel) {
+      if (labelVVerifiedWhenDeclared) {
         return true;
       }
     });
 
-    if (labelsVerifiedAtTopLevel) {
+    if (labelsVerifiedWhenDeclared) {
       const localContext = LocalContext.fromFileContext(this.fileContext),
             suppositionsVerified = this.suppositions.every((supposition) => {
               const suppositionVerified = supposition.verify(localContext);
@@ -47,7 +42,8 @@ class Theorem extends TopLevelAssertion {
         const consequentVerified = this.consequent.verify(localContext);
 
         if (consequentVerified) {
-          const substitutions = Substitutions.fromNothing(),
+          const { Substitutions } = shim,
+                substitutions = Substitutions.fromNothing(),
                 proofVerified = this.proof.verify(substitutions, this.consequent, localContext);
 
           if (proofVerified) {
@@ -71,7 +67,8 @@ class Theorem extends TopLevelAssertion {
   static fromJSON(json, fileContext) { return TopLevelAssertion.fromJSON(Theorem, json, fileContext); }
 
   static fromTheoremNode(theoremNode, fileContext) {
-    const proofNode = proofNodeQuery(theoremNode),
+    const { Label, Proof, Consequent, Supposition } = shim,
+          proofNode = proofNodeQuery(theoremNode),
           labelNodes = labelNodesQuery(theoremNode),
           consequentNode = consequentNodeQuery(theoremNode),
           suppositionNodes = suppositionNodesQuery(theoremNode),

package/src/topLevelAssertion.js

@@ -2,7 +2,7 @@
 
 import { arrayUtilities } from "necessary";
 
-import Substitutions from "./substitutions";
+import shim from "./shim";
 
 import { EMPTY_STRING } from "./constants";
 import { labelsFromJSON,
@@ -63,7 +63,8 @@ export default class TopLevelAssertion {
   unifyStatement(statement, localContext) {
     let statementUnified = false;
 
-    const proofSteps = localContext.getProofSteps(),
+    const { Substitutions } = shim,
+          proofSteps = localContext.getProofSteps(),
           substitutions = Substitutions.fromNothing(),
           proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
 

package/src/type.js

@@ -109,12 +109,12 @@ class Type {
     return typeNodeMatches;
   }
 
-  verifyAtTopLevel(fileContext) {
+  verifyWhenDeclared(fileContext) {
     let verifiedAtTopLevel = false;
 
     const typeString = this.string; ///
 
-    fileContext.trace(`Verifying the '${typeString}' type at top level...`);
+    fileContext.trace(`Verifying the '${typeString}' type when declared...`);
 
     const typePresent = fileContext.isTypePresentByTypeName(this.name);
 
@@ -136,7 +136,7 @@ class Type {
     }
 
     if (verifiedAtTopLevel) {
-      fileContext.debug(`...verified the '${typeString}' type at top level.`);
+      fileContext.debug(`...verified the '${typeString}' type when declared.`);
     }
 
     return verifiedAtTopLevel;

package/src/unifier/equality.js

@@ -5,7 +5,7 @@ import Unifier from "../unifier";
 import { nodeQuery } from "../utilities/query";
 import { findEquivalenceByTermNodes } from "../utilities/equivalences";
 
-const termNodeQuery = nodeQuery("/term!");
+const termNodeQuery = nodeQuery("/term");
 
 class EqualityUnifier extends Unifier {
   unify(leftTermNode, rightTermNode, localContext) {

package/src/unifier/metaLevel.js

@@ -6,11 +6,11 @@ import TermForVariableSubstitution from "../substitution/termForVariable";
 import FrameForMetavariableSubstitution from "../substitution/frameForMetavariable";
 
 import { nodeQuery } from "../utilities/query";
-import { variableNameFromVariableNode, metavariableNameFromMetavariableNode } from "../utilities/name";
+import { variableNameFromVariableNode } from "../utilities/name";
 
-const termNodeQuery = nodeQuery("/term!"),
-      frameNodeQuery = nodeQuery("/frame!"),
-      statementNodeQuery = nodeQuery("/statement!"),
+const termNodeQuery = nodeQuery("/term"),
+      frameNodeQuery = nodeQuery("/frame"),
+      statementNodeQuery = nodeQuery("/statement"),
       termVariableNodeQuery = nodeQuery("/term/variable!"),
       frameMetavariableNodeQuery = nodeQuery("/frame/metavariable!"),
       statementMetavariableNodeQuery = nodeQuery("/statement/metavariable!");
@@ -56,8 +56,7 @@ class MetaLevelUnifier extends Unifier {
 
             const { Statement } = shim,
                   metavariableNode = statementMetavariableNode, ///
-                  metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-                  metavariable = localContextA.findMetavariableByMetavariableName(metavariableName);
+                  metavariable = localContextA.findMetavariableByMetavariableNode(metavariableNode, localContextB);
 
             localContext = localContextB; ///
 
@@ -67,7 +66,7 @@ class MetaLevelUnifier extends Unifier {
 
             statementUnified = metavariable.unifyStatement(statement, substitution, substitutions, localContext);
           } else {
-            statementUnified = unifyStatementWithStatement(statementNodeA, statementNodeB, substitutions, localContextA, localContextB);
+            statementUnified = unifyChildNodes(statementNodeA, statementNodeB, substitutions, localContextA, localContextB);
           }
         }
 
@@ -81,8 +80,7 @@ class MetaLevelUnifier extends Unifier {
         let frameUnified = false;
 
         const metavariableNode = frameMetavariableNodeA,  ///
-              metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-              metavariablePresent = localContextA.isMetavariablePresentByMetavariableName(metavariableName);
+              metavariablePresent = localContextA.isMetavariablePresentByMetavariableNode(metavariableNode, localContextB);
 
         if (metavariablePresent) {
           const { Frame, Metavariable } = shim,
@@ -127,7 +125,7 @@ const metaLevelUnifier = new MetaLevelUnifier();
 
 export default metaLevelUnifier;
 
-function unifyStatementWithStatement(statementNodeA, statementNodeB, substitutions, localContextA, localContextB) {
+function unifyChildNodes(statementNodeA, statementNodeB, substitutions, localContextA, localContextB) {
   const nonTerminalNodeA = statementNodeA, ///
         nonTerminalNodeB = statementNodeB, ///
         nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),

package/src/unifier/metavariable.js

@@ -6,8 +6,8 @@ import Unifier from "../unifier";
 import { nodeQuery } from "../utilities/query";
 import { typeNameFromTypeNode } from "../utilities/name";
 
-const typeNodeQuery = nodeQuery("/type!"),
-      termNodeQuery = nodeQuery("/term!");
+const typeNodeQuery = nodeQuery("/type"),
+      termNodeQuery = nodeQuery("/term");
 
 class MetavariableUnifier extends Unifier {
   unify(metavariableNodeA, metavariableNodeB, localContext) {
@@ -27,7 +27,7 @@ class MetavariableUnifier extends Unifier {
       nodeQueryA: typeNodeQuery,
       nodeQueryB: termNodeQuery,
       unify: (typeNodeA, termNodeB, localContext) => {
-        let unified = false;
+        let termUnified = false;
 
         const { Term } = shim,
               typeNode = typeNodeA, ///
@@ -40,11 +40,11 @@ class MetavariableUnifier extends Unifier {
                 termVerifiedGivenType = term.verifyGivenType(type, localContext);
 
           if (termVerifiedGivenType) {
-            unified = true;
+            termUnified = true;
           }
         }
 
-        return unified;
+        return termUnified;
       }
     }
   ];

package/src/unifier/statementWithCombinator.js

@@ -6,11 +6,11 @@ import Unifier from "../unifier";
 import { nodeQuery } from "../utilities/query";
 import { typeNameFromTypeNode } from "../utilities/name";
 
-const termNodeQuery = nodeQuery("/term!"),
-      typeNodeQuery = nodeQuery("/type!"),
-      frameNodeQuery = nodeQuery("/frame!"),
-      metaTypeNodeQuery = nodeQuery("/metaType!"),
-      statementNodeQuery = nodeQuery("/statement!");
+const termNodeQuery = nodeQuery("/term"),
+      typeNodeQuery = nodeQuery("/type"),
+      frameNodeQuery = nodeQuery("/frame"),
+      metaTypeNodeQuery = nodeQuery("/metaType"),
+      statementNodeQuery = nodeQuery("/statement");
 
 class StatementWithCombinatorUnifier extends Unifier {
   unify(combinatorStatementNode, statementNode, assignments, stated, localContext) {

package/src/utilities/brackets.js

@@ -5,8 +5,8 @@ import { bracketedTermNode } from "../constructor/bracketed";
 import { bracketedStatementNode } from "../combinator/bracketed";
 import { BRACKETED_TERM_DEPTH, BRACKETED_STATEMENT_DEPTH } from "../constants";
 
-const bracketedTermChildNodeQuery = nodeQuery("/term/argument/term!"),
-      bracketedStatementChildNodeQuery = nodeQuery("/statement/metaArgument/statement!");
+const bracketedTermChildNodeQuery = nodeQuery("/term/argument/term"),
+      bracketedStatementChildNodeQuery = nodeQuery("/statement/metaArgument/statement");
 
 export function stripBracketsFromTermNode(termNode) {
   const bracketedTermChildNode = bracketedTermChildNodeFromTermNode(termNode);

package/src/utilities/node.js

@@ -1,23 +1,14 @@
 "use strict";
 
-import { parsersUtilities } from "occam-custom-grammars";
-
 import { nodeQuery } from "../utilities/query";
-import { combinedCustomGrammarFromNothing } from "./customGrammar";
 import { VARIABLE_RULE_NAME,
          METAVARIABLE_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
          CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
 import { variableTokensFromVariableString,
          metavariableTokensFromMetavariableString,
-         unqualifiedStatementTokensFromUnqualifiedStatementString,
          constructorDeclarationTokensFromConstructorDeclarationString } from "../utilities/tokens";
 
-const { nominalParserFromCombinedCustomGrammar } = parsersUtilities;
-
-const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
-      nominalParser = nominalParserFromCombinedCustomGrammar(combinedCustomGrammar);
-
 const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
       statementNodeQuery = nodeQuery("/unqualifiedStatement/statement"),
       substitutionNodeQuery = nodeQuery("/unqualifiedStatement/statement/substitution");
@@ -114,7 +105,7 @@ export function constructorDeclarationNodeFromConstructorDeclarationTokens(const
   return constructorDeclarationNode;
 }
 
-function nodeFromTokensRuleNameAndParser(tokens, ruleName, parser = nominalParser) {
+function nodeFromTokensRuleNameAndParser(tokens, ruleName, parser) {
   const ruleMap = parser.getRuleMap(),
         rule = ruleMap[ruleName],
         node = parser.parse(tokens, rule);

package/src/utilities/nominal.js

@@ -0,0 +1,14 @@
+"use strict";
+
+import { lexersUtilities, parsersUtilities } from "occam-custom-grammars";
+
+import { combinedCustomGrammarFromNothing } from "./customGrammar";
+
+const { nominalLexerFromCombinedCustomGrammar } = lexersUtilities,
+      { nominalParserFromCombinedCustomGrammar } = parsersUtilities;
+
+const combinedCustomGrammar = combinedCustomGrammarFromNothing();
+
+export const nominalLexer = nominalLexerFromCombinedCustomGrammar(combinedCustomGrammar);
+
+export const nominalParser = nominalParserFromCombinedCustomGrammar(combinedCustomGrammar);

package/src/utilities/subproof.js

@@ -3,8 +3,8 @@
 import { nodeQuery, nodesQuery } from "./query";
 import { nodeAsString, nodesAsString } from "./string";
 
-const subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement!"),
-      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement!");
+const subproofSuppositionStatementNodesQuery = nodesQuery("/subproof/supposition/unqualifiedStatement/statement"),
+      subproofLastProofStepStatementNodeQuery = nodeQuery("/subproof/subDerivation/lastProofStep/unqualifiedStatement|qualifiedStatement/statement");
 
 export function subproofStringFromSubproofNode(subproofNode, fileContext) {
   const tokens = fileContext.getTokens(),