decoders 2.0.0-beta4 → 2.0.0-beta8

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

@@ -1,6 +1,6 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
-import { indent, summarize } from '../_utils';
+import { annotate } from '../annotate.mjs';
+import { err, ok, orElse } from '../result.mjs';
+import { indent, summarize } from '../_utils.mjs';
 
 /**
  * Indents and adds a dash in front of this (potentially multiline) string.
@@ -42,12 +42,12 @@ function nest(errText) {
 
 export function either(d1, d2) {
   return function (blob) {
-    return Result.orElse(d1(blob), function (err1) {
-      return Result.orElse(d2(blob), function (err2) {
+    return orElse(d1(blob), function (err1) {
+      return orElse(d2(blob), function (err2) {
         var serr1 = summarize(err1).join('\n');
         var serr2 = summarize(err2).join('\n');
         var text = ['Either:', nest(serr1), nest(serr2)].join('\n');
-        return Result.err(annotate(blob, text));
+        return err(annotate(blob, text));
       });
     });
   };
@@ -80,10 +80,10 @@ export function oneOf(constants) {
     });
 
     if (winner !== undefined) {
-      return Result.ok(winner);
+      return ok(winner);
     }
 
-    return Result.err(annotate(blob, "Must be one of " + constants.map(function (value) {
+    return err(annotate(blob, "Must be one of " + constants.map(function (value) {
       return JSON.stringify(value);
     }).join(', ')));
   };

package/core/fail.d.ts

@@ -0,0 +1,3 @@
+import { Decoder } from '../_types';
+
+export function fail(msg: string): Decoder<never>;

package/core/fail.js

@@ -3,19 +3,15 @@
 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; }
+var _result = require("../result");
 
 /**
  * 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));
+    return (0, _result.err)((0, _annotate.annotate)(blob, msg));
   };
 }

package/core/fail.js.flow

@@ -1,12 +1,12 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
+import { err } from '../result';
 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));
+    return (blob: mixed) => err(annotate(blob, msg));
 }

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

@@ -1,11 +1,11 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
+import { annotate } from '../annotate.mjs';
+import { err } from '../result.mjs';
 
 /**
  * Decoder that always fails with the given error message, no matter what the input.
  */
 export function fail(msg) {
   return function (blob) {
-    return Result.err(annotate(blob, msg));
+    return err(annotate(blob, msg));
   };
 }

package/core/instanceOf.d.ts

@@ -0,0 +1,3 @@
+import { Decoder } from '../_types';
+
+export function instanceOf<T>(klass: new (...args: any) => T): Decoder<T>;

package/core/instanceOf.js

@@ -3,17 +3,13 @@
 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; }
+var _result = require("../result");
 
 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?
+    return blob instanceof klass ? (0, _result.ok)(blob) : (0, _result.err)((0, _annotate.annotate)(blob, "Must be " + // $FlowFixMe[incompatible-use] - klass.name is fine?
     klass.name + " instance"));
   };
 }

package/core/instanceOf.js.flow

