occam-verify-cli 1.0.707 → 1.0.708

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "occam-verify-cli",
   "author": "James Smith",
-  "version": "1.0.707",
+  "version": "1.0.708",
   "license": "MIT, Anti-996",
   "homepage": "https://github.com/djalbat/occam-verify-cli",
   "description": "Occam's Verifier",

package/src/element/assertion/type.js

@@ -4,9 +4,9 @@ import Assertion from "../assertion";
 
 import { define } from "../../elements";
 import { literally } from "../../utilities/context";
-import { typeFromJSON } from "../../utilities/json";
+import { instantiateTypeAssertion } from "../../process/instantiate";
 import { termFromTypeAssertionNode } from "../../utilities/element";
-import { instantiateSubproofAssertion } from "../../process/instantiate";
+import { typeFromJSON, typeToTypeJSON } from "../../utilities/json";
 import { variableAssignmentFromTypeAssertion } from "../../process/assign";
 
 export default define(class TypeAssertion extends Assertion {
@@ -216,7 +216,7 @@ export default define(class TypeAssertion extends Assertion {
     if (this.name === name) {
       literally((context) => {
         const { string } = json,
-              typeAssertionNode = instantiateSubproofAssertion(string, context),
+              typeAssertionNode = instantiateTypeAssertion(string, context),
               term = termFromTypeAssertionNode(typeAssertionNode, context),
               type = typeFromJSON(json, context),
               node = typeAssertionNode; ///

package/src/element/combinator.js

@@ -36,9 +36,9 @@ export default define(class Combinator extends Element {
     context.trace(`Verifying the '${combinatorString}' combinator...`);
 
     attempt((context) => {
-      const statementVerifiesAsCombinator = verifyStatementAsCombinator(this.statement, context);
+      const statementVerifies = this.verifyStatement(context);
 
-      if (statementVerifiesAsCombinator) {
+      if (statementVerifies) {
         this.setContext(context);
 
         verifies = true;
@@ -52,6 +52,27 @@ export default define(class Combinator extends Element {
     return verifies;
   }
 
+  verifyStatement(context) {
+    let statementVerifies = false;
+
+    const statementString = this.statement.getString(),
+          combinatorString = this.getString();  ///
+
+    context.trace(`Verifying the '${combinatorString}' combinator's '${statementString}' statement...`);
+
+    const statementVerifiesAsCombinator = verifyStatementAsCombinator(this.statement, context);
+
+    if (statementVerifiesAsCombinator) {
+      statementVerifies = true;
+    }
+
+    if (statementVerifies) {
+      context.debug(`...verified the '${combinatorString}' combinator's '${statementString}' statement.`);
+    }
+
+    return statementVerifies;
+  }
+
   unifyStatement(statement, stated, context) {
     let statementUnifies;
 

package/src/element/constructor.js

@@ -8,19 +8,24 @@ import { instantiateConstructor } from "../process/instantiate";
 import { verifyTermAsConstructor } from "../process/verify";
 import { termFromConstructorNode } from "../utilities/element";
 import { unifyTermWithConstructor } from "../process/unify";
-import { termToTermJSON, ephemeralContextFromJSON } from "../utilities/json";
+import { typeFromJSON, termToTermJSON, typeToTypeJSON, ephemeralContextFromJSON } from "../utilities/json";
 
 export default define(class Constructor extends Element {
-  constructor(context, string, node, term) {
-    super(context, string, node);
+  constructor(context, string, node, term, type) {
+    super(context, string, node, type);
 
     this.term = term;
+    this.type = type;
   }
 
   getTerm() {
     return this.term;
   }
 
+  getType() {
+    return this.type;
+  }
+
   getConclusionNode() {
     const node = this.getNode(),
           constructorNode = node;  ///
@@ -28,15 +33,12 @@ export default define(class Constructor extends Element {
     return constructorNode;
   }
 
-  getType() { return this.term.getType(); }
-
   getString(includeType = true) {
     let string;
 
     if (includeType) {
-      const type = this.getType(),
-            typeString = type.getString(),
-            termString = this.term.getString();
+      const termString = this.term.getString(),
+            typeString = this.type.getString();
 
       string = `${termString}.${typeString}`;
     } else {
@@ -46,7 +48,9 @@ export default define(class Constructor extends Element {
     return string;
   }
 
-  setType(type) { this.term.setType(type); }
+  setType(type) {
+    this.type = type;
+  }
 
   verify(context) {
     let verifies = false;
@@ -57,9 +61,9 @@ export default define(class Constructor extends Element {
     context.trace(`Verifying the '${constructorString}' constructor...`);
 
     attempt((context) => {
-      const termVerifiesAsConstructor = verifyTermAsConstructor(this.term, context);
+      const termVerifies = this.verifyTerm(context);
 
-      if (termVerifiesAsConstructor) {
+      if (termVerifies) {
         this.setContext(context);
 
         verifies = true;
@@ -73,6 +77,28 @@ export default define(class Constructor extends Element {
     return verifies;
   }
 
+  verifyTerm(context) {
+    let termVerifies = false;
+
+    const termString = this.term.getString(),
+          includeType = false,
+          constructorString = this.getString(includeType);
+
+    context.trace(`Verifying the '${constructorString}' constructor's '${termString}' term...`);
+
+    const termVerifiesAsConstructor = verifyTermAsConstructor(this.term, context);
+
+    if (termVerifiesAsConstructor) {
+      termVerifies = true;
+    }
+
+    if (termVerifies) {
+      context.debug(`...verified the '${constructorString}' constructor's '${termString}' term.`);
+    }
+
+    return termVerifies;
+  }
+
   unifyTerm(term, context, validateForwards) {
     let termUnifies = false;
 
@@ -95,9 +121,7 @@ export default define(class Constructor extends Element {
     if (termUnifiesWithConstructor) {
       let validatesForwards;
 
-      const type = this.getType();
-
-      term.setType(type);
+      term.setType(this.type);
 
       validatesForwards = validateForwards();
 
@@ -122,12 +146,15 @@ export default define(class Constructor extends Element {
 
     const includeType = false,
           termJSON = termToTermJSON(this.term),
+          typeJSON = typeToTypeJSON(this.type),
           string = this.getString(includeType),
           term = termJSON,  ///
+          type = typeJSON,  ///
           json = {
             context,
             string,
-            term
+            term,
+            type
           };
 
     return json;
@@ -141,11 +168,12 @@ export default define(class Constructor extends Element {
             constructorNode = instantiateConstructor(string, context),
             node = constructorNode, ///
             term = termFromConstructorNode(constructorNode, context),
+            type = typeFromJSON(json, context),
             ephemeralContext = ephemeralContextFromJSON(json, context);
 
       context = ephemeralContext; ///
 
-      const constructor = new Constructor(context, string, node, term);
+      const constructor = new Constructor(context, string, node, term, type);
 
       return constructor;
 

package/src/process/instantiate.js

@@ -23,6 +23,7 @@ import { TERM_RULE_NAME,
          CONSTRUCTOR_RULE_NAME,
          EQUIVALENCE_RULE_NAME,
          METAVARIABLE_RULE_NAME,
+         TYPE_ASSERTION_RULE_NAME,
          PROCEDURE_CALL_RULE_NAME,
          PROPERTY_RELATION_RULE_NAME,
          DEFINED_ASSERTION_RULE_NAME,
@@ -57,7 +58,8 @@ const termPlaceholderRule = ruleFromRuleName(TERM_RULE_NAME),
       constructorPlaceholderRule = ruleFromRuleName(CONSTRUCTOR_RULE_NAME),
       equivalencePlaceholderRule = ruleFromRuleName(EQUIVALENCE_RULE_NAME),
       metavariablePlaceholderRule = ruleFromRuleName(METAVARIABLE_RULE_NAME),
-      procedureCalllaceholderRule = ruleFromRuleName(PROCEDURE_CALL_RULE_NAME),
+      typeAssertionPlaceholderRule = ruleFromRuleName(TYPE_ASSERTION_RULE_NAME),
+      procedureCallPlaceholderRule = ruleFromRuleName(PROCEDURE_CALL_RULE_NAME),
       propertyRelationlaceholderRule = ruleFromRuleName(PROPERTY_RELATION_RULE_NAME),
       definedAssertionPlaceholderRule = ruleFromRuleName(DEFINED_ASSERTION_RULE_NAME),
       termSubstitutionPlaceholderRule = ruleFromRuleName(TERM_SUBSTITUTION_RULE_NAME),
@@ -133,7 +135,9 @@ export function instantiateEquivalence(string, context) { return instantiate(equ
 
 export function instantiateMetavariable(string, context) { return instantiate(metavariablePlaceholderRule, string, context); }
 
-export function instantiateProcedureCall(string, context) { return instantiate(procedureCalllaceholderRule, string, context); }
+export function instantiateTypeAssertion(string, context) { return instantiate(typeAssertionPlaceholderRule, string, context); }
+
+export function instantiateProcedureCall(string, context) { return instantiate(procedureCallPlaceholderRule, string, context); }
 
 export function instantiatePropertyRelation(string, context) { return instantiate(propertyRelationlaceholderRule, string, context); }
 

package/src/process/unify.js

@@ -234,15 +234,13 @@ class CombinatorPass extends ZipPass {
 
         const type = context.findTypeByNominalTypeName(nominalTypeName);
 
-        if (type !== null) {
-          context = specificContext;  ///
+        context = specificContext;  ///
 
-          const term = termFromTermNode(termNode, context),
-                termValidatesGivenType = term.validateGivenType(type, context);
+        const term = termFromTermNode(termNode, context),
+              termValidatesGivenType = term.validateGivenType(type, context);
 
-          if (termValidatesGivenType) {
-            success = true;
-          }
+        if (termValidatesGivenType) {
+          success = true;
         }
 
         return success;

package/src/utilities/element.js

@@ -482,7 +482,8 @@ export function constructorFromConstructorNode(constructorNode, context) {
         node = constructorNode, ///
         string = context.nodeAsString(node),
         term = termFromConstructorNode(constructorNode, context),
-        constructor = new Constructor(context, string, node, term);
+        type = typeFromConstructorNode(constructorNode, context),
+        constructor = new Constructor(context, string, node, term, type);
 
   return constructor;
 }
@@ -998,6 +999,12 @@ export function termFromConstructorNode(ocnstructorNode, context) {
   return term;
 }
 
+export function typeFromConstructorNode(ocnstructorNode, context) {
+  const type = null;
+
+  return type;
+}
+
 export function assumptionsFromFrameNode(frameNode, context) {
   const assumptionNodes = frameNode.getAssumptionNodes(),
         assumptions = assumptionsFromAssumptionNodes(assumptionNodes, context);