decoders 2.0.0-beta5 → 2.0.0-beta9

package/core/dispatch.js.flow

@@ -1,13 +1,12 @@
 // @flow strict
 
-import * as Result from '../result';
+import { andThen } from '../result';
 import { object } from './object';
 import { oneOf } from './either';
+import { prep } from './composition';
+import type { _Any } from '../_utils';
 import type { Decoder, DecoderType } from '../_types';
 
-// $FlowFixMe[unclear-type] (not really an issue) - deliberate use of `any` - not sure how we should get rid of this
-type anything = any;
-
 /**
  * Dispatches to one of several given decoders, based on the value found at
  * runtime in the given field.  For example, suppose you have these decoders:
@@ -30,26 +29,28 @@ type anything = any;
  * Then these two decoders are equivalent:
  *
  *     const shape = either(rectangle, circle)
- *     const shape = dispatch('type', { rectangle, circle })
+ *     const shape = taggedUnion('type', { rectangle, circle })
  *
  * Will be of type Decoder<Rectangle | Circle>.
  *
- * But the dispatch version will typically be more runtime-efficient.  The
- * reason is that it will first do minimal work to "look ahead" into the `type`
- * field here, and based on that value, pick the decoder to invoke.
+ * But `taggedUnion` will typically be more runtime-efficient.  The reason is
+ * that it will first do minimal work to "look ahead" into the `type` field
+ * here, and based on that value, pick the decoder to invoke.
  *
  * The `either` version will simply try to invoke each decoder, until it finds
  * one that matches.
  *
- * Also, the error messages will be less ambiguous using `dispatch()`.
+ * Also, the error messages will be less ambiguous using `taggedUnion()`.
  */
