modern-ts 0.8.0

package/dist/types/Resource/resource-async.d.ts

@@ -0,0 +1,79 @@
+import { StateOpened, StateClosed, AnyCleaner, NoneType } from './types';
+declare const _data: unique symbol;
+declare const _cleanup: unique symbol;
+/**
+ * Asynchronous resource management class.
+ * @typeParam T - The type of the resource data
+ * @typeParam S - The state type (opened or closed)
+ */
+export declare class ResourceAsync<T, S extends StateOpened | StateClosed> {
+    private state;
+    [_data]: T | NoneType;
+    [_cleanup]: AnyCleaner<T> | undefined;
+    private constructor();
+    /**
+     * Creates a new opened asynchronous resource.
+     * @typeParam D - The type of the resource data
+     * @param data - The resource data
+     * @param cleaner - Optional asynchronous cleanup function
+     * @returns A new opened asynchronous resource
+     */
+    static open<D>(data: D, cleaner?: AnyCleaner<D>): ResourceAsync<D, StateOpened>;
+    /**
+     * Asynchronously disposes the resource (cleanup).
+     * @returns Promise that resolves when disposal is complete
+     */
+    [Symbol.asyncDispose](this: ResourceAsync<T, StateOpened>): Promise<void>;
+}
+/**
+ * Union type for asynchronous resource states.
+ * @typeParam T - The type of the resource data
+ */
+export type ResAsyncType<T> = ResourceAsync<T, StateOpened> | ResourceAsync<T, StateClosed>;
+/**
+ * Uses an asynchronous resource with a callback function.
+ * @typeParam T - The type of the resource data
+ * @typeParam R - The return type of the callback
+ * @param resource - The opened asynchronous resource
+ * @param callback - Function to process the resource data
+ * @returns Promise with the result of the callback
+ * @throws Error if resource is already disposed
+ */
+export declare function useAsync<T, R>(resource: ResourceAsync<T, StateOpened>, callback: (data: T) => Promise<R> | R): Promise<R>;
+/**
+ * Performs a side effect on an asynchronous resource and returns the resource.
+ * @typeParam T - The type of the resource data
+ * @typeParam R - The return type of the side effect function
+ * @param resource - The opened asynchronous resource
+ * @param fn - Side effect function to execute
+ * @returns The same resource after executing the side effect
+ * @throws Error if resource is already disposed
+ */
+export declare function execAsync<T, R>(resource: ResourceAsync<T, StateOpened>, fn: (data: T) => Promise<R> | R): Promise<ResourceAsync<T, StateOpened>>;
+/**
+ * Closes an asynchronous resource (disposes it).
+ * @typeParam T - The type of the resource data
+ * @param resource - The opened asynchronous resource to close
+ * @returns The closed asynchronous resource
+ */
+export declare function closeAsync<T>(resource: ResourceAsync<T, StateOpened>): Promise<ResourceAsync<T, StateClosed>>;
+/**
+ * Executes an asynchronous or synchronous function on the resource and then closes it,
+ * guaranteeing asynchronous cleanup even if the function throws.
+ * @typeParam T - The type of the resource data
+ * @typeParam R - The return type of the function
+ * @param resource - The opened asynchronous resource
+ * @param fn - Asynchronous or synchronous function to execute before closing
+ * @returns A promise that resolves to the closed asynchronous resource
+ */
+export declare function disposeAsync<T, R>(resource: ResourceAsync<T, StateOpened>, fn: (data: T) => Promise<R> | R): Promise<ResourceAsync<T, StateClosed>>;
+/**
+ * Reopens a closed asynchronous resource with new data.
+ * @typeParam T - The type of the resource data
+ * @param resource - The closed asynchronous resource
+ * @param data - New data for the resource
+ * @param cleaner - Optional new cleanup function
+ * @returns The reopened asynchronous resource
+ */
+export declare function reopenAsync<T>(resource: ResourceAsync<T, StateClosed>, data: T, cleaner?: AnyCleaner<T>): ResourceAsync<T, StateOpened>;
+export {};

