effect 3.8.3 → 3.8.5

package/src/TSet.ts

@@ -60,7 +60,19 @@ export declare namespace TSet {
  * @category mutations
  */
 export const add: {
+  /**
+   * Stores new element in the set.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(value: A): (self: TSet<A>) => STM.STM<void>
+  /**
+   * Stores new element in the set.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(self: TSet<A>, value: A): STM.STM<void>
 } = internal.add
 
@@ -72,7 +84,21 @@ export const add: {
  * @category mutations
  */
 export const difference: {
+  /**
+   * Atomically transforms the set into the difference of itself and the
+   * provided set.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(other: TSet<A>): (self: TSet<A>) => STM.STM<void>
+  /**
+   * Atomically transforms the set into the difference of itself and the
+   * provided set.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(self: TSet<A>, other: TSet<A>): STM.STM<void>
 } = internal.difference
 
@@ -91,7 +117,19 @@ export const empty: <A>() => STM.STM<TSet<A>> = internal.empty
  * @category elements
  */
 export const forEach: {
+  /**
+   * Atomically performs transactional-effect for each element in set.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(f: (value: A) => STM.STM<void, E, R>): (self: TSet<A>) => STM.STM<void, E, R>
+  /**
+   * Atomically performs transactional-effect for each element in set.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(self: TSet<A>, f: (value: A) => STM.STM<void, E, R>): STM.STM<void, E, R>
 } = internal.forEach
 
@@ -110,7 +148,19 @@ export const fromIterable: <A>(iterable: Iterable<A>) => STM.STM<TSet<A>> = inte
  * @category elements
  */
 export const has: {
+  /**
+   * Tests whether or not set contains an element.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(value: A): (self: TSet<A>) => STM.STM<boolean>
+  /**
+   * Tests whether or not set contains an element.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TSet<A>, value: A): STM.STM<boolean>
 } = internal.has
 
@@ -122,7 +172,21 @@ export const has: {
  * @category mutations
  */
 export const intersection: {
+  /**
+   * Atomically transforms the set into the intersection of itself and the
+   * provided set.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(other: TSet<A>): (self: TSet<A>) => STM.STM<void>
+  /**
+   * Atomically transforms the set into the intersection of itself and the
+   * provided set.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(self: TSet<A>, other: TSet<A>): STM.STM<void>
 } = internal.intersection
 
@@ -151,7 +215,19 @@ export const make: <Elements extends Array<any>>(
  * @category folding
  */
 export const reduce: {
+  /**
+   * Atomically folds using a pure function.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
   <Z, A>(zero: Z, f: (accumulator: Z, value: A) => Z): (self: TSet<A>) => STM.STM<Z>
+  /**
+   * Atomically folds using a pure function.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
   <Z, A>(self: TSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z): STM.STM<Z>
 } = internal.reduce
 
@@ -162,7 +238,19 @@ export const reduce: {
  * @category folding
  */
 export const reduceSTM: {
+  /**
+   * Atomically folds using a transactional function.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
   <Z, A, R, E>(zero: Z, f: (accumulator: Z, value: A) => STM.STM<Z, E, R>): (self: TSet<A>) => STM.STM<Z, E, R>
+  /**
+   * Atomically folds using a transactional function.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
   <Z, A, R, E>(self: TSet<A>, zero: Z, f: (accumulator: Z, value: A) => STM.STM<Z, E, R>): STM.STM<Z, E, R>
 } = internal.reduceSTM
 
@@ -173,7 +261,19 @@ export const reduceSTM: {
  * @category mutations
  */
 export const remove: {
+  /**
+   * Removes a single element from the set.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(value: A): (self: TSet<A>) => STM.STM<void>
+  /**
+   * Removes a single element from the set.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(self: TSet<A>, value: A): STM.STM<void>
 } = internal.remove
 
@@ -184,7 +284,19 @@ export const remove: {
  * @category mutations
  */
 export const removeAll: {
+  /**
+   * Removes elements from the set.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(iterable: Iterable<A>): (self: TSet<A>) => STM.STM<void>
+  /**
+   * Removes elements from the set.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(self: TSet<A>, iterable: Iterable<A>): STM.STM<void>
 } = internal.removeAll
 
@@ -196,18 +308,53 @@ export const removeAll: {
  * @category mutations
  */
 export const removeIf: {
-  <A>(predicate: Predicate<A>, options: {
-    readonly discard: true
-  }): (self: TSet<A>) => STM.STM<void>
+  /**
+   * Removes entries from a `TSet` that satisfy the specified predicate and returns the removed entries
+   * (or `void` if `discard = true`).
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
+  <A>(
+    predicate: Predicate<A>,
+    options: {
+      readonly discard: true
+    }
+  ): (self: TSet<A>) => STM.STM<void>
+  /**
+   * Removes entries from a `TSet` that satisfy the specified predicate and returns the removed entries
+   * (or `void` if `discard = true`).
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(
     predicate: Predicate<A>,
     options?: {
       readonly discard: false
     }
   ): (self: TSet<A>) => STM.STM<Array<A>>
-  <A>(self: TSet<A>, predicate: Predicate<A>, options: {
-    readonly discard: true
-  }): STM.STM<void>
+  /**
+   * Removes entries from a `TSet` that satisfy the specified predicate and returns the removed entries
+   * (or `void` if `discard = true`).
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
+  <A>(
+    self: TSet<A>,
+    predicate: Predicate<A>,
+    options: {
+      readonly discard: true
+    }
+  ): STM.STM<void>
+  /**
+   * Removes entries from a `TSet` that satisfy the specified predicate and returns the removed entries
+   * (or `void` if `discard = true`).
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(
     self: TSet<A>,
     predicate: Predicate<A>,
@@ -225,18 +372,53 @@ export const removeIf: {
  * @category mutations
  */
 export const retainIf: {
-  <A>(predicate: Predicate<A>, options: {
-    readonly discard: true
-  }): (self: TSet<A>) => STM.STM<void>
+  /**
+   * Retains entries in a `TSet` that satisfy the specified predicate and returns the removed entries
+   * (or `void` if `discard = true`).
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
+  <A>(
+    predicate: Predicate<A>,
+    options: {
+      readonly discard: true
+    }
+  ): (self: TSet<A>) => STM.STM<void>
+  /**
+   * Retains entries in a `TSet` that satisfy the specified predicate and returns the removed entries
+   * (or `void` if `discard = true`).
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(
     predicate: Predicate<A>,
     options?: {
       readonly discard: false
     }
   ): (self: TSet<A>) => STM.STM<Array<A>>
-  <A>(self: TSet<A>, predicate: Predicate<A>, options: {
-    readonly discard: true
-  }): STM.STM<void>
+  /**
+   * Retains entries in a `TSet` that satisfy the specified predicate and returns the removed entries
+   * (or `void` if `discard = true`).
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
+  <A>(
+    self: TSet<A>,
+    predicate: Predicate<A>,
+    options: {
+      readonly discard: true
+    }
+  ): STM.STM<void>
+  /**
+   * Retains entries in a `TSet` that satisfy the specified predicate and returns the removed entries
+   * (or `void` if `discard = true`).
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(
     self: TSet<A>,
     predicate: Predicate<A>,
@@ -261,7 +443,19 @@ export const size: <A>(self: TSet<A>) => STM.STM<number> = internal.size
  * @category mutations
  */
 export const takeFirst: {
+  /**
+   * Takes the first matching value, or retries until there is one.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A, B>(pf: (a: A) => Option.Option<B>): (self: TSet<A>) => STM.STM<B>
+  /**
+   * Takes the first matching value, or retries until there is one.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A, B>(self: TSet<A>, pf: (a: A) => Option.Option<B>): STM.STM<B>
 } = internal.takeFirst
 
@@ -272,7 +466,19 @@ export const takeFirst: {
  * @category mutations
  */
 export const takeFirstSTM: {
+  /**
+   * Takes the first matching value, or retries until there is one.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A, B, E, R>(pf: (a: A) => STM.STM<B, Option.Option<E>, R>): (self: TSet<A>) => STM.STM<B, E, R>
+  /**
+   * Takes the first matching value, or retries until there is one.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A, B, E, R>(self: TSet<A>, pf: (a: A) => STM.STM<B, Option.Option<E>, R>): STM.STM<B, E, R>
 } = internal.takeFirstSTM
 
@@ -283,7 +489,19 @@ export const takeFirstSTM: {
  * @category mutations
  */
 export const takeSome: {
+  /**
+   * Takes all matching values, or retries until there is at least one.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A, B>(pf: (a: A) => Option.Option<B>): (self: TSet<A>) => STM.STM<[B, ...Array<B>]>
+  /**
+   * Takes all matching values, or retries until there is at least one.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A, B>(self: TSet<A>, pf: (a: A) => Option.Option<B>): STM.STM<[B, ...Array<B>]>
 } = internal.takeSome
 
@@ -294,7 +512,19 @@ export const takeSome: {
  * @category mutations
  */
 export const takeSomeSTM: {
+  /**
+   * Takes all matching values, or retries until there is at least one.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A, B, E, R>(pf: (a: A) => STM.STM<B, Option.Option<E>, R>): (self: TSet<A>) => STM.STM<[B, ...Array<B>], E, R>
+  /**
+   * Takes all matching values, or retries until there is at least one.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A, B, E, R>(self: TSet<A>, pf: (a: A) => STM.STM<B, Option.Option<E>, R>): STM.STM<[B, ...Array<B>], E, R>
 } = internal.takeSomeSTM
 
@@ -337,7 +567,19 @@ export const toReadonlySet: <A>(self: TSet<A>) => STM.STM<ReadonlySet<A>> = inte
  * @category mutations
  */
 export const transform: {
+  /**
+   * Atomically updates all elements using a pure function.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(f: (a: A) => A): (self: TSet<A>) => STM.STM<void>
+  /**
+   * Atomically updates all elements using a pure function.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(self: TSet<A>, f: (a: A) => A): STM.STM<void>
 } = internal.transform
 
@@ -348,7 +590,19 @@ export const transform: {
  * @category mutations
  */
 export const transformSTM: {
+  /**
+   * Atomically updates all elements using a transactional function.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A, R, E>(f: (a: A) => STM.STM<A, E, R>): (self: TSet<A>) => STM.STM<void, E, R>
+  /**
+   * Atomically updates all elements using a transactional function.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A, R, E>(self: TSet<A>, f: (a: A) => STM.STM<A, E, R>): STM.STM<void, E, R>
 } = internal.transformSTM
 
@@ -360,6 +614,20 @@ export const transformSTM: {
  * @category mutations
  */
 export const union: {
+  /**
+   * Atomically transforms the set into the union of itself and the provided
+   * set.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(other: TSet<A>): (self: TSet<A>) => STM.STM<void>
+  /**
+   * Atomically transforms the set into the union of itself and the provided
+   * set.
+   *
+   * @since 2.0.0
+   * @category mutations
+   */
   <A>(self: TSet<A>, other: TSet<A>): STM.STM<void>
 } = internal.union

package/src/Take.ts

@@ -177,7 +177,19 @@ export const make: <A, E>(exit: Exit.Exit<Chunk.Chunk<A>, Option.Option<E>>) =>
  * @category mapping
  */
 export const map: {
+  /**
+   * Transforms `Take<A, E>` to `Take<B, A>` by applying function `f`.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <A, B>(f: (a: A) => B): <E>(self: Take<A, E>) => Take<B, E>
+  /**
+   * Transforms `Take<A, E>` to `Take<B, A>` by applying function `f`.
+   *
+   * @since 2.0.0
+   * @category mapping
+   */
   <A, E, B>(self: Take<A, E>, f: (a: A) => B): Take<B, E>
 } = internal.map
 
@@ -189,6 +201,13 @@ export const map: {
  * @category destructors
  */
 export const match: {
+  /**
+   * Folds over the failure cause, success value and end-of-stream marker to
+   * yield a value.
+   *
+   * @since 2.0.0
+   * @category destructors
+   */
   <Z, E, Z2, A, Z3>(
     options: {
       readonly onEnd: () => Z
@@ -196,6 +215,13 @@ export const match: {
       readonly onSuccess: (chunk: Chunk.Chunk<A>) => Z3
     }
   ): (self: Take<A, E>) => Z | Z2 | Z3
+  /**
+   * Folds over the failure cause, success value and end-of-stream marker to
+   * yield a value.
+   *
+   * @since 2.0.0
+   * @category destructors
+   */
   <A, E, Z, Z2, Z3>(
     self: Take<A, E>,
     options: {
@@ -216,6 +242,15 @@ export const match: {
  * @category destructors
  */
 export const matchEffect: {
+  /**
+   * Effectful version of `Take.fold`.
+   *
+   * Folds over the failure cause, success value and end-of-stream marker to
+   * yield an effect.
+   *
+   * @since 2.0.0
+   * @category destructors
+   */
   <Z, E2, R, E, Z2, R2, A, Z3, E3, R3>(
     options: {
       readonly onEnd: Effect.Effect<Z, E2, R>
@@ -223,6 +258,15 @@ export const matchEffect: {
       readonly onSuccess: (chunk: Chunk.Chunk<A>) => Effect.Effect<Z3, E3, R3>
     }
   ): (self: Take<A, E>) => Effect.Effect<Z | Z2 | Z3, E2 | E | E3, R | R2 | R3>
+  /**
+   * Effectful version of `Take.fold`.
+   *
+   * Folds over the failure cause, success value and end-of-stream marker to
+   * yield an effect.
+   *
+   * @since 2.0.0
+   * @category destructors
+   */
   <A, E, Z, E2, R, Z2, R2, Z3, E3, R3>(
     self: Take<A, E>,
     options: {
@@ -248,9 +292,21 @@ export const of: <A>(value: A) => Take<A> = internal.of
  * @category sequencing
  */
 export const tap: {
+  /**
+   * Returns an effect that effectfully "peeks" at the success of this take.
+   *
+   * @since 2.0.0
+   * @category sequencing
+   */
   <A, X, E2, R>(
     f: (chunk: Chunk.Chunk<A>) => Effect.Effect<X, E2, R>
   ): <E>(self: Take<A, E>) => Effect.Effect<void, E2 | E, R>
+  /**
+   * Returns an effect that effectfully "peeks" at the success of this take.
+   *
+   * @since 2.0.0
+   * @category sequencing
+   */
   <A, E, X, E2, R>(
     self: Take<A, E>,
     f: (chunk: Chunk.Chunk<A>) => Effect.Effect<X, E2, R>

package/src/TestAnnotationMap.ts

@@ -55,7 +55,13 @@ export const make = (map: HashMap.HashMap<TestAnnotation.TestAnnotation<any>, an
  * @since 2.0.0
  */
 export const overwrite = dual<
+  /**
+   * @since 2.0.0
+   */
   <A>(key: TestAnnotation.TestAnnotation<A>, value: A) => (self: TestAnnotationMap) => TestAnnotationMap,
+  /**
+   * @since 2.0.0
+   */
   <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>, value: A) => TestAnnotationMap
 >(3, (self, key, value) => make(HashMap.set(self.map, key, value)))
 
@@ -63,8 +69,18 @@ export const overwrite = dual<
  * @since 2.0.0
  */
 export const update = dual<
+  /**
+   * @since 2.0.0
+   */
   <A>(key: TestAnnotation.TestAnnotation<A>, f: (value: A) => A) => (self: TestAnnotationMap) => TestAnnotationMap,
-  <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>, f: (value: A) => A) => TestAnnotationMap
+  /**
+   * @since 2.0.0
+   */
+  <A>(
+    self: TestAnnotationMap,
+    key: TestAnnotation.TestAnnotation<A>,
+    f: (value: A) => A
+  ) => TestAnnotationMap
 >(3, <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>, f: (value: A) => A) => {
   let value = key.initial
   if (HashMap.has(self.map, key.identifier)) {
@@ -80,7 +96,19 @@ export const update = dual<
  * @since 2.0.0
  */
 export const get = dual<
+  /**
+   * Retrieves the annotation of the specified type, or its default value if
+   * there is none.
+   *
+   * @since 2.0.0
+   */
   <A>(key: TestAnnotation.TestAnnotation<A>) => (self: TestAnnotationMap) => A,
+  /**
+   * Retrieves the annotation of the specified type, or its default value if
+   * there is none.
+   *
+   * @since 2.0.0
+   */
   <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>) => A
 >(2, <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>) => {
   if (HashMap.has(self.map, key.identifier)) {
@@ -95,7 +123,17 @@ export const get = dual<
  * @since 2.0.0
  */
 export const annotate = dual<
+  /**
+   * Appends the specified annotation to the annotation map.
+   *
+   * @since 2.0.0
+   */
   <A>(key: TestAnnotation.TestAnnotation<A>, value: A) => (self: TestAnnotationMap) => TestAnnotationMap,
+  /**
+   * Appends the specified annotation to the annotation map.
+   *
+   * @since 2.0.0
+   */
   <A>(self: TestAnnotationMap, key: TestAnnotation.TestAnnotation<A>, value: A) => TestAnnotationMap
 >(3, (self, key, value) => update(self, key, (_) => key.combine(_, value)))
 
@@ -103,7 +141,13 @@ export const annotate = dual<
  * @since 2.0.0
  */
 export const combine = dual<
+  /**
+   * @since 2.0.0
+   */
   (that: TestAnnotationMap) => (self: TestAnnotationMap) => TestAnnotationMap,
+  /**
+   * @since 2.0.0
+   */
   (self: TestAnnotationMap, that: TestAnnotationMap) => TestAnnotationMap
 >(2, (self, that) => {
   let result = self.map

package/src/TestClock.ts

@@ -474,7 +474,13 @@ export const adjust = (durationInput: Duration.DurationInput): Effect.Effect<voi
  * @since 2.0.0
  */
 export const adjustWith = dual<
+  /**
+   * @since 2.0.0
+   */
   (duration: Duration.DurationInput) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>,
+  /**
+   * @since 2.0.0
+   */
   <A, E, R>(effect: Effect.Effect<A, E, R>, duration: Duration.DurationInput) => Effect.Effect<A, E, R>
 >(2, (effect, durationInput) => {
   const duration = Duration.decode(durationInput)