retuple 1.0.0-next.2 → 1.0.0-next.4

package/dist/index.cjs

@@ -12,13 +12,20 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _ResultAsync_inner;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Result = exports.RetupleThrownValueError = exports.RetupleExpectFailed = exports.RetupleUnwrapErrFailed = exports.RetupleUnwrapFailed = void 0;
+exports.RetupleInvalidResultError = exports.RetupleThrownValueError = exports.RetupleExpectFailed = exports.RetupleUnwrapErrFailed = exports.RetupleUnwrapFailed = void 0;
+exports.Result = Result;
 exports.Ok = Ok;
 exports.Err = Err;
-exports.from = from;
+exports.nonNullable = nonNullable;
+exports.truthy = truthy;
 exports.safe = safe;
 exports.safeAsync = safeAsync;
 exports.safePromise = safePromise;
+/**
+ * ## Retuple Unwrap Failed
+ *
+ * An error which occurs when calling `$unwrap` on `Err`.
+ */
 class RetupleUnwrapFailed extends Error {
     constructor(value, msg = "Unwrap failed") {
         super(msg, value instanceof Error ? { cause: value } : undefined);
@@ -26,6 +33,11 @@ class RetupleUnwrapFailed extends Error {
     }
 }
 exports.RetupleUnwrapFailed = RetupleUnwrapFailed;
+/**
+ * ## Retuple Unwrap Err Failed
+ *
+ * An error which occurs when calling `$unwrapErr` on `Ok`.
+ */
 class RetupleUnwrapErrFailed extends Error {
     constructor(value, msg = "Unwrap error failed") {
         super(msg);
@@ -33,6 +45,12 @@ class RetupleUnwrapErrFailed extends Error {
     }
 }
 exports.RetupleUnwrapErrFailed = RetupleUnwrapErrFailed;
+/**
+ * ## Retuple Expect Failed
+ *
+ * An error which occurs when calling `$expect` on `Err`, and when the value
+ * contained in the `Err` is not an instance of `Error`.
+ */
 class RetupleExpectFailed extends Error {
     constructor(value) {
         super("Expect failed");
@@ -40,6 +58,13 @@ class RetupleExpectFailed extends Error {
     }
 }
 exports.RetupleExpectFailed = RetupleExpectFailed;
+/**
+ * ## 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.
+ */
 class RetupleThrownValueError extends Error {
     constructor(value) {
         super("Caught value was not an instance of Error");
@@ -47,50 +72,76 @@ class RetupleThrownValueError extends Error {
     }
 }
 exports.RetupleThrownValueError = RetupleThrownValueError;
+/**
+ * ## Retuple Invalid Result Error
+ *
+ * An error thrown when attempting to construct a `Result` from a native 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`.
+ */
+class RetupleInvalidResultError extends Error {
+    constructor(value) {
+        super("Constructing a Result from native tuple failed, at least one of the values at index 0 or 1 should be null or undefined");
+        this.value = value;
+    }
+}
+exports.RetupleInvalidResultError = RetupleInvalidResultError;
 /**
  * ## Result
  *
  * @TODO
  */
-exports.Result = {
-    Ok,
-    Err,
-    from,
-    safe,
-    safeAsync,
-    safePromise,
-};
-exports.default = exports.Result;
+function Result(resultLike) {
+    const [err, ok] = resultLike;
+    if (err === null || err === undefined) {
+        return new ResultOk(ok);
+    }
+    if (ok === null || ok === undefined) {
+        return new ResultErr(err);
+    }
+    throw new RetupleInvalidResultError(resultLike);
+}
+Result.Ok = Ok;
+Result.Err = Err;
+Result.nonNullable = nonNullable;
+Result.truthy = truthy;
+Result.safe = safe;
+Result.safeAsync = safeAsync;
+Result.safePromise = safePromise;
+Object.freeze(Result);
 function Ok(val) {
     return new ResultOk(val);
 }
 function Err(err) {
     return new ResultErr(err);
 }
-function from(value, error) {
-    if (value) {
+function nonNullable(value, error = mapTrue) {
+    if (value !== null && value !== undefined) {
         return new ResultOk(value);
     }
-    if (error) {
-        return new ResultErr(error());
+    return new ResultErr(error());
+}
+function truthy(value, error = mapTrue) {
+    if (value) {
+        return new ResultOk(value);
     }
-    return new ResultErr(true);
+    return new ResultErr(error());
 }
 function safe(f, mapError = ensureError) {
     try {
-        return Ok(f());
+        return new ResultOk(f());
     }
     catch (err) {
-        return Err(mapError(err));
+        return new ResultErr(mapError(err));
     }
 }
 function safeAsync(f, mapError = ensureError) {
     return new ResultAsync((async () => {
         try {
-            return Ok(await f());
+            return new ResultOk(await f());
         }
         catch (err) {
-            return Err(await mapError(err));
+            return new ResultErr(await mapError(err));
         }
     })());
 }
@@ -108,14 +159,23 @@ class ResultOk extends Array {
         this[0] = undefined;
         this[1] = value;
     }
+    toJSON() {
+        return this[1];
+    }
+    $toNativeTuple() {
+        return [undefined, this[1]];
+    }
     $value() {
         return this[1];
     }
+    $ok() {
+        return this[1];
+    }
     $isOk() {
         return true;
     }
     $isOkAnd(f) {
-        return f(this[1]);
+        return !!f(this[1]);
     }
     $isErr() {
         return false;
@@ -150,6 +210,12 @@ class ResultOk extends Array {
     $mapOrElse(_def, f) {
         return new ResultOk(f(this[1]));
     }
+    $assertOr(def, condition = isTruthy) {
+        return condition(this[1]) ? this : def;
+    }
+    $assertOrElse(def, condition = isTruthy) {
+        return condition(this[1]) ? this : def();
+    }
     $or() {
         return this;
     }
@@ -209,9 +275,18 @@ class ResultErr extends Array {
         this[0] = err;
         this[1] = undefined;
     }
+    toJSON() {
+        return null;
+    }
+    $toNativeTuple() {
+        return [this[0], undefined];
+    }
     $value() {
         return this[0];
     }
+    $ok() {
+        undefined;
+    }
     $isOk() {
         return false;
     }
@@ -222,7 +297,7 @@ class ResultErr extends Array {
         return true;
     }
     $isErrAnd(f) {
-        return f(this[0]);
+        return !!f(this[0]);
     }
     $expect() {
         if (this[0] instanceof Error) {
@@ -254,6 +329,12 @@ class ResultErr extends Array {
     $mapOrElse(def) {
         return new ResultOk(def(this[0]));
     }
+    $assertOr() {
+        return this;
+    }
+    $assertOrElse() {
+        return this;
+    }
     $or(or) {
         return or;
     }
@@ -314,12 +395,24 @@ class ResultAsync {
     then(onfulfilled, onrejected) {
         return __classPrivateFieldGet(this, _ResultAsync_inner, "f").then(onfulfilled, onrejected);
     }
+    /**
+     * @TODO
+     */
+    async $toNativeTuple() {
+        return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$toNativeTuple();
+    }
     /**
      * @TODO
      */
     async $value() {
         return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$value();
     }
+    /**
+     * @TODO
+     */
+    async $ok() {
+        return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$ok();
+    }
     /**
      * @TODO
      */
@@ -391,6 +484,22 @@ class ResultAsync {
                 : new ResultOk(def(res[0]));
         }));
     }
+    $assertOr(def, condition = isTruthy) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultErr || condition(res[1])) {
+                return res;
+            }
+            return await def;
+        }));
+    }
+    $assertOrElse(def, condition = isTruthy) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultErr || condition(res[1])) {
+                return res;
+            }
+            return await def();
+        }));
+    }
     /**
      * @TODO
      */
