occam-verify-cli 1.0.900 → 1.0.905

package/src/element/declaration/complexType.js

@@ -77,10 +77,18 @@ export default define(class ComplexTypeDeclaration extends Declaration {
           const propertyDeclarationsVerify = await this.verifyPropertyDeclaratisons(context);
 
           if (propertyDeclarationsVerify) {
-            const properties = this.getProperties();
+            const properties = this.getProperties(),
+                  typePrefix = context.getTypePrefix(),
+                  prefixName = (typePrefix !== null) ?
+                                 typePrefix.getPrefixName() :
+                                   null;
+
+            this.type.setProvisional(this.provisional);
 
             this.type.setProperties(properties);
 
+            this.type.setPrefixName(prefixName);
+
             context.addType(this.type);
 
             verifies = true;
@@ -231,7 +239,7 @@ export default define(class ComplexTypeDeclaration extends Declaration {
     const properties = this.getProperties();
 
     propertyDeclarationsVerify = await asyncEvery(this.propertyDeclarations, async (propertyDeclaration) => {
-      const propertyVerifes = await propertyDeclaration.verify(properties, context);
+      const propertyVerifes = await propertyDeclaration.verify(properties, this.type, context);
 
       if (propertyVerifes) {
         return true;

package/src/element/declaration/property.js

@@ -20,7 +20,7 @@ export default define(class PropertyDeclaration extends Declaration {
     return this.type;
   }
 
-  async verify(properties, context) {
+  async verify(properties, type, context) {
     let verifies = false;
 
     await this.break(context);
@@ -30,7 +30,7 @@ export default define(class PropertyDeclaration extends Declaration {
     context.trace(`Verifying the '${propertyDeclarationString}' property declaration...`);
 
     if (this.property !== null) {
-      const typeVerifies = this.verifyType(context);
+      const typeVerifies = this.verifyType(type, context);
 
       if (typeVerifies) {
         const propertyVerifies = this.verifyProperty(properties, context);
@@ -52,27 +52,36 @@ export default define(class PropertyDeclaration extends Declaration {
     return verifies;
   }
 
-  verifyType(context) {
+  verifyType(type, context) {
     let typeVerifies = false;
 
-    const typeString = this.type.getString(),
-          propertyDeclarationString = this.getString(); ///
+    const propertyDeclarationString = this.getString(); ///
 
-    context.trace(`Verifying the '${propertyDeclarationString}' property declaration's '${typeString}' type...`);
+    context.trace(`Verifying the '${propertyDeclarationString}' property declaration's type...`);
 
-    const typeName = this.type.getName(),
-          type = context.findTypeByTypeName(typeName);
+    const nominalTypeName = this.type.getNominalTypeName(),
+          comparesToNominalTypeName = type.compareNominalTypeName(nominalTypeName);
 
-    if (type !== null) {
+    if (comparesToNominalTypeName) {
       this.type = type;
 
       typeVerifies = true;
     } else {
-      context.debug(`The '${typeString}' type is not present.`);
+      const type = context.findTypeByTypeName(nominalTypeName);
+
+      if (type !== null) {
+        this.type = type;
+
+        typeVerifies = true;
+      } else {
+        const typeString = this.type.getString();
+
+        context.debug(`The '${typeString}' type is not present.`);
+      }
     }
 
     if (typeVerifies) {
-      context.debug(`...verified the '${propertyDeclarationString}' property declaration's '${typeString}' type`);
+      context.debug(`...verified the '${propertyDeclarationString}' property declaration's type`);
     }
 
     return typeVerifies;

package/src/element/declaration/simpleType.js

@@ -33,6 +33,12 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     return simpleTypeDeclarationNode;
   }
 
+  getProperties() {
+    const properties = [];
+
+    return properties;
+  }
+
   async verify(context) {
     let verifies = false;
 
@@ -51,20 +57,21 @@ export default define(class SimpleTypeDeclaration extends Declaration {
         const typePrefixVerifies = this.verifyTypePrefix(context);
 
         if (typePrefixVerifies) {
-          const propertiesVerifies = this.verifyProperties(context);
+          const properties = this.getProperties(),
+                typePrefix = context.getTypePrefix(),
+                prefixName = (typePrefix !== null) ?
+                               typePrefix.getPrefixName() :
+                                 null;
 
-          if (propertiesVerifies) {
-            const typePrefix = context.getTypePrefix(),
-                  prefixName = typePrefix.getPrefixName();
+          this.type.setProvisional(this.provisional);
 
-            this.type.setProvisional(this.provisional);
+          this.type.setProperties(properties);
 
-            this.type.setPrefixName(prefixName);
+          this.type.setPrefixName(prefixName);
 
-            context.addType(this.type);
+          context.addType(this.type);
 
-            verifies = true;
-          }
+          verifies = true;
         }
       }
     }
@@ -197,24 +204,5 @@ export default define(class SimpleTypeDeclaration extends Declaration {
     return typePrefixVerifies;
   }
 
-  verifyProperties(context) {
-    let propertiesVerify = true;  ///
-
-    const typeString = this.type.getString(),
-          simpleTypeDeclarationString = this.getString(); ///
-
-    context.trace(`Verifying the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type's properties...`);
-
-    const properties = [];
-
-    this.type.setProperties(properties);
-
-    if (propertiesVerify) {
-      context.debug(`...verified the '${simpleTypeDeclarationString}' simple type declaration's '${typeString}' type's properties.`);
-    }
-
-    return propertiesVerify;
-  }
-
   static name = "SimpleTypeDeclaration";
 });

package/src/element/equality.js

@@ -183,9 +183,9 @@ export default define(class Equality extends Element {
 
           const leftTermType = leftTerm.getType(),
                 rightTermType = rightTerm.getType(),
-                leftTermTypeComparableToRightTermType = leftTermType.isComparableTo(rightTermType);
+                leftTermTypeEqualToSubTypeOrSuperTypeOfRightTermType = leftTermType.isEqualToSubTypeOrSuperTypeOf(rightTermType);
 
-          if (leftTermTypeComparableToRightTermType) {
+          if (leftTermTypeEqualToSubTypeOrSuperTypeOfRightTermType) {
             validatesForwards = true;
           }
 

package/src/element/signature.js

@@ -6,9 +6,9 @@ import { arrayUtilities } from "necessary";
 import elements from "../elements";
 
 import { define } from "../elements";
-import { instantiate } from "../utilities/context";
 import { instantiateSignature } from "../process/instantiate";
 import { termsFromSignatureNode } from "../utilities/element";
+import { attempt, serialise, unserialise, instantiate } from "../utilities/context";
 
 const { match, compare, correlate } = arrayUtilities;
 
@@ -37,11 +37,17 @@ export default define(class Signature extends Element {
 
     context.trace(`Verifying the '${signatureString}' signature...`);
 
-    const signature = this.validate(context);
+    attempt((context) => {
+      const termsValidate = this.validateTerms(context);
 
-    if (signature !== null) {
-      verifies = true;
-    }
+      if (termsValidate !== null) {
+        verifies = true;
+      }
+
+      if (verifies) {
+        this.commit(context);
+      }
+    }, context);
 
     if (verifies) {
       context.debug(`...verified the '${signatureString}' signature.`);
@@ -50,71 +56,33 @@ export default define(class Signature extends Element {
     return verifies;
   }
 
-  validate(context) {
-    let signature = null;
+  validateTerms(context) {
+    let termsValidate;
 
     const signatureString = this.getString();  ///
 
-    context.trace(`Validating the '${signatureString}' signature...`);
-
-    const terms = [],
-          termsValidate = this.validateTerms(terms, context);
-
-    if (termsValidate) {
-      this.terms = terms;
-
-      signature = this; ///
-    }
-
-    if (signature) {
-      context.debug(`...validated the '${signatureString}' signature.`);
-    }
-
-    return signature
-  }
+    context.trace(`Validating the '${signatureString}' signature's terms...`);
 
-  validateTerm(term, terms, context) {
-    let termValidates = false;
+    const terms = [];
 
-    const termString = term.getString(),
-          signatureString = this.getString();  ///
+    termsValidate = this.terms.every((term) => {
+      term = term.validate(context, (term) => { ///
+        const validatesForwards = true;
 
-    context.trace(`Validating the '${signatureString}' signature's '${termString}' term...`);
+        return validatesForwards;
+      });
 
-    term = term.validate(context, (term) => { ///
-      const validatesForwards = true;
+      if (term !== null) {
+        terms.push(term);
 
-      return validatesForwards;
+        return true;
+      }
     });
 
-    if (term !== null) {
-      terms.push(term);
-
-      termValidates = true;
-    }
-
-    if (termValidates) {
-      context.debug(`...validated the '${signatureString}' signature's '${termString}' term.`);
+    if (termsValidate) {
+      this.terms = terms;
     }
 
-    return termValidates
-  }
-
-  validateTerms(terms, context) {
-    let termsValidate;
-
-    const signatureString = this.getString();  ///
-
-    context.trace(`Validating the '${signatureString}' signature's terms...`);
-
-    termsValidate = terms.every((term) => {
-      const termValidates = this.validateTerm(term, terms, context);
-
-      if (termValidates) {
-        return true;
-      }
-    })
-
     if (termsValidate){
       context.debug(`...validated the '${signatureString}' signature's terms.`);
     }
@@ -219,25 +187,35 @@ export default define(class Signature extends Element {
   static name = "Signature";
 
   toJSON() {
-    const string = this.getString(),
-          lineIndex = this.getLineIndex(),
-          json = {
-            string,
-            lineIndex
-          };
-
-    return json;
+    const context = this.getContext();
+
+    return serialise((context) => {
+      const string = this.getString(),
+            lineIndex = this.getLineIndex(),
+            json = {
+              context,
+              string,
+              lineIndex
+            };
+
+      return json;
+    }, context);
   }
 
   static fromJSON(json, context) {
-    return instantiate((context) => {
-      const { string, lineIndex } = json,
-            signatureNode = instantiateSignature(string, context),
-            node = signatureNode,  ///
-            terms = termsFromSignatureNode(signatureNode, context),
-            signature = new Signature(context, string, node, lineIndex, terms);
-
-      return signature;
-    }, context);
+    let signature;
+
+    unserialise((json, context) => {
+      instantiate((context) => {
+        const { string, lineIndex } = json,
+              signatureNode = instantiateSignature(string, context),
+              node = signatureNode,  ///
+              terms = termsFromSignatureNode(signatureNode, context);
+
+        signature = new Signature(context, string, node, lineIndex, terms);
+      }, context);
+    }, json, context);
+
+    return signature;
   }
 });

package/src/element/topLevelAssertion/axiom.js

@@ -58,7 +58,7 @@ export default define(class Axiom extends TopLevelAssertion {
 
     context.trace(`Verifying the '${axiomString}' axiom...`);
 
-    const signatureVerifies = this.verifySignature();
+    const signatureVerifies = this.verifySignature(context);
 
     if (signatureVerifies) {
       verifies = await super.verify(context);
@@ -75,16 +75,23 @@ export default define(class Axiom extends TopLevelAssertion {
     return verifies;
   }
 
-  verifySignature() {
+  verifySignature(context) {
     let signatureVerifies;
 
     const satisfiable = this.isSatisfiable();
 
     if (satisfiable) {
-      const context = this.getContext(),
-            signature = this.getSignature();
+      const axiomString = this.getString(); ///
+
+      context.trace(`Verifying the '${axiomString}' axiom's signature...`);
+
+      const signature = this.getSignature();
 
       signatureVerifies = signature.verify(context);
+
+      if (signatureVerifies) {
+        context.trace(`...verified the '${axiomString}' axiom's signature.`);
+      }
     } else {
       signatureVerifies = true
     }

package/src/element/type.js

@@ -210,15 +210,6 @@ export default define(class Type extends Element {
     return superTypeOf;
   }
 
-  isComparableTo(type) {
-    const equalTo = this.isEqualTo(type),
-          subTypeOf = this.isSubTypeOf(type),
-          superTypeOf = this.isSuperTypeOf(type),
-          comparableTo = (equalTo || subTypeOf || superTypeOf);
-
-    return comparableTo;
-  }
-
   isEqualToOrSubTypeOf(type) {
     const equalTo = this.isEqualTo(type),
           subTypeOf = this.isSubTypeOf(type),
@@ -235,6 +226,15 @@ export default define(class Type extends Element {
     return equalToOrSuperTypeOf;
   }
 
+  isEqualToSubTypeOrSuperTypeOf(type) {
+    const equalTo = this.isEqualTo(type),
+          subTypeOf = this.isSubTypeOf(type),
+          superTypeOf = this.isSuperTypeOf(type),
+          equalToSubTypeOrSuperTypeOf = (equalTo || subTypeOf || superTypeOf);
+
+    return equalToSubTypeOrSuperTypeOf;
+  }
+
   compareTypeName(typeName) {
     const nameTypeName = (this.name === typeName),
           comparesToTypeName = nameTypeName;  ///
@@ -259,22 +259,18 @@ export default define(class Type extends Element {
   compareNominalTypeName(nominalTypeName) {
     let comparesToNominalTypeName = false;
 
-    if (!comparesToNominalTypeName) {
-      const nominalTypeNameName = (this.name === nominalTypeName);
+    const nameNominalTypeName = (this.name === nominalTypeName);
 
-      if (nominalTypeNameName) {
-        comparesToNominalTypeName = true;
-      }
-    }
-
-    if (!comparesToNominalTypeName) {
+    if (nameNominalTypeName) {
+      comparesToNominalTypeName = true;
+    } else {
       const prefixed = this.isPrefixed();
 
       if (prefixed) {
         const prefixedName = this.getPrefixedName(),
-              nominalTypeNamePrefixedName = (nominalTypeName === prefixedName);
+              prefixedNameNominalTypeName = (prefixedName === nominalTypeName);
 
-        if (nominalTypeNamePrefixedName) {
+        if (prefixedNameNominalTypeName) {
           comparesToNominalTypeName = true;
         }
       }

package/src/utilities/assignment.js

@@ -11,9 +11,9 @@ export function variableAssignmentFromTermAndType(term, type, context) {
 
   if (termSingular) {
     const termType = term.getType(),
-          termTypeEqualToType = termType.isEqualTo(type);
+          termTypeSuperTypeOfType = termType.isSuperTypeOf(type);
 
-    if (!termTypeEqualToType) {
+    if (termTypeSuperTypeOfType) {
       const variableNode = term.getVariableNode(),
             variable = variableFromVariableNode(variableNode, context);
 

package/src/utilities/element.js

@@ -1166,7 +1166,7 @@ export function frameFromJudgementNode(judgementNode, context) {
 }
 
 export function termsFromSignatureNode(signatureNode, context) {
-  const termNodes = signatureNode.getAssumptionNodes(),
+  const termNodes = signatureNode.getTermNodes(),
         terms = termsFromTermNodes(termNodes, context);
 
   return terms;

package/src/utilities/json.js

@@ -518,11 +518,11 @@ export function referencesFromJSON(json, context) {
   let { references } = json;
 
   const { Reference } = elements,
-        referencesJSON = references; ///
+    referencesJSON = references; ///
 
   references = referencesJSON.map((referenceJSON) => {
     const json = referenceJSON,  ///
-          reference = Reference.fromJSON(json, context);
+      reference = Reference.fromJSON(json, context);
 
     return reference;
   });
@@ -530,6 +530,22 @@ export function referencesFromJSON(json, context) {
   return references;
 }
 
+export function signaturesFromJSON(json, context) {
+  let { signatures } = json;
+
+  const { Signature } = elements,
+        signaturesJSON = signatures; ///
+
+  signatures = signaturesJSON.map((signatureJSON) => {
+    const json = signatureJSON,  ///
+          signature = Signature.fromJSON(json, context);
+
+    return signature;
+  });
+
+  return signatures;
+}
+
 export function conjecturesFromJSON(json, context) {
   let { conjectures } = json;
 
@@ -1072,6 +1088,16 @@ export function statementsToStatementsJSON(statements) {
   return statementsJSON;
 }
 
+export function signaturesToSignaturesJSON(signatures) {
+  const signaturesJSON = signatures.map((signature) => {
+    const signatureJSON = signature.toJSON();
+
+    return signatureJSON;
+  });
+
+  return signaturesJSON;
+}
+
 export function assertionsToAssertionsJSON(assertions) {
   const assertionsJSON = assertions.map((assertion) => {
     const assertionJSON = assertion.toJSON();

package/src/utilities/synoptic.js

@@ -74,6 +74,16 @@ export function compressStatements(statements) {
   });
 }
 
+export function compressSignatures(signatures) {
+  compress(signatures, (signatureA, signatureB) => {
+    const signatureAEqualToSignatureB = signatureA.isEqualTo(signatureB);
+
+    if (!signatureAEqualToSignatureB) {
+      return true;
+    }
+  });
+}
+
 export function compressReferences(references) {
   compress(references, (referenceA, referenceB) => {
     const referenceAEqualToReferenceB = referenceA.isEqualTo(referenceB);