npm - happy-rusty - Versions diffs - 1.6.1 → 1.6.2 - Mend

happy-rusty 1.6.1 → 1.6.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/CHANGELOG.md CHANGED Viewed

@@ -5,6 +5,16 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## [1.6.2] - 2025-12-25
+### Changed
+- `promiseToAsyncResult` now accepts `PromiseLike<T>` instead of `Promise<T>` for broader compatibility with thenable objects
+- Use `AsyncResult` type alias in function signatures for consistency
+### Removed
+- Removed unused `source` field from package.json (Parcel legacy)
+- Removed redundant `@internal` tags from private (non-exported) functions
 ## [1.6.1] - 2025-12-19
 ### Changed
@@ -192,6 +202,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Full TypeScript support
 - Comprehensive API matching Rust's Option and Result
+[1.6.2]: https://github.com/JiangJie/happy-rusty/compare/v1.6.1...v1.6.2
+[1.6.1]: https://github.com/JiangJie/happy-rusty/compare/v1.6.0...v1.6.1
 [1.6.0]: https://github.com/JiangJie/happy-rusty/compare/v1.5.0...v1.6.0
 [1.5.0]: https://github.com/JiangJie/happy-rusty/compare/v1.4.0...v1.5.0
 [1.4.0]: https://github.com/JiangJie/happy-rusty/compare/v1.3.2...v1.4.0

package/README.cn.md CHANGED Viewed

@@ -1,17 +1,18 @@
 # happy-rusty