@@ -407,9 +516,6 @@ class ResultAsync {
             return res instanceof ResultErr ? await f(res[0]) : res;
         }));
     }
-    /**
-     * @TODO
-     */
     $orSafe(f, mapError = ensureError) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             if (res instanceof ResultOk) {
@@ -453,9 +559,6 @@ class ResultAsync {
             return res;
         }));
     }
-    /**
-     * @TODO
-     */
     $andSafe(f, mapError = ensureError) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             if (res instanceof ResultErr) {
@@ -514,18 +617,9 @@ function ensureError(err) {
     }
     return new RetupleThrownValueError(err);
 }
-Object.freeze(exports.Result);
-Object.freeze(ResultOk);
-Object.freeze(ResultErr);
-Object.freeze(ResultAsync);
-Object.freeze(RetupleUnwrapFailed);
-Object.freeze(RetupleUnwrapErrFailed);
-Object.freeze(RetupleExpectFailed);
-Object.freeze(RetupleThrownValueError);
-Object.freeze(ResultOk.prototype);
-Object.freeze(ResultErr.prototype);
-Object.freeze(ResultAsync.prototype);
-Object.freeze(RetupleUnwrapFailed.prototype);
-Object.freeze(RetupleUnwrapErrFailed.prototype);
-Object.freeze(RetupleExpectFailed.prototype);
-Object.freeze(RetupleThrownValueError.prototype);
+function mapTrue() {
+    return true;
+}
+function isTruthy(val) {
+    return !!val;
+}

package/dist/index.d.cts

