occam-verify-cli 0.0.478 → 0.0.479

package/src/type.js

@@ -17,39 +17,45 @@ export default class Type {
   }
 
   isEqualTo(type) {
-    const equalToType = (this === type);
+    const equalTo = (this === type);
 
-    return equalToType;
+    return equalTo;
   }
 
   isSubTypeOf(type) {
-    let subTypeOfType = false;
+    let subTypeOf = false;
 
-    if (this.superType === type) {
-      subTypeOfType = true;
-    } else {
-      if (this.superType !== null) {
-        subTypeOfType = this.superType.isSubTypeOf(type);
+    let superType = this.superType;
+
+    while (superType !== null) {
+      if (superType === type) {
+        subTypeOf = true;
+
+        break;
       }
+
+      superType = superType.getSuperType();
     }
 
-    return subTypeOfType;
+    return subTypeOf;
   }
 
   isSuperTypeOf(type) {
-    let superTypeOfType = false;
+    let superTypeOf = false;
 
-    const superType = type.getSuperType();
+    let superType = type.getSuperType();
 
-    if (superType === this) {
-      superTypeOfType = true;
-    } else {
-      if (superType !== null) {
-        superTypeOfType = superType.isSuperTypeOf(this);
+    while (superType !== null) {
+      if (superType === this) {
+        superTypeOf = true;
+
+        break;
       }
+
+      superType = superType.getSuperType();
     }
 
-    return superTypeOfType;
+    return superTypeOf;
   }
 
   isEqualToOrSubTypeOf(type) {
@@ -68,13 +74,13 @@ export default class Type {
     return equalToTypeOrSuperTypeOf;
   }
 
-  isEqualToSubTypeOfOrSuperTypeOf(type) {
+  match(type) {
     const equalToType = this.isEqualTo(type),
           subTypeOfType = this.isSubTypeOf(type),
           superTypeOfType = this.isSuperTypeOf(type),
-          equalToTypeSubTypeOfOrSuperTypeOf = (equalToType || subTypeOfType || superTypeOfType);
+          matches = (equalToType || subTypeOfType || superTypeOfType);
 
-    return equalToTypeSubTypeOfOrSuperTypeOf;
+    return matches;
   }
 
   matchName(name) {

package/src/variable.js

@@ -1,10 +1,10 @@
 "use strict";
 
 export default class Variable {
-  constructor(type, name, value) {
+  constructor(type, name, termNode) {
     this.type = type;
     this.name = name;
-    this.value = value;
+    this.termNode = termNode;
   }
 
   getType() {
@@ -15,18 +15,12 @@ export default class Variable {
     return this.name;
   }
 
-  getValue() {
-    return this.value;
+  getTermNode() {
+    return this.termNode;
   }
 
-  isDefined() {
-    const defined = (this.value !== undefined);
-
-    return defined;
-  }
-
-  setValue(value) {
-    this.value = value;
+  setTermNode(termNode) {
+    this.termNode = termNode;
   }
 
   matchName(name) {
@@ -41,9 +35,9 @@ export default class Variable {
     if (variable === this) {
       equalTo = true;
     } else {
-      const value = variable.getValue();
+      const termNode = variable.getTermNode();
 
-      if (value === this.value) {
+      if (termNode === this.termNode) {
         equalTo = true;
       }
     }
@@ -66,8 +60,8 @@ export default class Variable {
   }
 
   static fromTypeAndName(type, name) {
-    const value = undefined,
-          variable = new Variable(type, name, value);
+    const termNode = null,
+          variable = new Variable(type, name, termNode);
 
     return variable;
   }

package/src/verify/assertion/type.js

@@ -97,8 +97,11 @@ function verifyVariableTypeAssertion(typeAssertionNode, proofContext) {
         firstVariable = first(variables),
         variable = firstVariable, ///
         variableName = variable.getName(),
-        variableType = variable.getType(),
-        assertedTypeEqualToOrSubTypeOfVariableType = assertedType.isEqualToOrSubTypeOf(variableType);
+        variableType = variable.getType();
+
+  const assertedTypeEqualToOrSubTypeOfVariableType = (variableType === null) ?
+                                                        true :  ///
+                                                          assertedType.isEqualToOrSubTypeOf(variableType);
 
   if (!assertedTypeEqualToOrSubTypeOfVariableType) {
     proofContext.error(`The asserted type is not equal to or a sub-type of the '${variableName}' variable type.`);

package/src/verify/equality.js

@@ -1,11 +1,13 @@
 "use strict";
 
 import Equality from "../equality";
+import Variable from "../variable";
 import verifyTerm from "../verify/term";
 
 import { nodeQuery } from "../utilities/query";
 import { nodeAsString } from "../utilities/string";
 import { first, second } from "../utilities/array";
+import { verifyTermAsVariable } from "../verify/term";
 import { MAXIMUM_INDEXES_LENGTH } from "../constants";
 
 const leftTermNodeQuery = nodeQuery("/equality/term[0]"),
@@ -20,37 +22,6 @@ export default function verifyEquality(equalityNode, proofContext) {
 
   proofContext.debug(`Verifying the '${equalityString}' equality...`);
 
-  const equalityTypesVerified = verifyEqualityTypes(equalityNode, proofContext);
-
-  if (equalityTypesVerified) {
-    const derived = proofContext.isDerived();
-
-    if (derived) {
-      const equality = Equality.fromEqualityNode(equalityNode),
-            proofSteps = proofContext.getProofSteps(),
-            equalities = equalitiesFromProofSteps(proofSteps),
-            equalityEquates = equality.equate(equalities, proofContext);
-
-      equalityVerified = equalityEquates;  ///
-    } else {
-      equalityVerified = true;
-    }
-  }
-
-  if (equalityVerified) {
-    proofContext.info(`Verified the '${equalityString}' equality.`);
-  }
-
-  equalityVerified ?
-    proofContext.complete(equalityNode) :
-      proofContext.halt(equalityNode);
-
-  return equalityVerified;
-}
-
-function verifyEqualityTypes(equalityNode, proofContext) {
-  let equalityTypesVerified = false;
-
   const types = [],
         context = proofContext,  ///
         leftTermNode = leftTermNodeQuery(equalityNode),
@@ -63,14 +34,66 @@ function verifyEqualityTypes(equalityNode, proofContext) {
           secondType = second(types),
           leftType = firstType, ///
           rightType = secondType, ///
-          leftTypeEqualToSubTypeOfOrSuperTypeOfRightType = leftType.isEqualToSubTypeOfOrSuperTypeOf(rightType);
+          leftTermString = nodeAsString(leftTermNode),
+          rightTermString = nodeAsString(rightTermNode);
+
+    if ((leftType === null) && (rightType === null)) {
+      proofContext.error(`The types of the '${leftTermString}' and '${rightTermString}' terms are both undefined and therefore the terms cannot be equated.`);
+    } else if (rightType === null) {
+      const type = leftType,  ///
+            termNode = rightTermNode, ///
+            variable = addVariable(type, termNode, proofContext);
+
+      if (variable !== null) {
+        const leftTypeName = leftType.getName();
+
+        proofContext.info(`The '${rightTermString}' variable has been given the '${leftTypeName}' type.`);
+
+        equalityVerified = true;
+      }
+    } else if (leftType === null) {
+      const type = rightType,  ///
+            termNode = leftType, ///
+            variable = addVariable(type, termNode, proofContext);
 
-    if (leftTypeEqualToSubTypeOfOrSuperTypeOfRightType) {
-      equalityTypesVerified = true;
+      if (variable !== null) {
+        const rightTypeName = rightType.getName();
+
+        proofContext.info(`The '${rightTermString}' variable has been given the '${rightTypeName}' type.`);
+
+        equalityVerified = true;
+      }
+    } else {
+      const leftTypeMatchesRightType = leftType.match(rightType);
+
+      if (!leftTypeMatchesRightType) {
+        proofContext.error(`The types of the '${leftTermString}' and '${rightTermString}' terms do not match and therefore the terms cannot be equated.`);
+      } else {
+        const derived = proofContext.isDerived();
+
+        if (!derived) {
+          equalityVerified = true;
+        } else {
+          const equality = Equality.fromEqualityNode(equalityNode),
+                proofSteps = proofContext.getProofSteps(),
+                equalities = equalitiesFromProofSteps(proofSteps),
+                equalityEquates = equality.equate(equalities, proofContext);
+
+          equalityVerified = equalityEquates;  ///
+        }
+      }
     }
   }
 
-  return equalityTypesVerified;
+  if (equalityVerified) {
+    proofContext.info(`Verified the '${equalityString}' equality.`);
+  }
+
+  equalityVerified ?
+    proofContext.complete(equalityNode) :
+      proofContext.halt(equalityNode);
+
+  return equalityVerified;
 }
 
 function equalitiesFromProofSteps(proofSteps) {
@@ -90,3 +113,24 @@ function equalitiesFromProofSteps(proofSteps) {
 
   return equalities;
 }
+
+function addVariable(type, termNode, proofContext) {
+  let variable = null;
+
+  const variables = [],
+        termVerifiedAsVariable = verifyTermAsVariable(termNode, variables, proofContext);
+
+  if (termVerifiedAsVariable) {
+    const firstVariable = first(variables);
+
+    variable = firstVariable;  ///
+
+    const name = variable.getName();
+
+    variable = Variable.fromTypeAndName(type, name);  ///
+
+    proofContext.addVariable(variable);
+  }
+
+  return variable;
+}

package/src/verify/statement/qualified.js

@@ -22,9 +22,14 @@ export default function verifyQualifiedStatement(qualifiedStatementNode, proofCo
 
       qualifiedStatementVerified = statementVerified; ///
     } else {
-      const referenceName = referenceNameFromReferenceNode(referenceNode);
+      const referenceName = referenceNameFromReferenceNode(referenceNode),
+            rule = proofContext.findRuleByReferenceName(referenceName);
 
-      debugger
+      if (rule !== null) {
+        const ruleMatchesStatement = rule.matchStatement(statementNode, proofContext);
+
+        qualifiedStatementVerified = ruleMatchesStatement;  ///
+      }
     }
   }
 

package/src/verify/statement.js

@@ -20,16 +20,18 @@ export default function verifyStatement(statementNode, proofContext) {
 
   proofContext.debug(`Verifying the '${statementString}' statement...`);
 
-  if (equalityNode !== null) {
+  if (false) {
+    ///
+  } else if (equalityNode !== null) {
     const equalityVerified = verifyEquality(equalityNode, proofContext);
 
     statementVerified = equalityVerified; ///
-  }
-
-  if (typeAssertionNode !== null) {
+  } else if (typeAssertionNode !== null) {
     const typeAssertionVerified = verifyTypeAssertion(typeAssertionNode, proofContext);
 
     statementVerified = typeAssertionVerified; ///
+  } else {
+    statementVerified = true;
   }
 
   statementVerified ?