package/dist/types/Resource/resource.d.ts

@@ -0,0 +1,78 @@
+import { StateOpened, StateClosed, NoneType, Cleaner } from './types';
+declare const _data: unique symbol;
+declare const _cleanup: unique symbol;
+/**
+ * Synchronous resource management class.
+ * @typeParam T - The type of the resource data
+ * @typeParam S - The state type (opened or closed)
+ */
+export declare class Resource<T, S extends StateOpened | StateClosed> {
+    private state;
+    [_data]: T | NoneType;
+    [_cleanup]: Cleaner<T> | undefined;
+    private constructor();
+    /**
+     * Creates a new opened synchronous resource.
+     * @typeParam D - The type of the resource data
+     * @param data - The resource data
+     * @param cleaner - Optional synchronous cleanup function
+     * @returns A new opened synchronous resource
+     */
+    static open<D>(data: D, cleaner?: Cleaner<D>): Resource<D, StateOpened>;
+    /**
+     * Synchronously disposes the resource (cleanup).
+     */
+    [Symbol.dispose](this: Resource<T, StateOpened>): void;
+}
+/**
+ * Union type for synchronous resource states.
+ * @typeParam T - The type of the resource data
+ */
+export type ResType<T> = Resource<T, StateOpened> | Resource<T, StateClosed>;
+/**
+ * Uses a synchronous resource with a callback function.
+ * @typeParam T - The type of the resource data
+ * @typeParam R - The return type of the callback
+ * @param resource - The opened synchronous resource
+ * @param fn - Function to process the resource data
+ * @returns The result of the callback
+ * @throws Error if resource is already disposed
+ */
+export declare function use<T, R>(resource: Resource<T, StateOpened>, fn: (data: T) => R): R;
+/**
+ * Performs a side effect on a synchronous resource and returns the resource.
+ * @typeParam T - The type of the resource data
+ * @typeParam R - The return type of the side effect function
+ * @param resource - The opened synchronous resource
+ * @param fn - Side effect function to execute
+ * @returns The same resource after executing the side effect
+ * @throws Error if resource is already disposed
+ */
+export declare function exec<T, R>(resource: Resource<T, StateOpened>, fn: (data: T) => R): Resource<T, StateOpened>;
+/**
+ * Closes a synchronous resource (disposes it).
+ * @typeParam T - The type of the resource data
+ * @param resource - The opened synchronous resource to close
+ * @returns The closed synchronous resource
+ */
+export declare function close<T>(resource: Resource<T, StateOpened>): Resource<T, StateClosed>;
+/**
+ * Executes a function on the resource and then closes it,
+ * guaranteeing cleanup even if the function throws.
+ * @typeParam T - The type of the resource data
+ * @typeParam R - The return type of the function
+ * @param resource - The opened synchronous resource
+ * @param fn - Function to execute before closing
+ * @returns The closed synchronous resource
+ */
+export declare function dispose<T, R>(resource: Resource<T, StateOpened>, fn: (data: T) => R): Resource<T, StateClosed>;
+/**
+ * Reopens a closed synchronous resource with new data.
+ * @typeParam T - The type of the resource data
+ * @param resource - The closed synchronous resource
+ * @param data - New data for the resource
+ * @param cleaner - Optional new cleanup function
+ * @returns The reopened synchronous resource
+ */
+export declare function reopen<T>(resource: Resource<T, StateClosed>, data: T, cleaner?: Cleaner<T>): Resource<T, StateOpened>;
+export {};

package/dist/types/Resource/types.d.ts

