@nlozgachev/pipelined 0.35.0 → 0.37.0

package/dist/composition.js

@@ -32,6 +32,7 @@ __export(Composition_exports, {
   curry: () => curry,
   curry3: () => curry3,
   curry4: () => curry4,
+  defaultTo: () => defaultTo,
   flip: () => flip,
   flow: () => flow,
   identity: () => identity,
@@ -177,6 +178,53 @@ function flow(ab, bc, cd, de, ef, fg, gh, hi, ij, jk) {
     }
   }
 }
+var when = (predicate, onTrue) => (a) => predicate(a) ? onTrue(a) : a;
+var unless = (predicate, onFalse) => (a) => predicate(a) ? a : onFalse(a);
+var either = (predicate, onTrue, onFalse) => (a) => predicate(a) ? onTrue(a) : onFalse(a);
+var struct = (fields) => (a) => {
+  const result = {};
+  for (const key of Object.keys(fields)) {
+    result[key] = fields[key](a);
+  }
+  return result;
+};
+function safe(...fns) {
+  return (a) => {
+    let result = a;
+    if (result === null || result === void 0) {
+      return result;
+    }
+    for (const fn of fns) {
+      result = fn(result);
+      if (result === null || result === void 0) {
+        return result;
+      }
+    }
+    return result;
+  };
+}
+function async(...fns) {
+  return async (a) => {
+    let result = await a;
+    for (const fn of fns) {
+      result = await fn(result);
+    }
+    return result;
+  };
+}
+flow.when = when;
+flow.unless = unless;
+flow.either = either;
+flow.struct = struct;
+flow.safe = safe;
+flow.async = async;
+flow.try = (f, onError) => (a) => {
+  try {
+    return f(a);
+  } catch (error) {
+    return onError(error, a);
+  }
+};
 
 // src/Composition/fn.ts
 var identity = (a) => a;
@@ -200,6 +248,7 @@ var once = (f) => {
     return result;
   };
 };
+var defaultTo = (fallback) => (a) => a === null || a === void 0 ? fallback : a;
 
 // src/Composition/juxt.ts
 function juxt(fns) {
@@ -275,6 +324,49 @@ function pipe(a, ab, bc, cd, de, ef, fg, gh, hi, ij, jk) {
     }
   }
 }
