@fncts/io 0.0.20 → 0.0.22

package/Stream/api.d.ts

@@ -10,9 +10,8 @@ import { Fiber } from "@fncts/io/Fiber/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 import { Scope } from "@fncts/io/Scope/definition";
-import { Hub } from "@fncts/io/Hub/definition";
 import { Future } from "@fncts/io/Future";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 import { Environment } from "@fncts/base/data/Environment/definition";
 import { Duration } from "@fncts/base/data/Duration/definition";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
@@ -21,8 +20,9 @@ import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Layer } from "@fncts/io/Layer";
 import type { PHub } from "../Hub.js";
 import type { Canceler } from "../IO.js";
-import type { PQueue } from "../Queue.js";
+import type { PDequeue, PEnqueue, PQueue } from "../Queue.js";
 import { MergeDecision } from "../Channel/internal/MergeDecision.js";
+import { Hub } from "../Hub.js";
 import { Queue } from "../Queue.js";
 import { Stream } from "./definition.js";
 import { Take } from "./internal/Take.js";
@@ -43,16 +43,16 @@ export declare function absolve<R, E, E2, A>(self: Stream<R, E, Either<E2, A>>,
  *
  * Any sink can be used here, but see `Sink.foldWeightedM` and `Sink.foldUntilM` for
  * sinks that cover the common usecases.
- * @tsplus fluent fncts.io.Stream aggregateAsync
+ * @tsplus pipeable fncts.io.Stream aggregateAsync
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function aggregateAsync_<R, E, A extends A1, R1, E1, A1, B>(stream: Stream<R, E, A>, sink: Sink<R1, E1, A1, A1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
+export declare function aggregateAsync<R1, E1, A1, B>(sink: Sink<R1, E1, A1, A1, B>, __tsplusTrace?: string): <R, E, A extends A1>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
 /**
  * Like `aggregateAsyncWithinEither`, but only returns the `Right` results.
- * @tsplus fluent fncts.io.Stream aggregateAsyncWithin
+ * @tsplus pipeable fncts.io.Stream aggregateAsyncWithin
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function aggregateAsyncWithin_<R, E, A extends A1, R1, E1, A1, B, R2, C>(stream: Stream<R, E, A>, sink: Sink<R1, E1, A1, A1, B>, schedule: Schedule<R2, Maybe<B>, C>, __tsplusTrace?: string): Stream<R | R1 | R2, E | E1, B>;
+export declare function aggregateAsyncWithin<R1, E1, A1, B, R2, C>(sink: Sink<R1, E1, A1, A1, B>, schedule: Schedule<R2, Maybe<B>, C>, __tsplusTrace?: string): <R, E, A extends A1>(stream: Stream<R, E, A>) => Stream<R1 | R2 | R, E1 | E, B>;
 /**
  * Aggregates elements using the provided sink until it completes, or until the
  * delay signalled by the schedule has passed.
@@ -64,32 +64,32 @@ export declare function aggregateAsyncWithin_<R, E, A extends A1, R1, E1, A1, B,
  *
  * Aggregated elements will be fed into the schedule to determine the delays between
  * pulls.
- * @tsplus fluent fncts.io.Stream aggregateAsyncWithinEither
+ * @tsplus pipeable fncts.io.Stream aggregateAsyncWithinEither
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function aggregateAsyncWithinEither_<R, E, A extends A1, R1, E1, A1, B, R2, C>(stream: Stream<R, E, A>, sink: Sink<R1, E1, A1, A1, B>, schedule: Schedule<R2, Maybe<B>, C>, __tsplusTrace?: string): Stream<R | R1 | R2, E | E1, Either<C, B>>;
+export declare function aggregateAsyncWithinEither<R1, E1, A1, B, R2, C>(sink: Sink<R1, E1, A1, A1, B>, schedule: Schedule<R2, Maybe<B>, C>, __tsplusTrace?: string): <R, E, A extends A1>(stream: Stream<R, E, A>) => Stream<R1 | R2 | R, E1 | E, import("@fncts/base/data/Either.js").Either<C, B>>;
 /**
  * Composes this stream with the specified stream to create a cartesian product of elements,
  * but keeps only elements from this stream.
  * The `that` stream would be run multiple times, for every element in the `this` stream.
- * @tsplus fluent fncts.io.Stream apFirst
+ * @tsplus pipeable fncts.io.Stream zipLeft
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function apFirst_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
+export declare function zipLeft<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
 /**
  * Composes this stream with the specified stream to create a cartesian product of elements,
  * but keeps only elements from the other stream.
  * The `that` stream would be run multiple times, for every element in the `this` stream.
- * @tsplus fluent fncts.io.Stream apSecond
+ * @tsplus pipeable fncts.io.Stream zipRight
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function apSecond_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>, __tsplusTrace?: string): Stream<R | R1, E | E1, A1>;
+export declare function zipRight<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A1>;
 /**
  * Maps the success values of this stream to the specified constant value.
- * @tsplus fluent fncts.io.Stream as
+ * @tsplus pipeable fncts.io.Stream as
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function as_<R, E, A, B>(stream: Stream<R, E, A>, b: Lazy<B>, __tsplusTrace?: string): Stream<R, E, B>;
+export declare function as<B>(b: Lazy<B>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R, E, B>;
 /**
  * @tsplus static fncts.io.StreamOps asyncInterrupt
  * @tsplus location "@fncts/io/Stream/api"
@@ -117,68 +117,70 @@ export declare function asyncIO<R, E, A, R1 = R, E1 = E>(register: (resolve: (ne
 /**
  * Returns a stream whose failure and success channels have been mapped by
  * the specified pair of functions, `f` and `g`.
+ * @tsplus pipeable fncts.io.Stream bimap
+ * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function bimap_<R, E, E1, A, A1>(stream: Stream<R, E, A>, f: (e: E) => E1, g: (a: A) => A1, __tsplusTrace?: string): Stream<R, E1, A1>;
+export declare function bimap<E, E1, A, A1>(f: (e: E) => E1, g: (a: A) => A1, __tsplusTrace?: string): <R>(stream: Stream<R, E, A>) => Stream<R, E1, A1>;
 /**
  * Creates a stream from a single value that will get cleaned up after the
  * stream is consumed
  * @tsplus static fncts.io.StreamOps acquireRelease
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function acquireRelease_<R, E, A, R1>(acquire: IO<R, E, A>, release: (a: A) => IO<R1, never, unknown>, __tsplusTrace?: string): Stream<R | R1, E, A>;
+export declare function acquireRelease<R, E, A, R1>(acquire: IO<R, E, A>, release: (a: A) => IO<R1, never, unknown>, __tsplusTrace?: string): Stream<R | R1, E, A>;
 /**
  * Creates a stream from a single value that will get cleaned up after the
  * stream is consumed
  * @tsplus static fncts.io.StreamOps acquireReleaseExit
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function acquireReleaseExit_<R, E, A, R1>(acquire: IO<R, E, A>, release: (a: A, exit: Exit<any, any>) => IO<R1, never, unknown>, __tsplusTrace?: string): Stream<R | R1, E, A>;
+export declare function acquireReleaseExit<R, E, A, R1>(acquire: IO<R, E, A>, release: (a: A, exit: Exit<any, any>) => IO<R1, never, unknown>, __tsplusTrace?: string): Stream<R | R1, E, A>;
 /**
  * Fan out the stream, producing a list of streams that have the same elements as this stream.
  * The driver stream will only ever advance of the `maximumLag` chunks before the
  * slowest downstream stream.
- * @tsplus fluent fncts.io.Stream broadcast
+ * @tsplus pipeable fncts.io.Stream broadcast
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function broadcast_<R, E, A>(stream: Stream<R, E, A>, n: number, maximumLag: number, __tsplusTrace?: string): IO<R | Scope, never, Conc<Stream<unknown, E, A>>>;
+export declare function broadcast(n: number, maximumLag: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("@fncts/base/collection/immutable/Conc.js").Conc<Stream<unknown, E, A>>>;
 /**
  * Fan out the stream, producing a dynamic number of streams that have the same elements as this stream.
  * The driver stream will only ever advance of the `maximumLag` chunks before the
  * slowest downstream stream.
- * @tsplus fluent fncts.io.Stream broadcastDynamic
+ * @tsplus pipeable fncts.io.Stream broadcastDynamic
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function broadcastDynamic_<R, E, A>(stream: Stream<R, E, A>, maximumLag: number, __tsplusTrace?: string): IO<R | Scope, never, Stream<unknown, E, A>>;
+export declare function broadcastDynamic(maximumLag: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Stream<unknown, E, A>>;
 /**
  * Converts the stream to a managed list of queues. Every value will be replicated to every queue with the
  * slowest queue being allowed to buffer `maximumLag` chunks before the driver is backpressured.
  *
  * Queues can unsubscribe from upstream by shutting down.
- * @tsplus fluent fncts.io.Stream broadcastedQueues
+ * @tsplus pipeable fncts.io.Stream broadcastedQueues
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function broadcastedQueues_<R, E, A>(stream: Stream<R, E, A>, n: number, maximumLag: number, __tsplusTrace?: string): IO<R | Scope, never, Conc<Hub.Dequeue<unknown, never, Take<E, A>>>>;
+export declare function broadcastedQueues(n: number, maximumLag: number, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("@fncts/base/collection/immutable/Conc.js").Conc<Queue.Dequeue<Take<E, A>>>>;
 /**
  * Converts the stream to a managed dynamic amount of queues. Every chunk will be replicated to every queue with the
  * slowest queue being allowed to buffer `maximumLag` chunks before the driver is backpressured.
  *
  * Queues can unsubscribe from upstream by shutting down.
- * @tsplus fluent fncts.io.Stream broadcastedQueuesDynamic
+ * @tsplus pipeable fncts.io.Stream broadcastedQueuesDynamic
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function broadcastedQueuesDynamic_<R, E, A>(stream: Stream<R, E, A>, maximumLag: number, __tsplusTrace?: string): IO<R | Scope, never, IO<Scope, never, Hub.Dequeue<never, never, Take<E, A>>>>;
+export declare function broadcastedQueuesDynamic(maximumLag: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../IO.js").IO<import("../Scope.js").Scope, never, Queue.Dequeue<Take<E, A>>>>;
 /**
  * Allows a faster producer to progress independently of a slower consumer by buffering
  * up to `capacity` elements in a queue.
- * @tsplus fluent fncts.io.Stream buffer
+ * @tsplus pipeable fncts.io.Stream buffer
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function buffer_<R, E, A>(stream: Stream<R, E, A>, capacity: number, __tsplusTrace?: string): Stream<R, E, A>;
+export declare function buffer(capacity: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R, E, A>;
 /**
- * @tsplus fluent fncts.io.Stream bufferChunks
+ * @tsplus pipeable fncts.io.Stream bufferChunks
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function bufferChunks_<R, E, A>(stream: Stream<R, E, A>, capacity: number, __tsplusTrace?: string): Stream<R, E, A>;
+export declare function bufferChunks(capacity: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R, E, A>;
 /**
  * Allows a faster producer to progress independently of a slower consumer by buffering
  * elements into an unbounded queue.
@@ -189,40 +191,40 @@ export declare function bufferUnbounded<R, E, A>(stream: Stream<R, E, A>, __tspl
 /**
  * Switches over to the stream produced by the provided function in case this one
  * fails with a typed error.
- * @tsplus fluent fncts.io.Stream catchAll
+ * @tsplus pipeable fncts.io.Stream catchAll
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function catchAll_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, f: (e: E) => Stream<R1, E1, A1>, __tsplusTrace?: string): Stream<R | R1, E1, A | A1>;
+export declare function catchAll<R1, E, E1, A1>(f: (e: E) => Stream<R1, E1, A1>, __tsplusTrace?: string): <R, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1, A1 | A>;
 /**
  * Switches over to the stream produced by the provided function in case this one
  * fails. Allows recovery from all causes of failure, including interruption if the
  * stream is uninterruptible.
- * @tsplus fluent fncts.io.Stream catchAllCause
+ * @tsplus pipeable fncts.io.Stream catchAllCause
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function catchAllCause_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, f: (cause: Cause<E>) => Stream<R1, E1, A1>, __tsplusTrace?: string): Stream<R | R1, E1, A | A1>;
+export declare function catchAllCause<R1, E, E1, A1>(f: (cause: Cause<E>) => Stream<R1, E1, A1>, __tsplusTrace?: string): <R, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1, A1 | A>;
 /**
  * Switches over to the stream produced by the provided function in case this one
  * fails with some typed error.
- * @tsplus fluent fncts.io.Stream catchJust
+ * @tsplus pipeable fncts.io.Stream catchJust
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function catchJust_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, pf: (e: E) => Maybe<Stream<R1, E1, A1>>, __tsplusTrace?: string): Stream<R | R1, E | E1, A | A1>;
+export declare function catchJust<R1, E, E1, A1>(pf: (e: E) => Maybe<Stream<R1, E1, A1>>, __tsplusTrace?: string): <R, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E | E1, A1 | A>;
 /**
  * Switches over to the stream produced by the provided function in case this one
  * fails with some errors. Allows recovery from all causes of failure, including interruption if the
  * stream is uninterruptible.
- * @tsplus fluent fncts.io.Stream catchJustCause
+ * @tsplus pipeable fncts.io.Stream catchJustCause
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function catchJustCause_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, pf: (e: Cause<E>) => Maybe<Stream<R1, E1, A1>>, __tsplusTrace?: string): Stream<R | R1, E | E1, A | A1>;
+export declare function catchJustCause<R1, E, E1, A1>(pf: (e: Cause<E>) => Maybe<Stream<R1, E1, A1>>, __tsplusTrace?: string): <R, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E | E1, A1 | A>;
 /**
  * Returns a stream made of the concatenation in strict order of all the streams
  * produced by passing each element of this stream to `f`
- * @tsplus fluent fncts.io.Stream flatMap
+ * @tsplus pipeable fncts.io.Stream flatMap
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function flatMap_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => Stream<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
+export declare function flatMap<A, R1, E1, B>(f: (a: A) => Stream<R1, E1, B>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
 /**
  * Exposes the underlying chunks of the stream as a stream of chunks of elements
  * @tsplus getter fncts.io.Stream chunks
@@ -232,28 +234,28 @@ export declare function chunks<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?:
 /**
  * Performs the specified stream transformation with the chunk structure of
  * the stream exposed.
- * @tsplus fluent fncts.io.Stream chunksWith
+ * @tsplus pipeable fncts.io.Stream chunksWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function chunksWith<R, E, A, R1, E1, B>(self: Stream<R, E, A>, f: (_: Stream<R, E, Conc<A>>) => Stream<R1, E1, Conc<B>>, __tsplusTrace?: string): Stream<R1, E1, B>;
+export declare function chunksWith<R, E, A, R1, E1, B>(f: (_: Stream<R, E, Conc<A>>) => Stream<R1, E1, Conc<B>>, __tsplusTrace?: string): (self: Stream<R, E, A>) => Stream<R1, E1, B>;
 /**
  * Returns a new stream that only emits elements that are not equal to the
  * previous element emitted, using the specified function to determine
  * whether two elements are equal.
- * @tsplus fluent fncts.io.Stream changesWith
+ * @tsplus pipeable fncts.io.Stream changesWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function changesWith_<R, E, A>(stream: Stream<R, E, A>, f: (x: A, y: A) => boolean, __tsplusTrace?: string): Stream<R, E, A>;
+export declare function changesWith<A>(f: (x: A, y: A) => boolean, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, A>;
 /**
  * Transforms all elements of the stream for as long as the specified partial function is defined.
- * @tsplus fluent fncts.io.Stream collectWhile
+ * @tsplus pipeable fncts.io.Stream collectWhile
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function collectWhile_<R, E, A, A1>(stream: Stream<R, E, A>, pf: (a: A) => Maybe<A1>, __tsplusTrace?: string): Stream<R, E, A1>;
+export declare function collectWhile<A, A1>(pf: (a: A) => Maybe<A1>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, A1>;
 /**
  * Effectfully transforms all elements of the stream for as long as the specified partial function is defined.
  */
-export declare function collectWhileIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, pf: (a: A) => Maybe<IO<R1, E1, B>>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
+export declare function collectWhileIO<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, pf: (a: A) => Maybe<IO<R1, E1, B>>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
 /**
  * Combines the elements from this stream and the specified stream by repeatedly applying the
  * function `f` to extract an element using both sides and conceptually "offer"
@@ -261,67 +263,67 @@ export declare function collectWhileIO_<R, E, A, R1, E1, B>(stream: Stream<R, E,
  * the combining process, with the initial state being specified by `s`.
  *
  * Where possible, prefer `Stream#combineChunks` for a more efficient implementation.
- * @tsplus fluent fncts.io.Stream combine
+ * @tsplus pipeable fncts.io.Stream combine
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function combine_<R, E, A, R1, E1, A1, S, R2, A2>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>, s: S, f: (s: S, eff1: IO<R, Maybe<E>, A>, eff2: IO<R1, Maybe<E1>, A1>) => IO<R2, never, Exit<Maybe<E | E1>, readonly [A2, S]>>, __tsplusTrace?: string): Stream<R | R1 | R2, E | E1, A2>;
+export declare function combine<R, E, A, R1, E1, A1, S, R2, A2>(that: Stream<R1, E1, A1>, s: S, f: (s: S, eff1: IO<R, Maybe<E>, A>, eff2: IO<R1, Maybe<E1>, A1>) => IO<R2, never, Exit<Maybe<E | E1>, readonly [A2, S]>>, __tsplusTrace?: string): (stream: Stream<R, E, A>) => Stream<R | R1 | R2, E | E1, A2>;
 /**
  * Combines the chunks from this stream and the specified stream by repeatedly applying the
  * function `f` to extract a chunk using both sides and conceptually "offer"
  * it to the destination stream. `f` can maintain some internal state to control
  * the combining process, with the initial state being specified by `s`.
- * @tsplus fluent fncts.io.Stream combineChunks
+ * @tsplus pipeable fncts.io.Stream combineChunks
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function combineChunks_<R, E, A, R1, E1, A1, S, R2, A2>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>, s: S, f: (s: S, l: IO<R, Maybe<E>, Conc<A>>, r: IO<R1, Maybe<E1>, Conc<A1>>) => IO<R2, never, Exit<Maybe<E | E1>, readonly [Conc<A2>, S]>>, __tsplusTrace?: string): Stream<R1 | R | R2, E | E1, A2>;
+export declare function combineChunks<R, E, A, R1, E1, A1, S, R2, A2>(that: Stream<R1, E1, A1>, s: S, f: (s: S, l: IO<R, Maybe<E>, Conc<A>>, r: IO<R1, Maybe<E1>, Conc<A1>>) => IO<R2, never, Exit<Maybe<E | E1>, readonly [Conc<A2>, S]>>, __tsplusTrace?: string): (stream: Stream<R, E, A>) => Stream<R1 | R | R2, E | E1, A2>;
 /**
  * Concatenates the specified stream with this stream, resulting in a stream
  * that emits the elements from this stream and then the elements from the specified stream.
- * @tsplus fluent fncts.io.Stream concat
+ * @tsplus pipeable fncts.io.Stream concat
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function concat_<R, R1, E, E1, A, A1>(stream: Stream<R, E, A>, that: Stream<R1, E1, A1>, __tsplusTrace?: string): Stream<R | R1, E | E1, A | A1>;
+export declare function concat<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A1 | A>;
 /**
  * Composes this stream with the specified stream to create a cartesian product of elements.
  * The `that` stream would be run multiple times, for every element in the `this` stream.
- * @tsplus fluent fncts.io.Stream cross
+ * @tsplus pipeable fncts.io.Stream cross
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function cross_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, that: Stream<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, readonly [A, B]>;
+export declare function cross<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, readonly [A, B]>;
 /**
  * Composes this stream with the specified stream to create a cartesian product of elements
  * with a specified function.
  * The `fb` stream would be run multiple times, for every element in the `fa` stream.
- * @tsplus fluent fncts.io.Stream crossWith
+ * @tsplus pipeable fncts.io.Stream crossWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function crossWith_<R, E, A, R1, E1, B, C>(fa: Stream<R, E, A>, fb: Stream<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): Stream<R | R1, E | E1, C>;
+export declare function crossWith<A, R1, E1, B, C>(fb: Stream<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, C>;
 /**
  * Provides some of the environment required to run this effect,
  * leaving the remainder `R0`.
- * @tsplus fluent fncts.io.Stream contramapEnvironment
+ * @tsplus pipeable fncts.io.Stream contramapEnvironment
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function contramapEnvironment_<R, E, A, R0>(ra: Stream<R, E, A>, f: (r0: Environment<R0>) => Environment<R>, __tsplusTrace?: string): Stream<R0, E, A>;
+export declare function contramapEnvironment<R, R0>(f: (r0: Environment<R0>) => Environment<R>, __tsplusTrace?: string): <E, A>(ra: Stream<R, E, A>) => Stream<R0, E, A>;
 /**
- * @tsplus fluent fncts.io.Stream debounce
+ * @tsplus pipeable fncts.io.Stream debounce
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function debounce_<R, E, A>(stream: Stream<R, E, A>, duration: Lazy<Duration>, __tsplusTrace?: string): Stream<R, E, A>;
+export declare function debounce(duration: Lazy<Duration>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R, E, A>;
 /**
  * Switches to the provided stream in case this one is empty.
- * @tsplus fluent fncts.io.Stream defaultIfEmpty
+ * @tsplus pipeable fncts.io.Stream defaultIfEmpty
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function defaultIfEmpty_<R, E, A, R1, E1, B>(fa: Stream<R, E, A>, fb: Stream<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, A | B>;
+export declare function defaultIfEmpty<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B | A>;
 /**
  * More powerful version of `broadcast`. Allows to provide a function that determines what
  * queues should receive which elements. The decide function will receive the indices of the queues
  * in the resulting list.
- * @tsplus fluent fncts.io.Stream distributedWith
+ * @tsplus pipeable fncts.io.Stream distributedWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function distributedWith_<R, E, A>(self: Stream<R, E, A>, n: number, maximumLag: number, decide: (_: A) => UIO<(_: number) => boolean>, __tsplusTrace?: string): IO<R | Scope, never, Conc<Queue.Dequeue<Exit<Maybe<E>, A>>>>;
+export declare function distributedWith<A>(n: number, maximumLag: number, decide: (_: A) => UIO<(_: number) => boolean>, __tsplusTrace?: string): <R, E>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("@fncts/base/collection/immutable/Conc.js").Conc<Queue.Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>>>;
 /**
  * More powerful version of `ZStream#distributedWith`. This returns a function that will produce
  * new queues and corresponding indices.
@@ -329,10 +331,10 @@ export declare function distributedWith_<R, E, A>(self: Stream<R, E, A>, n: numb
  * Shutdown of the queues is handled by the driver.
  * Downstream users can also shutdown queues manually. In this case the driver will
  * continue but no longer backpressure on them.
- * @tsplus fluent fncts.io.Stream distributedWithDynamic
+ * @tsplus pipeable fncts.io.Stream distributedWithDynamic
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function distributedWithDynamic_<R, E, A>(self: Stream<R, E, A>, maximumLag: number, decide: (a: A) => UIO<(_: symbol) => boolean>, done?: (exit: Exit<Maybe<E>, never>) => UIO<any>, __tsplusTrace?: string): IO<R | Scope, never, UIO<readonly [symbol, Queue.Dequeue<Exit<Maybe<E>, A>>]>>;
+export declare function distributedWithDynamic<E, A>(maximumLag: number, decide: (a: A) => UIO<(_: symbol) => boolean>, done?: (exit: Exit<Maybe<E>, never>) => UIO<any>, __tsplusTrace?: string): <R>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../IO.js").UIO<readonly [symbol, Queue.Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>]>>;
 /**
  * Converts this stream to a stream that executes its effects but emits no
  * elements. Useful for sequencing effects using streams.
@@ -342,24 +344,24 @@ export declare function distributedWithDynamic_<R, E, A>(self: Stream<R, E, A>,
 export declare function drain<R, E, A>(fa: Stream<R, E, A>, __tsplusTrace?: string): Stream<R, E, void>;
 /**
  * Drops the specified number of elements from this stream.
- * @tsplus fluent fncts.io.Stream drop
+ * @tsplus pipeable fncts.io.Stream drop
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function drop_<R, E, A>(stream: Stream<R, E, A>, n: number, __tsplusTrace?: string): Stream<R, E, A>;
+export declare function drop(n: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R, E, A>;
 /**
  * Drops all elements of the stream for as long as the specified predicate
  * evaluates to `true`.
- * @tsplus fluent fncts.io.Stream dropWhile
+ * @tsplus pipeable fncts.io.Stream dropWhile
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function dropWhile_<R, E, A>(stream: Stream<R, E, A>, p: Predicate<A>, __tsplusTrace?: string): Stream<R, E, A>;
+export declare function dropWhile<A>(p: Predicate<A>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, A>;
 /**
  * Drops all elements of the stream until the specified predicate evaluates
  * to `true`.
- * @tsplus fluent fncts.io.Stream dropUntil
+ * @tsplus pipeable fncts.io.Stream dropUntil
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function dropUntil_<R, E, A>(stream: Stream<R, E, A>, p: Predicate<A>, __tsplusTrace?: string): Stream<R, E, A>;
+export declare function dropUntil<A>(p: Predicate<A>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, A>;
 /**
  * Returns a stream whose failures and successes have been lifted into an
  * `Either`. The resulting stream cannot fail, because the failures have
@@ -382,15 +384,15 @@ export declare const empty: Stream<never, never, never>;
  * completes. See `interruptWhen` for this behavior.
  *
  * If the IO completes with a failure, the stream will emit that failure.
- * @tsplus fluent fncts.io.Stream endWhen
+ * @tsplus pipeable fncts.io.Stream endWhen
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function endWhen_<R, E, A, R1, E1>(stream: Stream<R, E, A>, io: IO<R1, E1, any>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
+export declare function endWhen<R1, E1>(io: IO<R1, E1, any>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
 /**
- * @tsplus fluent fncts.io.Stream ensuring
+ * @tsplus pipeable fncts.io.Stream ensuring
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function ensuring_<R, E, A, R1>(self: Stream<R, E, A>, finalizer: IO<R1, never, any>, __tsplusTrace?: string): Stream<R | R1, E, A>;
+export declare function ensuring<R1>(finalizer: IO<R1, never, any>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<R1 | R, E, A>;
 /**
  * @tsplus static fncts.io.StreamOps environment
  * @tsplus location "@fncts/io/Stream/api"
@@ -439,38 +441,38 @@ export declare function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string)
  */
 export declare function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Stream<never, E, never>;
 /**
- * @tsplus fluent fncts.io.Stream filter
+ * @tsplus pipeable fncts.io.Stream filter
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function filter_<R, E, A, B extends A>(fa: Stream<R, E, A>, refinement: Refinement<A, B>): Stream<R, E, B>;
-export declare function filter_<R, E, A>(fa: Stream<R, E, A>, predicate: Predicate<A>): Stream<R, E, A>;
+export declare function filter<A, B extends A>(refinement: Refinement<A, B>): <R, E>(fa: Stream<R, E, A>) => Stream<R, E, B>;
+export declare function filter<A>(predicate: Predicate<A>): <R, E>(fa: Stream<R, E, A>) => Stream<R, E, A>;
 /**
- * @tsplus fluent fncts.io.Stream filterIO
+ * @tsplus pipeable fncts.io.Stream filterIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function filterIO_<R, E, A, R1, E1>(fa: Stream<R, E, A>, f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
+export declare function filterIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
 /**
- * @tsplus fluent fncts.io.Stream filterMap
+ * @tsplus pipeable fncts.io.Stream filterMap
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function filterMap_<R, E, A, B>(fa: Stream<R, E, A>, f: (a: A) => Maybe<B>, __tsplusTrace?: string): Stream<R, E, B>;
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R, E, B>;
 /**
- * @tsplus fluent fncts.io.Stream filterMapIO
+ * @tsplus pipeable fncts.io.Stream filterMapIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function filterMapIO_<R, E, A, R1, E1, B>(fa: Stream<R, E, A>, f: (a: A) => IO<R1, E1, Maybe<B>>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
+export declare function filterMapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, Maybe<B>>, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
 /**
  * Finds the first element emitted by this stream that satisfies the provided predicate.
- * @tsplus fluent fncts.io.Stream find
+ * @tsplus pipeable fncts.io.Stream find
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function find_<R, E, A>(stream: Stream<R, E, A>, p: Predicate<A>, __tsplusTrace?: string): Stream<R, E, A>;
+export declare function find<A>(p: Predicate<A>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, A>;
 /**
  * Finds the first element emitted by this stream that satisfies the provided effectful predicate.
- * @tsplus fluent fncts.io.Stream findIO
+ * @tsplus pipeable fncts.io.Stream findIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function findIO_<R, E, A, R1, E1>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
+export declare function findIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
 /**
  * Flattens this stream-of-streams into a stream made of the concatenation in
  * strict order of all the streams.
@@ -522,7 +524,7 @@ export declare function fromChunk<O>(c: Lazy<Conc<O>>, __tsplusTrace?: string):
  * @tsplus static fncts.io.StreamOps scoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function scoped<R, E, A>(stream: IO<R, E, A>, __tsplusTrace?: string): Stream<Exclude<R, Scope>, E, A>;
+export declare function scoped<R, E, A>(stream: Lazy<IO<R, E, A>>, __tsplusTrace?: string): Stream<Exclude<R, Scope>, E, A>;
 /**
  * Creates a stream from an effect producing a value of type `A`
  * @tsplus static fncts.io.StreamOps fromIO
@@ -560,12 +562,22 @@ export declare function fromPull<R, E, A>(scopedPull: IO<R, never, IO<R, Maybe<E
  * @tsplus static fncts.io.StreamOps fromQueue
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromQueue_<R, E, O>(queue: PQueue<never, R, unknown, E, never, O>, maxChunkSize?: number, __tsplusTrace?: string): Stream<R, E, O>;
+export declare function fromQueue<RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>, maxChunkSize?: number, __tsplusTrace?: string): Stream<RB, EB, B>;
 /**
  * @tsplus static fncts.io.StreamOps fromQueueWithShutdown
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromQueueWithShutdown<R, E, A>(queue: PQueue<never, R, unknown, E, never, A>, maxChunkSize?: number, __tsplusTrace?: string): Stream<R, E, A>;
+export declare function fromQueueWithShutdown<RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>, maxChunkSize?: number, __tsplusTrace?: string): Stream<RB, EB, B>;
+/**
+ * @tsplus static fncts.io.StreamOps fromHub
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function fromHub<A>(hub: Lazy<Hub<A>>, maxChunkSize?: number, __tsplusTrace?: string): Stream<never, never, A>;
+/**
+ * @tsplus static fncts.io.StreamOps fromHubScoped
+ * @tsplus location "@fncts/io/Stream/api"
+ */
+export declare function fromHubScoped<A>(hub: Lazy<Hub<A>>, maxChunkSize?: number, __tsplusTrace?: string): IO<Scope, never, Stream<never, never, A>>;
 /**
  * Halt a stream with the specified exception
  * @tsplus static fncts.io.StreamOps haltNow
@@ -587,23 +599,23 @@ export declare function halt(u: Lazy<unknown>, __tsplusTrace?: string): Stream<n
  * IO completes. See `interruptWhen` for this behavior.
  *
  * If the IO completes with a failure, the stream will emit that failure.
- * @tsplus fluent fncts.io.Stream haltWhen
+ * @tsplus pipeable fncts.io.Stream haltWhen
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function haltWhen_<R, E, A, R1, E1>(fa: Stream<R, E, A>, io: IO<R1, E1, any>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
+export declare function haltWhen<R1, E1>(io: IO<R1, E1, any>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
 /**
  * Halts the evaluation of this stream when the provided promise resolves.
  *
  * If the promise completes with a failure, the stream will emit that failure.
- * @tsplus fluent fncts.io.Stream haltWhen
+ * @tsplus pipeable fncts.io.Stream haltWhen
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function haltWhenFuture_<R, E, A, E1>(fa: Stream<R, E, A>, future: Future<E1, any>, __tsplusTrace?: string): Stream<R, E | E1, A>;
+export declare function haltWhenFuture<E1>(future: Future<E1, any>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R, E1 | E, A>;
 /**
- * @tsplus fluent fncts.io.Stream interleave
+ * @tsplus pipeable fncts.io.Stream interleave
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function interleave_<R, E, A, R1, E1, B>(sa: Stream<R, E, A>, sb: Stream<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, A | B>;
+export declare function interleave<R1, E1, B>(sb: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(sa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B | A>;
 /**
  * Combines this stream and the specified stream deterministically using the
  * stream of boolean values `b` to control which stream to pull from next.
@@ -611,14 +623,14 @@ export declare function interleave_<R, E, A, R1, E1, B>(sa: Stream<R, E, A>, sb:
  * from the specified stream. Only consumes as many elements as requested by
  * `b`. If either this stream or the specified stream are exhausted further
  * requests for values from that stream will be ignored.
- * @tsplus fluent fncts.io.Stream interleaveWith
+ * @tsplus pipeable fncts.io.Stream interleaveWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function interleaveWith_<R, E, A, R1, E1, B, R2, E2>(sa: Stream<R, E, A>, sb: Stream<R1, E1, B>, b: Stream<R2, E2, boolean>, __tsplusTrace?: string): Stream<R | R1 | R2, E | E1 | E2, A | B>;
+export declare function interleaveWith<R1, E1, B, R2, E2>(sb: Stream<R1, E1, B>, b: Stream<R2, E2, boolean>, __tsplusTrace?: string): <R, E, A>(sa: Stream<R, E, A>) => Stream<R1 | R2 | R, E1 | E2 | E, B | A>;
 /**
  * Intersperse stream with provided element
  */
-export declare function intersperse_<R, E, A, A1>(stream: Stream<R, E, A>, middle: A1, __tsplusTrace?: string): Stream<R, E, A | A1>;
+export declare function intersperse<R, E, A, A1>(stream: Stream<R, E, A>, middle: A1, __tsplusTrace?: string): Stream<R, E, A | A1>;
 /**
  * Interrupts the evaluation of this stream when the provided IO completes. The given
  * IO will be forked as part of this stream, and its success will be discarded. This
@@ -626,204 +638,204 @@ export declare function intersperse_<R, E, A, A1>(stream: Stream<R, E, A>, middl
  *
  * If the IO completes with a failure before the stream completes, the returned stream
  * will emit that failure.
- * @tsplus fluent fncts.io.Stream interruptWhen
+ * @tsplus pipeable fncts.io.Stream interruptWhen
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function interruptWhen_<R, E, A, R1, E1>(stream: Stream<R, E, A>, io: IO<R1, E1, any>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
+export declare function interruptWhen<R1, E1>(io: IO<R1, E1, any>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
 /**
- * @tsplus fluent fncts.io.Stream interruptWhen
+ * @tsplus pipeable fncts.io.Stream interruptWhen
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function interruptWhenFuture_<R, E, A, E1>(fa: Stream<R, E, A>, future: Future<E1, unknown>, __tsplusTrace?: string): Stream<R, E | E1, A>;
+export declare function interruptWhenFuture<E1>(future: Future<E1, unknown>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R, E1 | E, A>;
 /**
  * Transforms the elements of this stream using the supplied function.
- * @tsplus fluent fncts.io.Stream map
+ * @tsplus pipeable fncts.io.Stream map
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function map_<R, E, A, B>(stream: Stream<R, E, A>, f: (o: A) => B, __tsplusTrace?: string): Stream<R, E, B>;
+export declare function map<A, B>(f: (o: A) => B, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, B>;
 /**
  * Statefully maps over the elements of this stream to produce new elements.
- * @tsplus fluent fncts.io.Stream mapAccum
+ * @tsplus pipeable fncts.io.Stream mapAccum
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapAccum_<R, E, A, S, B>(stream: Stream<R, E, A>, s: S, f: (s: S, a: A) => readonly [S, B], __tsplusTrace?: string): Stream<R, E, B>;
+export declare function mapAccum<A, S, B>(s: S, f: (s: S, a: A) => readonly [S, B], __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, B>;
 /**
  * Statefully and effectfully maps over the elements of this stream to produce
  * new elements.
- * @tsplus fluent fncts.io.Stream mapAccumIO
+ * @tsplus pipeable fncts.io.Stream mapAccumIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapAccumIO_<R, E, A, R1, E1, S, B>(stream: Stream<R, E, A>, s: S, f: (s: S, a: A) => IO<R1, E1, readonly [B, S]>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
+export declare function mapAccumIO<A, R1, E1, S, B>(s: S, f: (s: S, a: A) => IO<R1, E1, readonly [B, S]>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
 /**
  * Transforms the chunks emitted by this stream.
- * @tsplus fluent fncts.io.Stream mapChunks
+ * @tsplus pipeable fncts.io.Stream mapChunks
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapChunks_<R, E, A, A1>(stream: Stream<R, E, A>, f: (chunk: Conc<A>) => Conc<A1>, __tsplusTrace?: string): Stream<R, E, A1>;
+export declare function mapChunks<A, A1>(f: (chunk: Conc<A>) => Conc<A1>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, A1>;
 /**
  * Effectfully transforms the chunks emitted by this stream.
- * @tsplus fluent fncts.io.Stream mapChunksIO
+ * @tsplus pipeable fncts.io.Stream mapChunksIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapChunksIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (chunk: Conc<A>) => IO<R1, E1, Conc<B>>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
+export declare function mapChunksIO<A, R1, E1, B>(f: (chunk: Conc<A>) => IO<R1, E1, Conc<B>>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
 /**
  * Maps each element to an iterable, and flattens the iterables into the
  * output of this stream.
- * @tsplus fluent fncts.io.Stream mapConcat
+ * @tsplus pipeable fncts.io.Stream mapConcat
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapConcat_<R, E, A, B>(stream: Stream<R, E, A>, f: (a: A) => Iterable<B>, __tsplusTrace?: string): Stream<R, E, B>;
+export declare function mapConcat<A, B>(f: (a: A) => Iterable<B>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, B>;
 /**
  * Maps each element to a chunk, and flattens the chunks into the output of
  * this stream.
- * @tsplus fluent fncts.io.Stream mapConcatChunk
+ * @tsplus pipeable fncts.io.Stream mapConcatChunk
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapConcatChunk_<R, E, A, B>(stream: Stream<R, E, A>, f: (a: A) => Conc<B>, __tsplusTrace?: string): Stream<R, E, B>;
+export declare function mapConcatChunk<A, B>(f: (a: A) => Conc<B>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R, E, B>;
 /**
  * Effectfully maps each element to a chunk, and flattens the chunks into
  * the output of this stream.
- * @tsplus fluent fncts.io.Stream mapConcatChunkIO
+ * @tsplus pipeable fncts.io.Stream mapConcatChunkIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapConcatChunkIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, Conc<B>>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
+export declare function mapConcatChunkIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, Conc<B>>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
 /**
  * Effectfully maps each element to an iterable, and flattens the iterables into
  * the output of this stream.
- * @tsplus fluent fncts.io.Stream mapConcatIO
+ * @tsplus pipeable fncts.io.Stream mapConcatIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapConcatIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, Iterable<B>>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
+export declare function mapConcatIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, Iterable<B>>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
 /**
  * Transforms the errors emitted by this stream using `f`.
- * @tsplus fluent fncts.io.Stream mapError
+ * @tsplus pipeable fncts.io.Stream mapError
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapError_<R, E, E1, A>(stream: Stream<R, E, A>, f: (e: E) => E1, __tsplusTrace?: string): Stream<R, E1, A>;
+export declare function mapError<E, E1>(f: (e: E) => E1, __tsplusTrace?: string): <R, A>(stream: Stream<R, E, A>) => Stream<R, E1, A>;
 /**
  * Transforms the full causes of failures emitted by this stream.
- * @tsplus fluent fncts.io.Stream mapErrorCause
+ * @tsplus pipeable fncts.io.Stream mapErrorCause
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapErrorCause_<R, E, A, E1>(fa: Stream<R, E, A>, f: (e: Cause<E>) => Cause<E1>, __tsplusTrace?: string): Stream<R, E1, A>;
+export declare function mapErrorCause<E, E1>(f: (e: Cause<E>) => Cause<E1>, __tsplusTrace?: string): <R, A>(fa: Stream<R, E, A>) => Stream<R, E1, A>;
 /**
  * Maps over elements of the stream with the specified effectful function.
- * @tsplus fluent fncts.io.Stream mapIO
+ * @tsplus pipeable fncts.io.Stream mapIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
+export declare function mapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
 /**
  * Maps over elements of the stream with the specified effectful function,
  * executing up to `n` invocations of `f` concurrently. Transformed elements
  * will be emitted in the original order.
  * @note This combinator destroys the chunking structure. It's recommended to use chunkN afterwards.
- * @tsplus fluent fncts.io.Stream mapIOC
+ * @tsplus pipeable fncts.io.Stream mapIOC
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mapIOC_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, n: number, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
+export declare function mapIOC<A, R1, E1, B>(n: number, f: (a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
 /**
  * Maps each element of this stream to another stream and returns the
  * non-deterministic merge of those streams, executing up to `n` inner streams
  * concurrently. Up to `bufferSize` elements of the produced streams may be
  * buffered in memory by this operator.
- * @tsplus fluent fncts.io.Stream mergeMap
+ * @tsplus pipeable fncts.io.Stream mergeMap
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeMap_<R, E, A, R1, E1, B>(ma: Stream<R, E, A>, f: (a: A) => Stream<R1, E1, B>, n: number, bufferSize?: number, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
+export declare function mergeMap<A, R1, E1, B>(f: (a: A) => Stream<R1, E1, B>, n: number, bufferSize?: number, __tsplusTrace?: string): <R, E>(ma: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
 /**
  * Maps over elements of the stream with the specified effectful function,
  * executing up to `n` invocations of `f` concurrently. The element order
  * is not enforced by this combinator, and elements may be reordered.
- * @tsplus fluent fncts.io.Stream mergeMapIO
+ * @tsplus pipeable fncts.io.Stream mergeMapIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeMapIO_<R, E, A, R1, E1, B>(stream: Stream<R, E, A>, f: (a: A) => IO<R1, E1, B>, n: number, bufferSize?: number, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
+export declare function mergeMapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, n: number, bufferSize?: number, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
 /**
- * @tsplus fluent fncts.io.Stream mergeEither
+ * @tsplus pipeable fncts.io.Stream mergeEither
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeEither_<R, E, A, R1, E1, B>(fa: Stream<R, E, A>, fb: Stream<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, Either<A, B>>;
+export declare function mergeEither<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplusTrace?: string): <R, E, A>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, import("@fncts/base/data/Either.js").Either<A, B>>;
 export declare function mergeWithHandler<R, E>(terminate: boolean, __tsplusTrace?: string): (exit: Exit<E, unknown>) => MergeDecision<R, E, unknown, E, unknown>;
 export type TerminationStrategy = "Left" | "Right" | "Both" | "Either";
 /**
- * @tsplus fluent fncts.io.Stream mergeWith
+ * @tsplus pipeable fncts.io.Stream mergeWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function mergeWith_<R, E, A, R1, E1, A1, B, C>(sa: Stream<R, E, A>, sb: Stream<R1, E1, A1>, l: (a: A) => B, r: (b: A1) => C, strategy?: TerminationStrategy, __tsplusTrace?: string): Stream<R | R1, E | E1, B | C>;
+export declare function mergeWith<A, R1, E1, A1, B, C>(sb: Stream<R1, E1, A1>, l: (a: A) => B, r: (b: A1) => C, strategy?: TerminationStrategy, __tsplusTrace?: string): <R, E>(sa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B | C>;
 /**
  * Runs the specified effect if this stream fails, providing the error to the effect if it exists.
  *
  * Note: Unlike `IO.onError`, there is no guarantee that the provided effect will not be interrupted.
- * @tsplus fluent fncts.io.Stream onError
+ * @tsplus pipeable fncts.io.Stream onError
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function onError_<R, E, A, R1>(stream: Stream<R, E, A>, cleanup: (e: Cause<E>) => IO<R1, never, any>, __tsplusTrace?: string): Stream<R | R1, E, A>;
+export declare function onError<E, R1>(cleanup: (e: Cause<E>) => IO<R1, never, any>, __tsplusTrace?: string): <R, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E, A>;
 /**
  * Switches to the provided stream in case this one fails with a typed error.
  *
  * See also Stream#catchAll
- * @tsplus fluent fncts.io.Stream orElse
+ * @tsplus pipeable fncts.io.Stream orElse
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function orElse_<R, E, A, R1, E1, A1>(stream: Stream<R, E, A>, that: Lazy<Stream<R1, E1, A1>>, __tsplusTrace?: string): Stream<R | R1, E1, A | A1>;
+export declare function orElse<R1, E1, A1>(that: Lazy<Stream<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1, A1 | A>;
 /**
  * Switches to the provided stream in case this one fails with a typed error.
  *
  * See also ZStream#catchAll
- * @tsplus fluent fncts.io.Stream orElseEither
+ * @tsplus pipeable fncts.io.Stream orElseEither
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function orElseEither_<R, E, A, R1, E1, A1>(stream: Stream<R, E, A>, that: Lazy<Stream<R1, E1, A1>>, __tsplusTrace?: string): Stream<R | R1, E1, Either<A, A1>>;
+export declare function orElseEither<R1, E1, A1>(that: Lazy<Stream<R1, E1, A1>>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1, import("@fncts/base/data/Either.js").Either<A, A1>>;
 /**
  * Fails with given error in case this one fails with a typed error.
  *
  * See also Stream#catchAll
- * @tsplus fluent fncts.io.Stream orElseFail
+ * @tsplus pipeable fncts.io.Stream orElseFail
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function orElseFail_<R, E, A, E1>(stream: Stream<R, E, A>, e: Lazy<E1>, __tsplusTrace?: string): Stream<R, E1, A>;
+export declare function orElseFail<E1>(e: Lazy<E1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R, E1, A>;
 /**
  * Switches to the provided stream in case this one fails with the `None` value.
  *
  * See also Stream#catchAll.
  */
-export declare function orElseOptional_<R, E, A, R1, E1, A1>(stream: Stream<R, Maybe<E>, A>, that: Lazy<Stream<R1, Maybe<E1>, A1>>, __tsplusTrace?: string): Stream<R | R1, Maybe<E | E1>, A | A1>;
+export declare function orElseOptional<R, E, A, R1, E1, A1>(stream: Stream<R, Maybe<E>, A>, that: Lazy<Stream<R1, Maybe<E1>, A1>>, __tsplusTrace?: string): Stream<R | R1, Maybe<E | E1>, A | A1>;
 /**
  * Succeeds with the specified value if this one fails with a typed error.
- * @tsplus fluent fncts.io.Stream orElseSucceed
+ * @tsplus pipeable fncts.io.Stream orElseSucceed
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function orElseSucceed_<R, E, A, A1>(stream: Stream<R, E, A>, a: Lazy<A1>, __tsplusTrace?: string): Stream<R, never, A | A1>;
+export declare function orElseSucceed<A1>(a: Lazy<A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R, never, A1 | A>;
 /**
- * @tsplus fluent fncts.io.Stream pipeThrough
+ * @tsplus pipeable fncts.io.Stream pipeThrough
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function pipeThrough_<R, E, A, R1, E1, L, Z>(ma: Stream<R, E, A>, sa: Sink<R1, E1, A, L, Z>, __tsplusTrace?: string): Stream<R | R1, E | E1, L>;
+export declare function pipeThrough<A, R1, E1, L, Z>(sa: Sink<R1, E1, A, L, Z>, __tsplusTrace?: string): <R, E>(ma: Stream<R, E, A>) => Stream<R1 | R, E1 | E, L>;
 /**
  * Provides the stream with its required environment, which eliminates
  * its dependency on `R`.
- * @tsplus fluent fncts.io.Stream provideEnvironment
+ * @tsplus pipeable fncts.io.Stream provideEnvironment
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function provideEnvironment_<R, E, A>(ra: Stream<R, E, A>, r: Environment<R>, __tsplusTrace?: string): Stream<never, E, A>;
+export declare function provideEnvironment<R>(r: Environment<R>, __tsplusTrace?: string): <E, A>(ra: Stream<R, E, A>) => Stream<never, E, A>;
 /**
- * @tsplus fluent fncts.io.Stream provideLayer
+ * @tsplus pipeable fncts.io.Stream provideLayer
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function provideLayer_<RIn, E, ROut, E1, A>(self: Stream<ROut, E, A>, layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): Stream<RIn, E | E1, A>;
+export declare function provideLayer<RIn, ROut, E1>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): <E, A>(self: Stream<ROut, E, A>) => Stream<RIn, E1 | E, A>;
 /**
- * @tsplus fluent fncts.io.Stream provideSomeLayer
+ * @tsplus pipeable fncts.io.Stream provideSomeLayer
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function provideSomeLayer_<R, E, A, RIn, E1, ROut>(self: Stream<R, E, A>, layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): Stream<RIn | Exclude<R, ROut>, E | E1, A>;
+export declare function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, ROut>, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => Stream<RIn | Exclude<R, ROut>, E1 | E, A>;
 /**
  * Re-chunks the elements of the stream into chunks of
  * `n` elements each.
  * The last chunk might contain less than `n` elements
- * @tsplus fluent fncts.io.Stream rechunk
+ * @tsplus pipeable fncts.io.Stream rechunk
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function rechunk_<R, E, A>(stream: Stream<R, E, A>, n: number, __tsplusTrace?: string): Stream<R, E, A>;
+export declare function rechunk(n: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R, E, A>;
 /**
  * Repeats the provided value infinitely.
  * @tsplus static fncts.io.StreamOps repeatValue
@@ -856,10 +868,10 @@ export declare function repeatIOChunk<R, E, A>(fa: IO<R, E, Conc<A>>, __tsplusTr
 export declare function repeatIOChunkMaybe<R, E, A>(fa: IO<R, Maybe<E>, Conc<A>>, __tsplusTrace?: string): Stream<R, E, A>;
 /**
  * Runs the sink on the stream to produce either the sink's result or an error.
- * @tsplus fluent fncts.io.Stream run
+ * @tsplus pipeable fncts.io.Stream run
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function run_<R, E, A, R2, E2, Z>(stream: Stream<R, E, A>, sink: Sink<R2, E2, A, unknown, Z>, __tsplusTrace?: string): IO<R | R2, E | E2, Z>;
+export declare function run<A, R2, E2, Z>(sink: Sink<R2, E2, A, unknown, Z>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => import("../IO.js").IO<R2 | R, E2 | E, Z>;
 /**
  * Runs the stream and collects all of its elements to a chunk.
  * @tsplus getter fncts.io.Stream runCollect
@@ -873,65 +885,65 @@ export declare function runCollect<R, E, A>(stream: Stream<R, E, A>, __tsplusTra
  */
 export declare function runDrain<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?: string): IO<R, E, void>;
 /**
- * @tsplus fluent fncts.io.Stream runForeachScoped
+ * @tsplus pipeable fncts.io.Stream runForeachScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runForeachScoped_<R, E, A, R2, E2>(self: Stream<R, E, A>, f: (a: A) => IO<R2, E2, any>, __tsplusTrace?: string): IO<R | R2 | Scope, E | E2, void>;
+export declare function runForeachScoped<A, R2, E2>(f: (a: A) => IO<R2, E2, any>, __tsplusTrace?: string): <R, E>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R2 | R, E2 | E, void>;
 /**
  * Like `into`, but provides the result as a `Managed` to allow for scope
  * composition.
- * @tsplus fluent fncts.io.Stream runIntoElementsScoped
+ * @tsplus pipeable fncts.io.Stream runIntoElementsScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoElementsScoped_<R, E, A, R1, E1>(stream: Stream<R, E, A>, queue: PQueue<R1, unknown, never, never, Exit<Maybe<E | E1>, A>, unknown>, __tsplusTrace?: string): IO<R | R1 | Scope, E | E1, void>;
+export declare function runIntoElementsScoped_<E, A, R1, E1>(queue: PQueue<R1, unknown, never, never, Exit<Maybe<E | E1>, A>, unknown>, __tsplusTrace?: string): <R>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R1 | R, E | E1, void>;
 /**
  * Like `Stream#into`, but provides the result as a `Managed` to allow for scope
  * composition.
- * @tsplus fluent fncts.io.Stream runIntoQueueScoped
+ * @tsplus pipeable fncts.io.Stream runIntoQueueScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoQueueScoped_<R, R1, E extends E1, E1, A>(stream: Stream<R, E, A>, queue: PQueue<R1, never, never, unknown, Take<E1, A>, any>, __tsplusTrace?: string): IO<R | R1 | Scope, E | E1, void>;
+export declare function runIntoQueueScoped<RA, RB, EA, EB, E1, A, B>(queue: PEnqueue<RA, RB, EA, EB, Take<E1, A>, B>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | RA | R, EA | E1 | E, void>;
 /**
  * Like `Stream#runIntoHub`, but provides the result as a `Managed` to allow for scope
  * composition.
- * @tsplus fluent fncts.io.Stream runIntoHubScoped
+ * @tsplus pipeable fncts.io.Stream runIntoHubScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoHubScoped_<R, R1, E extends E1, E1, A>(stream: Stream<R, E, A>, hub: PHub<R1, never, never, unknown, Take<E1, A>, any>, __tsplusTrace?: string): IO<R | R1 | Scope, E | E1, void>;
+export declare function runIntoHubScoped<RA, RB, EA, EB, E1, A, B>(hub: PHub<RA, RB, EA, EB, Take<E1, A>, B>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | RA | R, EA | E1 | E, void>;
 /**
  * Runs the sink on the stream to produce either the sink's result or an error.
- * @tsplus fluent fncts.io.Stream runScoped
+ * @tsplus pipeable fncts.io.Stream runScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runScoped_<R, E, A, R2, E2, Z>(stream: Stream<R, E, A>, sink: Sink<R2, E2, A, unknown, Z>, __tsplusTrace?: string): IO<R | R2 | Scope, E | E2, Z>;
+export declare function runScoped<A, R2, E2, Z>(sink: Sink<R2, E2, A, unknown, Z>, __tsplusTrace?: string): <R, E>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R2 | R, E2 | E, Z>;
 /**
  * Statefully maps over the elements of this stream to produce all intermediate results
  * of type `B` given an initial B.
- * @tsplus fluent fncts.io.Stream scan
+ * @tsplus pipeable fncts.io.Stream scan
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function scan_<R, E, A, B>(sa: Stream<R, E, A>, b: B, f: (b: B, a: A) => B, __tsplusTrace?: string): Stream<R, E, B>;
+export declare function scan<A, B>(b: B, f: (b: B, a: A) => B, __tsplusTrace?: string): <R, E>(sa: Stream<R, E, A>) => Stream<R, E, B>;
 /**
  * Statefully and effectfully maps over the elements of this stream to produce all
  * intermediate results of type `B` given an initial B.
- * @tsplus fluent fncts.io.Stream scanIO
+ * @tsplus pipeable fncts.io.Stream scanIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function scanIO_<R, E, A, R1, E1, B>(sa: Stream<R, E, A>, b: B, f: (b: B, a: A) => IO<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
+export declare function scanIO<A, R1, E1, B>(b: B, f: (b: B, a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(sa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
 /**
  * Statefully maps over the elements of this stream to produce all
  * intermediate results.
- * @tsplus fluent fncts.io.Stream scanReduce
+ * @tsplus pipeable fncts.io.Stream scanReduce
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function scanReduce_<R, E, A extends B, B>(fa: Stream<R, E, A>, f: (b: B, a: A) => B, __tsplusTrace?: string): Stream<R, E, B>;
+export declare function scanReduce<A extends B, B>(f: (b: B, a: A) => B, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R, E, B>;
 /**
  * Statefully and effectfully maps over the elements of this stream to produce
  * all intermediate results.
- * @tsplus fluent fncts.io.Stream scanReduceIO
+ * @tsplus pipeable fncts.io.Stream scanReduceIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function scanReduceIO_<R, E, A extends B, R1, E1, B>(fa: Stream<R, E, A>, f: (b: B, a: A) => IO<R1, E1, B>, __tsplusTrace?: string): Stream<R | R1, E | E1, B>;
+export declare function scanReduceIO<A extends B, R1, E1, B>(f: (b: B, a: A) => IO<R1, E1, B>, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, B>;
 /**
  * Creates a single-valued pure stream
  * @tsplus static fncts.io.StreamOps succeedNow
@@ -946,52 +958,52 @@ export declare function succeedNow<O>(o: O, __tsplusTrace?: string): Stream<neve
 export declare function succeed<A>(a: Lazy<A>, __tsplusTrace?: string): Stream<never, never, A>;
 /**
  * Takes the specified number of elements from this stream.
- * @tsplus fluent fncts.io.Stream take
+ * @tsplus pipeable fncts.io.Stream take
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function take_<R, E, A>(stream: Stream<R, E, A>, n: number, __tsplusTrace?: string): Stream<R, E, A>;
+export declare function take(n: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R, E, A>;
 /**
- * @tsplus fluent fncts.io.Stream takeUntilIO
+ * @tsplus pipeable fncts.io.Stream takeUntilIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function takeUntilIO_<R, E, A, R1, E1>(ma: Stream<R, E, A>, f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
+export declare function takeUntilIO<A, R1, E1>(f: (a: A) => IO<R1, E1, boolean>, __tsplusTrace?: string): <R, E>(ma: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
 /**
  * Takes all elements of the stream until the specified predicate evaluates
  * to `true`.
- * @tsplus fluent fncts.io.Stream takeUntil
+ * @tsplus pipeable fncts.io.Stream takeUntil
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function takeUntil_<R, E, A>(fa: Stream<R, E, A>, p: Predicate<A>, __tsplusTrace?: string): Stream<R, E, A>;
+export declare function takeUntil<A>(p: Predicate<A>, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R, E, A>;
 /**
- * @tsplus fluent fncts.io.Stream tap
+ * @tsplus pipeable fncts.io.Stream tap
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function tap_<R, E, A, R1, E1>(ma: Stream<R, E, A>, f: (a: A) => IO<R1, E1, any>, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
+export declare function tap<A, R1, E1>(f: (a: A) => IO<R1, E1, any>, __tsplusTrace?: string): <R, E>(ma: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
 /**
  * Throttles the chunks of this stream according to the given bandwidth parameters using the token bucket
  * algorithm. Allows for burst in the processing of elements by allowing the token bucket to accumulate
  * tokens up to a `units + burst` threshold. Chunks that do not meet the bandwidth constraints are dropped.
  * The weight of each chunk is determined by the `costFn` function.
- * @tsplus fluent fncts.io.Stream throttleEnforce
+ * @tsplus pipeable fncts.io.Stream throttleEnforce
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function throttleEnforce_<R, E, A>(sa: Stream<R, E, A>, costFn: (chunk: Conc<A>) => number, units: number, duration: number, burst?: number, __tsplusTrace?: string): Stream<R, E, A>;
+export declare function throttleEnforce<A>(costFn: (chunk: Conc<A>) => number, units: number, duration: number, burst?: number, __tsplusTrace?: string): <R, E>(sa: Stream<R, E, A>) => Stream<R, E, A>;
 /**
  * Throttles the chunks of this stream according to the given bandwidth parameters using the token bucket
  * algorithm. Allows for burst in the processing of elements by allowing the token bucket to accumulate
  * tokens up to a `units + burst` threshold. Chunks that do not meet the bandwidth constraints are dropped.
  * The weight of each chunk is determined by the `costFn` effectful function.
- * @tsplus fluent fncts.io.Stream throttleEnforceIO
+ * @tsplus pipeable fncts.io.Stream throttleEnforceIO
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function throttleEnforceIO_<R, E, A, R1, E1>(sa: Stream<R, E, A>, costFn: (chunk: Conc<A>) => IO<R1, E1, number>, units: number, duration: number, burst?: number, __tsplusTrace?: string): Stream<R | R1, E | E1, A>;
+export declare function throttleEnforceIO<A, R1, E1>(costFn: (chunk: Conc<A>) => IO<R1, E1, number>, units: number, duration: number, burst?: number, __tsplusTrace?: string): <R, E>(sa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
 /**
  * Converts the stream to a managed hub of chunks. After the managed hub is used,
  * the hub will never again produce values and should be discarded.
- * @tsplus fluent fncts.io.Stream toHub
+ * @tsplus pipeable fncts.io.Stream toHub
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toHub_<R, E, A>(stream: Stream<R, E, A>, capacity: number, __tsplusTrace?: string): IO<R | Scope, never, Hub<Take<E, A>>>;
+export declare function toHub(capacity: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Hub<Take<E, A>>>;
 /**
  * Interpret the stream as a managed pull
  * @tsplus getter fncts.io.Stream toPull
@@ -1001,25 +1013,25 @@ export declare function toPull<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?:
 /**
  * Converts the stream to a managed queue of chunks. After the managed queue is used,
  * the queue will never again produce values and should be discarded.
- * @tsplus fluent fncts.io.Stream toQueue
+ * @tsplus pipeable fncts.io.Stream toQueue
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueue_<R, E, A>(stream: Stream<R, E, A>, capacity?: number, __tsplusTrace?: string): IO<R | Scope, never, Queue<Take<E, A>>>;
+export declare function toQueue(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Queue.Dequeue<Take<E, A>>>;
 /**
- * @tsplus fluent fncts.io.Stream toQueueDropping
+ * @tsplus pipeable fncts.io.Stream toQueueDropping
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueueDropping_<R, E, A>(stream: Stream<R, E, A>, capacity?: number, __tsplusTrace?: string): IO<R | Scope, never, Queue.Dequeue<Take<E, A>>>;
+export declare function toQueueDropping(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Queue.Dequeue<Take<E, A>>>;
 /**
- * @tsplus fluent fncts.io.Stream toQueueOfElements
+ * @tsplus pipeable fncts.io.Stream toQueueOfElements
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueueOfElements_<R, E, A>(stream: Stream<R, E, A>, capacity?: number, __tsplusTrace?: string): IO<R | Scope, never, Queue.Dequeue<Exit<Maybe<E>, A>>>;
+export declare function toQueueOfElements(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Queue.Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>>;
 /**
- * @tsplus fluent fncts.io.Stream toQueueSliding
+ * @tsplus pipeable fncts.io.Stream toQueueSliding
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueueSliding_<R, E, A>(stream: Stream<R, E, A>, capacity?: number, __tsplusTrace?: string): IO<R | Scope, never, Queue.Dequeue<Take<E, A>>>;
+export declare function toQueueSliding(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Queue.Dequeue<Take<E, A>>>;
 /**
  * Converts the stream into an unbounded managed queue. After the managed queue
  * is used, the queue will never again produce values and should be discarded.
@@ -1074,7 +1086,7 @@ export declare function zipWithIndex_<R, E, A>(self: Stream<R, E, A>, __tsplusTr
  * Note: tracking the latest value is done on a per-chunk basis. That means
  * that emitted elements that are not the last value in chunks will never be
  * used for zipping.
- * @tsplus fluent fncts.io.Stream zipWithLatest
+ * @tsplus pipeable fncts.io.Stream zipWithLatest
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function zipWithLatest_<R, E, A, R1, E1, B, C>(fa: Stream<R, E, A>, fb: Stream<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): Stream<R | R1, E | E1, C>;
+export declare function zipWithLatest<A, R1, E1, B, C>(fb: Stream<R1, E1, B>, f: (a: A, b: B) => C, __tsplusTrace?: string): <R, E>(fa: Stream<R, E, A>) => Stream<R1 | R, E1 | E, C>;