@@ -0,0 +1,79 @@
+import { MaybePromise } from '../Utils/type-tool';
+/**
+ * Marker interface for opened state.
+ * @public
+ */
+export interface StateOpened {
+}
+/**
+ * Marker interface for closed state.
+ */
+export interface StateClosed {
+}
+/**
+ * Marker interface for committed state.
+ */
+export interface StateCommit {
+}
+/**
+ * Marker interface for rolled back state.
+ */
+export interface StateRollback {
+}
+/**
+ * Synchronous cleanup function type.
+ * @typeParam T - The type of the data to clean up
+ */
+export type Cleaner<T> = (data: T) => void;
+/**
+ * Asynchronous cleanup function type.
+ * @typeParam T - The type of the data to clean up
+ */
+export type AsyncCleaner<T> = (data: T) => PromiseLike<void> | void;
+/**
+ * Union type for any cleanup function (synchronous or asynchronous).
+ * @typeParam T - The type of the data to clean up
+ */
+export type AnyCleaner<T> = Cleaner<T> | AsyncCleaner<T>;
+/**
+ * Synchronous commit function type.
+ * @typeParam T - The type of the transaction data
+ */
+export type CommitUp<T> = (data: T) => void;
+/**
+ * Synchronous rollback function type.
+ * @typeParam T - The type of the transaction data
+ */
+export type RollbackUp<T> = (data: T) => void;
+/**
+ * Asynchronous commit function type.
+ * @typeParam T - The type of the transaction data
+ */
+export type AsyncCommitUp<T> = (data: T) => MaybePromise<void>;
+/**
+ * Asynchronous rollback function type.
+ * @typeParam T - The type of the transaction data
+ */
+export type AsyncRollbackUp<T> = (data: T) => MaybePromise<void>;
+/**
+ * Union type for any commit function (synchronous or asynchronous).
+ * @typeParam T - The type of the transaction data
+ */
+export type AnyCommitUp<T> = CommitUp<T> | AsyncCommitUp<T>;
+/**
+ * Union type for any rollback function (synchronous or asynchronous).
+ * @typeParam T - The type of the transaction data
+ */
+export type AnyRollbackUp<T> = RollbackUp<T> | AsyncRollbackUp<T>;
+/**
+ * A unique symbolic constant representing the absence of resources.
+ * * @remarks
+ * This is used as a placeholder within a `Resource` context to indicate
+ * that the resource pool is exhausted or no resource is available.
+ */
+export declare const NONE: unique symbol;
+/**
+ * Represents the type of the {@link NONE} constant.
+ * Use this type for type guards or function signatures that might return the `NONE` placeholder.
+ */
+export type NoneType = typeof NONE;

package/dist/types/Resource.d.ts

@@ -0,0 +1,2 @@
+export * from './Resource/__export-resource__'
+export {}

package/dist/types/Result/Consumers/branch-async.d.ts