+var when2 = (predicate, onTrue) => (a) => predicate(a) ? onTrue(a) : a;
+var unless2 = (predicate, onFalse) => (a) => predicate(a) ? a : onFalse(a);
+var either2 = (predicate, onTrue, onFalse) => (a) => predicate(a) ? onTrue(a) : onFalse(a);
+var struct2 = (fields) => (a) => {
+  const result = {};
+  for (const key of Object.keys(fields)) {
+    result[key] = fields[key](a);
+  }
+  return result;
+};
+function safe2(a, ...fns) {
+  let result = a;
+  if (result === null || result === void 0) {
+    return result;
+  }
+  for (const fn of fns) {
+    result = fn(result);
+    if (result === null || result === void 0) {
+      return result;
+    }
+  }
+  return result;
+}
+async function async2(a, ...fns) {
+  let result = await a;
+  for (const fn of fns) {
+    result = await fn(result);
+  }
+  return result;
+}
+pipe.when = when2;
+pipe.unless = unless2;
+pipe.either = either2;
+pipe.struct = struct2;
+pipe.safe = safe2;
+pipe.async = async2;
+pipe.try = (f, onError) => (a) => {
+  try {
+    return f(a);
+  } catch (error) {
+    return onError(error, a);
+  }
+};
 
 // src/Composition/tap.ts
 var tap = (f) => (a) => {
@@ -305,6 +397,7 @@ var uncurry4 = (f) => (a, b, c, d) => f(a)(b)(c)(d);
   curry,
   curry3,
   curry4,
+  defaultTo,
   flip,
   flow,
   identity,

package/dist/composition.mjs

@@ -11,6 +11,7 @@ import {
   curry,
   curry3,
   curry4,
+  defaultTo,
   flip,
   flow,
   identity,
@@ -26,7 +27,7 @@ import {
   uncurry,
   uncurry3,
   uncurry4
-} from "./chunk-AHEZFTMT.mjs";
+} from "./chunk-3Q5UBRYB.mjs";
 export {
   and,
   compose,
@@ -40,6 +41,7 @@ export {
   curry,
   curry3,
   curry4,
+  defaultTo,
   flip,
   flow,
   identity,

package/dist/core.d.mts

@@ -1,5 +1,5 @@
-import { M as Maybe, W as WithValue, c as WithLog, D as Deferred, R as Result, d as WithKind, e as WithError, f as RetryOptions, g as TimeoutOptions, h as WithTimeout, i as WithMinInterval, j as WithCooldown, k as WithConcurrency, l as WithSize, m as WithDuration, n as WithN, T as Task, o as WithErrors, p as WithFirst, q as WithSecond } from './Task-DXsuurnc.mjs';
-export { E as Equality, a as Err, N as None, O as Ok, b as Ordering, S as Some } from './Task-DXsuurnc.mjs';
+import { M as Maybe, q as WithValue, k as WithLog, D as Deferred, R as Result, j as WithKind, g as WithError, c as RetryOptions, d as TimeoutOptions, p as WithTimeout, l as WithMinInterval, e as WithCooldown, W as WithConcurrency, o as WithSize, f as WithDuration, m as WithN, T as Task, h as WithErrors, i as WithFirst, n as WithSecond } from './Task-fn1n--6H.mjs';
+export { E as Equality, a as Err, N as None, O as Ok, b as Ordering, S as Some } from './Task-fn1n--6H.mjs';
 import { Duration, NonEmptyList } from './types.mjs';
 
 /**
@@ -561,6 +561,27 @@ declare namespace Logged {
      * ```
      */
     const run: <W, A>(data: Logged<W, A>) => readonly [A, ReadonlyArray<W>];
+    /**
+     * Lifts a Logged value into an accumulator object.
+     *
+     * @example
+     * ```ts
+     * pipe(Logged.make<string, number>(42), Logged.bindTo("value")); // Logged({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <W, A>(data: Logged<W, A>) => Logged<W, { [P in K]: A; }>;
+    /**
+     * Evaluates a new Logged using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Logged.make<string, { a: number }>({ a: 1 }),
+     *   Logged.bind("b", ({ a }) => Logged.make<string, number>(a + 1))
+     * ); // Logged({ value: { a: 1, b: 2 } })
+     * ```
+     */
+    const bind: <K extends string, W, A, B>(key: K, f: (a: A) => Logged<W, B>) => (data: Logged<W, A>) => Logged<W, A & { [P in K]: B; }>;
 }
 
 type MaybeRetry<E, O> = O extends {
@@ -1091,18 +1112,18 @@ declare namespace Op {
     }) => (outcome: Outcome<E, A>) => B;
     /**
      * Eliminates an Outcome with positional handlers.
-     * Order: `onErr`, `onOk`, `onNil` — mirrors `Result.fold` for the first two.
+     * Order: `onErr`, `onNil`, `onOk` — mirrors `Result.fold` for the first and last cases.
      *
      * @example
      * ```ts
      * Op.fold(
      *   (e) => `error: ${e.message}`,
-     *   (v) => `value: ${v}`,
      *   ()  => "nothing",
+     *   (v) => `value: ${v}`,
      * )(outcome);
      * ```
      */
-    const fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B, onNil: () => B) => (outcome: Outcome<E, A>) => B;
+    const fold: <E, A, B>(onErr: (e: E) => B, onNil: () => B, onOk: (a: A) => B) => (outcome: Outcome<E, A>) => B;
     /**
      * Returns the success value, or the result of `defaultValue()` for `Err` or `Nil`.
      *
@@ -1715,6 +1736,27 @@ declare namespace Reader {
      * ```
      */
     const run: <R>(env: R) => <A>(data: Reader<R, A>) => A;
+    /**
+     * Lifts a Reader value into an accumulator object.
+     *
+     * @example
+     * ```ts
+     * pipe(Reader.resolve(42), Reader.bindTo("value")); // Reader({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <R, A>(data: Reader<R, A>) => Reader<R, { [P in K]: A; }>;
+    /**
+     * Evaluates a new Reader using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Reader.resolve({ a: 1 }),
+     *   Reader.bind("b", ({ a }) => Reader.resolve(a + 1))
+     * ); // Reader({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, R, A, B>(key: K, f: (a: A) => Reader<R, B>) => (data: Reader<R, A>) => Reader<R, A & { [P in K]: B; }>;
 }
 
 type NotAsked = WithKind<"NotAsked">;
@@ -1829,15 +1871,15 @@ declare namespace RemoteData {
      * pipe(
      *   userData,
      *   RemoteData.fold(
+     *     e => `Error: ${e}`,
      *     () => "Not asked",
      *     () => "Loading...",
-     *     e => `Error: ${e}`,
      *     value => `Got: ${value}`
      *   )
      * );
      * ```
      */
-    const fold: <E, A, B>(onNotAsked: () => B, onLoading: () => B, onFailure: (e: E) => B, onSuccess: (a: A) => B) => (data: RemoteData<E, A>) => B;
+    const fold: <E, A, B>(onFailure: (e: E) => B, onNotAsked: () => B, onLoading: () => B, onSuccess: (a: A) => B) => (data: RemoteData<E, A>) => B;
     /**
      * Pattern matches on a RemoteData, returning the result of the matching case.
      *
@@ -2092,6 +2134,28 @@ declare namespace TaskResult {
      * ```
      */
     const run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Promise<Result<E, A>>;
+    /**
+     * Converts a TaskResult value into an object containing a single property.
+     * Initiates the pipeline accumulator record.
+     *
+     * @example
+     * ```ts
+     * pipe(TaskResult.ok(42), TaskResult.bindTo("value")); // TaskResult({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <E, A>(data: TaskResult<E, A>) => TaskResult<E, { [P in K]: A; }>;
+    /**
+     * Evaluates a new TaskResult using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   TaskResult.ok({ a: 1 }),
+     *   TaskResult.bind("b", ({ a }) => TaskResult.ok(a + 1))
+     * ); // TaskResult({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, E, A, B>(key: K, f: (a: A) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, A & { [P in K]: B; }>;
 }
 
 /**
@@ -2379,6 +2443,27 @@ declare namespace State {
      * ```
      */
     const execute: <S>(initialState: S) => <A>(st: State<S, A>) => S;
+    /**
+     * Lifts a State value into an accumulator object.
+     *
+     * @example
+     * ```ts
+     * pipe(State.resolve(42), State.bindTo("value")); // State({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <S, A>(data: State<S, A>) => State<S, { [P in K]: A; }>;
+    /**
+     * Evaluates a new State using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   State.resolve({ a: 1 }),
+     *   State.bind("b", ({ a }) => State.resolve(a + 1))
+     * ); // State({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, S, A, B>(key: K, f: (a: A) => State<S, B>) => (data: State<S, A>) => State<S, A & { [P in K]: B; }>;
 }
 
 /**
@@ -2508,6 +2593,27 @@ declare namespace TaskMaybe {
      * ```
      */
     const toTaskResult: <E>(onNone: () => E) => <A>(data: TaskMaybe<A>) => TaskResult<E, A>;
+    /**
+     * Lifts a TaskMaybe value into an accumulator object.
+     *
+     * @example
+     * ```ts
+     * pipe(TaskMaybe.some(42), TaskMaybe.bindTo("value")); // TaskMaybe({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <A>(data: TaskMaybe<A>) => TaskMaybe<{ [P in K]: A; }>;
+    /**
+     * Evaluates a new TaskMaybe using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   TaskMaybe.some({ a: 1 }),
+     *   TaskMaybe.bind("b", ({ a }) => TaskMaybe.some(a + 1))
+     * ); // TaskMaybe({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, A, B>(key: K, f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<A & { [P in K]: B; }>;
 }
 
 type Passed<A> = WithKind<"Passed"> & WithValue<A>;

package/dist/core.d.ts

@@ -1,5 +1,5 @@
-import { M as Maybe, W as WithValue, c as WithLog, D as Deferred, R as Result, d as WithKind, e as WithError, f as RetryOptions, g as TimeoutOptions, h as WithTimeout, i as WithMinInterval, j as WithCooldown, k as WithConcurrency, l as WithSize, m as WithDuration, n as WithN, T as Task, o as WithErrors, p as WithFirst, q as WithSecond } from './Task-zAY4kSVB.js';
-export { E as Equality, a as Err, N as None, O as Ok, b as Ordering, S as Some } from './Task-zAY4kSVB.js';
+import { M as Maybe, q as WithValue, k as WithLog, D as Deferred, R as Result, j as WithKind, g as WithError, c as RetryOptions, d as TimeoutOptions, p as WithTimeout, l as WithMinInterval, e as WithCooldown, W as WithConcurrency, o as WithSize, f as WithDuration, m as WithN, T as Task, h as WithErrors, i as WithFirst, n as WithSecond } from './Task-DIgwvoIb.js';
+export { E as Equality, a as Err, N as None, O as Ok, b as Ordering, S as Some } from './Task-DIgwvoIb.js';
 import { Duration, NonEmptyList } from './types.js';
 
 /**
@@ -561,6 +561,27 @@ declare namespace Logged {
      * ```
      */
     const run: <W, A>(data: Logged<W, A>) => readonly [A, ReadonlyArray<W>];
+    /**
+     * Lifts a Logged value into an accumulator object.
+     *
+     * @example
+     * ```ts
+     * pipe(Logged.make<string, number>(42), Logged.bindTo("value")); // Logged({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <W, A>(data: Logged<W, A>) => Logged<W, { [P in K]: A; }>;
+    /**
+     * Evaluates a new Logged using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Logged.make<string, { a: number }>({ a: 1 }),
+     *   Logged.bind("b", ({ a }) => Logged.make<string, number>(a + 1))
+     * ); // Logged({ value: { a: 1, b: 2 } })
+     * ```
+     */
+    const bind: <K extends string, W, A, B>(key: K, f: (a: A) => Logged<W, B>) => (data: Logged<W, A>) => Logged<W, A & { [P in K]: B; }>;
 }
 
 type MaybeRetry<E, O> = O extends {
@@ -1091,18 +1112,18 @@ declare namespace Op {
     }) => (outcome: Outcome<E, A>) => B;
     /**
      * Eliminates an Outcome with positional handlers.
-     * Order: `onErr`, `onOk`, `onNil` — mirrors `Result.fold` for the first two.
+     * Order: `onErr`, `onNil`, `onOk` — mirrors `Result.fold` for the first and last cases.
      *
      * @example
      * ```ts
      * Op.fold(
      *   (e) => `error: ${e.message}`,
-     *   (v) => `value: ${v}`,
      *   ()  => "nothing",
+     *   (v) => `value: ${v}`,
      * )(outcome);
      * ```
      */
