retuple 1.0.0-next.25 → 1.0.0-next.27

package/dist/index.cjs

@@ -12,7 +12,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _ResultAsync_inner, _a, _ResultRetry_f, _ResultRetry_promise, _ResultRetry_times, _ResultRetry_attempt, _ResultRetry_aborted, _ResultRetry_abort, _ResultRetry_getDelay, _ResultRetry_handler;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RetupleCheckFailedError = exports.RetupleInvalidUnionError = exports.RetupleCaughtValueError = exports.RetupleExpectFailed = exports.RetupleUnwrapErrFailed = exports.RetupleUnwrapFailed = void 0;
+exports.RetupleInvalidUnionError = exports.RetupleCaughtValueError = exports.RetupleIndexFailed = exports.RetupleFilterFailed = exports.RetupleAssertFailed = exports.RetupleExpectFailed = exports.RetupleUnwrapErrFailed = exports.RetupleUnwrapFailed = void 0;
 exports.Result = Result;
 exports.Ok = Ok;
 exports.Err = Err;
@@ -54,6 +54,46 @@ class RetupleExpectFailed extends Error {
     }
 }
 exports.RetupleExpectFailed = RetupleExpectFailed;
+/**
+ * ## Retuple Assert Failed
+ *
+ * This error is used as the error type of a `Result` when using $assert,
+ * when no map error function is provided.
+ */
+class RetupleAssertFailed extends Error {
+    constructor(value) {
+        super("Assert failed");
+        this.value = value;
+    }
+}
+exports.RetupleAssertFailed = RetupleAssertFailed;
+/**
+ * ## Retuple Filter Failed
+ *
+ * This error is used as the error type of a `Result` when using $filter,
+ * when no map error function is provided.
+ */
+class RetupleFilterFailed extends Error {
+    constructor(value) {
+        super("Filter failed");
+        this.value = value;
+    }
+}
+exports.RetupleFilterFailed = RetupleFilterFailed;
+/**
+ * ## 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.
+ */
+class RetupleIndexFailed extends Error {
+    constructor(index, value) {
+        super("Index failed");
+        this.index = index;
+        this.value = value;
+    }
+}
+exports.RetupleIndexFailed = RetupleIndexFailed;
 /**
  * ## Retuple Thrown Value Error
  *
@@ -84,19 +124,6 @@ class RetupleInvalidUnionError extends Error {
     }
 }
 exports.RetupleInvalidUnionError = RetupleInvalidUnionError;
-/**
- * ## Retuple Check Failed Error
- *
- * This error is used as the error type of a `Result` when using $andAssert
- * or $andCheck, when no custom error handler is provided.
- */
-class RetupleCheckFailedError extends Error {
-    constructor(value) {
-        super("Check failed");
-        this.value = value;
-    }
-}
-exports.RetupleCheckFailedError = RetupleCheckFailedError;
 /**
  * ## Result
  *
@@ -579,19 +606,33 @@ class ResultOk extends Array {
     $mapOrElse(_def, f) {
         return Ok(f(this[1]));
     }
-    $assert(mapError = mapCheckError) {
-        return this[1] ? this : Err(mapError(this[1]));
+    $assert(mapError) {
+        return this[1]
+            ? this
+            : Err(mapError
+                ? mapError(this[1])
+                : new RetupleAssertFailed(this[1]));
     }
-    $check(check, mapError = mapCheckError) {
-        return check(this[1]) ? this : Err(mapError(this[1]));
+    $filter(filter, mapError) {
+        return filter(this[1])
+            ? this
+            : Err(mapError ? mapError(this[1]) : new RetupleFilterFailed(this[1]));
     }
-    $atIndex(index, mapError = mapCheckError) {
+    $atIndex(index, mapError) {
         const element = this[1][index];
-        return element ? Ok(element) : Err(mapError(this[1]));
+        return element
+            ? Ok(element)
+            : Err(mapError
+                ? mapError(this[1])
+                : new RetupleIndexFailed(index, this[1]));
     }
-    $firstIndex(mapError = mapCheckError) {
+    $firstIndex(mapError) {
         const first = this[1][0];
-        return first ? Ok(first) : Err(mapError(this[1]));
+        return first
+            ? Ok(first)
+            : Err(mapError
+                ? mapError(this[1])
+                : new RetupleIndexFailed(0, this[1]));
     }
     $or() {
         return this;
@@ -739,7 +780,7 @@ class ResultErr extends Array {
     $assert() {
         return this;
     }
-    $check() {
+    $filter() {
         return this;
     }
     $atIndex() {
@@ -922,40 +963,54 @@ class ResultAsync {
                 : new ResultOk(def(res[0]));
         }));
     }
-    $assert(mapError = mapCheckError) {
+    $assert(mapError) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             if (res instanceof ResultErr) {
                 return res;
             }
             return res[1]
                 ? res
-                : Err(mapError(res[1]));
+                : Err(mapError
+                    ? mapError(res[1])
+                    : new RetupleAssertFailed(res[1]));
         }));
     }
-    $check(check, mapError = mapCheckError) {
+    $filter(check, mapError) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             if (res instanceof ResultErr) {
                 return res;
             }
-            return check(res[1]) ? res : Err(mapError(res[1]));
+            return check(res[1])
+                ? res
+                : Err(mapError
+                    ? mapError(res[1])
+                    : new RetupleFilterFailed(res[1]));
         }));
     }
-    $atIndex(index, mapError = mapCheckError) {
+    $atIndex(index, mapError) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then((res) => {
             if (res instanceof ResultErr) {
                 return res;
             }
             const element = res[1][index];
-            return element ? Ok(element) : Err(mapError(res[1]));
+            return element
+                ? Ok(element)
+                : Err(mapError
+                    ? mapError(res[1])
+                    : new RetupleIndexFailed(index, res[1]));
         }));
     }
-    $firstIndex(mapError = mapCheckError) {
+    $firstIndex(mapError) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then((res) => {
             if (res instanceof ResultErr) {
                 return res;
             }
             const first = res[1][0];
-            return first ? Ok(first) : Err(mapError(res[1]));
+            return first
+                ? Ok(first)
+                : Err(mapError
+                    ? mapError(res[1])
+                    : new RetupleIndexFailed(0, res[1]));
         }));
     }
     $or(or) {
@@ -1272,6 +1327,3 @@ function ensureError(err) {
 function mapTrue() {
     return true;
 }
-function mapCheckError(value) {
-    return new RetupleCheckFailedError(value);
-}

package/dist/index.d.cts

@@ -36,6 +36,37 @@ 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
  *
@@ -59,16 +90,6 @@ export declare class RetupleInvalidUnionError extends Error {
     value: unknown;
     constructor(value: unknown);
 }
-/**
- * ## Retuple Check Failed Error
- *
- * This error is used as the error type of a `Result` when using $andAssert
- * or $andCheck, when no custom error handler is provided.
- */
-export declare class RetupleCheckFailedError<const T = unknown> extends Error {
-    value: T;
-    constructor(value: T);
-}
 /**
  * ## Result
  *
@@ -226,30 +247,30 @@ declare class ResultAsync<T, E> {
      */
     $mapOrElse<U, V = U>(this: ResultAsync<T, E>, def: (err: E) => U, f: (val: T) => V): ResultAsync<U | V, never>;
     /**
-     * The same as {@link Retuple.$check|$andAssert}, except it returns
+     * The same as {@link Retuple.$assert|$assert}, except it returns
      * {@link ResultAsync}.
      */
