@fncts/io 0.0.47 → 0.0.49

package/_src/Stream/api.ts

@@ -25,6 +25,34 @@ export function absolve<R, E, E2, A>(self: Stream<R, E, Either<E2, A>>, __tsplus
   return self.mapIO((either) => IO.fromEither(either));
 }
 
+/**
+ * Creates a stream from a single value that will get cleaned up after the
+ * stream is consumed
+ *
+ * @tsplus static fncts.io.StreamOps acquireRelease
+ */
+export 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> {
+  return Stream.scoped(IO.acquireRelease(acquire, release));
+}
+
+/**
+ * Creates a stream from a single value that will get cleaned up after the
+ * stream is consumed
+ *
+ * @tsplus static fncts.io.StreamOps acquireReleaseExit
+ */
+export 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> {
+  return Stream.scoped(IO.acquireReleaseExit(acquire, release));
+}
+
 /**
  * Aggregates elements of this stream using the provided sink for as long
  * as the downstream operators on the stream are busy.
@@ -81,13 +109,13 @@ export function aggregateAsyncWithinEither<R1, E1, A1, B, R2, C>(
 ) {
   return <R, E, A extends A1>(stream: Stream<R, E, A>): Stream<R | R1 | R2, E | E1, Either<C, B>> => {
     type LocalHandoffSignal = HandoffSignal<E | E1, A1>;
-    const deps = IO.sequenceT(
+    const deps = IO.all([
       Handoff<LocalHandoffSignal>(),
       Ref.make<SinkEndReason>(new ScheduleEnd()),
       Ref.make(Conc.empty<A1>()),
       schedule.driver,
       Ref.make(false),
-    );
+    ]);
     return Stream.fromIO(deps).flatMap(([handoff, sinkEndReason, sinkLeftovers, scheduleDriver, consumed]) => {
       const handoffProducer: Channel<never, E | E1, Conc<A1>, unknown, never, never, any> = Channel.readWithCause(
         (_in: Conc<A1>) => Channel.fromIO(handoff.offer(HandoffSignal.Emit(_in))).zipRight(handoffProducer),
@@ -192,32 +220,6 @@ export function aggregateAsyncWithinEither<R1, E1, A1, B, R2, C>(
   };
 }
 
-/**
- * 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 pipeable fncts.io.Stream zipLeft
- */
-export function zipLeft<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string) {
-  return <R, E, A>(stream: Stream<R, E, A>): Stream<R | R1, E | E1, A> => {
-    return stream.crossWith(that, (a, _) => 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 pipeable fncts.io.Stream zipRight
- */
-export function zipRight<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string) {
-  return <R, E, A>(stream: Stream<R, E, A>): Stream<R | R1, E | E1, A1> => {
-    return stream.crossWith(that, (_, b) => b);
-  };
-}
-
 /**
  * Maps the success values of this stream to the specified constant value.
  *
@@ -229,6 +231,20 @@ export function as<B>(b: Lazy<B>, __tsplusTrace?: string) {
   };
 }
 
+/**
+ * @tsplus static fncts.io.StreamOps async
+ */
+export function async<R, E, A>(
+  register: (resolve: (next: IO<R, Maybe<E>, Conc<A>>, offerCb?: (e: Exit<never, boolean>) => void) => void) => void,
+  outputBuffer = 16,
+  __tsplusTrace?: string,
+): Stream<R, E, A> {
+  return Stream.asyncMaybe((cb) => {
+    register(cb);
+    return Nothing();
+  }, outputBuffer);
+}
+
 /**
  * @tsplus static fncts.io.StreamOps asyncInterrupt
  */
@@ -273,38 +289,6 @@ export function asyncInterrupt<R, E, A>(
   );
 }
 
-/**
- * Creates a stream from an asynchronous callback that can be called multiple times.
- * The registration of the callback can possibly return the stream synchronously.
- * The optionality of the error type `E` can be used to signal the end of the stream,
- * by setting it to `None`.
- *
- * @tsplus static fncts.io.StreamOps asyncMaybe
- */
-export function asyncMaybe<R, E, A>(
-  register: (
-    resolve: (next: IO<R, Maybe<E>, Conc<A>>, offerCb?: (e: Exit<never, boolean>) => void) => void,
-  ) => Maybe<Stream<R, E, A>>,
-  outputBuffer = 16,
-  __tsplusTrace?: string,
-): Stream<R, E, A> {
-  return Stream.asyncInterrupt((k) => register(k).match(() => Either.left(IO.unit), Either.right), outputBuffer);
-}
-
-/**
- * @tsplus static fncts.io.StreamOps async
- */
-export function async<R, E, A>(
-  register: (resolve: (next: IO<R, Maybe<E>, Conc<A>>, offerCb?: (e: Exit<never, boolean>) => void) => void) => void,
-  outputBuffer = 16,
-  __tsplusTrace?: string,
-): Stream<R, E, A> {
-  return Stream.asyncMaybe((cb) => {
-    register(cb);
-    return Nothing();
-  }, outputBuffer);
-}
-
 /**
  * @tsplus static fncts.io.StreamOps asyncIO
  */
@@ -351,41 +335,31 @@ export function asyncIO<R, E, A, R1 = R, E1 = E>(
 }
 
 /**
- * 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
- */
-export function bimap<E, E1, A, A1>(f: (e: E) => E1, g: (a: A) => A1, __tsplusTrace?: string) {
-  return <R>(stream: Stream<R, E, A>): Stream<R, E1, A1> => stream.mapError(f).map(g);
-}
-
-/**
- * Creates a stream from a single value that will get cleaned up after the
- * stream is consumed
+ * Creates a stream from an asynchronous callback that can be called multiple times.
+ * The registration of the callback can possibly return the stream synchronously.
+ * The optionality of the error type `E` can be used to signal the end of the stream,
+ * by setting it to `None`.
  *
- * @tsplus static fncts.io.StreamOps acquireRelease
+ * @tsplus static fncts.io.StreamOps asyncMaybe
  */
-export function acquireRelease<R, E, A, R1>(
-  acquire: IO<R, E, A>,
-  release: (a: A) => IO<R1, never, unknown>,
+export function asyncMaybe<R, E, A>(
+  register: (
+    resolve: (next: IO<R, Maybe<E>, Conc<A>>, offerCb?: (e: Exit<never, boolean>) => void) => void,
+  ) => Maybe<Stream<R, E, A>>,
+  outputBuffer = 16,
   __tsplusTrace?: string,
-): Stream<R | R1, E, A> {
-  return Stream.scoped(IO.acquireRelease(acquire, release));
+): Stream<R, E, A> {
+  return Stream.asyncInterrupt((k) => register(k).match(() => Either.left(IO.unit), Either.right), outputBuffer);
 }
 
 /**
- * Creates a stream from a single value that will get cleaned up after the
- * stream is consumed
+ * Returns a stream whose failure and success channels have been mapped by
+ * the specified pair of functions, `f` and `g`.
  *
- * @tsplus static fncts.io.StreamOps acquireReleaseExit
+ * @tsplus pipeable fncts.io.Stream bimap
  */
-export 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> {
-  return Stream.scoped(IO.acquireReleaseExit(acquire, release));
+export function bimap<E, E1, A, A1>(f: (e: E) => E1, g: (a: A) => A1, __tsplusTrace?: string) {
+  return <R>(stream: Stream<R, E, A>): Stream<R, E1, A1> => stream.mapError(f).map(g);
 }
 
 /**
@@ -501,27 +475,19 @@ export function bufferChunks(capacity: number, __tsplusTrace?: string) {
   };
 }
 
-/**
- * Allows a faster producer to progress independently of a slower consumer by buffering
- * elements into an unbounded queue.
- *
- * @tsplus getter fncts.io.Stream bufferUnbounded
- */
-export function bufferUnbounded<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?: string): Stream<R, E, A> {
-  const queue = stream.toQueueUnbounded;
-  return new Stream(
-    Channel.unwrapScoped(
-      queue.map((queue) => {
-        const process: Channel<never, unknown, unknown, unknown, E, Conc<A>, void> = Channel.fromIO(queue.take).flatMap(
-          (take) =>
-            take.match(Channel.endNow(undefined), Channel.failCauseNow, (value) =>
-              Channel.writeNow(value).zipRight(process),
-            ),
-        );
-        return process;
-      }),
-    ),
+function bufferSignalConsumer<R, E, A>(
+  queue: Queue<readonly [Take<E, A>, Future<never, void>]>,
+  __tsplusTrace?: string,
+): Channel<R, unknown, unknown, unknown, E, Conc<A>, void> {
+  const process: Channel<never, unknown, unknown, unknown, E, Conc<A>, void> = Channel.fromIO(queue.take).flatMap(
+    ([take, promise]) =>
+      Channel.fromIO(promise.succeed(undefined)).zipRight(
+        take.match(Channel.endNow(undefined), Channel.failCauseNow, (value) =>
+          Channel.writeNow(value).zipRight(process),
+        ),
+      ),
   );
+  return process;
 }
 
 function bufferSignalProducer<E, A>(
@@ -554,19 +520,27 @@ function bufferSignalProducer<E, A>(
   );
 }
 
-function bufferSignalConsumer<R, E, A>(
-  queue: Queue<readonly [Take<E, A>, Future<never, void>]>,
-  __tsplusTrace?: string,
-): Channel<R, unknown, unknown, unknown, E, Conc<A>, void> {
-  const process: Channel<never, unknown, unknown, unknown, E, Conc<A>, void> = Channel.fromIO(queue.take).flatMap(
-    ([take, promise]) =>
-      Channel.fromIO(promise.succeed(undefined)).zipRight(
-        take.match(Channel.endNow(undefined), Channel.failCauseNow, (value) =>
-          Channel.writeNow(value).zipRight(process),
-        ),
-      ),
+/**
+ * Allows a faster producer to progress independently of a slower consumer by buffering
+ * elements into an unbounded queue.
+ *
+ * @tsplus getter fncts.io.Stream bufferUnbounded
+ */
+export function bufferUnbounded<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?: string): Stream<R, E, A> {
+  const queue = stream.toQueueUnbounded;
+  return new Stream(
+    Channel.unwrapScoped(
+      queue.map((queue) => {
+        const process: Channel<never, unknown, unknown, unknown, E, Conc<A>, void> = Channel.fromIO(queue.take).flatMap(
+          (take) =>
+            take.match(Channel.endNow(undefined), Channel.failCauseNow, (value) =>
+              Channel.writeNow(value).zipRight(process),
+            ),
+        );
+        return process;
+      }),
+    ),
   );
-  return process;
 }
 
 /**
@@ -623,25 +597,38 @@ export function catchJustCause<R1, E, E1, A1>(pf: (e: Cause<E>) => Maybe<Stream<
 }
 
 /**
- * Returns a stream made of the concatenation in strict order of all the streams
- * produced by passing each element of this stream to `f`
+ * 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 pipeable fncts.io.Stream flatMap
+ * @tsplus pipeable fncts.io.Stream changesWith
  */
-export function flatMap<A, R1, E1, B>(f: (a: A) => Stream<R1, E1, B>, __tsplusTrace?: string) {
-  return <R, E>(stream: Stream<R, E, A>): Stream<R | R1, E | E1, B> => {
-    return new Stream(
-      stream.channel.concatMap((as) =>
-        as
-          .map((a) => f(a).channel)
-          .foldLeft(Channel.unit as Channel<R1, unknown, unknown, unknown, E1, Conc<B>, unknown>, (s, a) =>
-            s.flatMap(() => a),
-          ),
-      ),
-    );
+export function changesWith<A>(f: (x: A, y: A) => boolean, __tsplusTrace?: string) {
+  return <R, E>(stream: Stream<R, E, A>): Stream<R, E, A> => {
+    return new Stream(stream.channel.pipeTo(changesWithWriter<R, E, A>(f, Nothing())));
   };
 }
 
+function changesWithWriter<R, E, A>(
+  f: (x: A, y: A) => boolean,
+  last: Maybe<A>,
+  __tsplusTrace?: string,
+): Channel<R, E, Conc<A>, unknown, E, Conc<A>, void> {
+  return Channel.readWithCause(
+    (chunk: Conc<A>) => {
+      const [newLast, newChunk] = chunk.foldLeft([last, Conc.empty<A>()], ([maybeLast, os], o1) =>
+        maybeLast.match(
+          () => [Just(o1), os.append(o1)],
+          (o) => (f(o, o1) ? [Just(o1), os] : [Just(o1), os.append(o1)]),
+        ),
+      );
+      return Channel.writeNow(newChunk).zipRight(changesWithWriter(f, newLast));
+    },
+    Channel.failCauseNow,
+    () => Channel.unit,
+  );
+}
+
 /**
  * Exposes the underlying chunks of the stream as a stream of chunks of elements
  *
@@ -666,39 +653,6 @@ export function chunksWith<R, E, A, R1, E1, B>(
   };
 }
 
-function changesWithWriter<R, E, A>(
-  f: (x: A, y: A) => boolean,
-  last: Maybe<A>,
-  __tsplusTrace?: string,
-): Channel<R, E, Conc<A>, unknown, E, Conc<A>, void> {
-  return Channel.readWithCause(
-    (chunk: Conc<A>) => {
-      const [newLast, newChunk] = chunk.foldLeft([last, Conc.empty<A>()], ([maybeLast, os], o1) =>
-        maybeLast.match(
-          () => [Just(o1), os.append(o1)],
-          (o) => (f(o, o1) ? [Just(o1), os] : [Just(o1), os.append(o1)]),
-        ),
-      );
-      return Channel.writeNow(newChunk).zipRight(changesWithWriter(f, newLast));
-    },
-    Channel.failCauseNow,
-    () => Channel.unit,
-  );
-}
-
-/**
- * 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 pipeable fncts.io.Stream changesWith
- */
-export function changesWith<A>(f: (x: A, y: A) => boolean, __tsplusTrace?: string) {
-  return <R, E>(stream: Stream<R, E, A>): Stream<R, E, A> => {
-    return new Stream(stream.channel.pipeTo(changesWithWriter<R, E, A>(f, Nothing())));
-  };
-}
-
 /**
  * Transforms all elements of the stream for as long as the specified partial function is defined.
  *
@@ -755,20 +709,6 @@ function collectWhileIOLoop<R, E, A, R1, E1, B>(
   }
 }
 
-function combineProducer<Err, Elem>(
-  handoff: Handoff<Exit<Maybe<Err>, Elem>>,
-  latch: Handoff<void>,
-  __tsplusTrace?: string,
-): Channel<never, Err, Elem, unknown, never, never, any> {
-  return Channel.fromIO(latch.take).zipRight(
-    Channel.readWithCause(
-      (value) => Channel.fromIO(handoff.offer(Exit.succeed(value))).zipRight(combineProducer(handoff, latch)),
-      (cause) => Channel.fromIO(handoff.offer(Exit.failCause(cause.map(Maybe.just)))),
-      () => Channel.fromIO(handoff.offer(Exit.fail(Nothing()))).zipRight(combineProducer(handoff, latch)),
-    ),
-  );
-}
-
 /**
  * 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"
@@ -811,21 +751,6 @@ export function combine<R, E, A, R1, E1, A1, S, R2, A2>(
   };
 }
 
-function combineChunksProducer<Err, Elem>(
-  handoff: Handoff<Take<Err, Elem>>,
-  latch: Handoff<void>,
-  __tsplusTrace?: string,
-): Channel<never, Err, Conc<Elem>, unknown, never, never, any> {
-  return Channel.fromIO(latch.take).zipRight(
-    Channel.readWithCause(
-      (chunk: Conc<Elem>) =>
-        Channel.fromIO(handoff.offer(Take.chunk(chunk))).zipRight(combineChunksProducer(handoff, latch)),
-      (cause) => Channel.fromIO(handoff.offer(Take.failCause(cause))),
-      () => Channel.fromIO(handoff.offer(Take.end)),
-    ),
-  );
-}
-
 /**
  * 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"
@@ -872,6 +797,35 @@ export function combineChunks<R, E, A, R1, E1, A1, S, R2, A2>(
   };
 }
 
+function combineChunksProducer<Err, Elem>(
+  handoff: Handoff<Take<Err, Elem>>,
+  latch: Handoff<void>,
+  __tsplusTrace?: string,
+): Channel<never, Err, Conc<Elem>, unknown, never, never, any> {
+  return Channel.fromIO(latch.take).zipRight(
+    Channel.readWithCause(
+      (chunk: Conc<Elem>) =>
+        Channel.fromIO(handoff.offer(Take.chunk(chunk))).zipRight(combineChunksProducer(handoff, latch)),
+      (cause) => Channel.fromIO(handoff.offer(Take.failCause(cause))),
+      () => Channel.fromIO(handoff.offer(Take.end)),
+    ),
+  );
+}
+
+function combineProducer<Err, Elem>(
+  handoff: Handoff<Exit<Maybe<Err>, Elem>>,
+  latch: Handoff<void>,
+  __tsplusTrace?: string,
+): Channel<never, Err, Elem, unknown, never, never, any> {
+  return Channel.fromIO(latch.take).zipRight(
+    Channel.readWithCause(
+      (value) => Channel.fromIO(handoff.offer(Exit.succeed(value))).zipRight(combineProducer(handoff, latch)),
+      (cause) => Channel.fromIO(handoff.offer(Exit.failCause(cause.map(Maybe.just)))),
+      () => Channel.fromIO(handoff.offer(Exit.fail(Nothing()))).zipRight(combineProducer(handoff, latch)),
+    ),
+  );
+}
+
 /**
  * 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.
@@ -884,6 +838,18 @@ export function concat<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: str
   };
 }
 
+/**
+ * Provides some of the environment required to run this effect,
+ * leaving the remainder `R0`.
+ *
+ * @tsplus pipeable fncts.io.Stream contramapEnvironment
+ */
+export function contramapEnvironment<R, R0>(f: (r0: Environment<R0>) => Environment<R>, __tsplusTrace?: string) {
+  return <E, A>(ra: Stream<R, E, A>): Stream<R0, E, A> => {
+    return Stream.environment<R0>().flatMap((r0) => ra.provideEnvironment(f(r0)));
+  };
+}
+
 /**
  * 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.
@@ -911,18 +877,6 @@ export function crossWith<A, R1, E1, B, C>(fb: Stream<R1, E1, B>, f: (a: A, b: B
   };
 }
 
-/**
- * Provides some of the environment required to run this effect,
- * leaving the remainder `R0`.
- *
- * @tsplus pipeable fncts.io.Stream contramapEnvironment
- */
-export function contramapEnvironment<R, R0>(f: (r0: Environment<R0>) => Environment<R>, __tsplusTrace?: string) {
-  return <E, A>(ra: Stream<R, E, A>): Stream<R0, E, A> => {
-    return Stream.environment<R0>().flatMap((r0) => ra.provideEnvironment(f(r0)));
-  };
-}
-
 /**
  * @tsplus pipeable fncts.io.Stream debounce
  */
@@ -933,7 +887,7 @@ export function debounce(duration: Lazy<Duration>, __tsplusTrace?: string) {
         Do((Δ) => {
           const handoff = Δ(Handoff<HandoffSignal<E, A>>());
           function enqueue(last: Conc<A>, __tsplusTrace?: string) {
-            return grafter(Clock.sleep(duration).as(last).fork).map((f) => consumer(DebounceState.Previous(f)));
+            return grafter.graft(Clock.sleep(duration).as(last).fork).map((f) => consumer(DebounceState.Previous(f)));
           }
           const producer: Channel<R, E, Conc<A>, unknown, E, never, unknown> = Channel.readWithCause(
             (inp: Conc<A>) =>
@@ -999,10 +953,14 @@ export function debounce(duration: Lazy<Duration>, __tsplusTrace?: string) {
 }
 
 /**
- * @tsplus static fncts.io.StreamOps defer
+ * Switches to the provided stream in case this one is empty.
+ *
+ * @tsplus pipeable fncts.io.Stream defaultIfEmpty
  */
-export function defer<R, E, A>(self: Lazy<Stream<R, E, A>>): Stream<R, E, A> {
-  return new Stream(Channel.defer(self().channel));
+export function defaultIfEmpty<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E, A>(fa: Stream<R, E, A>): Stream<R | R1, E | E1, A | B> => {
+    return new Stream(fa.channel.pipeTo(defaultIfEmptyWriter(fb)));
+  };
 }
 
 function defaultIfEmptyWriter<R, E, A, R1, E1, B>(
@@ -1018,14 +976,10 @@ function defaultIfEmptyWriter<R, E, A, R1, E1, B>(
 }
 
 /**
- * Switches to the provided stream in case this one is empty.
- *
- * @tsplus pipeable fncts.io.Stream defaultIfEmpty
+ * @tsplus static fncts.io.StreamOps defer
  */
-export function defaultIfEmpty<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplusTrace?: string) {
-  return <R, E, A>(fa: Stream<R, E, A>): Stream<R | R1, E | E1, A | B> => {
-    return new Stream(fa.channel.pipeTo(defaultIfEmptyWriter(fb)));
-  };
+export function defer<R, E, A>(self: Lazy<Stream<R, E, A>>): Stream<R, E, A> {
+  return new Stream(Channel.defer(self().channel));
 }
 
 /**
@@ -1167,6 +1121,17 @@ export function drain<R, E, A>(fa: Stream<R, E, A>, __tsplusTrace?: string): Str
   return new Stream(fa.channel.drain);
 }
 
+/**
+ * Drops the specified number of elements from this stream.
+ *
+ * @tsplus pipeable fncts.io.Stream drop
+ */
+export function drop(n: number, __tsplusTrace?: string) {
+  return <R, E, A>(stream: Stream<R, E, A>): Stream<R, E, A> => {
+    return new Stream(stream.channel.pipeTo(dropLoop(n)));
+  };
+}
+
 function dropLoop<R, E, A>(r: number, __tsplusTrace?: string): Channel<R, E, Conc<A>, unknown, E, Conc<A>, unknown> {
   return Channel.readWith(
     (inp: Conc<A>) => {
@@ -1181,13 +1146,14 @@ function dropLoop<R, E, A>(r: number, __tsplusTrace?: string): Channel<R, E, Con
 }
 
 /**
- * Drops the specified number of elements from this stream.
+ * Drops all elements of the stream until the specified predicate evaluates
+ * to `true`.
  *
- * @tsplus pipeable fncts.io.Stream drop
+ * @tsplus pipeable fncts.io.Stream dropUntil
  */
-export function drop(n: number, __tsplusTrace?: string) {
-  return <R, E, A>(stream: Stream<R, E, A>): Stream<R, E, A> => {
-    return new Stream(stream.channel.pipeTo(dropLoop(n)));
+export function dropUntil<A>(p: Predicate<A>, __tsplusTrace?: string) {
+  return <R, E>(stream: Stream<R, E, A>): Stream<R, E, A> => {
+    return stream.dropWhile(p.invert).drop(1);
   };
 }
 
@@ -1203,18 +1169,6 @@ export function dropWhile<A>(p: Predicate<A>, __tsplusTrace?: string) {
   };
 }
 
-/**
- * Drops all elements of the stream until the specified predicate evaluates
- * to `true`.
- *
- * @tsplus pipeable fncts.io.Stream dropUntil
- */
-export function dropUntil<A>(p: Predicate<A>, __tsplusTrace?: string) {
-  return <R, E>(stream: Stream<R, E, A>): Stream<R, E, A> => {
-    return stream.dropWhile(p.invert).drop(1);
-  };
-}
-
 /**
  * Returns a stream whose failures and successes have been lifted into an
  * `Either`. The resulting stream cannot fail, because the failures have
@@ -1228,11 +1182,76 @@ export function either<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?: string)
   return stream.map(Either.right).catchAll((e) => Stream.succeedNow(Either.left(e)));
 }
 
+/**
+ * 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 pipeable fncts.io.Stream flatMap
+ */
+export function flatMap<A, R1, E1, B>(f: (a: A) => Stream<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E>(stream: Stream<R, E, A>): Stream<R | R1, E | E1, B> => {
+    return new Stream(
+      stream.channel.concatMap((as) =>
+        as
+          .map((a) => f(a).channel)
+          .foldLeft(Channel.unit as Channel<R1, unknown, unknown, unknown, E1, Conc<B>, unknown>, (s, a) =>
+            s.flatMap(() => a),
+          ),
+      ),
+    );
+  };
+}
+
+/**
+ * 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 pipeable fncts.io.Stream zipLeft
+ */
+export function zipLeft<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string) {
+  return <R, E, A>(stream: Stream<R, E, A>): Stream<R | R1, E | E1, A> => {
+    return stream.crossWith(that, (a, _) => 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 pipeable fncts.io.Stream zipRight
+ */
+export function zipRight<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string) {
+  return <R, E, A>(stream: Stream<R, E, A>): Stream<R | R1, E | E1, A1> => {
+    return stream.crossWith(that, (_, b) => b);
+  };
+}
+
 /**
  * @tsplus static fncts.io.StreamOps empty
  */
 export const empty: Stream<never, never, never> = Stream.fromChunkNow(Conc.empty<never>());
 
+export type TerminationStrategy = "Left" | "Right" | "Both" | "Either";
+
+/**
+ * Halts the evaluation of this stream when the provided IO completes. The given IO
+ * will be forked as part of the returned stream, and its success will be discarded.
+ *
+ * An element in the process of being pulled will not be interrupted when the IO
+ * completes. See `interruptWhen` for this behavior.
+ *
+ * If the IO completes with a failure, the stream will emit that failure.
+ *
+ * @tsplus pipeable fncts.io.Stream endWhen
+ */
+export function endWhen<R1, E1>(io: IO<R1, E1, any>, __tsplusTrace?: string) {
+  return <R, E, A>(stream: Stream<R, E, A>): Stream<R | R1, E | E1, A> => {
+    return new Stream(Channel.unwrapScoped(io.forkScoped.map((fiber) => stream.channel.pipeTo(endWhenWriter(fiber)))));
+  };
+}
+
 function endWhenWriter<E, A, E1>(
   fiber: Fiber<E1, any>,
   __tsplusTrace?: string,
@@ -1252,23 +1271,6 @@ function endWhenWriter<E, A, E1>(
   );
 }
 
-/**
- * Halts the evaluation of this stream when the provided IO completes. The given IO
- * will be forked as part of the returned stream, and its success will be discarded.
- *
- * An element in the process of being pulled will not be interrupted when the IO
- * completes. See `interruptWhen` for this behavior.
- *
- * If the IO completes with a failure, the stream will emit that failure.
- *
- * @tsplus pipeable fncts.io.Stream endWhen
- */
-export function endWhen<R1, E1>(io: IO<R1, E1, any>, __tsplusTrace?: string) {
-  return <R, E, A>(stream: Stream<R, E, A>): Stream<R | R1, E | E1, A> => {
-    return new Stream(Channel.unwrapScoped(io.forkScoped.map((fiber) => stream.channel.pipeTo(endWhenWriter(fiber)))));
-  };
-}
-
 /**
  * @tsplus pipeable fncts.io.Stream ensuring
  */
@@ -1327,15 +1329,6 @@ export function execute<R, E>(io: IO<R, E, any>, __tsplusTrace?: string): Stream
   return Stream.fromIO(io).drain;
 }
 
-/**
- * Halt a stream with the specified error
- *
- * @tsplus static fncts.io.StreamOps failNow
- */
-export function failNow<E>(error: E, __tsplusTrace?: string): Stream<never, E, never> {
-  return new Stream(Channel.failNow(error));
-}
-
 /**
  * Halt a stream with the specified error
  *
@@ -1348,26 +1341,35 @@ export function fail<E>(error: Lazy<E>, __tsplusTrace?: string): Stream<never, E
 /**
  * The stream that always halts with `cause`.
  *
- * @tsplus static fncts.io.StreamOps failCauseNow
+ * @tsplus static fncts.io.StreamOps failCause
  */
-export function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Stream<never, E, never> {
-  return Stream.fromIO(IO.failCauseNow(cause));
+export function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Stream<never, E, never> {
+  return Stream.fromIO(IO.failCause(cause));
 }
 
 /**
  * The stream that always halts with `cause`.
  *
- * @tsplus static fncts.io.StreamOps failCause
+ * @tsplus static fncts.io.StreamOps failCauseNow
  */
-export function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Stream<never, E, never> {
-  return Stream.fromIO(IO.failCause(cause));
+export function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Stream<never, E, never> {
+  return Stream.fromIO(IO.failCauseNow(cause));
+}
+/**
+ * Halt a stream with the specified error
+ *
+ * @tsplus static fncts.io.StreamOps failNow
+ */
+export function failNow<E>(error: E, __tsplusTrace?: string): Stream<never, E, never> {
+  return new Stream(Channel.failNow(error));
 }
-
 /**
  * @tsplus pipeable fncts.io.Stream filter
  */
 export function filter<A, B extends A>(refinement: Refinement<A, B>): <R, E>(fa: Stream<R, E, A>) => Stream<R, E, B>;
+
 export function filter<A>(predicate: Predicate<A>): <R, E>(fa: Stream<R, E, A>) => Stream<R, E, A>;
+
 export function filter<A>(predicate: Predicate<A>, __tsplusTrace?: string) {
   return <R, E>(fa: Stream<R, E, A>): Stream<R, E, A> => {
     return fa.mapChunks((chunk) => chunk.filter(predicate));
@@ -1507,6 +1509,16 @@ export function flatten<R, E, R1, E1, A>(
   return self.flatMap(identity);
 }
 
+/**
+ * Submerges the chunks carried by this stream into the stream's structure, while
+ * still preserving them.
+ *
+ * @tsplus getter fncts.io.Stream flattenChunks
+ */
+export function flattenChunks<R, E, A>(stream: Stream<R, E, Conc<A>>, __tsplusTrace?: string): Stream<R, E, A> {
+  return new Stream(stream.channel.mapOut((c) => c.flatten));
+}
+
 /**
  * Unwraps `Exit` values that also signify end-of-stream by failing with `None`.
  *
@@ -1553,16 +1565,6 @@ export function flattenTake<R, E, E1, A>(
   return stream.map((take) => take.exit).flattenExitOption.flattenChunks;
 }
 
-/**
- * Submerges the chunks carried by this stream into the stream's structure, while
- * still preserving them.
- *
- * @tsplus getter fncts.io.Stream flattenChunks
- */
-export function flattenChunks<R, E, A>(stream: Stream<R, E, Conc<A>>, __tsplusTrace?: string): Stream<R, E, A> {
-  return new Stream(stream.channel.mapOut((c) => c.flatten));
-}
-
 /**
  * Repeats this stream forever.
  *
@@ -1573,12 +1575,27 @@ export function forever<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?: string
 }
 
 /**
- * Creates a stream from a `Chunk` of values
- *
- * @tsplus static fncts.io.StreamOps fromChunkNow
+ * @tsplus static fncts.io.StreamOps fromAsyncIterable
  */
-export function fromChunkNow<O>(c: Conc<O>, __tsplusTrace?: string): Stream<never, never, O> {
-  return new Stream(Channel.defer(() => (c.isEmpty ? Channel.unit : Channel.writeNow(c))));
+export function fromAsyncIterable<A>(iterable: AsyncIterable<A>, __tsplusTrace?: string): Stream<unknown, never, A> {
+  return new Stream(fromAsyncIterableLoop(iterable[Symbol.asyncIterator]()));
+}
+
+function fromAsyncIterableLoop<A>(
+  iterator: AsyncIterator<A>,
+  __tsplusTrace?: string,
+): Channel<unknown, unknown, unknown, unknown, never, Conc<A>, unknown> {
+  return Channel.unwrap(
+    IO.async<unknown, never, Channel<unknown, unknown, unknown, unknown, never, Conc<A>, unknown>>((k) => {
+      iterator
+        .next()
+        .then((result) =>
+          result.done
+            ? k(IO.succeedNow(Channel.end(undefined)))
+            : k(IO.succeedNow(Channel.writeNow(Conc.single(result.value)).zipRight(fromAsyncIterableLoop(iterator)))),
+        );
+    }),
+  );
 }
 
 /**
@@ -1591,91 +1608,34 @@ export function fromChunk<O>(c: Lazy<Conc<O>>, __tsplusTrace?: string): Stream<n
 }
 
 /**
- * @tsplus static fncts.io.StreamOps fromReadableStream
+ * Creates a stream from a `Chunk` of values
+ *
+ * @tsplus static fncts.io.StreamOps fromChunkNow
  */
-export function fromReadableStream<A, E>(
-  evaluate: Lazy<ReadableStream<A>>,
-  onError: (error: unknown) => E,
-): Stream<never, E, A> {
-  return Stream.unwrapScoped(
-    IO(evaluate().getReader())
-      .acquireRelease((reader) => IO.fromPromiseHalt(reader.cancel()))
-      .map((reader) =>
-        Stream.repeatIOMaybe(
-          IO.fromPromiseCatch(reader.read(), (reason) => Just(onError(reason))).flatMap(({ done, value }) =>
-            done ? IO.failNow(Nothing()) : IO.succeedNow(value),
-          ),
-        ),
-      ),
-  );
+export function fromChunkNow<O>(c: Conc<O>, __tsplusTrace?: string): Stream<never, never, O> {
+  return new Stream(Channel.defer(() => (c.isEmpty ? Channel.unit : Channel.writeNow(c))));
 }
 
 /**
- * Creates a single-valued stream from a managed resource
- *
- * @tsplus static fncts.io.StreamOps scoped
+ * @tsplus static fncts.io.StreamOps fromHub
  */
-export function scoped<R, E, A>(stream: Lazy<IO<R, E, A>>, __tsplusTrace?: string): Stream<Exclude<R, Scope>, E, A> {
-  return new Stream(Channel.scoped(stream().map(Conc.single)));
+export function fromHub<A>(
+  hub: Lazy<Hub<A>>,
+  maxChunkSize = DEFAULT_CHUNK_SIZE,
+  __tsplusTrace?: string,
+): Stream<never, never, A> {
+  return Stream.scoped(hub().subscribe).flatMap((queue) => Stream.fromQueueWithShutdown(queue, maxChunkSize));
 }
 
 /**
- * Emits a sliding window of n elements.
- *
- * @tsplus pipeable fncts.io.Stream sliding
+ * @tsplus static fncts.io.StreamOps fromHubScoped
  */
-export function sliding(chunkSize: number, stepSize: number, __tsplusTrace?: string) {
-  return <R, E, A>(self: Stream<R, E, A>): Stream<R, E, Conc<A>> => {
-    return Stream.defer(() => {
-      function slidingChunk(chunk: Conc<A>, input: Conc<A>): [Conc<A>, Conc<Conc<A>>] {
-        const updatedChunk = chunk.concat(input);
-        const length       = updatedChunk.length;
-        if (length >= chunkSize) {
-          const array    = new Array<Conc<A>>((length - chunkSize) / stepSize + 1);
-          let arrayIndex = 0;
-          let chunkIndex = 0;
-          while (chunkIndex + chunkSize <= length) {
-            array[arrayIndex] = updatedChunk.slice(chunkIndex, chunkIndex + chunkSize);
-            arrayIndex       += 1;
-            chunkIndex       += stepSize;
-          }
-          return [updatedChunk.drop(chunkIndex), Conc.fromArray(array)];
-        } else {
-          return [updatedChunk, Conc.empty()];
-        }
-      }
-      function sliding(chunk: Conc<A>, written: boolean): Channel<never, E, Conc<A>, any, E, Conc<Conc<A>>, any> {
-        return Channel.readWithCause(
-          (input) => {
-            const [updatedChunk, out] = slidingChunk(chunk, input);
-            if (out.isEmpty) {
-              return sliding(updatedChunk, written);
-            } else {
-              return Channel.writeNow(out) > sliding(updatedChunk, true);
-            }
-          },
-          (err) => {
-            const index = written && chunkSize > stepSize ? chunkSize - stepSize : 0;
-            if (index >= chunk.length) {
-              return Channel.failCauseNow(err);
-            } else {
-              return Channel.writeNow(Conc.single(chunk)) > Channel.failCauseNow(err);
-            }
-          },
-          (done) => {
-            const index = written && chunkSize > stepSize ? chunkSize - stepSize : 0;
-            if (index >= chunk.length) {
-              return Channel.succeedNow(done);
-            } else {
-              return Channel.writeNow(Conc.single(chunk)) > Channel.succeedNow(done);
-            }
-          },
-        );
-      }
-
-      return new Stream(self.channel >>> sliding(Conc.empty(), false));
-    });
-  };
+export function fromHubScoped<A>(
+  hub: Lazy<Hub<A>>,
+  maxChunkSize = DEFAULT_CHUNK_SIZE,
+  __tsplusTrace?: string,
+): IO<Scope, never, Stream<never, never, A>> {
+  return IO.defer(hub().subscribe.map((queue) => Stream.fromQueueWithShutdown(queue, maxChunkSize)));
 }
 
 /**
@@ -1703,30 +1663,6 @@ export function fromIOMaybe<R, E, A>(fa: IO<R, Maybe<E>, A>, __tsplusTrace?: str
   );
 }
 
-function fromAsyncIterableLoop<A>(
-  iterator: AsyncIterator<A>,
-  __tsplusTrace?: string,
-): Channel<unknown, unknown, unknown, unknown, never, Conc<A>, unknown> {
-  return Channel.unwrap(
-    IO.async<unknown, never, Channel<unknown, unknown, unknown, unknown, never, Conc<A>, unknown>>((k) => {
-      iterator
-        .next()
-        .then((result) =>
-          result.done
-            ? k(IO.succeedNow(Channel.end(undefined)))
-            : k(IO.succeedNow(Channel.writeNow(Conc.single(result.value)).zipRight(fromAsyncIterableLoop(iterator)))),
-        );
-    }),
-  );
-}
-
-/**
- * @tsplus static fncts.io.StreamOps fromAsyncIterable
- */
-export function fromAsyncIterable<A>(iterable: AsyncIterable<A>, __tsplusTrace?: string): Stream<unknown, never, A> {
-  return new Stream(fromAsyncIterableLoop(iterable[Symbol.asyncIterator]()));
-}
-
 /**
  * @tsplus static fncts.io.StreamOps fromIterable
  */
@@ -1833,64 +1769,43 @@ export function fromQueueWithShutdown<RA, RB, EA, EB, A, B>(
 }
 
 /**
- * @tsplus static fncts.io.StreamOps fromHub
- */
-export function fromHub<A>(
-  hub: Lazy<Hub<A>>,
-  maxChunkSize = DEFAULT_CHUNK_SIZE,
-  __tsplusTrace?: string,
-): Stream<never, never, A> {
-  return Stream.scoped(hub().subscribe).flatMap((queue) => Stream.fromQueueWithShutdown(queue, maxChunkSize));
-}
-
-/**
- * @tsplus static fncts.io.StreamOps fromHubScoped
+ * @tsplus static fncts.io.StreamOps fromReadableStream
  */
-export function fromHubScoped<A>(
-  hub: Lazy<Hub<A>>,
-  maxChunkSize = DEFAULT_CHUNK_SIZE,
-  __tsplusTrace?: string,
-): IO<Scope, never, Stream<never, never, A>> {
-  return IO.defer(hub().subscribe.map((queue) => Stream.fromQueueWithShutdown(queue, maxChunkSize)));
+export function fromReadableStream<A, E>(
+  evaluate: Lazy<ReadableStream<A>>,
+  onError: (error: unknown) => E,
+): Stream<never, E, A> {
+  return Stream.unwrapScoped(
+    IO(evaluate().getReader())
+      .acquireRelease((reader) => IO.fromPromiseHalt(reader.cancel()))
+      .map((reader) =>
+        Stream.repeatIOMaybe(
+          IO.fromPromiseCatch(reader.read(), (reason) => Just(onError(reason))).flatMap(({ done, value }) =>
+            done ? IO.failNow(Nothing()) : IO.succeedNow(value),
+          ),
+        ),
+      ),
+  );
 }
 
 /**
  * Halt a stream with the specified exception
  *
- * @tsplus static fncts.io.StreamOps haltNow
+ * @tsplus static fncts.io.StreamOps halt
  */
-export function haltNow(u: unknown, __tsplusTrace?: string): Stream<never, never, never> {
+export function halt(u: Lazy<unknown>, __tsplusTrace?: string): Stream<never, never, never> {
   return new Stream(Channel.halt(u));
 }
 
 /**
  * Halt a stream with the specified exception
  *
- * @tsplus static fncts.io.StreamOps halt
+ * @tsplus static fncts.io.StreamOps haltNow
  */
-export function halt(u: Lazy<unknown>, __tsplusTrace?: string): Stream<never, never, never> {
+export function haltNow(u: unknown, __tsplusTrace?: string): Stream<never, never, never> {
   return new Stream(Channel.halt(u));
 }
 
-function haltWhenWriter<E, A, E1>(
-  fiber: Fiber<E1, any>,
-  __tsplusTrace?: string,
-): Channel<never, E | E1, Conc<A>, unknown, E | E1, Conc<A>, void> {
-  return Channel.unwrap(
-    fiber.poll.map((maybeExit) =>
-      maybeExit.match(
-        () =>
-          Channel.readWith(
-            (i: Conc<A>) => Channel.writeNow(i).zipRight(haltWhenWriter<E, A, E1>(fiber)),
-            Channel.failNow,
-            () => Channel.unit,
-          ),
-        (exit) => exit.match(Channel.failCauseNow, () => Channel.unit),
-      ),
-    ),
-  );
-}
-
 /**
  * Halts the evaluation of this stream when the provided IO completes. The
  * given IO will be forked as part of the returned stream, and its success
@@ -1909,6 +1824,19 @@ export function haltWhen<R1, E1>(io: IO<R1, E1, any>, __tsplusTrace?: string) {
   };
 }
 
+/**
+ * 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 pipeable fncts.io.Stream haltWhen
+ */
+export function haltWhenFuture<E1>(future: Future<E1, any>, __tsplusTrace?: string) {
+  return <R, E, A>(fa: Stream<R, E, A>): Stream<R, E | E1, A> => {
+    return new Stream(fa.channel.pipeTo(haltWhenFutureWriter(future)));
+  };
+}
+
 function haltWhenFutureWriter<R, E, A, E1>(
   future: Future<E1, unknown>,
   __tsplusTrace?: string,
@@ -1928,17 +1856,23 @@ function haltWhenFutureWriter<R, E, A, E1>(
   );
 }
 
-/**
- * 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 pipeable fncts.io.Stream haltWhen
- */
-export function haltWhenFuture<E1>(future: Future<E1, any>, __tsplusTrace?: string) {
-  return <R, E, A>(fa: Stream<R, E, A>): Stream<R, E | E1, A> => {
-    return new Stream(fa.channel.pipeTo(haltWhenFutureWriter(future)));
-  };
+function haltWhenWriter<E, A, E1>(
+  fiber: Fiber<E1, any>,
+  __tsplusTrace?: string,
+): Channel<never, E | E1, Conc<A>, unknown, E | E1, Conc<A>, void> {
+  return Channel.unwrap(
+    fiber.poll.map((maybeExit) =>
+      maybeExit.match(
+        () =>
+          Channel.readWith(
+            (i: Conc<A>) => Channel.writeNow(i).zipRight(haltWhenWriter<E, A, E1>(fiber)),
+            Channel.failNow,
+            () => Channel.unit,
+          ),
+        (exit) => exit.match(Channel.failCauseNow, () => Channel.unit),
+      ),
+    ),
+  );
 }
 
 /**
@@ -1950,17 +1884,6 @@ export function interleave<R1, E1, B>(sb: Stream<R1, E1, B>, __tsplusTrace?: str
   };
 }
 
-function interleaveWithProducer<E, A>(
-  handoff: Handoff<Take<E, A>>,
-  __tsplusTrace?: string,
-): Channel<never, E, A, unknown, never, never, void> {
-  return Channel.readWithCause(
-    (value: A) => Channel.fromIO(handoff.offer(Take.single(value))).zipRight(interleaveWithProducer(handoff)),
-    (cause) => Channel.fromIO(handoff.offer(Take.failCause(cause))),
-    () => Channel.fromIO(handoff.offer(Take.end)),
-  );
-}
-
 /**
  * Combines this stream and the specified stream deterministically using the
  * stream of boolean values `b` to control which stream to pull from next.
@@ -2018,6 +1941,53 @@ export function interleaveWith<R1, E1, B, R2, E2>(
   };
 }
 
+function interleaveWithProducer<E, A>(
+  handoff: Handoff<Take<E, A>>,
+  __tsplusTrace?: string,
+): Channel<never, E, A, unknown, never, never, void> {
+  return Channel.readWithCause(
+    (value: A) => Channel.fromIO(handoff.offer(Take.single(value))).zipRight(interleaveWithProducer(handoff)),
+    (cause) => Channel.fromIO(handoff.offer(Take.failCause(cause))),
+    () => Channel.fromIO(handoff.offer(Take.end)),
+  );
+}
+
+/**
+ * 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
+ * combinator will also interrupt any in-progress element being pulled from upstream.
+ *
+ * If the IO completes with a failure before the stream completes, the returned stream
+ * will emit that failure.
+ *
+ * @tsplus pipeable fncts.io.Stream interruptWhen
+ */
+export function interruptWhen<R1, E1>(io: IO<R1, E1, any>, __tsplusTrace?: string) {
+  return <R, E, A>(stream: Stream<R, E, A>): Stream<R | R1, E | E1, A> => {
+    return new Stream(stream.channel.interruptWhen(io));
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.io.Stream interruptWhen
+ */
+export function interruptWhenFuture<E1>(future: Future<E1, unknown>, __tsplusTrace?: string) {
+  return <R, E, A>(fa: Stream<R, E, A>): Stream<R, E | E1, A> => {
+    return new Stream(fa.channel.interruptWhen(future));
+  };
+}
+
+/**
+ * Intersperse stream with provided element
+ */
+export function intersperse<R, E, A, A1>(
+  stream: Stream<R, E, A>,
+  middle: A1,
+  __tsplusTrace?: string,
+): Stream<R, E, A | A1> {
+  return new Stream(stream.channel.pipeTo(intersperseWriter(middle, true)));
+}
+
 function intersperseWriter<R, E, A, A1>(
   middle: A1,
   isFirst: boolean,
@@ -2044,49 +2014,24 @@ function intersperseWriter<R, E, A, A1>(
 }
 
 /**
- * Intersperse stream with provided element
- */
-export function intersperse<R, E, A, A1>(
-  stream: Stream<R, E, A>,
-  middle: A1,
-  __tsplusTrace?: string,
-): Stream<R, E, A | A1> {
-  return new Stream(stream.channel.pipeTo(intersperseWriter(middle, true)));
-}
-
-/**
- * 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
- * combinator will also interrupt any in-progress element being pulled from upstream.
- *
- * If the IO completes with a failure before the stream completes, the returned stream
- * will emit that failure.
+ * Transforms the elements of this stream using the supplied function.
  *
- * @tsplus pipeable fncts.io.Stream interruptWhen
- */
-export function interruptWhen<R1, E1>(io: IO<R1, E1, any>, __tsplusTrace?: string) {
-  return <R, E, A>(stream: Stream<R, E, A>): Stream<R | R1, E | E1, A> => {
-    return new Stream(stream.channel.interruptWhen(io));
-  };
-}
-
-/**
- * @tsplus pipeable fncts.io.Stream interruptWhen
+ * @tsplus pipeable fncts.io.Stream map
  */
-export function interruptWhenFuture<E1>(future: Future<E1, unknown>, __tsplusTrace?: string) {
-  return <R, E, A>(fa: Stream<R, E, A>): Stream<R, E | E1, A> => {
-    return new Stream(fa.channel.interruptWhen(future));
+export function map<A, B>(f: (o: A) => B, __tsplusTrace?: string) {
+  return <R, E>(stream: Stream<R, E, A>): Stream<R, E, B> => {
+    return new Stream(stream.channel.mapOut((as) => as.map(f)));
   };
 }
 
 /**
- * Transforms the elements of this stream using the supplied function.
+ * Statefully maps over the elements of this stream to produce new elements.
  *
- * @tsplus pipeable fncts.io.Stream map
+ * @tsplus pipeable fncts.io.Stream mapAccum
  */
-export function map<A, B>(f: (o: A) => B, __tsplusTrace?: string) {
+export function mapAccum<A, S, B>(s: S, f: (s: S, a: A) => readonly [S, B], __tsplusTrace?: string) {
   return <R, E>(stream: Stream<R, E, A>): Stream<R, E, B> => {
-    return new Stream(stream.channel.mapOut((as) => as.map(f)));
+    return new Stream(stream.channel.pipeTo(mapAccumAccumulator(s, f)));
   };
 }
 
@@ -2106,13 +2051,18 @@ function mapAccumAccumulator<S, E = never, A = never, B = never>(
 }
 
 /**
- * Statefully maps over the elements of this stream to produce new elements.
+ * Statefully and effectfully maps over the elements of this stream to produce
+ * new elements.
  *
- * @tsplus pipeable fncts.io.Stream mapAccum
+ * @tsplus pipeable fncts.io.Stream mapAccumIO
  */
-export function mapAccum<A, S, B>(s: S, f: (s: S, a: A) => readonly [S, B], __tsplusTrace?: string) {
-  return <R, E>(stream: Stream<R, E, A>): Stream<R, E, B> => {
-    return new Stream(stream.channel.pipeTo(mapAccumAccumulator(s, f)));
+export function mapAccumIO<A, R1, E1, S, B>(
+  s: S,
+  f: (s: S, a: A) => IO<R1, E1, readonly [B, S]>,
+  __tsplusTrace?: string,
+) {
+  return <R, E>(stream: Stream<R, E, A>): Stream<R | R1, E | E1, B> => {
+    return new Stream(stream.channel.pipeTo(mapAccumIOAccumulator(s, f)));
   };
 }
 
@@ -2146,22 +2096,6 @@ function mapAccumIOAccumulator<R, E, A, R1, E1, S, B>(
   );
 }
 
-/**
- * Statefully and effectfully maps over the elements of this stream to produce
- * new elements.
- *
- * @tsplus pipeable fncts.io.Stream mapAccumIO
- */
-export function mapAccumIO<A, R1, E1, S, B>(
-  s: S,
-  f: (s: S, a: A) => IO<R1, E1, readonly [B, S]>,
-  __tsplusTrace?: string,
-) {
-  return <R, E>(stream: Stream<R, E, A>): Stream<R | R1, E | E1, B> => {
-    return new Stream(stream.channel.pipeTo(mapAccumIOAccumulator(s, f)));
-  };
-}
-
 /**
  * Transforms the chunks emitted by this stream.
  *
@@ -2265,25 +2199,6 @@ export function mapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>, __tsplusTrace?:
   };
 }
 
-function mapIOLoop<R, E, A, R1, E1, B>(
-  iterator: Iterator<A>,
-  f: (a: A) => IO<R1, E1, B>,
-  __tsplusTrace?: string,
-): Channel<R | R1, E, Conc<A>, unknown, E | E1, Conc<B>, unknown> {
-  const next = iterator.next();
-  if (next.done) {
-    return Channel.readWithCause(
-      (elem) => mapIOLoop(elem[Symbol.iterator](), f),
-      Channel.failCauseNow,
-      Channel.succeedNow,
-    );
-  } else {
-    return Channel.unwrap(
-      f(next.value).map((b) => Channel.writeNow(Conc.single(b)) > mapIOLoop<R, E, A, R1, E1, B>(iterator, f)),
-    );
-  }
-}
-
 /**
  * Maps over elements of the stream with the specified effectful function,
  * executing up to `n` invocations of `f` concurrently. Transformed elements
@@ -2312,6 +2227,25 @@ export function mapIOConcurrentlyUnordered<A, R1, E1, B>(n: number, f: (a: A) =>
   };
 }
 
+function mapIOLoop<R, E, A, R1, E1, B>(
+  iterator: Iterator<A>,
+  f: (a: A) => IO<R1, E1, B>,
+  __tsplusTrace?: string,
+): Channel<R | R1, E, Conc<A>, unknown, E | E1, Conc<B>, unknown> {
+  const next = iterator.next();
+  if (next.done) {
+    return Channel.readWithCause(
+      (elem) => mapIOLoop(elem[Symbol.iterator](), f),
+      Channel.failCauseNow,
+      Channel.succeedNow,
+    );
+  } else {
+    return Channel.unwrap(
+      f(next.value).map((b) => Channel.writeNow(Conc.single(b)) > mapIOLoop<R, E, A, R1, E1, B>(iterator, f)),
+    );
+  }
+}
+
 /**
  * Merges this stream and the specified stream together.
  *
@@ -2330,6 +2264,15 @@ export function merge<R1, E1, B>(
   };
 }
 
+/**
+ * @tsplus pipeable fncts.io.Stream mergeEither
+ */
+export function mergeEither<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E, A>(fa: Stream<R, E, A>): Stream<R | R1, E | E1, Either<A, B>> => {
+    return fa.mergeWith(fb, Either.left, Either.right);
+  };
+}
+
 /**
  * Merges this stream and the specified stream together. New produced stream
  * will terminate when either stream terminates.
@@ -2378,18 +2321,6 @@ export function mergeLeft<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: st
   };
 }
 
-/**
- * Merges this stream and the specified stream together, discarding the values
- * from the left stream.
- *
- * @tsplus pipeable fncts.io.Stream mergeRight
- */
-export function mergeRight<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string) {
-  return <R, E, A>(self: Stream<R, E, A>): Stream<R | R1, E | E1, B> => {
-    return self.drain.merge(that);
-  };
-}
-
 /**
  * Maps each element of this stream to another stream and returns the
  * non-deterministic merge of those streams, executing up to `n` inner streams
@@ -2428,24 +2359,17 @@ export function mergeMapIO<A, R1, E1, B>(
 }
 
 /**
- * @tsplus pipeable fncts.io.Stream mergeEither
+ * Merges this stream and the specified stream together, discarding the values
+ * from the left stream.
+ *
+ * @tsplus pipeable fncts.io.Stream mergeRight
  */
-export function mergeEither<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplusTrace?: string) {
-  return <R, E, A>(fa: Stream<R, E, A>): Stream<R | R1, E | E1, Either<A, B>> => {
-    return fa.mergeWith(fb, Either.left, Either.right);
+export function mergeRight<R1, E1, B>(that: Stream<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E, A>(self: Stream<R, E, A>): Stream<R | R1, E | E1, B> => {
+    return self.drain.merge(that);
   };
 }
 
-function mergeWithHandler<R, E>(
-  terminate: boolean,
-  __tsplusTrace?: string,
-): (exit: Exit<E, unknown>) => MergeDecision<R, E, unknown, E, unknown> {
-  return (exit) =>
-    terminate || !exit.isSuccess() ? MergeDecision.Done(IO.fromExitNow(exit)) : MergeDecision.Await(IO.fromExitNow);
-}
-
-export type TerminationStrategy = "Left" | "Right" | "Both" | "Either";
-
 /**
  * @tsplus pipeable fncts.io.Stream mergeWith
  */
@@ -2469,6 +2393,14 @@ export function mergeWith<A, R1, E1, A1, B, C>(
   };
 }
 
+function mergeWithHandler<R, E>(
+  terminate: boolean,
+  __tsplusTrace?: string,
+): (exit: Exit<E, unknown>) => MergeDecision<R, E, unknown, E, unknown> {
+  return (exit) =>
+    terminate || !exit.isSuccess() ? MergeDecision.Done(IO.fromExitNow(exit)) : MergeDecision.Await(IO.fromExitNow);
+}
+
 /**
  * Runs the specified effect if this stream fails, providing the error to the effect if it exists.
  *
@@ -2599,6 +2531,19 @@ export function provideSomeLayer<RIn, E1, ROut>(layer: Layer<RIn, E1, ROut>, __t
   };
 }
 
+/**
+ * Re-chunks the elements of the stream into chunks of
+ * `n` elements each.
+ * The last chunk might contain less than `n` elements
+ *
+ * @tsplus pipeable fncts.io.Stream rechunk
+ */
+export function rechunk(n: number, __tsplusTrace?: string) {
+  return <R, E, A>(stream: Stream<R, E, A>): Stream<R, E, A> => {
+    return new Stream(stream.channel.pipeTo(rechunkProcess(new Rechunker(n), n)));
+  };
+}
+
 class Rechunker<A> {
   private builder: Array<A> = [];
   private pos               = 0;
@@ -2659,28 +2604,6 @@ function rechunkProcess<E, In>(
   );
 }
 
-/**
- * Re-chunks the elements of the stream into chunks of
- * `n` elements each.
- * The last chunk might contain less than `n` elements
- *
- * @tsplus pipeable fncts.io.Stream rechunk
- */
-export function rechunk(n: number, __tsplusTrace?: string) {
-  return <R, E, A>(stream: Stream<R, E, A>): Stream<R, E, A> => {
-    return new Stream(stream.channel.pipeTo(rechunkProcess(new Rechunker(n), n)));
-  };
-}
-
-/**
- * Repeats the provided value infinitely.
- *
- * @tsplus static fncts.io.StreamOps repeatValue
- */
-export function repeatValue<A>(a: A, __tsplusTrace?: string): Stream<unknown, never, A> {
-  return new Stream(Channel.writeNow(Conc.single(a)).repeated);
-}
-
 /**
  * Creates a stream from an effect producing a value of type `A` which repeats forever.
  *
@@ -2690,15 +2613,6 @@ export function repeatIO<R, E, A>(fa: IO<R, E, A>, __tsplusTrace?: string): Stre
   return Stream.repeatIOMaybe(fa.mapError(Maybe.just));
 }
 
-/**
- * Creates a stream from an effect producing values of type `A` until it fails with None.
- *
- * @tsplus static fncts.io.StreamOps repeatIOMaybe
- */
-export function repeatIOMaybe<R, E, A>(fa: IO<R, Maybe<E>, A>, __tsplusTrace?: string): Stream<R, E, A> {
-  return repeatIOChunkMaybe(fa.map(Conc.single));
-}
-
 /**
  * Creates a stream from an effect producing chunks of `A` values which repeats forever.
  *
@@ -2721,6 +2635,24 @@ export function repeatIOChunkMaybe<R, E, A>(fa: IO<R, Maybe<E>, Conc<A>>, __tspl
   );
 }
 
+/**
+ * Creates a stream from an effect producing values of type `A` until it fails with None.
+ *
+ * @tsplus static fncts.io.StreamOps repeatIOMaybe
+ */
+export function repeatIOMaybe<R, E, A>(fa: IO<R, Maybe<E>, A>, __tsplusTrace?: string): Stream<R, E, A> {
+  return repeatIOChunkMaybe(fa.map(Conc.single));
+}
+
+/**
+ * Repeats the provided value infinitely.
+ *
+ * @tsplus static fncts.io.StreamOps repeatValue
+ */
+export function repeatValue<A>(a: A, __tsplusTrace?: string): Stream<unknown, never, A> {
+  return new Stream(Channel.writeNow(Conc.single(a)).repeated);
+}
+
 /**
  * Runs the sink on the stream to produce either the sink's result or an error.
  *
@@ -2786,22 +2718,17 @@ export function runIntoElementsScoped_<E, A, R1, E1>(
 }
 
 /**
- * Like `Stream#into`, but provides the result as a `Managed` to allow for scope
+ * Like `Stream#runIntoHub`, but provides the result as a `Managed` to allow for scope
  * composition.
  *
- * @tsplus pipeable fncts.io.Stream runIntoQueueScoped
+ * @tsplus pipeable fncts.io.Stream runIntoHubScoped
  */
-export function runIntoQueueScoped<RA, RB, EA, EB, E1, A, B>(
-  queue: PEnqueue<RA, RB, EA, EB, Take<E1, A>, B>,
+export function runIntoHubScoped<RA, RB, EA, EB, E1, A, B>(
+  hub: PHub<RA, RB, EA, EB, Take<E1, A>, B>,
   __tsplusTrace?: string,
 ) {
   return <R, E extends E1>(stream: Stream<R, E, A>): IO<R | RA | Scope, E | EA | E1, void> => {
-    const writer: Channel<R, E, Conc<A>, unknown, E, Take<E | E1, A>, any> = Channel.readWithCause(
-      (inp) => Channel.writeNow(Take.chunk(inp)).zipRight(writer),
-      (cause) => Channel.writeNow(Take.failCause(cause)),
-      (_) => Channel.writeNow(Take.end),
-    );
-    return stream.channel.pipeTo(writer).mapOutIO((take) => queue.offer(take)).drain.runScoped.asUnit;
+    return stream.runIntoQueueScoped(hub);
   };
 }
 
@@ -2827,17 +2754,22 @@ export function runIntoQueueElementsScoped<E, A>(queue: Lazy<Queue.Enqueue<Exit<
 }
 
 /**
- * Like `Stream#runIntoHub`, but provides the result as a `Managed` to allow for scope
+ * Like `Stream#into`, but provides the result as a `Managed` to allow for scope
  * composition.
  *
- * @tsplus pipeable fncts.io.Stream runIntoHubScoped
+ * @tsplus pipeable fncts.io.Stream runIntoQueueScoped
  */
-export function runIntoHubScoped<RA, RB, EA, EB, E1, A, B>(
-  hub: PHub<RA, RB, EA, EB, Take<E1, A>, B>,
+export function runIntoQueueScoped<RA, RB, EA, EB, E1, A, B>(
+  queue: PEnqueue<RA, RB, EA, EB, Take<E1, A>, B>,
   __tsplusTrace?: string,
 ) {
   return <R, E extends E1>(stream: Stream<R, E, A>): IO<R | RA | Scope, E | EA | E1, void> => {
-    return stream.runIntoQueueScoped(hub);
+    const writer: Channel<R, E, Conc<A>, unknown, E, Take<E | E1, A>, any> = Channel.readWithCause(
+      (inp) => Channel.writeNow(Take.chunk(inp)).zipRight(writer),
+      (cause) => Channel.writeNow(Take.failCause(cause)),
+      (_) => Channel.writeNow(Take.end),
+    );
+    return stream.channel.pipeTo(writer).mapOutIO((take) => queue.offer(take)).drain.runScoped.asUnit;
   };
 }
 
@@ -2905,6 +2837,74 @@ export function scanReduceIO<A extends B, R1, E1, B>(f: (b: B, a: A) => IO<R1, E
   };
 }
 
+/**
+ * Creates a single-valued stream from a managed resource
+ *
+ * @tsplus static fncts.io.StreamOps scoped
+ */
+export function scoped<R, E, A>(stream: Lazy<IO<R, E, A>>, __tsplusTrace?: string): Stream<Exclude<R, Scope>, E, A> {
+  return new Stream(Channel.scoped(stream().map(Conc.single)));
+}
+
+/**
+ * Emits a sliding window of n elements.
+ *
+ * @tsplus pipeable fncts.io.Stream sliding
+ */
+export function sliding(chunkSize: number, stepSize: number, __tsplusTrace?: string) {
+  return <R, E, A>(self: Stream<R, E, A>): Stream<R, E, Conc<A>> => {
+    return Stream.defer(() => {
+      function slidingChunk(chunk: Conc<A>, input: Conc<A>): [Conc<A>, Conc<Conc<A>>] {
+        const updatedChunk = chunk.concat(input);
+        const length       = updatedChunk.length;
+        if (length >= chunkSize) {
+          const array    = new Array<Conc<A>>((length - chunkSize) / stepSize + 1);
+          let arrayIndex = 0;
+          let chunkIndex = 0;
+          while (chunkIndex + chunkSize <= length) {
+            array[arrayIndex] = updatedChunk.slice(chunkIndex, chunkIndex + chunkSize);
+            arrayIndex       += 1;
+            chunkIndex       += stepSize;
+          }
+          return [updatedChunk.drop(chunkIndex), Conc.fromArray(array)];
+        } else {
+          return [updatedChunk, Conc.empty()];
+        }
+      }
+      function sliding(chunk: Conc<A>, written: boolean): Channel<never, E, Conc<A>, any, E, Conc<Conc<A>>, any> {
+        return Channel.readWithCause(
+          (input) => {
+            const [updatedChunk, out] = slidingChunk(chunk, input);
+            if (out.isEmpty) {
+              return sliding(updatedChunk, written);
+            } else {
+              return Channel.writeNow(out) > sliding(updatedChunk, true);
+            }
+          },
+          (err) => {
+            const index = written && chunkSize > stepSize ? chunkSize - stepSize : 0;
+            if (index >= chunk.length) {
+              return Channel.failCauseNow(err);
+            } else {
+              return Channel.writeNow(Conc.single(chunk)) > Channel.failCauseNow(err);
+            }
+          },
+          (done) => {
+            const index = written && chunkSize > stepSize ? chunkSize - stepSize : 0;
+            if (index >= chunk.length) {
+              return Channel.succeedNow(done);
+            } else {
+              return Channel.writeNow(Conc.single(chunk)) > Channel.succeedNow(done);
+            }
+          },
+        );
+      }
+
+      return new Stream(self.channel >>> sliding(Conc.empty(), false));
+    });
+  };
+}
+
 /**
  * @tsplus pipeable fncts.io.Stream split
  */
@@ -2939,6 +2939,15 @@ export function split<A>(predicate: Predicate<A>, __tsplusTrace?: string) {
   };
 }
 
+/**
+ * Creates a single-valued pure stream
+ *
+ * @tsplus static fncts.io.StreamOps succeed
+ */
+export function succeed<A>(a: Lazy<A>, __tsplusTrace?: string): Stream<never, never, A> {
+  return fromChunk(Conc.single(a()));
+}
+
 /**
  * Creates a single-valued pure stream
  *
@@ -2949,12 +2958,20 @@ export function succeedNow<O>(o: O, __tsplusTrace?: string): Stream<never, never
 }
 
 /**
- * Creates a single-valued pure stream
+ * Takes the specified number of elements from this stream.
  *
- * @tsplus static fncts.io.StreamOps succeed
+ * @tsplus pipeable fncts.io.Stream take
  */
-export function succeed<A>(a: Lazy<A>, __tsplusTrace?: string): Stream<never, never, A> {
-  return fromChunk(Conc.single(a()));
+export function take(n: number, __tsplusTrace?: string) {
+  return <R, E, A>(stream: Stream<R, E, A>): Stream<R, E, A> => {
+    if (n <= 0) {
+      return empty;
+    }
+    if (!Number.isInteger(n)) {
+      return halt(new IllegalArgumentError(`${n} should be an integer`, "Stream.take"));
+    }
+    return new Stream(stream.channel.pipeTo(takeLoop(n)));
+  };
 }
 
 function takeLoop<E, A>(n: number, __tsplusTrace?: string): Channel<never, E, Conc<A>, unknown, E, Conc<A>, unknown> {
@@ -2974,19 +2991,14 @@ function takeLoop<E, A>(n: number, __tsplusTrace?: string): Channel<never, E, Co
 }
 
 /**
- * Takes the specified number of elements from this stream.
+ * Takes all elements of the stream until the specified predicate evaluates
+ * to `true`.
  *
- * @tsplus pipeable fncts.io.Stream take
+ * @tsplus pipeable fncts.io.Stream takeUntil
  */
-export function take(n: number, __tsplusTrace?: string) {
-  return <R, E, A>(stream: Stream<R, E, A>): Stream<R, E, A> => {
-    if (n <= 0) {
-      return empty;
-    }
-    if (!Number.isInteger(n)) {
-      return halt(new IllegalArgumentError(`${n} should be an integer`, "Stream.take"));
-    }
-    return new Stream(stream.channel.pipeTo(takeLoop(n)));
+export function takeUntil<A>(p: Predicate<A>, __tsplusTrace?: string) {
+  return <R, E>(fa: Stream<R, E, A>): Stream<R, E, A> => {
+    return new Stream(fa.channel.pipeTo(takeUntilLoop(p)));
   };
 }
 
@@ -3041,18 +3053,6 @@ function takeUntilLoop<R, E, A>(
   );
 }
 
-/**
- * Takes all elements of the stream until the specified predicate evaluates
- * to `true`.
- *
- * @tsplus pipeable fncts.io.Stream takeUntil
- */
-export function takeUntil<A>(p: Predicate<A>, __tsplusTrace?: string) {
-  return <R, E>(fa: Stream<R, E, A>): Stream<R, E, A> => {
-    return new Stream(fa.channel.pipeTo(takeUntilLoop(p)));
-  };
-}
-
 /**
  * @tsplus pipeable fncts.io.Stream tap
  */
@@ -3146,6 +3146,30 @@ export function throttleEnforce<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 pipeable fncts.io.Stream throttleEnforceIO
+ */
+export function throttleEnforceIO<A, R1, E1>(
+  costFn: (chunk: Conc<A>) => IO<R1, E1, number>,
+  units: number,
+  duration: number,
+  burst = 0,
+  __tsplusTrace?: string,
+) {
+  return <R, E>(sa: Stream<R, E, A>): Stream<R | R1, E | E1, A> => {
+    return new Stream(
+      Channel.fromIO(Clock.currentTime).flatMap((current) =>
+        sa.channel.pipeTo(throttleEnforceIOLoop(costFn, units, duration, burst, units, current)),
+      ),
+    );
+  };
+}
+
 function throttleEnforceIOLoop<E, A, R1, E1>(
   costFn: (chunk: Conc<A>) => IO<R1, E1, number>,
   units: number,
@@ -3178,30 +3202,6 @@ function throttleEnforceIOLoop<E, A, R1, E1>(
   );
 }
 
-/**
- * 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 pipeable fncts.io.Stream throttleEnforceIO
- */
-export function throttleEnforceIO<A, R1, E1>(
-  costFn: (chunk: Conc<A>) => IO<R1, E1, number>,
-  units: number,
-  duration: number,
-  burst = 0,
-  __tsplusTrace?: string,
-) {
-  return <R, E>(sa: Stream<R, E, A>): Stream<R | R1, E | E1, A> => {
-    return new Stream(
-      Channel.fromIO(Clock.currentTime).flatMap((current) =>
-        sa.channel.pipeTo(throttleEnforceIOLoop(costFn, units, duration, burst, units, current)),
-      ),
-    );
-  };
-}
-
 /**
  * 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.
@@ -3339,19 +3339,26 @@ export function toReadableStream<E, A>(self: Stream<never, E, A>, __tsplusTrace?
   });
 }
 
-function unfoldChunkIOLoop<S, R, E, A>(
+/**
+ * @tsplus static fncts.io.StreamOps unfold
+ */
+export function unfold<S, A>(
   s: S,
-  f: (s: S) => IO<R, E, Maybe<readonly [Conc<A>, S]>>,
+  f: (s: S) => Maybe<readonly [A, S]>,
   __tsplusTrace?: string,
-): Channel<R, unknown, unknown, unknown, E, Conc<A>, unknown> {
-  return Channel.unwrap(
-    f(s).map((m) =>
-      m.match(
-        () => Channel.unit,
-        ([as, s]) => Channel.writeNow(as).flatMap(() => unfoldChunkIOLoop(s, f)),
-      ),
-    ),
-  );
+): Stream<never, never, A> {
+  return Stream.unfoldChunk(s, (s) => f(s).map(([a, s]) => tuple(Conc.single(a), s)));
+}
+
+/**
+ * @tsplus static fncts.io.StreamOps unfoldChunk
+ */
+export function unfoldChunk<S, A>(
+  s: S,
+  f: (s: S) => Maybe<readonly [Conc<A>, S]>,
+  __tsplusTrace?: string,
+): Stream<never, never, A> {
+  return new Stream(Channel.defer(unfoldChunkLoop(s, f)));
 }
 
 /**
@@ -3367,17 +3374,19 @@ export function unfoldChunkIO<R, E, A, S>(
   return new Stream(unfoldChunkIOLoop(s, f));
 }
 
-/**
- * Creates a stream by effectfully peeling off the "layers" of a value of type `S`
- *
- * @tsplus static fncts.io.StreamOps unfoldIO
- */
-export function unfoldIO<S, R, E, A>(
+function unfoldChunkIOLoop<S, R, E, A>(
   s: S,
-  f: (s: S) => IO<R, E, Maybe<readonly [A, S]>>,
+  f: (s: S) => IO<R, E, Maybe<readonly [Conc<A>, S]>>,
   __tsplusTrace?: string,
-): Stream<R, E, A> {
-  return unfoldChunkIO(s, (_) => f(_).map((m) => m.map(([a, s]) => tuple(Conc.single(a), s))));
+): Channel<R, unknown, unknown, unknown, E, Conc<A>, unknown> {
+  return Channel.unwrap(
+    f(s).map((m) =>
+      m.match(
+        () => Channel.unit,
+        ([as, s]) => Channel.writeNow(as).flatMap(() => unfoldChunkIOLoop(s, f)),
+      ),
+    ),
+  );
 }
 
 function unfoldChunkLoop<S, A>(
@@ -3392,25 +3401,16 @@ function unfoldChunkLoop<S, A>(
 }
 
 /**
- * @tsplus static fncts.io.StreamOps unfoldChunk
- */
-export function unfoldChunk<S, A>(
-  s: S,
-  f: (s: S) => Maybe<readonly [Conc<A>, S]>,
-  __tsplusTrace?: string,
-): Stream<never, never, A> {
-  return new Stream(Channel.defer(unfoldChunkLoop(s, f)));
-}
-
-/**
- * @tsplus static fncts.io.StreamOps unfold
+ * Creates a stream by effectfully peeling off the "layers" of a value of type `S`
+ *
+ * @tsplus static fncts.io.StreamOps unfoldIO
  */
-export function unfold<S, A>(
+export function unfoldIO<S, R, E, A>(
   s: S,
-  f: (s: S) => Maybe<readonly [A, S]>,
+  f: (s: S) => IO<R, E, Maybe<readonly [A, S]>>,
   __tsplusTrace?: string,
-): Stream<never, never, A> {
-  return Stream.unfoldChunk(s, (s) => f(s).map(([a, s]) => tuple(Conc.single(a), s)));
+): Stream<R, E, A> {
+  return unfoldChunkIO(s, (_) => f(_).map((m) => m.map(([a, s]) => tuple(Conc.single(a), s))));
 }
 
 /**