-    const fold: <E, A, B>(onErr: (e: E) => B, onOk: (a: A) => B, onNil: () => B) => (outcome: Outcome<E, A>) => B;
+    const fold: <E, A, B>(onErr: (e: E) => B, onNil: () => B, onOk: (a: A) => B) => (outcome: Outcome<E, A>) => B;
     /**
      * Returns the success value, or the result of `defaultValue()` for `Err` or `Nil`.
      *
@@ -1715,6 +1736,27 @@ declare namespace Reader {
      * ```
      */
     const run: <R>(env: R) => <A>(data: Reader<R, A>) => A;
+    /**
+     * Lifts a Reader value into an accumulator object.
+     *
+     * @example
+     * ```ts
+     * pipe(Reader.resolve(42), Reader.bindTo("value")); // Reader({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <R, A>(data: Reader<R, A>) => Reader<R, { [P in K]: A; }>;
+    /**
+     * Evaluates a new Reader using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   Reader.resolve({ a: 1 }),
+     *   Reader.bind("b", ({ a }) => Reader.resolve(a + 1))
+     * ); // Reader({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, R, A, B>(key: K, f: (a: A) => Reader<R, B>) => (data: Reader<R, A>) => Reader<R, A & { [P in K]: B; }>;
 }
 
 type NotAsked = WithKind<"NotAsked">;
@@ -1829,15 +1871,15 @@ declare namespace RemoteData {
      * pipe(
      *   userData,
      *   RemoteData.fold(
+     *     e => `Error: ${e}`,
      *     () => "Not asked",
      *     () => "Loading...",
-     *     e => `Error: ${e}`,
      *     value => `Got: ${value}`
      *   )
      * );
      * ```
      */