-    $assert(this: ResultAsync<T, E>): ResultAsync<Truthy<T>, E | RetupleCheckFailedError<T>>;
-    $assert<F = E>(this: ResultAsync<T, E>, mapError: (val: T) => F): ResultAsync<Truthy<T>, E | F>;
+    $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>;
     /**
-     * The same as {@link Retuple.$check|$andCheck}, except it returns
+     * The same as {@link Retuple.$filter|$filter}, except it returns
      * {@link ResultAsync}.
      */
-    $check<U extends T = T>(this: ResultAsync<T, E>, predicate: (val: T) => val is U): ResultAsync<U, E | RetupleCheckFailedError<T>>;
-    $check(this: ResultAsync<T, E>, check: (val: T) => unknown): ResultAsync<T, E | RetupleCheckFailedError<T>>;
-    $check<U extends T = T, F = E>(this: ResultAsync<T, E>, predicate: (val: T) => val is U, mapError: (val: T) => F): ResultAsync<U, E | F>;
-    $check<F = E>(this: ResultAsync<T, E>, check: (val: T) => unknown, mapError: (val: T) => F): ResultAsync<T, E | F>;
+    $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>;
     /**
      * The same as {@link Retuple.$atIndex|$atIndex}, except it returns
      * {@link ResultAsync}.
      */
