decoders 2.0.0-beta3 → 2.0.0-beta7

package/core/constants.js

@@ -5,19 +5,15 @@ exports.constant = constant;
 exports.hardcoded = hardcoded;
 exports.unknown = exports.undefined_ = exports.null_ = exports.mixed = void 0;
 
-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 only returns Ok for `null` inputs.  Err otherwise.
  */
 var null_ = function null_(blob) {
-  return blob === null ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, 'Must be null'));
+  return blob === null ? (0, _result.ok)(blob) : (0, _result.err)((0, _annotate.annotate)(blob, 'Must be null'));
 };
 /**
  * Decoder that only returns Ok for `undefined` inputs.  Err otherwise.
@@ -27,7 +23,7 @@ var null_ = function null_(blob) {
 exports.null_ = null_;
 
 var undefined_ = function undefined_(blob) {
-  return blob === undefined ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, 'Must be undefined'));
+  return blob === undefined ? (0, _result.ok)(blob) : (0, _result.err)((0, _annotate.annotate)(blob, 'Must be undefined'));
 };
 /**
  * Decoder that only returns Ok for the given value constant.  Err otherwise.
@@ -38,7 +34,7 @@ exports.undefined_ = undefined_;
 
 function constant(value) {
   return function (blob) {
-    return blob === value ? Result.ok(value) : Result.err((0, _annotate.annotate)(blob, "Must be constant " + String(value)));
+    return blob === value ? (0, _result.ok)(value) : (0, _result.err)((0, _annotate.annotate)(blob, "Must be constant " + String(value)));
   };
 }
 /**
@@ -48,7 +44,7 @@ function constant(value) {
 
 function hardcoded(value) {
   return function () {
-    return Result.ok(value);
+    return (0, _result.ok)(value);
   };
 }
 /**
@@ -57,7 +53,7 @@ function hardcoded(value) {
 
 
 var unknown = function unknown(blob) {
-  return Result.ok(blob);
+  return (0, _result.ok)(blob);
 };
 /**
  * Alias of unknown.

package/core/constants.js.flow

@@ -1,22 +1,20 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
+import { err, ok } from '../result';
 import type { Decoder, Scalar } from '../_types';
 
 /**
  * Decoder that only returns Ok for `null` inputs.  Err otherwise.
  */
 export const null_: Decoder<null> = (blob: mixed) =>
-    blob === null ? Result.ok(blob) : Result.err(annotate(blob, 'Must be null'));
+    blob === null ? ok(blob) : err(annotate(blob, 'Must be null'));
 
 /**
  * Decoder that only returns Ok for `undefined` inputs.  Err otherwise.
  */
 export const undefined_: Decoder<void> = (blob: mixed) =>
-    blob === undefined
-        ? Result.ok(blob)
-        : Result.err(annotate(blob, 'Must be undefined'));
+    blob === undefined ? ok(blob) : err(annotate(blob, 'Must be undefined'));
 
 /**
  * Decoder that only returns Ok for the given value constant.  Err otherwise.
@@ -24,21 +22,21 @@ export const undefined_: Decoder<void> = (blob: mixed) =>
 export function constant<T: Scalar>(value: T): Decoder<T> {
     return (blob: mixed) =>
         blob === value
-            ? Result.ok(value)
-            : Result.err(annotate(blob, `Must be constant ${String(value)}`));
+            ? ok(value)
+            : err(annotate(blob, `Must be constant ${String(value)}`));
 }
 
 /**
  * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
  */
 export function hardcoded<T>(value: T): Decoder<T> {
-    return () => Result.ok(value);
+    return () => ok(value);
 }
 
 /**
  * Decoder that always returns Ok for the given hardcoded value, no matter what the input.
  */
