decoders 2.0.0-beta8 → 2.0.0-beta9

package/index.mjs

@@ -17,21 +17,20 @@
  *
  */
 export { guard } from './_guard.mjs';
-export { compose, map, predicate } from './core/composition.mjs';
-export { array, nonEmptyArray, poja } from './core/array.mjs';
+export { compose, predicate, prep, transform } from './core/composition.mjs';
+export { array, nonEmptyArray, poja, set } from './core/array.mjs';
 export { boolean, numericBoolean, truthy } from './core/boolean.mjs';
 export { constant, hardcoded, mixed, null_, undefined_, unknown } from './core/constants.mjs';
 export { date, iso8601 } from './core/date.mjs';
 export { describe } from './core/describe.mjs';
-export { disjointUnion } from './core/dispatch.mjs';
-export { either, either3, either4, either5, either6, either7, either8, either9, oneOf } from './core/either.mjs';
+export { dict, exact, inexact, mapping, object, pojo } from './core/object.mjs';
+export { either, oneOf } from './core/either.mjs';
+export { email, httpsUrl, nonEmptyString, regex, string, url, uuid, uuidv1, uuidv4 } from './core/string.mjs';
 export { fail } from './core/fail.mjs';
 export { instanceOf } from './core/instanceOf.mjs';
+export { integer, number, positiveInteger, positiveNumber } from './core/number.mjs';
 export { json, jsonObject, jsonArray } from './core/json.mjs';
 export { lazy } from './core/lazy.mjs';
-export { mapping, dict } from './core/mapping.mjs';
-export { integer, number, positiveInteger, positiveNumber } from './core/number.mjs';
-export { exact, inexact, object, pojo } from './core/object.mjs';
 export { maybe, nullable, optional } from './core/optional.mjs';
