retuple 1.0.0-next.3 → 1.0.0-next.30

package/dist/index.d.cts

@@ -1,12 +1,14 @@
-export type nonNullable = typeof nonNullable;
-export type truthy = typeof truthy;
-export type safe = typeof safe;
-export type safeAsync = typeof safeAsync;
-export type safePromise = typeof safePromise;
-export type Ok<T> = OkTuple<T> & Retuple<T, never>;
-export type Err<E> = ErrTuple<E> & Retuple<never, E>;
+import { type ResultLike } from "retuple-symbols";
+declare const RetupleStackSymbol: unique symbol;
+export type Ok = typeof Ok;
+export type Err = typeof Err;
 export type Result<T, E> = (OkTuple<T> | ErrTuple<E>) & Retuple<T, E>;
-export { type ResultAsync };
+export { type ResultAsync, type ResultRetry };
+export interface ResultRetryController<E> {
+    error: E;
+    attempt: number;
+    abort: () => void;
+}
 /**
  * ## Retuple Unwrap Failed
  *
@@ -28,13 +30,44 @@ export declare class RetupleUnwrapErrFailed<const T = unknown> extends Error {
 /**
  * ## Retuple Expect Failed
  *
- * An error which occurs when calling `$expect` on `Err`, and when the value
+ * An error which occurs when calling `$expect` on `Err`, when the value
  * contained in the `Err` is not an instance of `Error`.
  */
 export declare class RetupleExpectFailed<const E = unknown> extends Error {
     value: E;
     constructor(value: E);
 }
+/**
+ * ## Retuple Assert Failed
+ *
+ * This error is used as the error type of a `Result` when using $assert,
+ * when no map error function is provided.
+ */
+export declare class RetupleAssertFailed<const T = unknown> extends Error {
+    value: T;
+    constructor(value: T);
+}
+/**
+ * ## Retuple Filter Failed
+ *
+ * This error is used as the error type of a `Result` when using $filter,
+ * when no map error function is provided.
+ */
+export declare class RetupleFilterFailed<const T = unknown> extends Error {
+    value: T;
+    constructor(value: T);
+}
+/**
+ * ## Retuple Index Failed
+ *
+ * This error is used as the error type of a `Result` when using $atIndex or
+ * $firstIndex, when no map error function is provided.
+ */
+export declare class RetupleIndexFailed<const T = unknown> extends Error {
+    index: number;
+    value: T;
+    constructor(index: number, value: T);
+}
 /**
  * ## Retuple Thrown Value Error
  *
@@ -42,80 +75,126 @@ export declare class RetupleExpectFailed<const E = unknown> extends Error {
  * thrown error or rejected value is not an instance of `Error`, and when no
  * map error function is provided.
  */
-export declare class RetupleThrownValueError extends Error {
+export declare class RetupleCaughtValueError extends Error {
     value: unknown;
     constructor(value: unknown);
 }
 /**
- * ## Retuple Invalid Result Error
+ * ## Retuple Invalid Union Error
  *
- * An error constructed when a safe function call throws or rejects, when the
- * thrown error or rejected value is not an instance of `Error`, and when no
- * map error function is provided.
+ * This error is thrown when attempting to construct a `Result` from a
+ * discriminated union, when the 'success' property is not boolean. In this
+ * case, it is impossible to determine whether the result should be `Ok` or
+ * `Err`.
  */
-export declare class RetupleInvalidResultError extends Error {
-    value: unknown[];
-    constructor(value: unknown[]);
+export declare class RetupleInvalidUnionError extends Error {
+    value: unknown;
+    constructor(value: unknown);
 }
 /**
  * ## Result
  *
  * @TODO
  */
-export declare function Result<R extends [err: null | undefined, value: unknown] | [err: unknown, value: null | undefined]>(resultLike: R): (R extends [null | undefined, infer T] ? Ok<T> : R extends [infer E, null | undefined] ? Err<E> : never) extends Ok<infer T> | Err<infer E> ? Result<T, NonNullable<E>> : never;
+export declare function Result<T, E>(resultLike: ResultLike<T, E>): Result<T, E>;
 export declare namespace Result {
     var Ok: typeof import(".").Ok;
     var Err: typeof import(".").Err;
-    var nonNullable: typeof import(".").nonNullable;
-    var truthy: typeof import(".").truthy;
-    var safe: typeof import(".").safe;
-    var safeAsync: typeof import(".").safeAsync;
-    var safePromise: typeof import(".").safePromise;
+    var $from: <T, E>(result: ResultLike<T, E>) => Result<T, E>;
+    var $resolve: <T, E>(result: ResultLikeAwaitable<T, E>) => ResultAsync<T, E>;
+    var $nonNullable: {
+        <const T>(value: T): Result<NonNullable<T>, true>;
+        <const T, E>(value: T, error: () => E): Result<NonNullable<T>, E>;
+    };
+    var $truthy: {
+        <const T>(value: T): Result<Truthy<T>, true>;
+        <const T, E>(value: T, error: () => E): Result<Truthy<T>, E>;
+    };
+    var $fromUnion: <U extends ObjectUnionOk<any> | ObjectUnionErr<any>>(union: U) => Result<U extends ObjectUnionOk<infer T> ? T : never, U extends ObjectUnionErr<infer E> ? E : never>;
+    var $safe: {
+        <T>(f: () => Awaited<T>): Result<T, Error>;
+        <T, E>(f: () => Awaited<T>, mapError: (err: unknown) => E): Result<T, E>;
+    };
+    var $safeAsync: {
+        <T>(f: () => T | PromiseLike<T>): ResultAsync<T, Error>;
+        <T, E>(f: () => T | PromiseLike<T>, mapError: (err: unknown) => E): ResultAsync<T, E>;
+    };
+    var $safePromise: {
+        <T>(promise: PromiseLike<T>): ResultAsync<T, Error>;
+        <T, E>(promise: PromiseLike<T>, mapError: (err: unknown) => E): ResultAsync<T, E>;
+    };
+    var $retry: <T, E>(f: () => ResultLike<T, E> | PromiseLike<ResultLike<T, E>>) => ResultRetry<T, E>;
+    var $safeRetry: {
+        <T>(f: () => T | PromiseLike<T>): ResultRetry<T, Error>;
+        <T, E>(f: () => T | PromiseLike<T>, mapError: (err: unknown) => E): ResultRetry<T, E>;
+    };
+    var $all: <const TResults extends ResultLike<any, any>[]>(results: TResults) => Result<AllOk<TResults>, AllErr<TResults>>;
+    var $allPromised: <const TResults extends ResultLikeAwaitable<any, any>[]>(results: TResults) => ResultAsync<AllOk<TResults>, AllErr<TResults>>;
+    var $any: <const TResults extends ResultLike<any, any>[]>(results: TResults) => Result<AnyOk<TResults>, AnyErr<TResults>>;
+    var $anyPromised: <const TResults extends ResultLikeAwaitable<any, any>[]>(results: TResults) => ResultAsync<AnyOk<TResults>, AnyErr<TResults>>;
+    var $collect: <TResults extends Record<string, ResultLike<any, any>>>(results: TResults) => Result<CollectOk<TResults>, CollectErr<TResults>>;
+    var $collectPromised: <TResults extends Record<string, ResultLikeAwaitable<any, any>>>(results: TResults) => ResultAsync<CollectOk<TResults>, CollectErr<TResults>>;
+    var $pipe: {
+        <T0, E0, T1, E1>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>): Result<T1, E0 | E1>;
+        <T0, E0, T1, E1, T2, E2>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>): Result<T2, E0 | E1 | E2>;
+        <T0, E0, T1, E1, T2, E2, T3, E3>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>): Result<T3, E0 | E1 | E2 | E3>;
+        <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>): Result<T4, E0 | E1 | E2 | E3 | E4>;
+        <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>): Result<T5, E0 | E1 | E2 | E3 | E4 | E5>;
+        <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>, f6: (val5: T5) => ResultLike<T6, E6>): Result<T6, E0 | E1 | E2 | E3 | E4 | E5 | E6>;
+        <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6, T7, E7>(f0: () => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>, f6: (val5: T5) => ResultLike<T6, E6>, f7: (val6: T6) => ResultLike<T7, E7>): Result<T7, E0 | E1 | E2 | E3 | E4 | E5 | E6 | E7>;
+    };
+    var $pipeAsync: {
+        <T0, E0, T1, E1>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>): ResultAsync<T1, E0 | E1>;
+        <T0, E0, T1, E1, T2, E2>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>): ResultAsync<T2, E0 | E1 | E2>;
+        <T0, E0, T1, E1, T2, E2, T3, E3>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>): ResultAsync<T3, E0 | E1 | E2 | E3>;
+        <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>): ResultAsync<T4, E0 | E1 | E2 | E3 | E4>;
+        <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>): ResultAsync<T5, E0 | E1 | E2 | E3 | E4 | E5>;
+        <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>): ResultAsync<T6, E0 | E1 | E2 | E3 | E4 | E5 | E6>;
+        <T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6, T7, E7>(f0: () => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>, f7: (val6: T6) => ResultLikeAwaitable<T7, E7>): ResultAsync<T7, E0 | E1 | E2 | E3 | E4 | E5 | E6 | E7>;
+    };
 }
 /**
- * ## Ok
+ * Create a new {@link Result} with the `Ok` variant. When called without
+ * arguments the `T` type is `void`.
  *
- * @TODO
- */
-export declare function Ok(): Ok<void>;
-export declare function Ok<const T>(val: T): Ok<T>;
-/**
- * ## Err
+ * @example
  *
- * @TODO
- */
-export declare function Err(): Err<void>;
-export declare function Err<const E>(err: E): Err<E>;
-/**
- * Construct a {@link Result} from a value. If the value is neither null or
- * undefined, the result is `Ok`.
- */
-export declare function nonNullable<const T>(value: T): Result<NonNullable<T>, true>;
-export declare function nonNullable<const T, const E>(value: T, error: () => E): Result<NonNullable<T>, E>;
-/**
- * Construct a {@link Result} from a value. If the value is truthy, the result
- * is `Ok`.
- */
-export declare function truthy<const T>(value: T): Result<Truthy<T>, true>;
-export declare function truthy<const T, const E>(value: T, error: () => E): Result<Truthy<T>, E>;
-/**
- * Construct a {@link Result} from a synchronous function call. If the function
- * returns without throwing, the result is `Ok`.
- */
-export declare function safe<T>(f: () => Awaited<T>): Result<T, Error>;
-export declare function safe<T, E>(f: () => Awaited<T>, mapError: (err: unknown) => E): Result<T, E>;
-/**
- * Construct a {@link ResultAsync} from a function call. If the function returns
- * without throwing, and any promise returned resolves, the result is `Ok`.
+ * ```ts
+ * const [err, value] = Ok("test");
+ *
+ * assert.equal(err, undefined);
+ * assert.equal(value, "test");
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const result: Result<void, never> = Ok();
+ * ```
  */