-export const unknown: Decoder<mixed> = (blob: mixed) => Result.ok(blob);
+export const unknown: Decoder<mixed> = (blob: mixed) => ok(blob);
 
 /**
  * Alias of unknown.

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

@@ -1,18 +1,18 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
+import { annotate } from '../annotate.mjs';
+import { err, ok } from '../result.mjs';
 
 /**
  * Decoder that only returns Ok for `null` inputs.  Err otherwise.
  */
 export var null_ = function null_(blob) {
-  return blob === null ? Result.ok(blob) : Result.err(annotate(blob, 'Must be null'));
+  return blob === null ? ok(blob) : err(annotate(blob, 'Must be null'));
 };
 /**
  * Decoder that only returns Ok for `undefined` inputs.  Err otherwise.
  */
 
 export var undefined_ = function undefined_(blob) {
-  return blob === undefined ? Result.ok(blob) : Result.err(annotate(blob, 'Must be undefined'));
+  return blob === undefined ? ok(blob) : err(annotate(blob, 'Must be undefined'));
 };
 /**
  * Decoder that only returns Ok for the given value constant.  Err otherwise.
@@ -20,7 +20,7 @@ export var undefined_ = function undefined_(blob) {
 
 export function constant(value) {
   return function (blob) {
-    return blob === value ? Result.ok(value) : Result.err(annotate(blob, "Must be constant " + String(value)));
+    return blob === value ? ok(value) : err(annotate(blob, "Must be constant " + String(value)));
   };
 }
 /**
@@ -29,7 +29,7 @@ export function constant(value) {
 
 export function hardcoded(value) {
   return function () {
-    return Result.ok(value);
+    return ok(value);
   };
 }
 /**
@@ -37,7 +37,7 @@ export function hardcoded(value) {
  */
 
 export var unknown = function unknown(blob) {
-  return Result.ok(blob);
+  return ok(blob);
 };
 /**
  * Alias of unknown.

package/core/date.d.ts

@@ -0,0 +1,4 @@
+import { Decoder } from '../_types';
+
+export const date: Decoder<Date>;
+export const iso8601: Decoder<Date>;

package/core/date.js

@@ -3,27 +3,23 @@
 exports.__esModule = true;
 exports.iso8601 = exports.date = void 0;
 
-var Result = _interopRequireWildcard(require("../result"));
-
 var _annotate = require("../annotate");
 
+var _result = require("../result");
+
 var _utils = require("../_utils");
 
 var _composition = require("./composition");
 
 var _string = require("./string");
 
-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; }
-
 // Only matches the shape.  This "over-matches" some values that still aren't
 // valid dates (like 9999-99-99), but those will be caught by JS Date's
 // internal validations
 var iso8601_re = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[.]\d+)?(?:Z|[+-]\d{2}:?\d{2})$/;
 
 var date = function date(value) {
-  return (0, _utils.isDate)(value) ? Result.ok(value) : Result.err((0, _annotate.annotate)(value, 'Must be a Date'));
+  return (0, _utils.isDate)(value) ? (0, _result.ok)(value) : (0, _result.err)((0, _annotate.annotate)(value, 'Must be a Date'));
 };
 /**
  * Decoder that only returns Ok for strings that are valid ISO8601 date

package/core/date.js.flow

@@ -1,7 +1,7 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
+import { err, ok } from '../result';
 import { isDate } from '../_utils';
 import { map } from './composition';
 import { regex } from './string';
@@ -17,9 +17,7 @@ const iso8601_re =
     /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[.]\d+)?(?:Z|[+-]\d{2}:?\d{2})$/;
 
 export const date: Decoder<Date> = (value: mixed) =>
-    isDate(value)
-        ? Result.ok(((value: cast): Date))
-        : Result.err(annotate(value, 'Must be a Date'));
+    isDate(value) ? ok(((value: cast): Date)) : err(annotate(value, 'Must be a Date'));
 
 /**
  * Decoder that only returns Ok for strings that are valid ISO8601 date

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

@@ -1,14 +1,14 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import { isDate } from '../_utils';
-import { map } from './composition';
-import { regex } from './string';
+import { annotate } from '../annotate.mjs';
+import { err, ok } from '../result.mjs';
+import { isDate } from '../_utils.mjs';
+import { map } from './composition.mjs';
+import { regex } from './string.mjs';
 // Only matches the shape.  This "over-matches" some values that still aren't
 // valid dates (like 9999-99-99), but those will be caught by JS Date's
 // internal validations
 var iso8601_re = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:[.]\d+)?(?:Z|[+-]\d{2}:?\d{2})$/;
 export var date = function date(value) {
-  return isDate(value) ? Result.ok(value) : Result.err(annotate(value, 'Must be a Date'));
+  return isDate(value) ? ok(value) : err(annotate(value, 'Must be a Date'));
 };
 /**
  * Decoder that only returns Ok for strings that are valid ISO8601 date

package/core/describe.d.ts

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

package/core/describe.js

@@ -3,13 +3,9 @@
 exports.__esModule = true;
 exports.describe = describe;
 
-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");
 
 /**
  * Wrap another decoder, and override the error message in case it fails. This
@@ -19,7 +15,7 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
  */
 function describe(decoder, message) {
   return function (blob) {
-    return Result.mapError(decoder(blob), function (err) {
+    return (0, _result.mapError)(decoder(blob), function (err) {
       return (0, _annotate.annotate)(err, message);
     });
   };

package/core/describe.js.flow

@@ -1,7 +1,7 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
+import { mapError } from '../result';
 import type { Decoder } from '../_types';
 
 /**
@@ -12,6 +12,6 @@ import type { Decoder } from '../_types';
  */
 export function describe<T>(decoder: Decoder<T>, message: string): Decoder<T> {
     return (blob: mixed) => {
-        return Result.mapError(decoder(blob), (err) => annotate(err, message));
+        return mapError(decoder(blob), (err) => annotate(err, message));
     };
 }

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

@@ -1,5 +1,5 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
+import { annotate } from '../annotate.mjs';
+import { mapError } from '../result.mjs';
 
 /**
  * Wrap another decoder, and override the error message in case it fails. This
@@ -9,7 +9,7 @@ import { annotate } from '../annotate';
  */
 export function describe(decoder, message) {
   return function (blob) {
-    return Result.mapError(decoder(blob), function (err) {
+    return mapError(decoder(blob), function (err) {
       return annotate(err, message);
     });
   };

package/core/dispatch.d.ts

@@ -0,0 +1,8 @@
+import { Decoder, DecoderType } from '../_types';
+
+export type $Values<T extends object> = T[keyof T];
+
+export function dispatch<O extends { [key: string]: Decoder<any> }>(
+    field: string,
+    mapping: O,
+): Decoder<$Values<{ [key in keyof O]: DecoderType<O[key]> }>>;

package/core/dispatch.js

@@ -3,16 +3,12 @@
 exports.__esModule = true;
 exports.dispatch = dispatch;
 
-var Result = _interopRequireWildcard(require("../result"));
+var _result = require("../result");
 
 var _object2 = require("./object");
 
 var _either = require("./either");
 
-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; }
-
 /**
  * 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:
@@ -53,7 +49,7 @@ function dispatch(field, mapping) {
 
   var base = (0, _object2.object)((_object = {}, _object[field] = (0, _either.oneOf)(Object.keys(mapping)), _object));
   return function (blob) {
-    return Result.andThen(base(blob), function (baseObj) {
+    return (0, _result.andThen)(base(blob), function (baseObj) {
       var decoderName = baseObj[field];
       var decoder = mapping[decoderName];
       return decoder(blob);

package/core/dispatch.js.flow

@@ -1,6 +1,6 @@
 // @flow strict
 
-import * as Result from '../result';
+import { andThen } from '../result';
 import { object } from './object';
 import { oneOf } from './either';
 import type { Decoder, DecoderType } from '../_types';
@@ -49,7 +49,7 @@ export function dispatch<O: { +[field: string]: Decoder<anything>, ... }>(
 ): Decoder<$Values<$ObjMap<O, DecoderType>>> {
     const base = object({ [field]: 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,6 @@
-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';
 
 /**
  * Dispatches to one of several given decoders, based on the value found at
@@ -42,7 +42,7 @@ export function dispatch(field, mapping) {
 
   var base = object((_object = {}, _object[field] = 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,61 @@
+import { Decoder, Scalar } from '../_types';
+
+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

@@ -11,15 +11,11 @@ exports.either8 = either8;
 exports.either9 = either9;
 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");
 
 /**
  * Indents and adds a dash in front of this (potentially multiline) string.
@@ -61,12 +57,12 @@ function nest(errText) {
 
 function either(d1, d2) {
   return function (blob) {
-    return Result.orElse(d1(blob), function (err1) {
-      return Result.orElse(d2(blob), function (err2) {
+    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 Result.err((0, _annotate.annotate)(blob, text));
+        return (0, _result.err)((0, _annotate.annotate)(blob, text));
       });
     });
   };
@@ -107,10 +103,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,7 +1,7 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
+import { err, ok, orElse } from '../result';
 import { indent, summarize } from '../_utils';
 import type { Decoder, Scalar } from '../_types';
 
@@ -46,12 +46,12 @@ function nest(errText: string): string {
 
 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) => {
+        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 Result.err(annotate(blob, text));
+                return err(annotate(blob, text));
             }),
         );
 }
@@ -137,9 +137,9 @@ 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/{_esm/core/either.js → core/either.mjs}

@@ -1,6 +1,6 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import { indent, summarize } from '../_utils';
+import { annotate } from '../annotate.mjs';
+import { err, ok, orElse } from '../result.mjs';
+import { indent, summarize } from '../_utils.mjs';
 
 /**
  * Indents and adds a dash in front of this (potentially multiline) string.
@@ -42,12 +42,12 @@ function nest(errText) {
 
 export function either(d1, d2) {
   return function (blob) {
-    return Result.orElse(d1(blob), function (err1) {
-      return Result.orElse(d2(blob), function (err2) {
+    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 Result.err(annotate(blob, text));
+        return err(annotate(blob, text));
       });
     });
   };
@@ -80,10 +80,10 @@ export function oneOf(constants) {
     });
 
     if (winner !== undefined) {
-      return Result.ok(winner);
+      return ok(winner);
     }
 
-    return Result.err(annotate(blob, "Must be one of " + constants.map(function (value) {
+    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: any) => T): Decoder<T>;