-export { email, httpsUrl, nonEmptyString, regex, string, url } from './core/string.mjs';
-export { tuple1, tuple2, tuple3, tuple4, tuple5, tuple6 } from './core/tuple.mjs';
+export { taggedUnion } from './core/dispatch.mjs';
+export { tuple } from './core/tuple.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "decoders",
-    "version": "2.0.0-beta8",
+    "version": "2.0.0-beta9",
     "description": "Elegant and battle-tested validation library for type-safe input data (for TypeScript and Flow)",
     "license": "MIT",
     "repository": {

package/result.d.ts

@@ -1,11 +1,11 @@
 export interface Ok<T> {
-    type: 'ok';
+    ok: true;
     value: T;
     error: undefined;
 }
 
 export interface Err<E> {
-    type: 'err';
+    ok: false;
     value: undefined;
     error: E;
 }

package/result.js

@@ -22,7 +22,7 @@ exports.unwrap = unwrap;
  */
 function ok(value) {
   return {
-    type: 'ok',
+    ok: true,
     value: value,
     error: undefined
   };
@@ -34,7 +34,7 @@ function ok(value) {
 
 function err(error) {
   return {
-    type: 'err',
+    ok: false,
     value: undefined,
     error: error
   };
@@ -46,7 +46,7 @@ function err(error) {
 
 
 function unwrap(result) {
-  if (result.type === 'ok') {
+  if (result.ok) {
     return result.value;
   } else {
     throw result.error;
@@ -54,7 +54,7 @@ function unwrap(result) {
 }
 
 function expect(result, message) {
-  if (result.type === 'ok') {
+  if (result.ok) {
     return result.value;
   } else {
     throw message instanceof Error ? message : new Error(message);
@@ -62,7 +62,7 @@ function expect(result, message) {
 }
 
 function dispatch(result, okCallback, errCallback) {
-  return result.type === 'ok' ? okCallback(result.value) : errCallback(result.error);
+  return result.ok ? okCallback(result.value) : errCallback(result.error);
 }
 /**
  * Like .and(), aka &&, but the second argument gets evaluated lazily only if
@@ -72,7 +72,7 @@ function dispatch(result, okCallback, errCallback) {
 
 
 function andThen(result1, lazyResult2) {
-  return result1.type === 'ok' ? lazyResult2(result1.value) : result1;
+  return result1.ok ? lazyResult2(result1.value) : result1;
 }
 /**
  * Like .or(), aka ||, but the second argument gets evaluated lazily only if
@@ -82,7 +82,7 @@ function andThen(result1, lazyResult2) {
 
 
 function orElse(result1, lazyResult2) {
-  return result1.type === 'ok' ? result1 : lazyResult2(result1.error);
+  return result1.ok ? result1 : lazyResult2(result1.error);
 }
 /**
  * Transform an Ok result. Will not touch Err results.
@@ -90,7 +90,7 @@ function orElse(result1, lazyResult2) {
 
 
 function mapOk(result, mapper) {
-  return result.type === 'ok' ? ok(mapper(result.value)) : result;
+  return result.ok ? ok(mapper(result.value)) : result;
 }
 /**
  * Transform an Err value. Will not touch Ok results.
@@ -98,5 +98,5 @@ function mapOk(result, mapper) {
 
 
 function mapError(result, mapper) {
-  return result.type === 'ok' ? result : err(mapper(result.error));
+  return result.ok ? result : err(mapper(result.error));
 }

package/result.js.flow

@@ -6,8 +6,8 @@
  *     | Err <error>
  */
 
-type Ok<+T> = {| +type: 'ok', +value: T, +error: void |};
-type Err<+E> = {| +type: 'err', +value: void, +error: E |};
+type Ok<+T> = {| +ok: true, +value: T, +error: void |};
+type Err<+E> = {| +ok: false, +value: void, +error: E |};
 
 export type Result<+T, +E> = Ok<T> | Err<E>;
 
@@ -15,14 +15,14 @@ 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, error: undefined };
+    return { ok: true, value, error: undefined };
 }
 
 /**
  * Create a new Result instance representing a failed computation.
  */
 export function err<E>(error: E): Err<E> {
-    return { type: 'err', value: undefined, error };
+    return { ok: false, value: undefined, error };
 }
 
 /**
@@ -30,7 +30,7 @@ export function err<E>(error: E): Err<E> {
  * Otherwise, will throw the "Err" error via a runtime exception.
  */
 export function unwrap<T>(result: Result<T, mixed>): T {
-    if (result.type === 'ok') {
+    if (result.ok) {
         return result.value;
     } else {
         throw result.error;
@@ -38,7 +38,7 @@ export function unwrap<T>(result: Result<T, mixed>): T {
 }
 
 export function expect<T>(result: Result<T, mixed>, message: string | Error): T {
-    if (result.type === 'ok') {
+    if (result.ok) {
         return result.value;
     } else {
         throw message instanceof Error ? message : new Error(message);
@@ -50,7 +50,7 @@ export function dispatch<T, E, O>(
     okCallback: (value: T) => O,
     errCallback: (error: E) => O,
 ): O {
-    return result.type === 'ok' ? okCallback(result.value) : errCallback(result.error);
+    return result.ok ? okCallback(result.value) : errCallback(result.error);
 }
 
 /**
@@ -62,7 +62,7 @@ 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;
+    return result1.ok ? lazyResult2(result1.value) : result1;
 }
 
 /**
@@ -74,7 +74,7 @@ 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);
+    return result1.ok ? result1 : lazyResult2(result1.error);
 }
 
 /**
@@ -84,7 +84,7 @@ export function mapOk<T, E, T2>(
     result: Result<T, E>,
     mapper: (value: T) => T2,
 ): Result<T2, E> {
-    return result.type === 'ok' ? ok(mapper(result.value)) : result;
+    return result.ok ? ok(mapper(result.value)) : result;
 }
 
 /**
@@ -94,5 +94,5 @@ 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));
+    return result.ok ? result : err(mapper(result.error));
 }

package/result.mjs

@@ -9,7 +9,7 @@
  */
 export function ok(value) {
   return {
-    type: 'ok',
+    ok: true,
     value: value,
     error: undefined
   };
@@ -20,7 +20,7 @@ export function ok(value) {
 
 export function err(error) {
   return {
-    type: 'err',
+    ok: false,
     value: undefined,
     error: error
   };
@@ -31,21 +31,21 @@ export function err(error) {
  */
 
 export function unwrap(result) {
-  if (result.type === 'ok') {
+  if (result.ok) {
     return result.value;
   } else {
     throw result.error;
   }
 }
 export function expect(result, message) {
-  if (result.type === 'ok') {
+  if (result.ok) {
     return result.value;
   } else {
     throw message instanceof Error ? message : new Error(message);
   }
 }
 export function dispatch(result, okCallback, errCallback) {
-  return result.type === 'ok' ? okCallback(result.value) : errCallback(result.error);
+  return result.ok ? okCallback(result.value) : errCallback(result.error);
 }
 /**
  * Like .and(), aka &&, but the second argument gets evaluated lazily only if
@@ -54,7 +54,7 @@ export function dispatch(result, okCallback, errCallback) {
  */
 
 export function andThen(result1, lazyResult2) {
-  return result1.type === 'ok' ? lazyResult2(result1.value) : result1;
+  return result1.ok ? lazyResult2(result1.value) : result1;
 }
 /**
  * Like .or(), aka ||, but the second argument gets evaluated lazily only if
@@ -63,19 +63,19 @@ export function andThen(result1, lazyResult2) {
  */
 
 export function orElse(result1, lazyResult2) {
-  return result1.type === 'ok' ? result1 : lazyResult2(result1.error);
+  return result1.ok ? result1 : lazyResult2(result1.error);
 }
 /**
  * Transform an Ok result. Will not touch Err results.
  */
 
 export function mapOk(result, mapper) {
-  return result.type === 'ok' ? ok(mapper(result.value)) : result;
+  return result.ok ? ok(mapper(result.value)) : result;
 }
 /**
  * Transform an Err value. Will not touch Ok results.
  */
 
 export function mapError(result, mapper) {
-  return result.type === 'ok' ? result : err(mapper(result.error));
+  return result.ok ? result : err(mapper(result.error));
 }

package/core/mapping.d.ts

@@ -1,6 +0,0 @@
-/// <reference lib="es6" />
-
-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/core/mapping.js

@@ -1,67 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.dict = dict;
-exports.mapping = mapping;
-
-var _annotate = require("../annotate");
-
-var _composition = require("./composition");
-
-var _result = require("../result");
-
-var _object = require("./object");
-
-/**
- * Like mapping(), but returns an object rather than a Map instance.
- */
-function dict(decoder) {
-  return (0, _composition.compose)(_object.pojo, function (blob) {
-    var rv = {};
-    var errors = null;
-    Object.keys(blob).forEach(function (key) {
-      var value = blob[key];
-      var result = decoder(value);
-
-      if (result.type === '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 (0, _result.err)((0, _annotate.merge)((0, _annotate.annotateObject)(blob), errors));
-    } else {
-      return (0, _result.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)
- *
- */
-
-
-function mapping(decoder) {
-  return (0, _composition.map)(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/mapping.js.flow

@@ -1,62 +0,0 @@
-// @flow strict
-
-import { annotateObject } from '../annotate';
-import { compose, map } from './composition';
-import { err, ok } from '../result';
-import { merge } from '../annotate';
-import { pojo } from './object';
-import type { Annotation } from '../annotate';
-import type { Decoder } from '../_types';
-
-/**
- * Like mapping(), but returns an object rather than a Map instance.
- */
-export function dict<T>(decoder: Decoder<T>): Decoder<{ [string]: T }> {
-    return compose(pojo, (blob: { +[key: string]: mixed }) => {
-        let rv: { [key: string]: T } = {};
-        let errors: { [key: string]: Annotation } | null = null;
-
-        Object.keys(blob).forEach((key: string) => {
-            const value = blob[key];
-            const result = decoder(value);
-            if (result.type === '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<T>(decoder: Decoder<T>): Decoder<Map<string, T>> {
-    return map(
-        dict(decoder),
-        (obj) =>
-            new Map(
-                // This is effectively Object.entries(obj), but in a way that Flow
-                // will know the types are okay
-                Object.keys(obj).map((key) => [key, obj[key]]),
-            ),
-    );
-}

package/core/mapping.mjs

@@ -1,58 +0,0 @@
-import { annotateObject } from '../annotate.mjs';
-import { compose, map } from './composition.mjs';
-import { err, ok } from '../result.mjs';
-import { merge } from '../annotate.mjs';
-import { pojo } from './object.mjs';
-
-/**
- * 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.type === '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 map(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]];
-    }));
-  });
-}