occam-verify-cli 0.0.1074 → 0.0.1077

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,24 +224,46 @@ export default class Substitutions {
   }
 
   resolve(localContextA, localContextB) {
-    const metavariableNames = this.getMetavariableNames(),
-          resolved = metavariableNames.every((metavariableName) => {
-                        const complexSubstitutions = this.findComplexSubstitutionsByMetavariableName(metavariableName),
-                              complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
-                                const substitution = complexSubstitution, ///
-                                      substitutions = this, ///
-                                      substitutionResolved = substitution.resolve(substitutions, localContextA, localContextB);
-
-                                if (substitutionResolved) {
-                                  return true;
-                                }
-                              });
-
-                        if (complexSubstitutionsResolved) {
+    const metavariableNodes = this.getMetavariableNodes();
+
+    metavariableNodes.forEach((metavariableNode) => {
+      const complexSubstitutions = this.findComplexSubstitutionsByMetavariableNode(metavariableNode),
+            complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
+              let resolved;
+
+              const substitutions = this,
+                    substitution = complexSubstitution; ///
+
+              resolved = substitution.isResolved();
+
+              if (!resolved) {
+                substitution.resolve(substitutions, localContextA, localContextB);
+              }
+            });
+
+      if (complexSubstitutionsResolved) {
+        return true;
+      }
+    });
+  }
+
+  areResolved() {
+    const metavariableNodes = this.getMetavariableNodes(),
+          resolved = metavariableNodes.every((metavariableNode) => {
+            const complexSubstitutions = this.findComplexSubstitutionsByMetavariableNode(metavariableNode),
+                  complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
+                        const complexSubstitutionResolved = complexSubstitution.isResolved();
+
+                        if (complexSubstitutionResolved) {
                           return true;
                         }
                       });
 
+                    if (complexSubstitutionsResolved) {
+                      return true;
+                    }
+                  });
+
     return resolved;
   }
 
@@ -252,7 +278,7 @@ export default class Substitutions {
       ...this.array
     ];
 
-    rightDifference(this.savedArray, array);
+    leftDifference(array, this.savedArray);
 
     array.forEach((substitution) => {
       this.removeSubstitution(substitution, localContext);
@@ -303,11 +329,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";
@@ -60,37 +59,6 @@ class Supposition {
     return verified;
   }
 
-  unifySubproof(subproof, substitutions, localContext) {
-    let subproofUnified = false;
-
-    const supposition = this, ///
-          subproofString = subproof.getString(),
-          suppositionStatement = supposition.getStatement(),
-          suppositionStatementString = suppositionStatement.getString();
-
-    localContext.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
-
-    const statement = this.unqualifiedStatement.getStatement(),
-          statementNode = statement.getNode(),
-          statementTokens = statement.getTokens(),
-          context = this.fileContext, ///
-          tokens = statementTokens; ///
-
-    localContext = LocalContext.fromContextAndTokens(context, tokens);  ///
-
-    const subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, localContext);
-
-    if (subproofAssertion !== null) {
-      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
-    }
-
-    if (subproofUnified) {
-      localContext.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
-    }
-
-    return subproofUnified;
-  }
-
   unifyProofStep(proofStep, substitutions, localContext) {
     let proofStepUnified = false;
 
@@ -99,12 +67,27 @@ class Supposition {
 
     substitutions.snapshot();
 
+    let subproofUnified = false,
+        statementUnified = false;
+
     if (false) {
       ///
     } else if (subproof !== null) {
-      proofStepUnified = this.unifySubproof(subproof, substitutions, localContext);
+      subproofUnified = this.unifySubproof(subproof, substitutions, localContext);
     } else if (statement !== null) {
-      proofStepUnified = this.unifyStatement(statement, substitutions, localContext);
+      statementUnified = this.unifyStatement(statement, substitutions, localContext);
+    }
+
+    if (subproofUnified || statementUnified) {
+      const localContextB = localContext; ///
+
+      localContext = LocalContext.fromFileContext(this.fileContext);
+
+      const localContextA = localContext; ///
+
+      substitutions.resolve(localContextA, localContextB);
+
+      proofStepUnified = true;
     }
 
     proofStepUnified ?
@@ -137,6 +120,37 @@ class Supposition {
     return statementUnified;
   }
 
+  unifySubproof(subproof, substitutions, localContext) {
+    let subproofUnified = false;
+
+    const supposition = this, ///
+          subproofString = subproof.getString(),
+          suppositionStatement = supposition.getStatement(),
+          suppositionStatementString = suppositionStatement.getString();
+
+    localContext.trace(`Unifying the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement...`);
+
+    const statement = this.unqualifiedStatement.getStatement(),
+          statementNode = statement.getNode(),
+          statementTokens = statement.getTokens(),
+          context = this.fileContext, ///
+          tokens = statementTokens; ///
+
+    localContext = LocalContext.fromContextAndTokens(context, tokens);  ///
+
+    const subproofAssertion = SubproofAssertion.fromStatementNode(statementNode, localContext);
+
+    if (subproofAssertion !== null) {
+      subproofUnified = subproofAssertion.unifySubproof(subproof, substitutions, this.fileContext, localContext);
+    }
+
+    if (subproofUnified) {
+      localContext.debug(`...unified the '${subproofString}' subproof with the supposition's '${suppositionStatementString}' statement.`);
+    }
+
+    return subproofUnified;
+  }
+
   toJSON() {
     const unqualifiedStatementJSON = unqualifiedStatementToUnqualifiedStatementJSON(this.unqualifiedStatement),
           unqualifiedStatement = unqualifiedStatementJSON,  ///
@@ -155,7 +169,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,8 @@
 
 import { arrayUtilities } from "necessary";
 
-import Substitutions from "./substitutions";
+import shim from "./shim";
+import LocalContext from "./context/local";
 
 import { EMPTY_STRING } from "./constants";
 import { labelsFromJSON,
@@ -61,14 +62,22 @@ export default class TopLevelAssertion {
   }
 
   unifyStatement(statement, localContext) {
-    let statementUnified = false;
+    let statementUnified;
 
-    const proofSteps = localContext.getProofSteps(),
-          substitutions = Substitutions.fromNothing(),
-          proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
+    const { Substitutions } = shim,
+          substitutions = Substitutions.fromNothing();
 
-    if (proofStepsUnified) {
-      statementUnified = this.consequent.unifyStatement(statement, substitutions, localContext);
+    statementUnified = this.consequent.unifyStatement(statement, substitutions, localContext);
+
+    if (statementUnified) {
+      const proofSteps = localContext.getProofSteps(),
+            proofStepsUnified = this.unifyProofSteps(proofSteps, substitutions, localContext);
+
+      if (proofStepsUnified) {
+        const substitutionsResolved = substitutions.areResolved();
+
+        statementUnified = substitutionsResolved; ///
+      }
     }
 
     return statementUnified;

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);