effect 3.8.4 → 3.9.0

package/src/Equivalence.ts

@@ -76,7 +76,15 @@ export const symbol: Equivalence<symbol> = strict()
  * @since 2.0.0
  */
 export const combine: {
+  /**
+   * @category combining
+   * @since 2.0.0
+   */
   <A>(that: Equivalence<A>): (self: Equivalence<A>) => Equivalence<A>
+  /**
+   * @category combining
+   * @since 2.0.0
+   */
   <A>(self: Equivalence<A>, that: Equivalence<A>): Equivalence<A>
 } = dual(2, <A>(self: Equivalence<A>, that: Equivalence<A>): Equivalence<A> => make((x, y) => self(x, y) && that(x, y)))
 
@@ -85,7 +93,15 @@ export const combine: {
  * @since 2.0.0
  */
 export const combineMany: {
+  /**
+   * @category combining
+   * @since 2.0.0
+   */
   <A>(collection: Iterable<Equivalence<A>>): (self: Equivalence<A>) => Equivalence<A>
+  /**
+   * @category combining
+   * @since 2.0.0
+   */
   <A>(self: Equivalence<A>, collection: Iterable<Equivalence<A>>): Equivalence<A>
 } = dual(2, <A>(self: Equivalence<A>, collection: Iterable<Equivalence<A>>): Equivalence<A> =>
   make((x, y) => {
@@ -114,7 +130,15 @@ export const combineAll = <A>(collection: Iterable<Equivalence<A>>): Equivalence
  * @since 2.0.0
  */
 export const mapInput: {
+  /**
+   * @category mapping
+   * @since 2.0.0
+   */
   <B, A>(f: (b: B) => A): (self: Equivalence<A>) => Equivalence<B>
+  /**
+   * @category mapping
+   * @since 2.0.0
+   */
   <A, B>(self: Equivalence<A>, f: (b: B) => A): Equivalence<B>
 } = dual(
   2,

package/src/ExecutionStrategy.ts

@@ -106,14 +106,33 @@ export const isParallelN: (self: ExecutionStrategy) => self is ParallelN = inter
  * @category folding
  */
 export const match: {
-  <A>(options: {
-    readonly onSequential: LazyArg<A>
-    readonly onParallel: LazyArg<A>
-    readonly onParallelN: (n: number) => A
-  }): (self: ExecutionStrategy) => A
-  <A>(self: ExecutionStrategy, options: {
-    readonly onSequential: LazyArg<A>
-    readonly onParallel: LazyArg<A>
-    readonly onParallelN: (n: number) => A
-  }): A
+  /**
+   * Folds over the specified `ExecutionStrategy` using the provided case
+   * functions.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
+  <A>(
+    options: {
+      readonly onSequential: LazyArg<A>
+      readonly onParallel: LazyArg<A>
+      readonly onParallelN: (n: number) => A
+    }
+  ): (self: ExecutionStrategy) => A
+  /**
+   * Folds over the specified `ExecutionStrategy` using the provided case
+   * functions.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
+  <A>(
+    self: ExecutionStrategy,
+    options: {
+      readonly onSequential: LazyArg<A>
+      readonly onParallel: LazyArg<A>
+      readonly onParallelN: (n: number) => A
+    }
+  ): A
 } = internal.match

package/src/Exit.ts

@@ -118,7 +118,21 @@ export const isInterrupted: <A, E>(self: Exit<A, E>) => boolean = core.exitIsInt
  * @category mapping
  */
 export const as: {
+  /**
+   * Maps the `Success` value of the specified exit to the provided constant
+   * value.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <A2>(value: A2): <A, E>(self: Exit<A, E>) => Exit<A2, E>
+  /**
+   * Maps the `Success` value of the specified exit to the provided constant
+   * value.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <A, E, A2>(self: Exit<A, E>, value: A2): Exit<A2, E>
 } = core.exitAs
 
@@ -167,9 +181,37 @@ export const die: (defect: unknown) => Exit<never> = core.exitDie
  * @category elements
  */
 export const exists: {
+  /**
+   * Executes the predicate on the value of the specified exit if it is a
+   * `Success`, otherwise returns `false`.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, B extends A>(refinement: Refinement<NoInfer<A>, B>): <E>(self: Exit<A, E>) => self is Exit<B>
+  /**
+   * Executes the predicate on the value of the specified exit if it is a
+   * `Success`, otherwise returns `false`.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(predicate: Predicate<NoInfer<A>>): <E>(self: Exit<A, E>) => boolean
+  /**
+   * Executes the predicate on the value of the specified exit if it is a
+   * `Success`, otherwise returns `false`.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, E, B extends A>(self: Exit<A, E>, refinement: Refinement<A, B>): self is Exit<B>
+  /**
+   * Executes the predicate on the value of the specified exit if it is a
+   * `Success`, otherwise returns `false`.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, E>(self: Exit<A, E>, predicate: Predicate<A>): boolean
 } = core.exitExists
 
@@ -195,7 +237,15 @@ export const failCause: <E>(cause: Cause.Cause<E>) => Exit<never, E> = core.exit
  * @category sequencing
  */
 export const flatMap: {
+  /**
+   * @since 2.0.0
+   * @category sequencing
+   */
   <A, A2, E2>(f: (a: A) => Exit<A2, E2>): <E>(self: Exit<A, E>) => Exit<A2, E2 | E>
+  /**
+   * @since 2.0.0
+   * @category sequencing
+   */
   <A, E, E2, A2>(self: Exit<A, E>, f: (a: A) => Exit<A2, E2>): Exit<A2, E | E2>
 } = core.exitFlatMap
 
@@ -204,9 +254,17 @@ export const flatMap: {
  * @category sequencing
  */
 export const flatMapEffect: {
+  /**
+   * @since 2.0.0
+   * @category sequencing
+   */
   <A, E, A2, E2, R>(
     f: (a: A) => Effect.Effect<Exit<A2, E>, E2, R>
   ): (self: Exit<A, E>) => Effect.Effect<Exit<A2, E>, E2, R>
+  /**
+   * @since 2.0.0
+   * @category sequencing
+   */
   <A, E, A2, E2, R>(self: Exit<A, E>, f: (a: A) => Effect.Effect<Exit<A2, E>, E2, R>): Effect.Effect<Exit<A2, E>, E2, R>
 } = core.exitFlatMapEffect
 
@@ -221,7 +279,15 @@ export const flatten: <A, E, E2>(self: Exit<Exit<A, E>, E2>) => Exit<A, E | E2>
  * @category traversing
  */
 export const forEachEffect: {
+  /**
+   * @since 2.0.0
+   * @category traversing
+   */
   <A, B, E2, R>(f: (a: A) => Effect.Effect<B, E2, R>): <E>(self: Exit<A, E>) => Effect.Effect<Exit<B, E2 | E>, never, R>
+  /**
+   * @since 2.0.0
+   * @category traversing
+   */
   <A, E, B, E2, R>(self: Exit<A, E>, f: (a: A) => Effect.Effect<B, E2, R>): Effect.Effect<Exit<B, E | E2>, never, R>
 } = core.exitForEachEffect
 
@@ -250,7 +316,23 @@ export const fromOption: <A>(option: Option.Option<A>) => Exit<A, void> = core.e
  * @category getters
  */
 export const getOrElse: {
+  /**
+   * Returns the `A` if specified exit is a `Success`, otherwise returns the
+   * alternate `A` value computed from the specified function which receives the
+   * `Cause<E>` of the exit `Failure`.
+   *
+   * @since 2.0.0
+   * @category getters
+   */
   <E, A2>(orElse: (cause: Cause.Cause<E>) => A2): <A>(self: Exit<A, E>) => A2 | A
+  /**
+   * Returns the `A` if specified exit is a `Success`, otherwise returns the
+   * alternate `A` value computed from the specified function which receives the
+   * `Cause<E>` of the exit `Failure`.
+   *
+   * @since 2.0.0
+   * @category getters
+   */
   <A, E, A2>(self: Exit<A, E>, orElse: (cause: Cause.Cause<E>) => A2): A | A2
 } = core.exitGetOrElse
 
@@ -271,7 +353,21 @@ export const interrupt: (fiberId: FiberId.FiberId) => Exit<never> = core.exitInt
  * @category mapping
  */
 export const map: {
+  /**
+   * Maps over the `Success` value of the specified exit using the provided
+   * function.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <A, B>(f: (a: A) => B): <E>(self: Exit<A, E>) => Exit<B, E>
+  /**
+   * Maps over the `Success` value of the specified exit using the provided
+   * function.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <A, E, B>(self: Exit<A, E>, f: (a: A) => B): Exit<B, E>
 } = core.exitMap
 
@@ -283,9 +379,23 @@ export const map: {
  * @category mapping
  */
 export const mapBoth: {
+  /**
+   * Maps over the `Success` and `Failure` cases of the specified exit using the
+   * provided functions.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <E, A, E2, A2>(
     options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
   ): (self: Exit<A, E>) => Exit<A2, E2>
+  /**
+   * Maps over the `Success` and `Failure` cases of the specified exit using the
+   * provided functions.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <A, E, E2, A2>(
     self: Exit<A, E>,
     options: { readonly onFailure: (e: E) => E2; readonly onSuccess: (a: A) => A2 }
@@ -300,7 +410,21 @@ export const mapBoth: {
  * @category mapping
  */
 export const mapError: {
+  /**
+   * Maps over the error contained in the `Failure` of the specified exit using
+   * the provided function.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <E, E2>(f: (e: E) => E2): <A>(self: Exit<A, E>) => Exit<A, E2>
+  /**
+   * Maps over the error contained in the `Failure` of the specified exit using
+   * the provided function.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <A, E, E2>(self: Exit<A, E>, f: (e: E) => E2): Exit<A, E2>
 } = core.exitMapError
 
@@ -312,7 +436,21 @@ export const mapError: {
  * @category mapping
  */
 export const mapErrorCause: {
+  /**
+   * Maps over the `Cause` contained in the `Failure` of the specified exit using
+   * the provided function.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <E, E2>(f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): <A>(self: Exit<A, E>) => Exit<A, E2>
+  /**
+   * Maps over the `Cause` contained in the `Failure` of the specified exit using
+   * the provided function.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <E, A, E2>(self: Exit<A, E>, f: (cause: Cause.Cause<E>) => Cause.Cause<E2>): Exit<A, E2>
 } = core.exitMapErrorCause
 
@@ -321,9 +459,17 @@ export const mapErrorCause: {
  * @category folding
  */
 export const match: {
+  /**
+   * @since 2.0.0
+   * @category folding
+   */
   <E, A, Z1, Z2>(
     options: { readonly onFailure: (cause: Cause.Cause<E>) => Z1; readonly onSuccess: (a: A) => Z2 }
   ): (self: Exit<A, E>) => Z1 | Z2
+  /**
+   * @since 2.0.0
+   * @category folding
+   */
   <A, E, Z1, Z2>(
     self: Exit<A, E>,
     options: { readonly onFailure: (cause: Cause.Cause<E>) => Z1; readonly onSuccess: (a: A) => Z2 }
@@ -335,12 +481,20 @@ export const match: {
  * @category folding
  */
 export const matchEffect: {
+  /**
+   * @since 2.0.0
+   * @category folding
+   */
   <E, A2, E2, R, A, A3, E3, R2>(
     options: {
       readonly onFailure: (cause: Cause.Cause<E>) => Effect.Effect<A2, E2, R>
       readonly onSuccess: (a: A) => Effect.Effect<A3, E3, R2>
     }
   ): (self: Exit<A, E>) => Effect.Effect<A2 | A3, E2 | E3, R | R2>
+  /**
+   * @since 2.0.0
+   * @category folding
+   */
   <A, E, A2, E2, R, A3, E3, R2>(
     self: Exit<A, E>,
     options: {
@@ -377,7 +531,21 @@ export {
  * @category zipping
  */
 export const zip: {
+  /**
+   * Sequentially zips the this result with the specified result or else returns
+   * the failed `Cause<E | E2>`.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <A2, E2>(that: Exit<A2, E2>): <A, E>(self: Exit<A, E>) => Exit<[A, A2], E2 | E>
+  /**
+   * Sequentially zips the this result with the specified result or else returns
+   * the failed `Cause<E | E2>`.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <A, E, A2, E2>(self: Exit<A, E>, that: Exit<A2, E2>): Exit<[A, A2], E | E2>
 } = core.exitZip
 
@@ -389,7 +557,21 @@ export const zip: {
  * @category zipping
  */
 export const zipLeft: {
+  /**
+   * Sequentially zips the this result with the specified result discarding the
+   * second element of the tuple or else returns the failed `Cause<E | E2>`.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <A2, E2>(that: Exit<A2, E2>): <A, E>(self: Exit<A, E>) => Exit<A, E2 | E>
+  /**
+   * Sequentially zips the this result with the specified result discarding the
+   * second element of the tuple or else returns the failed `Cause<E | E2>`.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <A, E, A2, E2>(self: Exit<A, E>, that: Exit<A2, E2>): Exit<A, E | E2>
 } = core.exitZipLeft
 
@@ -401,7 +583,21 @@ export const zipLeft: {
  * @category zipping
  */
 export const zipRight: {
+  /**
+   * Sequentially zips the this result with the specified result discarding the
+   * first element of the tuple or else returns the failed `Cause<E | E2>`.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <A2, E2>(that: Exit<A2, E2>): <A, E>(self: Exit<A, E>) => Exit<A2, E2 | E>
+  /**
+   * Sequentially zips the this result with the specified result discarding the
+   * first element of the tuple or else returns the failed `Cause<E | E2>`.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <A, E, A2, E2>(self: Exit<A, E>, that: Exit<A2, E2>): Exit<A2, E | E2>
 } = core.exitZipRight
 
@@ -413,7 +609,21 @@ export const zipRight: {
  * @category zipping
  */
 export const zipPar: {
+  /**
+   * Parallelly zips the this result with the specified result or else returns
+   * the failed `Cause<E | E2>`.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <A2, E2>(that: Exit<A2, E2>): <A, E>(self: Exit<A, E>) => Exit<[A, A2], E2 | E>
+  /**
+   * Parallelly zips the this result with the specified result or else returns
+   * the failed `Cause<E | E2>`.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <A, E, A2, E2>(self: Exit<A, E>, that: Exit<A2, E2>): Exit<[A, A2], E | E2>
 } = core.exitZipPar
 
@@ -425,7 +635,21 @@ export const zipPar: {
  * @category zipping
  */
 export const zipParLeft: {
+  /**
+   * Parallelly zips the this result with the specified result discarding the
+   * second element of the tuple or else returns the failed `Cause<E | E2>`.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <A2, E2>(that: Exit<A2, E2>): <A, E>(self: Exit<A, E>) => Exit<A, E2 | E>
+  /**
+   * Parallelly zips the this result with the specified result discarding the
+   * second element of the tuple or else returns the failed `Cause<E | E2>`.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <A, E, A2, E2>(self: Exit<A, E>, that: Exit<A2, E2>): Exit<A, E | E2>
 } = core.exitZipParLeft
 
@@ -437,7 +661,21 @@ export const zipParLeft: {
  * @category zipping
  */
 export const zipParRight: {
+  /**
+   * Parallelly zips the this result with the specified result discarding the
+   * first element of the tuple or else returns the failed `Cause<E | E2>`.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <A2, E2>(that: Exit<A2, E2>): <A, E>(self: Exit<A, E>) => Exit<A2, E2 | E>
+  /**
+   * Parallelly zips the this result with the specified result discarding the
+   * first element of the tuple or else returns the failed `Cause<E | E2>`.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <A, E, A2, E2>(self: Exit<A, E>, that: Exit<A2, E2>): Exit<A2, E | E2>
 } = core.exitZipParRight
 
@@ -449,6 +687,13 @@ export const zipParRight: {
  * @category zipping
  */
 export const zipWith: {
+  /**
+   * Zips this exit together with that exit using the specified combination
+   * functions.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <B, E2, A, C, E>(
     that: Exit<B, E2>,
     options: {
@@ -456,6 +701,13 @@ export const zipWith: {
       readonly onFailure: (cause: Cause.Cause<E>, cause2: Cause.Cause<E2>) => Cause.Cause<any>
     }
   ): (self: Exit<A, E>) => Exit<C, any>
+  /**
+   * Zips this exit together with that exit using the specified combination
+   * functions.
+   *
+   * @since 2.0.0
+   * @category zipping
+   */
   <A, E, B, E2, C>(
     self: Exit<A, E>,
     that: Exit<B, E2>,