@nlozgachev/pipelined 0.32.0 → 0.34.0

package/dist/{Task-CJZfcOkO.d.mts → Task-zAY4kSVB.d.ts}

@@ -1,4 +1,4 @@
-import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
+import { NonEmptyList, Duration } from './types.js';
 
 type WithKind<K extends string> = {
     readonly kind: K;
@@ -24,19 +24,19 @@ type WithLog<T> = {
 /** Retry policy for `Op.interpret`. */
 type RetryOptions<E> = {
     readonly attempts: number;
-    readonly backoff?: number | ((attempt: number) => number);
+    readonly backoff?: Duration | ((attempt: number) => Duration);
     readonly when?: (error: E) => boolean;
 };
 /** Timeout policy for `Op.interpret`. Wraps the entire retry sequence. */
 type TimeoutOptions<E> = {
-    readonly ms: number;
+    readonly duration: Duration;
     readonly onTimeout: () => E;
 };
 type WithTimeout<E> = {
     readonly timeout?: TimeoutOptions<E>;
 };
-type WithMs = {
-    readonly ms: number;
+type WithDuration = {
+    readonly duration: Duration;
 };
 type WithN = {
     readonly n: number;
@@ -48,22 +48,22 @@ type WithSize = {
     readonly size?: number;
 };
 type WithCooldown = {
-    readonly cooldown?: number;
+    readonly cooldown?: Duration;
 };
 type WithMinInterval = {
-    readonly minInterval?: number;
+    readonly minInterval?: Duration;
 };
 
 type Ok<A> = WithKind<"Ok"> & WithValue<A>;
-type Error<E> = WithKind<"Error"> & WithError<E>;
+type Err<E> = WithKind<"Err"> & WithError<E>;
 /**
- * Result represents a value that can be one of two types: a success (Ok) or a failure (Error).
+ * Result represents a value that can be one of two types: a success (Ok) or a failure (Err).
  * Use Result when an operation can fail with a meaningful error value.
  *
  * @example
  * ```ts
  * const divide = (a: number, b: number): Result<string, number> =>
- *   b === 0 ? Result.error("Division by zero") : Result.ok(a / b);
+ *   b === 0 ? Result.err("Division by zero") : Result.ok(a / b);
  *
  * pipe(
  *   divide(10, 2),
@@ -72,7 +72,7 @@ type Error<E> = WithKind<"Error"> & WithError<E>;
  * ); // 10
  * ```
  */
-type Result<E, A> = Ok<A> | Error<E>;
+type Result<E, A> = Ok<A> | Err<E>;
 declare namespace Result {
     /**
      * Creates a successful Result with the given value.
@@ -81,17 +81,17 @@ declare namespace Result {
     /**
      * Creates a failed Result with the given error.
      */
-    const error: <E>(e: E) => Error<E>;
+    const err: <E>(e: E) => Err<E>;
     /**
-     * Type guard that checks if an Result is Ok.
+     * Type guard that checks if a Result is Ok.
      */
     const isOk: <E, A>(data: Result<E, A>) => data is Ok<A>;
     /**
-     * Type guard that checks if an Result is Error.
+     * Type guard that checks if a Result is Err.
      */
-    const isError: <E, A>(data: Result<E, A>) => data is Error<E>;
+    const isErr: <E, A>(data: Result<E, A>) => data is Err<E>;
     /**
-     * Creates an Result from a function that may throw.
+     * Creates a Result from a function that may throw.
      * Catches any errors and transforms them using the onError function.
      *
      * @example
@@ -105,21 +105,21 @@ declare namespace Result {
      */
     const tryCatch: <E, A>(f: () => A, onError: (e: unknown) => E) => Result<E, A>;
     /**
-     * Transforms the success value inside an Result.
+     * Transforms the success value inside a Result.
      *
      * @example
      * ```ts
      * pipe(Result.ok(5), Result.map(n => n * 2)); // Ok(10)
-     * pipe(Result.error("error"), Result.map(n => n * 2)); // Error("error")
+     * pipe(Result.err("error"), Result.map(n => n * 2)); // Err("error")
      * ```
      */
     const map: <E, A, B>(f: (a: A) => B) => (data: Result<E, A>) => Result<E, B>;
     /**
-     * Transforms the error value inside an Result.
+     * Transforms the error value inside a Result.
      *
      * @example
      * ```ts
-     * pipe(Result.error("oops"), Result.mapError(e => e.toUpperCase())); // Error("OOPS")
+     * pipe(Result.err("oops"), Result.mapError(e => e.toUpperCase())); // Err("OOPS")
      * ```
      */
     const mapError: <E, F, A>(f: (e: E) => F) => (data: Result<E, A>) => Result<F, A>;
@@ -130,15 +130,15 @@ declare namespace Result {
      * @example
      * ```ts
      * const validatePositive = (n: number): Result<string, number> =>
-     *   n > 0 ? Result.ok(n) : Result.error("Must be positive");
+     *   n > 0 ? Result.ok(n) : Result.err("Must be positive");
      *
      * pipe(Result.ok(5), Result.chain(validatePositive)); // Ok(5)
-     * pipe(Result.ok(-1), Result.chain(validatePositive)); // Error("Must be positive")
+     * pipe(Result.ok(-1), Result.chain(validatePositive)); // Err("Must be positive")
      * ```
      */
     const chain: <E, A, B>(f: (a: A) => Result<E, B>) => (data: Result<E, A>) => Result<E, B>;
     /**
-     * Extracts the value from an Result by providing handlers for both cases.
+     * Extracts the value from a Result by providing handlers for both cases.
      *
      * @example
      * ```ts
@@ -178,8 +178,8 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(Result.ok(5), Result.getOrElse(() => 0)); // 5
-     * pipe(Result.error("error"), Result.getOrElse(() => 0)); // 0
-     * pipe(Result.error("error"), Result.getOrElse(() => null)); // null — typed as number | null
+     * pipe(Result.err("error"), Result.getOrElse(() => 0)); // 0
+     * pipe(Result.err("error"), Result.getOrElse(() => null)); // null — typed as number | null
      * ```
      */
     const getOrElse: <E, A, B>(defaultValue: () => B) => (data: Result<E, A>) => A | B;
@@ -204,7 +204,7 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(
-     *   Result.error("not found"),
+     *   Result.err("not found"),
      *   Result.tapError(e => console.error("validation failed:", e)),
      *   Result.chain(save),
      * )
@@ -218,11 +218,49 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(5, Result.fromPredicate(n => n > 0, n => `${n} is not positive`));  // Ok(5)
-     * pipe(-1, Result.fromPredicate(n => n > 0, n => `${n} is not positive`)); // Error("-1 is not positive")
-     * pipe("", Result.fromPredicate(s => s.length > 0, () => "empty string")); // Error("empty string")
+     * pipe(-1, Result.fromPredicate(n => n > 0, n => `${n} is not positive`)); // Err("-1 is not positive")
+     * pipe("", Result.fromPredicate(s => s.length > 0, () => "empty string")); // Err("empty string")
      * ```
      */
     const fromPredicate: <E, A>(pred: (a: A) => boolean, onFalse: (a: A) => E) => (a: A) => Result<E, A>;
+    /**
+     * Creates a Result from a nullable value.
+     * Returns Ok if the value is not null or undefined, error from onNull otherwise.
+     *
+     * @example
+     * ```ts
+     * pipe(null, Result.fromNullable(() => "is null")); // Err("is null")
+     * pipe(42, Result.fromNullable(() => "is null"));   // Ok(42)
+     * ```
+     */
+    const fromNullable: <E>(onNull: () => E) => <A>(value: A | null | undefined) => Result<E, A>;
+    /**
+     * Creates a Result from a Maybe.
+     * Some becomes Ok, None becomes error from onNone.
+     *
+     * @example
+     * ```ts
+     * pipe(Maybe.none(), Result.fromMaybe(() => "is none")); // Err("is none")
+     * pipe(Maybe.some(42), Result.fromMaybe(() => "is none")); // Ok(42)
+     * ```
+     */
+    const fromMaybe: <E>(onNone: () => E) => <A>(maybe: Maybe<A>) => Result<E, A>;
+    /**
+     * Wraps a throwing function of any arguments, returning a new function
+     * that catches errors and returns a Result.
+     *
+     * @example
+     * ```ts
+     * const safeParse = Result.fromThrowable(
+     *   (s: string) => JSON.parse(s),
+     *   (e) => new Error(`Parse error: ${e}`)
+     * );
+     *
+     * safeParse('{"a":1}'); // Ok({ a: 1 })
+     * safeParse('invalid');  // Err(Error)
+     * ```
+     */
+    const fromThrowable: <Args extends readonly unknown[], A, E>(f: (...args: Args) => A, onError: (e: unknown) => E) => (...args: Args) => Result<E, A>;
     /**
      * Recovers from an error by providing a fallback Result.
      * The fallback can produce a different success type, widening the result to `Result<E, A | B>`.
@@ -235,25 +273,25 @@ declare namespace Result {
      * @example
      * ```ts
      * pipe(
-     *   Result.error(new Error("not found")),
+     *   Result.err(new Error("not found")),
      *   Result.recoverUnless(e => e.message === "fatal", () => Result.ok(0))
      * ); // Ok(0)
      * ```
      */
     const recoverUnless: <E, A, B>(isBlocked: (e: E) => boolean, fallback: () => Result<E, B>) => (data: Result<E, A>) => Result<E, A | B>;
     /**
-     * Converts a Result to an Maybe.
+     * Converts a Result to a Maybe.
      * Ok becomes Some, Err becomes None (the error is discarded).
      *
      * @example
      * ```ts
      * Result.toMaybe(Result.ok(42)); // Some(42)
-     * Result.toMaybe(Result.error("oops")); // None
+     * Result.toMaybe(Result.err("oops")); // None
      * ```
      */
     const toMaybe: <E, A>(data: Result<E, A>) => Maybe<A>;
     /**
-     * Applies a function wrapped in an Result to a value wrapped in an Result.
+     * Applies a function wrapped in a Result to a value wrapped in a Result.
      *
      * @example
      * ```ts
@@ -276,14 +314,13 @@ type None = WithKind<"None">;
  *
  * @example
  * ```ts
- * const findUser = (id: string): Maybe<User> =>
- *   users.has(id) ? Maybe.some(users.get(id)!) : Maybe.none();
+ * const user = { name: "Alice", email: Maybe.some("alice@example.com") };
  *
  * pipe(
- *   findUser("123"),
- *   Maybe.map(user => user.name),
- *   Maybe.getOrElse(() => "Unknown")
- * );
+ *   user.email,
+ *   Maybe.map(email => email.toUpperCase()),
+ *   Maybe.getOrElse(() => "NO EMAIL")
+ * ); // "ALICE@EXAMPLE.COM"
  * ```
  */
 type Maybe<T> = Some<T> | None;
@@ -338,7 +375,7 @@ declare namespace Maybe {
      */
     const fromPredicate: <A>(pred: (a: A) => boolean) => (a: A) => Maybe<A>;
     /**
-     * Converts an Maybe to a Result.
+     * Converts a Maybe to a Result.
      * Some becomes Ok, None becomes Err with the provided error.
      *
      * @example
@@ -356,13 +393,13 @@ declare namespace Maybe {
      */
     const toResult: <E>(onNone: () => E) => <A>(data: Maybe<A>) => Result<E, A>;
     /**
-     * Creates an Maybe from a Result.
+     * Creates a Maybe from a Result.
      * Ok becomes Some, Err becomes None (the error is discarded).
      *
      * @example
      * ```ts
      * Maybe.fromResult(Result.ok(42)); // Some(42)
-     * Maybe.fromResult(Result.error("oops")); // None
+     * Maybe.fromResult(Result.err("oops")); // None
      * ```
      */
     const fromResult: <E, A>(data: Result<E, A>) => Maybe<A>;
@@ -426,7 +463,7 @@ declare namespace Maybe {
         some: (a: A) => B;
     }) => (data: Maybe<A>) => B;
     /**
-     * Returns the value inside an Maybe, or a default value if None.
+     * Returns the value inside a Maybe, or a default value if None.
      * The default is a thunk `() => B` — evaluated only when the Maybe is None.
      * The default can be a different type, widening the result to `A | B`.
      *
@@ -844,37 +881,37 @@ declare namespace Task {
      */
     const all: <T extends readonly Task<unknown>[]>(tasks: T) => Task<{ [K in keyof T]: T[K] extends Task<infer A> ? A : never; }>;
     /**
-     * Delays the execution of a Task by the specified milliseconds.
+     * Delays the execution of a Task by the specified duration.
      * Useful for debouncing or rate limiting.
      *
      * @example
      * ```ts
      * pipe(
      *   Task.resolve(42),
-     *   Task.delay(1000)
+     *   Task.delay(Duration.seconds(1))
      * )(); // Resolves after 1 second
      * ```
      */
-    const delay: (ms: number) => <A>(data: Task<A>) => Task<A>;
+    const delay: (duration: Duration) => <A>(data: Task<A>) => Task<A>;
     /**
      * Runs a Task a fixed number of times sequentially, collecting all results into an array.
-     * An optional delay (ms) can be inserted between runs.
+     * An optional delay duration can be inserted between runs.
      *
      * @example
      * ```ts
      * pipe(
      *   pollSensor,
-     *   Task.repeat({ times: 5, delay: 1000 })
+     *   Task.repeat({ times: 5, delay: Duration.seconds(1) })
      * )(); // Task<Reading[]> — 5 readings, one per second
      * ```
      */
     const repeat: (options: {
         times: number;
-        delay?: number;
+        delay?: Duration;
     }) => <A>(task: Task<A>) => Task<readonly A[]>;
     /**
      * Runs a Task repeatedly until the result satisfies a predicate, returning that result.
-     * An optional delay (ms) can be inserted between runs.
+     * An optional delay duration can be inserted between runs.
      * An optional `maxAttempts` cap stops the loop after N calls — the last value is returned
      * regardless of whether the predicate was satisfied.
      *
@@ -882,18 +919,19 @@ declare namespace Task {
      * ```ts
      * pipe(
      *   checkStatus,
-     *   Task.repeatUntil({ when: (s) => s === "ready", delay: 500 })
+     *   Task.repeatUntil({ when: (s) => s === "ready", delay: Duration.milliseconds(500) })
      * )(); // polls every 500ms until status is "ready"
      * ```
      */
     const repeatUntil: <A>(options: {
         when: (a: A) => boolean;
-        delay?: number;
+        delay?: Duration;
         maxAttempts?: number;
     }) => (task: Task<A>) => Task<A>;
     /**
      * Resolves with the value of the first Task to complete. All Tasks start
-     * immediately; the rest are abandoned once one resolves.
+     * immediately. When one resolves, the other tasks are cancelled (aborted)
+     * downstream.
      *
      * @example
      * ```ts
@@ -904,6 +942,17 @@ declare namespace Task {
      * ```
      */
     const race: <A>(tasks: ReadonlyArray<Task<A>>) => Task<A>;
+    /**
+     * Runs an array of Tasks concurrently and collects their results in an array.
+     * Forward-propagates the call site's AbortSignal to all subtasks concurrently.
+     *
+     * @example
+     * ```ts
+     * Task.sequence([loadConfig, detectLocale, loadTheme])();
+     * // Deferred<[Config, string, Theme]>
+     * ```
+     */
+    const sequence: <A>(tasks: ReadonlyArray<Task<A>>) => Task<ReadonlyArray<A>>;
     /**
      * Runs an array of Tasks one at a time in order, collecting all results.
      * Each Task starts only after the previous one resolves.
@@ -923,20 +972,20 @@ declare namespace Task {
     const sequential: <A>(tasks: ReadonlyArray<Task<A>>) => Task<ReadonlyArray<A>>;
     /**
      * Converts a `Task<A>` into a `Task<Result<E, A>>`, resolving to `Err` if the
-     * Task does not complete within the given time. The inner Task receives an
-     * `AbortSignal` that fires when the deadline passes, so operations like `fetch`
+     * Task does not complete within the given duration. The inner Task receives an
+     * `AbortSignal` that fires when the deadline passes, so asynchronous operations
      * that accept a signal are cancelled rather than left dangling.
      *
      * @example
      * ```ts
      * pipe(
      *   heavyComputation,
-     *   Task.timeout(5000, () => "timed out"),
+     *   Task.timeout(Duration.seconds(5), () => "timed out"),
      *   TaskResult.chain(processResult)
      * );
      * ```
      */
-    const timeout: <E>(ms: number, onTimeout: () => E) => <A>(task: Task<A>) => Task<Result<E, A>>;
+    const timeout: <E>(duration: Duration, onTimeout: () => E) => <A>(task: Task<A>) => Task<Result<E, A>>;
     /**
      * Creates a Task paired with an `abort` handle. Calling `abort()` cancels the
      * current in-flight call immediately. Unlike a one-shot abort, calling `task()`
@@ -968,7 +1017,7 @@ declare namespace Task {
      * @example
      * ```ts
      * const name = await pipe(
-     *     fetchConfig,
+     *     loadConfig,
      *     Task.map(config => config.name),
      *     Task.run(),
      * );
@@ -977,4 +1026,4 @@ declare namespace Task {
     const run: (signal?: AbortSignal) => <A>(task: Task<A>) => Promise<A>;
 }
 
-export { Deferred as D, Equality as E, Maybe as M, type None as N, type Ok as O, Result as R, type Some as S, Task as T, type WithValue as W, type Error as a, Ordering as b, type WithLog as c, type WithKind as d, type WithError as e, type RetryOptions as f, type TimeoutOptions as g, type WithTimeout as h, type WithMinInterval as i, type WithCooldown as j, type WithConcurrency as k, type WithSize as l, type WithMs as m, type WithN as n, type WithErrors as o, type WithFirst as p, type WithSecond as q };
+export { Deferred as D, Equality as E, Maybe as M, type None as N, type Ok as O, Result as R, type Some as S, Task as T, type WithValue as W, type Err as a, Ordering as b, type WithLog as c, type WithKind as d, type WithError as e, type RetryOptions as f, type TimeoutOptions as g, type WithTimeout as h, type WithMinInterval as i, type WithCooldown as j, type WithConcurrency as k, type WithSize as l, type WithDuration as m, type WithN as n, type WithErrors as o, type WithFirst as p, type WithSecond as q };