decoders 2.0.0-beta9 → 2.0.0

package/core/number.js.flow

@@ -1,40 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { err, ok } from '../result';
-import { predicate } from './composition';
-import type { Decoder } from '../_types';
-
-const anyNumber: Decoder<number> = (blob: mixed) => {
-    return typeof blob === 'number' && !Number.isNaN(blob)
-        ? ok(blob)
-        : err(annotate(blob, 'Must be number'));
-};
-
-const isInteger = (n: number) => Number.isInteger(n);
-const isFinite = (n: number) => Number.isFinite(n);
-
-export const number: Decoder<number> = predicate(
-    anyNumber,
-    isFinite,
-    'Number must be finite',
-);
-
-export const positiveNumber: Decoder<number> = predicate(
-    number,
-    (n) => n >= 0,
-    'Number must be positive',
-);
-
-// Integers
-export const integer: Decoder<number> = predicate(
-    number,
-    isInteger,
-    'Number must be an integer',
-);
-
-export const positiveInteger: Decoder<number> = predicate(
-    integer,
-    (n) => n >= 0,
-    'Number must be positive',
-);

package/core/number.mjs

@@ -1,25 +0,0 @@
-import { annotate } from '../annotate.mjs';
-import { err, ok } from '../result.mjs';
-import { predicate } from './composition.mjs';
-
-var anyNumber = function anyNumber(blob) {
-  return typeof blob === 'number' && !Number.isNaN(blob) ? ok(blob) : err(annotate(blob, 'Must be number'));
-};
-
-var isInteger = function isInteger(n) {
-  return Number.isInteger(n);
-};
-
-var isFinite = function isFinite(n) {
-  return Number.isFinite(n);
-};
-
-export var number = predicate(anyNumber, isFinite, 'Number must be finite');
-export var positiveNumber = predicate(number, function (n) {
-  return n >= 0;
-}, 'Number must be positive'); // Integers
-
-export var integer = predicate(number, isInteger, 'Number must be an integer');
-export var positiveInteger = predicate(integer, function (n) {
-  return n >= 0;
-}, 'Number must be positive');

package/core/object.d.ts

