return-style - npm Package Compare versions

Comparing version 0.12.6 to 1.0.0

dist/es2015/index.umd.js

 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@blackglory/pass'), require('@blackglory/go')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@blackglory/pass', '@blackglory/go'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReturnStyle = {}, global.pass, global.go));
-})(this, (function (exports, pass, go) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@blackglory/prelude')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@blackglory/prelude'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReturnStyle = {}, global.prelude));
+})(this, (function (exports, prelude) { 'use strict';
 
@@ -62,15 +62,2 @@ function getErrorResult(fn) {
 
-    function __classPrivateFieldGet(receiver, state, kind, f) {
-        if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-        return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-    }
-
-    function __classPrivateFieldSet(receiver, state, value, kind, f) {
-        if (kind === "m") throw new TypeError("Private method is not writable");
-        if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-        return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-    }
-
     function getErrorResultAsync(fn) {
@@ -343,3 +330,3 @@ return __awaiter(this, void 0, void 0, function* () {
                         const _ = iterable_1_1.value;
-                        pass.pass();
+                        prelude.pass();
                     }
@@ -362,411 +349,324 @@ }
 
-    var _Ok_value, _Err_value;
-    class Result {
-        static Ok(value) {
-            return Ok.of(value);
+    var OptionType;
+    (function (OptionType) {
+        OptionType[OptionType["Some"] = 0] = "Some";
+        OptionType[OptionType["None"] = 1] = "None";
+    })(OptionType || (OptionType = {}));
+    class Option {
+        constructor(type, value) {
+            this.type = type;
+            this.value = value;
         }
-        static Err(error) {
-            return Err.of(error);
+        static Some(value) {
+            return new Option(OptionType.Some, value);
         }
-    }
-    class Ok extends Result {
-        constructor(value) {
-            super();
-            _Ok_value.set(this, void 0);
-            __classPrivateFieldSet(this, _Ok_value, value, "f");
+        static None() {
+            return new Option(OptionType.None);
         }
-        static of(value) {
-            return new Ok(value);
+        isSome() {
+            return this.type === OptionType.Some;
         }
-        isOk() {
-            return true;
+        isNone() {
+            return this.type === OptionType.None;
         }
-        isErr() {
-            return false;
+        map(mapper) {
+            if (this.isSome()) {
+                return Option.Some(mapper(this.value));
+            }
+            else {
+                return Option.None();
+            }
         }
-        onOk(callback) {
-            callback(__classPrivateFieldGet(this, _Ok_value, "f"));
-            return Ok.of(__classPrivateFieldGet(this, _Ok_value, "f"));
+        mapOr(defaultValue, mapper) {
+            if (this.isSome()) {
+                return Option.Some(mapper(this.value));
+            }
+            else {
+                return Option.Some(defaultValue);
+            }
         }
-        onErr() {
-            return Ok.of(__classPrivateFieldGet(this, _Ok_value, "f"));
+        mapOrElse(createDefaultValue, mapper) {
+            if (this.isSome()) {
+                return Option.Some(mapper(this.value));
+            }
+            else {
+                return Option.Some(createDefaultValue());
+            }
         }
-        orElse() {
-            return Ok.of(__classPrivateFieldGet(this, _Ok_value, "f"));
+        filter(predicate) {
+            if (this.isSome()) {
+                if (predicate(this.value)) {
+                    return Option.Some(this.value);
+                }
+                else {
+                    return Option.None();
+                }
+            }
+            else {
+                return Option.None();
+            }
         }
-        map(fn) {
-            return Ok.of(fn(__classPrivateFieldGet(this, _Ok_value, "f")));
+        /**
+         * @throws {Error}
+         */
+        unwrap() {
+            if (this.isSome()) {
+                return this.value;
+            }
+            else {
+                throw new Error('unwrap called on a None');
+            }
         }
-        get() {
-            return __classPrivateFieldGet(this, _Ok_value, "f");
+        unwrapOr(defaultValue) {
+            if (this.isSome()) {
+                return this.value;
+            }
+            else {
+                return defaultValue;
+            }
         }
-    }
-    _Ok_value = new WeakMap();
-    class Err extends Result {
-        constructor(err) {
-            super();
-            _Err_value.set(this, void 0);
-            __classPrivateFieldSet(this, _Err_value, err, "f");
+        unwrapOrElse(createDefaultValue) {
+            if (this.isSome()) {
+                return this.value;
+            }
+            else {
+                return createDefaultValue();
+            }
         }
-        static of(error) {
-            return new Err(error);
+        /**
+         * @throws {Error}
+         */
+        expect(message) {
+            if (this.isSome()) {
+                return this.value;
+            }
+            else {
+                throw new Error(message);
+            }
         }
-        isOk() {
-            return false;
+        okOr(err) {
+            if (this.isSome()) {
+                return Result.Ok(this.value);
+            }
+            else {
+                return Result.Err(err);
+            }
         }
-        isErr() {
-            return true;
+        okOrElse(createErr) {
+            if (this.isSome()) {
+                return Result.Ok(this.value);
+            }
+            else {
+                return Result.Err(createErr());
+            }
         }
-        onOk() {
-            return Err.of(__classPrivateFieldGet(this, _Err_value, "f"));
-        }
-        onErr(callback) {
-            callback(__classPrivateFieldGet(this, _Err_value, "f"));
-            return Err.of(__classPrivateFieldGet(this, _Err_value, "f"));
-        }
-        orElse(defaultValue) {
-            return Ok.of(defaultValue);
-        }
-        map() {
-            return Err.of(__classPrivateFieldGet(this, _Err_value, "f"));
-        }
-        get() {
-            throw __classPrivateFieldGet(this, _Err_value, "f");
-        }
     }
-    _Err_value = new WeakMap();
 
-    function toResult(fn) {
-        try {
-            const result = fn();
-            return Result.Ok(result);
+    var ResultType;
+    (function (ResultType) {
+        ResultType[ResultType["Ok"] = 0] = "Ok";
+        ResultType[ResultType["Err"] = 1] = "Err";
+    })(ResultType || (ResultType = {}));
+    class Result {
+        constructor(type, valueOrError) {
+            this.type = type;
+            if (type === ResultType.Ok) {
+                this.value = valueOrError;
+            }
+            else {
+                this.error = valueOrError;
+            }
         }
-        catch (e) {
-            return Result.Err(e);
-        }
-    }
-
-    var _AsyncResult_promise;
-    class AsyncResult {
-        constructor(promise) {
-            _AsyncResult_promise.set(this, void 0);
-            __classPrivateFieldSet(this, _AsyncResult_promise, Promise.resolve(promise), "f");
-        }
         static Ok(value) {
-            return AsyncOk.of(value);
+            return new Result(ResultType.Ok, value);
         }
         static Err(error) {
-            return AsyncErr.of(error);
+            return new Result(ResultType.Err, error);
         }
-        get then() {
-            const promise = __classPrivateFieldGet(this, _AsyncResult_promise, "f").then(x => Result.Ok(x), x => Result.Err(x));
-            return promise.then.bind(promise);
-        }
-        onOk(callback) {
-            go.go(() => __awaiter(this, void 0, void 0, function* () {
-                const [succ, ret] = yield getSuccessPromise(__classPrivateFieldGet(this, _AsyncResult_promise, "f"));
-                if (succ)
-                    callback(ret);
-            }));
-            return new AsyncResult(__classPrivateFieldGet(this, _AsyncResult_promise, "f"));
-        }
-        onErr(callback) {
-            go.go(() => __awaiter(this, void 0, void 0, function* () {
-                const [fail, err] = yield getFailurePromise(__classPrivateFieldGet(this, _AsyncResult_promise, "f"));
-                if (fail)
-                    callback(err);
-            }));
-            return new AsyncResult(__classPrivateFieldGet(this, _AsyncResult_promise, "f"));
-        }
         isOk() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return yield isSuccessPromise(__classPrivateFieldGet(this, _AsyncResult_promise, "f"));
-            });
+            return this.type === ResultType.Ok;
         }
         isErr() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return yield isFailurePromise(__classPrivateFieldGet(this, _AsyncResult_promise, "f"));
-            });
+            return this.type === ResultType.Err;
         }
-        orElse(defaultValue) {
-            const promise = go.go(() => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    return yield __classPrivateFieldGet(this, _AsyncResult_promise, "f");
-                }
-                catch (_a) {
-                    return defaultValue;
-                }
-            }));
-            return new AsyncResult(promise);
-        }
         map(mapper) {
-            const promise = go.go(() => __awaiter(this, void 0, void 0, function* () {
-                const result = yield __classPrivateFieldGet(this, _AsyncResult_promise, "f");
-                return mapper(result);
-            }));
-            return new AsyncResult(promise);
+            if (this.isOk()) {
+                return Result.Ok(mapper(this.value));
+            }
+            else {
+                return Result.Err(this.error);
+            }
         }
-        get() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return yield __classPrivateFieldGet(this, _AsyncResult_promise, "f");
-            });
+        mapOr(defaultValue, mapper) {
+            if (this.isOk()) {
+                return Result.Ok(mapper(this.value));
+            }
+            else {
+                return Result.Ok(defaultValue);
+            }
         }
-    }
-    _AsyncResult_promise = new WeakMap();
-    class AsyncOk extends AsyncResult {
-        static of(value) {
-            return new AsyncOk(value);
+        mapOrElse(createDefaultValue, mapper) {
+            if (this.isOk()) {
+                return Result.Ok(mapper(this.value));
+            }
+            else {
+                return Result.Ok(createDefaultValue(this.error));
+            }
         }
-        constructor(value) {
-            super(Promise.resolve(value));
+        mapErr(mapper) {
+            if (this.isOk()) {
+                return Result.Ok(this.value);
+            }
+            else {
+                return Result.Err(mapper(this.error));
+            }
         }
-    }
-    class AsyncErr extends AsyncResult {
-        static of(value) {
-            return new AsyncErr(value);
+        /**
+         * @throws {E}
+         */
+        unwrap() {
+            if (this.isOk()) {
+                return this.value;
+            }
+            else {
+                throw this.error;
+            }
         }
-        constructor(err) {
-            super(Promise.reject(err));
+        unwrapOr(defaultValue) {
+            if (this.isOk()) {
+                return this.value;
+            }
+            else {
+                return defaultValue;
+            }
         }
-    }
-
-    function toResultAsync(fn) {
-        try {
-            const result = fn();
-            return new AsyncResult(result);
+        unwrapOrElse(createDefaultValue) {
+            if (this.isOk()) {
+                return this.value;
+            }
+            else {
+                return createDefaultValue(this.error);
+            }
         }
-        catch (e) {
-            return AsyncResult.Err(e);
+        /**
+         * @throws {Error}
+         */
+        unwrapErr() {
+            if (this.isErr()) {
+                return this.error;
+            }
+            else {
+                throw new Error('unwrapErr called on a Ok');
+            }
         }
-    }
-
-    function toResultPromise(promise) {
-        return new AsyncResult(promise);
-    }
-
-    var _Some_value;
-    class Optional {
-        static Some(value) {
-            return Some.of(value);
+        /**
+         * @throws {Error}
+         */
+        expect(message) {
+            if (this.isOk()) {
+                return this.value;
+            }
+            else {
+                throw new Error(message);
+            }
         }
-        static None() {
-            return None.of();
+        /**
+         * @throws {Error}
+         */
+        expectErr(message) {
+            if (this.isErr()) {
+                return this.error;
+            }
+            else {
+                throw new Error(message);
+            }
         }
-    }
-    class Some extends Optional {
-        constructor(value) {
-            super();
-            _Some_value.set(this, void 0);
-            __classPrivateFieldSet(this, _Some_value, value, "f");
+        ok() {
+            if (this.isOk()) {
+                return Option.Some(this.value);
+            }
+            else {
+                return Option.None();
+            }
         }
-        static of(value) {
-            return new Some(value);
-        }
-        isSome() {
-            return true;
-        }
-        isNone() {
-            return false;
-        }
-        onSome(callback) {
-            callback(__classPrivateFieldGet(this, _Some_value, "f"));
-            return Some.of(__classPrivateFieldGet(this, _Some_value, "f"));
-        }
-        onNone() {
-            return Some.of(__classPrivateFieldGet(this, _Some_value, "f"));
-        }
-        orElse() {
-            return Some.of(__classPrivateFieldGet(this, _Some_value, "f"));
-        }
-        map(mapper) {
-            return Some.of(mapper(__classPrivateFieldGet(this, _Some_value, "f")));
-        }
-        filter(predicate) {
-            if (predicate(__classPrivateFieldGet(this, _Some_value, "f"))) {
-                return Some.of(__classPrivateFieldGet(this, _Some_value, "f"));
+        err() {
+            if (this.isOk()) {
+                return Option.None();
             }
             else {
-                return None.of();
+                return Option.Some(this.error);
             }
         }
-        get() {
-            return __classPrivateFieldGet(this, _Some_value, "f");
-        }
     }
-    _Some_value = new WeakMap();
-    class None extends Optional {
-        static of() {
-            return new None();
+
+    function toResult(fn) {
+        try {
+            const result = fn();
+            return Result.Ok(result);
         }
-        constructor() {
-            super();
+        catch (e) {
+            return Result.Err(e);
         }
-        isSome() {
-            return false;
-        }
-        isNone() {
-            return true;
-        }
-        onSome() {
-            return None.of();
-        }
-        onNone(callback) {
-            callback();
-            return None.of();
-        }
-        orElse(defaultValue) {
-            return Some.of(defaultValue);
-        }
-        map() {
-            return None.of();
-        }
-        filter() {
-            return None.of();
-        }
-        get() {
-            throw new Error('Cannot get value from None');
-        }
     }
 
-    function toOptionalPartial(isNone) {
-        return (fn) => toOptional(fn, isNone);
+    function toResultAsync(fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield fn();
+                return Result.Ok(result);
+            }
+            catch (err) {
+                return Result.Err(err);
+            }
+        });
     }
-    function toOptional(fn, isNone) {
-        const result = fn();
-        if (isNone(result)) {
-            return Optional.None();
-        }
-        else {
-            return Optional.Some(result);
-        }
+
+    function toResultPromise(promise) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield promise;
+                return Result.Ok(result);
+            }
+            catch (err) {
+                return Result.Err(err);
+            }
+        });
     }
 
-    var _AsyncOptional_promise;
-    const Nil = Symbol();
-    class AsyncOptional {
-        constructor(promise) {
-            _AsyncOptional_promise.set(this, void 0);
-            __classPrivateFieldSet(this, _AsyncOptional_promise, Promise.resolve(promise), "f");
+    function toOption(fn) {
+        try {
+            const result = fn();
+            return Option.Some(result);
         }
-        static Some(value) {
-            return AsyncSome.of(value);
+        catch (_a) {
+            return Option.None();
         }
-        static None() {
-            return AsyncNone.of();
-        }
-        get then() {
-            const promise = __classPrivateFieldGet(this, _AsyncOptional_promise, "f").then(x => x === Nil
-                ? Optional.None()
-                : Optional.Some(x));
-            return promise.then.bind(promise);
-        }
-        onSome(callback) {
-            go.go(() => __awaiter(this, void 0, void 0, function* () {
-                const result = yield __classPrivateFieldGet(this, _AsyncOptional_promise, "f");
-                if (result !== Nil)
-                    callback(result);
-            }));
-            return new AsyncOptional(__classPrivateFieldGet(this, _AsyncOptional_promise, "f"));
-        }
-        onNone(callback) {
-            go.go(() => __awaiter(this, void 0, void 0, function* () {
-                const result = yield __classPrivateFieldGet(this, _AsyncOptional_promise, "f");
-                if (result === Nil)
-                    callback();
-            }));
-            return new AsyncOptional(__classPrivateFieldGet(this, _AsyncOptional_promise, "f"));
-        }
-        isSome() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const result = yield __classPrivateFieldGet(this, _AsyncOptional_promise, "f");
-                return result !== Nil;
-            });
-        }
-        isNone() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const result = yield __classPrivateFieldGet(this, _AsyncOptional_promise, "f");
-                return result === Nil;
-            });
-        }
-        orElse(defaultValue) {
-            const promise = go.go(() => __awaiter(this, void 0, void 0, function* () {
-                const result = yield __classPrivateFieldGet(this, _AsyncOptional_promise, "f");
-                if (result === Nil)
-                    return defaultValue;
-                return result;
-            }));
-            return new AsyncOptional(promise);
-        }
-        map(mapper) {
-            const promise = go.go(() => __awaiter(this, void 0, void 0, function* () {
-                const result = yield __classPrivateFieldGet(this, _AsyncOptional_promise, "f");
-                if (result === Nil)
-                    return Nil;
-                return mapper(result);
-            }));
-            return new AsyncOptional(promise);
-        }
-        filter(predicate) {
-            const promise = go.go(() => __awaiter(this, void 0, void 0, function* () {
-                const result = yield __classPrivateFieldGet(this, _AsyncOptional_promise, "f");
-                if (result === Nil)
-                    return Nil;
-                if (predicate(result))
-                    return result;
-                return Nil;
-            }));
-            return new AsyncOptional(promise);
-        }
-        get() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const result = yield __classPrivateFieldGet(this, _AsyncOptional_promise, "f");
-                if (result === Nil)
-                    throw new Error('Cannot get value from None');
-                return result;
-            });
-        }
     }
-    _AsyncOptional_promise = new WeakMap();
-    class AsyncNone extends AsyncOptional {
-        static of() {
-            return new AsyncNone();
-        }
-        constructor() {
-            super(Promise.resolve(Nil));
-        }
-    }
-    class AsyncSome extends AsyncOptional {
-        static of(value) {
-            return new AsyncSome(value);
-        }
-        constructor(value) {
-            super(Promise.resolve(value));
-        }
-    }
 
-    function toOptionalAsyncPartial(isNone) {
-        return (fn) => toOptionalAsync(fn, isNone);
+    function toOptionAsync(fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield fn();
+                return Option.Some(result);
+            }
+            catch (_a) {
+                return Option.None();
+            }
+        });
     }
-    function toOptionalAsync(fn, isNone) {
-        const promise = go.go(() => __awaiter(this, void 0, void 0, function* () {
-            const result = yield fn();
-            if (isNone(result))
-                return Nil;
-            return result;
-        }));
-        return new AsyncOptional(promise);
-    }
 
-    function toOptionalPromisePartial(isNone) {
-        return (promise) => toOptionalPromise(promise, isNone);
+    function toOptionPromise(promise) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield promise;
+                return Option.Some(result);
+            }
+            catch (_a) {
+                return Option.None();
+            }
+        });
     }
-    function toOptionalPromise(promise, isNone) {
-        return new AsyncOptional(go.go(() => __awaiter(this, void 0, void 0, function* () {
-            const result = yield promise;
-            if (isNone(result))
-                return Nil;
-            return result;
-        })));
-    }
 
+    exports.Option = Option;
+    exports.Result = Result;
     exports.getError = getError;
@@ -797,8 +697,5 @@ exports.getErrorAsync = getErrorAsync;
     exports.isSuccessPromise = isSuccessPromise;
-    exports.toOptional = toOptional;
-    exports.toOptionalAsync = toOptionalAsync;
-    exports.toOptionalAsyncPartial = toOptionalAsyncPartial;
-    exports.toOptionalPartial = toOptionalPartial;
-    exports.toOptionalPromise = toOptionalPromise;
-    exports.toOptionalPromisePartial = toOptionalPromisePartial;
+    exports.toOption = toOption;
+    exports.toOptionAsync = toOptionAsync;
+    exports.toOptionPromise = toOptionPromise;
     exports.toResult = toResult;
@@ -805,0 +702,0 @@ exports.toResultAsync = toResultAsync;

dist/es2015/index.umd.min.js

@@ -1,2 +0,2 @@
-!function(t,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("@blackglory/pass"),require("@blackglory/go")):"function"==typeof define&&define.amd?define(["exports","@blackglory/pass","@blackglory/go"],r):r((t="undefined"!=typeof globalThis?globalThis:t||self).ReturnStyle={},t.pass,t.go)}(this,(function(t,r,n){"use strict";
+!function(r,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("@blackglory/prelude")):"function"==typeof define&&define.amd?define(["exports","@blackglory/prelude"],t):t((r="undefined"!=typeof globalThis?globalThis:r||self).ReturnStyle={},r.prelude)}(this,(function(r,t){"use strict";
 /*! *****************************************************************************
@@ -16,3 +16,3 @@ Copyright (c) Microsoft Corporation.
     ***************************************************************************** */
-function e(t,r,n,e){return new(n||(n=Promise))((function(o,i){function u(t){try{c(e.next(t))}catch(t){i(t)}}function s(t){try{c(e.throw(t))}catch(t){i(t)}}function c(t){var r;t.done?o(t.value):(r=t.value,r instanceof n?r:new n((function(t){t(r)}))).then(u,s)}c((e=e.apply(t,r||[])).next())}))}function o(t){var r="function"==typeof Symbol&&Symbol.iterator,n=r&&t[r],e=0;if(n)return n.call(t);if(t&&"number"==typeof t.length)return{next:function(){return t&&e>=t.length&&(t=void 0),{value:t&&t[e++],done:!t}}};throw new TypeError(r?"Object is not iterable.":"Symbol.iterator is not defined.")}function i(t){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var r,n=t[Symbol.asyncIterator];return n?n.call(t):(t=o(t),r={},e("next"),e("throw"),e("return"),r[Symbol.asyncIterator]=function(){return this},r);function e(n){r[n]=t[n]&&function(r){return new Promise((function(e,o){(function(t,r,n,e){Promise.resolve(e).then((function(r){t({value:r,done:n})}),r)})(e,o,(r=t[n](r)).done,r.value)}))}}}function u(t,r,n,e){if("a"===n&&!e)throw new TypeError("Private accessor was defined without a getter");if("function"==typeof r?t!==r||!e:!r.has(t))throw new TypeError("Cannot read private member from an object whose class did not declare it");return"m"===n?e:"a"===n?e.call(t):e?e.value:r.get(t)}function s(t,r,n,e,o){if("m"===e)throw new TypeError("Private method is not writable");if("a"===e&&!o)throw new TypeError("Private accessor was defined without a setter");if("function"==typeof r?t!==r||!o:!r.has(t))throw new TypeError("Cannot write private member to an object whose class did not declare it");return"a"===e?o.call(t,n):o?o.value=n:r.set(t,n),n}function c(t){return e(this,void 0,void 0,(function*(){try{return[!0,yield t]}catch(t){return[!1,void 0]}}))}function f(t){return e(this,void 0,void 0,(function*(){try{return yield t,[!1,void 0]}catch(t){return[!0,t]}}))}function a(t){return e(this,void 0,void 0,(function*(){try{return yield t,!0}catch(t){return!1}}))}function d(t){return e(this,void 0,void 0,(function*(){try{return yield t,!1}catch(t){return!0}}))}var h,l,v,y,w;class m{static Ok(t){return g.of(t)}static Err(t){return p.of(t)}}class g extends m{constructor(t){super(),h.set(this,void 0),s(this,h,t,"f")}static of(t){return new g(t)}isOk(){return!0}isErr(){return!1}onOk(t){return t(u(this,h,"f")),g.of(u(this,h,"f"))}onErr(){return g.of(u(this,h,"f"))}orElse(){return g.of(u(this,h,"f"))}map(t){return g.of(t(u(this,h,"f")))}get(){return u(this,h,"f")}}h=new WeakMap;class p extends m{constructor(t){super(),l.set(this,void 0),s(this,l,t,"f")}static of(t){return new p(t)}isOk(){return!1}isErr(){return!0}onOk(){return p.of(u(this,l,"f"))}onErr(t){return t(u(this,l,"f")),p.of(u(this,l,"f"))}orElse(t){return g.of(t)}map(){return p.of(u(this,l,"f"))}get(){throw u(this,l,"f")}}l=new WeakMap;class E{constructor(t){v.set(this,void 0),s(this,v,Promise.resolve(t),"f")}static Ok(t){return b.of(t)}static Err(t){return P.of(t)}get then(){const t=u(this,v,"f").then((t=>m.Ok(t)),(t=>m.Err(t)));return t.then.bind(t)}onOk(t){return n.go((()=>e(this,void 0,void 0,(function*(){const[r,n]=yield c(u(this,v,"f"));r&&t(n)})))),new E(u(this,v,"f"))}onErr(t){return n.go((()=>e(this,void 0,void 0,(function*(){const[r,n]=yield f(u(this,v,"f"));r&&t(n)})))),new E(u(this,v,"f"))}isOk(){return e(this,void 0,void 0,(function*(){return yield a(u(this,v,"f"))}))}isErr(){return e(this,void 0,void 0,(function*(){return yield d(u(this,v,"f"))}))}orElse(t){const r=n.go((()=>e(this,void 0,void 0,(function*(){try{return yield u(this,v,"f")}catch(r){return t}}))));return new E(r)}map(t){const r=n.go((()=>e(this,void 0,void 0,(function*(){const r=yield u(this,v,"f");return t(r)}))));return new E(r)}get(){return e(this,void 0,void 0,(function*(){return yield u(this,v,"f")}))}}v=new WeakMap;class b extends E{static of(t){return new b(t)}constructor(t){super(Promise.resolve(t))}}class P extends E{static of(t){return new P(t)}constructor(t){super(Promise.reject(t))}}class S{static Some(t){return k.of(t)}static None(){return O.of()}}class k extends S{constructor(t){super(),y.set(this,void 0),s(this,y,t,"f")}static of(t){return new k(t)}isSome(){return!0}isNone(){return!1}onSome(t){return t(u(this,y,"f")),k.of(u(this,y,"f"))}onNone(){return k.of(u(this,y,"f"))}orElse(){return k.of(u(this,y,"f"))}map(t){return k.of(t(u(this,y,"f")))}filter(t){return t(u(this,y,"f"))?k.of(u(this,y,"f")):O.of()}get(){return u(this,y,"f")}}y=new WeakMap;class O extends S{static of(){return new O}constructor(){super()}isSome(){return!1}isNone(){return!0}onSome(){return O.of()}onNone(t){return t(),O.of()}orElse(t){return k.of(t)}map(){return O.of()}filter(){return O.of()}get(){throw new Error("Cannot get value from None")}}function x(t,r){const n=t();return r(n)?S.None():S.Some(n)}const R=Symbol();class A{constructor(t){w.set(this,void 0),s(this,w,Promise.resolve(t),"f")}static Some(t){return T.of(t)}static None(){return N.of()}get then(){const t=u(this,w,"f").then((t=>t===R?S.None():S.Some(t)));return t.then.bind(t)}onSome(t){return n.go((()=>e(this,void 0,void 0,(function*(){const r=yield u(this,w,"f");r!==R&&t(r)})))),new A(u(this,w,"f"))}onNone(t){return n.go((()=>e(this,void 0,void 0,(function*(){(yield u(this,w,"f"))===R&&t()})))),new A(u(this,w,"f"))}isSome(){return e(this,void 0,void 0,(function*(){return(yield u(this,w,"f"))!==R}))}isNone(){return e(this,void 0,void 0,(function*(){return(yield u(this,w,"f"))===R}))}orElse(t){const r=n.go((()=>e(this,void 0,void 0,(function*(){const r=yield u(this,w,"f");return r===R?t:r}))));return new A(r)}map(t){const r=n.go((()=>e(this,void 0,void 0,(function*(){const r=yield u(this,w,"f");return r===R?R:t(r)}))));return new A(r)}filter(t){const r=n.go((()=>e(this,void 0,void 0,(function*(){const r=yield u(this,w,"f");return r===R?R:t(r)?r:R}))));return new A(r)}get(){return e(this,void 0,void 0,(function*(){const t=yield u(this,w,"f");if(t===R)throw new Error("Cannot get value from None");return t}))}}w=new WeakMap;class N extends A{static of(){return new N}constructor(){super(Promise.resolve(R))}}class T extends A{static of(t){return new T(t)}constructor(t){super(Promise.resolve(t))}}function j(t,r){const o=n.go((()=>e(this,void 0,void 0,(function*(){const n=yield t();return r(n)?R:n}))));return new A(o)}function F(t,r){return new A(n.go((()=>e(this,void 0,void 0,(function*(){const n=yield t;return r(n)?R:n})))))}t.getError=function(t){try{t()}catch(t){return t}},t.getErrorAsync=function(t){return e(this,void 0,void 0,(function*(){try{yield t()}catch(t){return t}}))},t.getErrorAsyncIterable=function(t){var n,o,u,s;return e(this,void 0,void 0,(function*(){try{try{for(n=i(t);!(o=yield n.next()).done;){o.value;r.pass()}}catch(t){u={error:t}}finally{try{o&&!o.done&&(s=n.return)&&(yield s.call(n))}finally{if(u)throw u.error}}}catch(t){return t}}))},t.getErrorPromise=function(t){return e(this,void 0,void 0,(function*(){try{yield t}catch(t){return t}}))},t.getErrorResult=function(t){try{return[void 0,t()]}catch(t){return[t,void 0]}},t.getErrorResultAsync=function(t){return e(this,void 0,void 0,(function*(){try{return[void 0,yield t()]}catch(t){return[t,void 0]}}))},t.getErrorResultPromise=function(t){return e(this,void 0,void 0,(function*(){try{return[void 0,yield t]}catch(t){return[t,void 0]}}))},t.getFailure=function(t){try{return t(),[!1,void 0]}catch(t){return[!0,t]}},t.getFailureAsync=function(t){return e(this,void 0,void 0,(function*(){try{return yield t(),[!1,void 0]}catch(t){return[!0,t]}}))},t.getFailurePromise=f,t.getResult=function(t){try{return t()}catch(t){return}},t.getResultAsync=function(t){return e(this,void 0,void 0,(function*(){try{return yield t()}catch(t){return}}))},t.getResultError=function(t){try{return[t(),void 0]}catch(t){return[void 0,t]}},t.getResultErrorAsync=function(t){return e(this,void 0,void 0,(function*(){try{return[yield t(),void 0]}catch(t){return[void 0,t]}}))},t.getResultErrorPromise=function(t){return e(this,void 0,void 0,(function*(){try{return[yield t,void 0]}catch(t){return[void 0,t]}}))},t.getResultPromise=function(t){return e(this,void 0,void 0,(function*(){try{return yield t}catch(t){return}}))},t.getSuccess=function(t){try{return[!0,t()]}catch(t){return[!1,void 0]}},t.getSuccessAsync=function(t){return e(this,void 0,void 0,(function*(){try{return[!0,yield t()]}catch(t){return[!1,void 0]}}))},t.getSuccessPromise=c,t.isFailure=function(t){try{return t(),!1}catch(t){return!0}},t.isFailureAsync=function(t){return e(this,void 0,void 0,(function*(){try{return yield t(),!1}catch(t){return!0}}))},t.isFailurePromise=d,t.isSuccess=function(t){try{return t(),!0}catch(t){return!1}},t.isSuccessAsync=function(t){return e(this,void 0,void 0,(function*(){try{return yield t(),!0}catch(t){return!1}}))},t.isSuccessPromise=a,t.toOptional=x,t.toOptionalAsync=j,t.toOptionalAsyncPartial=function(t){return r=>j(r,t)},t.toOptionalPartial=function(t){return r=>x(r,t)},t.toOptionalPromise=F,t.toOptionalPromisePartial=function(t){return r=>F(r,t)},t.toResult=function(t){try{const r=t();return m.Ok(r)}catch(t){return m.Err(t)}},t.toResultAsync=function(t){try{const r=t();return new E(r)}catch(t){return E.Err(t)}},t.toResultPromise=function(t){return new E(t)},Object.defineProperty(t,"__esModule",{value:!0})}));
+function e(r,t,e,n){return new(e||(e=Promise))((function(i,o){function u(r){try{c(n.next(r))}catch(r){o(r)}}function s(r){try{c(n.throw(r))}catch(r){o(r)}}function c(r){var t;r.done?i(r.value):(t=r.value,t instanceof e?t:new e((function(r){r(t)}))).then(u,s)}c((n=n.apply(r,t||[])).next())}))}function n(r){var t="function"==typeof Symbol&&Symbol.iterator,e=t&&r[t],n=0;if(e)return e.call(r);if(r&&"number"==typeof r.length)return{next:function(){return r&&n>=r.length&&(r=void 0),{value:r&&r[n++],done:!r}}};throw new TypeError(t?"Object is not iterable.":"Symbol.iterator is not defined.")}function i(r){if(!Symbol.asyncIterator)throw new TypeError("Symbol.asyncIterator is not defined.");var t,e=r[Symbol.asyncIterator];return e?e.call(r):(r=n(r),t={},i("next"),i("throw"),i("return"),t[Symbol.asyncIterator]=function(){return this},t);function i(e){t[e]=r[e]&&function(t){return new Promise((function(n,i){(function(r,t,e,n){Promise.resolve(n).then((function(t){r({value:t,done:e})}),t)})(n,i,(t=r[e](t)).done,t.value)}))}}}var o,u;!function(r){r[r.Some=0]="Some",r[r.None=1]="None"}(o||(o={}));class s{constructor(r,t){this.type=r,this.value=t}static Some(r){return new s(o.Some,r)}static None(){return new s(o.None)}isSome(){return this.type===o.Some}isNone(){return this.type===o.None}map(r){return this.isSome()?s.Some(r(this.value)):s.None()}mapOr(r,t){return this.isSome()?s.Some(t(this.value)):s.Some(r)}mapOrElse(r,t){return this.isSome()?s.Some(t(this.value)):s.Some(r())}filter(r){return this.isSome()&&r(this.value)?s.Some(this.value):s.None()}unwrap(){if(this.isSome())return this.value;throw new Error("unwrap called on a None")}unwrapOr(r){return this.isSome()?this.value:r}unwrapOrElse(r){return this.isSome()?this.value:r()}expect(r){if(this.isSome())return this.value;throw new Error(r)}okOr(r){return this.isSome()?c.Ok(this.value):c.Err(r)}okOrElse(r){return this.isSome()?c.Ok(this.value):c.Err(r())}}!function(r){r[r.Ok=0]="Ok",r[r.Err=1]="Err"}(u||(u={}));class c{constructor(r,t){this.type=r,r===u.Ok?this.value=t:this.error=t}static Ok(r){return new c(u.Ok,r)}static Err(r){return new c(u.Err,r)}isOk(){return this.type===u.Ok}isErr(){return this.type===u.Err}map(r){return this.isOk()?c.Ok(r(this.value)):c.Err(this.error)}mapOr(r,t){return this.isOk()?c.Ok(t(this.value)):c.Ok(r)}mapOrElse(r,t){return this.isOk()?c.Ok(t(this.value)):c.Ok(r(this.error))}mapErr(r){return this.isOk()?c.Ok(this.value):c.Err(r(this.error))}unwrap(){if(this.isOk())return this.value;throw this.error}unwrapOr(r){return this.isOk()?this.value:r}unwrapOrElse(r){return this.isOk()?this.value:r(this.error)}unwrapErr(){if(this.isErr())return this.error;throw new Error("unwrapErr called on a Ok")}expect(r){if(this.isOk())return this.value;throw new Error(r)}expectErr(r){if(this.isErr())return this.error;throw new Error(r)}ok(){return this.isOk()?s.Some(this.value):s.None()}err(){return this.isOk()?s.None():s.Some(this.error)}}r.Option=s,r.Result=c,r.getError=function(r){try{r()}catch(r){return r}},r.getErrorAsync=function(r){return e(this,void 0,void 0,(function*(){try{yield r()}catch(r){return r}}))},r.getErrorAsyncIterable=function(r){var n,o,u,s;return e(this,void 0,void 0,(function*(){try{try{for(n=i(r);!(o=yield n.next()).done;){o.value;t.pass()}}catch(r){u={error:r}}finally{try{o&&!o.done&&(s=n.return)&&(yield s.call(n))}finally{if(u)throw u.error}}}catch(r){return r}}))},r.getErrorPromise=function(r){return e(this,void 0,void 0,(function*(){try{yield r}catch(r){return r}}))},r.getErrorResult=function(r){try{return[void 0,r()]}catch(r){return[r,void 0]}},r.getErrorResultAsync=function(r){return e(this,void 0,void 0,(function*(){try{return[void 0,yield r()]}catch(r){return[r,void 0]}}))},r.getErrorResultPromise=function(r){return e(this,void 0,void 0,(function*(){try{return[void 0,yield r]}catch(r){return[r,void 0]}}))},r.getFailure=function(r){try{return r(),[!1,void 0]}catch(r){return[!0,r]}},r.getFailureAsync=function(r){return e(this,void 0,void 0,(function*(){try{return yield r(),[!1,void 0]}catch(r){return[!0,r]}}))},r.getFailurePromise=function(r){return e(this,void 0,void 0,(function*(){try{return yield r,[!1,void 0]}catch(r){return[!0,r]}}))},r.getResult=function(r){try{return r()}catch(r){return}},r.getResultAsync=function(r){return e(this,void 0,void 0,(function*(){try{return yield r()}catch(r){return}}))},r.getResultError=function(r){try{return[r(),void 0]}catch(r){return[void 0,r]}},r.getResultErrorAsync=function(r){return e(this,void 0,void 0,(function*(){try{return[yield r(),void 0]}catch(r){return[void 0,r]}}))},r.getResultErrorPromise=function(r){return e(this,void 0,void 0,(function*(){try{return[yield r,void 0]}catch(r){return[void 0,r]}}))},r.getResultPromise=function(r){return e(this,void 0,void 0,(function*(){try{return yield r}catch(r){return}}))},r.getSuccess=function(r){try{return[!0,r()]}catch(r){return[!1,void 0]}},r.getSuccessAsync=function(r){return e(this,void 0,void 0,(function*(){try{return[!0,yield r()]}catch(r){return[!1,void 0]}}))},r.getSuccessPromise=function(r){return e(this,void 0,void 0,(function*(){try{return[!0,yield r]}catch(r){return[!1,void 0]}}))},r.isFailure=function(r){try{return r(),!1}catch(r){return!0}},r.isFailureAsync=function(r){return e(this,void 0,void 0,(function*(){try{return yield r(),!1}catch(r){return!0}}))},r.isFailurePromise=function(r){return e(this,void 0,void 0,(function*(){try{return yield r,!1}catch(r){return!0}}))},r.isSuccess=function(r){try{return r(),!0}catch(r){return!1}},r.isSuccessAsync=function(r){return e(this,void 0,void 0,(function*(){try{return yield r(),!0}catch(r){return!1}}))},r.isSuccessPromise=function(r){return e(this,void 0,void 0,(function*(){try{return yield r,!0}catch(r){return!1}}))},r.toOption=function(r){try{const t=r();return s.Some(t)}catch(r){return s.None()}},r.toOptionAsync=function(r){return e(this,void 0,void 0,(function*(){try{const t=yield r();return s.Some(t)}catch(r){return s.None()}}))},r.toOptionPromise=function(r){return e(this,void 0,void 0,(function*(){try{const t=yield r;return s.Some(t)}catch(r){return s.None()}}))},r.toResult=function(r){try{const t=r();return c.Ok(t)}catch(r){return c.Err(r)}},r.toResultAsync=function(r){return e(this,void 0,void 0,(function*(){try{const t=yield r();return c.Ok(t)}catch(r){return c.Err(r)}}))},r.toResultPromise=function(r){return e(this,void 0,void 0,(function*(){try{const t=yield r;return c.Ok(t)}catch(r){return c.Err(r)}}))},Object.defineProperty(r,"__esModule",{value:!0})}));
 //# sourceMappingURL=index.umd.min.js.map

dist/es2018/index.umd.js

 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@blackglory/pass'), require('@blackglory/go')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@blackglory/pass', '@blackglory/go'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReturnStyle = {}, global.pass, global.go));
-})(this, (function (exports, pass, go) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@blackglory/prelude')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@blackglory/prelude'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.ReturnStyle = {}, global.prelude));
+})(this, (function (exports, prelude) { 'use strict';
 
@@ -247,3 +247,3 @@ function getErrorResult(fn) {
             for await (const _ of iterable) {
-                pass.pass();
+                prelude.pass();
             }
@@ -257,427 +257,316 @@ }
 
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-
-    function __classPrivateFieldGet(receiver, state, kind, f) {
-        if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-        return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-    }
-
-    function __classPrivateFieldSet(receiver, state, value, kind, f) {
-        if (kind === "m") throw new TypeError("Private method is not writable");
-        if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-        if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-        return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-    }
-
-    var _Ok_value, _Err_value;
-    class Result {
-        static Ok(value) {
-            return Ok.of(value);
+    var OptionType;
+    (function (OptionType) {
+        OptionType[OptionType["Some"] = 0] = "Some";
+        OptionType[OptionType["None"] = 1] = "None";
+    })(OptionType || (OptionType = {}));
+    class Option {
+        constructor(type, value) {
+            this.type = type;
+            this.value = value;
         }
-        static Err(error) {
-            return Err.of(error);
+        static Some(value) {
+            return new Option(OptionType.Some, value);
         }
-    }
-    class Ok extends Result {
-        constructor(value) {
-            super();
-            _Ok_value.set(this, void 0);
-            __classPrivateFieldSet(this, _Ok_value, value, "f");
+        static None() {
+            return new Option(OptionType.None);
         }
-        static of(value) {
-            return new Ok(value);
+        isSome() {
+            return this.type === OptionType.Some;
         }
-        isOk() {
-            return true;
+        isNone() {
+            return this.type === OptionType.None;
         }
-        isErr() {
-            return false;
+        map(mapper) {
+            if (this.isSome()) {
+                return Option.Some(mapper(this.value));
+            }
+            else {
+                return Option.None();
+            }
         }
-        onOk(callback) {
-            callback(__classPrivateFieldGet(this, _Ok_value, "f"));
-            return Ok.of(__classPrivateFieldGet(this, _Ok_value, "f"));
+        mapOr(defaultValue, mapper) {
+            if (this.isSome()) {
+                return Option.Some(mapper(this.value));
+            }
+            else {
+                return Option.Some(defaultValue);
+            }
         }
-        onErr() {
-            return Ok.of(__classPrivateFieldGet(this, _Ok_value, "f"));
+        mapOrElse(createDefaultValue, mapper) {
+            if (this.isSome()) {
+                return Option.Some(mapper(this.value));
+            }
+            else {
+                return Option.Some(createDefaultValue());
+            }
         }
-        orElse() {
-            return Ok.of(__classPrivateFieldGet(this, _Ok_value, "f"));
+        filter(predicate) {
+            if (this.isSome()) {
+                if (predicate(this.value)) {
+                    return Option.Some(this.value);
+                }
+                else {
+                    return Option.None();
+                }
+            }
+            else {
+                return Option.None();
+            }
         }
-        map(fn) {
-            return Ok.of(fn(__classPrivateFieldGet(this, _Ok_value, "f")));
+        /**
+         * @throws {Error}
+         */
+        unwrap() {
+            if (this.isSome()) {
+                return this.value;
+            }
+            else {
+                throw new Error('unwrap called on a None');
+            }
         }
-        get() {
-            return __classPrivateFieldGet(this, _Ok_value, "f");
+        unwrapOr(defaultValue) {
+            if (this.isSome()) {
+                return this.value;
+            }
+            else {
+                return defaultValue;
+            }
         }
-    }
-    _Ok_value = new WeakMap();
-    class Err extends Result {
-        constructor(err) {
-            super();
-            _Err_value.set(this, void 0);
-            __classPrivateFieldSet(this, _Err_value, err, "f");
+        unwrapOrElse(createDefaultValue) {
+            if (this.isSome()) {
+                return this.value;
+            }
+            else {
+                return createDefaultValue();
+            }
         }
-        static of(error) {
-            return new Err(error);
+        /**
+         * @throws {Error}
+         */
+        expect(message) {
+            if (this.isSome()) {
+                return this.value;
+            }
+            else {
+                throw new Error(message);
+            }
         }
-        isOk() {
-            return false;
+        okOr(err) {
+            if (this.isSome()) {
+                return Result.Ok(this.value);
+            }
+            else {
+                return Result.Err(err);
+            }
         }
-        isErr() {
-            return true;
+        okOrElse(createErr) {
+            if (this.isSome()) {
+                return Result.Ok(this.value);
+            }
+            else {
+                return Result.Err(createErr());
+            }
         }
-        onOk() {
-            return Err.of(__classPrivateFieldGet(this, _Err_value, "f"));
-        }
-        onErr(callback) {
-            callback(__classPrivateFieldGet(this, _Err_value, "f"));
-            return Err.of(__classPrivateFieldGet(this, _Err_value, "f"));
-        }
-        orElse(defaultValue) {
-            return Ok.of(defaultValue);
-        }
-        map() {
-            return Err.of(__classPrivateFieldGet(this, _Err_value, "f"));
-        }
-        get() {
-            throw __classPrivateFieldGet(this, _Err_value, "f");
-        }
     }
-    _Err_value = new WeakMap();
 
-    function toResult(fn) {
-        try {
-            const result = fn();
-            return Result.Ok(result);
+    var ResultType;
+    (function (ResultType) {
+        ResultType[ResultType["Ok"] = 0] = "Ok";
+        ResultType[ResultType["Err"] = 1] = "Err";
+    })(ResultType || (ResultType = {}));
+    class Result {
+        constructor(type, valueOrError) {
+            this.type = type;
+            if (type === ResultType.Ok) {
+                this.value = valueOrError;
+            }
+            else {
+                this.error = valueOrError;
+            }
         }
-        catch (e) {
-            return Result.Err(e);
-        }
-    }
-
-    var _AsyncResult_promise;
-    class AsyncResult {
-        constructor(promise) {
-            _AsyncResult_promise.set(this, void 0);
-            __classPrivateFieldSet(this, _AsyncResult_promise, Promise.resolve(promise), "f");
-        }
         static Ok(value) {
-            return AsyncOk.of(value);
+            return new Result(ResultType.Ok, value);
         }
         static Err(error) {
-            return AsyncErr.of(error);
+            return new Result(ResultType.Err, error);
         }
-        get then() {
-            const promise = __classPrivateFieldGet(this, _AsyncResult_promise, "f").then(x => Result.Ok(x), x => Result.Err(x));
-            return promise.then.bind(promise);
+        isOk() {
+            return this.type === ResultType.Ok;
         }
-        onOk(callback) {
-            go.go(async () => {
-                const [succ, ret] = await getSuccessPromise(__classPrivateFieldGet(this, _AsyncResult_promise, "f"));
-                if (succ)
-                    callback(ret);
-            });
-            return new AsyncResult(__classPrivateFieldGet(this, _AsyncResult_promise, "f"));
+        isErr() {
+            return this.type === ResultType.Err;
         }
-        onErr(callback) {
-            go.go(async () => {
-                const [fail, err] = await getFailurePromise(__classPrivateFieldGet(this, _AsyncResult_promise, "f"));
-                if (fail)
-                    callback(err);
-            });
-            return new AsyncResult(__classPrivateFieldGet(this, _AsyncResult_promise, "f"));
-        }
-        async isOk() {
-            return await isSuccessPromise(__classPrivateFieldGet(this, _AsyncResult_promise, "f"));
-        }
-        async isErr() {
-            return await isFailurePromise(__classPrivateFieldGet(this, _AsyncResult_promise, "f"));
-        }
-        orElse(defaultValue) {
-            const promise = go.go(async () => {
-                try {
-                    return await __classPrivateFieldGet(this, _AsyncResult_promise, "f");
-                }
-                catch (_a) {
-                    return defaultValue;
-                }
-            });
-            return new AsyncResult(promise);
-        }
         map(mapper) {
-            const promise = go.go(async () => {
-                const result = await __classPrivateFieldGet(this, _AsyncResult_promise, "f");
-                return mapper(result);
-            });
-            return new AsyncResult(promise);
+            if (this.isOk()) {
+                return Result.Ok(mapper(this.value));
+            }
+            else {
+                return Result.Err(this.error);
+            }
         }
-        async get() {
-            return await __classPrivateFieldGet(this, _AsyncResult_promise, "f");
+        mapOr(defaultValue, mapper) {
+            if (this.isOk()) {
+                return Result.Ok(mapper(this.value));
+            }
+            else {
+                return Result.Ok(defaultValue);
+            }
         }
-    }
-    _AsyncResult_promise = new WeakMap();
-    class AsyncOk extends AsyncResult {
-        static of(value) {
-            return new AsyncOk(value);
+        mapOrElse(createDefaultValue, mapper) {
+            if (this.isOk()) {
+                return Result.Ok(mapper(this.value));
+            }
+            else {
+                return Result.Ok(createDefaultValue(this.error));
+            }
         }
-        constructor(value) {
-            super(Promise.resolve(value));
+        mapErr(mapper) {
+            if (this.isOk()) {
+                return Result.Ok(this.value);
+            }
+            else {
+                return Result.Err(mapper(this.error));
+            }
         }
-    }
-    class AsyncErr extends AsyncResult {
-        static of(value) {
-            return new AsyncErr(value);
+        /**
+         * @throws {E}
+         */
+        unwrap() {
+            if (this.isOk()) {
+                return this.value;
+            }
+            else {
+                throw this.error;
+            }
         }
-        constructor(err) {
-            super(Promise.reject(err));
+        unwrapOr(defaultValue) {
+            if (this.isOk()) {
+                return this.value;
+            }
+            else {
+                return defaultValue;
+            }
         }
-    }
-
-    function toResultAsync(fn) {
-        try {
-            const result = fn();
-            return new AsyncResult(result);
+        unwrapOrElse(createDefaultValue) {
+            if (this.isOk()) {
+                return this.value;
+            }
+            else {
+                return createDefaultValue(this.error);
+            }
         }
-        catch (e) {
-            return AsyncResult.Err(e);
+        /**
+         * @throws {Error}
+         */
+        unwrapErr() {
+            if (this.isErr()) {
+                return this.error;
+            }
+            else {
+                throw new Error('unwrapErr called on a Ok');
+            }
         }
-    }
-
-    function toResultPromise(promise) {
-        return new AsyncResult(promise);
-    }
-
-    var _Some_value;
-    class Optional {
-        static Some(value) {
-            return Some.of(value);
+        /**
+         * @throws {Error}
+         */
+        expect(message) {
+            if (this.isOk()) {
+                return this.value;
+            }
+            else {
+                throw new Error(message);
+            }
         }
-        static None() {
-            return None.of();
+        /**
+         * @throws {Error}
+         */
+        expectErr(message) {
+            if (this.isErr()) {
+                return this.error;
+            }
+            else {
+                throw new Error(message);
+            }
         }
-    }
-    class Some extends Optional {
-        constructor(value) {
-            super();
-            _Some_value.set(this, void 0);
-            __classPrivateFieldSet(this, _Some_value, value, "f");
+        ok() {
+            if (this.isOk()) {
+                return Option.Some(this.value);
+            }
+            else {
+                return Option.None();
+            }
         }
-        static of(value) {
-            return new Some(value);
-        }
-        isSome() {
-            return true;
-        }
-        isNone() {
-            return false;
-        }
-        onSome(callback) {
-            callback(__classPrivateFieldGet(this, _Some_value, "f"));
-            return Some.of(__classPrivateFieldGet(this, _Some_value, "f"));
-        }
-        onNone() {
-            return Some.of(__classPrivateFieldGet(this, _Some_value, "f"));
-        }
-        orElse() {
-            return Some.of(__classPrivateFieldGet(this, _Some_value, "f"));
-        }
-        map(mapper) {
-            return Some.of(mapper(__classPrivateFieldGet(this, _Some_value, "f")));
-        }
-        filter(predicate) {
-            if (predicate(__classPrivateFieldGet(this, _Some_value, "f"))) {
-                return Some.of(__classPrivateFieldGet(this, _Some_value, "f"));
+        err() {
+            if (this.isOk()) {
+                return Option.None();
             }
             else {
-                return None.of();
+                return Option.Some(this.error);
             }
         }
-        get() {
-            return __classPrivateFieldGet(this, _Some_value, "f");
-        }
     }
-    _Some_value = new WeakMap();
-    class None extends Optional {
-        static of() {
-            return new None();
+
+    function toResult(fn) {
+        try {
+            const result = fn();
+            return Result.Ok(result);
         }
-        constructor() {
-            super();
+        catch (e) {
+            return Result.Err(e);
         }
-        isSome() {
-            return false;
-        }
-        isNone() {
-            return true;
-        }
-        onSome() {
-            return None.of();
-        }
-        onNone(callback) {
-            callback();
-            return None.of();
-        }
-        orElse(defaultValue) {
-            return Some.of(defaultValue);
-        }
-        map() {
-            return None.of();
-        }
-        filter() {
-            return None.of();
-        }
-        get() {
-            throw new Error('Cannot get value from None');
-        }
     }
 
-    function toOptionalPartial(isNone) {
-        return (fn) => toOptional(fn, isNone);
-    }
-    function toOptional(fn, isNone) {
-        const result = fn();
-        if (isNone(result)) {
-            return Optional.None();
+    async function toResultAsync(fn) {
+        try {
+            const result = await fn();
+            return Result.Ok(result);
         }
-        else {
-            return Optional.Some(result);
+        catch (err) {
+            return Result.Err(err);
         }
     }
 
-    var _AsyncOptional_promise;
-    const Nil = Symbol();
-    class AsyncOptional {
-        constructor(promise) {
-            _AsyncOptional_promise.set(this, void 0);
-            __classPrivateFieldSet(this, _AsyncOptional_promise, Promise.resolve(promise), "f");
+    async function toResultPromise(promise) {
+        try {
+            const result = await promise;
+            return Result.Ok(result);
         }
-        static Some(value) {
-            return AsyncSome.of(value);
+        catch (err) {
+            return Result.Err(err);
         }
-        static None() {
-            return AsyncNone.of();
-        }
-        get then() {
-            const promise = __classPrivateFieldGet(this, _AsyncOptional_promise, "f").then(x => x === Nil
-                ? Optional.None()
-                : Optional.Some(x));
-            return promise.then.bind(promise);
-        }
-        onSome(callback) {
-            go.go(async () => {
-                const result = await __classPrivateFieldGet(this, _AsyncOptional_promise, "f");
-                if (result !== Nil)
-                    callback(result);
-            });
-            return new AsyncOptional(__classPrivateFieldGet(this, _AsyncOptional_promise, "f"));
-        }
-        onNone(callback) {
-            go.go(async () => {
-                const result = await __classPrivateFieldGet(this, _AsyncOptional_promise, "f");
-                if (result === Nil)
-                    callback();
-            });
-            return new AsyncOptional(__classPrivateFieldGet(this, _AsyncOptional_promise, "f"));
-        }
-        async isSome() {
-            const result = await __classPrivateFieldGet(this, _AsyncOptional_promise, "f");
-            return result !== Nil;
-        }
-        async isNone() {
-            const result = await __classPrivateFieldGet(this, _AsyncOptional_promise, "f");
-            return result === Nil;
-        }
-        orElse(defaultValue) {
-            const promise = go.go(async () => {
-                const result = await __classPrivateFieldGet(this, _AsyncOptional_promise, "f");
-                if (result === Nil)
-                    return defaultValue;
-                return result;
-            });
-            return new AsyncOptional(promise);
-        }
-        map(mapper) {
-            const promise = go.go(async () => {
-                const result = await __classPrivateFieldGet(this, _AsyncOptional_promise, "f");
-                if (result === Nil)
-                    return Nil;
-                return mapper(result);
-            });
-            return new AsyncOptional(promise);
-        }
-        filter(predicate) {
-            const promise = go.go(async () => {
-                const result = await __classPrivateFieldGet(this, _AsyncOptional_promise, "f");
-                if (result === Nil)
-                    return Nil;
-                if (predicate(result))
-                    return result;
-                return Nil;
-            });
-            return new AsyncOptional(promise);
-        }
-        async get() {
-            const result = await __classPrivateFieldGet(this, _AsyncOptional_promise, "f");
-            if (result === Nil)
-                throw new Error('Cannot get value from None');
-            return result;
-        }
     }
-    _AsyncOptional_promise = new WeakMap();
-    class AsyncNone extends AsyncOptional {
-        static of() {
-            return new AsyncNone();
+
+    function toOption(fn) {
+        try {
+            const result = fn();
+            return Option.Some(result);
         }
-        constructor() {
-            super(Promise.resolve(Nil));
+        catch (_a) {
+            return Option.None();
         }
     }
-    class AsyncSome extends AsyncOptional {
-        static of(value) {
-            return new AsyncSome(value);
+
+    async function toOptionAsync(fn) {
+        try {
+            const result = await fn();
+            return Option.Some(result);
         }
-        constructor(value) {
-            super(Promise.resolve(value));
+        catch (_a) {
+            return Option.None();
         }
     }
 
-    function toOptionalAsyncPartial(isNone) {
-        return (fn) => toOptionalAsync(fn, isNone);
-    }
-    function toOptionalAsync(fn, isNone) {
-        const promise = go.go(async () => {
-            const result = await fn();
-            if (isNone(result))
-                return Nil;
-            return result;
-        });
-        return new AsyncOptional(promise);
-    }
-
-    function toOptionalPromisePartial(isNone) {
-        return (promise) => toOptionalPromise(promise, isNone);
-    }
-    function toOptionalPromise(promise, isNone) {
-        return new AsyncOptional(go.go(async () => {
+    async function toOptionPromise(promise) {
+        try {
             const result = await promise;
-            if (isNone(result))
-                return Nil;
-            return result;
-        }));
+            return Option.Some(result);
+        }
+        catch (_a) {
+            return Option.None();
+        }
     }
 
+    exports.Option = Option;
+    exports.Result = Result;
     exports.getError = getError;
@@ -708,8 +597,5 @@ exports.getErrorAsync = getErrorAsync;
     exports.isSuccessPromise = isSuccessPromise;
-    exports.toOptional = toOptional;
-    exports.toOptionalAsync = toOptionalAsync;
-    exports.toOptionalAsyncPartial = toOptionalAsyncPartial;
-    exports.toOptionalPartial = toOptionalPartial;
-    exports.toOptionalPromise = toOptionalPromise;
-    exports.toOptionalPromisePartial = toOptionalPromisePartial;
+    exports.toOption = toOption;
+    exports.toOptionAsync = toOptionAsync;
+    exports.toOptionPromise = toOptionPromise;
     exports.toResult = toResult;
@@ -716,0 +602,0 @@ exports.toResultAsync = toResultAsync;

dist/es2018/index.umd.min.js

@@ -1,17 +0,2 @@
-!function(t,r){"object"==typeof exports&&"undefined"!=typeof module?r(exports,require("@blackglory/pass"),require("@blackglory/go")):"function"==typeof define&&define.amd?define(["exports","@blackglory/pass","@blackglory/go"],r):r((t="undefined"!=typeof globalThis?globalThis:t||self).ReturnStyle={},t.pass,t.go)}(this,(function(t,r,e){"use strict";async function n(t){try{return[!0,await t]}catch(t){return[!1,void 0]}}async function o(t){try{return await t,[!1,void 0]}catch(t){return[!0,t]}}async function s(t){try{return await t,!0}catch(t){return!1}}async function i(t){try{return await t,!1}catch(t){return!0}}
-/*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-function c(t,r,e,n){if("a"===e&&!n)throw new TypeError("Private accessor was defined without a getter");if("function"==typeof r?t!==r||!n:!r.has(t))throw new TypeError("Cannot read private member from an object whose class did not declare it");return"m"===e?n:"a"===e?n.call(t):n?n.value:r.get(t)}function a(t,r,e,n,o){if("m"===n)throw new TypeError("Private method is not writable");if("a"===n&&!o)throw new TypeError("Private accessor was defined without a setter");if("function"==typeof r?t!==r||!o:!r.has(t))throw new TypeError("Cannot write private member to an object whose class did not declare it");return"a"===n?o.call(t,e):o?o.value=e:r.set(t,e),e}var u,f,h,y,l;class w{static Ok(t){return d.of(t)}static Err(t){return g.of(t)}}class d extends w{constructor(t){super(),u.set(this,void 0),a(this,u,t,"f")}static of(t){return new d(t)}isOk(){return!0}isErr(){return!1}onOk(t){return t(c(this,u,"f")),d.of(c(this,u,"f"))}onErr(){return d.of(c(this,u,"f"))}orElse(){return d.of(c(this,u,"f"))}map(t){return d.of(t(c(this,u,"f")))}get(){return c(this,u,"f")}}u=new WeakMap;class g extends w{constructor(t){super(),f.set(this,void 0),a(this,f,t,"f")}static of(t){return new g(t)}isOk(){return!1}isErr(){return!0}onOk(){return g.of(c(this,f,"f"))}onErr(t){return t(c(this,f,"f")),g.of(c(this,f,"f"))}orElse(t){return d.of(t)}map(){return g.of(c(this,f,"f"))}get(){throw c(this,f,"f")}}f=new WeakMap;class m{constructor(t){h.set(this,void 0),a(this,h,Promise.resolve(t),"f")}static Ok(t){return p.of(t)}static Err(t){return v.of(t)}get then(){const t=c(this,h,"f").then((t=>w.Ok(t)),(t=>w.Err(t)));return t.then.bind(t)}onOk(t){return e.go((async()=>{const[r,e]=await n(c(this,h,"f"));r&&t(e)})),new m(c(this,h,"f"))}onErr(t){return e.go((async()=>{const[r,e]=await o(c(this,h,"f"));r&&t(e)})),new m(c(this,h,"f"))}async isOk(){return await s(c(this,h,"f"))}async isErr(){return await i(c(this,h,"f"))}orElse(t){const r=e.go((async()=>{try{return await c(this,h,"f")}catch(r){return t}}));return new m(r)}map(t){const r=e.go((async()=>{const r=await c(this,h,"f");return t(r)}));return new m(r)}async get(){return await c(this,h,"f")}}h=new WeakMap;class p extends m{static of(t){return new p(t)}constructor(t){super(Promise.resolve(t))}}class v extends m{static of(t){return new v(t)}constructor(t){super(Promise.reject(t))}}class E{static Some(t){return P.of(t)}static None(){return k.of()}}class P extends E{constructor(t){super(),y.set(this,void 0),a(this,y,t,"f")}static of(t){return new P(t)}isSome(){return!0}isNone(){return!1}onSome(t){return t(c(this,y,"f")),P.of(c(this,y,"f"))}onNone(){return P.of(c(this,y,"f"))}orElse(){return P.of(c(this,y,"f"))}map(t){return P.of(t(c(this,y,"f")))}filter(t){return t(c(this,y,"f"))?P.of(c(this,y,"f")):k.of()}get(){return c(this,y,"f")}}y=new WeakMap;class k extends E{static of(){return new k}constructor(){super()}isSome(){return!1}isNone(){return!0}onSome(){return k.of()}onNone(t){return t(),k.of()}orElse(t){return P.of(t)}map(){return k.of()}filter(){return k.of()}get(){throw new Error("Cannot get value from None")}}function S(t,r){const e=t();return r(e)?E.None():E.Some(e)}const b=Symbol();class O{constructor(t){l.set(this,void 0),a(this,l,Promise.resolve(t),"f")}static Some(t){return A.of(t)}static None(){return R.of()}get then(){const t=c(this,l,"f").then((t=>t===b?E.None():E.Some(t)));return t.then.bind(t)}onSome(t){return e.go((async()=>{const r=await c(this,l,"f");r!==b&&t(r)})),new O(c(this,l,"f"))}onNone(t){return e.go((async()=>{await c(this,l,"f")===b&&t()})),new O(c(this,l,"f"))}async isSome(){return await c(this,l,"f")!==b}async isNone(){return await c(this,l,"f")===b}orElse(t){const r=e.go((async()=>{const r=await c(this,l,"f");return r===b?t:r}));return new O(r)}map(t){const r=e.go((async()=>{const r=await c(this,l,"f");return r===b?b:t(r)}));return new O(r)}filter(t){const r=e.go((async()=>{const r=await c(this,l,"f");return r===b?b:t(r)?r:b}));return new O(r)}async get(){const t=await c(this,l,"f");if(t===b)throw new Error("Cannot get value from None");return t}}l=new WeakMap;class R extends O{static of(){return new R}constructor(){super(Promise.resolve(b))}}class A extends O{static of(t){return new A(t)}constructor(t){super(Promise.resolve(t))}}function N(t,r){const n=e.go((async()=>{const e=await t();return r(e)?b:e}));return new O(n)}function x(t,r){return new O(e.go((async()=>{const e=await t;return r(e)?b:e})))}t.getError=function(t){try{t()}catch(t){return t}},t.getErrorAsync=async function(t){try{await t()}catch(t){return t}},t.getErrorAsyncIterable=async function(t){try{for await(const e of t)r.pass()}catch(t){return t}},t.getErrorPromise=async function(t){try{await t}catch(t){return t}},t.getErrorResult=function(t){try{return[void 0,t()]}catch(t){return[t,void 0]}},t.getErrorResultAsync=async function(t){try{return[void 0,await t()]}catch(t){return[t,void 0]}},t.getErrorResultPromise=async function(t){try{return[void 0,await t]}catch(t){return[t,void 0]}},t.getFailure=function(t){try{return t(),[!1,void 0]}catch(t){return[!0,t]}},t.getFailureAsync=async function(t){try{return await t(),[!1,void 0]}catch(t){return[!0,t]}},t.getFailurePromise=o,t.getResult=function(t){try{return t()}catch(t){return}},t.getResultAsync=async function(t){try{return await t()}catch(t){return}},t.getResultError=function(t){try{return[t(),void 0]}catch(t){return[void 0,t]}},t.getResultErrorAsync=async function(t){try{return[await t(),void 0]}catch(t){return[void 0,t]}},t.getResultErrorPromise=async function(t){try{return[await t,void 0]}catch(t){return[void 0,t]}},t.getResultPromise=async function(t){try{return await t}catch(t){return}},t.getSuccess=function(t){try{return[!0,t()]}catch(t){return[!1,void 0]}},t.getSuccessAsync=async function(t){try{return[!0,await t()]}catch(t){return[!1,void 0]}},t.getSuccessPromise=n,t.isFailure=function(t){try{return t(),!1}catch(t){return!0}},t.isFailureAsync=async function(t){try{return await t(),!1}catch(t){return!0}},t.isFailurePromise=i,t.isSuccess=function(t){try{return t(),!0}catch(t){return!1}},t.isSuccessAsync=async function(t){try{return await t(),!0}catch(t){return!1}},t.isSuccessPromise=s,t.toOptional=S,t.toOptionalAsync=N,t.toOptionalAsyncPartial=function(t){return r=>N(r,t)},t.toOptionalPartial=function(t){return r=>S(r,t)},t.toOptionalPromise=x,t.toOptionalPromisePartial=function(t){return r=>x(r,t)},t.toResult=function(t){try{const r=t();return w.Ok(r)}catch(t){return w.Err(t)}},t.toResultAsync=function(t){try{const r=t();return new m(r)}catch(t){return m.Err(t)}},t.toResultPromise=function(t){return new m(t)},Object.defineProperty(t,"__esModule",{value:!0})}));
+!function(r,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports,require("@blackglory/prelude")):"function"==typeof define&&define.amd?define(["exports","@blackglory/prelude"],t):t((r="undefined"!=typeof globalThis?globalThis:r||self).ReturnStyle={},r.prelude)}(this,(function(r,t){"use strict";var e,n;!function(r){r[r.Some=0]="Some",r[r.None=1]="None"}(e||(e={}));class i{constructor(r,t){this.type=r,this.value=t}static Some(r){return new i(e.Some,r)}static None(){return new i(e.None)}isSome(){return this.type===e.Some}isNone(){return this.type===e.None}map(r){return this.isSome()?i.Some(r(this.value)):i.None()}mapOr(r,t){return this.isSome()?i.Some(t(this.value)):i.Some(r)}mapOrElse(r,t){return this.isSome()?i.Some(t(this.value)):i.Some(r())}filter(r){return this.isSome()&&r(this.value)?i.Some(this.value):i.None()}unwrap(){if(this.isSome())return this.value;throw new Error("unwrap called on a None")}unwrapOr(r){return this.isSome()?this.value:r}unwrapOrElse(r){return this.isSome()?this.value:r()}expect(r){if(this.isSome())return this.value;throw new Error(r)}okOr(r){return this.isSome()?u.Ok(this.value):u.Err(r)}okOrElse(r){return this.isSome()?u.Ok(this.value):u.Err(r())}}!function(r){r[r.Ok=0]="Ok",r[r.Err=1]="Err"}(n||(n={}));class u{constructor(r,t){this.type=r,r===n.Ok?this.value=t:this.error=t}static Ok(r){return new u(n.Ok,r)}static Err(r){return new u(n.Err,r)}isOk(){return this.type===n.Ok}isErr(){return this.type===n.Err}map(r){return this.isOk()?u.Ok(r(this.value)):u.Err(this.error)}mapOr(r,t){return this.isOk()?u.Ok(t(this.value)):u.Ok(r)}mapOrElse(r,t){return this.isOk()?u.Ok(t(this.value)):u.Ok(r(this.error))}mapErr(r){return this.isOk()?u.Ok(this.value):u.Err(r(this.error))}unwrap(){if(this.isOk())return this.value;throw this.error}unwrapOr(r){return this.isOk()?this.value:r}unwrapOrElse(r){return this.isOk()?this.value:r(this.error)}unwrapErr(){if(this.isErr())return this.error;throw new Error("unwrapErr called on a Ok")}expect(r){if(this.isOk())return this.value;throw new Error(r)}expectErr(r){if(this.isErr())return this.error;throw new Error(r)}ok(){return this.isOk()?i.Some(this.value):i.None()}err(){return this.isOk()?i.None():i.Some(this.error)}}r.Option=i,r.Result=u,r.getError=function(r){try{r()}catch(r){return r}},r.getErrorAsync=async function(r){try{await r()}catch(r){return r}},r.getErrorAsyncIterable=async function(r){try{for await(const e of r)t.pass()}catch(r){return r}},r.getErrorPromise=async function(r){try{await r}catch(r){return r}},r.getErrorResult=function(r){try{return[void 0,r()]}catch(r){return[r,void 0]}},r.getErrorResultAsync=async function(r){try{return[void 0,await r()]}catch(r){return[r,void 0]}},r.getErrorResultPromise=async function(r){try{return[void 0,await r]}catch(r){return[r,void 0]}},r.getFailure=function(r){try{return r(),[!1,void 0]}catch(r){return[!0,r]}},r.getFailureAsync=async function(r){try{return await r(),[!1,void 0]}catch(r){return[!0,r]}},r.getFailurePromise=async function(r){try{return await r,[!1,void 0]}catch(r){return[!0,r]}},r.getResult=function(r){try{return r()}catch(r){return}},r.getResultAsync=async function(r){try{return await r()}catch(r){return}},r.getResultError=function(r){try{return[r(),void 0]}catch(r){return[void 0,r]}},r.getResultErrorAsync=async function(r){try{return[await r(),void 0]}catch(r){return[void 0,r]}},r.getResultErrorPromise=async function(r){try{return[await r,void 0]}catch(r){return[void 0,r]}},r.getResultPromise=async function(r){try{return await r}catch(r){return}},r.getSuccess=function(r){try{return[!0,r()]}catch(r){return[!1,void 0]}},r.getSuccessAsync=async function(r){try{return[!0,await r()]}catch(r){return[!1,void 0]}},r.getSuccessPromise=async function(r){try{return[!0,await r]}catch(r){return[!1,void 0]}},r.isFailure=function(r){try{return r(),!1}catch(r){return!0}},r.isFailureAsync=async function(r){try{return await r(),!1}catch(r){return!0}},r.isFailurePromise=async function(r){try{return await r,!1}catch(r){return!0}},r.isSuccess=function(r){try{return r(),!0}catch(r){return!1}},r.isSuccessAsync=async function(r){try{return await r(),!0}catch(r){return!1}},r.isSuccessPromise=async function(r){try{return await r,!0}catch(r){return!1}},r.toOption=function(r){try{const t=r();return i.Some(t)}catch(r){return i.None()}},r.toOptionAsync=async function(r){try{const t=await r();return i.Some(t)}catch(r){return i.None()}},r.toOptionPromise=async function(r){try{const t=await r;return i.Some(t)}catch(r){return i.None()}},r.toResult=function(r){try{const t=r();return u.Ok(t)}catch(r){return u.Err(r)}},r.toResultAsync=async function(r){try{const t=await r();return u.Ok(t)}catch(r){return u.Err(r)}},r.toResultPromise=async function(r){try{const t=await r;return u.Ok(t)}catch(r){return u.Err(r)}},Object.defineProperty(r,"__esModule",{value:!0})}));
 //# sourceMappingURL=index.umd.min.js.map

lib/es2015/classes/result.d.ts

@@ -1,13 +0,24 @@
-export interface IResult<T, X> {
+import { Option } from './option';
+export declare class Result<T, E> {
+    private type;
+    private value?;
+    private error?;
+    private constructor();
+    private constructor();
+    static Ok<T, E>(value: T): Result<T, E>;
+    static Err<T, E>(error: E): Result<T, E>;
     isOk(): boolean;
     isErr(): boolean;
-    onOk(callback: (val: T) => void): IResult<T, X>;
-    onErr(callback: (err: X) => void): IResult<T, X>;
-    orElse<U>(defaultValue: U): IResult<T, never> | IResult<U, never>;
-    map<U>(mapper: (val: T) => U): IResult<U, X>;
-    get(): T;
+    map<U>(mapper: (val: T) => U): Result<U, E>;
+    mapOr<U>(defaultValue: U, mapper: (val: T) => U): Result<U, E>;
+    mapOrElse<U>(createDefaultValue: (err: E) => U, mapper: (val: T) => U): Result<U, E>;
+    mapErr<U>(mapper: (err: E) => U): Result<T, U>;
+    unwrap(): T;
+    unwrapOr<U>(defaultValue: U): T | U;
+    unwrapOrElse<U>(createDefaultValue: (err: E) => U): T | U;
+    unwrapErr(): E;
+    expect(message: string): T;
+    expectErr(message: string): E;
+    ok(): Option<T>;
+    err(): Option<E>;
 }
-export declare abstract class Result {
-    static Ok<T>(value: T): IResult<T, never>;
-    static Err<T>(error: T): IResult<never, T>;
-}

lib/es2015/classes/result.js

 "use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Ok_value, _Err_value;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Result = void 0;
+const option_1 = require("./option");
+var ResultType;
+(function (ResultType) {
+    ResultType[ResultType["Ok"] = 0] = "Ok";
+    ResultType[ResultType["Err"] = 1] = "Err";
+})(ResultType || (ResultType = {}));
 class Result {
+    constructor(type, valueOrError) {
+        this.type = type;
+        if (type === ResultType.Ok) {
+            this.value = valueOrError;
+        }
+        else {
+            this.error = valueOrError;
+        }
+    }
     static Ok(value) {
-        return Ok.of(value);
+        return new Result(ResultType.Ok, value);
     }
     static Err(error) {
-        return Err.of(error);
+        return new Result(ResultType.Err, error);
     }
-}
-exports.Result = Result;
-class Ok extends Result {
-    constructor(value) {
-        super();
-        _Ok_value.set(this, void 0);
-        __classPrivateFieldSet(this, _Ok_value, value, "f");
-    }
-    static of(value) {
-        return new Ok(value);
-    }
     isOk() {
-        return true;
+        return this.type === ResultType.Ok;
     }
     isErr() {
-        return false;
+        return this.type === ResultType.Err;
     }
-    onOk(callback) {
-        callback(__classPrivateFieldGet(this, _Ok_value, "f"));
-        return Ok.of(__classPrivateFieldGet(this, _Ok_value, "f"));
+    map(mapper) {
+        if (this.isOk()) {
+            return Result.Ok(mapper(this.value));
+        }
+        else {
+            return Result.Err(this.error);
+        }
     }
-    onErr() {
-        return Ok.of(__classPrivateFieldGet(this, _Ok_value, "f"));
+    mapOr(defaultValue, mapper) {
+        if (this.isOk()) {
+            return Result.Ok(mapper(this.value));
+        }
+        else {
+            return Result.Ok(defaultValue);
+        }
     }
-    orElse() {
-        return Ok.of(__classPrivateFieldGet(this, _Ok_value, "f"));
+    mapOrElse(createDefaultValue, mapper) {
+        if (this.isOk()) {
+            return Result.Ok(mapper(this.value));
+        }
+        else {
+            return Result.Ok(createDefaultValue(this.error));
+        }
     }
-    map(fn) {
-        return Ok.of(fn(__classPrivateFieldGet(this, _Ok_value, "f")));
+    mapErr(mapper) {
+        if (this.isOk()) {
+            return Result.Ok(this.value);
+        }
+        else {
+            return Result.Err(mapper(this.error));
+        }
     }
-    get() {
-        return __classPrivateFieldGet(this, _Ok_value, "f");
+    unwrap() {
+        if (this.isOk()) {
+            return this.value;
+        }
+        else {
+            throw this.error;
+        }
     }
-}
-_Ok_value = new WeakMap();
-class Err extends Result {
-    constructor(err) {
-        super();
-        _Err_value.set(this, void 0);
-        __classPrivateFieldSet(this, _Err_value, err, "f");
+    unwrapOr(defaultValue) {
+        if (this.isOk()) {
+            return this.value;
+        }
+        else {
+            return defaultValue;
+        }
     }
-    static of(error) {
-        return new Err(error);
+    unwrapOrElse(createDefaultValue) {
+        if (this.isOk()) {
+            return this.value;
+        }
+        else {
+            return createDefaultValue(this.error);
+        }
     }
-    isOk() {
-        return false;
+    unwrapErr() {
+        if (this.isErr()) {
+            return this.error;
+        }
+        else {
+            throw new Error('unwrapErr called on a Ok');
+        }
     }
-    isErr() {
-        return true;
+    expect(message) {
+        if (this.isOk()) {
+            return this.value;
+        }
+        else {
+            throw new Error(message);
+        }
     }
-    onOk() {
-        return Err.of(__classPrivateFieldGet(this, _Err_value, "f"));
+    expectErr(message) {
+        if (this.isErr()) {
+            return this.error;
+        }
+        else {
+            throw new Error(message);
+        }
     }
-    onErr(callback) {
-        callback(__classPrivateFieldGet(this, _Err_value, "f"));
-        return Err.of(__classPrivateFieldGet(this, _Err_value, "f"));
+    ok() {
+        if (this.isOk()) {
+            return option_1.Option.Some(this.value);
+        }
+        else {
+            return option_1.Option.None();
+        }
     }
-    orElse(defaultValue) {
-        return Ok.of(defaultValue);
+    err() {
+        if (this.isOk()) {
+            return option_1.Option.None();
+        }
+        else {
+            return option_1.Option.Some(this.error);
+        }
     }
-    map() {
-        return Err.of(__classPrivateFieldGet(this, _Err_value, "f"));
-    }
-    get() {
-        throw __classPrivateFieldGet(this, _Err_value, "f");
-    }
 }
-_Err_value = new WeakMap();
+exports.Result = Result;
 //# sourceMappingURL=result.js.map

lib/es2015/functions/get-error-async-iterable.d.ts

@@ -1,1 +0,1 @@
-export declare function getErrorAsyncIterable<X = Error>(iterable: AsyncIterable<unknown>): Promise<X | undefined>;
+export declare function getErrorAsyncIterable<E = Error>(iterable: AsyncIterable<unknown>): Promise<E | undefined>;

lib/es2015/functions/get-error-async-iterable.js

@@ -20,3 +20,3 @@ "use strict";
 exports.getErrorAsyncIterable = void 0;
-const pass_1 = require("@blackglory/pass");
+const prelude_1 = require("@blackglory/prelude");
 function getErrorAsyncIterable(iterable) {
@@ -30,3 +30,3 @@ var iterable_1, iterable_1_1;
                     const _ = iterable_1_1.value;
-                    (0, pass_1.pass)();
+                    (0, prelude_1.pass)();
                 }
@@ -33,0 +33,0 @@ }

lib/es2015/functions/get-error-async.d.ts

@@ -1,1 +0,2 @@
-export declare function getErrorAsync<X = Error>(fn: () => PromiseLike<unknown> | unknown): Promise<X | undefined>;
+import { Awaitable } from '@blackglory/prelude';
+export declare function getErrorAsync<E = Error>(fn: () => Awaitable<unknown>): Promise<E | undefined>;

lib/es2015/functions/get-error-promise.d.ts

@@ -1,1 +0,1 @@
-export declare function getErrorPromise<X = Error>(promise: PromiseLike<unknown>): Promise<X | undefined>;
+export declare function getErrorPromise<E = Error>(promise: PromiseLike<unknown>): Promise<E | undefined>;

lib/es2015/functions/get-error-result-async.d.ts

@@ -1,1 +0,2 @@
-export declare function getErrorResultAsync<X = Error, T = unknown>(fn: () => PromiseLike<T> | T): Promise<[error: undefined, result: T] | [error: X, result: undefined]>;
+import { Awaitable } from '@blackglory/prelude';
+export declare function getErrorResultAsync<E = Error, T = unknown>(fn: () => Awaitable<T>): Promise<[error: undefined, result: T] | [error: E, result: undefined]>;

lib/es2015/functions/get-error-result-promise.d.ts

@@ -1,1 +0,1 @@
-export declare function getErrorResultPromise<X = Error, T = unknown>(promise: PromiseLike<T>): Promise<[error: undefined, result: T] | [error: X, result: undefined]>;
+export declare function getErrorResultPromise<E = Error, T = unknown>(promise: PromiseLike<T>): Promise<[error: undefined, result: T] | [error: E, result: undefined]>;

lib/es2015/functions/get-error-result.d.ts

@@ -1,1 +0,1 @@
-export declare function getErrorResult<X = Error, T = unknown>(fn: () => T): [error: undefined, result: T] | [error: X, result: undefined];
+export declare function getErrorResult<E = Error, T = unknown>(fn: () => T): [error: undefined, result: T] | [error: E, result: undefined];

lib/es2015/functions/get-error.d.ts

@@ -1,1 +0,1 @@
-export declare function getError<X = Error>(fn: () => unknown): X | undefined;
+export declare function getError<E = Error>(fn: () => unknown): E | undefined;

lib/es2015/functions/get-failure-async.d.ts

@@ -1,1 +0,2 @@
-export declare function getFailureAsync<X = Error>(fn: () => PromiseLike<unknown> | unknown): Promise<[failed: true, error: X] | [failed: false, error: undefined]>;
+import { Awaitable } from '@blackglory/prelude';
+export declare function getFailureAsync<E = Error>(fn: () => Awaitable<unknown>): Promise<[failed: true, error: E] | [failed: false, error: undefined]>;

lib/es2015/functions/get-failure-promise.d.ts

@@ -1,1 +0,1 @@
-export declare function getFailurePromise<X = Error>(promise: PromiseLike<unknown>): Promise<[failed: true, error: X] | [failed: false, error: undefined]>;
+export declare function getFailurePromise<E = Error>(promise: PromiseLike<unknown>): Promise<[failed: true, error: E] | [failed: false, error: undefined]>;

lib/es2015/functions/get-failure.d.ts

@@ -1,1 +0,1 @@
-export declare function getFailure<X = Error>(fn: () => unknown): [failed: true, error: X] | [faled: false, error: undefined];
+export declare function getFailure<E = Error>(fn: () => unknown): [failed: true, error: E] | [faled: false, error: undefined];

lib/es2015/functions/get-result-async.d.ts

@@ -1,1 +0,2 @@
-export declare function getResultAsync<T>(fn: () => PromiseLike<T> | T): Promise<T | undefined>;
+import { Awaitable } from '@blackglory/prelude';
+export declare function getResultAsync<T>(fn: () => Awaitable<T>): Promise<T | undefined>;

lib/es2015/functions/get-result-error-async.d.ts

@@ -1,1 +0,2 @@
-export declare function getResultErrorAsync<X = Error, T = unknown>(fn: () => PromiseLike<T> | T): Promise<[result: T, error: undefined] | [result: undefined, error: X]>;
+import { Awaitable } from '@blackglory/prelude';
+export declare function getResultErrorAsync<E = Error, T = unknown>(fn: () => Awaitable<T>): Promise<[result: T, error: undefined] | [result: undefined, error: E]>;

lib/es2015/functions/get-result-error-promise.d.ts

@@ -1,1 +0,1 @@
-export declare function getResultErrorPromise<X = Error, T = unknown>(promise: PromiseLike<T>): Promise<[result: T, error: undefined] | [result: undefined, error: X]>;
+export declare function getResultErrorPromise<E = Error, T = unknown>(promise: PromiseLike<T>): Promise<[result: T, error: undefined] | [result: undefined, error: E]>;

lib/es2015/functions/get-result-error.d.ts

@@ -1,1 +0,1 @@
-export declare function getResultError<X = Error, T = unknown>(fn: () => T): [result: T, error: undefined] | [result: undefined, error: X];
+export declare function getResultError<E = Error, T = unknown>(fn: () => T): [result: T, error: undefined] | [result: undefined, error: E];

lib/es2015/functions/get-success-async.d.ts

@@ -1,1 +0,2 @@
-export declare function getSuccessAsync<T>(fn: () => PromiseLike<T> | T): Promise<[succeeded: true, result: T] | [succeeded: false, result: undefined]>;
+import { Awaitable } from '@blackglory/prelude';
+export declare function getSuccessAsync<T>(fn: () => Awaitable<T>): Promise<[succeeded: true, result: T] | [succeeded: false, result: undefined]>;

lib/es2015/functions/is-failure-async.d.ts

@@ -1,1 +0,2 @@
-export declare function isFailureAsync(fn: () => Promise<unknown> | unknown): Promise<boolean>;
+import { Awaitable } from '@blackglory/prelude';
+export declare function isFailureAsync(fn: () => Awaitable<unknown>): Promise<boolean>;

lib/es2015/functions/is-success-async.d.ts

@@ -1,1 +0,2 @@
-export declare function isSuccessAsync(fn: () => PromiseLike<unknown> | unknown): Promise<boolean>;
+import { Awaitable } from '@blackglory/prelude';
+export declare function isSuccessAsync(fn: () => Awaitable<unknown>): Promise<boolean>;

lib/es2015/functions/to-result-async.d.ts

@@ -1,2 +0,3 @@
-import { IAsyncResult } from '../classes/async-result';
-export declare function toResultAsync<X = Error, T = unknown>(fn: () => PromiseLike<T> | T): IAsyncResult<T, X>;
+import { Result } from '../classes/result';
+import { Awaitable } from '@blackglory/prelude';
+export declare function toResultAsync<E = Error, T = unknown>(fn: () => Awaitable<T>): Promise<Result<T, E>>;

lib/es2015/functions/to-result-async.js

 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toResultAsync = void 0;
-const async_result_1 = require("../classes/async-result");
+const result_1 = require("../classes/result");
 function toResultAsync(fn) {
-    try {
-        const result = fn();
-        return new async_result_1.AsyncResult(result);
-    }
-    catch (e) {
-        return async_result_1.AsyncResult.Err(e);
-    }
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const result = yield fn();
+            return result_1.Result.Ok(result);
+        }
+        catch (err) {
+            return result_1.Result.Err(err);
+        }
+    });
 }
 exports.toResultAsync = toResultAsync;
 //# sourceMappingURL=to-result-async.js.map

lib/es2015/functions/to-result-promise.d.ts

@@ -1,2 +0,2 @@
-import { IAsyncResult } from '../classes/async-result';
-export declare function toResultPromise<X = Error, T = unknown>(promise: PromiseLike<T>): IAsyncResult<T, X>;
+import { Result } from '../classes/result';
+export declare function toResultPromise<E = Error, T = unknown>(promise: PromiseLike<T>): Promise<Result<T, E>>;

lib/es2015/functions/to-result-promise.js

 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toResultPromise = void 0;
-const async_result_1 = require("../classes/async-result");
+const result_1 = require("../classes/result");
 function toResultPromise(promise) {
-    return new async_result_1.AsyncResult(promise);
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const result = yield promise;
+            return result_1.Result.Ok(result);
+        }
+        catch (err) {
+            return result_1.Result.Err(err);
+        }
+    });
 }
 exports.toResultPromise = toResultPromise;
 //# sourceMappingURL=to-result-promise.js.map

lib/es2015/functions/to-result.d.ts

@@ -1,2 +0,2 @@
-import { IResult } from '../classes/result';
-export declare function toResult<X = Error, T = unknown>(fn: () => T): IResult<T, X>;
+import { Result } from '../classes/result';
+export declare function toResult<E = Error, T = unknown>(fn: () => T): Result<T, E>;

lib/es2015/index.d.ts

@@ -26,7 +26,9 @@ export { getErrorResult } from './functions/get-error-result';
 export { getErrorAsyncIterable } from './functions/get-error-async-iterable';
+export { Result } from './classes/result';
 export { toResult } from './functions/to-result';
 export { toResultAsync } from './functions/to-result-async';
 export { toResultPromise } from './functions/to-result-promise';
-export { toOptional, toOptionalPartial } from './functions/to-optional';
-export { toOptionalAsync, toOptionalAsyncPartial } from './functions/to-optional-async';
-export { toOptionalPromise, toOptionalPromisePartial } from './functions/to-optional-promise';
+export { Option } from './classes/option';
+export { toOption } from './functions/to-option';
+export { toOptionAsync } from './functions/to-option-async';
+export { toOptionPromise } from './functions/to-option-promise';

lib/es2015/index.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toOptionalPromisePartial = exports.toOptionalPromise = exports.toOptionalAsyncPartial = exports.toOptionalAsync = exports.toOptionalPartial = exports.toOptional = exports.toResultPromise = exports.toResultAsync = exports.toResult = exports.getErrorAsyncIterable = exports.getErrorPromise = exports.getErrorAsync = exports.getError = exports.getResultPromise = exports.getResultAsync = exports.getResult = exports.isFailurePromise = exports.isFailureAsync = exports.isFailure = exports.isSuccessPromise = exports.isSuccessAsync = exports.isSuccess = exports.getFailurePromise = exports.getFailureAsync = exports.getFailure = exports.getSuccessPromise = exports.getSuccessAsync = exports.getSuccess = exports.getResultErrorPromise = exports.getResultErrorAsync = exports.getResultError = exports.getErrorResultPromise = exports.getErrorResultAsync = exports.getErrorResult = void 0;
+exports.toOptionPromise = exports.toOptionAsync = exports.toOption = exports.Option = exports.toResultPromise = exports.toResultAsync = exports.toResult = exports.Result = exports.getErrorAsyncIterable = exports.getErrorPromise = exports.getErrorAsync = exports.getError = exports.getResultPromise = exports.getResultAsync = exports.getResult = exports.isFailurePromise = exports.isFailureAsync = exports.isFailure = exports.isSuccessPromise = exports.isSuccessAsync = exports.isSuccess = exports.getFailurePromise = exports.getFailureAsync = exports.getFailure = exports.getSuccessPromise = exports.getSuccessAsync = exports.getSuccess = exports.getResultErrorPromise = exports.getResultErrorAsync = exports.getResultError = exports.getErrorResultPromise = exports.getErrorResultAsync = exports.getErrorResult = void 0;
 var get_error_result_1 = require("./functions/get-error-result");
@@ -54,2 +54,4 @@ Object.defineProperty(exports, "getErrorResult", { enumerable: true, get: function () { return get_error_result_1.getErrorResult; } });
 Object.defineProperty(exports, "getErrorAsyncIterable", { enumerable: true, get: function () { return get_error_async_iterable_1.getErrorAsyncIterable; } });
+var result_1 = require("./classes/result");
+Object.defineProperty(exports, "Result", { enumerable: true, get: function () { return result_1.Result; } });
 var to_result_1 = require("./functions/to-result");
@@ -61,11 +63,10 @@ Object.defineProperty(exports, "toResult", { enumerable: true, get: function () { return to_result_1.toResult; } });
 Object.defineProperty(exports, "toResultPromise", { enumerable: true, get: function () { return to_result_promise_1.toResultPromise; } });
-var to_optional_1 = require("./functions/to-optional");
-Object.defineProperty(exports, "toOptional", { enumerable: true, get: function () { return to_optional_1.toOptional; } });
-Object.defineProperty(exports, "toOptionalPartial", { enumerable: true, get: function () { return to_optional_1.toOptionalPartial; } });
-var to_optional_async_1 = require("./functions/to-optional-async");
-Object.defineProperty(exports, "toOptionalAsync", { enumerable: true, get: function () { return to_optional_async_1.toOptionalAsync; } });
-Object.defineProperty(exports, "toOptionalAsyncPartial", { enumerable: true, get: function () { return to_optional_async_1.toOptionalAsyncPartial; } });
-var to_optional_promise_1 = require("./functions/to-optional-promise");
-Object.defineProperty(exports, "toOptionalPromise", { enumerable: true, get: function () { return to_optional_promise_1.toOptionalPromise; } });
-Object.defineProperty(exports, "toOptionalPromisePartial", { enumerable: true, get: function () { return to_optional_promise_1.toOptionalPromisePartial; } });
+var option_1 = require("./classes/option");
+Object.defineProperty(exports, "Option", { enumerable: true, get: function () { return option_1.Option; } });
+var to_option_1 = require("./functions/to-option");
+Object.defineProperty(exports, "toOption", { enumerable: true, get: function () { return to_option_1.toOption; } });
+var to_option_async_1 = require("./functions/to-option-async");
+Object.defineProperty(exports, "toOptionAsync", { enumerable: true, get: function () { return to_option_async_1.toOptionAsync; } });
+var to_option_promise_1 = require("./functions/to-option-promise");
+Object.defineProperty(exports, "toOptionPromise", { enumerable: true, get: function () { return to_option_promise_1.toOptionPromise; } });
 //# sourceMappingURL=index.js.map

lib/es2018/classes/result.d.ts

@@ -1,13 +0,24 @@
-export interface IResult<T, X> {
+import { Option } from './option';
+export declare class Result<T, E> {
+    private type;
+    private value?;
+    private error?;
+    private constructor();
+    private constructor();
+    static Ok<T, E>(value: T): Result<T, E>;
+    static Err<T, E>(error: E): Result<T, E>;
     isOk(): boolean;
     isErr(): boolean;
-    onOk(callback: (val: T) => void): IResult<T, X>;
-    onErr(callback: (err: X) => void): IResult<T, X>;
-    orElse<U>(defaultValue: U): IResult<T, never> | IResult<U, never>;
-    map<U>(mapper: (val: T) => U): IResult<U, X>;
-    get(): T;
+    map<U>(mapper: (val: T) => U): Result<U, E>;
+    mapOr<U>(defaultValue: U, mapper: (val: T) => U): Result<U, E>;
+    mapOrElse<U>(createDefaultValue: (err: E) => U, mapper: (val: T) => U): Result<U, E>;
+    mapErr<U>(mapper: (err: E) => U): Result<T, U>;
+    unwrap(): T;
+    unwrapOr<U>(defaultValue: U): T | U;
+    unwrapOrElse<U>(createDefaultValue: (err: E) => U): T | U;
+    unwrapErr(): E;
+    expect(message: string): T;
+    expectErr(message: string): E;
+    ok(): Option<T>;
+    err(): Option<E>;
 }
-export declare abstract class Result {
-    static Ok<T>(value: T): IResult<T, never>;
-    static Err<T>(error: T): IResult<never, T>;
-}

lib/es2018/classes/result.js

 "use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _Ok_value, _Err_value;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Result = void 0;
+const option_1 = require("./option");
+var ResultType;
+(function (ResultType) {
+    ResultType[ResultType["Ok"] = 0] = "Ok";
+    ResultType[ResultType["Err"] = 1] = "Err";
+})(ResultType || (ResultType = {}));
 class Result {
+    constructor(type, valueOrError) {
+        this.type = type;
+        if (type === ResultType.Ok) {
+            this.value = valueOrError;
+        }
+        else {
+            this.error = valueOrError;
+        }
+    }
     static Ok(value) {
-        return Ok.of(value);
+        return new Result(ResultType.Ok, value);
     }
     static Err(error) {
-        return Err.of(error);
+        return new Result(ResultType.Err, error);
     }
-}
-exports.Result = Result;
-class Ok extends Result {
-    constructor(value) {
-        super();
-        _Ok_value.set(this, void 0);
-        __classPrivateFieldSet(this, _Ok_value, value, "f");
-    }
-    static of(value) {
-        return new Ok(value);
-    }
     isOk() {
-        return true;
+        return this.type === ResultType.Ok;
     }
     isErr() {
-        return false;
+        return this.type === ResultType.Err;
     }
-    onOk(callback) {
-        callback(__classPrivateFieldGet(this, _Ok_value, "f"));
-        return Ok.of(__classPrivateFieldGet(this, _Ok_value, "f"));
+    map(mapper) {
+        if (this.isOk()) {
+            return Result.Ok(mapper(this.value));
+        }
+        else {
+            return Result.Err(this.error);
+        }
     }
-    onErr() {
-        return Ok.of(__classPrivateFieldGet(this, _Ok_value, "f"));
+    mapOr(defaultValue, mapper) {
+        if (this.isOk()) {
+            return Result.Ok(mapper(this.value));
+        }
+        else {
+            return Result.Ok(defaultValue);
+        }
     }
-    orElse() {
-        return Ok.of(__classPrivateFieldGet(this, _Ok_value, "f"));
+    mapOrElse(createDefaultValue, mapper) {
+        if (this.isOk()) {
+            return Result.Ok(mapper(this.value));
+        }
+        else {
+            return Result.Ok(createDefaultValue(this.error));
+        }
     }
-    map(fn) {
-        return Ok.of(fn(__classPrivateFieldGet(this, _Ok_value, "f")));
+    mapErr(mapper) {
+        if (this.isOk()) {
+            return Result.Ok(this.value);
+        }
+        else {
+            return Result.Err(mapper(this.error));
+        }
     }
-    get() {
-        return __classPrivateFieldGet(this, _Ok_value, "f");
+    unwrap() {
+        if (this.isOk()) {
+            return this.value;
+        }
+        else {
+            throw this.error;
+        }
     }
-}
-_Ok_value = new WeakMap();
-class Err extends Result {
-    constructor(err) {
-        super();
-        _Err_value.set(this, void 0);
-        __classPrivateFieldSet(this, _Err_value, err, "f");
+    unwrapOr(defaultValue) {
+        if (this.isOk()) {
+            return this.value;
+        }
+        else {
+            return defaultValue;
+        }
     }
-    static of(error) {
-        return new Err(error);
+    unwrapOrElse(createDefaultValue) {
+        if (this.isOk()) {
+            return this.value;
+        }
+        else {
+            return createDefaultValue(this.error);
+        }
     }
-    isOk() {
-        return false;
+    unwrapErr() {
+        if (this.isErr()) {
+            return this.error;
+        }
+        else {
+            throw new Error('unwrapErr called on a Ok');
+        }
     }
-    isErr() {
-        return true;
+    expect(message) {
+        if (this.isOk()) {
+            return this.value;
+        }
+        else {
+            throw new Error(message);
+        }
     }
-    onOk() {
-        return Err.of(__classPrivateFieldGet(this, _Err_value, "f"));
+    expectErr(message) {
+        if (this.isErr()) {
+            return this.error;
+        }
+        else {
+            throw new Error(message);
+        }
     }
-    onErr(callback) {
-        callback(__classPrivateFieldGet(this, _Err_value, "f"));
-        return Err.of(__classPrivateFieldGet(this, _Err_value, "f"));
+    ok() {
+        if (this.isOk()) {
+            return option_1.Option.Some(this.value);
+        }
+        else {
+            return option_1.Option.None();
+        }
     }
-    orElse(defaultValue) {
-        return Ok.of(defaultValue);
+    err() {
+        if (this.isOk()) {
+            return option_1.Option.None();
+        }
+        else {
+            return option_1.Option.Some(this.error);
+        }
     }
-    map() {
-        return Err.of(__classPrivateFieldGet(this, _Err_value, "f"));
-    }
-    get() {
-        throw __classPrivateFieldGet(this, _Err_value, "f");
-    }
 }
-_Err_value = new WeakMap();
+exports.Result = Result;
 //# sourceMappingURL=result.js.map

lib/es2018/functions/get-error-async-iterable.d.ts

@@ -1,1 +0,1 @@
-export declare function getErrorAsyncIterable<X = Error>(iterable: AsyncIterable<unknown>): Promise<X | undefined>;
+export declare function getErrorAsyncIterable<E = Error>(iterable: AsyncIterable<unknown>): Promise<E | undefined>;

lib/es2018/functions/get-error-async-iterable.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getErrorAsyncIterable = void 0;
-const pass_1 = require("@blackglory/pass");
+const prelude_1 = require("@blackglory/prelude");
 async function getErrorAsyncIterable(iterable) {
     try {
         for await (const _ of iterable) {
-            (0, pass_1.pass)();
+            (0, prelude_1.pass)();
         }
@@ -10,0 +10,0 @@ }

lib/es2018/functions/get-error-async.d.ts

@@ -1,1 +0,2 @@
-export declare function getErrorAsync<X = Error>(fn: () => PromiseLike<unknown> | unknown): Promise<X | undefined>;
+import { Awaitable } from '@blackglory/prelude';
+export declare function getErrorAsync<E = Error>(fn: () => Awaitable<unknown>): Promise<E | undefined>;

lib/es2018/functions/get-error-promise.d.ts

@@ -1,1 +0,1 @@
-export declare function getErrorPromise<X = Error>(promise: PromiseLike<unknown>): Promise<X | undefined>;
+export declare function getErrorPromise<E = Error>(promise: PromiseLike<unknown>): Promise<E | undefined>;

lib/es2018/functions/get-error-result-async.d.ts

@@ -1,1 +0,2 @@
-export declare function getErrorResultAsync<X = Error, T = unknown>(fn: () => PromiseLike<T> | T): Promise<[error: undefined, result: T] | [error: X, result: undefined]>;
+import { Awaitable } from '@blackglory/prelude';
+export declare function getErrorResultAsync<E = Error, T = unknown>(fn: () => Awaitable<T>): Promise<[error: undefined, result: T] | [error: E, result: undefined]>;

lib/es2018/functions/get-error-result-promise.d.ts

@@ -1,1 +0,1 @@
-export declare function getErrorResultPromise<X = Error, T = unknown>(promise: PromiseLike<T>): Promise<[error: undefined, result: T] | [error: X, result: undefined]>;
+export declare function getErrorResultPromise<E = Error, T = unknown>(promise: PromiseLike<T>): Promise<[error: undefined, result: T] | [error: E, result: undefined]>;

lib/es2018/functions/get-error-result.d.ts

@@ -1,1 +0,1 @@
-export declare function getErrorResult<X = Error, T = unknown>(fn: () => T): [error: undefined, result: T] | [error: X, result: undefined];
+export declare function getErrorResult<E = Error, T = unknown>(fn: () => T): [error: undefined, result: T] | [error: E, result: undefined];

lib/es2018/functions/get-error.d.ts

@@ -1,1 +0,1 @@
-export declare function getError<X = Error>(fn: () => unknown): X | undefined;
+export declare function getError<E = Error>(fn: () => unknown): E | undefined;

lib/es2018/functions/get-failure-async.d.ts

@@ -1,1 +0,2 @@
-export declare function getFailureAsync<X = Error>(fn: () => PromiseLike<unknown> | unknown): Promise<[failed: true, error: X] | [failed: false, error: undefined]>;
+import { Awaitable } from '@blackglory/prelude';
+export declare function getFailureAsync<E = Error>(fn: () => Awaitable<unknown>): Promise<[failed: true, error: E] | [failed: false, error: undefined]>;

lib/es2018/functions/get-failure-promise.d.ts

@@ -1,1 +0,1 @@
-export declare function getFailurePromise<X = Error>(promise: PromiseLike<unknown>): Promise<[failed: true, error: X] | [failed: false, error: undefined]>;
+export declare function getFailurePromise<E = Error>(promise: PromiseLike<unknown>): Promise<[failed: true, error: E] | [failed: false, error: undefined]>;

lib/es2018/functions/get-failure.d.ts

@@ -1,1 +0,1 @@
-export declare function getFailure<X = Error>(fn: () => unknown): [failed: true, error: X] | [faled: false, error: undefined];
+export declare function getFailure<E = Error>(fn: () => unknown): [failed: true, error: E] | [faled: false, error: undefined];

lib/es2018/functions/get-result-async.d.ts

@@ -1,1 +0,2 @@
-export declare function getResultAsync<T>(fn: () => PromiseLike<T> | T): Promise<T | undefined>;
+import { Awaitable } from '@blackglory/prelude';
+export declare function getResultAsync<T>(fn: () => Awaitable<T>): Promise<T | undefined>;

lib/es2018/functions/get-result-error-async.d.ts

@@ -1,1 +0,2 @@
-export declare function getResultErrorAsync<X = Error, T = unknown>(fn: () => PromiseLike<T> | T): Promise<[result: T, error: undefined] | [result: undefined, error: X]>;
+import { Awaitable } from '@blackglory/prelude';
+export declare function getResultErrorAsync<E = Error, T = unknown>(fn: () => Awaitable<T>): Promise<[result: T, error: undefined] | [result: undefined, error: E]>;

lib/es2018/functions/get-result-error-promise.d.ts

@@ -1,1 +0,1 @@
-export declare function getResultErrorPromise<X = Error, T = unknown>(promise: PromiseLike<T>): Promise<[result: T, error: undefined] | [result: undefined, error: X]>;
+export declare function getResultErrorPromise<E = Error, T = unknown>(promise: PromiseLike<T>): Promise<[result: T, error: undefined] | [result: undefined, error: E]>;

lib/es2018/functions/get-result-error.d.ts

@@ -1,1 +0,1 @@
-export declare function getResultError<X = Error, T = unknown>(fn: () => T): [result: T, error: undefined] | [result: undefined, error: X];
+export declare function getResultError<E = Error, T = unknown>(fn: () => T): [result: T, error: undefined] | [result: undefined, error: E];

lib/es2018/functions/get-success-async.d.ts

@@ -1,1 +0,2 @@
-export declare function getSuccessAsync<T>(fn: () => PromiseLike<T> | T): Promise<[succeeded: true, result: T] | [succeeded: false, result: undefined]>;
+import { Awaitable } from '@blackglory/prelude';
+export declare function getSuccessAsync<T>(fn: () => Awaitable<T>): Promise<[succeeded: true, result: T] | [succeeded: false, result: undefined]>;

lib/es2018/functions/is-failure-async.d.ts

@@ -1,1 +0,2 @@
-export declare function isFailureAsync(fn: () => Promise<unknown> | unknown): Promise<boolean>;
+import { Awaitable } from '@blackglory/prelude';
+export declare function isFailureAsync(fn: () => Awaitable<unknown>): Promise<boolean>;

lib/es2018/functions/is-success-async.d.ts

@@ -1,1 +0,2 @@
-export declare function isSuccessAsync(fn: () => PromiseLike<unknown> | unknown): Promise<boolean>;
+import { Awaitable } from '@blackglory/prelude';
+export declare function isSuccessAsync(fn: () => Awaitable<unknown>): Promise<boolean>;

lib/es2018/functions/to-result-async.d.ts

@@ -1,2 +0,3 @@
-import { IAsyncResult } from '../classes/async-result';
-export declare function toResultAsync<X = Error, T = unknown>(fn: () => PromiseLike<T> | T): IAsyncResult<T, X>;
+import { Result } from '../classes/result';
+import { Awaitable } from '@blackglory/prelude';
+export declare function toResultAsync<E = Error, T = unknown>(fn: () => Awaitable<T>): Promise<Result<T, E>>;

lib/es2018/functions/to-result-async.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toResultAsync = void 0;
-const async_result_1 = require("../classes/async-result");
-function toResultAsync(fn) {
+const result_1 = require("../classes/result");
+async function toResultAsync(fn) {
     try {
-        const result = fn();
-        return new async_result_1.AsyncResult(result);
+        const result = await fn();
+        return result_1.Result.Ok(result);
     }
-    catch (e) {
-        return async_result_1.AsyncResult.Err(e);
+    catch (err) {
+        return result_1.Result.Err(err);
     }
@@ -13,0 +13,0 @@ }

lib/es2018/functions/to-result-promise.d.ts

@@ -1,2 +0,2 @@
-import { IAsyncResult } from '../classes/async-result';
-export declare function toResultPromise<X = Error, T = unknown>(promise: PromiseLike<T>): IAsyncResult<T, X>;
+import { Result } from '../classes/result';
+export declare function toResultPromise<E = Error, T = unknown>(promise: PromiseLike<T>): Promise<Result<T, E>>;

lib/es2018/functions/to-result-promise.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toResultPromise = void 0;
-const async_result_1 = require("../classes/async-result");
-function toResultPromise(promise) {
-    return new async_result_1.AsyncResult(promise);
+const result_1 = require("../classes/result");
+async function toResultPromise(promise) {
+    try {
+        const result = await promise;
+        return result_1.Result.Ok(result);
+    }
+    catch (err) {
+        return result_1.Result.Err(err);
+    }
 }
 exports.toResultPromise = toResultPromise;
 //# sourceMappingURL=to-result-promise.js.map

lib/es2018/functions/to-result.d.ts

@@ -1,2 +0,2 @@
-import { IResult } from '../classes/result';
-export declare function toResult<X = Error, T = unknown>(fn: () => T): IResult<T, X>;
+import { Result } from '../classes/result';
+export declare function toResult<E = Error, T = unknown>(fn: () => T): Result<T, E>;

lib/es2018/index.d.ts

@@ -26,7 +26,9 @@ export { getErrorResult } from './functions/get-error-result';
 export { getErrorAsyncIterable } from './functions/get-error-async-iterable';
+export { Result } from './classes/result';
 export { toResult } from './functions/to-result';
 export { toResultAsync } from './functions/to-result-async';
 export { toResultPromise } from './functions/to-result-promise';
-export { toOptional, toOptionalPartial } from './functions/to-optional';
-export { toOptionalAsync, toOptionalAsyncPartial } from './functions/to-optional-async';
-export { toOptionalPromise, toOptionalPromisePartial } from './functions/to-optional-promise';
+export { Option } from './classes/option';
+export { toOption } from './functions/to-option';
+export { toOptionAsync } from './functions/to-option-async';
+export { toOptionPromise } from './functions/to-option-promise';

lib/es2018/index.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toOptionalPromisePartial = exports.toOptionalPromise = exports.toOptionalAsyncPartial = exports.toOptionalAsync = exports.toOptionalPartial = exports.toOptional = exports.toResultPromise = exports.toResultAsync = exports.toResult = exports.getErrorAsyncIterable = exports.getErrorPromise = exports.getErrorAsync = exports.getError = exports.getResultPromise = exports.getResultAsync = exports.getResult = exports.isFailurePromise = exports.isFailureAsync = exports.isFailure = exports.isSuccessPromise = exports.isSuccessAsync = exports.isSuccess = exports.getFailurePromise = exports.getFailureAsync = exports.getFailure = exports.getSuccessPromise = exports.getSuccessAsync = exports.getSuccess = exports.getResultErrorPromise = exports.getResultErrorAsync = exports.getResultError = exports.getErrorResultPromise = exports.getErrorResultAsync = exports.getErrorResult = void 0;
+exports.toOptionPromise = exports.toOptionAsync = exports.toOption = exports.Option = exports.toResultPromise = exports.toResultAsync = exports.toResult = exports.Result = exports.getErrorAsyncIterable = exports.getErrorPromise = exports.getErrorAsync = exports.getError = exports.getResultPromise = exports.getResultAsync = exports.getResult = exports.isFailurePromise = exports.isFailureAsync = exports.isFailure = exports.isSuccessPromise = exports.isSuccessAsync = exports.isSuccess = exports.getFailurePromise = exports.getFailureAsync = exports.getFailure = exports.getSuccessPromise = exports.getSuccessAsync = exports.getSuccess = exports.getResultErrorPromise = exports.getResultErrorAsync = exports.getResultError = exports.getErrorResultPromise = exports.getErrorResultAsync = exports.getErrorResult = void 0;
 var get_error_result_1 = require("./functions/get-error-result");
@@ -54,2 +54,4 @@ Object.defineProperty(exports, "getErrorResult", { enumerable: true, get: function () { return get_error_result_1.getErrorResult; } });
 Object.defineProperty(exports, "getErrorAsyncIterable", { enumerable: true, get: function () { return get_error_async_iterable_1.getErrorAsyncIterable; } });
+var result_1 = require("./classes/result");
+Object.defineProperty(exports, "Result", { enumerable: true, get: function () { return result_1.Result; } });
 var to_result_1 = require("./functions/to-result");
@@ -61,11 +63,10 @@ Object.defineProperty(exports, "toResult", { enumerable: true, get: function () { return to_result_1.toResult; } });
 Object.defineProperty(exports, "toResultPromise", { enumerable: true, get: function () { return to_result_promise_1.toResultPromise; } });
-var to_optional_1 = require("./functions/to-optional");
-Object.defineProperty(exports, "toOptional", { enumerable: true, get: function () { return to_optional_1.toOptional; } });
-Object.defineProperty(exports, "toOptionalPartial", { enumerable: true, get: function () { return to_optional_1.toOptionalPartial; } });
-var to_optional_async_1 = require("./functions/to-optional-async");
-Object.defineProperty(exports, "toOptionalAsync", { enumerable: true, get: function () { return to_optional_async_1.toOptionalAsync; } });
-Object.defineProperty(exports, "toOptionalAsyncPartial", { enumerable: true, get: function () { return to_optional_async_1.toOptionalAsyncPartial; } });
-var to_optional_promise_1 = require("./functions/to-optional-promise");
-Object.defineProperty(exports, "toOptionalPromise", { enumerable: true, get: function () { return to_optional_promise_1.toOptionalPromise; } });
-Object.defineProperty(exports, "toOptionalPromisePartial", { enumerable: true, get: function () { return to_optional_promise_1.toOptionalPromisePartial; } });
+var option_1 = require("./classes/option");
+Object.defineProperty(exports, "Option", { enumerable: true, get: function () { return option_1.Option; } });
+var to_option_1 = require("./functions/to-option");
+Object.defineProperty(exports, "toOption", { enumerable: true, get: function () { return to_option_1.toOption; } });
+var to_option_async_1 = require("./functions/to-option-async");
+Object.defineProperty(exports, "toOptionAsync", { enumerable: true, get: function () { return to_option_async_1.toOptionAsync; } });
+var to_option_promise_1 = require("./functions/to-option-promise");
+Object.defineProperty(exports, "toOptionPromise", { enumerable: true, get: function () { return to_option_promise_1.toOptionPromise; } });
 //# sourceMappingURL=index.js.map

package.json

 {
   "name": "return-style",
-  "version": "0.12.6",
+  "version": "1.0.0",
   "description": "Non-intrusively convert the result of any function or promise to the user's desired style.",
@@ -59,31 +59,30 @@ "keywords": [
   "devDependencies": {
-    "@blackglory/jest-matchers": "^0.2.1",
-    "@blackglory/types": "^0.6.5",
-    "@commitlint/cli": "^16.0.1",
-    "@commitlint/config-conventional": "^16.0.0",
-    "@rollup/plugin-typescript": "^8.3.0",
-    "@types/jest": "^27.4.0",
+    "@blackglory/jest-matchers": "^0.3.1",
+    "@blackglory/types": "^1.0.0",
+    "@commitlint/cli": "^16.2.3",
+    "@commitlint/config-conventional": "^16.2.1",
+    "@rollup/plugin-typescript": "^8.3.1",
+    "@types/jest": "^27.4.1",
     "@types/node": "14",
-    "@typescript-eslint/eslint-plugin": "^5.9.0",
-    "@typescript-eslint/parser": "^5.9.0",
-    "eslint": "^8.6.0",
+    "@typescript-eslint/eslint-plugin": "^5.15.0",
+    "@typescript-eslint/parser": "^5.15.0",
+    "eslint": "^8.11.0",
     "husky": "4",
-    "iterable-operator": "^0.14.5",
-    "jest": "^27.4.7",
-    "jest-extended": "^1.2.0",
+    "iterable-operator": "^1.0.0",
+    "jest": "^27.5.1",
+    "jest-extended": "^2.0.0",
     "npm-run-all": "^4.1.5",
     "rimraf": "^3.0.2",
-    "rollup": "^2.63.0",
+    "rollup": "^2.70.1",
     "rollup-plugin-analyzer": "^4.0.0",
     "rollup-plugin-terser": "^7.0.2",
     "standard-version": "^9.3.2",
-    "ts-jest": "^27.1.2",
+    "ts-jest": "^27.1.3",
     "tscpaths": "^0.0.9",
     "tslib": "^2.3.1",
-    "typescript": "^4.5.2"
+    "typescript": "^4.6.2"
   },
   "dependencies": {
-    "@blackglory/go": "^0.1.1",
-    "@blackglory/pass": "^0.1.0"
+    "@blackglory/prelude": "^0.1.0"
   }
 }

README.md

 # return-style
-
 Non-intrusively convert the result of any function or promise to the user's desired style.
 
 ## Install
-
 ```sh
@@ -14,3 +12,2 @@ npm install --save return-style
 ## API
-
 All functions whose names are suffixed with `Async` can handle synchronous errors.
@@ -20,9 +17,10 @@ If you only need to catch asynchronous errors, use functions with the suffix `Promise`.
 ### isSuccess
+```ts
+function isSuccess(fn: () => unknown): boolean
+function isSuccessAsync(fn: () => Awaitable<unknown>): Promise<boolean>
+function isSuccessPromise(promise: PromiseLike<unknown>): Promise<boolean>
+```
 
 Return true when returning, false when throwing.
 
-- `function isSuccess(fn: () => unknown): boolean`
-- `function isSuccessAsync(fn: () => PromiseLike<unknown> | unknown): Promise<boolean>`
-- `function isSuccessPromise(promise: PromiseLike<unknown>): Promise<boolean>`
-
 ```ts
@@ -43,9 +41,10 @@ if (isSuccess(() => fn())) {
 ### isFailure
+```ts
+function isFailure(fn: () => unknown): boolean
+function isFailureAsync(fn: () => Awaitable<unknown>): Promise<boolean>
+function isFailurePromise(promise: PromiseLike<unknown>): Promise<boolean>
+```
 
 Return true when throwing, true when returning.
 
-- `function isFailure(fn: () => unknown): boolean`
-- `function isFailureAsync(fn: () => PromiseLike<unknown> | unknown): Promise<boolean>`
-- `function isFailurePromise(promise: PromiseLike<unknown>): Promise<boolean>`
-
 ```ts
@@ -66,7 +65,8 @@ if (isFailure(() => fn())) {
 ### getResult
+```ts
+function getResult<T>(fn: () => T): T | undefined
+function getResultAsync<T>(fn: () => Awaitable<T>): Promise<T | undefined>
+function getResultPromise<T>(promise: PromiseLike<T>): Promise<T | undefined>
+```
 
-- `function getResult<T>(fn: () => T): T | undefined`
-- `function getResultAsync<T>(fn: () => PromiseLike<T> | T): Promise<T | undefined>`
-- `function getResultPromise<T>(promise: PromiseLike<T>): Promise<T | undefined>`
-
 ```js
@@ -90,10 +90,11 @@ const result = getResult(() => fn())
 ### getError
+```ts
+function getError<E>(fn: () => unknown): E | undefined
+function getErrorAsync<E>(fn: () => Awaitable<unknown>): Promise<E | undefined>
+function getErrorPromise<E>(promise: PromiseLike<unknown>): Promise<E | undefined>
+function getErrorAsyncIterable<E>(iterable: AsyncIterable<unknown>): Promise<E | undefined>
+```
 
 Designed for testing, helping to achieve Arrange-Act-Assert pattern.
 
-- `function getError<X>(fn: () => unknown): X | undefined`
-- `function getErrorAsync<X>(fn: () => PromiseLike<unknown> | unknown): Promise<X | undefined>`
-- `function getErrorPromise<X>(promise: PromiseLike<unknown>): Promise<X | undefined>`
-- `function getErrorAsyncIterable<X>(iterable: AsyncIterable<unknown>): Promise<X | undefined>`
-
 ```js
@@ -131,13 +132,14 @@ // BAD: try...catch
 ### Tuple / Go-like
-
 Since modern JavaScript does not advocate repeated declarations of variables (`var`), this style can sometimes be difficult to use.
 
 #### [Error, Result]
+```ts
+function getErrorResult<E = Error, T = unknown>(fn: () => T): [undefined, T] | [E, undefined]
+function getErrorResultAsync<E = Error, T = unknown>(fn: () => Awaitable<T>): Promise<[undefined, T] | [E, undefined]>
+function getErrorResultPromise<E = Error, T = unknown>(promise: PromiseLike<T>): Promise<[undefined, T] | [E, undefined]>
 
+```
+
 Return tuple (Error, Result).
 
-- `function getErrorResult<X = Error, T = unknown>(fn: () => T): [undefined, T] | [X, undefined]`
-- `function getErrorResultAsync<X = Error, T = unknown>(fn: () => PromiseLike<T> | T): Promise<[undefined, T] | [X, undefined]>`
-- `function getErrorResultPromise<X = Error, T = unknown>(promise: PromiseLike<T>): Promise<[undefined, T] | [X, undefined]>`
-
 ```ts
@@ -155,9 +157,10 @@ const [err, ret] = getErrorResult(() => fn())
 #### [Result, Error]
+```ts
+function getResultError<E = Error, T = unknown>(fn: () => T): [T, undefined] | [undefined, E]
+function getResultErrorAsync<E = Error, T = unknown>(fn: () => Awaitable<T>): Promise<[T, undefined] | [undefined, E]>
+function getResultErrorPromise<E = Error, T = unknown>(promise: PromiseLike<T>): Promise<[T, undefined] | [undefined, E]>
+```
 
 Return tuple (Result, Error).
 
-- `function getResultError<X = Error, T = unknown>(fn: () => T): [T, undefined] | [undefined, X]`
-- `function getResultErrorAsync<X = Error, T = unknown>(fn: () => PromiseLike<T> | T): Promise<[T, undefined] | [undefined, X]>`
-- `function getResultErrorPromise<X = Error, T = unknown>(promise: PromiseLike<T>): Promise<[T, undefined] | [undefined, X]>`
-
 ```ts
@@ -175,9 +178,10 @@ const [ret, err] = getResultError(() => fn())
 #### [isSuccess, Result | undefined]
+```ts
+function getSuccess<T>(fn: () => T): [true, T] | [false, undefined]
+function getSuccessAsync<T>(fn: () => Awaitable<T>): Promise<[true, T] | [false, undefined]>
+function getSuccessPromise<T>(promise: PromiseLike<T>): Promise<[true, T] | [false, undefined]>
+```
 
 Return tuple (isSuccess, Result | undefined)
 
-- `function getSuccess<T>(fn: () => T): [true, T] | [false, undefined]`
-- `function getSuccessAsync<T>(fn: () => PromiseLike<T> | T): Promise<[true, T] | [false, undefined]>`
-- `function getSuccessPromise<T>(promise: PromiseLike<T>): Promise<[true, T] | [false, undefined]>`
-
 ```ts
@@ -192,9 +196,10 @@ const [succ, ret] = getSuccess(() => fn())
 #### [isFailure, Error | undefined ]
+```ts
+function getFailure<E = Error>(fn: () => unknown): [true, E] | [false, undefined]
+function getFailureAsync<E = Error>(fn: () => Awaitable<unknown>): Promise<[true, E] | [false, undefined]>
+function getFailurePromise<E = Error>(promise: PromiseLike<unknown>): Promise<[true, E] | [false, undefined]>
+```
 
 Return tuple (isFailure, Error | undefined)
 
-- `function getFailure<X = Error>(fn: () => unknown): [true, X] | [false, undefined]`
-- `function getFailureAsync<X = Error>(fn: () => PromiseLike<unknown> | unknown): Promise<[true, X] | [false, undefined]>`
-- `function getFailurePromise<X = Error>(promise: PromiseLike<unknown>): Promise<[true, X] | [false, undefined]>`
-
 ```ts
@@ -209,13 +214,16 @@ const [fail, ret] = getFailure(() => fn())
 ### ADT / Rust-like / Haskell-like
+#### Result<T, E> = Ok<T> | Err<E>
+```ts
+function toResult<E = Error, T = unknown>(fn: () => T): Result<T, E>
+function toResultAsync<E = Error, T = unknown>(fn: () => Awaitable<T>): Promise<Result<T, E>>
+function toResultPromise<E = Error, T = unknown>(promise: PromiseLike<T>): Promise<Result<T, E>>
+```
 
-#### Result<T, X> = Ok<T> | Err<X>
+`Result` is designed according to Rust's enumeration of the same name,
+please refer to the relevant documentation.
 
-- `function toResult<X = Error, T = unknown>(fn: () => T): Result<T, X>`
-- `function toResultAsync<X = Error, T = unknown>(fn: () => PromiseLike<T> | T): AsyncResult<T, X>`
-- `function toResultPromise<X = Error, T = unknown>(promise: PromiseLike<T>): AsyncResult<T, X>`
-
 ```ts
-interface Result<T, X> {
-  onOk(callback: (val: T) => void): Result<T, X>
-  onErr(callback: (err: X) => void): Result<T, X>
+class Result<T, E> {
+  static Ok(val: T) => Result<T, E>
+  static Err(err: E) => Result<never, E>
 
@@ -225,35 +233,49 @@ isOk(): boolean
 
-  orElse<U>(defaultValue: U): Result<T | U, never>
-  map<U>(mapper: (val: T) => U): Result<U, X>
+  map<U>(mapper: (val: T) => U): Result<U, E>
+  mapOr<U>(defaultValue: U, mapper: (val: T) => U): Result<U, E>
+  mapOrElse<U>(createDefaultValue: (err: E) => U, mapper: (val: T) => U): Result<U, E>
+  mapErr<U>(mapper: (err: E) => U): Result<T, U>
 
-  get(): T
-}
+  /**
+   * @throws {E}
+   */
+  unwrap(): T
 
-interface AsyncResult<T, X> extends PromiseLike<Result<T, X>> {
-  onOk(callback: (val: T) => void): AsyncResult<T, X>
-  onErr(callback: (err: X) => void): AsyncResult<T, X>
+  unwrapOr<U>(defaultValue: U): T | U
+  unwrapOrElse<U>(createDefaultValue: (err: E) => U): T | U
 
-  isOk(): Promise<boolean>
-  isErr(): Promise<boolean>
+  /**
+   * @throws {Error}
+   */
+  unwrapErr(): E
 
-  orElse<U>(defaultValue: U): AsyncResult<T | U, never>
-  map<U>(mapper: (val: T) => U): AsyncResult<U, X>
+  /**
+   * @throws {Error}
+   */
+  expect(message: string): T
 
-  get(): Promise<T>
+  /**
+   * @throws {Error}
+   */
+  expectErr(message: string): E
+
+  ok(): Option<T>
+  err(): Option<E>
 }
 ```
 
-#### Optional<T> = Some<T> | None
+#### Option<T> = Some<T> | None
+```ts
+function toOption<T>(fn: () => T): Option<T>
+function toOptionAsync<T>(fn: () => Awaitable<T>): Promise<Option<T>>
+function toOptionPromise<T>(promise: PromiseLike<T>): Promise<Option<T>>
+```
 
-- `function toOptional<T>(fn: () => T, isNone: (val: T) => boolean): Optional<T>`
-- `function toOptionalPartial<T>(isNone: (val: T) => boolean): (fn: () => T | U) => Optional<T>`
-- `function toOptionalAsync<T>(fn: () => Promise<T> | T , isNone: (val: T) => boolean): AsyncOptional<T>`
-- `function toOptionalAsyncPartial<T>(isNone: (val: T) => boolean): (fn: () => PromiseLike<T> | T) => AsyncOptional<T>`
-- `function toOptionalPromise<T>(promise: PromiseLike<T>, isNone: (val: T) => boolean): AsyncOptional<T>`
-- `function toOptionalPromisePartial<T>(isNone: (val: T) => boolean): (promise: PromiseLike<T>) => AsyncOptional<T>`
+`Option` is designed according to Rust's enumeration of the same name,
+please refer to the relevant documentation.
 
 ```ts
-interface Optional<T> {
-  onSome(callback: (val: T) => void): Optional<T>
-  onNone(callback: () => void): Optional<T>
+class Option<T> {
+  static Some<T>(val: T) => Option<T>
+  static None<T>() => Option<T>
 
@@ -263,22 +285,24 @@ isSome(): boolean
 
-  orElse<U>(defaultValue: U): Optional<T | U>
-  map<U>(mapper: (val: T) => U): Optional<U>
-  filter<U extends T = T>(predicate: (val: T) => boolean): Optional<U>
+  map<U>(mapper: (val: T) => U): Option<U>
+  mapOr<U>(defaultValue: U, mapper: (val: T) => U): Option<U>
+  mapOrElse<U>(createDefaultValue: () => U, mapper: (val: T) => U): Option<U>
 
-  get(): T
-}
+  filter<U extends T = T>(predicate: (val: T) => boolean): Option<U>
 
-interface AsyncOptional<T> extends PromiseLike<Optional<T>> {
-  onSome(callback: (val: T) => void): AsyncOptional<T>
-  onNone(callback: () => void): AsyncOptional<T>
+  /**
+   * @throws {Error} 
+   */
+  unwrap(): T
 
-  isSome(): Promise<boolean>
-  isNone(): Promise<boolean>
+  unwrapOr<U>(defaultValue: U): T | U
+  unwrapOrElse<U>(createDefaultValue: () => U): T | U
 
-  orElse<U>(defaultValue: U): AsyncOptional<T | U>
-  map<U>(mapper: (val: T) => U): AsyncOptional<U>
-  filter<U extends T = T>(predicate: (val: T) => boolean): AsyncOptional<U>
+  /**
+   * @throws {Error}
+   */
+  expect(message: string): T
 
-  get(): Promise<T>
+  okOr<E>(err: E): Result<T, E>
+  okOrElse<E>(createErr: () => E): Result<T, E>
 }
 ```

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Dependency count

1

decreased by-50%

Number of low quality alerts

3

decreased by-25%

Number of lines in readme file

297

increased by8.79%

Worsened metrics

Total package byte prevSize

459793

decreased by-27.73%

Number of package files

223

decreased by-5.11%

Lines of code

4449

decreased by-16.12%

Dependency changes

• + Added@blackglory/prelude@^0.1.0

• + Added@blackglory/errors@2.4.3(transitive)

• + Added@blackglory/go@1.1.3(transitive)

• + Added@blackglory/log@1.3.5(transitive)

• + Added@blackglory/pass@1.1.1(transitive)

• + Added@blackglory/prelude@0.1.100.2.4(transitive)

• + Added@blackglory/structures@0.11.8(transitive)

• + Added@blackglory/types@1.4.0(transitive)

• + Addedextra-compatible@0.1.8(transitive)

• + Addedextra-fsm@0.1.1(transitive)

• + Addedextra-generator@0.2.23(transitive)

• + Addedextra-json-stable-stringify@0.1.2(transitive)

• + Addedextra-lazy@1.3.1(transitive)

• + Addedextra-promise@4.4.1(transitive)

• + Addedextra-rand@0.1.5(transitive)

• + Addedextra-timers@0.2.6(transitive)

• + Addedextra-utils@3.7.04.0.1(transitive)

• + Addedfast-stable-stringify@1.0.0(transitive)

• + Addedhotypes@0.5.1(transitive)

• + Addediterable-operator@2.5.0(transitive)

• + Addedjustypes@2.3.03.1.24.3.0(transitive)

• + Addedlodash@4.17.21(transitive)

• + Addedrxjs@7.8.1(transitive)

• + Addedtslib@2.7.0(transitive)

• - Removed@blackglory/go@^0.1.1

• - Removed@blackglory/pass@^0.1.0

• - Removed@blackglory/go@0.1.1(transitive)

• - Removed@blackglory/pass@0.1.0(transitive)