decoders 2.0.0-beta1 → 2.0.0-beta13

package/cjs/stdlib/either.js

@@ -1,117 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.either = either;
-exports.either3 = either3;
-exports.either4 = either4;
-exports.either5 = either5;
-exports.either6 = either6;
-exports.either7 = either7;
-exports.either8 = either8;
-exports.either9 = either9;
-exports.oneOf = oneOf;
-
-var Result = _interopRequireWildcard(require("../result"));
-
-var _annotate = require("../annotate");
-
-var _utils = require("../_utils");
-
-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; }
-
-/**
- * Indents and adds a dash in front of this (potentially multiline) string.
- */
-function itemize(s) {
-  return '-' + (0, _utils.indent)(s).substring(1);
-}
-/**
- * Nests another error as an item under a new-to-be-created "Either error". If
- * the given subitem already is an "Either error" of itself, don't indent, but
- * just "inject" its items at the same error level, for nicely flattened either
- * expressions.
- *
- * Avoids:
- *
- *     Either:
- *     - Either:
- *       - Must be P
- *       - Either:
- *         - Must be Q
- *         - Must be R
- *     - Must be S
- *
- * And "flattens" these to:
- *
- *     Either:
- *     - Must be P
- *     - Must be Q
- *     - Must be R
- *     - Must be S
- *
- */
-
-
-function nest(errText) {
-  var EITHER_PREFIX = 'Either:\n';
-  return errText.startsWith(EITHER_PREFIX) ? errText.substr(EITHER_PREFIX.length) : itemize(errText);
-}
-
-function either(d1, d2) {
-  return function (blob) {
-    return Result.orElse(d1(blob), function (err1) {
-      return Result.orElse(d2(blob), function (err2) {
-        var serr1 = (0, _utils.summarize)(err1).join('\n');
-        var serr2 = (0, _utils.summarize)(err2).join('\n');
-        var text = ['Either:', nest(serr1), nest(serr2)].join('\n');
-        return Result.err((0, _annotate.annotate)(blob, text));
-      });
-    });
-  };
-}
-
-function either3(d1, d2, d3) {
-  return either(d1, either(d2, d3));
-}
-
-function either4(d1, d2, d3, d4) {
-  return either(d1, either3(d2, d3, d4));
-}
-
-function either5(d1, d2, d3, d4, d5) {
-  return either(d1, either4(d2, d3, d4, d5));
-}
-
-function either6(d1, d2, d3, d4, d5, d6) {
-  return either(d1, either5(d2, d3, d4, d5, d6));
-}
-
-function either7(d1, d2, d3, d4, d5, d6, d7) {
-  return either(d1, either6(d2, d3, d4, d5, d6, d7));
-}
-
-function either8(d1, d2, d3, d4, d5, d6, d7, d8) {
-  return either(d1, either7(d2, d3, d4, d5, d6, d7, d8));
-}
-
-function either9(d1, d2, d3, d4, d5, d6, d7, d8, d9) {
-  return either(d1, either8(d2, d3, d4, d5, d6, d7, d8, d9));
-}
-
-function oneOf(constants) {
-  return function (blob) {
-    var winner = constants.find(function (c) {
-      return c === blob;
-    });
-
-    if (winner !== undefined) {
-      return Result.ok(winner);
-    }
-
-    return Result.err((0, _annotate.annotate)(blob, "Must be one of " + constants.map(function (value) {
-      return JSON.stringify(value);
-    }).join(', ')));
-  };
-}

package/cjs/stdlib/either.js.flow

