decoders 2.0.0-beta8 → 2.0.0-beta9

package/core/either.js

@@ -1,14 +1,7 @@
 "use strict";
 
 exports.__esModule = true;
-exports.either = either;
-exports.either3 = either3;
-exports.either4 = either4;
-exports.either5 = either5;
-exports.either6 = either6;
-exports.either7 = either7;
-exports.either8 = either8;
-exports.either9 = either9;
+exports.either = void 0;
 exports.oneOf = oneOf;
 
 var _annotate = require("../annotate");
@@ -17,9 +10,11 @@ var _result = require("../result");
 
 var _utils = require("../_utils");
 
+var EITHER_PREFIX = 'Either:\n';
 /**
  * Indents and adds a dash in front of this (potentially multiline) string.
  */
+
 function itemize(s) {
   return '-' + (0, _utils.indent)(s).substring(1);
 }
@@ -51,51 +46,44 @@ function itemize(s) {
 
 
 function nest(errText) {
-  var EITHER_PREFIX = 'Either:\n';
   return errText.startsWith(EITHER_PREFIX) ? errText.substr(EITHER_PREFIX.length) : itemize(errText);
-}
+} // prettier-ignore
 
-function either(d1, d2) {
-  return function (blob) {
-    return (0, _result.orElse)(d1(blob), function (err1) {
-      return (0, _result.orElse)(d2(blob), function (err2) {
-        var serr1 = (0, _utils.summarize)(err1).join('\n');
-        var serr2 = (0, _utils.summarize)(err2).join('\n');
-        var text = ['Either:', nest(serr1), nest(serr2)].join('\n');
-        return (0, _result.err)((0, _annotate.annotate)(blob, text));
-      });
-    });
-  };
-}
 