-    $atIndex<U>(this: ResultAsync<readonly U[], E>, index: number): ResultAsync<U, E | RetupleCheckFailedError<T>>;
+    $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>;
     /**
      * The same as {@link Retuple.$firstIndex|$firstIndex}, except it returns
      * {@link ResultAsync}.
      */
-    $firstIndex<U>(this: ResultAsync<readonly U[], E>): ResultAsync<U, E | RetupleCheckFailedError<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>;
     /**
      * The same as {@link Retuple.$or|$or}, except it:
@@ -791,7 +812,7 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      *   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 RetupleCheckFailedError} when the
+     * - 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.
@@ -800,7 +821,7 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      *
      * ```ts
      * const result: Result<string | null, never> = Ok("test");
-     * const asserted = result.$andAssert();
+     * const asserted = result.$assert();
      *
      * asserted satisfies Result<string, RetupleCheckFailedError<string | null>>;
      * assert.equal(asserted.$unwrap(), "test");
@@ -810,7 +831,7 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      *
      * ```ts
      * const result: Result<string | null | undefined, never> = Ok(null);
-     * const asserted = result.$andAssert(
+     * const asserted = result.$assert(
      *   (val) => val === null ? "value was null" : "value was undefined"
      * );
      *
@@ -818,17 +839,17 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      * assert.equal(asserted.$unwrapErr(), "value was null");
      * ```
      */
-    $assert(this: Result<T, E>): Result<Truthy<T>, E | RetupleCheckFailedError<T>>;
-    $assert<F = E>(this: Result<T, E>, mapError: (val: T) => F): Result<Truthy<T>, E | F>;
+    $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>;
     /**
      * Performs a check when this result is `Ok`:
      *
-     * - returning `Ok` containing the current ok value when the predicate/check
-     *   function returns true. Narrows the `T` type based on the check function;
+     * - 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 check;
-     * - returning `Err` containing {@link RetupleCheckFailedError} when the
-     *   ok value fails the check, and when no map error function is provided.
+     *   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.
      *
@@ -836,7 +857,7 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      *
      * ```ts
      * const result: Result<string, never> = Ok("test");
-     * const asserted = result.$andCheck((val) => val === "test");
+     * const asserted = result.$filter((val) => val === "test");
      *
      * asserted satisfies Result<string, RetupleCheckFailedError<string>>;
      * assert.equal(asserted.$unwrap(), "test");
@@ -846,7 +867,7 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      *
      * ```ts
      * const result: Result<string, never> = Ok("test");
-     * const checked = result.$andCheck(
+     * const checked = result.$filter(
      *   (val) => val === "value",
      *   (val) => `value was ${val}`,
      * );
@@ -855,10 +876,10 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      * assert.equal(checked.$unwrapErr(), "value was test");
      * ```
      */
-    $check<U extends T = T>(this: Result<T, E>, predicate: (val: T) => val is U): Result<U, E | RetupleCheckFailedError<T>>;
-    $check(this: Result<T, E>, check: (val: T) => unknown): Result<T, E | RetupleCheckFailedError<T>>;
-    $check<U extends T = T, F = E>(this: Result<T, E>, predicate: (val: T) => val is U, mapError: (val: T) => F): Result<U, E | F>;
-    $check<F = E>(this: Result<T, E>, check: (val: T) => unknown, mapError: (val: T) => F): Result<T, E | F>;
+    $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>;
     /**
      * Checks the specified element of the contained array when when this result
      * is `Ok`:
@@ -866,9 +887,9 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      * - 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 first array element fails the check;
-     * - returning `Err` containing {@link RetupleCheckFailedError} when the
-     *   first array elemnt fails the check, and when no map error function is
+     *   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.
@@ -876,8 +897,8 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      * @example
      *
      * ```ts
-     * const result: Result<(string | null)[], never> = Ok(["test", null]);
-     * const first = result.$andFirst();
+     * 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");
@@ -886,8 +907,9 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      * @example
      *
      * ```ts
-     * const result: Result<(string | null | undefined)[], never> = Ok([null, "test"]);
-     * const first = result.$andFirst(
+     * const result: Result<(string | null | undefined)[], never> = Ok(["test", null]);
+     * const first = result.$atIndex(
+     *   1,
      *   (val) => val === null ? "value was null" : "value was undefined",
      * );
      *
@@ -895,12 +917,12 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      * assert.equal(first.$unwrapErr(), "value was null");
      * ```
      */
-    $atIndex<U>(this: Result<readonly U[], E>, index: number): Result<Truthy<U>, E | RetupleCheckFailedError<T>>;
+    $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>;
     /**
      * Equivalent to calling `result.$atIndex(0)`.
      */