@@ -1,151 +0,0 @@
-// @flow strict
-
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import { indent, summarize } from '../_utils';
-import type { Decoder, Scalar } from '../_types';
-
-/**
- * Indents and adds a dash in front of this (potentially multiline) string.
- */
-function itemize(s: string): string {
-    return '-' + indent(s).substring(1);
-}
-
-/**
- * Nests another error as an item under a new-to-be-created "Either error". If
- * the given subitem already is an "Either error" of itself, don't indent, but
- * just "inject" its items at the same error level, for nicely flattened either
- * expressions.
- *
- * Avoids:
- *
- *     Either:
- *     - Either:
- *       - Must be P
- *       - Either:
- *         - Must be Q
- *         - Must be R
- *     - Must be S
- *
- * And "flattens" these to:
- *
- *     Either:
- *     - Must be P
- *     - Must be Q
- *     - Must be R
- *     - Must be S
- *
- */
-function nest(errText: string): string {
-    const EITHER_PREFIX = 'Either:\n';
-    return errText.startsWith(EITHER_PREFIX)
-        ? errText.substr(EITHER_PREFIX.length)
-        : itemize(errText);
-}
-
-export function either<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<T1 | T2> {
-    return (blob: mixed) =>
-        Result.orElse(d1(blob), (err1) =>
-            Result.orElse(d2(blob), (err2) => {
-                const serr1 = summarize(err1).join('\n');
-                const serr2 = summarize(err2).join('\n');
-                const text = ['Either:', nest(serr1), nest(serr2)].join('\n');
-                return Result.err(annotate(blob, text));
-            }),
-        );
-}
-
-export function either3<T1, T2, T3>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-): Decoder<T1 | T2 | T3> {
-    return either(d1, either(d2, d3));
-}
-
-export function either4<T1, T2, T3, T4>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-): Decoder<T1 | T2 | T3 | T4> {
-    return either(d1, either3(d2, d3, d4));
-}
-
-export function either5<T1, T2, T3, T4, T5>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-): Decoder<T1 | T2 | T3 | T4 | T5> {
-    return either(d1, either4(d2, d3, d4, d5));
-}
-
-export function either6<T1, T2, T3, T4, T5, T6>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>,
-): Decoder<T1 | T2 | T3 | T4 | T5 | T6> {
-    return either(d1, either5(d2, d3, d4, d5, d6));
-}
-
-export function either7<T1, T2, T3, T4, T5, T6, T7>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>,
-    d7: Decoder<T7>,
-): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7> {
-    return either(d1, either6(d2, d3, d4, d5, d6, d7));
-}
-
-export function either8<T1, T2, T3, T4, T5, T6, T7, T8>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>,
-    d7: Decoder<T7>,
-    d8: Decoder<T8>,
-): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8> {
-    return either(d1, either7(d2, d3, d4, d5, d6, d7, d8));
-}
-
-export function either9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(
-    d1: Decoder<T1>,
-    d2: Decoder<T2>,
-    d3: Decoder<T3>,
-    d4: Decoder<T4>,
-    d5: Decoder<T5>,
-    d6: Decoder<T6>,
-    d7: Decoder<T7>,
-    d8: Decoder<T8>,
-    d9: Decoder<T9>,
-): Decoder<T1 | T2 | T3 | T4 | T5 | T6 | T7 | T8 | T9> {
-    return either(d1, either8(d2, d3, d4, d5, d6, d7, d8, d9));
-}
-
-export function oneOf<T: Scalar>(constants: $ReadOnlyArray<T>): Decoder<T> {
-    return (blob: mixed) => {
-        const winner = constants.find((c) => c === blob);
-        if (winner !== undefined) {
-            return Result.ok(winner);
-        }
-        return Result.err(
-            annotate(
-                blob,
-                `Must be one of ${constants
-                    .map((value) => JSON.stringify(value))
-                    .join(', ')}`,
-            ),
-        );
-    };
-}

package/cjs/stdlib/fail.js

@@ -1,21 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.fail = fail;
-
-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; }
-
-/**
- * Decoder that always fails with the given error message, no matter what the input.
- */
-function fail(msg) {
-  return function (blob) {
-    return Result.err((0, _annotate.annotate)(blob, msg));
-  };
-}

package/cjs/stdlib/fail.js.flow

@@ -1,12 +0,0 @@
-// @flow strict
-
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import type { Decoder } from '../_types';
-
-/**
- * Decoder that always fails with the given error message, no matter what the input.
- */
-export function fail(msg: string): Decoder<empty> {
-    return (blob: mixed) => Result.err(annotate(blob, msg));
-}

package/cjs/stdlib/instanceOf.js

@@ -1,19 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.instanceOf = instanceOf;
-
-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; }
-
-function instanceOf(klass) {
-  return function (blob) {
-    return blob instanceof klass ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, "Must be " + // $FlowFixMe[incompatible-use] - klass.name is fine?
-    klass.name + " instance"));
-  };
-}

package/cjs/stdlib/instanceOf.js.flow

@@ -1,20 +0,0 @@
-// @flow strict
-
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import type { Decoder } from '../_types';
-
-export function instanceOf<T>(klass: Class<T>): Decoder<T> {
-    return (blob: mixed) =>
-        blob instanceof klass
-            ? Result.ok(blob)
-            : Result.err(
-                  annotate(
-                      blob,
-                      `Must be ${
-                          // $FlowFixMe[incompatible-use] - klass.name is fine?
-                          klass.name
-                      } instance`,
-                  ),
-              );
-}

package/cjs/stdlib/json.js

@@ -1,31 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.jsonObject = exports.jsonArray = exports.json = void 0;
-
-var _array = require("./array");
-
-var _boolean2 = require("./boolean");
-
-var _mapping = require("./mapping");
-
-var _either = require("./either");
-
-var _lazy = require("./lazy");
-
-var _constants = require("./constants");
-
-var _number = require("./number");
-
-var _string = require("./string");
-
-var jsonObject = (0, _lazy.lazy)(function () {
-  return (0, _mapping.dict)(json);
-});
-exports.jsonObject = jsonObject;
-var jsonArray = (0, _lazy.lazy)(function () {
-  return (0, _array.array)(json);
-});
-exports.jsonArray = jsonArray;
-var json = (0, _either.either6)(_constants.null_, _string.string, _number.number, _boolean2["boolean"], jsonObject, jsonArray);
-exports.json = json;

package/cjs/stdlib/json.js.flow

