@fncts/io 0.0.49 → 0.0.50

package/_src/Push/FlattenStrategy.ts

@@ -0,0 +1,137 @@
+import { withScope } from "@fncts/io/Push/internal";
+
+type ScopedFork = <R, E, A>(io: IO<R, E, A>) => IO<R | Scope, never, Fiber.Runtime<E, A>>;
+
+type Fork = <R>(io: IO<R, never, void>) => IO<R | Scope, never, void>;
+
+/**
+ * @tsplus type fncts.io.Push.FlattenStrategy
+ * @tsplus companion fncts.io.Push.FlattenStrategyOps
+ */
+export abstract class FlattenStrategy {
+  abstract withFork<R>(
+    f: (fork: Fork, scope: Scope) => IO<R, never, void>,
+    executionStrategy: ExecutionStrategy,
+  ): IO<R | Scope, never, void>;
+}
+
+function withScopedFork<R, E, A>(
+  f: (fork: ScopedFork, scope: Scope.Closeable) => IO<R, E, A>,
+  executionStrategy: ExecutionStrategy,
+): IO<R | Scope, E, A> {
+  return withScope((scope) => f((io) => io.forkIn(scope), scope), executionStrategy);
+}
+
+/**
+ * @tsplus static fncts.io.Push.FlattenStrategyOps Switch
+ */
+export const SwitchStrategy = new (class SwitchStrategy extends FlattenStrategy {
+  withFork<R>(
+    f: (fork: Fork, scope: Scope) => IO<R, never, void>,
+    executionStrategy: ExecutionStrategy,
+  ): IO<R | Scope, never, void> {
+    return withScopedFork(
+      (fork, scope) =>
+        Ref.Synchronized.make<Fiber<never, void>>(Fiber.unit).flatMap(
+          (ref) =>
+            f((io) => ref.updateIO((fiber) => fiber.interrupt > fork(io)), scope) >
+            ref.get.flatMap((fiber) => fiber.join),
+        ),
+      executionStrategy,
+    );
+  }
+})();
+
+/**
+ * @tsplus static fncts.io.Push.FlattenStrategyOps Exhaust
+ */
+export const ExhaustStrategy = new (class ExhaustStrategy extends FlattenStrategy {
+  withFork<R>(
+    f: (fork: Fork, scope: Scope) => IO<R, never, void>,
+    executionStrategy: ExecutionStrategy,
+  ): IO<R | Scope, never, void> {
+    return withScopedFork(
+      (fork, scope) =>
+        Ref.Synchronized.make<Fiber.Runtime<never, void> | null>(null).flatMap(
+          (ref) =>
+            f(
+              (io) =>
+                ref.updateIO((fiber) => {
+                  if (fiber) {
+                    return IO.succeedNow(fiber);
+                  } else {
+                    return fork(io.onExit(() => ref.set(null)));
+                  }
+                }),
+              scope,
+            ) >
+            ref.get.flatMap((fiber) => {
+              if (fiber) {
+                return fiber.join;
+              } else {
+                return IO.unit;
+              }
+            }),
+        ),
+      executionStrategy,
+    );
+  }
+})();
+
+/**
+ * @tsplus static fncts.io.Push.FlattenStrategyOps Unbounded
+ */
+export const UnboundedStrategy = new (class UnboundedStrategy extends FlattenStrategy {
+  withFork<R>(f: (fork: Fork, scope: Scope) => IO<R, never, void>): IO<R | Scope, never, void> {
+    return IO.scopeWith((scope) =>
+      FiberSet.make<never, void>().flatMap((fiberSet) => f((io) => fiberSet.run(io), scope) > Fiber.joinAll(fiberSet)),
+    );
+  }
+})();
+
+/**
+ * @tsplus static fncts.io.Push.FlattenStrategyOps Bounded
+ */
+export function makeBounded(capacity: number): BoundedStrategy {
+  return new BoundedStrategy(capacity);
+}
+
+class BoundedStrategy extends FlattenStrategy {
+  constructor(readonly capacity: number) {
+    super();
+  }
+
+  withFork<R>(
+    f: (fork: Fork, scope: Scope) => IO<R, never, void>,
+    executionStrategy: ExecutionStrategy,
+  ): IO<R | Scope, never, void> {
+    return withScopedFork(
+      (fork, scope) =>
+        Do((Δ) => {
+          const ref       = Δ(Ref.make<HashSet<Fiber.Runtime<never, void>>>(HashSet.empty()));
+          const semaphore = Δ(Semaphore.make(this.capacity));
+          Δ(
+            f(
+              (io) =>
+                Do((Δ) => {
+                  const fiber = Δ(fork(semaphore.withPermit(io)));
+                  Δ(ref.update((set) => set.add(fiber)));
+                  Δ(scope.addFinalizer(ref.update((set) => set.remove(fiber))));
+                }),
+              scope,
+            ),
+          );
+          return ref;
+        }).flatMap((ref) =>
+          ref.get.flatMap((fibers) => {
+            if (fibers.size > 0) {
+              return Fiber.joinAll(fibers);
+            } else {
+              return IO.unit;
+            }
+          }),
+        ),
+      executionStrategy,
+    );
+  }
+}