-    const fold: <E, A, B>(onNotAsked: () => B, onLoading: () => B, onFailure: (e: E) => B, onSuccess: (a: A) => B) => (data: RemoteData<E, A>) => B;
+    const fold: <E, A, B>(onFailure: (e: E) => B, onNotAsked: () => B, onLoading: () => B, onSuccess: (a: A) => B) => (data: RemoteData<E, A>) => B;
     /**
      * Pattern matches on a RemoteData, returning the result of the matching case.
      *
@@ -2092,6 +2134,28 @@ declare namespace TaskResult {
      * ```
      */
     const run: (signal?: AbortSignal) => <E, A>(task: TaskResult<E, A>) => Promise<Result<E, A>>;
+    /**
+     * Converts a TaskResult value into an object containing a single property.
+     * Initiates the pipeline accumulator record.
+     *
+     * @example
+     * ```ts
+     * pipe(TaskResult.ok(42), TaskResult.bindTo("value")); // TaskResult({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <E, A>(data: TaskResult<E, A>) => TaskResult<E, { [P in K]: A; }>;
+    /**
+     * Evaluates a new TaskResult using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   TaskResult.ok({ a: 1 }),
+     *   TaskResult.bind("b", ({ a }) => TaskResult.ok(a + 1))
+     * ); // TaskResult({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, E, A, B>(key: K, f: (a: A) => TaskResult<E, B>) => (data: TaskResult<E, A>) => TaskResult<E, A & { [P in K]: B; }>;
 }
 
 /**
@@ -2379,6 +2443,27 @@ declare namespace State {
      * ```
      */
     const execute: <S>(initialState: S) => <A>(st: State<S, A>) => S;
