happy-rusty 1.0.9 → 1.1.1

package/src/mod.ts

@@ -1,27 +1,13 @@
-import type { Option } from './enum/option.ts';
-import type { Result } from './enum/result.ts';
-
-export { None, Some, type Option } from './enum/option.ts';
-export { Err, Ok, type Result } from './enum/result.ts';
-
-// export some commonly used types
-
-/**
- * The shorthand of Promise<Option<T>>.
- */
-export type AsyncOption<T> = Promise<Option<T>>;
-
-/**
- * The shorthand of Promise<Result<T, E>>.
- */
-export type AsyncResult<T, E> = Promise<Result<T, E>>;
-
-/**
- * The shorthand of Result<T, Error>.
- */
-export type IOResult<T> = Result<T, Error>;
-
-/**
- * The shorthand of Promise<Result<T, Error>>.
- */
-export type AsyncIOResult<T> = Promise<IOResult<T>>;
+export {
+    Err,
+    None,
+    Ok,
+    Some,
+    promiseToResult,
+    type AsyncIOResult,
+    type AsyncOption,
+    type AsyncResult,
+    type IOResult,
+    type Option,
+    type Result
+} from './enum/prelude.ts';

package/src/enum/option.ts

@@ -1,68 +0,0 @@
-/**
- * @fileoverview A Rust-inspired [Option](https://doc.rust-lang.org/core/option/index.html) enum, used as an alternative to the use of null and undefined.
- */
-
-/**
- * option::Some type
- */
-interface Some<T> {
-    readonly kind: 'Some';
-    readonly isSome: (this: Option<T>) => this is Some<T>;
-    readonly isNone: (this: Option<T>) => this is None;
-    readonly unwrap: () => T;
-}
-
-/**
- * option::None type
- */
-interface None {
-    readonly kind: 'None';
-    readonly isSome: <T>(this: Option<T>) => this is Some<T>;
-    readonly isNone: <T>(this: Option<T>) => this is None;
-    readonly unwrap: () => never;
-}
-
-/**
- * option::Option type
- */
-export type Option<T> = Some<T> | None;
-
-/**
- * Create a `Some` object.
- *
- * # Examples
- *
- * ```
- * const v = Some(10);
- * console.assert(v.unwrap() === 10);
- * ```
- *
- * @param value The wrapped value which can not be null or undefined.
- * @returns {Some}
- */
-export function Some<T>(value: NonNullable<T>): Option<T> {
-    if (value == null) {
-        throw new TypeError('Some value can not be null or undefined');
-    }
-
-    return {
-        kind: 'Some',
-        isSome: () => true,
-        isNone: () => false,
-        unwrap: () => value,
-    } as const;
-}
-
-/**
- * `None` value is freeze.
- *
- * @constant {None}
- */
-export const None: None = {
-    kind: 'None',
-    isSome: () => false,
-    isNone: () => true,
-    unwrap: () => {
-        throw new TypeError('None can not unwrap');
-    },
-} as const;

package/src/enum/result.ts

@@ -1,104 +0,0 @@
-/**
- * @fileoverview A Rust-inspired [Result](https://doc.rust-lang.org/core/result/index.html) enum, used for better error handling.
- */
-
-/**
- * result::Ok type
- */
-interface Ok<T, E> {
-    readonly kind: 'Ok';
-    readonly isOk: (this: Result<T, E>) => this is Ok<T, E>;
-    readonly isErr: (this: Result<T, E>) => this is Err<T, E>;
-    readonly unwrap: () => T;
-    readonly err: () => never;
-}
-
-/**
- * result::Err type
- */
-interface Err<T, E> {
-    readonly kind: 'Err';
-    readonly isOk: (this: Result<T, E>) => this is Ok<T, E>;
-    readonly isErr: (this: Result<T, E>) => this is Err<T, E>;
-    readonly unwrap: () => never;
-    readonly err: () => E;
-}
-
-/**
- * result::Result type
- */
-export type Result<T, E> = Ok<T, E> | Err<T, E>;
-
-/**
- * Create an `Ok` object.
- *
- * # Examples
- *
- * ```
- * const v = Ok(10);
- * console.assert(v.unwrap() === 10);
- *
-function judge(n: number): Option<Promise<Result<number, Error>>> {
-    if (n < 0 || n >= 1) {
-        return None;
-    }
-
-    return Some(new Promise(resolve => {
-        const r = Math.random();
-        resolve(r > n ? Ok(r) : Err(new Error('lose')));
-    }));
-}
-
-const res = judge(0.8);
-if (res.isNone()) {
-    console.error('invalid number');
-} else {
-    const result = await res.unwrap();
-    if (result.isErr()) {
-        console.assert(result.err().message === 'lose');
-    } else {
-        console.log(result.unwrap()); // must greater than 0.8
-    }
-}
- *
- * ```
- *
- * @param value The wrapped value.
- * @returns {Ok}
- */
-export function Ok<T, E>(value: T): Result<T, E> {
-    return {
-        kind: 'Ok',
-        isOk: () => true,
-        isErr: () => false,
-        unwrap: () => value,
-        err: () => {
-            throw new TypeError('Ok is not Err');
-        },
-    } as const;
-}
-
-/**
- * Create an `Err` object.
- *
- * # Examples
- *
- * ```
- * const e = Err(new Error('unknown error'));
- * console.assert(e.err().message === 'unknown error');
- * ```
- *
- * @param error The wrapped error value.
- * @returns {Err}
- */
-export function Err<T, E>(error: E): Result<T, E> {
-    return {
-        kind: 'Err',
-        isOk: () => false,
-        isErr: () => true,
-        unwrap: () => {
-            throw error;
-        },
-        err: () => error,
-    } as const;
-}