-将 Rust 的 `Option`、`Result` 和同步原语带入 JavaScript/TypeScript - 更好的错误处理和空值安全模式。
+[![License](https://img.shields.io/npm/l/happy-rusty.svg)](LICENSE)
+[![Build Status](https://github.com/JiangJie/happy-rusty/actions/workflows/test.yml/badge.svg)](https://github.com/JiangJie/happy-rusty/actions/workflows/test.yml)
+[![codecov](https://codecov.io/gh/JiangJie/happy-rusty/graph/badge.svg)](https://codecov.io/gh/JiangJie/happy-rusty)
 [![NPM version](https://img.shields.io/npm/v/happy-rusty.svg)](https://npmjs.org/package/happy-rusty)
 [![NPM downloads](https://badgen.net/npm/dm/happy-rusty)](https://npmjs.org/package/happy-rusty)
 [![JSR Version](https://jsr.io/badges/@happy-js/happy-rusty)](https://jsr.io/@happy-js/happy-rusty)
 [![JSR Score](https://jsr.io/badges/@happy-js/happy-rusty/score)](https://jsr.io/@happy-js/happy-rusty/score)
-[![Build Status](https://github.com/JiangJie/happy-rusty/actions/workflows/test.yml/badge.svg)](https://github.com/JiangJie/happy-rusty/actions/workflows/test.yml)
-[![codecov](https://codecov.io/gh/JiangJie/happy-rusty/graph/badge.svg)](https://codecov.io/gh/JiangJie/happy-rusty)
+将 Rust 的 `Option`、`Result` 和同步原语带入 JavaScript/TypeScript - 更好的错误处理和空值安全模式。
 ---
-[English](README.md)
+[English](README.md) | [API 文档](https://jiangjie.github.io/happy-rusty/)
 ---
@@ -247,10 +248,6 @@ function tryFold<T, Acc>(
 - [Mutex](examples/mutex.ts)
 - [ControlFlow](examples/control_flow.ts)
-## 文档
-完整的 API 文档请查看 [jiangjie.github.io/happy-rusty](https://jiangjie.github.io/happy-rusty/)。
 ## 设计说明
 ### 不可变性

package/README.md CHANGED Viewed

@@ -1,17 +1,18 @@
 # happy-rusty
-Rust's `Option`, `Result`, and sync primitives for JavaScript/TypeScript - Better error handling and null-safety patterns.
+[![License](https://img.shields.io/npm/l/happy-rusty.svg)](LICENSE)
+[![Build Status](https://github.com/JiangJie/happy-rusty/actions/workflows/test.yml/badge.svg)](https://github.com/JiangJie/happy-rusty/actions/workflows/test.yml)
+[![codecov](https://codecov.io/gh/JiangJie/happy-rusty/graph/badge.svg)](https://codecov.io/gh/JiangJie/happy-rusty)
 [![NPM version](https://img.shields.io/npm/v/happy-rusty.svg)](https://npmjs.org/package/happy-rusty)
 [![NPM downloads](https://badgen.net/npm/dm/happy-rusty)](https://npmjs.org/package/happy-rusty)
 [![JSR Version](https://jsr.io/badges/@happy-js/happy-rusty)](https://jsr.io/@happy-js/happy-rusty)
 [![JSR Score](https://jsr.io/badges/@happy-js/happy-rusty/score)](https://jsr.io/@happy-js/happy-rusty/score)
-[![Build Status](https://github.com/JiangJie/happy-rusty/actions/workflows/test.yml/badge.svg)](https://github.com/JiangJie/happy-rusty/actions/workflows/test.yml)
-[![codecov](https://codecov.io/gh/JiangJie/happy-rusty/graph/badge.svg)](https://codecov.io/gh/JiangJie/happy-rusty)
+Rust's `Option`, `Result`, and sync primitives for JavaScript/TypeScript - Better error handling and null-safety patterns.
 ---
-[中文](README.cn.md)
+[中文](README.cn.md) | [API Documentation](https://jiangjie.github.io/happy-rusty/)
 ---
@@ -247,10 +248,6 @@ function tryFold<T, Acc>(
 - [Mutex](examples/mutex.ts)
 - [ControlFlow](examples/control_flow.ts)
-## Documentation
-Full API documentation is available at [jiangjie.github.io/happy-rusty](https://jiangjie.github.io/happy-rusty/).
 ## Design Notes
 ### Immutability

package/dist/main.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"main.cjs","sources":["../src/enum/symbols.ts","../src/enum/utils.ts","../src/enum/prelude.ts","../src/enum/constants.ts","../src/enum/extensions.ts","../src/ops/symbols.ts","../src/ops/control_flow.ts","../src/ops/utils.ts","../src/sync/lazy.ts","../src/sync/mutex.ts","../src/sync/once.ts"],"sourcesContent":["/*\n @fileoverview\n * Internal symbols used to identify `Option` and `Result` type variants.\n \n These symbols are used as property keys to distinguish between `Some`/`None` and `Ok`/`Err` variants.\n * They provide a reliable way to identify the variant of an `Option` or `Result` instance without\n * relying on method calls or duck typing.\n \n Note: These symbols are internal implementation details and are not exported as part of the public API.\n * Use the `isOption` and `isResult` utility functions for type checking instead.\n /\n\n/\n A unique symbol used as a property key to identify the variant of an `Option` instance.\n \n When accessed on an `Option`, returns `'Some'` if the Option contains a value,\n * or `'None'` if it represents the absence of a value.\n \n This symbol is used internally by the `isOption` utility function to verify\n * that an object is a valid `Option` instance.\n \n @internal\n /\nexport const OptionKindSymbol = Symbol('Option kind');\n\n/\n A unique symbol used as a property key to identify the variant of a `Result` instance.\n \n When accessed on a `Result`, returns `'Ok'` if the Result represents success,\n * or `'Err'` if it represents failure.\n \n This symbol is used internally by the `isResult` utility function to verify\n * that an object is a valid `Result` instance.\n \n @internal\n /\nexport const ResultKindSymbol = Symbol('Result kind');\n","/\n @fileoverview\n * Type guard utilities for checking if values are `Option` or `Result` types.\n \n These functions provide runtime type checking capabilities for the Option and Result types.\n /\nimport type { Option, Result } from './core.ts';\nimport { OptionKindSymbol, ResultKindSymbol } from './symbols.ts';\n\n/\n Checks if a value is an `Option`.\n \n @typeParam T - The expected type of the value contained within the `Option`.\n * @param o - The value to be checked as an `Option`.\n * @returns `true` if the value is an `Option`, otherwise `false`.\n * @example\n * ```ts\n * const x = Some(5);\n * console.log(isOption(x)); // true\n * console.log(isOption(null)); // false\n * console.log(isOption({ value: 5 })); // false\n * ```\n /\nexport function isOption<T>(o: unknown): o is Option<T> {\n // `Some` and `None` must be an object.\n return o != null && typeof o === 'object' && OptionKindSymbol in o;\n}\n\n/\n Checks if a value is a `Result`.\n \n @typeParam T - The expected type of the success value contained within the `Result`.\n * @typeParam E - The expected type of the error value contained within the `Result`.\n * @param r - The value to be checked as a `Result`.\n * @returns `true` if the value is a `Result`, otherwise `false`.\n * @example\n * ```ts\n * const x = Ok(5);\n * console.log(isResult(x)); // true\n * console.log(isResult(null)); // false\n * console.log(isResult({ value: 5 })); // false\n * ```\n /\nexport function isResult<T, E>(r: unknown): r is Result<T, E> {\n // `Ok` and `Err` must be an object.\n return r != null && typeof r === 'object' && ResultKindSymbol in r;\n}","/\n @fileoverview\n * Constructors and factory functions for creating `Option` and `Result` types.\n \n This module exports:\n * - `Some<T>(value)` - Creates an Option containing a value\n * - `None` - Constant representing absence of value\n * - `Ok<T, E>(value)` - Creates a successful Result\n * - `Err<T, E>(error)` - Creates a failed Result\n * - `None` interface - Type overrides for better type inference\n /\nimport type { AsyncOption, AsyncResult, Option, Result } from './core.ts';\nimport { OptionKindSymbol, ResultKindSymbol } from './symbols.ts';\nimport { isOption, isResult } from './utils.ts';\n\n/\n Represents the absence of a value, as a specialized `Option` type.\n * The type parameter is set to `never` because `None` does not hold a value.\n /\nexport interface None extends Option<never> {\n /\n When using `None` alone, the following overrides can make type inference more accurate.\n /\n\n readonly [OptionKindSymbol]: 'None';\n\n isSome(): false;\n isNone(): true;\n isSomeAnd(predicate: (value: never) => boolean): false;\n isSomeAndAsync(predicate: (value: never) => Promise<boolean>): Promise<false>;\n isNoneOr(predicate: (value: never) => boolean): true;\n isNoneOrAsync(predicate: (value: never) => Promise<boolean>): Promise<true>;\n\n expect(msg: string): never;\n unwrap(): never;\n unwrapOr<T>(defaultValue: T): T;\n unwrapOrElse<T>(fn: () => T): T;\n unwrapOrElseAsync<T>(fn: () => Promise<T>): Promise<T>;\n\n okOr<E>(error: E): Result<never, E>;\n okOrElse<E>(err: () => E): Result<never, E>;\n transpose(): Result<this, never>;\n\n filter(predicate: (value: never) => boolean): this;\n flatten(): this;\n map<U>(fn: (value: never) => U): this;\n mapOr<U>(defaultValue: U, fn: (value: never) => U): U;\n mapOrElse<U>(defaultFn: () => U, fn: (value: never) => U): U;\n\n zip<U>(other: Option<U>): this;\n zipWith<U, R>(other: Option<U>, fn: (value: never, otherValue: U) => R): this;\n unzip(): [this, this];\n\n and<U>(other: Option<U>): this;\n andThen<U>(fn: (value: never) => Option<U>): this;\n andThenAsync<U>(fn: (value: never) => AsyncOption<U>): Promise<this>;\n or<T>(other: Option<T>): Option<T>;\n orElse<T>(fn: () => Option<T>): Option<T>;\n orElseAsync<T>(fn: () => AsyncOption<T>): AsyncOption<T>;\n xor<T>(other: Option<T>): Option<T>;\n\n inspect(fn: (value: never) => void): this;\n\n eq<T>(other: Option<T>): boolean;\n}\n\n/\n Creates an `Option<T>` representing the presence of a value.\n * This function is typically used to construct an `Option` that contains a value, indicating that the operation yielding the value was successful.\n \n @typeParam T - The type of the value to be wrapped in a `Some`.\n * @param value - The value to wrap as a `Some` option.\n * @returns An `Option<T>` that contains the provided value, representing the `Some` case.\n \n @example\n * ```ts\n * const maybeValue = Some(1); // Option<number> with a value\n * if (maybeValue.isSome()) {\n * console.log(maybeValue.unwrap()); // Outputs: 1\n * }\n * ```\n /\nexport function Some<T>(value: T): Option<T> {\n const some: Option<T> = Object.freeze<Option<T>>({\n [Symbol.toStringTag]: 'Option',\n [OptionKindSymbol]: 'Some',\n\n isSome(): true {\n return true;\n },\n isNone(): false {\n return false;\n },\n isSomeAnd(predicate: (value: T) => boolean): boolean {\n return predicate(value);\n },\n isSomeAndAsync(predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n return predicate(value);\n },\n isNoneOr(predicate: (value: T) => boolean): boolean {\n return predicate(value);\n },\n isNoneOrAsync(predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n return predicate(value);\n },\n\n expect(_msg: string): T {\n return value;\n },\n unwrap(): T {\n return value;\n },\n unwrapOr(_defaultValue: T): T {\n return value;\n },\n unwrapOrElse(_fn: () => T): T {\n return value;\n },\n unwrapOrElseAsync(_fn: () => Promise<T>): Promise<T> {\n return Promise.resolve(value);\n },\n\n okOr<E>(_error: E): Result<T, E> {\n return Ok(value);\n },\n okOrElse<E>(_err: () => E): Result<T, E> {\n return Ok(value);\n },\n transpose<U, E>(): Result<Option<U>, E> {\n assertResult<U, E>(value);\n return value.isOk() ? Ok(Some(value.unwrap())) : Err(value.unwrapErr());\n },\n\n filter(predicate: (value: T) => boolean): Option<T> {\n return predicate(value) ? some : None;\n },\n flatten<U>(): Option<U> {\n assertOption<U>(value);\n return value;\n },\n map<U>(fn: (value: T) => U): Option<U> {\n return Some(fn(value));\n },\n\n mapOr<U>(_defaultValue: U, fn: (value: T) => U): U {\n return fn(value);\n },\n mapOrElse<U>(_defaultFn: () => U, fn: (value: T) => U): U {\n return fn(value);\n },\n\n zip<U>(other: Option<U>): Option<[T, U]> {\n assertOption<U>(other);\n return other.isSome() ? Some([value, other.unwrap()]) : None;\n },\n zipWith<U, R>(other: Option<U>, fn: (value: T, otherValue: U) => R): Option<R> {\n assertOption<U>(other);\n return other.isSome() ? Some(fn(value, other.unwrap())) : None;\n },\n unzip<U, R>(): [Option<U>, Option<R>] {\n const tuple = value as [U, R];\n\n if (!Array.isArray(tuple) \|\| tuple.length !== 2) {\n throw new TypeError(`Option::unzip() requires a 2-element tuple, received ${ Array.isArray(tuple) ? `array with ${ tuple.length } elements` : typeof tuple }.`);\n }\n\n const [a, b] = tuple;\n return [Some(a), Some(b)];\n },\n\n and<U>(other: Option<U>): Option<U> {\n assertOption<U>(other);\n return other;\n },\n andThen<U>(fn: (value: T) => Option<U>): Option<U> {\n return fn(value);\n },\n andThenAsync<U>(fn: (value: T) => AsyncOption<U>): AsyncOption<U> {\n return fn(value);\n },\n or(_other: Option<T>): Option<T> {\n return some;\n },\n orElse(_fn: () => Option<T>): Option<T> {\n return some;\n },\n orElseAsync(_fn: () => AsyncOption<T>): AsyncOption<T> {\n return Promise.resolve(some);\n },\n xor(other: Option<T>): Option<T> {\n assertOption<T>(other);\n return other.isSome() ? None : some;\n },\n\n inspect(fn: (value: T) => void): Option<T> {\n fn(value);\n return some;\n },\n\n eq(other: Option<T>): boolean {\n assertOption<T>(other);\n return other.isSome() && other.unwrap() === value;\n },\n\n toString(): string {\n return `Some(${ value })`;\n },\n } as const);\n\n return some;\n}\n\n/\n A constant representing the `None` case of an `Option`, indicating the absence of a value.\n * This constant is frozen to ensure it is immutable and cannot be altered, preserving the integrity of `None` throughout the application.\n \n @example\n * ```ts\n * // Use None to represent absence of a value\n * function findUser(id: number): Option<User> {\n * const user = users.find(u => u.id === id);\n * return user ? Some(user) : None;\n * }\n \n // None is a singleton, so you can compare by reference\n * const result = findUser(999);\n * if (result === None) {\n * console.log('User not found');\n * }\n \n // Use with Option methods\n * const name = None.unwrapOr('Anonymous'); // 'Anonymous'\n * ```\n /\nexport const None: None = Object.freeze<None>({\n [Symbol.toStringTag]: 'Option',\n [OptionKindSymbol]: 'None',\n\n isSome(): false {\n return false;\n },\n isNone(): true {\n return true;\n },\n isSomeAnd(_predicate: (value: never) => boolean): false {\n return false;\n },\n isSomeAndAsync(_predicate: (value: never) => Promise<boolean>): Promise<false> {\n return Promise.resolve(false);\n },\n isNoneOr(_predicate: (value: never) => boolean): true {\n return true;\n },\n isNoneOrAsync(_predicate: (value: never) => Promise<boolean>): Promise<true> {\n return Promise.resolve(true);\n },\n\n expect(msg: string): never {\n throw new TypeError(msg);\n },\n unwrap(): never {\n throw new TypeError('Option::unwrap() called on a `None` value.');\n },\n unwrapOr<T>(defaultValue: T): T {\n return defaultValue;\n },\n unwrapOrElse<T>(fn: () => T): T {\n return fn();\n },\n unwrapOrElseAsync<T>(fn: () => Promise<T>): Promise<T> {\n return fn();\n },\n\n okOr<E>(error: E): Result<never, E> {\n return Err(error);\n },\n okOrElse<E>(err: () => E): Result<never, E> {\n return Err(err());\n },\n transpose(): Result<None, never> {\n return Ok(None);\n },\n\n filter(_predicate: (value: never) => boolean): None {\n return None;\n },\n flatten(): None {\n return None;\n },\n map<U>(_fn: (value: never) => U): None {\n return None;\n },\n\n mapOr<U>(defaultValue: U, _fn: (value: never) => U): U {\n return defaultValue;\n },\n mapOrElse<U>(defaultFn: () => U, _fn: (value: never) => U): U {\n return defaultFn();\n },\n\n zip<U>(_other: Option<U>): None {\n return None;\n },\n zipWith<U, R>(_other: Option<U>, _fn: (value: never, otherValue: U) => R): None {\n return None;\n },\n unzip(): [None, None] {\n return [None, None];\n },\n\n and<U>(_other: Option<U>): None {\n return None;\n },\n andThen<U>(_fn: (value: never) => Option<U>): None {\n return None;\n },\n andThenAsync<U>(_fn: (value: never) => AsyncOption<U>): Promise<None> {\n return Promise.resolve(None);\n },\n or<T>(other: Option<T>): Option<T> {\n assertOption<T>(other);\n return other;\n },\n orElse<T>(fn: () => Option<T>): Option<T> {\n return fn();\n },\n orElseAsync<T>(fn: () => AsyncOption<T>): AsyncOption<T> {\n return fn();\n },\n xor<T>(other: Option<T>): Option<T> {\n assertOption<T>(other);\n return other.isSome() ? other : None;\n },\n\n inspect(_fn: (value: never) => void): None {\n return None;\n },\n\n eq<T>(other: Option<T>): boolean {\n assertOption<T>(other);\n return other === None;\n },\n\n toString(): string {\n return 'None';\n },\n} as const);\n\n/\n Creates a `Result<T, E>` representing a successful outcome containing a value.\n * This function is used to construct a `Result` that signifies the operation was successful by containing the value `T`.\n \n @typeParam T - The type of the value to be contained in the `Ok` result.\n * @typeParam E - The type of the error that the result could potentially contain (not used in this case).\n * @param value - The value to wrap as an `Ok` result.\n * @returns A `Result<T, E>` that contains the provided value, representing the `Ok` case.\n \n @example\n * ```ts\n * const goodResult = Ok<number, Error>(1); // Result<number, Error> with a value\n * if (goodResult.isOk()) {\n * console.log(goodResult.unwrap()); // Outputs: 1\n * }\n * ```\n /\nexport function Ok<T, E = never>(value: T): Result<T, E>;\n/\n Creates a `Result<void, E>` representing a successful outcome with no value.\n * This overload is used when the operation succeeds but doesn't produce a meaningful value.\n \n In Rust, this would be `Ok(())` using the unit type `()`.\n * Since JavaScript doesn't have a unit type, we use `void` instead.\n \n @typeParam E - The type of the error that the result could potentially contain.\n * @returns A `Result<void, E>` representing a successful operation with no value.\n \n @example\n * ```ts\n * function saveToFile(path: string): Result<void, Error> {\n * try {\n * fs.writeFileSync(path, data);\n * return Ok(); // Success with no return value\n * } catch (e) {\n * return Err(e as Error);\n * }\n * }\n \n const result = saveToFile('/tmp/data.txt');\n * if (result.isOk()) {\n * console.log('File saved successfully');\n * }\n * ```\n /\nexport function Ok<E = never>(): Result<void, E>;\nexport function Ok<T, E>(value?: T): Result<T, E> {\n const ok: Result<T, E> = Object.freeze<Result<T, E>>({\n [Symbol.toStringTag]: 'Result',\n [ResultKindSymbol]: 'Ok',\n\n isOk(): true {\n return true;\n },\n isErr(): false {\n return false;\n },\n isOkAnd(predicate: (value: T) => boolean): boolean {\n return predicate(value as T);\n },\n isOkAndAsync(predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n return predicate(value as T);\n },\n isErrAnd(_predicate: (error: E) => boolean): false {\n return false;\n },\n isErrAndAsync(_predicate: (error: E) => Promise<boolean>): Promise<false> {\n return Promise.resolve(false);\n },\n\n expect(_msg: string): T {\n return value as T;\n },\n unwrap(): T {\n return value as T;\n },\n unwrapOr(_defaultValue: T): T {\n return value as T;\n },\n unwrapOrElse(_fn: (error: E) => T): T {\n return value as T;\n },\n unwrapOrElseAsync(_fn: (error: E) => Promise<T>): Promise<T> {\n return Promise.resolve(value as T);\n },\n\n expectErr(msg: string): never {\n throw new TypeError(`${ msg }: ${ value }`);\n },\n unwrapErr(): never {\n throw new TypeError('Result::unwrapErr() called on an `Ok` value.');\n },\n\n ok(): Option<T> {\n return Some(value as T);\n },\n err(): None {\n return None;\n },\n transpose<U>(): Option<Result<U, E>> {\n assertOption<U>(value);\n return value.isSome() ? Some(Ok(value.unwrap())) : None;\n },\n\n map<U>(fn: (value: T) => U): Result<U, E> {\n return Ok(fn(value as T));\n },\n mapErr<F>(_fn: (error: E) => F): Result<T, F> {\n return Ok(value as T);\n },\n mapOr<U>(_defaultValue: U, fn: (value: T) => U): U {\n return fn(value as T);\n },\n mapOrElse<U>(_defaultFn: (error: E) => U, fn: (value: T) => U): U {\n return fn(value as T);\n },\n flatten<U>(): Result<U, E> {\n assertResult<U, E>(value);\n return value;\n },\n\n and<U>(other: Result<U, E>): Result<U, E> {\n assertResult<T, E>(other);\n return other;\n },\n or<F>(_other: Result<T, F>): Result<T, F> {\n return ok as unknown as Result<T, F>;\n },\n andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E> {\n return fn(value as T);\n },\n andThenAsync<U>(fn: (value: T) => AsyncResult<U, E>): AsyncResult<U, E> {\n return fn(value as T);\n },\n orElse<F>(_fn: (error: E) => Result<T, F>): Result<T, F> {\n return ok as unknown as Result<T, F>;\n },\n orElseAsync<F>(_fn: (error: E) => AsyncResult<T, F>): AsyncResult<T, F> {\n return Promise.resolve(ok as unknown as Result<T, F>);\n },\n\n inspect(fn: (value: T) => void): Result<T, E> {\n fn(value as T);\n return ok;\n },\n inspectErr(_fn: (error: E) => void): Result<T, E> {\n return ok;\n },\n\n eq(other: Result<T, E>): boolean {\n assertResult<T, E>(other);\n return other.isOk() && other.unwrap() === value;\n },\n\n asOk<F>(): Result<T, F> {\n return ok as unknown as Result<T, F>;\n },\n asErr(): never {\n throw new TypeError('Result::asErr() called on an `Ok` value.');\n },\n\n toString(): string {\n return `Ok(${ value })`;\n },\n } as const);\n\n return ok;\n}\n\n/\n Creates a `Result<T, E>` representing a failed outcome containing an error.\n * This function is used to construct a `Result` that signifies the operation failed by containing the error `E`.\n \n @typeParam T - The type of the value that the result could potentially contain (not used in this case).\n * @typeParam E - The type of the error to be wrapped in the `Err` result.\n * @param error - The error to wrap as an `Err` result.\n * @returns A `Result<T, E>` that contains the provided error, representing the `Err` case.\n \n @example\n * ```ts\n * const badResult = Err<number, Error>(new Error('Something went wrong'));\n * if (badResult.isErr()) {\n * console.error(badResult.unwrapErr()); // Outputs: Error: Something went wrong\n * }\n * ```\n /\nexport function Err<T = never, E = unknown>(error: E): Result<T, E> {\n const err: Result<T, E> = Object.freeze<Result<T, E>>({\n [Symbol.toStringTag]: 'Result',\n [ResultKindSymbol]: 'Err',\n\n isOk(): false {\n return false;\n },\n isErr(): true {\n return true;\n },\n isOkAnd(_predicate: (value: T) => boolean): false {\n return false;\n },\n isOkAndAsync(_predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n return Promise.resolve(false);\n },\n isErrAnd(predicate: (error: E) => boolean): boolean {\n return predicate(error);\n },\n isErrAndAsync(predicate: (error: E) => Promise<boolean>): Promise<boolean> {\n return predicate(error);\n },\n\n expect(msg: string): never {\n throw new TypeError(`${ msg }: ${ error }`);\n },\n unwrap(): never {\n throw new TypeError('Result::unwrap() called on an `Err` value.');\n },\n unwrapOr(defaultValue: T): T {\n return defaultValue;\n },\n unwrapOrElse(fn: (error: E) => T): T {\n return fn(error);\n },\n unwrapOrElseAsync(fn: (error: E) => Promise<T>): Promise<T> {\n return fn(error);\n },\n\n expectErr(_msg: string): E {\n return error;\n },\n unwrapErr(): E {\n return error;\n },\n\n ok(): None {\n return None;\n },\n err(): Option<E> {\n return Some(error);\n },\n transpose<U>(): Option<Result<U, E>> {\n return Some(err as unknown as Result<U, E>);\n },\n\n map<U>(_fn: (value: T) => U): Result<U, E> {\n return Err(error);\n },\n mapErr<F>(fn: (error: E) => F): Result<T, F> {\n return Err(fn(error));\n },\n mapOr<U>(defaultValue: U, _fn: (value: T) => U): U {\n return defaultValue;\n },\n mapOrElse<U>(defaultFn: (error: E) => U, _fn: (value: T) => U): U {\n return defaultFn(error);\n },\n flatten<U>(): Result<U, E> {\n return err as unknown as Result<U, E>;\n },\n\n and<U>(_other: Result<U, E>): Result<U, E> {\n return err as unknown as Result<U, E>;\n },\n or<F>(other: Result<T, F>): Result<T, F> {\n assertResult<T, E>(other);\n return other;\n },\n andThen<U>(_fn: (value: T) => Result<U, E>): Result<U, E> {\n return err as unknown as Result<U, E>;\n },\n andThenAsync<U>(_fn: (value: T) => AsyncResult<U, E>): AsyncResult<U, E> {\n return Promise.resolve(err as unknown as Result<U, E>);\n },\n orElse<F>(fn: (error: E) => Result<T, F>): Result<T, F> {\n return fn(error);\n },\n orElseAsync<F>(fn: (error: E) => AsyncResult<T, F>): AsyncResult<T, F> {\n return fn(error);\n },\n\n inspect(_fn: (value: T) => void): Result<T, E> {\n return err;\n },\n inspectErr(fn: (error: E) => void): Result<T, E> {\n fn(error);\n return err;\n },\n\n eq(other: Result<T, E>): boolean {\n assertResult<T, E>(other);\n return other.isErr() && other.unwrapErr() === error;\n },\n\n asOk(): never {\n throw new TypeError('Result::asOk() called on an `Err` value.');\n },\n asErr<U>(): Result<U, E> {\n return err as unknown as Result<U, E>;\n },\n\n toString(): string {\n return `Err(${ error })`;\n },\n } as const);\n\n return err;\n}\n\n/\n Safely converts a value to a string representation for error messages.\n * Handles cases where `toString()` might throw or values are null/undefined.\n \n @param value - The value to stringify.\n * @returns A safe string representation of the value.\n * @internal\n /\nfunction safeStringify(value: unknown): string {\n try {\n if (value === null) {\n return 'null';\n }\n if (value === undefined) {\n return 'undefined';\n }\n if (typeof value === 'object') {\n return Object.prototype.toString.call(value);\n }\n return String(value);\n } catch {\n return '[unable to stringify]';\n }\n}\n\n/\n Asserts that a given value is an `Option`.\n \n @typeParam T - The expected type of the value contained within the `Option`.\n * @param o - The value to be checked as an `Option`.\n * @throws {TypeError} If the value is not an `Option`.\n * @see isOption\n * @internal\n /\nfunction assertOption<T>(o: unknown): asserts o is Option<T> {\n if (!isOption(o)) {\n throw new TypeError(`Expected an Option, but received: ${ safeStringify(o) }.`);\n }\n}\n\n/\n Asserts that a given value is a `Result`.\n \n @typeParam T - The expected type of the success value contained within the `Result`.\n * @typeParam E - The expected type of the error value contained within the `Result`.\n * @param r - The value to be checked as a `Result`.\n * @throws {TypeError} If the value is not a `Result`.\n * @see isResult\n * @internal\n /\nfunction assertResult<T, E>(r: unknown): asserts r is Result<T, E> {\n if (!isResult(r)) {\n throw new TypeError(`Expected a Result, but received: ${ safeStringify(r) }.`);\n }\n}","/\n @fileoverview\n * Pre-defined Result constants for common return values.\n \n These immutable constants can be reused throughout the application to avoid\n * creating new Result instances for common values like `true`, `false`, `0`, and `void`.\n /\n/ eslint-disable @typescript-eslint/no-explicit-any /\nimport type { Result } from './core.ts';\nimport { Ok } from './prelude.ts';\n\n/\n Result constant for `true`.\n * Can be used anywhere due to immutability.\n * @example\n * ```ts\n * function validate(): Result<boolean, Error> {\n * return RESULT_TRUE;\n * }\n * ```\n /\nexport const RESULT_TRUE: Result<boolean, any> = Ok(true);\n\n/\n Result constant for `false`.\n * Can be used anywhere due to immutability.\n * @example\n * ```ts\n * function validate(): Result<boolean, Error> {\n * return RESULT_FALSE;\n * }\n * ```\n /\nexport const RESULT_FALSE: Result<boolean, any> = Ok(false);\n\n/\n Result constant for `0`.\n * Can be used anywhere due to immutability.\n * @example\n * ```ts\n * function count(): Result<number, Error> {\n * return RESULT_ZERO;\n * }\n * ```\n /\nexport const RESULT_ZERO: Result<number, any> = Ok(0);\n\n/\n Result constant for `void` or `()`.\n * Can be used anywhere due to immutability.\n * @example\n * ```ts\n * function doSomething(): Result<void, Error> {\n * return RESULT_VOID;\n * }\n * ```\n /\nexport const RESULT_VOID: Result<void, any> = Ok();","/\n @fileoverview\n * Extension functions for bridging Promise-based APIs with the Result type.\n \n This module provides utilities for integrating async/await patterns with Result-based error handling.\n /\nimport type { Result } from './core.ts';\nimport { Err, Ok } from './prelude.ts';\n\n/\n Converts a Promise to a Result type, capturing the resolved value in an `Ok`, or the error in an `Err`.\n * This allows for promise-based asynchronous operations to be handled in a way that is more in line with the Result pattern.\n \n Note: JavaScript promises can reject with any value, not just `Error` objects.\n * The error is cast to type `E`, so ensure your error handling accounts for this.\n \n @typeParam T - The type of the value that the promise resolves to.\n * @typeParam E - The type of the error that the promise may reject with, defaults to `Error`.\n * @param p - The promise to convert into a `Result` type.\n * @returns 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>`.\n \n @example\n * ```ts\n * async function example() {\n * const result = await promiseToAsyncResult(fetchData());\n * result.inspect(x => {\n * console.log('Data:', x);\n * }).inspectErr(err => {\n * console.error('Error:', err);\n * });\n * }\n * ```\n \n @example\n * ```ts\n * // With custom error type\n * const result = await promiseToAsyncResult<User, ApiError>(fetchUser(id));\n * ```\n /\nexport async function promiseToAsyncResult<T, E = Error>(p: Promise<T>): Promise<Result<T, E>> {\n try {\n return Ok(await p);\n } catch (err) {\n return Err(err as E);\n }\n}","/\n @fileoverview\n * Internal symbols used to identify `ControlFlow` type variants.\n \n These symbols are used as property keys to distinguish between `Break` and `Continue` variants.\n * They provide a reliable way to identify the variant of a `ControlFlow` instance without\n * relying on method calls or duck typing.\n \n Note: These symbols are internal implementation details and are not exported as part of the public API.\n * Use the `isControlFlow` utility function for type checking instead.\n /\n\n/\n A unique symbol used as a property key to identify the variant of a `ControlFlow` instance.\n \n When accessed on a `ControlFlow`, returns `'Break'` if the ControlFlow signals early exit,\n * or `'Continue'` if it signals to proceed as normal.\n \n This symbol is used internally by the `isControlFlow` utility function to verify\n * that an object is a valid `ControlFlow` instance.\n \n @internal\n /\nexport const ControlFlowKindSymbol = Symbol('ControlFlow kind');\n","/\n @fileoverview\n * Rust-inspired [ControlFlow](https://doc.rust-lang.org/std/ops/enum.ControlFlow.html) for control flow handling.\n \n `ControlFlow` is used to tell an operation whether it should exit early or go on as usual.\n * This is useful for:\n * - Short-circuiting iterators\n * - Signaling early termination in fold-like operations\n * - Implementing custom control flow patterns\n /\n\nimport { Err, None, Ok, Some, type Option, type Result } from '../enum/mod.ts';\nimport { ControlFlowKindSymbol } from './symbols.ts';\n\n/\n Used to tell an operation whether it should exit early or go on as usual.\n \n This is the return type of `try_fold` and similar iterator methods that support\n * short-circuiting. It can also be used in custom control flow scenarios.\n \n @typeParam B - The type of the value returned on `Break` (early exit).\n * @typeParam C - The type of the value returned on `Continue` (default: `void`).\n \n @example\n * ```ts\n * // Using ControlFlow to short-circuit a search\n * function findFirstNegative(numbers: number[]): Option<number> {\n * let result: Option<number> = None;\n \n for (const n of numbers) {\n * const flow = n < 0 ? Break(n) : Continue();\n * if (flow.isBreak()) {\n * result = Some(flow.breakValue().unwrap());\n * break;\n * }\n * }\n \n return result;\n * }\n * ```\n \n @example\n * ```ts\n * // Using ControlFlow in a custom fold operation\n * function tryFold<T, Acc>(\n * arr: T[],\n * init: Acc,\n * f: (acc: Acc, item: T) => ControlFlow<Acc, Acc>\n * ): ControlFlow<Acc, Acc> {\n * let acc = init;\n * for (const item of arr) {\n * const flow = f(acc, item);\n * if (flow.isBreak()) {\n * return flow;\n * }\n * acc = flow.continueValue().unwrap();\n * }\n * return Continue(acc);\n * }\n * ```\n /\nexport interface ControlFlow<B, C = void> {\n // #region Internal properties\n\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'ControlFlow'` so that `Object.prototype.toString.call(flow)` produces `'[object ControlFlow]'`.\n \n This enables reliable type identification even across different execution contexts (e.g., iframes, different module instances).\n \n @example\n * ```ts\n * const x = Break(5);\n * console.log(Object.prototype.toString.call(x)); // '[object ControlFlow]'\n * ```\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'ControlFlow';\n\n /\n A unique symbol property used to identify the variant of this `ControlFlow`.\n * Returns `'Break'` if the ControlFlow signals early exit, or `'Continue'` if it signals to proceed as normal.\n \n This is used internally by the `isControlFlow` utility function to verify that an object is a valid `ControlFlow` instance,\n * and to distinguish between `Break` and `Continue` variants without calling methods.\n \n Note: The symbol itself is not exported as part of the public API.\n * Use the `isControlFlow` utility function or the `isBreak()`/`isContinue()` methods for type checking.\n \n @internal\n /\n readonly [ControlFlowKindSymbol]: 'Break' \| 'Continue';\n\n // #endregion\n\n /\n Returns `true` if this is a `Break` variant.\n \n @example\n * ```ts\n * console.log(Break(3).isBreak()); // true\n * console.log(Continue().isBreak()); // false\n * ```\n /\n isBreak(): boolean;\n\n /\n Returns `true` if this is a `Continue` variant.\n \n @example\n * ```ts\n * console.log(Continue().isContinue()); // true\n * console.log(Break(3).isContinue()); // false\n * ```\n /\n isContinue(): boolean;\n\n /\n Converts the `ControlFlow` into an `Option` which is `Some` if the\n * `ControlFlow` was `Break` and `None` otherwise.\n \n @returns `Some(value)` if `Break`, `None` if `Continue`.\n \n @example\n * ```ts\n * console.log(Break(3).breakValue()); // Some(3)\n * console.log(Continue().breakValue()); // None\n * ```\n /\n breakValue(): Option<B>;\n\n /\n Converts the `ControlFlow` into an `Option` which is `Some` if the\n * `ControlFlow` was `Continue` and `None` otherwise.\n \n @returns `Some(value)` if `Continue`, `None` if `Break`.\n \n @example\n * ```ts\n * console.log(Continue(5).continueValue()); // Some(5)\n * console.log(Break(3).continueValue()); // None\n * ```\n /\n continueValue(): Option<C>;\n\n /\n Maps `ControlFlow<B, C>` to `ControlFlow<T, C>` by applying a function\n * to the break value in case it exists.\n \n @typeParam T - The type of the new break value.\n * @param fn - A function to apply to the break value.\n * @returns A new `ControlFlow` with the mapped break value.\n \n @example\n * ```ts\n * const flow = Break(3);\n * console.log(flow.mapBreak(v => v * 2).breakValue()); // Some(6)\n * ```\n /\n mapBreak<T>(fn: (value: B) => T): ControlFlow<T, C>;\n\n /\n Maps `ControlFlow<B, C>` to `ControlFlow<B, T>` by applying a function\n * to the continue value in case it exists.\n \n @typeParam T - The type of the new continue value.\n * @param fn - A function to apply to the continue value.\n * @returns A new `ControlFlow` with the mapped continue value.\n \n @example\n * ```ts\n * const flow = Continue(5);\n * console.log(flow.mapContinue(v => v * 2).continueValue()); // Some(10)\n * ```\n /\n mapContinue<T>(fn: (value: C) => T): ControlFlow<B, T>;\n\n /\n Converts the `ControlFlow` into a `Result` which is `Ok` if the\n * `ControlFlow` was `Break` and `Err` otherwise.\n \n @returns `Ok(breakValue)` if `Break`, `Err(continueValue)` if `Continue`.\n \n @example\n * ```ts\n * console.log(Break(3).breakOk()); // Ok(3)\n * console.log(Continue('still going').breakOk()); // Err('still going')\n * ```\n /\n breakOk(): Result<B, C>;\n\n /\n Converts the `ControlFlow` into a `Result` which is `Ok` if the\n * `ControlFlow` was `Continue` and `Err` otherwise.\n \n @returns `Ok(continueValue)` if `Continue`, `Err(breakValue)` if `Break`.\n \n @example\n * ```ts\n * console.log(Continue(5).continueOk()); // Ok(5)\n * console.log(Break('stopped').continueOk()); // Err('stopped')\n * ```\n /\n continueOk(): Result<C, B>;\n\n /\n Custom `toString` implementation that uses the `ControlFlow`'s contained value.\n * @example\n * ```ts\n * console.log(Break(5).toString()); // 'Break(5)'\n * console.log(Continue('ok').toString()); // 'Continue(ok)'\n * ```\n /\n toString(): string;\n}\n\n/\n Creates a `Break` variant of `ControlFlow`.\n \n Use this to signal that an operation should exit early with the given value.\n \n @typeParam B - The type of the break value.\n * @typeParam C - The type of the continue value (defaults to `void` when a value is provided).\n * @param value - The value to return on break.\n * @returns A `ControlFlow` in the `Break` state.\n \n @example\n * ```ts\n * const flow = Break('found it');\n * console.log(flow.isBreak()); // true\n * console.log(flow.breakValue().unwrap()); // 'found it'\n \n const voidFlow = Break();\n * console.log(voidFlow.isBreak()); // true\n * ```\n /\nexport function Break<B, C = never>(value: B): ControlFlow<B, C>;\n/\n Creates a `Break` variant of `ControlFlow` with no value.\n * This overload is used when the operation exits early but doesn't produce a meaningful value.\n \n @typeParam C - The type of the continue value (allows type specification when chaining with Continue).\n * @returns A `ControlFlow<void, C>` in the `Break` state.\n \n @example\n * ```ts\n * const voidFlow = Break();\n * console.log(voidFlow.isBreak()); // true\n * console.log(voidFlow.breakValue()); // Some(undefined)\n \n // With explicit type parameter\n * const typedFlow = Break<number>(); // ControlFlow<void, number>\n * ```\n /\nexport function Break<C = never>(): ControlFlow<void, C>;\nexport function Break<B, C>(value?: B): ControlFlow<B, C> {\n const brk: ControlFlow<B, C> = Object.freeze<ControlFlow<B, C>>({\n [Symbol.toStringTag]: 'ControlFlow',\n [ControlFlowKindSymbol]: 'Break',\n\n isBreak(): true {\n return true;\n },\n isContinue(): false {\n return false;\n },\n breakValue(): Option<B> {\n return Some(value as B);\n },\n continueValue(): Option<C> {\n return None;\n },\n mapBreak<T>(fn: (v: B) => T): ControlFlow<T, C> {\n return Break(fn(value as B));\n },\n mapContinue<T>(_fn: (v: C) => T): ControlFlow<B, T> {\n return brk as unknown as ControlFlow<B, T>;\n },\n breakOk(): Result<B, C> {\n return Ok(value as B);\n },\n continueOk(): Result<C, B> {\n return Err(value as B);\n },\n\n toString(): string {\n return `Break(${ value })`;\n },\n } as const);\n\n return brk;\n}\n\n/\n Creates a `Continue` variant of `ControlFlow`.\n \n Use this to signal that an operation should continue as normal.\n \n @typeParam B - The type of the break value (defaults to `void` when a value is provided).\n * @typeParam C - The type of the continue value.\n * @param value - The value to carry forward (optional, defaults to `undefined`).\n * @returns A `ControlFlow` in the `Continue` state.\n \n @example\n * ```ts\n * const flow = Continue();\n * console.log(flow.isContinue()); // true\n \n const flowWithValue = Continue(42);\n * console.log(flowWithValue.continueValue().unwrap()); // 42\n * ```\n /\nexport function Continue<B = never, C = void>(value: C): ControlFlow<B, C>;\n/\n Creates a `Continue` variant of `ControlFlow` with no value.\n * This overload is used when the operation continues but doesn't carry a meaningful value.\n \n @typeParam B - The type of the break value (allows type specification when chaining with Break).\n * @returns A `ControlFlow<B, void>` in the `Continue` state.\n \n @example\n * ```ts\n * const voidFlow = Continue();\n * console.log(voidFlow.isContinue()); // true\n * console.log(voidFlow.continueValue()); // Some(undefined)\n \n // With explicit type parameter\n * const typedFlow = Continue<string>(); // ControlFlow<string, void>\n * ```\n /\nexport function Continue<B = never>(): ControlFlow<B, void>;\nexport function Continue<B, C>(value?: C): ControlFlow<B, C> {\n const cont: ControlFlow<B, C> = Object.freeze<ControlFlow<B, C>>({\n [Symbol.toStringTag]: 'ControlFlow',\n [ControlFlowKindSymbol]: 'Continue',\n\n isBreak(): false {\n return false;\n },\n isContinue(): true {\n return true;\n },\n breakValue(): Option<B> {\n return None;\n },\n continueValue(): Option<C> {\n return Some(value as C);\n },\n mapBreak<T>(_fn: (v: B) => T): ControlFlow<T, C> {\n return cont as unknown as ControlFlow<T, C>;\n },\n mapContinue<T>(fn: (v: C) => T): ControlFlow<B, T> {\n return Continue(fn(value as C));\n },\n breakOk(): Result<B, C> {\n return Err(value as C);\n },\n continueOk(): Result<C, B> {\n return Ok(value as C);\n },\n\n toString(): string {\n return `Continue(${ value })`;\n },\n } as const);\n\n return cont;\n}\n","/\n @fileoverview\n * Type guard utilities for checking if values are `ControlFlow` types.\n \n These functions provide runtime type checking capabilities for the ControlFlow type.\n /\nimport type { ControlFlow } from './control_flow.ts';\nimport { ControlFlowKindSymbol } from './symbols.ts';\n\n/\n Checks if a value is a `ControlFlow`.\n \n @typeParam B - The expected type of the break value contained within the `ControlFlow`.\n * @typeParam C - The expected type of the continue value contained within the `ControlFlow`.\n * @param cf - The value to be checked as a `ControlFlow`.\n * @returns `true` if the value is a `ControlFlow`, otherwise `false`.\n * @example\n * ```ts\n * const x = Break(5);\n * console.log(isControlFlow(x)); // true\n * console.log(isControlFlow(null)); // false\n * console.log(isControlFlow({ isBreak: () => true })); // false\n * ```\n /\nexport function isControlFlow<B, C>(cf: unknown): cf is ControlFlow<B, C> {\n // `Break` and `Continue` must be an object.\n return cf != null && typeof cf === 'object' && ControlFlowKindSymbol in cf;\n}\n","/\n @fileoverview\n * Rust-inspired [LazyLock](https://doc.rust-lang.org/std/sync/struct.LazyLock.html) for lazy initialization.\n \n `Lazy<T>` is a value which is initialized on the first access. Unlike `Once<T>`,\n * the initialization function is provided at construction time.\n /\n\nimport { None, Some, type Option } from '../enum/mod.ts';\n\n/\n A value which is initialized on the first access.\n \n This is a lazily evaluated value. The initialization function is provided\n * at construction time and executed on first access. Subsequent accesses\n * return the cached value.\n \n Unlike `Once<T>`, which allows setting values manually or with different\n * initializers, `Lazy<T>` binds the initializer at creation time.\n \n @typeParam T - The type of the value stored.\n \n @example\n * ```ts\n * const expensive = Lazy(() => {\n * console.log('Computing...');\n * return heavyComputation();\n * });\n \n // Nothing computed yet\n * console.log(expensive.isInitialized()); // false\n \n // First access triggers computation\n * const value = expensive.force(); // logs \"Computing...\"\n \n // Subsequent access returns cached value\n * const same = expensive.force(); // no log, returns cached value\n * ```\n /\nexport interface Lazy<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'Lazy'` so that `Object.prototype.toString.call(lazy)` produces `'[object Lazy]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'Lazy';\n\n /\n Forces the evaluation of this lazy value and returns the result.\n \n If the value has already been initialized, returns the cached value.\n * Otherwise, executes the initialization function, caches the result,\n * and returns it.\n \n @returns The initialized value.\n \n @example\n * ```ts\n * const lazy = Lazy(() => 42);\n * console.log(lazy.force()); // 42\n * console.log(lazy.force()); // 42 (cached)\n * ```\n /\n force(): T;\n\n /\n Gets the value if it has been initialized.\n \n Unlike `force()`, this does not trigger initialization.\n \n @returns `Some(value)` if initialized, `None` otherwise.\n \n @example\n * ```ts\n * const lazy = Lazy(() => 42);\n * console.log(lazy.get()); // None\n \n lazy.force();\n * console.log(lazy.get()); // Some(42)\n * ```\n /\n get(): Option<T>;\n\n /\n Returns `true` if the value has been initialized.\n \n @example\n * ```ts\n * const lazy = Lazy(() => 42);\n * console.log(lazy.isInitialized()); // false\n \n lazy.force();\n * console.log(lazy.isInitialized()); // true\n * ```\n /\n isInitialized(): boolean;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const lazy = Lazy(() => 42);\n * console.log(lazy.toString()); // 'Lazy(<uninitialized>)'\n \n lazy.force();\n * console.log(lazy.toString()); // 'Lazy(42)'\n * ```\n /\n toString(): string;\n}\n\n/\n A value which is initialized asynchronously on the first access.\n \n Similar to `Lazy<T>`, but the initialization function is async.\n * If multiple calls to `force()` occur concurrently before initialization\n * completes, only one initialization will run.\n \n @typeParam T - The type of the value stored.\n \n @example\n * ```ts\n * const db = LazyAsync(async () => {\n * console.log('Connecting...');\n * return await Database.connect(url);\n * });\n \n // Multiple concurrent accesses - only one connection\n * const [db1, db2] = await Promise.all([\n * db.force(),\n * db.force(),\n * ]);\n * // db1 === db2\n * ```\n /\nexport interface LazyAsync<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'LazyAsync'` so that `Object.prototype.toString.call(lazy)` produces `'[object LazyAsync]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'LazyAsync';\n\n /\n Forces the evaluation of this lazy value and returns a promise to the result.\n \n If the value has already been initialized, returns the cached value.\n * If initialization is in progress, waits for it to complete.\n * Otherwise, starts initialization.\n \n @returns A promise that resolves to the initialized value.\n \n @example\n * ```ts\n * const lazy = LazyAsync(async () => {\n * await delay(100);\n * return 42;\n * });\n * console.log(await lazy.force()); // 42\n * ```\n /\n force(): Promise<T>;\n\n /\n Gets the value if it has been initialized.\n \n Unlike `force()`, this does not trigger initialization.\n \n @returns `Some(value)` if initialized, `None` otherwise.\n \n @example\n * ```ts\n * const lazy = LazyAsync(async () => 42);\n * console.log(lazy.get()); // None\n \n await lazy.force();\n * console.log(lazy.get()); // Some(42)\n * ```\n /\n get(): Option<T>;\n\n /\n Returns `true` if the value has been initialized.\n \n Note: Returns `false` while initialization is in progress.\n \n @example\n * ```ts\n * const lazy = LazyAsync(async () => 42);\n * console.log(lazy.isInitialized()); // false\n \n await lazy.force();\n * console.log(lazy.isInitialized()); // true\n * ```\n /\n isInitialized(): boolean;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const lazy = LazyAsync(async () => 42);\n * console.log(lazy.toString()); // 'LazyAsync(<uninitialized>)'\n \n await lazy.force();\n * console.log(lazy.toString()); // 'LazyAsync(42)'\n * ```\n /\n toString(): string;\n}\n\n/\n Creates a new `Lazy<T>` with the given synchronous initialization function.\n \n The function is called at most once, on first access via `force()`.\n \n @typeParam T - The type of value to store.\n * @param fn - The initialization function that produces the value.\n * @returns A new `Lazy<T>` instance.\n \n @example\n * ```ts\n * // Basic usage\n * const lazy = Lazy(() => {\n * console.log('Initializing');\n * return 42;\n * });\n \n console.log(lazy.isInitialized()); // false\n * console.log(lazy.force()); // logs \"Initializing\", returns 42\n * console.log(lazy.isInitialized()); // true\n * console.log(lazy.force()); // returns 42 (no log)\n * ```\n \n @example\n * ```ts\n * // Lazy singleton pattern\n * const logger = Lazy(() => new Logger('app'));\n \n function getLogger(): Logger {\n * return logger.force();\n * }\n * ```\n \n @example\n * ```ts\n * // Expensive computation\n * const fibonacci = Lazy(() => {\n * function fib(n: number): number {\n * if (n <= 1) return n;\n * return fib(n - 1) + fib(n - 2);\n * }\n * return fib(40); // Only computed once\n * });\n * ```\n /\nexport function Lazy<T>(fn: () => T): Lazy<T> {\n let value: T \| undefined;\n let initialized = false;\n\n return Object.freeze<Lazy<T>>({\n [Symbol.toStringTag]: 'Lazy',\n\n force(): T {\n if (!initialized) {\n value = fn();\n initialized = true;\n }\n return value as T;\n },\n\n get(): Option<T> {\n return initialized ? Some(value as T) : None;\n },\n\n isInitialized(): boolean {\n return initialized;\n },\n\n toString(): string {\n return initialized ? `Lazy(${ value })` : 'Lazy(<uninitialized>)';\n },\n } as const);\n}\n\n/\n Creates a new `LazyAsync<T>` with the given async initialization function.\n \n The function is called at most once, on first access via `force()`.\n * Concurrent calls to `force()` before initialization completes will\n * wait for the single initialization to finish.\n \n @typeParam T - The type of value to store.\n * @param fn - The async initialization function that produces the value.\n * @returns A new `LazyAsync<T>` instance.\n \n @example\n * ```ts\n * // Basic usage\n * const lazy = LazyAsync(async () => {\n * const response = await fetch('/api/data');\n * return await response.json();\n * });\n \n const data = await lazy.force();\n * ```\n \n @example\n * ```ts\n * // Database connection singleton\n * const db = LazyAsync(async () => {\n * console.log('Connecting to database...');\n * return await Database.connect(connectionString);\n * });\n \n async function getDb(): Promise<Database> {\n * return await db.force();\n * }\n \n // Multiple calls - connection happens only once\n * const [db1, db2] = await Promise.all([getDb(), getDb()]);\n * console.log(db1 === db2); // true\n * ```\n \n @example\n * ```ts\n * // Configuration loader\n * const config = LazyAsync(async () => {\n * const response = await fetch('/api/config');\n * if (!response.ok) {\n * throw new Error(`Failed to load config: ${response.status}`);\n * }\n * return await response.json() as Config;\n * });\n \n // Used throughout the app\n * async function getApiEndpoint(): Promise<string> {\n * const cfg = await config.force();\n * return cfg.apiEndpoint;\n * }\n * ```\n /\nexport function LazyAsync<T>(fn: () => Promise<T>): LazyAsync<T> {\n let value: T \| undefined;\n let initialized = false;\n let pendingPromise: Promise<T> \| undefined;\n\n return Object.freeze<LazyAsync<T>>({\n [Symbol.toStringTag]: 'LazyAsync',\n\n async force(): Promise<T> {\n if (initialized) {\n return value as T;\n }\n\n if (pendingPromise) {\n return pendingPromise;\n }\n\n pendingPromise = (async () => {\n try {\n const result = await fn();\n value = result;\n initialized = true;\n return result;\n } finally {\n pendingPromise = undefined;\n }\n })();\n\n return pendingPromise;\n },\n\n get(): Option<T> {\n return initialized ? Some(value as T) : None;\n },\n\n isInitialized(): boolean {\n return initialized;\n },\n\n toString(): string {\n return initialized ? `LazyAsync(${ value })` : 'LazyAsync(<uninitialized>)';\n },\n } as const);\n}\n","/\n @fileoverview\n * Rust-inspired [Mutex](https://doc.rust-lang.org/std/sync/struct.Mutex.html) for async mutual exclusion.\n \n In JavaScript's single-threaded environment, `Mutex<T>` is used to serialize\n * async operations, ensuring only one async task accesses the protected resource at a time.\n /\n\nimport { None, Some, type Option } from '../enum/mod.ts';\n\n/\n A guard that provides access to the mutex-protected value.\n \n The guard must be released after use by calling `unlock()`.\n * Failure to unlock will cause deadlock for subsequent lock attempts.\n \n @typeParam T - The type of the protected value.\n /\nexport interface MutexGuard<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'MutexGuard'` so that `Object.prototype.toString.call(guard)` produces `'[object MutexGuard]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'MutexGuard';\n\n /\n The protected value. Can be read or modified while the guard is held.\n /\n value: T;\n\n /\n Releases the lock, allowing other waiters to acquire it.\n \n Must be called when done with the protected value.\n * After calling `unlock()`, the guard should not be used.\n \n @example\n * ```ts\n * const guard = await mutex.lock();\n * try {\n * guard.value.push('item');\n * } finally {\n * guard.unlock();\n * }\n * ```\n /\n unlock(): void;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const guard = await mutex.lock();\n * console.log(guard.toString()); // 'MutexGuard(42)'\n * ```\n /\n toString(): string;\n}\n\n/\n An async mutual exclusion primitive for protecting shared data.\n \n This mutex provides exclusive access to the contained value, ensuring\n * that only one async operation can access it at a time. This is useful\n * for preventing race conditions in async code.\n \n Unlike Rust's Mutex which is for multi-threading, this JavaScript version\n * serializes async operations in the single-threaded event loop.\n \n @typeParam T - The type of the protected value.\n \n @example\n * ```ts\n * const mutex = Mutex({ balance: 100 });\n \n // Safe concurrent updates\n * await Promise.all([\n * mutex.withLock(async (account) => {\n * account.balance -= 50;\n * }),\n * mutex.withLock(async (account) => {\n * account.balance += 30;\n * }),\n * ]);\n * ```\n /\nexport interface Mutex<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'Mutex'` so that `Object.prototype.toString.call(mutex)` produces `'[object Mutex]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'Mutex';\n\n /\n Acquires the lock and executes the callback with the protected value.\n \n This is the recommended way to use the mutex as it automatically\n * releases the lock when the callback completes (or throws).\n \n @typeParam U - The return type of the callback.\n * @param fn - The callback that receives the protected value.\n * @returns A promise that resolves to the callback's return value.\n \n @example\n * ```ts\n * const mutex = Mutex<number[]>([]);\n \n await mutex.withLock(async (arr) => {\n * arr.push(await fetchItem());\n * });\n * ```\n /\n withLock<U>(fn: (value: T) => Promise<U> \| U): Promise<U>;\n\n /\n Acquires the lock and returns a guard for manual control.\n \n Use this when you need more control over when to release the lock.\n * Important: Always release the lock in a `finally` block to prevent deadlocks.\n \n @returns A promise that resolves to a guard providing access to the value.\n \n @example\n * ```ts\n * const guard = await mutex.lock();\n * try {\n * // Long-running operation with the protected value\n * await processData(guard.value);\n * guard.value = transformedData;\n * } finally {\n * guard.unlock();\n * }\n * ```\n /\n lock(): Promise<MutexGuard<T>>;\n\n /\n Attempts to acquire the lock without waiting.\n \n Returns immediately with `Some(guard)` if the lock is available,\n * or `None` if it's currently held by another operation.\n \n @returns `Some(guard)` if acquired, `None` if locked.\n \n @example\n * ```ts\n * const maybeGuard = mutex.tryLock();\n * if (maybeGuard.isSome()) {\n * const guard = maybeGuard.unwrap();\n * try {\n * // Use the value\n * } finally {\n * guard.unlock();\n * }\n * } else {\n * console.log('Mutex is busy');\n * }\n * ```\n /\n tryLock(): Option<MutexGuard<T>>;\n\n /\n Returns `true` if the mutex is currently locked.\n \n Note: This is a snapshot and may change immediately after the call.\n \n @example\n * ```ts\n * console.log(mutex.isLocked()); // false\n * const guard = await mutex.lock();\n * console.log(mutex.isLocked()); // true\n * guard.unlock();\n * console.log(mutex.isLocked()); // false\n * ```\n /\n isLocked(): boolean;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const mutex = Mutex(42);\n * console.log(mutex.toString()); // 'Mutex(<unlocked>)'\n \n const guard = await mutex.lock();\n * console.log(mutex.toString()); // 'Mutex(<locked>)'\n * ```\n /\n toString(): string;\n}\n\n/\n Creates a new `Mutex<T>` protecting the given value.\n \n @typeParam T - The type of the protected value.\n * @param value - The initial value to protect.\n * @returns A new `Mutex<T>` instance.\n \n @example\n * ```ts\n * // Protect a simple value\n * const counter = Mutex(0);\n \n // Protect an object\n * const state = Mutex({ users: [], lastUpdate: Date.now() });\n \n // Protect a resource\n * const db = Mutex(await createConnection());\n * ```\n \n @example\n * ```ts\n * // Database transaction safety\n * const connection = Mutex(db);\n \n async function transfer(from: string, to: string, amount: number) {\n * await connection.withLock(async (conn) => {\n * await conn.beginTransaction();\n * try {\n * const balance = await conn.query('SELECT balance FROM accounts WHERE id = ?', [from]);\n * if (balance < amount) {\n * throw new Error('Insufficient funds');\n * }\n * await conn.query('UPDATE accounts SET balance = balance - ? WHERE id = ?', [amount, from]);\n * await conn.query('UPDATE accounts SET balance = balance + ? WHERE id = ?', [amount, to]);\n * await conn.commit();\n * } catch (e) {\n * await conn.rollback();\n * throw e;\n * }\n * });\n * }\n * ```\n \n @example\n * ```ts\n * // Token refresh with mutex\n * const authState = Mutex({ token: '', expiresAt: 0 });\n \n async function getToken(): Promise<string> {\n * return await authState.withLock(async (state) => {\n * if (Date.now() > state.expiresAt) {\n * const response = await fetch('/api/refresh');\n * const data = await response.json();\n * state.token = data.token;\n * state.expiresAt = Date.now() + data.expiresIn * 1000;\n * }\n * return state.token;\n * });\n * }\n * ```\n \n @example\n * ```ts\n * // File write serialization\n * const fileLock = Mutex('/path/to/file.json');\n \n async function appendToFile(data: string) {\n * await fileLock.withLock(async (path) => {\n * const content = await fs.readFile(path, 'utf-8');\n * const json = JSON.parse(content);\n * json.entries.push(data);\n * await fs.writeFile(path, JSON.stringify(json, null, 2));\n * });\n * }\n * ```\n /\nexport function Mutex<T>(value: T): Mutex<T> {\n let currentValue = value;\n let locked = false;\n const waitQueue: (() => void)[] = [];\n\n function unlock(): void {\n if (waitQueue.length > 0) {\n // Wake up the next waiter\n const next = waitQueue.shift() as () => void;\n next();\n } else {\n locked = false;\n }\n }\n\n function createGuard(): MutexGuard<T> {\n let released = false;\n\n return Object.freeze<MutexGuard<T>>({\n [Symbol.toStringTag]: 'MutexGuard',\n\n get value(): T {\n if (released) {\n throw new Error('MutexGuard has been released.');\n }\n return currentValue;\n },\n set value(newValue: T) {\n if (released) {\n throw new Error('MutexGuard has been released.');\n }\n currentValue = newValue;\n },\n unlock(): void {\n if (released) {\n return; // Already released, ignore\n }\n released = true;\n unlock();\n },\n\n toString(): string {\n if (released) {\n return 'MutexGuard(<released>)';\n }\n return `MutexGuard(${ currentValue })`;\n },\n } as const);\n }\n\n function lock(): Promise<MutexGuard<T>> {\n if (!locked) {\n locked = true;\n return Promise.resolve(createGuard());\n }\n\n return new Promise<MutexGuard<T>>((resolve) => {\n waitQueue.push(() => {\n resolve(createGuard());\n });\n });\n }\n\n return Object.freeze<Mutex<T>>({\n [Symbol.toStringTag]: 'Mutex',\n\n async withLock<U>(fn: (value: T) => Promise<U> \| U): Promise<U> {\n const guard = await lock();\n try {\n return await fn(guard.value);\n } finally {\n guard.unlock();\n }\n },\n\n lock,\n\n tryLock(): Option<MutexGuard<T>> {\n if (locked) {\n return None;\n }\n locked = true;\n return Some(createGuard());\n },\n\n isLocked(): boolean {\n return locked;\n },\n\n toString(): string {\n return locked ? 'Mutex(<locked>)' : 'Mutex(<unlocked>)';\n },\n } as const);\n}\n","/\n @fileoverview\n * Rust-inspired [OnceLock](https://doc.rust-lang.org/std/sync/struct.OnceLock.html) for one-time initialization.\n \n `Once<T>` is a container which can be written to only once. It provides safe access\n * to lazily initialized data, supporting both sync and async initialization.\n /\n\nimport { Err, None, Ok, Some, type Option, type Result } from '../enum/mod.ts';\n\n/\n A container which can be written to only once.\n \n This is useful for lazy initialization of global data or expensive computations\n * that should only happen once. Supports both synchronous and asynchronous\n * initialization functions via separate methods.\n \n @typeParam T - The type of the value stored.\n \n @example\n * ```ts\n * const once = Once<number>();\n \n // Set value (only works once)\n * once.set(42); // Ok(undefined)\n * once.set(100); // Err(100) - already set\n \n // Get value\n * console.log(once.get()); // Some(42)\n * ```\n \n @example\n * ```ts\n * // Sync lazy initialization\n * const config = Once<Config>();\n * const cfg = config.getOrInit(() => loadConfigFromFile());\n * ```\n \n @example\n * ```ts\n * // Async lazy initialization\n * const db = Once<Database>();\n * const conn = await db.getOrInitAsync(async () => Database.connect(url));\n * ```\n /\nexport interface Once<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'Once'` so that `Object.prototype.toString.call(once)` produces `'[object Once]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'Once';\n\n /\n Gets the reference to the underlying value.\n \n @returns `Some(value)` if initialized, `None` otherwise.\n \n @example\n * ```ts\n * const once = Once<number>();\n * console.log(once.get()); // None\n \n once.set(42);\n * console.log(once.get()); // Some(42)\n * ```\n /\n get(): Option<T>;\n\n /\n Sets the contents to `value`.\n \n @param value - The value to store.\n * @returns `Ok(undefined)` if empty, `Err(value)` if already initialized.\n \n @example\n * ```ts\n * const once = Once<number>();\n \n console.log(once.set(42)); // Ok(undefined)\n * console.log(once.set(100)); // Err(100) - value returned back\n * console.log(once.get()); // Some(42)\n * ```\n /\n set(value: T): Result<void, T>;\n\n /\n Gets the contents, initializing it with `fn` if empty.\n \n @param fn - The synchronous initialization function, called only if empty.\n * @returns The stored value.\n \n @example\n * ```ts\n * const once = Once<number>();\n \n const value = once.getOrInit(() => {\n * console.log('Initializing...');\n * return 42;\n * });\n * console.log(value); // 42\n \n // Second call - fn is not called\n * const value2 = once.getOrInit(() => 100);\n * console.log(value2); // 42\n * ```\n /\n getOrInit(fn: () => T): T;\n\n /\n Gets the contents, initializing it with async `fn` if empty.\n \n If multiple calls occur concurrently, only the first one will run the\n * initialization function. Other calls will wait for it to complete.\n \n @param fn - The async initialization function.\n * @returns A promise that resolves to the stored value.\n \n @example\n * ```ts\n * const db = Once<Database>();\n \n // Multiple concurrent calls - only one connection happens\n * const [db1, db2, db3] = await Promise.all([\n * db.getOrInitAsync(() => Database.connect(url)),\n * db.getOrInitAsync(() => Database.connect(url)),\n * db.getOrInitAsync(() => Database.connect(url)),\n * ]);\n * // db1 === db2 === db3\n * ```\n /\n getOrInitAsync(fn: () => Promise<T>): Promise<T>;\n\n /\n Gets the contents, initializing it with `fn` if empty.\n * If `fn` returns `Err`, remains uninitialized.\n \n @typeParam E - The error type.\n * @param fn - The initialization function that may fail.\n * @returns `Ok(value)` if initialized, `Err(error)` if initialization failed.\n \n @example\n * ```ts\n * const once = Once<Config>();\n \n const result = once.getOrTryInit(() => {\n * const config = parseConfig(rawData);\n * return config ? Ok(config) : Err(new Error('Invalid config'));\n * });\n \n if (result.isOk()) {\n * console.log('Config loaded:', result.unwrap());\n * }\n * ```\n /\n getOrTryInit<E>(fn: () => Result<T, E>): Result<T, E>;\n\n /\n Gets the contents, initializing it with async `fn` if empty.\n * If `fn` returns `Err`, remains uninitialized.\n \n If multiple calls occur concurrently, only the first one will run the\n * initialization function. Other calls will wait for it to complete.\n \n @typeParam E - The error type.\n * @param fn - The async initialization function that may fail.\n * @returns A promise that resolves to `Ok(value)` or `Err(error)`.\n \n @example\n * ```ts\n * const config = Once<Config>();\n \n const result = await config.getOrTryInitAsync(async () => {\n * try {\n * const response = await fetch('/api/config');\n * return Ok(await response.json());\n * } catch (e) {\n * return Err(e as Error);\n * }\n * });\n * ```\n /\n getOrTryInitAsync<E>(fn: () => Promise<Result<T, E>>): Promise<Result<T, E>>;\n\n /\n Takes the value out, leaving it uninitialized.\n \n @returns `Some(value)` if initialized, `None` otherwise.\n \n @example\n * ```ts\n * const once = Once<number>();\n * once.set(42);\n \n console.log(once.take()); // Some(42)\n * console.log(once.get()); // None - now empty\n * console.log(once.take()); // None\n * ```\n /\n take(): Option<T>;\n\n /\n Returns `true` if initialized.\n \n @example\n * ```ts\n * const once = Once<number>();\n * console.log(once.isInitialized()); // false\n \n once.set(42);\n * console.log(once.isInitialized()); // true\n * ```\n /\n isInitialized(): boolean;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const once = Once<number>();\n * console.log(once.toString()); // 'Once(<uninitialized>)'\n \n once.set(42);\n * console.log(once.toString()); // 'Once(42)'\n * ```\n /\n toString(): string;\n}\n\n/\n Creates a new empty `Once<T>`.\n \n @typeParam T - The type of value to store.\n * @returns A new uninitialized `Once`.\n \n @example\n * ```ts\n * // Basic usage\n * const once = Once<string>();\n * once.set('hello');\n * console.log(once.get().unwrap()); // 'hello'\n * ```\n \n @example\n * ```ts\n * // Sync lazy singleton pattern\n * const logger = Once<Logger>();\n \n function getLogger(): Logger {\n * return logger.getOrInit(() => new Logger('app'));\n * }\n * ```\n \n @example\n * ```ts\n * // Async lazy initialization\n * const db = Once<Database>();\n \n async function getDb(): Promise<Database> {\n * return await db.getOrInitAsync(async () => {\n * console.log('Connecting to database...');\n * return await Database.connect(connectionString);\n * });\n * }\n \n // Multiple calls - connection happens only once\n * const [db1, db2] = await Promise.all([getDb(), getDb()]);\n * console.log(db1 === db2); // true\n * ```\n \n @example\n * ```ts\n * // Fallible async initialization\n * const config = Once<Config>();\n \n async function loadConfig(): Promise<Result<Config, Error>> {\n * return await config.getOrTryInitAsync(async () => {\n * try {\n * const response = await fetch('/api/config');\n * if (!response.ok) {\n * return Err(new Error(`HTTP ${response.status}`));\n * }\n * return Ok(await response.json());\n * } catch (e) {\n * return Err(e as Error);\n * }\n * });\n * }\n * ```\n */\nexport function Once<T>(): Once<T> {\n let value: T \| undefined;\n let initialized = false;\n let pendingPromise: Promise<T> \| undefined;\n\n return Object.freeze<Once<T>>({\n [Symbol.toStringTag]: 'Once',\n\n get(): Option<T> {\n return initialized ? Some(value as T) : None;\n },\n\n set(newValue: T): Result<void, T> {\n if (initialized) {\n return Err(newValue);\n }\n value = newValue;\n initialized = true;\n return Ok(undefined);\n },\n\n getOrInit(fn: () => T): T {\n if (!initialized) {\n value = fn();\n initialized = true;\n }\n return value as T;\n },\n\n async getOrInitAsync(fn: () => Promise<T>): Promise<T> {\n if (initialized) {\n return value as T;\n }\n\n // If already initializing, wait for the pending promise\n if (pendingPromise) {\n return pendingPromise;\n }\n\n pendingPromise = (async () => {\n try {\n const result = await fn();\n value = result;\n initialized = true;\n return result;\n } finally {\n pendingPromise = undefined;\n }\n })();\n\n return pendingPromise;\n },\n\n getOrTryInit<E>(fn: () => Result<T, E>): Result<T, E> {\n if (initialized) {\n return Ok(value as T);\n }\n\n const result = fn();\n if (result.isOk()) {\n value = result.unwrap();\n initialized = true;\n }\n return result;\n },\n\n async getOrTryInitAsync<E>(fn: () => Promise<Result<T, E>>): Promise<Result<T, E>> {\n if (initialized) {\n return Ok(value as T);\n }\n\n // If already initializing, wait for it\n if (pendingPromise) {\n try {\n await pendingPromise;\n // pendingPromise only resolves on success, so initialized must be true\n return Ok(value as T);\n } catch {\n // Previous initialization failed via Err result, let this call try again\n }\n }\n\n // Create a new pending promise for this initialization attempt\n pendingPromise = (async () => {\n const result = await fn();\n if (result.isOk()) {\n value = result.unwrap();\n initialized = true;\n return value;\n }\n // If Err, throw to signal failure (we'll catch and return the result)\n throw result;\n })();\n\n try {\n const resultValue = await pendingPromise;\n return Ok(resultValue as T);\n } catch (errResult) {\n return errResult as Result<T, E>;\n } finally {\n pendingPromise = undefined;\n }\n },\n\n take(): Option<T> {\n if (!initialized) {\n return None;\n }\n const taken = value as T;\n value = undefined;\n initialized = false;\n return Some(taken);\n },\n\n isInitialized(): boolean {\n return initialized;\n },\n\n toString(): string {\n return initialized ? `Once(${ value })` : 'Once(<uninitialized>)';\n },\n } as const);\n}\n"],"names":[],"mappings":"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"}
1	+ {"version":3,"file":"main.cjs","sources":["../src/enum/symbols.ts","../src/enum/utils.ts","../src/enum/prelude.ts","../src/enum/constants.ts","../src/enum/extensions.ts","../src/ops/symbols.ts","../src/ops/control_flow.ts","../src/ops/utils.ts","../src/sync/lazy.ts","../src/sync/mutex.ts","../src/sync/once.ts"],"sourcesContent":["/*\n @fileoverview\n * Internal symbols used to identify `Option` and `Result` type variants.\n \n These symbols are used as property keys to distinguish between `Some`/`None` and `Ok`/`Err` variants.\n * They provide a reliable way to identify the variant of an `Option` or `Result` instance without\n * relying on method calls or duck typing.\n \n Note: These symbols are internal implementation details and are not exported as part of the public API.\n * Use the `isOption` and `isResult` utility functions for type checking instead.\n /\n\n/\n A unique symbol used as a property key to identify the variant of an `Option` instance.\n \n When accessed on an `Option`, returns `'Some'` if the Option contains a value,\n * or `'None'` if it represents the absence of a value.\n \n This symbol is used internally by the `isOption` utility function to verify\n * that an object is a valid `Option` instance.\n \n @internal\n /\nexport const OptionKindSymbol = Symbol('Option kind');\n\n/\n A unique symbol used as a property key to identify the variant of a `Result` instance.\n \n When accessed on a `Result`, returns `'Ok'` if the Result represents success,\n * or `'Err'` if it represents failure.\n \n This symbol is used internally by the `isResult` utility function to verify\n * that an object is a valid `Result` instance.\n \n @internal\n /\nexport const ResultKindSymbol = Symbol('Result kind');\n","/\n @fileoverview\n * Type guard utilities for checking if values are `Option` or `Result` types.\n \n These functions provide runtime type checking capabilities for the Option and Result types.\n /\nimport type { Option, Result } from './core.ts';\nimport { OptionKindSymbol, ResultKindSymbol } from './symbols.ts';\n\n/\n Checks if a value is an `Option`.\n \n @typeParam T - The expected type of the value contained within the `Option`.\n * @param o - The value to be checked as an `Option`.\n * @returns `true` if the value is an `Option`, otherwise `false`.\n * @example\n * ```ts\n * const x = Some(5);\n * console.log(isOption(x)); // true\n * console.log(isOption(null)); // false\n * console.log(isOption({ value: 5 })); // false\n * ```\n /\nexport function isOption<T>(o: unknown): o is Option<T> {\n // `Some` and `None` must be an object.\n return o != null && typeof o === 'object' && OptionKindSymbol in o;\n}\n\n/\n Checks if a value is a `Result`.\n \n @typeParam T - The expected type of the success value contained within the `Result`.\n * @typeParam E - The expected type of the error value contained within the `Result`.\n * @param r - The value to be checked as a `Result`.\n * @returns `true` if the value is a `Result`, otherwise `false`.\n * @example\n * ```ts\n * const x = Ok(5);\n * console.log(isResult(x)); // true\n * console.log(isResult(null)); // false\n * console.log(isResult({ value: 5 })); // false\n * ```\n /\nexport function isResult<T, E>(r: unknown): r is Result<T, E> {\n // `Ok` and `Err` must be an object.\n return r != null && typeof r === 'object' && ResultKindSymbol in r;\n}","/\n @fileoverview\n * Constructors and factory functions for creating `Option` and `Result` types.\n \n This module exports:\n * - `Some<T>(value)` - Creates an Option containing a value\n * - `None` - Constant representing absence of value\n * - `Ok<T, E>(value)` - Creates a successful Result\n * - `Err<T, E>(error)` - Creates a failed Result\n * - `None` interface - Type overrides for better type inference\n /\nimport type { AsyncOption, AsyncResult, Option, Result } from './core.ts';\nimport { OptionKindSymbol, ResultKindSymbol } from './symbols.ts';\nimport { isOption, isResult } from './utils.ts';\n\n/\n Represents the absence of a value, as a specialized `Option` type.\n * The type parameter is set to `never` because `None` does not hold a value.\n /\nexport interface None extends Option<never> {\n /\n When using `None` alone, the following overrides can make type inference more accurate.\n /\n\n readonly [OptionKindSymbol]: 'None';\n\n isSome(): false;\n isNone(): true;\n isSomeAnd(predicate: (value: never) => boolean): false;\n isSomeAndAsync(predicate: (value: never) => Promise<boolean>): Promise<false>;\n isNoneOr(predicate: (value: never) => boolean): true;\n isNoneOrAsync(predicate: (value: never) => Promise<boolean>): Promise<true>;\n\n expect(msg: string): never;\n unwrap(): never;\n unwrapOr<T>(defaultValue: T): T;\n unwrapOrElse<T>(fn: () => T): T;\n unwrapOrElseAsync<T>(fn: () => Promise<T>): Promise<T>;\n\n okOr<E>(error: E): Result<never, E>;\n okOrElse<E>(err: () => E): Result<never, E>;\n transpose(): Result<this, never>;\n\n filter(predicate: (value: never) => boolean): this;\n flatten(): this;\n map<U>(fn: (value: never) => U): this;\n mapOr<U>(defaultValue: U, fn: (value: never) => U): U;\n mapOrElse<U>(defaultFn: () => U, fn: (value: never) => U): U;\n\n zip<U>(other: Option<U>): this;\n zipWith<U, R>(other: Option<U>, fn: (value: never, otherValue: U) => R): this;\n unzip(): [this, this];\n\n and<U>(other: Option<U>): this;\n andThen<U>(fn: (value: never) => Option<U>): this;\n andThenAsync<U>(fn: (value: never) => AsyncOption<U>): Promise<this>;\n or<T>(other: Option<T>): Option<T>;\n orElse<T>(fn: () => Option<T>): Option<T>;\n orElseAsync<T>(fn: () => AsyncOption<T>): AsyncOption<T>;\n xor<T>(other: Option<T>): Option<T>;\n\n inspect(fn: (value: never) => void): this;\n\n eq<T>(other: Option<T>): boolean;\n}\n\n/\n Creates an `Option<T>` representing the presence of a value.\n * This function is typically used to construct an `Option` that contains a value, indicating that the operation yielding the value was successful.\n \n @typeParam T - The type of the value to be wrapped in a `Some`.\n * @param value - The value to wrap as a `Some` option.\n * @returns An `Option<T>` that contains the provided value, representing the `Some` case.\n \n @example\n * ```ts\n * const maybeValue = Some(1); // Option<number> with a value\n * if (maybeValue.isSome()) {\n * console.log(maybeValue.unwrap()); // Outputs: 1\n * }\n * ```\n /\nexport function Some<T>(value: T): Option<T> {\n const some: Option<T> = Object.freeze<Option<T>>({\n [Symbol.toStringTag]: 'Option',\n [OptionKindSymbol]: 'Some',\n\n isSome(): true {\n return true;\n },\n isNone(): false {\n return false;\n },\n isSomeAnd(predicate: (value: T) => boolean): boolean {\n return predicate(value);\n },\n isSomeAndAsync(predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n return predicate(value);\n },\n isNoneOr(predicate: (value: T) => boolean): boolean {\n return predicate(value);\n },\n isNoneOrAsync(predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n return predicate(value);\n },\n\n expect(_msg: string): T {\n return value;\n },\n unwrap(): T {\n return value;\n },\n unwrapOr(_defaultValue: T): T {\n return value;\n },\n unwrapOrElse(_fn: () => T): T {\n return value;\n },\n unwrapOrElseAsync(_fn: () => Promise<T>): Promise<T> {\n return Promise.resolve(value);\n },\n\n okOr<E>(_error: E): Result<T, E> {\n return Ok(value);\n },\n okOrElse<E>(_err: () => E): Result<T, E> {\n return Ok(value);\n },\n transpose<U, E>(): Result<Option<U>, E> {\n assertResult<U, E>(value);\n return value.isOk() ? Ok(Some(value.unwrap())) : Err(value.unwrapErr());\n },\n\n filter(predicate: (value: T) => boolean): Option<T> {\n return predicate(value) ? some : None;\n },\n flatten<U>(): Option<U> {\n assertOption<U>(value);\n return value;\n },\n map<U>(fn: (value: T) => U): Option<U> {\n return Some(fn(value));\n },\n\n mapOr<U>(_defaultValue: U, fn: (value: T) => U): U {\n return fn(value);\n },\n mapOrElse<U>(_defaultFn: () => U, fn: (value: T) => U): U {\n return fn(value);\n },\n\n zip<U>(other: Option<U>): Option<[T, U]> {\n assertOption<U>(other);\n return other.isSome() ? Some([value, other.unwrap()]) : None;\n },\n zipWith<U, R>(other: Option<U>, fn: (value: T, otherValue: U) => R): Option<R> {\n assertOption<U>(other);\n return other.isSome() ? Some(fn(value, other.unwrap())) : None;\n },\n unzip<U, R>(): [Option<U>, Option<R>] {\n const tuple = value as [U, R];\n\n if (!Array.isArray(tuple) \|\| tuple.length !== 2) {\n throw new TypeError(`Option::unzip() requires a 2-element tuple, received ${ Array.isArray(tuple) ? `array with ${ tuple.length } elements` : typeof tuple }.`);\n }\n\n const [a, b] = tuple;\n return [Some(a), Some(b)];\n },\n\n and<U>(other: Option<U>): Option<U> {\n assertOption<U>(other);\n return other;\n },\n andThen<U>(fn: (value: T) => Option<U>): Option<U> {\n return fn(value);\n },\n andThenAsync<U>(fn: (value: T) => AsyncOption<U>): AsyncOption<U> {\n return fn(value);\n },\n or(_other: Option<T>): Option<T> {\n return some;\n },\n orElse(_fn: () => Option<T>): Option<T> {\n return some;\n },\n orElseAsync(_fn: () => AsyncOption<T>): AsyncOption<T> {\n return Promise.resolve(some);\n },\n xor(other: Option<T>): Option<T> {\n assertOption<T>(other);\n return other.isSome() ? None : some;\n },\n\n inspect(fn: (value: T) => void): Option<T> {\n fn(value);\n return some;\n },\n\n eq(other: Option<T>): boolean {\n assertOption<T>(other);\n return other.isSome() && other.unwrap() === value;\n },\n\n toString(): string {\n return `Some(${ value })`;\n },\n } as const);\n\n return some;\n}\n\n/\n A constant representing the `None` case of an `Option`, indicating the absence of a value.\n * This constant is frozen to ensure it is immutable and cannot be altered, preserving the integrity of `None` throughout the application.\n \n @example\n * ```ts\n * // Use None to represent absence of a value\n * function findUser(id: number): Option<User> {\n * const user = users.find(u => u.id === id);\n * return user ? Some(user) : None;\n * }\n \n // None is a singleton, so you can compare by reference\n * const result = findUser(999);\n * if (result === None) {\n * console.log('User not found');\n * }\n \n // Use with Option methods\n * const name = None.unwrapOr('Anonymous'); // 'Anonymous'\n * ```\n /\nexport const None: None = Object.freeze<None>({\n [Symbol.toStringTag]: 'Option',\n [OptionKindSymbol]: 'None',\n\n isSome(): false {\n return false;\n },\n isNone(): true {\n return true;\n },\n isSomeAnd(_predicate: (value: never) => boolean): false {\n return false;\n },\n isSomeAndAsync(_predicate: (value: never) => Promise<boolean>): Promise<false> {\n return Promise.resolve(false);\n },\n isNoneOr(_predicate: (value: never) => boolean): true {\n return true;\n },\n isNoneOrAsync(_predicate: (value: never) => Promise<boolean>): Promise<true> {\n return Promise.resolve(true);\n },\n\n expect(msg: string): never {\n throw new TypeError(msg);\n },\n unwrap(): never {\n throw new TypeError('Option::unwrap() called on a `None` value.');\n },\n unwrapOr<T>(defaultValue: T): T {\n return defaultValue;\n },\n unwrapOrElse<T>(fn: () => T): T {\n return fn();\n },\n unwrapOrElseAsync<T>(fn: () => Promise<T>): Promise<T> {\n return fn();\n },\n\n okOr<E>(error: E): Result<never, E> {\n return Err(error);\n },\n okOrElse<E>(err: () => E): Result<never, E> {\n return Err(err());\n },\n transpose(): Result<None, never> {\n return Ok(None);\n },\n\n filter(_predicate: (value: never) => boolean): None {\n return None;\n },\n flatten(): None {\n return None;\n },\n map<U>(_fn: (value: never) => U): None {\n return None;\n },\n\n mapOr<U>(defaultValue: U, _fn: (value: never) => U): U {\n return defaultValue;\n },\n mapOrElse<U>(defaultFn: () => U, _fn: (value: never) => U): U {\n return defaultFn();\n },\n\n zip<U>(_other: Option<U>): None {\n return None;\n },\n zipWith<U, R>(_other: Option<U>, _fn: (value: never, otherValue: U) => R): None {\n return None;\n },\n unzip(): [None, None] {\n return [None, None];\n },\n\n and<U>(_other: Option<U>): None {\n return None;\n },\n andThen<U>(_fn: (value: never) => Option<U>): None {\n return None;\n },\n andThenAsync<U>(_fn: (value: never) => AsyncOption<U>): Promise<None> {\n return Promise.resolve(None);\n },\n or<T>(other: Option<T>): Option<T> {\n assertOption<T>(other);\n return other;\n },\n orElse<T>(fn: () => Option<T>): Option<T> {\n return fn();\n },\n orElseAsync<T>(fn: () => AsyncOption<T>): AsyncOption<T> {\n return fn();\n },\n xor<T>(other: Option<T>): Option<T> {\n assertOption<T>(other);\n return other.isSome() ? other : None;\n },\n\n inspect(_fn: (value: never) => void): None {\n return None;\n },\n\n eq<T>(other: Option<T>): boolean {\n assertOption<T>(other);\n return other === None;\n },\n\n toString(): string {\n return 'None';\n },\n} as const);\n\n/\n Creates a `Result<T, E>` representing a successful outcome containing a value.\n * This function is used to construct a `Result` that signifies the operation was successful by containing the value `T`.\n \n @typeParam T - The type of the value to be contained in the `Ok` result.\n * @typeParam E - The type of the error that the result could potentially contain (not used in this case).\n * @param value - The value to wrap as an `Ok` result.\n * @returns A `Result<T, E>` that contains the provided value, representing the `Ok` case.\n \n @example\n * ```ts\n * const goodResult = Ok<number, Error>(1); // Result<number, Error> with a value\n * if (goodResult.isOk()) {\n * console.log(goodResult.unwrap()); // Outputs: 1\n * }\n * ```\n /\nexport function Ok<T, E = never>(value: T): Result<T, E>;\n/\n Creates a `Result<void, E>` representing a successful outcome with no value.\n * This overload is used when the operation succeeds but doesn't produce a meaningful value.\n \n In Rust, this would be `Ok(())` using the unit type `()`.\n * Since JavaScript doesn't have a unit type, we use `void` instead.\n \n @typeParam E - The type of the error that the result could potentially contain.\n * @returns A `Result<void, E>` representing a successful operation with no value.\n \n @example\n * ```ts\n * function saveToFile(path: string): Result<void, Error> {\n * try {\n * fs.writeFileSync(path, data);\n * return Ok(); // Success with no return value\n * } catch (e) {\n * return Err(e as Error);\n * }\n * }\n \n const result = saveToFile('/tmp/data.txt');\n * if (result.isOk()) {\n * console.log('File saved successfully');\n * }\n * ```\n /\nexport function Ok<E = never>(): Result<void, E>;\nexport function Ok<T, E>(value?: T): Result<T, E> {\n const ok: Result<T, E> = Object.freeze<Result<T, E>>({\n [Symbol.toStringTag]: 'Result',\n [ResultKindSymbol]: 'Ok',\n\n isOk(): true {\n return true;\n },\n isErr(): false {\n return false;\n },\n isOkAnd(predicate: (value: T) => boolean): boolean {\n return predicate(value as T);\n },\n isOkAndAsync(predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n return predicate(value as T);\n },\n isErrAnd(_predicate: (error: E) => boolean): false {\n return false;\n },\n isErrAndAsync(_predicate: (error: E) => Promise<boolean>): Promise<false> {\n return Promise.resolve(false);\n },\n\n expect(_msg: string): T {\n return value as T;\n },\n unwrap(): T {\n return value as T;\n },\n unwrapOr(_defaultValue: T): T {\n return value as T;\n },\n unwrapOrElse(_fn: (error: E) => T): T {\n return value as T;\n },\n unwrapOrElseAsync(_fn: (error: E) => Promise<T>): Promise<T> {\n return Promise.resolve(value as T);\n },\n\n expectErr(msg: string): never {\n throw new TypeError(`${ msg }: ${ value }`);\n },\n unwrapErr(): never {\n throw new TypeError('Result::unwrapErr() called on an `Ok` value.');\n },\n\n ok(): Option<T> {\n return Some(value as T);\n },\n err(): None {\n return None;\n },\n transpose<U>(): Option<Result<U, E>> {\n assertOption<U>(value);\n return value.isSome() ? Some(Ok(value.unwrap())) : None;\n },\n\n map<U>(fn: (value: T) => U): Result<U, E> {\n return Ok(fn(value as T));\n },\n mapErr<F>(_fn: (error: E) => F): Result<T, F> {\n return Ok(value as T);\n },\n mapOr<U>(_defaultValue: U, fn: (value: T) => U): U {\n return fn(value as T);\n },\n mapOrElse<U>(_defaultFn: (error: E) => U, fn: (value: T) => U): U {\n return fn(value as T);\n },\n flatten<U>(): Result<U, E> {\n assertResult<U, E>(value);\n return value;\n },\n\n and<U>(other: Result<U, E>): Result<U, E> {\n assertResult<T, E>(other);\n return other;\n },\n or<F>(_other: Result<T, F>): Result<T, F> {\n return ok as unknown as Result<T, F>;\n },\n andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E> {\n return fn(value as T);\n },\n andThenAsync<U>(fn: (value: T) => AsyncResult<U, E>): AsyncResult<U, E> {\n return fn(value as T);\n },\n orElse<F>(_fn: (error: E) => Result<T, F>): Result<T, F> {\n return ok as unknown as Result<T, F>;\n },\n orElseAsync<F>(_fn: (error: E) => AsyncResult<T, F>): AsyncResult<T, F> {\n return Promise.resolve(ok as unknown as Result<T, F>);\n },\n\n inspect(fn: (value: T) => void): Result<T, E> {\n fn(value as T);\n return ok;\n },\n inspectErr(_fn: (error: E) => void): Result<T, E> {\n return ok;\n },\n\n eq(other: Result<T, E>): boolean {\n assertResult<T, E>(other);\n return other.isOk() && other.unwrap() === value;\n },\n\n asOk<F>(): Result<T, F> {\n return ok as unknown as Result<T, F>;\n },\n asErr(): never {\n throw new TypeError('Result::asErr() called on an `Ok` value.');\n },\n\n toString(): string {\n return `Ok(${ value })`;\n },\n } as const);\n\n return ok;\n}\n\n/\n Creates a `Result<T, E>` representing a failed outcome containing an error.\n * This function is used to construct a `Result` that signifies the operation failed by containing the error `E`.\n \n @typeParam T - The type of the value that the result could potentially contain (not used in this case).\n * @typeParam E - The type of the error to be wrapped in the `Err` result.\n * @param error - The error to wrap as an `Err` result.\n * @returns A `Result<T, E>` that contains the provided error, representing the `Err` case.\n \n @example\n * ```ts\n * const badResult = Err<number, Error>(new Error('Something went wrong'));\n * if (badResult.isErr()) {\n * console.error(badResult.unwrapErr()); // Outputs: Error: Something went wrong\n * }\n * ```\n /\nexport function Err<T = never, E = unknown>(error: E): Result<T, E> {\n const err: Result<T, E> = Object.freeze<Result<T, E>>({\n [Symbol.toStringTag]: 'Result',\n [ResultKindSymbol]: 'Err',\n\n isOk(): false {\n return false;\n },\n isErr(): true {\n return true;\n },\n isOkAnd(_predicate: (value: T) => boolean): false {\n return false;\n },\n isOkAndAsync(_predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n return Promise.resolve(false);\n },\n isErrAnd(predicate: (error: E) => boolean): boolean {\n return predicate(error);\n },\n isErrAndAsync(predicate: (error: E) => Promise<boolean>): Promise<boolean> {\n return predicate(error);\n },\n\n expect(msg: string): never {\n throw new TypeError(`${ msg }: ${ error }`);\n },\n unwrap(): never {\n throw new TypeError('Result::unwrap() called on an `Err` value.');\n },\n unwrapOr(defaultValue: T): T {\n return defaultValue;\n },\n unwrapOrElse(fn: (error: E) => T): T {\n return fn(error);\n },\n unwrapOrElseAsync(fn: (error: E) => Promise<T>): Promise<T> {\n return fn(error);\n },\n\n expectErr(_msg: string): E {\n return error;\n },\n unwrapErr(): E {\n return error;\n },\n\n ok(): None {\n return None;\n },\n err(): Option<E> {\n return Some(error);\n },\n transpose<U>(): Option<Result<U, E>> {\n return Some(err as unknown as Result<U, E>);\n },\n\n map<U>(_fn: (value: T) => U): Result<U, E> {\n return Err(error);\n },\n mapErr<F>(fn: (error: E) => F): Result<T, F> {\n return Err(fn(error));\n },\n mapOr<U>(defaultValue: U, _fn: (value: T) => U): U {\n return defaultValue;\n },\n mapOrElse<U>(defaultFn: (error: E) => U, _fn: (value: T) => U): U {\n return defaultFn(error);\n },\n flatten<U>(): Result<U, E> {\n return err as unknown as Result<U, E>;\n },\n\n and<U>(_other: Result<U, E>): Result<U, E> {\n return err as unknown as Result<U, E>;\n },\n or<F>(other: Result<T, F>): Result<T, F> {\n assertResult<T, E>(other);\n return other;\n },\n andThen<U>(_fn: (value: T) => Result<U, E>): Result<U, E> {\n return err as unknown as Result<U, E>;\n },\n andThenAsync<U>(_fn: (value: T) => AsyncResult<U, E>): AsyncResult<U, E> {\n return Promise.resolve(err as unknown as Result<U, E>);\n },\n orElse<F>(fn: (error: E) => Result<T, F>): Result<T, F> {\n return fn(error);\n },\n orElseAsync<F>(fn: (error: E) => AsyncResult<T, F>): AsyncResult<T, F> {\n return fn(error);\n },\n\n inspect(_fn: (value: T) => void): Result<T, E> {\n return err;\n },\n inspectErr(fn: (error: E) => void): Result<T, E> {\n fn(error);\n return err;\n },\n\n eq(other: Result<T, E>): boolean {\n assertResult<T, E>(other);\n return other.isErr() && other.unwrapErr() === error;\n },\n\n asOk(): never {\n throw new TypeError('Result::asOk() called on an `Err` value.');\n },\n asErr<U>(): Result<U, E> {\n return err as unknown as Result<U, E>;\n },\n\n toString(): string {\n return `Err(${ error })`;\n },\n } as const);\n\n return err;\n}\n\n/\n Safely converts a value to a string representation for error messages.\n * Handles cases where `toString()` might throw or values are null/undefined.\n \n @param value - The value to stringify.\n * @returns A safe string representation of the value.\n /\nfunction safeStringify(value: unknown): string {\n try {\n if (value === null) {\n return 'null';\n }\n if (value === undefined) {\n return 'undefined';\n }\n if (typeof value === 'object') {\n return Object.prototype.toString.call(value);\n }\n return String(value);\n } catch {\n return '[unable to stringify]';\n }\n}\n\n/\n Asserts that a given value is an `Option`.\n \n @typeParam T - The expected type of the value contained within the `Option`.\n * @param o - The value to be checked as an `Option`.\n * @throws {TypeError} If the value is not an `Option`.\n * @see isOption\n /\nfunction assertOption<T>(o: unknown): asserts o is Option<T> {\n if (!isOption(o)) {\n throw new TypeError(`Expected an Option, but received: ${ safeStringify(o) }.`);\n }\n}\n\n/\n Asserts that a given value is a `Result`.\n \n @typeParam T - The expected type of the success value contained within the `Result`.\n * @typeParam E - The expected type of the error value contained within the `Result`.\n * @param r - The value to be checked as a `Result`.\n * @throws {TypeError} If the value is not a `Result`.\n * @see isResult\n /\nfunction assertResult<T, E>(r: unknown): asserts r is Result<T, E> {\n if (!isResult(r)) {\n throw new TypeError(`Expected a Result, but received: ${ safeStringify(r) }.`);\n }\n}","/\n @fileoverview\n * Pre-defined Result constants for common return values.\n \n These immutable constants can be reused throughout the application to avoid\n * creating new Result instances for common values like `true`, `false`, `0`, and `void`.\n /\n/ eslint-disable @typescript-eslint/no-explicit-any /\nimport type { Result } from './core.ts';\nimport { Ok } from './prelude.ts';\n\n/\n Result constant for `true`.\n * Can be used anywhere due to immutability.\n * @example\n * ```ts\n * function validate(): Result<boolean, Error> {\n * return RESULT_TRUE;\n * }\n * ```\n /\nexport const RESULT_TRUE: Result<boolean, any> = Ok(true);\n\n/\n Result constant for `false`.\n * Can be used anywhere due to immutability.\n * @example\n * ```ts\n * function validate(): Result<boolean, Error> {\n * return RESULT_FALSE;\n * }\n * ```\n /\nexport const RESULT_FALSE: Result<boolean, any> = Ok(false);\n\n/\n Result constant for `0`.\n * Can be used anywhere due to immutability.\n * @example\n * ```ts\n * function count(): Result<number, Error> {\n * return RESULT_ZERO;\n * }\n * ```\n /\nexport const RESULT_ZERO: Result<number, any> = Ok(0);\n\n/\n Result constant for `void` or `()`.\n * Can be used anywhere due to immutability.\n * @example\n * ```ts\n * function doSomething(): Result<void, Error> {\n * return RESULT_VOID;\n * }\n * ```\n /\nexport const RESULT_VOID: Result<void, any> = Ok();","/\n @fileoverview\n * Extension functions for bridging Promise-based APIs with the Result type.\n \n This module provides utilities for integrating async/await patterns with Result-based error handling.\n /\nimport type { AsyncResult } from './core.ts';\nimport { Err, Ok } from './prelude.ts';\n\n/\n Converts a Promise to a Result type, capturing the resolved value in an `Ok`, or the error in an `Err`.\n * This allows for promise-based asynchronous operations to be handled in a way that is more in line with the Result pattern.\n \n Note: JavaScript promises can reject with any value, not just `Error` objects.\n * The error is cast to type `E`, so ensure your error handling accounts for this.\n \n @typeParam T - The type of the value that the promise resolves to.\n * @typeParam E - The type of the error that the promise may reject with, defaults to `Error`.\n * @param p - The promise or promise-like object to convert into a `Result` type.\n * @returns 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>`.\n \n @example\n * ```ts\n * async function example() {\n * const result = await promiseToAsyncResult(fetchData());\n * result.inspect(x => {\n * console.log('Data:', x);\n * }).inspectErr(err => {\n * console.error('Error:', err);\n * });\n * }\n * ```\n \n @example\n * ```ts\n * // With custom error type\n * const result = await promiseToAsyncResult<User, ApiError>(fetchUser(id));\n * ```\n /\nexport async function promiseToAsyncResult<T, E = Error>(p: PromiseLike<T>): AsyncResult<T, E> {\n try {\n return Ok(await p);\n } catch (err) {\n return Err(err as E);\n }\n}","/\n @fileoverview\n * Internal symbols used to identify `ControlFlow` type variants.\n \n These symbols are used as property keys to distinguish between `Break` and `Continue` variants.\n * They provide a reliable way to identify the variant of a `ControlFlow` instance without\n * relying on method calls or duck typing.\n \n Note: These symbols are internal implementation details and are not exported as part of the public API.\n * Use the `isControlFlow` utility function for type checking instead.\n /\n\n/\n A unique symbol used as a property key to identify the variant of a `ControlFlow` instance.\n \n When accessed on a `ControlFlow`, returns `'Break'` if the ControlFlow signals early exit,\n * or `'Continue'` if it signals to proceed as normal.\n \n This symbol is used internally by the `isControlFlow` utility function to verify\n * that an object is a valid `ControlFlow` instance.\n \n @internal\n /\nexport const ControlFlowKindSymbol = Symbol('ControlFlow kind');\n","/\n @fileoverview\n * Rust-inspired [ControlFlow](https://doc.rust-lang.org/std/ops/enum.ControlFlow.html) for control flow handling.\n \n `ControlFlow` is used to tell an operation whether it should exit early or go on as usual.\n * This is useful for:\n * - Short-circuiting iterators\n * - Signaling early termination in fold-like operations\n * - Implementing custom control flow patterns\n /\n\nimport { Err, None, Ok, Some, type Option, type Result } from '../enum/mod.ts';\nimport { ControlFlowKindSymbol } from './symbols.ts';\n\n/\n Used to tell an operation whether it should exit early or go on as usual.\n \n This is the return type of `try_fold` and similar iterator methods that support\n * short-circuiting. It can also be used in custom control flow scenarios.\n \n @typeParam B - The type of the value returned on `Break` (early exit).\n * @typeParam C - The type of the value returned on `Continue` (default: `void`).\n \n @example\n * ```ts\n * // Using ControlFlow to short-circuit a search\n * function findFirstNegative(numbers: number[]): Option<number> {\n * let result: Option<number> = None;\n \n for (const n of numbers) {\n * const flow = n < 0 ? Break(n) : Continue();\n * if (flow.isBreak()) {\n * result = Some(flow.breakValue().unwrap());\n * break;\n * }\n * }\n \n return result;\n * }\n * ```\n \n @example\n * ```ts\n * // Using ControlFlow in a custom fold operation\n * function tryFold<T, Acc>(\n * arr: T[],\n * init: Acc,\n * f: (acc: Acc, item: T) => ControlFlow<Acc, Acc>\n * ): ControlFlow<Acc, Acc> {\n * let acc = init;\n * for (const item of arr) {\n * const flow = f(acc, item);\n * if (flow.isBreak()) {\n * return flow;\n * }\n * acc = flow.continueValue().unwrap();\n * }\n * return Continue(acc);\n * }\n * ```\n /\nexport interface ControlFlow<B, C = void> {\n // #region Internal properties\n\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'ControlFlow'` so that `Object.prototype.toString.call(flow)` produces `'[object ControlFlow]'`.\n \n This enables reliable type identification even across different execution contexts (e.g., iframes, different module instances).\n \n @example\n * ```ts\n * const x = Break(5);\n * console.log(Object.prototype.toString.call(x)); // '[object ControlFlow]'\n * ```\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'ControlFlow';\n\n /\n A unique symbol property used to identify the variant of this `ControlFlow`.\n * Returns `'Break'` if the ControlFlow signals early exit, or `'Continue'` if it signals to proceed as normal.\n \n This is used internally by the `isControlFlow` utility function to verify that an object is a valid `ControlFlow` instance,\n * and to distinguish between `Break` and `Continue` variants without calling methods.\n \n Note: The symbol itself is not exported as part of the public API.\n * Use the `isControlFlow` utility function or the `isBreak()`/`isContinue()` methods for type checking.\n \n @internal\n /\n readonly [ControlFlowKindSymbol]: 'Break' \| 'Continue';\n\n // #endregion\n\n /\n Returns `true` if this is a `Break` variant.\n \n @example\n * ```ts\n * console.log(Break(3).isBreak()); // true\n * console.log(Continue().isBreak()); // false\n * ```\n /\n isBreak(): boolean;\n\n /\n Returns `true` if this is a `Continue` variant.\n \n @example\n * ```ts\n * console.log(Continue().isContinue()); // true\n * console.log(Break(3).isContinue()); // false\n * ```\n /\n isContinue(): boolean;\n\n /\n Converts the `ControlFlow` into an `Option` which is `Some` if the\n * `ControlFlow` was `Break` and `None` otherwise.\n \n @returns `Some(value)` if `Break`, `None` if `Continue`.\n \n @example\n * ```ts\n * console.log(Break(3).breakValue()); // Some(3)\n * console.log(Continue().breakValue()); // None\n * ```\n /\n breakValue(): Option<B>;\n\n /\n Converts the `ControlFlow` into an `Option` which is `Some` if the\n * `ControlFlow` was `Continue` and `None` otherwise.\n \n @returns `Some(value)` if `Continue`, `None` if `Break`.\n \n @example\n * ```ts\n * console.log(Continue(5).continueValue()); // Some(5)\n * console.log(Break(3).continueValue()); // None\n * ```\n /\n continueValue(): Option<C>;\n\n /\n Maps `ControlFlow<B, C>` to `ControlFlow<T, C>` by applying a function\n * to the break value in case it exists.\n \n @typeParam T - The type of the new break value.\n * @param fn - A function to apply to the break value.\n * @returns A new `ControlFlow` with the mapped break value.\n \n @example\n * ```ts\n * const flow = Break(3);\n * console.log(flow.mapBreak(v => v * 2).breakValue()); // Some(6)\n * ```\n /\n mapBreak<T>(fn: (value: B) => T): ControlFlow<T, C>;\n\n /\n Maps `ControlFlow<B, C>` to `ControlFlow<B, T>` by applying a function\n * to the continue value in case it exists.\n \n @typeParam T - The type of the new continue value.\n * @param fn - A function to apply to the continue value.\n * @returns A new `ControlFlow` with the mapped continue value.\n \n @example\n * ```ts\n * const flow = Continue(5);\n * console.log(flow.mapContinue(v => v * 2).continueValue()); // Some(10)\n * ```\n /\n mapContinue<T>(fn: (value: C) => T): ControlFlow<B, T>;\n\n /\n Converts the `ControlFlow` into a `Result` which is `Ok` if the\n * `ControlFlow` was `Break` and `Err` otherwise.\n \n @returns `Ok(breakValue)` if `Break`, `Err(continueValue)` if `Continue`.\n \n @example\n * ```ts\n * console.log(Break(3).breakOk()); // Ok(3)\n * console.log(Continue('still going').breakOk()); // Err('still going')\n * ```\n /\n breakOk(): Result<B, C>;\n\n /\n Converts the `ControlFlow` into a `Result` which is `Ok` if the\n * `ControlFlow` was `Continue` and `Err` otherwise.\n \n @returns `Ok(continueValue)` if `Continue`, `Err(breakValue)` if `Break`.\n \n @example\n * ```ts\n * console.log(Continue(5).continueOk()); // Ok(5)\n * console.log(Break('stopped').continueOk()); // Err('stopped')\n * ```\n /\n continueOk(): Result<C, B>;\n\n /\n Custom `toString` implementation that uses the `ControlFlow`'s contained value.\n * @example\n * ```ts\n * console.log(Break(5).toString()); // 'Break(5)'\n * console.log(Continue('ok').toString()); // 'Continue(ok)'\n * ```\n /\n toString(): string;\n}\n\n/\n Creates a `Break` variant of `ControlFlow`.\n \n Use this to signal that an operation should exit early with the given value.\n \n @typeParam B - The type of the break value.\n * @typeParam C - The type of the continue value (defaults to `void` when a value is provided).\n * @param value - The value to return on break.\n * @returns A `ControlFlow` in the `Break` state.\n \n @example\n * ```ts\n * const flow = Break('found it');\n * console.log(flow.isBreak()); // true\n * console.log(flow.breakValue().unwrap()); // 'found it'\n \n const voidFlow = Break();\n * console.log(voidFlow.isBreak()); // true\n * ```\n /\nexport function Break<B, C = never>(value: B): ControlFlow<B, C>;\n/\n Creates a `Break` variant of `ControlFlow` with no value.\n * This overload is used when the operation exits early but doesn't produce a meaningful value.\n \n @typeParam C - The type of the continue value (allows type specification when chaining with Continue).\n * @returns A `ControlFlow<void, C>` in the `Break` state.\n \n @example\n * ```ts\n * const voidFlow = Break();\n * console.log(voidFlow.isBreak()); // true\n * console.log(voidFlow.breakValue()); // Some(undefined)\n \n // With explicit type parameter\n * const typedFlow = Break<number>(); // ControlFlow<void, number>\n * ```\n /\nexport function Break<C = never>(): ControlFlow<void, C>;\nexport function Break<B, C>(value?: B): ControlFlow<B, C> {\n const brk: ControlFlow<B, C> = Object.freeze<ControlFlow<B, C>>({\n [Symbol.toStringTag]: 'ControlFlow',\n [ControlFlowKindSymbol]: 'Break',\n\n isBreak(): true {\n return true;\n },\n isContinue(): false {\n return false;\n },\n breakValue(): Option<B> {\n return Some(value as B);\n },\n continueValue(): Option<C> {\n return None;\n },\n mapBreak<T>(fn: (v: B) => T): ControlFlow<T, C> {\n return Break(fn(value as B));\n },\n mapContinue<T>(_fn: (v: C) => T): ControlFlow<B, T> {\n return brk as unknown as ControlFlow<B, T>;\n },\n breakOk(): Result<B, C> {\n return Ok(value as B);\n },\n continueOk(): Result<C, B> {\n return Err(value as B);\n },\n\n toString(): string {\n return `Break(${ value })`;\n },\n } as const);\n\n return brk;\n}\n\n/\n Creates a `Continue` variant of `ControlFlow`.\n \n Use this to signal that an operation should continue as normal.\n \n @typeParam B - The type of the break value (defaults to `void` when a value is provided).\n * @typeParam C - The type of the continue value.\n * @param value - The value to carry forward (optional, defaults to `undefined`).\n * @returns A `ControlFlow` in the `Continue` state.\n \n @example\n * ```ts\n * const flow = Continue();\n * console.log(flow.isContinue()); // true\n \n const flowWithValue = Continue(42);\n * console.log(flowWithValue.continueValue().unwrap()); // 42\n * ```\n /\nexport function Continue<B = never, C = void>(value: C): ControlFlow<B, C>;\n/\n Creates a `Continue` variant of `ControlFlow` with no value.\n * This overload is used when the operation continues but doesn't carry a meaningful value.\n \n @typeParam B - The type of the break value (allows type specification when chaining with Break).\n * @returns A `ControlFlow<B, void>` in the `Continue` state.\n \n @example\n * ```ts\n * const voidFlow = Continue();\n * console.log(voidFlow.isContinue()); // true\n * console.log(voidFlow.continueValue()); // Some(undefined)\n \n // With explicit type parameter\n * const typedFlow = Continue<string>(); // ControlFlow<string, void>\n * ```\n /\nexport function Continue<B = never>(): ControlFlow<B, void>;\nexport function Continue<B, C>(value?: C): ControlFlow<B, C> {\n const cont: ControlFlow<B, C> = Object.freeze<ControlFlow<B, C>>({\n [Symbol.toStringTag]: 'ControlFlow',\n [ControlFlowKindSymbol]: 'Continue',\n\n isBreak(): false {\n return false;\n },\n isContinue(): true {\n return true;\n },\n breakValue(): Option<B> {\n return None;\n },\n continueValue(): Option<C> {\n return Some(value as C);\n },\n mapBreak<T>(_fn: (v: B) => T): ControlFlow<T, C> {\n return cont as unknown as ControlFlow<T, C>;\n },\n mapContinue<T>(fn: (v: C) => T): ControlFlow<B, T> {\n return Continue(fn(value as C));\n },\n breakOk(): Result<B, C> {\n return Err(value as C);\n },\n continueOk(): Result<C, B> {\n return Ok(value as C);\n },\n\n toString(): string {\n return `Continue(${ value })`;\n },\n } as const);\n\n return cont;\n}\n","/\n @fileoverview\n * Type guard utilities for checking if values are `ControlFlow` types.\n \n These functions provide runtime type checking capabilities for the ControlFlow type.\n /\nimport type { ControlFlow } from './control_flow.ts';\nimport { ControlFlowKindSymbol } from './symbols.ts';\n\n/\n Checks if a value is a `ControlFlow`.\n \n @typeParam B - The expected type of the break value contained within the `ControlFlow`.\n * @typeParam C - The expected type of the continue value contained within the `ControlFlow`.\n * @param cf - The value to be checked as a `ControlFlow`.\n * @returns `true` if the value is a `ControlFlow`, otherwise `false`.\n * @example\n * ```ts\n * const x = Break(5);\n * console.log(isControlFlow(x)); // true\n * console.log(isControlFlow(null)); // false\n * console.log(isControlFlow({ isBreak: () => true })); // false\n * ```\n /\nexport function isControlFlow<B, C>(cf: unknown): cf is ControlFlow<B, C> {\n // `Break` and `Continue` must be an object.\n return cf != null && typeof cf === 'object' && ControlFlowKindSymbol in cf;\n}\n","/\n @fileoverview\n * Rust-inspired [LazyLock](https://doc.rust-lang.org/std/sync/struct.LazyLock.html) for lazy initialization.\n \n `Lazy<T>` is a value which is initialized on the first access. Unlike `Once<T>`,\n * the initialization function is provided at construction time.\n /\n\nimport { None, Some, type Option } from '../enum/mod.ts';\n\n/\n A value which is initialized on the first access.\n \n This is a lazily evaluated value. The initialization function is provided\n * at construction time and executed on first access. Subsequent accesses\n * return the cached value.\n \n Unlike `Once<T>`, which allows setting values manually or with different\n * initializers, `Lazy<T>` binds the initializer at creation time.\n \n @typeParam T - The type of the value stored.\n \n @example\n * ```ts\n * const expensive = Lazy(() => {\n * console.log('Computing...');\n * return heavyComputation();\n * });\n \n // Nothing computed yet\n * console.log(expensive.isInitialized()); // false\n \n // First access triggers computation\n * const value = expensive.force(); // logs \"Computing...\"\n \n // Subsequent access returns cached value\n * const same = expensive.force(); // no log, returns cached value\n * ```\n /\nexport interface Lazy<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'Lazy'` so that `Object.prototype.toString.call(lazy)` produces `'[object Lazy]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'Lazy';\n\n /\n Forces the evaluation of this lazy value and returns the result.\n \n If the value has already been initialized, returns the cached value.\n * Otherwise, executes the initialization function, caches the result,\n * and returns it.\n \n @returns The initialized value.\n \n @example\n * ```ts\n * const lazy = Lazy(() => 42);\n * console.log(lazy.force()); // 42\n * console.log(lazy.force()); // 42 (cached)\n * ```\n /\n force(): T;\n\n /\n Gets the value if it has been initialized.\n \n Unlike `force()`, this does not trigger initialization.\n \n @returns `Some(value)` if initialized, `None` otherwise.\n \n @example\n * ```ts\n * const lazy = Lazy(() => 42);\n * console.log(lazy.get()); // None\n \n lazy.force();\n * console.log(lazy.get()); // Some(42)\n * ```\n /\n get(): Option<T>;\n\n /\n Returns `true` if the value has been initialized.\n \n @example\n * ```ts\n * const lazy = Lazy(() => 42);\n * console.log(lazy.isInitialized()); // false\n \n lazy.force();\n * console.log(lazy.isInitialized()); // true\n * ```\n /\n isInitialized(): boolean;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const lazy = Lazy(() => 42);\n * console.log(lazy.toString()); // 'Lazy(<uninitialized>)'\n \n lazy.force();\n * console.log(lazy.toString()); // 'Lazy(42)'\n * ```\n /\n toString(): string;\n}\n\n/\n A value which is initialized asynchronously on the first access.\n \n Similar to `Lazy<T>`, but the initialization function is async.\n * If multiple calls to `force()` occur concurrently before initialization\n * completes, only one initialization will run.\n \n @typeParam T - The type of the value stored.\n \n @example\n * ```ts\n * const db = LazyAsync(async () => {\n * console.log('Connecting...');\n * return await Database.connect(url);\n * });\n \n // Multiple concurrent accesses - only one connection\n * const [db1, db2] = await Promise.all([\n * db.force(),\n * db.force(),\n * ]);\n * // db1 === db2\n * ```\n /\nexport interface LazyAsync<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'LazyAsync'` so that `Object.prototype.toString.call(lazy)` produces `'[object LazyAsync]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'LazyAsync';\n\n /\n Forces the evaluation of this lazy value and returns a promise to the result.\n \n If the value has already been initialized, returns the cached value.\n * If initialization is in progress, waits for it to complete.\n * Otherwise, starts initialization.\n \n @returns A promise that resolves to the initialized value.\n \n @example\n * ```ts\n * const lazy = LazyAsync(async () => {\n * await delay(100);\n * return 42;\n * });\n * console.log(await lazy.force()); // 42\n * ```\n /\n force(): Promise<T>;\n\n /\n Gets the value if it has been initialized.\n \n Unlike `force()`, this does not trigger initialization.\n \n @returns `Some(value)` if initialized, `None` otherwise.\n \n @example\n * ```ts\n * const lazy = LazyAsync(async () => 42);\n * console.log(lazy.get()); // None\n \n await lazy.force();\n * console.log(lazy.get()); // Some(42)\n * ```\n /\n get(): Option<T>;\n\n /\n Returns `true` if the value has been initialized.\n \n Note: Returns `false` while initialization is in progress.\n \n @example\n * ```ts\n * const lazy = LazyAsync(async () => 42);\n * console.log(lazy.isInitialized()); // false\n \n await lazy.force();\n * console.log(lazy.isInitialized()); // true\n * ```\n /\n isInitialized(): boolean;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const lazy = LazyAsync(async () => 42);\n * console.log(lazy.toString()); // 'LazyAsync(<uninitialized>)'\n \n await lazy.force();\n * console.log(lazy.toString()); // 'LazyAsync(42)'\n * ```\n /\n toString(): string;\n}\n\n/\n Creates a new `Lazy<T>` with the given synchronous initialization function.\n \n The function is called at most once, on first access via `force()`.\n \n @typeParam T - The type of value to store.\n * @param fn - The initialization function that produces the value.\n * @returns A new `Lazy<T>` instance.\n \n @example\n * ```ts\n * // Basic usage\n * const lazy = Lazy(() => {\n * console.log('Initializing');\n * return 42;\n * });\n \n console.log(lazy.isInitialized()); // false\n * console.log(lazy.force()); // logs \"Initializing\", returns 42\n * console.log(lazy.isInitialized()); // true\n * console.log(lazy.force()); // returns 42 (no log)\n * ```\n \n @example\n * ```ts\n * // Lazy singleton pattern\n * const logger = Lazy(() => new Logger('app'));\n \n function getLogger(): Logger {\n * return logger.force();\n * }\n * ```\n \n @example\n * ```ts\n * // Expensive computation\n * const fibonacci = Lazy(() => {\n * function fib(n: number): number {\n * if (n <= 1) return n;\n * return fib(n - 1) + fib(n - 2);\n * }\n * return fib(40); // Only computed once\n * });\n * ```\n /\nexport function Lazy<T>(fn: () => T): Lazy<T> {\n let value: T \| undefined;\n let initialized = false;\n\n return Object.freeze<Lazy<T>>({\n [Symbol.toStringTag]: 'Lazy',\n\n force(): T {\n if (!initialized) {\n value = fn();\n initialized = true;\n }\n return value as T;\n },\n\n get(): Option<T> {\n return initialized ? Some(value as T) : None;\n },\n\n isInitialized(): boolean {\n return initialized;\n },\n\n toString(): string {\n return initialized ? `Lazy(${ value })` : 'Lazy(<uninitialized>)';\n },\n } as const);\n}\n\n/\n Creates a new `LazyAsync<T>` with the given async initialization function.\n \n The function is called at most once, on first access via `force()`.\n * Concurrent calls to `force()` before initialization completes will\n * wait for the single initialization to finish.\n \n @typeParam T - The type of value to store.\n * @param fn - The async initialization function that produces the value.\n * @returns A new `LazyAsync<T>` instance.\n \n @example\n * ```ts\n * // Basic usage\n * const lazy = LazyAsync(async () => {\n * const response = await fetch('/api/data');\n * return await response.json();\n * });\n \n const data = await lazy.force();\n * ```\n \n @example\n * ```ts\n * // Database connection singleton\n * const db = LazyAsync(async () => {\n * console.log('Connecting to database...');\n * return await Database.connect(connectionString);\n * });\n \n async function getDb(): Promise<Database> {\n * return await db.force();\n * }\n \n // Multiple calls - connection happens only once\n * const [db1, db2] = await Promise.all([getDb(), getDb()]);\n * console.log(db1 === db2); // true\n * ```\n \n @example\n * ```ts\n * // Configuration loader\n * const config = LazyAsync(async () => {\n * const response = await fetch('/api/config');\n * if (!response.ok) {\n * throw new Error(`Failed to load config: ${response.status}`);\n * }\n * return await response.json() as Config;\n * });\n \n // Used throughout the app\n * async function getApiEndpoint(): Promise<string> {\n * const cfg = await config.force();\n * return cfg.apiEndpoint;\n * }\n * ```\n /\nexport function LazyAsync<T>(fn: () => Promise<T>): LazyAsync<T> {\n let value: T \| undefined;\n let initialized = false;\n let pendingPromise: Promise<T> \| undefined;\n\n return Object.freeze<LazyAsync<T>>({\n [Symbol.toStringTag]: 'LazyAsync',\n\n async force(): Promise<T> {\n if (initialized) {\n return value as T;\n }\n\n if (pendingPromise) {\n return pendingPromise;\n }\n\n pendingPromise = (async () => {\n try {\n const result = await fn();\n value = result;\n initialized = true;\n return result;\n } finally {\n pendingPromise = undefined;\n }\n })();\n\n return pendingPromise;\n },\n\n get(): Option<T> {\n return initialized ? Some(value as T) : None;\n },\n\n isInitialized(): boolean {\n return initialized;\n },\n\n toString(): string {\n return initialized ? `LazyAsync(${ value })` : 'LazyAsync(<uninitialized>)';\n },\n } as const);\n}\n","/\n @fileoverview\n * Rust-inspired [Mutex](https://doc.rust-lang.org/std/sync/struct.Mutex.html) for async mutual exclusion.\n \n In JavaScript's single-threaded environment, `Mutex<T>` is used to serialize\n * async operations, ensuring only one async task accesses the protected resource at a time.\n /\n\nimport { None, Some, type Option } from '../enum/mod.ts';\n\n/\n A guard that provides access to the mutex-protected value.\n \n The guard must be released after use by calling `unlock()`.\n * Failure to unlock will cause deadlock for subsequent lock attempts.\n \n @typeParam T - The type of the protected value.\n /\nexport interface MutexGuard<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'MutexGuard'` so that `Object.prototype.toString.call(guard)` produces `'[object MutexGuard]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'MutexGuard';\n\n /\n The protected value. Can be read or modified while the guard is held.\n /\n value: T;\n\n /\n Releases the lock, allowing other waiters to acquire it.\n \n Must be called when done with the protected value.\n * After calling `unlock()`, the guard should not be used.\n \n @example\n * ```ts\n * const guard = await mutex.lock();\n * try {\n * guard.value.push('item');\n * } finally {\n * guard.unlock();\n * }\n * ```\n /\n unlock(): void;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const guard = await mutex.lock();\n * console.log(guard.toString()); // 'MutexGuard(42)'\n * ```\n /\n toString(): string;\n}\n\n/\n An async mutual exclusion primitive for protecting shared data.\n \n This mutex provides exclusive access to the contained value, ensuring\n * that only one async operation can access it at a time. This is useful\n * for preventing race conditions in async code.\n \n Unlike Rust's Mutex which is for multi-threading, this JavaScript version\n * serializes async operations in the single-threaded event loop.\n \n @typeParam T - The type of the protected value.\n \n @example\n * ```ts\n * const mutex = Mutex({ balance: 100 });\n \n // Safe concurrent updates\n * await Promise.all([\n * mutex.withLock(async (account) => {\n * account.balance -= 50;\n * }),\n * mutex.withLock(async (account) => {\n * account.balance += 30;\n * }),\n * ]);\n * ```\n /\nexport interface Mutex<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'Mutex'` so that `Object.prototype.toString.call(mutex)` produces `'[object Mutex]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'Mutex';\n\n /\n Acquires the lock and executes the callback with the protected value.\n \n This is the recommended way to use the mutex as it automatically\n * releases the lock when the callback completes (or throws).\n \n @typeParam U - The return type of the callback.\n * @param fn - The callback that receives the protected value.\n * @returns A promise that resolves to the callback's return value.\n \n @example\n * ```ts\n * const mutex = Mutex<number[]>([]);\n \n await mutex.withLock(async (arr) => {\n * arr.push(await fetchItem());\n * });\n * ```\n /\n withLock<U>(fn: (value: T) => Promise<U> \| U): Promise<U>;\n\n /\n Acquires the lock and returns a guard for manual control.\n \n Use this when you need more control over when to release the lock.\n * Important: Always release the lock in a `finally` block to prevent deadlocks.\n \n @returns A promise that resolves to a guard providing access to the value.\n \n @example\n * ```ts\n * const guard = await mutex.lock();\n * try {\n * // Long-running operation with the protected value\n * await processData(guard.value);\n * guard.value = transformedData;\n * } finally {\n * guard.unlock();\n * }\n * ```\n /\n lock(): Promise<MutexGuard<T>>;\n\n /\n Attempts to acquire the lock without waiting.\n \n Returns immediately with `Some(guard)` if the lock is available,\n * or `None` if it's currently held by another operation.\n \n @returns `Some(guard)` if acquired, `None` if locked.\n \n @example\n * ```ts\n * const maybeGuard = mutex.tryLock();\n * if (maybeGuard.isSome()) {\n * const guard = maybeGuard.unwrap();\n * try {\n * // Use the value\n * } finally {\n * guard.unlock();\n * }\n * } else {\n * console.log('Mutex is busy');\n * }\n * ```\n /\n tryLock(): Option<MutexGuard<T>>;\n\n /\n Returns `true` if the mutex is currently locked.\n \n Note: This is a snapshot and may change immediately after the call.\n \n @example\n * ```ts\n * console.log(mutex.isLocked()); // false\n * const guard = await mutex.lock();\n * console.log(mutex.isLocked()); // true\n * guard.unlock();\n * console.log(mutex.isLocked()); // false\n * ```\n /\n isLocked(): boolean;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const mutex = Mutex(42);\n * console.log(mutex.toString()); // 'Mutex(<unlocked>)'\n \n const guard = await mutex.lock();\n * console.log(mutex.toString()); // 'Mutex(<locked>)'\n * ```\n /\n toString(): string;\n}\n\n/\n Creates a new `Mutex<T>` protecting the given value.\n \n @typeParam T - The type of the protected value.\n * @param value - The initial value to protect.\n * @returns A new `Mutex<T>` instance.\n \n @example\n * ```ts\n * // Protect a simple value\n * const counter = Mutex(0);\n \n // Protect an object\n * const state = Mutex({ users: [], lastUpdate: Date.now() });\n \n // Protect a resource\n * const db = Mutex(await createConnection());\n * ```\n \n @example\n * ```ts\n * // Database transaction safety\n * const connection = Mutex(db);\n \n async function transfer(from: string, to: string, amount: number) {\n * await connection.withLock(async (conn) => {\n * await conn.beginTransaction();\n * try {\n * const balance = await conn.query('SELECT balance FROM accounts WHERE id = ?', [from]);\n * if (balance < amount) {\n * throw new Error('Insufficient funds');\n * }\n * await conn.query('UPDATE accounts SET balance = balance - ? WHERE id = ?', [amount, from]);\n * await conn.query('UPDATE accounts SET balance = balance + ? WHERE id = ?', [amount, to]);\n * await conn.commit();\n * } catch (e) {\n * await conn.rollback();\n * throw e;\n * }\n * });\n * }\n * ```\n \n @example\n * ```ts\n * // Token refresh with mutex\n * const authState = Mutex({ token: '', expiresAt: 0 });\n \n async function getToken(): Promise<string> {\n * return await authState.withLock(async (state) => {\n * if (Date.now() > state.expiresAt) {\n * const response = await fetch('/api/refresh');\n * const data = await response.json();\n * state.token = data.token;\n * state.expiresAt = Date.now() + data.expiresIn * 1000;\n * }\n * return state.token;\n * });\n * }\n * ```\n \n @example\n * ```ts\n * // File write serialization\n * const fileLock = Mutex('/path/to/file.json');\n \n async function appendToFile(data: string) {\n * await fileLock.withLock(async (path) => {\n * const content = await fs.readFile(path, 'utf-8');\n * const json = JSON.parse(content);\n * json.entries.push(data);\n * await fs.writeFile(path, JSON.stringify(json, null, 2));\n * });\n * }\n * ```\n /\nexport function Mutex<T>(value: T): Mutex<T> {\n let currentValue = value;\n let locked = false;\n const waitQueue: (() => void)[] = [];\n\n function unlock(): void {\n if (waitQueue.length > 0) {\n // Wake up the next waiter\n const next = waitQueue.shift() as () => void;\n next();\n } else {\n locked = false;\n }\n }\n\n function createGuard(): MutexGuard<T> {\n let released = false;\n\n return Object.freeze<MutexGuard<T>>({\n [Symbol.toStringTag]: 'MutexGuard',\n\n get value(): T {\n if (released) {\n throw new Error('MutexGuard has been released.');\n }\n return currentValue;\n },\n set value(newValue: T) {\n if (released) {\n throw new Error('MutexGuard has been released.');\n }\n currentValue = newValue;\n },\n unlock(): void {\n if (released) {\n return; // Already released, ignore\n }\n released = true;\n unlock();\n },\n\n toString(): string {\n if (released) {\n return 'MutexGuard(<released>)';\n }\n return `MutexGuard(${ currentValue })`;\n },\n } as const);\n }\n\n function lock(): Promise<MutexGuard<T>> {\n if (!locked) {\n locked = true;\n return Promise.resolve(createGuard());\n }\n\n return new Promise<MutexGuard<T>>((resolve) => {\n waitQueue.push(() => {\n resolve(createGuard());\n });\n });\n }\n\n return Object.freeze<Mutex<T>>({\n [Symbol.toStringTag]: 'Mutex',\n\n async withLock<U>(fn: (value: T) => Promise<U> \| U): Promise<U> {\n const guard = await lock();\n try {\n return await fn(guard.value);\n } finally {\n guard.unlock();\n }\n },\n\n lock,\n\n tryLock(): Option<MutexGuard<T>> {\n if (locked) {\n return None;\n }\n locked = true;\n return Some(createGuard());\n },\n\n isLocked(): boolean {\n return locked;\n },\n\n toString(): string {\n return locked ? 'Mutex(<locked>)' : 'Mutex(<unlocked>)';\n },\n } as const);\n}\n","/\n @fileoverview\n * Rust-inspired [OnceLock](https://doc.rust-lang.org/std/sync/struct.OnceLock.html) for one-time initialization.\n \n `Once<T>` is a container which can be written to only once. It provides safe access\n * to lazily initialized data, supporting both sync and async initialization.\n /\n\nimport { Err, None, Ok, Some, type AsyncResult, type Option, type Result } from '../enum/mod.ts';\n\n/\n A container which can be written to only once.\n \n This is useful for lazy initialization of global data or expensive computations\n * that should only happen once. Supports both synchronous and asynchronous\n * initialization functions via separate methods.\n \n @typeParam T - The type of the value stored.\n \n @example\n * ```ts\n * const once = Once<number>();\n \n // Set value (only works once)\n * once.set(42); // Ok(undefined)\n * once.set(100); // Err(100) - already set\n \n // Get value\n * console.log(once.get()); // Some(42)\n * ```\n \n @example\n * ```ts\n * // Sync lazy initialization\n * const config = Once<Config>();\n * const cfg = config.getOrInit(() => loadConfigFromFile());\n * ```\n \n @example\n * ```ts\n * // Async lazy initialization\n * const db = Once<Database>();\n * const conn = await db.getOrInitAsync(async () => Database.connect(url));\n * ```\n /\nexport interface Once<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'Once'` so that `Object.prototype.toString.call(once)` produces `'[object Once]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'Once';\n\n /\n Gets the reference to the underlying value.\n \n @returns `Some(value)` if initialized, `None` otherwise.\n \n @example\n * ```ts\n * const once = Once<number>();\n * console.log(once.get()); // None\n \n once.set(42);\n * console.log(once.get()); // Some(42)\n * ```\n /\n get(): Option<T>;\n\n /\n Sets the contents to `value`.\n \n @param value - The value to store.\n * @returns `Ok(undefined)` if empty, `Err(value)` if already initialized.\n \n @example\n * ```ts\n * const once = Once<number>();\n \n console.log(once.set(42)); // Ok(undefined)\n * console.log(once.set(100)); // Err(100) - value returned back\n * console.log(once.get()); // Some(42)\n * ```\n /\n set(value: T): Result<void, T>;\n\n /\n Gets the contents, initializing it with `fn` if empty.\n \n @param fn - The synchronous initialization function, called only if empty.\n * @returns The stored value.\n \n @example\n * ```ts\n * const once = Once<number>();\n \n const value = once.getOrInit(() => {\n * console.log('Initializing...');\n * return 42;\n * });\n * console.log(value); // 42\n \n // Second call - fn is not called\n * const value2 = once.getOrInit(() => 100);\n * console.log(value2); // 42\n * ```\n /\n getOrInit(fn: () => T): T;\n\n /\n Gets the contents, initializing it with async `fn` if empty.\n \n If multiple calls occur concurrently, only the first one will run the\n * initialization function. Other calls will wait for it to complete.\n \n @param fn - The async initialization function.\n * @returns A promise that resolves to the stored value.\n \n @example\n * ```ts\n * const db = Once<Database>();\n \n // Multiple concurrent calls - only one connection happens\n * const [db1, db2, db3] = await Promise.all([\n * db.getOrInitAsync(() => Database.connect(url)),\n * db.getOrInitAsync(() => Database.connect(url)),\n * db.getOrInitAsync(() => Database.connect(url)),\n * ]);\n * // db1 === db2 === db3\n * ```\n /\n getOrInitAsync(fn: () => Promise<T>): Promise<T>;\n\n /\n Gets the contents, initializing it with `fn` if empty.\n * If `fn` returns `Err`, remains uninitialized.\n \n @typeParam E - The error type.\n * @param fn - The initialization function that may fail.\n * @returns `Ok(value)` if initialized, `Err(error)` if initialization failed.\n \n @example\n * ```ts\n * const once = Once<Config>();\n \n const result = once.getOrTryInit(() => {\n * const config = parseConfig(rawData);\n * return config ? Ok(config) : Err(new Error('Invalid config'));\n * });\n \n if (result.isOk()) {\n * console.log('Config loaded:', result.unwrap());\n * }\n * ```\n /\n getOrTryInit<E>(fn: () => Result<T, E>): Result<T, E>;\n\n /\n Gets the contents, initializing it with async `fn` if empty.\n * If `fn` returns `Err`, remains uninitialized.\n \n If multiple calls occur concurrently, only the first one will run the\n * initialization function. Other calls will wait for it to complete.\n \n @typeParam E - The error type.\n * @param fn - The async initialization function that may fail.\n * @returns A promise that resolves to `Ok(value)` or `Err(error)`.\n \n @example\n * ```ts\n * const config = Once<Config>();\n \n const result = await config.getOrTryInitAsync(async () => {\n * try {\n * const response = await fetch('/api/config');\n * return Ok(await response.json());\n * } catch (e) {\n * return Err(e as Error);\n * }\n * });\n * ```\n /\n getOrTryInitAsync<E>(fn: () => AsyncResult<T, E>): AsyncResult<T, E>;\n\n /\n Takes the value out, leaving it uninitialized.\n \n @returns `Some(value)` if initialized, `None` otherwise.\n \n @example\n * ```ts\n * const once = Once<number>();\n * once.set(42);\n \n console.log(once.take()); // Some(42)\n * console.log(once.get()); // None - now empty\n * console.log(once.take()); // None\n * ```\n /\n take(): Option<T>;\n\n /\n Returns `true` if initialized.\n \n @example\n * ```ts\n * const once = Once<number>();\n * console.log(once.isInitialized()); // false\n \n once.set(42);\n * console.log(once.isInitialized()); // true\n * ```\n /\n isInitialized(): boolean;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const once = Once<number>();\n * console.log(once.toString()); // 'Once(<uninitialized>)'\n \n once.set(42);\n * console.log(once.toString()); // 'Once(42)'\n * ```\n /\n toString(): string;\n}\n\n/\n Creates a new empty `Once<T>`.\n \n @typeParam T - The type of value to store.\n * @returns A new uninitialized `Once`.\n \n @example\n * ```ts\n * // Basic usage\n * const once = Once<string>();\n * once.set('hello');\n * console.log(once.get().unwrap()); // 'hello'\n * ```\n \n @example\n * ```ts\n * // Sync lazy singleton pattern\n * const logger = Once<Logger>();\n \n function getLogger(): Logger {\n * return logger.getOrInit(() => new Logger('app'));\n * }\n * ```\n \n @example\n * ```ts\n * // Async lazy initialization\n * const db = Once<Database>();\n \n async function getDb(): Promise<Database> {\n * return await db.getOrInitAsync(async () => {\n * console.log('Connecting to database...');\n * return await Database.connect(connectionString);\n * });\n * }\n \n // Multiple calls - connection happens only once\n * const [db1, db2] = await Promise.all([getDb(), getDb()]);\n * console.log(db1 === db2); // true\n * ```\n \n @example\n * ```ts\n * // Fallible async initialization\n * const config = Once<Config>();\n \n async function loadConfig(): Promise<Result<Config, Error>> {\n * return await config.getOrTryInitAsync(async () => {\n * try {\n * const response = await fetch('/api/config');\n * if (!response.ok) {\n * return Err(new Error(`HTTP ${response.status}`));\n * }\n * return Ok(await response.json());\n * } catch (e) {\n * return Err(e as Error);\n * }\n * });\n * }\n * ```\n */\nexport function Once<T>(): Once<T> {\n let value: T \| undefined;\n let initialized = false;\n let pendingPromise: Promise<T> \| undefined;\n\n return Object.freeze<Once<T>>({\n [Symbol.toStringTag]: 'Once',\n\n get(): Option<T> {\n return initialized ? Some(value as T) : None;\n },\n\n set(newValue: T): Result<void, T> {\n if (initialized) {\n return Err(newValue);\n }\n value = newValue;\n initialized = true;\n return Ok(undefined);\n },\n\n getOrInit(fn: () => T): T {\n if (!initialized) {\n value = fn();\n initialized = true;\n }\n return value as T;\n },\n\n async getOrInitAsync(fn: () => Promise<T>): Promise<T> {\n if (initialized) {\n return value as T;\n }\n\n // If already initializing, wait for the pending promise\n if (pendingPromise) {\n return pendingPromise;\n }\n\n pendingPromise = (async () => {\n try {\n const result = await fn();\n value = result;\n initialized = true;\n return result;\n } finally {\n pendingPromise = undefined;\n }\n })();\n\n return pendingPromise;\n },\n\n getOrTryInit<E>(fn: () => Result<T, E>): Result<T, E> {\n if (initialized) {\n return Ok(value as T);\n }\n\n const result = fn();\n if (result.isOk()) {\n value = result.unwrap();\n initialized = true;\n }\n return result;\n },\n\n async getOrTryInitAsync<E>(fn: () => AsyncResult<T, E>): AsyncResult<T, E> {\n if (initialized) {\n return Ok(value as T);\n }\n\n // If already initializing, wait for it\n if (pendingPromise) {\n try {\n await pendingPromise;\n // pendingPromise only resolves on success, so initialized must be true\n return Ok(value as T);\n } catch {\n // Previous initialization failed via Err result, let this call try again\n }\n }\n\n // Create a new pending promise for this initialization attempt\n pendingPromise = (async () => {\n const result = await fn();\n if (result.isOk()) {\n value = result.unwrap();\n initialized = true;\n return value;\n }\n // If Err, throw to signal failure (we'll catch and return the result)\n throw result;\n })();\n\n try {\n const resultValue = await pendingPromise;\n return Ok(resultValue as T);\n } catch (errResult) {\n return errResult as Result<T, E>;\n } finally {\n pendingPromise = undefined;\n }\n },\n\n take(): Option<T> {\n if (!initialized) {\n return None;\n }\n const taken = value as T;\n value = undefined;\n initialized = false;\n return Some(taken);\n },\n\n isInitialized(): boolean {\n return initialized;\n },\n\n toString(): string {\n return initialized ? `Once(${ value })` : 'Once(<uninitialized>)';\n },\n } as const);\n}\n"],"names":[],"mappings":"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"}

package/dist/main.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"main.mjs","sources":["../src/enum/symbols.ts","../src/enum/utils.ts","../src/enum/prelude.ts","../src/enum/constants.ts","../src/enum/extensions.ts","../src/ops/symbols.ts","../src/ops/control_flow.ts","../src/ops/utils.ts","../src/sync/lazy.ts","../src/sync/mutex.ts","../src/sync/once.ts"],"sourcesContent":["/*\n @fileoverview\n * Internal symbols used to identify `Option` and `Result` type variants.\n \n These symbols are used as property keys to distinguish between `Some`/`None` and `Ok`/`Err` variants.\n * They provide a reliable way to identify the variant of an `Option` or `Result` instance without\n * relying on method calls or duck typing.\n \n Note: These symbols are internal implementation details and are not exported as part of the public API.\n * Use the `isOption` and `isResult` utility functions for type checking instead.\n /\n\n/\n A unique symbol used as a property key to identify the variant of an `Option` instance.\n \n When accessed on an `Option`, returns `'Some'` if the Option contains a value,\n * or `'None'` if it represents the absence of a value.\n \n This symbol is used internally by the `isOption` utility function to verify\n * that an object is a valid `Option` instance.\n \n @internal\n /\nexport const OptionKindSymbol = Symbol('Option kind');\n\n/\n A unique symbol used as a property key to identify the variant of a `Result` instance.\n \n When accessed on a `Result`, returns `'Ok'` if the Result represents success,\n * or `'Err'` if it represents failure.\n \n This symbol is used internally by the `isResult` utility function to verify\n * that an object is a valid `Result` instance.\n \n @internal\n /\nexport const ResultKindSymbol = Symbol('Result kind');\n","/\n @fileoverview\n * Type guard utilities for checking if values are `Option` or `Result` types.\n \n These functions provide runtime type checking capabilities for the Option and Result types.\n /\nimport type { Option, Result } from './core.ts';\nimport { OptionKindSymbol, ResultKindSymbol } from './symbols.ts';\n\n/\n Checks if a value is an `Option`.\n \n @typeParam T - The expected type of the value contained within the `Option`.\n * @param o - The value to be checked as an `Option`.\n * @returns `true` if the value is an `Option`, otherwise `false`.\n * @example\n * ```ts\n * const x = Some(5);\n * console.log(isOption(x)); // true\n * console.log(isOption(null)); // false\n * console.log(isOption({ value: 5 })); // false\n * ```\n /\nexport function isOption<T>(o: unknown): o is Option<T> {\n // `Some` and `None` must be an object.\n return o != null && typeof o === 'object' && OptionKindSymbol in o;\n}\n\n/\n Checks if a value is a `Result`.\n \n @typeParam T - The expected type of the success value contained within the `Result`.\n * @typeParam E - The expected type of the error value contained within the `Result`.\n * @param r - The value to be checked as a `Result`.\n * @returns `true` if the value is a `Result`, otherwise `false`.\n * @example\n * ```ts\n * const x = Ok(5);\n * console.log(isResult(x)); // true\n * console.log(isResult(null)); // false\n * console.log(isResult({ value: 5 })); // false\n * ```\n /\nexport function isResult<T, E>(r: unknown): r is Result<T, E> {\n // `Ok` and `Err` must be an object.\n return r != null && typeof r === 'object' && ResultKindSymbol in r;\n}","/\n @fileoverview\n * Constructors and factory functions for creating `Option` and `Result` types.\n \n This module exports:\n * - `Some<T>(value)` - Creates an Option containing a value\n * - `None` - Constant representing absence of value\n * - `Ok<T, E>(value)` - Creates a successful Result\n * - `Err<T, E>(error)` - Creates a failed Result\n * - `None` interface - Type overrides for better type inference\n /\nimport type { AsyncOption, AsyncResult, Option, Result } from './core.ts';\nimport { OptionKindSymbol, ResultKindSymbol } from './symbols.ts';\nimport { isOption, isResult } from './utils.ts';\n\n/\n Represents the absence of a value, as a specialized `Option` type.\n * The type parameter is set to `never` because `None` does not hold a value.\n /\nexport interface None extends Option<never> {\n /\n When using `None` alone, the following overrides can make type inference more accurate.\n /\n\n readonly [OptionKindSymbol]: 'None';\n\n isSome(): false;\n isNone(): true;\n isSomeAnd(predicate: (value: never) => boolean): false;\n isSomeAndAsync(predicate: (value: never) => Promise<boolean>): Promise<false>;\n isNoneOr(predicate: (value: never) => boolean): true;\n isNoneOrAsync(predicate: (value: never) => Promise<boolean>): Promise<true>;\n\n expect(msg: string): never;\n unwrap(): never;\n unwrapOr<T>(defaultValue: T): T;\n unwrapOrElse<T>(fn: () => T): T;\n unwrapOrElseAsync<T>(fn: () => Promise<T>): Promise<T>;\n\n okOr<E>(error: E): Result<never, E>;\n okOrElse<E>(err: () => E): Result<never, E>;\n transpose(): Result<this, never>;\n\n filter(predicate: (value: never) => boolean): this;\n flatten(): this;\n map<U>(fn: (value: never) => U): this;\n mapOr<U>(defaultValue: U, fn: (value: never) => U): U;\n mapOrElse<U>(defaultFn: () => U, fn: (value: never) => U): U;\n\n zip<U>(other: Option<U>): this;\n zipWith<U, R>(other: Option<U>, fn: (value: never, otherValue: U) => R): this;\n unzip(): [this, this];\n\n and<U>(other: Option<U>): this;\n andThen<U>(fn: (value: never) => Option<U>): this;\n andThenAsync<U>(fn: (value: never) => AsyncOption<U>): Promise<this>;\n or<T>(other: Option<T>): Option<T>;\n orElse<T>(fn: () => Option<T>): Option<T>;\n orElseAsync<T>(fn: () => AsyncOption<T>): AsyncOption<T>;\n xor<T>(other: Option<T>): Option<T>;\n\n inspect(fn: (value: never) => void): this;\n\n eq<T>(other: Option<T>): boolean;\n}\n\n/\n Creates an `Option<T>` representing the presence of a value.\n * This function is typically used to construct an `Option` that contains a value, indicating that the operation yielding the value was successful.\n \n @typeParam T - The type of the value to be wrapped in a `Some`.\n * @param value - The value to wrap as a `Some` option.\n * @returns An `Option<T>` that contains the provided value, representing the `Some` case.\n \n @example\n * ```ts\n * const maybeValue = Some(1); // Option<number> with a value\n * if (maybeValue.isSome()) {\n * console.log(maybeValue.unwrap()); // Outputs: 1\n * }\n * ```\n /\nexport function Some<T>(value: T): Option<T> {\n const some: Option<T> = Object.freeze<Option<T>>({\n [Symbol.toStringTag]: 'Option',\n [OptionKindSymbol]: 'Some',\n\n isSome(): true {\n return true;\n },\n isNone(): false {\n return false;\n },\n isSomeAnd(predicate: (value: T) => boolean): boolean {\n return predicate(value);\n },\n isSomeAndAsync(predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n return predicate(value);\n },\n isNoneOr(predicate: (value: T) => boolean): boolean {\n return predicate(value);\n },\n isNoneOrAsync(predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n return predicate(value);\n },\n\n expect(_msg: string): T {\n return value;\n },\n unwrap(): T {\n return value;\n },\n unwrapOr(_defaultValue: T): T {\n return value;\n },\n unwrapOrElse(_fn: () => T): T {\n return value;\n },\n unwrapOrElseAsync(_fn: () => Promise<T>): Promise<T> {\n return Promise.resolve(value);\n },\n\n okOr<E>(_error: E): Result<T, E> {\n return Ok(value);\n },\n okOrElse<E>(_err: () => E): Result<T, E> {\n return Ok(value);\n },\n transpose<U, E>(): Result<Option<U>, E> {\n assertResult<U, E>(value);\n return value.isOk() ? Ok(Some(value.unwrap())) : Err(value.unwrapErr());\n },\n\n filter(predicate: (value: T) => boolean): Option<T> {\n return predicate(value) ? some : None;\n },\n flatten<U>(): Option<U> {\n assertOption<U>(value);\n return value;\n },\n map<U>(fn: (value: T) => U): Option<U> {\n return Some(fn(value));\n },\n\n mapOr<U>(_defaultValue: U, fn: (value: T) => U): U {\n return fn(value);\n },\n mapOrElse<U>(_defaultFn: () => U, fn: (value: T) => U): U {\n return fn(value);\n },\n\n zip<U>(other: Option<U>): Option<[T, U]> {\n assertOption<U>(other);\n return other.isSome() ? Some([value, other.unwrap()]) : None;\n },\n zipWith<U, R>(other: Option<U>, fn: (value: T, otherValue: U) => R): Option<R> {\n assertOption<U>(other);\n return other.isSome() ? Some(fn(value, other.unwrap())) : None;\n },\n unzip<U, R>(): [Option<U>, Option<R>] {\n const tuple = value as [U, R];\n\n if (!Array.isArray(tuple) \|\| tuple.length !== 2) {\n throw new TypeError(`Option::unzip() requires a 2-element tuple, received ${ Array.isArray(tuple) ? `array with ${ tuple.length } elements` : typeof tuple }.`);\n }\n\n const [a, b] = tuple;\n return [Some(a), Some(b)];\n },\n\n and<U>(other: Option<U>): Option<U> {\n assertOption<U>(other);\n return other;\n },\n andThen<U>(fn: (value: T) => Option<U>): Option<U> {\n return fn(value);\n },\n andThenAsync<U>(fn: (value: T) => AsyncOption<U>): AsyncOption<U> {\n return fn(value);\n },\n or(_other: Option<T>): Option<T> {\n return some;\n },\n orElse(_fn: () => Option<T>): Option<T> {\n return some;\n },\n orElseAsync(_fn: () => AsyncOption<T>): AsyncOption<T> {\n return Promise.resolve(some);\n },\n xor(other: Option<T>): Option<T> {\n assertOption<T>(other);\n return other.isSome() ? None : some;\n },\n\n inspect(fn: (value: T) => void): Option<T> {\n fn(value);\n return some;\n },\n\n eq(other: Option<T>): boolean {\n assertOption<T>(other);\n return other.isSome() && other.unwrap() === value;\n },\n\n toString(): string {\n return `Some(${ value })`;\n },\n } as const);\n\n return some;\n}\n\n/\n A constant representing the `None` case of an `Option`, indicating the absence of a value.\n * This constant is frozen to ensure it is immutable and cannot be altered, preserving the integrity of `None` throughout the application.\n \n @example\n * ```ts\n * // Use None to represent absence of a value\n * function findUser(id: number): Option<User> {\n * const user = users.find(u => u.id === id);\n * return user ? Some(user) : None;\n * }\n \n // None is a singleton, so you can compare by reference\n * const result = findUser(999);\n * if (result === None) {\n * console.log('User not found');\n * }\n \n // Use with Option methods\n * const name = None.unwrapOr('Anonymous'); // 'Anonymous'\n * ```\n /\nexport const None: None = Object.freeze<None>({\n [Symbol.toStringTag]: 'Option',\n [OptionKindSymbol]: 'None',\n\n isSome(): false {\n return false;\n },\n isNone(): true {\n return true;\n },\n isSomeAnd(_predicate: (value: never) => boolean): false {\n return false;\n },\n isSomeAndAsync(_predicate: (value: never) => Promise<boolean>): Promise<false> {\n return Promise.resolve(false);\n },\n isNoneOr(_predicate: (value: never) => boolean): true {\n return true;\n },\n isNoneOrAsync(_predicate: (value: never) => Promise<boolean>): Promise<true> {\n return Promise.resolve(true);\n },\n\n expect(msg: string): never {\n throw new TypeError(msg);\n },\n unwrap(): never {\n throw new TypeError('Option::unwrap() called on a `None` value.');\n },\n unwrapOr<T>(defaultValue: T): T {\n return defaultValue;\n },\n unwrapOrElse<T>(fn: () => T): T {\n return fn();\n },\n unwrapOrElseAsync<T>(fn: () => Promise<T>): Promise<T> {\n return fn();\n },\n\n okOr<E>(error: E): Result<never, E> {\n return Err(error);\n },\n okOrElse<E>(err: () => E): Result<never, E> {\n return Err(err());\n },\n transpose(): Result<None, never> {\n return Ok(None);\n },\n\n filter(_predicate: (value: never) => boolean): None {\n return None;\n },\n flatten(): None {\n return None;\n },\n map<U>(_fn: (value: never) => U): None {\n return None;\n },\n\n mapOr<U>(defaultValue: U, _fn: (value: never) => U): U {\n return defaultValue;\n },\n mapOrElse<U>(defaultFn: () => U, _fn: (value: never) => U): U {\n return defaultFn();\n },\n\n zip<U>(_other: Option<U>): None {\n return None;\n },\n zipWith<U, R>(_other: Option<U>, _fn: (value: never, otherValue: U) => R): None {\n return None;\n },\n unzip(): [None, None] {\n return [None, None];\n },\n\n and<U>(_other: Option<U>): None {\n return None;\n },\n andThen<U>(_fn: (value: never) => Option<U>): None {\n return None;\n },\n andThenAsync<U>(_fn: (value: never) => AsyncOption<U>): Promise<None> {\n return Promise.resolve(None);\n },\n or<T>(other: Option<T>): Option<T> {\n assertOption<T>(other);\n return other;\n },\n orElse<T>(fn: () => Option<T>): Option<T> {\n return fn();\n },\n orElseAsync<T>(fn: () => AsyncOption<T>): AsyncOption<T> {\n return fn();\n },\n xor<T>(other: Option<T>): Option<T> {\n assertOption<T>(other);\n return other.isSome() ? other : None;\n },\n\n inspect(_fn: (value: never) => void): None {\n return None;\n },\n\n eq<T>(other: Option<T>): boolean {\n assertOption<T>(other);\n return other === None;\n },\n\n toString(): string {\n return 'None';\n },\n} as const);\n\n/\n Creates a `Result<T, E>` representing a successful outcome containing a value.\n * This function is used to construct a `Result` that signifies the operation was successful by containing the value `T`.\n \n @typeParam T - The type of the value to be contained in the `Ok` result.\n * @typeParam E - The type of the error that the result could potentially contain (not used in this case).\n * @param value - The value to wrap as an `Ok` result.\n * @returns A `Result<T, E>` that contains the provided value, representing the `Ok` case.\n \n @example\n * ```ts\n * const goodResult = Ok<number, Error>(1); // Result<number, Error> with a value\n * if (goodResult.isOk()) {\n * console.log(goodResult.unwrap()); // Outputs: 1\n * }\n * ```\n /\nexport function Ok<T, E = never>(value: T): Result<T, E>;\n/\n Creates a `Result<void, E>` representing a successful outcome with no value.\n * This overload is used when the operation succeeds but doesn't produce a meaningful value.\n \n In Rust, this would be `Ok(())` using the unit type `()`.\n * Since JavaScript doesn't have a unit type, we use `void` instead.\n \n @typeParam E - The type of the error that the result could potentially contain.\n * @returns A `Result<void, E>` representing a successful operation with no value.\n \n @example\n * ```ts\n * function saveToFile(path: string): Result<void, Error> {\n * try {\n * fs.writeFileSync(path, data);\n * return Ok(); // Success with no return value\n * } catch (e) {\n * return Err(e as Error);\n * }\n * }\n \n const result = saveToFile('/tmp/data.txt');\n * if (result.isOk()) {\n * console.log('File saved successfully');\n * }\n * ```\n /\nexport function Ok<E = never>(): Result<void, E>;\nexport function Ok<T, E>(value?: T): Result<T, E> {\n const ok: Result<T, E> = Object.freeze<Result<T, E>>({\n [Symbol.toStringTag]: 'Result',\n [ResultKindSymbol]: 'Ok',\n\n isOk(): true {\n return true;\n },\n isErr(): false {\n return false;\n },\n isOkAnd(predicate: (value: T) => boolean): boolean {\n return predicate(value as T);\n },\n isOkAndAsync(predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n return predicate(value as T);\n },\n isErrAnd(_predicate: (error: E) => boolean): false {\n return false;\n },\n isErrAndAsync(_predicate: (error: E) => Promise<boolean>): Promise<false> {\n return Promise.resolve(false);\n },\n\n expect(_msg: string): T {\n return value as T;\n },\n unwrap(): T {\n return value as T;\n },\n unwrapOr(_defaultValue: T): T {\n return value as T;\n },\n unwrapOrElse(_fn: (error: E) => T): T {\n return value as T;\n },\n unwrapOrElseAsync(_fn: (error: E) => Promise<T>): Promise<T> {\n return Promise.resolve(value as T);\n },\n\n expectErr(msg: string): never {\n throw new TypeError(`${ msg }: ${ value }`);\n },\n unwrapErr(): never {\n throw new TypeError('Result::unwrapErr() called on an `Ok` value.');\n },\n\n ok(): Option<T> {\n return Some(value as T);\n },\n err(): None {\n return None;\n },\n transpose<U>(): Option<Result<U, E>> {\n assertOption<U>(value);\n return value.isSome() ? Some(Ok(value.unwrap())) : None;\n },\n\n map<U>(fn: (value: T) => U): Result<U, E> {\n return Ok(fn(value as T));\n },\n mapErr<F>(_fn: (error: E) => F): Result<T, F> {\n return Ok(value as T);\n },\n mapOr<U>(_defaultValue: U, fn: (value: T) => U): U {\n return fn(value as T);\n },\n mapOrElse<U>(_defaultFn: (error: E) => U, fn: (value: T) => U): U {\n return fn(value as T);\n },\n flatten<U>(): Result<U, E> {\n assertResult<U, E>(value);\n return value;\n },\n\n and<U>(other: Result<U, E>): Result<U, E> {\n assertResult<T, E>(other);\n return other;\n },\n or<F>(_other: Result<T, F>): Result<T, F> {\n return ok as unknown as Result<T, F>;\n },\n andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E> {\n return fn(value as T);\n },\n andThenAsync<U>(fn: (value: T) => AsyncResult<U, E>): AsyncResult<U, E> {\n return fn(value as T);\n },\n orElse<F>(_fn: (error: E) => Result<T, F>): Result<T, F> {\n return ok as unknown as Result<T, F>;\n },\n orElseAsync<F>(_fn: (error: E) => AsyncResult<T, F>): AsyncResult<T, F> {\n return Promise.resolve(ok as unknown as Result<T, F>);\n },\n\n inspect(fn: (value: T) => void): Result<T, E> {\n fn(value as T);\n return ok;\n },\n inspectErr(_fn: (error: E) => void): Result<T, E> {\n return ok;\n },\n\n eq(other: Result<T, E>): boolean {\n assertResult<T, E>(other);\n return other.isOk() && other.unwrap() === value;\n },\n\n asOk<F>(): Result<T, F> {\n return ok as unknown as Result<T, F>;\n },\n asErr(): never {\n throw new TypeError('Result::asErr() called on an `Ok` value.');\n },\n\n toString(): string {\n return `Ok(${ value })`;\n },\n } as const);\n\n return ok;\n}\n\n/\n Creates a `Result<T, E>` representing a failed outcome containing an error.\n * This function is used to construct a `Result` that signifies the operation failed by containing the error `E`.\n \n @typeParam T - The type of the value that the result could potentially contain (not used in this case).\n * @typeParam E - The type of the error to be wrapped in the `Err` result.\n * @param error - The error to wrap as an `Err` result.\n * @returns A `Result<T, E>` that contains the provided error, representing the `Err` case.\n \n @example\n * ```ts\n * const badResult = Err<number, Error>(new Error('Something went wrong'));\n * if (badResult.isErr()) {\n * console.error(badResult.unwrapErr()); // Outputs: Error: Something went wrong\n * }\n * ```\n /\nexport function Err<T = never, E = unknown>(error: E): Result<T, E> {\n const err: Result<T, E> = Object.freeze<Result<T, E>>({\n [Symbol.toStringTag]: 'Result',\n [ResultKindSymbol]: 'Err',\n\n isOk(): false {\n return false;\n },\n isErr(): true {\n return true;\n },\n isOkAnd(_predicate: (value: T) => boolean): false {\n return false;\n },\n isOkAndAsync(_predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n return Promise.resolve(false);\n },\n isErrAnd(predicate: (error: E) => boolean): boolean {\n return predicate(error);\n },\n isErrAndAsync(predicate: (error: E) => Promise<boolean>): Promise<boolean> {\n return predicate(error);\n },\n\n expect(msg: string): never {\n throw new TypeError(`${ msg }: ${ error }`);\n },\n unwrap(): never {\n throw new TypeError('Result::unwrap() called on an `Err` value.');\n },\n unwrapOr(defaultValue: T): T {\n return defaultValue;\n },\n unwrapOrElse(fn: (error: E) => T): T {\n return fn(error);\n },\n unwrapOrElseAsync(fn: (error: E) => Promise<T>): Promise<T> {\n return fn(error);\n },\n\n expectErr(_msg: string): E {\n return error;\n },\n unwrapErr(): E {\n return error;\n },\n\n ok(): None {\n return None;\n },\n err(): Option<E> {\n return Some(error);\n },\n transpose<U>(): Option<Result<U, E>> {\n return Some(err as unknown as Result<U, E>);\n },\n\n map<U>(_fn: (value: T) => U): Result<U, E> {\n return Err(error);\n },\n mapErr<F>(fn: (error: E) => F): Result<T, F> {\n return Err(fn(error));\n },\n mapOr<U>(defaultValue: U, _fn: (value: T) => U): U {\n return defaultValue;\n },\n mapOrElse<U>(defaultFn: (error: E) => U, _fn: (value: T) => U): U {\n return defaultFn(error);\n },\n flatten<U>(): Result<U, E> {\n return err as unknown as Result<U, E>;\n },\n\n and<U>(_other: Result<U, E>): Result<U, E> {\n return err as unknown as Result<U, E>;\n },\n or<F>(other: Result<T, F>): Result<T, F> {\n assertResult<T, E>(other);\n return other;\n },\n andThen<U>(_fn: (value: T) => Result<U, E>): Result<U, E> {\n return err as unknown as Result<U, E>;\n },\n andThenAsync<U>(_fn: (value: T) => AsyncResult<U, E>): AsyncResult<U, E> {\n return Promise.resolve(err as unknown as Result<U, E>);\n },\n orElse<F>(fn: (error: E) => Result<T, F>): Result<T, F> {\n return fn(error);\n },\n orElseAsync<F>(fn: (error: E) => AsyncResult<T, F>): AsyncResult<T, F> {\n return fn(error);\n },\n\n inspect(_fn: (value: T) => void): Result<T, E> {\n return err;\n },\n inspectErr(fn: (error: E) => void): Result<T, E> {\n fn(error);\n return err;\n },\n\n eq(other: Result<T, E>): boolean {\n assertResult<T, E>(other);\n return other.isErr() && other.unwrapErr() === error;\n },\n\n asOk(): never {\n throw new TypeError('Result::asOk() called on an `Err` value.');\n },\n asErr<U>(): Result<U, E> {\n return err as unknown as Result<U, E>;\n },\n\n toString(): string {\n return `Err(${ error })`;\n },\n } as const);\n\n return err;\n}\n\n/\n Safely converts a value to a string representation for error messages.\n * Handles cases where `toString()` might throw or values are null/undefined.\n \n @param value - The value to stringify.\n * @returns A safe string representation of the value.\n * @internal\n /\nfunction safeStringify(value: unknown): string {\n try {\n if (value === null) {\n return 'null';\n }\n if (value === undefined) {\n return 'undefined';\n }\n if (typeof value === 'object') {\n return Object.prototype.toString.call(value);\n }\n return String(value);\n } catch {\n return '[unable to stringify]';\n }\n}\n\n/\n Asserts that a given value is an `Option`.\n \n @typeParam T - The expected type of the value contained within the `Option`.\n * @param o - The value to be checked as an `Option`.\n * @throws {TypeError} If the value is not an `Option`.\n * @see isOption\n * @internal\n /\nfunction assertOption<T>(o: unknown): asserts o is Option<T> {\n if (!isOption(o)) {\n throw new TypeError(`Expected an Option, but received: ${ safeStringify(o) }.`);\n }\n}\n\n/\n Asserts that a given value is a `Result`.\n \n @typeParam T - The expected type of the success value contained within the `Result`.\n * @typeParam E - The expected type of the error value contained within the `Result`.\n * @param r - The value to be checked as a `Result`.\n * @throws {TypeError} If the value is not a `Result`.\n * @see isResult\n * @internal\n /\nfunction assertResult<T, E>(r: unknown): asserts r is Result<T, E> {\n if (!isResult(r)) {\n throw new TypeError(`Expected a Result, but received: ${ safeStringify(r) }.`);\n }\n}","/\n @fileoverview\n * Pre-defined Result constants for common return values.\n \n These immutable constants can be reused throughout the application to avoid\n * creating new Result instances for common values like `true`, `false`, `0`, and `void`.\n /\n/ eslint-disable @typescript-eslint/no-explicit-any /\nimport type { Result } from './core.ts';\nimport { Ok } from './prelude.ts';\n\n/\n Result constant for `true`.\n * Can be used anywhere due to immutability.\n * @example\n * ```ts\n * function validate(): Result<boolean, Error> {\n * return RESULT_TRUE;\n * }\n * ```\n /\nexport const RESULT_TRUE: Result<boolean, any> = Ok(true);\n\n/\n Result constant for `false`.\n * Can be used anywhere due to immutability.\n * @example\n * ```ts\n * function validate(): Result<boolean, Error> {\n * return RESULT_FALSE;\n * }\n * ```\n /\nexport const RESULT_FALSE: Result<boolean, any> = Ok(false);\n\n/\n Result constant for `0`.\n * Can be used anywhere due to immutability.\n * @example\n * ```ts\n * function count(): Result<number, Error> {\n * return RESULT_ZERO;\n * }\n * ```\n /\nexport const RESULT_ZERO: Result<number, any> = Ok(0);\n\n/\n Result constant for `void` or `()`.\n * Can be used anywhere due to immutability.\n * @example\n * ```ts\n * function doSomething(): Result<void, Error> {\n * return RESULT_VOID;\n * }\n * ```\n /\nexport const RESULT_VOID: Result<void, any> = Ok();","/\n @fileoverview\n * Extension functions for bridging Promise-based APIs with the Result type.\n \n This module provides utilities for integrating async/await patterns with Result-based error handling.\n /\nimport type { Result } from './core.ts';\nimport { Err, Ok } from './prelude.ts';\n\n/\n Converts a Promise to a Result type, capturing the resolved value in an `Ok`, or the error in an `Err`.\n * This allows for promise-based asynchronous operations to be handled in a way that is more in line with the Result pattern.\n \n Note: JavaScript promises can reject with any value, not just `Error` objects.\n * The error is cast to type `E`, so ensure your error handling accounts for this.\n \n @typeParam T - The type of the value that the promise resolves to.\n * @typeParam E - The type of the error that the promise may reject with, defaults to `Error`.\n * @param p - The promise to convert into a `Result` type.\n * @returns 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>`.\n \n @example\n * ```ts\n * async function example() {\n * const result = await promiseToAsyncResult(fetchData());\n * result.inspect(x => {\n * console.log('Data:', x);\n * }).inspectErr(err => {\n * console.error('Error:', err);\n * });\n * }\n * ```\n \n @example\n * ```ts\n * // With custom error type\n * const result = await promiseToAsyncResult<User, ApiError>(fetchUser(id));\n * ```\n /\nexport async function promiseToAsyncResult<T, E = Error>(p: Promise<T>): Promise<Result<T, E>> {\n try {\n return Ok(await p);\n } catch (err) {\n return Err(err as E);\n }\n}","/\n @fileoverview\n * Internal symbols used to identify `ControlFlow` type variants.\n \n These symbols are used as property keys to distinguish between `Break` and `Continue` variants.\n * They provide a reliable way to identify the variant of a `ControlFlow` instance without\n * relying on method calls or duck typing.\n \n Note: These symbols are internal implementation details and are not exported as part of the public API.\n * Use the `isControlFlow` utility function for type checking instead.\n /\n\n/\n A unique symbol used as a property key to identify the variant of a `ControlFlow` instance.\n \n When accessed on a `ControlFlow`, returns `'Break'` if the ControlFlow signals early exit,\n * or `'Continue'` if it signals to proceed as normal.\n \n This symbol is used internally by the `isControlFlow` utility function to verify\n * that an object is a valid `ControlFlow` instance.\n \n @internal\n /\nexport const ControlFlowKindSymbol = Symbol('ControlFlow kind');\n","/\n @fileoverview\n * Rust-inspired [ControlFlow](https://doc.rust-lang.org/std/ops/enum.ControlFlow.html) for control flow handling.\n \n `ControlFlow` is used to tell an operation whether it should exit early or go on as usual.\n * This is useful for:\n * - Short-circuiting iterators\n * - Signaling early termination in fold-like operations\n * - Implementing custom control flow patterns\n /\n\nimport { Err, None, Ok, Some, type Option, type Result } from '../enum/mod.ts';\nimport { ControlFlowKindSymbol } from './symbols.ts';\n\n/\n Used to tell an operation whether it should exit early or go on as usual.\n \n This is the return type of `try_fold` and similar iterator methods that support\n * short-circuiting. It can also be used in custom control flow scenarios.\n \n @typeParam B - The type of the value returned on `Break` (early exit).\n * @typeParam C - The type of the value returned on `Continue` (default: `void`).\n \n @example\n * ```ts\n * // Using ControlFlow to short-circuit a search\n * function findFirstNegative(numbers: number[]): Option<number> {\n * let result: Option<number> = None;\n \n for (const n of numbers) {\n * const flow = n < 0 ? Break(n) : Continue();\n * if (flow.isBreak()) {\n * result = Some(flow.breakValue().unwrap());\n * break;\n * }\n * }\n \n return result;\n * }\n * ```\n \n @example\n * ```ts\n * // Using ControlFlow in a custom fold operation\n * function tryFold<T, Acc>(\n * arr: T[],\n * init: Acc,\n * f: (acc: Acc, item: T) => ControlFlow<Acc, Acc>\n * ): ControlFlow<Acc, Acc> {\n * let acc = init;\n * for (const item of arr) {\n * const flow = f(acc, item);\n * if (flow.isBreak()) {\n * return flow;\n * }\n * acc = flow.continueValue().unwrap();\n * }\n * return Continue(acc);\n * }\n * ```\n /\nexport interface ControlFlow<B, C = void> {\n // #region Internal properties\n\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'ControlFlow'` so that `Object.prototype.toString.call(flow)` produces `'[object ControlFlow]'`.\n \n This enables reliable type identification even across different execution contexts (e.g., iframes, different module instances).\n \n @example\n * ```ts\n * const x = Break(5);\n * console.log(Object.prototype.toString.call(x)); // '[object ControlFlow]'\n * ```\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'ControlFlow';\n\n /\n A unique symbol property used to identify the variant of this `ControlFlow`.\n * Returns `'Break'` if the ControlFlow signals early exit, or `'Continue'` if it signals to proceed as normal.\n \n This is used internally by the `isControlFlow` utility function to verify that an object is a valid `ControlFlow` instance,\n * and to distinguish between `Break` and `Continue` variants without calling methods.\n \n Note: The symbol itself is not exported as part of the public API.\n * Use the `isControlFlow` utility function or the `isBreak()`/`isContinue()` methods for type checking.\n \n @internal\n /\n readonly [ControlFlowKindSymbol]: 'Break' \| 'Continue';\n\n // #endregion\n\n /\n Returns `true` if this is a `Break` variant.\n \n @example\n * ```ts\n * console.log(Break(3).isBreak()); // true\n * console.log(Continue().isBreak()); // false\n * ```\n /\n isBreak(): boolean;\n\n /\n Returns `true` if this is a `Continue` variant.\n \n @example\n * ```ts\n * console.log(Continue().isContinue()); // true\n * console.log(Break(3).isContinue()); // false\n * ```\n /\n isContinue(): boolean;\n\n /\n Converts the `ControlFlow` into an `Option` which is `Some` if the\n * `ControlFlow` was `Break` and `None` otherwise.\n \n @returns `Some(value)` if `Break`, `None` if `Continue`.\n \n @example\n * ```ts\n * console.log(Break(3).breakValue()); // Some(3)\n * console.log(Continue().breakValue()); // None\n * ```\n /\n breakValue(): Option<B>;\n\n /\n Converts the `ControlFlow` into an `Option` which is `Some` if the\n * `ControlFlow` was `Continue` and `None` otherwise.\n \n @returns `Some(value)` if `Continue`, `None` if `Break`.\n \n @example\n * ```ts\n * console.log(Continue(5).continueValue()); // Some(5)\n * console.log(Break(3).continueValue()); // None\n * ```\n /\n continueValue(): Option<C>;\n\n /\n Maps `ControlFlow<B, C>` to `ControlFlow<T, C>` by applying a function\n * to the break value in case it exists.\n \n @typeParam T - The type of the new break value.\n * @param fn - A function to apply to the break value.\n * @returns A new `ControlFlow` with the mapped break value.\n \n @example\n * ```ts\n * const flow = Break(3);\n * console.log(flow.mapBreak(v => v * 2).breakValue()); // Some(6)\n * ```\n /\n mapBreak<T>(fn: (value: B) => T): ControlFlow<T, C>;\n\n /\n Maps `ControlFlow<B, C>` to `ControlFlow<B, T>` by applying a function\n * to the continue value in case it exists.\n \n @typeParam T - The type of the new continue value.\n * @param fn - A function to apply to the continue value.\n * @returns A new `ControlFlow` with the mapped continue value.\n \n @example\n * ```ts\n * const flow = Continue(5);\n * console.log(flow.mapContinue(v => v * 2).continueValue()); // Some(10)\n * ```\n /\n mapContinue<T>(fn: (value: C) => T): ControlFlow<B, T>;\n\n /\n Converts the `ControlFlow` into a `Result` which is `Ok` if the\n * `ControlFlow` was `Break` and `Err` otherwise.\n \n @returns `Ok(breakValue)` if `Break`, `Err(continueValue)` if `Continue`.\n \n @example\n * ```ts\n * console.log(Break(3).breakOk()); // Ok(3)\n * console.log(Continue('still going').breakOk()); // Err('still going')\n * ```\n /\n breakOk(): Result<B, C>;\n\n /\n Converts the `ControlFlow` into a `Result` which is `Ok` if the\n * `ControlFlow` was `Continue` and `Err` otherwise.\n \n @returns `Ok(continueValue)` if `Continue`, `Err(breakValue)` if `Break`.\n \n @example\n * ```ts\n * console.log(Continue(5).continueOk()); // Ok(5)\n * console.log(Break('stopped').continueOk()); // Err('stopped')\n * ```\n /\n continueOk(): Result<C, B>;\n\n /\n Custom `toString` implementation that uses the `ControlFlow`'s contained value.\n * @example\n * ```ts\n * console.log(Break(5).toString()); // 'Break(5)'\n * console.log(Continue('ok').toString()); // 'Continue(ok)'\n * ```\n /\n toString(): string;\n}\n\n/\n Creates a `Break` variant of `ControlFlow`.\n \n Use this to signal that an operation should exit early with the given value.\n \n @typeParam B - The type of the break value.\n * @typeParam C - The type of the continue value (defaults to `void` when a value is provided).\n * @param value - The value to return on break.\n * @returns A `ControlFlow` in the `Break` state.\n \n @example\n * ```ts\n * const flow = Break('found it');\n * console.log(flow.isBreak()); // true\n * console.log(flow.breakValue().unwrap()); // 'found it'\n \n const voidFlow = Break();\n * console.log(voidFlow.isBreak()); // true\n * ```\n /\nexport function Break<B, C = never>(value: B): ControlFlow<B, C>;\n/\n Creates a `Break` variant of `ControlFlow` with no value.\n * This overload is used when the operation exits early but doesn't produce a meaningful value.\n \n @typeParam C - The type of the continue value (allows type specification when chaining with Continue).\n * @returns A `ControlFlow<void, C>` in the `Break` state.\n \n @example\n * ```ts\n * const voidFlow = Break();\n * console.log(voidFlow.isBreak()); // true\n * console.log(voidFlow.breakValue()); // Some(undefined)\n \n // With explicit type parameter\n * const typedFlow = Break<number>(); // ControlFlow<void, number>\n * ```\n /\nexport function Break<C = never>(): ControlFlow<void, C>;\nexport function Break<B, C>(value?: B): ControlFlow<B, C> {\n const brk: ControlFlow<B, C> = Object.freeze<ControlFlow<B, C>>({\n [Symbol.toStringTag]: 'ControlFlow',\n [ControlFlowKindSymbol]: 'Break',\n\n isBreak(): true {\n return true;\n },\n isContinue(): false {\n return false;\n },\n breakValue(): Option<B> {\n return Some(value as B);\n },\n continueValue(): Option<C> {\n return None;\n },\n mapBreak<T>(fn: (v: B) => T): ControlFlow<T, C> {\n return Break(fn(value as B));\n },\n mapContinue<T>(_fn: (v: C) => T): ControlFlow<B, T> {\n return brk as unknown as ControlFlow<B, T>;\n },\n breakOk(): Result<B, C> {\n return Ok(value as B);\n },\n continueOk(): Result<C, B> {\n return Err(value as B);\n },\n\n toString(): string {\n return `Break(${ value })`;\n },\n } as const);\n\n return brk;\n}\n\n/\n Creates a `Continue` variant of `ControlFlow`.\n \n Use this to signal that an operation should continue as normal.\n \n @typeParam B - The type of the break value (defaults to `void` when a value is provided).\n * @typeParam C - The type of the continue value.\n * @param value - The value to carry forward (optional, defaults to `undefined`).\n * @returns A `ControlFlow` in the `Continue` state.\n \n @example\n * ```ts\n * const flow = Continue();\n * console.log(flow.isContinue()); // true\n \n const flowWithValue = Continue(42);\n * console.log(flowWithValue.continueValue().unwrap()); // 42\n * ```\n /\nexport function Continue<B = never, C = void>(value: C): ControlFlow<B, C>;\n/\n Creates a `Continue` variant of `ControlFlow` with no value.\n * This overload is used when the operation continues but doesn't carry a meaningful value.\n \n @typeParam B - The type of the break value (allows type specification when chaining with Break).\n * @returns A `ControlFlow<B, void>` in the `Continue` state.\n \n @example\n * ```ts\n * const voidFlow = Continue();\n * console.log(voidFlow.isContinue()); // true\n * console.log(voidFlow.continueValue()); // Some(undefined)\n \n // With explicit type parameter\n * const typedFlow = Continue<string>(); // ControlFlow<string, void>\n * ```\n /\nexport function Continue<B = never>(): ControlFlow<B, void>;\nexport function Continue<B, C>(value?: C): ControlFlow<B, C> {\n const cont: ControlFlow<B, C> = Object.freeze<ControlFlow<B, C>>({\n [Symbol.toStringTag]: 'ControlFlow',\n [ControlFlowKindSymbol]: 'Continue',\n\n isBreak(): false {\n return false;\n },\n isContinue(): true {\n return true;\n },\n breakValue(): Option<B> {\n return None;\n },\n continueValue(): Option<C> {\n return Some(value as C);\n },\n mapBreak<T>(_fn: (v: B) => T): ControlFlow<T, C> {\n return cont as unknown as ControlFlow<T, C>;\n },\n mapContinue<T>(fn: (v: C) => T): ControlFlow<B, T> {\n return Continue(fn(value as C));\n },\n breakOk(): Result<B, C> {\n return Err(value as C);\n },\n continueOk(): Result<C, B> {\n return Ok(value as C);\n },\n\n toString(): string {\n return `Continue(${ value })`;\n },\n } as const);\n\n return cont;\n}\n","/\n @fileoverview\n * Type guard utilities for checking if values are `ControlFlow` types.\n \n These functions provide runtime type checking capabilities for the ControlFlow type.\n /\nimport type { ControlFlow } from './control_flow.ts';\nimport { ControlFlowKindSymbol } from './symbols.ts';\n\n/\n Checks if a value is a `ControlFlow`.\n \n @typeParam B - The expected type of the break value contained within the `ControlFlow`.\n * @typeParam C - The expected type of the continue value contained within the `ControlFlow`.\n * @param cf - The value to be checked as a `ControlFlow`.\n * @returns `true` if the value is a `ControlFlow`, otherwise `false`.\n * @example\n * ```ts\n * const x = Break(5);\n * console.log(isControlFlow(x)); // true\n * console.log(isControlFlow(null)); // false\n * console.log(isControlFlow({ isBreak: () => true })); // false\n * ```\n /\nexport function isControlFlow<B, C>(cf: unknown): cf is ControlFlow<B, C> {\n // `Break` and `Continue` must be an object.\n return cf != null && typeof cf === 'object' && ControlFlowKindSymbol in cf;\n}\n","/\n @fileoverview\n * Rust-inspired [LazyLock](https://doc.rust-lang.org/std/sync/struct.LazyLock.html) for lazy initialization.\n \n `Lazy<T>` is a value which is initialized on the first access. Unlike `Once<T>`,\n * the initialization function is provided at construction time.\n /\n\nimport { None, Some, type Option } from '../enum/mod.ts';\n\n/\n A value which is initialized on the first access.\n \n This is a lazily evaluated value. The initialization function is provided\n * at construction time and executed on first access. Subsequent accesses\n * return the cached value.\n \n Unlike `Once<T>`, which allows setting values manually or with different\n * initializers, `Lazy<T>` binds the initializer at creation time.\n \n @typeParam T - The type of the value stored.\n \n @example\n * ```ts\n * const expensive = Lazy(() => {\n * console.log('Computing...');\n * return heavyComputation();\n * });\n \n // Nothing computed yet\n * console.log(expensive.isInitialized()); // false\n \n // First access triggers computation\n * const value = expensive.force(); // logs \"Computing...\"\n \n // Subsequent access returns cached value\n * const same = expensive.force(); // no log, returns cached value\n * ```\n /\nexport interface Lazy<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'Lazy'` so that `Object.prototype.toString.call(lazy)` produces `'[object Lazy]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'Lazy';\n\n /\n Forces the evaluation of this lazy value and returns the result.\n \n If the value has already been initialized, returns the cached value.\n * Otherwise, executes the initialization function, caches the result,\n * and returns it.\n \n @returns The initialized value.\n \n @example\n * ```ts\n * const lazy = Lazy(() => 42);\n * console.log(lazy.force()); // 42\n * console.log(lazy.force()); // 42 (cached)\n * ```\n /\n force(): T;\n\n /\n Gets the value if it has been initialized.\n \n Unlike `force()`, this does not trigger initialization.\n \n @returns `Some(value)` if initialized, `None` otherwise.\n \n @example\n * ```ts\n * const lazy = Lazy(() => 42);\n * console.log(lazy.get()); // None\n \n lazy.force();\n * console.log(lazy.get()); // Some(42)\n * ```\n /\n get(): Option<T>;\n\n /\n Returns `true` if the value has been initialized.\n \n @example\n * ```ts\n * const lazy = Lazy(() => 42);\n * console.log(lazy.isInitialized()); // false\n \n lazy.force();\n * console.log(lazy.isInitialized()); // true\n * ```\n /\n isInitialized(): boolean;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const lazy = Lazy(() => 42);\n * console.log(lazy.toString()); // 'Lazy(<uninitialized>)'\n \n lazy.force();\n * console.log(lazy.toString()); // 'Lazy(42)'\n * ```\n /\n toString(): string;\n}\n\n/\n A value which is initialized asynchronously on the first access.\n \n Similar to `Lazy<T>`, but the initialization function is async.\n * If multiple calls to `force()` occur concurrently before initialization\n * completes, only one initialization will run.\n \n @typeParam T - The type of the value stored.\n \n @example\n * ```ts\n * const db = LazyAsync(async () => {\n * console.log('Connecting...');\n * return await Database.connect(url);\n * });\n \n // Multiple concurrent accesses - only one connection\n * const [db1, db2] = await Promise.all([\n * db.force(),\n * db.force(),\n * ]);\n * // db1 === db2\n * ```\n /\nexport interface LazyAsync<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'LazyAsync'` so that `Object.prototype.toString.call(lazy)` produces `'[object LazyAsync]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'LazyAsync';\n\n /\n Forces the evaluation of this lazy value and returns a promise to the result.\n \n If the value has already been initialized, returns the cached value.\n * If initialization is in progress, waits for it to complete.\n * Otherwise, starts initialization.\n \n @returns A promise that resolves to the initialized value.\n \n @example\n * ```ts\n * const lazy = LazyAsync(async () => {\n * await delay(100);\n * return 42;\n * });\n * console.log(await lazy.force()); // 42\n * ```\n /\n force(): Promise<T>;\n\n /\n Gets the value if it has been initialized.\n \n Unlike `force()`, this does not trigger initialization.\n \n @returns `Some(value)` if initialized, `None` otherwise.\n \n @example\n * ```ts\n * const lazy = LazyAsync(async () => 42);\n * console.log(lazy.get()); // None\n \n await lazy.force();\n * console.log(lazy.get()); // Some(42)\n * ```\n /\n get(): Option<T>;\n\n /\n Returns `true` if the value has been initialized.\n \n Note: Returns `false` while initialization is in progress.\n \n @example\n * ```ts\n * const lazy = LazyAsync(async () => 42);\n * console.log(lazy.isInitialized()); // false\n \n await lazy.force();\n * console.log(lazy.isInitialized()); // true\n * ```\n /\n isInitialized(): boolean;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const lazy = LazyAsync(async () => 42);\n * console.log(lazy.toString()); // 'LazyAsync(<uninitialized>)'\n \n await lazy.force();\n * console.log(lazy.toString()); // 'LazyAsync(42)'\n * ```\n /\n toString(): string;\n}\n\n/\n Creates a new `Lazy<T>` with the given synchronous initialization function.\n \n The function is called at most once, on first access via `force()`.\n \n @typeParam T - The type of value to store.\n * @param fn - The initialization function that produces the value.\n * @returns A new `Lazy<T>` instance.\n \n @example\n * ```ts\n * // Basic usage\n * const lazy = Lazy(() => {\n * console.log('Initializing');\n * return 42;\n * });\n \n console.log(lazy.isInitialized()); // false\n * console.log(lazy.force()); // logs \"Initializing\", returns 42\n * console.log(lazy.isInitialized()); // true\n * console.log(lazy.force()); // returns 42 (no log)\n * ```\n \n @example\n * ```ts\n * // Lazy singleton pattern\n * const logger = Lazy(() => new Logger('app'));\n \n function getLogger(): Logger {\n * return logger.force();\n * }\n * ```\n \n @example\n * ```ts\n * // Expensive computation\n * const fibonacci = Lazy(() => {\n * function fib(n: number): number {\n * if (n <= 1) return n;\n * return fib(n - 1) + fib(n - 2);\n * }\n * return fib(40); // Only computed once\n * });\n * ```\n /\nexport function Lazy<T>(fn: () => T): Lazy<T> {\n let value: T \| undefined;\n let initialized = false;\n\n return Object.freeze<Lazy<T>>({\n [Symbol.toStringTag]: 'Lazy',\n\n force(): T {\n if (!initialized) {\n value = fn();\n initialized = true;\n }\n return value as T;\n },\n\n get(): Option<T> {\n return initialized ? Some(value as T) : None;\n },\n\n isInitialized(): boolean {\n return initialized;\n },\n\n toString(): string {\n return initialized ? `Lazy(${ value })` : 'Lazy(<uninitialized>)';\n },\n } as const);\n}\n\n/\n Creates a new `LazyAsync<T>` with the given async initialization function.\n \n The function is called at most once, on first access via `force()`.\n * Concurrent calls to `force()` before initialization completes will\n * wait for the single initialization to finish.\n \n @typeParam T - The type of value to store.\n * @param fn - The async initialization function that produces the value.\n * @returns A new `LazyAsync<T>` instance.\n \n @example\n * ```ts\n * // Basic usage\n * const lazy = LazyAsync(async () => {\n * const response = await fetch('/api/data');\n * return await response.json();\n * });\n \n const data = await lazy.force();\n * ```\n \n @example\n * ```ts\n * // Database connection singleton\n * const db = LazyAsync(async () => {\n * console.log('Connecting to database...');\n * return await Database.connect(connectionString);\n * });\n \n async function getDb(): Promise<Database> {\n * return await db.force();\n * }\n \n // Multiple calls - connection happens only once\n * const [db1, db2] = await Promise.all([getDb(), getDb()]);\n * console.log(db1 === db2); // true\n * ```\n \n @example\n * ```ts\n * // Configuration loader\n * const config = LazyAsync(async () => {\n * const response = await fetch('/api/config');\n * if (!response.ok) {\n * throw new Error(`Failed to load config: ${response.status}`);\n * }\n * return await response.json() as Config;\n * });\n \n // Used throughout the app\n * async function getApiEndpoint(): Promise<string> {\n * const cfg = await config.force();\n * return cfg.apiEndpoint;\n * }\n * ```\n /\nexport function LazyAsync<T>(fn: () => Promise<T>): LazyAsync<T> {\n let value: T \| undefined;\n let initialized = false;\n let pendingPromise: Promise<T> \| undefined;\n\n return Object.freeze<LazyAsync<T>>({\n [Symbol.toStringTag]: 'LazyAsync',\n\n async force(): Promise<T> {\n if (initialized) {\n return value as T;\n }\n\n if (pendingPromise) {\n return pendingPromise;\n }\n\n pendingPromise = (async () => {\n try {\n const result = await fn();\n value = result;\n initialized = true;\n return result;\n } finally {\n pendingPromise = undefined;\n }\n })();\n\n return pendingPromise;\n },\n\n get(): Option<T> {\n return initialized ? Some(value as T) : None;\n },\n\n isInitialized(): boolean {\n return initialized;\n },\n\n toString(): string {\n return initialized ? `LazyAsync(${ value })` : 'LazyAsync(<uninitialized>)';\n },\n } as const);\n}\n","/\n @fileoverview\n * Rust-inspired [Mutex](https://doc.rust-lang.org/std/sync/struct.Mutex.html) for async mutual exclusion.\n \n In JavaScript's single-threaded environment, `Mutex<T>` is used to serialize\n * async operations, ensuring only one async task accesses the protected resource at a time.\n /\n\nimport { None, Some, type Option } from '../enum/mod.ts';\n\n/\n A guard that provides access to the mutex-protected value.\n \n The guard must be released after use by calling `unlock()`.\n * Failure to unlock will cause deadlock for subsequent lock attempts.\n \n @typeParam T - The type of the protected value.\n /\nexport interface MutexGuard<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'MutexGuard'` so that `Object.prototype.toString.call(guard)` produces `'[object MutexGuard]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'MutexGuard';\n\n /\n The protected value. Can be read or modified while the guard is held.\n /\n value: T;\n\n /\n Releases the lock, allowing other waiters to acquire it.\n \n Must be called when done with the protected value.\n * After calling `unlock()`, the guard should not be used.\n \n @example\n * ```ts\n * const guard = await mutex.lock();\n * try {\n * guard.value.push('item');\n * } finally {\n * guard.unlock();\n * }\n * ```\n /\n unlock(): void;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const guard = await mutex.lock();\n * console.log(guard.toString()); // 'MutexGuard(42)'\n * ```\n /\n toString(): string;\n}\n\n/\n An async mutual exclusion primitive for protecting shared data.\n \n This mutex provides exclusive access to the contained value, ensuring\n * that only one async operation can access it at a time. This is useful\n * for preventing race conditions in async code.\n \n Unlike Rust's Mutex which is for multi-threading, this JavaScript version\n * serializes async operations in the single-threaded event loop.\n \n @typeParam T - The type of the protected value.\n \n @example\n * ```ts\n * const mutex = Mutex({ balance: 100 });\n \n // Safe concurrent updates\n * await Promise.all([\n * mutex.withLock(async (account) => {\n * account.balance -= 50;\n * }),\n * mutex.withLock(async (account) => {\n * account.balance += 30;\n * }),\n * ]);\n * ```\n /\nexport interface Mutex<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'Mutex'` so that `Object.prototype.toString.call(mutex)` produces `'[object Mutex]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'Mutex';\n\n /\n Acquires the lock and executes the callback with the protected value.\n \n This is the recommended way to use the mutex as it automatically\n * releases the lock when the callback completes (or throws).\n \n @typeParam U - The return type of the callback.\n * @param fn - The callback that receives the protected value.\n * @returns A promise that resolves to the callback's return value.\n \n @example\n * ```ts\n * const mutex = Mutex<number[]>([]);\n \n await mutex.withLock(async (arr) => {\n * arr.push(await fetchItem());\n * });\n * ```\n /\n withLock<U>(fn: (value: T) => Promise<U> \| U): Promise<U>;\n\n /\n Acquires the lock and returns a guard for manual control.\n \n Use this when you need more control over when to release the lock.\n * Important: Always release the lock in a `finally` block to prevent deadlocks.\n \n @returns A promise that resolves to a guard providing access to the value.\n \n @example\n * ```ts\n * const guard = await mutex.lock();\n * try {\n * // Long-running operation with the protected value\n * await processData(guard.value);\n * guard.value = transformedData;\n * } finally {\n * guard.unlock();\n * }\n * ```\n /\n lock(): Promise<MutexGuard<T>>;\n\n /\n Attempts to acquire the lock without waiting.\n \n Returns immediately with `Some(guard)` if the lock is available,\n * or `None` if it's currently held by another operation.\n \n @returns `Some(guard)` if acquired, `None` if locked.\n \n @example\n * ```ts\n * const maybeGuard = mutex.tryLock();\n * if (maybeGuard.isSome()) {\n * const guard = maybeGuard.unwrap();\n * try {\n * // Use the value\n * } finally {\n * guard.unlock();\n * }\n * } else {\n * console.log('Mutex is busy');\n * }\n * ```\n /\n tryLock(): Option<MutexGuard<T>>;\n\n /\n Returns `true` if the mutex is currently locked.\n \n Note: This is a snapshot and may change immediately after the call.\n \n @example\n * ```ts\n * console.log(mutex.isLocked()); // false\n * const guard = await mutex.lock();\n * console.log(mutex.isLocked()); // true\n * guard.unlock();\n * console.log(mutex.isLocked()); // false\n * ```\n /\n isLocked(): boolean;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const mutex = Mutex(42);\n * console.log(mutex.toString()); // 'Mutex(<unlocked>)'\n \n const guard = await mutex.lock();\n * console.log(mutex.toString()); // 'Mutex(<locked>)'\n * ```\n /\n toString(): string;\n}\n\n/\n Creates a new `Mutex<T>` protecting the given value.\n \n @typeParam T - The type of the protected value.\n * @param value - The initial value to protect.\n * @returns A new `Mutex<T>` instance.\n \n @example\n * ```ts\n * // Protect a simple value\n * const counter = Mutex(0);\n \n // Protect an object\n * const state = Mutex({ users: [], lastUpdate: Date.now() });\n \n // Protect a resource\n * const db = Mutex(await createConnection());\n * ```\n \n @example\n * ```ts\n * // Database transaction safety\n * const connection = Mutex(db);\n \n async function transfer(from: string, to: string, amount: number) {\n * await connection.withLock(async (conn) => {\n * await conn.beginTransaction();\n * try {\n * const balance = await conn.query('SELECT balance FROM accounts WHERE id = ?', [from]);\n * if (balance < amount) {\n * throw new Error('Insufficient funds');\n * }\n * await conn.query('UPDATE accounts SET balance = balance - ? WHERE id = ?', [amount, from]);\n * await conn.query('UPDATE accounts SET balance = balance + ? WHERE id = ?', [amount, to]);\n * await conn.commit();\n * } catch (e) {\n * await conn.rollback();\n * throw e;\n * }\n * });\n * }\n * ```\n \n @example\n * ```ts\n * // Token refresh with mutex\n * const authState = Mutex({ token: '', expiresAt: 0 });\n \n async function getToken(): Promise<string> {\n * return await authState.withLock(async (state) => {\n * if (Date.now() > state.expiresAt) {\n * const response = await fetch('/api/refresh');\n * const data = await response.json();\n * state.token = data.token;\n * state.expiresAt = Date.now() + data.expiresIn * 1000;\n * }\n * return state.token;\n * });\n * }\n * ```\n \n @example\n * ```ts\n * // File write serialization\n * const fileLock = Mutex('/path/to/file.json');\n \n async function appendToFile(data: string) {\n * await fileLock.withLock(async (path) => {\n * const content = await fs.readFile(path, 'utf-8');\n * const json = JSON.parse(content);\n * json.entries.push(data);\n * await fs.writeFile(path, JSON.stringify(json, null, 2));\n * });\n * }\n * ```\n /\nexport function Mutex<T>(value: T): Mutex<T> {\n let currentValue = value;\n let locked = false;\n const waitQueue: (() => void)[] = [];\n\n function unlock(): void {\n if (waitQueue.length > 0) {\n // Wake up the next waiter\n const next = waitQueue.shift() as () => void;\n next();\n } else {\n locked = false;\n }\n }\n\n function createGuard(): MutexGuard<T> {\n let released = false;\n\n return Object.freeze<MutexGuard<T>>({\n [Symbol.toStringTag]: 'MutexGuard',\n\n get value(): T {\n if (released) {\n throw new Error('MutexGuard has been released.');\n }\n return currentValue;\n },\n set value(newValue: T) {\n if (released) {\n throw new Error('MutexGuard has been released.');\n }\n currentValue = newValue;\n },\n unlock(): void {\n if (released) {\n return; // Already released, ignore\n }\n released = true;\n unlock();\n },\n\n toString(): string {\n if (released) {\n return 'MutexGuard(<released>)';\n }\n return `MutexGuard(${ currentValue })`;\n },\n } as const);\n }\n\n function lock(): Promise<MutexGuard<T>> {\n if (!locked) {\n locked = true;\n return Promise.resolve(createGuard());\n }\n\n return new Promise<MutexGuard<T>>((resolve) => {\n waitQueue.push(() => {\n resolve(createGuard());\n });\n });\n }\n\n return Object.freeze<Mutex<T>>({\n [Symbol.toStringTag]: 'Mutex',\n\n async withLock<U>(fn: (value: T) => Promise<U> \| U): Promise<U> {\n const guard = await lock();\n try {\n return await fn(guard.value);\n } finally {\n guard.unlock();\n }\n },\n\n lock,\n\n tryLock(): Option<MutexGuard<T>> {\n if (locked) {\n return None;\n }\n locked = true;\n return Some(createGuard());\n },\n\n isLocked(): boolean {\n return locked;\n },\n\n toString(): string {\n return locked ? 'Mutex(<locked>)' : 'Mutex(<unlocked>)';\n },\n } as const);\n}\n","/\n @fileoverview\n * Rust-inspired [OnceLock](https://doc.rust-lang.org/std/sync/struct.OnceLock.html) for one-time initialization.\n \n `Once<T>` is a container which can be written to only once. It provides safe access\n * to lazily initialized data, supporting both sync and async initialization.\n /\n\nimport { Err, None, Ok, Some, type Option, type Result } from '../enum/mod.ts';\n\n/\n A container which can be written to only once.\n \n This is useful for lazy initialization of global data or expensive computations\n * that should only happen once. Supports both synchronous and asynchronous\n * initialization functions via separate methods.\n \n @typeParam T - The type of the value stored.\n \n @example\n * ```ts\n * const once = Once<number>();\n \n // Set value (only works once)\n * once.set(42); // Ok(undefined)\n * once.set(100); // Err(100) - already set\n \n // Get value\n * console.log(once.get()); // Some(42)\n * ```\n \n @example\n * ```ts\n * // Sync lazy initialization\n * const config = Once<Config>();\n * const cfg = config.getOrInit(() => loadConfigFromFile());\n * ```\n \n @example\n * ```ts\n * // Async lazy initialization\n * const db = Once<Database>();\n * const conn = await db.getOrInitAsync(async () => Database.connect(url));\n * ```\n /\nexport interface Once<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'Once'` so that `Object.prototype.toString.call(once)` produces `'[object Once]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'Once';\n\n /\n Gets the reference to the underlying value.\n \n @returns `Some(value)` if initialized, `None` otherwise.\n \n @example\n * ```ts\n * const once = Once<number>();\n * console.log(once.get()); // None\n \n once.set(42);\n * console.log(once.get()); // Some(42)\n * ```\n /\n get(): Option<T>;\n\n /\n Sets the contents to `value`.\n \n @param value - The value to store.\n * @returns `Ok(undefined)` if empty, `Err(value)` if already initialized.\n \n @example\n * ```ts\n * const once = Once<number>();\n \n console.log(once.set(42)); // Ok(undefined)\n * console.log(once.set(100)); // Err(100) - value returned back\n * console.log(once.get()); // Some(42)\n * ```\n /\n set(value: T): Result<void, T>;\n\n /\n Gets the contents, initializing it with `fn` if empty.\n \n @param fn - The synchronous initialization function, called only if empty.\n * @returns The stored value.\n \n @example\n * ```ts\n * const once = Once<number>();\n \n const value = once.getOrInit(() => {\n * console.log('Initializing...');\n * return 42;\n * });\n * console.log(value); // 42\n \n // Second call - fn is not called\n * const value2 = once.getOrInit(() => 100);\n * console.log(value2); // 42\n * ```\n /\n getOrInit(fn: () => T): T;\n\n /\n Gets the contents, initializing it with async `fn` if empty.\n \n If multiple calls occur concurrently, only the first one will run the\n * initialization function. Other calls will wait for it to complete.\n \n @param fn - The async initialization function.\n * @returns A promise that resolves to the stored value.\n \n @example\n * ```ts\n * const db = Once<Database>();\n \n // Multiple concurrent calls - only one connection happens\n * const [db1, db2, db3] = await Promise.all([\n * db.getOrInitAsync(() => Database.connect(url)),\n * db.getOrInitAsync(() => Database.connect(url)),\n * db.getOrInitAsync(() => Database.connect(url)),\n * ]);\n * // db1 === db2 === db3\n * ```\n /\n getOrInitAsync(fn: () => Promise<T>): Promise<T>;\n\n /\n Gets the contents, initializing it with `fn` if empty.\n * If `fn` returns `Err`, remains uninitialized.\n \n @typeParam E - The error type.\n * @param fn - The initialization function that may fail.\n * @returns `Ok(value)` if initialized, `Err(error)` if initialization failed.\n \n @example\n * ```ts\n * const once = Once<Config>();\n \n const result = once.getOrTryInit(() => {\n * const config = parseConfig(rawData);\n * return config ? Ok(config) : Err(new Error('Invalid config'));\n * });\n \n if (result.isOk()) {\n * console.log('Config loaded:', result.unwrap());\n * }\n * ```\n /\n getOrTryInit<E>(fn: () => Result<T, E>): Result<T, E>;\n\n /\n Gets the contents, initializing it with async `fn` if empty.\n * If `fn` returns `Err`, remains uninitialized.\n \n If multiple calls occur concurrently, only the first one will run the\n * initialization function. Other calls will wait for it to complete.\n \n @typeParam E - The error type.\n * @param fn - The async initialization function that may fail.\n * @returns A promise that resolves to `Ok(value)` or `Err(error)`.\n \n @example\n * ```ts\n * const config = Once<Config>();\n \n const result = await config.getOrTryInitAsync(async () => {\n * try {\n * const response = await fetch('/api/config');\n * return Ok(await response.json());\n * } catch (e) {\n * return Err(e as Error);\n * }\n * });\n * ```\n /\n getOrTryInitAsync<E>(fn: () => Promise<Result<T, E>>): Promise<Result<T, E>>;\n\n /\n Takes the value out, leaving it uninitialized.\n \n @returns `Some(value)` if initialized, `None` otherwise.\n \n @example\n * ```ts\n * const once = Once<number>();\n * once.set(42);\n \n console.log(once.take()); // Some(42)\n * console.log(once.get()); // None - now empty\n * console.log(once.take()); // None\n * ```\n /\n take(): Option<T>;\n\n /\n Returns `true` if initialized.\n \n @example\n * ```ts\n * const once = Once<number>();\n * console.log(once.isInitialized()); // false\n \n once.set(42);\n * console.log(once.isInitialized()); // true\n * ```\n /\n isInitialized(): boolean;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const once = Once<number>();\n * console.log(once.toString()); // 'Once(<uninitialized>)'\n \n once.set(42);\n * console.log(once.toString()); // 'Once(42)'\n * ```\n /\n toString(): string;\n}\n\n/\n Creates a new empty `Once<T>`.\n \n @typeParam T - The type of value to store.\n * @returns A new uninitialized `Once`.\n \n @example\n * ```ts\n * // Basic usage\n * const once = Once<string>();\n * once.set('hello');\n * console.log(once.get().unwrap()); // 'hello'\n * ```\n \n @example\n * ```ts\n * // Sync lazy singleton pattern\n * const logger = Once<Logger>();\n \n function getLogger(): Logger {\n * return logger.getOrInit(() => new Logger('app'));\n * }\n * ```\n \n @example\n * ```ts\n * // Async lazy initialization\n * const db = Once<Database>();\n \n async function getDb(): Promise<Database> {\n * return await db.getOrInitAsync(async () => {\n * console.log('Connecting to database...');\n * return await Database.connect(connectionString);\n * });\n * }\n \n // Multiple calls - connection happens only once\n * const [db1, db2] = await Promise.all([getDb(), getDb()]);\n * console.log(db1 === db2); // true\n * ```\n \n @example\n * ```ts\n * // Fallible async initialization\n * const config = Once<Config>();\n \n async function loadConfig(): Promise<Result<Config, Error>> {\n * return await config.getOrTryInitAsync(async () => {\n * try {\n * const response = await fetch('/api/config');\n * if (!response.ok) {\n * return Err(new Error(`HTTP ${response.status}`));\n * }\n * return Ok(await response.json());\n * } catch (e) {\n * return Err(e as Error);\n * }\n * });\n * }\n * ```\n */\nexport function Once<T>(): Once<T> {\n let value: T \| undefined;\n let initialized = false;\n let pendingPromise: Promise<T> \| undefined;\n\n return Object.freeze<Once<T>>({\n [Symbol.toStringTag]: 'Once',\n\n get(): Option<T> {\n return initialized ? Some(value as T) : None;\n },\n\n set(newValue: T): Result<void, T> {\n if (initialized) {\n return Err(newValue);\n }\n value = newValue;\n initialized = true;\n return Ok(undefined);\n },\n\n getOrInit(fn: () => T): T {\n if (!initialized) {\n value = fn();\n initialized = true;\n }\n return value as T;\n },\n\n async getOrInitAsync(fn: () => Promise<T>): Promise<T> {\n if (initialized) {\n return value as T;\n }\n\n // If already initializing, wait for the pending promise\n if (pendingPromise) {\n return pendingPromise;\n }\n\n pendingPromise = (async () => {\n try {\n const result = await fn();\n value = result;\n initialized = true;\n return result;\n } finally {\n pendingPromise = undefined;\n }\n })();\n\n return pendingPromise;\n },\n\n getOrTryInit<E>(fn: () => Result<T, E>): Result<T, E> {\n if (initialized) {\n return Ok(value as T);\n }\n\n const result = fn();\n if (result.isOk()) {\n value = result.unwrap();\n initialized = true;\n }\n return result;\n },\n\n async getOrTryInitAsync<E>(fn: () => Promise<Result<T, E>>): Promise<Result<T, E>> {\n if (initialized) {\n return Ok(value as T);\n }\n\n // If already initializing, wait for it\n if (pendingPromise) {\n try {\n await pendingPromise;\n // pendingPromise only resolves on success, so initialized must be true\n return Ok(value as T);\n } catch {\n // Previous initialization failed via Err result, let this call try again\n }\n }\n\n // Create a new pending promise for this initialization attempt\n pendingPromise = (async () => {\n const result = await fn();\n if (result.isOk()) {\n value = result.unwrap();\n initialized = true;\n return value;\n }\n // If Err, throw to signal failure (we'll catch and return the result)\n throw result;\n })();\n\n try {\n const resultValue = await pendingPromise;\n return Ok(resultValue as T);\n } catch (errResult) {\n return errResult as Result<T, E>;\n } finally {\n pendingPromise = undefined;\n }\n },\n\n take(): Option<T> {\n if (!initialized) {\n return None;\n }\n const taken = value as T;\n value = undefined;\n initialized = false;\n return Some(taken);\n },\n\n isInitialized(): boolean {\n return initialized;\n },\n\n toString(): string {\n return initialized ? `Once(${ value })` : 'Once(<uninitialized>)';\n },\n } as const);\n}\n"],"names":[],"mappings":"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"}
1	+ {"version":3,"file":"main.mjs","sources":["../src/enum/symbols.ts","../src/enum/utils.ts","../src/enum/prelude.ts","../src/enum/constants.ts","../src/enum/extensions.ts","../src/ops/symbols.ts","../src/ops/control_flow.ts","../src/ops/utils.ts","../src/sync/lazy.ts","../src/sync/mutex.ts","../src/sync/once.ts"],"sourcesContent":["/*\n @fileoverview\n * Internal symbols used to identify `Option` and `Result` type variants.\n \n These symbols are used as property keys to distinguish between `Some`/`None` and `Ok`/`Err` variants.\n * They provide a reliable way to identify the variant of an `Option` or `Result` instance without\n * relying on method calls or duck typing.\n \n Note: These symbols are internal implementation details and are not exported as part of the public API.\n * Use the `isOption` and `isResult` utility functions for type checking instead.\n /\n\n/\n A unique symbol used as a property key to identify the variant of an `Option` instance.\n \n When accessed on an `Option`, returns `'Some'` if the Option contains a value,\n * or `'None'` if it represents the absence of a value.\n \n This symbol is used internally by the `isOption` utility function to verify\n * that an object is a valid `Option` instance.\n \n @internal\n /\nexport const OptionKindSymbol = Symbol('Option kind');\n\n/\n A unique symbol used as a property key to identify the variant of a `Result` instance.\n \n When accessed on a `Result`, returns `'Ok'` if the Result represents success,\n * or `'Err'` if it represents failure.\n \n This symbol is used internally by the `isResult` utility function to verify\n * that an object is a valid `Result` instance.\n \n @internal\n /\nexport const ResultKindSymbol = Symbol('Result kind');\n","/\n @fileoverview\n * Type guard utilities for checking if values are `Option` or `Result` types.\n \n These functions provide runtime type checking capabilities for the Option and Result types.\n /\nimport type { Option, Result } from './core.ts';\nimport { OptionKindSymbol, ResultKindSymbol } from './symbols.ts';\n\n/\n Checks if a value is an `Option`.\n \n @typeParam T - The expected type of the value contained within the `Option`.\n * @param o - The value to be checked as an `Option`.\n * @returns `true` if the value is an `Option`, otherwise `false`.\n * @example\n * ```ts\n * const x = Some(5);\n * console.log(isOption(x)); // true\n * console.log(isOption(null)); // false\n * console.log(isOption({ value: 5 })); // false\n * ```\n /\nexport function isOption<T>(o: unknown): o is Option<T> {\n // `Some` and `None` must be an object.\n return o != null && typeof o === 'object' && OptionKindSymbol in o;\n}\n\n/\n Checks if a value is a `Result`.\n \n @typeParam T - The expected type of the success value contained within the `Result`.\n * @typeParam E - The expected type of the error value contained within the `Result`.\n * @param r - The value to be checked as a `Result`.\n * @returns `true` if the value is a `Result`, otherwise `false`.\n * @example\n * ```ts\n * const x = Ok(5);\n * console.log(isResult(x)); // true\n * console.log(isResult(null)); // false\n * console.log(isResult({ value: 5 })); // false\n * ```\n /\nexport function isResult<T, E>(r: unknown): r is Result<T, E> {\n // `Ok` and `Err` must be an object.\n return r != null && typeof r === 'object' && ResultKindSymbol in r;\n}","/\n @fileoverview\n * Constructors and factory functions for creating `Option` and `Result` types.\n \n This module exports:\n * - `Some<T>(value)` - Creates an Option containing a value\n * - `None` - Constant representing absence of value\n * - `Ok<T, E>(value)` - Creates a successful Result\n * - `Err<T, E>(error)` - Creates a failed Result\n * - `None` interface - Type overrides for better type inference\n /\nimport type { AsyncOption, AsyncResult, Option, Result } from './core.ts';\nimport { OptionKindSymbol, ResultKindSymbol } from './symbols.ts';\nimport { isOption, isResult } from './utils.ts';\n\n/\n Represents the absence of a value, as a specialized `Option` type.\n * The type parameter is set to `never` because `None` does not hold a value.\n /\nexport interface None extends Option<never> {\n /\n When using `None` alone, the following overrides can make type inference more accurate.\n /\n\n readonly [OptionKindSymbol]: 'None';\n\n isSome(): false;\n isNone(): true;\n isSomeAnd(predicate: (value: never) => boolean): false;\n isSomeAndAsync(predicate: (value: never) => Promise<boolean>): Promise<false>;\n isNoneOr(predicate: (value: never) => boolean): true;\n isNoneOrAsync(predicate: (value: never) => Promise<boolean>): Promise<true>;\n\n expect(msg: string): never;\n unwrap(): never;\n unwrapOr<T>(defaultValue: T): T;\n unwrapOrElse<T>(fn: () => T): T;\n unwrapOrElseAsync<T>(fn: () => Promise<T>): Promise<T>;\n\n okOr<E>(error: E): Result<never, E>;\n okOrElse<E>(err: () => E): Result<never, E>;\n transpose(): Result<this, never>;\n\n filter(predicate: (value: never) => boolean): this;\n flatten(): this;\n map<U>(fn: (value: never) => U): this;\n mapOr<U>(defaultValue: U, fn: (value: never) => U): U;\n mapOrElse<U>(defaultFn: () => U, fn: (value: never) => U): U;\n\n zip<U>(other: Option<U>): this;\n zipWith<U, R>(other: Option<U>, fn: (value: never, otherValue: U) => R): this;\n unzip(): [this, this];\n\n and<U>(other: Option<U>): this;\n andThen<U>(fn: (value: never) => Option<U>): this;\n andThenAsync<U>(fn: (value: never) => AsyncOption<U>): Promise<this>;\n or<T>(other: Option<T>): Option<T>;\n orElse<T>(fn: () => Option<T>): Option<T>;\n orElseAsync<T>(fn: () => AsyncOption<T>): AsyncOption<T>;\n xor<T>(other: Option<T>): Option<T>;\n\n inspect(fn: (value: never) => void): this;\n\n eq<T>(other: Option<T>): boolean;\n}\n\n/\n Creates an `Option<T>` representing the presence of a value.\n * This function is typically used to construct an `Option` that contains a value, indicating that the operation yielding the value was successful.\n \n @typeParam T - The type of the value to be wrapped in a `Some`.\n * @param value - The value to wrap as a `Some` option.\n * @returns An `Option<T>` that contains the provided value, representing the `Some` case.\n \n @example\n * ```ts\n * const maybeValue = Some(1); // Option<number> with a value\n * if (maybeValue.isSome()) {\n * console.log(maybeValue.unwrap()); // Outputs: 1\n * }\n * ```\n /\nexport function Some<T>(value: T): Option<T> {\n const some: Option<T> = Object.freeze<Option<T>>({\n [Symbol.toStringTag]: 'Option',\n [OptionKindSymbol]: 'Some',\n\n isSome(): true {\n return true;\n },\n isNone(): false {\n return false;\n },\n isSomeAnd(predicate: (value: T) => boolean): boolean {\n return predicate(value);\n },\n isSomeAndAsync(predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n return predicate(value);\n },\n isNoneOr(predicate: (value: T) => boolean): boolean {\n return predicate(value);\n },\n isNoneOrAsync(predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n return predicate(value);\n },\n\n expect(_msg: string): T {\n return value;\n },\n unwrap(): T {\n return value;\n },\n unwrapOr(_defaultValue: T): T {\n return value;\n },\n unwrapOrElse(_fn: () => T): T {\n return value;\n },\n unwrapOrElseAsync(_fn: () => Promise<T>): Promise<T> {\n return Promise.resolve(value);\n },\n\n okOr<E>(_error: E): Result<T, E> {\n return Ok(value);\n },\n okOrElse<E>(_err: () => E): Result<T, E> {\n return Ok(value);\n },\n transpose<U, E>(): Result<Option<U>, E> {\n assertResult<U, E>(value);\n return value.isOk() ? Ok(Some(value.unwrap())) : Err(value.unwrapErr());\n },\n\n filter(predicate: (value: T) => boolean): Option<T> {\n return predicate(value) ? some : None;\n },\n flatten<U>(): Option<U> {\n assertOption<U>(value);\n return value;\n },\n map<U>(fn: (value: T) => U): Option<U> {\n return Some(fn(value));\n },\n\n mapOr<U>(_defaultValue: U, fn: (value: T) => U): U {\n return fn(value);\n },\n mapOrElse<U>(_defaultFn: () => U, fn: (value: T) => U): U {\n return fn(value);\n },\n\n zip<U>(other: Option<U>): Option<[T, U]> {\n assertOption<U>(other);\n return other.isSome() ? Some([value, other.unwrap()]) : None;\n },\n zipWith<U, R>(other: Option<U>, fn: (value: T, otherValue: U) => R): Option<R> {\n assertOption<U>(other);\n return other.isSome() ? Some(fn(value, other.unwrap())) : None;\n },\n unzip<U, R>(): [Option<U>, Option<R>] {\n const tuple = value as [U, R];\n\n if (!Array.isArray(tuple) \|\| tuple.length !== 2) {\n throw new TypeError(`Option::unzip() requires a 2-element tuple, received ${ Array.isArray(tuple) ? `array with ${ tuple.length } elements` : typeof tuple }.`);\n }\n\n const [a, b] = tuple;\n return [Some(a), Some(b)];\n },\n\n and<U>(other: Option<U>): Option<U> {\n assertOption<U>(other);\n return other;\n },\n andThen<U>(fn: (value: T) => Option<U>): Option<U> {\n return fn(value);\n },\n andThenAsync<U>(fn: (value: T) => AsyncOption<U>): AsyncOption<U> {\n return fn(value);\n },\n or(_other: Option<T>): Option<T> {\n return some;\n },\n orElse(_fn: () => Option<T>): Option<T> {\n return some;\n },\n orElseAsync(_fn: () => AsyncOption<T>): AsyncOption<T> {\n return Promise.resolve(some);\n },\n xor(other: Option<T>): Option<T> {\n assertOption<T>(other);\n return other.isSome() ? None : some;\n },\n\n inspect(fn: (value: T) => void): Option<T> {\n fn(value);\n return some;\n },\n\n eq(other: Option<T>): boolean {\n assertOption<T>(other);\n return other.isSome() && other.unwrap() === value;\n },\n\n toString(): string {\n return `Some(${ value })`;\n },\n } as const);\n\n return some;\n}\n\n/\n A constant representing the `None` case of an `Option`, indicating the absence of a value.\n * This constant is frozen to ensure it is immutable and cannot be altered, preserving the integrity of `None` throughout the application.\n \n @example\n * ```ts\n * // Use None to represent absence of a value\n * function findUser(id: number): Option<User> {\n * const user = users.find(u => u.id === id);\n * return user ? Some(user) : None;\n * }\n \n // None is a singleton, so you can compare by reference\n * const result = findUser(999);\n * if (result === None) {\n * console.log('User not found');\n * }\n \n // Use with Option methods\n * const name = None.unwrapOr('Anonymous'); // 'Anonymous'\n * ```\n /\nexport const None: None = Object.freeze<None>({\n [Symbol.toStringTag]: 'Option',\n [OptionKindSymbol]: 'None',\n\n isSome(): false {\n return false;\n },\n isNone(): true {\n return true;\n },\n isSomeAnd(_predicate: (value: never) => boolean): false {\n return false;\n },\n isSomeAndAsync(_predicate: (value: never) => Promise<boolean>): Promise<false> {\n return Promise.resolve(false);\n },\n isNoneOr(_predicate: (value: never) => boolean): true {\n return true;\n },\n isNoneOrAsync(_predicate: (value: never) => Promise<boolean>): Promise<true> {\n return Promise.resolve(true);\n },\n\n expect(msg: string): never {\n throw new TypeError(msg);\n },\n unwrap(): never {\n throw new TypeError('Option::unwrap() called on a `None` value.');\n },\n unwrapOr<T>(defaultValue: T): T {\n return defaultValue;\n },\n unwrapOrElse<T>(fn: () => T): T {\n return fn();\n },\n unwrapOrElseAsync<T>(fn: () => Promise<T>): Promise<T> {\n return fn();\n },\n\n okOr<E>(error: E): Result<never, E> {\n return Err(error);\n },\n okOrElse<E>(err: () => E): Result<never, E> {\n return Err(err());\n },\n transpose(): Result<None, never> {\n return Ok(None);\n },\n\n filter(_predicate: (value: never) => boolean): None {\n return None;\n },\n flatten(): None {\n return None;\n },\n map<U>(_fn: (value: never) => U): None {\n return None;\n },\n\n mapOr<U>(defaultValue: U, _fn: (value: never) => U): U {\n return defaultValue;\n },\n mapOrElse<U>(defaultFn: () => U, _fn: (value: never) => U): U {\n return defaultFn();\n },\n\n zip<U>(_other: Option<U>): None {\n return None;\n },\n zipWith<U, R>(_other: Option<U>, _fn: (value: never, otherValue: U) => R): None {\n return None;\n },\n unzip(): [None, None] {\n return [None, None];\n },\n\n and<U>(_other: Option<U>): None {\n return None;\n },\n andThen<U>(_fn: (value: never) => Option<U>): None {\n return None;\n },\n andThenAsync<U>(_fn: (value: never) => AsyncOption<U>): Promise<None> {\n return Promise.resolve(None);\n },\n or<T>(other: Option<T>): Option<T> {\n assertOption<T>(other);\n return other;\n },\n orElse<T>(fn: () => Option<T>): Option<T> {\n return fn();\n },\n orElseAsync<T>(fn: () => AsyncOption<T>): AsyncOption<T> {\n return fn();\n },\n xor<T>(other: Option<T>): Option<T> {\n assertOption<T>(other);\n return other.isSome() ? other : None;\n },\n\n inspect(_fn: (value: never) => void): None {\n return None;\n },\n\n eq<T>(other: Option<T>): boolean {\n assertOption<T>(other);\n return other === None;\n },\n\n toString(): string {\n return 'None';\n },\n} as const);\n\n/\n Creates a `Result<T, E>` representing a successful outcome containing a value.\n * This function is used to construct a `Result` that signifies the operation was successful by containing the value `T`.\n \n @typeParam T - The type of the value to be contained in the `Ok` result.\n * @typeParam E - The type of the error that the result could potentially contain (not used in this case).\n * @param value - The value to wrap as an `Ok` result.\n * @returns A `Result<T, E>` that contains the provided value, representing the `Ok` case.\n \n @example\n * ```ts\n * const goodResult = Ok<number, Error>(1); // Result<number, Error> with a value\n * if (goodResult.isOk()) {\n * console.log(goodResult.unwrap()); // Outputs: 1\n * }\n * ```\n /\nexport function Ok<T, E = never>(value: T): Result<T, E>;\n/\n Creates a `Result<void, E>` representing a successful outcome with no value.\n * This overload is used when the operation succeeds but doesn't produce a meaningful value.\n \n In Rust, this would be `Ok(())` using the unit type `()`.\n * Since JavaScript doesn't have a unit type, we use `void` instead.\n \n @typeParam E - The type of the error that the result could potentially contain.\n * @returns A `Result<void, E>` representing a successful operation with no value.\n \n @example\n * ```ts\n * function saveToFile(path: string): Result<void, Error> {\n * try {\n * fs.writeFileSync(path, data);\n * return Ok(); // Success with no return value\n * } catch (e) {\n * return Err(e as Error);\n * }\n * }\n \n const result = saveToFile('/tmp/data.txt');\n * if (result.isOk()) {\n * console.log('File saved successfully');\n * }\n * ```\n /\nexport function Ok<E = never>(): Result<void, E>;\nexport function Ok<T, E>(value?: T): Result<T, E> {\n const ok: Result<T, E> = Object.freeze<Result<T, E>>({\n [Symbol.toStringTag]: 'Result',\n [ResultKindSymbol]: 'Ok',\n\n isOk(): true {\n return true;\n },\n isErr(): false {\n return false;\n },\n isOkAnd(predicate: (value: T) => boolean): boolean {\n return predicate(value as T);\n },\n isOkAndAsync(predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n return predicate(value as T);\n },\n isErrAnd(_predicate: (error: E) => boolean): false {\n return false;\n },\n isErrAndAsync(_predicate: (error: E) => Promise<boolean>): Promise<false> {\n return Promise.resolve(false);\n },\n\n expect(_msg: string): T {\n return value as T;\n },\n unwrap(): T {\n return value as T;\n },\n unwrapOr(_defaultValue: T): T {\n return value as T;\n },\n unwrapOrElse(_fn: (error: E) => T): T {\n return value as T;\n },\n unwrapOrElseAsync(_fn: (error: E) => Promise<T>): Promise<T> {\n return Promise.resolve(value as T);\n },\n\n expectErr(msg: string): never {\n throw new TypeError(`${ msg }: ${ value }`);\n },\n unwrapErr(): never {\n throw new TypeError('Result::unwrapErr() called on an `Ok` value.');\n },\n\n ok(): Option<T> {\n return Some(value as T);\n },\n err(): None {\n return None;\n },\n transpose<U>(): Option<Result<U, E>> {\n assertOption<U>(value);\n return value.isSome() ? Some(Ok(value.unwrap())) : None;\n },\n\n map<U>(fn: (value: T) => U): Result<U, E> {\n return Ok(fn(value as T));\n },\n mapErr<F>(_fn: (error: E) => F): Result<T, F> {\n return Ok(value as T);\n },\n mapOr<U>(_defaultValue: U, fn: (value: T) => U): U {\n return fn(value as T);\n },\n mapOrElse<U>(_defaultFn: (error: E) => U, fn: (value: T) => U): U {\n return fn(value as T);\n },\n flatten<U>(): Result<U, E> {\n assertResult<U, E>(value);\n return value;\n },\n\n and<U>(other: Result<U, E>): Result<U, E> {\n assertResult<T, E>(other);\n return other;\n },\n or<F>(_other: Result<T, F>): Result<T, F> {\n return ok as unknown as Result<T, F>;\n },\n andThen<U>(fn: (value: T) => Result<U, E>): Result<U, E> {\n return fn(value as T);\n },\n andThenAsync<U>(fn: (value: T) => AsyncResult<U, E>): AsyncResult<U, E> {\n return fn(value as T);\n },\n orElse<F>(_fn: (error: E) => Result<T, F>): Result<T, F> {\n return ok as unknown as Result<T, F>;\n },\n orElseAsync<F>(_fn: (error: E) => AsyncResult<T, F>): AsyncResult<T, F> {\n return Promise.resolve(ok as unknown as Result<T, F>);\n },\n\n inspect(fn: (value: T) => void): Result<T, E> {\n fn(value as T);\n return ok;\n },\n inspectErr(_fn: (error: E) => void): Result<T, E> {\n return ok;\n },\n\n eq(other: Result<T, E>): boolean {\n assertResult<T, E>(other);\n return other.isOk() && other.unwrap() === value;\n },\n\n asOk<F>(): Result<T, F> {\n return ok as unknown as Result<T, F>;\n },\n asErr(): never {\n throw new TypeError('Result::asErr() called on an `Ok` value.');\n },\n\n toString(): string {\n return `Ok(${ value })`;\n },\n } as const);\n\n return ok;\n}\n\n/\n Creates a `Result<T, E>` representing a failed outcome containing an error.\n * This function is used to construct a `Result` that signifies the operation failed by containing the error `E`.\n \n @typeParam T - The type of the value that the result could potentially contain (not used in this case).\n * @typeParam E - The type of the error to be wrapped in the `Err` result.\n * @param error - The error to wrap as an `Err` result.\n * @returns A `Result<T, E>` that contains the provided error, representing the `Err` case.\n \n @example\n * ```ts\n * const badResult = Err<number, Error>(new Error('Something went wrong'));\n * if (badResult.isErr()) {\n * console.error(badResult.unwrapErr()); // Outputs: Error: Something went wrong\n * }\n * ```\n /\nexport function Err<T = never, E = unknown>(error: E): Result<T, E> {\n const err: Result<T, E> = Object.freeze<Result<T, E>>({\n [Symbol.toStringTag]: 'Result',\n [ResultKindSymbol]: 'Err',\n\n isOk(): false {\n return false;\n },\n isErr(): true {\n return true;\n },\n isOkAnd(_predicate: (value: T) => boolean): false {\n return false;\n },\n isOkAndAsync(_predicate: (value: T) => Promise<boolean>): Promise<boolean> {\n return Promise.resolve(false);\n },\n isErrAnd(predicate: (error: E) => boolean): boolean {\n return predicate(error);\n },\n isErrAndAsync(predicate: (error: E) => Promise<boolean>): Promise<boolean> {\n return predicate(error);\n },\n\n expect(msg: string): never {\n throw new TypeError(`${ msg }: ${ error }`);\n },\n unwrap(): never {\n throw new TypeError('Result::unwrap() called on an `Err` value.');\n },\n unwrapOr(defaultValue: T): T {\n return defaultValue;\n },\n unwrapOrElse(fn: (error: E) => T): T {\n return fn(error);\n },\n unwrapOrElseAsync(fn: (error: E) => Promise<T>): Promise<T> {\n return fn(error);\n },\n\n expectErr(_msg: string): E {\n return error;\n },\n unwrapErr(): E {\n return error;\n },\n\n ok(): None {\n return None;\n },\n err(): Option<E> {\n return Some(error);\n },\n transpose<U>(): Option<Result<U, E>> {\n return Some(err as unknown as Result<U, E>);\n },\n\n map<U>(_fn: (value: T) => U): Result<U, E> {\n return Err(error);\n },\n mapErr<F>(fn: (error: E) => F): Result<T, F> {\n return Err(fn(error));\n },\n mapOr<U>(defaultValue: U, _fn: (value: T) => U): U {\n return defaultValue;\n },\n mapOrElse<U>(defaultFn: (error: E) => U, _fn: (value: T) => U): U {\n return defaultFn(error);\n },\n flatten<U>(): Result<U, E> {\n return err as unknown as Result<U, E>;\n },\n\n and<U>(_other: Result<U, E>): Result<U, E> {\n return err as unknown as Result<U, E>;\n },\n or<F>(other: Result<T, F>): Result<T, F> {\n assertResult<T, E>(other);\n return other;\n },\n andThen<U>(_fn: (value: T) => Result<U, E>): Result<U, E> {\n return err as unknown as Result<U, E>;\n },\n andThenAsync<U>(_fn: (value: T) => AsyncResult<U, E>): AsyncResult<U, E> {\n return Promise.resolve(err as unknown as Result<U, E>);\n },\n orElse<F>(fn: (error: E) => Result<T, F>): Result<T, F> {\n return fn(error);\n },\n orElseAsync<F>(fn: (error: E) => AsyncResult<T, F>): AsyncResult<T, F> {\n return fn(error);\n },\n\n inspect(_fn: (value: T) => void): Result<T, E> {\n return err;\n },\n inspectErr(fn: (error: E) => void): Result<T, E> {\n fn(error);\n return err;\n },\n\n eq(other: Result<T, E>): boolean {\n assertResult<T, E>(other);\n return other.isErr() && other.unwrapErr() === error;\n },\n\n asOk(): never {\n throw new TypeError('Result::asOk() called on an `Err` value.');\n },\n asErr<U>(): Result<U, E> {\n return err as unknown as Result<U, E>;\n },\n\n toString(): string {\n return `Err(${ error })`;\n },\n } as const);\n\n return err;\n}\n\n/\n Safely converts a value to a string representation for error messages.\n * Handles cases where `toString()` might throw or values are null/undefined.\n \n @param value - The value to stringify.\n * @returns A safe string representation of the value.\n /\nfunction safeStringify(value: unknown): string {\n try {\n if (value === null) {\n return 'null';\n }\n if (value === undefined) {\n return 'undefined';\n }\n if (typeof value === 'object') {\n return Object.prototype.toString.call(value);\n }\n return String(value);\n } catch {\n return '[unable to stringify]';\n }\n}\n\n/\n Asserts that a given value is an `Option`.\n \n @typeParam T - The expected type of the value contained within the `Option`.\n * @param o - The value to be checked as an `Option`.\n * @throws {TypeError} If the value is not an `Option`.\n * @see isOption\n /\nfunction assertOption<T>(o: unknown): asserts o is Option<T> {\n if (!isOption(o)) {\n throw new TypeError(`Expected an Option, but received: ${ safeStringify(o) }.`);\n }\n}\n\n/\n Asserts that a given value is a `Result`.\n \n @typeParam T - The expected type of the success value contained within the `Result`.\n * @typeParam E - The expected type of the error value contained within the `Result`.\n * @param r - The value to be checked as a `Result`.\n * @throws {TypeError} If the value is not a `Result`.\n * @see isResult\n /\nfunction assertResult<T, E>(r: unknown): asserts r is Result<T, E> {\n if (!isResult(r)) {\n throw new TypeError(`Expected a Result, but received: ${ safeStringify(r) }.`);\n }\n}","/\n @fileoverview\n * Pre-defined Result constants for common return values.\n \n These immutable constants can be reused throughout the application to avoid\n * creating new Result instances for common values like `true`, `false`, `0`, and `void`.\n /\n/ eslint-disable @typescript-eslint/no-explicit-any /\nimport type { Result } from './core.ts';\nimport { Ok } from './prelude.ts';\n\n/\n Result constant for `true`.\n * Can be used anywhere due to immutability.\n * @example\n * ```ts\n * function validate(): Result<boolean, Error> {\n * return RESULT_TRUE;\n * }\n * ```\n /\nexport const RESULT_TRUE: Result<boolean, any> = Ok(true);\n\n/\n Result constant for `false`.\n * Can be used anywhere due to immutability.\n * @example\n * ```ts\n * function validate(): Result<boolean, Error> {\n * return RESULT_FALSE;\n * }\n * ```\n /\nexport const RESULT_FALSE: Result<boolean, any> = Ok(false);\n\n/\n Result constant for `0`.\n * Can be used anywhere due to immutability.\n * @example\n * ```ts\n * function count(): Result<number, Error> {\n * return RESULT_ZERO;\n * }\n * ```\n /\nexport const RESULT_ZERO: Result<number, any> = Ok(0);\n\n/\n Result constant for `void` or `()`.\n * Can be used anywhere due to immutability.\n * @example\n * ```ts\n * function doSomething(): Result<void, Error> {\n * return RESULT_VOID;\n * }\n * ```\n /\nexport const RESULT_VOID: Result<void, any> = Ok();","/\n @fileoverview\n * Extension functions for bridging Promise-based APIs with the Result type.\n \n This module provides utilities for integrating async/await patterns with Result-based error handling.\n /\nimport type { AsyncResult } from './core.ts';\nimport { Err, Ok } from './prelude.ts';\n\n/\n Converts a Promise to a Result type, capturing the resolved value in an `Ok`, or the error in an `Err`.\n * This allows for promise-based asynchronous operations to be handled in a way that is more in line with the Result pattern.\n \n Note: JavaScript promises can reject with any value, not just `Error` objects.\n * The error is cast to type `E`, so ensure your error handling accounts for this.\n \n @typeParam T - The type of the value that the promise resolves to.\n * @typeParam E - The type of the error that the promise may reject with, defaults to `Error`.\n * @param p - The promise or promise-like object to convert into a `Result` type.\n * @returns 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>`.\n \n @example\n * ```ts\n * async function example() {\n * const result = await promiseToAsyncResult(fetchData());\n * result.inspect(x => {\n * console.log('Data:', x);\n * }).inspectErr(err => {\n * console.error('Error:', err);\n * });\n * }\n * ```\n \n @example\n * ```ts\n * // With custom error type\n * const result = await promiseToAsyncResult<User, ApiError>(fetchUser(id));\n * ```\n /\nexport async function promiseToAsyncResult<T, E = Error>(p: PromiseLike<T>): AsyncResult<T, E> {\n try {\n return Ok(await p);\n } catch (err) {\n return Err(err as E);\n }\n}","/\n @fileoverview\n * Internal symbols used to identify `ControlFlow` type variants.\n \n These symbols are used as property keys to distinguish between `Break` and `Continue` variants.\n * They provide a reliable way to identify the variant of a `ControlFlow` instance without\n * relying on method calls or duck typing.\n \n Note: These symbols are internal implementation details and are not exported as part of the public API.\n * Use the `isControlFlow` utility function for type checking instead.\n /\n\n/\n A unique symbol used as a property key to identify the variant of a `ControlFlow` instance.\n \n When accessed on a `ControlFlow`, returns `'Break'` if the ControlFlow signals early exit,\n * or `'Continue'` if it signals to proceed as normal.\n \n This symbol is used internally by the `isControlFlow` utility function to verify\n * that an object is a valid `ControlFlow` instance.\n \n @internal\n /\nexport const ControlFlowKindSymbol = Symbol('ControlFlow kind');\n","/\n @fileoverview\n * Rust-inspired [ControlFlow](https://doc.rust-lang.org/std/ops/enum.ControlFlow.html) for control flow handling.\n \n `ControlFlow` is used to tell an operation whether it should exit early or go on as usual.\n * This is useful for:\n * - Short-circuiting iterators\n * - Signaling early termination in fold-like operations\n * - Implementing custom control flow patterns\n /\n\nimport { Err, None, Ok, Some, type Option, type Result } from '../enum/mod.ts';\nimport { ControlFlowKindSymbol } from './symbols.ts';\n\n/\n Used to tell an operation whether it should exit early or go on as usual.\n \n This is the return type of `try_fold` and similar iterator methods that support\n * short-circuiting. It can also be used in custom control flow scenarios.\n \n @typeParam B - The type of the value returned on `Break` (early exit).\n * @typeParam C - The type of the value returned on `Continue` (default: `void`).\n \n @example\n * ```ts\n * // Using ControlFlow to short-circuit a search\n * function findFirstNegative(numbers: number[]): Option<number> {\n * let result: Option<number> = None;\n \n for (const n of numbers) {\n * const flow = n < 0 ? Break(n) : Continue();\n * if (flow.isBreak()) {\n * result = Some(flow.breakValue().unwrap());\n * break;\n * }\n * }\n \n return result;\n * }\n * ```\n \n @example\n * ```ts\n * // Using ControlFlow in a custom fold operation\n * function tryFold<T, Acc>(\n * arr: T[],\n * init: Acc,\n * f: (acc: Acc, item: T) => ControlFlow<Acc, Acc>\n * ): ControlFlow<Acc, Acc> {\n * let acc = init;\n * for (const item of arr) {\n * const flow = f(acc, item);\n * if (flow.isBreak()) {\n * return flow;\n * }\n * acc = flow.continueValue().unwrap();\n * }\n * return Continue(acc);\n * }\n * ```\n /\nexport interface ControlFlow<B, C = void> {\n // #region Internal properties\n\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'ControlFlow'` so that `Object.prototype.toString.call(flow)` produces `'[object ControlFlow]'`.\n \n This enables reliable type identification even across different execution contexts (e.g., iframes, different module instances).\n \n @example\n * ```ts\n * const x = Break(5);\n * console.log(Object.prototype.toString.call(x)); // '[object ControlFlow]'\n * ```\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'ControlFlow';\n\n /\n A unique symbol property used to identify the variant of this `ControlFlow`.\n * Returns `'Break'` if the ControlFlow signals early exit, or `'Continue'` if it signals to proceed as normal.\n \n This is used internally by the `isControlFlow` utility function to verify that an object is a valid `ControlFlow` instance,\n * and to distinguish between `Break` and `Continue` variants without calling methods.\n \n Note: The symbol itself is not exported as part of the public API.\n * Use the `isControlFlow` utility function or the `isBreak()`/`isContinue()` methods for type checking.\n \n @internal\n /\n readonly [ControlFlowKindSymbol]: 'Break' \| 'Continue';\n\n // #endregion\n\n /\n Returns `true` if this is a `Break` variant.\n \n @example\n * ```ts\n * console.log(Break(3).isBreak()); // true\n * console.log(Continue().isBreak()); // false\n * ```\n /\n isBreak(): boolean;\n\n /\n Returns `true` if this is a `Continue` variant.\n \n @example\n * ```ts\n * console.log(Continue().isContinue()); // true\n * console.log(Break(3).isContinue()); // false\n * ```\n /\n isContinue(): boolean;\n\n /\n Converts the `ControlFlow` into an `Option` which is `Some` if the\n * `ControlFlow` was `Break` and `None` otherwise.\n \n @returns `Some(value)` if `Break`, `None` if `Continue`.\n \n @example\n * ```ts\n * console.log(Break(3).breakValue()); // Some(3)\n * console.log(Continue().breakValue()); // None\n * ```\n /\n breakValue(): Option<B>;\n\n /\n Converts the `ControlFlow` into an `Option` which is `Some` if the\n * `ControlFlow` was `Continue` and `None` otherwise.\n \n @returns `Some(value)` if `Continue`, `None` if `Break`.\n \n @example\n * ```ts\n * console.log(Continue(5).continueValue()); // Some(5)\n * console.log(Break(3).continueValue()); // None\n * ```\n /\n continueValue(): Option<C>;\n\n /\n Maps `ControlFlow<B, C>` to `ControlFlow<T, C>` by applying a function\n * to the break value in case it exists.\n \n @typeParam T - The type of the new break value.\n * @param fn - A function to apply to the break value.\n * @returns A new `ControlFlow` with the mapped break value.\n \n @example\n * ```ts\n * const flow = Break(3);\n * console.log(flow.mapBreak(v => v * 2).breakValue()); // Some(6)\n * ```\n /\n mapBreak<T>(fn: (value: B) => T): ControlFlow<T, C>;\n\n /\n Maps `ControlFlow<B, C>` to `ControlFlow<B, T>` by applying a function\n * to the continue value in case it exists.\n \n @typeParam T - The type of the new continue value.\n * @param fn - A function to apply to the continue value.\n * @returns A new `ControlFlow` with the mapped continue value.\n \n @example\n * ```ts\n * const flow = Continue(5);\n * console.log(flow.mapContinue(v => v * 2).continueValue()); // Some(10)\n * ```\n /\n mapContinue<T>(fn: (value: C) => T): ControlFlow<B, T>;\n\n /\n Converts the `ControlFlow` into a `Result` which is `Ok` if the\n * `ControlFlow` was `Break` and `Err` otherwise.\n \n @returns `Ok(breakValue)` if `Break`, `Err(continueValue)` if `Continue`.\n \n @example\n * ```ts\n * console.log(Break(3).breakOk()); // Ok(3)\n * console.log(Continue('still going').breakOk()); // Err('still going')\n * ```\n /\n breakOk(): Result<B, C>;\n\n /\n Converts the `ControlFlow` into a `Result` which is `Ok` if the\n * `ControlFlow` was `Continue` and `Err` otherwise.\n \n @returns `Ok(continueValue)` if `Continue`, `Err(breakValue)` if `Break`.\n \n @example\n * ```ts\n * console.log(Continue(5).continueOk()); // Ok(5)\n * console.log(Break('stopped').continueOk()); // Err('stopped')\n * ```\n /\n continueOk(): Result<C, B>;\n\n /\n Custom `toString` implementation that uses the `ControlFlow`'s contained value.\n * @example\n * ```ts\n * console.log(Break(5).toString()); // 'Break(5)'\n * console.log(Continue('ok').toString()); // 'Continue(ok)'\n * ```\n /\n toString(): string;\n}\n\n/\n Creates a `Break` variant of `ControlFlow`.\n \n Use this to signal that an operation should exit early with the given value.\n \n @typeParam B - The type of the break value.\n * @typeParam C - The type of the continue value (defaults to `void` when a value is provided).\n * @param value - The value to return on break.\n * @returns A `ControlFlow` in the `Break` state.\n \n @example\n * ```ts\n * const flow = Break('found it');\n * console.log(flow.isBreak()); // true\n * console.log(flow.breakValue().unwrap()); // 'found it'\n \n const voidFlow = Break();\n * console.log(voidFlow.isBreak()); // true\n * ```\n /\nexport function Break<B, C = never>(value: B): ControlFlow<B, C>;\n/\n Creates a `Break` variant of `ControlFlow` with no value.\n * This overload is used when the operation exits early but doesn't produce a meaningful value.\n \n @typeParam C - The type of the continue value (allows type specification when chaining with Continue).\n * @returns A `ControlFlow<void, C>` in the `Break` state.\n \n @example\n * ```ts\n * const voidFlow = Break();\n * console.log(voidFlow.isBreak()); // true\n * console.log(voidFlow.breakValue()); // Some(undefined)\n \n // With explicit type parameter\n * const typedFlow = Break<number>(); // ControlFlow<void, number>\n * ```\n /\nexport function Break<C = never>(): ControlFlow<void, C>;\nexport function Break<B, C>(value?: B): ControlFlow<B, C> {\n const brk: ControlFlow<B, C> = Object.freeze<ControlFlow<B, C>>({\n [Symbol.toStringTag]: 'ControlFlow',\n [ControlFlowKindSymbol]: 'Break',\n\n isBreak(): true {\n return true;\n },\n isContinue(): false {\n return false;\n },\n breakValue(): Option<B> {\n return Some(value as B);\n },\n continueValue(): Option<C> {\n return None;\n },\n mapBreak<T>(fn: (v: B) => T): ControlFlow<T, C> {\n return Break(fn(value as B));\n },\n mapContinue<T>(_fn: (v: C) => T): ControlFlow<B, T> {\n return brk as unknown as ControlFlow<B, T>;\n },\n breakOk(): Result<B, C> {\n return Ok(value as B);\n },\n continueOk(): Result<C, B> {\n return Err(value as B);\n },\n\n toString(): string {\n return `Break(${ value })`;\n },\n } as const);\n\n return brk;\n}\n\n/\n Creates a `Continue` variant of `ControlFlow`.\n \n Use this to signal that an operation should continue as normal.\n \n @typeParam B - The type of the break value (defaults to `void` when a value is provided).\n * @typeParam C - The type of the continue value.\n * @param value - The value to carry forward (optional, defaults to `undefined`).\n * @returns A `ControlFlow` in the `Continue` state.\n \n @example\n * ```ts\n * const flow = Continue();\n * console.log(flow.isContinue()); // true\n \n const flowWithValue = Continue(42);\n * console.log(flowWithValue.continueValue().unwrap()); // 42\n * ```\n /\nexport function Continue<B = never, C = void>(value: C): ControlFlow<B, C>;\n/\n Creates a `Continue` variant of `ControlFlow` with no value.\n * This overload is used when the operation continues but doesn't carry a meaningful value.\n \n @typeParam B - The type of the break value (allows type specification when chaining with Break).\n * @returns A `ControlFlow<B, void>` in the `Continue` state.\n \n @example\n * ```ts\n * const voidFlow = Continue();\n * console.log(voidFlow.isContinue()); // true\n * console.log(voidFlow.continueValue()); // Some(undefined)\n \n // With explicit type parameter\n * const typedFlow = Continue<string>(); // ControlFlow<string, void>\n * ```\n /\nexport function Continue<B = never>(): ControlFlow<B, void>;\nexport function Continue<B, C>(value?: C): ControlFlow<B, C> {\n const cont: ControlFlow<B, C> = Object.freeze<ControlFlow<B, C>>({\n [Symbol.toStringTag]: 'ControlFlow',\n [ControlFlowKindSymbol]: 'Continue',\n\n isBreak(): false {\n return false;\n },\n isContinue(): true {\n return true;\n },\n breakValue(): Option<B> {\n return None;\n },\n continueValue(): Option<C> {\n return Some(value as C);\n },\n mapBreak<T>(_fn: (v: B) => T): ControlFlow<T, C> {\n return cont as unknown as ControlFlow<T, C>;\n },\n mapContinue<T>(fn: (v: C) => T): ControlFlow<B, T> {\n return Continue(fn(value as C));\n },\n breakOk(): Result<B, C> {\n return Err(value as C);\n },\n continueOk(): Result<C, B> {\n return Ok(value as C);\n },\n\n toString(): string {\n return `Continue(${ value })`;\n },\n } as const);\n\n return cont;\n}\n","/\n @fileoverview\n * Type guard utilities for checking if values are `ControlFlow` types.\n \n These functions provide runtime type checking capabilities for the ControlFlow type.\n /\nimport type { ControlFlow } from './control_flow.ts';\nimport { ControlFlowKindSymbol } from './symbols.ts';\n\n/\n Checks if a value is a `ControlFlow`.\n \n @typeParam B - The expected type of the break value contained within the `ControlFlow`.\n * @typeParam C - The expected type of the continue value contained within the `ControlFlow`.\n * @param cf - The value to be checked as a `ControlFlow`.\n * @returns `true` if the value is a `ControlFlow`, otherwise `false`.\n * @example\n * ```ts\n * const x = Break(5);\n * console.log(isControlFlow(x)); // true\n * console.log(isControlFlow(null)); // false\n * console.log(isControlFlow({ isBreak: () => true })); // false\n * ```\n /\nexport function isControlFlow<B, C>(cf: unknown): cf is ControlFlow<B, C> {\n // `Break` and `Continue` must be an object.\n return cf != null && typeof cf === 'object' && ControlFlowKindSymbol in cf;\n}\n","/\n @fileoverview\n * Rust-inspired [LazyLock](https://doc.rust-lang.org/std/sync/struct.LazyLock.html) for lazy initialization.\n \n `Lazy<T>` is a value which is initialized on the first access. Unlike `Once<T>`,\n * the initialization function is provided at construction time.\n /\n\nimport { None, Some, type Option } from '../enum/mod.ts';\n\n/\n A value which is initialized on the first access.\n \n This is a lazily evaluated value. The initialization function is provided\n * at construction time and executed on first access. Subsequent accesses\n * return the cached value.\n \n Unlike `Once<T>`, which allows setting values manually or with different\n * initializers, `Lazy<T>` binds the initializer at creation time.\n \n @typeParam T - The type of the value stored.\n \n @example\n * ```ts\n * const expensive = Lazy(() => {\n * console.log('Computing...');\n * return heavyComputation();\n * });\n \n // Nothing computed yet\n * console.log(expensive.isInitialized()); // false\n \n // First access triggers computation\n * const value = expensive.force(); // logs \"Computing...\"\n \n // Subsequent access returns cached value\n * const same = expensive.force(); // no log, returns cached value\n * ```\n /\nexport interface Lazy<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'Lazy'` so that `Object.prototype.toString.call(lazy)` produces `'[object Lazy]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'Lazy';\n\n /\n Forces the evaluation of this lazy value and returns the result.\n \n If the value has already been initialized, returns the cached value.\n * Otherwise, executes the initialization function, caches the result,\n * and returns it.\n \n @returns The initialized value.\n \n @example\n * ```ts\n * const lazy = Lazy(() => 42);\n * console.log(lazy.force()); // 42\n * console.log(lazy.force()); // 42 (cached)\n * ```\n /\n force(): T;\n\n /\n Gets the value if it has been initialized.\n \n Unlike `force()`, this does not trigger initialization.\n \n @returns `Some(value)` if initialized, `None` otherwise.\n \n @example\n * ```ts\n * const lazy = Lazy(() => 42);\n * console.log(lazy.get()); // None\n \n lazy.force();\n * console.log(lazy.get()); // Some(42)\n * ```\n /\n get(): Option<T>;\n\n /\n Returns `true` if the value has been initialized.\n \n @example\n * ```ts\n * const lazy = Lazy(() => 42);\n * console.log(lazy.isInitialized()); // false\n \n lazy.force();\n * console.log(lazy.isInitialized()); // true\n * ```\n /\n isInitialized(): boolean;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const lazy = Lazy(() => 42);\n * console.log(lazy.toString()); // 'Lazy(<uninitialized>)'\n \n lazy.force();\n * console.log(lazy.toString()); // 'Lazy(42)'\n * ```\n /\n toString(): string;\n}\n\n/\n A value which is initialized asynchronously on the first access.\n \n Similar to `Lazy<T>`, but the initialization function is async.\n * If multiple calls to `force()` occur concurrently before initialization\n * completes, only one initialization will run.\n \n @typeParam T - The type of the value stored.\n \n @example\n * ```ts\n * const db = LazyAsync(async () => {\n * console.log('Connecting...');\n * return await Database.connect(url);\n * });\n \n // Multiple concurrent accesses - only one connection\n * const [db1, db2] = await Promise.all([\n * db.force(),\n * db.force(),\n * ]);\n * // db1 === db2\n * ```\n /\nexport interface LazyAsync<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'LazyAsync'` so that `Object.prototype.toString.call(lazy)` produces `'[object LazyAsync]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'LazyAsync';\n\n /\n Forces the evaluation of this lazy value and returns a promise to the result.\n \n If the value has already been initialized, returns the cached value.\n * If initialization is in progress, waits for it to complete.\n * Otherwise, starts initialization.\n \n @returns A promise that resolves to the initialized value.\n \n @example\n * ```ts\n * const lazy = LazyAsync(async () => {\n * await delay(100);\n * return 42;\n * });\n * console.log(await lazy.force()); // 42\n * ```\n /\n force(): Promise<T>;\n\n /\n Gets the value if it has been initialized.\n \n Unlike `force()`, this does not trigger initialization.\n \n @returns `Some(value)` if initialized, `None` otherwise.\n \n @example\n * ```ts\n * const lazy = LazyAsync(async () => 42);\n * console.log(lazy.get()); // None\n \n await lazy.force();\n * console.log(lazy.get()); // Some(42)\n * ```\n /\n get(): Option<T>;\n\n /\n Returns `true` if the value has been initialized.\n \n Note: Returns `false` while initialization is in progress.\n \n @example\n * ```ts\n * const lazy = LazyAsync(async () => 42);\n * console.log(lazy.isInitialized()); // false\n \n await lazy.force();\n * console.log(lazy.isInitialized()); // true\n * ```\n /\n isInitialized(): boolean;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const lazy = LazyAsync(async () => 42);\n * console.log(lazy.toString()); // 'LazyAsync(<uninitialized>)'\n \n await lazy.force();\n * console.log(lazy.toString()); // 'LazyAsync(42)'\n * ```\n /\n toString(): string;\n}\n\n/\n Creates a new `Lazy<T>` with the given synchronous initialization function.\n \n The function is called at most once, on first access via `force()`.\n \n @typeParam T - The type of value to store.\n * @param fn - The initialization function that produces the value.\n * @returns A new `Lazy<T>` instance.\n \n @example\n * ```ts\n * // Basic usage\n * const lazy = Lazy(() => {\n * console.log('Initializing');\n * return 42;\n * });\n \n console.log(lazy.isInitialized()); // false\n * console.log(lazy.force()); // logs \"Initializing\", returns 42\n * console.log(lazy.isInitialized()); // true\n * console.log(lazy.force()); // returns 42 (no log)\n * ```\n \n @example\n * ```ts\n * // Lazy singleton pattern\n * const logger = Lazy(() => new Logger('app'));\n \n function getLogger(): Logger {\n * return logger.force();\n * }\n * ```\n \n @example\n * ```ts\n * // Expensive computation\n * const fibonacci = Lazy(() => {\n * function fib(n: number): number {\n * if (n <= 1) return n;\n * return fib(n - 1) + fib(n - 2);\n * }\n * return fib(40); // Only computed once\n * });\n * ```\n /\nexport function Lazy<T>(fn: () => T): Lazy<T> {\n let value: T \| undefined;\n let initialized = false;\n\n return Object.freeze<Lazy<T>>({\n [Symbol.toStringTag]: 'Lazy',\n\n force(): T {\n if (!initialized) {\n value = fn();\n initialized = true;\n }\n return value as T;\n },\n\n get(): Option<T> {\n return initialized ? Some(value as T) : None;\n },\n\n isInitialized(): boolean {\n return initialized;\n },\n\n toString(): string {\n return initialized ? `Lazy(${ value })` : 'Lazy(<uninitialized>)';\n },\n } as const);\n}\n\n/\n Creates a new `LazyAsync<T>` with the given async initialization function.\n \n The function is called at most once, on first access via `force()`.\n * Concurrent calls to `force()` before initialization completes will\n * wait for the single initialization to finish.\n \n @typeParam T - The type of value to store.\n * @param fn - The async initialization function that produces the value.\n * @returns A new `LazyAsync<T>` instance.\n \n @example\n * ```ts\n * // Basic usage\n * const lazy = LazyAsync(async () => {\n * const response = await fetch('/api/data');\n * return await response.json();\n * });\n \n const data = await lazy.force();\n * ```\n \n @example\n * ```ts\n * // Database connection singleton\n * const db = LazyAsync(async () => {\n * console.log('Connecting to database...');\n * return await Database.connect(connectionString);\n * });\n \n async function getDb(): Promise<Database> {\n * return await db.force();\n * }\n \n // Multiple calls - connection happens only once\n * const [db1, db2] = await Promise.all([getDb(), getDb()]);\n * console.log(db1 === db2); // true\n * ```\n \n @example\n * ```ts\n * // Configuration loader\n * const config = LazyAsync(async () => {\n * const response = await fetch('/api/config');\n * if (!response.ok) {\n * throw new Error(`Failed to load config: ${response.status}`);\n * }\n * return await response.json() as Config;\n * });\n \n // Used throughout the app\n * async function getApiEndpoint(): Promise<string> {\n * const cfg = await config.force();\n * return cfg.apiEndpoint;\n * }\n * ```\n /\nexport function LazyAsync<T>(fn: () => Promise<T>): LazyAsync<T> {\n let value: T \| undefined;\n let initialized = false;\n let pendingPromise: Promise<T> \| undefined;\n\n return Object.freeze<LazyAsync<T>>({\n [Symbol.toStringTag]: 'LazyAsync',\n\n async force(): Promise<T> {\n if (initialized) {\n return value as T;\n }\n\n if (pendingPromise) {\n return pendingPromise;\n }\n\n pendingPromise = (async () => {\n try {\n const result = await fn();\n value = result;\n initialized = true;\n return result;\n } finally {\n pendingPromise = undefined;\n }\n })();\n\n return pendingPromise;\n },\n\n get(): Option<T> {\n return initialized ? Some(value as T) : None;\n },\n\n isInitialized(): boolean {\n return initialized;\n },\n\n toString(): string {\n return initialized ? `LazyAsync(${ value })` : 'LazyAsync(<uninitialized>)';\n },\n } as const);\n}\n","/\n @fileoverview\n * Rust-inspired [Mutex](https://doc.rust-lang.org/std/sync/struct.Mutex.html) for async mutual exclusion.\n \n In JavaScript's single-threaded environment, `Mutex<T>` is used to serialize\n * async operations, ensuring only one async task accesses the protected resource at a time.\n /\n\nimport { None, Some, type Option } from '../enum/mod.ts';\n\n/\n A guard that provides access to the mutex-protected value.\n \n The guard must be released after use by calling `unlock()`.\n * Failure to unlock will cause deadlock for subsequent lock attempts.\n \n @typeParam T - The type of the protected value.\n /\nexport interface MutexGuard<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'MutexGuard'` so that `Object.prototype.toString.call(guard)` produces `'[object MutexGuard]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'MutexGuard';\n\n /\n The protected value. Can be read or modified while the guard is held.\n /\n value: T;\n\n /\n Releases the lock, allowing other waiters to acquire it.\n \n Must be called when done with the protected value.\n * After calling `unlock()`, the guard should not be used.\n \n @example\n * ```ts\n * const guard = await mutex.lock();\n * try {\n * guard.value.push('item');\n * } finally {\n * guard.unlock();\n * }\n * ```\n /\n unlock(): void;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const guard = await mutex.lock();\n * console.log(guard.toString()); // 'MutexGuard(42)'\n * ```\n /\n toString(): string;\n}\n\n/\n An async mutual exclusion primitive for protecting shared data.\n \n This mutex provides exclusive access to the contained value, ensuring\n * that only one async operation can access it at a time. This is useful\n * for preventing race conditions in async code.\n \n Unlike Rust's Mutex which is for multi-threading, this JavaScript version\n * serializes async operations in the single-threaded event loop.\n \n @typeParam T - The type of the protected value.\n \n @example\n * ```ts\n * const mutex = Mutex({ balance: 100 });\n \n // Safe concurrent updates\n * await Promise.all([\n * mutex.withLock(async (account) => {\n * account.balance -= 50;\n * }),\n * mutex.withLock(async (account) => {\n * account.balance += 30;\n * }),\n * ]);\n * ```\n /\nexport interface Mutex<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'Mutex'` so that `Object.prototype.toString.call(mutex)` produces `'[object Mutex]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'Mutex';\n\n /\n Acquires the lock and executes the callback with the protected value.\n \n This is the recommended way to use the mutex as it automatically\n * releases the lock when the callback completes (or throws).\n \n @typeParam U - The return type of the callback.\n * @param fn - The callback that receives the protected value.\n * @returns A promise that resolves to the callback's return value.\n \n @example\n * ```ts\n * const mutex = Mutex<number[]>([]);\n \n await mutex.withLock(async (arr) => {\n * arr.push(await fetchItem());\n * });\n * ```\n /\n withLock<U>(fn: (value: T) => Promise<U> \| U): Promise<U>;\n\n /\n Acquires the lock and returns a guard for manual control.\n \n Use this when you need more control over when to release the lock.\n * Important: Always release the lock in a `finally` block to prevent deadlocks.\n \n @returns A promise that resolves to a guard providing access to the value.\n \n @example\n * ```ts\n * const guard = await mutex.lock();\n * try {\n * // Long-running operation with the protected value\n * await processData(guard.value);\n * guard.value = transformedData;\n * } finally {\n * guard.unlock();\n * }\n * ```\n /\n lock(): Promise<MutexGuard<T>>;\n\n /\n Attempts to acquire the lock without waiting.\n \n Returns immediately with `Some(guard)` if the lock is available,\n * or `None` if it's currently held by another operation.\n \n @returns `Some(guard)` if acquired, `None` if locked.\n \n @example\n * ```ts\n * const maybeGuard = mutex.tryLock();\n * if (maybeGuard.isSome()) {\n * const guard = maybeGuard.unwrap();\n * try {\n * // Use the value\n * } finally {\n * guard.unlock();\n * }\n * } else {\n * console.log('Mutex is busy');\n * }\n * ```\n /\n tryLock(): Option<MutexGuard<T>>;\n\n /\n Returns `true` if the mutex is currently locked.\n \n Note: This is a snapshot and may change immediately after the call.\n \n @example\n * ```ts\n * console.log(mutex.isLocked()); // false\n * const guard = await mutex.lock();\n * console.log(mutex.isLocked()); // true\n * guard.unlock();\n * console.log(mutex.isLocked()); // false\n * ```\n /\n isLocked(): boolean;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const mutex = Mutex(42);\n * console.log(mutex.toString()); // 'Mutex(<unlocked>)'\n \n const guard = await mutex.lock();\n * console.log(mutex.toString()); // 'Mutex(<locked>)'\n * ```\n /\n toString(): string;\n}\n\n/\n Creates a new `Mutex<T>` protecting the given value.\n \n @typeParam T - The type of the protected value.\n * @param value - The initial value to protect.\n * @returns A new `Mutex<T>` instance.\n \n @example\n * ```ts\n * // Protect a simple value\n * const counter = Mutex(0);\n \n // Protect an object\n * const state = Mutex({ users: [], lastUpdate: Date.now() });\n \n // Protect a resource\n * const db = Mutex(await createConnection());\n * ```\n \n @example\n * ```ts\n * // Database transaction safety\n * const connection = Mutex(db);\n \n async function transfer(from: string, to: string, amount: number) {\n * await connection.withLock(async (conn) => {\n * await conn.beginTransaction();\n * try {\n * const balance = await conn.query('SELECT balance FROM accounts WHERE id = ?', [from]);\n * if (balance < amount) {\n * throw new Error('Insufficient funds');\n * }\n * await conn.query('UPDATE accounts SET balance = balance - ? WHERE id = ?', [amount, from]);\n * await conn.query('UPDATE accounts SET balance = balance + ? WHERE id = ?', [amount, to]);\n * await conn.commit();\n * } catch (e) {\n * await conn.rollback();\n * throw e;\n * }\n * });\n * }\n * ```\n \n @example\n * ```ts\n * // Token refresh with mutex\n * const authState = Mutex({ token: '', expiresAt: 0 });\n \n async function getToken(): Promise<string> {\n * return await authState.withLock(async (state) => {\n * if (Date.now() > state.expiresAt) {\n * const response = await fetch('/api/refresh');\n * const data = await response.json();\n * state.token = data.token;\n * state.expiresAt = Date.now() + data.expiresIn * 1000;\n * }\n * return state.token;\n * });\n * }\n * ```\n \n @example\n * ```ts\n * // File write serialization\n * const fileLock = Mutex('/path/to/file.json');\n \n async function appendToFile(data: string) {\n * await fileLock.withLock(async (path) => {\n * const content = await fs.readFile(path, 'utf-8');\n * const json = JSON.parse(content);\n * json.entries.push(data);\n * await fs.writeFile(path, JSON.stringify(json, null, 2));\n * });\n * }\n * ```\n /\nexport function Mutex<T>(value: T): Mutex<T> {\n let currentValue = value;\n let locked = false;\n const waitQueue: (() => void)[] = [];\n\n function unlock(): void {\n if (waitQueue.length > 0) {\n // Wake up the next waiter\n const next = waitQueue.shift() as () => void;\n next();\n } else {\n locked = false;\n }\n }\n\n function createGuard(): MutexGuard<T> {\n let released = false;\n\n return Object.freeze<MutexGuard<T>>({\n [Symbol.toStringTag]: 'MutexGuard',\n\n get value(): T {\n if (released) {\n throw new Error('MutexGuard has been released.');\n }\n return currentValue;\n },\n set value(newValue: T) {\n if (released) {\n throw new Error('MutexGuard has been released.');\n }\n currentValue = newValue;\n },\n unlock(): void {\n if (released) {\n return; // Already released, ignore\n }\n released = true;\n unlock();\n },\n\n toString(): string {\n if (released) {\n return 'MutexGuard(<released>)';\n }\n return `MutexGuard(${ currentValue })`;\n },\n } as const);\n }\n\n function lock(): Promise<MutexGuard<T>> {\n if (!locked) {\n locked = true;\n return Promise.resolve(createGuard());\n }\n\n return new Promise<MutexGuard<T>>((resolve) => {\n waitQueue.push(() => {\n resolve(createGuard());\n });\n });\n }\n\n return Object.freeze<Mutex<T>>({\n [Symbol.toStringTag]: 'Mutex',\n\n async withLock<U>(fn: (value: T) => Promise<U> \| U): Promise<U> {\n const guard = await lock();\n try {\n return await fn(guard.value);\n } finally {\n guard.unlock();\n }\n },\n\n lock,\n\n tryLock(): Option<MutexGuard<T>> {\n if (locked) {\n return None;\n }\n locked = true;\n return Some(createGuard());\n },\n\n isLocked(): boolean {\n return locked;\n },\n\n toString(): string {\n return locked ? 'Mutex(<locked>)' : 'Mutex(<unlocked>)';\n },\n } as const);\n}\n","/\n @fileoverview\n * Rust-inspired [OnceLock](https://doc.rust-lang.org/std/sync/struct.OnceLock.html) for one-time initialization.\n \n `Once<T>` is a container which can be written to only once. It provides safe access\n * to lazily initialized data, supporting both sync and async initialization.\n /\n\nimport { Err, None, Ok, Some, type AsyncResult, type Option, type Result } from '../enum/mod.ts';\n\n/\n A container which can be written to only once.\n \n This is useful for lazy initialization of global data or expensive computations\n * that should only happen once. Supports both synchronous and asynchronous\n * initialization functions via separate methods.\n \n @typeParam T - The type of the value stored.\n \n @example\n * ```ts\n * const once = Once<number>();\n \n // Set value (only works once)\n * once.set(42); // Ok(undefined)\n * once.set(100); // Err(100) - already set\n \n // Get value\n * console.log(once.get()); // Some(42)\n * ```\n \n @example\n * ```ts\n * // Sync lazy initialization\n * const config = Once<Config>();\n * const cfg = config.getOrInit(() => loadConfigFromFile());\n * ```\n \n @example\n * ```ts\n * // Async lazy initialization\n * const db = Once<Database>();\n * const conn = await db.getOrInitAsync(async () => Database.connect(url));\n * ```\n /\nexport interface Once<T> {\n /\n The well-known symbol `Symbol.toStringTag` used by `Object.prototype.toString()`.\n * Returns `'Once'` so that `Object.prototype.toString.call(once)` produces `'[object Once]'`.\n \n @internal\n /\n readonly [Symbol.toStringTag]: 'Once';\n\n /\n Gets the reference to the underlying value.\n \n @returns `Some(value)` if initialized, `None` otherwise.\n \n @example\n * ```ts\n * const once = Once<number>();\n * console.log(once.get()); // None\n \n once.set(42);\n * console.log(once.get()); // Some(42)\n * ```\n /\n get(): Option<T>;\n\n /\n Sets the contents to `value`.\n \n @param value - The value to store.\n * @returns `Ok(undefined)` if empty, `Err(value)` if already initialized.\n \n @example\n * ```ts\n * const once = Once<number>();\n \n console.log(once.set(42)); // Ok(undefined)\n * console.log(once.set(100)); // Err(100) - value returned back\n * console.log(once.get()); // Some(42)\n * ```\n /\n set(value: T): Result<void, T>;\n\n /\n Gets the contents, initializing it with `fn` if empty.\n \n @param fn - The synchronous initialization function, called only if empty.\n * @returns The stored value.\n \n @example\n * ```ts\n * const once = Once<number>();\n \n const value = once.getOrInit(() => {\n * console.log('Initializing...');\n * return 42;\n * });\n * console.log(value); // 42\n \n // Second call - fn is not called\n * const value2 = once.getOrInit(() => 100);\n * console.log(value2); // 42\n * ```\n /\n getOrInit(fn: () => T): T;\n\n /\n Gets the contents, initializing it with async `fn` if empty.\n \n If multiple calls occur concurrently, only the first one will run the\n * initialization function. Other calls will wait for it to complete.\n \n @param fn - The async initialization function.\n * @returns A promise that resolves to the stored value.\n \n @example\n * ```ts\n * const db = Once<Database>();\n \n // Multiple concurrent calls - only one connection happens\n * const [db1, db2, db3] = await Promise.all([\n * db.getOrInitAsync(() => Database.connect(url)),\n * db.getOrInitAsync(() => Database.connect(url)),\n * db.getOrInitAsync(() => Database.connect(url)),\n * ]);\n * // db1 === db2 === db3\n * ```\n /\n getOrInitAsync(fn: () => Promise<T>): Promise<T>;\n\n /\n Gets the contents, initializing it with `fn` if empty.\n * If `fn` returns `Err`, remains uninitialized.\n \n @typeParam E - The error type.\n * @param fn - The initialization function that may fail.\n * @returns `Ok(value)` if initialized, `Err(error)` if initialization failed.\n \n @example\n * ```ts\n * const once = Once<Config>();\n \n const result = once.getOrTryInit(() => {\n * const config = parseConfig(rawData);\n * return config ? Ok(config) : Err(new Error('Invalid config'));\n * });\n \n if (result.isOk()) {\n * console.log('Config loaded:', result.unwrap());\n * }\n * ```\n /\n getOrTryInit<E>(fn: () => Result<T, E>): Result<T, E>;\n\n /\n Gets the contents, initializing it with async `fn` if empty.\n * If `fn` returns `Err`, remains uninitialized.\n \n If multiple calls occur concurrently, only the first one will run the\n * initialization function. Other calls will wait for it to complete.\n \n @typeParam E - The error type.\n * @param fn - The async initialization function that may fail.\n * @returns A promise that resolves to `Ok(value)` or `Err(error)`.\n \n @example\n * ```ts\n * const config = Once<Config>();\n \n const result = await config.getOrTryInitAsync(async () => {\n * try {\n * const response = await fetch('/api/config');\n * return Ok(await response.json());\n * } catch (e) {\n * return Err(e as Error);\n * }\n * });\n * ```\n /\n getOrTryInitAsync<E>(fn: () => AsyncResult<T, E>): AsyncResult<T, E>;\n\n /\n Takes the value out, leaving it uninitialized.\n \n @returns `Some(value)` if initialized, `None` otherwise.\n \n @example\n * ```ts\n * const once = Once<number>();\n * once.set(42);\n \n console.log(once.take()); // Some(42)\n * console.log(once.get()); // None - now empty\n * console.log(once.take()); // None\n * ```\n /\n take(): Option<T>;\n\n /\n Returns `true` if initialized.\n \n @example\n * ```ts\n * const once = Once<number>();\n * console.log(once.isInitialized()); // false\n \n once.set(42);\n * console.log(once.isInitialized()); // true\n * ```\n /\n isInitialized(): boolean;\n\n /\n Custom `toString` implementation.\n * @example\n * ```ts\n * const once = Once<number>();\n * console.log(once.toString()); // 'Once(<uninitialized>)'\n \n once.set(42);\n * console.log(once.toString()); // 'Once(42)'\n * ```\n /\n toString(): string;\n}\n\n/\n Creates a new empty `Once<T>`.\n \n @typeParam T - The type of value to store.\n * @returns A new uninitialized `Once`.\n \n @example\n * ```ts\n * // Basic usage\n * const once = Once<string>();\n * once.set('hello');\n * console.log(once.get().unwrap()); // 'hello'\n * ```\n \n @example\n * ```ts\n * // Sync lazy singleton pattern\n * const logger = Once<Logger>();\n \n function getLogger(): Logger {\n * return logger.getOrInit(() => new Logger('app'));\n * }\n * ```\n \n @example\n * ```ts\n * // Async lazy initialization\n * const db = Once<Database>();\n \n async function getDb(): Promise<Database> {\n * return await db.getOrInitAsync(async () => {\n * console.log('Connecting to database...');\n * return await Database.connect(connectionString);\n * });\n * }\n \n // Multiple calls - connection happens only once\n * const [db1, db2] = await Promise.all([getDb(), getDb()]);\n * console.log(db1 === db2); // true\n * ```\n \n @example\n * ```ts\n * // Fallible async initialization\n * const config = Once<Config>();\n \n async function loadConfig(): Promise<Result<Config, Error>> {\n * return await config.getOrTryInitAsync(async () => {\n * try {\n * const response = await fetch('/api/config');\n * if (!response.ok) {\n * return Err(new Error(`HTTP ${response.status}`));\n * }\n * return Ok(await response.json());\n * } catch (e) {\n * return Err(e as Error);\n * }\n * });\n * }\n * ```\n */\nexport function Once<T>(): Once<T> {\n let value: T \| undefined;\n let initialized = false;\n let pendingPromise: Promise<T> \| undefined;\n\n return Object.freeze<Once<T>>({\n [Symbol.toStringTag]: 'Once',\n\n get(): Option<T> {\n return initialized ? Some(value as T) : None;\n },\n\n set(newValue: T): Result<void, T> {\n if (initialized) {\n return Err(newValue);\n }\n value = newValue;\n initialized = true;\n return Ok(undefined);\n },\n\n getOrInit(fn: () => T): T {\n if (!initialized) {\n value = fn();\n initialized = true;\n }\n return value as T;\n },\n\n async getOrInitAsync(fn: () => Promise<T>): Promise<T> {\n if (initialized) {\n return value as T;\n }\n\n // If already initializing, wait for the pending promise\n if (pendingPromise) {\n return pendingPromise;\n }\n\n pendingPromise = (async () => {\n try {\n const result = await fn();\n value = result;\n initialized = true;\n return result;\n } finally {\n pendingPromise = undefined;\n }\n })();\n\n return pendingPromise;\n },\n\n getOrTryInit<E>(fn: () => Result<T, E>): Result<T, E> {\n if (initialized) {\n return Ok(value as T);\n }\n\n const result = fn();\n if (result.isOk()) {\n value = result.unwrap();\n initialized = true;\n }\n return result;\n },\n\n async getOrTryInitAsync<E>(fn: () => AsyncResult<T, E>): AsyncResult<T, E> {\n if (initialized) {\n return Ok(value as T);\n }\n\n // If already initializing, wait for it\n if (pendingPromise) {\n try {\n await pendingPromise;\n // pendingPromise only resolves on success, so initialized must be true\n return Ok(value as T);\n } catch {\n // Previous initialization failed via Err result, let this call try again\n }\n }\n\n // Create a new pending promise for this initialization attempt\n pendingPromise = (async () => {\n const result = await fn();\n if (result.isOk()) {\n value = result.unwrap();\n initialized = true;\n return value;\n }\n // If Err, throw to signal failure (we'll catch and return the result)\n throw result;\n })();\n\n try {\n const resultValue = await pendingPromise;\n return Ok(resultValue as T);\n } catch (errResult) {\n return errResult as Result<T, E>;\n } finally {\n pendingPromise = undefined;\n }\n },\n\n take(): Option<T> {\n if (!initialized) {\n return None;\n }\n const taken = value as T;\n value = undefined;\n initialized = false;\n return Some(taken);\n },\n\n isInitialized(): boolean {\n return initialized;\n },\n\n toString(): string {\n return initialized ? `Once(${ value })` : 'Once(<uninitialized>)';\n },\n } as const);\n}\n"],"names":[],"mappings":"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"}

package/dist/types.d.ts CHANGED Viewed

@@ -1273,7 +1273,7 @@ type AsyncVoidIOResult = AsyncIOResult<void>;
  *
  * @typeParam T - The type of the value that the promise resolves to.
  * @typeParam E - The type of the error that the promise may reject with, defaults to `Error`.
- * @param p - The promise to convert into a `Result` type.
+ * @param p - The promise or promise-like object to convert into a `Result` type.
  * @returns 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
@@ -1294,7 +1294,7 @@ type AsyncVoidIOResult = AsyncIOResult<void>;
  * const result = await promiseToAsyncResult<User, ApiError>(fetchUser(id));
  * ```
  */
-declare function promiseToAsyncResult<T, E = Error>(p: Promise<T>): Promise<Result<T, E>>;
+declare function promiseToAsyncResult<T, E = Error>(p: PromiseLike<T>): AsyncResult<T, E>;
 /**
  * @fileoverview
@@ -2560,7 +2560,7 @@ interface Once<T> {
      * });
      * ```
      */
-    getOrTryInitAsync<E>(fn: () => Promise<Result<T, E>>): Promise<Result<T, E>>;
+    getOrTryInitAsync<E>(fn: () => AsyncResult<T, E>): AsyncResult<T, E>;
     /**
      * Takes the value out, leaving it uninitialized.
      *

package/package.json CHANGED Viewed

@@ -3,9 +3,8 @@
   "description": "Rust's Option, Result, and sync primitives for JavaScript/TypeScript - Better error handling and null-safety patterns.",
   "author": "jiang115jie@gmail.com",
   "license": "MIT",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "type": "module",
-  "source": "src/mod.ts",
   "main": "dist/main.cjs",
   "module": "dist/main.mjs",
   "types": "dist/types.d.ts",