effect 3.10.19 → 3.11.1

package/dist/dts/Stream.d.ts

@@ -5690,30 +5690,40 @@ export declare const paginateChunkEffect: <S, A, E, R>(s: S, f: (s: S) => Effect
  */
 export declare const paginateEffect: <S, A, E, R>(s: S, f: (s: S) => Effect.Effect<readonly [A, Option.Option<S>], E, R>) => Stream<A, E, R>;
 /**
- * Partition a stream using a predicate. The first stream will contain all
- * element evaluated to true and the second one will contain all element
- * evaluated to false. 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 })
  * )
  *
  * const program = Effect.scoped(
  *   Effect.gen(function*() {
- *     const [evens, odds] = yield* partition
- *     console.log(yield* Stream.runCollect(evens))
+ *     const [odds, evens] = yield* partition
  *     console.log(yield* Stream.runCollect(odds))
+ *     console.log(yield* Stream.runCollect(evens))
  *   })
  * )
  *
  * // Effect.runPromise(program)
- * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
  * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
+ * // { _id: 'Chunk', values: [ 2, 4, 6, 8 ] }
  * ```
  *
  * @since 2.0.0
@@ -5721,30 +5731,40 @@ export declare const paginateEffect: <S, A, E, R>(s: S, f: (s: S) => Effect.Effe
  */
 export declare const partition: {
     /**
-     * Partition a stream using a predicate. The first stream will contain all
-     * element evaluated to true and the second one will contain all element
-     * evaluated to false. 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 })
      * )
      *
      * const program = Effect.scoped(
      *   Effect.gen(function*() {
-     *     const [evens, odds] = yield* partition
-     *     console.log(yield* Stream.runCollect(evens))
+     *     const [odds, evens] = yield* partition
      *     console.log(yield* Stream.runCollect(odds))
+     *     console.log(yield* Stream.runCollect(evens))
      *   })
      * )
      *
      * // Effect.runPromise(program)
-     * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
      * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
+     * // { _id: 'Chunk', values: [ 2, 4, 6, 8 ] }
      * ```
      *
      * @since 2.0.0
@@ -5754,30 +5774,40 @@ export declare const partition: {
         bufferSize?: number | undefined;
     } | undefined): <E, R>(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 true and the second one will contain all element
-     * evaluated to false. 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 })
      * )
      *
      * const program = Effect.scoped(
      *   Effect.gen(function*() {
-     *     const [evens, odds] = yield* partition
-     *     console.log(yield* Stream.runCollect(evens))
+     *     const [odds, evens] = yield* partition
      *     console.log(yield* Stream.runCollect(odds))
+     *     console.log(yield* Stream.runCollect(evens))
      *   })
      * )
      *
      * // Effect.runPromise(program)
-     * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
      * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
+     * // { _id: 'Chunk', values: [ 2, 4, 6, 8 ] }
      * ```
      *
      * @since 2.0.0
@@ -5787,30 +5817,40 @@ export declare const partition: {
         bufferSize?: number | undefined;
     } | undefined): <E, R>(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 true and the second one will contain all element
-     * evaluated to false. 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 })
      * )
      *
      * const program = Effect.scoped(
      *   Effect.gen(function*() {
-     *     const [evens, odds] = yield* partition
-     *     console.log(yield* Stream.runCollect(evens))
+     *     const [odds, evens] = yield* partition
      *     console.log(yield* Stream.runCollect(odds))
+     *     console.log(yield* Stream.runCollect(evens))
      *   })
      * )
      *
      * // Effect.runPromise(program)
-     * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
      * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
+     * // { _id: 'Chunk', values: [ 2, 4, 6, 8 ] }
      * ```
      *
      * @since 2.0.0
@@ -5820,30 +5860,40 @@ export declare const partition: {
         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 true and the second one will contain all element
-     * evaluated to false. 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 })
      * )
      *
      * const program = Effect.scoped(
      *   Effect.gen(function*() {
-     *     const [evens, odds] = yield* partition
-     *     console.log(yield* Stream.runCollect(evens))
+     *     const [odds, evens] = yield* partition
      *     console.log(yield* Stream.runCollect(odds))
+     *     console.log(yield* Stream.runCollect(evens))
      *   })
      * )
      *
      * // Effect.runPromise(program)
-     * // { _id: 'Chunk', values: [ 2, 4, 6, 8, 10 ] }
      * // { _id: 'Chunk', values: [ 1, 3, 5, 7, 9 ] }
+     * // { _id: 'Chunk', values: [ 2, 4, 6, 8 ] }
      * ```
      *
      * @since 2.0.0
@@ -5854,16 +5904,29 @@ export declare const partition: {
     } | undefined): Effect.Effect<[excluded: Stream<A, E, never>, satisfying: Stream<A, E, never>], E, R | Scope.Scope>;
 };
 /**
- * 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 }
  *   )
  * )
@@ -5877,8 +5940,8 @@ export declare 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
@@ -5886,16 +5949,29 @@ export declare const partition: {
  */
 export declare 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 }
      *   )
      * )
