effect 3.11.0 → 3.11.2

package/dist/dts/Stream.d.ts

@@ -5690,16 +5690,26 @@ 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 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 })
  * )
  *
@@ -5713,7 +5723,7 @@ export declare const paginateEffect: <S, A, E, R>(s: S, f: (s: S) => Effect.Effe
  *
  * // 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
@@ -5721,16 +5731,26 @@ 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 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 })
      * )
      *
@@ -5744,7 +5764,7 @@ export declare 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
@@ -5754,16 +5774,26 @@ 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 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 })
      * )
      *
@@ -5777,7 +5807,7 @@ export declare 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
@@ -5787,16 +5817,26 @@ 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 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 })
      * )
      *
@@ -5810,7 +5850,7 @@ export declare 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
@@ -5820,16 +5860,26 @@ 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 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 })
      * )
      *
@@ -5843,7 +5893,7 @@ export declare 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
@@ -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