occam-verify-cli 1.0.746 → 1.0.753

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.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,
@@ -152,7 +152,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,
@@ -64,7 +64,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, ///

package/src/element/typePrefix.js

@@ -3,7 +3,7 @@
 import { Element } from "occam-languages";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { instantiateTypePrefix } from "../process/instantiate";
 import { nameFromTypePrefixNode } from "../utilities/element";
 
@@ -43,7 +43,7 @@ export default define(class TypePrefix extends Element {
   static name = "TypePrefix";
 
   static fromJSON(json, context) {
-    const typePrefix = literally((context) => {const { string } = json,
+    const typePrefix = instantiate((context) => {const { string } = json,
             typePrefixNode = instantiateTypePrefix(string, context),
             node = typePrefixNode, ///
             name = nameFromTypePrefixNode(typePrefixNode, context);

package/src/element/variable.js

@@ -5,7 +5,7 @@ import { Element } from "occam-languages";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { instantiateVariable } from "../process/instantiate";
 import {identifierFromVarialbeNode, variableFromVariableNode} from "../utilities/element";
 import { typeFromJSON, typeToTypeJSON } from "../utilities/json";
@@ -82,7 +82,11 @@ export default define(class Variable extends Element {
     variable = context.findVariableByVariableIdentifier(variableIdentifier);
 
     if (variable !== null) {
-      const type = variable.getType();
+      const type = variable.getType(),
+            typeString = type.getString(),
+            variableString = this.getString();  ///
+
+      context.trace(`Setting the '${variableString}' variable's type to the '${typeString}' type.`);
 
       this.type = type;
 
@@ -180,7 +184,7 @@ export default define(class Variable extends Element {
   static name = "Variable";
 
   static fromJSON(json, context) {
-    const variable = literally((context) => {
+    const variable = instantiate((context) => {
       const { string } = json,
             variableNode = instantiateVariable(string, context),
             node = variableNode,  ///

package/src/process/unify.js

@@ -223,10 +223,13 @@ class CombinatorPass extends ZipPass {
 
         context = specificContext;  ///
 
-        const term = termFromTermNode(termNode, context),
-              termValidatesGivenType = term.validateGivenType(type, context);
+        let term;
 
-        if (termValidatesGivenType) {
+        term = termFromTermNode(termNode, context);
+
+        term = term.validateGivenType(type, context);
+
+        if (term !== null) {
           success = true;
         }
 
@@ -257,10 +260,13 @@ class ConstructorPass extends ZipPass {
         if (type !== null) {
           context = specificContext;  ///
 
-          const term = termFromTermNode(termNode, context),
-                termValidatesGivenType = term.validateGivenType(type, context);
+          let term;
+
+          term = termFromTermNode(termNode, context);
+
+          term = term.validateGivenType(type, context);
 
-          if (termValidatesGivenType) {
+          if (term !== null) {
             success = true;
           }
         }
@@ -285,9 +291,10 @@ class MetavariablePass extends ZipPass {
               type = generalContext.findTypeByNominalTypeName(nominalTypeName),
               context = specificContext, ///
               term = context.findTermByTermNode(termNode),
-              termValidatesGivenType = term.validateGivenType(type, context);
+              termType = term.getType(),
+              termTypeEqualToOrSubTypeOfGivenTypeType = termType.isEqualToOrSubTypeOf(type);
 
-        if (termValidatesGivenType) {
+        if (termTypeEqualToOrSubTypeOfGivenTypeType) {
           success = true;
         }
 

package/src/process/validate.js

@@ -11,7 +11,7 @@ const termNodeQuery = nodeQuery("/term"),
       typeNodeQuery = nodeQuery("/type"),
       statementNodeQuery = nodeQuery("/statement");
 
-class ConbinatorPass extends SimplePass {
+class CombinatorPass extends SimplePass {
   run(statementNode, context) {
     let success = false;
 
@@ -56,7 +56,7 @@ class ConbinatorPass extends SimplePass {
 
         term = termFromTermNode(termNode, context);
 
-        term = term.validate(context, () => { ///
+        term = term.validate(context, (term) => { ///
           const validatesForwards = true;
 
           return validatesForwards;
@@ -112,7 +112,7 @@ class ConstructorPass extends SimplePass {
 
         term = termFromTermNode(termNode, context);
 
-        term = term.validate(context, () => { ///
+        term = term.validate(context, (term) => { ///
           const validatesForwards = true;
 
           return validatesForwards;
@@ -143,7 +143,7 @@ class ConstructorPass extends SimplePass {
   ];
 }
 
-const combinatorPass = new ConbinatorPass(),
+const combinatorPass = new CombinatorPass(),
       constructorPass = new ConstructorPass();
 
 export function validateTermAsConstructor(term, context) {

package/src/utilities/context.js

@@ -5,6 +5,22 @@ import LiminalContext from "../context/liminal";
 import LiteralContext from "../context/literal";
 import EphemeralContext from "../context/ephemeral";
 import SyntheticContext from "../context/synthetic";
+import BranchingContext from "../context/branching";
+
+export function join(innerFunction, ...contexts) {
+  const syntheticContext = SyntheticContext.fromContexts(...contexts),
+        context = syntheticContext;  ///
+
+  return innerFunction(context);
+}
+
+export function choose(innerFunction, context) {
+  const branchingContext = BranchingContext.fromNothing(context);
+
+  context = branchingContext;  ///
+
+  return innerFunction(context);
+}
 
 export function attempt(innerFunction, context) {
   const ephemeralContext = EphemeralContext.fromNothing(context);
@@ -14,7 +30,7 @@ export function attempt(innerFunction, context) {
   return innerFunction(context);
 }
 
-export function liminally(innerFunction, context) {
+export function reconcile(innerFunction, context) {
   const liminalContext = LiminalContext.fromNothing(context);
 
   context = liminalContext;  ///
@@ -22,7 +38,7 @@ export function liminally(innerFunction, context) {
   return innerFunction(context);
 }
 
-export function literally(innerFunction, context) {
+export function instantiate(innerFunction, context) {
   const literalContext = LiteralContext.fromNothing(context);
 
   context = literalContext;  ///
@@ -30,15 +46,7 @@ export function literally(innerFunction, context) {
   return innerFunction(context);
 }
 
-export function synthetically(innerFunction, contexts, context) {
-  const syntheticContext = SyntheticContext.fromContexts(contexts, context);
-
-  context = syntheticContext;  ///
-
-  return innerFunction(context);
-}
-
-export async function asyncScope(innerFunction, metaLevelSubstitutions, context) {
+export async function asyncRestrict(innerFunction, metaLevelSubstitutions, context) {
   if (context === undefined) {
     context = metaLevelSubstitutions;  ///
 
@@ -52,7 +60,7 @@ export async function asyncScope(innerFunction, metaLevelSubstitutions, context)
   return await innerFunction(context);
 }
 
-export async function asyncLiminally(innerFunction, context) {
+export async function asyncReconcile(innerFunction, context) {
   const liminalContext = LiminalContext.fromNothing(context);
 
   context = liminalContext;  ///

package/src/utilities/element.js

@@ -2,7 +2,7 @@
 
 import elements from "../elements";
 
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { baseTypeFromNothing } from "../utilities/type";
 import { instantiateReference } from "../process/instantiate";
 import { equivalenceStringFromTerms,
@@ -1363,7 +1363,7 @@ export function metavariableFromReferenceNode(referenceNode, context) {
 export function referenceFromMetavariableNode(metavariableNode, context) {
   const metavariableString = context.nodeAsString(metavariableNode);
 
-  return literally((context) => {
+  return instantiate((context) => {
     const referenceString = metavariableString, ///
           string = referenceString,  ///
           referenceNode = instantiateReference(string, context),

package/src/utilities/instance.js

@@ -2,7 +2,7 @@
 
 import nominalContext from "../context/nominal";
 
-import { literally } from "../utilities/context";
+import { instantiate } from "../utilities/context";
 import { BASE_TYPE_SYMBOL } from "../constants";
 import { STATEMENT_META_TYPE_NAME } from "../metaTypeNames";
 import { instantiateCombinator, instantiateConstructor } from "../process/instantiate";
@@ -15,7 +15,7 @@ export function bracketedCombinatorFromNothing() {
   if (bracketedCombinator === null) {
     const context = nominalContext; ///
 
-    bracketedCombinator = literally((context) => {
+    bracketedCombinator = instantiate((context) => {
       const bracketedCombinatorString = `(${STATEMENT_META_TYPE_NAME})`,
             string = bracketedCombinatorString, ///
             combinatorNode = instantiateCombinator(string, context),
@@ -33,7 +33,7 @@ export function bracketedConstructorFromNothing() {
   if (bracketedConstructor === null) {
     const context = nominalContext; ///
 
-    bracketedConstructor = literally((context) => {
+    bracketedConstructor = instantiate((context) => {
       const bracketedConstructorString = `(${BASE_TYPE_SYMBOL})`,
             string = bracketedConstructorString,  ///
             constructorNode = instantiateConstructor(string, context),

package/src/utilities/validation.js

@@ -2,6 +2,7 @@
 
 import elements from "../elements";
 
+import { choose } from "./context";
 import { variableFromTerm } from "../utilities/term";
 import { bracketedConstructorFromNothing, bracketedCombinatorFromNothing } from "../utilities/instance";
 import { equalityFromStatement,
@@ -29,11 +30,14 @@ function validateTermAsVariable(term, context, validateForwards) {
     variable = variable.validate(context);
 
     if (variable !== null) {
-      const type = variable.getType();
+      const type = variable.getType(),
+            typeString = type.getString();
+
+      context.trace(`Setting the '${termString}' term's type to the '${typeString}' type.`);
 
       term.setType(type);
 
-      const validatesForwards = validateForwards();
+      const validatesForwards = validateForwards(term);
 
       if (validatesForwards) {
         termValidatesAsVariable = true;
@@ -54,9 +58,17 @@ function unifyTermWithConstructors(term, context, validateForwards) {
   const constructors = context.getConstructors();
 
   termUnifiesWithConstructors = constructors.some((constructor) => {
-    const unifiesWithConstructor = constructor.unifyTerm(term, context, validateForwards);
+    let termUnifies;
+
+    choose((context) => {
+      termUnifies = constructor.unifyTerm(term, context, validateForwards);
+
+      if (termUnifies) {
+        context.commit();
+      }
+    }, context);
 
-    if (unifiesWithConstructor) {
+    if (termUnifies) {
       return true;
     }
   });