decoders 1.26.0-test1 → 2.0.0-beta1

package/cjs/result.js

@@ -0,0 +1,172 @@
+"use strict";
+
+exports.__esModule = true;
+exports.andThen = andThen;
+exports.dispatch = dispatch;
+exports.err = err;
+exports.errValue = errValue;
+exports.expect = expect;
+exports.isErr = isErr;
+exports.isOk = isOk;
+exports.map = map;
+exports.mapError = mapError;
+exports.ok = ok;
+exports.orElse = orElse;
+exports.toString = toString;
+exports.unwrap = unwrap;
+exports.value = value;
+exports.withDefault = withDefault;
+
+/**
+ * Result <value> <error>
+ *     = Ok <value>
+ *     | Err <error>
+ */
+
+/**
+ * Create a new Result instance representing a successful computation.
+ */
+function ok(value) {
+  return {
+    type: 'ok',
+    value: value
+  };
+}
+/**
+ * Create a new Result instance representing a failed computation.
+ */
+
+
+function err(error) {
+  return {
+    type: 'err',
+    error: error
+  };
+}
+
+function toString(result) {
+  return result.type === 'ok' ? "Ok(" + String(result.value) + ")" : "Err(" + String(result.error) + ")";
+}
+
+function isOk(result) {
+  return result.type === 'ok';
+}
+
+function isErr(result) {
+  return result.type === 'err';
+}
+
+function withDefault(result, defaultValue) {
+  return result.type === 'ok' ? result.value : defaultValue;
+}
+
+function value(result) {
+  return result.type === 'ok' ? result.value : undefined;
+}
+
+function errValue(result) {
+  return result.type === 'err' ? result.error : undefined;
+}
+/**
+ * Unwrap the value from this Result instance if this is an "Ok" result.
+ * Otherwise, will throw the "Err" error via a runtime exception.
+ */
+
+
+function unwrap(result) {
+  if (result.type === 'ok') {
+    return result.value;
+  } else {
+    throw result.error;
+  }
+}
+
+function expect(result, message) {
+  if (result.type === 'ok') {
+    return result.value;
+  } else {
+    throw message instanceof Error ? message : new Error(message);
+  }
+}
+
+function dispatch(result, okCallback, errCallback) {
+  return result.type === 'ok' ? okCallback(result.value) : errCallback(result.error);
+}
+/**
+ * If the given result is OK, defers to the other result. Otherwise returns the
+ * error result.
+ *
+ * It's like saying A && B, but on Result.
+ *
+ * Examples:
+ *
+ *     Result.ok(42)     && Result.ok('hi')    // => Ok('hi')
+ *     Result.err('boo') && Result.ok('hi')    // => Err('boo')
+ *     Result.ok(42)     && Result.err('boo')  // => Err('boo')
+ *     Result.err('boo') && Result.err('boo')  // => Err('boo')
+ *
+ */
+// export function and<T, E, T2>(
+//     result1: Result<T, E>,
+//     result2: Result<T2, E>,
+// ): Result<T2, E> {
+//     return result1.type === 'ok' ? result2 : result1;
+// }
+
+/**
+ * If the given result is OK, return that result. Otherwise, defers to the
+ * other result.
+ *
+ * It's like saying A || B, but on Result.
+ *
+ * Examples:
+ *
+ *     Result.ok(42)      || Result.ok('hi')    // => Ok(42)
+ *     Result.err('boo')  || Result.ok('hi')    // => Ok('hi')
+ *     Result.ok(42)      || Result.err('boo')  // => Ok(42)
+ *     Result.err('bleh') || Result.err('boo')  // => Err('boo')
+ *
+ */
+// export function or<T, E, E2>(
+//     result1: Result<T, E>,
+//     result2: Result<T, E2>,
+// ): Result<T, E2> {
+//     return result1.type === 'ok' ? result1 : result2;
+// }
+
+/**
+ * Like .and(), aka &&, but the second argument gets evaluated lazily only if
+ * the first result is an Ok result. If so, it has access to the Ok value from
+ * the first argument.
+ */
+
+
+function andThen(result1, lazyResult2) {
+  return result1.type === 'ok' ? lazyResult2(result1.value) : result1;
+}
+/**
+ * Like .or(), aka ||, but the second argument gets evaluated lazily only if
+ * the first result is an Err result. If so, it has access to the Err value
+ * from the first argument.
+ */
+
+
+function orElse(result1, lazyResult2) {
+  return result1.type === 'ok' ? result1 : lazyResult2(result1.error);
+}
+/**
+ * Transform an Ok result. Will not touch Err results.
+ */
+
+
+function map(result, mapper) {
+  return result.type === 'ok' ? ok(mapper(result.value)) : result;
+}
+/**
+ * Transform an Err value. Will not touch Ok results.
+ */
+
+
+function mapError(result, mapper) {
+  return result.type === 'ok' ? result : err(mapper(result.error));
+}

