@zokugun/xtry 0.11.6 → 0.12.0

package/lib/esm/partial.d.mts

@@ -1,25 +1,28 @@
-import { type Result, type Failure, type Success } from './result.mjs';
-import { type NotPromise } from './utils/types.mjs';
-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.mjs';
+import type { NotPromise } from './utils/types.mjs';
+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/esm/partial.mjs

@@ -1,19 +1,25 @@
 import { isPromiseLike } from './utils/is-promise-like.mjs';
-export function yok(value) {
+export function yep(result) {
     return {
-        fails: false,
+        ...result,
         success: true,
-        value: value,
-        error: undefined,
     };
 }
-export function yerr(miscue) {
+export function yerr(issue) {
     return {
+        error: undefined,
         fails: false,
+        issue,
         success: false,
-        miscue,
         value: undefined,
+    };
+}
+export function yok(value) {
+    return {
         error: undefined,
+        fails: false,
+        success: true,
+        value: value,
     };
 }
 export function yres(result) {
@@ -22,21 +28,15 @@ export function yres(result) {
     }
     return yresSync(result);
 }
+export async function yresAsync(promise) {
+    return promise.then(yresSync);
+}
 export function yresSync(result) {
     if (result.fails) {
         return result;
     }
     return yep(result);
 }
-export async function yresAsync(promise) {
-    return promise.then(yresSync);
-}
-export function yep(result) {
-    return {
-        ...result,
-        success: true,
-    };
-}
 export const YOK = Object.freeze(yok());
 export const YOK_FALSE = Object.freeze(yok(false));
 export const YOK_NULL = Object.freeze(yok(null));

package/lib/esm/result.d.mts

@@ -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/esm/result.mjs

@@ -1,15 +1,15 @@
-export function ok(value) {
-    return {
-        fails: false,
-        value: value,
-        error: undefined,
-    };
-}
 export function err(error) {
     return {
+        error,
         fails: true,
         value: undefined,
-        error,
+    };
+}
+export function ok(value) {
+    return {
+        error: undefined,
+        fails: false,
+        value: value,
     };
 }
 export const OK = Object.freeze(ok());

package/lib/esm/sync.d.mts

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

package/lib/esm/sync.mjs

@@ -1,8 +1,9 @@
-export { xdefer as xdeferUnknown, xdeferAsync, xdeferSync as xdefer } from './defer.mjs';
+export { xdeferSync as xdefer, xdeferAsync, xdefer as xdeferUnknown } from './defer.mjs';
 export { parseJSON, parseJson } from './json.mjs';
-export { yok, yerr, yres as yresUnknown, yresAsync, yresSync as yres, yep, YOK, YOK_FALSE, YOK_NULL, YOK_TRUE, YOK_UNDEFINED } from './partial.mjs';
-export { ok, err, OK, OK_FALSE, OK_NULL, OK_TRUE, OK_UNDEFINED } from './result.mjs';
+export { yep, yerr, yok, YOK, YOK_FALSE, YOK_NULL, YOK_TRUE, YOK_UNDEFINED, yresSync as yres, yresAsync, yres as yresUnknown } from './partial.mjs';
+export { err, ok, OK, OK_FALSE, OK_NULL, OK_TRUE, OK_UNDEFINED } from './result.mjs';
 export { stringifyError } from './stringify-error.mjs';
 export { toStringFailure } from './to-string-failure.mjs';
-export { xtry as xtryUnknown, xtryAsync, xtryAsyncIterable, xtrySync as xtry, xtrySyncIterable as xtryIterable } from './try.mjs';
-export { xtryifyAsync, xtryifyAsyncIterable, xtryifySync as xtryify, xtryifySyncIterable as xtryifyIterable } from './tryify.mjs';
+export { xtrySync as xtry, xtryAsync, xtryAsyncIterable, xtrySyncIterable as xtryIterable, xtry as xtryUnknown } from './try.mjs';
+export { xtryifySync as xtryify, xtryifyAsync, xtryifyAsyncIterable, xtryifySyncIterable as xtryifyIterable } from './tryify.mjs';
+export { map, match, unwrap, unwrapOr } from './unwrap.mjs';

package/lib/esm/try.d.mts

@@ -1,5 +1,5 @@
+import type { MaybePromise, NonPromiseCallback, PromiseCallback } from './utils/types.mjs';
 import { type Result } from './result.mjs';
-import { type MaybePromise, type NonPromiseCallback, type PromiseCallback } from './utils/types.mjs';
 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/esm/try.mjs

@@ -2,22 +2,15 @@ import { err, ok } from './result.mjs';
 import { isAsyncIterable } from './utils/is-async-iterable.mjs';
 import { isPromiseLike } from './utils/is-promise-like.mjs';
 import { isSyncIterable } from './utils/is-sync-iterable.mjs';
-function handleError(handler, error) {
-    if (handler) {
-        const newError = handler(error);
-        if (newError !== undefined) {
-            return err(newError);
-        }
-    }
-    return err(error);
-} // }}}
 export function xtry(func, handler) {
     try {
         const value = typeof func === 'function' ? func() : func;
         if (isPromiseLike(value)) {
             return Promise.resolve(value).then(
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-            (value) => ok(value), (error) => handleError(handler, error));
+            // eslint-disable-next-line ts/no-unsafe-return, ts/no-explicit-any
+            (value) => ok(value), 
+            // eslint-disable-next-line ts/use-unknown-in-catch-callback-variable
+            (error) => handleError(handler, error));
         }
         if (isAsyncIterable(value)) {
             return xtryAsyncIterable(value, handler);
@@ -25,17 +18,7 @@ export function xtry(func, handler) {
         if (isSyncIterable(value)) {
             return xtrySyncIterable(value, handler);
         }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return ok(value);
-    }
-    catch (error) {
-        return handleError(handler, error);
-    }
-} // }}}
-export 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 ok(value);
     }
     catch (error) {
@@ -45,32 +28,33 @@ export function xtrySync(func, handler) {
 export async function xtryAsync(func, handler) {
     try {
         const value = await (func instanceof Promise || 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 ok(value);
     }
     catch (error) {
         return handleError(handler, error);
     }
 } // }}}
-export function xtrySyncIterable(iterable, handler) {
-    function* iterate() {
-        let generator;
+export 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);
@@ -79,31 +63,41 @@ export function xtrySyncIterable(iterable, handler) {
             if (step.done) {
                 return;
             }
+            // eslint-disable-next-line ts/no-explicit-any
             yield ok(step.value);
         }
     }
     return iterate();
 } // }}}
-export function xtryAsyncIterable(iterable, handler) {
-    const generator = typeof iterable === 'function' ? iterable : async () => iterable;
-    async function* iterate() {
-        let source;
+export function xtrySync(func, handler) {
+    try {
+        const value = func();
+        // eslint-disable-next-line ts/no-unsafe-return, ts/no-explicit-any
+        return ok(value);
+    }
+    catch (error) {
+        return handleError(handler, error);
+    }
+} // }}}
+export 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);
@@ -112,8 +106,18 @@ export function xtryAsyncIterable(iterable, handler) {
             if (step.done) {
                 return;
             }
+            // eslint-disable-next-line ts/no-explicit-any
             yield ok(step.value);
         }
     }
     return iterate();
 } // }}}
+function handleError(handler, error) {
+    if (handler) {
+        const newError = handler(error);
+        if (newError !== undefined) {
+            return err(newError);
+        }
+    }
+    return err(error);
+} // }}}

package/lib/esm/tryify.d.mts

@@ -1,5 +1,23 @@
-import { type Result } from './result.mjs';
-import { type NotPromise } from './utils/types.mjs';
+import type { Result } from './result.mjs';
+import type { NotPromise } from './utils/types.mjs';
+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/esm/tryify.mjs

@@ -1,20 +1,25 @@
+/* eslint-disable ts/no-explicit-any */
 import { xtryAsync, xtryAsyncIterable, xtrySync, xtrySyncIterable } from './try.mjs';
 export function xtryifyAsync(fn) {
+    // eslint-disable-next-line func-names
     return async function (...args) {
         return xtryAsync(async () => fn(...args));
     };
 }
 export function xtryifyAsyncIterable(fn) {
+    // eslint-disable-next-line func-names
     return function (...args) {
         return xtryAsyncIterable(fn(...args));
     };
 }
 export function xtryifySync(fn) {
+    // eslint-disable-next-line func-names
     return function (...args) {
         return xtrySync(() => fn(...args));
     };
 }
 export function xtryifySyncIterable(fn) {
+    // eslint-disable-next-line func-names
     return function (...args) {
         return xtrySyncIterable(fn(...args));
     };

package/lib/esm/unwrap.d.mts

@@ -0,0 +1,8 @@
+import type { Result } from './result.mjs';
+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/esm/unwrap.mjs

@@ -0,0 +1,37 @@
+import { ok } from './result.mjs';
+import { stringifyError } from './stringify-error.mjs';
+export function map(result, transform) {
+    if (result.fails) {
+        return result;
+    }
+    else {
+        return ok(transform(result.value));
+    }
+}
+export function match(result, handlers) {
+    if (result.fails) {
+        return handlers.failure(result.error);
+    }
+    else {
+        return handlers.success(result.value);
+    }
+}
+export function unwrap(result) {
+    if (result.fails) {
+        if (result.error instanceof Error) {
+            throw result.error;
+        }
+        else {
+            throw new Error(stringifyError(result.error));
+        }
+    }
+    return result.value;
+}
+export function unwrapOr(result, fallback) {
+    if (result.fails) {
+        return fallback;
+    }
+    else {
+        return result.value;
+    }
+}

package/lib/esm/utils/is-promise-like.d.mts

@@ -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/esm/utils/types.d.mts

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