-    $firstIndex<U>(this: Result<readonly U[], E>): Result<Truthy<U>, E | RetupleCheckFailedError<T>>;
+    $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>;
     /**
      * Returns `Ok` containing the return value of the map function when this
@@ -1518,17 +1540,18 @@ type ObjectUnionErr<E> = {
     error: E;
 };
 type AllOk<TResults extends ResultLikeAwaitable<any, any>[]> = {
-    [K in keyof TResults]: TResults[K] extends Result<infer T, any> ? T : never;
+    [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 Result<any, infer E> ? E : never;
+    [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 Result<infer T, any> ? T : never;
+    [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 Result<any, infer E> ? E : 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);

package/dist/index.d.ts

@@ -36,6 +36,37 @@ 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
  *
@@ -59,16 +90,6 @@ export declare class RetupleInvalidUnionError extends Error {
     value: unknown;
     constructor(value: unknown);
 }
-/**
- * ## Retuple Check Failed Error
- *
- * This error is used as the error type of a `Result` when using $andAssert
- * or $andCheck, when no custom error handler is provided.
- */
-export declare class RetupleCheckFailedError<const T = unknown> extends Error {
-    value: T;
-    constructor(value: T);
-}
 /**
  * ## Result
  *
@@ -226,30 +247,30 @@ declare class ResultAsync<T, E> {
      */
     $mapOrElse<U, V = U>(this: ResultAsync<T, E>, def: (err: E) => U, f: (val: T) => V): ResultAsync<U | V, never>;
     /**
-     * The same as {@link Retuple.$check|$andAssert}, except it returns
+     * The same as {@link Retuple.$assert|$assert}, except it returns
      * {@link ResultAsync}.
      */
-    $assert(this: ResultAsync<T, E>): ResultAsync<Truthy<T>, E | RetupleCheckFailedError<T>>;
-    $assert<F = E>(this: ResultAsync<T, E>, mapError: (val: T) => F): ResultAsync<Truthy<T>, E | F>;
+    $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>;
     /**
-     * The same as {@link Retuple.$check|$andCheck}, except it returns
+     * The same as {@link Retuple.$filter|$filter}, except it returns
      * {@link ResultAsync}.
      */
-    $check<U extends T = T>(this: ResultAsync<T, E>, predicate: (val: T) => val is U): ResultAsync<U, E | RetupleCheckFailedError<T>>;
-    $check(this: ResultAsync<T, E>, check: (val: T) => unknown): ResultAsync<T, E | RetupleCheckFailedError<T>>;
-    $check<U extends T = T, F = E>(this: ResultAsync<T, E>, predicate: (val: T) => val is U, mapError: (val: T) => F): ResultAsync<U, E | F>;
-    $check<F = E>(this: ResultAsync<T, E>, check: (val: T) => unknown, mapError: (val: T) => F): ResultAsync<T, E | F>;
+    $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>;
     /**
      * The same as {@link Retuple.$atIndex|$atIndex}, except it returns
      * {@link ResultAsync}.
      */
-    $atIndex<U>(this: ResultAsync<readonly U[], E>, index: number): ResultAsync<U, E | RetupleCheckFailedError<T>>;
+    $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>;
     /**
      * The same as {@link Retuple.$firstIndex|$firstIndex}, except it returns
      * {@link ResultAsync}.
      */
-    $firstIndex<U>(this: ResultAsync<readonly U[], E>): ResultAsync<U, E | RetupleCheckFailedError<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>;
     /**
      * The same as {@link Retuple.$or|$or}, except it:
@@ -791,7 +812,7 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      *   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 RetupleCheckFailedError} when the
+     * - 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.
@@ -800,7 +821,7 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      *
      * ```ts
      * const result: Result<string | null, never> = Ok("test");
-     * const asserted = result.$andAssert();
+     * const asserted = result.$assert();
      *
      * asserted satisfies Result<string, RetupleCheckFailedError<string | null>>;
      * assert.equal(asserted.$unwrap(), "test");
@@ -810,7 +831,7 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      *
      * ```ts
      * const result: Result<string | null | undefined, never> = Ok(null);
-     * const asserted = result.$andAssert(
+     * const asserted = result.$assert(
      *   (val) => val === null ? "value was null" : "value was undefined"
      * );
      *
@@ -818,17 +839,17 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      * assert.equal(asserted.$unwrapErr(), "value was null");
      * ```
      */