package/cjs/result.js.flow

@@ -0,0 +1,166 @@
+// @flow strict
+
+/**
+ * Result <value> <error>
+ *     = Ok <value>
+ *     | Err <error>
+ */
+
+type Ok<+T> = {| +type: 'ok', +value: T |};
+type Err<+E> = {| +type: 'err', +error: E |};
+
+export type Result<+T, +E> = Ok<T> | Err<E>;
+
+/**
+ * Create a new Result instance representing a successful computation.
+ */
+export function ok<T>(value: T): Ok<T> {
+    return { type: 'ok', value };
+}
+
+/**
+ * Create a new Result instance representing a failed computation.
+ */
+export function err<E>(error: E): Err<E> {
+    return { type: 'err', error };
+}
+
+export function toString(result: Result<mixed, mixed>): string {
+    return result.type === 'ok'
+        ? `Ok(${String(result.value)})`
+        : `Err(${String(result.error)})`;
+}
+
+export function isOk(result: Result<mixed, mixed>): boolean {
+    return result.type === 'ok';
+}
+
+export function isErr(result: Result<mixed, mixed>): boolean {
+    return result.type === 'err';
+}
+
+export function withDefault<T>(result: Result<T, mixed>, defaultValue: T): T {
+    return result.type === 'ok' ? result.value : defaultValue;
+}
+
+export function value<T>(result: Result<T, mixed>): void | T {
+    return result.type === 'ok' ? result.value : undefined;
+}
+
+export function errValue<E>(result: Result<mixed, E>): void | E {
+    return result.type === 'err' ? result.error : undefined;
+}
+
+/**
+ * Unwrap the value from this Result instance if this is an "Ok" result.
+ * Otherwise, will throw the "Err" error via a runtime exception.
+ */
+export function unwrap<T>(result: Result<T, mixed>): T {
+    if (result.type === 'ok') {
+        return result.value;
+    } else {
+        throw result.error;
+    }
+}
+
+export function expect<T>(result: Result<T, mixed>, message: string | Error): T {
+    if (result.type === 'ok') {
+        return result.value;
+    } else {
+        throw message instanceof Error ? message : new Error(message);
+    }
+}
+
+export function dispatch<T, E, O>(
+    result: Result<T, E>,
+    okCallback: (value: T) => O,
+    errCallback: (error: E) => O,
+): O {
+    return result.type === 'ok' ? okCallback(result.value) : errCallback(result.error);
+}
+
+/**
+ * If the given result is OK, defers to the other result. Otherwise returns the
+ * error result.
+ *
+ * It's like saying A && B, but on Result.
+ *
+ * Examples:
+ *
+ *     Result.ok(42)     && Result.ok('hi')    // => Ok('hi')
+ *     Result.err('boo') && Result.ok('hi')    // => Err('boo')
+ *     Result.ok(42)     && Result.err('boo')  // => Err('boo')
+ *     Result.err('boo') && Result.err('boo')  // => Err('boo')
+ *
+ */
+// export function and<T, E, T2>(
+//     result1: Result<T, E>,
+//     result2: Result<T2, E>,
+// ): Result<T2, E> {
+//     return result1.type === 'ok' ? result2 : result1;
+// }
+
+/**
+ * If the given result is OK, return that result. Otherwise, defers to the
+ * other result.
+ *
+ * It's like saying A || B, but on Result.
+ *
+ * Examples:
+ *
+ *     Result.ok(42)      || Result.ok('hi')    // => Ok(42)
+ *     Result.err('boo')  || Result.ok('hi')    // => Ok('hi')
+ *     Result.ok(42)      || Result.err('boo')  // => Ok(42)
+ *     Result.err('bleh') || Result.err('boo')  // => Err('boo')
+ *
+ */
+// export function or<T, E, E2>(
+//     result1: Result<T, E>,
+//     result2: Result<T, E2>,
+// ): Result<T, E2> {
+//     return result1.type === 'ok' ? result1 : result2;
+// }
+
+/**
+ * Like .and(), aka &&, but the second argument gets evaluated lazily only if
+ * the first result is an Ok result. If so, it has access to the Ok value from
+ * the first argument.
+ */
+export function andThen<T, E, T2>(
+    result1: Result<T, E>,
+    lazyResult2: (value: T) => Result<T2, E>,
+): Result<T2, E> {
+    return result1.type === 'ok' ? lazyResult2(result1.value) : result1;
+}
+
+/**
+ * Like .or(), aka ||, but the second argument gets evaluated lazily only if
+ * the first result is an Err result. If so, it has access to the Err value
+ * from the first argument.
+ */
+export function orElse<T, E, E2>(
+    result1: Result<T, E>,
+    lazyResult2: (errValue: E) => Result<T, E2>,
+): Result<T, E2> {
+    return result1.type === 'ok' ? result1 : lazyResult2(result1.error);
+}
+
+/**
+ * Transform an Ok result. Will not touch Err results.
+ */
+export function map<T, E, T2>(
+    result: Result<T, E>,
+    mapper: (value: T) => T2,
+): Result<T2, E> {
+    return result.type === 'ok' ? ok(mapper(result.value)) : result;
+}
+
+/**
+ * Transform an Err value. Will not touch Ok results.
+ */
+export function mapError<T, E, E2>(
+    result: Result<T, E>,
+    mapper: (error: E) => E2,
+): Result<T, E2> {
+    return result.type === 'ok' ? result : err(mapper(result.error));
+}