@@ -1,14 +1,14 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
+import { err, ok } from '../result';
 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(
+            ? ok(blob)
+            : err(
                   annotate(
                       blob,
                       `Must be ${

package/core/instanceOf.mjs

@@ -0,0 +1,8 @@
+import { annotate } from '../annotate.mjs';
+import { err, ok } from '../result.mjs';
+export function instanceOf(klass) {
+  return function (blob) {
+    return blob instanceof klass ? ok(blob) : err(annotate(blob, "Must be " + // $FlowFixMe[incompatible-use] - klass.name is fine?
+    klass.name + " instance"));
+  };
+}

package/core/json.d.ts

@@ -0,0 +1,11 @@
+import { Decoder } from '../_types';
+
+export type JSONValue = null | string | number | boolean | JSONObject | JSONArray;
+export interface JSONObject {
+    [key: string]: JSONValue;
+}
+export type JSONArray = JSONValue[];
+
+export const json: Decoder<JSONValue>;
+export const jsonArray: Decoder<JSONArray>;
+export const jsonObject: Decoder<JSONObject>;

package/core/json.mjs

@@ -0,0 +1,15 @@
+import { array } from './array.mjs';
+import { boolean as _boolean } from './boolean.mjs';
+import { dict } from './mapping.mjs';
+import { either6 } from './either.mjs';
+import { lazy } from './lazy.mjs';
+import { null_ } from './constants.mjs';
+import { number } from './number.mjs';
+import { string } from './string.mjs';
+export var jsonObject = lazy(function () {
+  return dict(json);
+});
+export var jsonArray = lazy(function () {
+  return array(json);
+});
+export var json = either6(null_, string, number, _boolean, jsonObject, jsonArray);

package/core/lazy.d.ts

@@ -0,0 +1,3 @@
+import { Decoder } from '../_types';
+
+export function lazy<T>(decoderFn: () => Decoder<T>): Decoder<T>;

package/core/mapping.d.ts

@@ -0,0 +1,6 @@
+/// <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

@@ -4,30 +4,20 @@ 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); }
+var _result = require("../result");
 
-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 _object = require("./object");
 
 /**
- * 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)
- *
+ * Like mapping(), but returns an object rather than a Map instance.
  */
-function mapping(decoder) {
+function dict(decoder) {
   return (0, _composition.compose)(_object.pojo, function (blob) {
-    var tuples = [];
+    var rv = {};
     var errors = null;
     Object.keys(blob).forEach(function (key) {
       var value = blob[key];
@@ -35,10 +25,10 @@ function mapping(decoder) {
 
       if (result.type === 'ok') {
         if (errors === null) {
-          tuples.push([key, result.value]);
+          rv[key] = result.value;
         }
       } else {
-        tuples.length = 0; // Clear the tuples array
+        rv = {}; // Clear the success value so it can get garbage collected early
 
         if (errors === null) {
           errors = {};
@@ -49,19 +39,29 @@ function mapping(decoder) {
     });
 
     if (errors !== null) {
-      return Result.err((0, _annotate.merge)((0, _annotate.annotateObject)(blob), errors));
+      return (0, _result.err)((0, _annotate.merge)((0, _annotate.annotateObject)(blob), errors));
     } else {
-      return Result.ok(new Map(tuples));
+      return (0, _result.ok)(rv);
     }
   });
 }
 /**
- * Like mapping(), but returns an object rather than a Map instance.
+ * 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 dict(decoder) {
-  return (0, _composition.map)(mapping(decoder), function (m) {
-    return Object.fromEntries(m);
+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,25 +1,19 @@
 // @flow strict
 
-import * as Result from '../result';
 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';
 
 /**
- * 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)
- *
+ * Like mapping(), but returns an object rather than a Map instance.
  */
-export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>> {
+export function dict<T>(decoder: Decoder<T>): Decoder<{ [string]: T }> {
     return compose(pojo, (blob: { +[key: string]: mixed }) => {
-        let tuples: Array<[string, T]> = [];
+        let rv: { [key: string]: T } = {};
         let errors: { [key: string]: Annotation } | null = null;
 
         Object.keys(blob).forEach((key: string) => {
@@ -27,10 +21,10 @@ export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>> {
             const result = decoder(value);
             if (result.type === 'ok') {
                 if (errors === null) {
-                    tuples.push([key, result.value]);
+                    rv[key] = result.value;
                 }
             } else {
-                tuples.length = 0; // Clear the tuples array
+                rv = {}; // Clear the success value so it can get garbage collected early
                 if (errors === null) {
                     errors = {};
                 }
@@ -39,16 +33,30 @@ export function mapping<T>(decoder: Decoder<T>): Decoder<Map<string, T>> {
         });
 
         if (errors !== null) {
-            return Result.err(merge(annotateObject(blob), errors));
+            return err(merge(annotateObject(blob), errors));
         } else {
-            return Result.ok(new Map(tuples));
+            return ok(rv);
         }
     });
 }
 
 /**
- * Like mapping(), but returns an object rather than a Map instance.
+ * 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 dict<T>(decoder: Decoder<T>): Decoder<{ [string]: T }> {
-    return map(mapping(decoder), (m) => Object.fromEntries(m));
+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/{_esm/core/mapping.js → core/mapping.mjs}

@@ -1,21 +1,15 @@
-import * as Result from '../result';
-import { annotateObject } from '../annotate';
-import { compose, map } from './composition';
-import { merge } from '../annotate';
-import { pojo } from './object';
+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';
 
 /**
- * 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)
- *
+ * Like mapping(), but returns an object rather than a Map instance.
  */
-export function mapping(decoder) {
+export function dict(decoder) {
   return compose(pojo, function (blob) {
-    var tuples = [];
+    var rv = {};
     var errors = null;
     Object.keys(blob).forEach(function (key) {
       var value = blob[key];
@@ -23,10 +17,10 @@ export function mapping(decoder) {
 
       if (result.type === 'ok') {
         if (errors === null) {
-          tuples.push([key, result.value]);
+          rv[key] = result.value;
         }
       } else {
-        tuples.length = 0; // Clear the tuples array
+        rv = {}; // Clear the success value so it can get garbage collected early
 
         if (errors === null) {
           errors = {};
@@ -37,18 +31,28 @@ export function mapping(decoder) {
     });
 
     if (errors !== null) {
-      return Result.err(merge(annotateObject(blob), errors));
+      return err(merge(annotateObject(blob), errors));
     } else {
-      return Result.ok(new Map(tuples));
+      return ok(rv);
     }
   });
 }
 /**
- * Like mapping(), but returns an object rather than a Map instance.
+ * 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 dict(decoder) {
-  return map(mapping(decoder), function (m) {
-    return Object.fromEntries(m);
+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]];
+    }));
   });
 }

package/core/number.d.ts

@@ -0,0 +1,6 @@
+import { Decoder } from '../_types';
+
+export const integer: Decoder<number>;
+export const number: Decoder<number>;
+export const positiveInteger: Decoder<number>;
+export const positiveNumber: Decoder<number>;

package/core/number.js

@@ -3,18 +3,14 @@
 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); }
+var _result = require("../result");
 
-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");
 
 var anyNumber = function anyNumber(blob) {
-  return typeof blob === 'number' && !Number.isNaN(blob) ? Result.ok(blob) : Result.err((0, _annotate.annotate)(blob, 'Must be number'));
+  return typeof blob === 'number' && !Number.isNaN(blob) ? (0, _result.ok)(blob) : (0, _result.err)((0, _annotate.annotate)(blob, 'Must be number'));
 };
 
 var isInteger = function isInteger(n) {
@@ -25,16 +21,16 @@ var isFinite = function isFinite(n) {
   return Number.isFinite(n);
 };
 
-var number = (0, _composition.compose)(anyNumber, (0, _composition.predicate)(isFinite, 'Number must be finite'));
+var number = (0, _composition.predicate)(anyNumber, isFinite, 'Number must be finite');
 exports.number = number;
-var positiveNumber = (0, _composition.compose)(number, (0, _composition.predicate)(function (n) {
+var positiveNumber = (0, _composition.predicate)(number, function (n) {
   return n >= 0;
-}, 'Number must be positive')); // Integers
+}, 'Number must be positive'); // Integers
 
 exports.positiveNumber = positiveNumber;
-var integer = (0, _composition.compose)(number, (0, _composition.predicate)(isInteger, 'Number must be an integer'));
+var integer = (0, _composition.predicate)(number, isInteger, 'Number must be an integer');
 exports.integer = integer;
-var positiveInteger = (0, _composition.compose)(integer, (0, _composition.predicate)(function (n) {
+var positiveInteger = (0, _composition.predicate)(integer, function (n) {
   return n >= 0;
-}, 'Number must be positive'));
+}, 'Number must be positive');
 exports.positiveInteger = positiveInteger;

package/core/number.js.flow

@@ -1,34 +1,40 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
-import { compose, predicate } from './composition';
+import { err, ok } from '../result';
+import { 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'));
+        ? ok(blob)
+        : 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(
+export const number: Decoder<number> = predicate(
     anyNumber,
-    predicate(isFinite, 'Number must be finite'),
+    isFinite,
+    'Number must be finite',
 );
-export const positiveNumber: Decoder<number> = compose(
+
+export const positiveNumber: Decoder<number> = predicate(
     number,
-    predicate((n) => n >= 0, 'Number must be positive'),
+    (n) => n >= 0,
+    'Number must be positive',
 );
 
 // Integers
-export const integer: Decoder<number> = compose(
+export const integer: Decoder<number> = predicate(
     number,
-    predicate(isInteger, 'Number must be an integer'),
+    isInteger,
+    'Number must be an integer',
 );
-export const positiveInteger: Decoder<number> = compose(
+
+export const positiveInteger: Decoder<number> = predicate(
     integer,
-    predicate((n) => n >= 0, 'Number must be positive'),
+    (n) => n >= 0,
+    'Number must be positive',
 );

package/core/number.mjs

@@ -0,0 +1,25 @@
+import { annotate } from '../annotate.mjs';
+import { err, ok } from '../result.mjs';
+import { predicate } from './composition.mjs';
+
+var anyNumber = function anyNumber(blob) {
+  return typeof blob === 'number' && !Number.isNaN(blob) ? ok(blob) : err(annotate(blob, 'Must be number'));
+};
+
+var isInteger = function isInteger(n) {
+  return Number.isInteger(n);
+};
+
+var isFinite = function isFinite(n) {
+  return Number.isFinite(n);
+};
+
+export var number = predicate(anyNumber, isFinite, 'Number must be finite');
+export var positiveNumber = predicate(number, function (n) {
+  return n >= 0;
+}, 'Number must be positive'); // Integers
+
+export var integer = predicate(number, isInteger, 'Number must be an integer');
+export var positiveInteger = predicate(integer, function (n) {
+  return n >= 0;
+}, 'Number must be positive');

package/core/object.d.ts

@@ -0,0 +1,33 @@
+import { Decoder, DecoderType } from '../_types';
+import { AllowImplicit } from './_helpers';
+
+export type ObjectDecoderType<T> = AllowImplicit<{
+    [key in keyof T]: DecoderType<T[key]>;
+}>;
+
+export const pojo: Decoder<{ [key: string]: unknown }>;
+
+export function object<O extends { [key: string]: Decoder<any> }>(
+    mapping: O,
+): Decoder<{ [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] }>;
+//         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//         This is basically just equivalent to:
+//             ObjectDecoderType<O>
+//
+//         But by "resolving" this with a mapped type, we remove the helper
+//         type names from the inferred type here, making this much easier to
+//         work with while developing.
+
+export function exact<O extends { [key: string]: Decoder<any> }>(
+    mapping: O,
+): Decoder<{ [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] }>;
+//         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+//         Ditto (see above)
+
+export function inexact<O extends { [key: string]: Decoder<any> }>(
+    mapping: O,
+): Decoder<
+    { [K in keyof ObjectDecoderType<O>]: ObjectDecoderType<O>[K] } & {
+        [extra: string]: unknown;
+    }
+>;