@fncts/io 0.0.21 → 0.0.23

package/MVar/api.d.ts

@@ -0,0 +1,101 @@
+import { UIO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import type { MVar } from "./definition";
+/**
+ * @tsplus static fncts.io.MVarOps empty
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function empty<A>(): UIO<MVar<A>>;
+/**
+ * @tsplus static fncts.io.MVarOps make
+ * @tsplus static fncts.io.MVarOps __call
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function make<A>(value: A): UIO<MVar<A>>;
+/**
+ * Check whether the `MVar` is empty.
+ *
+ * Notice that the boolean value returned is just a snapshot of the state of
+ * the `MVar`. By the time you get to react on its result, the `MVar` may have
+ * been filled (or emptied) - so be extremely careful when using this
+ * operation. Use `tryTake` instead if possible.
+ * @tsplus getter fncts.io.MVar isEmpty
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function isEmpty<A>(self: MVar<A>): UIO<boolean>;
+/**
+ * A slight variation on `update` that allows a value to be returned (`b`) in
+ * addition to the modified value of the `MVar`.
+ * @tsplus fluent fncts.io.MVar modify
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function modify<A, B>(self: MVar<A>, f: (a: A) => readonly [B, A]): UIO<B>;
+/**
+ * Put a value into an `MVar`. If the `MVar` is currently full, `put` will
+ * wait until it becomes empty.
+ * @tsplus fluent fncts.io.MVar put
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function put<A>(self: MVar<A>, value: A): UIO<void>;
+/**
+ * Atomically read the contents of an `MVar`. If the `MVar` is currently
+ * empty, `read` will wait until it is full. `read` is guaranteed to receive
+ * the next `put`.
+ * @tsplus getter fncts.io.MVar read
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function read<A>(self: MVar<A>): UIO<A>;
+/**
+ * Take a value from an `MVar`, put a new value into the `MVar` and return the
+ * value taken.
+ * @tsplus fluent fncts.io.MVar swap
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function swap<A>(self: MVar<A>, value: A): UIO<A>;
+/**
+ * Return the contents of the `MVar`. If the `MVar` is currently empty, `take`
+ * will wait until it is full. After a `take`, the `MVar` is left empty.
+ * @tsplus getter fncts.io.MVar take
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function take<A>(self: MVar<A>): UIO<A>;
+/**
+ * A non-blocking version of `put`. The `tryPut` function attempts to put the
+ * value into the `MVar`, returning `true` if it was successful, or
+ * `false` otherwise.
+ * @tsplus fluent fncts.io.MVar tryPut
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function tryPut<A>(self: MVar<A>, value: A): UIO<boolean>;
+/**
+ * A non-blocking version of `read`. The `tryRead` function returns
+ * immediately, with `None` if the `MVar` was empty, or `Some(x)` if the
+ * `MVar` was full with contents `x`.
+ * @tsplus getter fncts.io.MVar tryRead
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function tryRead<A>(self: MVar<A>): UIO<Maybe<A>>;
+/**
+ * A non-blocking version of `take`. The `tryTake` action returns immediately,
+ * with `None` if the `MVar` was empty, or `Some(x)` if the `MVar` was full
+ * with contents `x`. After `tryTake`, the `MVar` is left empty.
+ * @tsplus getter fncts.io.MVar tryTake
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function tryTake<A>(self: MVar<A>): UIO<Maybe<A>>;
+/**
+ * Replaces the contents of an `MVar` with the result of `f(a)`.
+ * @tsplus fluent fncts.io.MVar update
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function update<A>(self: MVar<A>, f: (a: A) => A): UIO<void>;
+/**
+ * @tsplus static fncts.io.MVarOps unsafeEmpty
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function unsafeEmpty<A>(): MVar<A>;
+/**
+ * @tsplus static fncts.io.MVarOps unsafeMake
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function unsafeMake<A>(value: A): MVar<A>;

package/MVar/definition.d.ts

@@ -0,0 +1,43 @@
+import { TRef } from "@fncts/io/TRef/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+export declare const MVarVariance: unique symbol;
+export type MVarVariance = typeof MVarVariance;
+export declare const MVarTypeId: unique symbol;
+export type MVarTypeId = typeof MVarTypeId;
+/**
+ * An `MVar<A>` is a mutable location that is either empty or contains a value
+ * of type `A`. It has two fundamental operations: `put` which fills an `MVar`
+ * if it is empty and blocks otherwise, and `take` which empties an `MVar` if it
+ * is full and blocks otherwise. They can be used in multiple different ways:
+ *
+ *   - As synchronized mutable variables,
+ *   - As channels, with `take` and `put` as `receive` and `send`, and
+ *   - As a binary semaphore `MVar<void>`, with `take` and `put` as `wait` and
+ *     `signal`.
+ *
+ * They were introduced in the paper "Concurrent Haskell" by Simon Peyton Jones,
+ * Andrew Gordon and Sigbjorn Finne.
+ *
+ * @tsplus type fncts.io.MVar
+ * @tsplus companion fncts.io.MVarOps
+ */
+export interface MVar<in out A> {
+    readonly [MVarVariance]: {
+        _A: (_: A) => A;
+    };
+    readonly [MVarTypeId]: MVarTypeId;
+}
+export declare class MVarInternal<in out A> implements MVar<A> {
+    readonly content: TRef<Maybe<A>>;
+    readonly [MVarTypeId]: MVarTypeId;
+    [MVarVariance]: {
+        _A: (_: A) => A;
+    };
+    constructor(content: TRef<Maybe<A>>);
+}
+/**
+ * @tsplus static fncts.io.MVarOps concrete
+ * @tsplus macro remove
+ * @tsplus location "@fncts/io/MVar/definition"
+ */
+export declare function concrete<A>(_: MVar<A>): asserts _ is MVarInternal<A>;

package/MVar.d.ts

@@ -0,0 +1,2 @@
+export * from "./MVar/api.js";
+export * from "./MVar/definition.js";

package/Push/api.d.ts

@@ -0,0 +1,235 @@
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Duration } from "@fncts/base/data/Duration/definition";
+import { Fiber } from "@fncts/io/Fiber/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Environment } from "@fncts/base/data/Environment/definition";
+import { Future } from "@fncts/io/Future";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Schedule } from "@fncts/io/Schedule/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import { Nothing, Just, Maybe } from "@fncts/base/data/Maybe/definition";
+import { FiberId } from "@fncts/base/data/FiberId/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { _A, _E, _R } from "@fncts/base/types";
+import { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import { Emitter, Push, PushTypeId, PushVariance } from "./definition.js";
+/**
+ * @tsplus pipeable fncts.io.Push as
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function as<B>(b: Lazy<B>): <R, E, A>(self: Push<R, E, A>) => Push<R, E, B>;
+/**
+ * @tsplus static fncts.io.PushOps combineLatest
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function combineLatest<A extends ReadonlyArray<Push<any, any, any>>>(streams: [...A]): Push<_R<A[number]>, _E<A[number]>, {
+    [K in keyof A]: [A[K]] extends [Push<any, any, infer A>] ? A : never;
+}>;
+export declare function combineLatest<R, E, A>(streams: Iterable<Push<R, E, A>>): Push<R, E, ReadonlyArray<A>>;
+/**
+ * @tsplus pipeable fncts.io.PushOps combineLatestWith
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function combineLatestWith<A, R1, E1, B, C>(that: Push<R1, E1, B>, f: (a: A, b: B) => C): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, C>;
+/**
+ * @tsplus pipeable fncts.io.Push debounce
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function debounce(duration: Lazy<Duration>): <R, E, A>(self: Push<R, E, A>) => Push<R, E, A>;
+/**
+ * @tsplus static fncts.io.PushOps defer
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function defer<R, E, A>(self: Lazy<Push<R, E, A>>): Push<R, E, A>;
+/**
+ * @tsplus pipeable fncts.io.Push flatMapConcurrentBounded
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function flatMapConcurrentBounded<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>, concurrency: number): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B>;
+/**
+ * @tsplus pipeable fncts.io.Push flatMapConcurrentUnbounded
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function flatMapConcurrentUnbounded<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B>;
+/**
+ * @tsplus pipeable fncts.io.Push flatMapConcurrent
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function flatMapConcurrent<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B>;
+/**
+ * @tsplus pipeable fncts.io.Push flatMap
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function flatMap<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B>;
+/**
+ * @tsplus getter fncts.io.Push flatten
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function flatten<R, E, R1, E1, A>(self: Push<R, E, Push<R1, E1, A>>): Push<R | R1, E | E1, A>;
+/**
+ * @tsplus static fncts.io.PushOps fromIO
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function fromIO<R, E, A>(io: Lazy<IO<R, E, A>>): Push<R, E, A>;
+/**
+ * @tsplus static fncts.io.PushOps fromAsyncIterable
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function fromAsyncIterable<A>(iterable: AsyncIterable<A>): Push<never, never, A>;
+/**
+ * @tsplus static fncts.io.PushOps fromIterable
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function fromIterable<A>(iterable: Iterable<A>): Push<never, never, A>;
+/**
+ * @tsplus getter fncts.io.Push multicast
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function multicast<R, E, A>(self: Push<R, E, A>): Push<R, E, A>;
+interface MulticastObserver<E, A> {
+    readonly emitter: Emitter<any, E, A>;
+    readonly environment: Environment<any>;
+    readonly future: Future<never, void>;
+}
+export declare class Multicast<R, E, A> implements Push<R, E, A>, Emitter<never, E, A> {
+    readonly push: Push<R, E, A>;
+    readonly [PushTypeId]: PushTypeId;
+    [PushVariance]: {
+        readonly _R: (_: never) => R;
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
+    protected observers: Array<MulticastObserver<E, A>>;
+    protected fiber: Fiber<never, unknown> | undefined;
+    constructor(push: Push<R, E, A>);
+    run<R1>(emitter: Emitter<R1, E, A>): IO<R | R1 | Scope, never, unknown>;
+    emit(value: A): import("../IO.js").IO<never, never, void>;
+    failCause(cause: Cause<E>): import("../IO.js").IO<never, never, void>;
+    get end(): import("../IO.js").IO<never, never, void>;
+    protected runEvent(value: A, observer: MulticastObserver<E, A>): import("../IO.js").FIO<never, unknown>;
+    protected runFailCause(cause: Cause<E>, observer: MulticastObserver<E, A>): import("../IO.js").FIO<never, boolean>;
+    protected runEnd(observer: MulticastObserver<E, A>): import("../IO.js").FIO<never, boolean>;
+    protected cleanup(): import("../IO.js").UIO<void>;
+}
+/**
+ * @tsplus getter fncts.io.Push hold
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function hold<R, E, A>(self: Push<R, E, A>): Push<R, E, A>;
+export declare class Hold<R, E, A> extends Multicast<R, E, A> {
+    readonly push: Push<R, E, A>;
+    readonly value: AtomicReference<import("@fncts/base/data/Maybe.js").Maybe<A>>;
+    protected pendingEmitters: Array<readonly [Emitter<unknown, E, A>, Array<A>]>;
+    protected scheduledFiber: Fiber<any, any> | null;
+    constructor(push: Push<R, E, A>);
+    run<R1>(emitter: Emitter<R1, E, A>): IO<R | R1 | Scope, never, void>;
+    emit(value: A): import("../IO.js").IO<never, never, void>;
+    failCause(cause: Cause<E>): import("../IO.js").IO<never, never, void>;
+    get end(): import("../IO.js").IO<never, never, void>;
+    protected shouldScheduleFlush(): boolean;
+    protected scheduleFlush<R>(observer: Emitter<R, E, A>): import("../IO.js").IO<import("../Scope.js").Scope, never, import("../Fiber.js").Fiber.Runtime<never, void>>;
+    protected flushPending(): import("../IO.js").UIO<void>;
+    protected addValue(value: A): void;
+}
+/**
+ * @tsplus pipeable fncts.io.Push map 1
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function map<A, B>(f: (a: A) => B): <R, E>(self: Push<R, E, A>) => Push<R, E, B>;
+/**
+ * @tsplus pipeable fncts.io.Push mapError
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function mapError<E, E1>(f: (e: E) => E1): <R, A>(self: Push<R, E, A>) => Push<R, E1, A>;
+/**
+ * @tsplus pipeable fncts.io.Push mapErrorCause
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function mapErrorCause<E, E1>(f: (cause: Cause<E>) => Cause<E1>): <R, A>(self: Push<R, E, A>) => Push<R, E1, A>;
+/**
+ * @tsplus pipeable fncts.io.Push mapIO
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function mapIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B>;
+/**
+ * @tsplus pipeable fncts.io.Push merge
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function merge<R1, E1, B>(that: Push<R1, E1, B>): <R, E, A>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B | A>;
+/**
+ * @tsplus static fncts.io.PushOps mergeAll
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function mergeAll<A extends ReadonlyArray<Push<any, any, any>>>(streams: [...A]): Push<_R<A[number]>, _E<A[number]>, _A<A[number]>>;
+export declare function mergeAll<R, E, A>(streams: Iterable<Push<R, E, A>>): Push<R, E, A>;
+/**
+ * @tsplus static fncts.io.PushOps repeatIOMaybe
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function repeatIOMaybe<R, E, A>(io: IO<R, Maybe<E>, A>, __tsplusTrace?: string): Push<R, E, A>;
+/**
+ * @tsplus getter fncts.io.Push runCollect
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function runCollect<R, E, A>(self: Push<R, E, A>): IO<R | Scope, E, Conc<A>>;
+/**
+ * @tsplus getter fncts.io.Push runDrain
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function runDrain<R, E, A>(self: Push<R, E, A>): IO<R | Scope, E, void>;
+/**
+ * @tsplus static fncts.io.PushOps scoped
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function scoped<R, E, A>(io: Lazy<IO<R, E, A>>, __tsplusTrace?: string): Push<Exclude<R, Scope>, E, A>;
+/**
+ * @tsplus static fncts.io.PushOps succeed
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function succeed<A>(value: Lazy<A>): Push<never, never, A>;
+/**
+ * @tsplus pipeable fncts.io.PushOps switchMap
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function switchMap<A, R1, E1, B>(f: (a: A) => Push<R1, E1, B>): <R, E>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, B>;
+/**
+ * @tsplus pipeable fncts.io.Push transform
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function transform<R1 = never>(f: <R, E, A>(io: IO<R, E, A>) => IO<R | R1, E, A>): <R, E, A>(self: Push<R, E, A>) => Push<R1 | R, E, A>;
+/**
+ * @tsplus static fncts.io.PushOps unfold
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function unfold<S, A>(s: S, f: (s: S) => Maybe<readonly [A, S]>): Push<never, never, A>;
+/**
+ * @tsplus static fncts.io.PushOps unfoldIO
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function unfoldIO<S, R, E, A>(s: S, f: (s: S) => IO<R, E, Maybe<readonly [A, S]>>): Push<R, E, A>;
+/**
+ * @tsplus pipeable fncts.io.Push untilFuture
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function untilFuture<E1, B>(future: Future<E1, B>): <R, E, A>(self: Push<R, E, A>) => Push<R, E1 | E, A>;
+/**
+ * @tsplus pipeable fncts.io.Push untilPush
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function untilPush<R1, E1, B>(signal: Push<R1, E1, B>): <R, E, A>(self: Push<R, E, A>) => Push<R1 | R, E1 | E, A>;
+/**
+ * @tsplus static fncts.io.PushOps unwrap
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function unwrap<R, E, R1, E1, A>(io: IO<R, E, Push<R1, E1, A>>): Push<R | R1, E | E1, A>;
+/**
+ * @tsplus static fncts.io.PushOps unwrapScoped
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare function unwrapScoped<R, E, R1, E1, A>(self: IO<R, E, Push<R1, E1, A>>, __tsplusTrace?: string): Push<R1 | Exclude<R, Scope>, E | E1, A>;
+/**
+ * @tsplus static fncts.io.PushOps never
+ * @tsplus location "@fncts/io/Push/api"
+ */
+export declare const never: Push<never, never, never>;
+export {};

package/Push/definition.d.ts

@@ -0,0 +1,41 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+export declare const PushVariance: unique symbol;
+export type PushVariance = typeof PushVariance;
+export declare const PushTypeId: unique symbol;
+export type PushTypeId = typeof PushTypeId;
+/**
+ * @tsplus type fncts.io.Push
+ * @tsplus companion fncts.io.PushOps
+ */
+export declare class Push<R, E, A> {
+    readonly run: <R1>(emitter: Emitter<R1, E, A>) => IO<R | R1 | Scope, never, unknown>;
+    readonly [PushTypeId]: PushTypeId;
+    [PushVariance]: {
+        readonly _R: (_: never) => R;
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
+    constructor(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 declare class Emitter<R, E, A> {
+    readonly emit: (value: A) => IO<R, never, unknown>;
+    readonly failCause: (cause: Cause<E>) => IO<R, never, void>;
+    readonly end: IO<R, never, void>;
+    constructor(emit: (value: A) => IO<R, never, unknown>, failCause: (cause: Cause<E>) => IO<R, never, void>, end: IO<R, never, void>);
+}
+/**
+ * @tsplus static fncts.io.PushOps __call
+ * @tsplus location "@fncts/io/Push/definition"
+ */
+export declare function makePush<R, E, A>(run: <R1>(emitter: Emitter<R1, E, A>) => IO<R | R1 | Scope, never, unknown>): Push<R, E, A>;
+/**
+ * @tsplus static fncts.io.Push.EmitterOps __call
+ * @tsplus location "@fncts/io/Push/definition"
+ */
+export declare 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>;

package/Push/internal.d.ts

@@ -0,0 +1,11 @@
+import { CountdownLatch } from "@fncts/io/CountdownLatch";
+import { IO } from "@fncts/io/IO/definition";
+export declare 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>;
+export declare const EarlyExitTypeId: unique symbol;
+export type EarlyExitTypeId = typeof EarlyExitTypeId;
+export declare class EarlyExit {
+    readonly [EarlyExitTypeId]: EarlyExitTypeId;
+}
+export declare function isEarlyExit(u: unknown): u is EarlyExit;
+export declare const earlyExit: import("../IO").UIO<never>;
+export declare function onEarlyExit<R1, E1, B>(onEarlyExit: IO<R1, E1, B>): <R, E, A>(self: import("../IO").IO<R, E, A>) => import("../IO").IO<R1 | R, E1 | E, B | A>;

package/Push.d.ts

@@ -0,0 +1,3 @@
+export * from "./Push/api.js";
+export * from "./Push/definition.js";
+export * from "./Push/internal.js";

package/Queue/api/dimapIO.d.ts

@@ -0,0 +1,102 @@
+import { IO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { PQueue } from "@fncts/io/Queue/definition";
+import type { UIO } from "@fncts/io/IO";
+import type { PDequeue, PDequeueInternal, PEnqueue, PEnqueueInternal } from "@fncts/io/Queue/definition";
+import { DequeueTypeId, EnqueueTypeId, QueueTypeId, QueueVariance } from "@fncts/io/Queue/definition";
+/**
+ * Transforms elements enqueued into and dequeued from this queue with the
+ * specified effectual functions.
+ * @tsplus pipeable fncts.io.Queue dimap
+ * @tsplus location "@fncts/io/Queue/api/dimapIO"
+ */
+export declare function dimap<A, B, C, D>(f: (c: C) => A, g: (b: B) => D, __tsplusTrace?: string): <RA, RB, EA, EB>(self: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, C, D>;
+/**
+ * Transforms elements enqueued into and dequeued from this queue with the
+ * specified effectual functions.
+ * @tsplus pipeable fncts.io.Queue dimapIO
+ * @tsplus location "@fncts/io/Queue/api/dimapIO"
+ */
+export declare 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): <RA, RB, EA, EB>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RC | RA, RD | RB, EC | EA, ED | EB, C, D>;
+/**
+ * Transforms elements enqueued into this queue with an effectful function.
+ * @tsplus pipeable fncts.io.Queue contramapIO
+ * @tsplus location "@fncts/io/Queue/api/dimapIO"
+ */
+export declare function contramapInputIO<A, RC, EC, C>(f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RC | RA, RB, EC | EA, EB, C, B>;
+/**
+ * Transforms elements enqueued into this queue with an effectful function.
+ * @tsplus pipeable fncts.io.Queue contramap
+ * @tsplus location "@fncts/io/Queue/api/dimapIO"
+ */
+export declare function contramapInput<A, C>(f: (c: C) => A, __tsplusTrace?: string): <RA, RB, EA, EB, B>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, C, B>;
+/**
+ * Transforms elements dequeued from this queue with an effectful function.
+ * @tsplus pipeable fncts.io.Queue mapIO
+ * @tsplus location "@fncts/io/Queue/api/dimapIO"
+ */
+export declare function mapIO<B, R2, E2, C>(f: (b: B) => IO<R2, E2, C>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA, R2 | RB, EA, E2 | EB, A, C>;
+/**
+ * Transforms elements dequeued from this queue with a function.
+ * @tsplus pipeable fncts.io.Queue map
+ * @tsplus location "@fncts/io/Queue/api/dimapIO"
+ */
+export declare function map<B, C>(f: (b: B) => C, __tsplusTrace?: string): <RA, RB, EA, EB, A>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, C>;
+declare class ContramapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PEnqueueInternal<RA | RC, RB, EA | EC, EB, C, B> {
+    readonly queue: PEnqueueInternal<RA, RB, EA, EB, A, B>;
+    readonly f: (c: C) => IO<RC, EC, A>;
+    readonly [EnqueueTypeId]: EnqueueTypeId;
+    readonly [QueueTypeId]: QueueTypeId;
+    [QueueVariance]: {
+        readonly _RA: (_: never) => RA | RC;
+        readonly _RB: (_: never) => RB;
+        readonly _EA: (_: never) => EA | EC;
+        readonly _EB: (_: never) => EB;
+        readonly _A: (_: C) => void;
+        readonly _B: (_: never) => B;
+    };
+    constructor(queue: PEnqueueInternal<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>);
+    awaitShutdown: UIO<void>;
+    capacity: number;
+    isShutdown: UIO<boolean>;
+    offer(c: C): IO<RC | RA, EA | EC, boolean>;
+    offerAll(cs: Iterable<C>): IO<RC | RA, EC | EA, boolean>;
+    shutdown: UIO<void>;
+    size: UIO<number>;
+}
+/**
+ * Transforms elements enqueued into this queue with an effectful function.
+ * @tsplus pipeable fncts.io.Queue.Enqueue contramapIO
+ * @tsplus location "@fncts/io/Queue/api/dimapIO"
+ */
+export declare function contramapEnqueueIO<A, RC, EC, C>(f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PEnqueue<RA, RB, EA, EB, A, B>) => ContramapIO<RA, RB, EA, EB, A, B, RC, EC, C>;
+declare class MapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PDequeueInternal<RA, RB | RC, EA, EB | EC, A, C> {
+    readonly queue: PDequeueInternal<RA, RB, EA, EB, A, B>;
+    readonly f: (b: B) => IO<RC, EC, C>;
+    readonly [DequeueTypeId]: DequeueTypeId;
+    readonly [QueueTypeId]: QueueTypeId;
+    [QueueVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _RB: (_: never) => RB | RC;
+        readonly _EA: (_: never) => EA;
+        readonly _EB: (_: never) => EB | EC;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => C;
+    };
+    constructor(queue: PDequeueInternal<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RC, EC, C>);
+    awaitShutdown: UIO<void>;
+    capacity: number;
+    isShutdown: UIO<boolean>;
+    shutdown: UIO<void>;
+    size: UIO<number>;
+    take: IO<RB | RC, EB | EC, C>;
+    takeAll: IO<RB | RC, EB | EC, Conc<C>>;
+    takeUpTo(n: number): IO<RB | RC, EB | EC, Conc<C>>;
+}
+/**
+ * Transforms elements enqueued into this queue with an effectful function.
+ * @tsplus pipeable fncts.io.Queue.Dequeue mapIO
+ * @tsplus location "@fncts/io/Queue/api/dimapIO"
+ */
+export declare function mapDequeueIO<B, RC, EC, C>(f: (b: B) => IO<RC, EC, C>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(self: PDequeue<RA, RB, EA, EB, A, B>) => MapIO<RA, RB, EA, EB, A, B, RC, EC, C>;
+export {};

package/Queue/api/filterInputIO.d.ts

@@ -0,0 +1,25 @@
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { Just, Nothing } from "@fncts/base/data/Maybe/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { PQueue } from "@fncts/io/Queue/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+import type { PEnqueue } from "@fncts/io/Queue/definition";
+/**
+ * Like `filterInput`, but uses an effectful function to filter the elements.
+ * @tsplus pipeable fncts.io.Queue filterInputIO
+ * @tsplus location "@fncts/io/Queue/api/filterInputIO"
+ */
+export declare function filterInputIO<A, A1 extends A, R2, E2>(f: (_: A1) => IO<R2, E2, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<R2 | RA, RB, E2 | EA, EB, A1, B>;
+/**
+ * Applies a filter to elements enqueued into this queue. Elements that do not
+ * pass the filter will be immediately dropped.
+ * @tsplus pipeable fncts.io.Queue filterInput
+ * @tsplus location "@fncts/io/Queue/api/filterInputIO"
+ */
+export declare function filterInput<A, A1 extends A>(f: Predicate<A1>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A1, B>;
+/**
+ * Like `filterInput`, but uses an effectful function to filter the elements.
+ * @tsplus pipeable fncts.io.Queue.Enqueue filterInputIO
+ * @tsplus location "@fncts/io/Queue/api/filterInputIO"
+ */
+export declare function filterInputEnqueueIO<A, A1 extends A, R2, E2>(f: (_: A1) => IO<R2, E2, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(queue: PEnqueue<RA, RB, EA, EB, A, B>) => PEnqueue<R2 | RA, RB, E2 | EA, EB, A1, B>;

package/Queue/api/filterOutputIO.d.ts

@@ -0,0 +1,20 @@
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { PQueue } from "@fncts/io/Queue/definition";
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+import type { PDequeue } from "@fncts/io/Queue/definition";
+/**
+ * @tsplus pipeable fncts.io.Queue filterOutputIO
+ * @tsplus location "@fncts/io/Queue/api/filterOutputIO"
+ */
+export declare function filterOutputIO<B, RB1, EB1>(f: (b: B) => IO<RB1, EB1, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA, RB1 | RB, EA, EB1 | EB, A, B>;
+/**
+ * @tsplus pipeable fncts.io.Queue filterOutput
+ * @tsplus location "@fncts/io/Queue/api/filterOutputIO"
+ */
+export declare function filterOutput<B>(p: Predicate<B>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(queue: import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>) => import("@fncts/io/Queue/definition").PQueue<RA, RB, EA, EB, A, B>;
+/**
+ * @tsplus pipeable fncts.io.Queue.Dequeue filterOutputIO
+ * @tsplus location "@fncts/io/Queue/api/filterOutputIO"
+ */
+export declare function filterOutputDequeueIO<B, RB1, EB1>(f: (b: B) => IO<RB1, EB1, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(queue: PDequeue<RA, RB, EA, EB, A, B>) => PDequeue<RA, RB1 | RB, EA, EB1 | EB, A, B>;