@zokugun/xtry 0.6.4 → 0.7.0

package/README.md

@@ -147,17 +147,32 @@ To minimize allocations when returning the same `Success` shape, you can reuse t
 
 ```
 function xtry<T, E>(func: (() => MaybePromise<T>) | Promise<T>, handler?: (error: unknown) => void | E): MaybePromise<Result<T, E>>;
-function xtrySync<T, E>(func: () => Exclude<T, Promise<unknown>>, handler?: (error: unknown) => void | E): Result<T, E>;
+function xtry<T, E>(iterable: (() => Iterable<T>) | Iterable<T>, handler?: (error: unknown) => void | E): Iterable<Result<T, E>>;
+function xtry<T, E>(iterable: (() => AsyncIterable<T>) | AsyncIterable<T>, handler?: (error: unknown) => void | E): AsyncIterable<Result<T, E>>;
 function xtryAsync<T, E>(func: (() => Promise<T>) | Promise<T>, handler?: (error: unknown) => void | E): Promise<Result<T, E>>;
+function xtryAsyncIterable<T, E>(iterable: (() => MaybePromise<AsyncIterable<T>>) | MaybePromise<AsyncIterable<T>>, handler?: (error: unknown) => void | E): AsyncIterable<Result<T, E>>;
+function xtrySync<T, E>(func: () => Exclude<T, Promise<unknown>>, handler?: (error: unknown) => void | E): Result<T, E>;
+function xtrySyncIterable<T, E>(iterable: (() => Iterable<T>) | Iterable<T>, handler?: (error: unknown) => void | E): Iterable<Result<T, E>>;
+(error: unknown) => void | E): AsyncIterable<Result<T, E>>;
 
 function stringifyError(error: unknown): string;
 ```
 
-`xtry` inspects the supplied value: if it is or returns a promise you get a `Promise<Result<…>>`, otherwise you get a plain `Result`. Use `xtrySync`/`xtryAsync` when you need to force a specific flavor (tree shaking, stricter contracts, etc.). All helpers:
+`xtry` inspects the supplied value and chooses the matching shape:
+
+- promises or async factories → `Promise<Result<…>>`
+- async iterables → `AsyncIterable<Result<…>>`
+- iterators/generators → `Iterable<Result<…>>`
+- everything else → plain `Result<…>`
+
+Wrap default collections (arrays, sets, maps, strings, typed arrays, …) inside a function if you need them treated as raw values instead of iterables.<br />
+Reach for `xtrySync`/`xtryAsync` when you want to force a specific mode, and prefer the explicit `xtrySyncIterable`/`xtryAsyncIterable` exports whenever you always expect iterable outputs.<br />
+`xtryIterable` and `xtryAsyncIterable` wrap synchronous or asynchronous iterables, yielding a stream of `Result` values and emitting a single `err(...)` before stopping when the underlying iterator throws or rejects.
+
+All helpers:
 
 - execute the supplied function and capture thrown values;
 - call the optional `handler` before turning that value into `err(error)`;
-- never throw, making the return signature a reliable discriminated union.
 
 ### Partial helpers
 

package/lib/cjs/async.cjs

@@ -1,12 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.xtry = exports.stringifyError = exports.OK_FALSE = exports.OK_TRUE = exports.OK_NULL = exports.OK = exports.err = exports.ok = exports.YOK_FALSE = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK = exports.yep = exports.yres = exports.yerr = exports.yok = exports.xdefer = void 0;
+exports.xtrySyncIterable = exports.xtrySync = exports.xtryIterable = exports.xtry = exports.xtryUnknown = exports.toStringFailure = exports.stringifyError = exports.OK_FALSE = exports.OK_TRUE = exports.OK_NULL = exports.OK = exports.err = exports.ok = exports.YOK_FALSE = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK = exports.yep = exports.yresSync = exports.yres = exports.yresUnknown = exports.yerr = exports.yok = exports.xdeferSync = exports.xdefer = exports.xdeferUnknown = 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, "xdefer", { enumerable: true, get: function () { return defer_js_1.xdeferAsync; } });
+Object.defineProperty(exports, "xdeferSync", { enumerable: true, get: function () { return defer_js_1.xdeferSync; } });
 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, "yres", { enumerable: true, get: function () { return partial_js_1.yresAsync; } });
