decoders 2.0.0-beta3 → 2.0.0-beta7

package/{_esm/core/string.js → core/string.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';
 
 /** Match groups in this regex:
  * \1 - the scheme
@@ -17,7 +17,7 @@ var DEFAULT_SCHEMES = ['https'];
  */
 
 export var string = function string(blob) {
-  return typeof blob === 'string' ? Result.ok(blob) : Result.err(annotate(blob, 'Must be string'));
+  return typeof blob === 'string' ? ok(blob) : err(annotate(blob, 'Must be string'));
 };
 /**
  * Decoder that only returns Ok for non-empty string inputs.  Err otherwise.
@@ -62,14 +62,14 @@ export var url = function url(schemes) {
     var matches = value.match(url_re);
 
     if (!matches) {
-      return Result.err(annotate(value, 'Must be URL'));
+      return err(annotate(value, 'Must be URL'));
     } else {
       var scheme = matches[1];
 
       if (schemes.length === 0 || schemes.includes(scheme.toLowerCase())) {
-        return Result.ok(value);
+        return ok(value);
       } else {
-        return Result.err(annotate(value, "URL scheme must be any of: " + schemes.join(', ')));
+        return err(annotate(value, "URL scheme must be any of: " + schemes.join(', ')));
       }
     }
   });

package/core/tuple.d.ts

@@ -0,0 +1,30 @@
+import { Decoder } from '../_types';
+
+export function tuple1<T1>(d1: Decoder<T1>): Decoder<[T1]>;
+export function tuple2<T1, T2>(d1: Decoder<T1>, d2: Decoder<T2>): Decoder<[T1, T2]>;
+export function tuple3<T1, T2, T3>(
+    d1: Decoder<T1>,
+    d2: Decoder<T2>,
+    d3: Decoder<T3>,
+): Decoder<[T1, T2, T3]>;
+export function tuple4<T1, T2, T3, T4>(
+    d1: Decoder<T1>,
+    d2: Decoder<T2>,
+    d3: Decoder<T3>,
+    d4: Decoder<T4>,
+): Decoder<[T1, T2, T3, T4]>;
+export function tuple5<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]>;
+export function tuple6<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]>;

package/core/tuple.js

@@ -16,6 +16,10 @@ var _result = require("../result");
 
 var _array = require("./array");
 
+function okOrErr(result) {
+  return result.type === 'ok' ? result.value : result.error;
+}
+
 var ntuple = function ntuple(n) {
   return (0, _composition.compose)(_array.poja, (0, _composition.predicate)(function (arr) {
     return arr.length === n;
@@ -37,7 +41,7 @@ function tuple1(decoder1) {
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)((0, _result.errValue)(result1)));
+      return (0, _result.err)((0, _annotate.annotate)([okOrErr(result1)]));
     }
   });
 }
@@ -59,7 +63,7 @@ function tuple2(decoder1, decoder2) {
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2)]));
+      return (0, _result.err)((0, _annotate.annotate)([okOrErr(result1), okOrErr(result2)]));
     }
   });
 }
@@ -83,7 +87,7 @@ function tuple3(decoder1, decoder2, decoder3) {
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3)]));
+      return (0, _result.err)((0, _annotate.annotate)([okOrErr(result1), okOrErr(result2), okOrErr(result3)]));
     }
   });
 }
@@ -109,7 +113,7 @@ function tuple4(decoder1, decoder2, decoder3, decoder4) {
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3), (0, _result.isErr)(result4) ? (0, _result.errValue)(result4) : (0, _result.value)(result4)]));
+      return (0, _result.err)((0, _annotate.annotate)([okOrErr(result1), okOrErr(result2), okOrErr(result3), okOrErr(result4)]));
     }
   });
 }
@@ -137,7 +141,7 @@ function tuple5(decoder1, decoder2, decoder3, decoder4, decoder5) {
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3), (0, _result.isErr)(result4) ? (0, _result.errValue)(result4) : (0, _result.value)(result4), (0, _result.isErr)(result5) ? (0, _result.errValue)(result5) : (0, _result.value)(result5)]));
+      return (0, _result.err)((0, _annotate.annotate)([okOrErr(result1), okOrErr(result2), okOrErr(result3), okOrErr(result4), okOrErr(result5)]));
     }
   });
 }
@@ -167,7 +171,7 @@ function tuple6(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6) {
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return (0, _result.err)((0, _annotate.annotate)([(0, _result.isErr)(result1) ? (0, _result.errValue)(result1) : (0, _result.value)(result1), (0, _result.isErr)(result2) ? (0, _result.errValue)(result2) : (0, _result.value)(result2), (0, _result.isErr)(result3) ? (0, _result.errValue)(result3) : (0, _result.value)(result3), (0, _result.isErr)(result4) ? (0, _result.errValue)(result4) : (0, _result.value)(result4), (0, _result.isErr)(result5) ? (0, _result.errValue)(result5) : (0, _result.value)(result5), (0, _result.isErr)(result6) ? (0, _result.errValue)(result6) : (0, _result.value)(result6)]));
+      return (0, _result.err)((0, _annotate.annotate)([okOrErr(result1), okOrErr(result2), okOrErr(result3), okOrErr(result4), okOrErr(result5), okOrErr(result6)]));
     }
   });
 }

package/core/tuple.js.flow

@@ -2,9 +2,14 @@
 
 import { annotate } from '../annotate';
 import { compose, predicate } from './composition';
-import { err, errValue, isErr, ok, unwrap, value } from '../result';
+import { err, ok, unwrap } from '../result';
 import { poja } from './array';
 import type { Decoder } from '../_types';
+import type { Result } from '../result';
+
+function okOrErr<T, E>(result: Result<T, E>): T | E {
+    return result.type === 'ok' ? result.value : result.error;
+}
 
 const ntuple = (n: number) =>
     compose(
@@ -26,7 +31,7 @@ export function tuple1<T>(decoder1: Decoder<T>): Decoder<[T]> {
         } catch (e) {
             // If a decoder error has happened while unwrapping all the
             // results, try to construct a good error message
-            return err(annotate(errValue(result1)));
+            return err(annotate([okOrErr(result1)]));
         }
     });
 }
@@ -49,12 +54,7 @@ export function tuple2<T1, T2>(
         } catch (e) {
             // If a decoder error has happened while unwrapping all the
             // results, try to construct a good error message
-            return err(
-                annotate([
-                    isErr(result1) ? errValue(result1) : value(result1),
-                    isErr(result2) ? errValue(result2) : value(result2),
-                ]),
-            );
+            return err(annotate([okOrErr(result1), okOrErr(result2)]));
         }
     });
 }
@@ -79,13 +79,7 @@ export function tuple3<T1, T2, T3>(
         } catch (e) {
             // If a decoder error has happened while unwrapping all the
             // results, try to construct a good error message
-            return err(
-                annotate([
-                    isErr(result1) ? errValue(result1) : value(result1),
-                    isErr(result2) ? errValue(result2) : value(result2),
-                    isErr(result3) ? errValue(result3) : value(result3),
-                ]),
-            );
+            return err(annotate([okOrErr(result1), okOrErr(result2), okOrErr(result3)]));
         }
     });
 }
@@ -119,10 +113,10 @@ export function tuple4<T1, T2, T3, T4>(
             // results, try to construct a good error message
             return err(
                 annotate([
-                    isErr(result1) ? errValue(result1) : value(result1),
-                    isErr(result2) ? errValue(result2) : value(result2),
-                    isErr(result3) ? errValue(result3) : value(result3),
-                    isErr(result4) ? errValue(result4) : value(result4),
+                    okOrErr(result1),
+                    okOrErr(result2),
+                    okOrErr(result3),
+                    okOrErr(result4),
                 ]),
             );
         }
@@ -161,11 +155,11 @@ export function tuple5<T1, T2, T3, T4, T5>(
             // results, try to construct a good error message
             return err(
                 annotate([
-                    isErr(result1) ? errValue(result1) : value(result1),
-                    isErr(result2) ? errValue(result2) : value(result2),
-                    isErr(result3) ? errValue(result3) : value(result3),
-                    isErr(result4) ? errValue(result4) : value(result4),
-                    isErr(result5) ? errValue(result5) : value(result5),
+                    okOrErr(result1),
+                    okOrErr(result2),
+                    okOrErr(result3),
+                    okOrErr(result4),
+                    okOrErr(result5),
                 ]),
             );
         }
@@ -207,12 +201,12 @@ export function tuple6<T1, T2, T3, T4, T5, T6>(
             // results, try to construct a good error message
             return err(
                 annotate([
-                    isErr(result1) ? errValue(result1) : value(result1),
-                    isErr(result2) ? errValue(result2) : value(result2),
-                    isErr(result3) ? errValue(result3) : value(result3),
-                    isErr(result4) ? errValue(result4) : value(result4),
-                    isErr(result5) ? errValue(result5) : value(result5),
-                    isErr(result6) ? errValue(result6) : value(result6),
+                    okOrErr(result1),
+                    okOrErr(result2),
+                    okOrErr(result3),
+                    okOrErr(result4),
+                    okOrErr(result5),
+                    okOrErr(result6),
                 ]),
             );
         }

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

@@ -1,7 +1,11 @@
-import { annotate } from '../annotate';
-import { compose, predicate } from './composition';
-import { err, errValue, isErr, ok, unwrap, value } from '../result';
-import { poja } from './array';
+import { annotate } from '../annotate.mjs';
+import { compose, predicate } from './composition.mjs';
+import { err, ok, unwrap } from '../result.mjs';
+import { poja } from './array.mjs';
+
+function okOrErr(result) {
+  return result.type === 'ok' ? result.value : result.error;
+}
 
 var ntuple = function ntuple(n) {
   return compose(poja, predicate(function (arr) {
@@ -24,7 +28,7 @@ export function tuple1(decoder1) {
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return err(annotate(errValue(result1)));
+      return err(annotate([okOrErr(result1)]));
     }
   });
 }
@@ -45,7 +49,7 @@ export function tuple2(decoder1, decoder2) {
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return err(annotate([isErr(result1) ? errValue(result1) : value(result1), isErr(result2) ? errValue(result2) : value(result2)]));
+      return err(annotate([okOrErr(result1), okOrErr(result2)]));
     }
   });
 }
@@ -68,7 +72,7 @@ export function tuple3(decoder1, decoder2, decoder3) {
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return err(annotate([isErr(result1) ? errValue(result1) : value(result1), isErr(result2) ? errValue(result2) : value(result2), isErr(result3) ? errValue(result3) : value(result3)]));
+      return err(annotate([okOrErr(result1), okOrErr(result2), okOrErr(result3)]));
     }
   });
 }
@@ -93,7 +97,7 @@ export function tuple4(decoder1, decoder2, decoder3, decoder4) {
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return err(annotate([isErr(result1) ? errValue(result1) : value(result1), isErr(result2) ? errValue(result2) : value(result2), isErr(result3) ? errValue(result3) : value(result3), isErr(result4) ? errValue(result4) : value(result4)]));
+      return err(annotate([okOrErr(result1), okOrErr(result2), okOrErr(result3), okOrErr(result4)]));
     }
   });
 }
@@ -120,7 +124,7 @@ export function tuple5(decoder1, decoder2, decoder3, decoder4, decoder5) {
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return err(annotate([isErr(result1) ? errValue(result1) : value(result1), isErr(result2) ? errValue(result2) : value(result2), isErr(result3) ? errValue(result3) : value(result3), isErr(result4) ? errValue(result4) : value(result4), isErr(result5) ? errValue(result5) : value(result5)]));
+      return err(annotate([okOrErr(result1), okOrErr(result2), okOrErr(result3), okOrErr(result4), okOrErr(result5)]));
     }
   });
 }
@@ -149,7 +153,7 @@ export function tuple6(decoder1, decoder2, decoder3, decoder4, decoder5, decoder
     } catch (e) {
       // If a decoder error has happened while unwrapping all the
       // results, try to construct a good error message
-      return err(annotate([isErr(result1) ? errValue(result1) : value(result1), isErr(result2) ? errValue(result2) : value(result2), isErr(result3) ? errValue(result3) : value(result3), isErr(result4) ? errValue(result4) : value(result4), isErr(result5) ? errValue(result5) : value(result5), isErr(result6) ? errValue(result6) : value(result6)]));
+      return err(annotate([okOrErr(result1), okOrErr(result2), okOrErr(result3), okOrErr(result4), okOrErr(result5), okOrErr(result6)]));
     }
   });
 }

package/format.d.ts

@@ -0,0 +1,4 @@
+import { Annotation } from './annotate';
+
+export function formatInline(ann: Annotation): string;
+export function formatShort(ann: Annotation): string;

package/{format/inline.js → format.js}

@@ -2,10 +2,11 @@
 
 exports.__esModule = true;
 exports.formatInline = formatInline;
+exports.formatShort = formatShort;
 exports.serializeAnnotation = serializeAnnotation;
 exports.serializeValue = serializeValue;
 
-var _utils = require("../_utils");
+var _utils = require("./_utils");
 
 function serializeString(s, width) {
   if (width === void 0) {
@@ -143,4 +144,8 @@ function formatInline(ann) {
   } else {
     return serialized;
   }
+}
+
+function formatShort(ann) {
+  return (0, _utils.summarize)(ann, []).join('\n');
 }

package/{_esm/format/inline.js.flow → format.js.flow}

@@ -1,7 +1,7 @@
 // @flow strict
 
-import { asDate, indent, INDENT, isMultiline } from '../_utils';
-import type { Annotation, ArrayAnnotation, ObjectAnnotation } from '../annotate';
+import { summarize as _summarize, asDate, INDENT, indent, isMultiline } from './_utils';
+import type { Annotation, ArrayAnnotation, ObjectAnnotation } from './annotate';
 
 function serializeString(s: string, width: number = 80): string {
     // Full string
@@ -120,3 +120,7 @@ export function formatInline(ann: Annotation): string {
         return serialized;
     }
 }
+
+export function formatShort(ann: Annotation): string {
+    return _summarize(ann, []).join('\n');
+}

package/{_esm/format/inline.js → format.mjs}

@@ -1,4 +1,4 @@
-import { asDate, indent, INDENT, isMultiline } from '../_utils';
+import { summarize as _summarize, asDate, INDENT, indent, isMultiline } from './_utils.mjs';
 
 function serializeString(s, width) {
   if (width === void 0) {
@@ -134,4 +134,7 @@ export function formatInline(ann) {
   } else {
     return serialized;
   }
+}
+export function formatShort(ann) {
+  return _summarize(ann, []).join('\n');
 }

package/{_esm/index.js.flow → index.d.ts}

@@ -1,24 +1,4 @@
-// @flow strict
-
-/**
- * Elm-like JSON decoders, for use with Flow.
- * See http://elmplayground.com/decoding-json-in-elm-1 for an introduction.
- *
- * Why? All JSON responses coming from our API endpoints are just that: free-form
- * JSON data.  To Flow, the only type classification possilbe is "any" -- effectively
- * turning off all type checks for anything related to JSON.  To the receiving end
- * (our frontend), the structure of that data is completely opaque to any type
- * checkers since JSON values can be anything: an object, an array, null, a string,
- * a bool, etc.  Our type system is not a runtime type system, so we need a way of
- * "converting" an any-type JSON value into a type that we want to work with in our
- * frontend code base.
- *
- * Elm's solution to this problem is to define composable decoders: functions that
- * take anything and either fail with an error, or guarantee to return the expected
- * type.  In our case, it's fine to fail with a runtime error.
- *
- */
-export type {
+export {
     Decoder,
     DecodeResult,
     DecoderType,
@@ -27,8 +7,8 @@ export type {
     Predicate,
     Scalar,
 } from './_types';
-
-export type { JSONValue, JSONObject, JSONArray } from './core/json';
+export { Result } from './result';
+export { JSONValue, JSONObject, JSONArray } from './core/json';
 
 export { guard } from './_guard';
 

package/index.js.flow

@@ -27,7 +27,7 @@ export type {
     Predicate,
     Scalar,
 } from './_types';
-
+export type { Result } from './result';
 export type { JSONValue, JSONObject, JSONArray } from './core/json';
 
 export { guard } from './_guard';

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

@@ -16,22 +16,22 @@
  * type.  In our case, it's fine to fail with a runtime error.
  *
  */
-export { guard } from './_guard';
-export { compose, map, predicate } from './core/composition';
-export { array, nonEmptyArray, poja } from './core/array';
-export { boolean, numericBoolean, truthy } from './core/boolean';
-export { constant, hardcoded, mixed, null_, undefined_, unknown } from './core/constants';
-export { date, iso8601 } from './core/date';
-export { describe } from './core/describe';
-export { dispatch } from './core/dispatch';
-export { either, either3, either4, either5, either6, either7, either8, either9, oneOf } from './core/either';
-export { fail } from './core/fail';
-export { instanceOf } from './core/instanceOf';
-export { json, jsonObject, jsonArray } from './core/json';
-export { lazy } from './core/lazy';
-export { mapping, dict } from './core/mapping';
-export { integer, number, positiveInteger, positiveNumber } from './core/number';
-export { exact, inexact, object, pojo } from './core/object';
-export { maybe, nullable, optional } from './core/optional';
-export { email, nonEmptyString, regex, string, url } from './core/string';
-export { tuple1, tuple2, tuple3, tuple4, tuple5, tuple6 } from './core/tuple';
+export { guard } from './_guard.mjs';
+export { compose, map, predicate } from './core/composition.mjs';
+export { array, nonEmptyArray, poja } from './core/array.mjs';
+export { boolean, numericBoolean, truthy } from './core/boolean.mjs';
+export { constant, hardcoded, mixed, null_, undefined_, unknown } from './core/constants.mjs';
+export { date, iso8601 } from './core/date.mjs';
+export { describe } from './core/describe.mjs';
+export { dispatch } from './core/dispatch.mjs';
+export { either, either3, either4, either5, either6, either7, either8, either9, oneOf } from './core/either.mjs';
+export { fail } from './core/fail.mjs';
+export { instanceOf } from './core/instanceOf.mjs';
+export { json, jsonObject, jsonArray } from './core/json.mjs';
+export { lazy } from './core/lazy.mjs';
+export { mapping, dict } from './core/mapping.mjs';
+export { integer, number, positiveInteger, positiveNumber } from './core/number.mjs';
+export { exact, inexact, object, pojo } from './core/object.mjs';
+export { maybe, nullable, optional } from './core/optional.mjs';
+export { email, nonEmptyString, regex, string, url } from './core/string.mjs';
+export { tuple1, tuple2, tuple3, tuple4, tuple5, tuple6 } from './core/tuple.mjs';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "decoders",
-    "version": "2.0.0-beta3",
+    "version": "2.0.0-beta7",
     "description": "Elegant and battle-tested validation library for type-safe input data (for TypeScript and Flow)",
     "license": "MIT",
     "repository": {
@@ -13,7 +13,7 @@
         "url": "https://github.com/nvie/decoders/issues"
     },
     "main": "./index.js",
-    "module": "./_esm/index.js",
+    "module": "./index.mjs",
     "keywords": [
         "decoder",
         "decoders",
@@ -40,6 +40,18 @@
         "map",
         "predicate"
     ],
+    "*": {
+        "*": [
+            "NotSupportedTSVersion.d.ts"
+        ]
+    },
     "githubUrl": "https://github.com/nvie/decoders",
-    "sideEffects": false
+    "sideEffects": false,
+    "typesVersions": {
+        ">=4.1.0": {
+            "*": [
+                "*"
+            ]
+        }
+    }
 }

package/result.d.ts

@@ -0,0 +1,39 @@
+export interface Ok<T> {
+    type: 'ok';
+    value: T;
+    error: undefined;
+}
+
+export interface Err<E> {
+    type: 'err';
+    value: undefined;
+    error: E;
+}
+
+export type Result<T, E> = Ok<T> | Err<E>;
+
+export function ok<T>(value: T): Ok<T>;
+export function err<E>(error: E): Err<E>;
+export function unwrap<T>(result: Result<T, unknown>): T;
+export function expect<T>(result: Result<T, unknown>, message: string | Error): T;
+export function dispatch<T, E, O>(
+    result: Result<T, E>,
+    okCallback: (value: T) => O,
+    errCallback: (error: E) => O,
+): O;
+export function andThen<T, E, T2>(
+    result1: Result<T, E>,
+    lazyResult2: (value: T) => Result<T2, E>,
+): Result<T2, E>;
+export function orElse<T, E, E2>(
+    result1: Result<T, E>,
+    lazyResult2: (errValue: E) => Result<T, E2>,
+): Result<T, E2>;
+export function mapOk<T, E, T2>(
+    result: Result<T, E>,
+    mapper: (value: T) => T2,
+): Result<T2, E>;
+export function mapError<T, E, E2>(
+    result: Result<T, E>,
+    mapper: (error: E) => E2,
+): Result<T, E2>;

package/result.js

@@ -4,18 +4,12 @@ exports.__esModule = true;
 exports.andThen = andThen;
 exports.dispatch = dispatch;
 exports.err = err;
-exports.errValue = errValue;
 exports.expect = expect;
-exports.isErr = isErr;
-exports.isOk = isOk;
-exports.map = map;
 exports.mapError = mapError;
+exports.mapOk = mapOk;
 exports.ok = ok;
 exports.orElse = orElse;
-exports.toString = toString;
 exports.unwrap = unwrap;
-exports.value = value;
-exports.withDefault = withDefault;
 
 /**
  * Result <value> <error>
@@ -29,7 +23,8 @@ exports.withDefault = withDefault;
 function ok(value) {
   return {
     type: 'ok',
-    value: value
+    value: value,
+    error: undefined
   };
 }
 /**
@@ -40,33 +35,10 @@ function ok(value) {
 function err(error) {
   return {
     type: 'err',
+    value: undefined,
     error: error
   };
 }
-
-function toString(result) {
-  return result.type === 'ok' ? "Ok(" + String(result.value) + ")" : "Err(" + String(result.error) + ")";
-}
-
-function isOk(result) {
-  return result.type === 'ok';
-}
-
-function isErr(result) {
-  return result.type === 'err';
-}
-
-function withDefault(result, defaultValue) {
-  return result.type === 'ok' ? result.value : defaultValue;
-}
-
-function value(result) {
-  return result.type === 'ok' ? result.value : undefined;
-}
-
-function errValue(result) {
-  return result.type === 'err' ? result.error : undefined;
-}
 /**
  * Unwrap the value from this Result instance if this is an "Ok" result.
  * Otherwise, will throw the "Err" error via a runtime exception.
@@ -92,48 +64,6 @@ function expect(result, message) {
 function dispatch(result, okCallback, errCallback) {
   return result.type === 'ok' ? okCallback(result.value) : errCallback(result.error);
 }
-/**
- * If the given result is OK, defers to the other result. Otherwise returns the
- * error result.
- *
- * It's like saying A && B, but on Result.
- *
- * Examples:
- *
- *     Result.ok(42)     && Result.ok('hi')    // => Ok('hi')
- *     Result.err('boo') && Result.ok('hi')    // => Err('boo')
- *     Result.ok(42)     && Result.err('boo')  // => Err('boo')
- *     Result.err('boo') && Result.err('boo')  // => Err('boo')
- *
- */
-// export function and<T, E, T2>(
-//     result1: Result<T, E>,
-//     result2: Result<T2, E>,
-// ): Result<T2, E> {
-//     return result1.type === 'ok' ? result2 : result1;
-// }
-
-/**
- * If the given result is OK, return that result. Otherwise, defers to the
- * other result.
- *
- * It's like saying A || B, but on Result.
- *
- * Examples:
- *
- *     Result.ok(42)      || Result.ok('hi')    // => Ok(42)
- *     Result.err('boo')  || Result.ok('hi')    // => Ok('hi')
- *     Result.ok(42)      || Result.err('boo')  // => Ok(42)
- *     Result.err('bleh') || Result.err('boo')  // => Err('boo')
- *
- */
-// export function or<T, E, E2>(
-//     result1: Result<T, E>,
-//     result2: Result<T, E2>,
-// ): Result<T, E2> {
-//     return result1.type === 'ok' ? result1 : result2;
-// }
-
 /**
  * Like .and(), aka &&, but the second argument gets evaluated lazily only if
  * the first result is an Ok result. If so, it has access to the Ok value from
@@ -159,7 +89,7 @@ function orElse(result1, lazyResult2) {
  */
 
 
-function map(result, mapper) {
+function mapOk(result, mapper) {
   return result.type === 'ok' ? ok(mapper(result.value)) : result;
 }
 /**