-export declare function safeAsync<T>(f: () => T | PromiseLike<T>): ResultAsync<T, Error>;
-export declare function safeAsync<T, E>(f: () => T | PromiseLike<T>, mapError: (err: unknown) => E): ResultAsync<T, E>;
+export declare function Ok(): Result<void, never>;
+export declare function Ok<const T>(val: T): Result<T, never>;
 /**
- * Construct a {@link Result} from a promise. If the promise resolves, the
- * result is `Ok`.
+ * Create a new {@link Result} with the `Err` variant. When called without
+ * arguments the `E` type is `void`.
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = Err("test");
+ *
+ * assert.equal(err, "test");
+ * assert.equal(value, undefined);
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const result: Result<never, void> = Err();
+ * ```
  */
-export declare function safePromise<T>(promise: PromiseLike<T>): ResultAsync<T, Error>;
-export declare function safePromise<T, E>(promise: PromiseLike<T>, mapError: (err: unknown) => E): ResultAsync<T, E>;
+export declare function Err(): Result<never, void>;
+export declare function Err<const E>(err: E): Result<never, E>;
 /**
  * ## ResultAsync
  *
@@ -126,367 +205,1429 @@ declare class ResultAsync<T, E> {
     constructor(inner: PromiseLike<Result<T, E>>);
     then<U = Result<T, E>, F = never>(onfulfilled?: ((value: Result<T, E>) => U | PromiseLike<U>) | null | undefined, onrejected?: ((reason: any) => F | PromiseLike<F>) | null | undefined): PromiseLike<U | F>;
     /**
-     * @TODO
-     */
-    $value(this: ResultAsync<T, E>): Promise<T | E>;
-    /**
-     * @TODO
+     * The same as {@link Retuple.$expect|$expect}, except it returns a `Promise`.
      */
     $expect(this: ResultAsync<T, Error>): Promise<T>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$unwrap|$unwrap}, except it returns a `Promise`.
      */
     $unwrap(this: ResultAsync<T, E>, msg?: string): Promise<T>;
     /**
-     * @TODO
-     */
-    $unwrapErr(this: ResultAsync<T, E>, msg?: string): Promise<E>;
-    /**
-     * @TODO
-     */
-    $unwrapOr<U>(this: ResultAsync<T, E>, def: U): Promise<T | U>;
-    /**
-     * @TODO
-     */
-    $unwrapOrElse<U>(this: ResultAsync<T, E>, f: () => U): Promise<T | U>;
-    /**
-     * @TODO
-     */
-    $map<U>(this: ResultAsync<T, E>, f: (val: T) => U): ResultAsync<U, E>;
-    /**
-     * @TODO
-     */
-    $mapErr<F>(this: ResultAsync<T, E>, f: (err: E) => F): ResultAsync<T, F>;
-    /**
-     * @TODO
-     */
-    $mapOr<U, V>(this: ResultAsync<T, E>, def: U, f: (val: T) => V): ResultAsync<U | V, E>;
-    /**
-     * @TODO
-     */
-    $mapOrElse<U, V>(this: ResultAsync<T, E>, def: (err: E) => U, f: (val: T) => V): ResultAsync<U | V, E>;
-    /**
-     * ## $assertOr
+     * Resolves this `ResultAsync` using the provided resolver. The resolver
+     * receives a promise which resolves when the result is `Ok` and rejects if
+     * the result is `Err`.
      *
-     * {@link Retuple.$assertOr|$assertOr}
-     */
-    $assertOr<U, F>(this: ResultAsync<T, E>, def: Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<Truthy<T>, E | F>;
-    $assertOr<U, F, A extends T>(this: ResultAsync<T, E>, def: Result<U, F> | PromiseLike<Result<U, F>>, predicate: (val: T) => val is A): ResultAsync<U | A, E | F>;
-    $assertOr<U, F>(this: ResultAsync<T, E>, def: Result<U, F> | PromiseLike<Result<U, F>>, condition: (val: T) => unknown): ResultAsync<T | U, E | F>;
-    $assertOrElse<U, F>(this: ResultAsync<T, E>, def: () => Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<Truthy<T>, E | F>;
-    $assertOrElse<U, F, A extends T>(this: ResultAsync<T, E>, def: () => Result<U, F> | PromiseLike<Result<U, F>>, predicate: (val: T) => val is A): ResultAsync<U | A, E | F>;
-    $assertOrElse<U, F>(this: ResultAsync<T, E>, def: () => Result<U, F> | PromiseLike<Result<U, F>>, condition: (val: T) => unknown): ResultAsync<T | U, E | F>;
-    /**
-     * @TODO
-     */
-    $or<U, F>(this: ResultAsync<T, E>, or: Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<T | U, E | F>;
-    /**
-     * @TODO
-     */
-    $orElse<U, F>(this: ResultAsync<T, E>, f: (err: E) => Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<T | U, E | F>;
-    /**
-     * @TODO
-     */
-    $orSafe<U>(this: ResultAsync<T, E>, f: (err: E) => U | PromiseLike<U>): ResultAsync<T | U, E | Error>;
-    $orSafe<U, F>(this: ResultAsync<T, E>, f: (err: E) => U | PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<T | U, E | F>;
-    /**
-     * @TODO
-     */
-    $and<U, F>(this: ResultAsync<T, E>, and: Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<U, E | F>;
-    /**
-     * @TODO
-     */
-    $andThen<U, F>(this: ResultAsync<T, E>, f: (val: T) => Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<U, E | F>;
-    /**
-     * @TODO
-     */
-    $andThrough<F>(this: ResultAsync<T, E>, f: (val: T) => Result<any, F> | PromiseLike<Result<any, F>>): ResultAsync<T, E | F>;
-    /**
-     * @TODO
+     * This method should only be called when the `E` type extends `Error`. This
+     * is enforced with a type constraint. If the error value is not an instance
+     * of Error, the promise rejects with `RetupleExpectFailed`.
+     *
+     * @example
+     *
+     * ```ts
+     * async function resolver(promise: Promise<URL>): string {
+     *   try {
+     *     const url = await promise;
+     *
+     *     return url.toString();
+     *   } catch (cause) {
+     *     throw new Error("Not a valid URL", { cause });
+     *   }
+     * }
+     *
+     * const urlString = await Result.$safeAsync(() => getDataAsync())
+     *   .$andSafe((data) => new URL(data.url))
+     *   .$resolve(resolver);
+     * ```
      */
-    $andSafe<U>(this: ResultAsync<T, E>, f: (val: T) => U | PromiseLike<U>): ResultAsync<T | U, E | Error>;
-    $andSafe<U, F>(this: ResultAsync<T, E>, f: (val: T) => U | PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<T | U, E | F>;
+    $resolve<U = T>(this: ResultAsync<T, Error>, resolver: (promise: Promise<T>) => PromiseLike<U>): Promise<U>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$unwrapErr|$unwrapErr}, except it returns
+     * a `Promise`.
      */
-    $peek(this: ResultAsync<T, E>, f: (res: Result<T, E>) => any): ResultAsync<T, E>;
+    $unwrapErr(this: ResultAsync<T, E>, msg?: string): Promise<E>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$unwrapOr|$unwrapOr}, except it returns
+     * a `Promise`.
      */
-    $tap(this: ResultAsync<T, E>, f: (val: T) => any): ResultAsync<T, E>;
+    $unwrapOr<const U = T>(this: ResultAsync<T, E>, def: U): Promise<T | U>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$unwrapOrElse|$unwrapOrElse}, except it returns
+     * a `Promise`.
      */
-    $tapErr(this: ResultAsync<T, E>, f: (err: E) => any): ResultAsync<T, E>;
+    $unwrapOrElse<U = T>(this: ResultAsync<T, E>, f: () => U): Promise<T | U>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$map|$map}, except it returns
+     * {@link ResultAsync}.
      */
-    $promise(this: ResultAsync<T, E>): Promise<Result<T, E>>;
-}
-type OkTuple<T> = [err: undefined, value: T];
-type ErrTuple<E> = [err: E, value: undefined];
-type Truthy<T> = Exclude<T, false | null | undefined | 0 | 0n | "">;
-/**
- * @TODO - Result.all / Result.any
- */
-interface Retuple<T, E> {
+    $map<U>(this: ResultAsync<T, E>, f: (val: T) => U): ResultAsync<U, E>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$mapErr|$mapErr}, except it returns
+     * {@link ResultAsync}.
      */
-    $toNativeTuple(this: Result<T, E>): OkTuple<T> | ErrTuple<E>;
+    $mapErr<F = E>(this: ResultAsync<T, E>, f: (err: E) => F): ResultAsync<T, F>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$mapOr|$mapOr}, except it returns
+     * {@link ResultAsync}.
      */
-    $value(this: Result<T, E>): T | E;
+    $mapOr<U, V = U>(this: ResultAsync<T, E>, def: U, f: (val: T) => V): ResultAsync<U | V, never>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$mapOrElse|$mapOrElse}, except it returns
+     * {@link ResultAsync}.
      */
-    $isOk(this: Result<T, E>): this is Ok<T>;
+    $mapOrElse<U, V = U>(this: ResultAsync<T, E>, def: (err: E) => U, f: (val: T) => V): ResultAsync<U | V, never>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$assert|$assert}, except it returns
+     * {@link ResultAsync}.
      */
