@zokugun/xtry 0.11.5 → 0.12.0

package/lib/cjs/partial.cjs

@@ -1,28 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.YOK_UNDEFINED = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK_FALSE = exports.YOK = void 0;
-exports.yok = yok;
+exports.yep = yep;
 exports.yerr = yerr;
+exports.yok = yok;
 exports.yres = yres;
-exports.yresSync = yresSync;
 exports.yresAsync = yresAsync;
-exports.yep = yep;
+exports.yresSync = yresSync;
 const is_promise_like_js_1 = require("./utils/is-promise-like.cjs");
-function yok(value) {
+function yep(result) {
     return {
-        fails: false,
+        ...result,
         success: true,
-        value: value,
-        error: undefined,
     };
 }
-function yerr(miscue) {
+function yerr(issue) {
     return {
+        error: undefined,
         fails: false,
+        issue,
         success: false,
-        miscue,
         value: undefined,
+    };
+}
+function yok(value) {
+    return {
         error: undefined,
+        fails: false,
+        success: true,
+        value: value,
     };
 }
 function yres(result) {
@@ -31,21 +37,15 @@ function yres(result) {
     }
     return yresSync(result);
 }
+async function yresAsync(promise) {
+    return promise.then(yresSync);
+}
 function yresSync(result) {
     if (result.fails) {
         return result;
     }
     return yep(result);
 }
-async function yresAsync(promise) {
-    return promise.then(yresSync);
-}
-function yep(result) {
-    return {
-        ...result,
-        success: true,
-    };
-}
 exports.YOK = Object.freeze(yok());
 exports.YOK_FALSE = Object.freeze(yok(false));
 exports.YOK_NULL = Object.freeze(yok(null));

package/lib/cjs/partial.d.cts

@@ -1,25 +1,28 @@
-import { type Result, type Failure, type Success } from './result.cjs';
-import { type NotPromise } from './utils/types.cjs';
-export type YResult<T, E, M> = Failure<E> | YSuccess<T> | YFailure<M>;
-export type YSuccess<T> = Success<T> & {
-    success: true;
-};
-export type YFailure<M> = {
+import type { Failure, Result, Success } from './result.cjs';
+import type { NotPromise } from './utils/types.cjs';
+export type AsyncYDResult<T = void, E = string, I = string> = Promise<YResult<T, E, I>>;
+export type AsyncYResult<T, E, I> = Promise<YResult<T, E, I>>;
+export type YDResult<T = void, E = string, I = string> = YResult<T, E, I>;
+export type YFailure<I> = {
+    error: undefined;
     fails: false;
+    issue: I;
     success: false;
-    miscue: M;
     value: undefined;
-    error: undefined;
 };
+export type YResult<T, E, I> = Failure<E> | YFailure<I> | YSuccess<T>;
+export type YSuccess<T> = {
+    success: true;
+} & Success<T>;
+type YRResult<T, E> = Failure<E> | YSuccess<T>;
+export declare function yep<T>(result: Success<T>): YSuccess<T>;
+export declare function yerr<I>(issue: I): YFailure<I>;
 export declare function yok(): YSuccess<void>;
 export declare function yok<T>(value: T): YSuccess<T>;
-export declare function yerr<M>(miscue: M): YFailure<M>;
-type YRResult<T, E> = Failure<E> | YSuccess<T>;
 export declare function yres<T, E>(result: NotPromise<Result<T, E>>): YRResult<T, E>;
 export declare function yres<T, E>(result: Promise<Result<T, E>>): Promise<YRResult<T, E>>;
-export declare function yresSync<T, E>(result: NotPromise<Result<T, E>>): YRResult<T, E>;
 export declare function yresAsync<T, E>(promise: Promise<Result<T, E>>): Promise<YRResult<T, E>>;
-export declare function yep<T>(result: Success<T>): YSuccess<T>;
+export declare function yresSync<T, E>(result: NotPromise<Result<T, E>>): YRResult<T, E>;
 export declare const YOK: Readonly<YSuccess<void>>;
 export declare const YOK_FALSE: Readonly<YSuccess<boolean>>;
 export declare const YOK_NULL: Readonly<YSuccess<null>>;

package/lib/cjs/result.cjs

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OK_UNDEFINED = exports.OK_TRUE = exports.OK_NULL = exports.OK_FALSE = exports.OK = void 0;
-exports.ok = ok;
 exports.err = err;
-function ok(value) {
-    return {
-        fails: false,
-        value: value,
-        error: undefined,
-    };
-}
+exports.ok = ok;
 function err(error) {
     return {
+        error,
         fails: true,
         value: undefined,
-        error,
+    };
+}
+function ok(value) {
+    return {
+        error: undefined,
+        fails: false,
+        value: value,
     };
 }
 exports.OK = Object.freeze(ok());

package/lib/cjs/result.d.cts

@@ -1,20 +1,20 @@
-export type Success<T> = {
-    fails: false;
-    value: T;
-    error: undefined;
-};
+export type AsyncDResult<T = void, E = string> = AsyncResult<T, E>;
+export type AsyncResult<T, E> = Promise<Result<T, E>>;
+export type DResult<T = void, E = string> = Result<T, E>;
 export type Failure<E> = {
+    error: E;
     fails: true;
     value: undefined;
-    error: E;
 };
-export type Result<T, E> = Success<T> | Failure<E>;
-export type AsyncResult<T, E> = Promise<Result<T, E>>;
-export type DResult<T = void, E = string> = Result<T, E>;
-export type AsyncDResult<T = void, E = string> = AsyncResult<T, E>;
+export type Result<T, E> = Failure<E> | Success<T>;
+export type Success<T> = {
+    error: undefined;
+    fails: false;
+    value: T;
+};
+export declare function err<E>(error: E): Failure<E>;
 export declare function ok(): Success<void>;
 export declare function ok<T>(value: T): Success<T>;
-export declare function err<E>(error: E): Failure<E>;
 export declare const OK: Readonly<Success<void>>;
 export declare const OK_FALSE: Readonly<Success<boolean>>;
 export declare const OK_NULL: Readonly<Success<null>>;

package/lib/cjs/sync.cjs

@@ -1,28 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.xtryifyIterable = exports.xtryify = exports.xtryifyAsyncIterable = exports.xtryifyAsync = exports.xtryIterable = exports.xtry = exports.xtryAsyncIterable = exports.xtryAsync = exports.xtryUnknown = exports.toStringFailure = exports.stringifyError = exports.OK_UNDEFINED = exports.OK_TRUE = exports.OK_NULL = exports.OK_FALSE = exports.OK = exports.err = exports.ok = exports.YOK_UNDEFINED = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK_FALSE = exports.YOK = exports.yep = exports.yres = exports.yresAsync = exports.yresUnknown = exports.yerr = exports.yok = exports.parseJson = exports.parseJSON = exports.xdefer = exports.xdeferAsync = exports.xdeferUnknown = void 0;
+exports.unwrapOr = exports.unwrap = exports.match = exports.map = exports.xtryifyIterable = exports.xtryifyAsyncIterable = exports.xtryifyAsync = exports.xtryify = exports.xtryUnknown = exports.xtryIterable = exports.xtryAsyncIterable = exports.xtryAsync = exports.xtry = exports.toStringFailure = exports.stringifyError = exports.OK_UNDEFINED = exports.OK_TRUE = exports.OK_NULL = exports.OK_FALSE = exports.OK = exports.ok = exports.err = exports.yresUnknown = exports.yresAsync = exports.yres = exports.YOK_UNDEFINED = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK_FALSE = exports.YOK = exports.yok = exports.yerr = exports.yep = exports.parseJson = exports.parseJSON = exports.xdeferUnknown = exports.xdeferAsync = exports.xdefer = void 0;
 var defer_js_1 = require("./defer.cjs");
-Object.defineProperty(exports, "xdeferUnknown", { enumerable: true, get: function () { return defer_js_1.xdefer; } });
-Object.defineProperty(exports, "xdeferAsync", { enumerable: true, get: function () { return defer_js_1.xdeferAsync; } });
 Object.defineProperty(exports, "xdefer", { enumerable: true, get: function () { return defer_js_1.xdeferSync; } });
+Object.defineProperty(exports, "xdeferAsync", { enumerable: true, get: function () { return defer_js_1.xdeferAsync; } });
+Object.defineProperty(exports, "xdeferUnknown", { enumerable: true, get: function () { return defer_js_1.xdefer; } });
 var json_js_1 = require("./json.cjs");
 Object.defineProperty(exports, "parseJSON", { enumerable: true, get: function () { return json_js_1.parseJSON; } });
 Object.defineProperty(exports, "parseJson", { enumerable: true, get: function () { return json_js_1.parseJson; } });
 var partial_js_1 = require("./partial.cjs");
-Object.defineProperty(exports, "yok", { enumerable: true, get: function () { return partial_js_1.yok; } });
-Object.defineProperty(exports, "yerr", { enumerable: true, get: function () { return partial_js_1.yerr; } });
-Object.defineProperty(exports, "yresUnknown", { enumerable: true, get: function () { return partial_js_1.yres; } });
-Object.defineProperty(exports, "yresAsync", { enumerable: true, get: function () { return partial_js_1.yresAsync; } });
-Object.defineProperty(exports, "yres", { enumerable: true, get: function () { return partial_js_1.yresSync; } });
 Object.defineProperty(exports, "yep", { enumerable: true, get: function () { return partial_js_1.yep; } });
+Object.defineProperty(exports, "yerr", { enumerable: true, get: function () { return partial_js_1.yerr; } });
+Object.defineProperty(exports, "yok", { enumerable: true, get: function () { return partial_js_1.yok; } });
 Object.defineProperty(exports, "YOK", { enumerable: true, get: function () { return partial_js_1.YOK; } });
 Object.defineProperty(exports, "YOK_FALSE", { enumerable: true, get: function () { return partial_js_1.YOK_FALSE; } });
 Object.defineProperty(exports, "YOK_NULL", { enumerable: true, get: function () { return partial_js_1.YOK_NULL; } });
 Object.defineProperty(exports, "YOK_TRUE", { enumerable: true, get: function () { return partial_js_1.YOK_TRUE; } });
 Object.defineProperty(exports, "YOK_UNDEFINED", { enumerable: true, get: function () { return partial_js_1.YOK_UNDEFINED; } });
+Object.defineProperty(exports, "yres", { enumerable: true, get: function () { return partial_js_1.yresSync; } });
+Object.defineProperty(exports, "yresAsync", { enumerable: true, get: function () { return partial_js_1.yresAsync; } });
+Object.defineProperty(exports, "yresUnknown", { enumerable: true, get: function () { return partial_js_1.yres; } });
 var result_js_1 = require("./result.cjs");
-Object.defineProperty(exports, "ok", { enumerable: true, get: function () { return result_js_1.ok; } });
 Object.defineProperty(exports, "err", { enumerable: true, get: function () { return result_js_1.err; } });
+Object.defineProperty(exports, "ok", { enumerable: true, get: function () { return result_js_1.ok; } });
 Object.defineProperty(exports, "OK", { enumerable: true, get: function () { return result_js_1.OK; } });
 Object.defineProperty(exports, "OK_FALSE", { enumerable: true, get: function () { return result_js_1.OK_FALSE; } });
 Object.defineProperty(exports, "OK_NULL", { enumerable: true, get: function () { return result_js_1.OK_NULL; } });
@@ -33,13 +33,18 @@ Object.defineProperty(exports, "stringifyError", { enumerable: true, get: functi
 var to_string_failure_js_1 = require("./to-string-failure.cjs");
 Object.defineProperty(exports, "toStringFailure", { enumerable: true, get: function () { return to_string_failure_js_1.toStringFailure; } });
 var try_js_1 = require("./try.cjs");
-Object.defineProperty(exports, "xtryUnknown", { enumerable: true, get: function () { return try_js_1.xtry; } });
+Object.defineProperty(exports, "xtry", { enumerable: true, get: function () { return try_js_1.xtrySync; } });
 Object.defineProperty(exports, "xtryAsync", { enumerable: true, get: function () { return try_js_1.xtryAsync; } });
 Object.defineProperty(exports, "xtryAsyncIterable", { enumerable: true, get: function () { return try_js_1.xtryAsyncIterable; } });
-Object.defineProperty(exports, "xtry", { enumerable: true, get: function () { return try_js_1.xtrySync; } });
 Object.defineProperty(exports, "xtryIterable", { enumerable: true, get: function () { return try_js_1.xtrySyncIterable; } });
+Object.defineProperty(exports, "xtryUnknown", { enumerable: true, get: function () { return try_js_1.xtry; } });
 var tryify_js_1 = require("./tryify.cjs");
+Object.defineProperty(exports, "xtryify", { enumerable: true, get: function () { return tryify_js_1.xtryifySync; } });
 Object.defineProperty(exports, "xtryifyAsync", { enumerable: true, get: function () { return tryify_js_1.xtryifyAsync; } });
 Object.defineProperty(exports, "xtryifyAsyncIterable", { enumerable: true, get: function () { return tryify_js_1.xtryifyAsyncIterable; } });
-Object.defineProperty(exports, "xtryify", { enumerable: true, get: function () { return tryify_js_1.xtryifySync; } });
 Object.defineProperty(exports, "xtryifyIterable", { enumerable: true, get: function () { return tryify_js_1.xtryifySyncIterable; } });
+var unwrap_js_1 = require("./unwrap.cjs");
+Object.defineProperty(exports, "map", { enumerable: true, get: function () { return unwrap_js_1.map; } });
+Object.defineProperty(exports, "match", { enumerable: true, get: function () { return unwrap_js_1.match; } });
+Object.defineProperty(exports, "unwrap", { enumerable: true, get: function () { return unwrap_js_1.unwrap; } });
+Object.defineProperty(exports, "unwrapOr", { enumerable: true, get: function () { return unwrap_js_1.unwrapOr; } });

package/lib/cjs/sync.d.cts

@@ -1,12 +1,13 @@
 export type { XDeferAsync, XDeferSync } from './defer.cjs';
-export { xdefer as xdeferUnknown, xdeferAsync, xdeferSync as xdefer } from './defer.cjs';
+export { xdeferSync as xdefer, xdeferAsync, xdefer as xdeferUnknown } from './defer.cjs';
 export { parseJSON, parseJson } from './json.cjs';
-export type { YResult, YSuccess, YFailure } from './partial.cjs';
-export { yok, yerr, yres as yresUnknown, yresAsync, yresSync as yres, yep, YOK, YOK_FALSE, YOK_NULL, YOK_TRUE, YOK_UNDEFINED } from './partial.cjs';
-export type { Success, Failure, Result, AsyncResult, DResult, AsyncDResult } from './result.cjs';
-export { ok, err, OK, OK_FALSE, OK_NULL, OK_TRUE, OK_UNDEFINED } from './result.cjs';
+export type { AsyncYDResult, AsyncYResult, YDResult, YFailure, YResult, YSuccess } from './partial.cjs';
+export { yep, yerr, yok, YOK, YOK_FALSE, YOK_NULL, YOK_TRUE, YOK_UNDEFINED, yresSync as yres, yresAsync, yres as yresUnknown } from './partial.cjs';
+export type { AsyncDResult, AsyncResult, DResult, Failure, Result, Success } from './result.cjs';
+export { err, ok, OK, OK_FALSE, OK_NULL, OK_TRUE, OK_UNDEFINED } from './result.cjs';
 export { stringifyError } from './stringify-error.cjs';
 export { toStringFailure } from './to-string-failure.cjs';
-export { xtry as xtryUnknown, xtryAsync, xtryAsyncIterable, xtrySync as xtry, xtrySyncIterable as xtryIterable } from './try.cjs';
-export type { AsyncFunction, AsyncIterableFunction, AsyncIteratableFunctionResult, AsyncIteratorElement, AsyncFunctionResult, PreserveAsyncIterableOverloads, PreserveAsyncOverloads, PreserveSyncIterableOverloads, PreserveSyncOverloads, SyncFunction, SyncIterableFunction, SyncIteratableFunctionResult, SyncIteratorElement, SyncFunctionResult } from './tryify.cjs';
-export { xtryifyAsync, xtryifyAsyncIterable, xtryifySync as xtryify, xtryifySyncIterable as xtryifyIterable } from './tryify.cjs';
+export { xtrySync as xtry, xtryAsync, xtryAsyncIterable, xtrySyncIterable as xtryIterable, xtry as xtryUnknown } from './try.cjs';
+export type { AsyncFunction, AsyncFunctionResult, AsyncIterableFunction, AsyncIteratableFunctionResult, AsyncIteratorElement, PreserveAsyncIterableOverloads, PreserveAsyncOverloads, PreserveSyncIterableOverloads, PreserveSyncOverloads, SyncFunction, SyncFunctionResult, SyncIterableFunction, SyncIteratableFunctionResult, SyncIteratorElement } from './tryify.cjs';
+export { xtryifySync as xtryify, xtryifyAsync, xtryifyAsyncIterable, xtryifySyncIterable as xtryifyIterable } from './tryify.cjs';
+export { map, match, unwrap, unwrapOr } from './unwrap.cjs';

package/lib/cjs/try.cjs

@@ -1,30 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.xtry = xtry;
-exports.xtrySync = xtrySync;
 exports.xtryAsync = xtryAsync;
-exports.xtrySyncIterable = xtrySyncIterable;
 exports.xtryAsyncIterable = xtryAsyncIterable;
+exports.xtrySync = xtrySync;
+exports.xtrySyncIterable = xtrySyncIterable;
 const result_js_1 = require("./result.cjs");
 const is_async_iterable_js_1 = require("./utils/is-async-iterable.cjs");
 const is_promise_like_js_1 = require("./utils/is-promise-like.cjs");
 const is_sync_iterable_js_1 = require("./utils/is-sync-iterable.cjs");
-function handleError(handler, error) {
-    if (handler) {
-        const newError = handler(error);
-        if (newError !== undefined) {
-            return (0, result_js_1.err)(newError);
-        }
-    }
-    return (0, result_js_1.err)(error);
-} // }}}
 function xtry(func, handler) {
     try {
         const value = typeof func === 'function' ? func() : func;
         if ((0, is_promise_like_js_1.isPromiseLike)(value)) {
             return Promise.resolve(value).then(
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-            (value) => (0, result_js_1.ok)(value), (error) => handleError(handler, error));
+            // eslint-disable-next-line ts/no-unsafe-return, ts/no-explicit-any
+            (value) => (0, result_js_1.ok)(value), 
+            // eslint-disable-next-line ts/use-unknown-in-catch-callback-variable
+            (error) => handleError(handler, error));
         }
         if ((0, is_async_iterable_js_1.isAsyncIterable)(value)) {
             return xtryAsyncIterable(value, handler);
@@ -32,17 +25,7 @@ function xtry(func, handler) {
         if ((0, is_sync_iterable_js_1.isSyncIterable)(value)) {
             return xtrySyncIterable(value, handler);
         }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return (0, result_js_1.ok)(value);
-    }
-    catch (error) {
-        return handleError(handler, error);
-    }
-} // }}}
-function xtrySync(func, handler) {
-    try {
-        const value = func();
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        // eslint-disable-next-line ts/no-unsafe-return, ts/no-explicit-any
         return (0, result_js_1.ok)(value);
     }
     catch (error) {
@@ -52,32 +35,33 @@ function xtrySync(func, handler) {
 async function xtryAsync(func, handler) {
     try {
         const value = await (func instanceof Promise || (0, is_async_iterable_js_1.isAsyncIterable)(func) ? func : Promise.resolve().then(func));
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        // eslint-disable-next-line ts/no-unsafe-return, ts/no-explicit-any
         return (0, result_js_1.ok)(value);
     }
     catch (error) {
         return handleError(handler, error);
     }
 } // }}}
-function xtrySyncIterable(iterable, handler) {
-    function* iterate() {
-        let generator;
+function xtryAsyncIterable(iterable, handler) {
+    const generator = typeof iterable === 'function' ? iterable : () => iterable;
+    async function* iterate() {
+        let source;
         try {
-            generator = typeof iterable === 'function' ? iterable() : iterable;
+            source = await Promise.resolve(generator());
         }
         catch (error) {
             yield handleError(handler, error);
             return;
         }
-        if (!generator || typeof generator[Symbol.iterator] !== 'function') {
-            yield handleError(handler, new TypeError('xtryIterable expects an Iterable'));
+        if (!source || typeof source[Symbol.asyncIterator] !== 'function') {
+            yield handleError(handler, new TypeError('xtryAsyncIterable expects an AsyncIterable'));
             return;
         }
-        const iterator = generator[Symbol.iterator]();
+        const iterator = source[Symbol.asyncIterator]();
         while (true) {
             let step;
             try {
-                step = iterator.next();
+                step = await iterator.next();
             }
             catch (error) {
                 yield handleError(handler, error);
@@ -86,31 +70,41 @@ function xtrySyncIterable(iterable, handler) {
             if (step.done) {
                 return;
             }
+            // eslint-disable-next-line ts/no-explicit-any
             yield (0, result_js_1.ok)(step.value);
         }
     }
     return iterate();
 } // }}}
-function xtryAsyncIterable(iterable, handler) {
-    const generator = typeof iterable === 'function' ? iterable : async () => iterable;
-    async function* iterate() {
-        let source;
+function xtrySync(func, handler) {
+    try {
+        const value = func();
+        // eslint-disable-next-line ts/no-unsafe-return, ts/no-explicit-any
+        return (0, result_js_1.ok)(value);
+    }
+    catch (error) {
+        return handleError(handler, error);
+    }
+} // }}}
+function xtrySyncIterable(iterable, handler) {
+    function* iterate() {
+        let generator;
         try {
-            source = await Promise.resolve(generator());
+            generator = typeof iterable === 'function' ? iterable() : iterable;
         }
         catch (error) {
             yield handleError(handler, error);
             return;
         }
-        if (!source || typeof source[Symbol.asyncIterator] !== 'function') {
-            yield handleError(handler, new TypeError('xtryAsyncIterable expects an AsyncIterable'));
+        if (!generator || typeof generator[Symbol.iterator] !== 'function') {
+            yield handleError(handler, new TypeError('xtryIterable expects an Iterable'));
             return;
         }
-        const iterator = source[Symbol.asyncIterator]();
+        const iterator = generator[Symbol.iterator]();
         while (true) {
             let step;
             try {
-                step = await iterator.next();
+                step = iterator.next();
             }
             catch (error) {
                 yield handleError(handler, error);
@@ -119,8 +113,18 @@ function xtryAsyncIterable(iterable, handler) {
             if (step.done) {
                 return;
             }
+            // eslint-disable-next-line ts/no-explicit-any
             yield (0, result_js_1.ok)(step.value);
         }
     }
     return iterate();
 } // }}}
+function handleError(handler, error) {
+    if (handler) {
+        const newError = handler(error);
+        if (newError !== undefined) {
+            return (0, result_js_1.err)(newError);
+        }
+    }
+    return (0, result_js_1.err)(error);
+} // }}}

package/lib/cjs/try.d.cts

@@ -1,5 +1,5 @@
+import type { MaybePromise, NonPromiseCallback, PromiseCallback } from './utils/types.cjs';
 import { type Result } from './result.cjs';
-import { type MaybePromise, type NonPromiseCallback, type PromiseCallback } from './utils/types.cjs';
 type AsyncIterableCallback<T> = (() => AsyncIterable<T>) | AsyncIterable<T>;
 type AsyncIterableResult<T, E> = AsyncIterable<VoidableResult<T, E>>;
 type ErrorHandler<T> = (error: unknown) => T | undefined;
@@ -10,8 +10,8 @@ export declare function xtry<T, E = unknown>(iterable: SyncIterableCallback<T>,
 export declare function xtry<T, E = unknown>(iterable: AsyncIterableCallback<T>, handler?: ErrorHandler<E>): AsyncIterableResult<T, E>;
 export declare function xtry<T, E = unknown>(func: NonPromiseCallback<T>, handler?: ErrorHandler<E>): VoidableResult<T, E>;
 export declare function xtry<T, E = unknown>(func: PromiseCallback<T>, handler?: ErrorHandler<E>): Promise<VoidableResult<T, E>>;
-export declare function xtrySync<T, E = unknown>(func: NonPromiseCallback<T>, handler?: ErrorHandler<E>): VoidableResult<T, E>;
 export declare function xtryAsync<T, E = unknown>(func: PromiseCallback<T>, handler?: ErrorHandler<E>): Promise<VoidableResult<T, E>>;
-export declare function xtrySyncIterable<T, E = unknown>(iterable: Iterable<T> | (() => Iterable<T>), handler?: ErrorHandler<E>): Iterable<VoidableResult<T, E>>;
-export declare function xtryAsyncIterable<T, E = unknown>(iterable: AsyncIterable<T> | Promise<AsyncIterable<T>> | (() => MaybePromise<AsyncIterable<T>>), handler?: ErrorHandler<E>): AsyncIterable<VoidableResult<T, E>>;
+export declare function xtryAsyncIterable<T, E = unknown>(iterable: (() => MaybePromise<AsyncIterable<T>>) | AsyncIterable<T> | Promise<AsyncIterable<T>>, handler?: ErrorHandler<E>): AsyncIterable<VoidableResult<T, E>>;
+export declare function xtrySync<T, E = unknown>(func: NonPromiseCallback<T>, handler?: ErrorHandler<E>): VoidableResult<T, E>;
+export declare function xtrySyncIterable<T, E = unknown>(iterable: (() => Iterable<T>) | Iterable<T>, handler?: ErrorHandler<E>): Iterable<VoidableResult<T, E>>;
 export {};

package/lib/cjs/tryify.cjs

@@ -1,4 +1,5 @@
 "use strict";
+/* eslint-disable ts/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.xtryifyAsync = xtryifyAsync;
 exports.xtryifyAsyncIterable = xtryifyAsyncIterable;
@@ -6,21 +7,25 @@ exports.xtryifySync = xtryifySync;
 exports.xtryifySyncIterable = xtryifySyncIterable;
 const try_js_1 = require("./try.cjs");
 function xtryifyAsync(fn) {
+    // eslint-disable-next-line func-names
     return async function (...args) {
         return (0, try_js_1.xtryAsync)(async () => fn(...args));
     };
 }
 function xtryifyAsyncIterable(fn) {
+    // eslint-disable-next-line func-names
     return function (...args) {
         return (0, try_js_1.xtryAsyncIterable)(fn(...args));
     };
 }
 function xtryifySync(fn) {
+    // eslint-disable-next-line func-names
     return function (...args) {
         return (0, try_js_1.xtrySync)(() => fn(...args));
     };
 }
 function xtryifySyncIterable(fn) {
+    // eslint-disable-next-line func-names
     return function (...args) {
         return (0, try_js_1.xtrySyncIterable)(fn(...args));
     };

package/lib/cjs/tryify.d.cts

@@ -1,5 +1,23 @@
-import { type Result } from './result.cjs';
-import { type NotPromise } from './utils/types.cjs';
+import type { Result } from './result.cjs';
+import type { NotPromise } from './utils/types.cjs';
+export type AsyncFunction<Fn extends (...args: any[]) => any> = ReturnType<Fn> extends Promise<any> ? Fn : never;
+export type AsyncFunctionResult<T extends (...args: unknown[]) => unknown, Err extends Error> = Promise<Result<Awaited<ReturnType<T>>, Err>>;
+export type AsyncIterableFunction = (...args: any[]) => AsyncIterable<unknown>;
+export type AsyncIteratableFunctionResult<T extends (...args: unknown[]) => unknown, Err extends Error> = AsyncIterable<Result<AsyncIteratorElement<ReturnType<T>>, Err>, unknown, unknown>;
+export type AsyncIteratorElement<T> = T extends Promise<infer P> ? AsyncIteratorElement<P> : T extends AsyncIterator<infer E> ? E : T extends AsyncIterable<infer E> ? E : T extends {
+    [Symbol.asyncIterator]: (...args: unknown[]) => infer I;
+} ? AsyncIteratorElement<I> : unknown;
+export type PreserveAsyncIterableOverloads<Fn extends AsyncIterableFunction, Err extends Error> = UnionToIntersection<WrapAsyncIterableOverload<OverloadsUnion<Fn>, Err>>;
+export type PreserveAsyncOverloads<Fn extends AnyAsyncFunction, Err extends Error> = UnionToIntersection<WrapAsyncOverload<OverloadsUnion<Fn>, Err>>;
+export type PreserveSyncIterableOverloads<Fn extends SyncIterableFunction, Err extends Error> = UnionToIntersection<WrapSyncIterableOverload<OverloadsUnion<Fn>, Err>>;
+export type PreserveSyncOverloads<Fn extends AnySyncFunction, Err extends Error> = UnionToIntersection<WrapSyncOverload<OverloadsUnion<Fn>, Err>>;
+export type SyncFunction<Fn extends (...args: any[]) => any> = LastIsFunction<Parameters<Fn>> extends true ? never : ReturnType<Fn> extends Promise<any> ? never : Fn;
+export type SyncFunctionResult<T extends (...args: unknown[]) => NotPromise<unknown>, Err extends Error> = Result<ReturnType<T>, Err>;
+export type SyncIterableFunction = (...args: any[]) => Iterable<unknown>;
+export type SyncIteratableFunctionResult<T extends (...args: unknown[]) => unknown, Err extends Error> = Iterable<Result<SyncIteratorElement<ReturnType<T>>, Err>, unknown, unknown>;
+export type SyncIteratorElement<T> = T extends Iterator<infer E> ? E : T extends Iterable<infer E> ? E : T extends {
+    [Symbol.iterator]: (...args: unknown[]) => infer I;
+} ? SyncIteratorElement<I> : unknown;
 type AnyAsyncFunction = (...args: any[]) => Promise<unknown>;
 type AnySyncFunction = (...args: any[]) => unknown;
 type LastIsFunction<T extends readonly any[]> = T extends [...infer Rest, infer Last] ? Last extends (...args: any[]) => any ? true : false : false;
@@ -16,28 +34,10 @@ type OverloadsUnion<Fn extends Function> = Fn extends {
     (...args: infer A10): infer R10;
 } ? ((...args: A1) => R1) | ((...args: A2) => R2) | ((...args: A3) => R3) | ((...args: A4) => R4) | ((...args: A5) => R5) | ((...args: A6) => R6) | ((...args: A7) => R7) | ((...args: A8) => R8) | ((...args: A9) => R9) | ((...args: A10) => R10) : Fn;
 type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-type WrapAsyncOverload<Fn extends AnyAsyncFunction, Err extends Error> = Fn extends (...args: infer Args) => unknown ? (...args: Args) => AsyncFunctionResult<Fn, Err> : never;
 type WrapAsyncIterableOverload<Fn extends AsyncIterableFunction, Err extends Error> = Fn extends (...args: infer Args) => AsyncIterable<unknown> ? (...args: Args) => AsyncIteratableFunctionResult<Fn, Err> : never;
-type WrapSyncOverload<Fn extends AnySyncFunction, Err extends Error> = Fn extends (...args: infer Args) => unknown ? (...args: Args) => SyncFunctionResult<Fn, Err> : never;
+type WrapAsyncOverload<Fn extends AnyAsyncFunction, Err extends Error> = Fn extends (...args: infer Args) => unknown ? (...args: Args) => AsyncFunctionResult<Fn, Err> : never;
 type WrapSyncIterableOverload<Fn extends SyncIterableFunction, Err extends Error> = Fn extends (...args: infer Args) => Iterable<unknown> ? (...args: Args) => SyncIteratableFunctionResult<Fn, Err> : never;
-export type AsyncFunction<Fn extends (...args: any[]) => any> = ReturnType<Fn> extends Promise<any> ? Fn : never;
-export type AsyncIterableFunction = (...args: any[]) => AsyncIterable<unknown>;
-export type AsyncIteratorElement<T> = T extends Promise<infer P> ? AsyncIteratorElement<P> : T extends AsyncIterator<infer E> ? E : T extends AsyncIterable<infer E> ? E : T extends {
-    [Symbol.asyncIterator]: (...args: unknown[]) => infer I;
-} ? AsyncIteratorElement<I> : unknown;
-export type AsyncFunctionResult<T extends (...args: unknown[]) => unknown, Err extends Error> = Promise<Result<Awaited<ReturnType<T>>, Err>>;
-export type AsyncIteratableFunctionResult<T extends (...args: unknown[]) => unknown, Err extends Error> = AsyncIterable<Result<AsyncIteratorElement<ReturnType<T>>, Err>, unknown, unknown>;
-export type PreserveAsyncOverloads<Fn extends AnyAsyncFunction, Err extends Error> = UnionToIntersection<WrapAsyncOverload<OverloadsUnion<Fn>, Err>>;
-export type PreserveAsyncIterableOverloads<Fn extends AsyncIterableFunction, Err extends Error> = UnionToIntersection<WrapAsyncIterableOverload<OverloadsUnion<Fn>, Err>>;
-export type PreserveSyncOverloads<Fn extends AnySyncFunction, Err extends Error> = UnionToIntersection<WrapSyncOverload<OverloadsUnion<Fn>, Err>>;
-export type PreserveSyncIterableOverloads<Fn extends SyncIterableFunction, Err extends Error> = UnionToIntersection<WrapSyncIterableOverload<OverloadsUnion<Fn>, Err>>;
-export type SyncFunction<Fn extends (...args: any[]) => any> = LastIsFunction<Parameters<Fn>> extends true ? never : ReturnType<Fn> extends Promise<any> ? never : Fn;
-export type SyncIterableFunction = (...args: any[]) => Iterable<unknown>;
-export type SyncIteratorElement<T> = T extends Iterator<infer E> ? E : T extends Iterable<infer E> ? E : T extends {
-    [Symbol.iterator]: (...args: unknown[]) => infer I;
-} ? SyncIteratorElement<I> : unknown;
-export type SyncFunctionResult<T extends (...args: unknown[]) => NotPromise<unknown>, Err extends Error> = Result<ReturnType<T>, Err>;
-export type SyncIteratableFunctionResult<T extends (...args: unknown[]) => unknown, Err extends Error> = Iterable<Result<SyncIteratorElement<ReturnType<T>>, Err>, unknown, unknown>;
+type WrapSyncOverload<Fn extends AnySyncFunction, Err extends Error> = Fn extends (...args: infer Args) => unknown ? (...args: Args) => SyncFunctionResult<Fn, Err> : never;
 export declare function xtryifyAsync<Err extends Error, Fn extends AnyAsyncFunction = any>(fn: AsyncFunction<Fn>): PreserveAsyncOverloads<Fn, Err>;
 export declare function xtryifyAsyncIterable<Err extends Error, Fn extends AsyncIterableFunction = any>(fn: Fn): PreserveAsyncIterableOverloads<Fn, Err>;
 export declare function xtryifySync<Err extends Error, Fn extends AnySyncFunction = any>(fn: SyncFunction<Fn>): PreserveSyncOverloads<Fn, Err>;

package/lib/cjs/unwrap.cjs

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.map = map;
+exports.match = match;
+exports.unwrap = unwrap;
+exports.unwrapOr = unwrapOr;
+const result_js_1 = require("./result.cjs");
+const stringify_error_js_1 = require("./stringify-error.cjs");
+function map(result, transform) {
+    if (result.fails) {
+        return result;
+    }
+    else {
+        return (0, result_js_1.ok)(transform(result.value));
+    }
+}
+function match(result, handlers) {
+    if (result.fails) {
+        return handlers.failure(result.error);
+    }
+    else {
+        return handlers.success(result.value);
+    }
+}
+function unwrap(result) {
+    if (result.fails) {
+        if (result.error instanceof Error) {
+            throw result.error;
+        }
+        else {
+            throw new Error((0, stringify_error_js_1.stringifyError)(result.error));
+        }
+    }
+    return result.value;
+}
+function unwrapOr(result, fallback) {
+    if (result.fails) {
+        return fallback;
+    }
+    else {
+        return result.value;
+    }
+}

package/lib/cjs/unwrap.d.cts

@@ -0,0 +1,8 @@
+import type { Result } from './result.cjs';
+export declare function map<T, E, U>(result: Result<T, E>, transform: (value: T) => U): Result<U, E>;
+export declare function match<T, E, R>(result: Result<T, E>, handlers: {
+    failure: (error: E) => R;
+    success: (value: T) => R;
+}): R;
+export declare function unwrap<T, E>(result: Result<T, E>): T;
+export declare function unwrapOr<T, E, F>(result: Result<T, E>, fallback: F): F | T;

package/lib/cjs/utils/is-promise-like.d.cts

@@ -1,3 +1,3 @@
-type MaybePromise<T> = T | PromiseLike<T>;
+type MaybePromise<T> = PromiseLike<T> | T;
 export declare function isPromiseLike<T>(value: MaybePromise<T>): value is PromiseLike<T>;
 export {};

package/lib/cjs/utils/types.d.cts

@@ -1,5 +1,5 @@
 export type Callback<T, Args extends unknown[] = []> = NonPromiseCallback<T, Args> | PromiseCallback<T, Args>;
-export type MaybePromise<T> = T | Promise<T>;
-export type NotPromise<T> = Exclude<T, Promise<unknown>>;
+export type MaybePromise<T> = Promise<T> | T;
 export type NonPromiseCallback<T, Args extends unknown[] = []> = (...args: Args) => NotPromise<T>;
+export type NotPromise<T> = Exclude<T, Promise<unknown>>;
 export type PromiseCallback<T, Args extends unknown[] = []> = ((...args: Args) => Promise<T>) | Promise<T>;