@@ -0,0 +1,77 @@
+import { AnyResult } from '../types';
+import { UnknownError } from '../../unknown-error';
+import { MaybePromise } from '../../Utils/type-tool';
+/**
+ * Asynchronously executes different callback functions based on the Result state and returns Promise<R>.
+ * Catches exceptions thrown by the callbacks.
+ * @typeParam T - The type of the success value
+ * @typeParam E - The type of the error
+ * @typeParam R - The type of the return value
+ * @param result_promise - The Result or Promise<Result> to match
+ * @param onOk - The callback function for a successful state (Ok)
+ * @param onErr - The callback function for a failure state (Err)
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns The Promise resolving to the return value of onOk or onErr, or an UnknownError if a callback throws
+ */
+export declare function matchResultAsync<T, E, R>(result_promise: AnyResult<T, E>, onOk: (value: T, signal?: AbortSignal) => MaybePromise<R>, onErr: (error: E, signal?: AbortSignal) => MaybePromise<R>, signal?: AbortSignal): Promise<R | UnknownError>;
+/**
+ * Asynchronously executes onOk if the Result is **Ok**; executes the optional onElse if **Err**.
+ * All exceptions thrown by the callbacks are caught and wrapped as UnknownError.
+ * @typeParam T - The type of the **Success Value** in the **Ok state**.
+ * @typeParam E - The type of the **Error** in the **Err state**.
+ * @typeParam R1 - The final resolved return type of the **onOk** callback.
+ * @param result_promise - The Result object or Promise<Result> to be checked.
+ * @param onOk - The callback executed if the Result is Ok. Returns R1 or Promise<R1>.
+ * @returns A Promise that resolves to the result of onOk (R1), or UnknownError if a callback throws, or **void** if the Result is Err.
+ */
+export declare function ifOkAsync<T, E, R1>(result_promise: AnyResult<T, E>, onOk: (value: T) => MaybePromise<R1>): Promise<R1 | UnknownError | void>;
+/**
+ * Asynchronously executes onOk if the Result is **Ok**; executes onElse if **Err**.
+ * All exceptions thrown by the callbacks are caught and wrapped as UnknownError.
+ * @typeParam T - The type of the **Success Value** in the **Ok state**.
+ * @typeParam E - The type of the **Error** in the **Err state**.
+ * @typeParam R1 - The final resolved return type of the **onOk** callback.
+ * @typeParam R2 - The final resolved return type of the **onElse** callback.
+ * @param result_promise - The Result object or Promise<Result> to be checked.
+ * @param onOk - The callback executed if the Result is Ok. Returns R1 or Promise<R1>.
+ * @param onElse - The callback executed if the Result is Err. Returns R2 or Promise<R2>.
+ * @returns A Promise that resolves to the result of onOk or onElse (R1 or R2), or UnknownError if a callback throws.
+ */
+export declare function ifOkAsync<T, E, R1, R2>(result_promise: AnyResult<T, E>, onOk: (value: T) => MaybePromise<R1>, onElse: (error: E) => MaybePromise<R2>): Promise<R1 | R2 | UnknownError>;
+/**
+ * Asynchronously executes onErr if the Result is **Err**; executes the optional onElse if **Ok**.
+ * All exceptions thrown by the callbacks are caught and wrapped as UnknownError.
+ * @typeParam T - The type of the **Success Value** in the **Ok state**.
+ * @typeParam E - The type of the **Error** in the **Err state**.
+ * @typeParam R1 - The final resolved return type of the **onErr** callback.
+ * @param result_promise - The Result object or Promise<Result> to be checked.
+ * @param onErr - The callback executed if the Result is Err. Returns R1 or Promise<R1>.
+ * @returns A Promise that resolves to the result of onErr (R1), or UnknownError if a callback throws, or **void** if the Result is Ok.
+ */
+export declare function ifErrAsync<T, E, R1>(result_promise: AnyResult<T, E>, onErr: (error: E) => MaybePromise<R1>): Promise<R1 | UnknownError | void>;
+/**
+ * Asynchronously executes onErr if the Result is **Err**; executes onElse if **Ok**.
+ * All exceptions thrown by the callbacks are caught and wrapped as UnknownError.
+ * @typeParam T - The type of the **Success Value** in the **Ok state**.
+ * @typeParam E - The type of the **Error** in the **Err state**.
+ * @typeParam R1 - The final resolved return type of the **onErr** callback.
+ * @typeParam R2 - The final resolved return type of the **onElse** callback.
+ * @param result_promise - The Result object or Promise<Result> to be checked.
+ * @param onErr - The callback executed if the Result is Err. Returns R1 or Promise<R1>.
+ * @param onElse - The callback executed if the Result is Ok. Returns R2 or Promise<R2>.
+ * @returns A Promise that resolves to the result of onErr or onElse (R1 or R2), or UnknownError if a callback throws.
+ */
+export declare function ifErrAsync<T, E, R1, R2>(result_promise: AnyResult<T, E>, onErr: (error: E) => MaybePromise<R1>, onElse: (value: T) => MaybePromise<R2>): Promise<R1 | R2 | UnknownError>;
+/**
+ * Asynchronously transforms the Result into a single type R.
+ * Uses mapFn on Success; uses defaultFn on Failure.
+ * Catches exceptions thrown by the callbacks.
+ * @typeParam T - The type of the success value
+ * @typeParam E - The type of the error
+ * @typeParam R - The type of the final return value
+ * @param result_promise - The Result or Promise<Result> to process
+ * @param defaultFn - The function to compute the default value on failure
+ * @param mapFn - The function to map the success value
+ * @returns The Promise resolving to the final return value, or an UnknownError if a callback throws
+ */
+export declare function mapOrElseAsync<T, E, R>(result_promise: AnyResult<T, E>, defaultFn: (error: E) => MaybePromise<R>, mapFn: (value: T) => MaybePromise<R>): Promise<R | UnknownError>;