-    $assert(this: Result<T, E>): Result<Truthy<T>, E | RetupleCheckFailedError<T>>;
-    $assert<F = E>(this: Result<T, E>, mapError: (val: T) => F): Result<Truthy<T>, E | F>;
+    $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>;
     /**
      * Performs a check when this result is `Ok`:
      *
-     * - returning `Ok` containing the current ok value when the predicate/check
-     *   function returns true. Narrows the `T` type based on the check function;
+     * - 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 check;
-     * - returning `Err` containing {@link RetupleCheckFailedError} when the
-     *   ok value fails the check, and when no map error function is provided.
+     *   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.
      *
@@ -836,7 +857,7 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      *
      * ```ts
      * const result: Result<string, never> = Ok("test");
-     * const asserted = result.$andCheck((val) => val === "test");
+     * const asserted = result.$filter((val) => val === "test");
      *
      * asserted satisfies Result<string, RetupleCheckFailedError<string>>;
      * assert.equal(asserted.$unwrap(), "test");
@@ -846,7 +867,7 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      *
      * ```ts
      * const result: Result<string, never> = Ok("test");
-     * const checked = result.$andCheck(
+     * const checked = result.$filter(
      *   (val) => val === "value",
      *   (val) => `value was ${val}`,
      * );
@@ -855,10 +876,10 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      * assert.equal(checked.$unwrapErr(), "value was test");
      * ```
      */
-    $check<U extends T = T>(this: Result<T, E>, predicate: (val: T) => val is U): Result<U, E | RetupleCheckFailedError<T>>;
-    $check(this: Result<T, E>, check: (val: T) => unknown): Result<T, E | RetupleCheckFailedError<T>>;
-    $check<U extends T = T, F = E>(this: Result<T, E>, predicate: (val: T) => val is U, mapError: (val: T) => F): Result<U, E | F>;
-    $check<F = E>(this: Result<T, E>, check: (val: T) => unknown, mapError: (val: T) => F): Result<T, E | F>;
+    $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>;
     /**
      * Checks the specified element of the contained array when when this result
      * is `Ok`:
@@ -866,9 +887,9 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      * - 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 first array element fails the check;
-     * - returning `Err` containing {@link RetupleCheckFailedError} when the
-     *   first array elemnt fails the check, and when no map error function is
+     *   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.
@@ -876,8 +897,8 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      * @example
      *
      * ```ts
-     * const result: Result<(string | null)[], never> = Ok(["test", null]);
-     * const first = result.$andFirst();
+     * 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");
@@ -886,8 +907,9 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      * @example
      *
      * ```ts
-     * const result: Result<(string | null | undefined)[], never> = Ok([null, "test"]);
-     * const first = result.$andFirst(
+     * const result: Result<(string | null | undefined)[], never> = Ok(["test", null]);
+     * const first = result.$atIndex(
+     *   1,
      *   (val) => val === null ? "value was null" : "value was undefined",
      * );
      *
@@ -895,12 +917,12 @@ interface Retuple<T, E> extends ResultLike<T, E> {
      * assert.equal(first.$unwrapErr(), "value was null");
      * ```
      */
-    $atIndex<U>(this: Result<readonly U[], E>, index: number): Result<Truthy<U>, E | RetupleCheckFailedError<T>>;
+    $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>;
     /**
      * Equivalent to calling `result.$atIndex(0)`.
      */