@@ -1,57 +1,103 @@
+export type nonNullable = typeof nonNullable;
+export type truthy = typeof truthy;
+export type safe = typeof safe;
+export type safeAsync = typeof safeAsync;
+export type safePromise = typeof safePromise;
 export type Ok<T> = OkTuple<T> & Retuple<T, never>;
 export type Err<E> = ErrTuple<E> & Retuple<never, E>;
 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`, and 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 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
+ *
+ * An error thrown when attempting to construct a `Result` from a native 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[]);
+}
 /**
  * ## 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] ? Ok<T> : R extends [infer E, null | undefined] ? Err<E> : never) extends Ok<infer T> | Err<infer E> ? Result<T, NonNullable<E>> : never;
+export declare namespace Result {
+    var Ok: typeof import(".").Ok;
+    var Err: typeof import(".").Err;
+    var nonNullable: typeof import(".").nonNullable;
+    var truthy: typeof import(".").truthy;
+    var safe: typeof import(".").safe;
+    var safeAsync: typeof import(".").safeAsync;
+    var safePromise: typeof import(".").safePromise;
+}
 /**
  * ## Ok
  *
  * @TODO
  */
 export declare function Ok(): Ok<void>;
-export declare function Ok<T>(val: T): Ok<T>;
+export declare function Ok<const T>(val: T): Ok<T>;
 /**
  * ## Err
  *
  * @TODO
  */
 export declare function Err(): Err<void>;
-export declare function Err<E>(err: E): Err<E>;
+export declare function Err<const E>(err: E): Err<E>;
+/**
+ * Construct a {@link Result} from a value. If the value is neither null or
+ * undefined, the result is `Ok`.
+ */
+export declare function nonNullable<const T>(value: T): Result<NonNullable<T>, true>;
+export declare function nonNullable<const T, const E>(value: T, error: () => E): Result<NonNullable<T>, E>;
 /**
  * Construct a {@link Result} from a value. If the value is truthy, the result
  * is `Ok`.
  */
-export declare function from<T>(value: T): Result<Truthy<T>, true>;
-export declare function from<T, E>(value: T, error: () => E): Result<Truthy<T>, E>;
+export declare function truthy<const T>(value: T): Result<Truthy<T>, true>;
+export declare function truthy<const T, const E>(value: T, error: () => E): Result<Truthy<T>, E>;
 /**
  * Construct a {@link Result} from a synchronous function call. If the function
  * returns without throwing, the result is `Ok`.
@@ -78,11 +124,19 @@ 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>;
+    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
+     */
+    $toNativeTuple(this: ResultAsync<T, E>): Promise<OkTuple<T> | ErrTuple<E>>;
     /**
      * @TODO
      */
     $value(this: ResultAsync<T, E>): Promise<T | E>;
+    /**
+     * @TODO
+     */
+    $ok(this: ResultAsync<T, E>): Promise<T | undefined>;
     /**
      * @TODO
      */
@@ -102,7 +156,7 @@ declare class ResultAsync<T, E> {
     /**
      * @TODO
      */
-    $unwrapOrElse<U = T>(this: ResultAsync<T, E>, f: () => U): Promise<T | U>;
+    $unwrapOrElse<U>(this: ResultAsync<T, E>, f: () => U): Promise<T | U>;
     /**
      * @TODO
      */
@@ -114,39 +168,52 @@ declare class ResultAsync<T, E> {
     /**
      * @TODO
      */
-    $mapOr<U>(this: ResultAsync<T, E>, def: U, f: (val: T) => U): ResultAsync<U, E>;
+    $mapOr<U, V>(this: ResultAsync<T, E>, def: U, f: (val: T) => V): ResultAsync<U | V, E>;
     /**
      * @TODO
      */
-    $mapOrElse<U>(this: ResultAsync<T, E>, def: (err: E) => U, f: (val: T) => U): ResultAsync<U, E>;
+    $mapOrElse<U, V>(this: ResultAsync<T, E>, def: (err: E) => U, f: (val: T) => V): ResultAsync<U | V, E>;
+    /**
+     * ## $assertOr
+     *
+     * {@link Retuple.$assertOr|$assertOr}
+     */
+    $assertOr<U, F>(this: ResultAsync<T, E>, def: Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<Truthy<T>, E | F>;
+    $assertOr<U, F, A extends T>(this: ResultAsync<T, E>, def: Result<U, F> | PromiseLike<Result<U, F>>, predicate: (val: T) => val is A): ResultAsync<U | A, E | F>;
+    $assertOr<U, F>(this: ResultAsync<T, E>, def: Result<U, F> | PromiseLike<Result<U, F>>, condition: (val: T) => unknown): ResultAsync<T | U, E | F>;
+    $assertOrElse<U, F>(this: ResultAsync<T, E>, def: () => Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<Truthy<T>, E | F>;
+    $assertOrElse<U, F, A extends T>(this: ResultAsync<T, E>, def: () => Result<U, F> | PromiseLike<Result<U, F>>, predicate: (val: T) => val is A): ResultAsync<U | A, E | F>;
+    $assertOrElse<U, F>(this: ResultAsync<T, E>, def: () => Result<U, F> | PromiseLike<Result<U, F>>, condition: (val: T) => unknown): ResultAsync<T | U, E | F>;
     /**
      * @TODO
      */
-    $or<U = T, F = E>(this: ResultAsync<T, E>, or: Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<T | U, E | F>;
+    $or<U, F>(this: ResultAsync<T, E>, or: Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<T | U, E | F>;
     /**
      * @TODO
      */
-    $orElse<U = T, F = E>(this: ResultAsync<T, E>, f: (err: E) => Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<T | U, E | F>;
+    $orElse<U, F>(this: ResultAsync<T, E>, f: (err: E) => Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<T | U, E | F>;
     /**
      * @TODO
      */
-    $orSafe<U = T, F = Error>(this: ResultAsync<T, E>, f: (err: E) => U | PromiseLike<U>, mapError?: (err: unknown) => F): ResultAsync<T | U, E | F>;
+    $orSafe<U>(this: ResultAsync<T, E>, f: (err: E) => U | PromiseLike<U>): ResultAsync<T | U, E | Error>;
+    $orSafe<U, F>(this: ResultAsync<T, E>, f: (err: E) => U | PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<T | U, E | F>;
     /**
      * @TODO
      */
-    $and<U = T, F = E>(this: ResultAsync<T, E>, and: Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<U, E | F>;
+    $and<U, F>(this: ResultAsync<T, E>, and: Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<U, E | F>;
     /**
      * @TODO
      */
-    $andThen<U = T, F = E>(this: ResultAsync<T, E>, f: (val: T) => Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<U, E | F>;
+    $andThen<U, F>(this: ResultAsync<T, E>, f: (val: T) => Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<U, E | F>;
     /**
      * @TODO
      */
-    $andThrough<F = E>(this: ResultAsync<T, E>, f: (val: T) => Result<any, F> | PromiseLike<Result<any, F>>): ResultAsync<T, E | F>;
+    $andThrough<F>(this: ResultAsync<T, E>, f: (val: T) => Result<any, F> | PromiseLike<Result<any, F>>): ResultAsync<T, E | F>;
     /**
      * @TODO
      */
-    $andSafe<U = T, F = Error>(this: ResultAsync<T, E>, f: (val: T) => U | PromiseLike<U>, mapError?: (err: unknown) => F): ResultAsync<U, E | F>;
+    $andSafe<U>(this: ResultAsync<T, E>, f: (val: T) => U | PromiseLike<U>): ResultAsync<T | U, E | Error>;
+    $andSafe<U, F>(this: ResultAsync<T, E>, f: (val: T) => U | PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<T | U, E | F>;
     /**
      * @TODO
      */
@@ -174,23 +241,33 @@ interface Retuple<T, E> {
     /**
      * @TODO
      */
-    $isOk(this: Result<T, E>): this is Ok<T>;
+    $toNativeTuple(this: Result<T, E>): OkTuple<T> | ErrTuple<E>;
     /**
      * @TODO
      */
-    $isOkAnd<U extends T = T>(this: Result<T, E>, f: ((val: T) => val is U) | ((val: T) => boolean)): this is Ok<U>;
+    $value(this: Result<T, E>): T | E;
     /**
      * @TODO
      */
-    $isErr(this: Result<T, E>): this is Err<E>;
+    $ok(this: Result<T, E>): T | undefined;
     /**
      * @TODO
      */
-    $isErrAnd<F extends E = E>(this: Result<T, E>, f: ((err: E) => err is F) | ((err: E) => boolean)): this is Err<F>;
+    $isOk(this: Result<T, E>): this is Ok<T>;
     /**
      * @TODO
      */
-    $value(this: Result<T, E>): T | E;
+    $isOkAnd<U extends T>(this: Result<T, E>, predicate: (val: T) => val is U): this is Ok<U>;
+    $isOkAnd(this: Result<T, E>, predicate: (val: T) => unknown): this is Ok<T>;
+    /**
+     * @TODO
+     */
+    $isErr(this: Result<T, E>): this is Err<E>;
+    /**
+     * @TODO
+     */
+    $isErrAnd<F extends E>(this: Result<T, E>, prediacte: (val: E) => val is F): this is Err<F>;
+    $isErrAnd(this: Result<T, E>, predicate: (val: E) => unknown): this is Err<E>;
     /**
      * @TODO
      */
@@ -206,11 +283,11 @@ interface Retuple<T, E> {
     /**
      * @TODO
      */
-    $unwrapOr<U = T>(this: Result<T, E>, def: U): T | U;
+    $unwrapOr<const U>(this: Result<T, E>, def: U): T | U;
     /**
      * @TODO
      */
-    $unwrapOrElse<U = T>(this: Result<T, E>, f: () => U): T | U;
+    $unwrapOrElse<U>(this: Result<T, E>, f: () => U): T | U;
     /**
      * @TODO
      */
@@ -222,43 +299,53 @@ interface Retuple<T, E> {
     /**
      * @TODO
      */
-    $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
+     */
+    $mapOrElse<U, V = U>(this: Result<T, E>, def: (err: E) => U, f: (val: T) => V): Result<U | V, E>;
+    /**
+     * @TODO
+     */
+    $or<U, F>(this: Result<T, E>, or: Result<U, F>): Result<T | U, E | F>;
     /**
      * @TODO
      */
-    $mapOrElse<U>(this: Result<T, E>, def: (err: E) => U, f: (val: T) => U): Result<U, E>;
+    $orElse<U, F>(this: Result<T, E>, f: (err: E) => Result<U, F>): Result<T | U, E | F>;
     /**
      * @TODO
      */
-    $or<U = T, F = E>(this: Result<T, E>, or: Result<U, F>): Result<T | U, E | F>;
+    $orSafe<U>(this: Result<T, E>, f: (err: E) => U): Result<T | U, E | Error>;
+    $orSafe<U, F>(this: Result<T, E>, f: (err: E) => U, mapError: (err: unknown) => F): Result<T | U, E | F>;
     /**
      * @TODO
      */
-    $orElse<U = never, F = never>(this: Result<T, E>, f: (err: E) => Result<U, F>): Result<T | U, E | F>;
+    $and<U, F>(this: Result<T, E>, and: Result<U, F>): Result<U, E | F>;
     /**
      * @TODO
      */
-    $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>;
+    $andThen<U, F>(this: Result<T, E>, f: (val: T) => Result<U, F>): Result<U, E | F>;
     /**
      * @TODO
      */
-    $and<U = T, F = E>(this: Result<T, E>, and: Result<U, F>): Result<U, E | F>;
+    $andThrough<F>(this: Result<T, E>, f: (val: T) => Result<any, F>): Result<T, E | F>;
     /**
      * @TODO
      */
-    $andThen<U = never, F = never>(this: Result<T, E>, f: (val: T) => Result<U, F>): Result<U, E | F>;
+    $andSafe<U>(this: Result<T, E>, f: (val: T) => U): Result<T | U, E | Error>;
+    $andSafe<U, F>(this: Result<T, E>, f: (val: T) => U, mapError: (err: unknown) => F): Result<T | U, E | F>;
     /**
      * @TODO
      */
-    $andThrough<F = never>(this: Result<T, E>, f: (val: T) => Result<any, F>): Result<T, E | F>;
+    $assertOr<U, F>(this: Result<T, E>, def: Result<U, F>): Result<Truthy<T>, E | F>;
+    $assertOr<U, F, A extends T>(this: Result<T, E>, def: Result<U, F>, predicate: (val: T) => val is A): Result<U | A, E | F>;
+    $assertOr<U, F>(this: Result<T, E>, def: Result<U, F>, condition: (val: T) => unknown): Result<T | U, E | F>;
     /**
      * @TODO
      */
-    $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>;
+    $assertOrElse<U, F>(this: Result<T, E>, def: () => Result<U, F>): Result<Truthy<T>, E | F>;
+    $assertOrElse<U, F, A extends T>(this: Result<T, E>, def: () => Result<U, F>, predicate: (val: T) => val is A): Result<U | A, E | F>;
+    $assertOrElse<U, F>(this: Result<T, E>, def: () => Result<U, F>, condition: (val: T) => unknown): Result<T | U, E | F>;
     /**
      * @TODO
      */

package/dist/index.d.ts

@@ -1,57 +1,103 @@
+export type nonNullable = typeof nonNullable;
+export type truthy = typeof truthy;
+export type safe = typeof safe;
+export type safeAsync = typeof safeAsync;
+export type safePromise = typeof safePromise;
 export type Ok<T> = OkTuple<T> & Retuple<T, never>;
 export type Err<E> = ErrTuple<E> & Retuple<never, E>;
 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`, and 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 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