package/cjs/stdlib/array.js

@@ -0,0 +1,108 @@
+"use strict";
+
+exports.__esModule = true;
+exports.array = array;
+exports.nonEmptyArray = nonEmptyArray;
+exports.poja = 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; }
+
+/**
+ * Like a "Plain Old JavaScript Object", but for arrays: "Plain Old JavaScript
+ * Array" ^_^
+ */
+var poja = function poja(blob) {
+  if (!Array.isArray(blob)) {
+    return Result.err((0, _annotate.annotate)(blob, 'Must be an array'));
+  }
+
+  return Result.ok( // NOTE: Since Flow 0.98, Array.isArray() returns $ReadOnlyArray<mixed>
+  // instead of Array<mixed>.  For rationale, see
+  // https://github.com/facebook/flow/issues/7684.  In this case, we
+  // don't want to output read-only types because it's up to the user of
+  // decoders to determine what they want to do with the decoded output.
+  // If they want to write items into the array, that's fine!
+  // The fastest way to turn a read-only array into a normal array in
+  // Javascript is to use .slice() on it, see this benchmark:
+  // http://jsben.ch/lO6C5
+  blob.slice());
+};
+/**
+ * Given an array of Result instances, loop over them all and return:
+ * - An [index, err] tuple, indicating the (index of the) first Err instance
+ *   encountered; or
+ * - a new Ok with an array of all unwrapped Ok'ed values
+ */
+
+
+exports.poja = poja;
+
+function all(items, blobs) {
+  var results = [];
+
+  for (var index = 0; index < items.length; ++index) {
+    var result = items[index];
+
+    if (result.type === 'ok') {
+      results.push(result.value);
+    } else {
+      var ann = result.error; // Rewrite the annotation to include the index information, and inject it into the original blob
+
+      var clone = [].concat(blobs);
+      clone.splice(index, 1, (0, _annotate.annotate)(ann, ann.text ? ann.text + " (at index " + index + ")" : "index " + index)); // const errValue = [];
+      // if (index > 0) {
+      //     errValue.push('...'); // TODO: make special mark, not string!
+      // }
+      // errValue.push(
+      // );
+      // if (index < iterable.length - 1) {
+      //     errValue.push('...'); // TODO: make special mark, not string!
+      // }
+
+      return Result.err((0, _annotate.annotate)(clone));
+    }
+  }
+
+  return Result.ok(results);
+}
+/**
+ * Given a T, builds a decoder that assumes an array input and returns an
+ * Array<T>.
+ */
+
+
+function members(decoder) {
+  return function (blobs) {
+    var results = blobs.map(decoder);
+    var result = all(results, blobs);
+    return result;
+  };
+}
+/**
+ * Builds a Decoder that returns Ok for values of `Array<T>`, given a Decoder
+ * for `T`.  Err otherwise.
+ */
+
+
+function array(decoder) {
+  return (0, _composition.compose)(poja, members(decoder));
+}
+/**
+ * Builds a Decoder that returns Ok for values of `Array<T>`, but will reject
+ * empty arrays.
+ */
+
+
+function nonEmptyArray(decoder) {
+  return (0, _composition.compose)(array(decoder), (0, _composition.predicate)(function (arr) {
+    return arr.length > 0;
+  }, 'Must be non-empty array'));
+}

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

