@satoshibits/functional 1.0.2

package/dist/reader-result.mjs

@@ -0,0 +1,758 @@
+"use strict";
+/**
+ * @module reader-result
+ * @description Combines Reader (dependency injection) with Result (error handling)
+ * for asynchronous computations. This provides a powerful abstraction for
+ * building composable, testable applications with explicit error handling
+ * and dependency injection. Similar to fp-ts's ReaderTaskEither but tailored
+ * for our Result type and async/await patterns.
+ *
+ * @example
+ * ```typescript
+ * import { ReaderResult, liftAsync } from './reader-result.mts';
+ *
+ * // define dependencies
+ * interface Deps {
+ *   db: Database;
+ *   logger: Logger;
+ *   config: Config;
+ * }
+ *
+ * // create reusable operations
+ * const getUser = (id: string): ReaderResult<Deps, string, User> =>
+ *   ReaderResult.tryCatch(
+ *     async (deps) => deps.db.users.findById(id),
+ *     (error) => `Failed to fetch user: ${error}`
+ *   );
+ *
+ * // compose operations
+ * const program = ReaderResult.Do()
+ *   .pipe(ReaderResult.bind('user', () => getUser('123')))
+ *   .pipe(ReaderResult.bind('posts', ({ user }) => getUserPosts(user.id)))
+ *   .pipe(ReaderResult.map(({ user, posts }) => ({ ...user, posts })));
+ *
+ * // run with dependencies
+ * const result = await ReaderResult.run(dependencies)(program);
+ * ```
+ *
+ * @category Core
+ * @since 2025-07-03
+ */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { Result as ResultUtils } from './result.mjs';
+/**
+ * Constructors and combinators for ReaderResult
+ */
+export var ReaderResult = {
+    /**
+     * Lift a pure value into ReaderResult context.
+     * @description Creates a ReaderResult that always succeeds with the given value,
+     * ignoring the dependencies.
+     *
+     * @template R - The type of dependencies
+     * @template E - The error type
+     * @template A - The type of the value
+     * @param {A} value - The value to wrap
+     * @returns {ReaderResult<R, E, A>} A ReaderResult that always succeeds with the value
+     *
+     * @category Constructors
+     * @example
+     * const always42 = ReaderResult.of<Deps, string, number>(42);
+     * const result = await ReaderResult.run(deps)(always42);
+     * // => { success: true, data: 42 }
+     *
+     * @since 2025-07-03
+     */
+    of: function (value) {
+        return function () { return Promise.resolve(ResultUtils.ok(value)); };
+    },
+    /**
+     * Lift an error into ReaderResult context.
+     * @description Creates a ReaderResult that always fails with the given error,
+     * ignoring the dependencies.
+     *
+     * @template R - The type of dependencies
+     * @template E - The error type
+     * @template A - The success type
+     * @param {E} error - The error to wrap
+     * @returns {ReaderResult<R, E, A>} A ReaderResult that always fails with the error
+     *
+     * @category Constructors
+     * @example
+     * const alwaysFails = ReaderResult.fail<Deps, string, User>('User not found');
+     * const result = await ReaderResult.run(deps)(alwaysFails);
+     * // => { success: false, error: 'User not found' }
+     *
+     * @since 2025-07-03
+     */
+    fail: function (error) {
+        return function () { return Promise.resolve(ResultUtils.err(error)); };
+    },
+    /**
+     * Sequential composition - the heart of ReaderResult.
+     * @description If first computation fails, short-circuit. Otherwise, feed result to next computation.
+     * This is the monadic bind operation that enables chaining ReaderResult computations.
+     *
+     * @template R - The type of dependencies
+     * @template E - The error type
+     * @template A - The input value type
+     * @template B - The output value type
+     * @param {(a: A) => ReaderResult<R, E, B>} f - Function that takes the success value and returns a new ReaderResult
+     * @returns {(ma: ReaderResult<R, E, A>) => ReaderResult<R, E, B>} A function that chains ReaderResults
+     *
+     * @category Combinators
+     * @example
+     * const getUser = (id: string): ReaderResult<Deps, string, User> => ...
+     * const getUserPosts = (userId: string): ReaderResult<Deps, string, Post[]> => ...
+     *
+     * const getUserWithPosts = ReaderResult.chain((user: User) =>
+     *   ReaderResult.map((posts: Post[]) => ({ ...user, posts }))(getUserPosts(user.id))
+     * )(getUser('123'));
+     *
+     * @since 2025-07-03
+     */
+    chain: function (f) { return function (ma) {
+        return function (deps) { return __awaiter(void 0, void 0, void 0, function () {
+            var resultA;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ma(deps)];
+                    case 1:
+                        resultA = _a.sent();
+                        if (!resultA.success) {
+                            return [2 /*return*/, resultA]; // Type assertion for proper inference
+                        }
+                        return [2 /*return*/, f(resultA.data)(deps)];
+                }
+            });
+        }); };
+    }; },
+    /**
+     * Map a pure function over the success value.
+     * @description Transforms the success value using a pure function. If the computation
+     * fails, the error is propagated unchanged.
+     *
+     * @template R - The type of dependencies
+     * @template E - The error type
+     * @template A - The input value type
+     * @template B - The output value type
+     * @param {(a: A) => B} f - Function to transform the success value
+     * @returns {(ma: ReaderResult<R, E, A>) => ReaderResult<R, E, B>} A function that maps over ReaderResult
+     *
+     * @category Transformations
+     * @example
+     * const double = ReaderResult.map((n: number) => n * 2);
+     * const program = double(ReaderResult.of<Deps, string, number>(21));
+     * const result = await ReaderResult.run(deps)(program);
+     * // => { success: true, data: 42 }
+     *
+     * @since 2025-07-03
+     */
+    map: function (f) { return function (ma) {
+        return ReaderResult.chain(function (a) { return ReaderResult.of(f(a)); })(ma);
+    }; },
+    /**
+     * Map a function over the error value.
+     * @description Transforms the error value using a pure function. If the computation
+     * succeeds, the success value is propagated unchanged.
+     *
+     * @template R - The type of dependencies
+     * @template E - The input error type
+     * @template F - The output error type
+     * @template A - The value type
+     * @param {(e: E) => F} f - Function to transform the error
+     * @returns {(ma: ReaderResult<R, E, A>) => ReaderResult<R, F, A>} A function that maps over errors
+     *
+     * @category Transformations
+     * @example
+     * const enrichError = ReaderResult.mapError((e: string) => ({
+     *   message: e,
+     *   timestamp: new Date()
+     * }));
+     *
+     * @since 2025-07-03
+     */
+    mapError: function (f) { return function (ma) {
+        return function (deps) { return __awaiter(void 0, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ma(deps)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, result.success
+                                ? result
+                                : ResultUtils.err(f(result.error))];
+                }
+            });
+        }); };
+    }; },
+    /**
+     * Access the dependencies.
+     * @description Returns a ReaderResult that succeeds with the current dependencies.
+     * Useful when you need to access the dependencies within a computation chain.
+     *
+     * @template R - The type of dependencies
+     * @template E - The error type
+     * @returns {ReaderResult<R, E, R>} A ReaderResult that returns the dependencies
+     *
+     * @category Dependencies
+     * @example
+     * const program = ReaderResult.Do()
+     *   .pipe(ReaderResult.bind('deps', () => ReaderResult.ask<Deps, string>()))
+     *   .pipe(ReaderResult.bind('config', ({ deps }) =>
+     *     ReaderResult.of(deps.config)
+     *   ));
+     *
+     * @since 2025-07-03
+     */
+    ask: function () {
+        return function (deps) { return Promise.resolve(ResultUtils.ok(deps)); };
+    },
+    /**
+     * Access a part of the dependencies.
+     * @description Returns a ReaderResult that succeeds with a projection of the dependencies.
+     * Useful for extracting specific values from the dependency container.
+     *
+     * @template R - The type of dependencies
+     * @template E - The error type
+     * @template A - The type of the extracted value
+     * @param {(deps: R) => A} f - Function to extract a value from dependencies
+     * @returns {ReaderResult<R, E, A>} A ReaderResult that returns the extracted value
+     *
+     * @category Dependencies
+     * @example
+     * const getConfig = ReaderResult.asks<Deps, string, Config>(deps => deps.config);
+     * const getLogger = ReaderResult.asks<Deps, string, Logger>(deps => deps.logger);
+     *
+     * @since 2025-07-03
+     */
+    asks: function (f) {
+        return function (deps) { return Promise.resolve(ResultUtils.ok(f(deps))); };
+    },
+    /**
+     * Lift a Result into ReaderResult
+     */
+    fromResult: function (result) {
+        return function () { return Promise.resolve(result); };
+    },
+    /**
+     * Lift an async operation that might throw into ReaderResult
+     */
+    tryCatch: function (f, onError) {
+        return function (deps) { return __awaiter(void 0, void 0, void 0, function () {
+            var result, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        _a.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, f(deps)];
+                    case 1:
+                        result = _a.sent();
+                        return [2 /*return*/, ResultUtils.ok(result)];
+                    case 2:
+                        error_1 = _a.sent();
+                        return [2 /*return*/, ResultUtils.err(onError(error_1))];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        }); };
+    },
+    /**
+     * Execute ReaderResult with dependencies
+     */
+    run: function (deps) { return function (ma) {
+        return ma(deps);
+    }; },
+    /**
+     * Combine two ReaderResults in parallel.
+     * @description Runs two ReaderResult computations in parallel and combines their results
+     * into a tuple. If either fails, returns the first failure.
+     *
+     * @template R - The type of dependencies
+     * @template E - The error type
+     * @template A - The first value type
+     * @template B - The second value type
+     * @param {ReaderResult<R, E, A>} ma - First computation
+     * @param {ReaderResult<R, E, B>} mb - Second computation
+     * @returns {ReaderResult<R, E, [A, B]>} A ReaderResult containing a tuple of both results
+     *
+     * @category Combinations
+     * @example
+     * const userAndPosts = ReaderResult.zip(
+     *   getUser('123'),
+     *   getUserPosts('123')
+     * );
+     *
+     * @since 2025-07-03
+     */
+    zip: function (ma, mb) {
+        return function (deps) { return __awaiter(void 0, void 0, void 0, function () {
+            var _a, resultA, resultB;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0: return [4 /*yield*/, Promise.all([
+                            ma(deps),
+                            mb(deps)
+                        ])];
+                    case 1:
+                        _a = _b.sent(), resultA = _a[0], resultB = _a[1];
+                        if (!resultA.success)
+                            return [2 /*return*/, resultA];
+                        if (!resultB.success)
+                            return [2 /*return*/, resultB];
+                        return [2 /*return*/, ResultUtils.ok([resultA.data, resultB.data])];
+                }
+            });
+        }); };
+    },
+    /**
+     * Sequence an array of ReaderResults.
+     * @description Transforms an array of ReaderResults into a ReaderResult of an array.
+     * Executes each computation sequentially. If any fails, returns the first failure.
+     *
+     * @template R - The type of dependencies
+     * @template E - The error type
+     * @template A - The value type
+     * @param {readonly ReaderResult<R, E, A>[]} rrs - Array of ReaderResult computations
+     * @returns {ReaderResult<R, E, readonly A[]>} A ReaderResult containing an array of all results
+     *
+     * @category Combinations
+     * @example
+     * const userIds = ['123', '456', '789'];
+     * const getUsers = ReaderResult.sequence(
+     *   userIds.map(id => getUser(id))
+     * );
+     *
+     * @since 2025-07-03
+     */
+    sequence: function (rrs) {
+        return function (deps) { return __awaiter(void 0, void 0, void 0, function () {
+            var results, _i, rrs_1, rr, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        results = [];
+                        _i = 0, rrs_1 = rrs;
+                        _a.label = 1;
+                    case 1:
+                        if (!(_i < rrs_1.length)) return [3 /*break*/, 4];
+                        rr = rrs_1[_i];
+                        return [4 /*yield*/, rr(deps)];
+                    case 2:
+                        result = _a.sent();
+                        if (!result.success) {
+                            return [2 /*return*/, result];
+                        }
+                        results.push(result.data);
+                        _a.label = 3;
+                    case 3:
+                        _i++;
+                        return [3 /*break*/, 1];
+                    case 4: return [2 /*return*/, ResultUtils.ok(results)];
+                }
+            });
+        }); };
+    },
+    /**
+     * Do notation for building up computations.
+     * @description Starts a Do notation chain for building complex computations
+     * in a more imperative style. Use with bind and let methods.
+     *
+     * @template R - The type of dependencies
+     * @template E - The error type
+     * @returns {ReaderResult<R, E, Record<string, never>>} An empty ReaderResult to start the chain
+     *
+     * @category Do Notation
+     * @example
+     * const program = ReaderResult.Do<Deps, string>()
+     *   .pipe(ReaderResult.bind('user', () => getUser('123')))
+     *   .pipe(ReaderResult.bind('posts', ({ user }) => getUserPosts(user.id)))
+     *   .pipe(ReaderResult.let('postCount', ({ posts }) => posts.length))
+     *   .pipe(ReaderResult.map(({ user, posts, postCount }) => ({
+     *     ...user,
+     *     posts,
+     *     stats: { postCount }
+     *   })));
+     *
+     * @since 2025-07-03
+     */
+    Do: function () {
+        return ReaderResult.of({});
+    },
+    /**
+     * Bind a computation result to a name (for Do notation)
+     */
+    bind: function (name, f) { return function (fa) {
+        return ReaderResult.chain(function (a) {
+            return ReaderResult.map(function (b) {
+                var _a;
+                return (__assign(__assign({}, a), (_a = {}, _a[name] = b, _a)));
+            })(f(a));
+        })(fa);
+    }; },
+    /**
+     * Bind a value to a name (for Do notation)
+     */
+    let: function (name, f) { return function (fa) {
+        return ReaderResult.map(function (a) {
+            var _a;
+            return (__assign(__assign({}, a), (_a = {}, _a[name] = f(a), _a)));
+        })(fa);
+    }; },
+    /**
+     * Provides a fallback ReaderResult if the original fails.
+     * @description The fallback function receives the error and returns a new ReaderResult.
+     * Useful for error recovery or providing default values.
+     *
+     * @template R - The type of dependencies
+     * @template E - The input error type
+     * @template F - The output error type
+     * @template A - The value type
+     * @param {(error: E) => ReaderResult<R, F, A>} onError - Function to handle the error
+     * @returns {(ma: ReaderResult<R, E, A>) => ReaderResult<R, F, A>} A function that adds fallback behavior
+     *
+     * @category Error Handling
+     * @example
+     * const getUserWithFallback = ReaderResult.orElse(
+     *   (error: string) => getDefaultUser()
+     * )(getUser('123'));
+     *
+     * @since 2025-07-03
+     */
+    orElse: function (onError) { return function (ma) {
+        return function (deps) { return __awaiter(void 0, void 0, void 0, function () {
+            var result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ma(deps)];
+                    case 1:
+                        result = _a.sent();
+                        if (result.success) {
+                            return [2 /*return*/, result];
+                        }
+                        return [2 /*return*/, onError(result.error)(deps)];
+                }
+            });
+        }); };
+    }; },
+    /**
+     * Timeout for ReaderResult computations.
+     * If the computation doesn't complete within the specified time, it fails with the timeout error.
+     */
+    timeout: function (ms, timeoutError) { return function (ma) {
+        return function (deps) { return __awaiter(void 0, void 0, void 0, function () {
+            var timeoutPromise;
+            return __generator(this, function (_a) {
+                timeoutPromise = new Promise(function (resolve) {
+                    setTimeout(function () { return resolve(ResultUtils.err(timeoutError)); }, ms);
+                });
+                return [2 /*return*/, Promise.race([ma(deps), timeoutPromise])];
+            });
+        }); };
+    }; },
+    /**
+     * Retry a ReaderResult computation with exponential backoff.
+     * Only retries on failures, not on successful results.
+     */
+    retry: function (maxAttempts, baseDelay, shouldRetry) {
+        if (baseDelay === void 0) { baseDelay = 1000; }
+        if (shouldRetry === void 0) { shouldRetry = function () { return true; }; }
+        return function (ma) {
+            return function (deps) { return __awaiter(void 0, void 0, void 0, function () {
+                var _loop_1, attempt, state_1;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            // If maxAttempts is not at least 1, just run the operation once.
+                            if (maxAttempts < 1) {
+                                return [2 /*return*/, ma(deps)];
+                            }
+                            _loop_1 = function (attempt) {
+                                var result, delay;
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0: return [4 /*yield*/, ma(deps)];
+                                        case 1:
+                                            result = _b.sent();
+                                            if (result.success) {
+                                                return [2 /*return*/, { value: result }];
+                                            }
+                                            // If it's the last attempt or shouldRetry returns false, return the error.
+                                            if (attempt === maxAttempts || !shouldRetry(result.error, attempt)) {
+                                                return [2 /*return*/, { value: result }];
+                                            }
+                                            delay = baseDelay * Math.pow(2, attempt - 1);
+                                            return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, delay); })];
+                                        case 2:
+                                            _b.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            };
+                            attempt = 1;
+                            _a.label = 1;
+                        case 1:
+                            if (!(attempt <= maxAttempts)) return [3 /*break*/, 4];
+                            return [5 /*yield**/, _loop_1(attempt)];
+                        case 2:
+                            state_1 = _a.sent();
+                            if (typeof state_1 === "object")
+                                return [2 /*return*/, state_1.value];
+                            _a.label = 3;
+                        case 3:
+                            attempt++;
+                            return [3 /*break*/, 1];
+                        case 4: 
+                        // This part is now unreachable due to the logic above, but satisfies TS.
+                        // A more robust way to signal this is to throw, as it should never happen.
+                        throw new Error('Retry logic reached an impossible state.');
+                    }
+                });
+            }); };
+        };
+    },
+    /**
+     * Execute multiple ReaderResults in parallel and collect all results.
+     * @description Similar to sequence but runs in parallel rather than sequentially.
+     * More efficient for independent computations but still fails fast on first error.
+     *
+     * @template R - The type of dependencies
+     * @template E - The error type
+     * @template A - The value type
+     * @param {readonly ReaderResult<R, E, A>[]} rrs - Array of ReaderResult computations
+     * @returns {ReaderResult<R, E, readonly A[]>} A ReaderResult containing an array of all results
+     *
+     * @category Combinations
+     * @example
+     * // Fetch multiple users in parallel
+     * const userIds = ['123', '456', '789'];
+     * const getUsers = ReaderResult.sequencePar(
+     *   userIds.map(id => getUser(id))
+     * );
+     *
+     * @since 2025-07-03
+     */
+    sequencePar: function (rrs) {
+        return function (deps) { return __awaiter(void 0, void 0, void 0, function () {
+            var results, data, _i, results_1, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(rrs.map(function (rr) { return rr(deps); }))];
+                    case 1:
+                        results = _a.sent();
+                        data = [];
+                        for (_i = 0, results_1 = results; _i < results_1.length; _i++) {
+                            result = results_1[_i];
+                            if (!result.success) {
+                                return [2 /*return*/, result];
+                            }
+                            data.push(result.data);
+                        }
+                        return [2 /*return*/, ResultUtils.ok(data)];
+                }
+            });
+        }); };
+    },
+    /**
+     * Combine multiple ReaderResults in parallel into a tuple.
+     * Extends zip to work with any number of ReaderResults.
+     */
+    zipAll: function () {
+        var rrs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            rrs[_i] = arguments[_i];
+        }
+        return function (deps) { return __awaiter(void 0, void 0, void 0, function () {
+            var results, data, _i, results_2, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, Promise.all(rrs.map(function (rr) { return rr(deps); }))];
+                    case 1:
+                        results = _a.sent();
+                        data = [];
+                        for (_i = 0, results_2 = results; _i < results_2.length; _i++) {
+                            result = results_2[_i];
+                            if (!result.success) {
+                                return [2 /*return*/, result];
+                            }
+                            data.push(result.data);
+                        }
+                        return [2 /*return*/, ResultUtils.ok(data)];
+                }
+            });
+        }); };
+    },
+    /**
+     * Run multiple ReaderResults in parallel and collect all results or all errors.
+     * @description Unlike sequencePar, this doesn't short-circuit on the first error.
+     * Collects all errors if any computations fail, making it useful for validation scenarios.
+     *
+     * @template R - The type of dependencies
+     * @template E - The error type
+     * @template T - The record type mapping keys to ReaderResults
+     *
+     * @category Combinations
+     * @example
+     * const validation = ReaderResult.parallel({
+     *   name: validateName(input.name),
+     *   email: validateEmail(input.email),
+     *   age: validateAge(input.age)
+     * });
+     * // If any fail, returns all failures
+     *
+     * @since 2025-07-03
+     */
+    parallel: function (rrs) {
+        return function (deps) { return __awaiter(void 0, void 0, void 0, function () {
+            var entries, results, errors, data, _i, results_3, _a, key, result;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        entries = Object.entries(rrs);
+                        return [4 /*yield*/, Promise.all(entries.map(function (_a) { return __awaiter(void 0, [_a], void 0, function (_b) {
+                                var _c;
+                                var key = _b[0], rr = _b[1];
+                                return __generator(this, function (_d) {
+                                    switch (_d.label) {
+                                        case 0:
+                                            _c = [key];
+                                            return [4 /*yield*/, rr(deps)];
+                                        case 1: return [2 /*return*/, _c.concat([_d.sent()])];
+                                    }
+                                });
+                            }); }))];
+                    case 1:
+                        results = _b.sent();
+                        errors = [];
+                        data = {};
+                        for (_i = 0, results_3 = results; _i < results_3.length; _i++) {
+                            _a = results_3[_i], key = _a[0], result = _a[1];
+                            if (result.success) {
+                                data[key] = result.data;
+                            }
+                            else {
+                                errors.push({ key: key, error: result.error });
+                            }
+                        }
+                        return [2 /*return*/, errors.length > 0
+                                ? ResultUtils.err(errors)
+                                : ResultUtils.ok(data)];
+                }
+            });
+        }); };
+    },
+};
+/**
+ * Helper to create ReaderResult from a domain function that returns Result.
+ * @description Lifts a pure function that returns a Result into the ReaderResult context.
+ * Useful for integrating existing Result-based functions.
+ *
+ * @template R - The type of dependencies
+ * @template E - The error type
+ * @template A - The value type
+ * @template Args - The argument types
+ * @param {(...args: Args) => Result<A, E>} f - Function that returns a Result
+ * @returns {(...args: Args) => ReaderResult<R, E, A>} A function that returns a ReaderResult
+ *
+ * @category Helpers
+ * @example
+ * const validateAge = (age: number): Result<number, string> =>
+ *   age >= 18 ? Result.ok(age) : Result.err('Must be 18 or older');
+ *
+ * const validateAgeRR = liftDomain<Deps, string, number, [number]>(validateAge);
+ *
+ * @since 2025-07-03
+ */
+export var liftDomain = function (f) { return function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return ReaderResult.fromResult(f.apply(void 0, args));
+}; };
+/**
+ * Helper to create ReaderResult from an async function that might throw.
+ * @description Lifts an async function that might throw into the ReaderResult context,
+ * converting exceptions to typed errors.
+ *
+ * @template R - The type of dependencies
+ * @template E - The error type
+ * @template A - The value type
+ * @template Args - The argument types
+ * @param {(deps: R, ...args: Args) => Promise<A>} f - Async function that might throw
+ * @param {(error: unknown) => E} onError - Function to convert exceptions to errors
+ * @returns {(...args: Args) => ReaderResult<R, E, A>} A function that returns a ReaderResult
+ *
+ * @category Helpers
+ * @example
+ * const fetchUser = liftAsync<Deps, string, User, [string]>(
+ *   async (deps, id) => deps.api.getUser(id),
+ *   (error) => `Failed to fetch user: ${error}`
+ * );
+ *
+ * @since 2025-07-03
+ */
+export var liftAsync = function (f, onError) { return function () {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return ReaderResult.tryCatch(function (deps) { return f.apply(void 0, __spreadArray([deps], args, false)); }, onError);
+}; };
+//# sourceMappingURL=reader-result.mjs.map