+ *
+ * An error thrown when attempting to construct a `Result` from a native 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[]);
+}
 /**
  * ## 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] ? Ok<T> : R extends [infer E, null | undefined] ? Err<E> : never) extends Ok<infer T> | Err<infer E> ? Result<T, NonNullable<E>> : never;
+export declare namespace Result {
+    var Ok: typeof import(".").Ok;
+    var Err: typeof import(".").Err;
+    var nonNullable: typeof import(".").nonNullable;
+    var truthy: typeof import(".").truthy;
+    var safe: typeof import(".").safe;
+    var safeAsync: typeof import(".").safeAsync;
+    var safePromise: typeof import(".").safePromise;
+}
 /**
  * ## Ok
  *
  * @TODO
  */
 export declare function Ok(): Ok<void>;
-export declare function Ok<T>(val: T): Ok<T>;
+export declare function Ok<const T>(val: T): Ok<T>;
 /**
  * ## Err
  *
  * @TODO
  */
 export declare function Err(): Err<void>;
-export declare function Err<E>(err: E): Err<E>;
+export declare function Err<const E>(err: E): Err<E>;
+/**
+ * Construct a {@link Result} from a value. If the value is neither null or
+ * undefined, the result is `Ok`.
+ */
+export declare function nonNullable<const T>(value: T): Result<NonNullable<T>, true>;
+export declare function nonNullable<const T, const E>(value: T, error: () => E): Result<NonNullable<T>, E>;
 /**
  * Construct a {@link Result} from a value. If the value is truthy, the result
  * is `Ok`.
  */
