occam-verify-cli 0.0.1065 → 0.0.1067

package/src/substitution/termForVariable.js

@@ -6,16 +6,18 @@ import Substitution from "../substitution";
 import { nodeQuery } from "../utilities/query";
 import { stripBracketsFromTerm } from "../utilities/brackets";
 
-const termVariableNodeQuery = nodeQuery("/term/variable!"),
+const substitutionNodeQuery = nodeQuery("/statement/substitution"),
+      termVariableNodeQuery = nodeQuery("/term/variable!"),
       substitutionTermNodeQuery = nodeQuery("/substitution/term!"),
       substitutionsVariableNodeQuery = nodeQuery("/substitution/variable!");
 
 export default class TermForVariableSubstitution extends Substitution {
-  constructor(string, termNode, variableNode) {
+  constructor(string, termNode, variableNode, substitutionNode) {
     super(string);
 
     this.termNode = termNode;
     this.variableNode = variableNode;
+    this.substitutionNode = substitutionNode;
   }
 
   getTermNode() {
@@ -26,7 +28,11 @@ export default class TermForVariableSubstitution extends Substitution {
     return this.variableNode;
   }
 
-  transformed(substitutions) {
+  getSubstitutionNode() {
+    return this.substitutionNode;
+  }
+
+  transformed(substitutions, localContext) {
     let transformedSubstitution = null;
 
     const transformedTermNode = transformTermNode(this.termNode, substitutions),
@@ -35,7 +41,11 @@ export default class TermForVariableSubstitution extends Substitution {
     if ((transformedTermNode !== null) && (transformedVariableNode !== null)) {
       const termNode = transformedTermNode, ///
             variableNode = transformedVariableNode, ///
-            termForVariableSubstitution = new TermForVariableSubstitution(termNode, variableNode);
+            termString = localContext.nodeAsString(termNode),
+            variableString = localContext.nodeAsString(variableNode),
+            string = `[${termString} for ${variableString}]`,
+            substitutionNode = null,
+            termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode);
 
       transformedSubstitution = termForVariableSubstitution;  ///
     }
@@ -44,11 +54,17 @@ export default class TermForVariableSubstitution extends Substitution {
   }
 
   isEqualTo(substitution) {
+    let equalTo = false;
+
     const termNode = substitution.getTermNode(),
-          variableNode = substitution.getVariableNode(),
-          termNodeMatches = this.matchTermNode(termNode),
-          variableNodeMatches = this.matchVariableNode(variableNode),
-          equalTo = (termNodeMatches && variableNodeMatches);
+          variableNode = substitution.getVariableNode();
+
+    if ((termNode !== null) && (variableNode !== null)) {
+      const termNodeMatches = this.matchTermNode(termNode),
+            variableNodeMatches = this.matchVariableNode(variableNode);
+
+      equalTo = (termNodeMatches && variableNodeMatches);
+    }
 
     return equalTo;
   }
@@ -67,6 +83,12 @@ export default class TermForVariableSubstitution extends Substitution {
     return variableNodeMatches;
   }
 
+  matchSubstitutionNode(substitutionNode) {
+    const substitutionNodeMatches = this.substitutionNode.match(substitutionNode);
+
+    return substitutionNodeMatches;
+  }
+
   unifyWithEquivalence(equivalence, substitutions, localContextA, localContextB) {
     let unifiedWithEquivalence;
 
@@ -83,42 +105,39 @@ export default class TermForVariableSubstitution extends Substitution {
     return unifiedWithEquivalence;
   }
 
-  static fromSubstitution(substitution, localContext) {
+  static fromStatementNode(statementNode, localContext) {
     let termForVariableSubstitution = null;
 
-    const substitutionNode = substitution.getNode();
-
-    let substitutionTermNode = substitutionTermNodeQuery(substitutionNode);
-
-    if (substitutionTermNode !== null) {
-      let termNode;
+    const substitutionNode = substitutionNodeQuery(statementNode);
 
-      const substitutionVariableNode = substitutionsVariableNodeQuery(substitutionNode),
-            variableNode = substitutionVariableNode;  ///
+    if (substitutionNode !== null) {
+      let substitutionTermNode = substitutionTermNodeQuery(substitutionNode);
 
-      termNode = substitutionTermNode;  ///
+      if (substitutionTermNode !== null) {
+        const { Term, Variable } = shim,
+              substitutionVariableNode = substitutionsVariableNodeQuery(substitutionNode),
+              variableNode = substitutionVariableNode,  ///
+              termNode = substitutionTermNode,  ///
+              term = Term.fromTermNode(termNode, localContext),
+              variable = Variable.fromVariableNode(variableNode, localContext),
+              string = stringFromTermAndVariable(term, variable, localContext);
 
-      termNode = stripBracketsFromTerm(termNode); ///
-
-      const { Term, Variable } = shim,
-            term = Term.fromTermNode(termNode, localContext),
-            variable = Variable.fromVariableNode(variableNode, localContext),
-            string = stringFromTermAndVariable(term, variable);
-
-      termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
+        termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode);
+      }
     }
 
     return termForVariableSubstitution;
   }
 
-  static fromTernAndVariable(term, variable) {
+  static fromTernAndVariable(term, variable, localContext) {
     let termNode = term.getNode();
 
     termNode = stripBracketsFromTerm(termNode); ///
 
-    const variableNode = variable.getNode(),
-          string = stringFromTermAndVariable(term, variable),
-          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode);
+    const string = stringFromTermAndVariable(term, variable, localContext),
+          variableNode = variable.getNode(),
+          substitutionNode = null,
+          termForVariableSubstitution = new TermForVariableSubstitution(string, termNode, variableNode, substitutionNode);
 
     return termForVariableSubstitution;
   }
@@ -169,8 +188,9 @@ function transformVariableNode(variableNode, substitutions) {
   return transformedVariableNode;
 }
 
-function stringFromTermAndVariable(term, variable) {
-  const termString = term.getString(),
+function stringFromTermAndVariable(term, variable, localContext) {
+  const termNode = term.getNode(),
+        termString = localContext.nodeAsString(termNode),
         variableString = variable.getString(),
         string = `[${termString} for ${variableString}]`;
 

package/src/substitution.js

@@ -9,24 +9,22 @@ export default class Substitution {
     return this.string;
   }
 
-  isSimple() {
-    const simple = true;
+  getTermNode() {
+    const termNode = null;
 
-    return simple;
+    return termNode;
   }
 
-  isComplex() {
-    const simple = this.isSimple(),
-          complex = !simple;
+  getFrameNode() {
+    const frameNode = null;
 
-    return complex;
+    return frameNode;
   }
 
-  isResolved() {
-    const simple = this.isSimple(),
-          resolved = simple; ///
+  getStatementNode() {
+    const statementNode = null;
 
-    return resolved;
+    return statementNode;
   }
 
   getVariableNode() {
@@ -41,18 +39,49 @@ export default class Substitution {
     return metavariableNode;
   }
 
+  getSubstitutionNode() {
+    const substitutionNode = null;
+
+    return substitutionNode;
+  }
+
+  isSimple() {
+    const simple = true;
+
+    return simple;
+  }
+
+  isComplex() {
+    const simple = this.isSimple(),
+          complex = !simple;
+
+    return complex;
+  }
+
   isEqualTo(substitution) {
     const equalTo = false;
 
     return equalTo;
   }
 
+  resolve(substitutions, localContext) {
+    const resolved = true;
+
+    return resolved;
+  }
+
   matchTermNode(termNode) {
     const termNodeMatches = false;
 
     return termNodeMatches;
   }
 
+  matchFrameNode(frameNode) {
+    const frameNodeMatches = false;
+
+    return frameNodeMatches;
+  }
+
   matchVariableNode(variableNode) {
     const variableNodeMatches = false;
 

package/src/substitutions.js

@@ -113,6 +113,7 @@ export default class Substitutions {
 
     return substitution;
   }
+
   findSubstitutionsByMetavariableNode(metavariableNode) {
     const substitutions = this.findSubstitutions((substitution) => {
       const metavariableNodeMatches = substitution.matchMetavariableNode(metavariableNode);
@@ -153,31 +154,25 @@ export default class Substitutions {
     return complexSubstitutions;
   }
 
-  findSubstitutionsByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+  findSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
     const substitutions = this.findSubstitutions((substitution) => {
-      const metavariableNodeAndSubstitutionNodeMatch = substitution.matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
-
-      if (metavariableNodeAndSubstitutionNodeMatch) {
-        return true;
-      }
-    });
-
-    return substitutions;
-  }
-
-  findComplexSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
-    const substitutions = this.findSubstitutionsByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode),
-          complexSubstitutions = substitutions.filterSubstitution((substitution) => {
-            const substitutionComplex = substitution.isComplex();
+            const metavariableNodeAndSubstitutionNodeMatch = substitution.matchMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode);
 
-            if (substitutionComplex) {
+            if (metavariableNodeAndSubstitutionNodeMatch) {
               return true;
             }
           }),
-          firstComplexSubstitution = complexSubstitutions.getFirstSubstitution(),
-          complexSubstitution = firstComplexSubstitution; ///
+          firstSubstitution = substitutions.getFirstSubstitution(),
+          substitution = firstSubstitution; ///
+
+    return substitution;
+  }
+
+  isSubstitutionPresentByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode) {
+    const substitution = this.findSubstitutionByMetavariableNodeAndSubstitutionNode(metavariableNode, substitutionNode),
+          substitutionPresent = (substitution !== null);
 
-    return complexSubstitution;
+    return substitutionPresent;
   }
 
   addSubstitution(substitution, localContext) {
@@ -218,12 +213,24 @@ export default class Substitutions {
     return unifiedWithEquivalences;
   }
 
-  areResolved() {
-    const resolved = this.everySubstitution((substitution) => {
-      const substitutionResolved = substitution.isResolved();
-
-      return substitutionResolved;
-    });
+  resolve(localContext) {
+    const metavariableNodes = this.getMetavariableNodes(),
+          resolved = metavariableNodes.every((metavariableNode) => {
+            const complexSubstitutions = this.findComplexSubstitutionsByMetavariableNode(metavariableNode),
+                  complexSubstitutionsResolved = complexSubstitutions.everySubstitution((complexSubstitution) => {
+                    const substitution = complexSubstitution, ///
+                          substitutions = this, ///
+                          substitutionResolved = substitution.resolve(substitutions, localContext);
+
+                    if (substitutionResolved) {
+                      return true;
+                    }
+                  });
+
+            if (complexSubstitutionsResolved) {
+              return true;
+            }
+          });
 
     return resolved;
   }

package/src/supposition.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import shim from "./shim";
+import LocalContext from "./context/local";
 import SubproofAssertion from "./assertion/subproof";
 import UnqualifiedStatement from "./statement/unqualified";
 
@@ -114,7 +115,13 @@ export default class Supposition {
 
     localContext.trace(`Unifying the '${statementString}' statement with the '${suppositionString}' supposition...`);
 
-    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, this.fileContext, localContext);
+    const localContextB = localContext;
+
+    localContext = LocalContext.fromFileContext(this.fileContext);
+
+    const localContextA = localContext; ///
+
+    statementUnified = this.unqualifiedStatement.unifyStatement(statement, substitutions, localContextA, localContextB);
 
     if (statementUnified) {
       localContext.debug(`...unified the '${statementString}' statement with the '${suppositionString}' supposition.`);

package/src/unifier/metaLevel.js

@@ -2,7 +2,8 @@
 
 import shim from "../shim";
 import Unifier from "../unifier";
-import unifyMetavariableWithFrame from "../unify/metavariableWithFrame";
+import TermForVariableSubstitution from "../substitution/termForVariable";
+import FrameForMetavariableSubstitution from "../substitution/frameForMetavariable";
 
 import { nodeQuery } from "../utilities/query";
 import { variableNameFromVariableNode, metavariableNameFromMetavariableNode } from "../utilities/name";
@@ -39,26 +40,32 @@ class MetaLevelUnifier extends Unifier {
         if (matches) {
           statementUnified = true;
         } else {
-          const statementNode = statementNodeA, ///
-                statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
+          let localContext,
+              statementNode;
+
+          localContext = localContextA; ///
+
+          statementNode = statementNodeA; ///
+
+          const statementMetavariableNode = statementMetavariableNodeQuery(statementNode);
 
           if (statementMetavariableNode !== null) {
+            const substitution = FrameForMetavariableSubstitution.fromStatementNode(statementNode, localContext) ||
+                                   TermForVariableSubstitution.fromStatementNode(statementNode, localContext) ||
+                                     null;
+
             const { Statement } = shim,
                   metavariableNode = statementMetavariableNode, ///
                   metavariableName = metavariableNameFromMetavariableNode(metavariableNode),
-                  metavariable = localContextA.findMetavariableByMetavariableName(metavariableName),
-                  substitution = substitutionA,  ///
-                  localContext = localContextB, ///
-                  statementNode = statementNodeB, ///
-                  statement = Statement.fromStatementNode(statementNode, localContext);
-
-            if (substitution === null) {
-              statementUnified = metavariable.unifyStatement(statement, substitutions, localContext);
-            } else {
-              const statementUnifiedGivenSubstitution = metavariable.unifyStatementGivenSubstitution(statement, substitution, substitutions, localContext);
-
-              statementUnified = statementUnifiedGivenSubstitution; ///
-            }
+                  metavariable = localContextA.findMetavariableByMetavariableName(metavariableName);
+
+            localContext = localContextB; ///
+
+            statementNode = statementNodeB; ///
+
+            const statement = Statement.fromStatementNode(statementNode, localContext);
+
+            statementUnified = metavariable.unifyStatement(statement, substitution, substitutions, localContext);
           } else {
             statementUnified = unifyStatementWithStatement(statementNodeA, statementNodeB, substitutions, localContextA, localContextB);
           }
@@ -109,8 +116,6 @@ const metaLevelUnifier = new MetaLevelUnifier();
 export default metaLevelUnifier;
 
 function unifyStatementWithStatement(statementNodeA, statementNodeB, substitutions, localContextA, localContextB) {
-  substitutionA = null;
-
   const nonTerminalNodeA = statementNodeA, ///
         nonTerminalNodeB = statementNodeB, ///
         nonTerminalNodeAChildNodes = nonTerminalNodeA.getChildNodes(),

package/src/unify/metavariableWithFrame.js

@@ -26,8 +26,8 @@ export default function unifyMetavariableWithFrame(metavariableNodeA, frameNodeB
       metavariableUnifiedWithFrame = true;
     } else {
       const frameNode = frameNodeB, ///
-            metavariableNode = metavariableNodeA, ///
-            frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromFrameNodeAndMetavariableNode(frameNode, metavariableNode, localContextA, localContextB),
+            metavariable = metavariableA, ///
+            frameForMetavariableSubstitution = FrameForMetavariableSubstitution.fromFrameAndMetavariable(frame, metavariable, localContextA, localContextB),
             substitution = frameForMetavariableSubstitution;  ///
 
       substitutions.addSubstitution(substitution, localContextA, localContextB);

package/src/utilities/brackets.js

@@ -1,9 +1,8 @@
 "use strict";
 
-import bracketedTermNode from "../node/term/bracketed";
-import bracketedStatementNode from "../node/statement/bracketed";
-
 import { nodeQuery } from "../utilities/query";
+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!"),

package/src/utilities/node.js

@@ -6,12 +6,10 @@ import { nodeQuery } from "../utilities/query";
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
 import { VARIABLE_RULE_NAME,
          METAVARIABLE_RULE_NAME,
-         SUBSTITUTION_RULE_NAME,
          UNQUALIFIED_STATEMENT_RULE_NAME,
          CONSTRUCTOR_DECLARATION_RULE_NAME } from "../ruleNames";
 import { variableTokensFromVariableString,
          metavariableTokensFromMetavariableString,
-         substitutionTokensFromSubstitutionString,
          unqualifiedStatementTokensFromUnqualifiedStatementString,
          constructorDeclarationTokensFromConstructorDeclarationString } from "../utilities/tokens";
 
@@ -24,11 +22,10 @@ const termNodeQuery = nodeQuery("/constructorDeclaration/term"),
       statementNodeQuery = nodeQuery("/unqualifiedStatement/statement");
 
 export function termNodeFromTermString(termString, lexer, parser) {
-  const constructorDeclarationString = `Constructor ${termString}
-`,
+  const constructorDeclarationString = constructorDeclarationStringFromTermString(termString),
         constructorDeclarationTokens = constructorDeclarationTokensFromConstructorDeclarationString(constructorDeclarationString, lexer),
         constructorDeclarationNode = constructorDeclarationNodeFromConstructorDeclarationTokens(constructorDeclarationTokens, parser),
-        termNode = termNodeQuery(constructorDeclarationNode, constructorDeclarationNode);
+        termNode = termNodeFromConstructorDeclarationNode(constructorDeclarationNode);
 
   return termNode;
 }
@@ -41,15 +38,40 @@ export function variableNodeFromVariableString(variableString, lexer, parser) {
 }
 
 export function statementNodeFromStatementString(statementString, lexer, parser) {
-  const unqualifiedStatementString = `${statementString}
-`,
+  const unqualifiedStatementString =unqualifiedStatementStringFromStatementString(statementString),
         unqualifiedStatementTokens = unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer),
         unqualifiedStatementNode = unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser),
-        statementNode = statementNodeQuery(unqualifiedStatementNode);
+        statementNode = statementNodeFromUnqualifiedStatementNode(unqualifiedStatementNode);
+
+  return statementNode;
+}
+
+export function termNodeFromConstructorDeclarationNode(constructorDeclarationNode) {
+  const termNode = termNodeQuery(constructorDeclarationNode, constructorDeclarationNode);
+
+  return termNode;
+}
+
+export function statementNodeFromUnqualifiedStatementNode(unqualifiedStatementNode) {
+  const statementNode = statementNodeQuery(unqualifiedStatementNode);
 
   return statementNode;
 }
 
+export function constructorDeclarationStringFromTermString(termString) {
+  const constructorDeclarationString = `Constructor ${termString}
+`;
+
+  return constructorDeclarationString;
+}
+
+export function unqualifiedStatementStringFromStatementString(statementString) {
+  const unqualifiedStatementString = `${statementString}
+`;
+
+  return unqualifiedStatementString;
+}
+
 export function metavariableNodeFromMetavariableString(metavariableString, lexer, parser) {
   const metavariableTokens = metavariableTokensFromMetavariableString(metavariableString, lexer),
         metavariableNode = metavariableNodeFromMetavariableTokens(metavariableTokens, parser);
@@ -57,13 +79,6 @@ export function metavariableNodeFromMetavariableString(metavariableString, lexer
   return metavariableNode;
 }
 
-export function substitutionNodeFromSubstitutionString(substitutionString, lexer, parser) {
-  const substitutionTokens = substitutionTokensFromSubstitutionString(substitutionString, lexer),
-        substitutionNode = substitutionNodeFromSubstitutionTokens(substitutionTokens, parser);
-
-  return substitutionNode;
-}
-
 export function variableNodeFromVariableTokens(variableTokens, parser) {
   const ruleName = VARIABLE_RULE_NAME,
         variableNode = nodeFromTokensRuleNameAndParser(variableTokens, ruleName, parser);
@@ -78,13 +93,6 @@ export function metavariableNodeFromMetavariableTokens(metavariableTokens, parse
   return metavariableNode;
 }
 
-export function substitutionNodeFromSubstitutionTokens(substitutionTokens, parser) {
-  const ruleName = SUBSTITUTION_RULE_NAME,
-        substitutionNode = nodeFromTokensRuleNameAndParser(substitutionTokens, ruleName, parser);
-
-  return substitutionNode;
-}
-
 export function unqualifiedStatementNodeFromUnqualifiedStatementTokens(unqualifiedStatementTokens, parser) {
   const tokens = unqualifiedStatementTokens,  ///
         ruleName = UNQUALIFIED_STATEMENT_RULE_NAME,

package/src/utilities/string.js

@@ -11,17 +11,9 @@ export function trim(string) {
 export function nodeAsString(node, tokens) {
   let string;
 
-  const nodeTerminalNode = node.isTerminalNode();
-
-  if (nodeTerminalNode) {
-    const terminalNode = node;  ///
-
-    string = terminalNodeAsString(terminalNode);
-  } else {
-    const nonTerminalNode = node; ///
+  tokens = nodeAsTokens(node, tokens);  ///
 
-    string = nonTerminalNodeAsString(nonTerminalNode, tokens);
-  }
+  string = tokensAsString(tokens);
 
   return string;
 }
@@ -40,14 +32,46 @@ export function nodesAsString(nodes, tokens) {
   return string;
 }
 
-function terminalNodeAsString(terminalNode) {
-  const content = terminalNode.getContent(),
-        string = content; ///
+export function tokensAsString(tokens) {
+  const string = tokens.reduce((string, token) => {
+    const content = token.getContent();
+
+    string = `${string}${content}`;
+
+    return string;
+  }, EMPTY_STRING);
 
   return string;
 }
 
-function nonTerminalNodeAsString(nonTerminalNode, tokens) {
+export function nodeAsTokens(node, tokens) {
+  const nodeTerminalNode = node.isTerminalNode();
+
+  if (nodeTerminalNode) {z
+    const terminalNode = node;  ///
+
+    tokens = terminalNodeAsTokens(terminalNode, tokens);
+  } else {
+    const nonTerminalNode = node; ///
+
+    tokens = nonTerminalNodeAsTokens(nonTerminalNode, tokens);
+  }
+
+  return tokens;
+}
+
+function terminalNodeAsTokens(terminalNode, tokens) {
+  const significantToken = terminalNode.getSignificantToken(),
+        token = significantToken; ///
+
+  tokens = [  ///
+    token
+  ];
+
+  return tokens;
+}
+
+function nonTerminalNodeAsTokens(nonTerminalNode, tokens) {
   const lastSignificantTokenIndex = nonTerminalNode.getLastSignificantTokenIndex(tokens),
         firstSignificantTokenIndex = nonTerminalNode.getFirstSignificantTokenIndex(tokens),
         start = firstSignificantTokenIndex, ///
@@ -55,13 +79,5 @@ function nonTerminalNodeAsString(nonTerminalNode, tokens) {
 
   tokens = tokens.slice(start, end);  ///
 
-  const string = tokens.reduce((string, token) => {
-    const content = token.getContent();
-
-    string = `${string}${content}`;
-
-    return string;
-  }, EMPTY_STRING);
-
-  return string;
+  return tokens;
 }

package/src/utilities/tokens.js

@@ -1,10 +1,12 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
 import { lexersUtilities } from "occam-custom-grammars";
 
 import { combinedCustomGrammarFromNothing } from "./customGrammar";
 
-const { nominalLexerFromCombinedCustomGrammar } = lexersUtilities;
+const { front } = arrayUtilities,
+      { nominalLexerFromCombinedCustomGrammar } = lexersUtilities;
 
 const combinedCustomGrammar = combinedCustomGrammarFromNothing(),
       nominalLexer = nominalLexerFromCombinedCustomGrammar(combinedCustomGrammar);
@@ -23,13 +25,6 @@ export function metavariableTokensFromMetavariableString(metavariableString, lex
   return metavariableTokens;
 }
 
-export function substitutionTokensFromSubstitutionString(substitutionString, lexer) {
-  const substitutionContent = `${substitutionString}`,
-        substitutionTokens = tokensFromContentAndLexer(substitutionContent, lexer);
-
-  return substitutionTokens;
-}
-
 export function unqualifiedStatementTokensFromUnqualifiedStatementString(unqualifiedStatementString, lexer) {
   const content = unqualifiedStatementString,  ///
         unqualifiedStatementTokens = tokensFromContentAndLexer(content, lexer);
@@ -44,6 +39,20 @@ export function constructorDeclarationTokensFromConstructorDeclarationString(con
   return constructorDeclarationTokens;
 }
 
+export function termTokensFromConstructorDeclarationTokens(constructorDeclarationTokens) {
+  const frontConstructorDeclarationTokens = front(constructorDeclarationTokens),
+        termTokens = frontConstructorDeclarationTokens;  ///
+
+  return termTokens;
+}
+
+export function statementTokensFromUnqualifiedStatementTokens(unqualifiedStatementTokens) {
+  const frontUnqualifiedStatementTokens = front(unqualifiedStatementTokens),
+        statementTokens = frontUnqualifiedStatementTokens;  ///
+
+  return statementTokens;
+}
+
 function tokensFromContentAndLexer(content, lexer = nominalLexer) {
   const tokens = lexer.tokenise(content);