effect 3.8.4 → 3.9.0

package/src/Queue.ts

@@ -64,7 +64,7 @@ export type BackingQueueTypeId = typeof BackingQueueTypeId
  * @since 2.0.0
  * @category models
  */
-export interface Queue<in out A> extends Enqueue<A>, Dequeue<A>, Pipeable {
+export interface Queue<in out A> extends Enqueue<A>, Dequeue<A> {
   /** @internal */
   readonly queue: BackingQueue<A>
   /** @internal */
@@ -134,7 +134,7 @@ export interface Enqueue<in A> extends Queue.EnqueueVariance<A>, BaseQueue, Pipe
  * @since 2.0.0
  * @category models
  */
-export interface Dequeue<out A> extends Effect.Effect<A>, Queue.DequeueVariance<A>, BaseQueue, Pipeable {
+export interface Dequeue<out A> extends Effect.Effect<A>, Queue.DequeueVariance<A>, BaseQueue {
   /**
    * Takes the oldest value in the queue. If the queue is empty, this will return
    * a computation that resumes when an item has been added to the queue.
@@ -541,7 +541,19 @@ export const shutdown: <A>(self: Dequeue<A> | Enqueue<A>) => Effect.Effect<void>
  * @category utils
  */
 export const offer: {
+  /**
+   * Places one value in the queue.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(value: A): (self: Enqueue<A>) => Effect.Effect<boolean>
+  /**
+   * Places one value in the queue.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(self: Enqueue<A>, value: A): Effect.Effect<boolean>
 } = internal.offer
 
@@ -552,7 +564,19 @@ export const offer: {
  * @category utils
  */
 export const unsafeOffer: {
+  /**
+   * Places one value in the queue.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(value: A): (self: Enqueue<A>) => boolean
+  /**
+   * Places one value in the queue.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(self: Enqueue<A>, value: A): boolean
 } = internal.unsafeOffer
 
@@ -575,7 +599,43 @@ export const unsafeOffer: {
  * @category utils
  */
 export const offerAll: {
+  /**
+   * For Bounded Queue: uses the `BackPressure` Strategy, places the values in
+   * the queue and always returns true. If the queue has reached capacity, then
+   * the fiber performing the `offerAll` will be suspended until there is room
+   * in the queue.
+   *
+   * For Unbounded Queue: Places all values in the queue and returns true.
+   *
+   * For Sliding Queue: uses `Sliding` Strategy If there is room in the queue,
+   * it places the values otherwise it removes the old elements and enqueues the
+   * new ones. Always returns true.
+   *
+   * For Dropping Queue: uses `Dropping` Strategy, It places the values in the
+   * queue but if there is no room it will not enqueue them and return false.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(iterable: Iterable<A>): (self: Enqueue<A>) => Effect.Effect<boolean>
+  /**
+   * For Bounded Queue: uses the `BackPressure` Strategy, places the values in
+   * the queue and always returns true. If the queue has reached capacity, then
+   * the fiber performing the `offerAll` will be suspended until there is room
+   * in the queue.
+   *
+   * For Unbounded Queue: Places all values in the queue and returns true.
+   *
+   * For Sliding Queue: uses `Sliding` Strategy If there is room in the queue,
+   * it places the values otherwise it removes the old elements and enqueues the
+   * new ones. Always returns true.
+   *
+   * For Dropping Queue: uses `Dropping` Strategy, It places the values in the
+   * queue but if there is no room it will not enqueue them and return false.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(self: Enqueue<A>, iterable: Iterable<A>): Effect.Effect<boolean>
 } = internal.offerAll
 
@@ -613,7 +673,19 @@ export const takeAll: <A>(self: Dequeue<A>) => Effect.Effect<Chunk.Chunk<A>> = i
  * @category utils
  */
 export const takeUpTo: {
+  /**
+   * Takes up to max number of values from the queue.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   (max: number): <A>(self: Dequeue<A>) => Effect.Effect<Chunk.Chunk<A>>
+  /**
+   * Takes up to max number of values from the queue.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(self: Dequeue<A>, max: number): Effect.Effect<Chunk.Chunk<A>>
 } = internal.takeUpTo
 
@@ -626,7 +698,23 @@ export const takeUpTo: {
  * @category utils
  */
 export const takeBetween: {
+  /**
+   * Takes a number of elements from the queue between the specified minimum and
+   * maximum. If there are fewer than the minimum number of elements available,
+   * suspends until at least the minimum number of elements have been collected.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   (min: number, max: number): <A>(self: Dequeue<A>) => Effect.Effect<Chunk.Chunk<A>>
+  /**
+   * Takes a number of elements from the queue between the specified minimum and
+   * maximum. If there are fewer than the minimum number of elements available,
+   * suspends until at least the minimum number of elements have been collected.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(self: Dequeue<A>, min: number, max: number): Effect.Effect<Chunk.Chunk<A>>
 } = internal.takeBetween
 
@@ -639,6 +727,22 @@ export const takeBetween: {
  * @category utils
  */
 export const takeN: {
+  /**
+   * Takes the specified number of elements from the queue. If there are fewer
+   * than the specified number of elements available, it suspends until they
+   * become available.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   (n: number): <A>(self: Dequeue<A>) => Effect.Effect<Chunk.Chunk<A>>
+  /**
+   * Takes the specified number of elements from the queue. If there are fewer
+   * than the specified number of elements available, it suspends until they
+   * become available.
+   *
+   * @since 2.0.0
+   * @category utils
+   */
   <A>(self: Dequeue<A>, n: number): Effect.Effect<Chunk.Chunk<A>>
 } = internal.takeN

package/src/RcMap.ts

@@ -77,6 +77,37 @@ export declare namespace RcMap {
  * })
  */
 export const make: {
+  /**
+   * An `RcMap` can contain multiple reference counted resources that can be indexed
+   * by a key. The resources are lazily acquired on the first call to `get` and
+   * released when the last reference is released.
+   *
+   * Complex keys can extend `Equal` and `Hash` to allow lookups by value.
+   *
+   * @since 3.5.0
+   * @category models
+   * @param capacity The maximum number of resources that can be held in the map.
+   * @param idleTimeToLive When the reference count reaches zero, the resource will be released after this duration.
+   * @example
+   * import { Effect, RcMap } from "effect"
+   *
+   * Effect.gen(function*() {
+   *   const map = yield* RcMap.make({
+   *     lookup: (key: string) =>
+   *       Effect.acquireRelease(
+   *         Effect.succeed(`acquired ${key}`),
+   *         () => Effect.log(`releasing ${key}`)
+   *       )
+   *   })
+   *
+   *   // Get "foo" from the map twice, which will only acquire it once.
+   *   // It will then be released once the scope closes.
+   *   yield* RcMap.get(map, "foo").pipe(
+   *     Effect.andThen(RcMap.get(map, "foo")),
+   *     Effect.scoped
+   *   )
+   * })
+   */
   <K, A, E, R>(
     options: {
       readonly lookup: (key: K) => Effect.Effect<A, E, R>
@@ -84,6 +115,37 @@ export const make: {
       readonly capacity?: undefined
     }
   ): Effect.Effect<RcMap<K, A, E>, never, Scope.Scope | R>
+  /**
+   * An `RcMap` can contain multiple reference counted resources that can be indexed
+   * by a key. The resources are lazily acquired on the first call to `get` and
+   * released when the last reference is released.
+   *
+   * Complex keys can extend `Equal` and `Hash` to allow lookups by value.
+   *
+   * @since 3.5.0
+   * @category models
+   * @param capacity The maximum number of resources that can be held in the map.
+   * @param idleTimeToLive When the reference count reaches zero, the resource will be released after this duration.
+   * @example
+   * import { Effect, RcMap } from "effect"
+   *
+   * Effect.gen(function*() {
+   *   const map = yield* RcMap.make({
+   *     lookup: (key: string) =>
+   *       Effect.acquireRelease(
+   *         Effect.succeed(`acquired ${key}`),
+   *         () => Effect.log(`releasing ${key}`)
+   *       )
+   *   })
+   *
+   *   // Get "foo" from the map twice, which will only acquire it once.
+   *   // It will then be released once the scope closes.
+   *   yield* RcMap.get(map, "foo").pipe(
+   *     Effect.andThen(RcMap.get(map, "foo")),
+   *     Effect.scoped
+   *   )
+   * })
+   */
   <K, A, E, R>(
     options: {
       readonly lookup: (key: K) => Effect.Effect<A, E, R>
@@ -98,7 +160,15 @@ export const make: {
  * @category combinators
  */
 export const get: {
+  /**
+   * @since 3.5.0
+   * @category combinators
+   */
   <K>(key: K): <A, E>(self: RcMap<K, A, E>) => Effect.Effect<A, E, Scope.Scope>
+  /**
+   * @since 3.5.0
+   * @category combinators
+   */
   <K, A, E>(self: RcMap<K, A, E>, key: K): Effect.Effect<A, E, Scope.Scope>
 } = internal.get
 

package/src/Readable.ts

@@ -57,7 +57,15 @@ export const make = <A, E, R>(get: Effect<A, E, R>): Readable<A, E, R> => {
  * @category combinators
  */
 export const map: {
+  /**
+   * @since 2.0.0
+   * @category combinators
+   */
   <A, B>(f: (a: NoInfer<A>) => B): <E, R>(fa: Readable<A, E, R>) => Readable<B, E, R>
+  /**
+   * @since 2.0.0
+   * @category combinators
+   */
   <A, E, R, B>(self: Readable<A, E, R>, f: (a: NoInfer<A>) => B): Readable<B, E, R>
 } = dual(
   2,
@@ -69,13 +77,16 @@ export const map: {
  * @category combinators
  */
 export const mapEffect: {
-  <A, B, E2, R2>(
-    f: (a: NoInfer<A>) => Effect<B, E2, R2>
-  ): <E, R>(fa: Readable<A, E, R>) => Readable<B, E | E2, R | R2>
-  <A, E, R, B, E2, R2>(
-    self: Readable<A, E, R>,
-    f: (a: NoInfer<A>) => Effect<B, E2, R2>
-  ): Readable<B, E | E2, R | R2>
+  /**
+   * @since 2.0.0
+   * @category combinators
+   */
+  <A, B, E2, R2>(f: (a: NoInfer<A>) => Effect<B, E2, R2>): <E, R>(fa: Readable<A, E, R>) => Readable<B, E | E2, R | R2>
+  /**
+   * @since 2.0.0
+   * @category combinators
+   */
+  <A, E, R, B, E2, R2>(self: Readable<A, E, R>, f: (a: NoInfer<A>) => Effect<B, E2, R2>): Readable<B, E | E2, R | R2>
 } = dual(2, <A, E, R, B, E2, R2>(
   self: Readable<A, E, R>,
   f: (a: NoInfer<A>) => Effect<B, E2, R2>