-export function dispatch<O: { +[field: string]: Decoder<anything>, ... }>(
+export function taggedUnion<O: { +[field: string]: Decoder<_Any>, ... }>(
     field: string,
     mapping: O,
 ): Decoder<$Values<$ObjMap<O, DecoderType>>> {
-    const base = object({ [field]: oneOf(Object.keys(mapping)) });
+    const base = object({
+        [field]: prep(String, oneOf(Object.keys(mapping))),
+    });
     return (blob: mixed) => {
-        return Result.andThen(base(blob), (baseObj) => {
+        return andThen(base(blob), (baseObj) => {
             const decoderName = baseObj[field];
             const decoder = mapping[decoderName];
             return decoder(blob);

package/{_esm/core/dispatch.js → core/dispatch.mjs}

@@ -1,6 +1,7 @@
-import * as Result from '../result';
-import { object } from './object';
-import { oneOf } from './either';
+import { andThen } from '../result.mjs';
+import { object } from './object.mjs';
+import { oneOf } from './either.mjs';
+import { prep } from './composition.mjs';
 
 /**
  * Dispatches to one of several given decoders, based on the value found at
@@ -24,25 +25,25 @@ import { oneOf } from './either';
  * Then these two decoders are equivalent:
  *
  *     const shape = either(rectangle, circle)
- *     const shape = dispatch('type', { rectangle, circle })
+ *     const shape = taggedUnion('type', { rectangle, circle })
  *
  * Will be of type Decoder<Rectangle | Circle>.
  *
- * But the dispatch version will typically be more runtime-efficient.  The
- * reason is that it will first do minimal work to "look ahead" into the `type`
- * field here, and based on that value, pick the decoder to invoke.
+ * But `taggedUnion` will typically be more runtime-efficient.  The reason is
+ * that it will first do minimal work to "look ahead" into the `type` field
+ * here, and based on that value, pick the decoder to invoke.
  *
  * The `either` version will simply try to invoke each decoder, until it finds
  * one that matches.
  *
- * Also, the error messages will be less ambiguous using `dispatch()`.
+ * Also, the error messages will be less ambiguous using `taggedUnion()`.
  */
-export function dispatch(field, mapping) {
+export function taggedUnion(field, mapping) {
   var _object;
 
-  var base = object((_object = {}, _object[field] = oneOf(Object.keys(mapping)), _object));
+  var base = object((_object = {}, _object[field] = prep(String, oneOf(Object.keys(mapping))), _object));
   return function (blob) {
-    return Result.andThen(base(blob), function (baseObj) {
+    return andThen(base(blob), function (baseObj) {
       var decoderName = baseObj[field];
       var decoder = mapping[decoderName];
       return decoder(blob);

package/core/either.d.ts

@@ -0,0 +1,66 @@
+import { Decoder, Scalar } from '../_types';
+
+export type DecoderTypes<T> = T extends ReadonlyArray<Decoder<infer U>> ? U : never;
+
+export function either<T extends ReadonlyArray<Decoder<any>>>(
+    ...args: T
+): Decoder<DecoderTypes<T>>;
+// export function either<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<T1 | T2>;
+// export function either2<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<T1 | T2>;
+// export function either3<T1, T2, T3>(
+//     d1: Decoder<T1>,
+//     d2: Decoder<T2>,
+//     d3: Decoder<T3>,
+// ): Decoder<T1 | T2 | T3>;
+// export function either4<T1, T2, T3, T4>(
+//     d1: Decoder<T1>,
+//     d2: Decoder<T2>,
+//     d3: Decoder<T3>,
+//     d4: Decoder<T4>,
+// ): Decoder<T1 | T2 | T3 | T4>;
+// 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>;
+// 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>;
+// 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>;
+// 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>;
+// 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>;
+export function oneOf<T extends Scalar>(constants: readonly T[]): Decoder<T>;

package/core/either.js

@@ -1,29 +1,20 @@
 "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 Result = _interopRequireWildcard(require("../result"));
-
 var _annotate = require("../annotate");
 
-var _utils = require("../_utils");
-
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+var _result = require("../result");
 
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+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);
 }
@@ -55,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 Result.orElse(d1(blob), function (err1) {
-      return 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 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) {
@@ -107,10 +91,10 @@ function oneOf(constants) {
     });
 
     if (winner !== undefined) {
-      return Result.ok(winner);
+      return (0, _result.ok)(winner);
     }
 
-    return Result.err((0, _annotate.annotate)(blob, "Must be one of " + constants.map(function (value) {
+    return (0, _result.err)((0, _annotate.annotate)(blob, "Must be one of " + constants.map(function (value) {
       return JSON.stringify(value);
     }).join(', ')));
   };

package/core/either.js.flow

@@ -1,9 +1,12 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
+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,108 +41,59 @@ 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) =>
-        Result.orElse(d1(blob), (err1) =>
-            Result.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 Result.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) => {
         const winner = constants.find((c) => c === blob);
         if (winner !== undefined) {
-            return Result.ok(winner);
+            return ok(winner);
         }
-        return Result.err(
+        return err(
             annotate(
                 blob,
                 `Must be one of ${constants

package/core/either.mjs

@@ -0,0 +1,90 @@
+import { annotate } from '../annotate.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);
+}
+/**
+ * Nests another error as an item under a new-to-be-created "Either error". If
+ * the given subitem already is an "Either error" of itself, don't indent, but
+ * just "inject" its items at the same error level, for nicely flattened either
+ * expressions.
+ *
+ * Avoids:
+ *
+ *     Either:
+ *     - Either:
+ *       - Must be P
+ *       - Either:
+ *         - Must be Q
+ *         - Must be R
+ *     - Must be S
+ *
+ * And "flattens" these to:
+ *
+ *     Either:
+ *     - Must be P
+ *     - Must be Q
+ *     - Must be R
+ *     - Must be S
+ *
+ */
+
+
+function nest(errText) {
+  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()');
+  }
+
+  return function (blob) {
+    // 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 var either = _either;
+export function oneOf(constants) {
+  return function (blob) {
+    var winner = constants.find(function (c) {
+      return c === blob;
+    });
+
+    if (winner !== undefined) {
+      return ok(winner);
+    }
+
+    return err(annotate(blob, "Must be one of " + constants.map(function (value) {
+      return JSON.stringify(value);
+    }).join(', ')));
+  };
+}

package/core/fail.d.ts

@@ -0,0 +1,3 @@
+import { Decoder } from '../_types';
+
+export function fail(msg: string): Decoder<never>;

package/core/fail.js

@@ -3,19 +3,15 @@
 exports.__esModule = true;
 exports.fail = fail;
 
-var Result = _interopRequireWildcard(require("../result"));
-
 var _annotate = require("../annotate");
 
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var _result = require("../result");
 
 /**
  * Decoder that always fails with the given error message, no matter what the input.
  */
 function fail(msg) {
   return function (blob) {
-    return Result.err((0, _annotate.annotate)(blob, msg));
+    return (0, _result.err)((0, _annotate.annotate)(blob, msg));
   };
 }

package/core/fail.js.flow

@@ -1,12 +1,12 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
+import { err } from '../result';
 import type { Decoder } from '../_types';
 
 /**
  * Decoder that always fails with the given error message, no matter what the input.
  */
 export function fail(msg: string): Decoder<empty> {
-    return (blob: mixed) => Result.err(annotate(blob, msg));
+    return (blob: mixed) => err(annotate(blob, msg));
 }

package/{_esm/core/fail.js → core/fail.mjs}

@@ -1,11 +1,11 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
+import { annotate } from '../annotate.mjs';
+import { err } from '../result.mjs';
 
 /**
  * Decoder that always fails with the given error message, no matter what the input.
  */
 export function fail(msg) {
   return function (blob) {
-    return Result.err(annotate(blob, msg));
+    return err(annotate(blob, msg));
   };
 }

package/core/instanceOf.d.ts

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

package/core/instanceOf.js

@@ -3,17 +3,13 @@
 exports.__esModule = true;
 exports.instanceOf = instanceOf;
 
-var Result = _interopRequireWildcard(require("../result"));
-
 var _annotate = require("../annotate");
 
-function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { "default": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj["default"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+var _result = require("../result");
 
 function instanceOf(klass) {
   return function (blob) {
-    return blob instanceof klass ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, "Must be " + // $FlowFixMe[incompatible-use] - klass.name is fine?
+    return blob instanceof klass ? (0, _result.ok)(blob) : (0, _result.err)((0, _annotate.annotate)(blob, "Must be " + // $FlowFixMe[incompatible-use] - klass.name is fine?
     klass.name + " instance"));
   };
 }

package/core/instanceOf.js.flow

@@ -1,14 +1,14 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
+import { err, ok } from '../result';
 import type { Decoder } from '../_types';
 
 export function instanceOf<T>(klass: Class<T>): Decoder<T> {
     return (blob: mixed) =>
         blob instanceof klass
-            ? Result.ok(blob)
-            : Result.err(
+            ? ok(blob)
+            : err(
                   annotate(
                       blob,
                       `Must be ${

package/core/instanceOf.mjs

@@ -0,0 +1,8 @@
+import { annotate } from '../annotate.mjs';
+import { err, ok } from '../result.mjs';
+export function instanceOf(klass) {
+  return function (blob) {
+    return blob instanceof klass ? ok(blob) : err(annotate(blob, "Must be " + // $FlowFixMe[incompatible-use] - klass.name is fine?
+    klass.name + " instance"));
+  };
+}