package/_src/Push/IndexedBuffer.ts

@@ -0,0 +1,79 @@
+import type { Push } from "./definition.js";
+
+export class IndexedBuffer<R, E, A> {
+  constructor(
+    public ready: boolean,
+    readonly future: Future<never, void>,
+    readonly sink: Push.UnsafeSink<R, E, A>,
+    readonly onDone: UIO<void>,
+  ) {}
+
+  buffer: Array<A> = [];
+
+  onSuccess(value: A) {
+    if (this.ready) {
+      if (this.buffer.length === 0) {
+        return this.sink.onSuccess(value);
+      }
+
+      this.buffer.push(value);
+      const b     = this.buffer;
+      this.buffer = [];
+      return IO.foreach(b, this.sink.onSuccess);
+    } else {
+      this.buffer.push(value);
+      return IO.unit;
+    }
+  }
+
+  get onEnd() {
+    return (
+      this.future.await >
+      IO.defer(() => {
+        if (this.buffer.length === 0) {
+          return this.onDone;
+        }
+        const b     = this.buffer;
+        this.buffer = [];
+        return IO.foreach(b, this.sink.onSuccess) > this.onDone;
+      })
+    );
+  }
+}
+
+export const withBuffers = <R, E, A>(
+  size: number,
+  sink: Push.UnsafeSink<R, E, A>,
+  id: FiberId,
+): {
+  onSuccess: (index: number, value: A) => IO<R, never, void>;
+  onEnd: (index: number) => IO<R, never, void>;
+  buffers: Map<number, IndexedBuffer<R, E, A>>;
+} => {
+  const buffers = new Map<number, IndexedBuffer<R, E, A>>();
+  const last    = size - 1;
+
+  for (let i = 0; i < size; i++) {
+    const future = Future.unsafeMake<never, void>(id);
+    const ready  = i === 0;
+    if (i === 0) {
+      future.unsafeDone(IO.unit);
+    }
+    const onDone =
+      i === last
+        ? IO.unit
+        : IO.defer(() => {
+            const next = buffers.get(i + 1)!;
+            next.ready = true;
+            return next.future.done(Exit.unit);
+          });
+
+    buffers.set(i, new IndexedBuffer(ready, future, sink, onDone));
+  }
+
+  return {
+    buffers,
+    onSuccess: (index, value) => buffers.get(index)!.onSuccess(value),
+    onEnd: (index) => buffers.get(index)!.onEnd,
+  };
+};

package/_src/Push/MergeStrategy.ts

