@praha/byethrow 0.7.2 → 0.8.0

package/dist/cjs/exports.cjs

@@ -15,8 +15,8 @@ var __webpack_modules__ = {
     "./functions/bind": function(module) {
         module.exports = require("./functions/bind.cjs");
     },
-    "./functions/combine": function(module) {
-        module.exports = require("./functions/combine.cjs");
+    "./functions/collect": function(module) {
+        module.exports = require("./functions/collect.cjs");
     },
     "./functions/do": function(module) {
         module.exports = require("./functions/do.cjs");
@@ -54,6 +54,9 @@ var __webpack_modules__ = {
     "./functions/pipe": function(module) {
         module.exports = require("./functions/pipe.cjs");
     },
+    "./functions/sequence": function(module) {
+        module.exports = require("./functions/sequence.cjs");
+    },
     "./functions/succeed": function(module) {
         module.exports = require("./functions/succeed.cjs");
     },
@@ -149,10 +152,10 @@ var __webpack_exports__ = {};
         return _functions_bind__WEBPACK_IMPORTED_MODULE_5__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_combine__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("./functions/combine");
+    var _functions_collect__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("./functions/collect");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_combine__WEBPACK_IMPORTED_MODULE_6__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_combine__WEBPACK_IMPORTED_MODULE_6__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_collect__WEBPACK_IMPORTED_MODULE_6__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_collect__WEBPACK_IMPORTED_MODULE_6__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
     var _functions_do__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__("./functions/do");
@@ -227,28 +230,34 @@ var __webpack_exports__ = {};
         return _functions_pipe__WEBPACK_IMPORTED_MODULE_18__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_succeed__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__("./functions/succeed");
+    var _functions_sequence__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__("./functions/sequence");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_sequence__WEBPACK_IMPORTED_MODULE_19__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_sequence__WEBPACK_IMPORTED_MODULE_19__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _functions_succeed__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__("./functions/succeed");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_succeed__WEBPACK_IMPORTED_MODULE_19__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_succeed__WEBPACK_IMPORTED_MODULE_19__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_succeed__WEBPACK_IMPORTED_MODULE_20__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_succeed__WEBPACK_IMPORTED_MODULE_20__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_try__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__("./functions/try");
+    var _functions_try__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__("./functions/try");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_try__WEBPACK_IMPORTED_MODULE_20__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_try__WEBPACK_IMPORTED_MODULE_20__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_try__WEBPACK_IMPORTED_MODULE_21__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_try__WEBPACK_IMPORTED_MODULE_21__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_unwrap__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__("./functions/unwrap");
+    var _functions_unwrap__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__("./functions/unwrap");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_unwrap__WEBPACK_IMPORTED_MODULE_21__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_unwrap__WEBPACK_IMPORTED_MODULE_21__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_unwrap__WEBPACK_IMPORTED_MODULE_22__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_unwrap__WEBPACK_IMPORTED_MODULE_22__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
-    var _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__("./functions/unwrap-error");
+    var _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__("./functions/unwrap-error");
     var __WEBPACK_REEXPORT_OBJECT__ = {};
-    for(var __WEBPACK_IMPORT_KEY__ in _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_22__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
-        return _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_22__[key];
+    for(var __WEBPACK_IMPORT_KEY__ in _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_23__)if ("default" !== __WEBPACK_IMPORT_KEY__) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _functions_unwrap_error__WEBPACK_IMPORTED_MODULE_23__[key];
     }).bind(0, __WEBPACK_IMPORT_KEY__);
     __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
 })();

package/dist/cjs/exports.d.ts

@@ -4,7 +4,7 @@ export * from './functions/and-through.js';
 export * from './functions/assert-failure.js';
 export * from './functions/assert-success.js';
 export * from './functions/bind.js';
-export * from './functions/combine.js';
+export * from './functions/collect.js';
 export * from './functions/do.js';
 export * from './functions/fail.js';
 export * from './functions/inspect.js';
@@ -17,6 +17,7 @@ export * from './functions/map-error.js';
 export * from './functions/or-else.js';
 export * from './functions/parse.js';
 export * from './functions/pipe.js';
+export * from './functions/sequence.js';
 export * from './functions/succeed.js';
 export * from './functions/try.js';
 export * from './functions/unwrap.js';

package/dist/cjs/functions/collect.cjs

@@ -0,0 +1,64 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    collect: ()=>collect
+});
+const external_fail_cjs_namespaceObject = require("./fail.cjs");
+const external_is_failure_cjs_namespaceObject = require("./is-failure.cjs");
+const external_succeed_cjs_namespaceObject = require("./succeed.cjs");
+const is_promise_cjs_namespaceObject = require("../internals/helpers/is-promise.cjs");
+const collect = (value, fn)=>{
+    const reduce = (entries, callback, initialValue)=>{
+        const errors = [];
+        const results = entries.map(([, entry])=>fn ? fn(entry) : entry);
+        if (results.some(is_promise_cjs_namespaceObject.isPromise)) return Promise.all(results).then((results)=>{
+            const accumulator = initialValue;
+            for (const [index, result] of results.entries())if ((0, external_is_failure_cjs_namespaceObject.isFailure)(result)) errors.push(result.error);
+            else callback(accumulator, result.value, entries[index]);
+            return errors.length > 0 ? (0, external_fail_cjs_namespaceObject.fail)(errors) : (0, external_succeed_cjs_namespaceObject.succeed)(accumulator);
+        });
+        const accumulator = initialValue;
+        for (const [index, result] of results.entries())if ((0, external_is_failure_cjs_namespaceObject.isFailure)(result)) errors.push(result.error);
+        else callback(accumulator, result.value, entries[index]);
+        return errors.length > 0 ? (0, external_fail_cjs_namespaceObject.fail)(errors) : (0, external_succeed_cjs_namespaceObject.succeed)(accumulator);
+    };
+    if (!Array.isArray(value)) return reduce(Object.entries(value), (accumulator, value, [key])=>{
+        accumulator[key] = value;
+    }, {});
+    if (fn) return reduce([
+        ...value.entries()
+    ], (accumulator, value)=>accumulator.push(value), []);
+    return reduce([
+        ...value.entries()
+    ], (accumulator, value)=>accumulator.push(value), []);
+};
+exports.collect = __webpack_exports__.collect;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "collect"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/functions/collect.d.ts

