 Server : Apache/2 System : Linux server-15-235-50-60 5.15.0-164-generic #174-Ubuntu SMP Fri Nov 14 20:25:16 UTC 2025 x86_64 User : gositeme ( 1004) PHP Version : 8.2.29 Disable Function : exec,system,passthru,shell_exec,proc_close,proc_open,dl,popen,show_source,posix_kill,posix_mkfifo,posix_getpwuid,posix_setpgid,posix_setsid,posix_setuid,posix_setgid,posix_seteuid,posix_setegid,posix_uname Directory : /home/gositeme/domains/lavocat.quebec/private_html/node_modules/effect/dist/dts/ |
/**
* @since 2.0.0
*/
export {
/**
* @since 2.0.0
*/
absurd,
/**
* @since 2.0.0
*/
flow,
/**
* @since 2.0.0
*/
hole,
/**
* @since 2.0.0
*/
identity,
/**
* @since 2.0.0
*/
pipe,
/**
* @since 2.0.0
*/
unsafeCoerce } from "./Function.js";
/**
* @since 3.10.0
*/
export * as Arbitrary from "./Arbitrary.js";
/**
* This module provides utility functions for working with arrays in TypeScript.
*
* @since 2.0.0
*/
export * as Array from "./Array.js";
/**
* This module provides utility functions and type class instances for working with the `BigDecimal` type in TypeScript.
* It includes functions for basic arithmetic operations, as well as type class instances for `Equivalence` and `Order`.
*
* A `BigDecimal` allows storing any real number to arbitrary precision; which avoids common floating point errors
* (such as 0.1 + 0.2 ≠ 0.3) at the cost of complexity.
*
* Internally, `BigDecimal` uses a `BigInt` object, paired with a 64-bit integer which determines the position of the
* decimal point. Therefore, the precision *is not* actually arbitrary, but limited to 2<sup>63</sup> decimal places.
*
* It is not recommended to convert a floating point number to a decimal directly, as the floating point representation
* may be unexpected.
*
* @module BigDecimal
* @since 2.0.0
* @see {@link module:BigInt} for more similar operations on `bigint` types
* @see {@link module:Number} for more similar operations on `number` types
*/
export * as BigDecimal from "./BigDecimal.js";
/**
* This module provides utility functions and type class instances for working with the `bigint` type in TypeScript.
* It includes functions for basic arithmetic operations, as well as type class instances for
* `Equivalence` and `Order`.
*
* @module BigInt
* @since 2.0.0
* @see {@link module:BigDecimal} for more similar operations on `BigDecimal` types
* @see {@link module:Number} for more similar operations on `number` types
*/
export * as BigInt from "./BigInt.js";
/**
* This module provides utility functions and type class instances for working with the `boolean` type in TypeScript.
* It includes functions for basic boolean operations, as well as type class instances for
* `Equivalence` and `Order`.
*
* @since 2.0.0
*/
export * as Boolean from "./Boolean.js";
/**
* This module provides types and utility functions to create and work with branded types,
* which are TypeScript types with an added type tag to prevent accidental usage of a value in the wrong context.
*
* The `refined` and `nominal` functions are both used to create branded types in TypeScript.
* The main difference between them is that `refined` allows for validation of the data, while `nominal` does not.
*
* The `nominal` function is used to create a new branded type that has the same underlying type as the input, but with a different name.
* This is useful when you want to distinguish between two values of the same type that have different meanings.
* The `nominal` function does not perform any validation of the input data.
*
* On the other hand, the `refined` function is used to create a new branded type that has the same underlying type as the input,
* but with a different name, and it also allows for validation of the input data.
* The `refined` function takes a predicate that is used to validate the input data.
* If the input data fails the validation, a `BrandErrors` is returned, which provides information about the specific validation failure.
*
* @since 2.0.0
*/
export * as Brand from "./Brand.js";
/**
* @since 2.0.0
*/
export * as Cache from "./Cache.js";
/**
* The `Effect<A, E, R>` type is polymorphic in values of type `E` and we can
* work with any error type that we want. However, there is a lot of information
* that is not inside an arbitrary `E` value. So as a result, an `Effect` needs
* somewhere to store things like unexpected errors or defects, stack and
* execution traces, causes of fiber interruptions, and so forth.
*
* Effect-TS is very strict about preserving the full information related to a
* failure. It captures all type of errors into the `Cause` data type. `Effect`
* uses the `Cause<E>` data type to store the full story of failure. So its
* error model is lossless. It doesn't throw information related to the failure
* result. So we can figure out exactly what happened during the operation of
* our effects.
*
* It is important to note that `Cause` is an underlying data type representing
* errors occuring within an `Effect` workflow. Thus, we don't usually deal with
* `Cause`s directly. Even though it is not a data type that we deal with very
* often, the `Cause` of a failing `Effect` workflow can be accessed at any
* time, which gives us total access to all parallel and sequential errors in
* occurring within our codebase.
*
* @since 2.0.0
*/
export * as Cause from "./Cause.js";
/**
* @since 2.0.0
*/
export * as Channel from "./Channel.js";
/**
* @since 2.0.0
*/
export * as ChildExecutorDecision from "./ChildExecutorDecision.js";
/**
* @since 2.0.0
*/
export * as Chunk from "./Chunk.js";
/**
* @since 2.0.0
*/
export * as Clock from "./Clock.js";
/**
* @since 2.0.0
*/
export * as Config from "./Config.js";
/**
* @since 2.0.0
*/
export * as ConfigError from "./ConfigError.js";
/**
* @since 2.0.0
*/
export * as ConfigProvider from "./ConfigProvider.js";
/**
* @since 2.0.0
*/
export * as ConfigProviderPathPatch from "./ConfigProviderPathPatch.js";
/**
* @since 2.0.0
*/
export * as Console from "./Console.js";
/**
* This module provides a data structure called `Context` that can be used for dependency injection in effectful
* programs. It is essentially a table mapping `Tag`s to their implementations (called `Service`s), and can be used to
* manage dependencies in a type-safe way. The `Context` data structure is essentially a way of providing access to a set
* of related services that can be passed around as a single unit. This module provides functions to create, modify, and
* query the contents of a `Context`, as well as a number of utility types for working with tags and services.
*
* @since 2.0.0
*/
export * as Context from "./Context.js";
/**
* @since 2.0.0
*/
export * as Cron from "./Cron.js";
/**
* @since 2.0.0
*/
export * as Data from "./Data.js";
/**
* @since 3.6.0
*/
export * as DateTime from "./DateTime.js";
/**
* @since 2.0.0
*/
export * as DefaultServices from "./DefaultServices.js";
/**
* @since 2.0.0
*/
export * as Deferred from "./Deferred.js";
/**
* @since 2.0.0
*/
export * as Differ from "./Differ.js";
/**
* @since 2.0.0
*/
export * as Duration from "./Duration.js";
/**
* @since 2.0.0
*/
export * as Effect from "./Effect.js";
/**
* @since 2.0.0
*/
export * as Effectable from "./Effectable.js";
/**
* @since 2.0.0
*/
export * as Either from "./Either.js";
/**
* This module provides encoding & decoding functionality for:
*
* - base64 (RFC4648)
* - base64 (URL)
* - hex
*
* @since 2.0.0
*/
export * as Encoding from "./Encoding.js";
/**
* @since 2.0.0
*/
export * as Equal from "./Equal.js";
/**
* This module provides an implementation of the `Equivalence` type class, which defines a binary relation
* that is reflexive, symmetric, and transitive. In other words, it defines a notion of equivalence between values of a certain type.
* These properties are also known in mathematics as an "equivalence relation".
*
* @since 2.0.0
*/
export * as Equivalence from "./Equivalence.js";
/**
* @since 3.16.0
* @experimental
*/
export * as ExecutionPlan from "./ExecutionPlan.js";
/**
* @since 2.0.0
*/
export * as ExecutionStrategy from "./ExecutionStrategy.js";
/**
* @since 2.0.0
*/
export * as Exit from "./Exit.js";
/**
* @since 3.10.0
*/
export * as FastCheck from "./FastCheck.js";
/**
* @since 2.0.0
*/
export * as Fiber from "./Fiber.js";
/**
* @since 2.0.0
*/
export * as FiberHandle from "./FiberHandle.js";
/**
* @since 2.0.0
*/
export * as FiberId from "./FiberId.js";
/**
* @since 2.0.0
*/
export * as FiberMap from "./FiberMap.js";
/**
* @since 2.0.0
*/
export * as FiberRef from "./FiberRef.js";
/**
* @since 2.0.0
*/
export * as FiberRefs from "./FiberRefs.js";
/**
* @since 2.0.0
*/
export * as FiberRefsPatch from "./FiberRefsPatch.js";
/**
* @since 2.0.0
*/
export * as FiberSet from "./FiberSet.js";
/**
* @since 2.0.0
*/
export * as FiberStatus from "./FiberStatus.js";
/**
* @since 2.0.0
*/
export * as Function from "./Function.js";
/**
* The `GlobalValue` module ensures that a single instance of a value is created globally,
* even when modules are imported multiple times (e.g., due to mixing CommonJS and ESM builds)
* or during hot-reloading in development environments like Next.js or Remix.
*
* It achieves this by using a versioned global store, identified by a unique `Symbol` tied to
* the current version of the `effect` library. The store holds values that are keyed by an identifier,
* allowing the reuse of previously computed instances across imports or reloads.
*
* This pattern is particularly useful in scenarios where frequent reloading can cause services or
* single-instance objects to be recreated unnecessarily, such as in development environments with hot-reloading.
*
* @since 2.0.0
*/
export * as GlobalValue from "./GlobalValue.js";
/**
* @since 2.0.0
*/
export * as GroupBy from "./GroupBy.js";
/**
* @since 2.0.0
*/
export * as HKT from "./HKT.js";
/**
* @since 2.0.0
*/
export * as Hash from "./Hash.js";
/**
* @since 2.0.0
*/
export * as HashMap from "./HashMap.js";
/**
* # HashSet
*
* An immutable `HashSet` provides a collection of unique values with efficient
* lookup, insertion and removal. Once created, a `HashSet` cannot be modified;
* any operation that would alter the set instead returns a new `HashSet` with
* the changes. This immutability offers benefits like predictable state
* management and easier reasoning about your code.
*
* ## What Problem Does It Solve?
*
* `HashSet` solves the problem of maintaining an unsorted collection where each
* value appears exactly once, with fast operations for checking membership and
* adding/removing values.
*
* ## When to Use
*
* Use `HashSet` when you need:
*
* - A collection with no duplicate values
* - Efficient membership testing (**`O(1)`** average complexity)
* - Set operations like union, intersection, and difference
* - An immutable data structure that preserves functional programming patterns
*
* ## Advanced Features
*
* HashSet provides operations for:
*
* - Transforming sets with map and flatMap
* - Filtering elements with filter
* - Combining sets with union, intersection and difference
* - Performance optimizations via mutable operations in controlled contexts
*
* ## Performance Characteristics
*
* - **Lookup** operations ({@link module:HashSet.has}): **`O(1)`** average time
* complexity
* - **Insertion** operations ({@link module:HashSet.add}): **`O(1)`** average time
* complexity
* - **Removal** operations ({@link module:HashSet.remove}): **`O(1)`** average
* time complexity
* - **Set** operations ({@link module:HashSet.union},
* {@link module:HashSet.intersection}): **`O(n)`** where n is the size of the
* smaller set
* - **Iteration**: **`O(n)`** where n is the size of the set
*
* The HashSet data structure implements the following traits:
*
* - {@link Iterable}: allows iterating over the values in the set
* - {@link Equal}: allows comparing two sets for value-based equality
* - {@link Pipeable}: allows chaining operations with the pipe operator
* - {@link Inspectable}: allows inspecting the contents of the set
*
* ## Operations Reference
*
* | Category | Operation | Description | Complexity |
* | ------------ | ----------------------------------- | ------------------------------------------- | ---------- |
* | constructors | {@link module:HashSet.empty} | Creates an empty HashSet | O(1) |
* | constructors | {@link module:HashSet.fromIterable} | Creates a HashSet from an iterable | O(n) |
* | constructors | {@link module:HashSet.make} | Creates a HashSet from multiple values | O(n) |
* | | | | |
* | elements | {@link module:HashSet.has} | Checks if a value exists in the set | O(1) avg |
* | elements | {@link module:HashSet.some} | Checks if any element satisfies a predicate | O(n) |
* | elements | {@link module:HashSet.every} | Checks if all elements satisfy a predicate | O(n) |
* | elements | {@link module:HashSet.isSubset} | Checks if a set is a subset of another | O(n) |
* | | | | |
* | getters | {@link module:HashSet.values} | Gets an iterator of all values | O(1) |
* | getters | {@link module:HashSet.toValues} | Gets an array of all values | O(n) |
* | getters | {@link module:HashSet.size} | Gets the number of elements | O(1) |
* | | | | |
* | mutations | {@link module:HashSet.add} | Adds a value to the set | O(1) avg |
* | mutations | {@link module:HashSet.remove} | Removes a value from the set | O(1) avg |
* | mutations | {@link module:HashSet.toggle} | Toggles a value's presence | O(1) avg |
* | | | | |
* | operations | {@link module:HashSet.difference} | Computes set difference (A - B) | O(n) |
* | operations | {@link module:HashSet.intersection} | Computes set intersection (A ∩ B) | O(n) |
* | operations | {@link module:HashSet.union} | Computes set union (A ∪ B) | O(n) |
* | | | | |
* | mapping | {@link module:HashSet.map} | Transforms each element | O(n) |
* | | | | |
* | sequencing | {@link module:HashSet.flatMap} | Transforms and flattens elements | O(n) |
* | | | | |
* | traversing | {@link module:HashSet.forEach} | Applies a function to each element | O(n) |
* | | | | |
* | folding | {@link module:HashSet.reduce} | Reduces the set to a single value | O(n) |
* | | | | |
* | filtering | {@link module:HashSet.filter} | Keeps elements that satisfy a predicate | O(n) |
* | | | | |
* | partitioning | {@link module:HashSet.partition} | Splits into two sets by a predicate | O(n) |
*
* ## Notes
*
* ### Composability with the Effect Ecosystem:
*
* This `HashSet` is designed to work seamlessly within the Effect ecosystem. It
* implements the {@link Iterable}, {@link Equal}, {@link Pipeable}, and
* {@link Inspectable} traits from Effect. This ensures compatibility with other
* Effect data structures and functionalities. For example, you can easily use
* Effect's `pipe` method to chain operations on the `HashSet`.
*
* **Equality of Elements with Effect's {@link Equal `Equal`} Trait:**
*
* This `HashSet` relies on Effect's {@link Equal} trait to determine the
* uniqueness of elements within the set. The way equality is checked depends on
* the type of the elements:
*
* - **Primitive Values:** For primitive JavaScript values like strings, numbers,
* booleans, `null`, and `undefined`, equality is determined by their value
* (similar to the `===` operator).
* - **Objects and Custom Types:** For objects and other custom types, equality is
* determined by whether those types implement the {@link Equal} interface
* themselves. If an element type implements `Equal`, the `HashSet` will
* delegate to that implementation to perform the equality check. This allows
* you to define custom logic for determining when two instances of your
* objects should be considered equal based on their properties, rather than
* just their object identity.
*
* ```ts
* import { Equal, Hash, HashSet } from "effect"
*
* class Person implements Equal.Equal {
* constructor(
* readonly id: number, // Unique identifier
* readonly name: string,
* readonly age: number
* ) {}
*
* // Define equality based on id, name, and age
* [Equal.symbol](that: Equal.Equal): boolean {
* if (that instanceof Person) {
* return (
* Equal.equals(this.id, that.id) &&
* Equal.equals(this.name, that.name) &&
* Equal.equals(this.age, that.age)
* )
* }
* return false
* }
*
* // Generate a hash code based on the unique id
* [Hash.symbol](): number {
* return Hash.hash(this.id)
* }
* }
*
* // Creating a HashSet with objects that implement the Equal interface
* const set = HashSet.empty().pipe(
* HashSet.add(new Person(1, "Alice", 30)),
* HashSet.add(new Person(1, "Alice", 30))
* )
*
* // HashSet recognizes them as equal, so only one element is stored
* console.log(HashSet.size(set))
* // Output: 1
* ```
*
* **Simplifying Equality and Hashing with `Data` and `Schema`:**
*
* Effect's {@link Data} and {@link Schema `Schema.Data`} modules offer powerful
* ways to automatically handle the implementation of both the {@link Equal} and
* {@link Hash} traits for your custom data structures.
*
* - **`Data` Module:** By using constructors like `Data.struct`, `Data.tuple`,
* `Data.array`, or `Data.case` to define your data types, Effect
* automatically generates the necessary implementations for value-based
* equality and consistent hashing. This significantly reduces boilerplate and
* ensures correctness.
*
* ```ts
* import { HashSet, Data, Equal } from "effect"
* import assert from "node:assert/strict"
*
* // Data.* implements the `Equal` traits for us
* const person1 = Data.struct({ id: 1, name: "Alice", age: 30 })
* const person2 = Data.struct({ id: 1, name: "Alice", age: 30 })
*
* assert(Equal.equals(person1, person2))
*
* const set = HashSet.empty().pipe(
* HashSet.add(person1),
* HashSet.add(person2)
* )
*
* // HashSet recognizes them as equal, so only one element is stored
* console.log(HashSet.size(set)) // Output: 1
* ```
*
* - **`Schema` Module:** When defining data schemas using the {@link Schema}
* module, you can use `Schema.Data` to automatically include the `Equal` and
* `Hash` traits in the decoded objects. This is particularly important when
* working with `HashSet`. **For decoded objects to be correctly recognized as
* equal within a `HashSet`, ensure that the schema for those objects is
* defined using `Schema.Data`.**
*
* ```ts
* import { Equal, HashSet, Schema } from "effect"
* import assert from "node:assert/strict"
*
* // Schema.Data implements the `Equal` traits for us
* const PersonSchema = Schema.Data(
* Schema.Struct({
* id: Schema.Number,
* name: Schema.String,
* age: Schema.Number
* })
* )
*
* const Person = Schema.decode(PersonSchema)
*
* const person1 = Person({ id: 1, name: "Alice", age: 30 })
* const person2 = Person({ id: 1, name: "Alice", age: 30 })
*
* assert(Equal.equals(person1, person2)) // Output: true
*
* const set = HashSet.empty().pipe(
* HashSet.add(person1),
* HashSet.add(person2)
* )
*
* // HashSet thanks to Schema.Data implementation of the `Equal` trait, recognizes the two Person as equal, so only one element is stored
* console.log(HashSet.size(set)) // Output: 1
* ```
*
* ### Interoperability with the JavaScript Runtime:
*
* To interoperate with the regular JavaScript runtime, Effect's `HashSet`
* provides methods to access its elements in formats readily usable by
* JavaScript APIs: {@link values `HashSet.values`},
* {@link toValues `HashSet.toValues`}
*
* ```ts
* import { HashSet } from "effect"
*
* const hashSet: HashSet.HashSet<number> = HashSet.make(1, 2, 3)
*
* // Using HashSet.values to convert HashSet.HashSet<A> to IterableIterator<A>
* const iterable: IterableIterator<number> = HashSet.values(hashSet)
*
* console.log(...iterable) // Logs: 1 2 3
*
* // Using HashSet.toValues to convert HashSet.HashSet<A> to Array<A>
* const array: Array<number> = HashSet.toValues(hashSet)
*
* console.log(array) // Logs: [ 1, 2, 3 ]
* ```
*
* Be mindful of performance implications (both time and space complexity) when
* frequently converting between Effect's immutable HashSet and mutable
* JavaScript data structures, especially for large collections.
*
* @module HashSet
* @since 2.0.0
*/
export * as HashSet from "./HashSet.js";
/**
* @since 2.0.0
*/
export * as Inspectable from "./Inspectable.js";
/**
* This module provides utility functions for working with Iterables in TypeScript.
*
* @since 2.0.0
*/
export * as Iterable from "./Iterable.js";
/**
* @since 3.10.0
*/
export * as JSONSchema from "./JSONSchema.js";
/**
* @since 2.0.0
*/
export * as KeyedPool from "./KeyedPool.js";
/**
* A `Layer<ROut, E, RIn>` describes how to build one or more services in your
* application. Services can be injected into effects via
* `Effect.provideService`. Effects can require services via `Effect.service`.
*
* Layer can be thought of as recipes for producing bundles of services, given
* their dependencies (other services).
*
* Construction of services can be effectful and utilize resources that must be
* acquired and safely released when the services are done being utilized.
*
* By default layers are shared, meaning that if the same layer is used twice
* the layer will only be allocated a single time.
*
* Because of their excellent composition properties, layers are the idiomatic
* way in Effect-TS to create services that depend on other services.
*
* @since 2.0.0
*/
export * as Layer from "./Layer.js";
/**
* @since 3.14.0
* @experimental
*/
export * as LayerMap from "./LayerMap.js";
/**
* A data type for immutable linked lists representing ordered collections of elements of type `A`.
*
* This data type is optimal for last-in-first-out (LIFO), stack-like access patterns. If you need another access pattern, for example, random access or FIFO, consider using a collection more suited to this than `List`.
*
* **Performance**
*
* - Time: `List` has `O(1)` prepend and head/tail access. Most other operations are `O(n)` on the number of elements in the list. This includes the index-based lookup of elements, `length`, `append` and `reverse`.
* - Space: `List` implements structural sharing of the tail list. This means that many operations are either zero- or constant-memory cost.
*
* @since 2.0.0
*/
export * as List from "./List.js";
/**
* @since 2.0.0
*/
export * as LogLevel from "./LogLevel.js";
/**
* @since 2.0.0
*/
export * as LogSpan from "./LogSpan.js";
/**
* @since 2.0.0
*/
export * as Logger from "./Logger.js";
/**
* @since 3.8.0
* @experimental
*/
export * as Mailbox from "./Mailbox.js";
/**
* @since 2.0.0
*/
export * as ManagedRuntime from "./ManagedRuntime.js";
/**
* The `effect/match` module provides a type-safe pattern matching system for
* TypeScript. Inspired by functional programming, it simplifies conditional
* logic by replacing verbose if/else or switch statements with a structured and
* expressive API.
*
* This module supports matching against types, values, and discriminated unions
* while enforcing exhaustiveness checking to ensure all cases are handled.
*
* Although pattern matching is not yet a native JavaScript feature,
* `effect/match` offers a reliable implementation that is available today.
*
* **How Pattern Matching Works**
*
* Pattern matching follows a structured process:
*
* - **Creating a matcher**: Define a `Matcher` that operates on either a
* specific `Match.type` or `Match.value`.
*
* - **Defining patterns**: Use combinators such as `Match.when`, `Match.not`,
* and `Match.tag` to specify matching conditions.
*
* - **Completing the match**: Apply a finalizer such as `Match.exhaustive`,
* `Match.orElse`, or `Match.option` to determine how unmatched cases should
* be handled.
*
* @since 1.0.0
*/
export * as Match from "./Match.js";
/**
* @since 2.0.0
*/
export * as MergeDecision from "./MergeDecision.js";
/**
* @since 2.0.0
*/
export * as MergeState from "./MergeState.js";
/**
* @since 2.0.0
*/
export * as MergeStrategy from "./MergeStrategy.js";
/**
* @since 2.0.0
*/
export * as Metric from "./Metric.js";
/**
* @since 2.0.0
*/
export * as MetricBoundaries from "./MetricBoundaries.js";
/**
* @since 2.0.0
*/
export * as MetricHook from "./MetricHook.js";
/**
* @since 2.0.0
*/
export * as MetricKey from "./MetricKey.js";
/**
* @since 2.0.0
*/
export * as MetricKeyType from "./MetricKeyType.js";
/**
* @since 2.0.0
*/
export * as MetricLabel from "./MetricLabel.js";
/**
* @since 2.0.0
*/
export * as MetricPair from "./MetricPair.js";
/**
* @since 2.0.0
*/
export * as MetricPolling from "./MetricPolling.js";
/**
* @since 2.0.0
*/
export * as MetricRegistry from "./MetricRegistry.js";
/**
* @since 2.0.0
*/
export * as MetricState from "./MetricState.js";
/**
* A lightweight alternative to the `Effect` data type, with a subset of the functionality.
*
* @since 3.4.0
* @experimental
*/
export * as Micro from "./Micro.js";
/**
* @since 2.0.0
*
* Enables low level framework authors to run on their own isolated effect version
*/
export * as ModuleVersion from "./ModuleVersion.js";
/**
* @since 2.0.0
*/
export * as MutableHashMap from "./MutableHashMap.js";
/**
* # MutableHashSet
*
* A mutable `MutableHashSet` provides a collection of unique values with
* efficient lookup, insertion and removal. Unlike its immutable sibling
* {@link module:HashSet}, a `MutableHashSet` can be modified in-place;
* operations like add, remove, and clear directly modify the original set
* rather than creating a new one. This mutability offers benefits like improved
* performance in scenarios where you need to build or modify a set
* incrementally.
*
* ## What Problem Does It Solve?
*
* `MutableHashSet` solves the problem of maintaining an unsorted collection
* where each value appears exactly once, with fast operations for checking
* membership and adding/removing values, in contexts where mutability is
* preferred for performance or implementation simplicity.
*
* ## When to Use
*
* Use `MutableHashSet` when you need:
*
* - A collection with no duplicate values
* - Efficient membership testing (**`O(1)`** average complexity)
* - In-place modifications for better performance
* - A set that will be built or modified incrementally
* - Local mutability in otherwise immutable code
*
* ## Advanced Features
*
* MutableHashSet provides operations for:
*
* - Adding and removing elements with direct mutation
* - Checking for element existence
* - Clearing all elements at once
* - Converting to/from other collection types
*
* ## Performance Characteristics
*
* - **Lookup** operations ({@link module:MutableHashSet.has}): **`O(1)`** average
* time complexity
* - **Insertion** operations ({@link module:MutableHashSet.add}): **`O(1)`**
* average time complexity
* - **Removal** operations ({@link module:MutableHashSet.remove}): **`O(1)`**
* average time complexity
* - **Iteration**: **`O(n)`** where n is the size of the set
*
* The MutableHashSet data structure implements the following traits:
*
* - {@link Iterable}: allows iterating over the values in the set
* - {@link Pipeable}: allows chaining operations with the pipe operator
* - {@link Inspectable}: allows inspecting the contents of the set
*
* ## Operations Reference
*
* | Category | Operation | Description | Complexity |
* | ------------ | ------------------------------------------ | ----------------------------------- | ---------- |
* | constructors | {@link module:MutableHashSet.empty} | Creates an empty MutableHashSet | O(1) |
* | constructors | {@link module:MutableHashSet.fromIterable} | Creates a set from an iterable | O(n) |
* | constructors | {@link module:MutableHashSet.make} | Creates a set from multiple values | O(n) |
* | | | | |
* | elements | {@link module:MutableHashSet.has} | Checks if a value exists in the set | O(1) avg |
* | elements | {@link module:MutableHashSet.add} | Adds a value to the set | O(1) avg |
* | elements | {@link module:MutableHashSet.remove} | Removes a value from the set | O(1) avg |
* | elements | {@link module:MutableHashSet.size} | Gets the number of elements | O(1) |
* | elements | {@link module:MutableHashSet.clear} | Removes all values from the set | O(1) |
*
* ## Notes
*
* ### Mutability Considerations:
*
* Unlike most data structures in the Effect ecosystem, `MutableHashSet` is
* mutable. This means that operations like `add`, `remove`, and `clear` modify
* the original set rather than creating a new one. This can lead to more
* efficient code in some scenarios, but requires careful handling to avoid
* unexpected side effects.
*
* ### When to Choose `MutableHashSet` vs {@link module:HashSet}:
*
* - Use `MutableHashSet` when you need to build or modify a set incrementally and
* performance is a priority
* - Use `HashSet` when you want immutability guarantees and functional
* programming patterns
* - Consider using {@link module:HashSet}'s bounded mutation context (via
* {@link module:HashSet.beginMutation}, {@link module:HashSet.endMutation}, and
* {@link module:HashSet.mutate} methods) when you need temporary mutability
* within an otherwise immutable context - this approach might be sufficient
* for many use cases without requiring a separate `MutableHashSet`
* - `MutableHashSet` is often useful for local operations where the mutability is
* contained and doesn't leak into the broader application
*
* @module MutableHashSet
* @since 2.0.0
*/
export * as MutableHashSet from "./MutableHashSet.js";
/**
* @since 2.0.0
*/
export * as MutableList from "./MutableList.js";
/**
* @since 2.0.0
*/
export * as MutableQueue from "./MutableQueue.js";
/**
* @since 2.0.0
*/
export * as MutableRef from "./MutableRef.js";
/**
* @since 2.0.0
*/
export * as NonEmptyIterable from "./NonEmptyIterable.js";
/**
* # Number
*
* This module provides utility functions and type class instances for working
* with the `number` type in TypeScript. It includes functions for basic
* arithmetic operations, as well as type class instances for `Equivalence` and
* `Order`.
*
* ## Operations Reference
*
* | Category | Operation | Description | Domain | Co-domain |
* | ------------ | ------------------------------------------ | ------------------------------------------------------- | ------------------------------ | --------------------- |
* | constructors | {@link module:Number.parse} | Safely parses a string to a number | `string` | `Option<number>` |
* | | | | | |
* | math | {@link module:Number.sum} | Adds two numbers | `number`, `number` | `number` |
* | math | {@link module:Number.sumAll} | Sums all numbers in a collection | `Iterable<number>` | `number` |
* | math | {@link module:Number.subtract} | Subtracts one number from another | `number`, `number` | `number` |
* | math | {@link module:Number.multiply} | Multiplies two numbers | `number`, `number` | `number` |
* | math | {@link module:Number.multiplyAll} | Multiplies all numbers in a collection | `Iterable<number>` | `number` |
* | math | {@link module:Number.divide} | Safely divides handling division by zero | `number`, `number` | `Option<number>` |
* | math | {@link module:Number.unsafeDivide} | Divides but misbehaves for division by zero | `number`, `number` | `number` |
* | math | {@link module:Number.remainder} | Calculates remainder of division | `number`, `number` | `number` |
* | math | {@link module:Number.increment} | Adds 1 to a number | `number` | `number` |
* | math | {@link module:Number.decrement} | Subtracts 1 from a number | `number` | `number` |
* | math | {@link module:Number.sign} | Determines the sign of a number | `number` | `Ordering` |
* | math | {@link module:Number.nextPow2} | Finds the next power of 2 | `number` | `number` |
* | math | {@link module:Number.round} | Rounds a number with specified precision | `number`, `number` | `number` |
* | | | | | |
* | predicates | {@link module:Number.between} | Checks if a number is in a range | `number`, `{minimum, maximum}` | `boolean` |
* | predicates | {@link module:Number.lessThan} | Checks if one number is less than another | `number`, `number` | `boolean` |
* | predicates | {@link module:Number.lessThanOrEqualTo} | Checks if one number is less than or equal | `number`, `number` | `boolean` |
* | predicates | {@link module:Number.greaterThan} | Checks if one number is greater than another | `number`, `number` | `boolean` |
* | predicates | {@link module:Number.greaterThanOrEqualTo} | Checks if one number is greater or equal | `number`, `number` | `boolean` |
* | | | | | |
* | guards | {@link module:Number.isNumber} | Type guard for JavaScript numbers | `unknown` | `boolean` |
* | | | | | |
* | comparison | {@link module:Number.min} | Returns the minimum of two numbers | `number`, `number` | `number` |
* | comparison | {@link module:Number.max} | Returns the maximum of two numbers | `number`, `number` | `number` |
* | comparison | {@link module:Number.clamp} | Restricts a number to a range | `number`, `{minimum, maximum}` | `number` |
* | | | | | |
* | instances | {@link module:Number.Equivalence} | Equivalence instance for numbers | | `Equivalence<number>` |
* | instances | {@link module:Number.Order} | Order instance for numbers | | `Order<number>` |
* | | | | | |
* | errors | {@link module:Number.DivisionByZeroError} | Error thrown by unsafeDivide | | |
*
* ## Composition Patterns and Type Safety
*
* When building function pipelines, understanding how types flow through
* operations is critical:
*
* ### Composing with type-preserving operations
*
* Most operations in this module are type-preserving (`number → number`),
* making them easily composable in pipelines:
*
* ```ts
* import { pipe } from "effect"
* import * as Number from "effect/Number"
*
* const result = pipe(
* 10,
* Number.increment, // number → number
* Number.multiply(2), // number → number
* Number.round(1) // number → number
* ) // Result: number (21)
* ```
*
* ### Working with Option results
*
* Operations that might fail (like division by zero) return Option types and
* require Option combinators:
*
* ```ts
* import { pipe, Option } from "effect"
* import * as Number from "effect/Number"
*
* const result = pipe(
* 10,
* Number.divide(0), // number → Option<number>
* Option.getOrElse(() => 0) // Option<number> → number
* ) // Result: number (0)
* ```
*
* ### Composition best practices
*
* - Chain type-preserving operations for maximum composability
* - Use Option combinators when working with potentially failing operations
* - Consider using Effect for operations that might fail with specific errors
* - Remember that all operations maintain JavaScript's floating-point precision
* limitations
*
* @module Number
* @since 2.0.0
* @see {@link module:BigInt} for more similar operations on `bigint` types
* @see {@link module:BigDecimal} for more similar operations on `BigDecimal` types
*/
export * as Number from "./Number.js";
/**
* @since 2.0.0
*/
export * as Option from "./Option.js";
/**
* This module provides an implementation of the `Order` type class which is used to define a total ordering on some type `A`.
* An order is defined by a relation `<=`, which obeys the following laws:
*
* - either `x <= y` or `y <= x` (totality)
* - if `x <= y` and `y <= x`, then `x == y` (antisymmetry)
* - if `x <= y` and `y <= z`, then `x <= z` (transitivity)
*
* The truth table for compare is defined as follows:
*
* | `x <= y` | `x >= y` | Ordering | |
* | -------- | -------- | -------- | --------------------- |
* | `true` | `true` | `0` | corresponds to x == y |
* | `true` | `false` | `< 0` | corresponds to x < y |
* | `false` | `true` | `> 0` | corresponds to x > y |
*
* @since 2.0.0
*/
export * as Order from "./Order.js";
/**
* @since 2.0.0
*/
export * as Ordering from "./Ordering.js";
/**
* @since 3.10.0
*/
export * as ParseResult from "./ParseResult.js";
/**
* @since 2.0.0
*/
export * as Pipeable from "./Pipeable.js";
/**
* @since 2.0.0
*/
export * as Pool from "./Pool.js";
/**
* @since 2.0.0
*/
export * as Predicate from "./Predicate.js";
/**
* @since 3.10.0
*/
export * as Pretty from "./Pretty.js";
/**
* @since 2.0.0
*/
export * as PrimaryKey from "./PrimaryKey.js";
/**
* @since 2.0.0
*/
export * as PubSub from "./PubSub.js";
/**
* @since 2.0.0
*/
export * as Queue from "./Queue.js";
/**
* @since 2.0.0
*/
export * as Random from "./Random.js";
/**
* Limits the number of calls to a resource to a maximum amount in some interval.
*
* @since 2.0.0
*/
export * as RateLimiter from "./RateLimiter.js";
/**
* @since 3.5.0
*/
export * as RcMap from "./RcMap.js";
/**
* @since 3.5.0
*/
export * as RcRef from "./RcRef.js";
/**
* @since 2.0.0
*/
export * as Readable from "./Readable.js";
/**
* This module provides utility functions for working with records in TypeScript.
*
* @since 2.0.0
*/
export * as Record from "./Record.js";
/**
* @since 2.0.0
*/
export * as RedBlackTree from "./RedBlackTree.js";
/**
* The Redacted module provides functionality for handling sensitive information
* securely within your application. By using the `Redacted` data type, you can
* ensure that sensitive values are not accidentally exposed in logs or error
* messages.
*
* @since 3.3.0
*/
export * as Redacted from "./Redacted.js";
/**
* @since 2.0.0
*/
export * as Ref from "./Ref.js";
/**
* This module provides utility functions for working with RegExp in TypeScript.
*
* @since 2.0.0
*/
export * as RegExp from "./RegExp.js";
/**
* @since 2.0.0
*/
export * as Reloadable from "./Reloadable.js";
/**
* @since 2.0.0
*/
export * as Request from "./Request.js";
/**
* @since 2.0.0
*/
export * as RequestBlock from "./RequestBlock.js";
/**
* @since 2.0.0
*/
export * as RequestResolver from "./RequestResolver.js";
/**
* @since 2.0.0
*/
export * as Resource from "./Resource.js";
/**
* @since 2.0.0
*/
export * as Runtime from "./Runtime.js";
/**
* @since 2.0.0
*/
export * as RuntimeFlags from "./RuntimeFlags.js";
/**
* @since 2.0.0
*/
export * as RuntimeFlagsPatch from "./RuntimeFlagsPatch.js";
/**
* @since 2.0.0
*/
export * as STM from "./STM.js";
/**
* @since 2.0.0
*/
export * as Schedule from "./Schedule.js";
/**
* @since 2.0.0
*/
export * as ScheduleDecision from "./ScheduleDecision.js";
/**
* @since 2.0.0
*/
export * as ScheduleInterval from "./ScheduleInterval.js";
/**
* @since 2.0.0
*/
export * as ScheduleIntervals from "./ScheduleIntervals.js";
/**
* @since 2.0.0
*/
export * as Scheduler from "./Scheduler.js";
/**
* @since 3.10.0
*/
export * as Schema from "./Schema.js";
/**
* @since 3.10.0
*/
export * as SchemaAST from "./SchemaAST.js";
/**
* @since 2.0.0
*/
export * as Scope from "./Scope.js";
/**
* @since 2.0.0
*/
export * as ScopedCache from "./ScopedCache.js";
/**
* @since 2.0.0
*/
export * as ScopedRef from "./ScopedRef.js";
/**
* @since 2.0.0
* @deprecated
*/
export * as Secret from "./Secret.js";
/**
* @since 2.0.0
*/
export * as SingleProducerAsyncInput from "./SingleProducerAsyncInput.js";
/**
* @since 2.0.0
*/
export * as Sink from "./Sink.js";
/**
* @since 2.0.0
*/
export * as SortedMap from "./SortedMap.js";
/**
* @since 2.0.0
*/
export * as SortedSet from "./SortedSet.js";
/**
* @since 2.0.0
*/
export * as Stream from "./Stream.js";
/**
* @since 2.0.0
*/
export * as StreamEmit from "./StreamEmit.js";
/**
* @since 2.0.0
*/
export * as StreamHaltStrategy from "./StreamHaltStrategy.js";
/**
* @since 2.0.0
*/
export * as Streamable from "./Streamable.js";
/**
* This module provides utility functions and type class instances for working with the `string` type in TypeScript.
* It includes functions for basic string manipulation, as well as type class instances for
* `Equivalence` and `Order`.
*
* @since 2.0.0
*/
export * as String from "./String.js";
/**
* This module provides utility functions for working with structs in TypeScript.
*
* @since 2.0.0
*/
export * as Struct from "./Struct.js";
/**
* @since 2.0.0
*/
export * as Subscribable from "./Subscribable.js";
/**
* @since 2.0.0
*/
export * as SubscriptionRef from "./SubscriptionRef.js";
/**
* A `Supervisor<T>` is allowed to supervise the launching and termination of
* fibers, producing some visible value of type `T` from the supervision.
*
* @since 2.0.0
*/
export * as Supervisor from "./Supervisor.js";
/**
* @since 2.0.0
*/
export * as Symbol from "./Symbol.js";
/**
* @since 2.0.0
*/
export * as SynchronizedRef from "./SynchronizedRef.js";
/**
* @since 2.0.0
*/
export * as TArray from "./TArray.js";
/**
* @since 2.0.0
*/
export * as TDeferred from "./TDeferred.js";
/**
* @since 2.0.0
*/
export * as TMap from "./TMap.js";
/**
* @since 2.0.0
*/
export * as TPriorityQueue from "./TPriorityQueue.js";
/**
* @since 2.0.0
*/
export * as TPubSub from "./TPubSub.js";
/**
* @since 2.0.0
*/
export * as TQueue from "./TQueue.js";
/**
* @since 2.0.0
*/
export * as TRandom from "./TRandom.js";
/**
* @since 2.0.0
*/
export * as TReentrantLock from "./TReentrantLock.js";
/**
* @since 2.0.0
*/
export * as TRef from "./TRef.js";
/**
* @since 2.0.0
*/
export * as TSemaphore from "./TSemaphore.js";
/**
* @since 2.0.0
*/
export * as TSet from "./TSet.js";
/**
* @since 3.10.0
*/
export * as TSubscriptionRef from "./TSubscriptionRef.js";
/**
* @since 2.0.0
*/
export * as Take from "./Take.js";
/**
* @since 2.0.0
*/
export * as TestAnnotation from "./TestAnnotation.js";
/**
* @since 2.0.0
*/
export * as TestAnnotationMap from "./TestAnnotationMap.js";
/**
* @since 2.0.0
*/
export * as TestAnnotations from "./TestAnnotations.js";
/**
* @since 2.0.0
*/
export * as TestClock from "./TestClock.js";
/**
* @since 2.0.0
*/
export * as TestConfig from "./TestConfig.js";
/**
* @since 2.0.0
*/
export * as TestContext from "./TestContext.js";
/**
* @since 2.0.0
*/
export * as TestLive from "./TestLive.js";
/**
* @since 2.0.0
*/
export * as TestServices from "./TestServices.js";
/**
* @since 2.0.0
*/
export * as TestSized from "./TestSized.js";
/**
* @since 2.0.0
*/
export * as Tracer from "./Tracer.js";
/**
* A `Trie` is used for locating specific `string` keys from within a set.
*
* It works similar to `HashMap`, but with keys required to be `string`.
* This constraint unlocks some performance optimizations and new methods to get string prefixes (e.g. `keysWithPrefix`, `longestPrefixOf`).
*
* Prefix search is also the main feature that makes a `Trie` more suited than `HashMap` for certain usecases.
*
* A `Trie` is often used to store a dictionary (list of words) that can be searched
* in a manner that allows for efficient generation of completion lists
* (e.g. predict the rest of a word a user is typing).
*
* A `Trie` has O(n) lookup time where `n` is the size of the key,
* or even less than `n` on search misses.
*
* @since 2.0.0
*/
export * as Trie from "./Trie.js";
/**
* This module provides utility functions for working with tuples in TypeScript.
*
* @since 2.0.0
*/
export * as Tuple from "./Tuple.js";
/**
* A collection of types that are commonly used types.
*
* @since 2.0.0
*/
export * as Types from "./Types.js";
/**
* @since 2.0.0
*/
export * as Unify from "./Unify.js";
/**
* @since 2.0.0
*/
export * as UpstreamPullRequest from "./UpstreamPullRequest.js";
/**
* @since 2.0.0
*/
export * as UpstreamPullStrategy from "./UpstreamPullStrategy.js";
/**
* @since 2.0.0
*/
export * as Utils from "./Utils.js";
//# sourceMappingURL=index.d.ts.map