retuple 1.0.0-next.1 → 1.0.0-next.11

package/dist/index.d.cts

@@ -1,75 +1,776 @@
-export type Ok<T> = OkTuple<T> & Retuple<T, never>;
-export type Err<E> = ErrTuple<E> & Retuple<never, E>;
+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 declare class RetupleUnwrapFailed<E = unknown> extends Error {
+/**
+ * ## Retuple Unwrap Failed
+ *
+ * An error which occurs when calling `$unwrap` on `Err`.
+ */
+export declare class RetupleUnwrapFailed<const E = unknown> extends Error {
     value: E;
     constructor(value: E, msg?: string);
 }
-export declare class RetupleUnwrapErrFailed<T = unknown> extends Error {
+/**
+ * ## Retuple Unwrap Err Failed
+ *
+ * An error which occurs when calling `$unwrapErr` on `Ok`.
+ */
+export declare class RetupleUnwrapErrFailed<const T = unknown> extends Error {
     value: T;
     constructor(value: T, msg?: string);
 }
-export declare class RetupleExpectFailed<E = unknown> extends Error {
+/**
+ * ## Retuple Expect Failed
+ *
+ * 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 Expect Failed
+ *
+ * An error which occurs when calling `$flatten` on `Ok`, when the value
+ * contained in the `Ok` is not an `Ok` or `Err`.
+ */
+export declare class RetupleFlattenFailed<const T = unknown> extends Error {
+    value: T;
+    constructor(value: T);
+}
+/**
+ * ## Retuple Thrown Value 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.
+ */
 export declare class RetupleThrownValueError extends Error {
     value: unknown;
     constructor(value: unknown);
 }
+/**
+ * ## Retuple Invalid Result Error
+ *
+ * This error is thrown when attempting to construct a `Result` from a tuple,
+ * when neither index 0 or 1 are null or undefined. 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[]);
+}
+/**
+ * ## Retuple Array Method Unavailable Error
+ *
+ * This error is thrown when calling a built-in array method from a `Result`.
+ */
+export declare class RetupleArrayMethodUnavailableError extends Error {
+    value: unknown[];
+    constructor(value: unknown[], method: Exclude<keyof any[] & string, "length">);
+}
 /**
  * ## Result
  *
  * @TODO
  */
-export declare const Result: {
-    Ok: typeof Ok;
-    Err: typeof Err;
-    from: typeof from;
-    safe: typeof safe;
-    safeAsync: typeof safeAsync;
-    safePromise: typeof safePromise;
-};
-export default Result;
+export declare function Result<R extends [err: null | undefined, value: unknown] | [err: unknown, value: null | undefined]>(resultLike: R): (R extends [null | undefined, infer T] ? ThisOk<T> : R extends [infer E, null | undefined] ? ThisErr<E> : never) extends ThisOk<infer T> | ThisErr<infer E> ? Result<T, NonNullable<E>> : never;
+export declare namespace Result {
+    var Ok: typeof import(".").Ok;
+    var Err: typeof import(".").Err;
+    var $resolve: typeof resolve;
+    var $nonNullable: typeof nonNullable;
+    var $truthy: typeof truthy;
+    var $safe: typeof safe;
+    var $safeAsync: typeof safeAsync;
+    var $safePromise: typeof safePromise;
+}
 /**
- * ## Ok
+ * Create a new {@link Result} with the `Ok` variant. When called without
+ * arguments the `T` type is `void`.
  *
- * @TODO
+ * @example
+ *
+ * ```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 Ok(): Ok<void>;
-export declare function Ok<T>(val: T): Ok<T>;
+export declare function Ok(): Result<void, never>;
+export declare function Ok<const T>(val: T): Result<T, never>;
 /**
- * ## Err
+ * Create a new {@link Result} with the `Err` variant. When called without
+ * arguments the `E` type is `void`.
  *
- * @TODO
+ * @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 Err(): Err<void>;
-export declare function Err<E>(err: E): Err<E>;
+export declare function Err(): Result<never, void>;
+export declare function Err<const E>(err: E): Result<never, E>;
+declare function resolve<T, E>(result: Retuple<T, E> | PromiseLike<Retuple<T, E>>): ResultAsync<T, E>;
+/**
+ * Construct a {@link Result} from a value. If the value is neither null or
+ * undefined, the result is `Ok`.
+ *
+ * Otherwise, the result is `Err` containing:
+
+ * - the returned value from the error function when provided;
+ * - or `true` otherwise.
+ *
+ * @example
+ *
+ * ```ts
+ * const result: Result<User, Error> = Result.$nonNullable(
+ *    users.find((user) => user.id === currentUserId),
+ *    () => new Error("User not found"),
+ * );
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = Result.$nonNullable("test");
+ *
+ * assert.equal(err, undefined);
+ * assert.equal(value, "test");
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = Result.$nonNullable(null);
+ *
+ * assert.equal(err, true);
+ * assert.equal(value, undefined);
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = Result.$nonNullable(null, () => "error");
+ *
+ * assert.equal(err, "error");
+ * assert.equal(value, undefined);
+ * ```
+ */
+declare function nonNullable<const T>(value: T): Result<NonNullable<T>, true>;
+declare function nonNullable<const T, 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`.
+ *
+ * Otherwise, the result is `Err` containing:
+ *
+ * - the returned value from the error function when provided;
+ * - or `true` otherwise.
+ *
+ * @example
+ *
+ * ```ts
+ * const result: Result<string, Error> = Result.$truthy(
+ *    username.trim(),
+ *    () => new Error("Username is empty"),
+ * );
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = Result.$truthy("test");
+ *
+ * assert.equal(err, undefined);
+ * assert.equal(value, "test");
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = Result.$truthy("");
+ *
+ * assert.equal(err, true);
+ * assert.equal(value, undefined);
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = Result.$truthy(0, () => "error");
+ *
+ * assert.equal(err, "error");
+ * assert.equal(value, undefined);
+ * ```
  */
-export declare function from<T>(value: T): Result<Truthy<T>, true>;
-export declare function from<T, E>(value: T, error: () => E): Result<Truthy<T>, E>;
+declare function truthy<const T>(value: T): Result<Truthy<T>, true>;
+declare function truthy<const T, 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`.
+ *
+ * Otherwise, the result is `Err` containing (in priority order):
+ *
+ * - the returned value from the map error function when provided;
+ * - the thrown error when it is an instance of `Error`;
+ * - `RetupleThrownValueError` when a non `Error` instance is thrown.
+ *
+ * @example
+ *
+ * ```ts
+ * const result: Result<URL, Error> = Result.$safe(
+ *    () => new URL(user.url),
+ *    () => new Error("Invalid URL"),
+ * );
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = Result.$safe(() => "test");
+ *
+ * assert.equal(err, undefined);
+ * assert.equal(value, "test");
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = Result.$safe(
+ *    () => {
+ *       throw new Error("throws");
+ *    },
+ *    () => "error",
+ * );
+ *
+ * assert.equal(err, "error");
+ * assert.equal(value, undefined);
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = Result.$safe(
+ *    () => {
+ *       throw new Error("throws")
+ *    },
+ * );
+ *
+ * assert(err instanceof Error && err.message === "throws");
+ * assert.equal(value, undefined);
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = Result.$safe(() => {
+ *    throw "non error";
+ * });
+ *
+ * assert(err instanceof RetupleThrownValueError && err.value === "non error");
+ * assert.equal(value, undefined);
  */
-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>;
+declare function safe<T>(f: () => Awaited<T>): Result<T, Error>;
+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`.
+ *
+ * Otherwise, the result is `Err` containing (in priority order):
+ *
+ * - the returned value from the map error function when provided;
+ * - the thrown/rejected error when it is an instance of `Error`;
+ * - `RetupleThrownValueError` when throwing/rejecting with a non `Error`.
+ *
+ * @example
+ *
+ * ```ts
+ * const result: Result<Response, Error> = await Result.$safeAsync(
+ *    () => fetch("http://example.com/api"),
+ *    () => new Error("Fetch failed"),
+ * );
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = await Result.$safeAsync(async () => "test");
+ *
+ * assert.equal(err, undefined);
+ * assert.equal(value, "test");
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = await Result.$safeAsync(
+ *    async () => {
+ *       throw new Error("throws");
+ *    },
+ *    () => "error",
+ * );
+ *
+ * assert.equal(err, "error");
+ * assert.equal(value, undefined);
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = await Result.$safeAsync(
+ *    async () => {
+ *       throw new Error("throws")
+ *    },
+ * );
+ *
+ * assert(err instanceof Error && err.message === "throws");
+ * assert.equal(value, undefined);
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = await Result.$safeAsync(async () => {
+ *    throw "non error";
+ * });
+ *
+ * assert(err instanceof RetupleThrownValueError && err.value === "non error");
+ * assert.equal(value, undefined);
  */
-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>;
+declare function safeAsync<T>(f: () => T | PromiseLike<T>): ResultAsync<T, Error>;
+declare function safeAsync<T, E>(f: () => T | PromiseLike<T>, mapError: (err: unknown) => E): ResultAsync<T, E>;
 /**
  * Construct a {@link Result} from a promise. If the promise resolves, the
  * result is `Ok`.
+ *
+ * Otherwise, the result is `Err` containing (in priority order):
+ *
+ * - the returned value from the map error function when provided;
+ * - the rejected error when it is an instance of `Error`;
+ * - `RetupleThrownValueError` when rejecting with a non `Error`.
+ *
+ * @example
+ *
+ * ```ts
+ * const result: Result<Response, Error> = await Result.$safePromise(
+ *    fetch("http://example.com/api"),
+ *    () => new Error("Fetch failed"),
+ * );
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = await Result.$safePromise(Promise.resolve("test"));
+ *
+ * assert.equal(err, undefined);
+ * assert.equal(value, "test");
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = await Result.$safePromise(
+ *    Promise.reject(new Error("rejects")),
+ *    () => "error",
+ * );
+ *
+ * assert.equal(err, "error");
+ * assert.equal(value, undefined);
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = await Result.$safePromise(
+ *    Promise.reject(new Error("rejects")),
+ * );
+ *
+ * assert(err instanceof Error && err.message === "rejects");
+ * assert.equal(value, undefined);
+ * ```
+ *
+ * @example
+ *
+ * ```ts
+ * const [err, value] = await Result.$safeAsync(
+ *    Promise.reject("non error"),
+ * );
+ *
+ * assert(err instanceof RetupleThrownValueError && err.value === "non error");
+ * assert.equal(value, undefined);
+ */
+declare function safePromise<T>(promise: PromiseLike<T>): ResultAsync<T, Error>;
+declare function safePromise<T, E>(promise: PromiseLike<T>, mapError: (err: unknown) => E): ResultAsync<T, E>;
+/**
+ * ## RetupleArray
+ *
+ * Using built-in array methods on a `Result` is probably a mistake. This class
+ * makes the built-in methods throw `RetupleArrayMethodUnavailableError`.
  */
-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>;
+declare class RetupleArray<T> extends Array<T> {
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    at(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    concat(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    copyWithin(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    entries(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    every(): this is never[];
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    fill(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    filter(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    find(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    findIndex(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    findLast(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    findLastIndex(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    flat(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    flatMap(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    forEach(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    includes(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    indexOf(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    join(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    keys(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    lastIndexOf(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    map(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    pop(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    push(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    reduce(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    reduceRight(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    reverse(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    shift(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    slice(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    some(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    sort(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    splice(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    toString(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    toLocaleString(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    toReversed(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    toSorted(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    toSpliced(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    unshift(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    values(): never;
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    with(): never;
+}
 /**
  * ## ResultAsync
  *
@@ -78,209 +779,1174 @@ export declare function safePromise<T, E>(promise: PromiseLike<T>, mapError: (er
 declare class ResultAsync<T, E> {
     #private;
     constructor(inner: PromiseLike<Result<T, E>>);
-    then<TResult1 = Result<T, E>, TResult2 = never>(onfulfilled?: ((result: Result<T, E>) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: (reason: any) => TResult2 | PromiseLike<TResult2>): PromiseLike<TResult1 | TResult2>;
-    /**
-     * @TODO
-     */
-    $value(this: ResultAsync<T, E>): Promise<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
+     * 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
+     * The same as {@link Retuple.$unwrapErr|$unwrapErr}, except it returns
+     * a `Promise`.
      */
     $unwrapErr(this: ResultAsync<T, E>, msg?: string): Promise<E>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$unwrapOr|$unwrapOr}, except it returns
+     * a `Promise`.
      */
-    $unwrapOr<U>(this: ResultAsync<T, E>, def: U): Promise<T | U>;
+    $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`.
      */
     $unwrapOrElse<U = T>(this: ResultAsync<T, E>, f: () => U): Promise<T | U>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$map|$map}, except it returns `ResultAsync`.
      */
     $map<U>(this: ResultAsync<T, E>, f: (val: T) => U): ResultAsync<U, E>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$mapErr|$mapErr}, except it returns
+     * `ResultAsync`.
      */
-    $mapErr<F>(this: ResultAsync<T, E>, f: (err: E) => F): ResultAsync<T, F>;
+    $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 `ResultAsync`.
      */
-    $mapOr<U>(this: ResultAsync<T, E>, def: U, f: (val: T) => U): ResultAsync<U, 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
+     * `ResultAsync`.
      */
-    $mapOrElse<U>(this: ResultAsync<T, E>, def: (err: E) => U, f: (val: T) => U): ResultAsync<U, E>;
+    $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.$andAssertOr|$andAssertOr}, except it:
+     *
+     * - can also accept a `PromiseLike` default value;
+     * - returns `ResultAsync`.
      */
-    $or<U = T, F = E>(this: ResultAsync<T, E>, or: Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<T | U, E | F>;
+    $andAssertOr<U = T, F = E>(this: ResultAsync<T, E>, def: RetupleAwaitable<U, F>): ResultAsync<Truthy<T> | U, E | F>;
+    $andAssertOr<U = T, F = E, A extends T = T>(this: ResultAsync<T, E>, def: RetupleAwaitable<U, F>, predicate: (val: T) => val is A): ResultAsync<U | A, E | F>;
+    $andAssertOr<U = T, F = E>(this: ResultAsync<T, E>, def: RetupleAwaitable<U, F>, condition: (val: T) => unknown): ResultAsync<T | U, E | F>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$andAssertOrElse|$andAssertOrElse}, except it:
+     *
+     * - can also accept an `async` default function;
+     * - returns `ResultAsync`.
      */
-    $orElse<U = T, F = E>(this: ResultAsync<T, E>, f: (err: E) => Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<T | U, E | F>;
+    $andAssertOrElse<U = T, F = E>(this: ResultAsync<T, E>, def: (val: T) => RetupleAwaitable<U, F>): ResultAsync<Truthy<T> | U, E | F>;
+    $andAssertOrElse<U = T, F = E, A extends T = T>(this: ResultAsync<T, E>, def: (val: T) => RetupleAwaitable<U, F>, predicate: (val: T) => val is A): ResultAsync<U | A, E | F>;
+    $andAssertOrElse<U = T, F = E>(this: ResultAsync<T, E>, def: (val: T) => RetupleAwaitable<U, F>, condition: (val: T) => unknown): ResultAsync<T | U, E | F>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$or|$or}, except it:
+     *
+     * - can also accept a `PromiseLike` or value;
+     * - returns `ResultAsync`.
      */
-    $orSafe<U = T, F = Error>(this: ResultAsync<T, E>, f: (err: E) => U | PromiseLike<U>, mapError?: (err: unknown) => F): ResultAsync<T | U, E | F>;
+    $or<U = T, F = E>(this: ResultAsync<T, E>, or: Retuple<U, F> | PromiseLike<Retuple<U, F>>): ResultAsync<T | U, F>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$orElse|$orElse}, except it:
+     *
+     * - can also accept an `async` or function;
+     * - returns `ResultAsync`.
      */
-    $and<U = T, F = E>(this: ResultAsync<T, E>, and: Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<U, E | F>;
+    $orElse<U = T, F = E>(this: ResultAsync<T, E>, f: (err: E) => RetupleAwaitable<U, F>): ResultAsync<T | U, F>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$orSafe|$orSafe}, except it:
+     *
+     * - can also accept an `async` safe function;
+     * - returns `ResultAsync`.
      */
-    $andThen<U = T, F = E>(this: ResultAsync<T, E>, f: (val: T) => Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<U, E | F>;
+    $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
      */
-    $andThrough<F = E>(this: ResultAsync<T, E>, f: (val: T) => Result<any, F> | PromiseLike<Result<any, F>>): ResultAsync<T, E | F>;
+    $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 `ResultAsync`.
      */
-    $andSafe<U = T, F = Error>(this: ResultAsync<T, E>, f: (val: T) => U | PromiseLike<U>, mapError?: (err: unknown) => F): ResultAsync<U, E | F>;
+    $and<U = T, F = E>(this: ResultAsync<T, E>, and: RetupleAwaitable<U, F>): ResultAsync<U, E | F>;
+    /**
+     * The same as {@link Retuple.$andThen|$andThen}, except it:
+     *
+     * - can also accept an `async` and function;
+     * - returns `ResultAsync`.
+     */
+    $andThen<U = T, F = E>(this: ResultAsync<T, E>, f: (val: T) => RetupleAwaitable<U, F>): ResultAsync<U, E | F>;
+    /**
+     * The same as {@link Retuple.$andThrough|$andThrough}, except it:
+     *
+     * - can also accept an `async` through function;
+     * - returns `ResultAsync`.
+     */
+    $andThrough<F = E>(this: ResultAsync<T, E>, f: (val: T) => RetupleAwaitable<any, F>): ResultAsync<T, E | F>;
+    /**
+     * The same as {@link Retuple.$andSafe|$andSafe}, except it:
+     *
+     * - can also accept an `async` safe function;
+     * - returns `ResultAsync`.
+     */
+    $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
      */
+    $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>;
+    /**
+     * The same as {@link Retuple.$peek|$peek}, except it:
+     *
+     * - awaits the peek function;
+     * - returns `ResultAsync`.
+     */
     $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 `ResultAsync`.
      */
     $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 `ResultAsync`.
      */
     $tapErr(this: ResultAsync<T, E>, f: (err: E) => any): ResultAsync<T, E>;
     /**
-     * @TODO
+     * The same as {@link Retuple.$promise|$promise}.
      */
     $promise(this: ResultAsync<T, E>): Promise<Result<T, E>>;
+    /**
+     * The same as {@link Retuple.$tuple|$tuple}, except it returns a `Promise`.
+     */
+    $tuple(this: ResultAsync<T, E>): Promise<[err: E | undefined, value: T | undefined]>;
+    /**
+     * The same as {@link Retuple.$tuple|$iter}, except it returns a `Promise`.
+     */
+    $iter<U>(this: ResultAsync<Iterable<U>, E>): Promise<IterableIterator<U, undefined, unknown>>;
 }
+type Truthy<T> = Exclude<T, false | null | undefined | 0 | 0n | "">;
 type OkTuple<T> = [err: undefined, value: T];
 type ErrTuple<E> = [err: E, value: undefined];
-/**
- * @TODO - Result.all / Result.any
- */
-interface Retuple<T, E> {
-    /**
-     * @TODO
-     */
-    $isOk(this: Result<T, E>): this is Ok<T>;
+type ThisOk<T> = OkTuple<T> & Retuple<T, never>;
+type ThisErr<E> = ErrTuple<E> & Retuple<never, E>;
+type RetupleAwaitable<T, E> = Retuple<T, E> | PromiseLike<Retuple<T, E>>;
+interface Retuple<T, E> extends RetupleArray<T | E | undefined> {
     /**
-     * @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>;
+     * }
+     * ```
      */
-    $isOkAnd<U extends T = T>(this: Result<T, E>, f: ((val: T) => val is U) | ((val: T) => boolean)): this is Ok<U>;
+    $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>;
+     * }
+     * ```
      */
-    $isErr(this: Result<T, E>): this is Err<E>;
+    $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>;
+     * }
+     * ```
      */
-    $isErrAnd<F extends E = E>(this: Result<T, E>, f: ((err: E) => err is F) | ((err: E) => boolean)): this is Err<F>;
+    $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>;
+     * }
+     * ```
      */
-    $value(this: Result<T, E>): 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>;
     /**
-     * @TODO
+     * 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;
     /**
-     * @TODO
+     * 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`
+     *   );
+     * }
+     * ```
      */
     $unwrap(this: Result<T, E>, msg?: string): T;
     /**
-     * @TODO
+     * 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",
+     *   );
+     * }
+     * ```
      */
     $unwrapErr(this: Result<T, E>, msg?: string): E;
     /**
-     * @TODO
+     * 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");
+     * ```
      */
-    $unwrapOr<U = T>(this: Result<T, E>, def: U): T | U;
+    $unwrapOr<const U = T>(this: Result<T, E>, def: U): T | U;
     /**
-     * @TODO
+     * 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");
+     * ```
      */
     $unwrapOrElse<U = T>(this: Result<T, E>, f: () => U): T | U;
     /**
-     * @TODO
+     * Performs an assertion when this result is `Ok`:
+     *
+     * - returning `Ok` containing the current ok value when it is truthy, and
+     *   when no predicate/condition function is provided. Narrows the `T` type
+     *   to include only truthy values;
+     * - returning `Ok` containing the current ok value when a
+     *   predicate/condition function  is provided and it returns a truthy value.
+     *   Narrows the `T` type to the predicate type (if any);
+     * - returning the default result when no predicate/condition function is
+     *   provided and the current ok value is falsey;
+     * - returning the default result when a predicate/condition function is
+     *   provided and it returns a falsey value.
+     *
+     * Otherwise returns `Err` containing the current error value.
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string | null, string> = Ok("test");
+     * const asserted = result.$andAssertOr(Ok("ok-default"));
+     *
+     * asserted satisfies Result<string, string>;
+     * assert.equal(asserted.$unwrap(), "test");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string | null, string> = Ok("test");
+     * const asserted = result.$andAssertOr(
+     *    Err("err-default"),
+     *    (val): val is "test" => val === "test",
+     * );
+     *
+     * asserted satisfies Result<"test", string>;
+     * assert.equal(asserted.$unwrap(), "test");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string | null, string> = Ok(null);
+     * const asserted = result.$andAssertOr(Ok("ok-default"));
+     *
+     * asserted satisfies Result<string, string>;
+     * assert.equal(asserted.$unwrap(), "ok-default");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string | null, string> = Ok("value");
+     * const asserted = result.$andAssertOr(
+     *    Err("err-default"),
+     *    (val): val is "test" => val === "test",
+     * );
+     *
+     * asserted satisfies Result<"test", string>;
+     * assert.equal(asserted.$unwrapErr(), "err-default");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string | null, string> = Err("test");
+     * const asserted = result.$andAssertOr(
+     *    Err("err-default"),
+     *    (val): val is "test" => val === "test",
+     * );
+     *
+     * asserted satisfies Result<"test", string>;
+     * assert.equal(asserted.$unwrapErr(), "test");
+     * ```
+     */
+    $andAssertOr<U = T, F = E>(this: Result<T, E>, def: Result<U, F>): Result<Truthy<T> | U, E | F>;
+    $andAssertOr<U = T, F = E, A extends T = T>(this: Result<T, E>, def: Result<U, F>, predicate: (val: T) => val is A): Result<U | A, E | F>;
+    $andAssertOr<U = T, F = E>(this: Result<T, E>, def: Result<U, F>, condition: (val: T) => unknown): Result<T | U, E | F>;
+    /**
+     * Performs an assertion when this result is `Ok`:
+     *
+     * - returning `Ok` containing the current ok value when it is truthy, and
+     *   when no predicate/condition function is provided. Narrows the `T` type
+     *   to include only truthy values;
+     * - returning `Ok` containing the current ok value when a
+     *   predicate/condition function  is provided and it returns a truthy value.
+     *   Narrows the `T` type to the predicate type (if any);
+     * - returning the result returned by the default function when no
+     *   predicate/condition function is provided and the current ok value is
+     *   falsey;
+     * - returning the result returned by the default function when a
+     *   predicate/condition function is  provided and it returns a falsey value.
+     *
+     * Otherwise returns `Err` containing the current error value.
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string | null, string> = Ok("test");
+     * const asserted = result.$andAssertOrElse(
+     *    (val) => Ok(`ok-default:${val}`),
+     * );
+     *
+     * asserted satisfies Result<string, string>;
+     * assert.equal(asserted.$unwrap(), "test");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string | null, string> = Ok("test");
+     * const asserted = result.$andAssertOrElse(
+     *    (val) => Err(`err-default:${val}`),
+     *    (val): val is "test" => val === "test",
+     * );
+     *
+     * asserted satisfies Result<"test", string>;
+     * assert.equal(asserted.$unwrap(), "test");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string | null, string> = Ok(null);
+     * const asserted = result.$andAssertOrElse(
+     *    (val) => Ok(`ok-default:${val}`),
+     * );
+     *
+     * asserted satisfies Result<string, string>;
+     * assert.equal(asserted.$unwrap(), "ok-default:null");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string | null, string> = Ok("value");
+     * const asserted = result.$andAssertOrElse(
+     *    (val) => Err(`err-default:${val}`),
+     *    (val): val is "test" => val === "test",
+     * );
+     *
+     * asserted satisfies Result<"test", string>;
+     * assert.equal(asserted.$unwrapErr(), "err-default:value");
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result: Result<string | null, string> = Err("test");
+     * const asserted = result.$andAssertOrElse(
+     *    (val) => Err(`err-default:${val}`),
+     *    (val): val is "test" => val === "test",
+     * );
+     *
+     * asserted satisfies Result<"test", string>;
+     * assert.equal(asserted.$unwrapErr(), "test");
+     * ```
+     */
+    $andAssertOrElse<U = T, F = E>(this: Result<T, E>, def: (val: T) => Result<U, F>): Result<Truthy<T> | U, E | F>;
+    $andAssertOrElse<U = T, F = E, A extends T = T>(this: Result<T, E>, def: (val: T) => Result<U, F>, predicate: (val: T) => val is A): Result<U | A, E | F>;
+    $andAssertOrElse<U = T, F = E>(this: Result<T, E>, def: (val: T) => Result<U, F>, condition: (val: T) => unknown): Result<T | U, E | F>;
+    /**
+     * 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: (value: T) => U): Result<U, E>;
     /**
-     * @TODO
+     * Returns `Err` containing the return value of the map 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>(this: Result<T, E>, f: (err: E) => F): Result<T, F>;
+    $mapErr<F = E>(this: Result<T, E>, f: (err: E) => F): Result<T, F>;
     /**
-     * @TODO
+     * 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>(this: Result<T, E>, def: U, f: (val: T) => U): Result<U, E>;
+    $mapOr<U, V = U>(this: Result<T, E>, def: U, f: (val: T) => V): Result<U | V, E>;
     /**
-     * @TODO
+     * 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>(this: Result<T, E>, def: (err: E) => U, f: (val: T) => U): Result<U, E>;
+    $mapOrElse<U, V = U>(this: Result<T, E>, def: (err: E) => U, f: (val: T) => V): Result<U | V, E>;
     /**
-     * @TODO
+     * 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",
+     * );
+     * ```
      */
-    $or<U = T, F = E>(this: Result<T, E>, or: Result<U, F>): Result<T | U, E | F>;
+    $or<U = T, F = E>(this: Result<T, E>, or: Result<U, F>): Result<T | U, F>;
     /**
-     * @TODO
+     * 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",
+     * );
+     * ```
      */
-    $orElse<U = never, F = never>(this: Result<T, E>, f: (err: E) => Result<U, F>): Result<T | U, E | F>;
+    $orElse<U = T, F = E>(this: Result<T, E>, f: (err: E) => Result<U, F>): Result<T | U, F>;
     /**
-     * @TODO
+     * Returns a `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(...))`.
      */
-    $orSafe<U = T>(this: Result<T, E>, f: (err: E) => U): Result<T | U, E | Error>;
-    $orSafe<U = T, F = E>(this: Result<T, E>, f: (err: E) => U, mapError: (err: unknown) => F): Result<T | U, E | F>;
-    $orSafe<U = T, F = Error>(this: Result<T, E>, f: (err: E) => U, mapError: (err: unknown) => F): Result<T | U, E | F>;
+    $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>;
     /**
-     * @TODO
+     * 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",
+     * );
+     * ```
      */
     $and<U = T, F = E>(this: Result<T, E>, and: Result<U, F>): Result<U, E | F>;
     /**
-     * @TODO
+     * 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 = never, F = never>(this: Result<T, E>, f: (val: T) => Result<U, F>): Result<U, E | F>;
+    $andThen<U = T, F = E>(this: Result<T, E>, f: (val: T) => Result<U, F>): Result<U, E | F>;
     /**
-     * @TODO
+     * 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",
+     * );
+     * ```
      */
-    $andThrough<F = never>(this: Result<T, E>, f: (val: T) => Result<any, F>): Result<T, E | F>;
+    $andThrough<F = E>(this: Result<T, E>, f: (val: T) => Result<any, F>): Result<T, E | F>;
     /**
-     * @TODO
+     * 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
+     * `result.$and(Result.$safe(...))`.
      */
-    $andSafe<U = T>(this: Result<T, E>, f: (val: T) => U): Result<T | U, E | Error>;
-    $andSafe<U = T, F = E>(this: Result<T, E>, f: (val: T) => U, mapError: (err: unknown) => F): Result<T | U, E | F>;
-    $andSafe<U, F = Error>(this: Result<T, E>, f: (val: T) => U, mapError: (err: unknown) => F): Result<T | U, E | F>;
+    $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>;
     /**
      * @TODO
      */
+    /**
+     * Calls the peek function and returns `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",
+     * );
+     * ```
+     */
     $peek(this: Result<T, E>, f: (res: Result<T, E>) => void): Result<T, E>;
     /**
-     * @TODO
+     * 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",
+     * );
+     * ```
      */
     $tap(this: Result<T, E>, f: (val: T) => any): Result<T, E>;
     /**
-     * @TODO
+     * 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",
+     * );
+     * ```
      */
     $tapErr(this: Result<T, E>, f: (err: E) => void): Result<T, E>;
     /**
-     * @TODO
+     * Returns the contained `Result` when this result is `Ok`.
+     *
+     * Otherwise returns `Err` containing the current error value.
+     *
+     * This method should only be called when the `T` type is `Result`. This
+     * is enforced with a type constraint. If the ok value is not
+     * a result, `RetupleFlattenFailed` is thrown.
+     *
+     * @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");
+     * ```
      */
     $flatten<U, F>(this: Result<Result<U, F>, E>): Result<U, E | F>;
     /**
-     * @TODO
+     * Returns an equivalent `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");
+     * ```
      */
     $async(this: Result<T, E>): ResultAsync<T, E>;
     /**
-     * @TODO
+     * 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);
+     * ```
      */
     $promise(this: Result<T, E>): Promise<Result<T, E>>;
+    /**
+     * Returns a two-element, standard array tuple equivalent to this result.
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Ok("test");
+     * assert.deepEqual(result.$tuple(), [undefined, "test"]);
+     * ```
+     *
+     * @example
+     *
+     * ```ts
+     * const result = Err("test");
+     * assert.deepEqual(result.$tuple(), ["test", undefined]);
+     * ```
+     */
+    $tuple(this: Result<T, E>): [err: E | undefined, value: T | undefined];
+    /**
+     * 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 Truthy<T> = Exclude<T, false | null | undefined | 0 | 0n | "">;