+    /**
+     * Lifts a State value into an accumulator object.
+     *
+     * @example
+     * ```ts
+     * pipe(State.resolve(42), State.bindTo("value")); // State({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <S, A>(data: State<S, A>) => State<S, { [P in K]: A; }>;
+    /**
+     * Evaluates a new State using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   State.resolve({ a: 1 }),
+     *   State.bind("b", ({ a }) => State.resolve(a + 1))
+     * ); // State({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, S, A, B>(key: K, f: (a: A) => State<S, B>) => (data: State<S, A>) => State<S, A & { [P in K]: B; }>;
 }
 
 /**
@@ -2508,6 +2593,27 @@ declare namespace TaskMaybe {
      * ```
      */
     const toTaskResult: <E>(onNone: () => E) => <A>(data: TaskMaybe<A>) => TaskResult<E, A>;
+    /**
+     * Lifts a TaskMaybe value into an accumulator object.
+     *
+     * @example
+     * ```ts
+     * pipe(TaskMaybe.some(42), TaskMaybe.bindTo("value")); // TaskMaybe({ value: 42 })
+     * ```
+     */
+    const bindTo: <K extends string>(key: K) => <A>(data: TaskMaybe<A>) => TaskMaybe<{ [P in K]: A; }>;
+    /**
+     * Evaluates a new TaskMaybe using the current accumulator and attaches the output to a new key.
+     *
+     * @example
+     * ```ts
+     * pipe(
+     *   TaskMaybe.some({ a: 1 }),
+     *   TaskMaybe.bind("b", ({ a }) => TaskMaybe.some(a + 1))
+     * ); // TaskMaybe({ a: 1, b: 2 })
+     * ```
+     */
+    const bind: <K extends string, A, B>(key: K, f: (a: A) => TaskMaybe<B>) => (data: TaskMaybe<A>) => TaskMaybe<A & { [P in K]: B; }>;
 }
 
 type Passed<A> = WithKind<"Passed"> & WithValue<A>;

