effect 3.13.8 → 3.13.9

package/src/Either.ts

@@ -142,6 +142,7 @@ export const left: <L>(left: L) => Either<never, L> = either.left
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Either } from "effect"
  *
  * assert.deepStrictEqual(Either.fromNullable(1, () => 'fallback'), Either.right(1))
@@ -158,6 +159,7 @@ export const fromNullable: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { Either } from "effect"
    *
    * assert.deepStrictEqual(Either.fromNullable(1, () => 'fallback'), Either.right(1))
@@ -174,6 +176,7 @@ export const fromNullable: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { Either } from "effect"
    *
    * assert.deepStrictEqual(Either.fromNullable(1, () => 'fallback'), Either.right(1))
@@ -193,6 +196,7 @@ export const fromNullable: {
 /**
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Either, Option } from "effect"
  *
  * assert.deepStrictEqual(Either.fromOption(Option.some(1), () => 'error'), Either.right(1))
@@ -206,6 +210,7 @@ export const fromOption: {
   /**
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { Either, Option } from "effect"
    *
    * assert.deepStrictEqual(Either.fromOption(Option.some(1), () => 'error'), Either.right(1))
@@ -219,6 +224,7 @@ export const fromOption: {
   /**
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { Either, Option } from "effect"
    *
    * assert.deepStrictEqual(Either.fromOption(Option.some(1), () => 'error'), Either.right(1))
@@ -274,10 +280,9 @@ export {
 /**
  * Tests if a value is a `Either`.
  *
- * @param input - The value to test.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Either } from "effect"
  *
  * assert.deepStrictEqual(Either.isEither(Either.right(1)), true)
@@ -293,10 +298,9 @@ export const isEither: (input: unknown) => input is Either<unknown, unknown> = e
 /**
  * Determine if a `Either` is a `Left`.
  *
- * @param self - The `Either` to check.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Either } from "effect"
  *
  * assert.deepStrictEqual(Either.isLeft(Either.right(1)), false)
@@ -311,10 +315,9 @@ export const isLeft: <R, L>(self: Either<R, L>) => self is Left<L, R> = either.i
 /**
  * Determine if a `Either` is a `Right`.
  *
- * @param self - The `Either` to check.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Either } from "effect"
  *
  * assert.deepStrictEqual(Either.isRight(Either.right(1)), true)
@@ -331,6 +334,7 @@ export const isRight: <R, L>(self: Either<R, L>) => self is Right<L, R> = either
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Either, Option } from "effect"
  *
  * assert.deepStrictEqual(Either.getRight(Either.right('ok')), Option.some('ok'))
@@ -347,6 +351,7 @@ export const getRight: <R, L>(self: Either<R, L>) => Option<R> = either.getRight
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Either, Option } from "effect"
  *
  * assert.deepStrictEqual(Either.getLeft(Either.right('ok')), Option.none())
@@ -409,9 +414,6 @@ export const mapBoth: {
 /**
  * Maps the `Left` side of an `Either` value to a new `Either` value.
  *
- * @param self - The input `Either` value to map.
- * @param f - A transformation function to apply to the `Left` value of the input `Either`.
- *
  * @category mapping
  * @since 2.0.0
  */
@@ -419,9 +421,6 @@ export const mapLeft: {
   /**
    * Maps the `Left` side of an `Either` value to a new `Either` value.
    *
-   * @param self - The input `Either` value to map.
-   * @param f - A transformation function to apply to the `Left` value of the input `Either`.
-   *
    * @category mapping
    * @since 2.0.0
    */
@@ -429,9 +428,6 @@ export const mapLeft: {
   /**
    * Maps the `Left` side of an `Either` value to a new `Either` value.
    *
-   * @param self - The input `Either` value to map.
-   * @param f - A transformation function to apply to the `Left` value of the input `Either`.
-   *
    * @category mapping
    * @since 2.0.0
    */
@@ -445,9 +441,6 @@ export const mapLeft: {
 /**
  * Maps the `Right` side of an `Either` value to a new `Either` value.
  *
- * @param self - An `Either` to map
- * @param f - The function to map over the value of the `Either`
- *
  * @category mapping
  * @since 2.0.0
  */
@@ -455,9 +448,6 @@ export const map: {
   /**
    * Maps the `Right` side of an `Either` value to a new `Either` value.
    *
-   * @param self - An `Either` to map
-   * @param f - The function to map over the value of the `Either`
-   *
    * @category mapping
    * @since 2.0.0
    */
@@ -465,9 +455,6 @@ export const map: {
   /**
    * Maps the `Right` side of an `Either` value to a new `Either` value.
    *
-   * @param self - An `Either` to map
-   * @param f - The function to map over the value of the `Either`
-   *
    * @category mapping
    * @since 2.0.0
    */
@@ -484,6 +471,7 @@ export const map: {
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { pipe, Either } from "effect"
  *
  * const onLeft  = (strings: ReadonlyArray<string>): string => `strings: ${strings.join(', ')}`
@@ -507,6 +495,7 @@ export const match: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { pipe, Either } from "effect"
    *
    * const onLeft  = (strings: ReadonlyArray<string>): string => `strings: ${strings.join(', ')}`
@@ -535,6 +524,7 @@ export const match: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { pipe, Either } from "effect"
    *
    * const onLeft  = (strings: ReadonlyArray<string>): string => `strings: ${strings.join(', ')}`
@@ -570,10 +560,9 @@ export const match: {
  * Transforms a `Predicate` function into a `Right` of the input value if the predicate returns `true`
  * or `Left` of the result of the provided function if the predicate returns false
  *
- * @param predicate - A `Predicate` function that takes in a value of type `A` and returns a boolean.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { pipe, Either } from "effect"
  *
  * const isPositive = (n: number): boolean => n > 0
@@ -602,10 +591,9 @@ export const liftPredicate: {
    * Transforms a `Predicate` function into a `Right` of the input value if the predicate returns `true`
    * or `Left` of the result of the provided function if the predicate returns false
    *
-   * @param predicate - A `Predicate` function that takes in a value of type `A` and returns a boolean.
-   *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { pipe, Either } from "effect"
    *
    * const isPositive = (n: number): boolean => n > 0
@@ -634,10 +622,9 @@ export const liftPredicate: {
    * Transforms a `Predicate` function into a `Right` of the input value if the predicate returns `true`
    * or `Left` of the result of the provided function if the predicate returns false
    *
-   * @param predicate - A `Predicate` function that takes in a value of type `A` and returns a boolean.
-   *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { pipe, Either } from "effect"
    *
    * const isPositive = (n: number): boolean => n > 0
@@ -666,10 +653,9 @@ export const liftPredicate: {
    * Transforms a `Predicate` function into a `Right` of the input value if the predicate returns `true`
    * or `Left` of the result of the provided function if the predicate returns false
    *
-   * @param predicate - A `Predicate` function that takes in a value of type `A` and returns a boolean.
-   *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { pipe, Either } from "effect"
    *
    * const isPositive = (n: number): boolean => n > 0
@@ -698,10 +684,9 @@ export const liftPredicate: {
    * Transforms a `Predicate` function into a `Right` of the input value if the predicate returns `true`
    * or `Left` of the result of the provided function if the predicate returns false
    *
-   * @param predicate - A `Predicate` function that takes in a value of type `A` and returns a boolean.
-   *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { pipe, Either } from "effect"
    *
    * const isPositive = (n: number): boolean => n > 0
@@ -742,6 +727,7 @@ export const liftPredicate: {
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { pipe, Either } from "effect"
  *
  * const isPositive = (n: number): boolean => n > 0
@@ -772,6 +758,7 @@ export const filterOrLeft: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { pipe, Either } from "effect"
    *
    * const isPositive = (n: number): boolean => n > 0
@@ -805,6 +792,7 @@ export const filterOrLeft: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { pipe, Either } from "effect"
    *
    * const isPositive = (n: number): boolean => n > 0
@@ -835,6 +823,7 @@ export const filterOrLeft: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { pipe, Either } from "effect"
    *
    * const isPositive = (n: number): boolean => n > 0
@@ -869,6 +858,7 @@ export const filterOrLeft: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { pipe, Either } from "effect"
    *
    * const isPositive = (n: number): boolean => n > 0
@@ -913,6 +903,7 @@ export const merge: <R, L>(self: Either<R, L>) => L | R = match({
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Either } from "effect"
  *
  * assert.deepStrictEqual(Either.getOrElse(Either.right(1), (error) => error + "!"), 1)
@@ -928,6 +919,7 @@ export const getOrElse: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { Either } from "effect"
    *
    * assert.deepStrictEqual(Either.getOrElse(Either.right(1), (error) => error + "!"), 1)
@@ -943,6 +935,7 @@ export const getOrElse: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { Either } from "effect"
    *
    * assert.deepStrictEqual(Either.getOrElse(Either.right(1), (error) => error + "!"), 1)
@@ -961,6 +954,7 @@ export const getOrElse: {
 /**
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Either } from "effect"
  *
  * assert.deepStrictEqual(Either.getOrNull(Either.right(1)), 1)
@@ -975,6 +969,7 @@ export const getOrNull: <R, L>(self: Either<R, L>) => R | null = getOrElse(const
 /**
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Either } from "effect"
  *
  * assert.deepStrictEqual(Either.getOrUndefined(Either.right(1)), 1)
@@ -991,11 +986,9 @@ export const getOrUndefined: <R, L>(self: Either<R, L>) => R | undefined = getOr
  *
  * If a default error is sufficient for your use case and you don't need to configure the thrown error, see {@link getOrThrow}.
  *
- * @param self - The `Either` to extract the value from.
- * @param onLeft - A function that will be called if the `Either` is `Left`. It returns the error to be thrown.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Either } from "effect"
  *
  * assert.deepStrictEqual(
@@ -1014,11 +1007,9 @@ export const getOrThrowWith: {
    *
    * If a default error is sufficient for your use case and you don't need to configure the thrown error, see {@link getOrThrow}.
    *
-   * @param self - The `Either` to extract the value from.
-   * @param onLeft - A function that will be called if the `Either` is `Left`. It returns the error to be thrown.
-   *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { Either } from "effect"
    *
    * assert.deepStrictEqual(
@@ -1037,11 +1028,9 @@ export const getOrThrowWith: {
    *
    * If a default error is sufficient for your use case and you don't need to configure the thrown error, see {@link getOrThrow}.
    *
-   * @param self - The `Either` to extract the value from.
-   * @param onLeft - A function that will be called if the `Either` is `Left`. It returns the error to be thrown.
-   *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { Either } from "effect"
    *
    * assert.deepStrictEqual(
@@ -1068,17 +1057,17 @@ export const getOrThrowWith: {
  *
  * The thrown error is a default error. To configure the error thrown, see  {@link getOrThrowWith}.
  *
- * @param self - The `Either` to extract the value from.
- * @throws `Error("getOrThrow called on a Left")`
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Either } from "effect"
  *
  * assert.deepStrictEqual(Either.getOrThrow(Either.right(1)), 1)
  * assert.throws(() => Either.getOrThrow(Either.left("error")))
  * ```
  *
+ * @throws `Error("getOrThrow called on a Left")`
+ *
  * @category getters
  * @since 2.0.0
  */
@@ -1089,9 +1078,6 @@ export const getOrThrow: <R, L>(self: Either<R, L>) => R = getOrThrowWith(() =>
 /**
  * Returns `self` if it is a `Right` or `that` otherwise.
  *
- * @param self - The input `Either` value to check and potentially return.
- * @param that - A function that takes the error value from `self` (if it's a `Left`) and returns a new `Either` value.
- *
  * @category error handling
  * @since 2.0.0
  */
@@ -1099,9 +1085,6 @@ export const orElse: {
   /**
    * Returns `self` if it is a `Right` or `that` otherwise.
    *
-   * @param self - The input `Either` value to check and potentially return.
-   * @param that - A function that takes the error value from `self` (if it's a `Left`) and returns a new `Either` value.
-   *
    * @category error handling
    * @since 2.0.0
    */
@@ -1109,9 +1092,6 @@ export const orElse: {
   /**
    * Returns `self` if it is a `Right` or `that` otherwise.
    *
-   * @param self - The input `Either` value to check and potentially return.
-   * @param that - A function that takes the error value from `self` (if it's a `Left`) and returns a new `Either` value.
-   *
    * @category error handling
    * @since 2.0.0
    */
@@ -1264,10 +1244,9 @@ export const ap: {
  * - If a struct is supplied, then the returned `Either` will contain a struct with the same keys.
  * - If an iterable is supplied, then the returned `Either` will contain an array.
  *
- * @param fields - the struct of `Either`s to be sequenced.
- *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Either } from "effect"
  *
  * assert.deepStrictEqual(Either.all([Either.right(1), Either.right(2)]), Either.right([1, 2]))
@@ -1294,7 +1273,7 @@ export const all: <const I extends Iterable<Either<any, any>> | Record<string, E
   ): Either<any, any> => {
     if (Symbol.iterator in input) {
       const out: Array<Either<any, any>> = []
-      for (const e of (input as Iterable<Either<any, any>>)) {
+      for (const e of input) {
         if (isLeft(e)) {
           return e
         }
@@ -1365,6 +1344,7 @@ export const gen: Gen.Gen<EitherTypeLambda, Gen.Adapter<EitherTypeLambda>> = (..
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Either, pipe } from "effect"
  *
  * const result = pipe(
@@ -1397,6 +1377,7 @@ export const Do: Either<{}> = right({})
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Either, pipe } from "effect"
  *
  * const result = pipe(
@@ -1428,6 +1409,7 @@ export const bind: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { Either, pipe } from "effect"
    *
    * const result = pipe(
@@ -1459,6 +1441,7 @@ export const bind: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { Either, pipe } from "effect"
    *
    * const result = pipe(
@@ -1496,6 +1479,7 @@ export const bind: {
  *
  * @example
  * ```ts
+ * import * as assert from "node:assert"
  * import { Either, pipe } from "effect"
  *
  * const result = pipe(
@@ -1527,6 +1511,7 @@ export const bindTo: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { Either, pipe } from "effect"
    *
    * const result = pipe(
@@ -1558,6 +1543,7 @@ export const bindTo: {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { Either, pipe } from "effect"
    *
    * const result = pipe(
@@ -1604,6 +1590,7 @@ export {
    *
    * @example
    * ```ts
+   * import * as assert from "node:assert"
    * import { Either, pipe } from "effect"
    *
    * const result = pipe(

package/src/Encoding.ts

@@ -187,7 +187,7 @@ export interface EncodeException {
 export const EncodeException: (input: string, message?: string) => EncodeException = Common.EncodeException
 
 /**
- * Returns `true` if the specified value is an `Exception`, `false` otherwise.
+ * Returns `true` if the specified value is an `EncodeException`, `false` otherwise.
  *
  * @since 3.12.0
  * @category refinements

package/src/Equivalence.ts

@@ -201,7 +201,7 @@ export const productMany = <A>(
 /**
  * Similar to `Promise.all` but operates on `Equivalence`s.
  *
- * ```
+ * ```ts skip-type-checking
  * [Equivalence<A>, Equivalence<B>, ...] -> Equivalence<[A, B, ...]>
  * ```
  *