retuple 1.0.0-next.0 → 1.0.0-next.10

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.RetupleArrayMethodUnavailableError = exports.RetupleInvalidResultError = exports.RetupleThrownValueError = exports.RetupleFlattenFailed = 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`, 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,26 @@ class RetupleExpectFailed extends Error {
     }
 }
 exports.RetupleExpectFailed = RetupleExpectFailed;
+/**
+ * ## 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`.
+ */
+class RetupleFlattenFailed extends Error {
+    constructor(value) {
+        super("Flatten Result failed, the contained value was not a Result");
+        this.value = value;
+    }
+}
+exports.RetupleFlattenFailed = RetupleFlattenFailed;
+/**
+ * ## 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,34 +85,74 @@ class RetupleThrownValueError extends Error {
     }
 }
 exports.RetupleThrownValueError = RetupleThrownValueError;
+/**
+ * ## 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`.
+ */
+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;
+/**
+ * ## Retuple Array Method Unavailable Error
+ *
+ * This error is thrown when calling a built-in array method from a `Result`.
+ */
+class RetupleArrayMethodUnavailableError extends Error {
+    constructor(value, method) {
+        super(`Built in array method '${method}' should not be called directly from ` +
+            "a Result, convert the Result to a tuple first");
+        this.value = value;
+    }
+}
+exports.RetupleArrayMethodUnavailableError = RetupleArrayMethodUnavailableError;
 /**
  * ## 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) {
-        return new ResultOk(value);
+function nonNullable(value, error = mapTrue) {
+    if (value !== null && value !== undefined) {
+        return Ok(value);
     }
-    if (error) {
-        return new ResultErr(error());
+    return Err(error());
+}
+function truthy(value, error = mapTrue) {
+    if (value) {
+        return Ok(value);
     }
-    return new ResultErr(true);
+    return Err(error());
 }
 function safe(f, mapError = ensureError) {
     try {
@@ -98,24 +176,450 @@ function safePromise(promise, mapError = ensureError) {
     return new ResultAsync(promise.then((Ok), async (err) => Err(await mapError(err))));
 }
 /**
- * ## Ok
+ * ## RetupleArray
  *
- * @TODO
+ * Using built-in array methods on a `Result` is probably a mistake. This class
+ * makes the built-in methods throw `RetupleArrayMethodUnavailableError`.
+ */
+class RetupleArray extends Array {
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    at() {
+        throw new RetupleArrayMethodUnavailableError(this, "at");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    concat() {
+        throw new RetupleArrayMethodUnavailableError(this, "concat");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    copyWithin() {
+        throw new RetupleArrayMethodUnavailableError(this, "copyWithin");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    entries() {
+        throw new RetupleArrayMethodUnavailableError(this, "entries");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    every() {
+        throw new RetupleArrayMethodUnavailableError(this, "every");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    fill() {
+        throw new RetupleArrayMethodUnavailableError(this, "fill");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    filter() {
+        throw new RetupleArrayMethodUnavailableError(this, "filter");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    find() {
+        throw new RetupleArrayMethodUnavailableError(this, "find");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    findIndex() {
+        throw new RetupleArrayMethodUnavailableError(this, "findIndex");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    findLast() {
+        throw new RetupleArrayMethodUnavailableError(this, "findLast");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    findLastIndex() {
+        throw new RetupleArrayMethodUnavailableError(this, "findLastIndex");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    flat() {
+        throw new RetupleArrayMethodUnavailableError(this, "flat");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    flatMap() {
+        throw new RetupleArrayMethodUnavailableError(this, "flatMap");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    forEach() {
+        throw new RetupleArrayMethodUnavailableError(this, "forEach");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    includes() {
+        throw new RetupleArrayMethodUnavailableError(this, "includes");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    indexOf() {
+        throw new RetupleArrayMethodUnavailableError(this, "indexOf");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    join() {
+        throw new RetupleArrayMethodUnavailableError(this, "join");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    keys() {
+        throw new RetupleArrayMethodUnavailableError(this, "keys");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    lastIndexOf() {
+        throw new RetupleArrayMethodUnavailableError(this, "lastIndexOf");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    map() {
+        throw new RetupleArrayMethodUnavailableError(this, "map");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    pop() {
+        throw new RetupleArrayMethodUnavailableError(this, "pop");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    push() {
+        throw new RetupleArrayMethodUnavailableError(this, "push");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    reduce() {
+        throw new RetupleArrayMethodUnavailableError(this, "reduce");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    reduceRight() {
+        throw new RetupleArrayMethodUnavailableError(this, "reduceRight");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    reverse() {
+        throw new RetupleArrayMethodUnavailableError(this, "reverse");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    shift() {
+        throw new RetupleArrayMethodUnavailableError(this, "shift");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    slice() {
+        throw new RetupleArrayMethodUnavailableError(this, "slice");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    some() {
+        throw new RetupleArrayMethodUnavailableError(this, "some");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    sort() {
+        throw new RetupleArrayMethodUnavailableError(this, "sort");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    splice() {
+        throw new RetupleArrayMethodUnavailableError(this, "splice");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    toString() {
+        throw new RetupleArrayMethodUnavailableError(this, "toString");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    toLocaleString() {
+        throw new RetupleArrayMethodUnavailableError(this, "toLocaleString");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    toReversed() {
+        throw new RetupleArrayMethodUnavailableError(this, "toReversed");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    toSorted() {
+        throw new RetupleArrayMethodUnavailableError(this, "toSorted");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    toSpliced() {
+        throw new RetupleArrayMethodUnavailableError(this, "toSpliced");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    unshift() {
+        throw new RetupleArrayMethodUnavailableError(this, "unshift");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    values() {
+        throw new RetupleArrayMethodUnavailableError(this, "values");
+    }
+    /**
+     * ## Method not available
+     *
+     * Built-in array methods not available on `Result` types, convert the result
+     * to a tuple using `$tuple()` first.
+     *
+     * @deprecated
+     */
+    with() {
+        throw new RetupleArrayMethodUnavailableError(this, "with");
+    }
+}
+/**
+ * ## ResultOk
+ *
+ * This is the `Ok` variant of a `Result`, used internally and not exported.
  */
-class ResultOk extends Array {
+class ResultOk extends RetupleArray {
     constructor(value) {
         super(2);
         this[0] = undefined;
         this[1] = value;
     }
-    $value() {
+    toJSON() {
         return this[1];
     }
     $isOk() {
         return true;
     }
     $isOkAnd(f) {
-        return f(this[1]);
+        return !!f(this[1]);
     }
     $isErr() {
         return false;
@@ -139,16 +643,22 @@ class ResultOk extends Array {
         return this[1];
     }
     $map(f) {
-        return new ResultOk(f(this[1]));
+        return Ok(f(this[1]));
     }
     $mapErr() {
         return this;
     }
     $mapOr(_def, f) {
-        return new ResultOk(f(this[1]));
+        return Ok(f(this[1]));
     }
     $mapOrElse(_def, f) {
-        return new ResultOk(f(this[1]));
+        return Ok(f(this[1]));
+    }
+    $andAssertOr(def, condition = isTruthy) {
+        return condition(this[1]) ? this : def;
+    }
+    $andAssertOrElse(def, condition = isTruthy) {
+        return condition(this[1]) ? this : def(this[1]);
     }
     $or() {
         return this;
@@ -171,10 +681,10 @@ class ResultOk extends Array {
     }
     $andSafe(f, mapError = ensureError) {
         try {
-            return new ResultOk(f(this[1]));
+            return Ok(f(this[1]));
         }
         catch (err) {
-            return new ResultErr(mapError(err));
+            return Err(mapError(err));
         }
     }
     $peek(f) {
@@ -189,7 +699,11 @@ class ResultOk extends Array {
         return this;
     }
     $flatten() {
-        return this[1];
+        const inner = this[1];
+        if (inner instanceof ResultOk || inner instanceof ResultErr) {
+            return inner;
+        }
+        throw new RetupleFlattenFailed(this[1]);
     }
     $async() {
         return new ResultAsync(Promise.resolve(this));
@@ -197,20 +711,26 @@ class ResultOk extends Array {
     $promise() {
         return Promise.resolve(this);
     }
+    $tuple() {
+        return [undefined, this[1]];
+    }
+    *$iter() {
+        yield* this[1];
+    }
 }
 /**
- * ## Err
+ * ## ResultErr
  *
- * @TODO
+ * This is the `Err` variant of a `Result`, used internally and not exported.
  */
-class ResultErr extends Array {
+class ResultErr extends RetupleArray {
     constructor(err) {
         super(2);
         this[0] = err;
         this[1] = undefined;
     }
-    $value() {
-        return this[0];
+    toJSON() {
+        return null;
     }
     $isOk() {
         return false;
@@ -222,7 +742,7 @@ class ResultErr extends Array {
         return true;
     }
     $isErrAnd(f) {
-        return f(this[0]);
+        return !!f(this[0]);
     }
     $expect() {
         if (this[0] instanceof Error) {
@@ -246,13 +766,19 @@ class ResultErr extends Array {
         return this;
     }
     $mapErr(f) {
-        return new ResultErr(f(this[0]));
+        return Err(f(this[0]));
     }
     $mapOr(def) {
-        return new ResultOk(def);
+        return Ok(def);
     }
     $mapOrElse(def) {
-        return new ResultOk(def(this[0]));
+        return Ok(def(this[0]));
+    }
+    $andAssertOr() {
+        return this;
+    }
+    $andAssertOrElse() {
+        return this;
     }
     $or(or) {
         return or;
@@ -262,10 +788,10 @@ class ResultErr extends Array {
     }
     $orSafe(f, mapError = ensureError) {
         try {
-            return new ResultOk(f(this[0]));
+            return Ok(f(this[0]));
         }
         catch (err) {
-            return new ResultErr(mapError(err));
+            return Err(mapError(err));
         }
     }
     $and() {
@@ -300,6 +826,12 @@ class ResultErr extends Array {
     $promise() {
         return Promise.resolve(this);
     }
+    $tuple() {
+        return [this[0], undefined];
+    }
+    *$iter() {
+        return;
+    }
 }
 /**
  * ## ResultAsync
@@ -315,133 +847,137 @@ class ResultAsync {
         return __classPrivateFieldGet(this, _ResultAsync_inner, "f").then(onfulfilled, onrejected);
     }
     /**
-     * @TODO
-     */
-    async $value() {
-        return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$value();
-    }
-    /**
-     * @TODO
+     * The same as {@link Retuple.$expect|$expect}, except it returns a `Promise`.
      */
     async $expect() {
         return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$expect();
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$unwrap|$unwrap}, except it returns a `Promise`.
      */
     async $unwrap(msg) {
         return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$unwrap(msg);
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$unwrapErr|$unwrapErr}, except it returns
+     * a `Promise`.
      */
     async $unwrapErr(msg) {
         return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$unwrapErr(msg);
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$unwrapOr|$unwrapOr}, except it returns
+     * a `Promise`.
      */
     async $unwrapOr(def) {
         return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$unwrapOr(def);
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$unwrapOrElse|$unwrapOrElse}, except it returns
+     * a `Promise`.
      */
     async $unwrapOrElse(f) {
         const res = await __classPrivateFieldGet(this, _ResultAsync_inner, "f");
         return res instanceof ResultOk ? res[1] : f();
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$map|$map}, except it returns `ResultAsync`.
      */
     $map(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
-            return res instanceof ResultOk
-                ? new ResultOk(f(res[1]))
-                : res;
+            return res instanceof ResultOk ? Ok(f(res[1])) : res;
         }));
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$mapErr|$mapErr}, except it returns
+     * `ResultAsync`.
      */
     $mapErr(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
-            return res instanceof ResultErr
-                ? new ResultErr(f(res[0]))
-                : res;
+            return res instanceof ResultErr ? Err(f(res[0])) : res;
         }));
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$mapOr|$mapOr}, except it returns `ResultAsync`.
      */
     $mapOr(def, f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
-            return res instanceof ResultOk
-                ? new ResultOk(f(res[1]))
-                : new ResultOk(def);
+            return res instanceof ResultOk ? Ok(f(res[1])) : Ok(def);
         }));
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$mapOrElse|$mapOrElse}, except it returns
+     * `ResultAsync`.
      */
     $mapOrElse(def, f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
-            return res instanceof ResultOk
-                ? new ResultOk(f(res[1]))
-                : new ResultOk(def(res[0]));
+            return res instanceof ResultOk ? Ok(f(res[1])) : Ok(def(res[0]));
+        }));
+    }
+    $andAssertOr(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;
+        }));
+    }
+    $andAssertOrElse(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(res[1]);
         }));
     }
-    /**
-     * @TODO
-     */
     $or(or) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             return res instanceof ResultErr ? await or : res;
         }));
     }
-    /**
-     * @TODO
-     */
     $orElse(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
-            return res instanceof ResultErr ? await f(res[0]) : res;
+            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) {
                 return res;
             }
             try {
-                return new ResultOk(await f(res[0]));
+                return Ok(await f(res[0]));
             }
             catch (err) {
-                return new ResultErr(mapError(err));
+                return Err(mapError(err));
+            }
+        }));
+    }
+    $orSafePromise(promise, mapError = ensureError) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultOk) {
+                return res;
+            }
+            try {
+                return Ok(await promise);
+            }
+            catch (err) {
+                return Err(mapError(err));
             }
         }));
     }
-    /**
-     * @TODO
-     */
     $and(and) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             return res instanceof ResultOk ? await and : res;
         }));
     }
-    /**
-     * @TODO
-     */
     $andThen(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             return res instanceof ResultOk ? await f(res[1]) : res;
         }));
     }
-    /**
-     * @TODO
-     */
     $andThrough(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             if (res instanceof ResultOk) {
@@ -453,24 +989,37 @@ class ResultAsync {
             return res;
         }));
     }
-    /**
-     * @TODO
-     */
     $andSafe(f, mapError = ensureError) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
             if (res instanceof ResultErr) {
                 return res;
             }
             try {
-                return new ResultOk(await f(res[1]));
+                return Ok(await f(res[1]));
             }
             catch (err) {
-                return new ResultErr(mapError(err));
+                return Err(mapError(err));
+            }
+        }));
+    }
+    $andSafePromise(promise, mapError = ensureError) {
+        return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
+            if (res instanceof ResultErr) {
+                return res;
+            }
+            try {
+                return Ok(await promise);
+            }
+            catch (err) {
+                return Err(mapError(err));
             }
         }));
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$peek|$peek}, except it:
+     *
+     * - awaits the peek function;
+     * - returns `ResultAsync`.
      */
     $peek(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
@@ -479,7 +1028,10 @@ class ResultAsync {
         }));
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$tap|$tap}, except it:
+     *
+     * - awaits the tap function;
+     * - returns `ResultAsync`.
      */
     $tap(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
@@ -490,7 +1042,10 @@ class ResultAsync {
         }));
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$tapErr|$tapErr}, except it:
+     *
+     * - awaits the tap error function;
+     * - returns `ResultAsync`.
      */
     $tapErr(f) {
         return new ResultAsync(__classPrivateFieldGet(this, _ResultAsync_inner, "f").then(async (res) => {
@@ -501,11 +1056,23 @@ class ResultAsync {
         }));
     }
     /**
-     * @TODO
+     * The same as {@link Retuple.$promise|$promise}.
      */
     $promise() {
         return Promise.resolve(this);
     }
+    /**
+     * The same as {@link Retuple.$tuple|$tuple}, except it returns a `Promise`.
+     */
+    async $tuple() {
+        return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$tuple();
+    }
+    /**
+     * The same as {@link Retuple.$tuple|$iter}, except it returns a `Promise`.
+     */
+    async $iter() {
+        return (await __classPrivateFieldGet(this, _ResultAsync_inner, "f")).$iter();
+    }
 }
 _ResultAsync_inner = new WeakMap();
 function ensureError(err) {
@@ -514,18 +1081,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;
+}