@@ -0,0 +1,103 @@
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
+/**
+ * Processes multiple {@link Result} or {@link ResultAsync} values into a single result.
+ * If all results are {@link Success}, returns a {@link Success} containing all values.
+ * If any result is a {@link Failure}, returns a {@link Failure} containing an array of all errors.
+ *
+ * Unlike {@link sequence}, which stops at the first error and returns only that error,
+ * `collect` processes all results and collects all errors.
+ *
+ * @function
+ * @typeParam X - The input type (object or array of Results).
+ *
+ * @example Object of Results (all succeed)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.collect({
+ *   name: Result.succeed('Alice'),
+ *   age: Result.succeed(20),
+ * });
+ * // { type: 'Success', value: { name: 'Alice', age: 20 } }
+ * ```
+ *
+ * @example Object of Results (some fail)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.collect({
+ *   name: Result.succeed('Alice'),
+ *   age: Result.fail('Invalid age'),
+ * });
+ * // { type: 'Failure', error: ['Invalid age'] }
+ * ```
+ *
+ * @example Array of Results (all succeed)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.collect([
+ *   Result.succeed(1),
+ *   Result.succeed(2),
+ *   Result.succeed(3),
+ * ]);
+ * // { type: 'Success', value: [1, 2, 3] }
+ * ```
+ *
+ * @example Array of Results (some fail)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.collect([
+ *   Result.succeed(1),
+ *   Result.fail('error1'),
+ *   Result.fail('error2'),
+ * ]);
+ * // { type: 'Failure', error: ['error1', 'error2'] }
+ * ```
+ *
+ * @example Using a mapper function (all succeed)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.collect(['1', '2', '3'], (value) => {
+ *   const number = Number(value);
+ *   return Number.isNaN(number)
+ *     ? Result.fail(`Invalid number: ${value}`)
+ *     : Result.succeed(number);
+ * });
+ * // { type: 'Success', value: [1, 2, 3] }
+ * ```
+ *
+ * @example Using a mapper function (some fail)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.collect(['1', 'invalid', '3'], (value) => {
+ *   const number = Number(value);
+ *   return Number.isNaN(number)
+ *     ? Result.fail(`Invalid number: ${value}`)
+ *     : Result.succeed(number);
+ * });
+ * // { type: 'Failure', error: ['Invalid number: invalid'] }
+ * ```
+ *
+ * @category Utilities
+ */
+export declare const collect: {
+    <X extends Record<string, ResultMaybeAsync<any, any>>>(x: X): ResultFor<X[keyof X], {
+        [K in keyof X]: InferSuccess<X[K]>;
+    }, InferFailure<X[keyof X]>[]>;
+    <const X extends Array<ResultMaybeAsync<any, any>>>(x: X): ResultFor<X[number], {
+        [K in keyof X]: InferSuccess<X[K]>;
+    }, InferFailure<X[number]>[]>;
+    <const X extends ReadonlyArray<ResultMaybeAsync<any, any>>>(x: X): ResultFor<X[number], {
+        [K in keyof X]: InferSuccess<X[K]>;
+    }, InferFailure<X[number]>[]>;
+    <const X extends Array<unknown>, Fn extends (value: X[number]) => ResultMaybeAsync<any, any>>(x: X, fn: Fn): ResultFor<ReturnType<Fn>, {
+        [K in keyof X]: InferSuccess<Fn>;
+    }, InferFailure<Fn>[]>;
+    <const X extends ReadonlyArray<unknown>, Fn extends (value: X[number]) => ResultMaybeAsync<any, any>>(x: X, fn: Fn): ResultFor<ReturnType<Fn>, {
+        [K in keyof X]: InferSuccess<Fn>;
+    }, InferFailure<Fn>[]>;
+};

package/dist/cjs/functions/fail.d.ts

