decoders 2.0.0-beta5 → 2.0.0-beta9

package/core/tuple.js

@@ -1,12 +1,7 @@
 "use strict";
 
 exports.__esModule = true;
-exports.tuple1 = tuple1;
-exports.tuple2 = tuple2;
-exports.tuple3 = tuple3;
-exports.tuple4 = tuple4;
-exports.tuple5 = tuple5;
-exports.tuple6 = tuple6;
+exports.tuple = void 0;
 
 var _annotate = require("../annotate");
 
@@ -17,157 +12,43 @@ 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 (0, _composition.predicate)(_array.poja, 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.
- */
+  }, "Must be a " + n + "-tuple");
+}; // prettier-ignore
 
 
-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.okOrErrValue)(result1)]));
-    }
-  });
-}
 /**
- * Builds a Decoder that returns Ok for 2-tuples of [T1, T2], given Decoders
- * for T1 and T2.  Err otherwise.
+ * Accepts n-tuples [A, B, C, ...] matching the given decoders A, B, C, ...
  */
-
-
-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) {
+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)([(0, _result.okOrErrValue)(result1), (0, _result.okOrErrValue)(result2)]));
+      return (0, _result.err)((0, _annotate.annotate)(rvs));
     }
   });
 }
-/**
- * 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.okOrErrValue)(result1), (0, _result.okOrErrValue)(result2), (0, _result.okOrErrValue)(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.okOrErrValue)(result1), (0, _result.okOrErrValue)(result2), (0, _result.okOrErrValue)(result3), (0, _result.okOrErrValue)(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.okOrErrValue)(result1), (0, _result.okOrErrValue)(result2), (0, _result.okOrErrValue)(result3), (0, _result.okOrErrValue)(result4), (0, _result.okOrErrValue)(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.okOrErrValue)(result1), (0, _result.okOrErrValue)(result2), (0, _result.okOrErrValue)(result3), (0, _result.okOrErrValue)(result4), (0, _result.okOrErrValue)(result5), (0, _result.okOrErrValue)(result6)]));
-    }
-  });
-}
+var tuple = _tuple;
+exports.tuple = tuple;

package/core/tuple.js.flow

@@ -2,214 +2,50 @@
 
 import { annotate } from '../annotate';
 import { compose, predicate } from './composition';
-import { err, ok, okOrErrValue, unwrap } from '../result';
+import { err, ok } from '../result';
 import { poja } from './array';
+import type { _Any } from '../_utils';
 import type { Decoder } from '../_types';
 
 const ntuple = (n: number) =>
-    compose(
-        poja,
-        predicate((arr) => 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<T>(decoder1: Decoder<T>): Decoder<[T]> {
-    return compose(ntuple(1), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1] = blobs;
-
-        const 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([okOrErrValue(result1)]));
-        }
-    });
-}
-
-/**
- * Builds a Decoder that returns Ok for 2-tuples of [T1, T2], given Decoders
- * for T1 and T2.  Err otherwise.
- */
-export function tuple2<T1, T2>(
-    decoder1: Decoder<T1>,
-    decoder2: Decoder<T2>,
-): Decoder<[T1, T2]> {
-    return compose(ntuple(2), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1, blob2] = blobs;
-
-        const result1 = decoder1(blob1);
-        const 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([okOrErrValue(result1), okOrErrValue(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<T1, T2, T3>(
-    decoder1: Decoder<T1>,
-    decoder2: Decoder<T2>,
-    decoder3: Decoder<T3>,
-): Decoder<[T1, T2, T3]> {
-    return compose(ntuple(3), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1, blob2, blob3] = blobs;
-
-        const result1 = decoder1(blob1);
-        const result2 = decoder2(blob2);
-        const 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([
-                    okOrErrValue(result1),
-                    okOrErrValue(result2),
-                    okOrErrValue(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<T1, T2, T3, T4>(
-    decoder1: Decoder<T1>,
-    decoder2: Decoder<T2>,
-    decoder3: Decoder<T3>,
-    decoder4: Decoder<T4>,
-): Decoder<[T1, T2, T3, T4]> {
-    return compose(ntuple(4), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1, blob2, blob3, blob4] = blobs;
-
-        const result1 = decoder1(blob1);
-        const result2 = decoder2(blob2);
-        const result3 = decoder3(blob3);
-        const 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([
-                    okOrErrValue(result1),
-                    okOrErrValue(result2),
-                    okOrErrValue(result3),
-                    okOrErrValue(result4),
-                ]),
-            );
-        }
-    });
+    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]>;
 }
 
 /**
- * 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.
+ * Accepts n-tuples [A, B, C, ...] matching the given decoders A, B, C, ...
  */
-export function tuple5<T1, T2, T3, T4, T5>(
-    decoder1: Decoder<T1>,
-    decoder2: Decoder<T2>,
-    decoder3: Decoder<T3>,
-    decoder4: Decoder<T4>,
-    decoder5: Decoder<T5>,
-): Decoder<[T1, T2, T3, T4, T5]> {
-    return compose(ntuple(5), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1, blob2, blob3, blob4, blob5] = blobs;
-
-        const result1 = decoder1(blob1);
-        const result2 = decoder2(blob2);
-        const result3 = decoder3(blob3);
-        const result4 = decoder4(blob4);
-        const result5 = decoder5(blob5);
-        try {
-            return ok([
-                unwrap(result1),
-                unwrap(result2),
-                unwrap(result3),
-                unwrap(result4),
-                unwrap(result5),
-            ]);
-        } catch (e) {
+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([
-                    okOrErrValue(result1),
-                    okOrErrValue(result2),
-                    okOrErrValue(result3),
-                    okOrErrValue(result4),
-                    okOrErrValue(result5),
-                ]),
-            );
+            return err(annotate(rvs));
         }
     });
 }
 