package/dist/core.js

@@ -93,6 +93,10 @@ var Result;
   Result2.recoverUnless = (isBlocked, fallback) => (data) => (0, Result2.isErr)(data) && !isBlocked(data.error) ? fallback() : data;
   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;
+  Result2.bindTo = (key) => (data) => (0, Result2.map)((a) => ({ [key]: a }))(data);
+  Result2.bind = (key, f) => (data) => (0, Result2.chain)(
+    (a) => (0, Result2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Result || (Result = {}));
 
 // src/Core/Maybe.ts
@@ -123,6 +127,10 @@ var Maybe;
   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)();
+  Maybe2.bindTo = (key) => (data) => (0, Maybe2.map)((a) => ({ [key]: a }))(data);
+  Maybe2.bind = (key, f) => (data) => (0, Maybe2.chain)(
+    (a) => (0, Maybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Maybe || (Maybe = {}));
 
 // src/Core/Combinable.ts
@@ -230,6 +238,10 @@ var Logged;
     return data;
   };
   Logged2.run = (data) => [data.value, data.log];
+  Logged2.bindTo = (key) => (data) => (0, Logged2.map)((a) => ({ [key]: a }))(data);
+  Logged2.bind = (key, f) => (data) => (0, Logged2.chain)(
+    (a) => (0, Logged2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Logged || (Logged = {}));
 
 // src/Types/Brand.ts
@@ -1244,7 +1256,7 @@ var Op;
     }
     return cases.nil();
   };
-  Op2.fold = (onErr, onOk, onNil) => (outcome) => {
+  Op2.fold = (onErr, onNil, onOk) => (outcome) => {
     if (outcome.kind === "OpOk") {
       return onOk(outcome.value);
     }
@@ -1429,6 +1441,10 @@ var Reader;
   };
   Reader2.local = (f) => (data) => (env) => data(f(env));
   Reader2.run = (env) => (data) => data(env);
+  Reader2.bindTo = (key) => (data) => (0, Reader2.map)((a) => ({ [key]: a }))(data);
+  Reader2.bind = (key, f) => (data) => (0, Reader2.chain)(
+    (a) => (0, Reader2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Reader || (Reader = {}));
 
 // src/Core/Refinement.ts
@@ -1473,17 +1489,17 @@ var RemoteData;
     }
     return (0, RemoteData2.notAsked)();
   };
