unthrown 0.2.0 → 1.0.0

package/dist/index.d.cts

@@ -1,4 +1,20 @@
 //#region src/types.d.ts
+/**
+ * Flatten an intersection into a single object literal so accumulated `bind` /
+ * `let` scopes display cleanly (`{ a; b }` rather than `{ a } & { b }`).
+ *
+ * @internal
+ */
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+/**
+ * The scope produced by a `bind` / `let` step: `T` with `K` added (as a readonly
+ * property of type `U`). `Omit<T, K>` first drops any existing `K`, so re-binding
+ * a name **overwrites** it — matching the runtime spread — rather than producing
+ * an unsound `T[K] & U` intersection.
+ *
+ * @internal
+ */
+type Bound<T, K extends string, U> = Prettify<Omit<T, K> & { readonly [P in K]: U }>;
 /**
  * The method surface every {@link Result} variant carries. Factored out so the
  * three variants ({@link OkView}, {@link ErrView}, {@link DefectView}) can each
@@ -39,6 +55,58 @@ type ResultMethods<T, E> = {
    * @param f - the side effect (its return value is ignored).
    */
   tap(f: (value: T) => void): Result$1<T, E>;
+  /**
+   * Run a **failable** side effect on the success value, keeping the original
+   * value but threading the effect's error.
+   *
+   * @remarks
+   * This is to {@link ResultMethods.tap | tap} what
+   * {@link ResultMethods.flatMap | flatMap} is to {@link ResultMethods.map | map}:
+   * `f` returns a `Result`, but its **success value is discarded** — on success
+   * the original value flows through (`Result<T, E | E2>`), while an `Err` (or
+   * `Defect`) from `f` short-circuits. Runs only on `Ok`; `Err` and `Defect` pass
+   * through. If `f` throws, the throw becomes a `Defect`. Use it for a validation
+   * or write whose _result_ matters but whose _value_ you don't need.
+   *
+   * @typeParam E2 - the error type the effect may introduce.
+   * @param f - the failable side effect; its `Ok` value is ignored.
+   */
+  flatTap<E2>(f: (value: T) => Result$1<unknown, E2>): Result$1<T, E | E2>;
+  /**
+   * Do-notation: run `f` for a `Result` and **bind its value** under `name` in
+   * an accumulating object scope.
+   *
+   * @remarks
+   * Begin a chain with {@link Do} (an empty object scope) and grow it step by
+   * step. `f` receives the scope accumulated so far and returns a `Result`; on
+   * `Ok` the value is added as `{ ...scope, [name]: value }`, on `Err`/`Defect`
+   * the chain short-circuits. Errors union (`E | E2`). A throw becomes a
+   * `Defect` — as does calling `bind` on a non-object scope (e.g. `Ok(5).bind`),
+   * which is misuse: the scope is always an object inside a real `Do()` chain.
+   * (`let` is the pure-value counterpart.)
+   *
+   * @typeParam K - the key the bound value is stored under.
+   * @typeParam U - the bound value type.
+   * @typeParam E2 - the error type `f` may introduce.
+   * @param name - the scope key.
+   * @param f - produces a `Result` from the accumulated scope.
+   */
+  bind<K extends string, U, E2>(name: K, f: (scope: T) => Result$1<U, E2>): Result$1<Bound<T, K, U>, E | E2>;
+  /**
+   * Do-notation: run `f` for a **plain value** and bind it under `name` in the
+   * accumulating object scope. The pure-value counterpart of {@link ResultMethods.bind | bind}.
+   *
+   * @remarks
+   * `f` receives the scope and returns a value (not a `Result`); it is added as
+   * `{ ...scope, [name]: value }`. Runs only on `Ok`; `Err`/`Defect` pass
+   * through. A throw becomes a `Defect`.
+   *
+   * @typeParam K - the key the value is stored under.
+   * @typeParam U - the value type.
+   * @param name - the scope key.
+   * @param f - computes a value from the accumulated scope.
+   */
+  let<K extends string, U>(name: K, f: (scope: T) => U): Result$1<Bound<T, K, U>, E>;
   /**
    * Replace the success value with a constant `value`.
    *
@@ -96,12 +164,12 @@ type ResultMethods<T, E> = {
    * @remarks
    * Runs `f` only when a `Defect` is present, re-entering the modeled world by
    * returning a `Result` (an `Ok` or a fresh `Err`). `Ok` and `Err` pass
-   * through. Recovering a defect should be rare: usually you let it bubble to
+   * through. Recovering a Defect should be rare: usually you let it bubble to
    * the edge. If `f` throws, the throw becomes a new `Defect`.
    *
    * @typeParam U - a success type the recovery may produce.
    * @typeParam E2 - an error type the recovery may produce.
-   * @param f - maps the defect's unknown cause to a recovering `Result`.
+   * @param f - maps the Defect's unknown cause to a recovering `Result`.
    */
   recoverDefect<U, E2>(f: (cause: unknown) => Result$1<U, E2>): Result$1<T | U, E | E2>;
   /**
@@ -115,9 +183,9 @@ type ResultMethods<T, E> = {
    * Exhaustively fold all three runtime states into a single value of type `R`.
    *
    * @remarks
-   * Exactly one handler runs. Together with the throw-to-defect guarantee, this
+   * Exactly one handler runs. Together with the throw-to-Defect guarantee, this
    * is typically the single place a pipeline is handled at the edge — mapping
-   * `ok`/`err`/`defect` to (for example) 2xx / 4xx / 5xx with no `try`/`catch`.
+   * `Ok`/`Err`/`Defect` to (for example) 2xx / 4xx / 5xx with no `try`/`catch`.
    * (For richer matching, a `Result` is also a discriminated union — branch on
    * its `tag` property, e.g. with `ts-pattern`.)
    *
@@ -135,7 +203,7 @@ type ResultMethods<T, E> = {
    * @returns the `Ok` value.
    * @throws On `Err`, an {@link UnwrapError} carrying the error. On a `Defect`,
    * re-throws the **original cause** with its original stack, so an unhandled
-   * defect surfaces at the global handler as the real failure.
+   * Defect surfaces at the global handler as the real failure.
    */
   unwrap(): T;
   /**
@@ -150,7 +218,7 @@ type ResultMethods<T, E> = {
    * The success value, or `fallback` on `Err`.
    *
    * @param fallback - returned when the result is an `Err`.
-   * @throws Re-throws on a `Defect` — a defect is a bug, not an absent value, so
+   * @throws Re-throws on a `Defect` — a Defect is a bug, not an absent value, so
    * it is never silently replaced.
    */
   unwrapOr(fallback: T): T;
