decoders 2.0.0-beta1 → 2.0.0-beta13

package/es/stdlib/string.js

@@ -1,76 +0,0 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import { compose, predicate } from './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]*)?)?$/; // The URL schemes the url() decoder accepts by default
-
-var DEFAULT_SCHEMES = ['https'];
-/**
- * Decoder that only returns Ok for string inputs.  Err otherwise.
- */
-
-export var string = function string(blob) {
-  return typeof blob === 'string' ? Result.ok(blob) : Result.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 compose(string, predicate(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');
-/**
- * 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 var url = function url(schemes) {
-  if (schemes === void 0) {
-    schemes = DEFAULT_SCHEMES;
-  }
-
-  return compose(string, function (value) {
-    var matches = value.match(url_re);
-
-    if (!matches) {
-      return Result.err(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(annotate(value, "URL scheme must be any of: " + schemes.join(', ')));
-      }
-    }
-  });
-};

package/es/stdlib/tuple.js

@@ -1,155 +0,0 @@
-import { annotate } from '../annotate';
-import { compose, predicate } from './composition';
-import { err, errValue, isErr, ok, unwrap, value } from '../result';
-import { poja } from './array';
-
-var ntuple = function ntuple(n) {
-  return compose(poja, predicate(function (arr) {
-    return arr.length === n;
-  }, "Must be a " + n + "-tuple"));
-};
-/**
- * Builds a Decoder that returns Ok for 1-tuple of [T], given a Decoder for T.
- * Err otherwise.
- */
-
-
-export function tuple1(decoder1) {
-  return compose(ntuple(1), function (blobs) {
-    var blob1 = blobs[0];
-    var result1 = decoder1(blob1);
-
-    try {
-      return ok([unwrap(result1)]);
-    } catch (e) {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return err(annotate(errValue(result1)));
-    }
-  });
-}
-/**
- * Builds a Decoder that returns Ok for 2-tuples of [T1, T2], given Decoders
- * for T1 and T2.  Err otherwise.
- */
-
-export function tuple2(decoder1, decoder2) {
-  return compose(ntuple(2), function (blobs) {
-    var blob1 = blobs[0],
-        blob2 = blobs[1];
-    var result1 = decoder1(blob1);
-    var result2 = decoder2(blob2);
-
-    try {
-      return ok([unwrap(result1), unwrap(result2)]);
-    } catch (e) {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return err(annotate([isErr(result1) ? errValue(result1) : value(result1), isErr(result2) ? errValue(result2) : value(result2)]));
-    }
-  });
-}
-/**
- * Builds a Decoder that returns Ok for 3-tuples of [T1, T2, T3], given
- * Decoders for T1, T2, and T3.  Err otherwise.
- */
-
-export function tuple3(decoder1, decoder2, decoder3) {
-  return compose(ntuple(3), function (blobs) {
-    var blob1 = blobs[0],
-        blob2 = blobs[1],
-        blob3 = blobs[2];
-    var result1 = decoder1(blob1);
-    var result2 = decoder2(blob2);
-    var result3 = decoder3(blob3);
-
-    try {
-      return ok([unwrap(result1), unwrap(result2), unwrap(result3)]);
-    } catch (e) {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return err(annotate([isErr(result1) ? errValue(result1) : value(result1), isErr(result2) ? errValue(result2) : value(result2), isErr(result3) ? errValue(result3) : value(result3)]));
-    }
-  });
-}
-/**
- * Builds a Decoder that returns Ok for 4-tuples of [T1, T2, T3, T4], given
- * Decoders for T1, T2, T3, and T4.  Err otherwise.
- */
-
-export function tuple4(decoder1, decoder2, decoder3, decoder4) {
-  return compose(ntuple(4), function (blobs) {
-    var blob1 = blobs[0],
-        blob2 = blobs[1],
-        blob3 = blobs[2],
-        blob4 = blobs[3];
-    var result1 = decoder1(blob1);
-    var result2 = decoder2(blob2);
-    var result3 = decoder3(blob3);
-    var result4 = decoder4(blob4);
-
-    try {
-      return ok([unwrap(result1), unwrap(result2), unwrap(result3), unwrap(result4)]);
-    } catch (e) {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return err(annotate([isErr(result1) ? errValue(result1) : value(result1), isErr(result2) ? errValue(result2) : value(result2), isErr(result3) ? errValue(result3) : value(result3), isErr(result4) ? errValue(result4) : value(result4)]));
-    }
-  });
-}
-/**
- * Builds a Decoder that returns Ok for 5-tuples of [T1, T2, T3, T4, T5], given
- * Decoders for T1, T2, T3, T4, and T5.  Err otherwise.
- */
-
-export function tuple5(decoder1, decoder2, decoder3, decoder4, decoder5) {
-  return compose(ntuple(5), function (blobs) {
-    var blob1 = blobs[0],
-        blob2 = blobs[1],
-        blob3 = blobs[2],
-        blob4 = blobs[3],
-        blob5 = blobs[4];
-    var result1 = decoder1(blob1);
-    var result2 = decoder2(blob2);
-    var result3 = decoder3(blob3);
-    var result4 = decoder4(blob4);
-    var result5 = decoder5(blob5);
-
-    try {
-      return ok([unwrap(result1), unwrap(result2), unwrap(result3), unwrap(result4), unwrap(result5)]);
-    } catch (e) {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return err(annotate([isErr(result1) ? errValue(result1) : value(result1), isErr(result2) ? errValue(result2) : value(result2), isErr(result3) ? errValue(result3) : value(result3), isErr(result4) ? errValue(result4) : value(result4), isErr(result5) ? errValue(result5) : value(result5)]));
-    }
-  });
-}
-/**
- * Builds a Decoder that returns Ok for 5-tuples of [T1, T2, T3, T4, T5], given
- * Decoders for T1, T2, T3, T4, T5, and T6.  Err otherwise.
- */
-
-export function tuple6(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6) {
-  return compose(ntuple(6), function (blobs) {
-    var blob1 = blobs[0],
-        blob2 = blobs[1],
-        blob3 = blobs[2],
-        blob4 = blobs[3],
-        blob5 = blobs[4],
-        blob6 = blobs[5];
-    var result1 = decoder1(blob1);
-    var result2 = decoder2(blob2);
-    var result3 = decoder3(blob3);
-    var result4 = decoder4(blob4);
-    var result5 = decoder5(blob5);
-    var result6 = decoder6(blob6);
-
-    try {
-      return ok([unwrap(result1), unwrap(result2), unwrap(result3), unwrap(result4), unwrap(result5), unwrap(result6)]);
-    } catch (e) {
-      // If a decoder error has happened while unwrapping all the
-      // results, try to construct a good error message
-      return err(annotate([isErr(result1) ? errValue(result1) : value(result1), isErr(result2) ? errValue(result2) : value(result2), isErr(result3) ? errValue(result3) : value(result3), isErr(result4) ? errValue(result4) : value(result4), isErr(result5) ? errValue(result5) : value(result5), isErr(result6) ? errValue(result6) : value(result6)]));
-    }
-  });
-}

package/ts/_guard.d.ts

@@ -1,7 +0,0 @@
-import { Annotation } from './annotate';
-import { Decoder, Guard } from './_types';
-
-export function guard<T>(
-    decoder: Decoder<T>,
-    formatter?: (annotation: Annotation) => string,
-): Guard<T>;

package/ts/_types.d.ts

@@ -1,16 +0,0 @@
-import { Annotation } from './annotate';
-import { Result } from './result';
-
-export type Scalar = string | number | boolean | symbol | undefined | null;
-
-export interface Guard<T> {
-    (blob: unknown): T;
-}
-export type Predicate<T> = (value: T) => boolean;
-export type DecodeResult<T> = Result<T, Annotation>;
-export interface Decoder<T, F = unknown> {
-    (blob: F): DecodeResult<T>;
-}
-
-export type DecoderType<T> = T extends Decoder<infer V> ? V : never;
-export type GuardType<T> = T extends Guard<infer V> ? V : never;

package/ts/_utils.d.ts

@@ -1,13 +0,0 @@
-import { Decoder } from './_types';
-
-export function isDate(value: unknown): boolean;
-export function map<T, V>(decoder: Decoder<T>, mapper: (value: T) => V): Decoder<V>;
-export function compose<T, V>(decoder: Decoder<T>, next: Decoder<V, T>): Decoder<V>;
-export function predicate<T extends F, F = unknown>(
-    predicate: (value: F) => value is T,
-    msg: string,
-): Decoder<T, F>;
-export function predicate<T>(
-    predicate: (value: T) => boolean,
-    msg: string,
-): Decoder<T, T>;

package/ts/array.d.ts

@@ -1,5 +0,0 @@
-import { Decoder } from '../_types';
-
-export const poja: Decoder<unknown[]>;
-export function array<T>(decoder: Decoder<T>): Decoder<T[]>;
-export function nonEmptyArray<T>(decoder: Decoder<T>): Decoder<[T, ...T[]]>;

package/ts/boolean.d.ts

@@ -1,5 +0,0 @@
-import { Decoder } from '../_types';
-
-export const boolean: Decoder<boolean>;
-export const truthy: Decoder<boolean>;
-export const numericBoolean: Decoder<boolean>;

package/ts/constants.d.ts

@@ -1,11 +0,0 @@
-import { Decoder, Scalar } from '../_types';
-
-// Constants
-
-export const null_: Decoder<null>;
-export const undefined_: Decoder<undefined>;
-export function constant<T extends Scalar>(value: T): Decoder<T>;
-export function hardcoded<T extends Scalar>(value: T): Decoder<T>;
-export function hardcoded<T>(value: T): Decoder<T>;
-export const mixed: Decoder<unknown>;
-export const unknown: Decoder<unknown>;

package/ts/date.d.ts

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

package/ts/describe.d.ts

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

package/ts/dispatch.d.ts

@@ -1,8 +0,0 @@
-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/ts/either.d.ts

@@ -1,61 +0,0 @@
-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/ts/fail.d.ts

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

package/ts/index.d.ts

@@ -1,42 +0,0 @@
-export { Decoder, Guard } from './_types';
-export { DecoderType, GuardType } from './_types';
-
-export { guard } from './_guard';
-export { compose, map, predicate } from './_utils';
-
-export { JSONArray, JSONObject, JSONValue } from './stdlib/json';
-
-export { array, nonEmptyArray, poja } from './stdlib/array';
-export { boolean, numericBoolean, truthy } from './stdlib/boolean';
-export {
-    constant,
-    hardcoded,
-    mixed,
-    null_,
-    undefined_,
-    unknown,
-} from './stdlib/constants';
-export { date, iso8601 } from './stdlib/date';
-export { describe } from './stdlib/describe';
-export { dispatch } from './stdlib/dispatch';
-export {
-    either,
-    either3,
-    either4,
-    either5,
-    either6,
-    either7,
-    either8,
-    either9,
-    oneOf,
-} from './stdlib/either';
-export { fail } from './stdlib/fail';
-export { instanceOf } from './stdlib/instanceOf';
-export { json, jsonArray, jsonObject } from './stdlib/json';
-export { lazy } from './stdlib/lazy';
-export { mapping, dict } from './stdlib/mapping';
-export { integer, number, positiveInteger, positiveNumber } from './stdlib/number';
-export { exact, inexact, object, pojo } from './stdlib/object';
-export { maybe, nullable, optional } from './stdlib/optional';
-export { email, nonEmptyString, regex, string, url } from './stdlib/string';
-export { tuple1, tuple2, tuple3, tuple4, tuple5, tuple6 } from './stdlib/tuple';

package/ts/inline.d.ts

@@ -1,3 +0,0 @@
-import { Annotation } from '../annotate';
-
-export function formatInline(ann: Annotation): string;

package/ts/instanceOf.d.ts

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

package/ts/json.d.ts

@@ -1,11 +0,0 @@
-import { Decoder } from '../_types';
-
-export type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
-export interface JSONObject {
-    [key: string]: JSONValue;
-}
-export type JSONArray = JSONValue[];
-
-export const json: Decoder<JSONValue>;
-export const jsonArray: Decoder<JSONArray>;
-export const jsonObject: Decoder<JSONObject>;

package/ts/lazy.d.ts

@@ -1,3 +0,0 @@
-import { Decoder } from '../_types';
-
-export function lazy<T>(decoderFn: () => Decoder<T>): Decoder<T>;

package/ts/mapping.d.ts

@@ -1,4 +0,0 @@
-import { Decoder } from '../_types';
-
-export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>>;
-export function dict<T>(decoder: Decoder<T>): Decoder<{ [key: string]: T }>;

package/ts/number.d.ts

@@ -1,6 +0,0 @@
-import { Decoder } from '../_types';
-
-export const integer: Decoder<number>;
-export const number: Decoder<number>;
-export const positiveInteger: Decoder<number>;
-export const positiveNumber: Decoder<number>;

package/ts/object.d.ts

@@ -1,33 +0,0 @@
-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;
-    }
->;

package/ts/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/ts/result.d.ts

@@ -1,39 +0,0 @@
-export interface Ok<T> {
-    readonly type: 'ok';
-    readonly value: T;
-}
-
-export interface Err<E> {
-    readonly type: 'err';
-    readonly error: E;
-}
-
-export type Result<T, E> = Ok<T> | Err<E>;
-
-export function ok<T>(value: T): Ok<T>;
-export function err<E>(error: E): Err<E>;
-export function toString(result: Result<unknown, unknown>): string;
-export function isOk(result: Result<unknown, unknown>): boolean;
-export function isErr(result: Result<unknown, unknown>): boolean;
-export function withDefault<T>(result: Result<T, unknown>, defaultValue: T): T;
-export function value<T>(result: Result<T, unknown>): void | T;
-export function errValue<E>(result: Result<unknown, E>): void | E;
-export function unwrap<T>(result: Result<T, unknown>): T;
-export function expect<T>(result: Result<T, unknown>, message: string | Error): T;
-export function dispatch<T, E, O>(
-    result: Result<T, E>,
-    okCallback: (value: T) => O,
-    errCallback: (error: E) => O,
-): O;
-export function andThen<T, E, V>(
-    result: Result<T, E>,
-    callback: (value: T) => Result<V, E>,
-): Result<V, E>;
-export function map<T, E, T2>(
-    result: Result<T, E>,
-    mapper: (value: T) => T2,
-): Result<T2, E>;
-export function mapError<T, E, E2>(
-    result: Result<T, E>,
-    mapper: (error: E) => E2,
-): Result<T, E2>;

package/ts/short.d.ts

@@ -1,3 +0,0 @@
-import { Annotation } from '../annotate';
-
-export function formatShort(ann: Annotation): string;

package/ts/string.d.ts

@@ -1,7 +0,0 @@
-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 function url(schemes?: readonly string[]): Decoder<string>;

package/ts/tuple.d.ts

@@ -1,30 +0,0 @@
-import { Decoder } from '../_types';
-
-export function tuple1<T1>(d1: Decoder<T1>): Decoder<[T1]>;
-export function tuple2<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<[T1, T2]>;
-export function tuple3<T1, T2, T3>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-): Decoder<[T1, T2, T3]>;
-export function tuple4<T1, T2, T3, T4>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-): Decoder<[T1, T2, T3, T4]>;
-export function tuple5<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 tuple6<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]>;