occam-furtle 3.0.366 → 3.0.370

package/src/example/furtle/entries.js

@@ -1,14 +1,14 @@
 "use strict";
 
 const LATIN = "[\\p{Script=Latin}]",
-      DECIMAL = "[0-9]";
+  DECIMAL = "[0-9]";
 
 const entries = [
   {
     "bracket": "^(?:\\{|\\})"
   },
   {
-    "primary-keyword": "^return"
+    "primary-keyword": "^(?:export|import|from|return)"
   },
   {
     "secondary-keyword": "^(?:as|if|else)"

package/src/node/{procedure/anoymous.js → anoymousProcedure.js}

@@ -1,10 +1,10 @@
 "use strict";
 
-import ProcedureNode from "../../node/procedure";
+import { NonTerminalNode } from "occam-languages";
 
-import { TYPE_RULE_NAME, PARAMETERS_RULE_NAME, RETURN_BLOCK_RULE_NAME } from "../../ruleNames";
+import { TYPE_RULE_NAME, PARAMETERS_RULE_NAME, RETURN_BLOCK_RULE_NAME } from "../ruleNames";
 
-export default class AnonymousProcedureNode extends ProcedureNode {
+export default class AnonymousProcedureNode extends NonTerminalNode {
   getTypeNode() {
     const ruleName = TYPE_RULE_NAME,
           typeNode = this.getNodeByRuleName(ruleName);
@@ -26,5 +26,5 @@ export default class AnonymousProcedureNode extends ProcedureNode {
     return returnBlockNode;
   }
 
-  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return ProcedureNode.fromRuleNameChildNodesOpacityAndPrecedence(AnonymousProcedureNode, ruleName, childNodes, opacity, precedence); }
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(AnonymousProcedureNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/procedure.js

@@ -2,6 +2,36 @@
 
 import { NonTerminalNode } from "occam-languages";
 
+import { TYPE_RULE_NAME, LABEL_RULE_NAME, PARAMETERS_RULE_NAME, RETURN_BLOCK_RULE_NAME } from "../ruleNames";
+
 export default class ProcedureNode extends NonTerminalNode {
-  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
+  getTypeNode() {
+    const ruleName = TYPE_RULE_NAME,
+          labelNode = this.getNodeByRuleName(ruleName);
+
+    return labelNode;
+  }
+
+  getLabelNode() {
+    const ruleName = LABEL_RULE_NAME,
+          labelNode = this.getNodeByRuleName(ruleName);
+
+    return labelNode;
+  }
+
+  getParametersNode() {
+    const ruleName = PARAMETERS_RULE_NAME,
+          parametersNode = this.getNodeByRuleName(ruleName);
+
+    return parametersNode;
+  }
+
+  getReturnBlockNode() {
+    const ruleName = RETURN_BLOCK_RULE_NAME,
+          returnBlockNode = this.getNodeByRuleName(ruleName);
+
+    return returnBlockNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ProcedureNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/node/returnBlock.js

@@ -2,7 +2,7 @@
 
 import { NonTerminalNode } from "occam-languages";
 
-import { STEP_RULE_NAME, NONSENSE_RULE_NAME, RETURN_STATEMENT_RULE_NAME } from "../ruleNames";
+import { STATEMENT_RULE_NAME, NONSENSE_RULE_NAME, RETURN_STATEMENT_RULE_NAME } from "../ruleNames";
 
 export default class ReturnBlockNode extends NonTerminalNode {
   isNonsensical() {
@@ -13,11 +13,11 @@ export default class ReturnBlockNode extends NonTerminalNode {
     return nonsensical;
   }
 
-  getStepNodes() {
-    const ruleName = STEP_RULE_NAME,
-          stepNodes = this.getNodesByRuleName(ruleName);
+  getStatementNodes() {
+    const ruleName = STATEMENT_RULE_NAME,
+          statementNodes = this.getNodesByRuleName(ruleName);
 
-    return stepNodes;
+    return statementNodes;
   }
 
   getNonsenseNodes() {

package/src/node/returnStatement.js

@@ -0,0 +1,16 @@
+"use strict";
+
+import { NonTerminalNode } from "occam-languages";
+
+import { VALUE_RULE_NAME } from "../ruleNames";
+
+export default class ReturnStatementNode extends NonTerminalNode {
+  getValueNode() {
+    const ruleName = VALUE_RULE_NAME,
+          valueNode = this.getNodeByRuleName(ruleName);
+
+    return valueNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(ReturnStatementNode, ruleName, childNodes, opacity, precedence); }
+}

package/src/node/statement.js

@@ -2,6 +2,29 @@
 
 import { NonTerminalNode } from "occam-languages";
 
+import { ARRAY_ASSIGNMENT_RULE_NAME, OBJECT_ASSIGNMENT_RULE_NAME, VARIABLE_ASSIGNMENTS_RULE_NAME } from "../ruleNames"
+
 export default class StatementNode extends NonTerminalNode {
-  static fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(Class, ruleName, childNodes, opacity, precedence); }
+  getArrayAssignmentNode() {
+    const ruleName = ARRAY_ASSIGNMENT_RULE_NAME,
+          arrayAssignmentNode = this.getNodeByRuleName(ruleName);
+
+    return arrayAssignmentNode;
+  }
+
+  getObjectAssignmentNode() {
+    const ruleName = OBJECT_ASSIGNMENT_RULE_NAME,
+          objectAssignmentNode = this.getNodeByRuleName(ruleName);
+
+    return objectAssignmentNode;
+  }
+
+  getVariableAssignmentsNode() {
+    const ruleName = VARIABLE_ASSIGNMENTS_RULE_NAME,
+          variableAssignmentsNode = this.getNodeByRuleName(ruleName);
+
+    return variableAssignmentsNode;
+  }
+
+  static fromRuleNameChildNodesOpacityAndPrecedence(ruleName, childNodes, opacity, precedence) { return NonTerminalNode.fromRuleNameChildNodesOpacityAndPrecedence(StatementNode, ruleName, childNodes, opacity, precedence); }
 }

package/src/nonTerminalNodeMap.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import StepNode from "./node/step";
 import SomeNode from "./node/some";
 import TermNode from "./node/term";
 import TypeNode from "./node/type";
@@ -21,8 +20,10 @@ import LengthOfNode from "./node/lengthOf";
 import PrimitiveNode from "./node/primitive";
 import ReferenceNode from "./node/reference";
 import ParameterNode from "./node/parameter";
+import StatementNode from "./node/statement";
 import NodeQueryNode from "./node/nodeQuery";
 import ToIntegerNode from "./node/toInteger";
+import ProcedureNode from "./node/procedure";
 import TryIntegerNode from "./node/tryInteger";
 import NodesQueryNode from "./node/nodesQuery";
 import ExpressionNode from "./node/expression";
@@ -35,16 +36,14 @@ import ProcedureCallNode from "./node/procedureCall";
 import NamedBindingsNode from "./node/bindings/named";
 import BracketedTermNode from "./node/term/bracketed";
 import ComparisonTermNode from "./node/term/comparison";
-import ReturnStatementNode from "./node/statement/return";
+import ReturnStatementNode from "./node/returnStatement";
 import ArrayAssignmentNode from "./node/assignment/array";
 import ObjectAssignmentNode from "./node/assignment/object";
-import AnonymousProcedureNode from "./node/procedure/anoymous";
+import AnonymousProcedureNode from "./node/anoymousProcedure";
 import VariableAssignmentNode from "./node/assignment/variable";
 import VariableAssignmentsNode from "./node/assignments/variable";
-import ProcedureDeclarationNode from "./node/declaration/procedure";
 
-import { STEP_RULE_NAME,
-         SOME_RULE_NAME,
+import { SOME_RULE_NAME,
          TERM_RULE_NAME,
          TYPE_RULE_NAME,
          TERMS_RULE_NAME,
@@ -64,6 +63,8 @@ import { STEP_RULE_NAME,
          PRIMITIVE_RULE_NAME,
          REFERENCE_RULE_NAME,
          PARAMETER_RULE_NAME,
+         STATEMENT_RULE_NAME,
+         PROCEDURE_RULE_NAME,
          NODE_QUERY_RULE_NAME,
          EXPRESSION_RULE_NAME,
          PARAMETERS_RULE_NAME,
@@ -83,11 +84,9 @@ import { STEP_RULE_NAME,
          OBJECT_ASSIGNMENT_RULE_NAME,
          VARIABLE_ASSIGNMENT_RULE_NAME,
          ANONYMOUS_PROCEDURE_RULE_NAME,
-         VARIABLE_ASSIGNMENTS_RULE_NAME,
-         PROCEDURE_DECLARATION_RULE_NAME } from "./ruleNames";
+         VARIABLE_ASSIGNMENTS_RULE_NAME } from "./ruleNames";
 
 const NonTerminalNodeMap = {
-  [STEP_RULE_NAME]: StepNode,
   [SOME_RULE_NAME]: SomeNode,
   [TERM_RULE_NAME]: TermNode,
   [TYPE_RULE_NAME]: TypeNode,
@@ -107,7 +106,9 @@ const NonTerminalNodeMap = {
   [LENGTH_OF_RULE_NAME]: LengthOfNode,
   [PRIMITIVE_RULE_NAME]: PrimitiveNode,
   [REFERENCE_RULE_NAME]: ReferenceNode,
+  [STATEMENT_RULE_NAME]: StatementNode,
   [PARAMETER_RULE_NAME]: ParameterNode,
+  [PROCEDURE_RULE_NAME]: ProcedureNode,
   [TO_INTEGER_RULE_NAME]: ToIntegerNode,
   [NODE_QUERY_RULE_NAME]: NodeQueryNode,
   [EXPRESSION_RULE_NAME]: ExpressionNode,
@@ -127,8 +128,7 @@ const NonTerminalNodeMap = {
   [OBJECT_ASSIGNMENT_RULE_NAME]: ObjectAssignmentNode,
   [ANONYMOUS_PROCEDURE_RULE_NAME]: AnonymousProcedureNode,
   [VARIABLE_ASSIGNMENT_RULE_NAME]: VariableAssignmentNode,
-  [VARIABLE_ASSIGNMENTS_RULE_NAME]: VariableAssignmentsNode,
-  [PROCEDURE_DECLARATION_RULE_NAME]: ProcedureDeclarationNode
+  [VARIABLE_ASSIGNMENTS_RULE_NAME]: VariableAssignmentsNode
 };
 
 export default NonTerminalNodeMap;

package/src/preamble.js

@@ -1,6 +1,5 @@
 "use strict";
 
-import Step from "./element/step";
 import Some from "./element/some";
 import Term from "./element/term";
 import Type from "./element/type";
@@ -22,6 +21,7 @@ import Procedure from "./element/procedure";
 import NodeQuery from "./element/nodeQuery";
 import Parameter from "./element/parameter";
 import ToInteger from "./element/toInteger";
+import Statement from "./element/statement";
 import TryInteger from "./element/tryInteger";
 import Parameters from "./element/parameters";
 import NodesQuery from "./element/nodesQuery";
@@ -35,9 +35,8 @@ import NamedBindings from "./element/bindings/named";
 import BracketedTerm from "./element/term/bracketed";
 import ComparisonTerm from "./element/term/comparison";
 import ArrayAssigment from "./element/assignment/array";
-import ReturnStatement from "./element/statement/return";
+import ReturnStatement from "./element/returnStatement";
 import ObjectAssignment from "./element/assignment/object";
-import AnonymousProcedure from "./element/procedure/anonymous";
+import AnonymousProcedure from "./element/anonymousProcedure";
 import VariableAssignment from "./element/assignment/variable";
 import VariableAssignments from "./element/assignments/variable";
-import ProcedureDeclaration from "./element/declaration/procedure";

package/src/process/instantiate.js

@@ -0,0 +1,194 @@
+"use strict";
+
+import { ruleFromRuleName } from "../utilities/bnf";
+import { TERM_RULE_NAME,
+         TYPE_RULE_NAME,
+         FRAME_RULE_NAME,
+         LABEL_RULE_NAME,
+         PREMISE_RULE_NAME,
+         VARIABLE_RULE_NAME,
+         EQUALITY_RULE_NAME,
+         PROPERTY_RULE_NAME,
+         JUDGEMENT_RULE_NAME,
+         DEDUCTION_RULE_NAME,
+         PARAMETER_RULE_NAME,
+         STATEMENT_RULE_NAME,
+         REFERENCE_RULE_NAME,
+         SIGNATURE_RULE_NAME,
+         GENERATOR_RULE_NAME,
+         COMBINATOR_RULE_NAME,
+         CONCLUSION_RULE_NAME,
+         HYPOTHESIS_RULE_NAME,
+         CONSTRAINT_RULE_NAME,
+         TYPE_PREFIX_RULE_NAME,
+         SUPPOSITION_RULE_NAME,
+         CONSTRUCTOR_RULE_NAME,
+         EQUIVALENCE_RULE_NAME,
+         METAVARIABLE_RULE_NAME,
+         TYPE_ASSERTION_RULE_NAME,
+         DEFINED_ASSERTION_RULE_NAME,
+         TERM_SUBSTITUTION_RULE_NAME,
+         PROPERTY_ASSERTION_RULE_NAME,
+         SUBPROOF_ASSERTION_RULE_NAME,
+         FRAME_SUBSTITUTION_RULE_NAME,
+         PROCEDURE_REFERENCE_RULE_NAME,
+         CONTAINED_ASSERTION_RULE_NAME,
+         SIGNATURE_ASSERTION_RULE_NAME,
+         IMPLICIT_ASSUMPTION_RULE_NAME,
+         STATEMENT_SUBSTITUTION_RULE_NAME,
+         REFERENCE_SUBSTITUTION_RULE_NAME } from "../ruleNames";
+
+const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
+      typePlaceholderRule = ruleFromRuleName(TYPE_RULE_NAME),
+      framePlaceholderRule = ruleFromRuleName(FRAME_RULE_NAME),
+      labelPlaceholderRule = ruleFromRuleName(LABEL_RULE_NAME),
+      premisePlaceholderRule = ruleFromRuleName(PREMISE_RULE_NAME),
+      variablePlaceholderRule = ruleFromRuleName(VARIABLE_RULE_NAME),
+      equalityPlaceholderRule = ruleFromRuleName(EQUALITY_RULE_NAME),
+      propertyPlaceholderRule = ruleFromRuleName(PROPERTY_RULE_NAME),
+      judgementPlaceholderRule = ruleFromRuleName(JUDGEMENT_RULE_NAME),
+      generatorPlaceholderRule = ruleFromRuleName(GENERATOR_RULE_NAME),
+      deductionPlaceholderRule = ruleFromRuleName(DEDUCTION_RULE_NAME),
+      parameterPlaceholderRule = ruleFromRuleName(PARAMETER_RULE_NAME),
+      statementPlaceholderRule = ruleFromRuleName(STATEMENT_RULE_NAME),
+      referencePlaceholderRule = ruleFromRuleName(REFERENCE_RULE_NAME),
+      signaturePlaceholderRule = ruleFromRuleName(SIGNATURE_RULE_NAME),
+      constraintPlaceholderRule = ruleFromRuleName(CONSTRAINT_RULE_NAME),
+      combinatorPlaceholderRule = ruleFromRuleName(COMBINATOR_RULE_NAME),
+      conclusionPlaceholderRule = ruleFromRuleName(CONCLUSION_RULE_NAME),
+      hypothesisPlaceholderRule = ruleFromRuleName(HYPOTHESIS_RULE_NAME),
+      typePrefixPlaceholderRule = ruleFromRuleName(TYPE_PREFIX_RULE_NAME),
+      suppositionPlaceholderRule = ruleFromRuleName(SUPPOSITION_RULE_NAME),
+      constructorPlaceholderRule = ruleFromRuleName(CONSTRUCTOR_RULE_NAME),
+      equivalencePlaceholderRule = ruleFromRuleName(EQUIVALENCE_RULE_NAME),
+      metavariablePlaceholderRule = ruleFromRuleName(METAVARIABLE_RULE_NAME),
+      typeAssertionPlaceholderRule = ruleFromRuleName(TYPE_ASSERTION_RULE_NAME),
+      definedAssertionPlaceholderRule = ruleFromRuleName(DEFINED_ASSERTION_RULE_NAME),
+      termSubstitutionPlaceholderRule = ruleFromRuleName(TERM_SUBSTITUTION_RULE_NAME),
+      subproofAssertionlaceholderRule = ruleFromRuleName(SUBPROOF_ASSERTION_RULE_NAME),
+      propertyAssertionPlaceholderRule = ruleFromRuleName(PROPERTY_ASSERTION_RULE_NAME),
+      frameSubstitutionPlaceholderRule = ruleFromRuleName(FRAME_SUBSTITUTION_RULE_NAME),
+      procedureReferencelaceholderRule = ruleFromRuleName(PROCEDURE_REFERENCE_RULE_NAME),
+      containedAssertionPlaceholderRule = ruleFromRuleName(CONTAINED_ASSERTION_RULE_NAME),
+      signatureAssertionPlaceholderRule = ruleFromRuleName(SIGNATURE_ASSERTION_RULE_NAME),
+      implicitAssumptionPlaceholderRule = ruleFromRuleName(IMPLICIT_ASSUMPTION_RULE_NAME),
+      statementSubstitutionPlaceholderRule = ruleFromRuleName(STATEMENT_SUBSTITUTION_RULE_NAME),
+      referenceSubstitutionPlaceholderRule = ruleFromRuleName(REFERENCE_SUBSTITUTION_RULE_NAME);
+
+export function instantiatePremise(string, context) {
+  string = `${string}
+`;  ///
+
+  return instantiate(premisePlaceholderRule, string, context);
+}
+
+export function instantiateDeduction(string, context) {
+  string = `${string}
+`;  ///
+
+  return instantiate(deductionPlaceholderRule, string, context);
+}
+
+export function instantiateConclusion(string, context) {
+  string = `${string}
+`;  ///
+
+  return instantiate(conclusionPlaceholderRule, string, context);
+}
+
+export function instantiateSupposition(string, context) {
+  string = `${string}
+`;  ///
+
+  return instantiate(suppositionPlaceholderRule, string, context);
+}
+
+export function instantiateTerm(string, context) { return instantiate(termPlaceholderRule, string, context); }
+
+export function instantiateType(string, context) { return instantiate(typePlaceholderRule, string, context); }
+
+export function instantiateFrame(string, context) { return instantiate(framePlaceholderRule, string, context); }
+
+export function instantiateLabel(string, context) { return instantiate(labelPlaceholderRule, string, context); }
+
+export function instantiateVariable(string, context) { return instantiate(variablePlaceholderRule, string, context); }
+
+export function instantiateEquality(string, context) { return instantiate(equalityPlaceholderRule, string, context); }
+
+export function instantiateProperty(string, context) { return instantiate(propertyPlaceholderRule, string, context); }
+
+export function instantiateGenerator(string, context) { return instantiate(generatorPlaceholderRule, string, context); }
+
+export function instantiateJudgement(string, context) { return instantiate(judgementPlaceholderRule, string, context); }
+
+export function instantiateParameter(string, context) { return instantiate(parameterPlaceholderRule, string, context); }
+
+export function instantiateStatement(string, context) { return instantiate(statementPlaceholderRule, string, context); }
+
+export function instantiateReference(string, context) { return instantiate(referencePlaceholderRule, string, context); }
+
+export function instantiateSignature(string, context) { return instantiate(signaturePlaceholderRule, string, context); }
+
+export function instantiateCombinator(string, context) { return instantiate(combinatorPlaceholderRule, string, context); }
+
+export function instantiateHypothesis(string, context) { return instantiate(hypothesisPlaceholderRule, string, context); }
+
+export function instantiateConstraint(string, context) { return instantiate(constraintPlaceholderRule, string, context); }
+
+export function instantiateTypePrefix(string, context) { return instantiate(typePrefixPlaceholderRule, string, context); }
+
+export function instantiateConstructor(string, context) { return instantiate(constructorPlaceholderRule, string, context); }
+
+export function instantiateEquivalence(string, context) { return instantiate(equivalencePlaceholderRule, string, context); }
+
+export function instantiateMetavariable(string, context) { return instantiate(metavariablePlaceholderRule, string, context); }
+
+export function instantiateTypeAssertion(string, context) { return instantiate(typeAssertionPlaceholderRule, string, context); }
+
+export function instantiateDefinedAssertion(string, context) { return instantiate(definedAssertionPlaceholderRule, string, context); }
+
+export function instantiateTermSubstitution(string, context) { return instantiate(termSubstitutionPlaceholderRule, string, context); }
+
+export function instantiateSubproofAssertion(string, context) { return instantiate(subproofAssertionlaceholderRule, string, context); }
+
+export function instantiatePropertyAssertion(string, context) { return instantiate(propertyAssertionPlaceholderRule, string, context); }
+
+export function instantiateFrameSubstitution(string, context) { return instantiate(frameSubstitutionPlaceholderRule, string, context); }
+
+export function instantiateProcedureReference(string, context) { return instantiate(procedureReferencelaceholderRule, string, context); }
+
+export function instantiateContainedAssertion(string, context) { return instantiate(containedAssertionPlaceholderRule, string, context); }
+
+export function instantiateSignatureAssertion(string, context) { return instantiate(signatureAssertionPlaceholderRule, string, context); }
+
+export function instantiateImplicitAssumption(string, context) { return instantiate(implicitAssumptionPlaceholderRule, string, context); }
+
+export function instantiateStatementSubstitution(string, context) { return instantiate(statementSubstitutionPlaceholderRule, string, context); }
+
+export function instantiateReferenceSubstitution(string, context) { return instantiate(referenceSubstitutionPlaceholderRule, string, context); }
+
+function instantiate(placeholderRule, string, context) {
+  let node;
+
+  const lexer = context.getLexer(),
+        parser = context.getParser(),
+        content = `${string}
+`,
+        tokens = lexer.tokenise(content);
+
+  context.setTokens(tokens);
+
+  const startRule = placeholderRule;  ///
+
+  node = parser.parse(tokens, startRule);
+
+  const nonTerminalNode = node; ///
+
+  nonTerminalNode.someChildNode((childNode) => {
+    node = childNode; ///
+
+    return true;
+  });
+
+  return node;
+}

package/src/process/verify.js

@@ -3,12 +3,12 @@
 import { SimplePass } from "occam-languages";
 import { queryUtilities } from "occam-query";
 
-import { errorFromErrorNode, procedureDeclarationFromProcedureDeclarationNode } from "../utilities/element";
+import { errorFromErrorNode, procedureFromProcedureNode } from "../utilities/element";
 
 const { nodeQuery } = queryUtilities;
 
 const errorNodeQuery = nodeQuery("/error"),
-      procedureDeclarationNodeQuery = nodeQuery("/procedureDeclaration");
+      procedureNodeQuery = nodeQuery("/procedure");
 
 class TopLevelPass extends SimplePass {
   static maps = [
@@ -28,14 +28,14 @@ class TopLevelPass extends SimplePass {
       }
     },
     {
-      nodeQuery: procedureDeclarationNodeQuery,
-      run: (procedureDeclarationNode, context) => {
+      nodeQuery: procedureNodeQuery,
+      run: (procedureNode, context) => {
         let success = false;
 
-        const procedureDeclaration = procedureDeclarationFromProcedureDeclarationNode(procedureDeclarationNode, context),
-              procedureDeclarationVerifies = procedureDeclaration.verify(context);
+        const procedure = procedureFromProcedureNode(procedureNode, context),
+              procedureVerifies = procedure.verify(context);
 
-        if (procedureDeclarationVerifies) {
+        if (procedureVerifies) {
           success = true;
         }
 

package/src/ruleNames.js

@@ -1,6 +1,5 @@
 "use strict";
 
-export const STEP_RULE_NAME = "step";
 export const SOME_RULE_NAME = "some";
 export const TERM_RULE_NAME = "term";
 export const TYPE_RULE_NAME = "type";
@@ -17,6 +16,8 @@ export const VARIABLE_RULE_NAME = "variable";
 export const NONSENSE_RULE_NAME = "nonsense";
 export const DOCUMENT_RULE_NAME = "document";
 export const BINDINGS_RULE_NAME = "bindings";
+export const STATEMENT_RULE_NAME = "statement";
+export const PROCEDURE_RULE_NAME = "procedure";
 export const LENGTH_OF_RULE_NAME = "lengthOf";
 export const PRIMITIVE_RULE_NAME = "primitive";
 export const REFERENCE_RULE_NAME = "reference";
@@ -41,5 +42,4 @@ export const OBJECT_ASSIGNMENT_RULE_NAME = "objectAssignment";
 export const VARIABLE_ASSIGNMENT_RULE_NAME = "variableAssignment";
 export const ANONYMOUS_PROCEDURE_RULE_NAME = "anonymousProcedure";
 export const VARIABLE_ASSIGNMENTS_RULE_NAME = "variableAssignments";
-export const PROCEDURE_DECLARATION_RULE_NAME = "procedureDeclaration";
 

package/src/utilities/context.js

@@ -1,6 +1,7 @@
 "use strict";
 
 import BlockContext from "../context/block";
+import LiteralContext from "../context/literal";
 
 import { isContextBlockContext } from "../context/block";
 
@@ -18,6 +19,14 @@ export function confine(innerFunction, variables, context) {
   return innerFunction(context);
 }
 
+export function instantiate(innerFunction, context) {
+  const literalContext = LiteralContext.fromNothing(context);
+
+  context = literalContext;  ///
+
+  return innerFunction(context);
+}
+
 function freeContext(context) {
   let contextBlockContext = isContextBlockContext(context);