-    $isOkAnd<U extends T>(this: Result<T, E>, predicate: (val: T) => val is U): this is Ok<U>;
-    $isOkAnd(this: Result<T, E>, predicate: (val: T) => unknown): this is Ok<T>;
+    $assert(this: ResultAsync<T, E>): ResultAsync<Truthy<T>, E | RetupleAssertFailed<T>>;
+    $assert<F = E>(this: ResultAsync<T, E>, mapError: (val: Falsey<T>) => F): ResultAsync<Truthy<T>, E | F>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$filter|$filter}, except it returns
+     * {@link ResultAsync}.
      */
-    $isErr(this: Result<T, E>): this is Err<E>;
+    $filter<U extends T = T>(this: ResultAsync<T, E>, predicate: (val: T) => val is U): ResultAsync<U, E | RetupleFilterFailed<T>>;
+    $filter(this: ResultAsync<T, E>, check: (val: T) => unknown): ResultAsync<T, E | RetupleFilterFailed<T>>;
+    $filter<U extends T = T, F = E>(this: ResultAsync<T, E>, predicate: (val: T) => val is U, mapError: (val: T) => F): ResultAsync<U, E | F>;
+    $filter<F = E>(this: ResultAsync<T, E>, check: (val: T) => unknown, mapError: (val: T) => F): ResultAsync<T, E | F>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$atIndex|$atIndex}, except it returns
+     * {@link ResultAsync}.
      */
-    $isErrAnd<F extends E>(this: Result<T, E>, prediacte: (val: E) => val is F): this is Err<F>;
-    $isErrAnd(this: Result<T, E>, predicate: (val: E) => unknown): this is Err<E>;
+    $atIndex<U>(this: ResultAsync<readonly U[], E>, index: number): ResultAsync<U, E | RetupleFilterFailed<T>>;
+    $atIndex<U, F = E>(this: ResultAsync<readonly U[], E>, index: number, mapError: (val: T) => F): ResultAsync<U, E | F>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$firstIndex|$firstIndex}, except it returns
+     * {@link ResultAsync}.
      */
-    $expect(this: Result<T, Error>): T;
+    $firstIndex<U>(this: ResultAsync<readonly U[], E>): ResultAsync<U, E | RetupleIndexFailed<T>>;
+    $firstIndex<U, F = E>(this: ResultAsync<readonly U[], E>, mapError: (val: T) => F): ResultAsync<U, E | F>;
     /**
-     * @TODO
-     */
-    $unwrap(this: Result<T, E>, msg?: string): T;
-    /**
-     * @TODO
+     * The same as {@link Retuple.$or|$or}, except it:
+     *
+     * - can also accept a `PromiseLike` or value;
+     * - returns {@link ResultAsync}.
      */
-    $unwrapErr(this: Result<T, E>, msg?: string): E;
+    $or<U = T, F = E>(this: ResultAsync<T, E>, or: ResultLikeAwaitable<U, F>): ResultAsync<T | U, F>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$orElse|$orElse}, except it:
+     *
+     * - can also accept an `async` or function;
+     * - returns {@link ResultAsync}.
      */
-    $unwrapOr<const U>(this: Result<T, E>, def: U): T | U;
+    $orElse<U = T, F = E>(this: ResultAsync<T, E>, f: (err: E) => ResultLikeAwaitable<U, F>): ResultAsync<T | U, F>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$orSafe|$orSafe}, except it:
+     *
+     * - can also accept an `async` safe function;
+     * - returns {@link ResultAsync}.
      */
-    $unwrapOrElse<U>(this: Result<T, E>, f: () => U): T | U;
+    $orSafe<U = T>(this: ResultAsync<T, E>, f: (err: E) => U | PromiseLike<U>): ResultAsync<T | U, Error>;
+    $orSafe<U = T, F = E>(this: ResultAsync<T, E>, f: (err: E) => U | PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<T | U, F>;
     /**
-     * @TODO
+     * Returns {@link ResultAsync} based on the outcome of the promise when this
+     * result is `Err`.
+     *
+     * Otherwise, returns `Ok` containing the current contained value.
+     *
+     * Uses the same strategy as {@link Result.$safePromise}, equivalent to
+     * calling:
+     *
+     * ```ts
+     * resultAsync.$orElse(() => Result.$safePromise(...))
+     * ```
      */
-    $map<U>(this: Result<T, E>, f: (value: T) => U): Result<U, E>;
+    $orSafePromise<U = T>(this: ResultAsync<T, E>, promise: PromiseLike<U>): ResultAsync<T | U, Error>;
+    $orSafePromise<U = T, F = E>(this: ResultAsync<T, E>, promise: PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<T | U, F>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$and|$and}, except it:
+     *
+     * - can also accept a `PromiseLike` and value;
+     * - returns {@link ResultAsync}.
      */
-    $mapErr<F>(this: Result<T, E>, f: (err: E) => F): Result<T, F>;
+    $and<U = T, F = E>(this: ResultAsync<T, E>, and: ResultLikeAwaitable<U, F>): ResultAsync<U, E | F>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$andThen|$andThen}, except it:
+     *
+     * - can also accept an `async` and function;
+     * - returns {@link ResultAsync}.
      */
-    $mapOr<U, V = U>(this: Result<T, E>, def: U, f: (val: T) => V): Result<U | V, E>;
+    $andThen<U = T, F = E>(this: ResultAsync<T, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<U, E | F>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$andStack|$andStack}, except it:
+     *
+     * - can also accept an `async` and function;
+     * - returns {@link ResultAsync}.
      */
-    $mapOrElse<U, V = U>(this: Result<T, E>, def: (err: E) => U, f: (val: T) => V): Result<U | V, E>;
+    $andStack<U = T, F = E, S extends [...any[], any] = [...any[], any]>(this: ResultAsync<Stack<S>, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<Stack<[...S, U]>, E | F>;
+    $andStack<U = T, F = E>(this: ResultAsync<T, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<Stack<[T, U]>, E | F>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$andThrough|$andThrough}, except it:
+     *
+     * - can also accept an `async` through function;
+     * - returns {@link ResultAsync}.
      */
-    $or<U, F>(this: Result<T, E>, or: Result<U, F>): Result<T | U, E | F>;
+    $andThrough<F = E>(this: ResultAsync<T, E>, f: (val: T) => ResultLikeAwaitable<any, F>): ResultAsync<T, E | F>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$andSafe|$andSafe}, except it:
+     *
+     * - can also accept an `async` safe function;
+     * - returns {@link ResultAsync}.
      */
