occam-verify-cli 1.0.776 → 1.0.785

package/src/element/assumption.js

@@ -3,8 +3,11 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { descend, instantiate } from "../utilities/context";
+import { unifyAssumption } from "../process/unify";
 import { instantiateAssumption } from "../process/instantiate";
+import { assumptionFromAssumptionNode } from "../utilities/element";
+import { assumptionStringFromStatementAndReference } from "../utilities/string";
+import { join, descend, simplify, reconcile, instantiate } from "../utilities/context";
 
 export default define(class Assumption extends Element {
   constructor(context, string, node, reference, statement) {
@@ -33,6 +36,14 @@ export default define(class Assumption extends Element {
 
   getTopLevelMetaAssertion() { return this.reference.getTopLevelMetaAssertion(); }
 
+  isEqualTo(assumption) {
+    const assumptionNode = assumption.getNode(),
+          assumptionNodeMatches = this.matchAssumptionNode(assumptionNode),
+          equalTo = assumptionNodeMatches;  ///
+
+    return equalTo;
+  }
+
   matchAssumptionNode(assumptionNode) {
     const node = assumptionNode, ///
           nodeMatches = this.matchNode(node),
@@ -41,46 +52,26 @@ export default define(class Assumption extends Element {
     return assumptionNodeMatches;
   }
 
-  compareSubstitution(substitution, context) {
-    let comparesToSubstituion = false;
-
-    const assumptionString = this.getString(),  ///
-          substitutionString = substitution.getString();
-
-    context.trace(`Comparing the '${assumptionString}' assumption to the '${substitutionString}' substitution...`);
-
-    const statement = substitution.getStatement(),
-          metavariableName = substitution.getMetavariableName(),
-          statementEqualToStatement = this.statement.isEqualTo(statement),
-          referenceMetavariableComparesToMetavariable = this.reference.compareMetavariableName(metavariableName);
-
-    if (statementEqualToStatement && referenceMetavariableComparesToMetavariable) {
-      comparesToSubstituion = true;
-    }
-
-    if (comparesToSubstituion) {
-      context.debug(`...compared the '${substitutionString}' assumption to the '${assumptionString}' substitution.`);
-    }
-
-    return comparesToSubstituion;
-  }
-
-  findValidAssumption(context) {
+  findValidAssumption(context, metaLevel = false) {
     const assumptionNode = this.getAssumptionNode(),
-          assumption = context.findAssumptionByAssumptionNode(assumptionNode),
+          assumption = context.findAssumptionByAssumptionNode(assumptionNode, metaLevel),
           validAssumption = assumption;  ///
 
     return validAssumption;
   }
 
-  validate(context) {
+  validate(context, metaLevel = false) {
     let assumption = null;
 
+    if (metaLevel) {
+      context = this.getContext();
+    }
+
     const assumptionString = this.getString();  ///
 
     context.trace(`Validating the '${assumptionString}' assumption...`);
 
-    const validAssumption = this.findValidAssumption(context);
+    const validAssumption = this.findValidAssumption(context, metaLevel);
 
     if (validAssumption) {
       assumption = validAssumption; ///
@@ -115,7 +106,7 @@ export default define(class Assumption extends Element {
       if (validates) {
         assumption = this;  ///
 
-        context.addAssumption(assumption);
+        context.addAssumption(assumption, metaLevel);
 
         context.debug(`...validated the '${assumptionString}' assumption.`);
       }
@@ -208,7 +199,6 @@ export default define(class Assumption extends Element {
     const assumptionString = this.getString();  ///
 
     context.trace(`Validating the '${assumptionString}' derived assumption...`);
-
     const topLevelMetaAssertion = this.getTopLevelMetaAssertion();
 
     if (topLevelMetaAssertion !== null) {
@@ -224,6 +214,39 @@ export default define(class Assumption extends Element {
     return validatesWhenDerived;
   }
 
+  unifyAssumption(assumption, generalContext, specificContext) {
+    let assumptionUnifies;
+
+    const context = specificContext,  ///
+          generalAssumption = this, ///
+          specificAssumption = assumption,  ///
+          generalAssumptionString = generalAssumption.getString(),
+          specificAssumptionString = specificAssumption.getString();
+
+    context.trace(`Unifying the '${specificAssumptionString}' assumption with the '${generalAssumptionString}' assumption...`);
+
+    const assumptionContext = assumption.getContext();
+
+    specificContext = assumptionContext;  ///
+
+    join((specificContext) => {
+      reconcile((specificContext) => {
+        assumptionUnifies = unifyAssumption(generalAssumption, specificAssumption, generalContext, specificContext);
+
+        if (assumptionUnifies) {
+          specificContext.commit(context);
+        }
+
+      }, specificContext);
+    }, specificContext, context);
+
+    if (assumptionUnifies) {
+      context.debug(`...unified the '${specificAssumptionString}' assumption with the '${generalAssumptionString}' assumption.`);
+    }
+
+    return assumptionUnifies;
+  }
+
   unifyTopLevelMetaAssertion(topLevelMetaAssertion, context) {
     let topLevelMetaAssertionUnifies;
 
@@ -273,6 +296,24 @@ export default define(class Assumption extends Element {
 
     return assumption;
   }
+
+  static fromStatementAndReference(statement, reference, context) {
+    let assumption;
+
+    simplify((context) => {
+      instantiate((context) => {
+        const assumptionString = assumptionStringFromStatementAndReference(statement, reference),
+              string = assumptionString,  ///
+              assumptionNode = instantiateAssumption(string, context);
+
+        assumption = assumptionFromAssumptionNode(assumptionNode, context);
+
+        assumption.setContext(context);
+      }, context);
+    }, context);
+
+    return assumption;
+  }
 });
 
 function referenceFromAssumptionNode(assumptionNode, context) {

package/src/element/equivalences.js

@@ -203,8 +203,11 @@ export default define(class Equivalences extends Element {
   static fromNothing(context) {
     const string = EMPTY_STRING,
           node = null,
-          array = [],
-          equivalences = new Equivalences(context, string, node, array);
+          array = [];
+
+    context = null;
+
+    const equivalences = new Equivalences(context, string, node, array);
 
     return equivalences;
   }

package/src/element/frame.js

@@ -7,7 +7,7 @@ import { instantiateFrame } from "../process/instantiate";
 import { FRAME_META_TYPE_NAME } from "../metaTypeNames";
 import { metavariableFromFrameNode } from "../utilities/element";
 import { descend, reconcile, instantiate } from "../utilities/context";
-import { assumptionsStringFromAssumptions, metaLevelSubstitutionsStringFromMetaLevelSubstitutions } from "../utilities/string";
+import { assumptionsStringFromAssumptions } from "../utilities/string";
 
 export default define(class Frame extends Element {
   constructor(context, string, node, assumptions, metavariable) {
@@ -46,22 +46,6 @@ export default define(class Frame extends Element {
     return metavariableName;
   }
 
-  matchFrameNode(frameNode) {
-    const node = frameNode, ///
-          nodeMatches = this.matchNode(node),
-          frameNodeMatches = nodeMatches; ///
-
-    return frameNodeMatches;
-  }
-
-  findValidFrame(context) {
-    const frameNode = this.getFrameNode(),
-          frame = context.findFrameByFrameNode(frameNode),
-          validFrame = frame; ///
-
-    return validFrame;
-  }
-
   isEqualTo(frame) {
     const frameNode = frame.getNode(),
           frameNodeMatches = this.matchFrameNode(frameNode),
@@ -77,6 +61,26 @@ export default define(class Frame extends Element {
     return singular;
   }
 
+  matchFrameNode(frameNode) {
+    const node = frameNode, ///
+          nodeMatches = this.matchNode(node),
+          frameNodeMatches = nodeMatches; ///
+
+    return frameNodeMatches;
+  }
+
+  matchMetavariableNode(metavariableNode) {
+    let metavariableNodeMatches = false;
+
+    const singular = this.isSingular();
+
+    if (singular) {
+      metavariableNodeMatches = this.metavariable.matchMetavariableNode(metavariableNode);
+    }
+
+    return metavariableNodeMatches;
+  }
+
   compareParameter(parameter) {
     let comparesToParamter = false;
 
@@ -97,54 +101,6 @@ export default define(class Frame extends Element {
     return comparesToParamter;
   }
 
-  compareMetaLevelSubstitution(metaLevelSubstitution, context) {
-    let comparesToMetaLevelSubstitution = false;
-
-    const frameString = this.getString(),  ///
-          metaLevelSubstitutioString = metaLevelSubstitution.getString();
-
-    context.trace(`Comparing the '${frameString}' frame to the '${metaLevelSubstitutioString}' meta-level substitutio...`);
-
-    if (!comparesToMetaLevelSubstitution) {
-      comparesToMetaLevelSubstitution = this.assumptions.some((assumption) => {
-        const assumptionComparesToSubstitution = assumption.compareMetaLevelSubstitution(metaLevelSubstitution, context);
-
-        if (assumptionComparesToSubstitution) {
-          return true;
-        }
-      });
-    }
-
-    if (comparesToMetaLevelSubstitution) {
-      context.debug(`...compared the the '${frameString}' frame to the '${metaLevelSubstitutioString}' meta-Level-substituution.`);
-    }
-
-    return comparesToMetaLevelSubstitution;
-  }
-
-  compareMetaLevelSubstitutions(metaLevelSubstitutions, context) {
-    let comparesToMetaLevelSubstitutions;
-
-    const frameString = this.getString(),  ///
-          metaLevelSubstitutionsString = metaLevelSubstitutionsStringFromMetaLevelSubstitutions(metaLevelSubstitutions);
-
-    context.trace(`Comparing the '${frameString}' frame to the '${metaLevelSubstitutionsString}' meta-level substitutio...`);
-
-    comparesToMetaLevelSubstitutions = metaLevelSubstitutions.every((metaLevelSubstitution) => {
-      const compaaresToMetaLevelSubstitution = this.compareMetaLevelSubstitution(metaLevelSubstitution, context);
-
-      if (compaaresToMetaLevelSubstitution) {
-        return true;
-      }
-    });
-
-    if (comparesToMetaLevelSubstitutions) {
-      context.debug(`...compared the '${frameString}' frame to the '${metaLevelSubstitutionsString}' metaLevelSubstitutions.`);
-    }
-
-    return comparesToMetaLevelSubstitutions;
-  }
-
   compareMetavariableName(metavariableName) {
     let comparesToMetavariableName = false;
 
@@ -163,6 +119,14 @@ export default define(class Frame extends Element {
     return comparesToMetavariableName;
   }
 
+  findValidFrame(context) {
+    const frameNode = this.getFrameNode(),
+          frame = context.findFrameByFrameNode(frameNode),
+          validFrame = frame; ///
+
+    return validFrame;
+  }
+
   validate(context) {
     let frame = null;
 
@@ -377,4 +341,3 @@ function assumptionsFromFrameNode(frameNode, context) {
 
   return assumptions;
 }
-

package/src/element/judgement.js

@@ -5,6 +5,7 @@ import { Element } from "occam-languages";
 import { define } from "../elements";
 import { instantiateJudgement } from "../process/instantiate";
 import { reconcile, instantiate } from "../utilities/context";
+import { judgementFromStatementNode } from "../utilities/element";
 import { judgementAssignmentFromJudgement } from "../process/assign";
 
 export default define(class Judgement extends Element {
@@ -19,7 +20,7 @@ export default define(class Judgement extends Element {
     return this.frame;
   }
 
-  getDeclaration() {
+  getAssumption() {
     return this.assumption;
   }
 
@@ -39,6 +40,8 @@ export default define(class Judgement extends Element {
 
   getMetavariable() { return this.frame.getMetavariable(); }
 
+  getMetavariableNode() { return this.frame.getMetavariableNode(); }
+
   matchJudgementNode(judgementNode) {
     const node = judgementNode, ///
           nodeMatches = this.matchNode(node),
@@ -47,6 +50,8 @@ export default define(class Judgement extends Element {
     return judgementNodeMatches;
   }
 
+  matchMetavariableNode(metavariableNode) { return this.frame.matchMetavariableNode(metavariableNode); }
+
   compareMetavariableName(metavariableName) { return this.frame.compareMetavariableName(metavariableName); }
 
   findValidJudgement(context) {
@@ -182,12 +187,40 @@ export default define(class Judgement extends Element {
     context.trace(`Validating the '${judgementString}' derived judgement...`);
 
     const topLevelMetaAssertion = this.assumption.getTopLevelMetaAssertion(),
-          metaLevelSubstitutions = topLevelMetaAssertion.getMetaLevelSubstitutions(),
-          frameComparesToSubstitutions = this.frame.compareMetaLevelSubstitutions(metaLevelSubstitutions, context);
+          metavariableNode = this.getMetavariableNode(),
+          judgements = context.findJudgementsByMetavariableNode(metavariableNode);
 
-    if (frameComparesToSubstitutions) {
-      validatesWhenDerived = true;
-    }
+    let assumptions;
+
+    assumptions = topLevelMetaAssertion.getAssumptions();
+
+    const specificAssumptions = assumptions; ///
+
+    assumptions = assumptionsFromJudgements(judgements);
+
+    const generalAssumptions = assumptions;  ///
+
+    reconcile((context) => {
+      const specificAssumptionsUnify = specificAssumptions.every((specificAssumption) => {
+        const specificAssumptionUnifies = generalAssumptions.some((generalAssumption) => {
+          const generalContext = context, ///
+                specificContext = context,  ///
+                specificAssumptionUnifies = generalAssumption.unifyAssumption(specificAssumption, generalContext, specificContext);
+
+          if (specificAssumptionUnifies) {
+            return true;
+          }
+        });
+
+        if (specificAssumptionUnifies) {
+          return true;
+        }
+      });
+
+      if (specificAssumptionsUnify) {
+        validatesWhenDerived = true;
+      }
+    }, context);
 
     if (validatesWhenDerived) {
       context.debug(`...validated the '${judgementString}' derived judgement.`);
@@ -235,6 +268,13 @@ export default define(class Judgement extends Element {
       return judgement;
     }, context);
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          judgement = judgementFromStatementNode(statementNode, context);
+
+    return judgement;
+  }
 });
 
 function frameFromJudgementNode(judgementNode, context) {
@@ -244,6 +284,16 @@ function frameFromJudgementNode(judgementNode, context) {
   return frame;
 }
 
+function assumptionsFromJudgements(judgements) {
+  const assumptions = judgements.map((judgement) => {
+    const assumption = judgement.getAssumption();
+
+    return assumption;
+  });
+
+  return assumptions;
+}
+
 function assumptionFromJudgementNode(judgementNode, context) {
   const assumptionNode = judgementNode.getAssumptionNode(),
         assumption = context.findAssumptionByAssumptionNode(assumptionNode);

package/src/element/metavariable.js

@@ -10,7 +10,7 @@ import { EMPTY_STRING } from "../constants";
 import { instantiateMetavariable } from "../process/instantiate";
 import { metaTypeFromJSON, metaTypeToMetaTypeJSON } from "../utilities/json";
 import { unifyMetavariable, unifyMetavariableIntrinsically } from "../process/unify";
-import { nameFromMetavariableNode, termFromMetavariableNode, typeFromMetavariableNode } from "../utilities/element";
+import { nameFromMetavariableNode, termFromMetavariableNode, typeFromMetavariableNode, metavariableFromStatementNode } from "../utilities/element";
 
 export default define(class Metavariable extends Element {
   constructor(context, string, node, name, term, type, metaType) {
@@ -58,6 +58,14 @@ export default define(class Metavariable extends Element {
 
   isMetaTypeEqualTo(metaType) { return this.metaType.isEqualTo(metaType); }
 
+  matchMetavariableNode(metavariableNode) {
+    const node = metavariableNode, ///
+          nodeMatches = this.matchNode(node),
+          metavariableNodeMatches = nodeMatches; ///
+
+    return metavariableNodeMatches;
+  }
+
   compare(metavariable) {
     const metavariableName = metavariable.getName(),
           comparesToMetavariableName = this.compareMetavariableName(metavariableName),
@@ -73,14 +81,6 @@ export default define(class Metavariable extends Element {
     return comparesToMetavariableName;
   }
 
-  matchMetavariableNode(metavariableNode) {
-    const node = metavariableNode, ///
-          nodeMatches = this.matchNode(node),
-          metavariableNodeMatches = nodeMatches; ///
-
-    return metavariableNodeMatches;
-  }
-
   verify(context) {
     let verifies = false;
 
@@ -290,11 +290,10 @@ export default define(class Metavariable extends Element {
       frameUnifies = true;
     } else {
       const metavariableName = this.getMetavariableName(),
-            simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
+            substitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
 
-      if (simpleSubstitution !== null) {
-        const substitution = simpleSubstitution,  ///
-              substitutionFrameComparesToFrame = substitution.compareFrame(frame, context);
+      if (substitution !== null) {
+        const substitutionFrameComparesToFrame = substitution.compareFrame(frame, context);
 
         if (substitutionFrameComparesToFrame) {
           const frameSubstitution = substitution, ///
@@ -402,12 +401,10 @@ export default define(class Metavariable extends Element {
       referenceUnifies = true;
     } else {
       const metavariableName = this.getMetavariableName(),
-            simpleSubstitutionPresent = context.isSimpleSubstitutionPresentByMetavariableName(metavariableName);
+            substitution = context.findSubstitutionByMetavariableName(metavariableName);
 
-      if (simpleSubstitutionPresent) {
-        const simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName),
-              substitution = simpleSubstitution,  ///
-              substitutionReferenceComparesToReference = substitution.compareReference(reference, context);
+      if (substitution !== null) {
+        const substitutionReferenceComparesToReference = substitution.compareReference(reference, context);
 
         if (substitutionReferenceComparesToReference) {
           const referenceSubstitution = substitution, ///
@@ -625,4 +622,11 @@ export default define(class Metavariable extends Element {
       return metavariable;
     }, context);
   }
+
+  static fromStatement(statement, context) {
+    const statementNode = statement.getNode(),
+          metavariable = metavariableFromStatementNode(statementNode, context);
+
+    return metavariable;
+  }
 });

package/src/element/proofAssertion/step.js

@@ -2,11 +2,11 @@
 
 import { asynchronousUtilities } from "occam-languages";
 
+import elements from "../../elements";
 import ProofAssertion from "../proofAssertion";
 
 import { define } from "../../elements";
 import { unifyStatements } from "../../utilities/unification";
-import { propertyAssertionFromStatement } from "../../utilities/statement";
 import { derive, attempt, descend, asyncReconcile } from "../../utilities/context";
 
 const { asyncSome } = asynchronousUtilities;
@@ -49,8 +49,9 @@ export default define(class Step extends ProofAssertion {
   compareTermAndPropertyRelation(term, propertyRelation, context) {
     let comparesToTermAndPropertyRelation = false;
 
-    const statement = this.getStatement(),
-          propertyAssertion = propertyAssertionFromStatement(statement, context);
+    const { PropertyAssertion } = elements,
+          statement = this.getStatement(),
+          propertyAssertion = PropertyAssertion.fromStatement(statement, context);
 
     if (propertyAssertion !== null) {
       comparesToTermAndPropertyRelation = propertyAssertion.compareTermAndPropertyRelation(term, propertyRelation, context);

package/src/element/topLevelMetaAssertion.js

@@ -7,23 +7,23 @@ import { topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction } from "..
 import { labelFromJSON,
          labelToLabelJSON,
          deductionFromJSON,
+         assumptionsFromJSON,
          suppositionsFromJSON,
          deductionToDeductionJSON,
-         suppositionsToSuppositionsJSON,
-         metaLevelSubstitutionsFromJSON,
-         metaLevelSubstitutionsToMetaLevelSubstitutionsJSON } from "../utilities/json";
+         assumptionsToAssumptionsJSON,
+         suppositionsToSuppositionsJSON } from "../utilities/json";
 
 const { asyncForwardsEvery } = asynchronousUtilities;
 
 export default class TopLevelMetaAssertion extends Element {
-  constructor(context, string, node, label, suppositions, deduction, proof, metaLevelSubstitutions) {
+  constructor(context, string, node, label, suppositions, deduction, proof, assumptions) {
     super(context, string, node);
 
     this.label = label;
     this.suppositions = suppositions;
     this.deduction = deduction;
     this.proof = proof;
-    this.metaLevelSubstitutions = metaLevelSubstitutions;
+    this.assumptions = assumptions;
   }
 
   getLabel() {
@@ -42,8 +42,8 @@ export default class TopLevelMetaAssertion extends Element {
     return this.proof;
   }
 
-  getMetaLevelSubstitutions() {
-    return this.metaLevelSubstitutions;
+  getAssumptions() {
+    return this.assumptions;
   }
 
   getStatement() {
@@ -121,7 +121,7 @@ export default class TopLevelMetaAssertion extends Element {
           }
         }
       }
-    }, this.metaLevelSubstitutions, context);
+    }, this.assumptions, context);
 
     if (verifies) {
       context.debug(`...verified the '${topLevelMetaAssertionString}' top level meta assertion.`);
@@ -234,16 +234,16 @@ export default class TopLevelMetaAssertion extends Element {
     const labelJSON = labelToLabelJSON(this.label),
           deductionJSON = deductionToDeductionJSON(this.deduction),
           suppositionsJSON = suppositionsToSuppositionsJSON(this.suppositions),
-          metaLevelSubstitutionsJSON = metaLevelSubstitutionsToMetaLevelSubstitutionsJSON(this.metaLevelSubstitutions),
+          assumptionsJSON = assumptionsToAssumptionsJSON(this.assumptions),
           label = labelJSON,  ///
           deduction = deductionJSON,  ///
           suppositions = suppositionsJSON,  ///
-          metaLevelSubstitutions = metaLevelSubstitutionsJSON,  ///
+          assumptions = assumptionsJSON,  ///
           json = {
             label,
             deduction,
             suppositions,
-            metaLevelSubstitutions
+            assumptions
           };
 
     return json;
@@ -253,11 +253,11 @@ export default class TopLevelMetaAssertion extends Element {
     const label = labelFromJSON(json, context),
           deduction = deductionFromJSON(json, context),
           suppositions = suppositionsFromJSON(json, context),
-          metaLevelSubstitutions = metaLevelSubstitutionsFromJSON(json, context),
+          assumptions = assumptionsFromJSON(json, context),
           node = null,
           proof = null,
           string = topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction(label, suppositions, deduction),
-          topLevelMetaAssertion = new Class(context, string, node, label, suppositions, deduction, proof, metaLevelSubstitutions);
+          topLevelMetaAssertion = new Class(context, string, node, label, suppositions, deduction, proof, assumptions);
 
     return topLevelMetaAssertion;
   }

package/src/nonTerminalNodeMap.js

@@ -79,7 +79,6 @@ import SimpleTypeDeclarationNode from "./node/declaration/simpleType";
 import CombinatorDeclarationNode from "./node/declaration/combinator";
 import ReferenceSubstitutionNode from "./node/substitution/reference";
 import StatementSubstitutionNode from "./node/substitution/statement";
-import MetaLevelSubstitutionNode from "./node/substitution/metaLevel";
 import TypePrefixDeclarationNode from "./node/declaration/typePrefix";
 import ComplexTypeDeclarationNode from "./node/declaration/complexType";
 import DonstructorDeclarationNode from "./node/declaration/constructor";
@@ -164,7 +163,6 @@ import {
   COMBINATOR_DECLARATION_RULE_NAME,
   REFERENCE_SUBSTITUTION_RULE_NAME,
   STATEMENT_SUBSTITUTION_RULE_NAME,
-  META_LEVEL_SUBSTITUTION_RULE_NAME,
   SIMPLE_TYPE_DECLARATION_RULE_NAME,
   CONSTRUCTOR_DECLARATION_RULE_NAME,
   TYPE_PREFIX_DECLARATION_RULE_NAME,
@@ -250,7 +248,6 @@ const NonTerminalNodeMap = {
   [COMBINATOR_DECLARATION_RULE_NAME]: CombinatorDeclarationNode,
   [STATEMENT_SUBSTITUTION_RULE_NAME]: StatementSubstitutionNode,
   [REFERENCE_SUBSTITUTION_RULE_NAME]: ReferenceSubstitutionNode,
-  [META_LEVEL_SUBSTITUTION_RULE_NAME]: MetaLevelSubstitutionNode,
   [SIMPLE_TYPE_DECLARATION_RULE_NAME]: SimpleTypeDeclarationNode,
   [TYPE_PREFIX_DECLARATION_RULE_NAME]: TypePrefixDeclarationNode,
   [CONSTRUCTOR_DECLARATION_RULE_NAME]: DonstructorDeclarationNode,

package/src/preamble.js

@@ -57,7 +57,6 @@ import SimpleTypeDeclaration from "./element/declaration/simpleType";
 import StatementSubstitution from "./element/substitution/statement";
 import ReferenceSubstitution from "./element/substitution/reference";
 import CombinatorDeclaration from "./element/declaration/combinator";
-import MetaLevelSubstitution from "./element/substitution/metaLevel";
 import TypePrefixDeclaration from "./element/declaration/typePrefix";
 import ConstructorDeclaration from "./element/declaration/constructor";
 import ComplexTypeDeclaration from "./element/declaration/complexType";

package/src/process/instantiate.js

@@ -34,8 +34,7 @@ import { TERM_RULE_NAME,
          CONTAINED_ASSERTION_RULE_NAME,
          SATISFIES_ASSERTION_RULE_NAME,
          STATEMENT_SUBSTITUTION_RULE_NAME,
-         REFERENCE_SUBSTITUTION_RULE_NAME,
-         META_LEVEL_SUBSTITUTION_RULE_NAME } from "../ruleNames";
+         REFERENCE_SUBSTITUTION_RULE_NAME } from "../ruleNames";
 
 const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
       typePlaceholderRule = ruleFromRuleName(TYPE_RULE_NAME),
@@ -70,8 +69,7 @@ const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
       containedAssertionPlaceholderRule = ruleFromRuleName(CONTAINED_ASSERTION_RULE_NAME),
       satisfiesAssertionPlaceholderRule = ruleFromRuleName(SATISFIES_ASSERTION_RULE_NAME),
       statementSubstitutionPlaceholderRule = ruleFromRuleName(STATEMENT_SUBSTITUTION_RULE_NAME),
-      referenceSubstitutionPlaceholderRule = ruleFromRuleName(REFERENCE_SUBSTITUTION_RULE_NAME),
-      metaLevelSubstitutionPlaceholderRule = ruleFromRuleName(META_LEVEL_SUBSTITUTION_RULE_NAME);
+      referenceSubstitutionPlaceholderRule = ruleFromRuleName(REFERENCE_SUBSTITUTION_RULE_NAME);
 
 export function instantiatePremise(string, context) {
   string = `${string}
@@ -161,8 +159,6 @@ export function instantiateStatementSubstitution(string, context) { return insta
 
 export function instantiateReferenceSubstitution(string, context) { return instantiate(referenceSubstitutionPlaceholderRule, string, context); }
 
-export function instantiateMetaLevelSubstitution(string, context) { return instantiate(metaLevelSubstitutionPlaceholderRule, string, context); }
-
 function instantiate(placeholderRule, string, context) {
   let node;