@@ -5909,8 +5985,8 @@ export declare 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
@@ -5920,16 +5996,29 @@ export declare const partitionEither: {
         readonly bufferSize?: number | undefined;
     } | undefined): <E, R>(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 }
      *   )
      * )
@@ -5943,8 +6032,8 @@ export declare 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
@@ -6826,21 +6915,21 @@ export declare const run: {
  * @since 2.0.0
  * @category destructors
  */
-export declare const runCollect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Chunk.Chunk<A>, E, Exclude<R, Scope.Scope>>;
+export declare const runCollect: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<Chunk.Chunk<A>, E, R>;
 /**
  * Runs the stream and emits the number of elements processed
  *
  * @since 2.0.0
  * @category destructors
  */
-export declare const runCount: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<number, E, Exclude<R, Scope.Scope>>;
+export declare const runCount: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<number, E, R>;
 /**
  * Runs the stream only for its effects. The emitted elements are discarded.
  *
  * @since 2.0.0
  * @category destructors
  */
-export declare const runDrain: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E, Exclude<R, Scope.Scope>>;
+export declare const runDrain: <A, E, R>(self: Stream<A, E, R>) => Effect.Effect<void, E, R>;
 /**
  * Executes a pure fold over the stream of values - reduces all elements in
  * the stream to a value of type `S`.
@@ -6856,7 +6945,7 @@ export declare const runFold: {
      * @since 2.0.0
      * @category destructors
      */
-    <S, A>(s: S, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, Exclude<R, Scope.Scope>>;
+    <S, A>(s: S, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, R>;
     /**
      * Executes a pure fold over the stream of values - reduces all elements in
      * the stream to a value of type `S`.
@@ -6864,7 +6953,7 @@ export declare const runFold: {
      * @since 2.0.0
      * @category destructors
      */
-    <A, E, R, S>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Effect.Effect<S, E, Exclude<R, Scope.Scope>>;
+    <A, E, R, S>(self: Stream<A, E, R>, s: S, f: (s: S, a: A) => S): Effect.Effect<S, E, R>;
 };
 /**
  * Executes an effectful fold over the stream of values.
@@ -6953,7 +7042,7 @@ export declare const runFoldWhile: {
      * @since 2.0.0
      * @category destructors
      */
-    <S, A>(s: S, cont: Predicate<S>, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, Exclude<R, Scope.Scope>>;
+    <S, A>(s: S, cont: Predicate<S>, f: (s: S, a: A) => S): <E, R>(self: Stream<A, E, R>) => Effect.Effect<S, E, R>;
     /**
      * Reduces the elements in the stream to a value of type `S`. Stops the fold
      * early when the condition is not fulfilled. Example:
@@ -6961,7 +7050,7 @@ export declare const runFoldWhile: {
      * @since 2.0.0
      * @category destructors
      */
-    <A, E, R, S>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S): Effect.Effect<S, E, Exclude<R, Scope.Scope>>;
+    <A, E, R, S>(self: Stream<A, E, R>, s: S, cont: Predicate<S>, f: (s: S, a: A) => S): Effect.Effect<S, E, R>;
 };
 /**
  * Executes an effectful fold over the stream of values. Stops the fold early
@@ -7583,6 +7672,15 @@ export declare const scheduleWith: {
  * @category constructors
  */
 export declare const scoped: <A, E, R>(effect: Effect.Effect<A, E, R>) => Stream<A, E, Exclude<R, Scope.Scope>>;
+/**
+ * Use a function that receives a scope and returns an effect to emit an output
+ * element. The output element will be the result of the returned effect, if
+ * successful.
+ *
+ * @since 3.11.0
+ * @category constructors
+ */
+export declare const scopedWith: <A, E, R>(f: (scope: Scope.Scope) => Effect.Effect<A, E, R>) => Stream<A, E, R>;
 /**
  * Emits a sliding window of `n` elements.
  *
@@ -9061,6 +9159,15 @@ export declare const unwrap: <A, E2, R2, E, R>(effect: Effect.Effect<Stream<A, E
  * @category constructors
  */
 export declare const unwrapScoped: <A, E2, R2, E, R>(effect: Effect.Effect<Stream<A, E2, R2>, E, R>) => Stream<A, E | E2, R2 | Exclude<R, Scope.Scope>>;
+/**
+ * Creates a stream produced from a function which receives a `Scope` and
+ * returns an `Effect`. The resulting stream will emit a single element, which
+ * will be the result of the returned effect, if successful.
+ *
+ * @since 3.11.0
+ * @category constructors
+ */
+export declare const unwrapScopedWith: <A, E2, R2, E, R>(f: (scope: Scope.Scope) => Effect.Effect<Stream<A, E2, R2>, E, R>) => Stream<A, E | E2, R | R2>;
 /**
  * Updates the specified service within the context of the `Stream`.
  *