-  RemoteData2.fold = (onNotAsked, onLoading, onFailure, onSuccess) => (data) => {
+  RemoteData2.fold = (onFailure, onNotAsked, onLoading, onSuccess) => (data) => {
     switch (data.kind) {
+      case "Failure": {
+        return onFailure(data.error);
+      }
       case "NotAsked": {
         return onNotAsked();
       }
       case "Loading": {
         return onLoading();
       }
-      case "Failure": {
-        return onFailure(data.error);
-      }
       case "Success": {
         return onSuccess(data.value);
       }
@@ -1748,6 +1764,10 @@ var Task;
     return { task, abort };
   };
   Task2.run = (signal) => (task) => Deferred.toPromise(task(signal));
+  Task2.bindTo = (key) => (data) => (0, Task2.map)((a) => ({ [key]: a }))(data);
+  Task2.bind = (key, f) => (data) => (0, Task2.chain)(
+    (a) => (0, Task2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(Task || (Task = {}));
 
 // src/Core/Resource.ts
@@ -1825,6 +1845,10 @@ var State;
   State2.run = (initialState) => (st) => st(initialState);
   State2.evaluate = (initialState) => (st) => st(initialState)[0];
   State2.execute = (initialState) => (st) => st(initialState)[1];
+  State2.bindTo = (key) => (data) => (0, State2.map)((a) => ({ [key]: a }))(data);
+  State2.bind = (key, f) => (data) => (0, State2.chain)(
+    (a) => (0, State2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(State || (State = {}));
 
 // src/Core/TaskMaybe.ts
@@ -1850,6 +1874,10 @@ var TaskMaybe;
   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);
+  TaskMaybe2.bindTo = (key) => (data) => (0, TaskMaybe2.map)((a) => ({ [key]: a }))(data);
+  TaskMaybe2.bind = (key, f) => (data) => (0, TaskMaybe2.chain)(
+    (a) => (0, TaskMaybe2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(TaskMaybe || (TaskMaybe = {}));
 
 // src/Core/TaskResult.ts
@@ -1881,6 +1909,10 @@ var TaskResult;
     )
   );
   TaskResult2.run = (signal) => (task) => Deferred.toPromise(task(signal));
+  TaskResult2.bindTo = (key) => (data) => (0, TaskResult2.map)((a) => ({ [key]: a }))(data);
+  TaskResult2.bind = (key, f) => (data) => (0, TaskResult2.chain)(
+    (a) => (0, TaskResult2.map)((b) => ({ ...a, [key]: b }))(f(a))
+  )(data);
 })(TaskResult || (TaskResult = {}));
 
 // src/Core/Validation.ts

package/dist/core.mjs

@@ -19,13 +19,13 @@ import {
   These,
   Tuple,
   Validation
-} from "./chunk-5AWUAG7G.mjs";
+} from "./chunk-SHO53CQC.mjs";
 import {
   Deferred,
   Maybe,
   Result,
   Task
-} from "./chunk-DLBHVYII.mjs";
+} from "./chunk-PUMSVZB4.mjs";
 import "./chunk-VWVPHDZO.mjs";
 export {
   Combinable,

package/dist/index.d.mts

@@ -1,5 +1,5 @@
-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 { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, defaultTo, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, uncurry, uncurry3, uncurry4 } from './composition.mjs';
 export { Combinable, Failed, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Passed, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, TaskMaybe, TaskResult, TaskValidation, These, TheseBoth, TheseFirst, TheseSecond, Tuple, Validation } from './core.mjs';
-export { D as Deferred, E as Equality, a as Err, M as Maybe, N as None, O as Ok, b as Ordering, R as Result, S as Some, T as Task } from './Task-DXsuurnc.mjs';
+export { D as Deferred, E as Equality, a as Err, M as Maybe, N as None, O as Ok, b as Ordering, R as Result, S as Some, T as Task } from './Task-fn1n--6H.mjs';
 export { Brand, Duration, NonEmptyList, isNonEmptyList } from './types.mjs';
 export { Arr, Dict, Num, Rec, Str, Uniq } from './utils.mjs';

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-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 { and, compose, constFalse, constNull, constTrue, constUndefined, constVoid, constant, converge, curry, curry3, curry4, defaultTo, flip, flow, identity, juxt, memoize, memoizeWeak, not, on, once, or, pipe, tap, uncurry, uncurry3, uncurry4 } from './composition.js';
 export { Combinable, Failed, Failure, Lazy, Lens, Loading, Logged, NotAsked, Op, Optional, Passed, Predicate, Reader, Refinement, RemoteData, Resource, State, Success, TaskMaybe, TaskResult, TaskValidation, These, TheseBoth, TheseFirst, TheseSecond, Tuple, Validation } from './core.js';
-export { D as Deferred, E as Equality, a as Err, M as Maybe, N as None, O as Ok, b as Ordering, R as Result, S as Some, T as Task } from './Task-zAY4kSVB.js';
+export { D as Deferred, E as Equality, a as Err, M as Maybe, N as None, O as Ok, b as Ordering, R as Result, S as Some, T as Task } from './Task-DIgwvoIb.js';
 export { Brand, Duration, NonEmptyList, isNonEmptyList } from './types.js';
 export { Arr, Dict, Num, Rec, Str, Uniq } from './utils.js';