package/dist/types/Result/Consumers/branch.d.ts

@@ -0,0 +1,70 @@
+import { Result } from '../types';
+/**
+ * Executes one of two callbacks based on whether the Result is Ok or Err,
+ * and returns the result of the executed callback.
+ * @typeParam T - The type of the success value in the Ok variant.
+ * @typeParam E - The type of the error in the Err variant.
+ * @typeParam R1 - The return type of the onOk callback.
+ * @typeParam R2 - The return type of the onErr callback.
+ * @param result - The Result object to match against.
+ * @param onOk - Callback executed if the Result is Ok. Receives the inner value (T).
+ * @param onErr - Callback executed if the Result is Err. Receives the inner error (E).
+ * @returns The result of either onOk or onErr, with type R1 | R2.
+ */
+export declare const match: <T, E, R1, R2>(result: Result<T, E>, onOk: (value: T) => R1, onErr: (error: E) => R2) => R1 | R2;
+/**
+ * Executes onOk if the Result is **Ok** (Success).
+ * @typeParam T - The type of the **Success Value** contained in the **Ok state**.
+ * @typeParam E - The type of the **Error** contained in the **Err state**.
+ * @typeParam R1 - The return type of the **onOk** callback.
+ * @param result - The Result object to check.
+ * @param onOk - The function executed when the Result is **Ok**, receiving the internal value (T).
+ * @returns The return value of onOk (R1) or **void** if the Result is Err.
+ */
+export declare function ifOk<T, E, R1>(result: Result<T, E>, onOk: (value: T) => R1): R1 | void;
+/**
+ * Executes onOk if the Result is **Ok**; executes onElse if **Err**.
+ * @typeParam T - The type of the **Success Value** contained in the **Ok state**.
+ * @typeParam E - The type of the **Error** contained in the **Err state**.
+ * @typeParam R1 - The return type of the **onOk** callback.
+ * @typeParam R2 - The return type of the **onElse** callback.
+ * @param result - The Result object to check.
+ * @param onOk - The function executed when the Result is **Ok**, receiving the internal value (T).
+ * @param onElse - The function executed when the Result is **Err**, receiving the internal error (E).
+ * @returns The return value of onOk (R1) or onElse (R2).
+ */
+export declare function ifOk<T, E, R1, R2>(result: Result<T, E>, onOk: (value: T) => R1, onElse: (error: E) => R2): R1 | R2;
+/**
+ * Executes onErr if the Result is **Err** (Failure).
+ * @typeParam T - The type of the **Success Value** contained in the **Ok state**.
+ * @typeParam E - The type of the **Error** contained in the **Err state**.
+ * @typeParam R1 - The return type of the **onErr** callback.
+ * @param result - The Result object to check.
+ * @param onErr - The function executed when the Result is **Err**, receiving the internal error (E).
+ * @returns The return value of onErr (R1) or **void** if the Result is Ok.
+ */
+export declare function ifErr<T, E, R1>(result: Result<T, E>, onErr: (error: E) => R1): R1 | void;
+/**
+ * Executes onErr if the Result is **Err**; executes onElse if **Ok**.
+ * @typeParam T - The type of the **Success Value** contained in the **Ok state**.
+ * @typeParam E - The type of the **Error** contained in the **Err state**.
+ * @typeParam R1 - The return type of the **onErr** callback.
+ * @typeParam R2 - The return type of the **onElse** callback.
+ * @param result - The Result object to check.
+ * @param onErr - The function executed when the Result is **Err**, receiving the internal error (E).
+ * @param onElse - The function executed when the Result is **Ok**, receiving the internal value (T).
+ * @returns The return value of onErr (R1) or onElse (R2).
+ */
+export declare function ifErr<T, E, R1, R2>(result: Result<T, E>, onErr: (error: E) => R1, onElse: (value: T) => R2): R1 | R2;
+/**
+ * Transforms the Result into a single type R. Uses mapFn to transform the value on Success;
+ * uses defaultFn to transform the error into a default value on Failure.
+ * @typeParam T - The type of the success value
+ * @typeParam E - The type of the error
+ * @typeParam R - The type of the final return value
+ * @param result - The Result to process
+ * @param defaultFn - The function to compute the default value on failure
+ * @param mapFn - The function to map the success value
+ * @returns The final return value R
+ */
+export declare const mapOrElse: <T, E, R1, R2>(result: Result<T, E>, defaultFn: (error: E) => R1, mapFn: (value: T) => R2) => R1 | R2;