-    $orElse<U, F>(this: Result<T, E>, f: (err: E) => Result<U, F>): Result<T | U, E | F>;
+    $andSafe<U = T>(this: ResultAsync<T, E>, f: (val: T) => U | PromiseLike<U>): ResultAsync<U, E | Error>;
+    $andSafe<U = T, F = E>(this: ResultAsync<T, E>, f: (val: T) => U | PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<U, E | F>;
     /**
-     * @TODO
+     * Returns {@link ResultAsync} based on the outcome of the promise when this
+     * result is `Ok`.
+     *
+     * Otherwise, returns `Err` containing the current error value.
+     *
+     * Uses the same strategy as {@link Result.$safePromise}, equivalent to
+     * calling:
+     *
+     * ```ts
+     * resultAsync.$andThen(() => Result.$safePromise(...))
+     * ```
      */
-    $orSafe<U>(this: Result<T, E>, f: (err: E) => U): Result<T | U, E | Error>;
-    $orSafe<U, F>(this: Result<T, E>, f: (err: E) => U, mapError: (err: unknown) => F): Result<T | U, E | F>;
+    $andSafePromise<U = T>(this: ResultAsync<T, E>, promise: PromiseLike<U>): ResultAsync<U, E | Error>;
+    $andSafePromise<U = T, F = E>(this: ResultAsync<T, E>, promise: PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<U, E | F>;
     /**
-     * @TODO
+     * Execute a pipeline starting with the resolved `Ok` value of this result,
+     * resolving to the `Ok` of the final function in the pipe or the first
+     * `Err` encountered. If you only need to execute a single function, use
+     * `$andThen`.
+     *
+     * Uses the same strategy as {@link Result.$pipeAsync}, equivalent to calling:
+     *
+     * ```ts
+     * resultAsync.$andThen(
+     *   (val) => Result.$pipeAsync(
+     *     () => fn1(val),
+     *     async (val2) => fn2(val2),
+     *   ),
+     * );
+     * ```
+     */
+    $andPipe<T0, E0, T1, E1>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>): ResultAsync<T1, E0 | E1>;
+    $andPipe<T0, E0, T1, E1, T2, E2>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>): ResultAsync<T2, E0 | E1 | E2>;
+    $andPipe<T0, E0, T1, E1, T2, E2, T3, E3>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>): ResultAsync<T3, E0 | E1 | E2 | E3>;
+    $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>): ResultAsync<T4, E0 | E1 | E2 | E3 | E4>;
+    $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>): ResultAsync<T5, E0 | E1 | E2 | E3 | E4 | E5>;
+    $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>): ResultAsync<T6, E0 | E1 | E2 | E3 | E4 | E5 | E6>;
+    $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6, T7, E7>(this: ResultAsync<T, E>, f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>, f7: (val6: T6) => ResultLikeAwaitable<T7, E7>): ResultAsync<T7, E | E0 | E1 | E2 | E3 | E4 | E5 | E6 | E7>;
+    /**
+     * The same as {@link Retuple.$peek|$peek}, except it:
+     *
+     * - awaits the peek function;
+     * - returns {@link ResultAsync}.
      */
-    $and<U, F>(this: Result<T, E>, and: Result<U, F>): Result<U, E | F>;
+    $peek(this: ResultAsync<T, E>, f: (res: Result<T, E>) => any): ResultAsync<T, E>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$tap|$tap}, except it:
+     *
+     * - awaits the tap function;
+     * - returns {@link ResultAsync}.
      */
-    $andThen<U, F>(this: Result<T, E>, f: (val: T) => Result<U, F>): Result<U, E | F>;
+    $tap(this: ResultAsync<T, E>, f: (val: T) => any): ResultAsync<T, E>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$tapErr|$tapErr}, except it:
+     *
+     * - awaits the tap error function;
+     * - returns {@link ResultAsync}.
      */
-    $andThrough<F>(this: Result<T, E>, f: (val: T) => Result<any, F>): Result<T, E | F>;
+    $tapErr(this: ResultAsync<T, E>, f: (err: E) => any): ResultAsync<T, E>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$flatten|$flatten} except it returns
+     * {@link ResultAsync}.
      */
-    $andSafe<U>(this: Result<T, E>, f: (val: T) => U): Result<T | U, E | Error>;
-    $andSafe<U, F>(this: Result<T, E>, f: (val: T) => U, mapError: (err: unknown) => F): Result<T | U, E | F>;
+    $flatten<U, F>(this: ResultAsync<Result<U, F>, E>): ResultAsync<U, E | F>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$promise|$promise}.
      */
-    $assertOr<U, F>(this: Result<T, E>, def: Result<U, F>): Result<Truthy<T>, E | F>;
-    $assertOr<U, F, A extends T>(this: Result<T, E>, def: Result<U, F>, predicate: (val: T) => val is A): Result<U | A, E | F>;
-    $assertOr<U, F>(this: Result<T, E>, def: Result<U, F>, condition: (val: T) => unknown): Result<T | U, E | F>;
+    $promise(this: ResultAsync<T, E>): Promise<Result<T, E>>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$iter|$iter}, except it returns a `Promise`.
      */
-    $assertOrElse<U, F>(this: Result<T, E>, def: () => Result<U, F>): Result<Truthy<T>, E | F>;
-    $assertOrElse<U, F, A extends T>(this: Result<T, E>, def: () => Result<U, F>, predicate: (val: T) => val is A): Result<U | A, E | F>;
-    $assertOrElse<U, F>(this: Result<T, E>, def: () => Result<U, F>, condition: (val: T) => unknown): Result<T | U, E | F>;
-    /**
-     * @TODO
+    $iter<U>(this: ResultAsync<Iterable<U>, E>): Promise<IterableIterator<U, undefined, unknown>>;
+}
+/**
+ * ## ResultRetry
+ */
+declare class ResultRetry<T, E> extends ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
+    #private;
+    private static MAX_TIMEOUT;
+    private static MAX_RETRY;
+    private static zero;
+    private static delay;
+    private static integer;
+    constructor(f: () => ResultLikeAwaitable<T, E>);
+    then<U = Result<T, E>, F = never>(this: ResultRetry<T, E>, onfulfilled?: ((value: Result<T, E>) => U | PromiseLike<U>) | null | undefined, onrejected?: ((reason: any) => F | PromiseLike<F>) | null | undefined): PromiseLike<U | F>;
+    /**
+     * Sets the maximum number of times the retry function can be executed,
+     * mutating this `ResultRetry` instance.
+     *
+     * **The default value is 1 - meaning that unless set, no retries will be
+     * attempted.**
+     *
+     * The retry function can be called up to the maximum number of times until
+     * it returns `Ok`. If it never returns `Ok`, the  most recent `Err` is
+     * returned.
+     *
+     * This function accepts a positive integer between 1 and 100:
+     *
+     * - Integers outside of this range are clamped to the nearest valid value;
+     * - Any other value (NaN, Infinity, fractions, strings) are treated as 1.
+     *
+     * @example
+     *
+     * ```ts
+     * // Retry someResultFn up to 3 times until Ok is returned:
+     * const result = await Result.$retry(someResultFn).$times(3);
+     * ```
      */