@@ -0,0 +1,59 @@
+import type { Push } from "./definition.js";
+
+import { withBuffers } from "./IndexedBuffer.js";
+import { Sink } from "./Sink.js";
+
+export abstract class MergeStrategy {
+  abstract runMerge<Ps extends ReadonlyArray<Push<any, any, any>>, R>(
+    ps: Ps,
+    sink: Push.UnsafeSink<R, any, any>,
+  ): IO<R | Push.EnvironmentOf<Ps[number]>, never, void>;
+}
+
+export class Unordered extends MergeStrategy {
+  constructor(readonly executionStrategy: ExecutionStrategy) {
+    super();
+  }
+
+  runMerge<Ps extends ReadonlyArray<Push<any, any, any>>, R>(
+    ps: Ps,
+    sink: Push.UnsafeSink<R, any, any>,
+  ): IO<R | Push.EnvironmentOf<Ps[number]>, never, void> {
+    return IO.foreachExecDiscard(ps, this.executionStrategy, (p) => p.run(sink));
+  }
+}
+
+export class Ordered extends MergeStrategy {
+  constructor(readonly executionStrategy: ExecutionStrategy) {
+    super();
+  }
+
+  runMerge<Ps extends ReadonlyArray<Push<any, any, any>>, R>(
+    ps: Ps,
+    sink: Push.UnsafeSink<R, any, any>,
+  ): IO<R | Push.EnvironmentOf<Ps[number]>, never, void> {
+    return IO.fiberIdWith((fiberId) => {
+      const buffers = withBuffers(ps.length, sink, fiberId);
+      return IO.foreachWithIndexDiscardExec(
+        ps,
+        this.executionStrategy,
+        (index, p) =>
+          p.run(
+            Sink.unsafeMake(
+              (value) => buffers.onSuccess(index, value),
+              (cause) => (cause.isInterruptedOnly ? buffers.onEnd(index) : sink.onFailure(cause)),
+            ),
+          ) > buffers.onEnd(index),
+      );
+    });
+  }
+}
+
+export class Switch extends MergeStrategy {
+  runMerge<Ps extends ReadonlyArray<Push<any, any, any>>, R>(
+    ps: Ps,
+    sink: Push.UnsafeSink<R, any, any>,
+  ): IO<R | Push.EnvironmentOf<Ps[number]>, never, void> {
+    return IO.foreachDiscard(ps, (p) => p.run(sink));
+  }
+}

package/_src/Push/Operator/IOLoopOperator.ts