+Object.defineProperty(exports, "yresSync", { 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, "YOK", { enumerable: true, get: function () { return partial_js_1.YOK; } });
 Object.defineProperty(exports, "YOK_NULL", { enumerable: true, get: function () { return partial_js_1.YOK_NULL; } });
@@ -21,5 +25,11 @@ Object.defineProperty(exports, "OK_TRUE", { enumerable: true, get: function () {
 Object.defineProperty(exports, "OK_FALSE", { enumerable: true, get: function () { return result_js_1.OK_FALSE; } });
 var stringify_error_js_1 = require("./stringify-error.cjs");
 Object.defineProperty(exports, "stringifyError", { enumerable: true, get: function () { return stringify_error_js_1.stringifyError; } });
+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.xtryAsync; } });
+Object.defineProperty(exports, "xtryIterable", { enumerable: true, get: function () { return try_js_1.xtryAsyncIterable; } });
+Object.defineProperty(exports, "xtrySync", { enumerable: true, get: function () { return try_js_1.xtrySync; } });
+Object.defineProperty(exports, "xtrySyncIterable", { enumerable: true, get: function () { return try_js_1.xtrySyncIterable; } });

package/lib/cjs/async.d.cts

@@ -1,7 +1,8 @@
-export { xdeferAsync as xdefer } from './defer.cjs';
+export { xdefer as xdeferUnknown, xdeferAsync as xdefer, xdeferSync } from './defer.cjs';
 export type { YResult, YSuccess, YFailure } from './partial.cjs';
-export { yok, yerr, yresAsync as yres, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.cjs';
+export { yok, yerr, yres as yresUnknown, yresAsync as yres, yresSync, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.cjs';
 export type { Success, Failure, Result } from './result.cjs';
 export { ok, err, OK, OK_NULL, OK_TRUE, OK_FALSE } from './result.cjs';
 export { stringifyError } from './stringify-error.cjs';
-export { xtryAsync as xtry } from './try.cjs';
+export { toStringFailure } from './to-string-failure.cjs';
+export { xtry as xtryUnknown, xtryAsync as xtry, xtryAsyncIterable as xtryIterable, xtrySync, xtrySyncIterable } from './try.cjs';

package/lib/cjs/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.xtrySync = exports.xtryAsync = exports.xtry = exports.stringifyError = exports.OK_FALSE = exports.OK_TRUE = exports.OK_NULL = exports.OK = exports.err = exports.ok = exports.YOK_FALSE = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK = exports.yep = exports.yresSync = exports.yresAsync = exports.yres = exports.yerr = exports.yok = exports.xdeferSync = exports.xdeferAsync = exports.xdefer = void 0;
+exports.xtrySyncIterable = exports.xtrySync = exports.xtryAsyncIterable = exports.xtryAsync = exports.xtry = exports.toStringFailure = exports.stringifyError = exports.OK_FALSE = exports.OK_TRUE = exports.OK_NULL = exports.OK = exports.err = exports.ok = exports.YOK_FALSE = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK = exports.yep = exports.yresSync = exports.yresAsync = exports.yres = exports.yerr = exports.yok = exports.xdeferSync = exports.xdeferAsync = exports.xdefer = void 0;
 var defer_js_1 = require("./defer.cjs");
 Object.defineProperty(exports, "xdefer", { enumerable: true, get: function () { return defer_js_1.xdefer; } });
 Object.defineProperty(exports, "xdeferAsync", { enumerable: true, get: function () { return defer_js_1.xdeferAsync; } });
@@ -25,7 +25,11 @@ Object.defineProperty(exports, "OK_TRUE", { enumerable: true, get: function () {
 Object.defineProperty(exports, "OK_FALSE", { enumerable: true, get: function () { return result_js_1.OK_FALSE; } });
 var stringify_error_js_1 = require("./stringify-error.cjs");
 Object.defineProperty(exports, "stringifyError", { enumerable: true, get: function () { return stringify_error_js_1.stringifyError; } });
+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, "xtry", { enumerable: true, get: function () { return try_js_1.xtry; } });
 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, "xtrySync", { enumerable: true, get: function () { return try_js_1.xtrySync; } });
+Object.defineProperty(exports, "xtrySyncIterable", { enumerable: true, get: function () { return try_js_1.xtrySyncIterable; } });

package/lib/cjs/index.d.cts

@@ -4,4 +4,5 @@ export { yok, yerr, yres, yresAsync, yresSync, yep, YOK, YOK_NULL, YOK_TRUE, YOK
 export type { Success, Failure, Result } from './result.cjs';
 export { ok, err, OK, OK_NULL, OK_TRUE, OK_FALSE } from './result.cjs';
 export { stringifyError } from './stringify-error.cjs';
-export { xtry, xtryAsync, xtrySync } from './try.cjs';
+export { toStringFailure } from './to-string-failure.cjs';
+export { xtry, xtryAsync, xtryAsyncIterable, xtrySync, xtrySyncIterable } from './try.cjs';

package/lib/cjs/sync.cjs

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.xtry = exports.stringifyError = exports.OK_FALSE = exports.OK_TRUE = exports.OK_NULL = exports.OK = exports.err = exports.ok = exports.YOK_FALSE = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK = exports.yep = exports.yres = exports.yerr = exports.yok = exports.xdefer = void 0;
+exports.xtryIterable = exports.xtry = exports.xtryAsyncIterable = exports.xtryAsync = exports.xtryUnknown = exports.toStringFailure = exports.stringifyError = exports.OK_FALSE = exports.OK_TRUE = exports.OK_NULL = exports.OK = exports.err = exports.ok = exports.YOK_FALSE = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK = exports.yep = exports.yres = exports.yresAsync = exports.yresUnknown = exports.yerr = exports.yok = exports.xdefer = exports.xdeferAsync = exports.xdeferUnknown = 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; } });
 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, "YOK", { enumerable: true, get: function () { return partial_js_1.YOK; } });
@@ -21,5 +25,11 @@ Object.defineProperty(exports, "OK_TRUE", { enumerable: true, get: function () {
 Object.defineProperty(exports, "OK_FALSE", { enumerable: true, get: function () { return result_js_1.OK_FALSE; } });
 var stringify_error_js_1 = require("./stringify-error.cjs");
 Object.defineProperty(exports, "stringifyError", { enumerable: true, get: function () { return stringify_error_js_1.stringifyError; } });
+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, "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; } });

package/lib/cjs/sync.d.cts

@@ -1,7 +1,8 @@
-export { xdeferSync as xdefer } from './defer.cjs';
+export { xdefer as xdeferUnknown, xdeferAsync, xdeferSync as xdefer } from './defer.cjs';
 export type { YResult, YSuccess, YFailure } from './partial.cjs';
-export { yok, yerr, yresSync as yres, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.cjs';
+export { yok, yerr, yres as yresUnknown, yresAsync, yresSync as yres, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.cjs';
 export type { Success, Failure, Result } from './result.cjs';
 export { ok, err, OK, OK_NULL, OK_TRUE, OK_FALSE } from './result.cjs';
 export { stringifyError } from './stringify-error.cjs';
-export { xtrySync as xtry } from './try.cjs';
+export { toStringFailure } from './to-string-failure.cjs';
+export { xtry as xtryUnknown, xtryAsync, xtryAsyncIterable, xtrySync as xtry, xtrySyncIterable as xtryIterable } from './try.cjs';

package/lib/cjs/to-string-failure.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toStringFailure = toStringFailure;
+const result_js_1 = require("./result.cjs");
+const stringify_error_js_1 = require("./stringify-error.cjs");
+function toStringFailure(error) {
+    return (0, result_js_1.err)((0, stringify_error_js_1.stringifyError)(error));
+}

package/lib/cjs/to-string-failure.d.cts

@@ -0,0 +1,2 @@
+import { type Failure } from './result.cjs';
+export declare function toStringFailure(error: unknown): Failure<string>;

package/lib/cjs/try.cjs

@@ -3,35 +3,44 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.xtry = xtry;
 exports.xtrySync = xtrySync;
 exports.xtryAsync = xtryAsync;
+exports.xtrySyncIterable = xtrySyncIterable;
+exports.xtryAsyncIterable = xtryAsyncIterable;
 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) {
     // eslint-disable-next-line @typescript-eslint/promise-function-async
     const run = func instanceof Function ? func : () => func;
-    const handleError = (error) => {
-        if (handler) {
-            const newError = handler(error);
-            if (newError !== undefined) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return (0, result_js_1.err)(newError);
-            }
-        }
-        return (0, result_js_1.err)(error);
-    };
-    const handleSuccess = (value) => (0, result_js_1.ok)(value);
     try {
         const value = run();
         if ((0, is_promise_like_js_1.isPromiseLike)(value)) {
-            return Promise.resolve(value).then(handleSuccess, handleError);
+            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));
+        }
+        if ((0, is_async_iterable_js_1.isAsyncIterable)(value)) {
+            return xtryAsyncIterable(value, 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) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return handleError(error);
+        return handleError(handler, error);
     }
-}
+} // }}}
 function xtrySync(func, handler) {
     try {
         const value = func();
@@ -39,17 +48,9 @@ function xtrySync(func, handler) {
         return (0, result_js_1.ok)(value);
     }
     catch (error) {
-        if (handler) {
-            const newError = handler(error);
-            if (newError !== undefined) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return (0, result_js_1.err)(newError);
-            }
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return (0, result_js_1.err)(error);
+        return handleError(handler, error);
     }
-}
+} // }}}
 async function xtryAsync(func, handler) {
     try {
         const value = await (func instanceof Promise ? func : Promise.resolve().then(func));
@@ -57,14 +58,72 @@ async function xtryAsync(func, handler) {
         return (0, result_js_1.ok)(value);
     }
     catch (error) {
-        if (handler) {
-            const newError = handler(error);
-            if (newError !== undefined) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return (0, result_js_1.err)(newError);
+        return handleError(handler, error);
+    }
+} // }}}
+function xtrySyncIterable(iterable, handler) {
+    const generator = iterable instanceof Function ? iterable : () => iterable;
+    function* iterate() {
+        let source;
+        try {
+            source = generator();
+        }
+        catch (error) {
+            yield handleError(handler, error);
+            return;
+        }
+        if (!source || typeof source[Symbol.iterator] !== 'function') {
+            yield handleError(handler, new TypeError('xtryIterable expects an Iterable'));
+            return;
+        }
+        const iterator = source[Symbol.iterator]();
+        while (true) {
+            let step;
+            try {
+                step = iterator.next();
+            }
+            catch (error) {
+                yield handleError(handler, error);
+                return;
+            }
+            if (step.done) {
+                return;
             }
+            yield (0, result_js_1.ok)(step.value);
+        }
+    }
+    return iterate();
+} // }}}
+function xtryAsyncIterable(iterable, handler) {
+    const generator = iterable instanceof Function ? iterable : async () => iterable;
+    async function* iterate() {
+        let source;
+        try {
+            source = await Promise.resolve(generator());
+        }
+        catch (error) {
+            yield handleError(handler, error);
+            return;
+        }
+        if (!source || typeof source[Symbol.asyncIterator] !== 'function') {
+            yield handleError(handler, new TypeError('xtryAsyncIterable expects an AsyncIterable'));
+            return;
+        }
+        const iterator = source[Symbol.asyncIterator]();
+        while (true) {
+            let step;
+            try {
+                step = await iterator.next();
+            }
+            catch (error) {
+                yield handleError(handler, error);
+                return;
+            }
+            if (step.done) {
+                return;
+            }
+            yield (0, result_js_1.ok)(step.value);
         }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return (0, result_js_1.err)(error);
     }
-}
+    return iterate();
+} // }}}

package/lib/cjs/try.d.cts

@@ -1,9 +1,17 @@
 import { type Result } from './result.cjs';
-import { type NonPromiseCallback, type PromiseCallback } from './utils/types.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;
+type SyncIterableCallback<T> = (() => Iterable<T>) | Iterable<T>;
+type SyncIterableResult<T, E> = Iterable<VoidableResult<T, E>>;
 type VoidableResult<T, E> = E extends void ? Result<T, unknown> : Result<T, E>;
+export declare function xtry<T, E = unknown>(iterable: SyncIterableCallback<T>, handler?: ErrorHandler<E>): SyncIterableResult<T, E>;
+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 {};

package/lib/cjs/utils/is-async-iterable.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAsyncIterable = isAsyncIterable;
+function isAsyncIterable(item) {
+    return item !== null && typeof item === 'object' && typeof item[Symbol.asyncIterator] === 'function';
+}

package/lib/cjs/utils/is-async-iterable.d.cts

@@ -0,0 +1 @@
+export declare function isAsyncIterable<T>(item: unknown): item is AsyncIterableIterator<T>;

package/lib/cjs/utils/is-sync-iterable.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSyncIterable = isSyncIterable;
+function isSyncIterable(item) {
+    return item !== null && typeof item === 'object' && typeof item[Symbol.iterator] === 'function';
+}

package/lib/cjs/utils/is-sync-iterable.d.cts

@@ -0,0 +1 @@
+export declare function isSyncIterable<T>(item: unknown): item is IterableIterator<T>;

package/lib/esm/async.d.mts

@@ -1,7 +1,8 @@
-export { xdeferAsync as xdefer } from './defer.mjs';
+export { xdefer as xdeferUnknown, xdeferAsync as xdefer, xdeferSync } from './defer.mjs';
 export type { YResult, YSuccess, YFailure } from './partial.mjs';
-export { yok, yerr, yresAsync as yres, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.mjs';
+export { yok, yerr, yres as yresUnknown, yresAsync as yres, yresSync, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.mjs';
 export type { Success, Failure, Result } from './result.mjs';
 export { ok, err, OK, OK_NULL, OK_TRUE, OK_FALSE } from './result.mjs';
 export { stringifyError } from './stringify-error.mjs';
-export { xtryAsync as xtry } from './try.mjs';
+export { toStringFailure } from './to-string-failure.mjs';
+export { xtry as xtryUnknown, xtryAsync as xtry, xtryAsyncIterable as xtryIterable, xtrySync, xtrySyncIterable } from './try.mjs';

package/lib/esm/async.mjs

@@ -1,5 +1,6 @@
-export { xdeferAsync as xdefer } from './defer.mjs';
-export { yok, yerr, yresAsync as yres, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.mjs';
+export { xdefer as xdeferUnknown, xdeferAsync as xdefer, xdeferSync } from './defer.mjs';
+export { yok, yerr, yres as yresUnknown, yresAsync as yres, yresSync, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.mjs';
 export { ok, err, OK, OK_NULL, OK_TRUE, OK_FALSE } from './result.mjs';
 export { stringifyError } from './stringify-error.mjs';
-export { xtryAsync as xtry } from './try.mjs';
+export { toStringFailure } from './to-string-failure.mjs';
+export { xtry as xtryUnknown, xtryAsync as xtry, xtryAsyncIterable as xtryIterable, xtrySync, xtrySyncIterable } from './try.mjs';

package/lib/esm/index.d.mts

@@ -4,4 +4,5 @@ export { yok, yerr, yres, yresAsync, yresSync, yep, YOK, YOK_NULL, YOK_TRUE, YOK
 export type { Success, Failure, Result } from './result.mjs';
 export { ok, err, OK, OK_NULL, OK_TRUE, OK_FALSE } from './result.mjs';
 export { stringifyError } from './stringify-error.mjs';
-export { xtry, xtryAsync, xtrySync } from './try.mjs';
+export { toStringFailure } from './to-string-failure.mjs';
+export { xtry, xtryAsync, xtryAsyncIterable, xtrySync, xtrySyncIterable } from './try.mjs';

package/lib/esm/index.mjs

@@ -2,4 +2,5 @@ export { xdefer, xdeferAsync, xdeferSync } from './defer.mjs';
 export { yok, yerr, yres, yresAsync, yresSync, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.mjs';
 export { ok, err, OK, OK_NULL, OK_TRUE, OK_FALSE } from './result.mjs';
 export { stringifyError } from './stringify-error.mjs';
-export { xtry, xtryAsync, xtrySync } from './try.mjs';
+export { toStringFailure } from './to-string-failure.mjs';
+export { xtry, xtryAsync, xtryAsyncIterable, xtrySync, xtrySyncIterable } from './try.mjs';

package/lib/esm/sync.d.mts

@@ -1,7 +1,8 @@
-export { xdeferSync as xdefer } from './defer.mjs';
+export { xdefer as xdeferUnknown, xdeferAsync, xdeferSync as xdefer } from './defer.mjs';
 export type { YResult, YSuccess, YFailure } from './partial.mjs';
-export { yok, yerr, yresSync as yres, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.mjs';
+export { yok, yerr, yres as yresUnknown, yresAsync, yresSync as yres, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.mjs';
 export type { Success, Failure, Result } from './result.mjs';
 export { ok, err, OK, OK_NULL, OK_TRUE, OK_FALSE } from './result.mjs';
 export { stringifyError } from './stringify-error.mjs';
-export { xtrySync as xtry } from './try.mjs';
+export { toStringFailure } from './to-string-failure.mjs';
+export { xtry as xtryUnknown, xtryAsync, xtryAsyncIterable, xtrySync as xtry, xtrySyncIterable as xtryIterable } from './try.mjs';

package/lib/esm/sync.mjs

@@ -1,5 +1,6 @@
-export { xdeferSync as xdefer } from './defer.mjs';
-export { yok, yerr, yresSync as yres, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.mjs';
+export { xdefer as xdeferUnknown, xdeferAsync, xdeferSync as xdefer } from './defer.mjs';
+export { yok, yerr, yres as yresUnknown, yresAsync, yresSync as yres, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE } from './partial.mjs';
 export { ok, err, OK, OK_NULL, OK_TRUE, OK_FALSE } from './result.mjs';
 export { stringifyError } from './stringify-error.mjs';
-export { xtrySync as xtry } from './try.mjs';
+export { toStringFailure } from './to-string-failure.mjs';
+export { xtry as xtryUnknown, xtryAsync, xtryAsyncIterable, xtrySync as xtry, xtrySyncIterable as xtryIterable } from './try.mjs';

package/lib/esm/to-string-failure.d.mts

@@ -0,0 +1,2 @@
+import { type Failure } from './result.mjs';
+export declare function toStringFailure(error: unknown): Failure<string>;

package/lib/esm/to-string-failure.mjs

@@ -0,0 +1,5 @@
+import { err } from './result.mjs';
+import { stringifyError } from './stringify-error.mjs';
+export function toStringFailure(error) {
+    return err(stringifyError(error));
+}

package/lib/esm/try.d.mts

@@ -1,9 +1,17 @@
 import { type Result } from './result.mjs';
-import { type NonPromiseCallback, type PromiseCallback } from './utils/types.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;
+type SyncIterableCallback<T> = (() => Iterable<T>) | Iterable<T>;
+type SyncIterableResult<T, E> = Iterable<VoidableResult<T, E>>;
 type VoidableResult<T, E> = E extends void ? Result<T, unknown> : Result<T, E>;
+export declare function xtry<T, E = unknown>(iterable: SyncIterableCallback<T>, handler?: ErrorHandler<E>): SyncIterableResult<T, E>;
+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 {};

package/lib/esm/try.mjs

@@ -1,32 +1,39 @@
 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) {
     // eslint-disable-next-line @typescript-eslint/promise-function-async
     const run = func instanceof Function ? func : () => func;
-    const handleError = (error) => {
-        if (handler) {
-            const newError = handler(error);
-            if (newError !== undefined) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return err(newError);
-            }
-        }
-        return err(error);
-    };
-    const handleSuccess = (value) => ok(value);
     try {
         const value = run();
         if (isPromiseLike(value)) {
-            return Promise.resolve(value).then(handleSuccess, handleError);
+            return Promise.resolve(value).then(
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            (value) => ok(value), (error) => handleError(handler, error));
+        }
+        if (isAsyncIterable(value)) {
+            return xtryAsyncIterable(value, handler);
+        }
+        if (isSyncIterable(value)) {
+            return xtrySyncIterable(value, handler);
         }
         // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return ok(value);
     }
     catch (error) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return handleError(error);
+        return handleError(handler, error);
     }
-}
+} // }}}
 export function xtrySync(func, handler) {
     try {
         const value = func();
@@ -34,17 +41,9 @@ export function xtrySync(func, handler) {
         return ok(value);
     }
     catch (error) {
-        if (handler) {
-            const newError = handler(error);
-            if (newError !== undefined) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return err(newError);
-            }
-        }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return err(error);
+        return handleError(handler, error);
     }
-}
+} // }}}
 export async function xtryAsync(func, handler) {
     try {
         const value = await (func instanceof Promise ? func : Promise.resolve().then(func));
@@ -52,14 +51,72 @@ export async function xtryAsync(func, handler) {
         return ok(value);
     }
     catch (error) {
-        if (handler) {
-            const newError = handler(error);
-            if (newError !== undefined) {
-                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-                return err(newError);
+        return handleError(handler, error);
+    }
+} // }}}
+export function xtrySyncIterable(iterable, handler) {
+    const generator = iterable instanceof Function ? iterable : () => iterable;
+    function* iterate() {
+        let source;
+        try {
+            source = generator();
+        }
+        catch (error) {
+            yield handleError(handler, error);
+            return;
+        }
+        if (!source || typeof source[Symbol.iterator] !== 'function') {
+            yield handleError(handler, new TypeError('xtryIterable expects an Iterable'));
+            return;
+        }
+        const iterator = source[Symbol.iterator]();
+        while (true) {
+            let step;
+            try {
+                step = iterator.next();
+            }
+            catch (error) {
+                yield handleError(handler, error);
+                return;
+            }
+            if (step.done) {
+                return;
             }
+            yield ok(step.value);
+        }
+    }
+    return iterate();
+} // }}}
+export function xtryAsyncIterable(iterable, handler) {
+    const generator = iterable instanceof Function ? iterable : async () => iterable;
+    async function* iterate() {
+        let source;
+        try {
+            source = await Promise.resolve(generator());
+        }
+        catch (error) {
+            yield handleError(handler, error);
+            return;
+        }
+        if (!source || typeof source[Symbol.asyncIterator] !== 'function') {
+            yield handleError(handler, new TypeError('xtryAsyncIterable expects an AsyncIterable'));
+            return;
+        }
+        const iterator = source[Symbol.asyncIterator]();
+        while (true) {
+            let step;
+            try {
+                step = await iterator.next();
+            }
+            catch (error) {
+                yield handleError(handler, error);
+                return;
+            }
+            if (step.done) {
+                return;
+            }
+            yield ok(step.value);
         }
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        return err(error);
     }
-}
+    return iterate();
+} // }}}

package/lib/esm/utils/is-async-iterable.d.mts

@@ -0,0 +1 @@
+export declare function isAsyncIterable<T>(item: unknown): item is AsyncIterableIterator<T>;

package/lib/esm/utils/is-async-iterable.mjs

@@ -0,0 +1,3 @@
+export function isAsyncIterable(item) {
+    return item !== null && typeof item === 'object' && typeof item[Symbol.asyncIterator] === 'function';
+}

package/lib/esm/utils/is-sync-iterable.d.mts

@@ -0,0 +1 @@
+export declare function isSyncIterable<T>(item: unknown): item is IterableIterator<T>;

package/lib/esm/utils/is-sync-iterable.mjs

@@ -0,0 +1,3 @@
+export function isSyncIterable(item) {
+    return item !== null && typeof item === 'object' && typeof item[Symbol.iterator] === 'function';
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@zokugun/xtry",
 	"description": "simple try/catch wrapper returning Result",
-	"version": "0.6.4",
+	"version": "0.7.0",
 	"author": {
 		"name": "Baptiste Augrain",
 		"email": "daiyam@zokugun.org"