-    $peek(this: Result<T, E>, f: (res: Result<T, E>) => void): Result<T, E>;
+    $times<N extends number>(this: ResultRetry<T, E>, times: NonZero<N> & NonNegativeOrDecimal<N>): ResultRetry<T, E>;
     /**
-     * @TODO
-     */
-    $tap(this: Result<T, E>, f: (val: T) => any): Result<T, E>;
+     * Sets the delay between each retry attempt, mutating this `ResultRetry`
+     * instance.
+     *
+     * - Provide a number of milliseconds to introduce a static delay between
+     *   attempts;
+     * - Provide a function to compute the delay dynamically for each attempt;
+     * - If the maximum number of retries is 1, this setting as no effect.
+     *
+     * **The default value is 0 - meaning that unless set, there will be no delay
+     * between attempts.**
+     *
+     * This function accepts an integer between 0 and 3600000:
+     *
+     * - Integers outside of this range are clamped to the nearest valid value;
+     * - Any other value (NaN, Infinity, fractions, strings) are treated as 0.
+     *
+     * @example
+     *
+     * ```ts
+     * // Retry someResultFn up to 3 times until Ok is returned,
+     * // with a 1 second delay between each invocation:
+     * const result = await Result.$retry(someResultFn).$times(3).$delay(1000);
+     * ```
+     */
+    $delay<N extends number>(this: ResultRetry<T, E>, f: (attempt: number) => NonNegativeOrDecimal<N>): ResultRetry<T, E>;
+    $delay<N extends number>(this: ResultRetry<T, E>, ms: NonNegativeOrDecimal<N>): ResultRetry<T, E>;
+    /**
+     * Sets a handler to be called when an attempt returns `Err`, mutating this
+     * `ResultRetry` instance. The handler can be used to capture information
+     * about each failure, and to abort early and prevent further retries.
+     *
+     * The handler function is called with `ResultRetryHandleState`, containing:
+     *
+     * - **error** - The error value from the last failed attempt;
+     * - **attempt** - The attempt number;
+     * - **abort** - A function which when called, prevents further retries.
+     *
+     * @example
+     *
+     * ```ts
+     * // Retry someResultFn up to 3 times until Ok is returned, logging each
+     * // attempt and aborting early if the error code is "UNAUTHORIZED".
+     * const result = await Result.$retry(someResultFn)
+     *    .$times(3)
+     *    .$handle(({ error, attempt, abort }) => {
+     *       console.info(`Attempt ${attempt} failed: ${error}`);
+     *       if (error === "UNAUTHORIZED") {
+     *          abort();
+     *       }
+     *    });
+     * ```
+     */
+    $handle(f: (controller: ResultRetryController<E>) => void): ResultRetry<T, E>;
+    private drain;
+}
+type Stack<T extends [...any[], any] = [...any[], any]> = T & {
+    [RetupleStackSymbol]: T;
+};
+interface Retuple<T, E> extends ResultLike<T, E> {
     /**
-     * @TODO
+     * Returns true when this result is `Ok`. Acts as a type guard.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.equal(result.$isOk(), true);
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     * assert.equal(result.$isOk(), false);
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string, Error> = someResultFn();
+     *
+     * if (result.$isOk()) {
+     *    result satisfies Result<string, never>;
+     * }
+     * ```
      */
-    $tapErr(this: Result<T, E>, f: (err: E) => void): Result<T, E>;
+    $isOk(this: Result<T, E>): this is Result<T, never>;
     /**
-     * @TODO
+     * Returns true when this result is `Ok`, and when the predicate/condition
+     * function returns true. Acts as a type guard.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.equal(result.$isOkAnd((val) => val === "test"), true);
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok<string>("test");
+     * assert.equal(result.$isOkAnd((val) => val !== "test"), false);
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     * assert.equal(result.$isOkAnd((err) => err === "test"), false);
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string | number, Error> = someResultFn();
+     *
+     * if (result.$isOkAnd((val): val is number => typeof val === "number")) {
+     *    result satisfies Result<number, never>;
+     * }
+     * ```
      */
-    $flatten<U, F>(this: Result<Result<U, F>, E>): Result<U, E | F>;
+    $isOkAnd<U extends T = T>(this: Result<T, E>, predicate: (val: T) => val is U): this is Result<U, never>;
+    $isOkAnd(this: Result<T, E>, predicate: (val: T) => unknown): this is Result<T, never>;
     /**
-     * @TODO
+     * Returns true when this result is `Err`. Acts as a type guard.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     * assert.equal(result.$isErr(), true);
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.equal(result.$isErr(), false);
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string, Error> = someResultFn();
+     *
+     * if (result.$isErr()) {
+     *    result satisfies Result<never, Error>;
+     * }
+     * ```
      */
-    $async(this: Result<T, E>): ResultAsync<T, E>;
+    $isErr(this: Result<T, E>): this is Result<never, E>;
     /**
-     * @TODO
+     * Returns true when this result is `Err`, and when the predicate/condition
+     * function returns true. Acts as a type guard.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     * assert.equal(result.$isErrAnd((err) => err === "test"), true);
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err<string>("test");
+     * assert.equal(result.$isErrAnd((err) => err !== "test"), false);
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.equal(result.$isErrAnd((val) => val === "test"), false);
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string, Error | number> = someResultFn();
+     *
+     * if (result.$isErrAnd((err): err is number => typeof err === "number")) {
+     *    result satisfies Result<never, number>;
+     * }
+     * ```
      */
-    $promise(this: Result<T, E>): Promise<Result<T, E>>;
+    $isErrAnd<F extends E = E>(this: Result<T, E>, prediacte: (val: E) => val is F): this is Result<never, F>;
+    $isErrAnd(this: Result<T, E>, predicate: (val: E) => unknown): this is Result<never, E>;
     /**
-     * Mark standard array methods as deprecated, to assist with type hinting.
+     * Returns the ok value when this result is `Ok`.
+     *
+     * Otherwise, the error value is thrown.
+     *
+     * This method should only be called when the `E` type extends `Error`. This
+     * is enforced with a type constraint. If the error value is not an instance
+     * of Error, `RetupleExpectFailed` is thrown. Use
+     * {@link Retuple.$unwrap|$unwrap} When the `E` type does not extend Error.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.equal(result.$expect(), "test");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const error = new Error("test");
+     * const result = Err(error);
+     *
+     * try {
+     *   const value = result.$expect(); // throws
+     * } catch (e) {
+     *   assert.equal(e, error);
+     * }
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     *
+     * try {
+     *   // This is a type error - the E type does not extend Error
+     *   const value = result.$expect(); // throws
+     * } catch (e) {
+     *   assert(e instanceof RetupleExpectFailed && e.value === "test");
+     * }
+     * ```
      */
+    $expect(this: Result<T, Error>): T;
     /**
-     * @deprecated
+     * Returns the ok value when this result is `Ok`.
+     *
+     * Otherwise, `RetupleUnwrapFailed` is thrown. A custom error message can be
+     * provided.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.equal(result.$unwrap(), "test");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     *
+     * try {
+     *   const value = result.$unwrap(); // throws
+     * } catch (e) {
+     *   assert(e instanceof RetupleUnwrapFailed && e.value === "test");
+     * }
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const error = new Error("test");
+     * const result = Err(error);
+     *
+     * try {
+     *   const value = result.$unwrap("error-message"); // throws
+     * } catch (e) {
+     *   assert(
+     *      e instanceof RetupleUnwrapFailed &&
+     *      e.message === "error-message" &&
+     *      e.value === error &&
+     *      e.cause === error, // set when error value was an instance of `Error`
+     *   );
+     * }
+     * ```
      */
-    at(...args: unknown[]): unknown;
+    $unwrap(this: Result<T, E>, msg?: string): T;
     /**
-     * @deprecated
+     * Returns the error value when this result is `Err`.
+     *
+     * Otherwise, `RetupleUnwrapErrFailed` is thrown. A custom error message can
+     * be provided.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     * assert.equal(result.$unwrapErr(), "test");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     *
+     * try {
+     *   const value = result.$unwrapErr(); // throws
+     * } catch (e) {
+     *   assert(e instanceof RetupleUnwrapErrFailed && e.value === "test");
+     * }
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     *
+     * try {
+     *   const value = result.$unwrapErr("error-message"); // throws
+     * } catch (e) {
+     *   assert(
+     *      e instanceof RetupleUnwrapErrFailed &&
+     *      e.message === "error-message" &&
+     *      e.value === "test",
+     *   );
+     * }
+     * ```
      */
-    concat(...args: unknown[]): unknown;
+    $unwrapErr(this: Result<T, E>, msg?: string): E;
     /**
-     * @deprecated
+     * Returns the ok value when this result is `Ok`.
+     *
+     * Otherwise, returns the default value.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.equal(result.$unwrapOr("default"), "test");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     * assert.equal(result.$unwrapOr("default"), "default");
+     * ```
      */
-    copyWithin(...args: unknown[]): unknown;
+    $unwrapOr<const U = T>(this: Result<T, E>, def: U): T | U;
     /**
-     * @deprecated
+     * Returns the ok value when this result is `Ok`.
+     *
+     * Otherwise, returns the value returned by the default function.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.equal(result.$unwrapOrElse(() => "default"), "test");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     * assert.equal(result.$unwrapOrElse(() => "default"), "default");
+     * ```
      */
-    entries(...args: unknown[]): unknown;
+    $unwrapOrElse<U = T>(this: Result<T, E>, f: () => U): T | U;
     /**
-     * @deprecated
+     * Performs an assertion when this result is `Ok`:
+     *
+     * - returning `Ok` containing the current ok value when it is truthy.
+     *   Narrows the `T` type to include only truthy values;
+     * - returning `Err` containing the return value of the map error function
+     *   when the ok value is falsey;
+     * - returning `Err` containing {@link RetupleAssertFailed} when the
+     *   ok value is falsey, and when no map error function is provided.
+     *
+     * Otherwise returns `Err` containing the current error value.
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string | null, never> = Ok("test");
+     * const asserted = result.$assert();
+     *
+     * asserted satisfies Result<string, RetupleCheckFailedError<string | null>>;
+     * assert.equal(asserted.$unwrap(), "test");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string | null | undefined, never> = Ok(null);
+     * const asserted = result.$assert(
+     *   (val) => val === null ? "value was null" : "value was undefined"
+     * );
+     *
+     * asserted satisfies Result<string, string>;
+     * assert.equal(asserted.$unwrapErr(), "value was null");
+     * ```
      */
-    every(...args: unknown[]): unknown;
+    $assert(this: Result<T, E>): Result<Truthy<T>, E | RetupleFilterFailed<T>>;
+    $assert<F = E>(this: Result<T, E>, mapError: (val: Falsey<T>) => F): Result<Truthy<T>, E | F>;
     /**
-     * @deprecated
+     * Performs a check when this result is `Ok`:
+     *
+     * - returning `Ok` containing the current ok value when the filter function
+     *   returns true. Narrows the `T` type based on the filter function;
+     * - returning `Err` containing the return value of the map error function
+     *   when the ok value fails the filter;
+     * - returning `Err` containing {@link RetupleFilterFailed} when the
+     *   ok value fails the filter, and when no map error function is provided.
+     *
+     * Otherwise returns `Err` containing the current error value.
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string, never> = Ok("test");
+     * const asserted = result.$filter((val) => val === "test");
+     *
+     * asserted satisfies Result<string, RetupleCheckFailedError<string>>;
+     * assert.equal(asserted.$unwrap(), "test");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string, never> = Ok("test");
+     * const checked = result.$filter(
+     *   (val) => val === "value",
+     *   (val) => `value was ${val}`,
+     * );
+     *
+     * checked satisfies Result<"value", string>;
+     * assert.equal(checked.$unwrapErr(), "value was test");
+     * ```
      */
-    fill(...args: unknown[]): unknown;
+    $filter<U extends T = T>(this: Result<T, E>, predicate: (val: T) => val is U): Result<U, E | RetupleFilterFailed<T>>;
+    $filter(this: Result<T, E>, filter: (val: T) => unknown): Result<T, E | RetupleFilterFailed<T>>;
+    $filter<U extends T = T, F = E>(this: Result<T, E>, predicate: (val: T) => val is U, mapError: (val: T) => F): Result<U, E | F>;
+    $filter<F = E>(this: Result<T, E>, filter: (val: T) => unknown, mapError: (val: T) => F): Result<T, E | F>;
     /**
-     * @deprecated
+     * Checks the specified element of the contained array when when this result
+     * is `Ok`:
+     *
+     * - returning `Ok` containing the specified element when it is truthy.
+     *   Narrows the type to include only truthy values;
+     * - returning `Err` containing the return value of the map error function
+     *   when the specified array element fails the check;
+     * - returning `Err` containing {@link RetupleIndexFailed} when the specified
+     *   array element fails the check, and when no map error function is
+     *   provided.
+     *
+     * Otherwise returns `Err` containing the current error value.
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<(string | null)[], never> = Ok([null, "test"]);
+     * const first = result.$atIndex(1);
+     *
+     * first satisfies Result<string, RetupleCheckFailedError<string | null>>;
+     * assert.equal(first.$unwrap(), "test");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<(string | null | undefined)[], never> = Ok(["test", null]);
+     * const first = result.$atIndex(
+     *   1,
+     *   (val) => val === null ? "value was null" : "value was undefined",
+     * );
+     *
+     * first satisfies Result<string, string>;
+     * assert.equal(first.$unwrapErr(), "value was null");
+     * ```
      */
-    filter(...args: unknown[]): unknown;
+    $atIndex<U>(this: Result<readonly U[], E>, index: number): Result<Truthy<U>, E | RetupleIndexFailed<T>>;
+    $atIndex<U, F = E>(this: Result<readonly U[], E>, index: number, mapError: (val: T) => F): Result<Truthy<U>, E | F>;
     /**
-     * @deprecated
+     * Equivalent to calling `result.$atIndex(0)`.
      */
-    find(...args: unknown[]): unknown;
+    $firstIndex<U>(this: Result<readonly U[], E>): Result<Truthy<U>, E | RetupleFilterFailed<T>>;
+    $firstIndex<U, F = E>(this: Result<readonly U[], E>, mapError: (val: T) => F): Result<Truthy<U>, E | F>;
     /**
-     * @deprecated
+     * Returns `Ok` containing the return value of the map function when this
+     * result is `Ok`.
+     *
+     * Otherwise, returns `Err` containing the current error value.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.equal(
+     *    result.$map((val) => `map:${val}`).$unwrap(),
+     *    "map:test",
+     * );
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string, string> = Err("test");
+     * assert.equal(
+     *    result.$map((val) => `map:${val}`).$unwrapErr(),
+     *    "test",
+     * );
+     * ```
+     */
+    $map<U>(this: Result<T, E>, f: (val: T) => U): Result<U, E>;
+    /**
+     * Returns `Err` containing the return value of the map error function
+     * when this result is `Err`.
+     *
+     * Otherwise, returns `Ok` containing the current ok value.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     * assert.equal(
+     *    result.$mapErr((err) => `map-err:${err}`).$unwrapErr(),
+     *    "map-err:test",
+     * );
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string, string> = Ok("test");
+     * assert.equal(
+     *    result.$mapErr((err) => `map-err:${err}`).$unwrap(),
+     *    "test",
+     * );
+     * ```
+     */
+    $mapErr<F = E>(this: Result<T, E>, f: (err: E) => F): Result<T, F>;
+    /**
+     * Returns `Ok` containing the return value of the map function when this
+     * result is `Ok`.
+     *
+     * Otherwise, returns `Ok` containing the default value.
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string, string> = Ok("test");
+     * assert.equal(
+     *    result.$mapOr("default", (val) => `map:${val}`).$unwrap(),
+     *    "map:test",
+     * );
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string, string> = Err("test");
+     * assert.equal(
+     *    result.$mapOr("default", (val) => `map:${val}`).$unwrap(),
+     *    "default",
+     * );
+     * ```
+     */
+    $mapOr<U, V = U>(this: Result<T, E>, def: U, f: (val: T) => V): Result<U | V, never>;
+    /**
+     * Returns `Ok` containing the return value of the map function when this
+     * result is `Ok`.
+     *
+     * Otherwise, returns `Ok` containing the return value of the default
+     * function.
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string, string> = Ok("test");
+     * assert.equal(
+     *    result.$mapOrElse(
+     *       (err) => `default:${err}`,
+     *       (val) => `map:${val}`,
+     *    ).$unwrap(),
+     *    "map:test",
+     * );
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string, string> = Err("test");
+     * assert.equal(
+     *    result.$mapOrElse(
+     *       (err) => `default:${err}`,
+     *       (val) => `map:${val}`,
+     *    ).$unwrap(),
+     *    "default:test",
+     * );
+     * ```
+     */
+    $mapOrElse<U, V = U>(this: Result<T, E>, def: (err: E) => U, f: (val: T) => V): Result<U | V, never>;
+    /**
+     * Returns the or result, when this result is `Err`.
+     *
+     * Otherwise, returns `Ok` containing the current ok value.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     * assert.equal(
+     *    result.$or(Ok("or-ok")).$unwrap(),
+     *    "or-ok",
+     * );
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     * assert.equal(
+     *    result.$or(Err("or-err")).$unwrapErr(),
+     *    "or-err",
+     * );
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.equal(
+     *    result.$or(Ok("or-ok")).$unwrap(),
+     *    "test",
+     * );
+     * ```
      */
-    findIndex(...args: unknown[]): unknown;
+    $or<U = T, F = E>(this: Result<T, E>, or: ResultLike<U, F>): Result<T | U, F>;
     /**
-     * @deprecated
+     * Shorthand for `result.$async().$or(...)`
      */
-    flat(...args: unknown[]): unknown;
+    $orAsync<U = T, F = E>(this: Result<T, E>, or: ResultLikeAwaitable<U, F>): ResultAsync<T | U, F>;
     /**
-     * @deprecated
+     * Returns the result returned by the or function, when this result is `Err`.
+     *
+     * Otherwise, returns `Ok` containing the current ok value.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     * assert.equal(
+     *    result.$orElse((err) => Ok(`or-ok:${err}`)).$unwrap(),
+     *    "or-ok:test",
+     * );
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     * assert.equal(
+     *    result.$orElse((err) => Err(`or-err:${err}`)).$unwrapErr(),
+     *    "or-err:test",
+     * );
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string, string> = Ok("test");
+     * assert.equal(
+     *    result.$orElse((err) => Ok(`or-ok:${err}`)).$unwrap(),
+     *    "test",
+     * );
+     * ```
      */
-    flatMap(...args: unknown[]): unknown;
+    $orElse<U = T, F = E>(this: Result<T, E>, f: (err: E) => ResultLike<U, F>): Result<T | U, F>;
     /**
-     * @deprecated
+     * Shorthand for `result.$async().$orElse(...)`
      */
-    forEach(...args: unknown[]): unknown;
+    $orElseAsync<U = T, F = E>(this: Result<T, E>, f: (err: E) => ResultLikeAwaitable<U, F>): ResultAsync<T | U, F>;
     /**
-     * @deprecated
+     * Returns a {@link Result} based on the outcome of the safe function when
+     * this result is `Err`.
+     *
+     * Otherwise, returns `Ok` containing the current ok value.
+     *
+     * Uses the same strategy as {@link Result.$safe}, equivalent to calling
+     * `result.$or(Result.$safe(...))`.
      */
-    includes(...args: unknown[]): unknown;
+    $orSafe<U = T>(this: Result<T, E>, f: (err: E) => U): Result<T | U, Error>;
+    $orSafe<U = T, F = E>(this: Result<T, E>, f: (err: E) => U, mapError: (err: unknown) => F): Result<T | U, F>;
     /**
-     * @deprecated
+     * Shorthand for `result.$async().$orSafe(...)`
      */
-    indexOf(...args: unknown[]): unknown;
+    $orSafeAsync<U = T>(this: Result<T, E>, f: (err: E) => U | PromiseLike<U>): ResultAsync<T | U, Error>;
+    $orSafeAsync<U = T, F = E>(this: Result<T, E>, f: (err: E) => U | PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<T | U, F>;
     /**
-     * @deprecated
+     * Shorthand for `result.$async().$orSafePromise(...)`
      */
-    join(...args: unknown[]): unknown;
+    $orSafePromise<U = T>(this: Result<T, E>, promise: PromiseLike<U>): ResultAsync<T | U, Error>;
+    $orSafePromise<U = T, F = E>(this: Result<T, E>, promise: PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<T | U, F>;
     /**
-     * @deprecated
+     * Returns the and result, when this result is `Ok`.
+     *
+     * Otherwise, returns `Err` containing the current error value.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.equal(
+     *    result.$and(Ok("and-ok")).$unwrap(),
+     *    "and-ok",
+     * );
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.equal(
+     *    result.$and(Err("and-err")).$unwrapErr(),
+     *    "and-err",
+     * );
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     * assert.equal(
+     *    result.$and(Ok("and-ok")).$unwrapErr(),
+     *    "test",
+     * );
+     * ```
      */
-    keys(...args: unknown[]): unknown;
+    $and<U = T, F = E>(this: Result<T, E>, and: ResultLike<U, F>): Result<U, E | F>;
     /**
-     * @deprecated
+     * Shorthand for `result.$async().$and(...)`
      */
-    lastIndexOf(...args: unknown[]): unknown;
+    $andAsync<U = T, F = E>(this: Result<T, E>, and: ResultLikeAwaitable<U, F>): ResultAsync<U, E | F>;
     /**
-     * @deprecated
+     * Returns the and result, when this result is `Ok`.
+     *
+     * Otherwise, returns `Err` containing the current error value.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.equal(
+     *    result.$and((val) => Ok(`and-ok:${val}`)).$unwrap(),
+     *    "and-ok:test",
+     * );
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.equal(
+     *    result.$and((val) => Err(`and-err:${val}`)).$unwrapErr(),
+     *    "and-err:test",
+     * );
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string, string> = Err("test");
+     * assert.equal(
+     *    result.$and((val) => Ok(`and-ok:${val}`)).$unwrapErr(),
+     *    "test",
+     * );
+     * ```
+     */
+    $andThen<U = T, F = E>(this: Result<T, E>, f: (val: T) => ResultLike<U, F>): Result<U, E | F>;
+    /**
+     * Stacks the result of the and function on to the current contained
+     * value, when this result and the result of the function is `Ok`.
+     *
+     * Otherwise, returns the current `Err` or the `Err` from the and
+     * function.
+     *
+     * A stack is a special tuple which makes it possilble to pass multiple
+     * values down a chain with minimal effort.
+     *
+     * @example
+     *
+     * ```ts
+     * const identity = <T>(val: T) => Ok(val);
+     *
+     * const stack = Ok("test")
+     *    .$andStack((val) => identity(`${val}-2`))
+     *    .$andStack(([val, val2]) => identity(val.length + val2.length))
+     *    .$map(([val, val2, len]) => `'${val}${val2}' has length ${len}`);
+     *
+     * const nostack = Ok("test")
+     *   .$andThen((val) => identity(`${val}-2`).$map((val2) => [val, val2]))
+     *   .$andThen(([val, val2]) => {
+     *      return identity(val.length + val2.length)
+     *         .$map((len) => [val, val2, len]);
+     *   })
+     *   .$map(([val, val2, len]) => `'${val}${val2}' has length ${len}`);
+     * ```
      */
-    map(...args: unknown[]): unknown;
+    $andStack<U = T, F = E, S extends [...any[], any] = [...any[], any]>(this: Result<Stack<S>, E>, f: (val: T) => ResultLike<U, F>): Result<Stack<[...S, U]>, E | F>;
+    $andStack<U = T, F = E>(this: Result<T, E>, f: (val: T) => ResultLike<U, F>): Result<Stack<[T, U]>, E | F>;
     /**
-     * @deprecated
+     * Shorthand for `result.$async().$andThen(...)`
      */
-    pop(...args: unknown[]): any;
+    $andThenAsync<U = T, F = E>(this: Result<T, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<U, E | F>;
     /**
-     * @deprecated
+     * Shorthand for `result.$async().$andStack(...)`
      */
-    push(...args: unknown[]): unknown;
+    $andStackAsync<U = T, F = E, S extends [...any[], any] = [...any[], any]>(this: Result<Stack<S>, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<Stack<[...S, U]>, E | F>;
+    $andStackAsync<U = T, F = E>(this: Result<T, E>, f: (val: T) => ResultLikeAwaitable<U, F>): ResultAsync<Stack<[T, U]>, E | F>;
     /**
-     * @deprecated
+     * Calls the through function when this result is `Ok` and returns:
+     *
+     * - `Ok` containing the original ok value when the through function
+     *   returns `Ok`;
+     * - the `Err` returned by the through function when it returns `Err`.
+     *
+     * Otherwise, returns `Err` containing the current error value.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.equal(
+     *    result.$andThrough((val) => Ok(`ok-through:${val}`)).$unwrap(),
+     *    "test",
+     * );
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.equal(
+     *    result.$andThrough((val) => Err(`err-through:${val}`)).$unwrapErr(),
+     *    "err-through:test",
+     * );
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string, string> = Err("test");
+     * assert.equal(
+     *    result.$andThrough((val) => Ok(`ok-through:${val}`)).$unwrapErr(),
+     *    "test",
+     * );
+     * ```
      */
-    reduce(...args: unknown[]): unknown;
+    $andThrough<F = E>(this: Result<T, E>, f: (val: T) => ResultLike<any, F>): Result<T, E | F>;
     /**
-     * @deprecated
+     * Shorthand for `result.$async().$andThrough(...)`
      */
-    reduceRight(...args: unknown[]): unknown;
+    $andThroughAsync<F = E>(this: Result<T, E>, f: (val: T) => ResultLikeAwaitable<any, F>): ResultAsync<T, E | F>;
     /**
-     * @deprecated
+     * Returns a result based on the outcome of the safe function when this
+     * result is `Ok`.
+     *
+     * Otherwise, returns `Err` containing the current error value.
+     *
+     * Uses the same strategy as {@link Result.$safe}, equivalent to calling:
+     *
+     * ```ts
+     * result.$andThen(() => Result.$safe(...))
+     * ```
      */
-    reverse(...args: unknown[]): unknown;
+    $andSafe<U = T>(this: Result<T, E>, f: (val: T) => U): Result<U, E | Error>;
+    $andSafe<U = T, F = E>(this: Result<T, E>, f: (val: T) => U, mapError: (err: unknown) => F): Result<U, E | F>;
     /**
-     * @deprecated
+     * Shorthand for `result.$async().$andSafe(...)`
      */
-    shift(...args: unknown[]): unknown;
+    $andSafeAsync<U = T>(this: Result<T, E>, f: (val: T) => U | PromiseLike<U>): ResultAsync<U, E | Error>;
+    $andSafeAsync<U = T, F = E>(this: Result<T, E>, f: (val: T) => U | PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<U, E | F>;
     /**
-     * @deprecated
+     * Shorthand for `result.$async().$andSafePromise(...)`
      */
-    slice(...args: unknown[]): unknown;
+    $andSafePromise<U = T>(this: Result<T, E>, promise: PromiseLike<U>): ResultAsync<U, E | Error>;
+    $andSafePromise<U = T, F = E>(this: Result<T, E>, promise: PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<U, E | F>;
     /**
-     * @deprecated
+     * Execute a pipeline starting with the `Ok` value of this result, returning
+     * the `Ok` of the final function in the pipe or the first `Err` encountered.
+     * If you only need to execute a single function, use `$andThen`
+     *
+     * Uses the same strategy as {@link Result.$pipe}, equivalent to calling:
+     *
+     * ```ts
+     * result.$andThen(
+     *   (val) => Result.$pipe(
+     *     () => fn1(val),
+     *     (val2) => fn2(val2),
+     *   ),
+     * );
+     * ```
+     */
+    $andPipe<T0, E0, T1, E1>(this: ResultLike<T, E>, f0: (val: T) => ResultLike<T0, E0>, f1: (val: T0) => ResultLike<T1, E1>): Result<T1, E | E0 | E1>;
+    $andPipe<T0, E0, T1, E1, T2, E2>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>): Result<T2, E | E0 | E1 | E2>;
+    $andPipe<T0, E0, T1, E1, T2, E2, T3, E3>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>): Result<T3, E | E0 | E1 | E2 | E3>;
+    $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>): Result<T4, E | E0 | E1 | E2 | E3 | E4>;
+    $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>): Result<T5, E | E0 | E1 | E2 | E3 | E4 | E5>;
+    $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>, f6: (val5: T5) => ResultLike<T6, E6>): Result<T6, E | E0 | E1 | E2 | E3 | E4 | E5 | E6>;
+    $andPipe<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6, T7, E7>(f0: (val: T) => ResultLike<T0, E0>, f1: (val0: T0) => ResultLike<T1, E1>, f2: (val1: T1) => ResultLike<T2, E2>, f3: (val2: T2) => ResultLike<T3, E3>, f4: (val3: T3) => ResultLike<T4, E4>, f5: (val4: T4) => ResultLike<T5, E5>, f6: (val5: T5) => ResultLike<T6, E6>, f7: (val6: T6) => ResultLike<T7, E7>): Result<T7, E | E0 | E1 | E2 | E3 | E4 | E5 | E6 | E7>;
+    /**
+     * Shorthand for `result.$async().$andPipe(...)`
+     *
+     * If you only need to execute a single function, use `$andThenAsync`
+     */
+    $andPipeAsync<T0, E0, T1, E1>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>): ResultAsync<T1, E0 | E1>;
+    $andPipeAsync<T0, E0, T1, E1, T2, E2>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>): ResultAsync<T2, E0 | E1 | E2>;
+    $andPipeAsync<T0, E0, T1, E1, T2, E2, T3, E3>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>): ResultAsync<T3, E0 | E1 | E2 | E3>;
+    $andPipeAsync<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>): ResultAsync<T4, E0 | E1 | E2 | E3 | E4>;
+    $andPipeAsync<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>): ResultAsync<T5, E0 | E1 | E2 | E3 | E4 | E5>;
+    $andPipeAsync<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>): ResultAsync<T6, E0 | E1 | E2 | E3 | E4 | E5 | E6>;
+    $andPipeAsync<T0, E0, T1, E1, T2, E2, T3, E3, T4, E4, T5, E5, T6, E6, T7, E7>(f0: (val: T) => ResultLikeAwaitable<T0, E0>, f1: (val0: T0) => ResultLikeAwaitable<T1, E1>, f2: (val1: T1) => ResultLikeAwaitable<T2, E2>, f3: (val2: T2) => ResultLikeAwaitable<T3, E3>, f4: (val3: T3) => ResultLikeAwaitable<T4, E4>, f5: (val4: T4) => ResultLikeAwaitable<T5, E5>, f6: (val5: T5) => ResultLikeAwaitable<T6, E6>, f7: (val6: T6) => ResultLikeAwaitable<T7, E7>): ResultAsync<T7, E | E0 | E1 | E2 | E3 | E4 | E5 | E6 | E7>;
+    /**
+     * Calls the peek function and returns {@link Result} equivalent to this
+     * result.
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string, string> = Ok("test");
+     * assert.equal(
+     *    result
+     *       .$peek((res) => {
+     *          const [err, value] = res;
+     *
+     *          console.log("Err:", err); // Err: undefined
+     *          console.log("Value:", value); // Value: test
+     *       })
+     *       .$unwrap(),
+     *    "test",
+     * );
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string, string> = Err("test");
+     * assert.equal(
+     *    result
+     *       .$peek((res) => {
+     *          const [err, value] = res;
+     *
+     *          console.log("Err:", err); // Err: test
+     *          console.log("Value:", value); // Value: undefined
+     *       })
+     *       .$unwrapErr(),
+     *    "test",
+     * );
+     * ```
      */
