@fncts/io 0.0.20 → 0.0.22

package/_src/Push/definition.ts

@@ -0,0 +1,42 @@
+/**
+ * @tsplus type fncts.io.Push
+ * @tsplus companion fncts.io.PushOps
+ */
+export class Push<R, E, A> {
+  declare _R: (_: never) => R;
+  declare _E: (_: never) => E;
+  declare _A: (_: never) => A;
+  constructor(readonly run: <R1>(emitter: Emitter<R1, E, A>) => IO<R | R1 | Scope, never, unknown>) {}
+}
+
+/**
+ * @tsplus type fncts.io.Push.Emitter
+ * @tsplus companion fncts.io.Push.EmitterOps
+ */
+export class Emitter<R, E, A> {
+  constructor(
+    readonly emit: (value: A) => IO<R, never, unknown>,
+    readonly failCause: (cause: Cause<E>) => IO<R, never, void>,
+    readonly end: IO<R, never, void>,
+  ) {}
+}
+
+/**
+ * @tsplus static fncts.io.PushOps __call
+ */
+export function makePush<R, E, A>(
+  run: <R1>(emitter: Emitter<R1, E, A>) => IO<R | R1 | Scope, never, unknown>,
+): Push<R, E, A> {
+  return new Push(run);
+}
+
+/**
+ * @tsplus static fncts.io.Push.EmitterOps __call
+ */
+export function makeEmitter<R, E, A>(
+  emit: (value: A) => IO<R, never, unknown>,
+  failCause: (cause: Cause<E>) => IO<R, never, unknown>,
+  end: IO<R, never, unknown>,
+): Emitter<R, E, A> {
+  return new Emitter(emit, failCause, end);
+}

package/_src/Push/internal.ts

@@ -0,0 +1,39 @@
+export function withCountdownLatch<R, E, A, R1, E1, B>(
+  n: number,
+  f: (latch: CountdownLatch) => IO<R, E, A>,
+  onEnd: IO<R1, E1, B>,
+): IO<R | R1, E | E1, B> {
+  return Do((Δ) => {
+    const latch = Δ(CountdownLatch(n));
+    Δ(f(latch));
+    return Δ(latch.await > onEnd);
+  });
+}
+
+export const EarlyExitTypeId = Symbol.for("fncts.io.Push.EarlyExit");
+export type EarlyExitTypeId = typeof EarlyExitTypeId;
+
+export class EarlyExit {
+  readonly _typeId: EarlyExitTypeId = EarlyExitTypeId;
+}
+
+export function isEarlyExit(u: unknown): u is EarlyExit {
+  return hasTypeId(u, EarlyExitTypeId);
+}
+
+export const earlyExit = IO.haltNow(new EarlyExit());
+
+export function onEarlyExit<R1, E1, B>(onEarlyExit: IO<R1, E1, B>) {
+  return <R, E, A>(self: IO<R, E, A>): IO<R | R1, E | E1, A | B> => {
+    return self.matchCauseIO(
+      (cause) =>
+        cause
+          .find((cause) => (cause.isHalt() && isEarlyExit(cause.value) ? Just(cause) : Nothing()))
+          .match(
+            () => IO.failCauseNow(cause),
+            () => onEarlyExit,
+          ),
+      IO.succeedNow,
+    );
+  };
+}

package/_src/Push.ts

@@ -0,0 +1,5 @@
+// codegen:start { preset: barrel, include: ./Push/*.ts }
+export * from "./Push/api.js";
+export * from "./Push/definition.js";
+export * from "./Push/internal.js";
+// codegen:end

package/_src/Queue/api/dimapIO.ts

@@ -1,6 +1,9 @@
-import { concrete, QueueInternal } from "@fncts/io/Queue/definition";
+import type { UIO } from "@fncts/io/IO";
+import type { PDequeue, PDequeueInternal, PEnqueue, PEnqueueInternal } from "@fncts/io/Queue/definition";
 
-class DimapIO<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D> extends QueueInternal<
+import { concrete, DequeueTypeId, EnqueueTypeId, QueueInternal, QueueTypeId } from "@fncts/io/Queue/definition";
+
+class DimapIO<RA, RB, EA, EB, A, B, RC, EC, C, RD, ED, D> extends QueueInternal<
   RC | RA,
   RD | RB,
   EC | EA,