@@ -31,11 +31,11 @@ import type { ResultFor } from '../result.js';
  * // Result.Result<never, void>
  * ```
  *
- * @see {@link combine} - For combining multiple Results into a single Result.
+ * @see {@link collect} - For collect multiple Results into a single Result.
  *
  * @category Creators
  */
 export declare const fail: {
     (): ResultFor<never, never, void>;
-    <E>(error: E): ResultFor<E, never, Awaited<E>>;
+    <const E>(error: E): ResultFor<E, never, Awaited<E>>;
 };

package/dist/cjs/functions/map-error.d.ts

@@ -34,6 +34,6 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  * @category Combinators
  */
 export declare const mapError: {
-    <R1 extends ResultMaybeAsync<any, any>, E2>(fn: (a: InferFailure<R1>) => E2): (result: R1) => ResultFor<R1, InferSuccess<R1>, E2>;
-    <E1, E2>(fn: (a: E1) => E2): <R1 extends ResultMaybeAsync<any, E1>>(result: R1) => ResultFor<R1, InferSuccess<R1>, E2>;
+    <R1 extends ResultMaybeAsync<any, any>, const E2>(fn: (a: InferFailure<R1>) => E2): (result: R1) => ResultFor<R1, InferSuccess<R1>, E2>;
+    <E1, const E2>(fn: (a: E1) => E2): <R1 extends ResultMaybeAsync<any, E1>>(result: R1) => ResultFor<R1, InferSuccess<R1>, E2>;
 };

package/dist/cjs/functions/map.d.ts

@@ -34,6 +34,6 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  * @category Combinators
  */
 export declare const map: {
-    <R1 extends ResultMaybeAsync<any, any>, T2>(fn: (a: InferSuccess<R1>) => T2): (result: R1) => ResultFor<R1, T2, InferFailure<R1>>;
-    <T1, T2>(fn: (a: T1) => T2): <R1 extends ResultMaybeAsync<T1, any>>(result: R1) => ResultFor<R1, T2, InferFailure<R1>>;
+    <R1 extends ResultMaybeAsync<any, any>, const T2>(fn: (a: InferSuccess<R1>) => T2): (result: R1) => ResultFor<R1, T2, InferFailure<R1>>;
+    <T1, const T2>(fn: (a: T1) => T2): <R1 extends ResultMaybeAsync<T1, any>>(result: R1) => ResultFor<R1, T2, InferFailure<R1>>;
 };

package/dist/cjs/functions/sequence.cjs

@@ -0,0 +1,69 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    sequence: ()=>sequence
+});
+const external_fail_cjs_namespaceObject = require("./fail.cjs");
+const external_is_failure_cjs_namespaceObject = require("./is-failure.cjs");
+const external_succeed_cjs_namespaceObject = require("./succeed.cjs");
+const is_promise_cjs_namespaceObject = require("../internals/helpers/is-promise.cjs");
+const sequence = (value, fn)=>{
+    const reduce = (entries, callback, initialValue)=>{
+        const accumulator = initialValue;
+        for (const [index, entry] of entries.entries()){
+            const result = fn ? fn(entry[1]) : entry[1];
+            if ((0, is_promise_cjs_namespaceObject.isPromise)(result)) return result.then(async (result)=>{
+                if ((0, external_is_failure_cjs_namespaceObject.isFailure)(result)) return (0, external_fail_cjs_namespaceObject.fail)(result.error);
+                callback(accumulator, result.value, entry);
+                for (const entry of entries.slice(index + 1)){
+                    const result = await (fn ? fn(entry[1]) : entry[1]);
+                    if ((0, external_is_failure_cjs_namespaceObject.isFailure)(result)) return (0, external_fail_cjs_namespaceObject.fail)(result.error);
+                    callback(accumulator, result.value, entry);
+                }
+                return (0, external_succeed_cjs_namespaceObject.succeed)(accumulator);
+            });
+            if ((0, external_is_failure_cjs_namespaceObject.isFailure)(result)) return (0, external_fail_cjs_namespaceObject.fail)(result.error);
+            callback(accumulator, result.value, entry);
+        }
+        return (0, external_succeed_cjs_namespaceObject.succeed)(accumulator);
+    };
+    if (!Array.isArray(value)) return reduce(Object.entries(value), (accumulator, value, [key])=>{
+        accumulator[key] = value;
+    }, {});
+    if (fn) return reduce([
+        ...value.entries()
+    ], (accumulator, value)=>accumulator.push(value), []);
+    return reduce([
+        ...value.entries()
+    ], (accumulator, value)=>accumulator.push(value), []);
+};
+exports.sequence = __webpack_exports__.sequence;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "sequence"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/functions/sequence.d.ts

@@ -0,0 +1,101 @@
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
+/**
+ * Processes multiple {@link Result} or {@link ResultAsync} values into a single result.
+ * If all results are {@link Success}, returns a {@link Success} containing all values.
+ * If any result is a {@link Failure}, immediately stops processing and returns a {@link Failure} with that single error.
+ *
+ * Unlike {@link collect}, which processes all results and collects all errors,
+ * `sequence` stops at the first error and returns only that error.
+ *
+ * @function
+ * @typeParam X - The input type (object or array of Results).
+ *
+ * @example Object of Results (all succeed)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.sequence({
+ *   name: Result.succeed('Alice'),
+ *   age: Result.succeed(20),
+ * });
+ * // { type: 'Success', value: { name: 'Alice', age: 20 } }
+ * ```
+ *
+ * @example Object of Results (stops at first failure)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.sequence({
+ *   name: Result.succeed('Alice'),
+ *   age: Result.fail('Invalid age'),
+ * });
+ * // { type: 'Failure', error: 'Invalid age' }
+ * ```
+ *
+ * @example Array of Results (all succeed)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.sequence([
+ *   Result.succeed(1),
+ *   Result.succeed(2),
+ * ]);
+ * // { type: 'Success', value: [1, 2, 3] }
+ * ```
+ *
+ * @example Array of Results (stops at first failure)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.sequence([
+ *   Result.succeed(1),
+ *   Result.fail('error1'),
+ * ]);
+ * // { type: 'Failure', error: 'error1' }
+ * ```
+ *
+ * @example Using a mapper function (all succeed)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.sequence(['1', '2', '3'], (value) => {
+ *   const number = Number(value);
+ *   return Number.isNaN(number)
+ *     ? Result.fail(`Invalid number: ${value}`)
+ *     : Result.succeed(number);
+ * });
+ * // { type: 'Success', value: [1, 2, 3] }
+ * ```
+ *
+ * @example Using a mapper function (stops at first failure)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.sequence(['1', 'invalid', '3'], (value) => {
+ *   const number = Number(value);
+ *   return Number.isNaN(number)
+ *     ? Result.fail(`Invalid number: ${value}`)
+ *     : Result.succeed(number);
+ * });
+ * // { type: 'Failure', error: 'Invalid number: invalid' }
+ * ```
+ *
+ * @category Utilities
+ */
+export declare const sequence: {
+    <X extends Record<string, ResultMaybeAsync<any, any>>>(x: X): ResultFor<X[keyof X], {
+        [K in keyof X]: InferSuccess<X[K]>;
+    }, InferFailure<X[keyof X]>>;
+    <const X extends Array<ResultMaybeAsync<any, any>>>(x: X): ResultFor<X[number], {
+        [K in keyof X]: InferSuccess<X[K]>;
+    }, InferFailure<X[number]>>;
+    <const X extends ReadonlyArray<ResultMaybeAsync<any, any>>>(x: X): ResultFor<X[number], {
+        [K in keyof X]: InferSuccess<X[K]>;
+    }, InferFailure<X[number]>>;
+    <const X extends Array<unknown>, Fn extends (value: X[number]) => ResultMaybeAsync<any, any>>(x: X, fn: Fn): ResultFor<ReturnType<Fn>, {
+        [K in keyof X]: InferSuccess<Fn>;
+    }, InferFailure<Fn>>;
+    <const X extends ReadonlyArray<unknown>, Fn extends (value: X[number]) => ResultMaybeAsync<any, any>>(x: X, fn: Fn): ResultFor<ReturnType<Fn>, {
+        [K in keyof X]: InferSuccess<Fn>;
+    }, InferFailure<Fn>>;
+};

package/dist/cjs/functions/succeed.d.ts

@@ -31,11 +31,11 @@ import type { ResultFor } from '../result.js';
  * // Result.Result<void, never>
  * ```
  *