-    some(...args: unknown[]): unknown;
+    $peek(this: Result<T, E>, f: (res: Result<T, E>) => void): Result<T, E>;
     /**
-     * @deprecated
+     * Calls the tap function when this result is `Ok`, and returns `Ok`
+     * containing the current ok value.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.equal(
+     *    result
+     *       .$tap((val) => console.log("Value:", val)) // Value: test
+     *       .$unwrap(),
+     *    "test",
+     * );
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Record<string, string> = Err("test");
+     * assert.equal(
+     *    result
+     *       .$tap((val) => console.log("Value:", val)) // not executed
+     *       .$unwrapErr(),
+     *    "test",
+     * );
+     * ```
      */
-    sort(...args: unknown[]): unknown;
+    $tap(this: Result<T, E>, f: (val: T) => any): Result<T, E>;
     /**
-     * @deprecated
+     * Calls the tap error function when this result is `Err`, and returns `Err`
+     * containing the current error value.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     * assert.equal(
+     *    result
+     *       .$tapErr((err) => console.log("Err:", err)) // Err: test
+     *       .$unwrapErr(),
+     *    "test",
+     * );
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Record<string, string> = Ok("test");
+     * assert.equal(
+     *    result
+     *       .$tapErr((err) => console.log("Err:", err)) // not executed
+     *       .$unwrap(),
+     *    "test",
+     * );
+     * ```
      */
