effect 3.8.4 → 3.8.5

package/src/RedBlackTree.ts

@@ -55,7 +55,15 @@ export declare namespace RedBlackTree {
  * @category refinements
  */
 export const isRedBlackTree: {
+  /**
+   * @since 2.0.0
+   * @category refinements
+   */
   <K, V>(u: Iterable<readonly [K, V]>): u is RedBlackTree<K, V>
+  /**
+   * @since 2.0.0
+   * @category refinements
+   */
   (u: unknown): u is RedBlackTree<unknown, unknown>
 } = RBT.isRedBlackTree
 
@@ -74,7 +82,19 @@ export const empty: <K, V = never>(ord: Order<K>) => RedBlackTree<K, V> = RBT.em
  * @category constructors
  */
 export const fromIterable: {
+  /**
+   * Creates a new `RedBlackTree` from an iterable collection of key/value pairs.
+   *
+   * @since 2.0.0
+   * @category constructors
+   */
   <B>(ord: Order<B>): <K extends B, V>(entries: Iterable<readonly [K, V]>) => RedBlackTree<K, V>
+  /**
+   * Creates a new `RedBlackTree` from an iterable collection of key/value pairs.
+   *
+   * @since 2.0.0
+   * @category constructors
+   */
   <K extends B, V, B>(entries: Iterable<readonly [K, V]>, ord: Order<B>): RedBlackTree<K, V>
 } = RBT.fromIterable
 
@@ -100,7 +120,25 @@ export const make: <K>(
  * @category traversing
  */
 export const at: {
+  /**
+   * Returns an iterator that points to the element at the specified index of the
+   * tree.
+   *
+   * **Note**: The iterator will run through elements in order.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   (index: number): <K, V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
+  /**
+   * Returns an iterator that points to the element at the specified index of the
+   * tree.
+   *
+   * **Note**: The iterator will run through elements in order.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(self: RedBlackTree<K, V>, index: number): Iterable<[K, V]>
 } = RBT.atForwards
 
@@ -114,7 +152,25 @@ export const at: {
  * @category traversing
  */
 export const atReversed: {
+  /**
+   * Returns an iterator that points to the element at the specified index of the
+   * tree.
+   *
+   * **Note**: The iterator will run through elements in reverse order.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   (index: number): <K, V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
+  /**
+   * Returns an iterator that points to the element at the specified index of the
+   * tree.
+   *
+   * **Note**: The iterator will run through elements in reverse order.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(self: RedBlackTree<K, V>, index: number): Iterable<[K, V]>
 } = RBT.atBackwards
 
@@ -125,7 +181,19 @@ export const atReversed: {
  * @category elements
  */
 export const findAll: {
+  /**
+   * Finds all values in the tree associated with the specified key.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <K>(key: K): <V>(self: RedBlackTree<K, V>) => Chunk<V>
+  /**
+   * Finds all values in the tree associated with the specified key.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <K, V>(self: RedBlackTree<K, V>, key: K): Chunk<V>
 } = RBT.findAll
 
@@ -136,7 +204,19 @@ export const findAll: {
  * @since 2.0.0
  */
 export const findFirst: {
+  /**
+   * Finds the first value in the tree associated with the specified key, if it exists.
+   *
+   * @category elements
+   * @since 2.0.0
+   */
   <K>(key: K): <V>(self: RedBlackTree<K, V>) => Option<V>
+  /**
+   * Finds the first value in the tree associated with the specified key, if it exists.
+   *
+   * @category elements
+   * @since 2.0.0
+   */
   <K, V>(self: RedBlackTree<K, V>, key: K): Option<V>
 } = RBT.findFirst
 
@@ -156,7 +236,21 @@ export const first: <K, V>(self: RedBlackTree<K, V>) => Option<[K, V]> = RBT.fir
  * @category elements
  */
 export const getAt: {
+  /**
+   * Returns the element at the specified index within the tree or `None` if the
+   * specified index does not exist.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   (index: number): <K, V>(self: RedBlackTree<K, V>) => Option<[K, V]>
+  /**
+   * Returns the element at the specified index within the tree or `None` if the
+   * specified index does not exist.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <K, V>(self: RedBlackTree<K, V>, index: number): Option<[K, V]>
 } = RBT.getAt
 
@@ -176,7 +270,21 @@ export const getOrder: <K, V>(self: RedBlackTree<K, V>) => Order<K> = RBT.getOrd
  * @category traversing
  */
 export const greaterThan: {
+  /**
+   * Returns an iterator that traverse entries in order with keys greater than the
+   * specified key.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
+  /**
+   * Returns an iterator that traverse entries in order with keys greater than the
+   * specified key.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(self: RedBlackTree<K, V>, key: K): Iterable<[K, V]>
 } = RBT.greaterThanForwards
 
@@ -188,7 +296,21 @@ export const greaterThan: {
  * @category traversing
  */
 export const greaterThanReversed: {
+  /**
+   * Returns an iterator that traverse entries in reverse order with keys greater
+   * than the specified key.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
+  /**
+   * Returns an iterator that traverse entries in reverse order with keys greater
+   * than the specified key.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(self: RedBlackTree<K, V>, key: K): Iterable<[K, V]>
 } = RBT.greaterThanBackwards
 
@@ -200,7 +322,21 @@ export const greaterThanReversed: {
  * @category traversing
  */
 export const greaterThanEqual: {
+  /**
+   * Returns an iterator that traverse entries in order with keys greater than or
+   * equal to the specified key.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
+  /**
+   * Returns an iterator that traverse entries in order with keys greater than or
+   * equal to the specified key.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(self: RedBlackTree<K, V>, key: K): Iterable<[K, V]>
 } = RBT.greaterThanEqualForwards
 
@@ -212,7 +348,21 @@ export const greaterThanEqual: {
  * @category traversing
  */
 export const greaterThanEqualReversed: {
+  /**
+   * Returns an iterator that traverse entries in reverse order with keys greater
+   * than or equal to the specified key.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
+  /**
+   * Returns an iterator that traverse entries in reverse order with keys greater
+   * than or equal to the specified key.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(self: RedBlackTree<K, V>, key: K): Iterable<[K, V]>
 } = RBT.greaterThanEqualBackwards
 
@@ -223,7 +373,19 @@ export const greaterThanEqualReversed: {
  * @category elements
  */
 export const has: {
+  /**
+   * Finds the item with key, if it exists.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <K>(key: K): <V>(self: RedBlackTree<K, V>) => boolean
+  /**
+   * Finds the item with key, if it exists.
+   *
+   * @since 2.0.0
+   * @category elements
+   */
   <K, V>(self: RedBlackTree<K, V>, key: K): boolean
 } = RBT.has
 
@@ -233,7 +395,17 @@ export const has: {
  * @since 2.0.0
  */
 export const insert: {
+  /**
+   * Insert a new item into the tree.
+   *
+   * @since 2.0.0
+   */
   <K, V>(key: K, value: V): (self: RedBlackTree<K, V>) => RedBlackTree<K, V>
+  /**
+   * Insert a new item into the tree.
+   *
+   * @since 2.0.0
+   */
   <K, V>(self: RedBlackTree<K, V>, key: K, value: V): RedBlackTree<K, V>
 } = RBT.insert
 
@@ -269,7 +441,21 @@ export const last: <K, V>(self: RedBlackTree<K, V>) => Option<[K, V]> = RBT.last
  * @category traversing
  */
 export const lessThan: {
+  /**
+   * Returns an iterator that traverse entries in order with keys less than the
+   * specified key.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
+  /**
+   * Returns an iterator that traverse entries in order with keys less than the
+   * specified key.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(self: RedBlackTree<K, V>, key: K): Iterable<[K, V]>
 } = RBT.lessThanForwards
 
@@ -281,7 +467,21 @@ export const lessThan: {
  * @category traversing
  */
 export const lessThanReversed: {
+  /**
+   * Returns an iterator that traverse entries in reverse order with keys less
+   * than the specified key.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
+  /**
+   * Returns an iterator that traverse entries in reverse order with keys less
+   * than the specified key.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(self: RedBlackTree<K, V>, key: K): Iterable<[K, V]>
 } = RBT.lessThanBackwards
 
@@ -293,7 +493,21 @@ export const lessThanReversed: {
  * @category traversing
  */
 export const lessThanEqual: {
+  /**
+   * Returns an iterator that traverse entries in order with keys less than or
+   * equal to the specified key.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
+  /**
+   * Returns an iterator that traverse entries in order with keys less than or
+   * equal to the specified key.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(self: RedBlackTree<K, V>, key: K): Iterable<[K, V]>
 } = RBT.lessThanEqualForwards
 
@@ -305,7 +519,21 @@ export const lessThanEqual: {
  * @category traversing
  */
 export const lessThanEqualReversed: {
+  /**
+   * Returns an iterator that traverse entries in reverse order with keys less
+   * than or equal to the specified key.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<[K, V]>
+  /**
+   * Returns an iterator that traverse entries in reverse order with keys less
+   * than or equal to the specified key.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(self: RedBlackTree<K, V>, key: K): Iterable<[K, V]>
 } = RBT.lessThanEqualBackwards
 
@@ -316,7 +544,19 @@ export const lessThanEqualReversed: {
  * @category traversing
  */
 export const forEach: {
+  /**
+   * Execute the specified function for each node of the tree, in order.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void
+  /**
+   * Execute the specified function for each node of the tree, in order.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(self: RedBlackTree<K, V>, f: (key: K, value: V) => void): void
 } = RBT.forEach
 
@@ -327,7 +567,19 @@ export const forEach: {
  * @category traversing
  */
 export const forEachGreaterThanEqual: {
+  /**
+   * Visit each node of the tree in order with key greater then or equal to max.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(min: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void
+  /**
+   * Visit each node of the tree in order with key greater then or equal to max.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(self: RedBlackTree<K, V>, min: K, f: (key: K, value: V) => void): void
 } = RBT.forEachGreaterThanEqual
 
@@ -338,7 +590,19 @@ export const forEachGreaterThanEqual: {
  * @category traversing
  */
 export const forEachLessThan: {
+  /**
+   * Visit each node of the tree in order with key lower then max.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(max: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void
+  /**
+   * Visit each node of the tree in order with key lower then max.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(self: RedBlackTree<K, V>, max: K, f: (key: K, value: V) => void): void
 } = RBT.forEachLessThan
 
@@ -350,6 +614,13 @@ export const forEachLessThan: {
  * @category traversing
  */
 export const forEachBetween: {
+  /**
+   * Visit each node of the tree in order with key lower than max and greater
+   * than or equal to min.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(
     options: {
       readonly min: K
@@ -357,6 +628,13 @@ export const forEachBetween: {
       readonly body: (key: K, value: V) => void
     }
   ): (self: RedBlackTree<K, V>) => void
+  /**
+   * Visit each node of the tree in order with key lower than max and greater
+   * than or equal to min.
+   *
+   * @since 2.0.0
+   * @category traversing
+   */
   <K, V>(
     self: RedBlackTree<K, V>,
     options: {
@@ -374,8 +652,24 @@ export const forEachBetween: {
  * @category folding
  */
 export const reduce: {
+  /**
+   * Reduce a state over the entries of the tree.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
   <Z, V, K>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: RedBlackTree<K, V>) => Z
-  <Z, V, K>(self: RedBlackTree<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z
+  /**
+   * Reduce a state over the entries of the tree.
+   *
+   * @since 2.0.0
+   * @category folding
+   */
+  <Z, V, K>(
+    self: RedBlackTree<K, V>,
+    zero: Z,
+    f: (accumulator: Z, value: V, key: K) => Z
+  ): Z
 } = RBT.reduce
 
 /**
@@ -384,7 +678,17 @@ export const reduce: {
  * @since 2.0.0
  */
 export const removeFirst: {
+  /**
+   * Removes the entry with the specified key, if it exists.
+   *
+   * @since 2.0.0
+   */
   <K>(key: K): <V>(self: RedBlackTree<K, V>) => RedBlackTree<K, V>
+  /**
+   * Removes the entry with the specified key, if it exists.
+   *
+   * @since 2.0.0
+   */
   <K, V>(self: RedBlackTree<K, V>, key: K): RedBlackTree<K, V>
 } = RBT.removeFirst
 

package/src/Ref.ts

@@ -79,7 +79,15 @@ export const get: <A>(self: Ref<A>) => Effect.Effect<A> = internal.get
  * @category utils
  */
 export const getAndSet: {
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(value: A): (self: Ref<A>) => Effect.Effect<A>
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(self: Ref<A>, value: A): Effect.Effect<A>
 } = internal.getAndSet
 
@@ -88,7 +96,15 @@ export const getAndSet: {
  * @category utils
  */
 export const getAndUpdate: {
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<A>
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<A>
 } = internal.getAndUpdate
 
@@ -97,7 +113,15 @@ export const getAndUpdate: {
  * @category utils
  */
 export const getAndUpdateSome: {
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(pf: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<A>
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(self: Ref<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>
 } = internal.getAndUpdateSome
 
@@ -106,7 +130,15 @@ export const getAndUpdateSome: {
  * @category utils
  */
 export const modify: {
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A, B>(f: (a: A) => readonly [B, A]): (self: Ref<A>) => Effect.Effect<B>
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A, B>(self: Ref<A>, f: (a: A) => readonly [B, A]): Effect.Effect<B>
 } = internal.modify
 
@@ -115,7 +147,15 @@ export const modify: {
  * @category utils
  */
 export const modifySome: {
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <B, A>(fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): (self: Ref<A>) => Effect.Effect<B>
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A, B>(self: Ref<A>, fallback: B, pf: (a: A) => Option.Option<readonly [B, A]>): Effect.Effect<B>
 } = internal.modifySome
 
@@ -124,7 +164,15 @@ export const modifySome: {
  * @category utils
  */
 export const set: {
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(value: A): (self: Ref<A>) => Effect.Effect<void>
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(self: Ref<A>, value: A): Effect.Effect<void>
 } = internal.set
 
@@ -133,7 +181,15 @@ export const set: {
  * @category utils
  */
 export const setAndGet: {
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(value: A): (self: Ref<A>) => Effect.Effect<A>
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(self: Ref<A>, value: A): Effect.Effect<A>
 } = internal.setAndGet
 
@@ -142,7 +198,15 @@ export const setAndGet: {
  * @category utils
  */
 export const update: {
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<void>
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<void>
 } = internal.update
 
@@ -151,7 +215,15 @@ export const update: {
  * @category utils
  */
 export const updateAndGet: {
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(f: (a: A) => A): (self: Ref<A>) => Effect.Effect<A>
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(self: Ref<A>, f: (a: A) => A): Effect.Effect<A>
 } = internal.updateAndGet
 
@@ -160,7 +232,15 @@ export const updateAndGet: {
  * @category utils
  */
 export const updateSome: {
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(f: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<void>
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(self: Ref<A>, f: (a: A) => Option.Option<A>): Effect.Effect<void>
 } = internal.updateSome
 
@@ -169,7 +249,15 @@ export const updateSome: {
  * @category utils
  */
 export const updateSomeAndGet: {
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(pf: (a: A) => Option.Option<A>): (self: Ref<A>) => Effect.Effect<A>
+  /**
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(self: Ref<A>, pf: (a: A) => Option.Option<A>): Effect.Effect<A>
 } = internal.updateSomeAndGet