@@ -1,38 +0,0 @@
-/// <reference lib="es6" />
-
-import { Decoder, DecoderType } from '../_types';
-import { AllowImplicit } from './_helpers';
-
-export type ObjectDecoderType<T> = AllowImplicit<{
-    [key in keyof T]: DecoderType<T[key]>;
-}>;
-
-export const pojo: Decoder<{ [key: string]: unknown }>;
-
-export function object<O extends { [key: string]: Decoder<any> }>(
-    mapping: O,
-): Decoder<{ [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] }>;
-//         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//         This is basically just equivalent to:
-//             ObjectDecoderType<O>
-//
-//         But by "resolving" this with a mapped type, we remove the helper
-//         type names from the inferred type here, making this much easier to
-//         work with while developing.
-
-export function exact<O extends { [key: string]: Decoder<any> }>(
-    mapping: O,
-): Decoder<{ [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] }>;
-//         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-//         Ditto (see above)
-
-export function inexact<O extends { [key: string]: Decoder<any> }>(
-    mapping: O,
-): Decoder<
-    { [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] } & {
-        [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/optional.d.ts

@@ -1,5 +0,0 @@
-import { Decoder } from '../_types';
-
-export function optional<T>(decoder: Decoder<T>): Decoder<T | undefined>;
-export function nullable<T>(decoder: Decoder<T>): Decoder<T | null>;
-export function maybe<T>(decoder: Decoder<T>): Decoder<T | null | undefined>;

package/core/optional.js

@@ -1,50 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.maybe = maybe;
-exports.nullable = nullable;
-exports.optional = optional;
-
-var _annotate = require("../annotate");
-
-var _either = require("./either");
-
-var _result = require("../result");
-
-var _constants = require("./constants");
-
-/**
- * Builds a Decoder that returns Ok for either `undefined` or `T` values,
- * given a Decoder for `T`.  Err otherwise.
- */
-function optional(decoder) {
-  return (0, _either.either)(_constants.undefined_, decoder);
-}
-/**
- * Builds a Decoder that returns Ok for either `null` or `T` values,
- * given a Decoder for `T`.  Err otherwise.
- */
-
-
-function nullable(decoder) {
-  return (0, _either.either)(_constants.null_, decoder);
-}
-/**
- * Decoder that only returns Ok for `null` or `undefined` inputs.
- * This is effectively equivalent to either(null_, undefined_), but combines
- * their error message output into a single line for convenience.
- */
-
-
-var undefined_or_null = function undefined_or_null(blob) {
-  return blob === undefined || blob === null ? (0, _result.ok)(blob) : // Combine error message into a single line
-  (0, _result.err)((0, _annotate.annotate)(blob, 'Must be undefined or null'));
-};
-/**
- * Decoder that only returns Ok for `null` or `undefined` inputs.
- */
-
-
-function maybe(decoder) {
-  return (0, _either.either)(undefined_or_null, decoder);
-}

package/core/optional.js.flow

@@ -1,41 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { either } from './either';
-import { err, ok } from '../result';
-import { null_, undefined_ } from './constants';
-import type { Decoder } from '../_types';
-
-/**
- * Builds a Decoder that returns Ok for either `undefined` or `T` values,
- * given a Decoder for `T`.  Err otherwise.
- */
-export function optional<T>(decoder: Decoder<T>): Decoder<void | T> {
-    return either(undefined_, decoder);
-}
-
-/**
- * Builds a Decoder that returns Ok for either `null` or `T` values,
- * given a Decoder for `T`.  Err otherwise.
- */
-export function nullable<T>(decoder: Decoder<T>): Decoder<null | T> {
-    return either(null_, decoder);
-}
-
-/**
- * Decoder that only returns Ok for `null` or `undefined` inputs.
- * This is effectively equivalent to either(null_, undefined_), but combines
- * their error message output into a single line for convenience.
- */
-const undefined_or_null: Decoder<null | void> = (blob: mixed) =>
-    blob === undefined || blob === null
-        ? ok(blob)
-        : // Combine error message into a single line
-          err(annotate(blob, 'Must be undefined or null'));
-
-/**
- * Decoder that only returns Ok for `null` or `undefined` inputs.
- */
-export function maybe<T>(decoder: Decoder<T>): Decoder<?T> {
-    return either(undefined_or_null, decoder);
-}

package/core/optional.mjs

@@ -1,38 +0,0 @@
-import { annotate } from '../annotate.mjs';
-import { either } from './either.mjs';
-import { err, ok } from '../result.mjs';
-import { null_, undefined_ } from './constants.mjs';
-
-/**
- * Builds a Decoder that returns Ok for either `undefined` or `T` values,
- * given a Decoder for `T`.  Err otherwise.
- */
-export function optional(decoder) {
-  return either(undefined_, decoder);
-}
-/**
- * Builds a Decoder that returns Ok for either `null` or `T` values,
- * given a Decoder for `T`.  Err otherwise.
- */
-
-export function nullable(decoder) {
-  return either(null_, decoder);
-}
-/**
- * Decoder that only returns Ok for `null` or `undefined` inputs.
- * This is effectively equivalent to either(null_, undefined_), but combines
- * their error message output into a single line for convenience.
- */
-
-var undefined_or_null = function undefined_or_null(blob) {
-  return blob === undefined || blob === null ? ok(blob) : // Combine error message into a single line
-  err(annotate(blob, 'Must be undefined or null'));
-};
-/**
- * Decoder that only returns Ok for `null` or `undefined` inputs.
- */
-
-
-export function maybe(decoder) {
-  return either(undefined_or_null, decoder);
-}

package/core/string.d.ts

@@ -1,13 +0,0 @@
-/// <reference lib="dom" />
-
-import { Decoder } from '../_types';
-
-export const string: Decoder<string>;
-export const nonEmptyString: Decoder<string>;
-export function regex(regex: RegExp, msg: string): Decoder<string>;
-export const email: Decoder<string>;
-export const url: Decoder<URL>;
-export const httpsUrl: Decoder<URL>;
-export const uuid: Decoder<string>;
-export const uuidv1: Decoder<string>;
-export const uuidv4: Decoder<string>;

package/core/string.js

@@ -1,80 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.nonEmptyString = exports.httpsUrl = exports.email = void 0;
-exports.regex = regex;
-exports.uuidv4 = exports.uuidv1 = exports.uuid = exports.url = exports.string = void 0;
-
-var _annotate = require("../annotate");
-
-var _either = require("./either");
-
-var _result = require("../result");
-
-var _instanceOf = require("./instanceOf");
-
-var _composition = require("./composition");
-
-/** Match groups in this regex:
- * \1 - the scheme
- * \2 - the username/password (optional)
- * \3 - the host
- * \4 - the port (optional)
- * \5 - the path (optional)
- */
-var url_re = /^([A-Za-z]{3,9}(?:[+][A-Za-z]{3,9})?):\/\/(?:([-;:&=+$,\w]+)@)?(?:([A-Za-z0-9.-]+)(?::([0-9]{2,5}))?)(\/(?:[-+~%/.,\w]*)?(?:\?[-+=&;%@.,\w]*)?(?:#[.,!/\w]*)?)?$/;
-/**
- * Decoder that only returns Ok for string inputs.  Err otherwise.
- */
-
-var string = function string(blob) {
-  return typeof blob === 'string' ? (0, _result.ok)(blob) : (0, _result.err)((0, _annotate.annotate)(blob, 'Must be string'));
-};
-/**
- * Decoder that only returns Ok for non-empty string inputs.  Err otherwise.
- */
-
-
-exports.string = string;
-var nonEmptyString = regex(/\S/, 'Must be non-empty string');
-/**
- * Decoder that only returns Ok for string inputs that match the regular
- * expression.  Err otherwise.  Will always validate that the input is a string
- * before testing the regex.
- */
-
-exports.nonEmptyString = nonEmptyString;
-
-function regex(regex, msg) {
-  return (0, _composition.predicate)(string, function (s) {
-    return regex.test(s);
-  }, msg);
-}
-/**
- * Decoder that only returns Ok for string inputs that match the almost perfect
- * email regex, taken from http://emailregex.com.  Err otherwise.
- */
-
-
-var email = regex(/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/, 'Must be email');
-exports.email = email;
-var url = (0, _either.either)((0, _composition.transform)(regex(url_re, 'Must be URL'), function (value) {
-  return new URL(value);
-}), (0, _instanceOf.instanceOf)(URL));
-exports.url = url;
-var httpsUrl = (0, _composition.predicate)(url, function (value) {
-  return value.protocol === 'https:';
-}, 'Must be an HTTPS URL');
-exports.httpsUrl = httpsUrl;
-var uuid = regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, 'Must be uuid');
-exports.uuid = uuid;
-var uuidv1 = // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)
-(0, _composition.predicate)(uuid, function (value) {
-  return value[14] === '1';
-}, 'Must be uuidv1');
-exports.uuidv1 = uuidv1;
-var uuidv4 = // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_(random)
-(0, _composition.predicate)(uuid, function (value) {
-  return value[14] === '4';
-}, 'Must be uuidv4');
-exports.uuidv4 = uuidv4;

package/core/string.js.flow

@@ -1,72 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { either } from './either';
-import { err, ok } from '../result';
-import { instanceOf } from './instanceOf';
-import { predicate, transform } from './composition';
-import type { Decoder } from '../_types';
-
-/** Match groups in this regex:
- * \1 - the scheme
- * \2 - the username/password (optional)
- * \3 - the host
- * \4 - the port (optional)
- * \5 - the path (optional)
- */
-const url_re =
-    /^([A-Za-z]{3,9}(?:[+][A-Za-z]{3,9})?):\/\/(?:([-;:&=+$,\w]+)@)?(?:([A-Za-z0-9.-]+)(?::([0-9]{2,5}))?)(\/(?:[-+~%/.,\w]*)?(?:\?[-+=&;%@.,\w]*)?(?:#[.,!/\w]*)?)?$/;
-
-/**
- * Decoder that only returns Ok for string inputs.  Err otherwise.
- */
-export const string: Decoder<string> = (blob: mixed) => {
-    return typeof blob === 'string' ? ok(blob) : err(annotate(blob, 'Must be string'));
-};
-
-/**
- * Decoder that only returns Ok for non-empty string inputs.  Err otherwise.
- */
-export const nonEmptyString: Decoder<string> = regex(/\S/, 'Must be non-empty string');
-
-/**
- * Decoder that only returns Ok for string inputs that match the regular
- * expression.  Err otherwise.  Will always validate that the input is a string
- * before testing the regex.
- */
-export function regex(regex: RegExp, msg: string): Decoder<string> {
-    return predicate(string, (s) => regex.test(s), msg);
-}
-
-/**
- * Decoder that only returns Ok for string inputs that match the almost perfect
- * email regex, taken from http://emailregex.com.  Err otherwise.
- */
-export const email: Decoder<string> = regex(
-    /^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/,
-    'Must be email',
-);
-
-export const url: Decoder<URL> = either(
-    transform(regex(url_re, 'Must be URL'), (value) => new URL(value)),
-    instanceOf(URL),
-);
-
-export const httpsUrl: Decoder<URL> = predicate(
-    url,
-    (value) => value.protocol === 'https:',
-    'Must be an HTTPS URL',
-);
-
-export const uuid: Decoder<string> = regex(
-    /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
-    'Must be uuid',
-);
-
-export const uuidv1: Decoder<string> =
-    // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)
-    predicate(uuid, (value) => value[14] === '1', 'Must be uuidv1');
-
-export const uuidv4: Decoder<string> =
-    // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_(random)
-    predicate(uuid, (value) => value[14] === '4', 'Must be uuidv4');

package/core/string.mjs

@@ -1,58 +0,0 @@
-import { annotate } from '../annotate.mjs';
-import { either } from './either.mjs';
-import { err, ok } from '../result.mjs';
-import { instanceOf } from './instanceOf.mjs';
-import { predicate, transform } from './composition.mjs';
-
-/** Match groups in this regex:
- * \1 - the scheme
- * \2 - the username/password (optional)
- * \3 - the host
- * \4 - the port (optional)
- * \5 - the path (optional)
- */
-var url_re = /^([A-Za-z]{3,9}(?:[+][A-Za-z]{3,9})?):\/\/(?:([-;:&=+$,\w]+)@)?(?:([A-Za-z0-9.-]+)(?::([0-9]{2,5}))?)(\/(?:[-+~%/.,\w]*)?(?:\?[-+=&;%@.,\w]*)?(?:#[.,!/\w]*)?)?$/;
-/**
- * Decoder that only returns Ok for string inputs.  Err otherwise.
- */
-
-export var string = function string(blob) {
-  return typeof blob === 'string' ? ok(blob) : err(annotate(blob, 'Must be string'));
-};
-/**
- * Decoder that only returns Ok for non-empty string inputs.  Err otherwise.
- */
-
-export var nonEmptyString = regex(/\S/, 'Must be non-empty string');
-/**
- * Decoder that only returns Ok for string inputs that match the regular
- * expression.  Err otherwise.  Will always validate that the input is a string
- * before testing the regex.
- */
-
-export function regex(regex, msg) {
-  return predicate(string, function (s) {
-    return regex.test(s);
-  }, msg);
-}
-/**
- * Decoder that only returns Ok for string inputs that match the almost perfect
- * email regex, taken from http://emailregex.com.  Err otherwise.
- */
-
-export var email = regex(/^(([^<>()[\]\\.,;:\s@"]+(\.[^<>()[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/, 'Must be email');
-export var url = either(transform(regex(url_re, 'Must be URL'), function (value) {
-  return new URL(value);
-}), instanceOf(URL));
-export var httpsUrl = predicate(url, function (value) {
-  return value.protocol === 'https:';
-}, 'Must be an HTTPS URL');
-export var uuid = regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i, 'Must be uuid');
-export var uuidv1 = // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_1_(date-time_and_MAC_address)
-predicate(uuid, function (value) {
-  return value[14] === '1';
-}, 'Must be uuidv1');
-export var uuidv4 = // https://en.wikipedia.org/wiki/Universally_unique_identifier#Version_4_(random)
-predicate(uuid, function (value) {
-  return value[14] === '4';
-}, 'Must be uuidv4');

package/core/tuple.d.ts

@@ -1,30 +0,0 @@
-import { Decoder } from '../_types';
-
-export function tuple<A>(a: Decoder<A>): Decoder<[A]>;
-export function tuple<A, B>(a: Decoder<A>, b: Decoder<B>): Decoder<[A, B]>;
-export function tuple<A, B, C>(
-    a: Decoder<A>,
-    b: Decoder<B>,
-    c: Decoder<C>,
-): Decoder<[A, B, C]>;
-export function tuple<A, B, C, D>(
-    a: Decoder<A>,
-    b: Decoder<B>,
-    c: Decoder<C>,
-    d: Decoder<D>,
-): Decoder<[A, B, C, D]>;
-export function tuple<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]>;
-export function tuple<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]>;

package/core/tuple.js

@@ -1,54 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.tuple = void 0;
-
-var _annotate = require("../annotate");
-
-var _composition = require("./composition");
-
-var _result = require("../result");
-
-var _array = require("./array");
-
-var ntuple = function ntuple(n) {
-  return (0, _composition.predicate)(_array.poja, function (arr) {
-    return arr.length === n;
-  }, "Must be a " + n + "-tuple");
-}; // prettier-ignore
-
-
-/**
- * Accepts n-tuples [A, B, C, ...] matching the given decoders A, B, C, ...
- */
-function _tuple() {
-  for (var _len = arguments.length, decoders = new Array(_len), _key = 0; _key < _len; _key++) {
-    decoders[_key] = arguments[_key];
-  }
-
-  return (0, _composition.compose)(ntuple(decoders.length), function (blobs) {
-    var allOk = true;
-    var rvs = decoders.map(function (decoder, i) {
-      var blob = blobs[i];
-      var result = decoder(blob);
-
-      if (result.ok) {
-        return result.value;
-      } else {
-        allOk = false;
-        return result.error;
-      }
-    });
-
-    if (allOk) {
-      return (0, _result.ok)(rvs);
-    } else {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)(rvs));
-    }
-  });
-}
-
-var tuple = _tuple;
-exports.tuple = tuple;

package/core/tuple.js.flow

@@ -1,51 +0,0 @@
-// @flow strict
-
-import { annotate } from '../annotate';
-import { compose, predicate } from './composition';
-import { err, ok } from '../result';
-import { poja } from './array';
-import type { _Any } from '../_utils';
-import type { Decoder } from '../_types';
-
-const ntuple = (n: number) =>
-    predicate(poja, (arr) => arr.length === n, `Must be a ${n}-tuple`);
-
-// prettier-ignore
-interface TupleFuncSignature {
-    <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]>;
-}
-
-/**
- * Accepts n-tuples [A, B, C, ...] matching the given decoders A, B, C, ...
- */
-function _tuple(...decoders: $ReadOnlyArray<Decoder<mixed>>): Decoder<mixed> {
-    return compose(ntuple(decoders.length), (blobs: $ReadOnlyArray<mixed>) => {
-        let allOk = true;
-
-        const rvs = decoders.map((decoder, i) => {
-            const blob = blobs[i];
-            const result = decoder(blob);
-            if (result.ok) {
-                return result.value;
-            } else {
-                allOk = false;
-                return result.error;
-            }
-        });
-
-        if (allOk) {
-            return ok(rvs);
-        } else {
-            // If a decoder error has happened while unwrapping all the
-            // results, try to construct a good error message
-            return err(annotate(rvs));
-        }
-    });
-}
-
-export const tuple: TupleFuncSignature = (_tuple: _Any);

package/core/tuple.mjs

@@ -1,45 +0,0 @@
-import { annotate } from '../annotate.mjs';
-import { compose, predicate } from './composition.mjs';
-import { err, ok } from '../result.mjs';
-import { poja } from './array.mjs';
-
-var ntuple = function ntuple(n) {
-  return predicate(poja, function (arr) {
-    return arr.length === n;
-  }, "Must be a " + n + "-tuple");
-}; // prettier-ignore
-
-
-/**
- * Accepts n-tuples [A, B, C, ...] matching the given decoders A, B, C, ...
- */
-function _tuple() {
-  for (var _len = arguments.length, decoders = new Array(_len), _key = 0; _key < _len; _key++) {
-    decoders[_key] = arguments[_key];
-  }
-
-  return compose(ntuple(decoders.length), function (blobs) {
-    var allOk = true;
-    var rvs = decoders.map(function (decoder, i) {
-      var blob = blobs[i];
-      var result = decoder(blob);
-
-      if (result.ok) {
-        return result.value;
-      } else {
-        allOk = false;
-        return result.error;
-      }
-    });
-
-    if (allOk) {
-      return ok(rvs);
-    } else {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return err(annotate(rvs));
-    }
-  });
-}
-
-export var tuple = _tuple;