effect 3.8.4 → 3.9.0

package/src/TArray.ts

@@ -58,7 +58,21 @@ export declare namespace TArray {
  * @category elements
  */
 export const collectFirst: {
+  /**
+   * Finds the result of applying a partial function to the first value in its
+   * domain.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, B>(pf: (a: A) => Option.Option<B>): (self: TArray<A>) => STM.STM<Option.Option<B>>
+  /**
+   * Finds the result of applying a partial function to the first value in its
+   * domain.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, B>(self: TArray<A>, pf: (a: A) => Option.Option<B>): STM.STM<Option.Option<B>>
 } = internal.collectFirst
 
@@ -70,7 +84,21 @@ export const collectFirst: {
  * @category elements
  */
 export const collectFirstSTM: {
+  /**
+   * Finds the result of applying an transactional partial function to the first
+   * value in its domain.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, B, E, R>(pf: (a: A) => Option.Option<STM.STM<B, E, R>>): (self: TArray<A>) => STM.STM<Option.Option<B>, E, R>
+  /**
+   * Finds the result of applying an transactional partial function to the first
+   * value in its domain.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, B, E, R>(self: TArray<A>, pf: (a: A) => Option.Option<STM.STM<B, E, R>>): STM.STM<Option.Option<B>, E, R>
 } = internal.collectFirstSTM
 
@@ -82,7 +110,21 @@ export const collectFirstSTM: {
  * @category elements
  */
 export const contains: {
+  /**
+   * Determine if the array contains a specified value.
+   *
+   * @macro trace
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(value: A): (self: TArray<A>) => STM.STM<boolean>
+  /**
+   * Determine if the array contains a specified value.
+   *
+   * @macro trace
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TArray<A>, value: A): STM.STM<boolean>
 } = internal.contains
 
@@ -94,7 +136,21 @@ export const contains: {
  * @category folding
  */
 export const count: {
+  /**
+   * Count the values in the array matching a predicate.
+   *
+   * @macro trace
+   * @since 2.0.0
+   * @category folding
+   */
   <A>(predicate: Predicate<A>): (self: TArray<A>) => STM.STM<number>
+  /**
+   * Count the values in the array matching a predicate.
+   *
+   * @macro trace
+   * @since 2.0.0
+   * @category folding
+   */
   <A>(self: TArray<A>, predicate: Predicate<A>): STM.STM<number>
 } = internal.count
 
@@ -106,7 +162,21 @@ export const count: {
  * @category folding
  */
 export const countSTM: {
+  /**
+   * Count the values in the array matching a transactional predicate.
+   *
+   * @macro trace
+   * @since 2.0.0
+   * @category folding
+   */
   <A, R, E>(predicate: (value: A) => STM.STM<boolean, E, R>): (self: TArray<A>) => STM.STM<number, E, R>
+  /**
+   * Count the values in the array matching a transactional predicate.
+   *
+   * @macro trace
+   * @since 2.0.0
+   * @category folding
+   */
   <A, R, E>(self: TArray<A>, predicate: (value: A) => STM.STM<boolean, E, R>): STM.STM<number, E, R>
 } = internal.countSTM
 
@@ -126,7 +196,21 @@ export const empty: <A>() => STM.STM<TArray<A>> = internal.empty
  * @category elements
  */
 export const every: {
+  /**
+   * Atomically evaluate the conjunction of a predicate across the members of
+   * the array.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(predicate: Predicate<A>): (self: TArray<A>) => STM.STM<boolean>
+  /**
+   * Atomically evaluate the conjunction of a predicate across the members of
+   * the array.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TArray<A>, predicate: Predicate<A>): STM.STM<boolean>
 } = internal.every
 
@@ -138,7 +222,21 @@ export const every: {
  * @category elements
  */
 export const everySTM: {
+  /**
+   * Atomically evaluate the conjunction of a transactional predicate across the
+   * members of the array.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(predicate: (value: A) => STM.STM<boolean, E, R>): (self: TArray<A>) => STM.STM<boolean, E, R>
+  /**
+   * Atomically evaluate the conjunction of a transactional predicate across the
+   * members of the array.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(self: TArray<A>, predicate: (value: A) => STM.STM<boolean, E, R>): STM.STM<boolean, E, R>
 } = internal.everySTM
 
@@ -149,7 +247,19 @@ export const everySTM: {
  * @category elements
  */
 export const findFirst: {
+  /**
+   * Find the first element in the array matching the specified predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(predicate: Predicate<A>): (self: TArray<A>) => STM.STM<Option.Option<A>>
+  /**
+   * Find the first element in the array matching the specified predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TArray<A>, predicate: Predicate<A>): STM.STM<Option.Option<A>>
 } = internal.findFirst
 
@@ -160,7 +270,19 @@ export const findFirst: {
  * @category elements
  */
 export const findFirstIndex: {
+  /**
+   * Get the first index of a specific value in the array.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(value: A): (self: TArray<A>) => STM.STM<Option.Option<number>>
+  /**
+   * Get the first index of a specific value in the array.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TArray<A>, value: A): STM.STM<Option.Option<number>>
 } = internal.findFirstIndex
 
@@ -172,7 +294,21 @@ export const findFirstIndex: {
  * @category elements
  */
 export const findFirstIndexFrom: {
+  /**
+   * Get the first index of a specific value in the array starting from the
+   * specified index.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(value: A, from: number): (self: TArray<A>) => STM.STM<Option.Option<number>>
+  /**
+   * Get the first index of a specific value in the array starting from the
+   * specified index.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TArray<A>, value: A, from: number): STM.STM<Option.Option<number>>
 } = internal.findFirstIndexFrom
 
@@ -183,7 +319,19 @@ export const findFirstIndexFrom: {
  * @category elements
  */
 export const findFirstIndexWhere: {
+  /**
+   * Get the index of the first entry in the array matching a predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(predicate: Predicate<A>): (self: TArray<A>) => STM.STM<Option.Option<number>>
+  /**
+   * Get the index of the first entry in the array matching a predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TArray<A>, predicate: Predicate<A>): STM.STM<Option.Option<number>>
 } = internal.findFirstIndexWhere
 
@@ -195,7 +343,21 @@ export const findFirstIndexWhere: {
  * @category elements
  */
 export const findFirstIndexWhereFrom: {
+  /**
+   * Get the index of the first entry in the array starting from the specified
+   * index, matching a predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(predicate: Predicate<A>, from: number): (self: TArray<A>) => STM.STM<Option.Option<number>>
+  /**
+   * Get the index of the first entry in the array starting from the specified
+   * index, matching a predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TArray<A>, predicate: Predicate<A>, from: number): STM.STM<Option.Option<number>>
 } = internal.findFirstIndexWhereFrom
 
@@ -206,7 +368,19 @@ export const findFirstIndexWhereFrom: {
  * @category elements
  */
 export const findFirstIndexWhereSTM: {
+  /**
+   * Get the index of the next entry that matches a transactional predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(predicate: (value: A) => STM.STM<boolean, E, R>): (self: TArray<A>) => STM.STM<Option.Option<number>, E, R>
+  /**
+   * Get the index of the next entry that matches a transactional predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(self: TArray<A>, predicate: (value: A) => STM.STM<boolean, E, R>): STM.STM<Option.Option<number>, E, R>
 } = internal.findFirstIndexWhereSTM
 
@@ -218,10 +392,24 @@ export const findFirstIndexWhereSTM: {
  * @category elements
  */
 export const findFirstIndexWhereFromSTM: {
+  /**
+   * Starting at specified index, get the index of the next entry that matches a
+   * transactional predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(
     predicate: (value: A) => STM.STM<boolean, E, R>,
     from: number
   ): (self: TArray<A>) => STM.STM<Option.Option<number>, E, R>
+  /**
+   * Starting at specified index, get the index of the next entry that matches a
+   * transactional predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(
     self: TArray<A>,
     predicate: (value: A) => STM.STM<boolean, E, R>,
@@ -236,7 +424,19 @@ export const findFirstIndexWhereFromSTM: {
  * @category elements
  */
 export const findFirstSTM: {
+  /**
+   * Find the first element in the array matching a transactional predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(predicate: (value: A) => STM.STM<boolean, E, R>): (self: TArray<A>) => STM.STM<Option.Option<A>, E, R>
+  /**
+   * Find the first element in the array matching a transactional predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(self: TArray<A>, predicate: (value: A) => STM.STM<boolean, E, R>): STM.STM<Option.Option<A>, E, R>
 } = internal.findFirstSTM
 
@@ -247,7 +447,19 @@ export const findFirstSTM: {
  * @category elements
  */
 export const findLast: {
+  /**
+   * Find the last element in the array matching a predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(predicate: Predicate<A>): (self: TArray<A>) => STM.STM<Option.Option<A>>
+  /**
+   * Find the last element in the array matching a predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TArray<A>, predicate: Predicate<A>): STM.STM<Option.Option<A>>
 } = internal.findLast
 
@@ -259,7 +471,21 @@ export const findLast: {
  * @category elements
  */
 export const findLastIndex: {
+  /**
+   * Get the last index of a specific value in the array bounded above by a
+   * specific index.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(value: A): (self: TArray<A>) => STM.STM<Option.Option<number>>
+  /**
+   * Get the last index of a specific value in the array bounded above by a
+   * specific index.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TArray<A>, value: A): STM.STM<Option.Option<number>>
 } = internal.findLastIndex
 
@@ -271,7 +497,21 @@ export const findLastIndex: {
  * @category elements
  */
 export const findLastIndexFrom: {
+  /**
+   * Get the last index of a specific value in the array bounded above by a
+   * specific index.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(value: A, end: number): (self: TArray<A>) => STM.STM<Option.Option<number>>
+  /**
+   * Get the last index of a specific value in the array bounded above by a
+   * specific index.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TArray<A>, value: A, end: number): STM.STM<Option.Option<number>>
 } = internal.findLastIndexFrom
 
@@ -282,7 +522,19 @@ export const findLastIndexFrom: {
  * @category elements
  */
 export const findLastSTM: {
+  /**
+   * Find the last element in the array matching a transactional predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(predicate: (value: A) => STM.STM<boolean, E, R>): (self: TArray<A>) => STM.STM<Option.Option<A>, E, R>
+  /**
+   * Find the last element in the array matching a transactional predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(self: TArray<A>, predicate: (value: A) => STM.STM<boolean, E, R>): STM.STM<Option.Option<A>, E, R>
 } = internal.findLastSTM
 
@@ -293,7 +545,19 @@ export const findLastSTM: {
  * @category elements
  */
 export const forEach: {
+  /**
+   * Atomically performs transactional effect for each item in array.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(f: (value: A) => STM.STM<void, E, R>): (self: TArray<A>) => STM.STM<void, E, R>
+  /**
+   * Atomically performs transactional effect for each item in array.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(self: TArray<A>, f: (value: A) => STM.STM<void, E, R>): STM.STM<void, E, R>
 } = internal.forEach
 
@@ -312,7 +576,19 @@ export const fromIterable: <A>(iterable: Iterable<A>) => STM.STM<TArray<A>> = in
  * @category elements
  */
 export const get: {
+  /**
+   * Extracts value from ref in array.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   (index: number): <A>(self: TArray<A>) => STM.STM<A>
+  /**
+   * Extracts value from ref in array.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TArray<A>, index: number): STM.STM<A>
 } = internal.get
 
@@ -349,7 +625,19 @@ export const make: <Elements extends [any, ...Array<any>]>(
  * @category elements
  */
 export const maxOption: {
+  /**
+   * Atomically compute the greatest element in the array, if it exists.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(order: Order.Order<A>): (self: TArray<A>) => STM.STM<Option.Option<A>>
+  /**
+   * Atomically compute the greatest element in the array, if it exists.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TArray<A>, order: Order.Order<A>): STM.STM<Option.Option<A>>
 } = internal.maxOption
 
@@ -360,7 +648,19 @@ export const maxOption: {
  * @category elements
  */
 export const minOption: {
+  /**
+   * Atomically compute the least element in the array, if it exists.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(order: Order.Order<A>): (self: TArray<A>) => STM.STM<Option.Option<A>>
+  /**
+   * Atomically compute the least element in the array, if it exists.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TArray<A>, order: Order.Order<A>): STM.STM<Option.Option<A>>
 } = internal.minOption
 
@@ -371,7 +671,19 @@ export const minOption: {
  * @category folding
  */
 export const reduce: {
+  /**
+   * Atomically folds using a pure function.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
   <Z, A>(zero: Z, f: (accumulator: Z, current: A) => Z): (self: TArray<A>) => STM.STM<Z>
+  /**
+   * Atomically folds using a pure function.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
   <Z, A>(self: TArray<A>, zero: Z, f: (accumulator: Z, current: A) => Z): STM.STM<Z>
 } = internal.reduce
 
@@ -382,7 +694,19 @@ export const reduce: {
  * @category elements
  */
 export const reduceOption: {
+  /**
+   * Atomically reduce the array, if non-empty, by a binary operator.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(f: (x: A, y: A) => A): (self: TArray<A>) => STM.STM<Option.Option<A>>
+  /**
+   * Atomically reduce the array, if non-empty, by a binary operator.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TArray<A>, f: (x: A, y: A) => A): STM.STM<Option.Option<A>>
 } = internal.reduceOption
 
@@ -394,7 +718,21 @@ export const reduceOption: {
  * @category elements
  */
 export const reduceOptionSTM: {
+  /**
+   * Atomically reduce the non-empty array using a transactional binary
+   * operator.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(f: (x: A, y: A) => STM.STM<A, E, R>): (self: TArray<A>) => STM.STM<Option.Option<A>, E, R>
+  /**
+   * Atomically reduce the non-empty array using a transactional binary
+   * operator.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(self: TArray<A>, f: (x: A, y: A) => STM.STM<A, E, R>): STM.STM<Option.Option<A>, E, R>
 } = internal.reduceOptionSTM
 
@@ -406,8 +744,26 @@ export const reduceOptionSTM: {
  * @category folding
  */
 export const reduceSTM: {
+  /**
+   * Atomically folds using a transactional function.
+   *
+   * @macro trace
+   * @since 2.0.0
+   * @category folding
+   */
   <Z, A, R, E>(zero: Z, f: (accumulator: Z, current: A) => STM.STM<Z, E, R>): (self: TArray<A>) => STM.STM<Z, E, R>
-  <Z, A, R, E>(self: TArray<A>, zero: Z, f: (accumulator: Z, current: A) => STM.STM<Z, E, R>): STM.STM<Z, E, R>
+  /**
+   * Atomically folds using a transactional function.
+   *
+   * @macro trace
+   * @since 2.0.0
+   * @category folding
+   */
+  <Z, A, R, E>(
+    self: TArray<A>,
+    zero: Z,
+    f: (accumulator: Z, current: A) => STM.STM<Z, E, R>
+  ): STM.STM<Z, E, R>
 } = internal.reduceSTM
 
 /**
@@ -425,7 +781,19 @@ export const size: <A>(self: TArray<A>) => number = internal.size
  * @category elements
  */
 export const some: {
+  /**
+   * Determine if the array contains a value satisfying a predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(predicate: Predicate<A>): (self: TArray<A>) => STM.STM<boolean>
+  /**
+   * Determine if the array contains a value satisfying a predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TArray<A>, predicate: Predicate<A>): STM.STM<boolean>
 } = internal.some
 
@@ -437,7 +805,21 @@ export const some: {
  * @category elements
  */
 export const someSTM: {
+  /**
+   * Determine if the array contains a value satisfying a transactional
+   * predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(predicate: (value: A) => STM.STM<boolean, E, R>): (self: TArray<A>) => STM.STM<boolean, E, R>
+  /**
+   * Determine if the array contains a value satisfying a transactional
+   * predicate.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(self: TArray<A>, predicate: (value: A) => STM.STM<boolean, E, R>): STM.STM<boolean, E, R>
 } = internal.someSTM
 
@@ -457,7 +839,19 @@ export const toArray: <A>(self: TArray<A>) => STM.STM<Array<A>> = internal.toArr
  * @category elements
  */
 export const transform: {
+  /**
+   * Atomically updates all elements using a pure function.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(f: (value: A) => A): (self: TArray<A>) => STM.STM<void>
+  /**
+   * Atomically updates all elements using a pure function.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TArray<A>, f: (value: A) => A): STM.STM<void>
 } = internal.transform
 
@@ -468,7 +862,19 @@ export const transform: {
  * @category elements
  */
 export const transformSTM: {
+  /**
+   * Atomically updates all elements using a transactional effect.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(f: (value: A) => STM.STM<A, E, R>): (self: TArray<A>) => STM.STM<void, E, R>
+  /**
+   * Atomically updates all elements using a transactional effect.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(self: TArray<A>, f: (value: A) => STM.STM<A, E, R>): STM.STM<void, E, R>
 } = internal.transformSTM
 
@@ -479,7 +885,19 @@ export const transformSTM: {
  * @category elements
  */
 export const update: {
+  /**
+   * Updates element in the array with given function.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(index: number, f: (value: A) => A): (self: TArray<A>) => STM.STM<void>
+  /**
+   * Updates element in the array with given function.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A>(self: TArray<A>, index: number, f: (value: A) => A): STM.STM<void>
 } = internal.update
 
@@ -490,6 +908,18 @@ export const update: {
  * @category elements
  */
 export const updateSTM: {
+  /**
+   * Atomically updates element in the array with given transactional effect.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(index: number, f: (value: A) => STM.STM<A, E, R>): (self: TArray<A>) => STM.STM<void, E, R>
+  /**
+   * Atomically updates element in the array with given transactional effect.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <A, R, E>(self: TArray<A>, index: number, f: (value: A) => STM.STM<A, E, R>): STM.STM<void, E, R>
 } = internal.updateSTM