decoders 2.0.0-beta6 → 2.0.0-beta7

package/NotSupportedTSVersion.d.ts

@@ -0,0 +1 @@
+"Package `decoders` requires TypeScript >= 4.1.0"

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/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,5 @@
+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[]]>;

package/core/array.js

@@ -5,15 +5,11 @@ 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; }
+var _result = require("../result");
 
 /**
  * Like a "Plain Old JavaScript Object", but for arrays: "Plain Old JavaScript
@@ -21,10 +17,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
@@ -67,11 +63,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

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 { 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
@@ -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);
 }
 
 /**

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 } 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
@@ -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

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 _result = require("../result");
+
 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'));
+  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.

package/core/boolean.js.flow

@@ -1,7 +1,7 @@
 // @flow strict
 
-import * as Result from '../result';
 import { annotate } from '../annotate';
+import { err, ok } from '../result';
 import { map } from './composition';
 import { number } from './number';
 import type { Decoder } from '../_types';
@@ -10,16 +10,14 @@ 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);
 };
 
 /**

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 { map } from './composition.mjs';
+import { number } from './number.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,7 +16,7 @@ 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.

package/core/composition.d.ts

@@ -0,0 +1,12 @@
+import { Decoder } from '../_types';
+
+export function map<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 extends F, F = unknown>(
+    predicate: (value: F) => value is T,
+    msg: string,
+): Decoder<T, F>;
+export function predicate<T>(
+    predicate: (value: T) => boolean,
+    msg: string,
+): Decoder<T, T>;

package/core/composition.js

@@ -5,14 +5,10 @@ exports.compose = compose;
 exports.map = map;
 exports.predicate = predicate;
 
-var Result = _interopRequireWildcard(require("../result"));
+var _result = 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.
@@ -20,9 +16,9 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj &&
 function map(decoder, mapper) {
   return compose(decoder, function (x) {
     try {
-      return Result.ok(mapper(x));
+      return (0, _result.ok)(mapper(x));
     } catch (e) {
-      return Result.err((0, _annotate.annotate)(x, e instanceof Error ? e.message : String(e)));
+      return (0, _result.err)((0, _annotate.annotate)(x, e instanceof Error ? e.message : String(e)));
     }
   });
 }
@@ -40,7 +36,7 @@ function map(decoder, mapper) {
 
 function compose(decoder, next) {
   return function (blob) {
-    return Result.andThen(decoder(blob), next);
+    return (0, _result.andThen)(decoder(blob), next);
   };
 }
 /**
@@ -49,8 +45,8 @@ function compose(decoder, next) {
  */
 
 
-function predicate(predicate, msg) {
+function predicate(predicateFn, msg) {
   return function (value) {
-    return predicate(value) ? Result.ok(value) : Result.err((0, _annotate.annotate)(value, msg));
+    return predicateFn(value) ? (0, _result.ok)(value) : (0, _result.err)((0, _annotate.annotate)(value, msg));
   };
 }

package/core/composition.js.flow

@@ -1,6 +1,6 @@
 // @flow strict
 
-import * as Result from '../result';
+import { andThen, err, ok } from '../result';
 import { annotate } from '../annotate';
 import type { Decoder } from '../_types';
 
@@ -11,9 +11,9 @@ import type { Decoder } from '../_types';
 export function map<T, V>(decoder: Decoder<T>, mapper: (T) => V): Decoder<V> {
     return compose(decoder, (x) => {
         try {
-            return Result.ok(mapper(x));
+            return ok(mapper(x));
         } catch (e) {
-            return Result.err(annotate(x, e instanceof Error ? e.message : String(e)));
+            return err(annotate(x, e instanceof Error ? e.message : String(e)));
         }
     });
 }
@@ -29,15 +29,15 @@ export function map<T, V>(decoder: Decoder<T>, mapper: (T) => V): Decoder<V> {
  * argument.
  */
 export function compose<T, V>(decoder: Decoder<T>, next: Decoder<V, T>): Decoder<V> {
-    return (blob: mixed) => Result.andThen(decoder(blob), next);
+    return (blob: mixed) => andThen(decoder(blob), next);
 }
 
 /**
  * Factory function returning a Decoder<T>, given a predicate function that
  * accepts/rejects the input of type T.
  */
-export function predicate<T>(predicate: (T) => boolean, msg: string): Decoder<T, T> {
+export function predicate<T>(predicateFn: (T) => boolean, msg: string): Decoder<T, T> {
     return (value: T) => {
-        return predicate(value) ? Result.ok(value) : Result.err(annotate(value, msg));
+        return predicateFn(value) ? ok(value) : err(annotate(value, msg));
     };
 }

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

@@ -1,5 +1,5 @@
-import * as Result from '../result';
-import { annotate } from '../annotate';
+import { andThen, err, ok } from '../result.mjs';
+import { annotate } from '../annotate.mjs';
 
 /**
  * Given a decoder T and a mapping function from T's to V's, returns a decoder
@@ -8,9 +8,9 @@ import { annotate } from '../annotate';
 export function map(decoder, mapper) {
   return compose(decoder, function (x) {
     try {
-      return Result.ok(mapper(x));
+      return ok(mapper(x));
     } catch (e) {
-      return Result.err(annotate(x, e instanceof Error ? e.message : String(e)));
+      return err(annotate(x, e instanceof Error ? e.message : String(e)));
     }
   });
 }
@@ -27,7 +27,7 @@ export function map(decoder, mapper) {
 
 export function compose(decoder, next) {
   return function (blob) {
-    return Result.andThen(decoder(blob), next);
+    return andThen(decoder(blob), next);
   };
 }
 /**
@@ -35,8 +35,8 @@ export function compose(decoder, next) {
  * accepts/rejects the input of type T.
  */
 
-export function predicate(predicate, msg) {
+export function predicate(predicateFn, msg) {
   return function (value) {
-    return predicate(value) ? Result.ok(value) : Result.err(annotate(value, msg));
+    return predicateFn(value) ? ok(value) : err(annotate(value, msg));
   };
 }

package/core/constants.d.ts

@@ -0,0 +1,11 @@
+import { Decoder, Scalar } from '../_types';
+
+// Constants
+
+export const null_: Decoder<null>;
+export const undefined_: Decoder<undefined>;
+export function constant<T extends Scalar>(value: T): Decoder<T>;
+export function hardcoded<T extends Scalar>(value: T): Decoder<T>;
+export function hardcoded<T>(value: T): Decoder<T>;
+export const mixed: Decoder<unknown>;
+export const unknown: Decoder<unknown>;