occam-verify-cli 1.0.747 → 1.0.757

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;
 
@@ -122,6 +126,11 @@ export default define(class Variable extends Element {
       const substitutionComparesToTerm = substitution.compareTerm(term, context);
 
       if (substitutionComparesToTerm) {
+        const termSubstitution = substitution,  ///
+              termSubstitutionString = termSubstitution.getString();
+
+        context.trace(`The '${termSubstitutionString}' term substitution is already present.`);
+
         termUnifies = true;
       }
     } else {
@@ -180,7 +189,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);
 
-          if (termValidatesGivenType) {
+          term = term.validateGivenType(type, context);
+
+          if (term !== null) {
             success = true;
           }
         }
@@ -285,9 +291,71 @@ 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;
+        }
+
+        return success;
+      }
+    }
+  ];
+}
+
+class SubstitutionPass extends ZipPass {
+  static maps = [
+    {
+      generalNodeQuery: frameAMetavariableNodeQuery,
+      specificNodeQuery: frameNodeQuery,
+      run: (generalFrameMetavariableNode, specificFrameNode, generalContext, specificContext) => {
+        let success = false;
+
+        const frameNode = specificFrameNode, ///
+              metavariableNode = generalFrameMetavariableNode,  ///
+              metavariableName = metavariableNode.getMetavariableName();
+
+        let context;
+
+        context = generalContext; ///
+
+        const metavariable = context.findMetavariableByMetavariableName(metavariableName);
+
+        context = specificContext;  ///
+
+        const frame = context.findFrameByFrameNode(frameNode),
+              frameUnifies = metavariable.unifyFrame(frame, generalContext, specificContext);
+
+        if (frameUnifies) {
+          success = true;
+        }
+
+        return success;
+      }
+    },
+    {
+      generalNodeQuery: termVariableNodeQuery,
+      specificNodeQuery: termNodeQuery,
+      run: (generalTermVariableNode, specificTermNode, generalContext, specificContext) => {
+        let success = false;
+
+        const termNode = specificTermNode, ///
+              variableNode = generalTermVariableNode, ///
+              variableIdentifier = variableNode.getVariableIdentifier();
+
+        let context;
+
+        context = generalContext; ///
+
+        const variable = context.findVariableByVariableIdentifier(variableIdentifier);
+
+        context = specificContext;  ///
+
+        const term = context.findTermByTermNode(termNode),
+              termUnifies = variable.unifyTerm(term, generalContext, specificContext);
+
+        if (termUnifies) {
           success = true;
         }
 
@@ -334,6 +402,7 @@ const metaLevelPass = new MetaLevelPass(),
       combinatorPass = new CombinatorPass(),
       constructorPass = new ConstructorPass(),
       metavariablePass = new MetavariablePass(),
+      substitutionPass = new SubstitutionPass(),
       intrinsicLevelPass = new IntrinsicLevelPass();
 
 export function unifyStatement(generalStatement, specificStatement, generalContext, specificContext) {
@@ -359,7 +428,7 @@ export function unifySubstitution(generalSubstitution, specificSubstitution, gen
         specificSubstitutionNode = specificSubstitution.getNode(),
         generalNode = generalSubstitutionNode, ///
         specificNode = specificSubstitutionNode,  ///
-        success = metaLevelPass.run(generalNode, specificNode, generalContext, specificContext);
+        success = substitutionPass.run(generalNode, specificNode, generalContext, specificContext);
 
   if (success) {
     substitutionUnifies = 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/releaseContext.js

@@ -1,7 +1,7 @@
 "use strict";
 
 import { releaseContextUtilities } from "occam-languages";
-import { fileSystemUtilities as occamFileSystemUtilities } from "occam-file-system";
+import { fileSystemUtilities as occamFileSystemUtilities } from "occam-server";
 import { pathUtilities, fileSystemUtilities as necessaryFileSystemUtilities } from "necessary";
 
 const { loadProject } = occamFileSystemUtilities,

package/src/utilities/string.js

@@ -168,10 +168,10 @@ export function sectionStringFromHypothesesTopLevelAssertion(hypotheses, axiom,
 }
 
 export function subproofStringFromSuppositionsAndSubDerivation(suppositions, subDerivation) {
-  const lastProofAssertion = subDerivation.getLastProofAssertion(),
+  const lastStep = subDerivation.getLastStep(),
         suppositionsString = suppositionsStringFromSuppositions(suppositions),
-        lastProofAssertionString = lastProofAssertion.getString(),
-        subproofString = `[${suppositionsString}]...${lastProofAssertionString}`;
+        lastStepString = lastStep.getString(),
+        subproofString = `[${suppositionsString}]...${lastStepString}`;
 
   return subproofString;
 }

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;
     }
   });