effect 3.13.8 → 3.13.9

package/src/Function.ts

@@ -14,10 +14,9 @@ export interface FunctionTypeLambda extends TypeLambda {
 /**
  * Tests if a value is a `function`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isFunction } from "effect/Predicate"
  *
  * assert.deepStrictEqual(isFunction(isFunction), true)
@@ -42,13 +41,13 @@ export const isFunction = (input: unknown): input is Function => typeof input ==
  * takes an optional argument, you can use a predicate to determine if the
  * function is being used in a data-first or data-last style.
  *
- * @param arity - Either the arity of the uncurried function or a predicate
- *                which determines if the function is being used in a data-first
- *                or data-last style.
- * @param body - The definition of the uncurried function.
+ * You can pass either the arity of the uncurried function or a predicate
+ * which determines if the function is being used in a data-first or
+ * data-last style.
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { dual, pipe } from "effect/Function"
  *
  * // Exampe using arity to determine data-first or data-last style
@@ -86,13 +85,13 @@ export const dual: {
    * takes an optional argument, you can use a predicate to determine if the
    * function is being used in a data-first or data-last style.
    *
-   * @param arity - Either the arity of the uncurried function or a predicate
-   *                which determines if the function is being used in a data-first
-   *                or data-last style.
-   * @param body - The definition of the uncurried function.
+   * You can pass either the arity of the uncurried function or a predicate
+   * which determines if the function is being used in a data-first or
+   * data-last style.
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { dual, pipe } from "effect/Function"
    *
    * // Exampe using arity to determine data-first or data-last style
@@ -130,13 +129,13 @@ export const dual: {
    * takes an optional argument, you can use a predicate to determine if the
    * function is being used in a data-first or data-last style.
    *
-   * @param arity - Either the arity of the uncurried function or a predicate
-   *                which determines if the function is being used in a data-first
-   *                or data-last style.
-   * @param body - The definition of the uncurried function.
+   * You can pass either the arity of the uncurried function or a predicate
+   * which determines if the function is being used in a data-first or
+   * data-last style.
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { dual, pipe } from "effect/Function"
    *
    * // Exampe using arity to determine data-first or data-last style
@@ -233,11 +232,9 @@ export const dual: {
 /**
  * Apply a function to a given value.
  *
- * @param a - The value that the function will be applied to.
- * @param self - The function to be applied to a value.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { pipe, apply } from "effect/Function"
  * import { length } from "effect/String"
  *
@@ -253,6 +250,7 @@ export const apply = <A>(a: A) => <B>(self: (a: A) => B): B => self(a)
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { LazyArg, constant } from "effect/Function"
  *
  * const constNull: LazyArg<null> = constant(null)
@@ -267,6 +265,7 @@ export interface LazyArg<A> {
 /**
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { FunctionN } from "effect/Function"
  *
  * const sum: FunctionN<[number, number], number> = (a, b) => a + b
@@ -281,10 +280,9 @@ export interface FunctionN<A extends ReadonlyArray<unknown>, B> {
 /**
  * The identity function, i.e. A function that returns its input argument.
  *
- * @param a - The input argument.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { identity } from "effect/Function"
  *
  * assert.deepStrictEqual(identity(5), 5)
@@ -300,6 +298,7 @@ export const identity = <A>(a: A): A => a
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { satisfies } from "effect/Function"
  *
  * const test1 = satisfies<number>()(5 as const)
@@ -318,10 +317,9 @@ export const satisfies = <A>() => <B extends A>(b: B) => b
 /**
  * Casts the result to the specified type.
  *
- * @param a - The value to be casted to the target type.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { unsafeCoerce, identity } from "effect/Function"
  *
  * assert.deepStrictEqual(unsafeCoerce, identity)
@@ -337,10 +335,9 @@ export const unsafeCoerce: <A, B>(a: A) => B = identity as any
  * This is useful when you want to pass a value to a higher-order function (a function that takes another function as its argument)
  * and want that inner function to always use the same value, no matter how many times it is called.
  *
- * @param value - The constant value to be returned.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { constant } from "effect/Function"
  *
  * const constNull = constant(null)
@@ -358,6 +355,7 @@ export const constant = <A>(value: A): LazyArg<A> => () => value
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { constTrue } from "effect/Function"
  *
  * assert.deepStrictEqual(constTrue(), true)
@@ -372,6 +370,7 @@ export const constTrue: LazyArg<boolean> = constant(true)
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { constFalse } from "effect/Function"
  *
  * assert.deepStrictEqual(constFalse(), false)
@@ -386,6 +385,7 @@ export const constFalse: LazyArg<boolean> = constant(false)
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { constNull } from "effect/Function"
  *
  * assert.deepStrictEqual(constNull(), null)
@@ -400,6 +400,7 @@ export const constNull: LazyArg<null> = constant(null)
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { constUndefined } from "effect/Function"
  *
  * assert.deepStrictEqual(constUndefined(), undefined)
@@ -414,6 +415,7 @@ export const constUndefined: LazyArg<undefined> = constant(undefined)
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { constVoid } from "effect/Function"
  *
  * assert.deepStrictEqual(constVoid(), undefined)
@@ -426,10 +428,9 @@ export const constVoid: LazyArg<void> = constUndefined
 /**
  * Reverses the order of arguments for a curried function.
  *
- * @param f - A curried function that takes multiple arguments.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { flip } from "effect/Function"
  *
  * const f = (a: number) => (b: string) => a - b.length
@@ -449,11 +450,9 @@ export const flip = <A extends Array<unknown>, B extends Array<unknown>, C>(
  * Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
  * The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
  *
- * @param ab - A function that maps from `A` to `B`.
- * @param bc - A function that maps from `B` to `C`.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { compose } from "effect/Function"
  *
  * const increment = (n: number) => n + 1;
@@ -469,11 +468,9 @@ export const compose: {
    * Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
    * The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
    *
-   * @param ab - A function that maps from `A` to `B`.
-   * @param bc - A function that maps from `B` to `C`.
-   *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { compose } from "effect/Function"
    *
    * const increment = (n: number) => n + 1;
@@ -489,11 +486,9 @@ export const compose: {
    * Composes two functions, `ab` and `bc` into a single function that takes in an argument `a` of type `A` and returns a result of type `C`.
    * The result is obtained by first applying the `ab` function to `a` and then applying the `bc` function to the result of `ab`.
    *
-   * @param ab - A function that maps from `A` to `B`.
-   * @param bc - A function that maps from `B` to `C`.
-   *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { compose } from "effect/Function"
    *
    * const increment = (n: number) => n + 1;
@@ -520,10 +515,11 @@ export const absurd = <A>(_: never): A => {
 }
 
 /**
- * Creates a tupled version of this function: instead of `n` arguments, it accepts a single tuple argument.
+ * Creates a   version of this function: instead of `n` arguments, it accepts a single tuple argument.
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { tupled } from "effect/Function"
  *
  * const sumTupled = tupled((x: number, y: number): number => x + y)
@@ -540,6 +536,7 @@ export const tupled = <A extends ReadonlyArray<unknown>, B>(f: (...a: A) => B):
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { untupled } from "effect/Function"
  *
  * const getFirst = untupled(<A, B>(tuple: [A, B]): A => tuple[0])
@@ -554,23 +551,6 @@ export const untupled = <A extends ReadonlyArray<unknown>, B>(f: (a: A) => B): (
 /**
  * Pipes the value of an expression into a pipeline of functions.
  *
- * **When to Use**
- *
- * This is useful in combination with data-last functions as a simulation of
- * methods:
- *
- * ```ts
- * as.map(f).filter(g)
- * ```
- *
- * becomes:
- *
- * ```ts
- * import { pipe, Array } from "effect"
- *
- * pipe(as, Array.map(f), Array.filter(g))
- * ```
- *
  * **Details**
  *
  * The `pipe` function is a utility that allows us to compose functions in a
@@ -578,7 +558,7 @@ export const untupled = <A extends ReadonlyArray<unknown>, B>(f: (a: A) => B): (
  * passes it as the input to the next function in the pipeline. This enables us
  * to build complex transformations by chaining multiple functions together.
  *
- * ```ts
+ * ```ts skip-type-checking
  * import { pipe } from "effect"
  *
  * const result = pipe(input, func1, func2, ..., funcN)
@@ -591,7 +571,7 @@ export const untupled = <A extends ReadonlyArray<unknown>, B>(f: (a: A) => B): (
  *
  * Here's an illustration of how `pipe` works:
  *
- * ```text
+ * ```
  * ┌───────┐    ┌───────┐    ┌───────┐    ┌───────┐    ┌───────┐    ┌────────┐
  * │ input │───►│ func1 │───►│ func2 │───►│  ...  │───►│ funcN │───►│ result │
  * └───────┘    └───────┘    └───────┘    └───────┘    └───────┘    └────────┘
@@ -600,9 +580,26 @@ export const untupled = <A extends ReadonlyArray<unknown>, B>(f: (a: A) => B): (
  * It's important to note that functions passed to `pipe` must have a **single
  * argument** because they are only called with a single argument.
  *
- * @example
+ * **When to Use**
+ *
+ * This is useful in combination with data-last functions as a simulation of
+ * methods:
+ *
+ * ```ts skip-type-checking
+ * as.map(f).filter(g)
+ * ```
+ *
+ * becomes:
+ *
+ * ```ts skip-type-checking
+ * import { pipe, Array } from "effect"
+ *
+ * pipe(as, Array.map(f), Array.filter(g))
+ * ```
+ *
+ * **Example** (Chaining Arithmetic Operations)
+ *
  * ```ts
- * // Example: Chaining Arithmetic Operations
  * import { pipe } from "effect"
  *
  * // Define simple arithmetic operations
@@ -1114,6 +1111,7 @@ export function pipe(
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { flow } from "effect/Function"
  *
  * const len = (s: string): number => s.length
@@ -1304,11 +1302,9 @@ export const hole: <T>() => T = unsafeCoerce(absurd)
  *
  * This function is useful for discarding the first argument passed to it and returning the second argument.
  *
- * @param _ - The first argument to be discarded.
- * @param b - The second argument to be returned.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { SK } from "effect/Function";
  *
  * assert.deepStrictEqual(SK(0, "hello"), "hello")

package/src/HashMap.ts

@@ -754,9 +754,6 @@ export const findFirst: {
 /**
  * Checks if any entry in a hashmap meets a specific condition.
  *
- * @param self - The hashmap to check.
- * @param predicate - The condition to test entries (value, key).
- *
  * @since 3.13.0
  * @category elements
  */
@@ -764,9 +761,6 @@ export const some: {
   /**
    * Checks if any entry in a hashmap meets a specific condition.
    *
-   * @param self - The hashmap to check.
-   * @param predicate - The condition to test entries (value, key).
-   *
    * @since 3.13.0
    * @category elements
    */
@@ -774,9 +768,6 @@ export const some: {
   /**
    * Checks if any entry in a hashmap meets a specific condition.
    *
-   * @param self - The hashmap to check.
-   * @param predicate - The condition to test entries (value, key).
-   *
    * @since 3.13.0
    * @category elements
    */

package/src/Iterable.ts

@@ -25,6 +25,7 @@ import type { NoInfer } from "./Types.js"
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { makeBy } from "effect/Iterable"
  *
  * assert.deepStrictEqual(Array.from(makeBy(n => n * 2, { length: 5 })), [0, 2, 4, 6, 8])
@@ -59,6 +60,7 @@ export const makeBy = <A>(f: (i: number) => A, options?: {
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { range } from "effect/Iterable"
  *
  * assert.deepStrictEqual(Array.from(range(1, 3)), [1, 2, 3])
@@ -83,6 +85,7 @@ export const range = (start: number, end?: number): Iterable<number> => {
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { replicate } from "effect/Iterable"
  *
  * assert.deepStrictEqual(Array.from(replicate("a", 3)), ["a", "a", "a"])
@@ -99,6 +102,7 @@ export const replicate: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { replicate } from "effect/Iterable"
    *
    * assert.deepStrictEqual(Array.from(replicate("a", 3)), ["a", "a", "a"])
@@ -115,6 +119,7 @@ export const replicate: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { replicate } from "effect/Iterable"
    *
    * assert.deepStrictEqual(Array.from(replicate("a", 3)), ["a", "a", "a"])
@@ -129,10 +134,9 @@ export const replicate: {
 /**
  * Takes a record and returns an Iterable of tuples containing its keys and values.
  *
- * @param self - The record to transform.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { fromRecord } from "effect/Iterable"
  *
  * const x = { a: 1, b: 2, c: 3 }
@@ -180,6 +184,7 @@ export const prepend: {
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Iterable } from "effect"
  *
  * assert.deepStrictEqual(
@@ -197,6 +202,7 @@ export const prependAll: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { Iterable } from "effect"
    *
    * assert.deepStrictEqual(
@@ -214,6 +220,7 @@ export const prependAll: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { Iterable } from "effect"
    *
    * assert.deepStrictEqual(
@@ -346,6 +353,7 @@ export const scan: {
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { isEmpty } from "effect/Iterable"
  *
  * assert.deepStrictEqual(isEmpty([]), true);
@@ -1197,6 +1205,7 @@ export const filterMapWhile: {
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Iterable, Option } from "effect"
  *
  * assert.deepStrictEqual(
@@ -1215,6 +1224,7 @@ export const getSomes: <A>(self: Iterable<Option<A>>) => Iterable<A> = filterMap
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Iterable, Either } from "effect"
  *
  * assert.deepStrictEqual(
@@ -1233,6 +1243,7 @@ export const getLefts = <R, L>(self: Iterable<Either<R, L>>): Iterable<L> => fil
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Iterable, Either } from "effect"
  *
  * assert.deepStrictEqual(

package/src/List.ts

@@ -350,6 +350,7 @@ export const append: {
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { List } from "effect"
  *
  * assert.deepStrictEqual(
@@ -368,6 +369,7 @@ export const appendAll: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { List } from "effect"
    *
    * assert.deepStrictEqual(
@@ -386,6 +388,7 @@ export const appendAll: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { List } from "effect"
    *
    * assert.deepStrictEqual(
@@ -404,6 +407,7 @@ export const appendAll: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { List } from "effect"
    *
    * assert.deepStrictEqual(
@@ -422,6 +426,7 @@ export const appendAll: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { List } from "effect"
    *
    * assert.deepStrictEqual(
@@ -471,6 +476,7 @@ A | B>(element, self))
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { List } from "effect"
  *
  * assert.deepStrictEqual(
@@ -489,6 +495,7 @@ export const prependAll: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { List } from "effect"
    *
    * assert.deepStrictEqual(
@@ -507,6 +514,7 @@ export const prependAll: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { List } from "effect"
    *
    * assert.deepStrictEqual(
@@ -525,6 +533,7 @@ export const prependAll: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { List } from "effect"
    *
    * assert.deepStrictEqual(
@@ -543,6 +552,7 @@ export const prependAll: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { List } from "effect"
    *
    * assert.deepStrictEqual(
@@ -567,6 +577,7 @@ export const prependAll: {
      *
      * @example
      * ```ts
+     * import * as assert from "node:assert"
      * import { List } from "effect"
      *
      * assert.deepStrictEqual(
@@ -588,6 +599,7 @@ export const prependAll: {
        *
        * @example
        * ```ts
+       * import * as assert from "node:assert"
        * import { List } from "effect"
        *
        * assert.deepStrictEqual(

package/src/Logger.ts

@@ -215,8 +215,6 @@ export const map: {
  * Creates a batched logger that groups log messages together and processes them
  * in intervals.
  *
- * @param window - The time window in which to batch log messages.
- *
  * @example
  * ```ts
  * import { Console, Effect, Logger } from "effect"
@@ -250,8 +248,6 @@ export const batched: {
    * Creates a batched logger that groups log messages together and processes them
    * in intervals.
    *
-   * @param window - The time window in which to batch log messages.
-   *
    * @example
    * ```ts
    * import { Console, Effect, Logger } from "effect"
@@ -288,8 +284,6 @@ export const batched: {
    * Creates a batched logger that groups log messages together and processes them
    * in intervals.
    *
-   * @param window - The time window in which to batch log messages.
-   *
    * @example
    * ```ts
    * import { Console, Effect, Logger } from "effect"

package/src/Mailbox.ts

@@ -179,6 +179,7 @@ export interface ReadonlyMailbox<out A, out E = never>
  * @category constructors
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Effect, Mailbox } from "effect"
  *
  * Effect.gen(function*() {

package/src/ManagedRuntime.ts

@@ -25,8 +25,6 @@ export type TypeId = typeof TypeId
 /**
  * Checks if the provided argument is a `ManagedRuntime`.
  *
- * @param input - The value to be checked if it is a `ManagedRuntime`.
-
  * @since 3.9.0
  * @category guards
  */