result_option 0.1.5 → 0.1.7

package/dist/index.d.ts

@@ -48,6 +48,10 @@ export declare class Option<T> {
      * x.is_some_and((x) => x > 1); // -> true
      */
     is_some_and(f: (value: T) => boolean): boolean;
+    /**
+     * Same as `Option.is_some_and()` but async.
+     */
+    is_some_and_async(f: (value: T) => Promise<boolean>): Promise<boolean>;
     /**
      *
      * @returns `true` if the `Option` is `None` or the value inside of it matches the predicate.
@@ -59,6 +63,10 @@ export declare class Option<T> {
      * y.is_none_or((x) => x > 1); // -> true
      */
     is_none_or(f: (value: T) => boolean): boolean;
+    /**
+     * Same as `Option.is_none_or()` but async.
+     */
+    is_none_or_async(f: (value: T) => Promise<boolean>): Promise<boolean>;
     /**
      *
      * @returns the contained `Some` value.
@@ -117,6 +125,10 @@ export declare class Option<T> {
      * const y = x.map((val) => val * 2); // -> y = Option.None
      */
     map<U>(f: (val: T) => U): Option<U>;
+    /**
+     * Same as `Option.map()` but async.
+     */
+    map_async<U>(f: (val: T) => Promise<U>): Promise<Option<U>>;
     /**
      *
      * @param dft default value.
@@ -167,6 +179,10 @@ export declare class Option<T> {
      * const y = x.ok_or(() => 0); // -> y = Result.Err(0)
      */
     ok_or_else<E>(err: () => E): Result<T, E>;
+    /**
+     * Same as `Option.ok_or_else()` but async.
+     */
+    ok_or_else_async<E>(err: () => Promise<E>): Promise<Result<T, E>>;
     /**
      *
      * @param optb value.
@@ -195,6 +211,10 @@ export declare class Option<T> {
      * const z = x.and_then(y); // -> z = Option.None()
      */
     and_then<U>(f: (val: T) => Option<U>): Option<U>;
+    /**
+     * Same as `Option.and_then()` but async.
+     */
+    and_then_async<U>(f: (val: T) => Promise<Option<U>>): Promise<Option<U>>;
     /**
      *
      * @param optb value.
@@ -223,6 +243,10 @@ export declare class Option<T> {
      * const z = x.or_else(y); // -> z = Option.Some(100)
      */
     or_else(f: () => Option<T>): Option<T>;
+    /**
+     * Same as `Option.or_else()` but async.
+     */
+    or_else_async(f: () => Promise<Option<T>>): Promise<Option<T>>;
     /**
      * @param cases - An object containing the match arms
      * @param cases.Some - Called with the value if Option is Some
@@ -293,6 +317,10 @@ export declare class Result<T, E> {
      * x.is_ok_and((x) => x > 5); // -> false
      */
     is_ok_and(f: (value: T) => boolean): boolean;
+    /**
+     * Same as `Result.is_ok_and()` but async.
+     */
+    is_ok_and_async(f: (value: T) => Promise<boolean>): Promise<boolean>;
     /**
      * @returns `true` if the `Result` is `Err` and the error matches the predicate.
      * @example
@@ -303,6 +331,10 @@ export declare class Result<T, E> {
      * x.is_err_and((e) => e === "error"); // -> false
      */
     is_err_and(f: (error: E) => boolean): boolean;
+    /**
+     * Same as `Result.is_ok_and()` but async.
+     */
+    is_err_and_async(f: (error: E) => Promise<boolean>): Promise<boolean>;
     /**
      * @returns `Option.Some(v)` if `Ok(v)`, otherwise `Option.None()`.
      * @example
@@ -334,6 +366,10 @@ export declare class Result<T, E> {
      * const y = x.map((val) => val * 2); // -> y = Result.Err("error")
      */
     map<U>(f: (val: T) => U): Result<U, E>;
+    /**
+     * Same as `Result.map()` but async.
+     */
+    map_async<U>(f: (val: T) => Promise<U>): Promise<Result<U, E>>;
     /**
      * @param dft - default value.
      * @param f - lambda.
@@ -369,6 +405,10 @@ export declare class Result<T, E> {
      * const y = x.map_err((e) => e.length); // -> y = Result.Ok(10)
      */
     map_err<F>(op: (err: E) => F): Result<T, F>;
+    /**
+     * Same as `Result.map_err()` but async.
+     */
+    map_err_async<F>(op: (err: E) => Promise<F>): Promise<Result<T, F>>;
     /**
      * @returns the contained `Ok` value.
      * @throws {Error} if the `Result` is `Err`.
@@ -461,6 +501,10 @@ export declare class Result<T, E> {
      * const y = x.and_then((val) => Result.Ok(val * 2)); // -> y = Result.Err("error")
      */
     and_then<U>(op: (val: T) => Result<U, E>): Result<U, E>;
+    /**
+     * Same as `Result.and_then()` but async.
+     */
+    and_then_async<U>(op: (val: T) => Promise<Result<U, E>>): Promise<Result<U, E>>;
     /**
      * @param res - value.
      * @returns `this` if `Ok`, otherwise returns `res`.
@@ -485,6 +529,10 @@ export declare class Result<T, E> {
      * const y = x.or_else((e) => Result.Ok(0)); // -> y = Result.Ok(10)
      */
     or_else<F>(op: (err: E) => Result<T, F>): Result<T, F>;
+    /**
+     * Same as `Result.or_else()` but async.
+     */
+    or_else_async<F>(op: (err: E) => Promise<Result<T, F>>): Promise<Result<T, F>>;
     /**
      * @param cases - An object containing the match arms.
      * @param cases.Ok - Called with the value if `Result` is `Ok`.

package/dist/index.js

@@ -77,6 +77,15 @@ export class Option {
             None: () => false,
         });
     }
+    /**
+     * Same as `Option.is_some_and()` but async.
+     */
+    async is_some_and_async(f) {
+        return this.match({
+            Some: f,
+            None: async () => false,
+        });
+    }
     /**
      *
      * @returns `true` if the `Option` is `None` or the value inside of it matches the predicate.
@@ -93,6 +102,15 @@ export class Option {
             None: () => true,
         });
     }
+    /**
+     * Same as `Option.is_none_or()` but async.
+     */
+    async is_none_or_async(f) {
+        return this.match({
+            Some: f,
+            None: async () => true,
+        });
+    }
     /**
      *
      * @returns the contained `Some` value.
@@ -180,6 +198,15 @@ export class Option {
             None: () => Option.None(),
         });
     }
+    /**
+     * Same as `Option.map()` but async.
+     */
+    async map_async(f) {
+        return this.match({
+            Some: async (val) => Option.Some(await f(val)),
+            None: async () => Option.None(),
+        });
+    }
     /**
      *
      * @param dft default value.
@@ -250,6 +277,15 @@ export class Option {
             None: () => Result.Err(err()),
         });
     }
+    /**
+     * Same as `Option.ok_or_else()` but async.
+     */
+    async ok_or_else_async(err) {
+        return this.match({
+            Some: async (val) => Result.Ok(val),
+            None: async () => Result.Err(await err()),
+        });
+    }
     /**
      *
      * @param optb value.
@@ -288,6 +324,15 @@ export class Option {
             None: () => Option.None(),
         });
     }
+    /**
+     * Same as `Option.and_then()` but async.
+     */
+    async and_then_async(f) {
+        return this.match({
+            Some: f,
+            None: async () => Option.None(),
+        });
+    }
     /**
      *
      * @param optb value.
@@ -326,6 +371,15 @@ export class Option {
             None: f,
         });
     }
+    /**
+     * Same as `Option.or_else()` but async.
+     */
+    async or_else_async(f) {
+        return this.match({
+            Some: async (_) => this,
+            None: f,
+        });
+    }
     /**
      * @param cases - An object containing the match arms
      * @param cases.Some - Called with the value if Option is Some
@@ -413,6 +467,15 @@ export class Result {
             Err: (_) => false,
         });
     }
+    /**
+     * Same as `Result.is_ok_and()` but async.
+     */
+    async is_ok_and_async(f) {
+        return this.match({
+            Ok: f,
+            Err: async (_) => false,
+        });
+    }
     /**
      * @returns `true` if the `Result` is `Err` and the error matches the predicate.
      * @example
@@ -428,6 +491,15 @@ export class Result {
             Err: f,
         });
     }
+    /**
+     * Same as `Result.is_ok_and()` but async.
+     */
+    async is_err_and_async(f) {
+        return this.match({
+            Ok: async (_) => false,
+            Err: f,
+        });
+    }
     /**
      * @returns `Option.Some(v)` if `Ok(v)`, otherwise `Option.None()`.
      * @example
@@ -474,6 +546,15 @@ export class Result {
             Err: (e) => Result.Err(e),
         });
     }
+    /**
+     * Same as `Result.map()` but async.
+     */
+    async map_async(f) {
+        return this.match({
+            Ok: async (t) => Result.Ok(await f(t)),
+            Err: async (e) => Result.Err(e),
+        });
+    }
     /**
      * @param dft - default value.
      * @param f - lambda.
@@ -524,6 +605,15 @@ export class Result {
             Err: (e) => Result.Err(op(e)),
         });
     }
+    /**
+     * Same as `Result.map_err()` but async.
+     */
+    async map_err_async(op) {
+        return this.match({
+            Ok: async (val) => Result.Ok(val),
+            Err: async (e) => Result.Err(await op(e)),
+        });
+    }
     /**
      * @returns the contained `Ok` value.
      * @throws {Error} if the `Result` is `Err`.
@@ -664,6 +754,15 @@ export class Result {
             Err: (e) => Result.Err(e),
         });
     }
+    /**
+     * Same as `Result.and_then()` but async.
+     */
+    async and_then_async(op) {
+        return this.match({
+            Ok: op,
+            Err: async (e) => Result.Err(e),
+        });
+    }
     /**
      * @param res - value.
      * @returns `this` if `Ok`, otherwise returns `res`.
@@ -698,6 +797,15 @@ export class Result {
             Err: op,
         });
     }
+    /**
+     * Same as `Result.or_else()` but async.
+     */
+    async or_else_async(op) {
+        return this.match({
+            Ok: async (t) => Result.Ok(t),
+            Err: op,
+        });
+    }
     /**
      * @param cases - An object containing the match arms.
      * @param cases.Ok - Called with the value if `Result` is `Ok`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "result_option",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Result and Option types for typescript.",
   "main": "./dist/index.ts",
   "module": "./dist/index.mts",