@@ -1,28 +0,0 @@
-// @flow strict
-
-import { array } from './array';
-import { boolean } from './boolean';
-import { dict } from './mapping';
-import { either6 } from './either';
-import { lazy } from './lazy';
-import { null_ } from './constants';
-import { number } from './number';
-import { string } from './string';
-import type { Decoder } from '../_types';
-
-export type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
-export type JSONObject = { [string]: JSONValue };
-export type JSONArray = Array<JSONValue>;
-
-export const jsonObject: Decoder<JSONObject> = lazy(() => dict(json));
-
-export const jsonArray: Decoder<JSONArray> = lazy(() => array(json));
-
-export const json: Decoder<JSONValue> = either6(
-    null_,
-    string,
-    number,
-    boolean,
-    jsonObject,
-    jsonArray,
-);

package/cjs/stdlib/lazy.js

@@ -1,16 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.lazy = lazy;
-
-/**
- * Given an function returning a Decoder, will use that decoder to decode the
- * value. This is typically used to build decoders for recursive or
- * self-referential types.
- */
-function lazy(decoderFn) {
-  return function (blob) {
-    var decoder = decoderFn();
-    return decoder(blob);
-  };
-}

package/cjs/stdlib/lazy.js.flow

@@ -1,15 +0,0 @@
-// @flow strict
-
-import type { Decoder } from '../_types';
-
-/**
- * Given an function returning a Decoder, will use that decoder to decode the
- * value. This is typically used to build decoders for recursive or
- * self-referential types.
- */
-export function lazy<T>(decoderFn: () => Decoder<T>): Decoder<T> {
-    return (blob: mixed) => {
-        const decoder = decoderFn();
-        return decoder(blob);
-    };
-}

package/cjs/stdlib/mapping.js

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

package/cjs/stdlib/mapping.js.flow

@@ -1,54 +0,0 @@
-// @flow strict
-
-import * as Result from '../result';
-import { annotateObject } from '../annotate';
-import { compose, map } from './composition';
-import { merge } from '../annotate';
-import { pojo } from './object';
-import type { Annotation } from '../annotate';
-import type { Decoder } from '../_types';
-
-/**
- * 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 compose(pojo, (blob: { +[key: string]: mixed }) => {
-        let tuples: Array<[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) {
-                    tuples.push([key, result.value]);
-                }
-            } else {
-                tuples.length = 0; // Clear the tuples array
-                if (errors === null) {
-                    errors = {};
-                }
-                errors[key] = result.error;
-            }
-        });
-
-        if (errors !== null) {
-            return Result.err(merge(annotateObject(blob), errors));
-        } else {
-            return Result.ok(new Map(tuples));
-        }
-    });
-}
-
-/**
- * Like mapping(), but returns an object rather than a Map instance.
- */
-export function dict<T>(decoder: Decoder<T>): Decoder<{ [string]: T }> {
-    return map(mapping(decoder), (m) => Object.fromEntries(m));
-}

package/cjs/stdlib/number.js

@@ -1,40 +0,0 @@
-"use strict";
-
-exports.__esModule = true;
-exports.positiveNumber = exports.positiveInteger = exports.number = exports.integer = 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; }
-
-var anyNumber = function anyNumber(blob) {
-  return typeof blob === 'number' && !Number.isNaN(blob) ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, 'Must be number'));
-};
-
-var isInteger = function isInteger(n) {
-  return Number.isInteger(n);
-};
-
-var isFinite = function isFinite(n) {
-  return Number.isFinite(n);
-};
-
-var number = (0, _composition.compose)(anyNumber, (0, _composition.predicate)(isFinite, 'Number must be finite'));
-exports.number = number;
-var positiveNumber = (0, _composition.compose)(number, (0, _composition.predicate)(function (n) {
-  return n >= 0;
-}, 'Number must be positive')); // Integers
-
-exports.positiveNumber = positiveNumber;
-var integer = (0, _composition.compose)(number, (0, _composition.predicate)(isInteger, 'Number must be an integer'));
-exports.integer = integer;
-var positiveInteger = (0, _composition.compose)(integer, (0, _composition.predicate)(function (n) {
-  return n >= 0;
-}, 'Number must be positive'));
-exports.positiveInteger = positiveInteger;

package/cjs/stdlib/number.js.flow

@@ -1,34 +0,0 @@
-// @flow strict
-
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import { compose, predicate } from './composition';
-import type { Decoder } from '../_types';
-
-const anyNumber: Decoder<number> = (blob: mixed) => {
-    return typeof blob === 'number' && !Number.isNaN(blob)
-        ? Result.ok(blob)
-        : Result.err(annotate(blob, 'Must be number'));
-};
-
-const isInteger = (n: number) => Number.isInteger(n);
-const isFinite = (n: number) => Number.isFinite(n);
-
-export const number: Decoder<number> = compose(
-    anyNumber,
-    predicate(isFinite, 'Number must be finite'),
-);
-export const positiveNumber: Decoder<number> = compose(
-    number,
-    predicate((n) => n >= 0, 'Number must be positive'),
-);
-
-// Integers
-export const integer: Decoder<number> = compose(
-    number,
-    predicate(isInteger, 'Number must be an integer'),
-);
-export const positiveInteger: Decoder<number> = compose(
-    integer,
-    predicate((n) => n >= 0, 'Number must be positive'),
-);