- * @see {@link combine} - For combining multiple Results into a single Result.
+ * @see {@link collect} - For collect multiple Results into a single Result.
  *
  * @category Creators
  */
 export declare const succeed: {
     (): ResultFor<never, void, never>;
-    <T>(value: T): ResultFor<T, Awaited<T>, never>;
+    <const T>(value: T): ResultFor<T, Awaited<T>, never>;
 };

package/dist/esm/exports.d.ts

@@ -4,7 +4,7 @@ export * from './functions/and-through.js';
 export * from './functions/assert-failure.js';
 export * from './functions/assert-success.js';
 export * from './functions/bind.js';
-export * from './functions/combine.js';
+export * from './functions/collect.js';
 export * from './functions/do.js';
 export * from './functions/fail.js';
 export * from './functions/inspect.js';
@@ -17,6 +17,7 @@ export * from './functions/map-error.js';
 export * from './functions/or-else.js';
 export * from './functions/parse.js';
 export * from './functions/pipe.js';
+export * from './functions/sequence.js';
 export * from './functions/succeed.js';
 export * from './functions/try.js';
 export * from './functions/unwrap.js';

package/dist/esm/exports.js

@@ -4,7 +4,7 @@ export * from "./functions/and-through.js";
 export * from "./functions/assert-failure.js";
 export * from "./functions/assert-success.js";
 export * from "./functions/bind.js";
-export * from "./functions/combine.js";
+export * from "./functions/collect.js";
 export * from "./functions/do.js";
 export * from "./functions/fail.js";
 export * from "./functions/inspect.js";
@@ -17,6 +17,7 @@ export * from "./functions/map-error.js";
 export * from "./functions/or-else.js";
 export * from "./functions/parse.js";
 export * from "./functions/pipe.js";
+export * from "./functions/sequence.js";
 export * from "./functions/succeed.js";
 export * from "./functions/try.js";
 export * from "./functions/unwrap.js";

package/dist/esm/functions/collect.d.ts

