effect 4.0.0-beta.66 → 4.0.0-beta.68

package/dist/Trie.d.ts

@@ -23,9 +23,14 @@ import type { Result } from "./Result.ts";
 import type { Covariant, NoInfer } from "./Types.ts";
 declare const TypeId = "~effect/collections/Trie";
 /**
- * @example
+ * An immutable string-keyed map optimized for prefix lookup. Iteration yields
+ * `[key, value]` pairs in key order, and update operations such as insert and
+ * remove return new `Trie` values.
+ *
+ * **Example** (Using a trie for prefix search)
+ *
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  *
  * // Create a trie with string-to-number mappings
  * const trie: Trie.Trie<number> = Trie.make(
@@ -56,8 +61,8 @@ declare const TypeId = "~effect/collections/Trie";
  * console.log(Trie.size(trie)) // 4
  * ```
  *
- * @since 2.0.0
  * @category models
+ * @since 2.0.0
  */
 export interface Trie<in out Value> extends Iterable<[string, Value]>, Equal, Pipeable, Inspectable {
     readonly [TypeId]: {
@@ -67,9 +72,10 @@ export interface Trie<in out Value> extends Iterable<[string, Value]>, Equal, Pi
 /**
  * Creates an empty `Trie`.
  *
- * @example
+ * **Example** (Creating an empty trie)
+ *
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<string>()
@@ -78,17 +84,17 @@ export interface Trie<in out Value> extends Iterable<[string, Value]>, Equal, Pi
  * assert.deepStrictEqual(Array.from(trie), [])
  * ```
  *
- * @since 2.0.0
  * @category constructors
+ * @since 2.0.0
  */
 export declare const empty: <V = never>() => Trie<V>;
 /**
  * Creates a new `Trie` from an iterable collection of key/value pairs (e.g. `Array<[string, V]>`).
  *
- * @example
+ * **Example** (Creating a trie from entries)
+ *
  * ```ts
- * import * as Equal from "effect/Equal"
- * import * as Trie from "effect/Trie"
+ * import { Equal, Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const iterable: Array<readonly [string, number]> = [["call", 0], ["me", 1], [
@@ -111,17 +117,17 @@ export declare const empty: <V = never>() => Trie<V>;
  * )
  * ```
  *
- * @since 2.0.0
  * @category constructors
+ * @since 2.0.0
  */
 export declare const fromIterable: <V>(entries: Iterable<readonly [string, V]>) => Trie<V>;
 /**
  * Constructs a new `Trie` from the specified entries (`[string, V]`).
  *
- * @example
+ * **Example** (Constructing a trie from entries)
+ *
  * ```ts
- * import * as Equal from "effect/Equal"
- * import * as Trie from "effect/Trie"
+ * import { Equal, Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.make(["ca", 0], ["me", 1])
@@ -133,16 +139,17 @@ export declare const fromIterable: <V>(entries: Iterable<readonly [string, V]>)
  * )
  * ```
  *
- * @since 2.0.0
  * @category constructors
+ * @since 2.0.0
  */
 export declare const make: <Entries extends Array<readonly [string, any]>>(...entries: Entries) => Trie<Entries[number] extends readonly [any, infer V] ? V : never>;
 /**
  * Insert a new entry in the `Trie`.
  *
- * @example
+ * **Example** (Inserting entries)
+ *
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie1 = Trie.empty<number>().pipe(
@@ -161,16 +168,17 @@ export declare const make: <Entries extends Array<readonly [string, any]>>(...en
  * ]])
  * ```
  *
- * @since 2.0.0
  * @category mutations
+ * @since 2.0.0
  */
 export declare const insert: {
     /**
      * Insert a new entry in the `Trie`.
      *
-     * @example
+     * **Example** (Inserting entries)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie1 = Trie.empty<number>().pipe(
@@ -189,16 +197,17 @@ export declare const insert: {
      * ]])
      * ```
      *
-     * @since 2.0.0
      * @category mutations
+     * @since 2.0.0
      */
     <V>(key: string, value: V): (self: Trie<V>) => Trie<V>;
     /**
      * Insert a new entry in the `Trie`.
      *
-     * @example
+     * **Example** (Inserting entries)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie1 = Trie.empty<number>().pipe(
@@ -217,8 +226,8 @@ export declare const insert: {
      * ]])
      * ```
      *
-     * @since 2.0.0
      * @category mutations
+     * @since 2.0.0
      */
     <V>(self: Trie<V>, key: string, value: V): Trie<V>;
 };
@@ -227,9 +236,10 @@ export declare const insert: {
  *
  * The keys are returned in alphabetical order, regardless of insertion order.
  *
- * @example
+ * **Example** (Reading keys in alphabetical order)
+ *
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -242,8 +252,8 @@ export declare const insert: {
  * assert.deepStrictEqual(result, ["abc", "bca", "cab"])
  * ```
  *
- * @since 2.0.0
  * @category getters
+ * @since 2.0.0
  */
 export declare const keys: <V>(self: Trie<V>) => IterableIterator<string>;
 /**
@@ -251,9 +261,10 @@ export declare const keys: <V>(self: Trie<V>) => IterableIterator<string>;
  *
  * Values are ordered based on their key in alphabetical order, regardless of insertion order.
  *
- * @example
+ * **Example** (Reading values by key order)
+ *
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -266,8 +277,8 @@ export declare const keys: <V>(self: Trie<V>) => IterableIterator<string>;
  * assert.deepStrictEqual(result, [2, 0, 1])
  * ```
  *
- * @since 2.0.0
  * @category getters
+ * @since 2.0.0
  */
 export declare const values: <V>(self: Trie<V>) => IterableIterator<V>;
 /**
@@ -275,9 +286,10 @@ export declare const values: <V>(self: Trie<V>) => IterableIterator<V>;
  *
  * The entries are returned by keys in alphabetical order, regardless of insertion order.
  *
- * @example
+ * **Example** (Reading entries in alphabetical order)
+ *
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -289,18 +301,19 @@ export declare const values: <V>(self: Trie<V>) => IterableIterator<V>;
  * assert.deepStrictEqual(result, [["call", 0], ["me", 1]])
  * ```
  *
- * @since 2.0.0
  * @category getters
+ * @since 2.0.0
  */
 export declare const entries: <V>(self: Trie<V>) => IterableIterator<[string, V]>;
 /**
- * Returns an `Array<[K, V]>` of the entries within the `Trie`.
+ * Returns an `Array<[string, V]>` of the entries within the `Trie`.
  *
  * Equivalent to `Array.from(Trie.entries(trie))`.
  *
- * @example
+ * **Example** (Converting entries to an array)
+ *
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -312,17 +325,18 @@ export declare const entries: <V>(self: Trie<V>) => IterableIterator<[string, V]
  * assert.deepStrictEqual(result, [["call", 0], ["me", 1]])
  * ```
  *
- * @since 2.0.0
  * @category getters
+ * @since 2.0.0
  */
 export declare const toEntries: <V>(self: Trie<V>) => Array<[string, V]>;
 /**
  * Returns an `IterableIterator` of the keys within the `Trie`
  * that have `prefix` as prefix (`prefix` included if it exists).
  *
- * @example
+ * **Example** (Finding keys with a prefix)
+ *
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -336,17 +350,18 @@ export declare const toEntries: <V>(self: Trie<V>) => Array<[string, V]>;
  * assert.deepStrictEqual(result, ["she", "shells"])
  * ```
  *
- * @since 2.0.0
  * @category getters
+ * @since 2.0.0
  */
 export declare const keysWithPrefix: {
     /**
      * Returns an `IterableIterator` of the keys within the `Trie`
      * that have `prefix` as prefix (`prefix` included if it exists).
      *
-     * @example
+     * **Example** (Finding keys with a prefix)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -360,17 +375,18 @@ export declare const keysWithPrefix: {
      * assert.deepStrictEqual(result, ["she", "shells"])
      * ```
      *
-     * @since 2.0.0
      * @category getters
+     * @since 2.0.0
      */
     (prefix: string): <V>(self: Trie<V>) => IterableIterator<string>;
     /**
      * Returns an `IterableIterator` of the keys within the `Trie`
      * that have `prefix` as prefix (`prefix` included if it exists).
      *
-     * @example
+     * **Example** (Finding keys with a prefix)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -384,8 +400,8 @@ export declare const keysWithPrefix: {
      * assert.deepStrictEqual(result, ["she", "shells"])
      * ```
      *
-     * @since 2.0.0
      * @category getters
+     * @since 2.0.0
      */
     <V>(self: Trie<V>, prefix: string): IterableIterator<string>;
 };
@@ -393,9 +409,10 @@ export declare const keysWithPrefix: {
  * Returns an `IterableIterator` of the values within the `Trie`
  * that have `prefix` as prefix (`prefix` included if it exists).
  *
- * @example
+ * **Example** (Finding values with a prefix)
+ *
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -411,17 +428,18 @@ export declare const keysWithPrefix: {
  * assert.deepStrictEqual(result, [0, 1])
  * ```
  *
- * @since 2.0.0
  * @category getters
+ * @since 2.0.0
  */
 export declare const valuesWithPrefix: {
     /**
      * Returns an `IterableIterator` of the values within the `Trie`
      * that have `prefix` as prefix (`prefix` included if it exists).
      *
-     * @example
+     * **Example** (Finding values with a prefix)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -437,17 +455,18 @@ export declare const valuesWithPrefix: {
      * assert.deepStrictEqual(result, [0, 1])
      * ```
      *
-     * @since 2.0.0
      * @category getters
+     * @since 2.0.0
      */
     (prefix: string): <V>(self: Trie<V>) => IterableIterator<V>;
     /**
      * Returns an `IterableIterator` of the values within the `Trie`
      * that have `prefix` as prefix (`prefix` included if it exists).
      *
-     * @example
+     * **Example** (Finding values with a prefix)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -463,8 +482,8 @@ export declare const valuesWithPrefix: {
      * assert.deepStrictEqual(result, [0, 1])
      * ```
      *
-     * @since 2.0.0
      * @category getters
+     * @since 2.0.0
      */
     <V>(self: Trie<V>, prefix: string): IterableIterator<V>;
 };
@@ -472,9 +491,10 @@ export declare const valuesWithPrefix: {
  * Returns an `IterableIterator` of the entries within the `Trie`
  * that have `prefix` as prefix (`prefix` included if it exists).
  *
- * @example
+ * **Example** (Finding entries with a prefix)
+ *
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -488,17 +508,18 @@ export declare const valuesWithPrefix: {
  * assert.deepStrictEqual(result, [["she", 0], ["shells", 1]])
  * ```
  *
- * @since 2.0.0
  * @category getters
+ * @since 2.0.0
  */
 export declare const entriesWithPrefix: {
     /**
      * Returns an `IterableIterator` of the entries within the `Trie`
      * that have `prefix` as prefix (`prefix` included if it exists).
      *
-     * @example
+     * **Example** (Finding entries with a prefix)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -512,17 +533,18 @@ export declare const entriesWithPrefix: {
      * assert.deepStrictEqual(result, [["she", 0], ["shells", 1]])
      * ```
      *
-     * @since 2.0.0
      * @category getters
+     * @since 2.0.0
      */
     (prefix: string): <V>(self: Trie<V>) => IterableIterator<[string, V]>;
     /**
      * Returns an `IterableIterator` of the entries within the `Trie`
      * that have `prefix` as prefix (`prefix` included if it exists).
      *
-     * @example
+     * **Example** (Finding entries with a prefix)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -536,18 +558,19 @@ export declare const entriesWithPrefix: {
      * assert.deepStrictEqual(result, [["she", 0], ["shells", 1]])
      * ```
      *
-     * @since 2.0.0
      * @category getters
+     * @since 2.0.0
      */
     <V>(self: Trie<V>, prefix: string): IterableIterator<[string, V]>;
 };
 /**
- * Returns `Array<[K, V]>` of the entries within the `Trie`
- * that have `prefix` as prefix (`prefix` included if it exists).
+ * Returns an `Array<[string, V]>` of the entries within the `Trie` whose keys
+ * start with `prefix`, including the entry for `prefix` itself when it exists.
+ *
+ * **Example** (Converting prefixed entries to an array)
  *
- * @example
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -561,17 +584,18 @@ export declare const entriesWithPrefix: {
  * assert.deepStrictEqual(result, [["she", 3], ["shells", 0]])
  * ```
  *
- * @since 2.0.0
  * @category getters
+ * @since 2.0.0
  */
 export declare const toEntriesWithPrefix: {
     /**
-     * Returns `Array<[K, V]>` of the entries within the `Trie`
-     * that have `prefix` as prefix (`prefix` included if it exists).
+     * Returns an `Array<[string, V]>` of the entries within the `Trie` whose keys
+     * start with `prefix`, including the entry for `prefix` itself when it exists.
+     *
+     * **Example** (Converting prefixed entries to an array)
      *
-     * @example
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -585,17 +609,18 @@ export declare const toEntriesWithPrefix: {
      * assert.deepStrictEqual(result, [["she", 3], ["shells", 0]])
      * ```
      *
-     * @since 2.0.0
      * @category getters
+     * @since 2.0.0
      */
     (prefix: string): <V>(self: Trie<V>) => Array<[string, V]>;
     /**
-     * Returns `Array<[K, V]>` of the entries within the `Trie`
-     * that have `prefix` as prefix (`prefix` included if it exists).
+     * Returns an `Array<[string, V]>` of the entries within the `Trie` whose keys
+     * start with `prefix`, including the entry for `prefix` itself when it exists.
+     *
+     * **Example** (Converting prefixed entries to an array)
      *
-     * @example
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -609,8 +634,8 @@ export declare const toEntriesWithPrefix: {
      * assert.deepStrictEqual(result, [["she", 3], ["shells", 0]])
      * ```
      *
-     * @since 2.0.0
      * @category getters
+     * @since 2.0.0
      */
     <V>(self: Trie<V>, prefix: string): Array<[string, V]>;
 };
@@ -618,9 +643,10 @@ export declare const toEntriesWithPrefix: {
  * Returns the longest key/value in the `Trie`
  * that is a prefix of that `key` if it exists, `None` otherwise.
  *
- * @example
+ * **Example** (Finding the longest prefix)
+ *
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -639,17 +665,18 @@ export declare const toEntriesWithPrefix: {
  * }
  * ```
  *
- * @since 2.0.0
  * @category getters
+ * @since 2.0.0
  */
 export declare const longestPrefixOf: {
     /**
      * Returns the longest key/value in the `Trie`
      * that is a prefix of that `key` if it exists, `None` otherwise.
      *
-     * @example
+     * **Example** (Finding the longest prefix)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -668,17 +695,18 @@ export declare const longestPrefixOf: {
      * }
      * ```
      *
-     * @since 2.0.0
      * @category getters
+     * @since 2.0.0
      */
     (key: string): <V>(self: Trie<V>) => Option<[string, V]>;
     /**
      * Returns the longest key/value in the `Trie`
      * that is a prefix of that `key` if it exists, `None` otherwise.
      *
-     * @example
+     * **Example** (Finding the longest prefix)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -697,17 +725,18 @@ export declare const longestPrefixOf: {
      * }
      * ```
      *
-     * @since 2.0.0
      * @category getters
+     * @since 2.0.0
      */
     <V>(self: Trie<V>, key: string): Option<[string, V]>;
 };
 /**
  * Returns the size of the `Trie` (number of entries in the `Trie`).
  *
- * @example
+ * **Example** (Getting the size)
+ *
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -718,17 +747,17 @@ export declare const longestPrefixOf: {
  * assert.equal(Trie.size(trie), 2)
  * ```
  *
- * @since 2.0.0
  * @category getters
+ * @since 2.0.0
  */
 export declare const size: <V>(self: Trie<V>) => number;
 /**
  * Safely lookup the value for the specified key in the `Trie`.
  *
- * @example
+ * **Example** (Looking up values safely)
+ *
  * ```ts
- * import * as Option from "effect/Option"
- * import * as Trie from "effect/Trie"
+ * import { Option, Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -748,17 +777,17 @@ export declare const size: <V>(self: Trie<V>) => number;
  * assert.deepStrictEqual(Trie.get(trie, "mea"), Option.none())
  * ```
  *
- * @since 2.0.0
  * @category elements
+ * @since 2.0.0
  */
 export declare const get: {
     /**
      * Safely lookup the value for the specified key in the `Trie`.
      *
-     * @example
+     * **Example** (Looking up values safely)
+     *
      * ```ts
-     * import * as Option from "effect/Option"
-     * import * as Trie from "effect/Trie"
+     * import { Option, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -778,17 +807,17 @@ export declare const get: {
      * assert.deepStrictEqual(Trie.get(trie, "mea"), Option.none())
      * ```
      *
-     * @since 2.0.0
      * @category elements
+     * @since 2.0.0
      */
     (key: string): <V>(self: Trie<V>) => Option<V>;
     /**
      * Safely lookup the value for the specified key in the `Trie`.
      *
-     * @example
+     * **Example** (Looking up values safely)
+     *
      * ```ts
-     * import * as Option from "effect/Option"
-     * import * as Trie from "effect/Trie"
+     * import { Option, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -808,17 +837,18 @@ export declare const get: {
      * assert.deepStrictEqual(Trie.get(trie, "mea"), Option.none())
      * ```
      *
-     * @since 2.0.0
      * @category elements
+     * @since 2.0.0
      */
     <V>(self: Trie<V>, key: string): Option<V>;
 };
 /**
  * Check if the given key exists in the `Trie`.
  *
- * @example
+ * **Example** (Checking key membership)
+ *
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -838,16 +868,17 @@ export declare const get: {
  * assert.equal(Trie.has(trie, "mea"), false)
  * ```
  *
- * @since 2.0.0
  * @category elements
+ * @since 2.0.0
  */
 export declare const has: {
     /**
      * Check if the given key exists in the `Trie`.
      *
-     * @example
+     * **Example** (Checking key membership)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -867,16 +898,17 @@ export declare const has: {
      * assert.equal(Trie.has(trie, "mea"), false)
      * ```
      *
-     * @since 2.0.0
      * @category elements
+     * @since 2.0.0
      */
     (key: string): <V>(self: Trie<V>) => boolean;
     /**
      * Check if the given key exists in the `Trie`.
      *
-     * @example
+     * **Example** (Checking key membership)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -896,17 +928,18 @@ export declare const has: {
      * assert.equal(Trie.has(trie, "mea"), false)
      * ```
      *
-     * @since 2.0.0
      * @category elements
+     * @since 2.0.0
      */
     <V>(self: Trie<V>, key: string): boolean;
 };
 /**
- * Checks if the `Trie` contains any entries.
+ * Returns `true` when the `Trie` contains no entries.
+ *
+ * **Example** (Checking whether a trie is empty)
  *
- * @example
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>()
@@ -916,8 +949,8 @@ export declare const has: {
  * assert.equal(Trie.isEmpty(trie1), false)
  * ```
  *
- * @since 2.0.0
  * @category elements
+ * @since 2.0.0
  */
 export declare const isEmpty: <V>(self: Trie<V>) => boolean;
 /**
@@ -926,9 +959,10 @@ export declare const isEmpty: <V>(self: Trie<V>) => boolean;
  * `getUnsafe` will throw if the key is not found. Use `get` instead to safely
  * get a value from the `Trie`.
  *
- * @example
+ * **Example** (Looking up values unsafely)
+ *
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -939,8 +973,8 @@ export declare const isEmpty: <V>(self: Trie<V>) => boolean;
  * assert.throws(() => Trie.getUnsafe(trie, "mae"))
  * ```
  *
- * @since 2.0.0
  * @category unsafe
+ * @since 4.0.0
  */
 export declare const getUnsafe: {
     /**
@@ -949,9 +983,10 @@ export declare const getUnsafe: {
      * `getUnsafe` will throw if the key is not found. Use `get` instead to safely
      * get a value from the `Trie`.
      *
-     * @example
+     * **Example** (Looking up values unsafely)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -962,8 +997,8 @@ export declare const getUnsafe: {
      * assert.throws(() => Trie.getUnsafe(trie, "mae"))
      * ```
      *
-     * @since 2.0.0
      * @category unsafe
+     * @since 4.0.0
      */
     (key: string): <V>(self: Trie<V>) => V;
     /**
@@ -972,9 +1007,10 @@ export declare const getUnsafe: {
      * `getUnsafe` will throw if the key is not found. Use `get` instead to safely
      * get a value from the `Trie`.
      *
-     * @example
+     * **Example** (Looking up values unsafely)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -985,18 +1021,18 @@ export declare const getUnsafe: {
      * assert.throws(() => Trie.getUnsafe(trie, "mae"))
      * ```
      *
-     * @since 2.0.0
      * @category unsafe
+     * @since 4.0.0
      */
     <V>(self: Trie<V>, key: string): V;
 };
 /**
  * Remove the entry for the specified key in the `Trie`.
  *
- * @example
+ * **Example** (Removing entries)
+ *
  * ```ts
- * import * as Option from "effect/Option"
- * import * as Trie from "effect/Trie"
+ * import { Option, Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -1014,17 +1050,17 @@ export declare const getUnsafe: {
  * assert.deepStrictEqual(Trie.get(trie2, "call"), Option.none())
  * ```
  *
- * @since 2.0.0
  * @category mutations
+ * @since 2.0.0
  */
 export declare const remove: {
     /**
      * Remove the entry for the specified key in the `Trie`.
      *
-     * @example
+     * **Example** (Removing entries)
+     *
      * ```ts
-     * import * as Option from "effect/Option"
-     * import * as Trie from "effect/Trie"
+     * import { Option, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1042,17 +1078,17 @@ export declare const remove: {
      * assert.deepStrictEqual(Trie.get(trie2, "call"), Option.none())
      * ```
      *
-     * @since 2.0.0
      * @category mutations
+     * @since 2.0.0
      */
     (key: string): <V>(self: Trie<V>) => Trie<V>;
     /**
      * Remove the entry for the specified key in the `Trie`.
      *
-     * @example
+     * **Example** (Removing entries)
+     *
      * ```ts
-     * import * as Option from "effect/Option"
-     * import * as Trie from "effect/Trie"
+     * import { Option, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1070,17 +1106,18 @@ export declare const remove: {
      * assert.deepStrictEqual(Trie.get(trie2, "call"), Option.none())
      * ```
      *
-     * @since 2.0.0
      * @category mutations
+     * @since 2.0.0
      */
     <V>(self: Trie<V>, key: string): Trie<V>;
 };
 /**
  * Reduce a state over the entries of the `Trie`.
  *
- * @example
+ * **Example** (Reducing entries)
+ *
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -1109,16 +1146,17 @@ export declare const remove: {
  * )
  * ```
  *
- * @since 2.0.0
  * @category folding
+ * @since 2.0.0
  */
 export declare const reduce: {
     /**
      * Reduce a state over the entries of the `Trie`.
      *
-     * @example
+     * **Example** (Reducing entries)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1147,16 +1185,17 @@ export declare const reduce: {
      * )
      * ```
      *
-     * @since 2.0.0
      * @category folding
+     * @since 2.0.0
      */
     <Z, V>(zero: Z, f: (accumulator: Z, value: V, key: string) => Z): (self: Trie<V>) => Z;
     /**
      * Reduce a state over the entries of the `Trie`.
      *
-     * @example
+     * **Example** (Reducing entries)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1185,18 +1224,18 @@ export declare const reduce: {
      * )
      * ```
      *
-     * @since 2.0.0
      * @category folding
+     * @since 2.0.0
      */
     <Z, V>(self: Trie<V>, zero: Z, f: (accumulator: Z, value: V, key: string) => Z): Z;
 };
 /**
  * Maps over the entries of the `Trie` using the specified function.
  *
- * @example
+ * **Example** (Mapping entries)
+ *
  * ```ts
- * import * as Equal from "effect/Equal"
- * import * as Trie from "effect/Trie"
+ * import { Equal, Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -1221,17 +1260,17 @@ export declare const reduce: {
  * assert.equal(Equal.equals(Trie.map(trie, (_, k) => k.length), trieMapK), true)
  * ```
  *
- * @since 2.0.0
  * @category folding
+ * @since 2.0.0
  */
 export declare const map: {
     /**
      * Maps over the entries of the `Trie` using the specified function.
      *
-     * @example
+     * **Example** (Mapping entries)
+     *
      * ```ts
-     * import * as Equal from "effect/Equal"
-     * import * as Trie from "effect/Trie"
+     * import { Equal, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1256,17 +1295,17 @@ export declare const map: {
      * assert.equal(Equal.equals(Trie.map(trie, (_, k) => k.length), trieMapK), true)
      * ```
      *
-     * @since 2.0.0
      * @category folding
+     * @since 2.0.0
      */
     <A, V>(f: (value: V, key: string) => A): (self: Trie<V>) => Trie<A>;
     /**
      * Maps over the entries of the `Trie` using the specified function.
      *
-     * @example
+     * **Example** (Mapping entries)
+     *
      * ```ts
-     * import * as Equal from "effect/Equal"
-     * import * as Trie from "effect/Trie"
+     * import { Equal, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1291,18 +1330,18 @@ export declare const map: {
      * assert.equal(Equal.equals(Trie.map(trie, (_, k) => k.length), trieMapK), true)
      * ```
      *
-     * @since 2.0.0
      * @category folding
+     * @since 2.0.0
      */
     <V, A>(self: Trie<V>, f: (value: V, key: string) => A): Trie<A>;
 };
 /**
  * Filters entries out of a `Trie` using the specified predicate.
  *
- * @example
+ * **Example** (Filtering entries)
+ *
  * ```ts
- * import * as Equal from "effect/Equal"
- * import * as Trie from "effect/Trie"
+ * import { Equal, Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -1327,17 +1366,17 @@ export declare const map: {
  * )
  * ```
  *
- * @since 2.0.0
  * @category filtering
+ * @since 2.0.0
  */
 export declare const filter: {
     /**
      * Filters entries out of a `Trie` using the specified predicate.
      *
-     * @example
+     * **Example** (Filtering entries)
+     *
      * ```ts
-     * import * as Equal from "effect/Equal"
-     * import * as Trie from "effect/Trie"
+     * import { Equal, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1362,17 +1401,17 @@ export declare const filter: {
      * )
      * ```
      *
-     * @since 2.0.0
      * @category filtering
+     * @since 2.0.0
      */
     <A, B extends A>(f: (a: NoInfer<A>, k: string) => a is B): (self: Trie<A>) => Trie<B>;
     /**
      * Filters entries out of a `Trie` using the specified predicate.
      *
-     * @example
+     * **Example** (Filtering entries)
+     *
      * ```ts
-     * import * as Equal from "effect/Equal"
-     * import * as Trie from "effect/Trie"
+     * import { Equal, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1397,17 +1436,17 @@ export declare const filter: {
      * )
      * ```
      *
-     * @since 2.0.0
      * @category filtering
+     * @since 2.0.0
      */
     <A>(f: (a: NoInfer<A>, k: string) => boolean): (self: Trie<A>) => Trie<A>;
     /**
      * Filters entries out of a `Trie` using the specified predicate.
      *
-     * @example
+     * **Example** (Filtering entries)
+     *
      * ```ts
-     * import * as Equal from "effect/Equal"
-     * import * as Trie from "effect/Trie"
+     * import { Equal, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1432,17 +1471,17 @@ export declare const filter: {
      * )
      * ```
      *
-     * @since 2.0.0
      * @category filtering
+     * @since 2.0.0
      */
     <A, B extends A>(self: Trie<A>, f: (a: A, k: string) => a is B): Trie<B>;
     /**
      * Filters entries out of a `Trie` using the specified predicate.
      *
-     * @example
+     * **Example** (Filtering entries)
+     *
      * ```ts
-     * import * as Equal from "effect/Equal"
-     * import * as Trie from "effect/Trie"
+     * import { Equal, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1467,8 +1506,8 @@ export declare const filter: {
      * )
      * ```
      *
-     * @since 2.0.0
      * @category filtering
+     * @since 2.0.0
      */
     <A>(self: Trie<A>, f: (a: A, k: string) => boolean): Trie<A>;
 };
@@ -1476,11 +1515,10 @@ export declare const filter: {
  * Maps over the entries of the `Trie` using the specified filter and keeps
  * only successful results.
  *
- * @example
+ * **Example** (Filtering and mapping entries)
+ *
  * ```ts
- * import * as Equal from "effect/Equal"
- * import * as Result from "effect/Result"
- * import * as Trie from "effect/Trie"
+ * import { Equal, Result, Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -1517,19 +1555,18 @@ export declare const filter: {
  * )
  * ```
  *
- * @since 2.0.0
  * @category filtering
+ * @since 2.0.0
  */
 export declare const filterMap: {
     /**
      * Maps over the entries of the `Trie` using the specified filter and keeps
      * only successful results.
      *
-     * @example
+     * **Example** (Filtering and mapping entries)
+     *
      * ```ts
-     * import * as Equal from "effect/Equal"
-     * import * as Result from "effect/Result"
-     * import * as Trie from "effect/Trie"
+     * import { Equal, Result, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1566,19 +1603,18 @@ export declare const filterMap: {
      * )
      * ```
      *
-     * @since 2.0.0
      * @category filtering
+     * @since 2.0.0
      */
     <A, B, X>(f: (input: A, key: string) => Result<B, X>): (self: Trie<A>) => Trie<B>;
     /**
      * Maps over the entries of the `Trie` using the specified filter and keeps
      * only successful results.
      *
-     * @example
+     * **Example** (Filtering and mapping entries)
+     *
      * ```ts
-     * import * as Equal from "effect/Equal"
-     * import * as Result from "effect/Result"
-     * import * as Trie from "effect/Trie"
+     * import { Equal, Result, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1615,19 +1651,18 @@ export declare const filterMap: {
      * )
      * ```
      *
-     * @since 2.0.0
      * @category filtering
+     * @since 2.0.0
      */
     <A, B, X>(self: Trie<A>, f: (input: A, key: string) => Result<B, X>): Trie<B>;
 };
 /**
  * Filters out `None` values from a `Trie` of `Options`s.
  *
- * @example
+ * **Example** (Compacting optional values)
+ *
  * ```ts
- * import * as Equal from "effect/Equal"
- * import * as Option from "effect/Option"
- * import * as Trie from "effect/Trie"
+ * import { Equal, Option, Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<Option.Option<number>>().pipe(
@@ -1644,16 +1679,17 @@ export declare const filterMap: {
  * assert.equal(Equal.equals(Trie.compact(trie), trieMapV), true)
  * ```
  *
- * @since 2.0.0
  * @category filtering
+ * @since 2.0.0
  */
 export declare const compact: <A>(self: Trie<Option<A>>) => Trie<A>;
 /**
  * Applies the specified function to the entries of the `Trie`.
  *
- * @example
+ * **Example** (Iterating over entries)
+ *
  * ```ts
- * import * as Trie from "effect/Trie"
+ * import { Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * let value = 0
@@ -1670,16 +1706,17 @@ export declare const compact: <A>(self: Trie<Option<A>>) => Trie<A>;
  * assert.equal(value, 17)
  * ```
  *
- * @since 2.0.0
  * @category traversing
+ * @since 2.0.0
  */
 export declare const forEach: {
     /**
      * Applies the specified function to the entries of the `Trie`.
      *
-     * @example
+     * **Example** (Iterating over entries)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * let value = 0
@@ -1696,16 +1733,17 @@ export declare const forEach: {
      * assert.equal(value, 17)
      * ```
      *
-     * @since 2.0.0
      * @category traversing
+     * @since 2.0.0
      */
     <V>(f: (value: V, key: string) => void): (self: Trie<V>) => void;
     /**
      * Applies the specified function to the entries of the `Trie`.
      *
-     * @example
+     * **Example** (Iterating over entries)
+     *
      * ```ts
-     * import * as Trie from "effect/Trie"
+     * import { Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * let value = 0
@@ -1722,19 +1760,18 @@ export declare const forEach: {
      * assert.equal(value, 17)
      * ```
      *
-     * @since 2.0.0
      * @category traversing
+     * @since 2.0.0
      */
     <V>(self: Trie<V>, f: (value: V, key: string) => void): void;
 };
 /**
  * Updates the value of the specified key within the `Trie` if it exists.
  *
- * @example
+ * **Example** (Modifying an existing value)
+ *
  * ```ts
- * import * as Equal from "effect/Equal"
- * import * as Option from "effect/Option"
- * import * as Trie from "effect/Trie"
+ * import { Equal, Option, Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -1751,18 +1788,17 @@ export declare const forEach: {
  * assert.equal(Equal.equals(trie.pipe(Trie.modify("me", (v) => v)), trie), true)
  * ```
  *
- * @since 2.0.0
  * @category mutations
+ * @since 2.0.0
  */
 export declare const modify: {
     /**
      * Updates the value of the specified key within the `Trie` if it exists.
      *
-     * @example
+     * **Example** (Modifying an existing value)
+     *
      * ```ts
-     * import * as Equal from "effect/Equal"
-     * import * as Option from "effect/Option"
-     * import * as Trie from "effect/Trie"
+     * import { Equal, Option, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1779,18 +1815,17 @@ export declare const modify: {
      * assert.equal(Equal.equals(trie.pipe(Trie.modify("me", (v) => v)), trie), true)
      * ```
      *
-     * @since 2.0.0
      * @category mutations
+     * @since 2.0.0
      */
     <V>(key: string, f: (v: V) => V): (self: Trie<V>) => Trie<V>;
     /**
      * Updates the value of the specified key within the `Trie` if it exists.
      *
-     * @example
+     * **Example** (Modifying an existing value)
+     *
      * ```ts
-     * import * as Equal from "effect/Equal"
-     * import * as Option from "effect/Option"
-     * import * as Trie from "effect/Trie"
+     * import { Equal, Option, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1807,18 +1842,18 @@ export declare const modify: {
      * assert.equal(Equal.equals(trie.pipe(Trie.modify("me", (v) => v)), trie), true)
      * ```
      *
-     * @since 2.0.0
      * @category mutations
+     * @since 2.0.0
      */
     <V>(self: Trie<V>, key: string, f: (v: V) => V): Trie<V>;
 };
 /**
  * Removes all entries in the `Trie` which have the specified keys.
  *
- * @example
+ * **Example** (Removing multiple entries)
+ *
  * ```ts
- * import * as Equal from "effect/Equal"
- * import * as Trie from "effect/Trie"
+ * import { Equal, Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -1836,17 +1871,17 @@ export declare const modify: {
  * )
  * ```
  *
- * @since 2.0.0
  * @category mutations
+ * @since 2.0.0
  */
 export declare const removeMany: {
     /**
      * Removes all entries in the `Trie` which have the specified keys.
      *
-     * @example
+     * **Example** (Removing multiple entries)
+     *
      * ```ts
-     * import * as Equal from "effect/Equal"
-     * import * as Trie from "effect/Trie"
+     * import { Equal, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1864,17 +1899,17 @@ export declare const removeMany: {
      * )
      * ```
      *
-     * @since 2.0.0
      * @category mutations
+     * @since 2.0.0
      */
     (keys: Iterable<string>): <V>(self: Trie<V>) => Trie<V>;
     /**
      * Removes all entries in the `Trie` which have the specified keys.
      *
-     * @example
+     * **Example** (Removing multiple entries)
+     *
      * ```ts
-     * import * as Equal from "effect/Equal"
-     * import * as Trie from "effect/Trie"
+     * import { Equal, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1892,18 +1927,18 @@ export declare const removeMany: {
      * )
      * ```
      *
-     * @since 2.0.0
      * @category mutations
+     * @since 2.0.0
      */
     <V>(self: Trie<V>, keys: Iterable<string>): Trie<V>;
 };
 /**
  * Insert multiple entries in the `Trie` at once.
  *
- * @example
+ * **Example** (Inserting multiple entries)
+ *
  * ```ts
- * import * as Equal from "effect/Equal"
- * import * as Trie from "effect/Trie"
+ * import { Equal, Trie } from "effect"
  * import * as assert from "node:assert"
  *
  * const trie = Trie.empty<number>().pipe(
@@ -1925,17 +1960,17 @@ export declare const removeMany: {
  * )
  * ```
  *
- * @since 2.0.0
  * @category mutations
+ * @since 2.0.0
  */
 export declare const insertMany: {
     /**
      * Insert multiple entries in the `Trie` at once.
      *
-     * @example
+     * **Example** (Inserting multiple entries)
+     *
      * ```ts
-     * import * as Equal from "effect/Equal"
-     * import * as Trie from "effect/Trie"
+     * import { Equal, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1957,17 +1992,17 @@ export declare const insertMany: {
      * )
      * ```
      *
-     * @since 2.0.0
      * @category mutations
+     * @since 2.0.0
      */
     <V>(iter: Iterable<[string, V]>): (self: Trie<V>) => Trie<V>;
     /**
      * Insert multiple entries in the `Trie` at once.
      *
-     * @example
+     * **Example** (Inserting multiple entries)
+     *
      * ```ts
-     * import * as Equal from "effect/Equal"
-     * import * as Trie from "effect/Trie"
+     * import { Equal, Trie } from "effect"
      * import * as assert from "node:assert"
      *
      * const trie = Trie.empty<number>().pipe(
@@ -1989,8 +2024,8 @@ export declare const insertMany: {
      * )
      * ```
      *
-     * @since 2.0.0
      * @category mutations
+     * @since 2.0.0
      */
     <V>(self: Trie<V>, iter: Iterable<[string, V]>): Trie<V>;
 };