package/dist/types/Result/Consumers/inspect.d.ts

@@ -0,0 +1,66 @@
+import { AnyResult, Result } from '../types';
+import { UnknownError } from '../../unknown-error';
+import { MaybePromise } from '../../Utils/type-tool';
+/**
+ * Returns the Result as is, regardless of its state. Used for side effects (e.g., logging) on both Success/Failure paths.
+ * @typeParam T - The type of the success value
+ * @typeParam E - The type of the error
+ * @param result - The Result to peek
+ * @param options - Options object containing optional side-effect functions
+ * @returns The unchanged Result
+ */
+export declare function peekBoth<T, E>(result: Result<T, E>, { fnOk, fnErr, }: {
+    fnOk?: (value: T) => void;
+    fnErr?: (error: E) => void;
+}): Result<T, E>;
+/**
+ * Executes the fnErr function as a side effect if the Result is Failure; then returns the Result as is.
+ * @typeParam T - The type of the success value
+ * @typeParam E - The type of the error
+ * @param result - The Result to peek
+ * @param fnErr - The side-effect function to execute on Failure
+ * @returns The unchanged Result
+ */
+export declare function peekErr<T, E>(result: Result<T, E>, fnErr: (error: E) => void): Result<T, E>;
+/**
+ * Executes the fnOk function as a side effect if the Result is Success; then returns the Result as is.
+ * @typeParam T - The type of the success value
+ * @typeParam E - The type of the error
+ * @param result - The Result to peek
+ * @param fnOk - The side-effect function to execute on Success
+ * @returns The unchanged Result
+ */
+export declare function peekOk<T, E>(result: Result<T, E>, fnOk: (value: T) => void): Result<T, E>;
+/**
+ * Asynchronously executes side effects for both Success/Failure paths, and returns the AsyncResult unchanged.
+ * @typeParam T - The type of the success value
+ * @typeParam E - The type of the error
+ * @param result_promise - The Result or Promise<Result> to peek
+ * @param options - Options object containing optional side-effect functions
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns A Promise containing the original Result, or an UnknownError if a side effect throws
+ */
+export declare function peekBothAsync<T, E>(result_promise: AnyResult<T, E>, { fnOk, fnErr, }: {
+    fnOk?: (value: T, signal?: AbortSignal) => MaybePromise<void>;
+    fnErr?: (error: E, signal?: AbortSignal) => MaybePromise<void>;
+}, signal?: AbortSignal): Promise<Result<T, E | DOMException | UnknownError>>;
+/**
+ * Asynchronously executes fnErr as a side effect if the Result is Failure; then returns the Result unchanged.
+ * @typeParam T - The type of the success value
+ * @typeParam E - The type of the error
+ * @param result_promise - The Result or Promise<Result> to peek
+ * @param fnErr - The side-effect function to execute on Failure
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns A Promise containing the original Result, or an UnknownError if fnErr throws
+ */
+export declare function peekErrAsync<T, E>(result_promise: AnyResult<T, E>, fnErr: (error: E, signal?: AbortSignal) => MaybePromise<void>, signal?: AbortSignal): Promise<Result<T, E | DOMException | UnknownError>>;
+/**
+ * Asynchronously executes fnOk as a side effect if the Result is Success; then returns the Result unchanged.
+ * @typeParam T - The type of the success value
+ * @typeParam E - The type of the error
+ * @param result_promise - The Result or Promise<Result> to peek
+ * @param fnOk - The side-effect function to execute on Success
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns A Promise containing the original Result, or an UnknownError if fnOk throws
+ */
+export declare function peekOkAsync<T, E>(result_promise: AnyResult<T, E>, fnOk: (value: T, signal?: AbortSignal) => MaybePromise<void>, signal?: AbortSignal): Promise<Result<T, E | DOMException | UnknownError>>;