@@ -0,0 +1,103 @@
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
+/**
+ * Processes multiple {@link Result} or {@link ResultAsync} values into a single result.
+ * If all results are {@link Success}, returns a {@link Success} containing all values.
+ * If any result is a {@link Failure}, returns a {@link Failure} containing an array of all errors.
+ *
+ * Unlike {@link sequence}, which stops at the first error and returns only that error,
+ * `collect` processes all results and collects all errors.
+ *
+ * @function
+ * @typeParam X - The input type (object or array of Results).
+ *
+ * @example Object of Results (all succeed)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.collect({
+ *   name: Result.succeed('Alice'),
+ *   age: Result.succeed(20),
+ * });
+ * // { type: 'Success', value: { name: 'Alice', age: 20 } }
+ * ```
+ *
+ * @example Object of Results (some fail)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.collect({
+ *   name: Result.succeed('Alice'),
+ *   age: Result.fail('Invalid age'),
+ * });
+ * // { type: 'Failure', error: ['Invalid age'] }
+ * ```
+ *
+ * @example Array of Results (all succeed)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.collect([
+ *   Result.succeed(1),
+ *   Result.succeed(2),
+ *   Result.succeed(3),
+ * ]);
+ * // { type: 'Success', value: [1, 2, 3] }
+ * ```
+ *
+ * @example Array of Results (some fail)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.collect([
+ *   Result.succeed(1),
+ *   Result.fail('error1'),
+ *   Result.fail('error2'),
+ * ]);
+ * // { type: 'Failure', error: ['error1', 'error2'] }
+ * ```
+ *
+ * @example Using a mapper function (all succeed)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.collect(['1', '2', '3'], (value) => {
+ *   const number = Number(value);
+ *   return Number.isNaN(number)
+ *     ? Result.fail(`Invalid number: ${value}`)
+ *     : Result.succeed(number);
+ * });
+ * // { type: 'Success', value: [1, 2, 3] }
+ * ```
+ *
+ * @example Using a mapper function (some fail)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.collect(['1', 'invalid', '3'], (value) => {
+ *   const number = Number(value);
+ *   return Number.isNaN(number)
+ *     ? Result.fail(`Invalid number: ${value}`)
+ *     : Result.succeed(number);
+ * });
+ * // { type: 'Failure', error: ['Invalid number: invalid'] }
+ * ```
+ *
+ * @category Utilities
+ */
+export declare const collect: {
+    <X extends Record<string, ResultMaybeAsync<any, any>>>(x: X): ResultFor<X[keyof X], {
+        [K in keyof X]: InferSuccess<X[K]>;
+    }, InferFailure<X[keyof X]>[]>;
+    <const X extends Array<ResultMaybeAsync<any, any>>>(x: X): ResultFor<X[number], {
+        [K in keyof X]: InferSuccess<X[K]>;
+    }, InferFailure<X[number]>[]>;
+    <const X extends ReadonlyArray<ResultMaybeAsync<any, any>>>(x: X): ResultFor<X[number], {
+        [K in keyof X]: InferSuccess<X[K]>;
+    }, InferFailure<X[number]>[]>;
+    <const X extends Array<unknown>, Fn extends (value: X[number]) => ResultMaybeAsync<any, any>>(x: X, fn: Fn): ResultFor<ReturnType<Fn>, {
+        [K in keyof X]: InferSuccess<Fn>;
+    }, InferFailure<Fn>[]>;
+    <const X extends ReadonlyArray<unknown>, Fn extends (value: X[number]) => ResultMaybeAsync<any, any>>(x: X, fn: Fn): ResultFor<ReturnType<Fn>, {
+        [K in keyof X]: InferSuccess<Fn>;
+    }, InferFailure<Fn>[]>;
+};

package/dist/esm/functions/collect.js

@@ -0,0 +1,30 @@
+import { fail } from "./fail.js";
+import { isFailure } from "./is-failure.js";
+import { succeed } from "./succeed.js";
+import { isPromise } from "../internals/helpers/is-promise.js";
+const collect = (value, fn)=>{
+    const reduce = (entries, callback, initialValue)=>{
+        const errors = [];
+        const results = entries.map(([, entry])=>fn ? fn(entry) : entry);
+        if (results.some(isPromise)) return Promise.all(results).then((results)=>{
+            const accumulator = initialValue;
+            for (const [index, result] of results.entries())if (isFailure(result)) errors.push(result.error);
+            else callback(accumulator, result.value, entries[index]);
+            return errors.length > 0 ? fail(errors) : succeed(accumulator);
+        });
+        const accumulator = initialValue;
+        for (const [index, result] of results.entries())if (isFailure(result)) errors.push(result.error);
+        else callback(accumulator, result.value, entries[index]);
+        return errors.length > 0 ? fail(errors) : succeed(accumulator);
+    };
+    if (!Array.isArray(value)) return reduce(Object.entries(value), (accumulator, value, [key])=>{
+        accumulator[key] = value;
+    }, {});
+    if (fn) return reduce([
+        ...value.entries()
+    ], (accumulator, value)=>accumulator.push(value), []);
+    return reduce([
+        ...value.entries()
+    ], (accumulator, value)=>accumulator.push(value), []);
+};
+export { collect };

package/dist/esm/functions/fail.d.ts