-    splice(...args: unknown[]): unknown;
+    $tapErr(this: Result<T, E>, f: (err: E) => void): Result<T, E>;
     /**
-     * @deprecated
+     * Returns the contained {@link Result} when this result is `Ok`.
+     *
+     * Otherwise returns `Err` containing the current error value.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok(Ok("test"));
+     * assert.equal(result.$flatten().$unwrap(), "test");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok(Err("test"));
+     * assert.equal(result.$flatten().$unwrapErr(), "test");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     * assert.equal(result.$flatten().$unwrapErr(), "test");
+     * ```
      */
-    toString(...args: unknown[]): unknown;
+    $flatten<U, F>(this: Result<Result<U, F>, E>): Result<U, E | F>;
     /**
-     * @deprecated
+     * Returns an equivalent {@link ResultAsync}.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test").$async();
+     * assert.equal(await result.$unwrap(), "test");
+     * ```
+     * @example
+     *
+     * ```ts
+     * const result = Err("test").$async();
+     * assert.equal(await result.$unwrapErr(), "test");
+     * ```
      */
-    toLocaleString(...args: unknown[]): unknown;
+    $async(this: Result<T, E>): ResultAsync<T, E>;
     /**
-     * @deprecated
+     * Returns a `Promise` which resolves to this result.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test").$promise();
+     * assert.equal(await result, result);
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test").$promise();
+     * assert.equal(await result, result);
+     * ```
      */
