happy-rusty 1.0.9 → 1.1.0

package/docs/functions/Err.md

@@ -0,0 +1,46 @@
+[**happy-rusty**](../index.md) • **Docs**
+
+***
+
+[happy-rusty](../index.md) / Err
+
+# Function: Err()
+
+```ts
+function Err<T, E>(error): Result<T, E>
+```
+
+Creates a `Result<T, E>` representing a failed outcome containing an error.
+This function is used to construct a `Result` that signifies the operation failed by containing the error `E`.
+
+## Type parameters
+
+| Type parameter | Description |
+| :------ | :------ |
+| `T` | The type of the value that the result could potentially contain (not used in this case). |
+| `E` | The type of the error to be wrapped in the `Err` result. |
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `error` | `E` | The error to wrap as an `Err` result. |
+
+## Returns
+
+[`Result`](../interfaces/Result.md)\<`T`, `E`\>
+
+A `Result<T, E>` that contains the provided error, representing the `Err` case.
+
+## Example
+
+```ts
+const badResult = Err<number, Error>(new Error('Something went wrong'));
+if (badResult.isErr()) {
+  console.error(badResult.unwrapErr()); // Outputs: Error: Something went wrong
+}
+```
+
+## Source
+
+[enum/prelude.ts:855](https://github.com/JiangJie/happy-rusty/blob/15ed105e08c6cc3943e22243c9386336a521d83e/src/enum/prelude.ts#L855)

package/docs/functions/Ok.md

@@ -0,0 +1,46 @@
+[**happy-rusty**](../index.md) • **Docs**
+
+***
+
+[happy-rusty](../index.md) / Ok
+
+# Function: Ok()
+
+```ts
+function Ok<T, E>(value): Result<T, E>
+```
+
+Creates a `Result<T, E>` representing a successful outcome containing a value.
+This function is used to construct a `Result` that signifies the operation was successful by containing the value `T`.
+
+## Type parameters
+
+| Type parameter | Description |
+| :------ | :------ |
+| `T` | The type of the value to be contained in the `Ok` result. |
+| `E` | The type of the error that the result could potentially contain (not used in this case). |
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `value` | `T` | The value to wrap as an `Ok` result. |
+
+## Returns
+
+[`Result`](../interfaces/Result.md)\<`T`, `E`\>
+
+A `Result<T, E>` that contains the provided value, representing the `Ok` case.
+
+## Example
+
+```ts
+const goodResult = Ok<number, Error>(1); // Result<number, Error> with a value
+if (goodResult.isOk()) {
+  console.log(goodResult.unwrap()); // Outputs: 1
+}
+```
+
+## Source
+
+[enum/prelude.ts:776](https://github.com/JiangJie/happy-rusty/blob/15ed105e08c6cc3943e22243c9386336a521d83e/src/enum/prelude.ts#L776)

package/docs/functions/Some.md

@@ -0,0 +1,45 @@
+[**happy-rusty**](../index.md) • **Docs**
+
+***
+
+[happy-rusty](../index.md) / Some
+
+# Function: Some()
+
+```ts
+function Some<T>(value): Option<T>
+```
+
+Creates an `Option<T>` representing the presence of a value.
+This function is typically used to construct an `Option` that contains a value, indicating that the operation yielding the value was successful.
+
+## Type parameters
+
+| Type parameter | Description |
+| :------ | :------ |
+| `T` | The type of the value to be wrapped in a `Some`. |
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `value` | `T` | The value to wrap as a `Some` option. |
+
+## Returns
+
+[`Option`](../interfaces/Option.md)\<`T`\>
+
+An `Option<T>` that contains the provided value, representing the `Some` case.
+
+## Example
+
+```ts
+const maybeValue = Some(1); // Option<number> with a value
+if (maybeValue.isSome()) {
+    console.log(maybeValue.unwrap()); // Outputs: 1
+}
+```
+
+## Source
+
+[enum/prelude.ts:627](https://github.com/JiangJie/happy-rusty/blob/15ed105e08c6cc3943e22243c9386336a521d83e/src/enum/prelude.ts#L627)

package/docs/functions/promiseToResult.md

@@ -0,0 +1,50 @@
+[**happy-rusty**](../index.md) • **Docs**
+
+***
+
+[happy-rusty](../index.md) / promiseToResult
+
+# Function: promiseToResult()
+
+```ts
+function promiseToResult<T, E>(p): Promise<Result<T, E>>
+```
+
+Converts a Promise to a Result type, capturing the resolved value in an `Ok`, or the error in an `Err`.
+This allows for promise-based asynchronous operations to be handled in a way that is more in line with the Result pattern.
+
+## Type parameters
+
+| Type parameter | Value | Description |
+| :------ | :------ | :------ |
+| `T` | - | The type of the value that the promise resolves to. |
+| `E` | `Error` | The type of the error that the promise may reject with, defaults to `Error`. |
+
+## Parameters
+
+| Parameter | Type | Description |
+| :------ | :------ | :------ |
+| `p` | `Promise`\<`T`\> | The promise to convert into a `Result` type. |
+
+## Returns
+
+`Promise`\<[`Result`](../interfaces/Result.md)\<`T`, `E`\>\>
+
+A promise that resolves to a `Result<T, E>`. If the input promise `p` resolves, the resulting promise will resolve with `Ok<T>`. If the input promise `p` rejects, the resulting promise will resolve with `Err<E>`.
+
+## Example
+
+```ts
+async function example() {
+  const result = await promiseToResult(fetchData());
+  if (result.isOk()) {
+    console.log('Data:', result.unwrap());
+  } else {
+    console.error('Error:', result.unwrapErr());
+  }
+}
+```
+
+## Source
+
+[enum/prelude.ts:959](https://github.com/JiangJie/happy-rusty/blob/15ed105e08c6cc3943e22243c9386336a521d83e/src/enum/prelude.ts#L959)

package/docs/index.md

@@ -0,0 +1,37 @@
+**happy-rusty** • **Docs**
+
+***
+
+# happy-rusty
+
+## Interfaces
+
+| Interface | Description |
+| :------ | :------ |
+| [None](interfaces/None.md) | Represents the absence of a value, as a specialized `Option` type. The type parameter is set to `never` because `None` does not hold a value. |
+| [Option](interfaces/Option.md) | Type `Option` represents an optional value: every `Option` is either `Some` and contains a value, or `None`, and does not. This interface includes methods that act on the `Option` type, similar to Rust's `Option` enum. |
+| [Result](interfaces/Result.md) | The `Result` type is used for returning and propagating errors. It is an enum with the variants, `Ok(T)`, representing success and containing a value, and `Err(E)`, representing error and containing an error value. This interface includes methods that act on the `Result` type, similar to Rust's `Result` enum. |
+
+## Type Aliases
+
+| Type alias | Description |
+| :------ | :------ |
+| [AsyncIOResult](type-aliases/AsyncIOResult.md) | Represents an asynchronous I/O operation that yields a `Result<T, Error>`. This is a promise that resolves to `Ok(T)` if the I/O operation was successful, or `Err(Error)` if there was an error. |
+| [AsyncOption](type-aliases/AsyncOption.md) | 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. |
+| [AsyncResult](type-aliases/AsyncResult.md) | 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. |
+| [IOResult](type-aliases/IOResult.md) | Represents a synchronous operation that yields a `Result<T, Error>`. This is a result that is either `Ok(T)` if the operation was successful, or `Err(Error)` if there was an error. |
+
+## Variables
+
+| Variable | Description |
+| :------ | :------ |
+| [None](variables/None.md) | A constant representing the `None` case of an `Option`, indicating the absence of a value. This constant is frozen to ensure it is immutable and cannot be altered, preserving the integrity of `None` throughout the application. |
+
+## Functions
+
+| Function | Description |
+| :------ | :------ |
+| [Err](functions/Err.md) | Creates a `Result<T, E>` representing a failed outcome containing an error. This function is used to construct a `Result` that signifies the operation failed by containing the error `E`. |
+| [Ok](functions/Ok.md) | Creates a `Result<T, E>` representing a successful outcome containing a value. This function is used to construct a `Result` that signifies the operation was successful by containing the value `T`. |
+| [Some](functions/Some.md) | Creates an `Option<T>` representing the presence of a value. This function is typically used to construct an `Option` that contains a value, indicating that the operation yielding the value was successful. |
+| [promiseToResult](functions/promiseToResult.md) | Converts a Promise to a Result type, capturing the resolved value in an `Ok`, or the error in an `Err`. This allows for promise-based asynchronous operations to be handled in a way that is more in line with the Result pattern. |