@@ -31,11 +31,11 @@ import type { ResultFor } from '../result.js';
  * // Result.Result<never, void>
  * ```
  *
- * @see {@link combine} - For combining multiple Results into a single Result.
+ * @see {@link collect} - For collect multiple Results into a single Result.
  *
  * @category Creators
  */
 export declare const fail: {
     (): ResultFor<never, never, void>;
-    <E>(error: E): ResultFor<E, never, Awaited<E>>;
+    <const E>(error: E): ResultFor<E, never, Awaited<E>>;
 };

package/dist/esm/functions/map-error.d.ts

@@ -34,6 +34,6 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  * @category Combinators
  */
 export declare const mapError: {
-    <R1 extends ResultMaybeAsync<any, any>, E2>(fn: (a: InferFailure<R1>) => E2): (result: R1) => ResultFor<R1, InferSuccess<R1>, E2>;
-    <E1, E2>(fn: (a: E1) => E2): <R1 extends ResultMaybeAsync<any, E1>>(result: R1) => ResultFor<R1, InferSuccess<R1>, E2>;
+    <R1 extends ResultMaybeAsync<any, any>, const E2>(fn: (a: InferFailure<R1>) => E2): (result: R1) => ResultFor<R1, InferSuccess<R1>, E2>;
+    <E1, const E2>(fn: (a: E1) => E2): <R1 extends ResultMaybeAsync<any, E1>>(result: R1) => ResultFor<R1, InferSuccess<R1>, E2>;
 };

package/dist/esm/functions/map.d.ts

@@ -34,6 +34,6 @@ import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '..
  * @category Combinators
  */
 export declare const map: {
-    <R1 extends ResultMaybeAsync<any, any>, T2>(fn: (a: InferSuccess<R1>) => T2): (result: R1) => ResultFor<R1, T2, InferFailure<R1>>;
-    <T1, T2>(fn: (a: T1) => T2): <R1 extends ResultMaybeAsync<T1, any>>(result: R1) => ResultFor<R1, T2, InferFailure<R1>>;
+    <R1 extends ResultMaybeAsync<any, any>, const T2>(fn: (a: InferSuccess<R1>) => T2): (result: R1) => ResultFor<R1, T2, InferFailure<R1>>;
+    <T1, const T2>(fn: (a: T1) => T2): <R1 extends ResultMaybeAsync<T1, any>>(result: R1) => ResultFor<R1, T2, InferFailure<R1>>;
 };

package/dist/esm/functions/sequence.d.ts

@@ -0,0 +1,101 @@
+import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
+/**
+ * Processes multiple {@link Result} or {@link ResultAsync} values into a single result.
+ * If all results are {@link Success}, returns a {@link Success} containing all values.
+ * If any result is a {@link Failure}, immediately stops processing and returns a {@link Failure} with that single error.
+ *
+ * Unlike {@link collect}, which processes all results and collects all errors,
+ * `sequence` stops at the first error and returns only that error.
+ *
+ * @function
+ * @typeParam X - The input type (object or array of Results).
+ *
+ * @example Object of Results (all succeed)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.sequence({
+ *   name: Result.succeed('Alice'),
+ *   age: Result.succeed(20),
+ * });
+ * // { type: 'Success', value: { name: 'Alice', age: 20 } }
+ * ```
+ *
+ * @example Object of Results (stops at first failure)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.sequence({
+ *   name: Result.succeed('Alice'),
+ *   age: Result.fail('Invalid age'),
+ * });
+ * // { type: 'Failure', error: 'Invalid age' }
+ * ```
+ *
+ * @example Array of Results (all succeed)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.sequence([
+ *   Result.succeed(1),
+ *   Result.succeed(2),
+ * ]);
+ * // { type: 'Success', value: [1, 2, 3] }
+ * ```
+ *
+ * @example Array of Results (stops at first failure)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.sequence([
+ *   Result.succeed(1),
+ *   Result.fail('error1'),
+ * ]);
+ * // { type: 'Failure', error: 'error1' }
+ * ```
+ *
+ * @example Using a mapper function (all succeed)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.sequence(['1', '2', '3'], (value) => {
+ *   const number = Number(value);
+ *   return Number.isNaN(number)
+ *     ? Result.fail(`Invalid number: ${value}`)
+ *     : Result.succeed(number);
+ * });
+ * // { type: 'Success', value: [1, 2, 3] }
+ * ```
+ *
+ * @example Using a mapper function (stops at first failure)
+ * ```ts
+ * import { Result } from '@praha/byethrow';
+ *
+ * const result = Result.sequence(['1', 'invalid', '3'], (value) => {
+ *   const number = Number(value);
+ *   return Number.isNaN(number)
+ *     ? Result.fail(`Invalid number: ${value}`)
+ *     : Result.succeed(number);
+ * });
+ * // { type: 'Failure', error: 'Invalid number: invalid' }
+ * ```
+ *
+ * @category Utilities
+ */
+export declare const sequence: {
+    <X extends Record<string, ResultMaybeAsync<any, any>>>(x: X): ResultFor<X[keyof X], {
+        [K in keyof X]: InferSuccess<X[K]>;
+    }, InferFailure<X[keyof X]>>;
+    <const X extends Array<ResultMaybeAsync<any, any>>>(x: X): ResultFor<X[number], {
+        [K in keyof X]: InferSuccess<X[K]>;
+    }, InferFailure<X[number]>>;
+    <const X extends ReadonlyArray<ResultMaybeAsync<any, any>>>(x: X): ResultFor<X[number], {
+        [K in keyof X]: InferSuccess<X[K]>;
+    }, InferFailure<X[number]>>;
+    <const X extends Array<unknown>, Fn extends (value: X[number]) => ResultMaybeAsync<any, any>>(x: X, fn: Fn): ResultFor<ReturnType<Fn>, {
+        [K in keyof X]: InferSuccess<Fn>;
+    }, InferFailure<Fn>>;
+    <const X extends ReadonlyArray<unknown>, Fn extends (value: X[number]) => ResultMaybeAsync<any, any>>(x: X, fn: Fn): ResultFor<ReturnType<Fn>, {
+        [K in keyof X]: InferSuccess<Fn>;
+    }, InferFailure<Fn>>;
+};

package/dist/esm/functions/sequence.js