@@ -0,0 +1,413 @@
+import type { IOOperator } from "./IOOperator.js";
+import type { SyncLoopOperator } from "@fncts/io/Push/Operator/LoopOperator";
+import type { SyncOperator } from "@fncts/io/Push/Operator/SyncOperator";
+
+export const enum IOLoopOperatorTag {
+  LoopIO = "LoopIO",
+  FilterMapLoopIO = "FilterMapLoopIO",
+}
+
+/**
+ * @tsplus type fncts.io.Push.IOLoopOperator
+ */
+export type IOLoopOperator<B = any, A = any, R = any, E = any, C = any> =
+  | LoopIOOperator<B, A, R, E, C>
+  | FilterMapLoopIOOperator<B, A, R, E, C>;
+
+export interface LoopIOOperator<B, A, R, E, C> {
+  readonly _tag: IOLoopOperatorTag.LoopIO;
+  readonly seed: B;
+  readonly f: (acc: B, a: A) => IO<R, E, readonly [C, B]>;
+}
+
+export function LoopIOOperator<const B, A, R, E, C>(
+  seed: B,
+  f: (acc: B, a: A) => IO<R, E, readonly [C, B]>,
+): LoopIOOperator<B, A, R, E, C> {
+  return {
+    _tag: IOLoopOperatorTag.LoopIO,
+    seed,
+    f,
+  };
+}
+
+export interface FilterMapLoopIOOperator<B, A, R, E, C> {
+  readonly _tag: IOLoopOperatorTag.FilterMapLoopIO;
+  readonly seed: B;
+  readonly f: (acc: B, a: A) => IO<R, E, readonly [Maybe<C>, B]>;
+}
+
+export function FilterMapLoopIOOperator<const B, A, R, E, C>(
+  seed: B,
+  f: (acc: B, a: A) => IO<R, E, readonly [Maybe<C>, B]>,
+): FilterMapLoopIOOperator<B, A, R, E, C> {
+  return {
+    _tag: IOLoopOperatorTag.FilterMapLoopIO,
+    seed,
+    f,
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.io.Push.IOLoopOperator match
+ */
+export function match<B, A, R, E, C, D, F>(matchers: {
+  LoopIO: (op: LoopIOOperator<B, A, R, E, C>) => D;
+  FilterMapLoopIO: (op: FilterMapLoopIOOperator<B, A, R, E, C>) => F;
+}) {
+  return (self: IOLoopOperator<B, A, R, E, C>): D | F => {
+    switch (self._tag) {
+      case IOLoopOperatorTag.LoopIO:
+        return matchers.LoopIO(self);
+      case IOLoopOperatorTag.FilterMapLoopIO:
+        return matchers.FilterMapLoopIO(self);
+    }
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.io.Push.IOLoopOperator fuse
+ */
+export function fuse<C, D, F, R2, E2>(that: IOLoopOperator<D, C, R2, E2, F>) {
+  return <A, B, R1, E1>(
+    self: IOLoopOperator<A, B, R1, E1, C>,
+  ): IOLoopOperator<readonly [A, D], B, R1 | R2, E1 | E2, F> =>
+    self.match({
+      LoopIO: (op1) =>
+        that.match({
+          LoopIO: (op2) =>
+            LoopIOOperator([op1.seed, op2.seed], ([a, d], b) =>
+              op1.f(a, b).flatMap(([c, a1]) => op2.f(d, c).map(([f, d1]) => [f, [a1, d1]])),
+            ),
+          FilterMapLoopIO: (op2) =>
+            FilterMapLoopIOOperator([op1.seed, op2.seed], ([a, d], b) =>
+              op1.f(a, b).flatMap(([c, a1]) => op2.f(d, c).map(([f, d1]) => [f, [a1, d1]])),
+            ),
+        }),
+      FilterMapLoopIO: (op1) =>
+        that.match({
+          LoopIO: (op2) =>
+            FilterMapLoopIOOperator([op1.seed, op2.seed], ([a, d], b) =>
+              op1.f(a, b).flatMap(([c, a1]) =>
+                c.match(
+                  () => [Nothing(), [a1, d]] as const,
+                  (c) => op2.f(d, c).map(([f, d1]) => [Just(f), [a1, d1]]),
+                ),
+              ),
+            ),
+          FilterMapLoopIO: (op2) =>
+            FilterMapLoopIOOperator([op1.seed, op2.seed], ([a, d], b) =>
+              op1.f(a, b).flatMap(([c, a1]) =>
+                c.match(
+                  () => [Nothing(), [a1, d]] as const,
+                  (c) => op2.f(d, c).map(([f, d1]) => [f, [a1, d1]]),
+                ),
+              ),
+            ),
+        }),
+    });
+}
+
+/**
+ * @tsplus pipeable fncts.io.Push.IOLoopOperator after
+ */
+export function fuseSyncLoopOperatorBefore<A, B, C>(that: SyncLoopOperator<A, B, C>) {
+  return <D, R, E, F>(self: IOLoopOperator<D, C, R, E, F>): IOLoopOperator<readonly [A, D], B, R, E, F> =>
+    that.match({
+      Loop: (op1) =>
+        self.match({
+          LoopIO: (op2) =>
+            LoopIOOperator([op1.seed, op2.seed], ([a, d], b) => {
+              const [c, a1] = op1.f(a, b);
+              return op2.f(d, c).map(([f, d1]) => [f, [a1, d1]]);
+            }),
+          FilterMapLoopIO: (op2) =>
+            FilterMapLoopIOOperator([op1.seed, op2.seed], ([a, d], b) => {
+              const [c, a1] = op1.f(a, b);
+              return op2.f(d, c).map(([f, d1]) => [f, [a1, d1]]);
+            }),
+        }),
+      FilterMapLoop: (op1) =>
+        self.match({
+          LoopIO: (op2) =>
+            FilterMapLoopIOOperator([op1.seed, op2.seed], ([a, d], b) => {
+              const [c, a1] = op1.f(a, b);
+              return c.match(
+                () => IO.succeedNow([Nothing(), [a1, d]]),
+                (c) => op2.f(d, c).map(([f, d1]) => [Just(f), [a1, d1]]),
+              );
+            }),
+          FilterMapLoopIO: (op2) =>
+            FilterMapLoopIOOperator([op1.seed, op2.seed], ([a, d], b) => {
+              const [c, a1] = op1.f(a, b);
+              return c.match(
+                () => IO.succeedNow([Nothing(), [a1, d]]),
+                (c) => op2.f(d, c).map(([f, d1]) => [f, [a1, d1]]),
+              );
+            }),
+        }),
+    });
+}
+
+/**
+ * @tsplus pipeable fncts.io.Push.IOLoopOperator before
+ */
+export function fuseSyncLoopOperatorAfter<D, C, F>(that: SyncLoopOperator<D, C, F>) {
+  return <A, B, R, E>(self: IOLoopOperator<A, B, R, E, C>): IOLoopOperator<readonly [A, D], B, R, E, F> =>
+    self.match({
+      LoopIO: (op1) =>
+        that.match({
+          Loop: (op2) =>
+            LoopIOOperator([op1.seed, op2.seed], ([a, d], b) =>
+              op1.f(a, b).map(([c, a1]) => {
+                const [f, d1] = op2.f(d, c);
+                return [f, [a1, d1]];
+              }),
+            ),
+          FilterMapLoop: (op2) =>
+            FilterMapLoopIOOperator([op1.seed, op2.seed], ([a, d], b) =>
+              op1.f(a, b).map(([c, a1]) => {
+                const [f, d1] = op2.f(d, c);
+                return [f, [a1, d1]];
+              }),
+            ),
+        }),
+      FilterMapLoopIO: (op1) =>
+        that.match({
+          Loop: (op2) =>
+            FilterMapLoopIOOperator([op1.seed, op2.seed], ([a, d], b) =>
+              op1.f(a, b).map(([c, a1]) =>
+                c.match(
+                  () => [Nothing(), [a1, d]],
+                  (c) => {
+                    const [f, d1] = op2.f(d, c);
+                    return [Just(f), [a1, d1]];
+                  },
+                ),
+              ),
+            ),
+          FilterMapLoop: (op2) =>
+            FilterMapLoopIOOperator([op1.seed, op2.seed], ([a, d], b) =>
+              op1.f(a, b).map(([c, a1]) =>
+                c.match(
+                  () => [Nothing(), [a1, d]],
+                  (c) => {
+                    const [f, d1] = op2.f(d, c);
+                    return [f, [a1, d1]];
+                  },
+                ),
+              ),
+            ),
+        }),
+    });
+}
+
+/**
+ * @tsplus pipeable fncts.io.Push.IOLoopOperator after
+ */
+export function fuseSyncOperatorBefore(that: SyncOperator) {
+  return (self: IOLoopOperator): IOLoopOperator =>
+    that.match({
+      Map: (op) =>
+        self.match({
+          LoopIO: (op2) => LoopIOOperator(op2.seed, (acc, a) => op2.f(acc, op.f(a))),
+          FilterMapLoopIO: (op2) => FilterMapLoopIOOperator(op2.seed, (acc, a) => op2.f(acc, op.f(a))),
+        }),
+      Filter: (op) =>
+        self.match({
+          LoopIO: (op2) =>
+            LoopIOOperator(op2.seed, (acc, a) => {
+              if (op.f(a)) {
+                return op2.f(acc, a);
+              } else {
+                return IO.succeedNow([Nothing(), acc]);
+              }
+            }),
+          FilterMapLoopIO: (op2) =>
+            FilterMapLoopIOOperator(op2.seed, (acc, a) => {
+              if (op.f(a)) {
+                return op2.f(acc, a);
+              } else {
+                return IO.succeedNow([Nothing(), acc]);
+              }
+            }),
+        }),
+      FilterMap: (op) =>
+        self.match({
+          LoopIO: (op2) =>
+            LoopIOOperator(op2.seed, (acc, a) =>
+              op.f(a).match(
+                () => IO.succeedNow([Nothing(), acc] as const),
+                (b) => self.f(acc, b),
+              ),
+            ),
+          FilterMapLoopIO: (op2) =>
+            FilterMapLoopIOOperator(op2.seed, (acc, a) =>
+              op.f(a).match(
+                () => IO.succeedNow([Nothing(), acc] as const),
+                (b) => self.f(acc, b),
+              ),
+            ),
+        }),
+    });
+}
+
+/**
+ * @tsplus pipeable fncts.io.Push.IOLoopOperator before
+ */
+export function fuseSyncOperatorAfter(that: SyncOperator) {
+  return (self: IOLoopOperator): IOLoopOperator =>
+    self.match({
+      LoopIO: (op1) =>
+        that.match({
+          Map: (op) => LoopIOOperator(op1.seed, (acc, a) => op1.f(acc, a).map(([b, c]) => [op.f(b), c] as const)),
+          Filter: (op) =>
+            FilterMapLoopIOOperator(op1.seed, (acc, a) =>
+              op1.f(acc, a).map(([b, c]) => [Maybe.fromPredicate(b, op.f), c] as const),
+            ),
+          FilterMap: (op) =>
+            FilterMapLoopIOOperator(op1.seed, (acc, a) => op1.f(acc, a).map(([b, c]) => [op.f(b), c] as const)),
+        }),
+      FilterMapLoopIO: (op1) =>
+        that.match({
+          Map: (op) =>
+            FilterMapLoopIOOperator(op1.seed, (acc, a) => op1.f(acc, a).map(([b, c]) => [b.map(op.f), c] as const)),
+          Filter: (op) =>
+            FilterMapLoopIOOperator(op1.seed, (acc, a) => op1.f(acc, a).map(([b, c]) => [b.filter(op.f), c] as const)),
+          FilterMap: (op) =>
+            FilterMapLoopIOOperator(op1.seed, (acc, a) => op1.f(acc, a).map(([b, c]) => [b.flatMap(op.f), c] as const)),
+        }),
+    });
+}
+
+export function fuseIOOperatorBefore(that: IOOperator) {
+  return (self: IOLoopOperator): IOLoopOperator =>
+    that.match({
+      MapIO: (op) =>
+        self.match({
+          LoopIO: (op2) => LoopIOOperator(op2.seed, (acc, a) => op.f(a).flatMap((b) => op2.f(acc, b))),
+          FilterMapLoopIO: (op2) =>
+            FilterMapLoopIOOperator(op2.seed, (acc, a) => op.f(a).flatMap((b) => op2.f(acc, b))),
+        }),
+      TapIO: (op) =>
+        self.match({
+          LoopIO: (op2) => LoopIOOperator(op2.seed, (acc, a) => op.f(a).flatMap(() => op2.f(acc, a))),
+          FilterMapLoopIO: (op2) => FilterMapLoopIOOperator(op2.seed, (acc, a) => op.f(a).flatMap(() => op2.f(acc, a))),
+        }),
+      FilterIO: (op) =>
+        self.match({
+          LoopIO: (op2) =>
+            LoopIOOperator(op2.seed, (acc, a) =>
+              op.f(a).flatMap((b) => {
+                if (b) {
+                  return op2.f(acc, a);
+                } else {
+                  return IO.succeedNow([Nothing(), acc] as const);
+                }
+              }),
+            ),
+          FilterMapLoopIO: (op2) =>
+            FilterMapLoopIOOperator(op2.seed, (acc, a) =>
+              op.f(a).flatMap((b) => {
+                if (b) {
+                  return op2.f(acc, a);
+                } else {
+                  return IO.succeedNow([Nothing(), acc] as const);
+                }
+              }),
+            ),
+        }),
+      FilterMapIO: (op) =>
+        self.match({
+          LoopIO: (op2) =>
+            LoopIOOperator(op2.seed, (acc, a) =>
+              op.f(a).flatMap((b) =>
+                b.match(
+                  () => IO.succeedNow([Nothing(), acc] as const),
+                  (c) => op2.f(acc, c),
+                ),
+              ),
+            ),
+          FilterMapLoopIO: (op2) =>
+            FilterMapLoopIOOperator(op2.seed, (acc, a) =>
+              op.f(a).flatMap((b) =>
+                b.match(
+                  () => IO.succeedNow([Nothing(), acc] as const),
+                  (c) => op2.f(acc, c),
+                ),
+              ),
+            ),
+        }),
+    });
+}
+
+export function fuseIOOperatorAfter(that: IOOperator) {
+  return (self: IOLoopOperator) =>
+    self.match({
+      LoopIO: (op1) =>
+        that.match({
+          MapIO: (op) =>
+            LoopIOOperator(op1.seed, (acc, a) =>
+              op1.f(acc, a).flatMap(([b, c]) => op.f(b).map((d) => [d, c] as const)),
+            ),
+          TapIO: (op) =>
+            LoopIOOperator(op1.seed, (acc, a) => op1.f(acc, a).flatMap(([b, c]) => op.f(b).map(() => [b, c] as const))),
+          FilterIO: (op) =>
+            FilterMapLoopIOOperator(op1.seed, (acc, a) =>
+              op1
+                .f(acc, a)
+                .flatMap(([b, c]) => op.f(b).map((d) => (d ? ([Just(b), c] as const) : ([Nothing(), c] as const)))),
+            ),
+          FilterMapIO: (op) =>
+            FilterMapLoopIOOperator(op1.seed, (acc, a) =>
+              op1.f(acc, a).flatMap(([b, c]) => op.f(b).map((d) => [d, c] as const)),
+            ),
+        }),
+      FilterMapLoopIO: (op1) =>
+        that.match({
+          MapIO: (op) =>
+            FilterMapLoopIOOperator(op1.seed, (acc, a) =>
+              op1.f(acc, a).flatMap(([b, c]) =>
+                b.match(
+                  () => IO.succeedNow([Nothing(), c] as const),
+                  (d) => op.f(d).map((e) => [Just(e), c] as const),
+                ),
+              ),
+            ),
+          TapIO: (op) =>
+            FilterMapLoopIOOperator(op1.seed, (acc, a) =>
+              op1.f(acc, a).flatMap(([b, c]) =>
+                b.match(
+                  () => IO.succeedNow([Nothing(), c] as const),
+                  (d) => op.f(d).map(() => [Just(d), c] as const),
+                ),
+              ),
+            ),
+          FilterIO: (op) =>
+            FilterMapLoopIOOperator(op1.seed, (acc, a) =>
+              op1.f(acc, a).flatMap(([b, c]) =>
+                b.match(
+                  () => IO.succeedNow([Nothing(), c] as const),
+                  (d) => op.f(d).map((e) => (e ? ([Just(d), c] as const) : ([Nothing(), c] as const))),
+                ),
+              ),
+            ),
+          FilterMapIO: (op) =>
+            FilterMapLoopIOOperator(op1.seed, (acc, a) =>
+              op1.f(acc, a).flatMap(([b, c]) =>
+                b.match(
+                  () => IO.succeedNow([Nothing(), c] as const),
+                  (d) => op.f(d).map((e) => [e, c] as const),
+                ),
+              ),
+            ),
+        }),
+    });
+}
+
+export function liftLoopOperator(self: SyncLoopOperator): IOLoopOperator {
+  return self.match({
+    Loop: (op) => LoopIOOperator(op.seed, (acc, a) => IO.succeedNow(op.f(acc, a))),
+    FilterMapLoop: (op) => FilterMapLoopIOOperator(op.seed, (acc, a) => IO.succeedNow(op.f(acc, a))),
+  });
+}