-    unshift(...args: unknown[]): unknown;
+    $promise(this: Result<T, E>): Promise<Result<T, E>>;
     /**
-     * @deprecated
-     */
-    values(...args: unknown[]): unknown;
+     * Returns an `IterableIterator` over the contained ok value, when this
+     * result is `Ok`.
+     *
+     * Otherwise, returns an empty `IterableIterator`.
+     *
+     * This method should only be called when the `T` type is `Iterable`. This
+     * is enforced with a type constraint. If the ok value is not iterable,
+     * attempting to iterate over it will throw the built-in error.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok([1, 2, 3]);
+     *
+     * for (const n of result.$iter()) {
+     *    console.log(n); // 1.. 2.. 3
+     * }
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err([1, 2, 3]);
+     *
+     * for (const n of result.$iter()) {
+     *    console.log(n); // not executed, iterator is empty
+     * }
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok<any>(1);
+     *
+     * try {
+     *    for (const n of result.$iter()) {}
+     * } catch (err) {
+     *    // err is 'TypeError: number 1 is not iterable' in V8
+     * }
+     * ```
+     */
+    $iter<U>(this: Result<Iterable<U>, E>): IterableIterator<U, undefined, unknown>;
 }
+type OkTuple<T> = [err: undefined, value: T];
+type ErrTuple<E> = [err: E, value: undefined];
+type ResultLikeAwaitable<T, E> = ResultLike<T, E> | PromiseLike<ResultLike<T, E>>;
+type ObjectUnionOk<T> = {
+    success: true;
+    data: T;
+    error?: never | undefined;
+};
+type ObjectUnionErr<E> = {
+    success: false;
+    data?: never | undefined;
+    error: E;
+};
+type AllOk<TResults extends ResultLikeAwaitable<any, any>[]> = {
+    [K in keyof TResults]: TResults[K] extends ResultLikeAwaitable<infer T, any> ? T : never;
+};
+type AllErr<TResults extends ResultLikeAwaitable<any, any>[]> = TResults[number] extends ResultLikeAwaitable<any, infer E> ? E : never;
+type AnyOk<TResult extends ResultLikeAwaitable<any, any>[]> = TResult[number] extends ResultLikeAwaitable<infer T, any> ? T : never;
+type AnyErr<TResults extends ResultLikeAwaitable<any, any>[]> = {
+    [K in keyof TResults]: TResults[K] extends ResultLikeAwaitable<any, infer E> ? E : never;
+};
+type CollectOk<TResults extends Record<string, ResultLikeAwaitable<any, any>>> = {
+    [K in keyof TResults]: TResults[K] extends ResultLikeAwaitable<infer T, any> ? T : never;
+} & {};
+type CollectErr<TResults extends Record<string, ResultLikeAwaitable<any, any>>> = TResults[keyof TResults] extends ResultLikeAwaitable<any, infer E> ? E : never;
+type Truthy<T> = Exclude<T, false | null | undefined | 0 | 0n | "">;
+type Falsey<T> = Extract<T, false | null | undefined | 0 | 0n | "">;
+type NonZero<N extends number> = N & (`${N}` extends "0" ? never : N);
+type NonNegativeOrDecimal<N extends number> = N & (`${N}` extends `-${string}` | `${string}.${string}` ? never : N);