@@ -0,0 +1,35 @@
+import { fail } from "./fail.js";
+import { isFailure } from "./is-failure.js";
+import { succeed } from "./succeed.js";
+import { isPromise } from "../internals/helpers/is-promise.js";
+const sequence = (value, fn)=>{
+    const reduce = (entries, callback, initialValue)=>{
+        const accumulator = initialValue;
+        for (const [index, entry] of entries.entries()){
+            const result = fn ? fn(entry[1]) : entry[1];
+            if (isPromise(result)) return result.then(async (result)=>{
+                if (isFailure(result)) return fail(result.error);
+                callback(accumulator, result.value, entry);
+                for (const entry of entries.slice(index + 1)){
+                    const result = await (fn ? fn(entry[1]) : entry[1]);
+                    if (isFailure(result)) return fail(result.error);
+                    callback(accumulator, result.value, entry);
+                }
+                return succeed(accumulator);
+            });
+            if (isFailure(result)) return fail(result.error);
+            callback(accumulator, result.value, entry);
+        }
+        return succeed(accumulator);
+    };
+    if (!Array.isArray(value)) return reduce(Object.entries(value), (accumulator, value, [key])=>{
+        accumulator[key] = value;
+    }, {});
+    if (fn) return reduce([
+        ...value.entries()
+    ], (accumulator, value)=>accumulator.push(value), []);
+    return reduce([
+        ...value.entries()
+    ], (accumulator, value)=>accumulator.push(value), []);
+};
+export { sequence };

package/dist/esm/functions/succeed.d.ts