-export declare function from<T>(value: T): Result<Truthy<T>, true>;
-export declare function from<T, E>(value: T, error: () => E): Result<Truthy<T>, E>;
+export declare function truthy<const T>(value: T): Result<Truthy<T>, true>;
+export declare function truthy<const T, const E>(value: T, error: () => E): Result<Truthy<T>, E>;
 /**
  * Construct a {@link Result} from a synchronous function call. If the function
  * returns without throwing, the result is `Ok`.
@@ -78,11 +124,19 @@ 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>;
+    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
+     */
+    $toNativeTuple(this: ResultAsync<T, E>): Promise<OkTuple<T> | ErrTuple<E>>;
     /**
      * @TODO
      */
     $value(this: ResultAsync<T, E>): Promise<T | E>;
+    /**
+     * @TODO
+     */
+    $ok(this: ResultAsync<T, E>): Promise<T | undefined>;
     /**
      * @TODO
      */
@@ -102,7 +156,7 @@ declare class ResultAsync<T, E> {
     /**
      * @TODO
      */
-    $unwrapOrElse<U = T>(this: ResultAsync<T, E>, f: () => U): Promise<T | U>;
+    $unwrapOrElse<U>(this: ResultAsync<T, E>, f: () => U): Promise<T | U>;
     /**
      * @TODO
      */
@@ -114,39 +168,52 @@ declare class ResultAsync<T, E> {
     /**
      * @TODO
      */
-    $mapOr<U>(this: ResultAsync<T, E>, def: U, f: (val: T) => U): ResultAsync<U, E>;
+    $mapOr<U, V>(this: ResultAsync<T, E>, def: U, f: (val: T) => V): ResultAsync<U | V, E>;
     /**
      * @TODO
      */
-    $mapOrElse<U>(this: ResultAsync<T, E>, def: (err: E) => U, f: (val: T) => U): ResultAsync<U, E>;
+    $mapOrElse<U, V>(this: ResultAsync<T, E>, def: (err: E) => U, f: (val: T) => V): ResultAsync<U | V, E>;
+    /**
+     * ## $assertOr
+     *
+     * {@link Retuple.$assertOr|$assertOr}
+     */
+    $assertOr<U, F>(this: ResultAsync<T, E>, def: Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<Truthy<T>, E | F>;
+    $assertOr<U, F, A extends T>(this: ResultAsync<T, E>, def: Result<U, F> | PromiseLike<Result<U, F>>, predicate: (val: T) => val is A): ResultAsync<U | A, E | F>;
+    $assertOr<U, F>(this: ResultAsync<T, E>, def: Result<U, F> | PromiseLike<Result<U, F>>, condition: (val: T) => unknown): ResultAsync<T | U, E | F>;
+    $assertOrElse<U, F>(this: ResultAsync<T, E>, def: () => Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<Truthy<T>, E | F>;
+    $assertOrElse<U, F, A extends T>(this: ResultAsync<T, E>, def: () => Result<U, F> | PromiseLike<Result<U, F>>, predicate: (val: T) => val is A): ResultAsync<U | A, E | F>;
+    $assertOrElse<U, F>(this: ResultAsync<T, E>, def: () => Result<U, F> | PromiseLike<Result<U, F>>, condition: (val: T) => unknown): ResultAsync<T | U, E | F>;
     /**
      * @TODO
      */
-    $or<U = T, F = E>(this: ResultAsync<T, E>, or: Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<T | U, E | F>;
+    $or<U, F>(this: ResultAsync<T, E>, or: Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<T | U, E | F>;
     /**
      * @TODO
      */
-    $orElse<U = T, F = E>(this: ResultAsync<T, E>, f: (err: E) => Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<T | U, E | F>;
+    $orElse<U, F>(this: ResultAsync<T, E>, f: (err: E) => Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<T | U, E | F>;
     /**
      * @TODO
      */
-    $orSafe<U = T, F = Error>(this: ResultAsync<T, E>, f: (err: E) => U | PromiseLike<U>, mapError?: (err: unknown) => F): ResultAsync<T | U, E | F>;
+    $orSafe<U>(this: ResultAsync<T, E>, f: (err: E) => U | PromiseLike<U>): ResultAsync<T | U, E | Error>;
+    $orSafe<U, F>(this: ResultAsync<T, E>, f: (err: E) => U | PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<T | U, E | F>;
     /**
      * @TODO
      */
-    $and<U = T, F = E>(this: ResultAsync<T, E>, and: Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<U, E | F>;
+    $and<U, F>(this: ResultAsync<T, E>, and: Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<U, E | F>;
     /**
      * @TODO
      */
-    $andThen<U = T, F = E>(this: ResultAsync<T, E>, f: (val: T) => Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<U, E | F>;
+    $andThen<U, F>(this: ResultAsync<T, E>, f: (val: T) => Result<U, F> | PromiseLike<Result<U, F>>): ResultAsync<U, E | F>;
     /**
      * @TODO
      */
-    $andThrough<F = E>(this: ResultAsync<T, E>, f: (val: T) => Result<any, F> | PromiseLike<Result<any, F>>): ResultAsync<T, E | F>;
+    $andThrough<F>(this: ResultAsync<T, E>, f: (val: T) => Result<any, F> | PromiseLike<Result<any, F>>): ResultAsync<T, E | F>;
     /**
      * @TODO
      */
-    $andSafe<U = T, F = Error>(this: ResultAsync<T, E>, f: (val: T) => U | PromiseLike<U>, mapError?: (err: unknown) => F): ResultAsync<U, E | F>;
+    $andSafe<U>(this: ResultAsync<T, E>, f: (val: T) => U | PromiseLike<U>): ResultAsync<T | U, E | Error>;
+    $andSafe<U, F>(this: ResultAsync<T, E>, f: (val: T) => U | PromiseLike<U>, mapError: (err: unknown) => F): ResultAsync<T | U, E | F>;
     /**
      * @TODO
      */
@@ -174,23 +241,33 @@ interface Retuple<T, E> {
     /**
      * @TODO
      */
-    $isOk(this: Result<T, E>): this is Ok<T>;
+    $toNativeTuple(this: Result<T, E>): OkTuple<T> | ErrTuple<E>;
     /**
      * @TODO
      */
-    $isOkAnd<U extends T = T>(this: Result<T, E>, f: ((val: T) => val is U) | ((val: T) => boolean)): this is Ok<U>;
+    $value(this: Result<T, E>): T | E;
     /**
      * @TODO
      */
-    $isErr(this: Result<T, E>): this is Err<E>;
+    $ok(this: Result<T, E>): T | undefined;
     /**
      * @TODO
      */
-    $isErrAnd<F extends E = E>(this: Result<T, E>, f: ((err: E) => err is F) | ((err: E) => boolean)): this is Err<F>;
+    $isOk(this: Result<T, E>): this is Ok<T>;
     /**
      * @TODO
      */
-    $value(this: Result<T, E>): T | E;
+    $isOkAnd<U extends T>(this: Result<T, E>, predicate: (val: T) => val is U): this is Ok<U>;
+    $isOkAnd(this: Result<T, E>, predicate: (val: T) => unknown): this is Ok<T>;
+    /**
+     * @TODO
+     */
+    $isErr(this: Result<T, E>): this is Err<E>;
+    /**
+     * @TODO
+     */
+    $isErrAnd<F extends E>(this: Result<T, E>, prediacte: (val: E) => val is F): this is Err<F>;
+    $isErrAnd(this: Result<T, E>, predicate: (val: E) => unknown): this is Err<E>;
     /**
      * @TODO
      */
@@ -206,11 +283,11 @@ interface Retuple<T, E> {
     /**
      * @TODO
      */
-    $unwrapOr<U = T>(this: Result<T, E>, def: U): T | U;
+    $unwrapOr<const U>(this: Result<T, E>, def: U): T | U;
     /**
      * @TODO
      */
-    $unwrapOrElse<U = T>(this: Result<T, E>, f: () => U): T | U;
+    $unwrapOrElse<U>(this: Result<T, E>, f: () => U): T | U;
     /**
      * @TODO
      */
@@ -222,43 +299,53 @@ interface Retuple<T, E> {
     /**
      * @TODO
      */
-    $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
+     */
+    $mapOrElse<U, V = U>(this: Result<T, E>, def: (err: E) => U, f: (val: T) => V): Result<U | V, E>;
+    /**
+     * @TODO
+     */
+    $or<U, F>(this: Result<T, E>, or: Result<U, F>): Result<T | U, E | F>;
     /**
      * @TODO
      */
-    $mapOrElse<U>(this: Result<T, E>, def: (err: E) => U, f: (val: T) => U): Result<U, E>;
+    $orElse<U, F>(this: Result<T, E>, f: (err: E) => Result<U, F>): Result<T | U, E | F>;
     /**
      * @TODO
      */
-    $or<U = T, F = E>(this: Result<T, E>, or: Result<U, F>): Result<T | U, E | F>;
+    $orSafe<U>(this: Result<T, E>, f: (err: E) => U): Result<T | U, E | Error>;
+    $orSafe<U, F>(this: Result<T, E>, f: (err: E) => U, mapError: (err: unknown) => F): Result<T | U, E | F>;
     /**
      * @TODO
      */
-    $orElse<U = never, F = never>(this: Result<T, E>, f: (err: E) => Result<U, F>): Result<T | U, E | F>;
+    $and<U, F>(this: Result<T, E>, and: Result<U, F>): Result<U, E | F>;
     /**
      * @TODO
      */
-    $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>;
+    $andThen<U, F>(this: Result<T, E>, f: (val: T) => Result<U, F>): Result<U, E | F>;
     /**
      * @TODO
      */
-    $and<U = T, F = E>(this: Result<T, E>, and: Result<U, F>): Result<U, E | F>;
+    $andThrough<F>(this: Result<T, E>, f: (val: T) => Result<any, F>): Result<T, E | F>;
     /**
      * @TODO
      */
-    $andThen<U = never, F = never>(this: Result<T, E>, f: (val: T) => Result<U, F>): Result<U, E | F>;
+    $andSafe<U>(this: Result<T, E>, f: (val: T) => U): Result<T | U, E | Error>;
+    $andSafe<U, F>(this: Result<T, E>, f: (val: T) => U, mapError: (err: unknown) => F): Result<T | U, E | F>;
     /**
      * @TODO
      */
-    $andThrough<F = never>(this: Result<T, E>, f: (val: T) => Result<any, F>): Result<T, E | F>;
+    $assertOr<U, F>(this: Result<T, E>, def: Result<U, F>): Result<Truthy<T>, E | F>;
+    $assertOr<U, F, A extends T>(this: Result<T, E>, def: Result<U, F>, predicate: (val: T) => val is A): Result<U | A, E | F>;
+    $assertOr<U, F>(this: Result<T, E>, def: Result<U, F>, condition: (val: T) => unknown): Result<T | U, E | F>;
     /**
      * @TODO
      */
-    $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>;
+    $assertOrElse<U, F>(this: Result<T, E>, def: () => Result<U, F>): Result<Truthy<T>, E | F>;
+    $assertOrElse<U, F, A extends T>(this: Result<T, E>, def: () => Result<U, F>, predicate: (val: T) => val is A): Result<U | A, E | F>;
+    $assertOrElse<U, F>(this: Result<T, E>, def: () => Result<U, F>, condition: (val: T) => unknown): Result<T | U, E | F>;
     /**
      * @TODO
      */

package/dist/index.js

@@ -10,74 +10,122 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _ResultAsync_inner;
+/**
+ * ## Retuple Unwrap Failed
+ *
+ * An error which occurs when calling `$unwrap` on `Err`.
+ */
 export class RetupleUnwrapFailed extends Error {
     constructor(value, msg = "Unwrap failed") {
         super(msg, value instanceof Error ? { cause: value } : undefined);
         this.value = value;
     }
 }
+/**
+ * ## Retuple Unwrap Err Failed
+ *
+ * An error which occurs when calling `$unwrapErr` on `Ok`.
+ */
 export class RetupleUnwrapErrFailed extends Error {
     constructor(value, msg = "Unwrap error failed") {
         super(msg);
         this.value = value;
     }
 }
+/**
+ * ## Retuple Expect Failed
+ *
+ * An error which occurs when calling `$expect` on `Err`, and when the value
+ * contained in the `Err` is not an instance of `Error`.
+ */
 export class RetupleExpectFailed extends Error {
     constructor(value) {
         super("Expect failed");
         this.value = value;
     }
 }
+/**
+ * ## 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 class RetupleThrownValueError extends Error {
     constructor(value) {
         super("Caught value was not an instance of Error");
         this.value = value;
     }
 }
+/**
+ * ## Retuple Invalid Result Error
+ *
+ * An error thrown when attempting to construct a `Result` from a native 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 class RetupleInvalidResultError extends Error {
+    constructor(value) {
+        super("Constructing a Result from native tuple failed, at least one of the values at index 0 or 1 should be null or undefined");
+        this.value = value;
+    }
+}
 /**
  * ## Result
  *
  * @TODO
  */
-export const Result = {
-    Ok,
-    Err,
-    from,
-    safe,
-    safeAsync,
-    safePromise,
-};
-export default Result;
+export function Result(resultLike) {
+    const [err, ok] = resultLike;
+    if (err === null || err === undefined) {
+        return new ResultOk(ok);
+    }
+    if (ok === null || ok === undefined) {
+        return new ResultErr(err);
+    }
+    throw new RetupleInvalidResultError(resultLike);
+}
+Result.Ok = Ok;
+Result.Err = Err;
+Result.nonNullable = nonNullable;
+Result.truthy = truthy;
+Result.safe = safe;
+Result.safeAsync = safeAsync;
+Result.safePromise = safePromise;
+Object.freeze(Result);
 export function Ok(val) {
     return new ResultOk(val);
 }
 export function Err(err) {
     return new ResultErr(err);
 }
-export function from(value, error) {
-    if (value) {
+export function nonNullable(value, error = mapTrue) {
+    if (value !== null && value !== undefined) {
         return new ResultOk(value);
     }
-    if (error) {
-        return new ResultErr(error());
+    return new ResultErr(error());
+}
+export function truthy(value, error = mapTrue) {
+    if (value) {
+        return new ResultOk(value);
     }
-    return new ResultErr(true);
+    return new ResultErr(error());
 }
 export function safe(f, mapError = ensureError) {
     try {
-        return Ok(f());
+        return new ResultOk(f());
     }
     catch (err) {
-        return Err(mapError(err));
+        return new ResultErr(mapError(err));
     }
 }
 export function safeAsync(f, mapError = ensureError) {
     return new ResultAsync((async () => {
         try {
-            return Ok(await f());
+            return new ResultOk(await f());
         }
         catch (err) {
-            return Err(await mapError(err));
+            return new ResultErr(await mapError(err));
         }
     })());
 }
@@ -95,14 +143,23 @@ class ResultOk extends Array {
         this[0] = undefined;
         this[1] = value;
     }
+    toJSON() {
+        return this[1];
+    }
+    $toNativeTuple() {
+        return [undefined, this[1]];
+    }
     $value() {
         return this[1];
     }
+    $ok() {
+        return this[1];
+    }
     $isOk() {
         return true;
     }
     $isOkAnd(f) {
-        return f(this[1]);
+        return !!f(this[1]);
     }
     $isErr() {
         return false;
@@ -137,6 +194,12 @@ class ResultOk extends Array {
     $mapOrElse(_def, f) {
         return new ResultOk(f(this[1]));
     }
+    $assertOr(def, condition = isTruthy) {
+        return condition(this[1]) ? this : def;
+    }
+    $assertOrElse(def, condition = isTruthy) {
+        return condition(this[1]) ? this : def();
+    }
     $or() {
         return this;
     }
@@ -196,9 +259,18 @@ class ResultErr extends Array {
         this[0] = err;
         this[1] = undefined;
     }
+    toJSON() {
+        return null;
+    }
+    $toNativeTuple() {
+        return [this[0], undefined];
+    }
     $value() {
         return this[0];
     }
+    $ok() {
+        undefined;
+    }
     $isOk() {
         return false;
     }
@@ -209,7 +281,7 @@ class ResultErr extends Array {
         return true;
     }
     $isErrAnd(f) {
-        return f(this[0]);
+        return !!f(this[0]);
     }
     $expect() {
         if (this[0] instanceof Error) {
@@ -241,6 +313,12 @@ class ResultErr extends Array {
     $mapOrElse(def) {
         return new ResultOk(def(this[0]));
     }
+    $assertOr() {
+        return this;
+    }
+    $assertOrElse() {
+        return this;
+    }
     $or(or) {
         return or;
     }
@@ -301,12 +379,24 @@ class ResultAsync {
     then(onfulfilled, onrejected) {
         return __classPrivateFieldGet(this, _ResultAsync_inner, "f").then(onfulfilled, onrejected);
     }
+    /**
+     * @TODO
+     */
+    async $toNativeTuple() {
+        return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$toNativeTuple();
+    }
     /**
      * @TODO
      */
     async $value() {
         return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$value();
     }
+    /**
+     * @TODO
+     */
+    async $ok() {
+        return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$ok();
+    }
     /**
      * @TODO
      */
@@ -378,6 +468,22 @@ class ResultAsync {
                 : new ResultOk(def(res[0]));
         }));
     }
+    $assertOr(def, condition = isTruthy) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultErr || condition(res[1])) {
+                return res;
+            }
+            return await def;
+        }));
+    }
+    $assertOrElse(def, condition = isTruthy) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultErr || condition(res[1])) {
+                return res;
+            }
+            return await def();
+        }));
+    }
     /**
      * @TODO
      */
@@ -394,9 +500,6 @@ class ResultAsync {
             return res instanceof ResultErr ? await f(res[0]) : res;
         }));
     }
-    /**
-     * @TODO
-     */
     $orSafe(f, mapError = ensureError) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             if (res instanceof ResultOk) {
@@ -440,9 +543,6 @@ class ResultAsync {
             return res;
         }));
     }
-    /**
-     * @TODO
-     */
     $andSafe(f, mapError = ensureError) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             if (res instanceof ResultErr) {
@@ -501,18 +601,9 @@ function ensureError(err) {
     }
     return new RetupleThrownValueError(err);
 }
-Object.freeze(Result);
-Object.freeze(ResultOk);
-Object.freeze(ResultErr);
-Object.freeze(ResultAsync);
-Object.freeze(RetupleUnwrapFailed);
-Object.freeze(RetupleUnwrapErrFailed);
-Object.freeze(RetupleExpectFailed);
-Object.freeze(RetupleThrownValueError);
-Object.freeze(ResultOk.prototype);
-Object.freeze(ResultErr.prototype);
-Object.freeze(ResultAsync.prototype);
-Object.freeze(RetupleUnwrapFailed.prototype);
-Object.freeze(RetupleUnwrapErrFailed.prototype);
-Object.freeze(RetupleExpectFailed.prototype);
-Object.freeze(RetupleThrownValueError.prototype);
+function mapTrue() {
+    return true;
+}
+function isTruthy(val) {
+    return !!val;
+}

package/package.json

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