@nlozgachev/pipelined 0.16.0 → 0.18.0

package/dist/core.d.ts

@@ -1,5 +1,5 @@
-import { a as Option, W as WithValue, b as WithLog, R as Result, c as WithKind, d as WithError, T as Task, e as WithErrors, f as WithFirst, g as WithSecond } from './Task-BjAkkD6t.js';
-export { D as Deferred, E as Err, N as None, O as Ok, S as Some } from './Task-BjAkkD6t.js';
+import { M as Maybe, W as WithValue, a as WithLog, R as Result, b as WithKind, c as WithError, T as Task, d as WithErrors, e as WithFirst, f as WithSecond } from './Task-DUdIQm-Q.js';
+export { D as Deferred, E as Err, N as None, O as Ok, S as Some } from './Task-DUdIQm-Q.js';
 import { N as NonEmptyList } from './NonEmptyList-BlGFjor5.js';
 
 /** Keys of T for which undefined is assignable (i.e. optional fields). */
@@ -8,7 +8,7 @@ type OptionalKeys<T> = {
 }[keyof T];
 /**
  * Optional<S, A> focuses on a value A inside a structure S that may or may
- * not be present. Like a Lens, but get returns Option<A>.
+ * not be present. Like a Lens, but get returns Maybe<A>.
  *
  * Compose with other Optionals via `andThen`, or with a Lens via `andThenLens`.
  * Convert a Lens to an Optional with `Lens.toOptional`.
@@ -25,22 +25,22 @@ type OptionalKeys<T> = {
  * ```
  */
 type Optional<S, A> = {
-    readonly get: (s: S) => Option<A>;
+    readonly get: (s: S) => Maybe<A>;
     readonly set: (a: A) => (s: S) => S;
 };
 declare namespace Optional {
     /**
-     * Constructs an Optional from a getter (returning Option<A>) and a setter.
+     * Constructs an Optional from a getter (returning Maybe<A>) and a setter.
      *
      * @example
      * ```ts
      * const firstChar = Optional.make(
-     *   (s: string) => s.length > 0 ? Option.some(s[0]) : Option.none(),
+     *   (s: string) => s.length > 0 ? Maybe.some(s[0]) : Maybe.none(),
      *   (c) => (s) => s.length > 0 ? c + s.slice(1) : s,
      * );
      * ```
      */
-    const make: <S, A>(get: (s: S) => Option<A>, set: (a: A) => (s: S) => S) => Optional<S, A>;
+    const make: <S, A>(get: (s: S) => Maybe<A>, set: (a: A) => (s: S) => S) => Optional<S, A>;
     /**
      * Creates an Optional that focuses on an optional property of an object.
      * Only keys whose type includes undefined (i.e. `field?: T`) are accepted.
@@ -67,14 +67,14 @@ declare namespace Optional {
      */
     const index: <A>(i: number) => Optional<A[], A>;
     /**
-     * Reads the focused value from a structure, returning Option<A>.
+     * Reads the focused value from a structure, returning Maybe<A>.
      *
      * @example
      * ```ts
      * pipe(profile, Optional.get(bioOpt)); // Some("...") or None
      * ```
      */
-    const get: <S, A>(opt: Optional<S, A>) => (s: S) => Option<A>;
+    const get: <S, A>(opt: Optional<S, A>) => (s: S) => Maybe<A>;
     /**
      * Replaces the focused value within a structure.
      * For indexed focuses, this is a no-op when the index is out of bounds.
@@ -500,10 +500,10 @@ declare namespace Refinement {
      */
     const or: <A, C extends A>(second: Refinement<A, C>) => <B extends A>(first: Refinement<A, B>) => Refinement<A, B | C>;
     /**
-     * Converts a `Refinement<A, B>` into a function `(a: A) => Option<B>`.
+     * Converts a `Refinement<A, B>` into a function `(a: A) => Maybe<B>`.
      *
      * Returns `Some(a)` when the refinement holds, `None` otherwise. Useful for
-     * integrating runtime validation into an `Option`-based pipeline.
+     * integrating runtime validation into an `Maybe`-based pipeline.
      *
      * @example
      * ```ts
@@ -515,7 +515,7 @@ declare namespace Refinement {
      * pipe(42, Refinement.toFilter(isPositive)); // Some(42)
      * ```
      */
-    const toFilter: <A, B extends A>(r: Refinement<A, B>) => (a: A) => Option<B>;
+    const toFilter: <A, B extends A>(r: Refinement<A, B>) => (a: A) => Maybe<B>;
     /**
      * Converts a `Refinement<A, B>` into a function `(a: A) => Result<E, B>`.
      *
@@ -1025,10 +1025,10 @@ declare namespace RemoteData {
      */
     const recover: <E, A, B>(fallback: (e: E) => RemoteData<E, B>) => (data: RemoteData<E, A>) => RemoteData<E, A | B>;
     /**
-     * Converts a RemoteData to an Option.
+     * Converts a RemoteData to an Maybe.
      * Success becomes Some, all other states become None.
      */
-    const toOption: <E, A>(data: RemoteData<E, A>) => Option<A>;
+    const toMaybe: <E, A>(data: RemoteData<E, A>) => Maybe<A>;
     /**
      * Converts a RemoteData to a Result.
      * Success becomes Ok, Failure becomes Err.
@@ -1148,8 +1148,38 @@ declare namespace TaskResult {
         backoff?: number | ((attempt: number) => number);
         when?: (error: E) => boolean;
     }) => <A>(data: TaskResult<E, A>) => TaskResult<E, A>;
+    /**
+     * Polls a TaskResult repeatedly until the success value satisfies a predicate.
+     * Stops immediately and returns `Err` if the task fails.
+     *
+     * `delay` accepts a fixed number of milliseconds or a function `(attempt) => ms`
+     * for a computed delay — useful for starting fast and slowing down over time.
+     *
+     * @example
+     * ```ts
+     * const checkJob = (id: string): TaskResult<string, { status: "pending" | "done" }> =>
+     *   TaskResult.tryCatch(() => fetch(`/jobs/${id}`).then(r => r.json()), String);
+     *
+     * // Fixed delay: poll every 2s
+     * pipe(
+     *   checkJob(jobId),
+     *   TaskResult.pollUntil({ when: job => job.status === "done", delay: 2000 }),
+     * );
+     *
+     * // Computed delay: 1s, 2s, 3s, ...
+     * pipe(
+     *   checkJob(jobId),
+     *   TaskResult.pollUntil({ when: job => job.status === "done", delay: n => n * 1000 }),
+     * );
+     * ```
+     */
+    const pollUntil: <A>(options: {
+        when: (a: A) => boolean;
+        delay?: number | ((attempt: number) => number);
+    }) => <E>(task: TaskResult<E, A>) => TaskResult<E, A>;
     /**
      * Fails a TaskResult with a typed error if it does not resolve within the given time.
+     * Uses `Promise.race` — the underlying operation keeps running after the timeout fires.
      *
      * @example
      * ```ts
@@ -1451,84 +1481,84 @@ declare namespace State {
 
 /**
  * A Task that resolves to an optional value.
- * Combines async operations with the Option type for values that may not exist.
+ * Combines async operations with the Maybe type for values that may not exist.
  *
  * @example
  * ```ts
- * const findUser = (id: string): TaskOption<User> =>
- *   TaskOption.tryCatch(() => db.users.findById(id));
+ * const findUser = (id: string): TaskMaybe<User> =>
+ *   TaskMaybe.tryCatch(() => db.users.findById(id));
  *
  * pipe(
  *   findUser("123"),
- *   TaskOption.map(user => user.name),
- *   TaskOption.getOrElse(() => "Unknown")
+ *   TaskMaybe.map(user => user.name),
+ *   TaskMaybe.getOrElse(() => "Unknown")
  * )();
  * ```
  */
-type TaskOption<A> = Task<Option<A>>;
-declare namespace TaskOption {
+type TaskMaybe<A> = Task<Maybe<A>>;
+declare namespace TaskMaybe {
     /**
      * Wraps a value in a Some inside a Task.
      */
-    const some: <A>(value: A) => TaskOption<A>;
+    const some: <A>(value: A) => TaskMaybe<A>;
     /**
-     * Creates a TaskOption that resolves to None.
+     * Creates a TaskMaybe that resolves to None.
      */
-    const none: <A = never>() => TaskOption<A>;
+    const none: <A = never>() => TaskMaybe<A>;
     /**
-     * Lifts an Option into a TaskOption.
+     * Lifts an Option into a TaskMaybe.
      */
-    const fromOption: <A>(option: Option<A>) => TaskOption<A>;
+    const fromMaybe: <A>(option: Maybe<A>) => TaskMaybe<A>;
     /**
-     * Lifts a Task into a TaskOption by wrapping its result in Some.
+     * Lifts a Task into a TaskMaybe by wrapping its result in Some.
      */
-    const fromTask: <A>(task: Task<A>) => TaskOption<A>;
+    const fromTask: <A>(task: Task<A>) => TaskMaybe<A>;
     /**
-     * Creates a TaskOption from a Promise-returning function.
+     * Creates a TaskMaybe from a Promise-returning function.
      * Returns Some if the promise resolves, None if it rejects.
      *
      * @example
      * ```ts
-     * const fetchUser = TaskOption.tryCatch(() =>
+     * const fetchUser = TaskMaybe.tryCatch(() =>
      *   fetch("/user/1").then(r => r.json())
      * );
      * ```
      */
-    const tryCatch: <A>(f: () => Promise<A>) => TaskOption<A>;
+    const tryCatch: <A>(f: () => Promise<A>) => TaskMaybe<A>;
     /**
-     * Transforms the value inside a TaskOption.
+     * Transforms the value inside a TaskMaybe.
      */
-    const map: <A, B>(f: (a: A) => B) => (data: TaskOption<A>) => TaskOption<B>;
+    const map: <A, B>(f: (a: A) => B) => (data: TaskMaybe<A>) => TaskMaybe<B>;
     /**
-     * Chains TaskOption computations. If the first resolves to Some, passes the
+     * Chains TaskMaybe computations. If the first resolves to Some, passes the
      * value to f. If the first resolves to None, propagates None.
      *
      * @example
      * ```ts
      * pipe(
      *   findUser("123"),
-     *   TaskOption.chain(user => findOrg(user.orgId))
+     *   TaskMaybe.chain(user => findOrg(user.orgId))
      * )();
      * ```
      */
-    const chain: <A, B>(f: (a: A) => TaskOption<B>) => (data: TaskOption<A>) => TaskOption<B>;
+    const chain: <A, B>(f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<B>;
     /**
-     * Applies a function wrapped in a TaskOption to a value wrapped in a TaskOption.
+     * Applies a function wrapped in a TaskMaybe to a value wrapped in a TaskMaybe.
      * Both Tasks run in parallel.
      */
-    const ap: <A>(arg: TaskOption<A>) => <B>(data: TaskOption<(a: A) => B>) => TaskOption<B>;
+    const ap: <A>(arg: TaskMaybe<A>) => <B>(data: TaskMaybe<(a: A) => B>) => TaskMaybe<B>;
     /**
-     * Extracts a value from a TaskOption by providing handlers for both cases.
+     * Extracts a value from a TaskMaybe by providing handlers for both cases.
      */
-    const fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: TaskOption<A>) => Task<B>;
+    const fold: <A, B>(onNone: () => B, onSome: (a: A) => B) => (data: TaskMaybe<A>) => Task<B>;
     /**
-     * Pattern matches on a TaskOption, returning a Task of the result.
+     * Pattern matches on a TaskMaybe, returning a Task of the result.
      *
      * @example
      * ```ts
      * pipe(
      *   findUser("123"),
-     *   TaskOption.match({
+     *   TaskMaybe.match({
      *     some: user => `Hello, ${user.name}`,
      *     none: () => "User not found"
      *   })
@@ -1538,33 +1568,33 @@ declare namespace TaskOption {
     const match: <A, B>(cases: {
         none: () => B;
         some: (a: A) => B;
-    }) => (data: TaskOption<A>) => Task<B>;
+    }) => (data: TaskMaybe<A>) => Task<B>;
     /**
-     * Returns the value or a default if the TaskOption resolves to None.
+     * Returns the value or a default if the TaskMaybe resolves to None.
      * The default can be a different type, widening the result to `Task<A | B>`.
      */
-    const getOrElse: <A, B>(defaultValue: () => B) => (data: TaskOption<A>) => Task<A | B>;
+    const getOrElse: <A, B>(defaultValue: () => B) => (data: TaskMaybe<A>) => Task<A | B>;
     /**
-     * Executes a side effect on the value without changing the TaskOption.
+     * Executes a side effect on the value without changing the TaskMaybe.
      * Useful for logging or debugging.
      */
-    const tap: <A>(f: (a: A) => void) => (data: TaskOption<A>) => TaskOption<A>;
+    const tap: <A>(f: (a: A) => void) => (data: TaskMaybe<A>) => TaskMaybe<A>;
     /**
-     * Filters the value inside a TaskOption. Returns None if the predicate fails.
+     * Filters the value inside a TaskMaybe. Returns None if the predicate fails.
      */
-    const filter: <A>(predicate: (a: A) => boolean) => (data: TaskOption<A>) => TaskOption<A>;
+    const filter: <A>(predicate: (a: A) => boolean) => (data: TaskMaybe<A>) => TaskMaybe<A>;
     /**
-     * Converts a TaskOption to a TaskResult, using onNone to produce the error value.
+     * Converts a TaskMaybe to a TaskResult, using onNone to produce the error value.
      *
      * @example
      * ```ts
      * pipe(
      *   findUser("123"),
-     *   TaskOption.toTaskResult(() => "User not found")
+     *   TaskMaybe.toTaskResult(() => "User not found")
      * );
      * ```
      */
-    const toTaskResult: <E>(onNone: () => E) => <A>(data: TaskOption<A>) => TaskResult<E, A>;
+    const toTaskResult: <E>(onNone: () => E) => <A>(data: TaskMaybe<A>) => TaskResult<E, A>;
 }
 
 type Valid<A> = WithKind<"Valid"> & WithValue<A>;
@@ -2262,4 +2292,4 @@ declare namespace Tuple {
     const tap: <A, B>(f: (a: A, b: B) => void) => (tuple: Tuple<A, B>) => Tuple<A, B>;
 }
 
-export { type Failure, type Invalid, Lens, type Loading, Logged, type NotAsked, Option, Optional, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, type Success, Task, TaskOption, TaskResult, TaskValidation, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple, type Valid, Validation };
+export { type Failure, type Invalid, Lens, type Loading, Logged, Maybe, type NotAsked, Optional, Predicate, Reader, Refinement, RemoteData, Resource, Result, State, type Success, Task, TaskMaybe, TaskResult, TaskValidation, These, type TheseBoth, type TheseFirst, type TheseSecond, Tuple, type Valid, Validation };

package/dist/core.js

@@ -23,7 +23,7 @@ __export(Core_exports, {
   Deferred: () => Deferred,
   Lens: () => Lens,
   Logged: () => Logged,
-  Option: () => Option,
+  Maybe: () => Maybe,
   Optional: () => Optional,
   Predicate: () => Predicate,
   Reader: () => Reader,
@@ -33,7 +33,7 @@ __export(Core_exports, {
   Result: () => Result,
   State: () => State,
   Task: () => Task,
-  TaskOption: () => TaskOption,
+  TaskMaybe: () => TaskMaybe,
   TaskResult: () => TaskResult,
   TaskValidation: () => TaskValidation,
   These: () => These,
@@ -129,37 +129,37 @@ var Result;
   };
   Result2.recover = (fallback) => (data) => (0, Result2.isOk)(data) ? data : fallback(data.error);
   Result2.recoverUnless = (blockedErr, fallback) => (data) => (0, Result2.isErr)(data) && data.error !== blockedErr ? fallback() : data;
-  Result2.toOption = (data) => (0, Result2.isOk)(data) ? Option.some(data.value) : Option.none();
+  Result2.toMaybe = (data) => (0, Result2.isOk)(data) ? Maybe.some(data.value) : Maybe.none();
   Result2.ap = (arg) => (data) => (0, Result2.isOk)(data) && (0, Result2.isOk)(arg) ? (0, Result2.ok)(data.value(arg.value)) : (0, Result2.isErr)(data) ? data : arg;
 })(Result || (Result = {}));
 
-// src/Core/Option.ts
+// src/Core/Maybe.ts
 var _none = { kind: "None" };
-var Option;
-((Option2) => {
-  Option2.some = (value) => ({ kind: "Some", value });
-  Option2.isSome = (data) => data.kind === "Some";
-  Option2.none = () => _none;
-  Option2.isNone = (data) => data.kind === "None";
-  Option2.fromNullable = (value) => value === null || value === void 0 ? (0, Option2.none)() : (0, Option2.some)(value);
-  Option2.toNullable = (data) => (0, Option2.isSome)(data) ? data.value : null;
-  Option2.toUndefined = (data) => (0, Option2.isSome)(data) ? data.value : void 0;
-  Option2.fromUndefined = (value) => value === void 0 ? (0, Option2.none)() : (0, Option2.some)(value);
-  Option2.toResult = (onNone) => (data) => (0, Option2.isSome)(data) ? Result.ok(data.value) : Result.err(onNone());
-  Option2.fromResult = (data) => Result.isOk(data) ? (0, Option2.some)(data.value) : (0, Option2.none)();
-  Option2.map = (f) => (data) => (0, Option2.isSome)(data) ? (0, Option2.some)(f(data.value)) : data;
-  Option2.chain = (f) => (data) => (0, Option2.isSome)(data) ? f(data.value) : data;
-  Option2.fold = (onNone, onSome) => (data) => (0, Option2.isSome)(data) ? onSome(data.value) : onNone();
-  Option2.match = (cases) => (data) => (0, Option2.isSome)(data) ? cases.some(data.value) : cases.none();
-  Option2.getOrElse = (defaultValue) => (data) => (0, Option2.isSome)(data) ? data.value : defaultValue();
-  Option2.tap = (f) => (data) => {
-    if ((0, Option2.isSome)(data)) f(data.value);
+var Maybe;
+((Maybe2) => {
+  Maybe2.some = (value) => ({ kind: "Some", value });
+  Maybe2.isSome = (data) => data.kind === "Some";
+  Maybe2.none = () => _none;
+  Maybe2.isNone = (data) => data.kind === "None";
+  Maybe2.fromNullable = (value) => value === null || value === void 0 ? (0, Maybe2.none)() : (0, Maybe2.some)(value);
+  Maybe2.toNullable = (data) => (0, Maybe2.isSome)(data) ? data.value : null;
+  Maybe2.toUndefined = (data) => (0, Maybe2.isSome)(data) ? data.value : void 0;
+  Maybe2.fromUndefined = (value) => value === void 0 ? (0, Maybe2.none)() : (0, Maybe2.some)(value);
+  Maybe2.toResult = (onNone) => (data) => (0, Maybe2.isSome)(data) ? Result.ok(data.value) : Result.err(onNone());
+  Maybe2.fromResult = (data) => Result.isOk(data) ? (0, Maybe2.some)(data.value) : (0, Maybe2.none)();
+  Maybe2.map = (f) => (data) => (0, Maybe2.isSome)(data) ? (0, Maybe2.some)(f(data.value)) : data;
+  Maybe2.chain = (f) => (data) => (0, Maybe2.isSome)(data) ? f(data.value) : data;
+  Maybe2.fold = (onNone, onSome) => (data) => (0, Maybe2.isSome)(data) ? onSome(data.value) : onNone();
+  Maybe2.match = (cases) => (data) => (0, Maybe2.isSome)(data) ? cases.some(data.value) : cases.none();
+  Maybe2.getOrElse = (defaultValue) => (data) => (0, Maybe2.isSome)(data) ? data.value : defaultValue();
+  Maybe2.tap = (f) => (data) => {
+    if ((0, Maybe2.isSome)(data)) f(data.value);
     return data;
   };
-  Option2.filter = (predicate) => (data) => (0, Option2.isSome)(data) ? predicate(data.value) ? data : (0, Option2.none)() : data;
-  Option2.recover = (fallback) => (data) => (0, Option2.isSome)(data) ? data : fallback();
-  Option2.ap = (arg) => (data) => (0, Option2.isSome)(data) && (0, Option2.isSome)(arg) ? (0, Option2.some)(data.value(arg.value)) : (0, Option2.none)();
-})(Option || (Option = {}));
+  Maybe2.filter = (predicate) => (data) => (0, Maybe2.isSome)(data) ? predicate(data.value) ? data : (0, Maybe2.none)() : data;
+  Maybe2.recover = (fallback) => (data) => (0, Maybe2.isSome)(data) ? data : fallback();
+  Maybe2.ap = (arg) => (data) => (0, Maybe2.isSome)(data) && (0, Maybe2.isSome)(arg) ? (0, Maybe2.some)(data.value(arg.value)) : (0, Maybe2.none)();
+})(Maybe || (Maybe = {}));
 
 // src/Core/Optional.ts
 var Optional;
@@ -168,12 +168,12 @@ var Optional;
   Optional2.prop = () => (key) => (0, Optional2.make)(
     (s) => {
       const val = s[key];
-      return val !== null && val !== void 0 ? Option.some(val) : Option.none();
+      return val !== null && val !== void 0 ? Maybe.some(val) : Maybe.none();
     },
     (a) => (s) => ({ ...s, [key]: a })
   );
   Optional2.index = (i) => (0, Optional2.make)(
-    (arr) => i >= 0 && i < arr.length ? Option.some(arr[i]) : Option.none(),
+    (arr) => i >= 0 && i < arr.length ? Maybe.some(arr[i]) : Maybe.none(),
     (a) => (arr) => {
       if (i < 0 || i >= arr.length) return arr;
       const copy = [...arr];
@@ -202,7 +202,7 @@ var Optional;
   Optional2.andThen = (inner) => (outer) => (0, Optional2.make)(
     (s) => {
       const mid = outer.get(s);
-      return mid.kind === "None" ? Option.none() : inner.get(mid.value);
+      return mid.kind === "None" ? Maybe.none() : inner.get(mid.value);
     },
     (b) => (s) => {
       const mid = outer.get(s);
@@ -212,7 +212,7 @@ var Optional;
   Optional2.andThenLens = (inner) => (outer) => (0, Optional2.make)(
     (s) => {
       const mid = outer.get(s);
-      return mid.kind === "None" ? Option.none() : Option.some(inner.get(mid.value));
+      return mid.kind === "None" ? Maybe.none() : Maybe.some(inner.get(mid.value));
     },
     (b) => (s) => {
       const mid = outer.get(s);
@@ -258,7 +258,7 @@ var Refinement;
   Refinement2.compose = (bc) => (ab) => (a) => ab(a) && bc(a);
   Refinement2.and = (second) => (first) => (a) => first(a) && second(a);
   Refinement2.or = (second) => (first) => (a) => first(a) || second(a);
-  Refinement2.toFilter = (r) => (a) => r(a) ? Option.some(a) : Option.none();
+  Refinement2.toFilter = (r) => (a) => r(a) ? Maybe.some(a) : Maybe.none();
   Refinement2.toResult = (r, onFail) => (a) => r(a) ? Result.ok(a) : Result.err(onFail(a));
 })(Refinement || (Refinement = {}));
 
@@ -323,7 +323,7 @@ var RemoteData;
     return data;
   };
   RemoteData2.recover = (fallback) => (data) => (0, RemoteData2.isFailure)(data) ? fallback(data.error) : data;
-  RemoteData2.toOption = (data) => (0, RemoteData2.isSuccess)(data) ? Option.some(data.value) : Option.none();
+  RemoteData2.toMaybe = (data) => (0, RemoteData2.isSuccess)(data) ? Maybe.some(data.value) : Maybe.none();
   RemoteData2.toResult = (onNotReady) => (data) => (0, RemoteData2.isSuccess)(data) ? Result.ok(data.value) : Result.err((0, RemoteData2.isFailure)(data) ? data.error : onNotReady());
 })(RemoteData || (RemoteData = {}));
 
@@ -466,31 +466,31 @@ var State;
   State2.execute = (initialState) => (st) => st(initialState)[1];
 })(State || (State = {}));
 
-// src/Core/TaskOption.ts
-var TaskOption;
-((TaskOption2) => {
-  TaskOption2.some = (value) => Task.resolve(Option.some(value));
-  TaskOption2.none = () => Task.resolve(Option.none());
-  TaskOption2.fromOption = (option) => Task.resolve(option);
-  TaskOption2.fromTask = (task) => Task.map(Option.some)(task);
-  TaskOption2.tryCatch = (f) => Task.from(
-    () => f().then(Option.some).catch(() => Option.none())
+// src/Core/TaskMaybe.ts
+var TaskMaybe;
+((TaskMaybe2) => {
+  TaskMaybe2.some = (value) => Task.resolve(Maybe.some(value));
+  TaskMaybe2.none = () => Task.resolve(Maybe.none());
+  TaskMaybe2.fromMaybe = (option) => Task.resolve(option);
+  TaskMaybe2.fromTask = (task) => Task.map(Maybe.some)(task);
+  TaskMaybe2.tryCatch = (f) => Task.from(
+    () => f().then(Maybe.some).catch(() => Maybe.none())
   );
-  TaskOption2.map = (f) => (data) => Task.map(Option.map(f))(data);
-  TaskOption2.chain = (f) => (data) => Task.chain((option) => Option.isSome(option) ? f(option.value) : Task.resolve(Option.none()))(data);
-  TaskOption2.ap = (arg) => (data) => Task.from(
+  TaskMaybe2.map = (f) => (data) => Task.map(Maybe.map(f))(data);
+  TaskMaybe2.chain = (f) => (data) => Task.chain((option) => Maybe.isSome(option) ? f(option.value) : Task.resolve(Maybe.none()))(data);
+  TaskMaybe2.ap = (arg) => (data) => Task.from(
     () => Promise.all([
       Deferred.toPromise(data()),
       Deferred.toPromise(arg())
-    ]).then(([of_, oa]) => Option.ap(oa)(of_))
+    ]).then(([of_, oa]) => Maybe.ap(oa)(of_))
   );
-  TaskOption2.fold = (onNone, onSome) => (data) => Task.map(Option.fold(onNone, onSome))(data);
-  TaskOption2.match = (cases) => (data) => Task.map(Option.match(cases))(data);
-  TaskOption2.getOrElse = (defaultValue) => (data) => Task.map(Option.getOrElse(defaultValue))(data);
-  TaskOption2.tap = (f) => (data) => Task.map(Option.tap(f))(data);
-  TaskOption2.filter = (predicate) => (data) => Task.map(Option.filter(predicate))(data);
-  TaskOption2.toTaskResult = (onNone) => (data) => Task.map(Option.toResult(onNone))(data);
-})(TaskOption || (TaskOption = {}));
+  TaskMaybe2.fold = (onNone, onSome) => (data) => Task.map(Maybe.fold(onNone, onSome))(data);
+  TaskMaybe2.match = (cases) => (data) => Task.map(Maybe.match(cases))(data);
+  TaskMaybe2.getOrElse = (defaultValue) => (data) => Task.map(Maybe.getOrElse(defaultValue))(data);
+  TaskMaybe2.tap = (f) => (data) => Task.map(Maybe.tap(f))(data);
+  TaskMaybe2.filter = (predicate) => (data) => Task.map(Maybe.filter(predicate))(data);
+  TaskMaybe2.toTaskResult = (onNone) => (data) => Task.map(Maybe.toResult(onNone))(data);
+})(TaskMaybe || (TaskMaybe = {}));
 
 // src/Core/TaskResult.ts
 var TaskResult;
@@ -526,6 +526,17 @@ var TaskResult;
     });
     return run(attempts);
   });