@@ -47,84 +50,158 @@ class DimapIO<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D> extends QueueInternal<
  * Transforms elements enqueued into and dequeued from this queue with the
  * specified effectual functions.
  *
- * @tsplus fluent fncts.io.Queue dimap
+ * @tsplus pipeable fncts.io.Queue dimap
  */
-export function dimap_<RA, RB, EA, EB, A, B, C, D>(
-  self: PQueue<RA, RB, EA, EB, A, B>,
-  f: (c: C) => A,
-  g: (b: B) => D,
-  __tsplusTrace?: string,
-) {
-  return self.dimapIO(
-    (c: C) => IO.succeedNow(f(c)),
-    (b) => IO.succeedNow(g(b)),
-  );
+export function dimap<A, B, C, D>(f: (c: C) => A, g: (b: B) => D, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB>(self: PQueue<RA, RB, EA, EB, A, B>) => {
+    return self.dimapIO(
+      (c: C) => IO.succeedNow(f(c)),
+      (b) => IO.succeedNow(g(b)),
+    );
+  };
 }
 
 /**
  * Transforms elements enqueued into and dequeued from this queue with the
  * specified effectual functions.
  *
- * @tsplus fluent fncts.io.Queue dimapIO
+ * @tsplus pipeable fncts.io.Queue dimapIO
  */
-export function dimapIO_<RA, RB, EA, EB, A, B, C, RC, EC, RD, ED, D>(
-  queue: PQueue<RA, RB, EA, EB, A, B>,
+export function dimapIO_<A, B, RC, EC, C, RD, ED, D>(
   f: (c: C) => IO<RC, EC, A>,
   g: (b: B) => IO<RD, ED, D>,
   __tsplusTrace?: string,
-): PQueue<RC | RA, RD | RB, EC | EA, ED | EB, C, D> {
-  concrete(queue);
-  return new DimapIO(queue, f, g);
+) {
+  return <RA, RB, EA, EB>(queue: PQueue<RA, RB, EA, EB, A, B>): PQueue<RC | RA, RD | RB, EC | EA, ED | EB, C, D> => {
+    concrete(queue);
+    return new DimapIO(queue, f, g);
+  };
 }
 
 /**
  * Transforms elements enqueued into this queue with an effectful function.
  *
- * @tsplus fluent fncts.io.Queue contramapIO
+ * @tsplus pipeable fncts.io.Queue contramapIO
  */
-export function contramapIO_<RA, RB, EA, EB, A, B, RC, EC, C>(
-  queue: PQueue<RA, RB, EA, EB, A, B>,
-  f: (c: C) => IO<RC, EC, A>,
-  __tsplusTrace?: string,
-): PQueue<RA | RC, RB, EA | EC, EB, C, B> {
-  return queue.dimapIO(f, IO.succeedNow);
+export function contramapInputIO<A, RC, EC, C>(f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, B>(self: PQueue<RA, RB, EA, EB, A, B>): PQueue<RA | RC, RB, EA | EC, EB, C, B> => {
+    return self.dimapIO(f, IO.succeedNow);
+  };
 }
 
 /**
  * Transforms elements enqueued into this queue with an effectful function.
  *
- * @tsplus fluent fncts.io.Queue contramap
+ * @tsplus pipeable fncts.io.Queue contramap
  */
-export function contramap_<RA, RB, EA, EB, A, B, C>(
-  queue: PQueue<RA, RB, EA, EB, A, B>,
-  f: (c: C) => A,
-  __tsplusTrace?: string,
-): PQueue<RA, RB, EA, EB, C, B> {
-  return queue.contramapIO((c) => IO.succeedNow(f(c)));
+export function contramapInput<A, C>(f: (c: C) => A, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, B>(queue: PQueue<RA, RB, EA, EB, A, B>): PQueue<RA, RB, EA, EB, C, B> => {
+    return queue.contramapIO((c) => IO.succeedNow(f(c)));
+  };
 }
 
 /**
  * Transforms elements dequeued from this queue with an effectful function.
  *
- * @tsplus fluent fncts.io.Queue mapIO
+ * @tsplus pipeable fncts.io.Queue mapIO
  */
-export function mapIO_<RA, RB, EA, EB, A, B, R2, E2, C>(
-  queue: PQueue<RA, RB, EA, EB, A, B>,
-  f: (b: B) => IO<R2, E2, C>,
-  __tsplusTrace?: string,
-): PQueue<RA, R2 | RB, EA, EB | E2, A, C> {
-  return queue.dimapIO(IO.succeedNow, f);
+export function mapIO<B, R2, E2, C>(f: (b: B) => IO<R2, E2, C>, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, A>(queue: PQueue<RA, RB, EA, EB, A, B>): PQueue<RA, R2 | RB, EA, EB | E2, A, C> => {
+    return queue.dimapIO(IO.succeedNow, f);
+  };
 }
 
 /**
  * Transforms elements dequeued from this queue with a function.
  *
- * @tsplus fluent fncts.io.Queue map
+ * @tsplus pipeable fncts.io.Queue map
  */
-export function map_<RA, RB, EA, EB, A, B, C>(
-  queue: PQueue<RA, RB, EA, EB, A, B>,
-  f: (b: B) => C,
-  __tsplusTrace?: string,
-): PQueue<RA, RB, EA, EB, A, C> {
-  return queue.mapIO((b) => IO.succeedNow(f(b)));
+export function map<B, C>(f: (b: B) => C, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, A>(queue: PQueue<RA, RB, EA, EB, A, B>): PQueue<RA, RB, EA, EB, A, C> => {
+    return queue.mapIO((b) => IO.succeedNow(f(b)));
+  };
+}
+
+class ContramapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PEnqueueInternal<RA | RC, RB, EA | EC, EB, C, B> {
+  readonly [EnqueueTypeId]: EnqueueTypeId = EnqueueTypeId;
+  readonly [QueueTypeId]: QueueTypeId     = QueueTypeId;
+  declare _RA: () => RA | RC;
+  declare _RB: () => RB;
+  declare _EA: () => EA | EC;
+  declare _EB: () => EB;
+  declare _A: (_: C) => void;
+  declare _B: () => B;
+  constructor(readonly queue: PEnqueueInternal<RA, RB, EA, EB, A, B>, readonly f: (c: C) => IO<RC, EC, A>) {}
+
+  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+
+  capacity: number = this.queue.capacity;
+
+  isShutdown: UIO<boolean> = this.queue.isShutdown;
+
+  offer(c: C): IO<RC | RA, EA | EC, boolean> {
+    return this.f(c).flatMap((a) => this.queue.offer(a));
+  }
+
+  offerAll(cs: Iterable<C>): IO<RC | RA, EC | EA, boolean> {
+    return IO.foreach(cs, this.f).flatMap((as) => this.queue.offerAll(as));
+  }
+
+  shutdown: UIO<void> = this.queue.shutdown;
+
+  size: UIO<number> = this.queue.size;
+}
+
+/**
+ * Transforms elements enqueued into this queue with an effectful function.
+ *
+ * @tsplus pipeable fncts.io.Queue.Enqueue contramapIO
+ */
+export function contramapEnqueueIO<A, RC, EC, C>(f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, B>(self: PEnqueue<RA, RB, EA, EB, A, B>) => {
+    concrete(self);
+    return new ContramapIO(self, f);
+  };
+}
+
+class MapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PDequeueInternal<RA, RB | RC, EA, EB | EC, A, C> {
+  readonly [DequeueTypeId]: DequeueTypeId = DequeueTypeId;
+  readonly [QueueTypeId]: QueueTypeId     = QueueTypeId;
+  declare _RA: () => RA;
+  declare _RB: () => RB | RC;
+  declare _EA: () => EA;
+  declare _EB: () => EB | EC;
+  declare _A: (_: A) => void;
+  declare _B: () => C;
+  constructor(readonly queue: PDequeueInternal<RA, RB, EA, EB, A, B>, readonly f: (b: B) => IO<RC, EC, C>) {}
+
+  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+
+  capacity: number = this.queue.capacity;
+
+  isShutdown: UIO<boolean> = this.queue.isShutdown;
+
+  shutdown: UIO<void> = this.queue.shutdown;
+
+  size: UIO<number> = this.queue.size;
+
+  take: IO<RB | RC, EB | EC, C> = this.queue.take.flatMap(this.f);
+
+  takeAll: IO<RB | RC, EB | EC, Conc<C>> = this.queue.takeAll.flatMap((bs) => IO.foreach(bs, this.f));
+
+  takeUpTo(n: number): IO<RB | RC, EB | EC, Conc<C>> {
+    return this.queue.takeUpTo(n).flatMap((bs) => IO.foreach(bs, this.f));
+  }
+}
+
+/**
+ * Transforms elements enqueued into this queue with an effectful function.
+ *
+ * @tsplus pipeable fncts.io.Queue.Dequeue mapIO
+ */
+export function mapDequeueIO<B, RC, EC, C>(f: (b: B) => IO<RC, EC, C>, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, A>(self: PDequeue<RA, RB, EA, EB, A, B>) => {
+    concrete(self);
+    return new MapIO(self, f);
+  };
 }

package/_src/Queue/api/filterInputIO.ts

@@ -1,13 +1,8 @@
-import { concrete, QueueInternal } from "@fncts/io/Queue/definition";
-
-export class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends QueueInternal<
-  RA | R2,
-  RB,
-  EA | E2,
-  EB,
-  A1,
-  B
-> {
+import type { PEnqueue, PEnqueueInternal } from "@fncts/io/Queue/definition";
+
+import { concrete, EnqueueTypeId, QueueInternal, QueueTypeId } from "@fncts/io/Queue/definition";
+
+class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends QueueInternal<RA | R2, RB, EA | E2, EB, A1, B> {
   constructor(readonly queue: QueueInternal<RA, RB, EA, EB, A, B>, readonly f: (_: A1) => IO<R2, E2, boolean>) {
     super();
   }
@@ -49,27 +44,77 @@ export class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends Q
 /**
  * Like `filterInput`, but uses an effectful function to filter the elements.
  *
- * @tsplus fluent fncts.io.Queue filterInputIO
+ * @tsplus pipeable fncts.io.Queue filterInputIO
  */
-export function filterInputIO_<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>(
-  queue: PQueue<RA, RB, EA, EB, A, B>,
-  f: (_: A1) => IO<R2, E2, boolean>,
-  __tsplusTrace?: string,
-): PQueue<RA | R2, RB, EA | E2, EB, A1, B> {
-  concrete(queue);
-  return new FilterInputIO(queue, f);
+export function filterInputIO<A, A1 extends A, R2, E2>(f: (_: A1) => IO<R2, E2, boolean>, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, B>(queue: PQueue<RA, RB, EA, EB, A, B>): PQueue<RA | R2, RB, EA | E2, EB, A1, B> => {
+    concrete(queue);
+    return new FilterInputIO(queue, f);
+  };
 }
 
 /**
  * Applies a filter to elements enqueued into this queue. Elements that do not
  * pass the filter will be immediately dropped.
  *
- * @tsplus fluent fncts.io.Queue filterInput
+ * @tsplus pipeable fncts.io.Queue filterInput
+ */
+export function filterInput<A, A1 extends A>(f: Predicate<A1>, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, B>(queue: PQueue<RA, RB, EA, EB, A, B>): PQueue<RA, RB, EA, EB, A1, B> => {
+    return queue.filterInputIO((a) => IO.succeedNow(f(a)));
+  };
+}
+
+class FilterInputEnqueueIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>
+  implements PEnqueueInternal<RA | R2, RB, EA | E2, EB, A1, B>
+{
+  readonly [EnqueueTypeId]: EnqueueTypeId = EnqueueTypeId;
+  readonly [QueueTypeId]: QueueTypeId     = QueueTypeId;
+  declare _RA: () => RA | R2;
+  declare _RB: () => RB;
+  declare _EA: () => EA | E2;
+  declare _EB: () => EB;
+  declare _A: (_: A1) => void;
+  declare _B: () => B;
+  constructor(readonly queue: PEnqueueInternal<RA, RB, EA, EB, A, B>, readonly f: (_: A1) => IO<R2, E2, boolean>) {}
+
+  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+
+  capacity: number = this.queue.capacity;
+
+  isShutdown: UIO<boolean> = this.queue.isShutdown;
+
+  offer(a: A1): IO<RA | R2, EA | E2, boolean> {
+    return this.f(a).flatMap((b) => (b ? this.queue.offer(a) : IO.succeedNow(false)));
+  }
+
+  offerAll(as: Iterable<A1>): IO<RA | R2, EA | E2, boolean> {
+    return IO.foreach(as, (a) => this.f(a).map((b) => (b ? Just(a) : Nothing()))).flatMap((ms) => {
+      const filtered = ms.compact;
+      if (filtered.isEmpty) {
+        return IO.succeedNow(false);
+      } else {
+        return this.queue.offerAll(filtered);
+      }
+    });
+  }
+
+  shutdown: UIO<void> = this.queue.shutdown;
+
+  size: UIO<number> = this.queue.size;
+}
+
+/**
+ * Like `filterInput`, but uses an effectful function to filter the elements.
+ *
+ * @tsplus pipeable fncts.io.Queue.Enqueue filterInputIO
  */
-export function filterInput_<RA, RB, EA, EB, B, A, A1 extends A>(
-  queue: PQueue<RA, RB, EA, EB, A, B>,
-  f: (_: A1) => boolean,
+export function filterInputEnqueueIO<A, A1 extends A, R2, E2>(
+  f: (_: A1) => IO<R2, E2, boolean>,
   __tsplusTrace?: string,
-): PQueue<RA, RB, EA, EB, A1, B> {
-  return queue.filterInputIO((a) => IO.succeedNow(f(a)));
+) {
+  return <RA, RB, EA, EB, B>(queue: PEnqueue<RA, RB, EA, EB, A, B>): PEnqueue<RA | R2, RB, EA | E2, EB, A1, B> => {
+    concrete(queue);
+    return new FilterInputEnqueueIO(queue, f);
+  };
 }

package/_src/Queue/api/filterOutputIO.ts

@@ -1,6 +1,8 @@
-import { concrete, QueueInternal } from "@fncts/io/Queue/definition";
+import type { PDequeue, PDequeueInternal } from "@fncts/io/Queue/definition";
 
-export class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, RB | RB1, EA, EB | EB1, A, B> {
+import { concrete, DequeueTypeId, QueueInternal, QueueTypeId } from "@fncts/io/Queue/definition";
+
+class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, RB | RB1, EA, EB | EB1, A, B> {
   constructor(readonly queue: QueueInternal<RA, RB, EA, EB, A, B>, readonly f: (b: B) => IO<RB1, EB1, boolean>) {
     super();
   }
@@ -53,24 +55,82 @@ export class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInterna
 }
 
 /**
- * @tsplus fluent fncts.io.Queue filterOutputIO
+ * @tsplus pipeable fncts.io.Queue filterOutputIO
+ */
+export function filterOutputIO<B, RB1, EB1>(f: (b: B) => IO<RB1, EB1, boolean>, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, A>(queue: PQueue<RA, RB, EA, EB, A, B>): PQueue<RA, RB | RB1, EA, EB | EB1, A, B> => {
+    concrete(queue);
+    return new FilterOutputIO(queue, f);
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.io.Queue filterOutput
  */
-export function filterOutputIO_<RA, RB, EA, EB, A, B, RB1, EB1>(
-  queue: PQueue<RA, RB, EA, EB, A, B>,
-  f: (b: B) => IO<RB1, EB1, boolean>,
-  __tsplusTrace?: string,
-): PQueue<RA, RB | RB1, EA, EB | EB1, A, B> {
-  concrete(queue);
-  return new FilterOutputIO(queue, f);
+export function filterOutput<B>(p: Predicate<B>, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, A>(queue: PQueue<RA, RB, EA, EB, A, B>): PQueue<RA, RB, EA, EB, A, B> => {
+    return queue.filterOutputIO((b) => IO.succeedNow(p(b)));
+  };
+}
+
+class FilterOutputDequeueIO<RA, RB, EA, EB, A, B, RB1, EB1>
+  implements PDequeueInternal<RA, RB | RB1, EA, EB | EB1, A, B>
+{
+  readonly [QueueTypeId]: QueueTypeId     = QueueTypeId;
+  readonly [DequeueTypeId]: DequeueTypeId = DequeueTypeId;
+  declare _RA: () => RA;
+  declare _RB: () => RB | RB1;
+  declare _EA: () => EA;
+  declare _EB: () => EB | EB1;
+  declare _A: (_: A) => void;
+  declare _B: () => B;
+  constructor(readonly queue: PDequeueInternal<RA, RB, EA, EB, A, B>, readonly f: (b: B) => IO<RB1, EB1, boolean>) {}
+
+  awaitShutdown: UIO<void> = this.queue.awaitShutdown;
+
+  capacity: number = this.queue.capacity;
+
+  isShutdown: UIO<boolean> = this.queue.isShutdown;
+
+  shutdown: UIO<void> = this.queue.shutdown;
+
+  size: UIO<number> = this.queue.size;
+
+  take: IO<RB | RB1, EB1 | EB, B> = this.queue.take.flatMap((b) =>
+    this.f(b).flatMap((p) => (p ? IO.succeedNow(b) : this.take)),
+  );
+
+  takeAll: IO<RB | RB1, EB | EB1, Conc<B>> = this.queue.takeAll.flatMap((bs) => IO.filter(bs, this.f));
+
+  loop(max: number, acc: Conc<B>): IO<RB | RB1, EB | EB1, Conc<B>> {
+    return this.queue.takeUpTo(max).flatMap((bs) => {
+      if (bs.isEmpty) {
+        return IO.succeedNow(acc);
+      }
+
+      return IO.filter(bs, this.f).flatMap((filtered) => {
+        const length = filtered.length;
+
+        if (length === max) {
+          return IO.succeedNow(acc.concat(filtered));
+        } else {
+          return this.loop(max - length, acc.concat(filtered));
+        }
+      });
+    });
+  }
+
+  takeUpTo(n: number): IO<RB | RB1, EB | EB1, Conc<B>> {
+    return IO.defer(this.loop(n, Conc.empty()));
+  }
 }
 
 /**
- * @tsplus fluent fncts.io.Queue filterOutput
+ * @tsplus pipeable fncts.io.Queue.Dequeue filterOutputIO
  */
-export function filterOutput_<RA, RB, EA, EB, A, B>(
-  queue: PQueue<RA, RB, EA, EB, A, B>,
-  p: Predicate<B>,
-  __tsplusTrace?: string,
-): PQueue<RA, RB, EA, EB, A, B> {
-  return queue.filterOutputIO((b) => IO.succeedNow(p(b)));
+export function filterOutputDequeueIO<B, RB1, EB1>(f: (b: B) => IO<RB1, EB1, boolean>, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, A>(queue: PDequeue<RA, RB, EA, EB, A, B>): PDequeue<RA, RB | RB1, EA, EB | EB1, A, B> => {
+    concrete(queue);
+    return new FilterOutputDequeueIO(queue, f);
+  };
 }

package/_src/Queue/api/operations.ts

@@ -1,3 +1,5 @@
+import type { PDequeue, PEnqueue, PQueueCommon } from "@fncts/io/Queue/definition";
+
 import { concrete } from "@fncts/io/Queue/definition";
 
 /**
@@ -8,7 +10,7 @@ import { concrete } from "@fncts/io/Queue/definition";
  * @tsplus getter fncts.io.Queue awaitShutdown
  */
 export function awaitShutdown<RA, RB, EA, EB, A, B>(
-  queue: PQueue<RA, RB, EA, EB, A, B>,
+  queue: PQueueCommon<RA, RB, EA, EB, A, B>,
   __tsplusTrace?: string,
 ): UIO<void> {
   concrete(queue);
@@ -20,7 +22,10 @@ export function awaitShutdown<RA, RB, EA, EB, A, B>(
  *
  * @tsplus getter fncts.io.Queue capacity
  */
-export function capacity<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): number {
+export function capacity<RA, RB, EA, EB, A, B>(
+  queue: PQueueCommon<RA, RB, EA, EB, A, B>,
+  __tsplusTrace?: string,
+): number {
   concrete(queue);
   return queue.capacity;
 }
@@ -31,7 +36,7 @@ export function capacity<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A,
  * @tsplus getter fncts.io.Queue isShutdown
  */
 export function isShutdown<RA, RB, EA, EB, A, B>(
-  queue: PQueue<RA, RB, EA, EB, A, B>,
+  queue: PQueueCommon<RA, RB, EA, EB, A, B>,
   __tsplusTrace?: string,
 ): UIO<boolean> {
   concrete(queue);
@@ -41,15 +46,13 @@ export function isShutdown<RA, RB, EA, EB, A, B>(
 /**
  * Places one value in the queue.
  *
- * @tsplus fluent fncts.io.Queue offer
+ * @tsplus pipeable fncts.io.Queue offer
  */
-export function offer_<RA, RB, EA, EB, A, B>(
-  queue: PQueue<RA, RB, EA, EB, A, B>,
-  a: A,
-  __tsplusTrace?: string,
-): IO<RA, EA, boolean> {
-  concrete(queue);
-  return queue.offer(a);
+export function offer<A>(a: A, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, B>(queue: PEnqueue<RA, RB, EA, EB, A, B>): IO<RA, EA, boolean> => {
+    concrete(queue);
+    return queue.offer(a);
+  };
 }
 
 /**
@@ -68,15 +71,13 @@ export function offer_<RA, RB, EA, EB, A, B>(
  * For Dropping Queue: uses `Dropping` Strategy,
  * It places the values in the queue but if there is no room it will not enqueue them and return false.
  *
- * @tsplus fluent fncts.io.Queue offerAll
+ * @tsplus pipeable fncts.io.Queue offerAll
  */
-export function offerAll_<RA, RB, EA, EB, A, B>(
-  queue: PQueue<RA, RB, EA, EB, A, B>,
-  as: Iterable<A>,
-  __tsplusTrace?: string,
-) {
-  concrete(queue);
-  return queue.offerAll(as);
+export function offerAll<A>(as: Iterable<A>, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, B>(queue: PEnqueue<RA, RB, EA, EB, A, B>) => {
+    concrete(queue);
+    return queue.offerAll(as);
+  };
 }
 
 /**
@@ -85,7 +86,7 @@ export function offerAll_<RA, RB, EA, EB, A, B>(
  *
  * @tsplus getter fncts.io.Queue shutdown
  */
-export function shutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string) {
+export function shutdown<RA, RB, EA, EB, A, B>(queue: PQueueCommon<RA, RB, EA, EB, A, B>, __tsplusTrace?: string) {
   concrete(queue);
   return queue.shutdown;
 }
@@ -97,7 +98,7 @@ export function shutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A,
  *
  * @tsplus getter fncts.io.Queue size
  */
-export function size<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string) {
+export function size<RA, RB, EA, EB, A, B>(queue: PQueueCommon<RA, RB, EA, EB, A, B>, __tsplusTrace?: string) {
   concrete(queue);
   return queue.size;
 }
@@ -108,7 +109,10 @@ export function size<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>,
  *
  * @tsplus getter fncts.io.Queue take
  */
-export function take<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<RB, EB, B> {
+export function take<RA, RB, EA, EB, A, B>(
+  queue: PDequeue<RA, RB, EA, EB, A, B>,
+  __tsplusTrace?: string,
+): IO<RB, EB, B> {
   concrete(queue);
   return queue.take;
 }
@@ -119,7 +123,7 @@ export function take<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>,
  *
  * @tsplus getter fncts.io.Queue takeAll
  */
-export function takeAll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string) {
+export function takeAll<RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string) {
   concrete(queue);
   return queue.takeAll;
 }
@@ -127,13 +131,11 @@ export function takeAll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B
 /**
  * Takes up to max number of values in the queue.
  *
- * @tsplus fluent fncts.io.Queue takeAllUpTo
+ * @tsplus pipeable fncts.io.Queue takeAllUpTo
  */
-export function takeAllUpTo_<RA, RB, EA, EB, A, B>(
-  queue: PQueue<RA, RB, EA, EB, A, B>,
-  n: number,
-  __tsplusTrace?: string,
-) {
-  concrete(queue);
-  return queue.takeUpTo(n);
+export function takeAllUpTo(n: number, __tsplusTrace?: string) {
+  return <RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>) => {
+    concrete(queue);
+    return queue.takeUpTo(n);
+  };
 }