package/dist/types/Result/Operators/Async/combine-async.d.ts

@@ -0,0 +1,69 @@
+import { AnyResult, AsyncResult } from '../../types';
+import { UnknownError } from '../../../unknown-error';
+/**
+ * Asynchronous Applicative Apply.
+ * Applies the function inside result_fab to the value inside result_a, executing concurrently.
+ * Short-circuits on the first error encountered in either input.
+ *
+ * @typeParam T - The type of the input value A
+ * @typeParam E - The type of the error
+ * @typeParam U - The type of the output value B
+ * @typeParam F - The error type of the function Result
+ * @param result_fab - The AnyResult containing the mapping function (A) => B
+ * @param result_a - The AnyResult containing the value A
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns An AsyncResult containing the output value B or the first error
+ */
+export declare function apAsync<T, E, U, F>(result_fab: AnyResult<(value: T, signal?: AbortSignal) => U, F>, result_a: AnyResult<T, E>, signal?: AbortSignal): AsyncResult<U, E | F | UnknownError | DOMException>;
+/**
+ * Asynchronously combines two Results into a tuple (executed concurrently).
+ * @typeParam T - The success value type of the first Result
+ * @typeParam E - The error type of the first Result
+ * @typeParam U - The success value type of the second Result
+ * @typeParam F - The error type of the second Result
+ * @param result_a - The first AnyResult
+ * @param result_b - The second AnyResult
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns An AsyncResult containing the tuple or the first error
+ */
+export declare function zipAsync<T, E, U, F>(result_a: AnyResult<T, E>, result_b: AnyResult<U, F>, signal?: AbortSignal): AsyncResult<[T, U], E | F | UnknownError | DOMException>;
+/**
+ * Executes multiple AsyncResults concurrently. Returns an array if all succeed, or short-circuits by returning the first error.
+ * @typeParam T - The type of the success value
+ * @typeParam E - The type of the error
+ * @param results - The array of AnyResults
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns An AsyncResult containing the array of values or the first error
+ */
+export declare function allAsync<T, E>(results: readonly AnyResult<T, E>[], signal?: AbortSignal): AsyncResult<T[], E | UnknownError | DOMException>;
+/**
+ * Executes multiple AsyncResults sequentially. Returns an array if all succeed, or short-circuits by returning the first error.
+ * @typeParam T - The type of the success value
+ * @typeParam E - The type of the error
+ * @param results - The array of AnyResults
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns An AsyncResult containing the array of values or the first error
+ */
+export declare function sequenceAsync<T, E>(results: readonly AnyResult<T, E>[], signal?: AbortSignal): AsyncResult<T[], E | UnknownError | DOMException>;
+/**
+ * Asynchronous logical AND operation. If result is Ok, awaits and returns other; if result is Err, returns result's error.
+ * @typeParam T - The success value type of the first Result
+ * @typeParam E - The type of the error
+ * @typeParam U - The success value type of the second Result
+ * @param result_promise - The first AnyResult
+ * @param other_promise - The second AnyResult
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns The result of the logical AND
+ */
+export declare function andAsync<T, E, U>(result_promise: AnyResult<T, E>, other_promise: AnyResult<U, E>, signal?: AbortSignal): AsyncResult<U, E | UnknownError | DOMException>;
+/**
+ * Asynchronous logical OR operation. If result is Ok, returns result; if result is Err, awaits and returns other.
+ * @typeParam T - The type of the success value
+ * @typeParam E - The type of the original error
+ * @typeParam F - The type of the alternative error
+ * @param result_promise - The first AnyResult
+ * @param other_promise - The second AnyResult
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns The result of the logical OR
+ */
+export declare function orAsync<T, E, F>(result_promise: AnyResult<T, E>, other_promise: AnyResult<T, F>, signal?: AbortSignal): AsyncResult<T, F | UnknownError | DOMException>;