@@ -203,7 +271,7 @@ type DefectView<T = never, E = never> = ResultMethods<T, E> & {
  *
  * - **`Ok`** — a success carrying a `value: T`.
  * - **`Err`** — a modeled, anticipated failure carrying an `error: E`.
- * - **`Defect`** — an *unmodeled* failure carrying an unknown `cause`. A defect
+ * - **`Defect`** — an *unmodeled* failure carrying an unknown `cause`. A Defect
  *   never appears in `E`; it is the library's third, out-of-band channel.
  *
  * Because it is a real union, you can match it natively (a `switch` on `tag`, or
@@ -217,10 +285,10 @@ type DefectView<T = never, E = never> = ResultMethods<T, E> & {
  *
  * @example
  * ```ts
- * import { ok, err, type Result } from "unthrown";
+ * import { Ok, Err, type Result } from "unthrown";
  *
  * function half(n: number): Result<number, "odd"> {
- *   return n % 2 === 0 ? ok(n / 2) : err("odd");
+ *   return n % 2 === 0 ? Ok(n / 2) : Err("odd");
  * }
  *
  * const message = half(10).match({
@@ -258,7 +326,8 @@ type Awaitable<T> = {
  * {@link fromPromise} forces. To do further async work, re-enter through a
  * qualified boundary and compose it: `ar.flatMap((v) => fromPromise(work(v),
  * qualify))`. The eliminators (`unwrap`, …) return promises; the binds
- * (`flatMap`, `orElse`, `recoverDefect`) additionally accept an `AsyncResult`.
+ * (`flatMap`, `flatTap`, `orElse`, `recoverDefect`) additionally accept an
+ * `AsyncResult`.
  *
  * To pattern-match an `AsyncResult`, `await` it first: `match(await ar)`.
  *
@@ -272,7 +341,19 @@ type AsyncResult<T, E> = Awaitable<Result$1<T, E>> & {
    * (never a raw `Promise`); a throw becomes a `Defect`.
    */
   flatMap<U, E2>(f: (value: T) => Result$1<U, E2> | AsyncResult<U, E2>): AsyncResult<U, E | E2>; /** Asynchronous `tap`. `f` is synchronous; a throw becomes a `Defect`. */
-  tap(f: (value: T) => void): AsyncResult<T, E>; /** Asynchronous `as`. */
+  tap(f: (value: T) => void): AsyncResult<T, E>;
+  /**
+   * Asynchronous `flatTap` — a failable tap that keeps the original value. `f`
+   * may return a `Result` **or** an `AsyncResult`; its `Ok` value is discarded,
+   * an `Err`/`Defect` short-circuits, and a throw becomes a `Defect`.
+   */
+  flatTap<E2>(f: (value: T) => Result$1<unknown, E2> | AsyncResult<unknown, E2>): AsyncResult<T, E | E2>;
+  /**
+   * Asynchronous `bind` (do-notation). `f` may return a `Result` **or** an
+   * `AsyncResult`; its value is bound under `name` in the accumulating scope.
+   */
+  bind<K extends string, U, E2>(name: K, f: (scope: T) => Result$1<U, E2> | AsyncResult<U, E2>): AsyncResult<Bound<T, K, U>, E | E2>; /** Asynchronous `let` (do-notation). `f` returns a plain value, bound under `name`. */
+  let<K extends string, U>(name: K, f: (scope: T) => U): AsyncResult<Bound<T, K, U>, E>; /** Asynchronous `as`. */
   as<U>(value: U): AsyncResult<U, E>; /** Asynchronous `mapErr`. `f` is synchronous; a throw becomes a `Defect`. */
   mapErr<E2>(f: (error: E) => E2): AsyncResult<T, E2>; /** Asynchronous `orElse`. `f` may return a `Result` or an `AsyncResult`. */
   orElse<U, E2>(f: (error: E) => Result$1<U, E2> | AsyncResult<U, E2>): AsyncResult<T | U, E2>; /** Asynchronous `recover`. `f` is synchronous; a throw becomes a `Defect`. */
@@ -332,11 +413,11 @@ type AsyncErrOf<R> = R extends AsyncResult<unknown, infer E> ? E : never;
  *
  * @example
  * ```ts
- * import { ok } from "unthrown";
- * ok(42).unwrap(); // 42
+ * import { Ok } from "unthrown";
+ * Ok(42).unwrap(); // 42
  * ```
  */
-declare function ok<T>(value: T): Result$1<T, never>;
+declare function Ok<T>(value: T): Result$1<T, never>;
 /**
  * Construct a failed {@link Result} carrying a **modeled** error.
  *
@@ -345,11 +426,11 @@ declare function ok<T>(value: T): Result$1<T, never>;
  *
  * @example
  * ```ts
- * import { err } from "unthrown";
- * err("not_found").unwrapErr(); // "not_found"
+ * import { Err } from "unthrown";
+ * Err("not_found").unwrapErr(); // "not_found"
  * ```
  */
-declare function err<E>(error: E): Result$1<never, E>;
+declare function Err<E>(error: E): Result$1<never, E>;
 /**
  * Type guard: narrow a {@link Result} to its `Ok` variant, exposing `.value`.
  *
@@ -405,7 +486,7 @@ declare const DEFECT: unique symbol;
  * @remarks
  * `qualify` (passed to {@link fromPromise} / {@link fromThrowable}) returns
  * `E | Defect`: either a modeled domain error, or a `Defect` produced by
- * {@link defect} to say "this failure is not modeled". A `Defect` is opaque —
+ * {@link Defect} to say "this failure is not modeled". A `Defect` is opaque —
  * it carries the original cause for the boundary to convert into the third
  * runtime state of a `Result`.
  */
@@ -418,18 +499,43 @@ type Defect = {
  * function when a failure is **not** a modeled domain error.
  *
  * @param cause - the original thrown/rejected value.
- * @returns an opaque defect marker carrying `cause`.
+ * @returns an opaque Defect marker carrying `cause`.
  *
  * @example
  * ```ts
- * import { fromPromise, defect } from "unthrown";
+ * import { fromPromise, Defect } from "unthrown";
  *
  * const user = fromPromise(fetchUser(id), (cause) =>
- *   cause instanceof NotFoundError ? cause : defect(cause),
+ *   cause instanceof NotFoundError ? cause : Defect(cause),
  * );
  * ```
  */
-declare function defect(cause: unknown): Defect;
+declare function Defect(cause: unknown): Defect;
+//#endregion
+//#region src/do.d.ts
+/**
+ * Start a do-notation chain with an empty object scope, grown step by step with
+ * `bind` (for `Result`-returning steps) and `let` (for pure values).
+ *
+ * @remarks
+ * Capitalised because `do` is a reserved word. Each step receives the scope
+ * accumulated so far; the error types union across `bind`s, and a throw in any
+ * step becomes a `Defect`. To go asynchronous, lift the chain with `toAsync()`
+ * (then a `bind` may return an `AsyncResult`).
+ *
+ * @example
+ * ```ts
+ * import { Do, Ok } from "unthrown";
+ *
+ * const result = Do()
+ *   .bind("user", () => findUser(id)) // Result<User, NotFound>
+ *   .bind("org", ({ user }) => findOrg(user.orgId)) // Result<Org, NotFound>
+ *   .let("label", ({ user, org }) => `${user.name} @ ${org.name}`)
+ *   .map(({ user, org, label }) => render(user, org, label));
+ * // Result<View, NotFound>
+ * ```
+ */
+declare function Do(): Result$1<{}, never>;
 //#endregion
 //#region src/interop.d.ts
 /**
@@ -437,7 +543,7 @@ declare function defect(cause: unknown): Defect;
  * `Err`. The sanctioned alternative to an `Option` type.
  *
  * @remarks
- * `null` and `undefined` map to `err(onAbsent())`; any other value (including
+ * `null` and `undefined` map to `Err(onAbsent())`; any other value (including
  * falsy ones like `0`, `""`, `false`) maps to `Ok`.
  *
  * @typeParam T - the (nullable) value type.
@@ -458,14 +564,14 @@ declare function fromNullable<T, E>(value: T | null | undefined, onAbsent: () =>
  *
  * @remarks
  * `qualify` **must** triage every thrown cause into a modeled error `E` or a
- * {@link Defect} (via {@link defect}) — there is no path that leaves `unknown`
+ * {@link Defect} (via {@link Defect}) — there is no path that leaves `unknown`
  * in `E`. A throw inside `qualify` itself is treated as a `Defect`.
  *
  * The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of
  * `qualify`'s return is **subtracted** from `E`, never inferred into it. So a
- * `qualify` that returns *only* `defect(cause)` yields `E = never` (a defect is
+ * `qualify` that returns *only* `Defect(cause)` yields `E = never` (a Defect is
  * out-of-band and must not pollute the error channel); reach for
- * {@link fromSafePromise} when every failure is a defect.
+ * {@link fromSafePromise} when every failure is a Defect.
  *
  * @typeParam A - the wrapped function's argument tuple.
  * @typeParam T - the wrapped function's return type.
@@ -477,8 +583,8 @@ declare function fromNullable<T, E>(value: T | null | undefined, onAbsent: () =>
  *
  * @example
  * ```ts
- * import { fromThrowable, defect } from "unthrown";
- * const parse = fromThrowable(JSON.parse, (cause) => defect(cause));
+ * import { fromThrowable, Defect } from "unthrown";
+ * const parse = fromThrowable(JSON.parse, (cause) => Defect(cause));
  * parse("{}").unwrap();
  * ```
  */
@@ -495,8 +601,8 @@ declare function fromThrowable<A extends unknown[], T, R>(fn: (...args: A) => T,
  *
  * The modeled error type is `Exclude<R, Defect>` — the `Defect` arm of
  * `qualify`'s return is **subtracted** from `E`, never inferred into it. So a
- * `qualify` that returns *only* `defect(cause)` yields `E = never`; when every
- * rejection is a defect, prefer {@link fromSafePromise}.
+ * `qualify` that returns *only* `Defect(cause)` yields `E = never`; when every
+ * rejection is a Defect, prefer {@link fromSafePromise}.
  *
  * @typeParam T - the resolved value type.
  * @typeParam R - `qualify`'s return type; the modeled error `E` is
@@ -506,9 +612,9 @@ declare function fromThrowable<A extends unknown[], T, R>(fn: (...args: A) => T,
  *
  * @example
  * ```ts
- * import { fromPromise, defect } from "unthrown";
+ * import { fromPromise, Defect } from "unthrown";
  * const user = await fromPromise(fetchUser(id), (cause) =>
- *   cause instanceof NotFoundError ? ("not_found" as const) : defect(cause),
+ *   cause instanceof NotFoundError ? ("not_found" as const) : Defect(cause),
  * );
  * ```
  */
@@ -544,81 +650,115 @@ declare function fromSafePromise<T>(promise: Promise<T> | (() => Promise<T>)): A
  * @internal
  */
 type AllOk<Rs extends readonly unknown[], Ts extends readonly unknown[]> = number extends Rs["length"] ? Ts[number][] : Ts;
+/** A record of `Result`s — the input to {@link allFromDict}. */
+type ResultRecord = Record<string, Result$1<unknown, unknown>>;
+/** A record of `AsyncResult`s — the input to {@link allFromDictAsync}. */
+type AsyncResultRecord = Record<string, AsyncResult<unknown, unknown>>;
 /**
- * Collect {@link Result}s into a single `Result` of all their success values.
+ * Collect a tuple/array of {@link Result}s into a single `Result` of all their
+ * success values.
  *
  * @remarks
  * Short-circuits on the **first** `Err` (later entries are not inspected for
  * their error); any `Defect` present **dominates**, winning even over an earlier
- * `Err`. A **fixed tuple** keeps its positional types — `all([ok(1), ok("a")])`
+ * `Err`. A **fixed tuple** keeps its positional types — `all([Ok(1), Ok("a")])`
  * is `Result<[number, string], …>` — while a **dynamic array** `Result<T, E>[]`
- * collapses to `Result<T[], E>` with no cast.
- *
- * @typeParam Rs - the tuple/array of input `Result` types.
- * @param results - the results to combine.
+ * collapses to `Result<T[], E>` with no cast. For a **record** keyed by name,
+ * use {@link allFromDict}.
  *
  * @example
  * ```ts
- * import { all, ok } from "unthrown";
- * all([ok(1), ok("a"), ok(true)]).unwrap(); // [1, "a", true] (typed [number, string, boolean])
- * all([ok(1), ok(2)] as Result<number, never>[]).unwrap(); // number[]
+ * import { all, Ok } from "unthrown";
+ * all([Ok(1), Ok("a"), Ok(true)]).unwrap(); // [1, "a", true] (typed [number, string, boolean])
+ * all([Ok(1), Ok(2)] as Result<number, never>[]).unwrap(); // number[]
  * ```
  */
 declare function all<Rs extends readonly Result$1<unknown, unknown>[]>(results: readonly [...Rs]): Result$1<AllOk<Rs, { [K in keyof Rs]: OkOf<Rs[K]> }>, ErrOf<Rs[number]>>;
 /**
- * The asynchronous counterpart of {@link all}: combine {@link AsyncResult}s into
- * one `AsyncResult` of all their success values.
+ * Collect a **record** of {@link Result}s into a single `Result` of a record of
+ * their success values — `allFromDict({ a: Result<A, E>, b: Result<B, E> })` is
+ * `Result<{ a: A; b: B }, E>`. The named counterpart of {@link all}, for
+ * parallel work you'd rather not tuple.
  *
  * @remarks
- * The inputs are resolved **concurrently** (their order is preserved); the
- * resolved `Result`s are then folded with the same rules as {@link all} —
- * first `Err` short-circuits, any `Defect` dominates. As ever, the returned
- * `AsyncResult`'s internal promise never rejects. A **fixed tuple** keeps its
- * positional types; a **dynamic array** `AsyncResult<T, E>[]` collapses to
- * `AsyncResult<T[], E>`.
+ * Same folding rules as {@link all}: first `Err` short-circuits, any `Defect`
+ * dominates. This is **not** error accumulation.
+ *
+ * @example
+ * ```ts
+ * import { allFromDict, Ok } from "unthrown";
+ * allFromDict({ id: Ok(1), name: Ok("ada") }).unwrap(); // { id: 1, name: "ada" }
+ * ```
+ */
+declare function allFromDict<R extends ResultRecord>(results: R): Result$1<{ [K in keyof R]: OkOf<R[K]> }, ErrOf<R[keyof R]>>;
+/**
+ * The asynchronous counterpart of {@link all}: combine a tuple/array of
+ * {@link AsyncResult}s into one `AsyncResult` of all their success values.
  *
- * @typeParam Rs - the tuple/array of input `AsyncResult` types.
- * @param results - the async results to combine.
+ * @remarks
+ * The inputs are resolved **concurrently** (order preserved); the resolved
+ * `Result`s are then folded with the same rules as {@link all} — first `Err`
+ * short-circuits, any `Defect` dominates. As ever, the returned `AsyncResult`'s
+ * internal promise never rejects. For a **record**, use {@link allFromDictAsync}.
  *
  * @example
  * ```ts
  * import { allAsync, fromSafePromise } from "unthrown";
- * const both = await allAsync([fromSafePromise(a()), fromSafePromise(b())]);
+ * await allAsync([fromSafePromise(a()), fromSafePromise(b())]);
  * ```
  */
 declare function allAsync<Rs extends readonly AsyncResult<unknown, unknown>[]>(results: readonly [...Rs]): AsyncResult<AllOk<Rs, { [K in keyof Rs]: AsyncOkOf<Rs[K]> }>, AsyncErrOf<Rs[number]>>;
+/**
+ * The asynchronous counterpart of {@link allFromDict}: combine a record of
+ * {@link AsyncResult}s into one `AsyncResult` of a record of their values.
+ *
+ * @remarks
+ * Resolved concurrently (order preserved), folded with the {@link all} rules,
+ * and the internal promise never rejects.
+ *
+ * @example
+ * ```ts
+ * import { allFromDictAsync, fromSafePromise } from "unthrown";
+ * await allFromDictAsync({ a: fromSafePromise(a()), b: fromSafePromise(b()) });
+ * ```
+ */
+declare function allFromDictAsync<R extends AsyncResultRecord>(results: R): AsyncResult<{ [K in keyof R]: AsyncOkOf<R[K]> }, AsyncErrOf<R[keyof R]>>;
 //#endregion
 //#region src/facade.d.ts
 /**
  * Companion object grouping the standalone entry points under a single,
- * discoverable namespace: {@link Result.ok}, {@link Result.err},
- * {@link Result.defect}, {@link Result.fromNullable}, {@link Result.fromThrowable},
+ * discoverable namespace: {@link Result.Ok}, {@link Result.Err},
+ * {@link Result.Defect}, {@link Result.fromNullable}, {@link Result.fromThrowable},
  * {@link Result.fromPromise}, {@link Result.fromSafePromise}, {@link Result.all},
- * {@link Result.allAsync}, {@link Result.isOk}, {@link Result.isErr},
+ * {@link Result.allAsync}, {@link Result.allFromDict},
+ * {@link Result.allFromDictAsync}, {@link Result.isOk}, {@link Result.isErr},
  * {@link Result.isDefect}.
  *
  * @remarks
  * Purely additive sugar — each member **is** the corresponding free function.
  * The free functions remain the primary, tree-shakeable API; importing only
- * `{ ok }` never pulls this object in. The value `Result` and the type
+ * `{ Ok }` never pulls this object in. The value `Result` and the type
  * {@link Result} share one name (the companion-object pattern).
  *
  * @example
  * ```ts
  * import { Result } from "unthrown";
- * Result.ok(1).flatMap((n) => Result.ok(n + 1)).unwrap(); // 2
+ * Result.Ok(1).flatMap((n) => Result.Ok(n + 1)).unwrap(); // 2
  * ```
  */
 declare const Result: {
-  readonly ok: typeof ok;
-  readonly err: typeof err;
-  readonly defect: typeof defect;
+  readonly Ok: typeof Ok;
+  readonly Err: typeof Err;
+  readonly Defect: typeof Defect;
+  readonly Do: typeof Do;
   readonly fromNullable: typeof fromNullable;
   readonly fromThrowable: typeof fromThrowable;
   readonly fromPromise: typeof fromPromise;
   readonly fromSafePromise: typeof fromSafePromise;
   readonly all: typeof all;
   readonly allAsync: typeof allAsync;
+  readonly allFromDict: typeof allFromDict;
+  readonly allFromDictAsync: typeof allFromDictAsync;
   readonly isOk: typeof isOk;
   readonly isErr: typeof isErr;
   readonly isDefect: typeof isDefect;
@@ -747,5 +887,5 @@ declare function matchTags<T, E extends {
   _tag: string;
 }, R>(result: AsyncResult<T, E>, handlers: TagHandlers<T, E, R>): Promise<R>;
 //#endregion
-export { type AsyncErrOf, type AsyncOkOf, type AsyncResult, type Awaitable, type Defect, type DefectView, type ErrOf, type ErrView, type OkOf, type OkView, Result, type TagHandlers, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, UnwrapError, all, allAsync, defect, err, fromNullable, fromPromise, fromSafePromise, fromThrowable, isDefect, isErr, isOk, matchTags, ok };
+export { type AsyncErrOf, type AsyncOkOf, type AsyncResult, type Awaitable, Defect, type DefectView, Do, Err, type ErrOf, type ErrView, Ok, type OkOf, type OkView, Result, type TagHandlers, TaggedError, type TaggedErrorConstructor, type TaggedErrorInstance, UnwrapError, all, allAsync, allFromDict, allFromDictAsync, fromNullable, fromPromise, fromSafePromise, fromThrowable, isDefect, isErr, isOk, matchTags };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/constructors.ts","../src/core.ts","../src/defect.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/types.ts","../src/constructors.ts","../src/core.ts","../src/defect.ts","../src/do.ts","../src/interop.ts","../src/facade.ts","../src/tagged.ts"],"mappings":"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"}