decoders 2.0.0-beta5 → 2.0.0-beta9

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

@@ -1,8 +1,8 @@
 function _extends() { _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
 
-import * as Result from '../result';
-import { annotate, annotateObject, merge, updateText } from '../annotate';
-import { compose, map } from './composition';
+import { annotate, annotateObject, merge, updateText } from '../annotate.mjs';
+import { compose, transform } from './composition.mjs';
+import { err, ok } from '../result.mjs';
 
 function isPojo(o) {
   return o !== null && o !== undefined && typeof o === 'object' && // This still seems to be the only reliable way to determine whether
@@ -22,7 +22,7 @@ function subtract(xs, ys) {
 }
 
 export var pojo = function pojo(blob) {
-  return isPojo(blob) ? Result.ok( // NOTE:
+  return isPojo(blob) ? ok( // NOTE:
   // Since Flow 0.98, typeof o === 'object' refines to
   //     {| +[string]: mixed |}
   // instead of
@@ -36,7 +36,7 @@ export var pojo = function pojo(blob) {
   // way to turn a read-only Object to a writeable one in ES6 seems
   // to be to use object-spread. (Going off this benchmark:
   // https://thecodebarbarian.com/object-assign-vs-object-spread.html)
-  _extends({}, blob)) : Result.err(annotate(blob, 'Must be an object'));
+  _extends({}, blob)) : err(annotate(blob, 'Must be an object'));
 };
 /**
  * Given a mapping of fields-to-decoders, builds a decoder for an object type.
@@ -74,7 +74,7 @@ export 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) {
@@ -122,10 +122,10 @@ export function object(mapping) {
         objAnn = updateText(objAnn, "Missing " + pluralized + ": " + errMsg);
       }
 
-      return Result.err(objAnn);
+      return err(objAnn);
     }
 
-    return Result.ok(record);
+    return ok(record);
   });
 }
 export function exact(mapping) {
@@ -136,10 +136,10 @@ export function exact(mapping) {
     var superfluous = subtract(actual, allowed);
 
     if (superfluous.size > 0) {
-      return Result.err(annotate(blob, "Superfluous keys: " + Array.from(superfluous).join(', ')));
+      return err(annotate(blob, "Superfluous keys: " + Array.from(superfluous).join(', ')));
     }
 
-    return Result.ok(blob);
+    return ok(blob);
   }); // Defer to the "object" decoder for doing the real decoding work.  Since
   // we made sure there are no superfluous keys in this structure, it's now
   // safe to force-cast it to an $Exact<> type.
@@ -150,7 +150,7 @@ export function exact(mapping) {
 export function inexact(mapping) {
   return compose(pojo, function (blob) {
     var allkeys = new Set(Object.keys(blob));
-    var decoder = map(object(mapping), function (safepart) {
+    var decoder = 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) {
@@ -172,4 +172,57 @@ export function inexact(mapping) {
     });
     return decoder(blob);
   });
+}
+/**
+ * Like mapping(), but returns an object rather than a Map instance.
+ */
+
+export function dict(decoder) {
+  return 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 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(decoder) {
+  return 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/optional.d.ts

@@ -0,0 +1,5 @@
+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

@@ -5,17 +5,13 @@ exports.maybe = maybe;
 exports.nullable = nullable;
 exports.optional = optional;
 
-var Result = _interopRequireWildcard(require("../result"));
-
 var _annotate = require("../annotate");
 
 var _either = require("./either");
 
-var _constants = require("./constants");
-
-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 _constants = require("./constants");
 
 /**
  * Builds a Decoder that returns Ok for either `undefined` or `T` values,
@@ -41,8 +37,8 @@ function nullable(decoder) {
 
 
 var undefined_or_null = function undefined_or_null(blob) {
-  return blob === undefined || blob === null ? Result.ok(blob) : // Combine error message into a single line
-  Result.err((0, _annotate.annotate)(blob, 'Must be undefined or null'));
+  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.

package/core/optional.js.flow

@@ -1,8 +1,8 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
 import { either } from './either';
+import { err, ok } from '../result';
 import { null_, undefined_ } from './constants';
 import type { Decoder } from '../_types';
 
@@ -29,9 +29,9 @@ export function nullable<T>(decoder: Decoder<T>): Decoder<null | T> {
  */
 const undefined_or_null: Decoder<null | void> = (blob: mixed) =>
     blob === undefined || blob === null
-        ? Result.ok(blob)
+        ? ok(blob)
         : // Combine error message into a single line
-          Result.err(annotate(blob, 'Must be undefined or null'));
+          err(annotate(blob, 'Must be undefined or null'));
 
 /**
  * Decoder that only returns Ok for `null` or `undefined` inputs.

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

@@ -1,7 +1,7 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import { either } from './either';
-import { null_, undefined_ } from './constants';
+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,
@@ -25,8 +25,8 @@ export function nullable(decoder) {
  */
 
 var undefined_or_null = function undefined_or_null(blob) {
-  return blob === undefined || blob === null ? Result.ok(blob) : // Combine error message into a single line
-  Result.err(annotate(blob, 'Must be undefined or null'));
+  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.

package/core/string.d.ts

@@ -0,0 +1,13 @@
+/// <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,19 +1,19 @@
 "use strict";
 
 exports.__esModule = true;
-exports.nonEmptyString = exports.email = void 0;
+exports.nonEmptyString = exports.httpsUrl = exports.email = void 0;
 exports.regex = regex;
-exports.url = exports.string = void 0;
-
-var Result = _interopRequireWildcard(require("../result"));
+exports.uuidv4 = exports.uuidv1 = exports.uuid = exports.url = exports.string = void 0;
 
 var _annotate = require("../annotate");
 
-var _composition = require("./composition");
+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); }
+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 _instanceOf = require("./instanceOf");
+
+var _composition = require("./composition");
 
 /** Match groups in this regex:
  * \1 - the scheme
@@ -22,15 +22,13 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
  * \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]*)?)?$/; // The URL schemes the url() decoder accepts by default
-
-var DEFAULT_SCHEMES = ['https'];
+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' ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, 'Must be string'));
+  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.
@@ -48,9 +46,9 @@ var nonEmptyString = regex(/\S/, 'Must be non-empty string');
 exports.nonEmptyString = nonEmptyString;
 
 function regex(regex, msg) {
-  return (0, _composition.compose)(string, (0, _composition.predicate)(function (s) {
+  return (0, _composition.predicate)(string, function (s) {
     return regex.test(s);
-  }, msg));
+  }, msg);
 }
 /**
  * Decoder that only returns Ok for string inputs that match the almost perfect
@@ -59,40 +57,24 @@ function regex(regex, msg) {
 
 
 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');
-/**
- * Decoder that only returns Ok for string inputs that match URLs of the
- * expected scheme.  Defaults to only accept HTTPS URLs.  Err otherwise.
- *
- * Variants that can be used:
- *
- * - url()                      accepts only https:// URLs
- * - url([])                    accepts any URL scheme
- * - url(['http'])              accepts only HTTP
- * - url(['https', 'git+ssh'])  accepts both https:// and git+ssh:// URLs
- */
-
 exports.email = email;
-
-var url = function url(schemes) {
-  if (schemes === void 0) {
-    schemes = DEFAULT_SCHEMES;
-  }
-
-  return (0, _composition.compose)(string, function (value) {
-    var matches = value.match(url_re);
-
-    if (!matches) {
-      return Result.err((0, _annotate.annotate)(value, 'Must be URL'));
-    } else {
-      var scheme = matches[1];
-
-      if (schemes.length === 0 || schemes.includes(scheme.toLowerCase())) {
-        return Result.ok(value);
-      } else {
-        return Result.err((0, _annotate.annotate)(value, "URL scheme must be any of: " + schemes.join(', ')));
-      }
-    }
-  });
-};
-
-exports.url = url;
+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,8 +1,10 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
-import { compose, predicate } from './composition';
+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:
@@ -15,16 +17,11 @@ import type { Decoder } from '../_types';
 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]*)?)?$/;
 
-// The URL schemes the url() decoder accepts by default
-const DEFAULT_SCHEMES = ['https'];
-
 /**
  * Decoder that only returns Ok for string inputs.  Err otherwise.
  */
 export const string: Decoder<string> = (blob: mixed) => {
-    return typeof blob === 'string'
-        ? Result.ok(blob)
-        : Result.err(annotate(blob, 'Must be string'));
+    return typeof blob === 'string' ? ok(blob) : err(annotate(blob, 'Must be string'));
 };
 
 /**
@@ -38,10 +35,7 @@ export const nonEmptyString: Decoder<string> = regex(/\S/, 'Must be non-empty st
  * before testing the regex.
  */
 export function regex(regex: RegExp, msg: string): Decoder<string> {
-    return compose(
-        string,
-        predicate((s) => regex.test(s), msg),
-    );
+    return predicate(string, (s) => regex.test(s), msg);
 }
 
 /**
@@ -53,30 +47,26 @@ export const email: Decoder<string> = regex(
     'Must be email',
 );
 
-/**
- * Decoder that only returns Ok for string inputs that match URLs of the
- * expected scheme.  Defaults to only accept HTTPS URLs.  Err otherwise.
- *
- * Variants that can be used:
- *
- * - url()                      accepts only https:// URLs
- * - url([])                    accepts any URL scheme
- * - url(['http'])              accepts only HTTP
- * - url(['https', 'git+ssh'])  accepts both https:// and git+ssh:// URLs
- */
-export const url = (schemes: $ReadOnlyArray<string> = DEFAULT_SCHEMES): Decoder<string> =>
-    compose(string, (value: string) => {
-        const matches = value.match(url_re);
-        if (!matches) {
-            return Result.err(annotate(value, 'Must be URL'));
-        } else {
-            const scheme = matches[1];
-            if (schemes.length === 0 || schemes.includes(scheme.toLowerCase())) {
-                return Result.ok(value);
-            } else {
-                return Result.err(
-                    annotate(value, `URL scheme must be any of: ${schemes.join(', ')}`),
-                );
-            }
-        }
-    });
+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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,30 @@
+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]>;