@@ -1,10 +1,9 @@
 // @flow strict
 
-import { annotate } from 'debrief';
-import { Err, Ok } from 'lemons/Result';
-
-import type { DecodeResult, 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, DecodeResult } from '../_types';
 
 /**
  * Like a "Plain Old JavaScript Object", but for arrays: "Plain Old JavaScript
@@ -12,9 +11,9 @@ import { compose, predicate } from './utils';
  */
 export const poja: Decoder<Array<mixed>> = (blob: mixed) => {
     if (!Array.isArray(blob)) {
-        return Err(annotate(blob, 'Must be an array'));
+        return Result.err(annotate(blob, 'Must be an array'));
     }
-    return Ok(
+    return Result.ok(
         // NOTE: Since Flow 0.98, Array.isArray() returns $ReadOnlyArray<mixed>
         // instead of Array<mixed>.  For rationale, see
         // https://github.com/facebook/flow/issues/7684.  In this case, we
@@ -24,27 +23,28 @@ export const poja: Decoder<Array<mixed>> = (blob: mixed) => {
         // The fastest way to turn a read-only array into a normal array in
         // Javascript is to use .slice() on it, see this benchmark:
         // http://jsben.ch/lO6C5
-        blob.slice()
+        blob.slice(),
     );
 };
 
 /**
- * Given an iterable of Result instances, exhaust them all and return:
+ * Given an array of Result instances, loop over them all and return:
  * - An [index, err] tuple, indicating the (index of the) first Err instance
  *   encountered; or
  * - a new Ok with an array of all unwrapped Ok'ed values
  */
 function all<T>(
-    iterable: $ReadOnlyArray<DecodeResult<T>>,
-    blobs: $ReadOnlyArray<mixed>
+    items: $ReadOnlyArray<DecodeResult<T>>,
+    blobs: $ReadOnlyArray<mixed>,
 ): DecodeResult<Array<T>> {
     const results: Array<T> = [];
-    let index = 0;
-    for (const result of iterable) {
-        try {
-            const value = result.unwrap();
-            results.push(value);
-        } catch (ann) {
+    for (let index = 0; index < items.length; ++index) {
+        const result = items[index];
+        if (result.type === 'ok') {
+            results.push(result.value);
+        } else {
+            const ann = result.error;
+
             // Rewrite the annotation to include the index information, and inject it into the original blob
             const clone = [...blobs];
             clone.splice(
@@ -52,10 +52,8 @@ function all<T>(
                 1,
                 annotate(
                     ann,
-                    ann.annotation !== undefined
-                        ? `${ann.annotation} (at index ${index})`
-                        : `index ${index}`
-                )
+                    ann.text ? `${ann.text} (at index ${index})` : `index ${index}`,
+                ),
             );
 
             // const errValue = [];
@@ -67,11 +65,10 @@ function all<T>(
             // if (index < iterable.length - 1) {
             //     errValue.push('...'); // TODO: make special mark, not string!
             // }
-            return Err(annotate(clone));
+            return Result.err(annotate(clone));
         }
-        index++;
     }
-    return Ok(results);
+    return Result.ok(results);
 }
 
 /**
@@ -101,6 +98,6 @@ export function array<T>(decoder: Decoder<T>): Decoder<Array<T>> {
 export function nonEmptyArray<T>(decoder: Decoder<T>): Decoder<Array<T>> {
     return compose(
         array(decoder),
-        predicate((arr) => arr.length > 0, 'Must be non-empty array')
+        predicate((arr) => arr.length > 0, 'Must be non-empty array'),
     );
 }

package/cjs/stdlib/boolean.js

@@ -0,0 +1,44 @@
+"use strict";
+
+exports.__esModule = true;
+exports.truthy = exports.numericBoolean = exports["boolean"] = void 0;
+
+var Result = _interopRequireWildcard(require("../result"));
+
+var _annotate = require("../annotate");
+
+var _composition = require("./composition");
+
+var _number = require("./number");
+
+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; }
+
+/**
+ * Decoder that only returns Ok for boolean inputs.  Err otherwise.
+ */
+var _boolean = function _boolean(blob) {
+  return typeof blob === 'boolean' ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, 'Must be boolean'));
+};
+/**
+ * Decoder that returns true for all truthy values, and false otherwise.  Never fails.
+ */
+
+
+exports["boolean"] = _boolean;
+
+var truthy = function truthy(blob) {
+  return Result.ok(!!blob);
+};
+/**
+ * Decoder that only returns Ok for numeric input values representing booleans.
+ * Returns their boolean representation.  Err otherwise.
+ */
+
+
+exports.truthy = truthy;
+var numericBoolean = (0, _composition.map)(_number.number, function (n) {
+  return !!n;
+});
+exports.numericBoolean = numericBoolean;

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

@@ -1,24 +1,25 @@
 // @flow strict
 
-import { annotate } from 'debrief';
-import { Err, Ok } from 'lemons/Result';
-
+import * as Result from '../result';
+import { annotate } from '../annotate';
+import { map } from './composition';
 import { number } from './number';
-import type { Decoder } from './types';
-import { map } from './utils';
+import type { Decoder } from '../_types';
 
 /**
  * Decoder that only returns Ok for boolean inputs.  Err otherwise.
  */
 export const boolean: Decoder<boolean> = (blob: mixed) => {
-    return typeof blob === 'boolean' ? Ok(blob) : Err(annotate(blob, 'Must be boolean'));
+    return typeof blob === 'boolean'
+        ? Result.ok(blob)
+        : Result.err(annotate(blob, 'Must be boolean'));
 };
 
 /**
  * Decoder that returns true for all truthy values, and false otherwise.  Never fails.
  */
 export const truthy: Decoder<boolean> = (blob: mixed) => {
-    return Ok(!!blob);
+    return Result.ok(!!blob);
 };
 
 /**

package/cjs/stdlib/composition.js

@@ -0,0 +1,56 @@
+"use strict";
+
+exports.__esModule = true;
+exports.compose = compose;
+exports.map = map;
+exports.predicate = predicate;
+
+var Result = _interopRequireWildcard(require("../result"));
+
+var _annotate = require("../annotate");
+
+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; }
+
+/**
+ * Given a decoder T and a mapping function from T's to V's, returns a decoder
+ * for V's.  This is useful to change the original input data.
+ */
+function map(decoder, mapper) {
+  return compose(decoder, function (x) {
+    try {
+      return Result.ok(mapper(x));
+    } catch (e) {
+      return Result.err((0, _annotate.annotate)(x, e instanceof Error ? e.message : String(e)));
+    }
+  });
+}
+/**
+ * Compose two decoders by passing the result of the first into the second.
+ * The second decoder may assume as its input type the output type of the first
+ * decoder (so it's not necessary to accept the typical "mixed").  This is
+ * useful for "narrowing down" the checks.  For example, if you want to write
+ * a decoder for positive numbers, you can compose it from an existing decoder
+ * for any number, and a decoder that, assuming a number, checks if it's
+ * positive.  Very often combined with the predicate() helper as the second
+ * argument.
+ */
+
+
+function compose(decoder, next) {
+  return function (blob) {
+    return Result.andThen(decoder(blob), next);
+  };
+}
+/**
+ * Factory function returning a Decoder<T>, given a predicate function that
+ * accepts/rejects the input of type T.
+ */
+
+
+function predicate(predicate, msg) {
+  return function (value) {
+    return predicate(value) ? Result.ok(value) : Result.err((0, _annotate.annotate)(value, msg));
+  };
+}