decoders 2.0.0-beta5 → 2.0.0-beta9

package/_guard.d.ts

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

package/_guard.js

@@ -3,13 +3,9 @@
 exports.__esModule = true;
 exports.guard = guard;
 
-var Result = _interopRequireWildcard(require("./result"));
-
 var _format = require("./format");
 
-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; }
+var _result = require("./result");
 
 function guard(decoder, formatter) {
   if (formatter === void 0) {
@@ -17,7 +13,7 @@ function guard(decoder, formatter) {
   }
 
   return function (blob) {
-    return Result.unwrap(Result.mapError(decoder(blob), function (annotation) {
+    return (0, _result.unwrap)((0, _result.mapError)(decoder(blob), function (annotation) {
       var err = new Error('\n' + formatter(annotation));
       err.name = 'Decoding error';
       return err;

package/_guard.js.flow

@@ -1,7 +1,7 @@
 // @flow strict
 
-import * as Result from './result';
 import { formatInline } from './format';
+import { mapError, unwrap } from './result';
 import type { Annotation } from './annotate';
 import type { Decoder, Guard } from './_types';
 
@@ -10,8 +10,8 @@ export function guard<T>(
     formatter: (Annotation) => string = formatInline,
 ): Guard<T> {
     return (blob: mixed) =>
-        Result.unwrap(
-            Result.mapError(decoder(blob), (annotation) => {
+        unwrap(
+            mapError(decoder(blob), (annotation) => {
                 const err = new Error('\n' + formatter(annotation));
                 err.name = 'Decoding error';
                 return err;

package/{_esm/_guard.js → _guard.mjs}

@@ -1,12 +1,12 @@
-import * as Result from './result';
-import { formatInline } from './format';
+import { formatInline } from './format.mjs';
+import { mapError, unwrap } from './result.mjs';
 export function guard(decoder, formatter) {
   if (formatter === void 0) {
     formatter = formatInline;
   }
 
   return function (blob) {
-    return Result.unwrap(Result.mapError(decoder(blob), function (annotation) {
+    return unwrap(mapError(decoder(blob), function (annotation) {
       var err = new Error('\n' + formatter(annotation));
       err.name = 'Decoding error';
       return err;

package/_types.d.ts

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

package/_utils.d.ts

@@ -0,0 +1,10 @@
+import { Annotation } from './annotate';
+
+export function isDate(value: unknown): boolean;
+export function asDate(value: unknown): Date | null;
+export function isMultiline(s: string): boolean;
+export function indent(s: string, prefix?: string): string;
+export function summarize(
+    ann: Annotation,
+    keypath?: ReadonlyArray<number | string>,
+): string[];

package/_utils.js

@@ -7,7 +7,7 @@ exports.indent = indent;
 exports.isDate = isDate;
 exports.isMultiline = isMultiline;
 exports.summarize = summarize;
-// $FlowFixMe[unclear-type] - deliberate casting
+// $FlowFixMe[unclear-type] - deliberate use of `any`
 // Two spaces of indentation
 var INDENT = '  ';
 /**

package/_utils.js.flow

@@ -2,8 +2,8 @@
 
 import type { Annotation } from './annotate';
 
-// $FlowFixMe[unclear-type] - deliberate casting
-type cast = any;
+// $FlowFixMe[unclear-type] - deliberate use of `any`
+export type _Any = any;
 
 // Two spaces of indentation
 export const INDENT = '  ';
@@ -29,7 +29,7 @@ export function isDate(value: mixed): boolean {
  * null.
  */
 export function asDate(value: mixed): Date | null {
-    return isDate(value) ? ((value: cast): Date) : null;
+    return isDate(value) ? ((value: _Any): Date) : null;
 }
 
 export function isMultiline(s: string): boolean {

package/{_esm/_utils.js → _utils.mjs}

@@ -1,4 +1,4 @@
-// $FlowFixMe[unclear-type] - deliberate casting
+// $FlowFixMe[unclear-type] - deliberate use of `any`
 // Two spaces of indentation
 export var INDENT = '  ';
 /**

package/annotate.d.ts

@@ -0,0 +1,62 @@
+export interface ObjectAnnotation {
+    readonly type: 'object';
+    readonly fields: { readonly [key: string]: Annotation };
+    readonly text?: string;
+}
+
+export interface ArrayAnnotation {
+    readonly type: 'array';
+    readonly items: readonly Annotation[];
+    readonly text?: string;
+}
+
+export interface ScalarAnnotation {
+    readonly type: 'scalar';
+    readonly value: unknown;
+    readonly text?: string;
+}
+
+export interface FunctionAnnotation {
+    readonly type: 'function';
+    readonly text?: string;
+}
+
+export interface CircularRefAnnotation {
+    readonly type: 'circular-ref';
+    readonly text?: string;
+}
+
+export interface UnknownAnnotation {
+    readonly type: 'unknown';
+    readonly value: unknown;
+    readonly text?: string;
+}
+
+export type Annotation =
+    | ObjectAnnotation
+    | ArrayAnnotation
+    | ScalarAnnotation
+    | FunctionAnnotation
+    | CircularRefAnnotation
+    | UnknownAnnotation;
+
+export function object(
+    fields: { readonly [key: string]: Annotation },
+    text?: string,
+): ObjectAnnotation;
+export function array(items: readonly Annotation[], text?: string): ArrayAnnotation;
+export function func(text?: string): FunctionAnnotation;
+export function unknown(value: unknown, text?: string): UnknownAnnotation;
+export function scalar(value: unknown, text?: string): ScalarAnnotation;
+export function circularRef(text?: string): CircularRefAnnotation;
+export function updateText<A extends Annotation>(annotation: A, text?: string): A;
+export function merge(
+    objAnnotation: ObjectAnnotation,
+    fields: { readonly [key: string]: Annotation },
+): ObjectAnnotation;
+export function asAnnotation(thing: unknown): Annotation | void;
+export function annotate(value: unknown, text?: string): Annotation;
+export function annotateObject(
+    obj: { readonly [field: string]: unknown },
+    text?: string,
+): ObjectAnnotation;

package/core/_helpers.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Given a type like:
+ *
+ *   {
+ *     a: string;
+ *     b: number | undefined;
+ *     c: null | undefined;
+ *     d: null;
+ *     e: undefined;
+ *   }
+ *
+ * Will drop all the "undefined" types. In this case, only "e":
+ *
+ *   {
+ *     a: string;
+ *     b: number | undefined;
+ *     c: null | undefined;
+ *     d: null;
+ *   }
+ *
+ */
+type Compact<T> = { [K in IsDefined<T, keyof T>]: T[K] };
+
+type IsDefined<T, K extends keyof T> = K extends any
+    ? T[K] extends undefined
+        ? never
+        : K
+    : never;
+
+//
+// HACK:
+// These weird conditionals test whether TypeScript is configured with the
+// `strictNullChecks` compiler option. We use these definitions to influence
+// what's considered a "required" vs an "optional" key for the AllowImplicit
+// type.
+//
+// If strictNullChecks is false, then we should not be emitting any `?` fields
+// and consider all fields "required" because everything is optional by default
+// in that mode anyway.
+//
+type NoStrictNullChecks = undefined extends string ? 1 : undefined;
+//                        ^^^^^^^^^^^^^^^^^^^^^^^^
+type StrictNullChecks = undefined extends string ? undefined : 1;
+//                      ^^^^^^^^^^^^^^^^^^^^^^^^
+
+export type RequiredKeys<T> = keyof Compact<{
+    [K in keyof T]: undefined extends T[K] ? NoStrictNullChecks : 1;
+}>;
+
+export type OptionalKeys<T> = keyof Compact<{
+    [K in keyof T]: undefined extends T[K] ? 1 : StrictNullChecks;
+}>;
+
+/**
+ * Transforms an object type, by marking all fields that contain "undefined"
+ * with a question mark, i.e. allowing implicit-undefineds when
+ * explicit-undefined are also allowed.
+ *
+ * For example, if:
+ *
+ *   type User = {
+ *     name: string;
+ *     age: number | null | undefined;
+ *   }
+ *
+ * Then AllowImplicit<User> will become equivalent to:
+ *
+ *   {
+ *     name: string;
+ *     age?: number | null;
+ *        ^
+ *        Note the question mark
+ *   }
+ */
+type AllowImplicit<T> = { [K in RequiredKeys<T>]-?: T[K] } & {
+    [K in OptionalKeys<T>]+?: Exclude<T[K], undefined>;
+};
+
+export { AllowImplicit };

package/core/array.d.ts

@@ -0,0 +1,8 @@
+/// <reference lib="es6" />
+
+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[]]>;
+export function set<T>(decoder: Decoder<T>): Decoder<Set<T>>;

package/core/array.js

@@ -4,16 +4,13 @@ exports.__esModule = true;
 exports.array = array;
 exports.nonEmptyArray = nonEmptyArray;
 exports.poja = void 0;
-
-var Result = _interopRequireWildcard(require("../result"));
+exports.set = set;
 
 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; }
+var _result = require("../result");
 
 /**
  * Like a "Plain Old JavaScript Object", but for arrays: "Plain Old JavaScript
@@ -21,10 +18,10 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
  */
 var poja = function poja(blob) {
   if (!Array.isArray(blob)) {
-    return Result.err((0, _annotate.annotate)(blob, 'Must be an array'));
+    return (0, _result.err)((0, _annotate.annotate)(blob, 'Must be an array'));
   }
 
-  return Result.ok( // NOTE: Since Flow 0.98, Array.isArray() returns $ReadOnlyArray<mixed>
+  return (0, _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
@@ -51,7 +48,7 @@ function all(items, blobs) {
   for (var index = 0; index < items.length; ++index) {
     var result = items[index];
 
-    if (result.type === 'ok') {
+    if (result.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
@@ -67,11 +64,11 @@ function all(items, blobs) {
       //     errValue.push('...'); // TODO: make special mark, not string!
       // }
 
-      return Result.err((0, _annotate.annotate)(clone));
+      return (0, _result.err)((0, _annotate.annotate)(clone));
     }
   }
 
-  return Result.ok(results);
+  return (0, _result.ok)(results);
 }
 /**
  * Given a T, builds a decoder that assumes an array input and returns an
@@ -102,7 +99,17 @@ function array(decoder) {
 
 
 function nonEmptyArray(decoder) {
-  return (0, _composition.compose)(array(decoder), (0, _composition.predicate)(function (arr) {
+  return (0, _composition.predicate)(array(decoder), function (arr) {
     return arr.length > 0;
-  }, 'Must be non-empty array'));
+  }, 'Must be non-empty array');
+}
+/**
+ * Similar to `array()`, but returns the result as an ES6 Set.
+ */
+
+
+function set(decoder) {
+  return (0, _composition.transform)(array(decoder), function (items) {
+    return new Set(items);
+  });
 }

package/core/array.js.flow

@@ -1,8 +1,8 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
-import { compose, predicate } from './composition';
+import { compose, predicate, transform } from './composition';
+import { err, ok } from '../result';
 import type { Decoder, DecodeResult } from '../_types';
 
 /**
@@ -11,9 +11,9 @@ import type { Decoder, DecodeResult } from '../_types';
  */
 export const poja: Decoder<Array<mixed>> = (blob: mixed) => {
     if (!Array.isArray(blob)) {
-        return Result.err(annotate(blob, 'Must be an array'));
+        return err(annotate(blob, 'Must be an array'));
     }
-    return Result.ok(
+    return 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
@@ -40,7 +40,7 @@ function all<T>(
     const results: Array<T> = [];
     for (let index = 0; index < items.length; ++index) {
         const result = items[index];
-        if (result.type === 'ok') {
+        if (result.ok) {
             results.push(result.value);
         } else {
             const ann = result.error;
@@ -65,10 +65,10 @@ function all<T>(
             // if (index < iterable.length - 1) {
             //     errValue.push('...'); // TODO: make special mark, not string!
             // }
-            return Result.err(annotate(clone));
+            return err(annotate(clone));
         }
     }
-    return Result.ok(results);
+    return ok(results);
 }
 
 /**
@@ -96,8 +96,12 @@ export function array<T>(decoder: Decoder<T>): Decoder<Array<T>> {
  * empty arrays.
  */
 export function nonEmptyArray<T>(decoder: Decoder<T>): Decoder<Array<T>> {
-    return compose(
-        array(decoder),
-        predicate((arr) => arr.length > 0, 'Must be non-empty array'),
-    );
+    return predicate(array(decoder), (arr) => arr.length > 0, 'Must be non-empty array');
+}
+
+/**
+ * Similar to `array()`, but returns the result as an ES6 Set.
+ */
+export function set<T>(decoder: Decoder<T>): Decoder<Set<T>> {
+    return transform(array(decoder), (items) => new Set(items));
 }

package/{_esm/core/array.js → core/array.mjs}

@@ -1,6 +1,6 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import { compose, predicate } from './composition';
+import { annotate } from '../annotate.mjs';
+import { compose, predicate, transform } from './composition.mjs';
+import { err, ok } from '../result.mjs';
 
 /**
  * Like a "Plain Old JavaScript Object", but for arrays: "Plain Old JavaScript
@@ -8,10 +8,10 @@ import { compose, predicate } from './composition';
  */
 export var poja = function poja(blob) {
   if (!Array.isArray(blob)) {
-    return Result.err(annotate(blob, 'Must be an array'));
+    return err(annotate(blob, 'Must be an array'));
   }
 
-  return Result.ok( // NOTE: Since Flow 0.98, Array.isArray() returns $ReadOnlyArray<mixed>
+  return 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
@@ -35,7 +35,7 @@ function all(items, blobs) {
   for (var index = 0; index < items.length; ++index) {
     var result = items[index];
 
-    if (result.type === 'ok') {
+    if (result.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
@@ -51,11 +51,11 @@ function all(items, blobs) {
       //     errValue.push('...'); // TODO: make special mark, not string!
       // }
 
-      return Result.err(annotate(clone));
+      return err(annotate(clone));
     }
   }
 
-  return Result.ok(results);
+  return ok(results);
 }
 /**
  * Given a T, builds a decoder that assumes an array input and returns an
@@ -85,7 +85,16 @@ export function array(decoder) {
  */
 
 export function nonEmptyArray(decoder) {
-  return compose(array(decoder), predicate(function (arr) {
+  return predicate(array(decoder), function (arr) {
     return arr.length > 0;
-  }, 'Must be non-empty array'));
+  }, 'Must be non-empty array');
+}
+/**
+ * Similar to `array()`, but returns the result as an ES6 Set.
+ */
+
+export function set(decoder) {
+  return transform(array(decoder), function (items) {
+    return new Set(items);
+  });
 }

package/core/boolean.d.ts

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

package/core/boolean.js

@@ -3,23 +3,19 @@
 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 _result = require("../result");
 
 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; }
+var _composition = require("./composition");
 
 /**
  * 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'));
+  return typeof blob === 'boolean' ? (0, _result.ok)(blob) : (0, _result.err)((0, _annotate.annotate)(blob, 'Must be boolean'));
 };
 /**
  * Decoder that returns true for all truthy values, and false otherwise.  Never fails.
@@ -29,7 +25,7 @@ var _boolean = function _boolean(blob) {
 exports["boolean"] = _boolean;
 
 var truthy = function truthy(blob) {
-  return Result.ok(!!blob);
+  return (0, _result.ok)(!!blob);
 };
 /**
  * Decoder that only returns Ok for numeric input values representing booleans.
@@ -38,7 +34,7 @@ var truthy = function truthy(blob) {
 
 
 exports.truthy = truthy;
-var numericBoolean = (0, _composition.map)(_number.number, function (n) {
+var numericBoolean = (0, _composition.transform)(_number.number, function (n) {
   return !!n;
 });
 exports.numericBoolean = numericBoolean;

package/core/boolean.js.flow

@@ -1,29 +1,27 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
-import { map } from './composition';
+import { err, ok } from '../result';
 import { number } from './number';
+import { transform } from './composition';
 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'
-        ? Result.ok(blob)
-        : Result.err(annotate(blob, 'Must be boolean'));
+    return typeof blob === 'boolean' ? ok(blob) : 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 Result.ok(!!blob);
+    return ok(!!blob);
 };
 
 /**
  * Decoder that only returns Ok for numeric input values representing booleans.
  * Returns their boolean representation.  Err otherwise.
  */
-export const numericBoolean: Decoder<boolean> = map(number, (n) => !!n);
+export const numericBoolean: Decoder<boolean> = transform(number, (n) => !!n);

package/{_esm/core/boolean.js → core/boolean.mjs}

@@ -1,13 +1,13 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import { map } from './composition';
-import { number } from './number';
+import { annotate } from '../annotate.mjs';
+import { err, ok } from '../result.mjs';
+import { number } from './number.mjs';
+import { transform } from './composition.mjs';
 
 /**
  * Decoder that only returns Ok for boolean inputs.  Err otherwise.
  */
 var _boolean = function _boolean(blob) {
-  return typeof blob === 'boolean' ? Result.ok(blob) : Result.err(annotate(blob, 'Must be boolean'));
+  return typeof blob === 'boolean' ? ok(blob) : err(annotate(blob, 'Must be boolean'));
 };
 /**
  * Decoder that returns true for all truthy values, and false otherwise.  Never fails.
@@ -16,13 +16,13 @@ var _boolean = function _boolean(blob) {
 
 export { _boolean as boolean };
 export var truthy = function truthy(blob) {
-  return Result.ok(!!blob);
+  return ok(!!blob);
 };
 /**
  * Decoder that only returns Ok for numeric input values representing booleans.
  * Returns their boolean representation.  Err otherwise.
  */
 
-export var numericBoolean = map(number, function (n) {
+export var numericBoolean = transform(number, function (n) {
   return !!n;
 });

package/core/composition.d.ts

@@ -0,0 +1,18 @@
+import { Decoder } from '../_types';
+
+export function transform<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, N extends T>(
+    decoder: Decoder<T>,
+    predicate: (value: T) => value is N,
+    msg: string,
+): Decoder<N>;
+export function predicate<T>(
+    decoder: Decoder<T>,
+    predicate: (value: T) => boolean,
+    msg: string,
+): Decoder<T>;
+export function prep<T, I>(
+    mapperFn: (blob: unknown) => I,
+    decoder: Decoder<T, I>,
+): Decoder<T>;