@@ -31,11 +31,11 @@ import type { ResultFor } from '../result.js';
  * // Result.Result<void, never>
  * ```
  *
- * @see {@link combine} - For combining multiple Results into a single Result.
+ * @see {@link collect} - For collect multiple Results into a single Result.
  *
  * @category Creators
  */
 export declare const succeed: {
     (): ResultFor<never, void, never>;
-    <T>(value: T): ResultFor<T, Awaited<T>, never>;
+    <const T>(value: T): ResultFor<T, Awaited<T>, never>;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praha/byethrow",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "A lightweight, tree-shakable Result type package with a simple, consistent API designed",
   "keywords": [
     "javascript",
@@ -44,13 +44,16 @@
     "@standard-schema/spec": "^1.0.0"
   },
   "devDependencies": {
-    "@rslib/core": "0.15.0",
+    "@rslib/core": "0.15.1",
     "eslint": "9.37.0",
-    "typedoc": "0.28.13",
+    "typedoc": "0.28.14",
     "typedoc-plugin-markdown": "4.9.0",
     "typescript": "5.9.3",
     "vitest": "3.2.4"
   },
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
   "publishConfig": {
     "provenance": true
   },

package/dist/cjs/functions/combine.cjs

@@ -1,89 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    combine: ()=>combine
-});
-const external_fail_cjs_namespaceObject = require("./fail.cjs");
-const external_is_failure_cjs_namespaceObject = require("./is-failure.cjs");
-const external_succeed_cjs_namespaceObject = require("./succeed.cjs");
-const is_promise_cjs_namespaceObject = require("../internals/helpers/is-promise.cjs");
-const combine = (value)=>{
-    if (Array.isArray(value)) {
-        const group = (results)=>{
-            const errors = [];
-            const successes = [];
-            for (const result of results)if ((0, external_is_failure_cjs_namespaceObject.isFailure)(result)) errors.push(result.error);
-            else successes.push(result.value);
-            return {
-                errors,
-                successes
-            };
-        };
-        if (value.some(is_promise_cjs_namespaceObject.isPromise)) {
-            const results = value;
-            return Promise.all(results).then((results)=>{
-                const { successes, errors } = group(results);
-                return errors.length > 0 ? (0, external_fail_cjs_namespaceObject.fail)(errors) : (0, external_succeed_cjs_namespaceObject.succeed)(successes);
-            });
-        }
-        const results = value;
-        const { successes, errors } = group(results);
-        return errors.length > 0 ? (0, external_fail_cjs_namespaceObject.fail)(errors) : (0, external_succeed_cjs_namespaceObject.succeed)(successes);
-    }
-    {
-        const group = (entries)=>{
-            const errors = [];
-            const successes = {};
-            for (const [key, result] of entries)if ((0, external_is_failure_cjs_namespaceObject.isFailure)(result)) errors.push(result.error);
-            else successes[key] = result.value;
-            return {
-                errors,
-                successes
-            };
-        };
-        const entries = Object.entries(value);
-        if (entries.some(([, result])=>(0, is_promise_cjs_namespaceObject.isPromise)(result))) {
-            const results = entries;
-            const promises = results.map(async ([key, result])=>[
-                    key,
-                    await result
-                ]);
-            return Promise.all(promises).then((entries)=>{
-                const { successes, errors } = group(entries);
-                return errors.length > 0 ? (0, external_fail_cjs_namespaceObject.fail)(errors) : (0, external_succeed_cjs_namespaceObject.succeed)(successes);
-            });
-        }
-        const { successes, errors } = group(entries);
-        return errors.length > 0 ? (0, external_fail_cjs_namespaceObject.fail)(errors) : (0, external_succeed_cjs_namespaceObject.succeed)(successes);
-    }
-};
-exports.combine = __webpack_exports__.combine;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "combine"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});

package/dist/cjs/functions/combine.d.ts

@@ -1,54 +0,0 @@
-import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
-/**
- * Combines multiple {@link Result} or {@link ResultAsync} values into a single result.
- * If all inputs are {@link Success}, returns a {@link Success} with combined values.
- * If any input is a {@link Failure}, returns a {@link Failure} with an array of all errors.
- *
- * @function
- * @typeParam X - The input type (object or array of Results).
- *
- * @example Object Input
- * ```ts
- * import { Result } from '@praha/byethrow';
- *
- * const result = Result.combine({
- *   a: Result.succeed(1),
- *   b: Result.succeed('hello'),
- * });
- * // { type: 'Success', value: { a: 1, b: 'hello' } }
- * ```
- *
- * @example Array Input
- * ```ts
- * import { Result } from '@praha/byethrow';
- *
- * const result = Result.combine([
- *   Result.succeed(1),
- *   Result.succeed(2),
- *   Result.succeed(3),
- * ]);
- * // { type: 'Success', value: [1, 2, 3] }
- * ```
- *
- * @example With Failures
- * ```ts
- * import { Result } from '@praha/byethrow';
- *
- * const result = Result.combine([
- *   Result.succeed(1),
- *   Result.fail('error1'),
- *   Result.fail('error2'),
- * ]);
- * // { type: 'Failure', error: ['error1', 'error2'] }
- * ```
- *
- * @category Utilities
- */
-export declare const combine: {
-    <X extends Record<string, ResultMaybeAsync<any, any>>>(x: X): ResultFor<X[keyof X], {
-        [K in keyof X]: InferSuccess<X[K]>;
-    }, InferFailure<X[keyof X]>[]>;
-    <const X extends Array<ResultMaybeAsync<any, any>>>(x: X): ResultFor<X[number], {
-        [K in keyof X]: InferSuccess<X[K]>;
-    }, InferFailure<X[number]>[]>;
-};

package/dist/esm/functions/combine.d.ts

@@ -1,54 +0,0 @@
-import type { InferFailure, InferSuccess, ResultFor, ResultMaybeAsync } from '../result.js';
-/**
- * Combines multiple {@link Result} or {@link ResultAsync} values into a single result.
- * If all inputs are {@link Success}, returns a {@link Success} with combined values.
- * If any input is a {@link Failure}, returns a {@link Failure} with an array of all errors.
- *
- * @function
- * @typeParam X - The input type (object or array of Results).
- *
- * @example Object Input
- * ```ts
- * import { Result } from '@praha/byethrow';
- *
- * const result = Result.combine({
- *   a: Result.succeed(1),
- *   b: Result.succeed('hello'),
- * });
- * // { type: 'Success', value: { a: 1, b: 'hello' } }
- * ```
- *
- * @example Array Input
- * ```ts
- * import { Result } from '@praha/byethrow';
- *
- * const result = Result.combine([
- *   Result.succeed(1),
- *   Result.succeed(2),
- *   Result.succeed(3),
- * ]);
- * // { type: 'Success', value: [1, 2, 3] }
- * ```
- *
- * @example With Failures
- * ```ts
- * import { Result } from '@praha/byethrow';
- *
- * const result = Result.combine([
- *   Result.succeed(1),
- *   Result.fail('error1'),
- *   Result.fail('error2'),
- * ]);
- * // { type: 'Failure', error: ['error1', 'error2'] }
- * ```
- *
- * @category Utilities
- */
-export declare const combine: {
-    <X extends Record<string, ResultMaybeAsync<any, any>>>(x: X): ResultFor<X[keyof X], {
-        [K in keyof X]: InferSuccess<X[K]>;
-    }, InferFailure<X[keyof X]>[]>;
-    <const X extends Array<ResultMaybeAsync<any, any>>>(x: X): ResultFor<X[number], {
-        [K in keyof X]: InferSuccess<X[K]>;
-    }, InferFailure<X[number]>[]>;
-};

package/dist/esm/functions/combine.js

@@ -1,55 +0,0 @@
-import { fail } from "./fail.js";
-import { isFailure } from "./is-failure.js";
-import { succeed } from "./succeed.js";
-import { isPromise } from "../internals/helpers/is-promise.js";
-const combine = (value)=>{
-    if (Array.isArray(value)) {
-        const group = (results)=>{
-            const errors = [];
-            const successes = [];
-            for (const result of results)if (isFailure(result)) errors.push(result.error);
-            else successes.push(result.value);
-            return {
-                errors,
-                successes
-            };
-        };
-        if (value.some(isPromise)) {
-            const results = value;
-            return Promise.all(results).then((results)=>{
-                const { successes, errors } = group(results);
-                return errors.length > 0 ? fail(errors) : succeed(successes);
-            });
-        }
-        const results = value;
-        const { successes, errors } = group(results);
-        return errors.length > 0 ? fail(errors) : succeed(successes);
-    }
-    {
-        const group = (entries)=>{
-            const errors = [];
-            const successes = {};
-            for (const [key, result] of entries)if (isFailure(result)) errors.push(result.error);
-            else successes[key] = result.value;
-            return {
-                errors,
-                successes
-            };
-        };
-        const entries = Object.entries(value);
-        if (entries.some(([, result])=>isPromise(result))) {
-            const results = entries;
-            const promises = results.map(async ([key, result])=>[
-                    key,
-                    await result
-                ]);
-            return Promise.all(promises).then((entries)=>{
-                const { successes, errors } = group(entries);
-                return errors.length > 0 ? fail(errors) : succeed(successes);
-            });
-        }
-        const { successes, errors } = group(entries);
-        return errors.length > 0 ? fail(errors) : succeed(successes);
-    }
-};
-export { combine };