Detailed error messages

index.ts

@@ -1,4 +1,10 @@
-export * from "./lib/result";
+export {
+  // Because lib/result has a bunch of pretty-printing helpers and such,
+  // we only export specific thigns  publically
+  Result,
+  Err,
+  StructuralError,
+} from "./lib/result";
 export * from "./lib/type";
 export * from "./lib/get-type";
 export * from "./lib/match"

lib/checks/any.ts

@@ -5,6 +5,10 @@ export class Any extends Type<any> {
   check(val: any): Result<any> {
     return val;
   }
+
+  toString() {
+    return 'any'
+  }
 }
 
 export const any = new Any();

lib/checks/array.ts

@@ -10,17 +10,27 @@ export class Arr<T> extends Type<Array<T>> {
   }
 
   check(val: any): Result<Array<T>> {
-    if(!Array.isArray(val)) return new Err(`${val} is not an array`);
+    if(!Array.isArray(val)) return this.err(`not an array`, val)
 
-    for(const el of val) {
-      const result = this.elementType.check(el);
-      // Don't bother collecting all errors in an array: for long arrays this is very obnoxious
-      if(result instanceof Err) return new Err(result.message);
+
+    // use traditional iteration so we know the index
+    for (let i = 0; i<val.length; i++) {
+      if (i in val) { // support sparse arrays
+        const el = val[i]
+        const result = this.elementType.check(el);
+        if (result instanceof Err) {
+          return Err.lift(result, i)
+        }
+      }
     }
 
     // If we got this far, there were no errors; it's an Array<T>
     return val as Array<T>;
   }
+
+  toString() {
+    return `Array<${this.elementType}>`
+  }
 }
 
 export function array<T>(t: Type<T>): Arr<T> {

lib/checks/dict.ts

@@ -13,17 +13,21 @@ export class Dict<V> extends Type<RawDict<V>> {
   }
 
   check(val: any): Result<RawDict<V>> {
-    if(typeof val !== 'object') return new Err(`${val} is not an object`);
-    if(Array.isArray(val)) return new Err(`${val} is an array`);
-    if(val === null) return new Err(`${val} is null`);
+    if(typeof val !== 'object') return this.err(`not an object`, val);
+    if(Array.isArray(val)) return this.err(`is an array`, val);
+    if(val === null) return this.err(`is null`, val);
 
     for(const prop in val) {
       const result = this.valueType.check(val[prop]);
-      if(result instanceof Err) return new Err(`[${prop}]: ${result.message}`);
+      if(result instanceof Err) return Err.lift(result, prop)
     }
 
     return val as Result<RawDict<V>>;
   }
+
+  toString() {
+    return `{ [key: string]: ${this.valueType} }`
+  }
 }
 
 export function dict<V>(v: Type<V>): Dict<V> {

lib/checks/instance-of.ts

@@ -1,4 +1,4 @@
-import { Err, Result } from "../result";
+import { Result } from "../result";
 import { Type } from "../type";
 
 type Constructor<T> = Function & { prototype: T }
@@ -13,7 +13,14 @@ export class InstanceOf<T> extends Type<T> {
 
   check(val: any): Result<T> {
     if(val instanceof this.klass) return val;
-    return new Err(`${val} is not an instance of ${this.klass}`);
+    return this.err(() => `not an instance of ${this.klass}`, val);
+  }
+
+  toString() {
+    if (this.klass.name) {
+      return this.klass.name
+    }
+    return `instanceof ${this.klass}`
   }
 }
 

lib/checks/is.ts

@@ -1,4 +1,4 @@
-import { Err, Result } from "../result";
+import { Result } from "../result";
 import { Type } from "../type";
 
 type Guard<T> = (val: any) => val is T
@@ -15,7 +15,11 @@ export class Is<T> extends Type<T> {
 
   check(val: any): Result<T> {
     if(this.isT(val)) return val;
-    return new Err(`${val} is not a ${this.name} (guard failed)`)
+    return this.err(`guard failed`, val)
+  }
+
+  toString() {
+    return `is(${this.name}, ${this.isT})`
   }
 }
 

lib/checks/map.ts

@@ -1,4 +1,4 @@
-import { Err, Result } from "../result";
+import { Err, MapKey, MapKeyIndex, Result } from "../result";
 import { Type } from "../type";
 
 export class MapType<K, V> extends Type<Map<K, V>> {
@@ -12,17 +12,23 @@ export class MapType<K, V> extends Type<Map<K, V>> {
   }
 
   check(val: any): Result<Map<K, V>> {
-    if(!(val instanceof Map)) return new Err(`${val} is not an instance of Map`);
+    if(!(val instanceof Map)) return this.err(`not a Map`, val);
 
+    let i = 0
     for(const [k, v] of val) {
       const kResult = this.keyType.check(k);
-      if(kResult instanceof Err) return new Err(`{val} key error: ${kResult.message}`);
+      if(kResult instanceof Err) return Err.lift(kResult, new MapKeyIndex(i))
       const vResult = this.valueType.check(v);
-      if(vResult instanceof Err) return new Err(`{val} value error: ${vResult.message}`);
+      if(vResult instanceof Err) return Err.lift(vResult, new MapKey(k))
+      i++
     }
 
     return val as Map<K, V>;
   }
+
+  toString() {
+    return `Map<${this.keyType}, ${this.valueType}>`
+  }
 }
 
 export function map<K, V>(k: Type<K>, v: Type<V>): MapType<K, V> {

lib/checks/never.ts

@@ -1,10 +1,2 @@
-import { Result, Err } from "../result";
-import { Type } from "../type";
-
-export class Never extends Type<never> {
-  check(_: any): Result<never> {
-    return new Err('never')
-  }
-}
-
-export const never = new Never();
+import { never, Never } from "../type";
+export { never, Never }

lib/checks/set.ts

@@ -1,4 +1,4 @@
-import { Err, Result } from "../result";
+import { Err, Result, MapKeyIndex } from "../result";
 import { Type } from "../type";
 
 export class SetType<V> extends Type<Set<V>> {
@@ -10,13 +10,19 @@ export class SetType<V> extends Type<Set<V>> {
   }
 
   check(val: any): Result<Set<V>> {
-    if(!(val instanceof Set)) return new Err(`${val} is not an instance of Set`);
+    if(!(val instanceof Set)) return this.err(`not an instance of Set`, val);
+    let i = 0
     for(const v of val) {
       const result = this.valueType.check(v);
-      if(result instanceof Err) return new Err(`{val} failed set check on value ${v}: ${result.message}`);
+      if(result instanceof Err) return Err.lift(result, new MapKeyIndex(i))
+      i++
     }
     return val as Set<V>;
   }
+
+  toString() {
+    return `Set<${this.valueType}>`
+  }
 }
 
 export function set<V>(v: Type<V>): SetType<V> {

lib/checks/struct.ts

@@ -1,4 +1,4 @@
-import { Err } from "../result";
+import { Err, shouldWrap, indentNext } from "../result";
 import { KeyTrackResult, Type, KeyTrackingType } from "../type";
 import { GetType } from "../get-type";
 
@@ -72,35 +72,59 @@ export class Struct<T extends TypeStruct> extends KeyTrackingType<UnwrappedTypeS
       }
     }
 
-    return new Err(`${val} failed the following checks:\n${errs.join('\n')}`);
+    if (errs.length === 1) {
+      return errs[0]
+    }
+
+    return Err.combine(errs, {
+      value: val,
+      type: this,
+    })
   }
 
   private checkType(val: any): Err<UnwrappedTypeStruct<T>> | undefined {
-    if(typeof val !== 'object') return new Err(`${val} is not an object`);
-    if(Array.isArray(val)) return new Err(`${val} is an array`);
-    if(val === null) return new Err(`${val} is null`);
+    if(typeof val !== 'object') return this.err(`isn't an object`, val)
+    if(Array.isArray(val)) return this.err('is an array', val)
+    if(val === null) return this.err('is null', val)
     return undefined;
   }
 
