effect 4.0.0-beta.69 → 4.0.0-beta.70

package/src/Graph.ts

@@ -2301,8 +2301,10 @@ export const neighborsDirected: {
 /**
  * Configuration options for GraphViz DOT format generation from graphs.
  *
- * Provides customization for node labels, edge labels, and graph naming
- * in DOT format compatible with GraphViz tools.
+ * **Details**
+ *
+ * These options customize node labels, edge labels, and graph naming in DOT
+ * format compatible with GraphViz tools.
  *
  * **Example** (Configuring GraphViz labels)
  *
@@ -2488,6 +2490,8 @@ export const toGraphViz: {
 /**
  * Mermaid node shape types for diagram visualization.
  *
+ * **Details**
+ *
  * Each shape produces different visual representations in Mermaid diagrams:
  * - `rectangle`: Standard rectangular nodes `A["label"]`
  * - `rounded`: Rounded rectangular nodes `A("label")`
@@ -2533,6 +2537,8 @@ export type MermaidNodeShape =
 /**
  * Mermaid diagram direction types for controlling layout orientation.
  *
+ * **Details**
+ *
  * Determines the flow direction of nodes and edges in the diagram:
  * - `TB`/`TD`: Top to Bottom (vertical layout, default)
  * - `BT`: Bottom to Top (reverse vertical)
@@ -2573,6 +2579,8 @@ export type MermaidDirection =
 /**
  * Mermaid diagram types for different visualization formats.
  *
+ * **Details**
+ *
  * Specifies the Mermaid diagram syntax to use:
  * - `flowchart`: For directed graphs with arrows (`A --> B`)
  * - `graph`: For undirected graphs with lines (`A --- B`)
@@ -2615,8 +2623,10 @@ export type MermaidDiagramType =
 /**
  * Configuration options for Mermaid diagram generation from graphs.
  *
- * Provides customization for node labels, edge labels, diagram type,
- * layout direction, node shapes, and graph naming in Mermaid format.
+ * **Details**
+ *
+ * These options customize node labels, edge labels, diagram type, layout
+ * direction, node shapes, and graph naming in Mermaid format.
  *
  * **Example** (Configuring Mermaid output)
  *
@@ -2731,6 +2741,8 @@ const formatMermaidNode = (
 /**
  * Exports a graph to Mermaid diagram format for visualization.
  *
+ * **Details**
+ *
  * Mermaid is a popular diagram-as-code tool that generates flowcharts and other
  * visualizations from text-based definitions. This function converts Effect Graph
  * structures to valid Mermaid syntax for use in documentation, web applications,
@@ -2909,6 +2921,8 @@ export const toMermaid: {
   /**
    * Exports a graph to Mermaid diagram format for visualization.
    *
+   * **Details**
+   *
    * Mermaid is a popular diagram-as-code tool that generates flowcharts and other
    * visualizations from text-based definitions. This function converts Effect Graph
    * structures to valid Mermaid syntax for use in documentation, web applications,
@@ -3087,6 +3101,8 @@ export const toMermaid: {
   /**
    * Exports a graph to Mermaid diagram format for visualization.
    *
+   * **Details**
+   *
    * Mermaid is a popular diagram-as-code tool that generates flowcharts and other
    * visualizations from text-based definitions. This function converts Effect Graph
    * structures to valid Mermaid syntax for use in documentation, web applications,
@@ -3353,6 +3369,8 @@ export type Direction = "outgoing" | "incoming"
 /**
  * Checks if the graph is acyclic (contains no cycles).
  *
+ * **Details**
+ *
  * Uses depth-first search to detect back edges, which indicate cycles.
  * For directed graphs, any back edge creates a cycle. For undirected graphs,
  * a back edge that doesn't go to the immediate parent creates a cycle.
@@ -3464,6 +3482,8 @@ export const isAcyclic = <N, E, T extends Kind = "directed">(
 /**
  * Checks if an undirected graph is bipartite.
  *
+ * **Details**
+ *
  * A bipartite graph is one whose vertices can be divided into two disjoint sets
  * such that no two vertices within the same set are adjacent. Uses BFS coloring
  * to determine bipartiteness.
@@ -4887,6 +4907,8 @@ export class Walker<T, N> implements Iterable<[T, N]> {
   /**
    * Visits each element and maps it to a value using the provided function.
    *
+   * **Details**
+   *
    * Takes a function that receives the index and data,
    * and returns an iterable of the mapped values. Skips elements that
    * no longer exist in the graph.
@@ -5418,6 +5440,8 @@ export interface TopoConfig {
 /**
  * Creates a new topological sort iterator with optional configuration.
  *
+ * **Details**
+ *
  * The iterator uses Kahn's algorithm to lazily produce nodes in topological order.
  * Throws an error if the graph contains cycles.
  *
@@ -5463,6 +5487,8 @@ export const topo: {
   /**
    * Creates a new topological sort iterator with optional configuration.
    *
+   * **Details**
+   *
    * The iterator uses Kahn's algorithm to lazily produce nodes in topological order.
    * Throws an error if the graph contains cycles.
    *
@@ -5508,6 +5534,8 @@ export const topo: {
   /**
    * Creates a new topological sort iterator with optional configuration.
    *
+   * **Details**
+   *
    * The iterator uses Kahn's algorithm to lazily produce nodes in topological order.
    * Throws an error if the graph contains cycles.
    *
@@ -5805,6 +5833,8 @@ export const dfsPostOrder: {
 /**
  * Creates an iterator over all node indices in the graph.
  *
+ * **Details**
+ *
  * The iterator produces node indices in the order they were added to the graph.
  * This provides access to all nodes regardless of connectivity.
  *
@@ -5851,6 +5881,8 @@ export const nodes = <N, E, T extends Kind = "directed">(
 /**
  * Creates an iterator over all edge indices in the graph.
  *
+ * **Details**
+ *
  * The iterator produces edge indices in the order they were added to the graph.
  * This provides access to all edges regardless of connectivity.
  *
@@ -5912,10 +5944,12 @@ export interface ExternalsConfig {
 }
 
 /**
- * Creates an iterator over external nodes (nodes without edges in specified direction).
+ * Creates an iterator over external nodes (nodes without edges in the specified direction).
+ *
+ * **Details**
  *
- * External nodes are nodes that have no outgoing edges (direction="outgoing") or
- * no incoming edges (direction="incoming"). These are useful for finding
+ * External nodes have no outgoing edges (`direction: "outgoing"`) or no
+ * incoming edges (`direction: "incoming"`). These are useful for finding
  * sources, sinks, or isolated nodes.
  *
  * **Example** (Iterating external nodes)
@@ -5951,10 +5985,12 @@ export interface ExternalsConfig {
  */
 export const externals: {
   /**
-   * Creates an iterator over external nodes (nodes without edges in specified direction).
+   * Creates an iterator over external nodes (nodes without edges in the specified direction).
    *
-   * External nodes are nodes that have no outgoing edges (direction="outgoing") or
-   * no incoming edges (direction="incoming"). These are useful for finding
+   * **Details**
+   *
+   * External nodes have no outgoing edges (`direction: "outgoing"`) or no
+   * incoming edges (`direction: "incoming"`). These are useful for finding
    * sources, sinks, or isolated nodes.
    *
    * **Example** (Iterating external nodes)
@@ -5990,10 +6026,12 @@ export const externals: {
    */
   (config?: ExternalsConfig): <N, E, T extends Kind = "directed">(graph: Graph<N, E, T> | MutableGraph<N, E, T>) => NodeWalker<N>
   /**
-   * Creates an iterator over external nodes (nodes without edges in specified direction).
+   * Creates an iterator over external nodes (nodes without edges in the specified direction).
+   *
+   * **Details**
    *
-   * External nodes are nodes that have no outgoing edges (direction="outgoing") or
-   * no incoming edges (direction="incoming"). These are useful for finding
+   * External nodes have no outgoing edges (`direction: "outgoing"`) or no
+   * incoming edges (`direction: "incoming"`). These are useful for finding
    * sources, sinks, or isolated nodes.
    *
    * **Example** (Iterating external nodes)

package/src/HKT.ts

@@ -38,11 +38,12 @@
 import type * as Types from "./Types.ts"
 
 /**
- * A unique symbol used to identify TypeClass implementations.
+ * A unique symbol used to associate `TypeClass` implementations with their `TypeLambda`.
  *
- * This symbol is used internally by the HKT system to associate type classes
- * with their corresponding TypeLambda. It provides a way to link runtime
- * type class instances with their compile-time type information.
+ * **Details**
+ *
+ * This symbol is used internally by the HKT system to link runtime type class
+ * instances with their compile-time type information.
  *
  * **Example** (Linking a type class to a type lambda)
  *
@@ -76,8 +77,10 @@ export declare const URI: unique symbol
 /**
  * Base interface for type classes that work with Higher-Kinded Types.
  *
- * A TypeClass defines operations that can be performed on any type constructor
- * that matches the given TypeLambda. This enables writing generic code that
+ * **Details**
+ *
+ * A `TypeClass` defines operations that can be performed on any type constructor
+ * that matches the given `TypeLambda`. This enables writing generic code that
  * works across different container types like Array, Option, Effect, etc.
  *
  * **Example** (Defining higher-kinded type classes)
@@ -112,15 +115,13 @@ export interface TypeClass<F extends TypeLambda> {
 /**
  * Base interface for defining Higher-Kinded Type parameters.
  *
- * A TypeLambda encodes the "shape" of a type constructor, specifying how many
- * type parameters it takes and their variance (contravariant, covariant, or invariant).
- * This allows representing complex types like `Effect<A, E, R>` in a uniform way.
+ * **Details**
  *
- * The four parameters represent:
- * - `In`: Contravariant input parameter
- * - `Out2`: Covariant output parameter (often used for errors)
- * - `Out1`: Covariant output parameter (often used for context/environment)
- * - `Target`: Invariant target parameter (the main type)
+ * A `TypeLambda` encodes the "shape" of a type constructor, specifying how many
+ * type parameters it takes and their variance (contravariant, covariant, or
+ * invariant). The four parameters are `In` for contravariant input, `Out2` for
+ * covariant output often used for errors, `Out1` for covariant output often used
+ * for context or environment, and `Target` for the invariant main type.
  *
  * **Example** (Defining type lambdas)
  *
@@ -154,15 +155,15 @@ export interface TypeLambda {
 }
 
 /**
- * Applies type parameters to a TypeLambda to get the concrete type.
+ * Applies type parameters to a `TypeLambda` to get the concrete type.
  *
- * This type-level function takes a TypeLambda and four type parameters,
- * then "applies" them to get the actual type. It handles the variance
- * correctly, ensuring contravariant parameters are used as inputs and
- * covariant parameters as outputs.
+ * **Details**
  *
- * This is the core mechanism that allows HKT to work - it transforms
- * abstract type constructors into concrete types by applying arguments.
+ * This type-level function takes a `TypeLambda` and four type parameters, then
+ * "applies" them to get the actual type. It handles variance correctly, ensuring
+ * contravariant parameters are used as inputs and covariant parameters as
+ * outputs. This is the core mechanism that allows HKT to transform abstract type
+ * constructors into concrete types by applying arguments.
  *
  * **Example** (Applying type lambdas)
  *

package/src/Hash.ts

@@ -22,6 +22,8 @@ export const symbol = "~effect/interfaces/Hash"
 /**
  * A type that represents an object that can be hashed.
  *
+ * **Details**
+ *
  * Objects implementing this interface provide a method to compute their hash value,
  * which is used for efficient comparison and storage operations.
  *
@@ -52,19 +54,19 @@ export interface Hash {
 /**
  * Computes a hash value for any given value.
  *
+ * **Details**
+ *
  * This function can hash primitives (numbers, strings, booleans, etc.) as well as
  * objects, arrays, and other complex data structures. It automatically handles
  * different types and provides a consistent hash value for equivalent inputs.
  *
- * **⚠️ CRITICAL IMMUTABILITY REQUIREMENT**: Objects being hashed must be treated as
- * immutable after their first hash computation. Hash results are cached, so mutating
- * an object after hashing will lead to stale cached values and broken hash-based
- * operations. For mutable objects, use referential equality by implementing custom
- * `Hash` interface that hashes the object reference, not its content.
+ * **Gotchas**
  *
- * **FORBIDDEN**: Modifying objects after `Hash.hash()` has been called on them
- * **ALLOWED**: Using immutable objects, or mutable objects with custom `Hash` interface
- * that uses referential equality (hashes the object reference, not content)
+ * Objects being hashed must be treated as immutable after their first hash
+ * computation. Hash results are cached, so mutating an object after hashing will
+ * lead to stale cached values and broken hash-based operations. For mutable
+ * objects, implement a custom `Hash` interface that hashes the object reference
+ * rather than its content.
  *
  * **Example** (Hashing different values)
  *
@@ -142,6 +144,8 @@ export const hash: <A>(self: A) => number = <A>(self: A) => {
 /**
  * Generates a random hash value for an object and caches it.
  *
+ * **Details**
+ *
  * This function creates a random hash value for objects that don't have their own
  * hash implementation. The hash value is cached using a WeakMap, so the same object
  * will always return the same hash value during its lifetime.
@@ -174,6 +178,8 @@ export const random: <A extends object>(self: A) => number = (self) => {
 /**
  * Combines two hash values into a single hash value.
  *
+ * **Details**
+ *
  * This function takes two hash values and combines them using a mathematical
  * operation to produce a new hash value. It's useful for creating hash values
  * of composite structures.
@@ -201,6 +207,8 @@ export const combine: {
   /**
    * Combines two hash values into a single hash value.
    *
+   * **Details**
+   *
    * This function takes two hash values and combines them using a mathematical
    * operation to produce a new hash value. It's useful for creating hash values
    * of composite structures.
@@ -228,6 +236,8 @@ export const combine: {
   /**
    * Combines two hash values into a single hash value.
    *
+   * **Details**
+   *
    * This function takes two hash values and combines them using a mathematical
    * operation to produce a new hash value. It's useful for creating hash values
    * of composite structures.
@@ -257,6 +267,8 @@ export const combine: {
 /**
  * Optimizes a hash value by applying bit manipulation techniques.
  *
+ * **Details**
+ *
  * This function takes a hash value and applies bitwise operations to improve
  * the distribution of hash values, reducing the likelihood of collisions.
  *
@@ -281,6 +293,8 @@ export const optimize = (n: number): number => (n & 0xbfffffff) | ((n >>> 1) & 0
 /**
  * Checks if a value implements the Hash interface.
  *
+ * **Details**
+ *
  * This function determines whether a given value has the Hash symbol property,
  * indicating that it can provide its own hash value implementation.
  *
@@ -309,6 +323,8 @@ export const isHash = (u: unknown): u is Hash => hasProperty(u, symbol)
 /**
  * Computes a hash value for a number.
  *
+ * **Details**
+ *
  * This function creates a hash value for numeric inputs, handling special cases
  * like NaN, Infinity, and -Infinity with distinct hash values. It uses bitwise operations to ensure good distribution
  * of hash values across different numeric inputs.
@@ -353,6 +369,8 @@ export const number = (n: number) => {
 /**
  * Computes a hash value for a string using the djb2 algorithm.
  *
+ * **Details**
+ *
  * This function implements a variation of the djb2 hash algorithm, which is
  * known for its good distribution properties and speed. It processes each
  * character of the string to produce a consistent hash value.
@@ -384,6 +402,8 @@ export const string = (str: string) => {
 /**
  * Computes a hash value for an object using only the specified keys.
  *
+ * **Details**
+ *
  * This function allows you to hash an object by considering only specific keys,
  * which is useful when you want to create a hash based on a subset of an object's
  * properties.
@@ -420,8 +440,9 @@ export const structureKeys = (o: object, keys: Iterable<PropertyKey>) => {
 }
 
 /**
- * Computes a structural hash for an object using Effect's object key
- * collection.
+ * Computes a structural hash for an object using Effect's object key collection.
+ *
+ * **Details**
  *
  * The hash is based on the object's structural keys and their values, including
  * symbol keys and relevant prototype keys for non-plain objects.
@@ -459,6 +480,8 @@ const iterableWith = (seed: number, f: (el: any) => number) => (iter: Iterable<a
 /**
  * Computes a hash value for an array by hashing all of its elements.
  *
+ * **Details**
+ *
  * This function creates a hash value based on all elements in the array.
  * The order of elements matters, so arrays with the same elements in different
  * orders will produce different hash values.

package/src/HashMap.ts

@@ -198,6 +198,7 @@ export declare namespace HashMap {
    * const getUserById = (id: UserKey) => HashMap.get(userMap, id)
    * console.log(getUserById("alice")) // Option.some({ name: "Alice", age: 30 })
    * ```
+   *
    * @category type-level
    * @since 2.0.0
    */
@@ -228,6 +229,7 @@ export declare namespace HashMap {
    * const alice = HashMap.get(userMap, "alice")
    * // alice has type Option<User> thanks to type extraction
    * ```
+   *
    * @category type-level
    * @since 2.0.0
    */
@@ -259,6 +261,7 @@ export declare namespace HashMap {
    * const descriptions = HashMap.toEntries(catalog).map(processEntry).sort()
    * console.log(descriptions) // ["book: $29 (education)", "laptop: $999 (electronics)"]
    * ```
+   *
    * @category type-level
    * @since 3.9.0
    */
@@ -577,8 +580,10 @@ export const getHash: {
  * Unsafely lookup the value for the specified key in the `HashMap` using the
  * internal hashing function.
  *
- * ⚠️ **Warning**: This function throws an error if the key is not found.
- * Use `HashMap.get` for safe access that returns `Option`.
+ * **Gotchas**
+ *
+ * This function throws an error if the key is not found. Use `HashMap.get` for
+ * safe access that returns `Option`.
  *
  * **Example** (Unsafely looking up values)
  *
@@ -613,8 +618,10 @@ export const getUnsafe: {
    * Unsafely lookup the value for the specified key in the `HashMap` using the
    * internal hashing function.
    *
-   * ⚠️ **Warning**: This function throws an error if the key is not found.
-   * Use `HashMap.get` for safe access that returns `Option`.
+   * **Gotchas**
+   *
+   * This function throws an error if the key is not found. Use `HashMap.get` for
+   * safe access that returns `Option`.
    *
    * **Example** (Unsafely looking up values)
    *
@@ -649,8 +656,10 @@ export const getUnsafe: {
    * Unsafely lookup the value for the specified key in the `HashMap` using the
    * internal hashing function.
    *
-   * ⚠️ **Warning**: This function throws an error if the key is not found.
-   * Use `HashMap.get` for safe access that returns `Option`.
+   * **Gotchas**
+   *
+   * This function throws an error if the key is not found. Use `HashMap.get` for
+   * safe access that returns `Option`.
    *
    * **Example** (Unsafely looking up values)
    *
@@ -1131,6 +1140,8 @@ export const size: <K, V>(self: HashMap<K, V>) => number = internal.size
 /**
  * Creates a transient mutable `HashMap` for efficient batched updates.
  *
+ * **Details**
+ *
  * Apply updates to the returned map, then call `endMutation` to finish the
  * mutation window and use the result as an immutable `HashMap`.
  *
@@ -1195,6 +1206,8 @@ export const endMutation: <K, V>(self: HashMap<K, V>) => HashMap<K, V> = interna
  * Runs a batch of updates against a transient mutable copy of the `HashMap`
  * and returns the finalized immutable result.
  *
+ * **Details**
+ *
  * The callback may call mutation-oriented helpers such as `set` and `remove`
  * on the transient map.
  *
@@ -1219,6 +1232,8 @@ export const mutate: {
    * Runs a batch of updates against a transient mutable copy of the `HashMap`
    * and returns the finalized immutable result.
    *
+   * **Details**
+   *
    * The callback may call mutation-oriented helpers such as `set` and `remove`
    * on the transient map.
    *
@@ -1243,6 +1258,8 @@ export const mutate: {
    * Runs a batch of updates against a transient mutable copy of the `HashMap`
    * and returns the finalized immutable result.
    *
+   * **Details**
+   *
    * The callback may call mutation-oriented helpers such as `set` and `remove`
    * on the transient map.
    *
@@ -1268,6 +1285,8 @@ export const mutate: {
 /**
  * Sets or removes the specified key using an update function.
  *
+ * **Details**
+ *
  * The update function receives `Some(value)` when the key exists or `None`
  * when it does not. Returning `Some(newValue)` stores the value, and returning
  * `None` removes the key or leaves it absent.
@@ -1294,6 +1313,8 @@ export const modifyAt: {
   /**
    * Sets or removes the specified key using an update function.
    *
+   * **Details**
+   *
    * The update function receives `Some(value)` when the key exists or `None`
    * when it does not. Returning `Some(newValue)` stores the value, and returning
    * `None` removes the key or leaves it absent.
@@ -1320,6 +1341,8 @@ export const modifyAt: {
   /**
    * Sets or removes the specified key using an update function.
    *
+   * **Details**
+   *
    * The update function receives `Some(value)` when the key exists or `None`
    * when it does not. Returning `Some(newValue)` stores the value, and returning
    * `None` removes the key or leaves it absent.
@@ -1349,6 +1372,8 @@ export const modifyAt: {
  * Sets or removes the specified key using a precomputed hash and an update
  * function.
  *
+ * **Details**
+ *
  * The update function receives `Some(value)` when the key exists or `None`
  * when it does not. Returning `Some(newValue)` stores the value, and returning
  * `None` removes the key or leaves it absent.
@@ -1398,6 +1423,8 @@ export const modifyHash: {
    * Sets or removes the specified key using a precomputed hash and an update
    * function.
    *
+   * **Details**
+   *
    * The update function receives `Some(value)` when the key exists or `None`
    * when it does not. Returning `Some(newValue)` stores the value, and returning
    * `None` removes the key or leaves it absent.
@@ -1447,6 +1474,8 @@ export const modifyHash: {
    * Sets or removes the specified key using a precomputed hash and an update
    * function.
    *
+   * **Details**
+   *
    * The update function receives `Some(value)` when the key exists or `None`
    * when it does not. Returning `Some(newValue)` stores the value, and returning
    * `None` removes the key or leaves it absent.
@@ -1556,6 +1585,8 @@ export const modify: {
 /**
  * Combines two `HashMap`s into one.
  *
+ * **Details**
+ *
  * Entries from `that` are inserted into `self`; when both maps contain an
  * equal key, the value from `that` replaces the value from `self`.
  *
@@ -1579,6 +1610,8 @@ export const union: {
   /**
    * Combines two `HashMap`s into one.
    *
+   * **Details**
+   *
    * Entries from `that` are inserted into `self`; when both maps contain an
    * equal key, the value from `that` replaces the value from `self`.
    *
@@ -1602,6 +1635,8 @@ export const union: {
   /**
    * Combines two `HashMap`s into one.
    *
+   * **Details**
+   *
    * Entries from `that` are inserted into `self`; when both maps contain an
    * equal key, the value from `that` replaces the value from `self`.
    *
@@ -1878,7 +1913,9 @@ export const map: {
 /**
  * Chains over the entries of the `HashMap` using the specified function.
  *
- * **NOTE**: the hash and equal of both maps have to be the same.
+ * **Gotchas**
+ *
+ * The hash and equality behavior of both maps have to be the same.
  *
  * **Example** (FlatMapping values)
  *
@@ -1903,7 +1940,9 @@ export const flatMap: {
   /**
    * Chains over the entries of the `HashMap` using the specified function.
    *
-   * **NOTE**: the hash and equal of both maps have to be the same.
+   * **Gotchas**
+   *
+   * The hash and equality behavior of both maps have to be the same.
    *
    * **Example** (FlatMapping values)
    *
@@ -1928,7 +1967,9 @@ export const flatMap: {
   /**
    * Chains over the entries of the `HashMap` using the specified function.
    *
-   * **NOTE**: the hash and equal of both maps have to be the same.
+   * **Gotchas**
+   *
+   * The hash and equality behavior of both maps have to be the same.
    *
    * **Example** (FlatMapping values)
    *

package/src/HashRing.ts

@@ -73,6 +73,8 @@ const TypeId = "~effect/cluster/HashRing" as const
  * A weighted consistent-hashing ring for assigning inputs to nodes with stable
  * remapping as nodes are added or removed.
  *
+ * **Details**
+ *
  * Nodes are identified by their `PrimaryKey` value and can be iterated from the
  * ring.
  *
@@ -98,6 +100,8 @@ export const isHashRing = (u: unknown): u is HashRing<any> => hasProperty(u, Typ
 /**
  * Creates an empty `HashRing`.
  *
+ * **Details**
+ *
  * `baseWeight` controls how many virtual points are added for a node with
  * weight `1`; it defaults to `128` and is clamped to at least `1`.
  *

package/src/HashSet.ts

@@ -108,6 +108,8 @@ export declare namespace HashSet {
   /**
    * Extracts the element type from a `HashSet`.
    *
+   * **Details**
+   *
    * For `HashSet.HashSet<A>`, `HashSet.Value<...>` resolves to `A`.
    *
    * **Example** (Extracting a HashSet value type)