package/dist/types/Result/Operators/Async/partition-async.d.ts

@@ -0,0 +1,29 @@
+import { AnyResult } from '../../types';
+import { UnknownError } from '../../../unknown-error';
+/**
+ * Asynchronously collects all success values from an array of AsyncResults.
+ * @typeParam T - The type of the success value
+ * @typeParam E - The type of the error
+ * @param results - The array of AsyncResults
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns A Promise of the array of collected success values
+ */
+export declare function collectOkAsync<T, E>(results: readonly AnyResult<T, E>[], signal?: AbortSignal): Promise<T[]>;
+/**
+ * Asynchronously collects all failure errors from an array of AsyncResults.
+ * @typeParam T - The type of the success value
+ * @typeParam E - The type of the error
+ * @param results - The array of AsyncResults
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns A Promise of the array of collected error values
+ */
+export declare function collectErrAsync<T, E>(results: readonly AnyResult<T, E>[], signal?: AbortSignal): Promise<E[]>;
+/**
+ * Asynchronously executes the Result array concurrently and partitions it into a tuple of success values and error values (non-short-circuiting).
+ * @typeParam T - The type of the success value
+ * @typeParam E - The type of the error
+ * @param results - The array of AsyncResults
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns A Promise of a tuple containing the success value array and the error value array
+ */
+export declare function partitionAsync<T, E>(results: readonly AnyResult<T, E>[], signal?: AbortSignal): Promise<[T[], Array<E | DOMException | UnknownError>]>;

package/dist/types/Result/Operators/Async/reduce-async.d.ts

@@ -0,0 +1,15 @@
+import { AnyResult, AsyncResult } from '../../types';
+import { UnknownError } from '../../../unknown-error';
+import { MaybePromise } from '../../../Utils/type-tool';
+/**
+ * Asynchronously and sequentially reduces multiple AsyncResults into a single Result (short-circuit).
+ * @typeParam T - The type of the success value
+ * @typeParam E - The type of the error
+ * @typeParam R - The type of the reduced result
+ * @param resultPromises - The array of AsyncResults to reduce
+ * @param initial - The initial value
+ * @param reducer - The reduction function (can be async)
+ * @param signal - Optional AbortSignal for cancellation
+ * @returns An AsyncResult containing the reduced result
+ */
+export declare function reduceAsync<T, E, R>(resultPromises: readonly AnyResult<T, E>[], initial: R, reducer: (accumulator: R, value: T, signal?: AbortSignal) => MaybePromise<R>, signal?: AbortSignal): AsyncResult<R, E | UnknownError | DOMException>;