occam-verify-cli 1.0.747 → 1.0.757

package/src/element/substitution/statement.js

@@ -4,9 +4,9 @@ import Substitution from "../substitution";
 
 import { define } from "../../elements";
 import { unifySubstitution } from "../../process/unify";
+import { join, reconcile, instantiate } from "../../utilities/context";
 import { stripBracketsFromStatement } from "../../utilities/brackets";
 import { instantiateStatementSubstitution } from "../../process/instantiate";
-import { liminally, literally, synthetically } from "../../utilities/context";
 import { statementSubstitutionFromStatementSubstitutionNode } from "../../utilities/element";
 import { statementSubstitutionStringFromStatementAndMetavariable, statementSubstitutionStringFromStatementMetavariableAndSubstitution } from "../../utilities/string";
 
@@ -156,7 +156,7 @@ export default define(class StatementSubstitution extends Substitution {
           targetStatementString = this.targetStatement.getString(),
           statementSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${statementSubstitutionString}' statement subtitution's '${targetStatementString}' target statement...`);
+    context.trace(`Validating the '${statementSubstitutionString}' statement substitution's '${targetStatementString}' target statement...`);
 
     const targetStatementSingular = this.targetStatement.isSingular();
 
@@ -168,11 +168,11 @@ export default define(class StatementSubstitution extends Substitution {
         targetStatementValidates = true;
       }
     } else {
-      context.debug(`The '${statementSubstitutionString}' statement subtitution's '${targetStatementString}' target statement is not singular.`);
+      context.debug(`The '${statementSubstitutionString}' statement substitution's '${targetStatementString}' target statement is not singular.`);
     }
 
     if (targetStatementValidates) {
-      context.debug(`...validated the '${statementSubstitutionString}' statement subtitution's '${targetStatementString}' target statement...`);
+      context.debug(`...validated the '${statementSubstitutionString}' statement substitution's '${targetStatementString}' target statement...`);
     }
 
     return targetStatementValidates;
@@ -185,7 +185,7 @@ export default define(class StatementSubstitution extends Substitution {
           replacementStatementString = this.replacementStatement.getString(),
           statementSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${statementSubstitutionString}' statement subtitution's '${replacementStatementString}' replacement statement...`);
+    context.trace(`Validating the '${statementSubstitutionString}' statement substitution's '${replacementStatementString}' replacement statement...`);
 
     const stated = true,
           replacementStatement = this.replacementStatement.validate(stated, context);
@@ -195,36 +195,15 @@ export default define(class StatementSubstitution extends Substitution {
     }
 
     if (replacementStatementValidates) {
-      context.debug(`...validated the '${statementSubstitutionString}' statement subtitution's '${replacementStatementString}' replacement statement.`);
+      context.debug(`...validated the '${statementSubstitutionString}' statement substitution's '${replacementStatementString}' replacement statement.`);
     }
 
     return replacementStatementValidates;
   }
 
-  unifyReplacementStatement(replacementStatement, generalContext, specificContext) {
-    let replacementStatemnentUnifies = false;
-
-    const context = specificContext,  ///
-          substitutionString = this.getString(),  ///
-          replacementStatementString = replacementStatement.getString(),
-          substitutionReplacementStatementString = this.replacementStatement.getString();  ///
-
-    context.trace(`Unifying the '${replacementStatementString}' replacement statement with the '${substitutionString}' substiution's '${substitutionReplacementStatementString}' replacement statement...`);
-
-    const statementUnifies = this.replacementStatement.unifyStatement(replacementStatement, generalContext, specificContext);
-
-    if (statementUnifies) {
-      replacementStatemnentUnifies = true;
-    }
-
-    if (replacementStatemnentUnifies) {
-      context.debug(`...unified the '${replacementStatementString}' replacement statement with the '${substitutionString}' substiution's '${substitutionReplacementStatementString}' replacement statement.`);
-    }
-
-    return replacementStatemnentUnifies;
-  }
-
   unifySubstitution(substitution, generalContext, specificContext) {
+    let substitutionUnifies;
+
     const context = specificContext,
           generalSubstitution = this.substitution,  ///
           specificSubstitution = substitution,  ///
@@ -233,7 +212,13 @@ export default define(class StatementSubstitution extends Substitution {
 
     context.trace(`Unifying the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution...`);
 
-    const substitutionUnifies = unifySubstitution(generalSubstitution, specificSubstitution, generalContext, specificContext);
+    reconcile((specificContext) => {
+      substitutionUnifies = unifySubstitution(generalSubstitution, specificSubstitution, generalContext, specificContext);
+
+      if (substitutionUnifies) {
+        specificContext.commit();
+      }
+    }, specificContext);
 
     if (substitutionUnifies) {
       context.trace(`...unified the '${specificSubstitutionString}' substitution with the '${generalSubstitutionString}' substitution.`);
@@ -242,81 +227,119 @@ export default define(class StatementSubstitution extends Substitution {
     return substitutionUnifies;
   }
 
-  resolve(generalContext, specificContext) {
-    let context;
+  uniffyComplexSubstitution(complexSubstitution, generalContext, specificContext) {
+    let substitution = null;
 
-    context = this.getContext();
+    const context = specificContext, ///
+          simpleSubstitutionString = this.getString(),  ///
+          complexSubstitutionString = complexSubstitution.getString();  ///
 
-    const substitutionString = this.getString(); ///
+    context.trace(`Unifying the '${complexSubstitutionString}' complex substitution with the '${simpleSubstitutionString}' simple substitution...`);
 
-    context.trace(`Resolving the ${substitutionString} substitution...`);
+    let simpleSubstitutionUnifies = false;
 
-    context = generalContext; ///
+    reconcile((specificContext) => {
+      const replacementStatement = complexSubstitution.getReplacementStatement(),
+            replacementStatementUnifies = this.unifyReplacementStatement(replacementStatement, generalContext, specificContext);
 
-    const metavariableName = this.getMetavariableName();
+      if (replacementStatementUnifies) {
+        const nested = false,
+              context = specificContext,  ///
+              soleNonTrivialSubstitution = context.getSoleNonTrivialSubstitution(nested);
 
-    context = specificContext;  ///
+        substitution = soleNonTrivialSubstitution;  ///
+      }
+    }, specificContext);
 
-    const simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
+    if (substitution !== null) {
+      simpleSubstitutionUnifies = true;
+    }
 
-    if (simpleSubstitution !== null) {
-      context = this.getContext();
+    if (simpleSubstitutionUnifies) {
+      context.debug(`...unified the '${complexSubstitutionString}' complex substitution with the '${simpleSubstitutionString}' simple substitution.`);
+    }
 
-      const subtitution = liminally((context) => {
-        let substitution = null;
+    return substitution;
+  }
 
-        const specificContext = context;  ///
+  unifyReplacementStatement(replacementStatement, generalContext, specificContext) {
+    let replacementStatemnentUnifies = false;
 
-        context = simpleSubstitution.getContext();
+    const context = specificContext,  ///
+          replacementStatementString = replacementStatement.getString(),
+          substitutionReplacementStatementString = this.replacementStatement.getString();  ///
 
-        const generalContext = context; ///
+    context.trace(`Unifying the '${replacementStatementString}' replacement statement with the '${substitutionReplacementStatementString}' replacement statement...`);
 
-        context = specificContext;  ///
+    const statementUnifies = this.replacementStatement.unifyStatement(replacementStatement, generalContext, specificContext);
 
-        const replacementStatementUnifies = simpleSubstitution.unifyReplacementStatement(this.replacementStatement, generalContext, specificContext);
+    if (statementUnifies) {
+      replacementStatemnentUnifies = true;
+    }
 
-        if (replacementStatementUnifies) {
-          const nested = false,
-                soleNonTrivialSubstitution = context.getSoleNonTrivialSubstitution(nested);
+    if (replacementStatemnentUnifies) {
+      context.debug(`...unified the '${replacementStatementString}' replacement statement with the '${substitutionReplacementStatementString}' replacement statement.`);
+    }
 
-          substitution = soleNonTrivialSubstitution;  ///
-        }
+    return replacementStatemnentUnifies;
+  }
 
-        return substitution;
-      }, context);
+  unifyWithSipmleSubstitution(simpleSubstitution, generalContext, specificContext) {
+    let substitution;
 
-      if (subtitution !== null) {
-        liminally((specificContext) => {
-          const contexts = [];
+    const complexSubstitution = this; ///
 
-          context = simpleSubstitution.getContext();
+    let context;
 
-          contexts.push(context);
+    context = this.getContext();
+
+    specificContext = context;  ///
 
-          context = this.getContext();
+    context = simpleSubstitution.getContext();
 
-          contexts.push(context);
+    generalContext = context; ///
 
-          context = specificContext;  ///
+    substitution = simpleSubstitution.uniffyComplexSubstitution(complexSubstitution, generalContext, specificContext);
 
-          synthetically((context) => {
-            const specificContext = context;  ///
+    return substitution;
+  }
 
-            context = this.substitution.getContext();
+  resolve(generalContext, specificContext) {
+    let resolved = false;
 
-            const generalContext = context; ///
+    const context = specificContext,  ///
+          substitutionString = this.getString(); ///
 
-            this.unifySubstitution(subtitution, generalContext, specificContext);
-          }, contexts, context);
+    context.trace(`Resolving the ${substitutionString} substitution...`);
 
-          specificContext.commit();
-        }, specificContext);
+    const metavariableName = this.getMetavariableName(),
+          simpleSubstitution = context.findSimpleSubstitutionByMetavariableName(metavariableName);
 
-        this.resolved = true;
+    if (simpleSubstitution !== null) {
+      const substitution = this.unifyWithSipmleSubstitution(simpleSubstitution, generalContext, specificContext); ///
+
+      if (substitution !== null) {
+        const complexSubstitution = this, ///
+              simpleSubstitutionComplex = simpleSubstitution.getContext(),
+              complexSubstitutionContext = complexSubstitution.getContext();
+
+        join((context) => {
+          const specificContext = context;  ///
+
+          context = this.substitution.getContext();
+
+          const generalContext = context; ///
+
+          this.unifySubstitution(substitution, generalContext, specificContext);
+        }, complexSubstitutionContext, simpleSubstitutionComplex, context);
+
+        resolved = true;
       }
     }
 
-    if (this.resolved) {
+    if (resolved) {
+      this.resolved = true;
+
       context.debug(`...resolved the '${substitutionString}' substitution.`);
     }
   }
@@ -329,7 +352,7 @@ export default define(class StatementSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      literally((context) => {
+      instantiate((context) => {
         const { string } = json,
               statementSubstitutionNode = instantiateStatementSubstitution(string, context),
               node = statementSubstitutionNode,  ///
@@ -348,7 +371,7 @@ export default define(class StatementSubstitution extends Substitution {
   static fromStatementAndMetavariable(statement, metavariable, context) {
     statement = stripBracketsFromStatement(statement, context); ///
 
-    return literally((context) => {
+    return instantiate((context) => {
       const statementSubstitutionString = statementSubstitutionStringFromStatementAndMetavariable(statement, metavariable, context),
             string = statementSubstitutionString, ///
             statementSubstitutionNode = instantiateStatementSubstitution(string, context),
@@ -361,7 +384,7 @@ export default define(class StatementSubstitution extends Substitution {
   static fromStatementMetavariableAndSubstitution(statement, metavariable, substitution, context) {
     statement = stripBracketsFromStatement(statement, context); ///
 
-    return literally((context) => {
+    return instantiate((context) => {
       const statementSubstitutionString = statementSubstitutionStringFromStatementMetavariableAndSubstitution(statement, metavariable, substitution),
             string = statementSubstitutionString, ///
             statementSubstitutionNode = instantiateStatementSubstitution(string, context),

package/src/element/substitution/term.js

@@ -3,7 +3,7 @@
 import Substitution from "../substitution";
 
 import { define } from "../../elements";
-import { literally } from "../../utilities/context";
+import { instantiate } from "../../utilities/context";
 import { stripBracketsFromTerm } from "../../utilities/brackets";
 import { instantiateTermSubstitution } from "../../process/instantiate";
 import { termSubstitutionStringFromTermAndVariable } from "../../utilities/string";
@@ -124,12 +124,12 @@ export default define(class TermSubstitution extends Substitution {
           targetTermString = this.targetTerm.getString(),
           termSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${termSubstitutionString}' term subtitution's '${targetTermString}' target term...`);
+    context.trace(`Validating the '${termSubstitutionString}' term substitution's '${targetTermString}' target term...`);
 
     const targetTermSingular = this.targetTerm.isSingular();
 
     if (targetTermSingular) {
-      const targetTerm = this.targetTerm.validate(context, () => {
+      const targetTerm = this.targetTerm.validate(context, (targetTerm) => {
         const validatesForwards = true;
 
         return validatesForwards;
@@ -141,11 +141,11 @@ export default define(class TermSubstitution extends Substitution {
         targetTermValidates = true;
       }
     } else {
-      context.debug(`The '${termSubstitutionString}' term subtitution's '${targetTermString}' target term is not singular.`);
+      context.debug(`The '${termSubstitutionString}' term substitution's '${targetTermString}' target term is not singular.`);
     }
 
     if (targetTermValidates) {
-      context.debug(`...validated the '${termSubstitutionString}' term subtitution's '${targetTermString}' target term...`);
+      context.debug(`...validated the '${termSubstitutionString}' term substitution's '${targetTermString}' target term...`);
     }
 
     return targetTermValidates;
@@ -158,9 +158,9 @@ export default define(class TermSubstitution extends Substitution {
           replacementTermString = this.replacementTerm.getString(),
           termSubstitutionString = this.getString();  ///
 
-    context.trace(`Validating the '${termSubstitutionString}' term subtitution's '${replacementTermString}' replacement term...`);
+    context.trace(`Validating the '${termSubstitutionString}' term substitution's '${replacementTermString}' replacement term...`);
 
-    const replacementTerm = this.replacementTerm.validate(context, () => {
+    const replacementTerm = this.replacementTerm.validate(context, (replacementTerm) => {
       const validatesForwards = true;
 
       return validatesForwards;
@@ -173,7 +173,7 @@ export default define(class TermSubstitution extends Substitution {
     }
 
     if (replacementTermValidates) {
-      context.debug(`...validated the '${termSubstitutionString}' term subtitution's '${replacementTermString}' replacement term...`);
+      context.debug(`...validated the '${termSubstitutionString}' term substitution's '${replacementTermString}' replacement term...`);
     }
 
     return replacementTermValidates;
@@ -187,7 +187,7 @@ export default define(class TermSubstitution extends Substitution {
     const { name } = json;
 
     if (this.name === name) {
-      literally((context) => {
+      instantiate((context) => {
         const { string } = json,
               termSubstitutionNode = instantiateTermSubstitution(string, context),
               node = termSubstitutionNode,  ///
@@ -213,7 +213,7 @@ export default define(class TermSubstitution extends Substitution {
   static fromTermAndVariable(term, variable, context) {
     term = stripBracketsFromTerm(term, context); ///
 
-    return literally((context) => {
+    return instantiate((context) => {
       const termSubstitutionString = termSubstitutionStringFromTermAndVariable(term, variable),
             string = termSubstitutionString,  ///
             termSubstitutionNode = instantiateTermSubstitution(string, context),

package/src/element/term.js

@@ -4,7 +4,7 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { validateTerms } from "../utilities/validation";
 import { instantiateTerm } from "../process/instantiate";
 import { variablesFromTerm } from "../utilities/equivalence";
@@ -158,12 +158,14 @@ export default define(class Term extends Element {
           valid = (validTerm !== null);
 
     if (valid) {
-      const validatesForward = validateForwards();
+      term = validTerm; ///
 
-      if (validatesForward) {
-        term = validTerm; ///
+      context.debug(`...the '${termString}' term is already valid.`);
 
-        context.debug(`...the '${termString}' term is already valid.`);
+      const validatesForward = validateForwards(term);
+
+      if (!validatesForward) {
+        term = null;
       }
     } else {
       const validates = validateTerms.some((validateTerm) => {  ///
@@ -188,33 +190,37 @@ export default define(class Term extends Element {
   }
 
   validateGivenType(type, context) {
-    let validatesGivenType = false;
+    let term;
 
     const typeString = type.getString(),
           termString = this.getString();  ///
 
     context.trace(`Validating the '${termString}' term given the '${typeString}' type...`);
 
-    const term = this.validate(context, () => {
-      const validatesForwards = true;
+    let validatesGivenType = false;
 
-      return validatesForwards;
-    });
+    term = this.validate(context, (term) => {
+      let validatesForwards = false;
 
-    if (term !== null) {
       const termType = term.getType(),
-            termTypeEqualToOrSubTypeOfGivenTypeType = termType.isEqualToOrSubTypeOf(type);
+            termTypeEqualToOrSubTypeOfType = termType.isEqualToOrSubTypeOf(type);
 
-      if (termTypeEqualToOrSubTypeOfGivenTypeType) {
-        validatesGivenType = true;
+      if (termTypeEqualToOrSubTypeOfType) {
+        validatesForwards = true;
       }
+
+      return validatesForwards;
+    });
+
+    if (term !== null) {
+      validatesGivenType = true;
     }
 
     if (validatesGivenType) {
       context.debug(`...validated the '${termString}' term given the '${typeString}' type.`);
     }
 
-    return validatesGivenType;
+    return term;
   }
 
   toJSON() {
@@ -232,7 +238,7 @@ export default define(class Term extends Element {
   static name = "Term";
 
   static fromJSON(json, context) {
-    const term = literally((context) => {
+    const term = instantiate((context) => {
       const { string } = json,
             termNode = instantiateTerm(string, context),
             node = termNode,  ///

package/src/element/topLevelAssertion/axiom.js

@@ -1,9 +1,13 @@
 "use strict";
 
+import { arrayUtilities } from "necessary";
+
 import TopLevelAssertion from "../topLevelAssertion";
 
 import { define } from "../../elements";
 
+const { backwardsEvery } = arrayUtilities;
+
 export default define(class Axiom extends TopLevelAssertion {
   getAxiomNode() {
     const node = this.getNode(),
@@ -120,7 +124,7 @@ export default define(class Axiom extends TopLevelAssertion {
   unifySubproof(subproof, context) {
     let subproofUnifies = false;
 
-    const axiomString = this.getString(),
+    const axiomString = this.getString(), ///
           subproofString = subproof.getString();
 
     context.trace(`Unifying the '${subproofString}' subproof with the '${axiomString}' axiom...`);
@@ -130,10 +134,10 @@ export default define(class Axiom extends TopLevelAssertion {
     if (unconditional) {
       context.trace(`Unable to unify the '${subproofString}' subproof with the '${axiomString}' axiom because the axiom is unconditional.`);
     } else {
-      const lastProofAssertion = subproof.getLastProofAssertion(),
-            lastProofAssertionUnifies = this.unifyLastProofAssertion(lastProofAssertion, context);
+      const lastStep = subproof.getLastStep(),
+            lastStepUnifies = this.unifyLastStep(lastStep, context);
 
-      if (lastProofAssertionUnifies) {
+      if (lastStepUnifies) {
         const suppositions = subproof.getSuppositions(),
               suppositionsUnify = this.unifySuppositions(suppositions, context);
 
@@ -196,7 +200,7 @@ export default define(class Axiom extends TopLevelAssertion {
     if (generalSuppositionsLength === specificSuppositionsLength) {
       suppositions = specificSuppositions;  ///
 
-      suppositionsUnify = suppositions.every((supposition, index) => {
+      suppositionsUnify = backwardsEvery(suppositions, (supposition, index) => {
         const suppositionUnifies = this.unifySupposition(supposition, index, generalContext, specificContext);
 
         if (suppositionUnifies) {
@@ -208,32 +212,32 @@ export default define(class Axiom extends TopLevelAssertion {
     return suppositionsUnify;
   }
 
-  unifyLastProofAssertion(lastProofAssertion, context) {
-    let lastProofAssertionUnifies = false;
+  unifyLastStep(lastStep, context) {
+    let lastStepUnifies = false;
 
-    const axiomString = this.getString(),
-          lastProofAssertionString = lastProofAssertion.getString();
+    const axiomString = this.getString(), ///
+          lastStepString = lastStep.getString();
 
-    context.trace(`Unifying the '${lastProofAssertionString}' last proof assertion with the '${axiomString}' axiom...`)
+    context.trace(`Unifying the '${lastStepString}' last step with the '${axiomString}' axiom...`);
 
-    const statement = lastProofAssertion.getStatement(),
+    const statement = lastStep.getStatement(),
           statementUnifiesWithDeduction = this.unifyStatementWithDeduction(statement, context);
 
     if (statementUnifiesWithDeduction) {
-      lastProofAssertionUnifies = true;
+      lastStepUnifies = true;
     }
 
-    if (lastProofAssertionUnifies) {
-      context.debug(`...unified the '${lastProofAssertionString}' last proof assertion with the '${axiomString}' axiom.`)
+    if (lastStepUnifies) {
+      context.debug(`...unified the '${lastStepString}' last step with the '${axiomString}' axiom.`);
     }
 
-    return lastProofAssertionUnifies;
+    return lastStepUnifies;
   }
 
   unifyTopLevelAssertion(topLevelAssertion, context) {
     let topLevelAssertionUnifies = false;
 
-    const axiomString = this.getString(),
+    const axiomString = this.getString(), ///
           topLevelAssertionString = topLevelAssertion.getString();
 
     context.trace(`Unifying the '${topLevelAssertionString}' top level assertion with the '${axiomString}' axiom...`);

package/src/element/topLevelAssertion.js

@@ -3,7 +3,7 @@
 import { arrayUtilities } from "necessary";
 import { Element, asynchronousUtilities } from "occam-languages";
 
-import { asyncScope } from "../utilities/context";
+import { asyncRestrict } from "../utilities/context";
 import { topLevelAssertionStringFromLabelsSuppositionsAndDeduction } from "../utilities/string";
 import { labelsFromJSON,
          deductionFromJSON,
@@ -59,8 +59,6 @@ export default class TopLevelAssertion extends Element {
     this.hypotheses = hypotheses;
   }
 
-  getStatement() { return this.deduction.getStatement(); }
-
   isHypothetical() {
     const hypothesesLength = this.hypotheses.length,
           hypothetical = (hypothesesLength > 0);
@@ -152,7 +150,7 @@ export default class TopLevelAssertion extends Element {
 
     context.trace(`Verifying the '${topLevelAssertionString}' top level assertion...`);
 
-    await asyncScope(async (context) => {
+    await asyncRestrict(async (context) => {
       const labelsVerify = this.verifyLabels();
 
       if (labelsVerify) {

package/src/element/topLevelMetaAssertion.js

@@ -2,7 +2,7 @@
 
 import { Element, asynchronousUtilities } from "occam-languages";
 
-import { asyncScope } from "../utilities/context";
+import { asyncRestrict } from "../utilities/context";
 import { topLevelMetaAssertionStringFromLabelSuppositionsAndDeduction } from "../utilities/string";
 import { labelFromJSON,
          labelToLabelJSON,
@@ -46,7 +46,46 @@ export default class TopLevelMetaAssertion extends Element {
     return this.metaLevelSubstitutions;
   }
 
-  getStatement() { return this.deduction.getStatement(); }
+  getStatement() {
+    let statement = null;
+
+    const unconditional = this.isUnconditional();
+
+    if (unconditional) {
+      statement = this.deduction.getStatement();
+    }
+
+    return statement;
+  }
+
+  getStatements() {
+    let statements = null;
+
+    const unconditional = this.isUnconditional();
+
+    if (!unconditional) {
+      const suppositionStatements = this.suppositions.map((supposition) => {
+              const suppositionStatement = supposition.getStatement();
+
+              return suppositionStatement;
+            }),
+            deductionStatement = this.deduction.getStatement();
+
+      statements = [
+        ...suppositionStatements,
+        deductionStatement
+      ];
+    }
+
+    return statements;
+  }
+
+  isUnconditional() {
+    const suppositionsLength = this.suppositions.length,
+          unconditional = (suppositionsLength === 0);
+
+    return unconditional;
+  }
 
   compareReference(reference) {
     const label = this.getLabel(),
@@ -64,7 +103,7 @@ export default class TopLevelMetaAssertion extends Element {
 
     context.trace(`Verifying the '${topLevelMetaAssertionString}' top level meta assertion...`);
 
-    await asyncScope(async (context) => {
+    await asyncRestrict(async (context) => {
       const labelVerifies = this.verifyLabel();
 
       if (labelVerifies) {

package/src/element/type.js

@@ -4,7 +4,7 @@ import { Element } from "occam-languages";
 import { arrayUtilities } from "necessary";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { instantiateType } from "../process/instantiate";
 import { baseTypeFromNothing } from "../utilities/type";
 import { nameFromTypeNode, prefixNameFromTypeNode } from "../utilities/element";
@@ -15,6 +15,7 @@ const { push, first } = arrayUtilities;
 export default define(class Type extends Element {
   constructor(context, string, node, name, prefixName, superTypes, properties, provisional) {
     super(context, string, node);
+
     this.name = name;
     this.prefixName = prefixName;
     this.superTypes = superTypes;
@@ -315,7 +316,7 @@ export default define(class Type extends Element {
   static name = "Type";
 
   static fromJSON(json, context) {
-    const type = literally((context) => {
+    const type = instantiate((context) => {
       const { string } = json,
             typeNode = instantiateType(string, context),
             node = typeNode, ///