decoders 1.25.4 → 2.0.0-beta1

package/{object.js.flow → cjs/stdlib/object.js.flow}

@@ -1,11 +1,10 @@
 // @flow strict
 
-import { annotate, annotateFields, isAnnotation } from 'debrief';
-import type { Annotation } from 'debrief';
-import { Err, Ok } from 'lemons/Result';
-
-import type { $DecoderType, Decoder } from './types';
-import { compose, map } from './utils';
+import * as Result from '../result';
+import { annotate, annotateObject, merge, updateText } from '../annotate';
+import { compose, map } from './composition';
+import type { Annotation } from '../annotate';
+import type { Decoder, DecoderType } from '../_types';
 
 // $FlowFixMe[unclear-type] (not really an issue) - deliberate use of `any` - not sure how we should get rid of this
 type AnyDecoder = any;
@@ -27,17 +26,17 @@ function isPojo(o: mixed): boolean %checks {
 
 function subtract(xs: Set<string>, ys: Set<string>): Set<string> {
     const result = new Set();
-    for (const x of xs) {
+    xs.forEach((x) => {
         if (!ys.has(x)) {
             result.add(x);
         }
-    }
+    });
     return result;
 }
 
 export const pojo: Decoder<{| [string]: mixed |}> = (blob: mixed) => {
     return isPojo(blob)
-        ? Ok(
+        ? Result.ok(
               // NOTE:
               // Since Flow 0.98, typeof o === 'object' refines to
               //     {| +[string]: mixed |}
@@ -52,9 +51,9 @@ export const pojo: Decoder<{| [string]: mixed |}> = (blob: mixed) => {
               // 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)
-              { ...blob }
+              { ...blob },
           )
-        : Err(annotate(blob, 'Must be an object'));
+        : Result.err(annotate(blob, 'Must be an object'));
 };
 
 /**
@@ -77,10 +76,10 @@ export const pojo: Decoder<{| [string]: mixed |}> = (blob: mixed) => {
  * in an object, and wraps it in a Decoder<...>.
  */
 export function object<O: { +[field: string]: AnyDecoder, ... }>(
-    mapping: O
-): Decoder<$ObjMap<O, $DecoderType>> {
+    mapping: O,
+): Decoder<$ObjMap<O, DecoderType>> {
     const known = new Set(Object.keys(mapping));
-    return compose(pojo, (blob: {| [string]: mixed |}) => {
+    return compose(pojo, (blob: { +[string]: mixed }) => {
         const actual = new Set(Object.keys(blob));
 
         // At this point, "missing" will also include all fields that may
@@ -90,16 +89,15 @@ export function object<O: { +[field: string]: AnyDecoder, ... }>(
         const missing = subtract(known, actual);
 
         let record = {};
-        const fieldErrors: { [key: string]: Annotation } = { ...null };
+        let errors: { [key: string]: Annotation } | null = null;
 
-        // NOTE: We're using .keys() here over .entries(), since .entries()
-        // will type the value part as "mixed"
-        for (const key of Object.keys(mapping)) {
+        Object.keys(mapping).forEach((key) => {
             const decoder = mapping[key];
             const rawValue = blob[key];
             const result = decoder(rawValue);
-            try {
-                const value = result.unwrap();
+
+            if (result.type === 'ok') {
+                const value = result.value;
                 if (value !== undefined) {
                     record[key] = value;
                 }
@@ -107,11 +105,8 @@ export function object<O: { +[field: string]: AnyDecoder, ... }>(
                 // If this succeeded, remove the key from the missing keys
                 // tracker
                 missing.delete(key);
-            } catch (ann) {
-                /* istanbul ignore next */
-                if (!isAnnotation(ann)) {
-                    throw ann;
-                }
+            } else {
+                const ann = result.error;
 
                 // Keep track of the annotation, but don't return just yet. We
                 // want to collect more error information.
@@ -122,24 +117,23 @@ export function object<O: { +[field: string]: AnyDecoder, ... }>(
                     // keys).
                     missing.add(key);
                 } else {
-                    fieldErrors[key] = ann;
+                    if (errors === null) {
+                        errors = {};
+                    }
+                    errors[key] = ann;
                 }
             }
-        }
+        });
 
         // Deal with errors now. There are two classes of errors we want to
         // report.  First of all, we want to report any inline errors in this
         // object.  Lastly, any fields that are missing should be annotated on
         // the outer object itself.
-        const fieldsWithErrors = Object.keys(fieldErrors);
-        if (fieldsWithErrors.length > 0 || missing.size > 0) {
-            let err;
+        if (errors || missing.size > 0) {
+            let objAnn = annotateObject(blob);
 
-            if (fieldsWithErrors.length > 0) {
-                const errorlist = fieldsWithErrors.map((k) => [k, fieldErrors[k]]);
-                err = annotateFields(blob, errorlist);
-            } else {
-                err = annotate(blob);
+            if (errors) {
+                objAnn = merge(objAnn, errors);
             }
 
             if (missing.size > 0) {
@@ -147,54 +141,52 @@ export function object<O: { +[field: string]: AnyDecoder, ... }>(
                     .map((key) => `"${key}"`)
                     .join(', ');
                 const pluralized = missing.size > 1 ? 'keys' : 'key';
-                err = annotate(err, `Missing ${pluralized}: ${errMsg}`);
+                objAnn = updateText(objAnn, `Missing ${pluralized}: ${errMsg}`);
             }
 
-            return Err(err);
+            return Result.err(objAnn);
         }
 
-        return Ok(record);
+        return Result.ok(record);
     });
 }
 
 export function exact<O: { +[field: string]: AnyDecoder, ... }>(
-    mapping: O
-): Decoder<$ObjMap<$Exact<O>, $DecoderType>> {
+    mapping: O,
+): Decoder<$ObjMap<$Exact<O>, DecoderType>> {
     // Check the inputted object for any superfluous keys
     const allowed = new Set(Object.keys(mapping));
     const checked = compose(pojo, (blob: {| [string]: mixed |}) => {
         const actual = new Set(Object.keys(blob));
         const superfluous = subtract(actual, allowed);
         if (superfluous.size > 0) {
-            return Err(
-                annotate(blob, `Superfluous keys: ${Array.from(superfluous).join(', ')}`)
+            return Result.err(
+                annotate(blob, `Superfluous keys: ${Array.from(superfluous).join(', ')}`),
             );
         }
-        return Ok(blob);
+        return Result.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.
-    const decoder = ((object(mapping): cast): Decoder<$ObjMap<$Exact<O>, $DecoderType>>);
+    const decoder = ((object(mapping): cast): Decoder<$ObjMap<$Exact<O>, DecoderType>>);
     return compose(checked, decoder);
 }
 
 export function inexact<O: { +[field: string]: AnyDecoder }>(
-    mapping: O
-): Decoder<$ObjMap<O, $DecoderType> & { +[string]: mixed }> {
+    mapping: O,
+): Decoder<$ObjMap<O, DecoderType> & { +[string]: mixed }> {
     return compose(pojo, (blob: {| [string]: mixed |}) => {
         const allkeys = new Set(Object.keys(blob));
-        const decoder = map(object(mapping), (safepart: $ObjMap<O, $DecoderType>) => {
+        const decoder = map(object(mapping), (safepart: $ObjMap<O, DecoderType>) => {
             const safekeys = new Set(Object.keys(mapping));
 
             // To account for hard-coded keys that aren't part of the input
-            for (const k of safekeys) {
-                allkeys.add(k);
-            }
+            safekeys.forEach((k) => allkeys.add(k));
 
             const rv = {};
-            for (const k of allkeys) {
+            allkeys.forEach((k) => {
                 if (safekeys.has(k)) {
                     const value = safepart[k];
                     if (value !== undefined) {
@@ -203,7 +195,7 @@ export function inexact<O: { +[field: string]: AnyDecoder }>(
                 } else {
                     rv[k] = blob[k];
                 }
-            }
+            });
             return rv;
         });
         return decoder(blob);

package/cjs/stdlib/optional.js

@@ -0,0 +1,54 @@
+"use strict";
+
+exports.__esModule = true;
+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); }
+
+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; }
+
+/**
+ * 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 ? Result.ok(blob) : // Combine error message into a single line
+  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/{optional.js.flow → cjs/stdlib/optional.js.flow}

@@ -1,11 +1,10 @@
 // @flow strict
 
-import { annotate } from 'debrief';
-import { Err, Ok } from 'lemons/Result';
-
-import { null_, undefined_ } from './constants';
+import * as Result from '../result';
+import { annotate } from '../annotate';
 import { either } from './either';
-import type { Decoder } from './types';
+import { null_, undefined_ } from './constants';
+import type { Decoder } from '../_types';
 
 /**
  * Builds a Decoder that returns Ok for either `undefined` or `T` values,
@@ -30,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
-        ? Ok(blob)
+        ? Result.ok(blob)
         : // Combine error message into a single line
-          Err(annotate(blob, 'Must be undefined or null'));
+          Result.err(annotate(blob, 'Must be undefined or null'));
 
 /**
  * Decoder that only returns Ok for `null` or `undefined` inputs.

package/cjs/stdlib/string.js

@@ -0,0 +1,98 @@
+"use strict";
+
+exports.__esModule = true;
+exports.nonEmptyString = exports.email = void 0;
+exports.regex = regex;
+exports.url = exports.string = void 0;
+
+var Result = _interopRequireWildcard(require("../result"));
+
+var _annotate = require("../annotate");
+
+var _composition = require("./composition");
+
+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; }
+
+/** 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.
+ */
+
+var string = function string(blob) {
+  return typeof blob === 'string' ? Result.ok(blob) : 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.compose)(string, (0, _composition.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.
+ */
+
+
+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;

package/{string.js.flow → cjs/stdlib/string.js.flow}

@@ -1,10 +1,9 @@
 // @flow strict
 
-import { annotate } from 'debrief';
-import { Err, Ok } from 'lemons/Result';
-
-import type { Decoder } from './types';
-import { compose, predicate } from './utils';
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import { compose, predicate } from './composition';
+import type { Decoder } from '../_types';
 
 /** Match groups in this regex:
  * \1 - the scheme
@@ -23,7 +22,9 @@ 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' ? Ok(blob) : Err(annotate(blob, 'Must be string'));
+    return typeof blob === 'string'
+        ? Result.ok(blob)
+        : Result.err(annotate(blob, 'Must be string'));
 };
 
 /**
@@ -39,7 +40,7 @@ export const nonEmptyString: Decoder<string> = regex(/\S/, 'Must be non-empty st
 export function regex(regex: RegExp, msg: string): Decoder<string> {
     return compose(
         string,
-        predicate((s) => regex.test(s), msg)
+        predicate((s) => regex.test(s), msg),
     );
 }
 
@@ -49,7 +50,7 @@ export function regex(regex: RegExp, msg: string): Decoder<string> {
  */
 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'
+    'Must be email',
 );
 
 /**
@@ -67,14 +68,14 @@ export const url = (schemes: $ReadOnlyArray<string> = DEFAULT_SCHEMES): Decoder<
     compose(string, (value: string) => {
         const matches = value.match(url_re);
         if (!matches) {
-            return Err(annotate(value, 'Must be URL'));
+            return Result.err(annotate(value, 'Must be URL'));
         } else {
             const scheme = matches[1];
             if (schemes.length === 0 || schemes.includes(scheme.toLowerCase())) {
-                return Ok(value);
+                return Result.ok(value);
             } else {
-                return Err(
-                    annotate(value, `URL scheme must be any of: ${schemes.join(', ')}`)
+                return Result.err(
+                    annotate(value, `URL scheme must be any of: ${schemes.join(', ')}`),
                 );
             }
         }

package/cjs/stdlib/tuple.js

@@ -0,0 +1,173 @@
+"use strict";
+
+exports.__esModule = true;
+exports.tuple1 = tuple1;
+exports.tuple2 = tuple2;
+exports.tuple3 = tuple3;
+exports.tuple4 = tuple4;
+exports.tuple5 = tuple5;
+exports.tuple6 = tuple6;
+
+var _annotate = require("../annotate");
+
+var _composition = require("./composition");
+
+var _result = require("../result");
+
+var _array = require("./array");
+
+var ntuple = function ntuple(n) {
+  return (0, _composition.compose)(_array.poja, (0, _composition.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.
+ */
+
+
+function tuple1(decoder1) {
+  return (0, _composition.compose)(ntuple(1), function (blobs) {
+    var blob1 = blobs[0];
+    var result1 = decoder1(blob1);
+
+    try {
+      return (0, _result.ok)([(0, _result.unwrap)(result1)]);
+    } catch (e) {
+      // 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)((0, _result.errValue)(result1)));
+    }
+  });
+}
+/**
+ * Builds a Decoder that returns Ok for 2-tuples of [T1, T2], given Decoders
+ * for T1 and T2.  Err otherwise.
+ */
+
+
+function tuple2(decoder1, decoder2) {
+  return (0, _composition.compose)(ntuple(2), function (blobs) {
+    var blob1 = blobs[0],
+        blob2 = blobs[1];
+    var result1 = decoder1(blob1);
+    var result2 = decoder2(blob2);
+
+    try {
+      return (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2)]);
+    } catch (e) {
+      // 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)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2)]));
+    }
+  });
+}
+/**
+ * Builds a Decoder that returns Ok for 3-tuples of [T1, T2, T3], given
+ * Decoders for T1, T2, and T3.  Err otherwise.
+ */
+
+
+function tuple3(decoder1, decoder2, decoder3) {
+  return (0, _composition.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 (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2), (0, _result.unwrap)(result3)]);
+    } catch (e) {
+      // 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)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.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.
+ */
+
+
+function tuple4(decoder1, decoder2, decoder3, decoder4) {
+  return (0, _composition.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 (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2), (0, _result.unwrap)(result3), (0, _result.unwrap)(result4)]);
+    } catch (e) {
+      // 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)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3), (0, _result.isErr)(result4) ? (0, _result.errValue)(result4) : (0, _result.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.
+ */
+
+
+function tuple5(decoder1, decoder2, decoder3, decoder4, decoder5) {
+  return (0, _composition.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 (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2), (0, _result.unwrap)(result3), (0, _result.unwrap)(result4), (0, _result.unwrap)(result5)]);
+    } catch (e) {
+      // 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)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3), (0, _result.isErr)(result4) ? (0, _result.errValue)(result4) : (0, _result.value)(result4), (0, _result.isErr)(result5) ? (0, _result.errValue)(result5) : (0, _result.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.
+ */
+
+
+function tuple6(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6) {
+  return (0, _composition.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 (0, _result.ok)([(0, _result.unwrap)(result1), (0, _result.unwrap)(result2), (0, _result.unwrap)(result3), (0, _result.unwrap)(result4), (0, _result.unwrap)(result5), (0, _result.unwrap)(result6)]);
+    } catch (e) {
+      // 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)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3), (0, _result.isErr)(result4) ? (0, _result.errValue)(result4) : (0, _result.value)(result4), (0, _result.isErr)(result5) ? (0, _result.errValue)(result5) : (0, _result.value)(result5), (0, _result.isErr)(result6) ? (0, _result.errValue)(result6) : (0, _result.value)(result6)]));
+    }
+  });
+}