-function either3(d1, d2, d3) {
-  return either(d1, either(d2, d3));
-}
+function _either() {
+  for (var _len = arguments.length, decoders = new Array(_len), _key = 0; _key < _len; _key++) {
+    decoders[_key] = arguments[_key];
+  }
 
-function either4(d1, d2, d3, d4) {
-  return either(d1, either3(d2, d3, d4));
-}
+  if (decoders.length === 0) {
+    throw new Error('Pass at least one decoder to either()');
+  }
 
-function either5(d1, d2, d3, d4, d5) {
-  return either(d1, either4(d2, d3, d4, d5));
-}
+  return function (blob) {
+    // Collect errors here along the way
+    var errors = [];
 
-function either6(d1, d2, d3, d4, d5, d6) {
-  return either(d1, either5(d2, d3, d4, d5, d6));
-}
+    for (var _i = 0; _i < decoders.length; _i++) {
+      var result = decoders[_i](blob);
 
-function either7(d1, d2, d3, d4, d5, d6, d7) {
-  return either(d1, either6(d2, d3, d4, d5, d6, d7));
-}
+      if (result.ok) {
+        return result;
+      } else {
+        errors.push(result.error);
+      }
+    } // Decoding all alternatives failed, return the combined error message
 
-function either8(d1, d2, d3, d4, d5, d6, d7, d8) {
-  return either(d1, either7(d2, d3, d4, d5, d6, d7, d8));
-}
 
-function either9(d1, d2, d3, d4, d5, d6, d7, d8, d9) {
-  return either(d1, either8(d2, d3, d4, d5, d6, d7, d8, d9));
+    var text = EITHER_PREFIX + errors.map(function (err) {
+      return nest((0, _utils.summarize)(err).join('\n'));
+    }).join('\n');
+    return (0, _result.err)((0, _annotate.annotate)(blob, text));
+  };
 }
 
+var either = _either;
+exports.either = either;
+
 function oneOf(constants) {
   return function (blob) {
     var winner = constants.find(function (c) {

package/core/either.js.flow

@@ -1,9 +1,12 @@
 // @flow strict
 
 import { annotate } from '../annotate';
-import { err, ok, orElse } from '../result';
+import { err, ok } from '../result';
 import { indent, summarize } from '../_utils';
-import type { Decoder, Scalar } from '../_types';
+import type { _Any } from '../_utils';
+import type { Decoder, DecodeResult, Scalar } from '../_types';
+
+const EITHER_PREFIX = 'Either:\n';
 
 /**
  * Indents and adds a dash in front of this (potentially multiline) string.
@@ -38,100 +41,51 @@ function itemize(s: string): string {
  *
  */
 function nest(errText: string): string {
-    const EITHER_PREFIX = 'Either:\n';
     return errText.startsWith(EITHER_PREFIX)
         ? errText.substr(EITHER_PREFIX.length)
         : itemize(errText);
 }
 
-export function either<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<T1 | T2> {
-    return (blob: mixed) =>
-        orElse(d1(blob), (err1) =>
-            orElse(d2(blob), (err2) => {
-                const serr1 = summarize(err1).join('\n');
-                const serr2 = summarize(err2).join('\n');
-                const text = ['Either:', nest(serr1), nest(serr2)].join('\n');
-                return err(annotate(blob, text));
-            }),
-        );
-}
-
-export function either3<T1, T2, T3>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-): Decoder<T1 | T2 | T3> {
-    return either(d1, either(d2, d3));
+// prettier-ignore
+interface EitherDecoderSignatures {
+  <A>(a: Decoder<A>): Decoder<A>;
+  <A, B>(a: Decoder<A>, b: Decoder<B>): Decoder<A | B>;
+  <A, B, C>(a: Decoder<A>, b: Decoder<B>, c: Decoder<C>): Decoder<A | B | C>;
+  <A, B, C, D>(a: Decoder<A>, b: Decoder<B>, c: Decoder<C>, d: Decoder<D>): Decoder<A | B | C | D>;
+  <A, B, C, D, E>(a: Decoder<A>, b: Decoder<B>, c: Decoder<C>, d: Decoder<D>, e: Decoder<E>): Decoder<A | B | C | D | E>;
+  <A, B, C, D, E, F>(a: Decoder<A>, b: Decoder<B>, c: Decoder<C>, d: Decoder<D>, e: Decoder<E>, f: Decoder<F>): Decoder<A | B | C | D | E | F>;
+  <A, B, C, D, E, F, G>(a: Decoder<A>, b: Decoder<B>, c: Decoder<C>, d: Decoder<D>, e: Decoder<E>, f: Decoder<F>, g: Decoder<G>): Decoder<A | B | C | D | E | F | G>;
+  <A, B, C, D, E, F, G, H>(a: Decoder<A>, b: Decoder<B>, c: Decoder<C>, d: Decoder<D>, e: Decoder<E>, f: Decoder<F>, g: Decoder<G>, h: Decoder<H>): Decoder<A | B | C | D | E | F | G | H>;
+  <A, B, C, D, E, F, G, H, I>(a: Decoder<A>, b: Decoder<B>, c: Decoder<C>, d: Decoder<D>, e: Decoder<E>, f: Decoder<F>, g: Decoder<G>, h: Decoder<H>, i: Decoder<I>): Decoder<A | B | C | D | E | F | G | H | I>;
 }
 
-export function either4<T1, T2, T3, T4>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-): Decoder<T1 | T2 | T3 | T4> {
-    return either(d1, either3(d2, d3, d4));
-}
-
-export function either5<T1, T2, T3, T4, T5>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-): Decoder<T1 | T2 | T3 | T4 | T5> {
-    return either(d1, either4(d2, d3, d4, d5));
-}
+function _either(...decoders: $ReadOnlyArray<Decoder<mixed>>): Decoder<mixed> {
+    if (decoders.length === 0) {
+        throw new Error('Pass at least one decoder to either()');
+    }
 
-export function either6<T1, T2, T3, T4, T5, T6>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>,
-): Decoder<T1 | T2 | T3 | T4 | T5 | T6> {
-    return either(d1, either5(d2, d3, d4, d5, d6));
-}
+    return (blob: mixed) => {
+        // Collect errors here along the way
+        const errors = [];
 
-export function either7<T1, T2, T3, T4, T5, T6, T7>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>,
-    d7: Decoder<T7>,
-): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7> {
-    return either(d1, either6(d2, d3, d4, d5, d6, d7));
-}
+        for (let i = 0; i < decoders.length; i++) {
+            const result: DecodeResult<mixed> = decoders[i](blob);
+            if (result.ok) {
+                return result;
+            } else {
+                errors.push(result.error);
+            }
+        }
 
-export function either8<T1, T2, T3, T4, T5, T6, T7, T8>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>,
-    d7: Decoder<T7>,
-    d8: Decoder<T8>,
-): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8> {
-    return either(d1, either7(d2, d3, d4, d5, d6, d7, d8));
+        // Decoding all alternatives failed, return the combined error message
+        const text =
+            EITHER_PREFIX +
+            errors.map((err) => nest(summarize(err).join('\n'))).join('\n');
+        return err(annotate(blob, text));
+    };
 }
 
-export function either9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>,
-    d7: Decoder<T7>,
-    d8: Decoder<T8>,
-    d9: Decoder<T9>,
-): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9> {
-    return either(d1, either8(d2, d3, d4, d5, d6, d7, d8, d9));
-}
+export const either: EitherDecoderSignatures = (_either: _Any);
 
 export function oneOf<T: Scalar>(constants: $ReadOnlyArray<T>): Decoder<T> {
     return (blob: mixed) => {

package/core/either.mjs

@@ -1,10 +1,11 @@
 import { annotate } from '../annotate.mjs';
-import { err, ok, orElse } from '../result.mjs';
+import { err, ok } from '../result.mjs';
 import { indent, summarize } from '../_utils.mjs';
-
+var EITHER_PREFIX = 'Either:\n';
 /**
  * Indents and adds a dash in front of this (potentially multiline) string.
  */
+
 function itemize(s) {
   return '-' + indent(s).substring(1);
 }
@@ -36,43 +37,42 @@ function itemize(s) {
 
 
 function nest(errText) {
-  var EITHER_PREFIX = 'Either:\n';
   return errText.startsWith(EITHER_PREFIX) ? errText.substr(EITHER_PREFIX.length) : itemize(errText);
-}
+} // prettier-ignore
+
+
+function _either() {
+  for (var _len = arguments.length, decoders = new Array(_len), _key = 0; _key < _len; _key++) {
+    decoders[_key] = arguments[_key];
+  }
+
+  if (decoders.length === 0) {
+    throw new Error('Pass at least one decoder to either()');
+  }
 
-export function either(d1, d2) {
   return function (blob) {
-    return orElse(d1(blob), function (err1) {
-      return orElse(d2(blob), function (err2) {
-        var serr1 = summarize(err1).join('\n');
-        var serr2 = summarize(err2).join('\n');
-        var text = ['Either:', nest(serr1), nest(serr2)].join('\n');
-        return err(annotate(blob, text));
-      });
-    });
+    // Collect errors here along the way
+    var errors = [];
+
+    for (var _i = 0; _i < decoders.length; _i++) {
+      var result = decoders[_i](blob);
+
+      if (result.ok) {
+        return result;
+      } else {
+        errors.push(result.error);
+      }
+    } // Decoding all alternatives failed, return the combined error message
+
+
+    var text = EITHER_PREFIX + errors.map(function (err) {
+      return nest(summarize(err).join('\n'));
+    }).join('\n');
+    return err(annotate(blob, text));
   };
 }
-export function either3(d1, d2, d3) {
-  return either(d1, either(d2, d3));
-}
-export function either4(d1, d2, d3, d4) {
-  return either(d1, either3(d2, d3, d4));
-}
-export function either5(d1, d2, d3, d4, d5) {
-  return either(d1, either4(d2, d3, d4, d5));
-}
-export function either6(d1, d2, d3, d4, d5, d6) {
-  return either(d1, either5(d2, d3, d4, d5, d6));
-}
-export function either7(d1, d2, d3, d4, d5, d6, d7) {
-  return either(d1, either6(d2, d3, d4, d5, d6, d7));
-}
-export function either8(d1, d2, d3, d4, d5, d6, d7, d8) {
-  return either(d1, either7(d2, d3, d4, d5, d6, d7, d8));
-}
-export function either9(d1, d2, d3, d4, d5, d6, d7, d8, d9) {
-  return either(d1, either8(d2, d3, d4, d5, d6, d7, d8, d9));
-}
+
+export var either = _either;
 export function oneOf(constants) {
   return function (blob) {
     var winner = constants.find(function (c) {

package/core/instanceOf.d.ts

@@ -1,3 +1,3 @@
 import { Decoder } from '../_types';
 
-export function instanceOf<T>(klass: new (...args: any) => T): Decoder<T>;
+export function instanceOf<T>(klass: new (...args: readonly any[]) => T): Decoder<T>;

package/core/json.js

@@ -7,7 +7,7 @@ var _array = require("./array");
 
 var _boolean2 = require("./boolean");
 
-var _mapping = require("./mapping");
+var _object = require("./object");
 
 var _either = require("./either");
 
@@ -20,12 +20,12 @@ var _number = require("./number");
 var _string = require("./string");
 
 var jsonObject = (0, _lazy.lazy)(function () {
-  return (0, _mapping.dict)(json);
+  return (0, _object.dict)(json);
 });
 exports.jsonObject = jsonObject;
 var jsonArray = (0, _lazy.lazy)(function () {
   return (0, _array.array)(json);
 });
 exports.jsonArray = jsonArray;
-var json = (0, _either.either6)(_constants.null_, _string.string, _number.number, _boolean2["boolean"], jsonObject, jsonArray);
+var json = (0, _either.either)(_constants.null_, _string.string, _number.number, _boolean2["boolean"], jsonObject, jsonArray);
 exports.json = json;

package/core/json.js.flow

@@ -2,8 +2,8 @@
 
 import { array } from './array';
 import { boolean } from './boolean';
-import { dict } from './mapping';
-import { either6 } from './either';
+import { dict } from './object';
+import { either } from './either';
 import { lazy } from './lazy';
 import { null_ } from './constants';
 import { number } from './number';
@@ -18,7 +18,7 @@ export const jsonObject: Decoder<JSONObject> = lazy(() => dict(json));
 
 export const jsonArray: Decoder<JSONArray> = lazy(() => array(json));
 
-export const json: Decoder<JSONValue> = either6(
+export const json: Decoder<JSONValue> = either(
     null_,
     string,
     number,

package/core/json.mjs

@@ -1,7 +1,7 @@
 import { array } from './array.mjs';
 import { boolean as _boolean } from './boolean.mjs';
-import { dict } from './mapping.mjs';
-import { either6 } from './either.mjs';
+import { dict } from './object.mjs';
+import { either } from './either.mjs';
 import { lazy } from './lazy.mjs';
 import { null_ } from './constants.mjs';
 import { number } from './number.mjs';
@@ -12,4 +12,4 @@ export var jsonObject = lazy(function () {
 export var jsonArray = lazy(function () {
   return array(json);
 });
-export var json = either6(null_, string, number, _boolean, jsonObject, jsonArray);
+export var json = either(null_, string, number, _boolean, jsonObject, jsonArray);

package/core/object.d.ts

@@ -1,3 +1,5 @@
+/// <reference lib="es6" />
+
 import { Decoder, DecoderType } from '../_types';
 import { AllowImplicit } from './_helpers';
 
@@ -31,3 +33,6 @@ export function inexact<O extends { [key: string]: Decoder<any> }>(
         [extra: string]: unknown;
     }
 >;
+
+export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>>;
+export function dict<T>(decoder: Decoder<T>): Decoder<{ [key: string]: T }>;

package/core/object.js

@@ -1,8 +1,10 @@
 "use strict";
 
 exports.__esModule = true;
+exports.dict = dict;
 exports.exact = exact;
 exports.inexact = inexact;
+exports.mapping = mapping;
 exports.object = object;
 exports.pojo = void 0;
 
@@ -87,7 +89,7 @@ function object(mapping) {
       var rawValue = blob[key];
       var result = decoder(rawValue);
 
-      if (result.type === 'ok') {
+      if (result.ok) {
         var value = result.value;
 
         if (value !== undefined) {
@@ -165,7 +167,7 @@ function exact(mapping) {
 function inexact(mapping) {
   return (0, _composition.compose)(pojo, function (blob) {
     var allkeys = new Set(Object.keys(blob));
-    var decoder = (0, _composition.map)(object(mapping), function (safepart) {
+    var decoder = (0, _composition.transform)(object(mapping), function (safepart) {
       var safekeys = new Set(Object.keys(mapping)); // To account for hard-coded keys that aren't part of the input
 
       safekeys.forEach(function (k) {
@@ -187,4 +189,59 @@ function inexact(mapping) {
     });
     return decoder(blob);
   });
+}
+/**
+ * Like mapping(), but returns an object rather than a Map instance.
+ */
+
+
+function dict(decoder) {
+  return (0, _composition.compose)(pojo, function (blob) {
+    var rv = {};
+    var errors = null;
+    Object.keys(blob).forEach(function (key) {
+      var value = blob[key];
+      var result = decoder(value);
+
+      if (result.ok) {
+        if (errors === null) {
+          rv[key] = result.value;
+        }
+      } else {
+        rv = {}; // Clear the success value so it can get garbage collected early
+
+        if (errors === null) {
+          errors = {};
+        }
+
+        errors[key] = result.error;
+      }
+    });
+
+    if (errors !== null) {
+      return (0, _result.err)((0, _annotate.merge)((0, _annotate.annotateObject)(blob), errors));
+    } else {
+      return (0, _result.ok)(rv);
+    }
+  });
+}
+/**
+ * Given an object, will decode a Map of string keys to whatever values.
+ *
+ * For example, given a decoder for a Person, we can verify a Person lookup
+ * table structure (of type Map<string, Person>) like so:
+ *
+ *   mapping(person)
+ *
+ */
+
+
+function mapping(decoder) {
+  return (0, _composition.transform)(dict(decoder), function (obj) {
+    return new Map( // This is effectively Object.entries(obj), but in a way that Flow
+    // will know the types are okay
+    Object.keys(obj).map(function (key) {
+      return [key, obj[key]];
+    }));
+  });
 }

package/core/object.js.flow

@@ -1,10 +1,10 @@
 // @flow strict
 
 import { annotate, annotateObject, merge, updateText } from '../annotate';
-import { compose, map } from './composition';
+import { compose, transform } from './composition';
 import { err, ok } from '../result';
 import type { Annotation } from '../annotate';
-import type { Decoder, DecoderType } from '../_types';
+import type { Decoder, DecodeResult, DecoderType } from '../_types';
 
 // $FlowFixMe[unclear-type] (not really an issue) - deliberate use of `any` - not sure how we should get rid of this
 type AnyDecoder = any;
@@ -94,9 +94,9 @@ export function object<O: { +[field: string]: AnyDecoder, ... }>(
         Object.keys(mapping).forEach((key) => {
             const decoder = mapping[key];
             const rawValue = blob[key];
-            const result = decoder(rawValue);
+            const result: DecodeResult<mixed> = decoder(rawValue);
 
-            if (result.type === 'ok') {
+            if (result.ok) {
                 const value = result.value;
                 if (value !== undefined) {
                     record[key] = value;
@@ -179,25 +179,81 @@ export function inexact<O: { +[field: string]: AnyDecoder }>(
 ): Decoder<$ObjMap<O, DecoderType> & { +[string]: mixed }> {
     return compose(pojo, (blob: {| [string]: mixed |}) => {
         const allkeys = new Set(Object.keys(blob));
-        const decoder = map(object(mapping), (safepart: $ObjMap<O, DecoderType>) => {
-            const safekeys = new Set(Object.keys(mapping));
-
-            // To account for hard-coded keys that aren't part of the input
-            safekeys.forEach((k) => allkeys.add(k));
-
-            const rv = {};
-            allkeys.forEach((k) => {
-                if (safekeys.has(k)) {
-                    const value = safepart[k];
-                    if (value !== undefined) {
-                        rv[k] = value;
+        const decoder = transform(
+            object(mapping),
+            (safepart: $ObjMap<O, DecoderType>) => {
+                const safekeys = new Set(Object.keys(mapping));
+
+                // To account for hard-coded keys that aren't part of the input
+                safekeys.forEach((k) => allkeys.add(k));
+
+                const rv = {};
+                allkeys.forEach((k) => {
+                    if (safekeys.has(k)) {
+                        const value = safepart[k];
+                        if (value !== undefined) {
+                            rv[k] = value;
+                        }
+                    } else {
+                        rv[k] = blob[k];
                     }
-                } else {
-                    rv[k] = blob[k];
+                });
+                return rv;
+            },
+        );
+        return decoder(blob);
+    });
+}
+
+/**
+ * Like mapping(), but returns an object rather than a Map instance.
+ */
+export function dict<T>(decoder: Decoder<T>): Decoder<{ [string]: T }> {
+    return compose(pojo, (blob: { +[key: string]: mixed }) => {
+        let rv: { [key: string]: T } = {};
+        let errors: { [key: string]: Annotation } | null = null;
+
+        Object.keys(blob).forEach((key: string) => {
+            const value = blob[key];
+            const result = decoder(value);
+            if (result.ok) {
+                if (errors === null) {
+                    rv[key] = result.value;
+                }
+            } else {
+                rv = {}; // Clear the success value so it can get garbage collected early
+                if (errors === null) {
+                    errors = {};
                 }
-            });
-            return rv;
+                errors[key] = result.error;
+            }
         });
-        return decoder(blob);
+
+        if (errors !== null) {
+            return err(merge(annotateObject(blob), errors));
+        } else {
+            return ok(rv);
+        }
     });
 }
+
+/**
+ * Given an object, will decode a Map of string keys to whatever values.
+ *
+ * For example, given a decoder for a Person, we can verify a Person lookup
+ * table structure (of type Map<string, Person>) like so:
+ *
+ *   mapping(person)
+ *
+ */
+export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>> {
+    return transform(
+        dict(decoder),
+        (obj) =>
+            new Map(
+                // This is effectively Object.entries(obj), but in a way that Flow
+                // will know the types are okay
+                Object.keys(obj).map((key) => [key, obj[key]]),
+            ),
+    );
+}