@fncts/io 0.0.1 → 0.0.4

package/_src/IO/api/sequenceT.ts

@@ -7,6 +7,6 @@ import { identity, unsafeCoerce } from "@fncts/base/data/function";
  */
 export function sequenceT<T extends ReadonlyNonEmptyArray<IO<any, any, any>>>(
   ...ios: T
-): IO<_R<T[number]>, _E<T[number]>, { [K in keyof T]: _A<T[K]> }> {
+): IO<HKT._R<T[number]>, HKT._E<T[number]>, { [K in keyof T]: HKT._A<T[K]> }> {
   return unsafeCoerce(IO.foreach(ios, identity));
 }

package/_src/IO/api/sleep.ts

@@ -1,6 +1,6 @@
 /**
  * @tsplus static fncts.io.IOOps sleep
  */
-export function sleep(duration: number, __tsplusTrace?: string): UIO<void> {
+export function sleep(duration: Lazy<Duration>, __tsplusTrace?: string): UIO<void> {
   return Clock.sleep(duration);
 }

package/_src/IO/api/timeout.ts

@@ -0,0 +1,19 @@
+/**
+ * @tsplus fluent fncts.io.IO timeoutTo
+ */
+export function timeoutTo<R, E, A, B, B1>(
+  self: IO<R, E, A>,
+  duration: Lazy<Duration>,
+  b: Lazy<B>,
+  f: (a: A) => B1,
+  __tsplusTrace?: string,
+): IO<R, E, B | B1> {
+  return self.map(f).raceFirst(IO.sleep(duration).interruptible.as(b));
+}
+
+/**
+ * @tsplus fluent fncts.io.IO timeout
+ */
+export function timeout<R, E, A>(self: IO<R, E, A>, duration: Lazy<Duration>): IO<R, E, Maybe<A>> {
+  return self.timeoutTo(duration, Nothing(), Maybe.just);
+}

package/_src/IO/api.ts

@@ -761,12 +761,14 @@ export function foldLeft_<A, B, R, E>(
 /**
  * Combines an array of `IO`s using a `Monoid`
  *
- * @constrained
  * @tsplus static fncts.io.IOOps foldMap
  */
-export function foldMap_<M>(M: P.Monoid<M>) {
-  return <R, E, A>(as: Iterable<IO<R, E, A>>, f: (a: A) => M): IO<R, E, M> =>
-    IO.foldLeft(as, M.nat, (m, a) => a.map((a) => M.combine_(m, f(a))));
+export function foldMap_<R, E, A, M>(
+  as: Iterable<IO<R, E, A>>,
+  f: (a: A) => M,
+  /** @tsplus auto */ M: P.Monoid<M>,
+): IO<R, E, M> {
+  return IO.foldLeft(as, M.nat, (m, a) => a.map((a) => M.combine(m, f(a))));
 }
 
 function foldRightLoop<A, B, R, E>(

package/_src/IO/definition.ts

@@ -4,15 +4,19 @@ import type { FiberContext } from "@fncts/io/Fiber/FiberContext";
 export const IOTypeId = Symbol.for("fncts.io.IO");
 export type IOTypeId = typeof IOTypeId;
 
+export interface IOF extends IO<any, any, any> {}
+
 /**
  * @tsplus type fncts.io.IO
  * @tsplus companion fncts.io.IOOps
  */
 export abstract class IO<R, E, A> {
   readonly _typeId: IOTypeId = IOTypeId;
-  readonly _R!: (_: R) => void;
-  readonly _E!: () => E;
-  readonly _A!: () => A;
+  readonly [HKT.F]!: IOF;
+  readonly [HKT.R]!: (_: R) => void;
+  readonly [HKT.E]!: () => E;
+  readonly [HKT.A]!: () => A;
+  readonly [HKT.T]!: IO<HKT._R<this>, HKT._E<this>, HKT._A<this>>;
 }
 
 /**
@@ -407,7 +411,7 @@ export type Instruction =
   | SetRuntimeConfig;
 
 /**
- * @optimize identity
+ * @tsplus macro identity
  */
 export function concrete(_: IO<any, any, any>): Instruction {
   // @ts-expect-error

package/_src/IO.ts

@@ -11,6 +11,7 @@ export * from "./IO/api/acquireReleaseInterruptible.js";
 export * from "./IO/api/acquireReleaseInterruptibleExit.js";
 export * from "./IO/api/addFinalizer.js";
 export * from "./IO/api/addFinalizerExit.js";
+export * from "./IO/api/asyncIO.js";
 export * from "./IO/api/bracket.js";
 export * from "./IO/api/bracketExit.js";
 export * from "./IO/api/clockWith.js";
@@ -18,6 +19,7 @@ export * from "./IO/api/concurrency.js";
 export * from "./IO/api/concurrentFinalizers.js";
 export * from "./IO/api/consoleWith.js";
 export * from "./IO/api/core-scope.js";
+export * from "./IO/api/ensuringChildren.js";
 export * from "./IO/api/environment.js";
 export * from "./IO/api/foreachC.js";
 export * from "./IO/api/foreachExec.js";
@@ -43,6 +45,7 @@ export * from "./IO/api/scopeWith.js";
 export * from "./IO/api/sequenceT.js";
 export * from "./IO/api/sleep.js";
 export * from "./IO/api/stateful.js";
+export * from "./IO/api/timeout.js";
 export * from "./IO/api/withChildren.js";
 export * from "./IO/api/withFinalizer.js";
 export * from "./IO/api/withFinalizerExit.js";

package/_src/Layer/api.ts

@@ -282,7 +282,7 @@ function retryUpdate<S, RIn, E, X>(
         .flatMap(([state, _, decision]) =>
           decision._tag === DecisionTag.Done
             ? IO.failNow(e)
-            : Clock.sleep(decision.interval.startMilliseconds - now).as({ state }),
+            : Clock.sleep(Duration.fromInterval(now, decision.interval.startMilliseconds)).as({ state }),
         ),
     ),
     tag,

package/_src/Ref/Atomic/api.ts

@@ -29,6 +29,7 @@ export function getAndUpdateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>) {
   return IO.succeed(() => {
     const v = self.unsafeGet;
     const o = f(v);
+    Maybe.concrete(o);
     if (o._tag === "Just") {
       self.unsafeSet(o.value);
     }
@@ -56,6 +57,7 @@ export function modifyJust<A, B>(self: Atomic<A>, def: B, f: (a: A) => Maybe<rea
     const v = self.unsafeGet;
     const o = f(v);
 
+    Maybe.concrete(o);
     if (o._tag === "Just") {
       self.unsafeSet(o.value[1]);
       return o.value[0];
@@ -91,6 +93,7 @@ export function updateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>) {
   return IO.succeed(() => {
     const o = f(self.unsafeGet);
 
+    Maybe.concrete(o);
     if (o._tag === "Just") {
       self.unsafeSet(o.value);
     }
@@ -104,6 +107,7 @@ export function updateJustAndGet<A>(self: Atomic<A>, f: (a: A) => Maybe<A>) {
   return IO.succeed(() => {
     const o = f(self.unsafeGet);
 
+    Maybe.concrete(o);
     if (o._tag === "Just") {
       self.unsafeSet(o.value);
     }

package/_src/Schedule/Decision.ts

@@ -1,5 +1,3 @@
-import type { Interval } from "./Interval.js";
-
 export const enum DecisionTag {
   Continue = "Continue",
   Done = "Done",

package/_src/Schedule/api/driver.ts

@@ -19,7 +19,7 @@ export function driver<State, Env, In, Out>(
             (interval) =>
               ref
                 .set([Just(out), state1])
-                .apSecond(Clock.sleep(interval.startMilliseconds - now))
+                .apSecond(Clock.sleep(Duration.fromInterval(now, interval.startMilliseconds)))
                 .as(out),
           ),
         );

package/_src/Schedule/api.ts

@@ -1,7 +1,4 @@
-import { Driver } from "@fncts/io/Schedule/Driver";
-
 import { Decision, DecisionTag } from "./Decision.js";
-import { Interval } from "./Interval.js";
 
 /**
  * @tsplus static fncts.io.ScheduleOps __call

package/_src/Schedule.ts

@@ -3,5 +3,4 @@ export * from "./Schedule/api.js";
 export * from "./Schedule/Decision.js";
 export * from "./Schedule/definition.js";
 export * from "./Schedule/Driver.js";
-export * from "./Schedule/Interval.js";
 // codegen:end

package/_src/Scope/Finalizer/definition.ts

@@ -1,5 +1,5 @@
 interface FinalizerN extends HKT {
-  readonly type: Finalizer;
+  readonly [HKT.T]: Finalizer;
 }
 
 /**

package/_src/Scope/ReleaseMap/definition.ts

@@ -15,7 +15,7 @@ export class Running {
 export type State = Exited | Running;
 
 interface ReleaseMapN extends HKT {
-  readonly type: ReleaseMap;
+  readonly [HKT.T]: ReleaseMap;
 }
 
 /**

package/_src/Stream/api.ts

@@ -12,7 +12,8 @@ import { DEFAULT_CHUNK_SIZE, Stream } from "./definition.js";
 import { DebounceState } from "./internal/DebounceState.js";
 import { Handoff, HandoffSignal } from "./internal/Handoff.js";
 import { Pull } from "./internal/Pull.js";
-import { ScheduleEnd, ScheduleTimeout, SinkEnd, UpstreamEnd } from "./internal/SinkEndReason.js";
+import { SinkEndReasonTag } from "./internal/SinkEndReason.js";
+import { ScheduleEnd, UpstreamEnd } from "./internal/SinkEndReason.js";
 import { Take } from "./internal/Take.js";
 
 /**
@@ -77,17 +78,17 @@ export function aggregateAsyncWithinEither_<R, E, A extends A1, R1, E1, A1, B, R
   sink: Sink<R1, E1, A1, A1, B>,
   schedule: Schedule<R2, Maybe<B>, C>,
 ): Stream<R & R1 & R2, E | E1, Either<C, B>> {
-  type LocalHandoffSignal = HandoffSignal<C, E | E1, A1>;
-  type LocalSinkEndReason = SinkEndReason<C>;
+  type LocalHandoffSignal = HandoffSignal<E | E1, A1>;
 
   const deps = IO.sequenceT(
     Handoff<LocalHandoffSignal>(),
-    Ref.make<LocalSinkEndReason>(new SinkEnd()),
+    Ref.make<SinkEndReason>(new ScheduleEnd()),
     Ref.make(Conc.empty<A1>()),
     schedule.driver,
+    Ref.make(false),
   );
 
-  return Stream.fromIO(deps).flatMap(([handoff, sinkEndReason, sinkLeftovers, scheduleDriver]) => {
+  return Stream.fromIO(deps).flatMap(([handoff, sinkEndReason, sinkLeftovers, scheduleDriver, consumed]) => {
     const handoffProducer: Channel<unknown, E | E1, Conc<A1>, unknown, never, never, any> = Channel.readWithCause(
       (_in: Conc<A1>) => Channel.fromIO(handoff.offer(HandoffSignal.Emit(_in))).apSecond(handoffProducer),
       (cause: Cause<E | E1>) => Channel.fromIO(handoff.offer(HandoffSignal.Halt(cause))),
@@ -96,62 +97,102 @@ export function aggregateAsyncWithinEither_<R, E, A extends A1, R1, E1, A1, B, R
 
     const handoffConsumer: Channel<unknown, unknown, unknown, unknown, E | E1, Conc<A1>, void> = Channel.unwrap(
       sinkLeftovers.getAndSet(Conc.empty<A>()).flatMap((leftovers) => {
-        if (leftovers.isEmpty) {
-          return IO.succeedNow(Channel.writeNow(leftovers).apSecond(handoffConsumer));
+        if (leftovers.isNonEmpty) {
+          return consumed.set(true) > IO.succeedNow(Channel.writeNow(leftovers) > handoffConsumer);
         } else {
           return handoff.take.map((signal) =>
             signal.match({
-              Emit: ({ els }) => Channel.writeNow(els).apSecond(handoffConsumer),
+              Emit: ({ els }) => Channel.fromIO(consumed.set(true)) > Channel.writeNow(els) > handoffConsumer,
               Halt: ({ error }) => Channel.failCause(error),
-              End: ({ reason }) => Channel.fromIO(sinkEndReason.set(reason)),
+              End: ({ reason }) => {
+                if (reason._tag === SinkEndReasonTag.ScheduleEnd) {
+                  return Channel.unwrap(
+                    consumed.get.map((p) =>
+                      p
+                        ? Channel.fromIO(sinkEndReason.set(new ScheduleEnd()))
+                        : Channel.fromIO(sinkEndReason.set(new ScheduleEnd())) > handoffConsumer,
+                    ),
+                  );
+                } else {
+                  return Channel.fromIO(sinkEndReason.set(reason));
+                }
+              },
             }),
           );
         }
       }),
     );
 
+    function timeout(lastB: Maybe<B>): IO<R2, Nothing, C> {
+      return scheduleDriver.next(lastB);
+    }
+
     const scheduledAggregator = (
-      lastB: Maybe<B>,
+      sinkFiber: Fiber.Runtime<E | E1, readonly [Conc<Conc<A1>>, B]>,
+      scheduleFiber: Fiber.Runtime<Nothing, C>,
     ): Channel<R1 & R2, unknown, unknown, unknown, E | E1, Conc<Either<C, B>>, any> => {
-      const timeout = scheduleDriver.next(lastB).matchCauseIO(
-        (_) =>
-          _.failureOrCause.match(
-            () => handoff.offer(HandoffSignal.End(new ScheduleTimeout())),
-            (cause) => handoff.offer(HandoffSignal.Halt(cause)),
-          ),
-        (c) => handoff.offer(HandoffSignal.End(new ScheduleEnd(c))),
-      );
+      const forkSink =
+        consumed.set(false) > handoffConsumer.pipeToOrFail(sink.channel).doneCollect.runScoped.forkScoped;
+
+      function handleSide(leftovers: Conc<Conc<A1>>, b: B, c: Maybe<C>) {
+        return Channel.unwrap(
+          sinkLeftovers.set(leftovers.flatten) >
+            sinkEndReason.get.map((reason) =>
+              reason.match({
+                ScheduleEnd: () =>
+                  Channel.unwrapScoped(
+                    Do((Δ) => {
+                      const consumed_     = Δ(consumed.get);
+                      const sinkFiber     = Δ(forkSink);
+                      const scheduleFiber = Δ(timeout(Just(b)).forkScoped);
+                      const toWrite       = c.match(
+                        () => Conc(Either.right(b)),
+                        (c) => Conc(Either.right(b), Either.left(c)),
+                      );
+                      return consumed_
+                        ? Channel.write(toWrite) > scheduledAggregator(sinkFiber, scheduleFiber)
+                        : scheduledAggregator(sinkFiber, scheduleFiber);
+                    }),
+                  ),
+                UpstreamEnd: () =>
+                  Channel.unwrap(consumed.get.map((p) => (p ? Channel.write(Conc(Either.right(b))) : Channel.unit))),
+              }),
+            ),
+        );
+      }
 
-      return Channel.unwrapScoped(
-        timeout.forkScoped.map((fiber) => {
-          return handoffConsumer.pipeToOrFail(sink.channel).doneCollect.flatMap(([leftovers, b]) => {
-            return Channel.fromIO(fiber.interrupt.apSecond(sinkLeftovers.set(leftovers.flatten))).apSecond(
-              Channel.unwrap(
-                sinkEndReason.modify((reason) =>
-                  reason.match({
-                    ScheduleEnd: ({ c }) =>
-                      tuple(Channel.writeNow(Conc.from([Either.right(b), Either.left(c)])).as(Just(b)), new SinkEnd()),
-                    ScheduleTimeout: () =>
-                      tuple(Channel.writeNow(Conc.single(Either.right(b))).as(Just(b)), new SinkEnd()),
-                    SinkEnd: () => tuple(Channel.writeNow(Conc.single(Either.right(b))).as(Just(b)), new SinkEnd()),
-                    UpstreamEnd: () =>
-                      tuple(Channel.writeNow(Conc.single(Either.right(b))).as(Nothing()), new UpstreamEnd()),
-                  }),
+      return Channel.unwrap(
+        sinkFiber.join.raceWith(
+          scheduleFiber.join,
+          (sinkExit, scheduleFiber) =>
+            scheduleFiber.interrupt >
+            IO.fromExit(sinkExit).map(([leftovers, b]) => handleSide(leftovers, b, Nothing())),
+          (scheduleExit, sinkFiber) =>
+            IO.fromExit(scheduleExit).matchCauseIO(
+              (cause) =>
+                cause.failureOrCause.match(
+                  () =>
+                    handoff.offer(HandoffSignal.End(new ScheduleEnd())).forkDaemon >
+                    sinkFiber.join.map(([leftovers, b]) => handleSide(leftovers, b, Nothing())),
+                  (cause) =>
+                    handoff.offer(HandoffSignal.Halt(cause)).forkDaemon >
+                    sinkFiber.join.map(([leftovers, b]) => handleSide(leftovers, b, Nothing())),
                 ),
-              ),
-            );
-          });
-        }),
-      ).flatMap((_) =>
-        _.match(
-          () => Channel.unit,
-          () => scheduledAggregator(_),
+              (c) =>
+                handoff.offer(HandoffSignal.End(new ScheduleEnd())).forkDaemon >
+                sinkFiber.join.map(([leftovers, b]) => handleSide(leftovers, b, Just(c))),
+            ),
         ),
       );
     };
 
-    return Stream.scoped(stream.channel.pipeTo(handoffProducer).runScoped.forkDaemon).apSecond(
-      new Stream(scheduledAggregator(Nothing())),
+    return Stream.unwrapScoped(
+      Do((Δ) => {
+        Δ(stream.channel.pipeTo(handoffProducer).runScoped.forkScoped);
+        const sinkFiber     = Δ(handoffConsumer.pipeToOrFail(sink.channel).doneCollect.runScoped.forkScoped);
+        const scheduleFiber = Δ(timeout(Nothing()).forkScoped);
+        return new Stream(scheduledAggregator(sinkFiber, scheduleFiber));
+      }),
     );
   });
 }
@@ -669,23 +710,28 @@ export function collectWhileIO_<R, E, A, R1, E1, B>(
   stream: Stream<R, E, A>,
   pf: (a: A) => Maybe<IO<R1, E1, B>>,
 ): Stream<R & R1, E | E1, B> {
-  return stream.loopOnPartialChunks((chunk, emit) => {
-    const pfJust = (a: A) =>
-      pf(a).match(
-        () => IO.succeedNow(false),
-        (effect) => effect.flatMap(emit).as(true),
-      );
-
-    const loop = (chunk: Conc<A>): IO<R1, E1, boolean> => {
-      if (chunk.isEmpty) {
-        return IO.succeedNow(true);
-      } else {
-        return pfJust(chunk.unsafeHead).flatMap((cont) => (cont ? loop(chunk.unsafeTail) : IO.succeedNow(false)));
-      }
-    };
+  return new Stream(stream.channel.pipeTo(collectWhileIOLoop(Iterable.empty<A>()[Symbol.iterator](), pf)));
+}
 
-    return loop(chunk);
-  });
+function collectWhileIOLoop<R, E, A, R1, E1, B>(
+  iterator: Iterator<A>,
+  pf: (a: A) => Maybe<IO<R1, E1, B>>,
+): Channel<R & R1, E, Conc<A>, unknown, E | E1, Conc<B>, unknown> {
+  const next = iterator.next();
+  if (next.done) {
+    return Channel.readWithCause(
+      (elem) => collectWhileIOLoop(elem[Symbol.iterator](), pf),
+      Channel.failCauseNow,
+      Channel.succeedNow,
+    );
+  } else {
+    return Channel.unwrap(
+      pf(next.value).match(
+        () => IO.succeedNow(Channel.unit),
+        (b) => b.map((b) => Channel.writeNow(Conc.single(b)) > collectWhileIOLoop<R, E, A, R1, E1, B>(iterator, pf)),
+      ),
+    );
+  }
 }
 
 function combineProducer<Err, Elem>(
@@ -857,11 +903,11 @@ export function contramapEnvironment_<R, E, A, R0>(
 /**
  * @tsplus fluent fncts.io.Stream debounce
  */
-export function debounce_<R, E, A>(stream: Stream<R, E, A>, duration: number): Stream<R, E, A> {
+export function debounce_<R, E, A>(stream: Stream<R, E, A>, duration: Lazy<Duration>): Stream<R, E, A> {
   return Stream.unwrap(
     IO.transplant((grafter) =>
       Do((Δ) => {
-        const handoff = Δ(Handoff<HandoffSignal<void, E, A>>());
+        const handoff = Δ(Handoff<HandoffSignal<E, A>>());
         function enqueue(last: Conc<A>) {
           return grafter(Clock.sleep(duration).as(last).fork).map((f) => consumer(DebounceState.Previous(f)));
         }
@@ -1274,7 +1320,29 @@ export function filterIO_<R, E, A, R1, E1>(
   fa: Stream<R, E, A>,
   f: (a: A) => IO<R1, E1, boolean>,
 ): Stream<R & R1, E | E1, A> {
-  return fa.loopOnPartialChunksElements((a, emit) => f(a).flatMap((r) => (r ? emit(a) : IO.unit)));
+  return new Stream(fa.channel.pipeTo(filterIOLoop(Iterable.empty<A>()[Symbol.iterator](), f)));
+}
+
+function filterIOLoop<R, E, A, R1, E1>(
+  iterator: Iterator<A>,
+  f: (a: A) => IO<R1, E1, boolean>,
+): Channel<R & R1, E, Conc<A>, unknown, E | E1, Conc<A>, unknown> {
+  const next = iterator.next();
+  if (next.done) {
+    return Channel.readWithCause(
+      (elem) => filterIOLoop(elem[Symbol.iterator](), f),
+      Channel.failCauseNow,
+      Channel.succeedNow,
+    );
+  } else {
+    return Channel.unwrap(
+      f(next.value).map((b) =>
+        b
+          ? Channel.writeNow(Conc.single(next.value)) > filterIOLoop<R, E, A, R1, E1>(iterator, f)
+          : filterIOLoop<R, E, A, R1, E1>(iterator, f),
+      ),
+    );
+  }
 }
 
 /**
@@ -1291,7 +1359,30 @@ export function filterMapIO_<R, E, A, R1, E1, B>(
   fa: Stream<R, E, A>,
   f: (a: A) => IO<R1, E1, Maybe<B>>,
 ): Stream<R & R1, E | E1, B> {
-  return fa.loopOnPartialChunksElements((a, emit) => f(a).flatMap((maybeB) => maybeB.match(() => IO.unit, emit)));
+  return new Stream(fa.channel.pipeTo(filterMapIOLoop<R, E, A, R1, E1, B>(Iterable.empty<A>()[Symbol.iterator](), f)));
+}
+
+function filterMapIOLoop<R, E, A, R1, E1, B>(
+  iterator: Iterator<A>,
+  f: (a: A) => IO<R1, E1, Maybe<B>>,
+): Channel<R & R1, E, Conc<A>, unknown, E | E1, Conc<B>, unknown> {
+  const next = iterator.next();
+  if (next.done) {
+    return Channel.readWithCause(
+      (elem) => filterMapIOLoop(elem[Symbol.iterator](), f),
+      Channel.failCauseNow,
+      Channel.succeedNow,
+    );
+  } else {
+    return Channel.unwrap(
+      f(next.value).map((b) =>
+        b.match(
+          () => filterMapIOLoop(iterator, f),
+          (b) => Channel.writeNow(Conc.single(b)) > filterMapIOLoop<R, E, A, R1, E1, B>(iterator, f),
+        ),
+      ),
+    );
+  }
 }
 
 /**
@@ -1788,68 +1879,6 @@ export function interruptWhenFuture_<R, E, A, E1>(
   return new Stream(fa.channel.interruptWhen(future));
 }
 
-/**
- * Loops over the stream chunks concatenating the result of f
- *
- * @tsplus fluent fncts.io.Stream loopOnChunks
- */
-export function loopOnChunks_<R, E, A, R1, E1, A1>(
-  stream: Stream<R, E, A>,
-  f: (a: Conc<A>) => Channel<R1, E | E1, Conc<A>, unknown, E | E1, Conc<A1>, boolean>,
-): Stream<R & R1, E | E1, A1> {
-  const loop: Channel<R1, E | E1, Conc<A>, unknown, E | E1, Conc<A1>, boolean> = Channel.readWithCause(
-    (chunk) => f(chunk).flatMap((cont) => (cont ? loop : Channel.endNow(false))),
-    Channel.failCauseNow,
-    (_) => Channel.succeedNow(false),
-  );
-  return new Stream(stream.channel.pipeTo(loop));
-}
-
-/**
- * Loops on chunks emitting partially
- *
- * @tsplus fluent fncts.io.Stream loopOnPartialChunks
- */
-export function loopOnPartialChunks_<R, E, A, R1, E1, A1>(
-  stream: Stream<R, E, A>,
-  f: (a: Conc<A>, emit: (a: A1) => UIO<void>) => IO<R1, E1, boolean>,
-): Stream<R & R1, E | E1, A1> {
-  return stream.loopOnChunks((chunk) =>
-    Channel.unwrap(
-      IO.defer(() => {
-        let outputChunk = Conc.empty<A1>();
-        return f(chunk, (a) =>
-          IO.succeed(() => {
-            outputChunk = outputChunk.append(a);
-          }),
-        )
-          .map((cont) => Channel.write(outputChunk).apSecond(Channel.endNow(cont)))
-          .catchAll((failure) =>
-            IO.succeed(() => {
-              if (outputChunk.isEmpty) {
-                return Channel.failNow(failure);
-              } else {
-                return Channel.writeNow(outputChunk).apSecond(Channel.failNow(failure));
-              }
-            }),
-          );
-      }),
-    ),
-  );
-}
-
-/**
- * Loops on chunks elements emitting partially
- *
- * @tsplus fluent fncts.io.Stream loopOnPartialChunksElements
- */
-export function loopOnPartialChunksElements_<R, E, A, R1, E1, A1>(
-  stream: Stream<R, E, A>,
-  f: (a: A, emit: (a: A1) => UIO<void>) => IO<R1, E1, void>,
-): Stream<R & R1, E | E1, A1> {
-  return stream.loopOnPartialChunks((as, emit) => as.mapIO((a) => f(a, emit)).as(true));
-}
-
 /**
  * Transforms the elements of this stream using the supplied function.
  *
@@ -1861,11 +1890,11 @@ export function map_<R, E, A, B>(stream: Stream<R, E, A>, f: (o: A) => B): Strea
 
 function mapAccumAccumulator<S, E = never, A = never, B = never>(
   currS: S,
-  f: (s: S, a: A) => readonly [B, S],
+  f: (s: S, a: A) => readonly [S, B],
 ): Channel<unknown, E, Conc<A>, unknown, E, Conc<B>, void> {
   return Channel.readWith(
     (inp: Conc<A>) => {
-      const [bs, nextS] = inp.mapAccum(currS, f);
+      const [nextS, bs] = inp.mapAccum(currS, f);
       return Channel.writeNow(bs).apSecond(mapAccumAccumulator(nextS, f));
     },
     Channel.failNow,
@@ -1881,7 +1910,7 @@ function mapAccumAccumulator<S, E = never, A = never, B = never>(
 export function mapAccum_<R, E, A, S, B>(
   stream: Stream<R, E, A>,
   s: S,
-  f: (s: S, a: A) => readonly [B, S],
+  f: (s: S, a: A) => readonly [S, B],
 ): Stream<R, E, B> {
   return new Stream(stream.channel.pipeTo(mapAccumAccumulator(s, f)));
 }
@@ -2023,7 +2052,25 @@ export function mapIO_<R, E, A, R1, E1, B>(
   stream: Stream<R, E, A>,
   f: (a: A) => IO<R1, E1, B>,
 ): Stream<R & R1, E | E1, B> {
-  return stream.loopOnPartialChunksElements((a, emit) => f(a).flatMap(emit));
+  return new Stream(stream.channel.pipeTo(mapIOLoop(Iterable.empty<A>()[Symbol.iterator](), f)));
+}
+
+function mapIOLoop<R, E, A, R1, E1, B>(
+  iterator: Iterator<A>,
+  f: (a: A) => IO<R1, E1, B>,
+): 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)),
+    );
+  }
 }
 
 /**
@@ -2582,11 +2629,29 @@ export function takeUntilIO_<R, E, A, R1, E1>(
   ma: Stream<R, E, A>,
   f: (a: A) => IO<R1, E1, boolean>,
 ): Stream<R & R1, E | E1, A> {
-  return ma.loopOnPartialChunks((chunk, emit) =>
-    chunk
-      .takeWhileIO((v) => emit(v).apSecond(f(v).map((b) => !b)))
-      .map((taken) => taken.drop(taken.length).take(1).isEmpty),
-  );
+  return new Stream(ma.channel.pipeTo(takeUntilIOLoop(Iterable.empty<A>()[Symbol.iterator](), f)));
+}
+
+function takeUntilIOLoop<R, E, A, R1, E1>(
+  iterator: Iterator<A>,
+  f: (a: A) => IO<R1, E1, boolean>,
+): Channel<R & R1, E, Conc<A>, unknown, E | E1, Conc<A>, unknown> {
+  const next = iterator.next();
+  if (next.done) {
+    return Channel.readWithCause(
+      (elem) => takeUntilIOLoop(elem[Symbol.iterator](), f),
+      Channel.failCauseNow,
+      Channel.succeedNow,
+    );
+  } else {
+    return Channel.unwrap(
+      f(next.value).map((b) =>
+        b
+          ? Channel.writeNow(Conc.single(next.value))
+          : Channel.writeNow(Conc.single(next.value)) > takeUntilIOLoop<R, E, A, R1, E1>(iterator, f),
+      ),
+    );
+  }
 }
 
 function takeUntilLoop<R, E, A>(p: Predicate<A>): Channel<R, E, Conc<A>, unknown, E, Conc<A>, unknown> {