-    $firstIndex<U>(this: Result<readonly U[], E>): Result<Truthy<U>, E | RetupleCheckFailedError<T>>;
+    $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>;
     /**
      * Returns `Ok` containing the return value of the map function when this
@@ -1518,17 +1540,18 @@ type ObjectUnionErr<E> = {
     error: E;
 };
 type AllOk<TResults extends ResultLikeAwaitable<any, any>[]> = {
-    [K in keyof TResults]: TResults[K] extends Result<infer T, any> ? T : never;
+    [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 Result<any, infer E> ? E : never;
+    [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 Result<infer T, any> ? T : never;
+    [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 Result<any, infer E> ? E : 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);

package/dist/index.js

@@ -45,6 +45,43 @@ export class RetupleExpectFailed extends Error {
         this.value = value;
     }
 }
+/**
+ * ## 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 class RetupleAssertFailed extends Error {
+    constructor(value) {
+        super("Assert failed");
+        this.value = value;
+    }
+}
+/**
+ * ## 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 class RetupleFilterFailed extends Error {
+    constructor(value) {
+        super("Filter failed");
+        this.value = value;
+    }
+}
+/**
+ * ## 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 class RetupleIndexFailed extends Error {
+    constructor(index, value) {
+        super("Index failed");
+        this.index = index;
+        this.value = value;
+    }
+}
 /**
  * ## Retuple Thrown Value Error
  *
@@ -73,18 +110,6 @@ export class RetupleInvalidUnionError extends Error {
         this.value = value;
     }
 }
-/**
- * ## Retuple Check Failed Error
- *
- * This error is used as the error type of a `Result` when using $andAssert
- * or $andCheck, when no custom error handler is provided.
- */
-export class RetupleCheckFailedError extends Error {
-    constructor(value) {
-        super("Check failed");
-        this.value = value;
-    }
-}
 /**
  * ## Result
  *
@@ -567,19 +592,33 @@ class ResultOk extends Array {
     $mapOrElse(_def, f) {
         return Ok(f(this[1]));
     }
-    $assert(mapError = mapCheckError) {
-        return this[1] ? this : Err(mapError(this[1]));
+    $assert(mapError) {
+        return this[1]
+            ? this
+            : Err(mapError
+                ? mapError(this[1])
+                : new RetupleAssertFailed(this[1]));
     }
-    $check(check, mapError = mapCheckError) {
-        return check(this[1]) ? this : Err(mapError(this[1]));
+    $filter(filter, mapError) {
+        return filter(this[1])
+            ? this
+            : Err(mapError ? mapError(this[1]) : new RetupleFilterFailed(this[1]));
     }
-    $atIndex(index, mapError = mapCheckError) {
+    $atIndex(index, mapError) {
         const element = this[1][index];
-        return element ? Ok(element) : Err(mapError(this[1]));
+        return element
+            ? Ok(element)
+            : Err(mapError
+                ? mapError(this[1])
+                : new RetupleIndexFailed(index, this[1]));
     }
-    $firstIndex(mapError = mapCheckError) {
+    $firstIndex(mapError) {
         const first = this[1][0];
-        return first ? Ok(first) : Err(mapError(this[1]));
+        return first
+            ? Ok(first)
+            : Err(mapError
+                ? mapError(this[1])
+                : new RetupleIndexFailed(0, this[1]));
     }
     $or() {
         return this;
@@ -727,7 +766,7 @@ class ResultErr extends Array {
     $assert() {
         return this;
     }
-    $check() {
+    $filter() {
         return this;
     }
     $atIndex() {
@@ -910,40 +949,54 @@ class ResultAsync {
                 : new ResultOk(def(res[0]));
         }));
     }
-    $assert(mapError = mapCheckError) {
+    $assert(mapError) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             if (res instanceof ResultErr) {
                 return res;
             }
             return res[1]
                 ? res
-                : Err(mapError(res[1]));
+                : Err(mapError
+                    ? mapError(res[1])
+                    : new RetupleAssertFailed(res[1]));
         }));
     }
-    $check(check, mapError = mapCheckError) {
+    $filter(check, mapError) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             if (res instanceof ResultErr) {
                 return res;
             }
-            return check(res[1]) ? res : Err(mapError(res[1]));
+            return check(res[1])
+                ? res
+                : Err(mapError
+                    ? mapError(res[1])
+                    : new RetupleFilterFailed(res[1]));
         }));
     }
-    $atIndex(index, mapError = mapCheckError) {
+    $atIndex(index, mapError) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then((res) => {
             if (res instanceof ResultErr) {
                 return res;
             }
             const element = res[1][index];
-            return element ? Ok(element) : Err(mapError(res[1]));
+            return element
+                ? Ok(element)
+                : Err(mapError
+                    ? mapError(res[1])
+                    : new RetupleIndexFailed(index, res[1]));
         }));
     }
-    $firstIndex(mapError = mapCheckError) {
+    $firstIndex(mapError) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then((res) => {
             if (res instanceof ResultErr) {
                 return res;
             }
             const first = res[1][0];
-            return first ? Ok(first) : Err(mapError(res[1]));
+            return first
+                ? Ok(first)
+                : Err(mapError
+                    ? mapError(res[1])
+                    : new RetupleIndexFailed(0, res[1]));
         }));
     }
     $or(or) {
@@ -1260,6 +1313,3 @@ function ensureError(err) {
 function mapTrue() {
     return true;
 }
-function mapCheckError(value) {
-    return new RetupleCheckFailedError(value);
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "retuple",
-  "version": "1.0.0-next.25",
+  "version": "1.0.0-next.27",
   "scripts": {
     "test": "vitest",
     "lint": "eslint . --ext .ts -c eslint.config.mjs --fix",