-  private checkFields(val: any): string[] {
-    const errs: string[] = [];
+  private checkFields(val: any): Err<any>[] {
+    const errs: Err<any>[] = [];
     for(const prop in this.definition) {
       const field = this.definition[prop]
       if (!(prop in val)) {
         if (isOptional(field)) {
           continue;
         }
 
-        errs.push(`missing key '${prop}'`);
+        errs.push(new Err('key missing', {
+          path: [prop],
+          type: keyType(field),
+          value: undefined,
+        }))
         continue;
       }
 
       const result = keyType(field).check(val[prop]);
-      if(result instanceof Err) errs.push(result.message);
+      if(result instanceof Err) errs.push(Err.lift(result, prop));
     }
 
     return errs;
   }
+
+  toString() {
+    const kvs: string[] = []
+    Object.keys(this.definition).forEach(key => {
+      const value = this.definition[key]
+      const keystr = isOptional(value) ? `${key}?: ` : `${key}: `
+      // is this cooL??? hard to reason about
+      const valstr = keyType(value).toString()
+      kvs.push(keystr + valstr)
+    })
+    const sep = shouldWrap(kvs) ? ",\n" : ', '
+    return '{ ' + indentNext(kvs.join(sep)) + ' }'
+  }
 }
 
 type HiddenStruct<T extends TypeStruct> = Type<UnwrappedTypeStruct<T>>;

lib/checks/type-of.ts

@@ -1,4 +1,4 @@
-import { Err, Result } from "../result";
+import { Result } from "../result";
 import { Type } from "../type";
 
 export class TypeOf<T> extends Type<T> {
@@ -10,7 +10,11 @@ export class TypeOf<T> extends Type<T> {
 
   check(val: any): Result<T> {
     if(typeof val === this.typestring) return val as T;
-    return new Err(`${val} is not a ${this.typestring}`);
+    return this.err(`not a ${this.typestring}`, val)
+  }
+
+  toString() {
+    return this.typestring
   }
 }
 

lib/checks/value.ts

@@ -1,4 +1,4 @@
-import { Err, Result } from "../result";
+import { Result } from "../result";
 import { Type } from "../type";
 
 export class Value<T> extends Type<T> {
@@ -10,7 +10,17 @@ export class Value<T> extends Type<T> {
 
   check(val: any): Result<T> {
     if(val === this.val) return val;
-    return new Err(`${val} is not equal to ${this.val}`);
+    return this.err('not equal', val)
+  }
+
+  toString() {
+    if (typeof this.val === 'string' ||
+        typeof this.val === 'number' ||
+        this.val === null
+       ) {
+      return JSON.stringify(this.val)
+    }
+    return `=== ${this.val}`
   }
 }