-/**
- * 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<T1, T2, T3, T4, T5, T6>(
-    decoder1: Decoder<T1>,
-    decoder2: Decoder<T2>,
-    decoder3: Decoder<T3>,
-    decoder4: Decoder<T4>,
-    decoder5: Decoder<T5>,
-    decoder6: Decoder<T6>,
-): Decoder<[T1, T2, T3, T4, T5, T6]> {
-    return compose(ntuple(6), (blobs: $ReadOnlyArray<mixed>) => {
-        const [blob1, blob2, blob3, blob4, blob5, blob6] = blobs;
-
-        const result1 = decoder1(blob1);
-        const result2 = decoder2(blob2);
-        const result3 = decoder3(blob3);
-        const result4 = decoder4(blob4);
-        const result5 = decoder5(blob5);
-        const 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([
-                    okOrErrValue(result1),
-                    okOrErrValue(result2),
-                    okOrErrValue(result3),
-                    okOrErrValue(result4),
-                    okOrErrValue(result5),
-                    okOrErrValue(result6),
-                ]),
-            );
-        }
-    });
-}
+export const tuple: TupleFuncSignature = (_tuple: _Any);

package/core/tuple.mjs

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

package/format.d.ts

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

package/{format/inline.js → format.js}

@@ -2,10 +2,11 @@
 
 exports.__esModule = true;
 exports.formatInline = formatInline;
+exports.formatShort = formatShort;
 exports.serializeAnnotation = serializeAnnotation;
 exports.serializeValue = serializeValue;
 
-var _utils = require("../_utils");
+var _utils = require("./_utils");
 
 function serializeString(s, width) {
   if (width === void 0) {
@@ -143,4 +144,8 @@ function formatInline(ann) {
   } else {
     return serialized;
   }
+}
+
+function formatShort(ann) {
+  return (0, _utils.summarize)(ann, []).join('\n');
 }

package/{_esm/format/inline.js.flow → format.js.flow}

@@ -1,7 +1,7 @@
 // @flow strict
 
-import { asDate, indent, INDENT, isMultiline } from '../_utils';
-import type { Annotation, ArrayAnnotation, ObjectAnnotation } from '../annotate';
+import { summarize as _summarize, asDate, INDENT, indent, isMultiline } from './_utils';
+import type { Annotation, ArrayAnnotation, ObjectAnnotation } from './annotate';
 
 function serializeString(s: string, width: number = 80): string {
     // Full string
@@ -120,3 +120,7 @@ export function formatInline(ann: Annotation): string {
         return serialized;
     }
 }
+
+export function formatShort(ann: Annotation): string {
+    return _summarize(ann, []).join('\n');
+}

package/{_esm/format/inline.js → format.mjs}

@@ -1,4 +1,4 @@
-import { asDate, indent, INDENT, isMultiline } from '../_utils';
+import { summarize as _summarize, asDate, INDENT, indent, isMultiline } from './_utils.mjs';
 
 function serializeString(s, width) {
   if (width === void 0) {
@@ -134,4 +134,7 @@ export function formatInline(ann) {
   } else {
     return serialized;
   }
+}
+export function formatShort(ann) {
+  return _summarize(ann, []).join('\n');
 }

package/index.d.ts

@@ -0,0 +1,42 @@
+export {
+    Decoder,
+    DecodeResult,
+    DecoderType,
+    Guard,
+    GuardType,
+    Predicate,
+    Scalar,
+} from './_types';
+export { Result } from './result';
+export { JSONValue, JSONObject, JSONArray } from './core/json';
+
+export { guard } from './_guard';
+
+export { compose, predicate, prep, transform } from './core/composition';
+
+export { array, nonEmptyArray, poja, set } from './core/array';
+export { boolean, numericBoolean, truthy } from './core/boolean';
+export { constant, hardcoded, mixed, null_, undefined_, unknown } from './core/constants';
+export { date, iso8601 } from './core/date';
+export { describe } from './core/describe';
+export { dict, exact, inexact, mapping, object, pojo } from './core/object';
+export { either, oneOf } from './core/either';
+export {
+    email,
+    httpsUrl,
+    nonEmptyString,
+    regex,
+    string,
+    url,
+    uuid,
+    uuidv1,
+    uuidv4,
+} from './core/string';
+export { fail } from './core/fail';
+export { instanceOf } from './core/instanceOf';
+export { integer, number, positiveInteger, positiveNumber } from './core/number';
+export { json, jsonObject, jsonArray } from './core/json';
+export { lazy } from './core/lazy';
+export { maybe, nullable, optional } from './core/optional';
+export { taggedUnion } from './core/dispatch';
+export { tuple } from './core/tuple';