effect 3.11.0 → 3.11.2

package/src/Stream.ts

@@ -6161,16 +6161,26 @@ export const paginateEffect: <S, A, E, R>(
 ) => Stream<A, E, R> = internal.paginateEffect
 
 /**
- * Partition a stream using a predicate. The first stream will contain all
- * element evaluated to false and the second one will contain all element
- * evaluated to true. The faster stream may advance by up to buffer elements
- * further than the slower one.
+ * Splits a stream into two substreams based on a predicate.
+ *
+ * **Details**
+ *
+ * The `Stream.partition` function splits a stream into two parts: one for
+ * elements that satisfy the predicate (evaluated to `true`) and another for
+ * those that do not (evaluated to `false`).
+ *
+ * The faster stream may advance up to `bufferSize` elements ahead of the slower
+ * one.
+ *
+ * @see {@link partitionEither} for partitioning a stream based on effectful
+ * conditions.
  *
  * @example
  * ```ts
+ * // Title: Partitioning a Stream into Even and Odd Numbers
  * import { Effect, Stream } from "effect"
  *
- * const partition = Stream.range(1, 10).pipe(
+ * const partition = Stream.range(1, 9).pipe(
  *   Stream.partition((n) => n % 2 === 0, { bufferSize: 5 })
  * )
  *
@@ -6184,7 +6194,7 @@ export const paginateEffect: <S, A, E, R>(
  *
  * // Effect.runPromise(program)
  * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
- * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
+ * // { _id: 'Chunk', values: [ 2, 4, 6, 8 ] }
  * ```
  *
  * @since 2.0.0
@@ -6192,16 +6202,26 @@ export const paginateEffect: <S, A, E, R>(
  */
 export const partition: {
   /**
-   * Partition a stream using a predicate. The first stream will contain all
-   * element evaluated to false and the second one will contain all element
-   * evaluated to true. The faster stream may advance by up to buffer elements
-   * further than the slower one.
+   * Splits a stream into two substreams based on a predicate.
+   *
+   * **Details**
+   *
+   * The `Stream.partition` function splits a stream into two parts: one for
+   * elements that satisfy the predicate (evaluated to `true`) and another for
+   * those that do not (evaluated to `false`).
+   *
+   * The faster stream may advance up to `bufferSize` elements ahead of the slower
+   * one.
+   *
+   * @see {@link partitionEither} for partitioning a stream based on effectful
+   * conditions.
    *
    * @example
    * ```ts
+   * // Title: Partitioning a Stream into Even and Odd Numbers
    * import { Effect, Stream } from "effect"
    *
-   * const partition = Stream.range(1, 10).pipe(
+   * const partition = Stream.range(1, 9).pipe(
    *   Stream.partition((n) => n % 2 === 0, { bufferSize: 5 })
    * )
    *
@@ -6215,7 +6235,7 @@ export const partition: {
    *
    * // Effect.runPromise(program)
    * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
-   * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
+   * // { _id: 'Chunk', values: [ 2, 4, 6, 8 ] }
    * ```
    *
    * @since 2.0.0
@@ -6228,16 +6248,26 @@ export const partition: {
     self: Stream<C, E, R>
   ) => Effect.Effect<[excluded: Stream<Exclude<C, B>, E, never>, satisfying: Stream<B, E, never>], E, R | Scope.Scope>
   /**
-   * Partition a stream using a predicate. The first stream will contain all
-   * element evaluated to false and the second one will contain all element
-   * evaluated to true. The faster stream may advance by up to buffer elements
-   * further than the slower one.
+   * Splits a stream into two substreams based on a predicate.
+   *
+   * **Details**
+   *
+   * The `Stream.partition` function splits a stream into two parts: one for
+   * elements that satisfy the predicate (evaluated to `true`) and another for
+   * those that do not (evaluated to `false`).
+   *
+   * The faster stream may advance up to `bufferSize` elements ahead of the slower
+   * one.
+   *
+   * @see {@link partitionEither} for partitioning a stream based on effectful
+   * conditions.
    *
    * @example
    * ```ts
+   * // Title: Partitioning a Stream into Even and Odd Numbers
    * import { Effect, Stream } from "effect"
    *
-   * const partition = Stream.range(1, 10).pipe(
+   * const partition = Stream.range(1, 9).pipe(
    *   Stream.partition((n) => n % 2 === 0, { bufferSize: 5 })
    * )
    *
@@ -6251,7 +6281,7 @@ export const partition: {
    *
    * // Effect.runPromise(program)
    * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
-   * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
+   * // { _id: 'Chunk', values: [ 2, 4, 6, 8 ] }
    * ```
    *
    * @since 2.0.0
@@ -6264,16 +6294,26 @@ export const partition: {
     self: Stream<A, E, R>
   ) => Effect.Effect<[excluded: Stream<A, E, never>, satisfying: Stream<A, E, never>], E, Scope.Scope | R>
   /**
-   * Partition a stream using a predicate. The first stream will contain all
-   * element evaluated to false and the second one will contain all element
-   * evaluated to true. The faster stream may advance by up to buffer elements
-   * further than the slower one.
+   * Splits a stream into two substreams based on a predicate.
+   *
+   * **Details**
+   *
+   * The `Stream.partition` function splits a stream into two parts: one for
+   * elements that satisfy the predicate (evaluated to `true`) and another for
+   * those that do not (evaluated to `false`).
+   *
+   * The faster stream may advance up to `bufferSize` elements ahead of the slower
+   * one.
+   *
+   * @see {@link partitionEither} for partitioning a stream based on effectful
+   * conditions.
    *
    * @example
    * ```ts
+   * // Title: Partitioning a Stream into Even and Odd Numbers
    * import { Effect, Stream } from "effect"
    *
-   * const partition = Stream.range(1, 10).pipe(
+   * const partition = Stream.range(1, 9).pipe(
    *   Stream.partition((n) => n % 2 === 0, { bufferSize: 5 })
    * )
    *
@@ -6287,7 +6327,7 @@ export const partition: {
    *
    * // Effect.runPromise(program)
    * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
-   * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
+   * // { _id: 'Chunk', values: [ 2, 4, 6, 8 ] }
    * ```
    *
    * @since 2.0.0
@@ -6299,16 +6339,26 @@ export const partition: {
     options?: { bufferSize?: number | undefined } | undefined
   ): Effect.Effect<[excluded: Stream<Exclude<C, B>, E, never>, satisfying: Stream<B, E, never>], E, R | Scope.Scope>
   /**
-   * Partition a stream using a predicate. The first stream will contain all
-   * element evaluated to false and the second one will contain all element
-   * evaluated to true. The faster stream may advance by up to buffer elements
-   * further than the slower one.
+   * Splits a stream into two substreams based on a predicate.
+   *
+   * **Details**
+   *
+   * The `Stream.partition` function splits a stream into two parts: one for
+   * elements that satisfy the predicate (evaluated to `true`) and another for
+   * those that do not (evaluated to `false`).
+   *
+   * The faster stream may advance up to `bufferSize` elements ahead of the slower
+   * one.
+   *
+   * @see {@link partitionEither} for partitioning a stream based on effectful
+   * conditions.
    *
    * @example
    * ```ts
+   * // Title: Partitioning a Stream into Even and Odd Numbers
    * import { Effect, Stream } from "effect"
    *
-   * const partition = Stream.range(1, 10).pipe(
+   * const partition = Stream.range(1, 9).pipe(
    *   Stream.partition((n) => n % 2 === 0, { bufferSize: 5 })
    * )
    *
@@ -6322,7 +6372,7 @@ export const partition: {
    *
    * // Effect.runPromise(program)
    * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
-   * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
+   * // { _id: 'Chunk', values: [ 2, 4, 6, 8 ] }
    * ```
    *
    * @since 2.0.0
@@ -6336,16 +6386,29 @@ export const partition: {
 } = internal.partition
 
 /**
- * Split a stream by an effectful predicate. The faster stream may advance by
- * up to buffer elements further than the slower one.
+ * Splits a stream into two substreams based on an effectful condition.
+ *
+ * **Details**
+ *
+ * The `Stream.partitionEither` function is used to divide a stream into two
+ * parts: one for elements that satisfy a condition producing `Either.left`
+ * values, and another for those that produce `Either.right` values. This
+ * function applies an effectful predicate to each element in the stream to
+ * determine which substream it belongs to.
+ *
+ * The faster stream may advance up to `bufferSize` elements ahead of the slower
+ * one.
+ *
+ * @see {@link partition} for partitioning a stream based on simple conditions.
  *
  * @example
  * ```ts
+ * // Title: Partitioning a Stream with an Effectful Predicate
  * import { Effect, Either, Stream } from "effect"
  *
  * const partition = Stream.range(1, 9).pipe(
  *   Stream.partitionEither(
- *     (n) => Effect.succeed(n % 2 === 0 ? Either.left(n) : Either.right(n)),
+ *     (n) => Effect.succeed(n % 2 === 0 ? Either.right(n) : Either.left(n)),
  *     { bufferSize: 5 }
  *   )
  * )
@@ -6359,8 +6422,8 @@ export const partition: {
  * )
  *
  * // Effect.runPromise(program)
- * // { _id: 'Chunk', values: [ 2, 4, 6, 8 ] }
  * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
+ * // { _id: 'Chunk', values: [ 2, 4, 6, 8 ] }
  * ```
  *
  * @since 2.0.0
@@ -6368,16 +6431,29 @@ export const partition: {
  */
 export const partitionEither: {
   /**
-   * Split a stream by an effectful predicate. The faster stream may advance by
-   * up to buffer elements further than the slower one.
+   * Splits a stream into two substreams based on an effectful condition.
+   *
+   * **Details**
+   *
+   * The `Stream.partitionEither` function is used to divide a stream into two
+   * parts: one for elements that satisfy a condition producing `Either.left`
+   * values, and another for those that produce `Either.right` values. This
+   * function applies an effectful predicate to each element in the stream to
+   * determine which substream it belongs to.
+   *
+   * The faster stream may advance up to `bufferSize` elements ahead of the slower
+   * one.
+   *
+   * @see {@link partition} for partitioning a stream based on simple conditions.
    *
    * @example
    * ```ts
+   * // Title: Partitioning a Stream with an Effectful Predicate
    * import { Effect, Either, Stream } from "effect"
    *
    * const partition = Stream.range(1, 9).pipe(
    *   Stream.partitionEither(
-   *     (n) => Effect.succeed(n % 2 === 0 ? Either.left(n) : Either.right(n)),
+   *     (n) => Effect.succeed(n % 2 === 0 ? Either.right(n) : Either.left(n)),
    *     { bufferSize: 5 }
    *   )
    * )
@@ -6391,8 +6467,8 @@ export const partitionEither: {
    * )
    *
    * // Effect.runPromise(program)
-   * // { _id: 'Chunk', values: [ 2, 4, 6, 8 ] }
    * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
+   * // { _id: 'Chunk', values: [ 2, 4, 6, 8 ] }
    * ```
    *
    * @since 2.0.0
@@ -6405,16 +6481,29 @@ export const partitionEither: {
     self: Stream<A, E, R>
   ) => Effect.Effect<[left: Stream<A2, E2 | E, never>, right: Stream<A3, E2 | E, never>], E2 | E, Scope.Scope | R2 | R>
   /**
-   * Split a stream by an effectful predicate. The faster stream may advance by
-   * up to buffer elements further than the slower one.
+   * Splits a stream into two substreams based on an effectful condition.
+   *
+   * **Details**
+   *
+   * The `Stream.partitionEither` function is used to divide a stream into two
+   * parts: one for elements that satisfy a condition producing `Either.left`
+   * values, and another for those that produce `Either.right` values. This
+   * function applies an effectful predicate to each element in the stream to
+   * determine which substream it belongs to.
+   *
+   * The faster stream may advance up to `bufferSize` elements ahead of the slower
+   * one.
+   *
+   * @see {@link partition} for partitioning a stream based on simple conditions.
    *
    * @example
    * ```ts
+   * // Title: Partitioning a Stream with an Effectful Predicate
    * import { Effect, Either, Stream } from "effect"
    *
    * const partition = Stream.range(1, 9).pipe(
    *   Stream.partitionEither(
-   *     (n) => Effect.succeed(n % 2 === 0 ? Either.left(n) : Either.right(n)),
+   *     (n) => Effect.succeed(n % 2 === 0 ? Either.right(n) : Either.left(n)),
    *     { bufferSize: 5 }
    *   )
    * )
@@ -6428,8 +6517,8 @@ export const partitionEither: {
    * )
    *
    * // Effect.runPromise(program)
-   * // { _id: 'Chunk', values: [ 2, 4, 6, 8 ] }
    * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
+   * // { _id: 'Chunk', values: [ 2, 4, 6, 8 ] }
    * ```
    *
    * @since 2.0.0

package/src/internal/pool.ts

@@ -226,7 +226,9 @@ class PoolImpl<A, E> extends Effectable.Class<A, E, Scope> implements Pool<A, E>
                 circular.forkIn(core.interruptible(this.resize), this.scope)
               ),
               function loop(): Effect<PoolItem<A, E>> {
-                if (self.available.size > 0) {
+                if (self.isShuttingDown) {
+                  return core.interrupt
+                } else if (self.available.size > 0) {
                   return core.succeed(Iterable.unsafeHead(self.available))
                 }
                 self.availableLatch.unsafeClose()
@@ -328,6 +330,7 @@ class PoolImpl<A, E> extends Effectable.Class<A, E, Scope> implements Pool<A, E>
         return item.finalizer
       }).pipe(
         core.zipRight(this.semaphore.releaseAll),
+        core.zipRight(this.availableLatch.open),
         core.zipRight(semaphore.take(size))
       )
     })

package/src/internal/version.ts

@@ -1,4 +1,4 @@
-let moduleVersion = "3.11.0"
+let moduleVersion = "3.11.2"
 
 export const getCurrentVersion = () => moduleVersion