happy-rusty 1.3.2 → 1.5.0

package/src/enum/core.ts

@@ -26,8 +26,10 @@ export interface Option<T> {
 
     /**
      * [object Option].
+     *
+     * @private
      */
-    [Symbol.toStringTag]: 'Option',
+    readonly [Symbol.toStringTag]: 'Option',
 
     /**
      * Identify `Some` or `None`.
@@ -60,6 +62,11 @@ export interface Option<T> {
      */
     isSomeAnd(predicate: (value: T) => boolean): boolean;
 
+    /**
+     * Asynchronous version of `isSomeAnd`.
+     */
+    isSomeAndAsync(predicate: (value: T) => Promise<boolean>): Promise<boolean>;
+
     // #endregion
 
     // #region Extracting the contained value
@@ -93,6 +100,11 @@ export interface Option<T> {
      */
     unwrapOrElse(fn: () => T): T;
 
+    /**
+     * Asynchronous version of `unwrapOrElse`.
+     */
+    unwrapOrElseAsync(fn: () => Promise<T>): Promise<T>;
+
     // #endregion
 
     // #region Transforming contained values
@@ -228,6 +240,11 @@ export interface Option<T> {
      */
     andThen<U>(fn: (value: T) => Option<U>): Option<U>;
 
+    /**
+     * Asynchronous version of `andThen`.
+     */
+    andThenAsync<U>(fn: (value: T) => AsyncOption<U>): AsyncOption<U>;
+
     /**
      * Returns the Option if it contains a value, otherwise returns `other`.
      * This can be used for providing a fallback `Option`.
@@ -244,6 +261,11 @@ export interface Option<T> {
      */
     orElse(fn: () => Option<T>): Option<T>;
 
+    /**
+     * Asynchronous version of `orElse`.
+     */
+    orElseAsync(fn: () => AsyncOption<T>): AsyncOption<T>;
+
     /**
      * Returns `Some` if exactly one of `this`, `other` is `Some`, otherwise returns `None`.
      * This can be thought of as an exclusive or operation on `Option` values.
@@ -300,8 +322,10 @@ export interface Result<T, E> {
 
     /**
      * [object Result].
+     *
+     * @private
      */
-    [Symbol.toStringTag]: 'Result',
+    readonly [Symbol.toStringTag]: 'Result',
 
     /**
      * Identify `Ok` or `Err`.
@@ -334,12 +358,22 @@ export interface Result<T, E> {
      */
     isOkAnd(predicate: (value: T) => boolean): boolean;
 
+    /**
+     * Asynchronous version of `isOkAnd`.
+     */
+    isOkAndAsync(predicate: (value: T) => Promise<boolean>): Promise<boolean>;
+
     /**
      * Returns `true` if the result is `Err` and the provided predicate returns `true` for the contained error.
      * @param predicate - A function that takes the `Err` value and returns a boolean.
      */
     isErrAnd(predicate: (error: E) => boolean): boolean;
 
+    /**
+     * Asynchronous version of `isErrAnd`.
+     */
+    isErrAndAsync(predicate: (error: E) => Promise<boolean>): Promise<boolean>;
+
     // #endregion
 
     // #region Extracting the contained value
@@ -373,6 +407,11 @@ export interface Result<T, E> {
      */
     unwrapOrElse(fn: (error: E) => T): T;
 
+    /**
+     * Asynchronous version of `unwrapOrElse`.
+     */
+    unwrapOrElseAsync(fn: (error: E) => Promise<T>): Promise<T>;
+
     /**
      * These methods extract the contained value in a `Result<T, E>` when it is the `Err` variant.
      */
@@ -504,6 +543,11 @@ export interface Result<T, E> {
      */
     andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E>;
 
+    /**
+     * Asynchronous version of `andThen`.
+     */
+    andThenAsync<U>(fn: (value: T) => AsyncResult<U, E>): AsyncResult<U, E>;
+
     /**
      * Calls the provided function with the contained error if `this` is `Err`, otherwise returns `this` as `Ok`.
      * @typeParam F - The type of the error returned by the function.
@@ -512,6 +556,11 @@ export interface Result<T, E> {
      */
     orElse<F>(fn: (error: E) => Result<T, F>): Result<T, F>;
 
+    /**
+     * Asynchronous version of `orElse`.
+     */
+    orElseAsync<F>(fn: (error: E) => AsyncResult<T, F>): AsyncResult<T, F>;
+
     // #endregion
 
     /**
@@ -566,4 +615,21 @@ export interface Result<T, E> {
      * Custom `toString` implementation that uses the `Result`'s contained value.
      */
     toString(): string;
-}
+}
+
+/**
+ * Represents an asynchronous operation that yields an `Option<T>`.
+ * This is a promise that resolves to either `Some(T)` if the value is present, or `None` if the value is absent.
+ *
+ * @typeParam T - The type of the value that may be contained within the `Option`.
+ */
+export type AsyncOption<T> = Promise<Option<T>>;
+
+/**
+ * Represents an asynchronous operation that yields a `Result<T, E>`.
+ * This is a promise that resolves to `Ok(T)` if the operation was successful, or `Err(E)` if there was an error.
+ *
+ * @typeParam T - The type of the value that is produced by a successful operation.
+ * @typeParam E - The type of the error that may be produced by a failed operation.
+ */
+export type AsyncResult<T, E> = Promise<Result<T, E>>;

package/src/enum/defines.ts

@@ -2,24 +2,21 @@
  * Exports some commonly used types.
  */
 
-import type { Option, Result } from './core.ts';
+import type { AsyncResult, Result } from './core.ts';
 
 /**
- * Represents an asynchronous operation that yields an `Option<T>`.
- * This is a promise that resolves to either `Some(T)` if the value is present, or `None` if the value is absent.
+ * Similar to Rust's `Result<(), E>`.
  *
- * @typeParam T - The type of the value that may be contained within the `Option`.
+ * @typeParam E - The type of the error that may be produced by a failed operation.
  */
-export type AsyncOption<T> = Promise<Option<T>>;
+export type VoidResult<E> = Result<void, E>;
 
 /**
- * Represents an asynchronous operation that yields a `Result<T, E>`.
- * This is a promise that resolves to `Ok(T)` if the operation was successful, or `Err(E)` if there was an error.
+ * `VoidResult<E>` wrapped by `Promise`.
  *
- * @typeParam T - The type of the value that is produced by a successful operation.
  * @typeParam E - The type of the error that may be produced by a failed operation.
  */
-export type AsyncResult<T, E> = Promise<Result<T, E>>;
+export type AsyncVoidResult<E> = Promise<VoidResult<E>>;
 
 /**
  * Represents a synchronous operation that yields a `Result<T, Error>`.
@@ -35,4 +32,14 @@ export type IOResult<T> = Result<T, Error>;
  *
  * @typeParam T - The type of the value that is produced by a successful I/O operation.
  */
-export type AsyncIOResult<T> = AsyncResult<T, Error>;
+export type AsyncIOResult<T> = AsyncResult<T, Error>;
+
+/**
+ * Similar to Rust's `Result<(), Error>`.
+ */
+export type VoidIOResult = IOResult<void>;
+
+/**
+ * `VoidIOResult` wrapped by `Promise`.
+ */
+export type AsyncVoidIOResult = AsyncIOResult<void>;

package/src/enum/prelude.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import type { Option, Result } from './core.ts';
+import type { AsyncOption, AsyncResult, Option, Result } from './core.ts';
 import { OptionKindSymbol, ResultKindSymbol } from './symbols.ts';
 import { isOption, isResult } from './utils.ts';
 
@@ -14,14 +14,26 @@ export interface None extends Option<never> {
 
     readonly [OptionKindSymbol]: 'None';
 
+    isSome(): false;
+    isNone(): true;
+    isSomeAnd(predicate: (value: never) => boolean): false;
+    isSomeAndAsync(predicate: (value: never) => Promise<boolean>): Promise<false>;
+
+    expect(msg: string): never;
+    unwrap(): never;
     unwrapOr<T>(defaultValue: T): T;
     unwrapOrElse<T>(fn: () => T): T;
+    unwrapOrElseAsync<T>(fn: () => Promise<T>): Promise<T>;
 
+    okOr<E>(error: E): Result<never, E>;
+    okOrElse<E>(err: () => E): Result<never, E>;
     transpose(): Result<None, never>;
 
     filter(predicate: (value: never) => boolean): None;
     flatten(): None;
     map<U>(fn: (value: never) => U): None;
+    mapOr<U>(defaultValue: U, fn: (value: never) => U): U;
+    mapOrElse<U>(defaultFn: () => U, fn: (value: never) => U): U;
 
     zip<U>(other: Option<U>): None;
     zipWith<U, R>(other: Option<U>, fn: (value: never, otherValue: U) => R): None;
@@ -29,10 +41,14 @@ export interface None extends Option<never> {
 
     and<U>(other: Option<U>): None;
     andThen<U>(fn: (value: never) => Option<U>): None;
+    andThenAsync<U>(fn: (value: never) => AsyncOption<U>): Promise<None>;
     or<T>(other: Option<T>): Option<T>;
     orElse<T>(fn: () => Option<T>): Option<T>;
+    orElseAsync<T>(fn: () => AsyncOption<T>): AsyncOption<T>;
     xor<T>(other: Option<T>): Option<T>;
 
+    inspect(fn: (value: never) => void): this;
+
     eq<T>(other: Option<T>): boolean;
 }
 
@@ -66,6 +82,9 @@ export function Some<T>(value: T): Option<T> {
         isSomeAnd(predicate: (value: T) => boolean): boolean {
             return predicate(value);
         },
+        isSomeAndAsync(predicate: (value: T) => Promise<boolean>): Promise<boolean> {
+            return predicate(value);
+        },
 
         expect(_msg: string): T {
             return value;
@@ -79,6 +98,9 @@ export function Some<T>(value: T): Option<T> {
         unwrapOrElse(_fn: () => T): T {
             return value;
         },
+        unwrapOrElseAsync(_fn: () => Promise<T>): Promise<T> {
+            return Promise.resolve(value);
+        },
 
         okOr<E>(_error: E): Result<T, E> {
             return Ok(value);
@@ -137,12 +159,18 @@ export function Some<T>(value: T): Option<T> {
         andThen<U>(fn: (value: T) => Option<U>): Option<U> {
             return fn(value);
         },
+        andThenAsync<U>(fn: (value: T) => AsyncOption<U>): AsyncOption<U> {
+            return fn(value);
+        },
         or(_other: Option<T>): Option<T> {
             return some;
         },
         orElse(_fn: () => Option<T>): Option<T> {
             return some;
         },
+        orElseAsync(_fn: () => AsyncOption<T>): AsyncOption<T> {
+            return Promise.resolve(some);
+        },
         xor(other: Option<T>): Option<T> {
             assertOption(other);
             return other.isSome() ? None : some;
@@ -183,6 +211,9 @@ export const None = Object.freeze<None>({
     isSomeAnd(_predicate: (value: never) => boolean): false {
         return false;
     },
+    isSomeAndAsync(_predicate: (value: never) => Promise<boolean>): Promise<false> {
+        return Promise.resolve(false);
+    },
 
     expect(msg: string): never {
         throw new TypeError(msg);
@@ -196,6 +227,9 @@ export const None = Object.freeze<None>({
     unwrapOrElse<T>(fn: () => T): T {
         return fn();
     },
+    unwrapOrElseAsync<T>(fn: () => Promise<T>): Promise<T> {
+        return fn();
+    },
 
     okOr<E>(error: E): Result<never, E> {
         return Err(error);
@@ -240,6 +274,9 @@ export const None = Object.freeze<None>({
     andThen<U>(_fn: (value: never) => Option<U>): None {
         return None;
     },
+    andThenAsync<U>(_fn: (value: never) => AsyncOption<U>): Promise<None> {
+        return Promise.resolve(None);
+    },
     or<T>(other: Option<T>): Option<T> {
         assertOption(other);
         return other;
@@ -247,6 +284,9 @@ export const None = Object.freeze<None>({
     orElse<T>(fn: () => Option<T>): Option<T> {
         return fn();
     },
+    orElseAsync<T>(fn: () => AsyncOption<T>): AsyncOption<T> {
+        return fn();
+    },
     xor<T>(other: Option<T>): Option<T> {
         assertOption(other);
         return other.isSome() ? other : None;
@@ -283,7 +323,12 @@ export const None = Object.freeze<None>({
  * }
  * ```
  */
-export function Ok<T, E>(value: T): Result<T, E> {
+export function Ok<T, E>(value: T): Result<T, E>;
+/**
+ * Because javascript does not have a `()` type, use `void` instead.
+ */
+export function Ok<E>(): Result<void, E>;
+export function Ok<T, E>(value?: T): Result<T, E> {
     const ok: Result<T, E> = {
         [Symbol.toStringTag]: 'Result',
         [ResultKindSymbol]: 'Ok',
@@ -295,23 +340,32 @@ export function Ok<T, E>(value: T): Result<T, E> {
             return false;
         },
         isOkAnd(predicate: (value: T) => boolean): boolean {
-            return predicate(value);
+            return predicate(value as T);
+        },
+        isOkAndAsync(predicate: (value: T) => Promise<boolean>): Promise<boolean> {
+            return predicate(value as T);
         },
         isErrAnd(_predicate: (error: E) => boolean): false {
             return false;
         },
+        isErrAndAsync(_predicate: (error: E) => Promise<boolean>): Promise<false> {
+            return Promise.resolve(false);
+        },
 
         expect(_msg: string): T {
-            return value;
+            return value as T;
         },
         unwrap(): T {
-            return value;
+            return value as T;
         },
         unwrapOr(_defaultValue: T): T {
-            return value;
+            return value as T;
         },
         unwrapOrElse(_fn: (error: E) => T): T {
-            return value;
+            return value as T;
+        },
+        unwrapOrElseAsync(_fn: (error: E) => Promise<T>): Promise<T> {
+            return Promise.resolve(value as T);
         },
 
         expectErr(msg: string): E {
@@ -322,7 +376,7 @@ export function Ok<T, E>(value: T): Result<T, E> {
         },
 
         ok(): Option<T> {
-            return Some(value);
+            return Some(value as T);
         },
         err(): None {
             return None;
@@ -334,16 +388,16 @@ export function Ok<T, E>(value: T): Result<T, E> {
         },
 
         map<U>(fn: (value: T) => U): Result<U, E> {
-            return Ok(fn(value));
+            return Ok(fn(value as T));
         },
         mapErr<F>(_fn: (error: E) => F): Result<T, F> {
-            return Ok(value);
+            return Ok(value as T);
         },
         mapOr<U>(_defaultValue: U, fn: (value: T) => U): U {
-            return fn(value);
+            return fn(value as T);
         },
         mapOrElse<U>(_defaultFn: (error: E) => U, fn: (value: T) => U): U {
-            return fn(value);
+            return fn(value as T);
         },
         flatten<T>(): Result<T, E> {
             const r = value as Result<T, E>;
@@ -359,14 +413,20 @@ export function Ok<T, E>(value: T): Result<T, E> {
             return ok as unknown as Result<T, F>;
         },
         andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E> {
-            return fn(value);
+            return fn(value as T);
+        },
+        andThenAsync<U>(fn: (value: T) => AsyncResult<U, E>): AsyncResult<U, E> {
+            return fn(value as T);
         },
         orElse<F>(_fn: (error: E) => Result<T, F>): Result<T, F> {
             return ok as unknown as Result<T, F>;
         },
+        orElseAsync<F>(_fn: (error: E) => AsyncResult<T, F>): AsyncResult<T, F> {
+            return Promise.resolve(ok as unknown as Result<T, F>);
+        },
 
         inspect(fn: (value: T) => void): Result<T, E> {
-            fn(value);
+            fn(value as T);
             return ok;
         },
         inspectErr(_fn: (error: E) => void): Result<T, E> {
@@ -424,9 +484,15 @@ export function Err<T, E>(error: E): Result<T, E> {
         isOkAnd(_predicate: (value: T) => boolean): false {
             return false;
         },
+        isOkAndAsync(_predicate: (value: T) => Promise<boolean>): Promise<boolean> {
+            return Promise.resolve(false);
+        },
         isErrAnd(predicate: (error: E) => boolean): boolean {
             return predicate(error);
         },
+        isErrAndAsync(predicate: (error: E) => Promise<boolean>): Promise<boolean> {
+            return predicate(error);
+        },
 
         expect(msg: string): T {
             throw new TypeError(`${ msg }: ${ error }`);
@@ -440,6 +506,9 @@ export function Err<T, E>(error: E): Result<T, E> {
         unwrapOrElse(fn: (error: E) => T): T {
             return fn(error);
         },
+        unwrapOrElseAsync(fn: (error: E) => Promise<T>): Promise<T> {
+            return fn(error);
+        },
 
         expectErr(_msg: string): E {
             return error;
@@ -484,9 +553,15 @@ export function Err<T, E>(error: E): Result<T, E> {
         andThen<U>(_fn: (value: T) => Result<U, E>): Result<U, E> {
             return err as unknown as Result<U, E>;
         },
+        andThenAsync<U>(_fn: (value: T) => AsyncResult<U, E>): AsyncResult<U, E> {
+            return Promise.resolve(err as unknown as Result<U, E>);
+        },
         orElse<F>(fn: (error: E) => Result<T, F>): Result<T, F> {
             return fn(error);
         },
+        orElseAsync<F>(fn: (error: E) => AsyncResult<T, F>): AsyncResult<T, F> {
+            return fn(error);
+        },
 
         inspect(_fn: (value: T) => void): Result<T, E> {
             return err;