+  TaskResult2.pollUntil = (options) => (task) => Task.from(() => {
+    const { when: predicate, delay } = options;
+    const getDelay = (attempt) => delay === void 0 ? 0 : typeof delay === "function" ? delay(attempt) : delay;
+    const run = (attempt) => Deferred.toPromise(task()).then((result) => {
+      if (Result.isErr(result)) return result;
+      if (predicate(result.value)) return result;
+      const ms = getDelay(attempt);
+      return (ms > 0 ? new Promise((r) => setTimeout(r, ms)) : Promise.resolve()).then(() => run(attempt + 1));
+    });
+    return run(1);
+  });
   TaskResult2.timeout = (ms, onTimeout) => (data) => Task.from(() => {
     let timerId;
     return Promise.race([
@@ -715,7 +726,7 @@ var Tuple;
   Deferred,
   Lens,
   Logged,
-  Option,
+  Maybe,
   Optional,
   Predicate,
   Reader,
@@ -725,7 +736,7 @@ var Tuple;
   Result,
   State,
   Task,
-  TaskOption,
+  TaskMaybe,
   TaskResult,
   TaskValidation,
   These,

package/dist/core.mjs

@@ -8,24 +8,24 @@ import {
   RemoteData,
   Resource,
   State,
-  TaskOption,
+  TaskMaybe,
   TaskResult,
   TaskValidation,
   These,
   Tuple,
   Validation
-} from "./chunk-2XKWSZEU.mjs";
+} from "./chunk-UWGFO7BH.mjs";
 import {
   Deferred,
-  Option,
+  Maybe,
   Result,
   Task
-} from "./chunk-QPTGO5AS.mjs";
+} from "./chunk-EAR4TIGH.mjs";
 export {
   Deferred,
   Lens,
   Logged,
-  Option,
+  Maybe,
   Optional,
   Predicate,
   Reader,
@@ -35,7 +35,7 @@ export {
   Result,
   State,
   Task,
-  TaskOption,
+  TaskMaybe,
   TaskResult,
   TaskValidation,
   These,

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, uncurry, uncurry3, uncurry4 } from './composition.mjs';
-export { D as Deferred, E as Err, N as None, O as Ok, a as Option, R as Result, S as Some, T as Task } from './Task-Bd3gXPRQ.mjs';
-export { Failure, Invalid, Lens, Loading, Logged, NotAsked, Optional, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, TaskOption, TaskResult, TaskValidation, These, TheseBoth, TheseFirst, TheseSecond, Tuple, Valid, Validation } from './core.mjs';
+export { D as Deferred, E as Err, M as Maybe, N as None, O as Ok, R as Result, S as Some, T as Task } from './Task-DBW4nOZR.mjs';
+export { Failure, Invalid, Lens, Loading, Logged, NotAsked, Optional, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, TaskMaybe, TaskResult, TaskValidation, These, TheseBoth, TheseFirst, TheseSecond, Tuple, Valid, Validation } from './core.mjs';
 export { Brand } from './types.mjs';
 export { N as NonEmptyList, i as isNonEmptyList } from './NonEmptyList-BlGFjor5.mjs';
 export { Arr, Dict, Num, Rec, Str, Uniq } from './utils.mjs';

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, uncurry, uncurry3, uncurry4 } from './composition.js';
-export { D as Deferred, E as Err, N as None, O as Ok, a as Option, R as Result, S as Some, T as Task } from './Task-BjAkkD6t.js';
-export { Failure, Invalid, Lens, Loading, Logged, NotAsked, Optional, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, TaskOption, TaskResult, TaskValidation, These, TheseBoth, TheseFirst, TheseSecond, Tuple, Valid, Validation } from './core.js';
+export { D as Deferred, E as Err, M as Maybe, N as None, O as Ok, R as Result, S as Some, T as Task } from './Task-DUdIQm-Q.js';
+export { Failure, Invalid, Lens, Loading, Logged, NotAsked, Optional, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, TaskMaybe, TaskResult, TaskValidation, These, TheseBoth, TheseFirst, TheseSecond, Tuple, Valid, Validation } from './core.js';
 export { Brand } from './types.js';
 export { N as NonEmptyList, i as isNonEmptyList } from './NonEmptyList-BlGFjor5.js';
 export { Arr, Dict, Num, Rec, Str, Uniq } from './utils.js';