@fncts/io 0.0.20 → 0.0.21

package/IO/definition.d.ts

@@ -48,17 +48,23 @@ export declare const IOAspects: IOAspects;
  */
 export declare function unifyIO<X extends IO<any, any, any>>(self: X): IO<[
     X
-] extends [{
-    _R: () => infer R;
-}] ? R : never, [
+] extends [
+    {
+        _R: () => infer R;
+    }
+] ? R : never, [
     X
-] extends [{
-    _E: () => infer E;
-}] ? E : never, [
+] extends [
+    {
+        _E: () => infer E;
+    }
+] ? E : never, [
     X
-] extends [{
-    _A: () => infer A;
-}] ? A : never>;
+] extends [
+    {
+        _A: () => infer A;
+    }
+] ? A : never>;
 export type UIO<A> = IO<never, never, A>;
 export type URIO<R, A> = IO<R, never, A>;
 export type FIO<E, A> = IO<never, E, A>;

package/Layer/MemoMap.d.ts

@@ -33,12 +33,12 @@ export declare function makeMemoMap(__tsplusTrace?: string): UIO<MemoMap>;
  */
 export declare function build<R, E, A>(self: Layer<R, E, A>, __tsplusTrace?: string): IO<R | Scope, E, Environment<A>>;
 /**
- * @tsplus fluent fncts.io.Layer build
+ * @tsplus pipeable fncts.io.Layer build
  * @tsplus location "@fncts/io/Layer/MemoMap"
  */
-export declare function build_<R, E, A>(self: Layer<R, E, A>, scope: Scope, __tsplusTrace?: string): IO<R, E, Environment<A>>;
+export declare function build_(scope: Scope, __tsplusTrace?: string): <R, E, A>(self: import("@fncts/io/Layer/definition").Layer<R, E, A>) => import("../IO").IO<R, E, import("@fncts/base/data/Environment").Environment<A>>;
 /**
- * @tsplus fluent fncts.io.Layer scope
+ * @tsplus pipeable fncts.io.Layer scope
  * @tsplus location "@fncts/io/Layer/MemoMap"
  */
-export declare function scope<R, E, A>(layer: Layer<R, E, A>, scope: Scope, __tsplusTrace?: string): IO<never, never, (_: MemoMap) => IO<R, E, Environment<A>>>;
+export declare function scope(scope: Scope, __tsplusTrace?: string): <R, E, A>(layer: import("@fncts/io/Layer/definition").Layer<R, E, A>) => import("../IO").IO<never, never, (_: MemoMap) => import("../IO").IO<R, E, import("@fncts/base/data/Environment").Environment<A>>>;

package/Layer/api.d.ts

@@ -8,41 +8,41 @@ import { Schedule } from "@fncts/io/Schedule/definition";
 import type { Spreadable } from "@fncts/base/types";
 import { Layer } from "@fncts/io/Layer/definition";
 /**
- * @tsplus fluent fncts.io.Layer and
+ * @tsplus pipeable fncts.io.Layer and
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function and_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): Layer<RIn | RIn1, E | E1, ROut | ROut1>;
+export declare function and<RIn1, E1, ROut1>(that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn1 | RIn, E1 | E, ROut1 | ROut>;
 /**
  * Feeds the output services of this layer into the input of the specified
  * layer, resulting in a new layer with the inputs of this layer, and the
  * outputs of both layers.
- * @tsplus fluent fncts.io.Layer andTo
+ * @tsplus pipeable fncts.io.Layer andTo
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function andTo_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut | ROut1>;
+export declare function andTo<RIn1, E1, ROut1>(that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn | Exclude<RIn1, ROut>, E1 | E, ROut1 | ROut>;
 /**
  * Feeds the output services of this layer into the input of the specified
  * layer, resulting in a new layer with the inputs of this layer, and the
  * outputs of both layers.
- * @tsplus fluent fncts.io.Layer andTo
+ * @tsplus pipeable fncts.io.Layer andTo
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function andUsing_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn1, E1, ROut1>, that: Layer<RIn, E, ROut>, __tsplusTrace?: string): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut | ROut1>;
+export declare function andUsing<RIn, E, ROut>(that: Layer<RIn, E, ROut>, __tsplusTrace?: string): <RIn1, E1, ROut1>(self: Layer<RIn1, E1, ROut1>) => Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut | ROut1>;
 /**
- * @tsplus fluent fncts.io.Layer catchAll
+ * @tsplus pipeable fncts.io.Layer catchAll
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function catchAll_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, f: (e: E) => Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): Layer<RIn | RIn1, E1, ROut | ROut1>;
+export declare function catchAll<E, RIn1, E1, ROut1>(f: (e: E) => Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): <RIn, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn1 | RIn, E1, ROut1 | ROut>;
 /**
- * @tsplus fluent fncts.io.Layer flatMap
+ * @tsplus pipeable fncts.io.Layer flatMap
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function flatMap_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, f: (r: Environment<ROut>) => Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): Layer<RIn | RIn1, E | E1, ROut1>;
+export declare function flatMap<ROut, RIn1, E1, ROut1>(f: (r: Environment<ROut>) => Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): <RIn, E>(self: Layer<RIn, E, ROut>) => Layer<RIn1 | RIn, E1 | E, ROut1>;
 /**
- * @tsplus fluent fncts.io.Layer compose
+ * @tsplus pipeable fncts.io.Layer compose
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function compose_<RIn, E, ROut, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<ROut, E1, ROut1>, __tsplusTrace?: string): Layer<RIn, E | E1, ROut1>;
+export declare function compose<ROut, E1, ROut1>(that: Layer<ROut, E1, ROut1>, __tsplusTrace?: string): <RIn, E>(self: Layer<RIn, E, ROut>) => Layer<RIn, E1 | E, ROut1>;
 /**
  * @tsplus static fncts.io.LayerOps environment
  * @tsplus location "@fncts/io/Layer/api"
@@ -117,35 +117,35 @@ export declare function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Lay
  */
 export declare function haltNow(defect: unknown, __tsplusTrace?: string): Layer<never, never, never>;
 /**
- * @tsplus fluent fncts.io.Layer matchCauseLayer
+ * @tsplus pipeable fncts.io.Layer matchCauseLayer
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function matchCauseLayer_<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(self: Layer<RIn, E, ROut>, failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>, success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>, __tsplusTrace?: string): Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2>;
+export declare function matchCauseLayer<E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(failure: (cause: Cause<E>) => Layer<RIn1, E1, ROut1>, success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>, __tsplusTrace?: string): <RIn>(self: Layer<RIn, E, ROut>) => Layer<RIn1 | RIn2 | RIn, E1 | E2, ROut1 | ROut2>;
 /**
- * @tsplus fluent fncts.io.Layer matchLayer
+ * @tsplus pipeable fncts.io.Layer matchLayer
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function matchLayer_<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(self: Layer<RIn, E, ROut>, failure: (e: E) => Layer<RIn1, E1, ROut1>, success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>, __tsplusTrace?: string): Layer<RIn | RIn1 | RIn2, E1 | E2, ROut1 | ROut2>;
+export declare function matchLayer<E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2>(failure: (e: E) => Layer<RIn1, E1, ROut1>, success: (r: Environment<ROut>) => Layer<RIn2, E2, ROut2>, __tsplusTrace?: string): <RIn>(self: Layer<RIn, E, ROut>) => Layer<RIn1 | RIn2 | RIn, E1 | E2, ROut1 | ROut2>;
 /**
- * @tsplus fluent fncts.io.Layer map
+ * @tsplus pipeable fncts.io.Layer map
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function map_<RIn, E, ROut, ROut1>(self: Layer<RIn, E, ROut>, f: (r: Environment<ROut>) => Environment<ROut1>, __tsplusTrace?: string): Layer<RIn, E, ROut1>;
+export declare function map<ROut, ROut1>(f: (r: Environment<ROut>) => Environment<ROut1>, __tsplusTrace?: string): <RIn, E>(self: Layer<RIn, E, ROut>) => Layer<RIn, E, ROut1>;
 /**
- * @tsplus fluent fncts.io.Layer mapError
+ * @tsplus pipeable fncts.io.Layer mapError
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function mapError_<RIn, E, ROut, E1>(self: Layer<RIn, E, ROut>, f: (e: E) => E1, __tsplusTrace?: string): Layer<RIn, E1, ROut>;
+export declare function mapError<E, E1>(f: (e: E) => E1, __tsplusTrace?: string): <RIn, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn, E1, ROut>;
 /**
  * @tsplus getter fncts.io.Layer memoize
  * @tsplus location "@fncts/io/Layer/api"
  */
 export declare function memoize<RIn, E, ROut>(self: Layer<RIn, E, ROut>, __tsplusTrace?: string): URIO<Scope, Layer<RIn, E, ROut>>;
 /**
- * @tsplus fluent fncts.io.Layer orElse
+ * @tsplus pipeable fncts.io.Layer orElse
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function orElse_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): Layer<RIn | RIn1, E | E1, ROut | ROut1>;
+export declare function orElse<RIn1, E1, ROut1>(that: Layer<RIn1, E1, ROut1>, __tsplusTrace?: string): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn1 | RIn, E1 | E, ROut1 | ROut>;
 /**
  * @tsplus getter fncts.io.Layer orHalt
  * @tsplus location "@fncts/io/Layer/api"
@@ -157,10 +157,10 @@ export declare function orHalt<RIn, E, ROut>(self: Layer<RIn, E, ROut>, __tsplus
  */
 export declare function passthrough<RIn extends Spreadable, E, ROut extends Spreadable>(self: Layer<RIn, E, ROut>, __tsplusTrace?: string): Layer<RIn, E, RIn & ROut>;
 /**
- * @tsplus fluent fncts.io.Layer retry
+ * @tsplus pipeable fncts.io.Layer retry
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function retry_<RIn, E, ROut, S, RIn1>(self: Layer<RIn, E, ROut>, schedule: Schedule.WithState<S, RIn1, E, any>, __tsplusTrace?: string): Layer<RIn | RIn1, E, ROut>;
+export declare function retry<E, S, RIn1>(schedule: Schedule.WithState<S, RIn1, E, any>, __tsplusTrace?: string): <RIn, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn1 | RIn, E, ROut>;
 /**
  * @tsplus static fncts.io.LayerOps scoped
  * @tsplus location "@fncts/io/Layer/api"
@@ -197,12 +197,12 @@ export declare function succeedEnvironmentNow<A>(a: Environment<A>, __tsplusTrac
  */
 export declare function succeedNow<A>(resource: A, tag: Tag<A>, __tsplusTrace?: string): Layer<never, never, A>;
 /**
- * @tsplus fluent fncts.io.Layer to
+ * @tsplus pipeable fncts.io.Layer to
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function to_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut1>;
+export declare function to<RIn1, E1, ROut1>(that: Layer<RIn1, E1, ROut1>): <RIn, E, ROut>(self: Layer<RIn, E, ROut>) => Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut1>;
 /**
- * @tsplus fluent fncts.io.Layer using
+ * @tsplus pipeable fncts.io.Layer using
  * @tsplus location "@fncts/io/Layer/api"
  */
-export declare function using_<RIn, E, ROut, RIn1, E1, ROut1>(self: Layer<RIn1, E1, ROut1>, that: Layer<RIn, E, ROut>): Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut1>;
+export declare function using<RIn, E, ROut>(that: Layer<RIn, E, ROut>): <RIn1, E1, ROut1>(self: Layer<RIn1, E1, ROut1>) => Layer<RIn | Exclude<RIn1, ROut>, E | E1, ROut1>;

package/LogLevel.d.ts

@@ -9,29 +9,29 @@ export declare class LogLevel {
     constructor(ordinal: number, label: string, syslog: number);
 }
 /**
- * @tsplus fluent fncts.LogLevel lt
- * @tsplus operator fncts.LogLevel <
+ * @tsplus pipeable fncts.LogLevel lt
+ * @tsplus pipeable-operator fncts.LogLevel <
  * @tsplus location "@fncts/io/LogLevel"
  */
-export declare function lt(self: LogLevel, that: LogLevel): boolean;
+export declare function lt(that: LogLevel): (self: LogLevel) => boolean;
 /**
- * @tsplus fluent fncts.LogLevel lte
- * @tsplus operator fncts.LogLevel <=
+ * @tsplus pipeable fncts.LogLevel lte
+ * @tsplus pipeable-operator fncts.LogLevel <=
  * @tsplus location "@fncts/io/LogLevel"
  */
-export declare function lte(self: LogLevel, that: LogLevel): boolean;
+export declare function lte(that: LogLevel): (self: LogLevel) => boolean;
 /**
- * @tsplus fluent fncts.LogLevel gte
- * @tsplus operator fncts.LogLevel >=
+ * @tsplus pipeable fncts.LogLevel gte
+ * @tsplus pipeable-operator fncts.LogLevel >=
  * @tsplus location "@fncts/io/LogLevel"
  */
-export declare function gte(self: LogLevel, that: LogLevel): boolean;
+export declare function gte(that: LogLevel): (self: LogLevel) => boolean;
 /**
- * @tsplus fluent fncts.LogLevel gt
- * @tsplus operator fncts.LogLevel >
+ * @tsplus pipeable fncts.LogLevel gt
+ * @tsplus pipeable-operator fncts.LogLevel >
  * @tsplus location "@fncts/io/LogLevel"
  */
-export declare function gt(self: LogLevel, that: LogLevel): boolean;
+export declare function gt(that: LogLevel): (self: LogLevel) => boolean;
 /**
  * @tsplus static fncts.LogLevelOps All
  * @tsplus location "@fncts/io/LogLevel"

package/LogSpan.d.ts

@@ -8,7 +8,7 @@ export declare class LogSpan {
     constructor(label: string, startTime: number);
 }
 /**
- * @tsplus fluent fncts.LogSpan render
+ * @tsplus pipeable fncts.LogSpan render
  * @tsplus location "@fncts/io/LogSpan"
  */
-export declare function render(self: LogSpan, now: number): string;
+export declare function render(now: number): (self: LogSpan) => string;

package/Logger/api.d.ts

@@ -1,14 +1,14 @@
-import { Logger } from "@fncts/io/Logger/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { LogLevel } from "@fncts/io/LogLevel";
+import { Logger } from "@fncts/io/Logger/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 /**
- * @tsplus fluent fncts.io.Logger filterLogLevel
+ * @tsplus pipeable fncts.io.Logger filterLogLevel
  * @tsplus location "@fncts/io/Logger/api"
  */
-export declare function filterLogLevel_<Message, Output>(self: Logger<Message, Output>, p: Predicate<LogLevel>): Logger<Message, Maybe<Output>>;
+export declare function filterLogLevel(p: Predicate<LogLevel>): <Message, Output>(self: import("./definition").Logger<Message, Output>) => import("./definition").Logger<Message, import("@fncts/base/data/Maybe").Maybe<Output>>;
 /**
- * @tsplus fluent fncts.io.Logger map
+ * @tsplus pipeable fncts.io.Logger map
  * @tsplus location "@fncts/io/Logger/api"
  */
-export declare function map_<Message, Output, B>(self: Logger<Message, Output>, f: (_: Output) => B): Logger<Message, B>;
+export declare function map<Output, B>(f: (_: Output) => B): <Message>(self: import("./definition").Logger<Message, Output>) => import("./definition").Logger<Message, B>;

package/Queue/constructors.d.ts

@@ -1,5 +1,6 @@
 import { UIO } from "@fncts/io/IO/definition";
-import type { Queue } from "@fncts/io/Queue/definition";
+import { Future } from "@fncts/io/Future";
+import { Queue } from "@fncts/io/Queue/definition";
 /**
  * @tsplus static fncts.io.QueueOps makeSliding
  * @tsplus location "@fncts/io/Queue/constructors"

package/Queue/definition.d.ts

@@ -1,64 +1,55 @@
-import { UIO, IO } from "@fncts/io/IO/definition";
+import { Future } from "@fncts/io/Future";
+import { IO } from "@fncts/io/IO/definition";
+import type { MutableQueue } from "../internal/MutableQueue.js";
+import type { UIO } from "../IO.js";
+import type { Strategy } from "./strategy.js";
+import type { Maybe } from "@fncts/base/data/Maybe";
+import type { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
-/**
- * A `PQueue<RA, RB, EA, EB, A, B>` is a lightweight, asynchronous queue into which values of
- * type `A` can be enqueued and of which elements of type `B` can be dequeued. The queue's
- * enqueueing operations may utilize an environment of type `RA` and may fail with errors of
- * type `EA`. The dequeueing operations may utilize an environment of type `RB` and may fail
- * with errors of type `EB`.
- *
- * @tsplus type fncts.io.Queue
- */
-export interface PQueue<RA, RB, EA, EB, A, B> {
-    readonly _RA: () => RA;
-    readonly _RB: () => RB;
-    readonly _EA: () => EA;
-    readonly _EB: () => EB;
-    readonly _A: (_: A) => void;
-    readonly _B: () => B;
-}
-/**
- * @tsplus type fncts.io.QueueOps
- */
-export interface QueueOps {
-}
-export declare const Queue: QueueOps;
-/**
- * @optimize remove
- */
-export declare function concrete<RA, RB, EA, EB, A, B>(_: PQueue<RA, RB, EA, EB, A, B>): asserts _ is QueueInternal<RA, RB, EA, EB, A, B>;
-/**
- * A `Queue<RA, RB, EA, EB, A, B>` is a lightweight, asynchronous queue into which values of
- * type `A` can be enqueued and of which elements of type `B` can be dequeued. The queue's
- * enqueueing operations may utilize an environment of type `RA` and may fail with errors of
- * type `EA`. The dequeueing operations may utilize an environment of type `RB` and may fail
- * with errors of type `EB`.
- */
-export declare abstract class QueueInternal<RA, RB, EA, EB, A, B> implements PQueue<RA, RB, EA, EB, A, B> {
-    readonly _RA: () => RA;
-    readonly _RB: () => RB;
-    readonly _EA: () => EA;
-    readonly _EB: () => EB;
-    readonly _A: (_: A) => void;
-    readonly _B: () => B;
+export declare const QueueTypeId: unique symbol;
+export type QueueTypeId = typeof QueueTypeId;
+export interface CommonQueue {
+    readonly [QueueTypeId]: QueueTypeId;
+    /**
+     * How many elements can hold in the queue
+     */
+    get capacity(): number;
+    /**
+     * Retrieves the size of the queue, which is equal to the number of elements
+     * in the queue. This may be negative if fibers are suspended waiting for
+     * elements to be added to the queue.
+     */
+    readonly size: UIO<number>;
     /**
      * Waits until the queue is shutdown.
      * The `IO` returned by this method will not resume until the queue has been shutdown.
      * If the queue is already shutdown, the `IO` will resume right away.
      */
-    abstract readonly awaitShutdown: UIO<void>;
+    readonly awaitShutdown: UIO<void>;
     /**
-     * How many elements can hold in the queue
+     * `true` if `shutdown` has been called.
      */
-    abstract readonly capacity: number;
+    readonly isShutdown: UIO<boolean>;
     /**
-     * `true` if `shutdown` has been called.
+     * Interrupts any fibers that are suspended on `offer` or `take`.
+     * Future calls to `offer*` and `take*` will be interrupted immediately.
+     */
+    readonly shutdown: UIO<void>;
+    /**
+     * Checks whether the queue is currently full.
      */
-    abstract readonly isShutdown: UIO<boolean>;
+    readonly isFull: UIO<boolean>;
+    /**
+     * Checks whether the queue is currently empty.
+     */
+    readonly isEmpty: UIO<boolean>;
+}
+export interface Enqueue<in A> extends CommonQueue {
+    readonly _In: (_: A) => void;
     /**
      * Places one value in the queue.
      */
-    abstract offer(a: A, __tsplusTrace?: string): IO<RA, EA, boolean>;
+    offer(this: this, a: A, __tsplusTrace?: string): UIO<boolean>;
     /**
      * For Bounded Queue: uses the `BackPressure` Strategy, places the values in the queue and always returns true.
      * If the queue has reached capacity, then
@@ -76,54 +67,72 @@ export declare abstract class QueueInternal<RA, RB, EA, EB, A, B> implements PQu
      * It places the values in the queue but if there is no room it will not enqueue them and return false.
      *
      */
-    abstract offerAll(as: Iterable<A>, __tsplusTrace?: string): IO<RA, EA, boolean>;
-    /**
-     * Interrupts any fibers that are suspended on `offer` or `take`.
-     * Future calls to `offer*` and `take*` will be interrupted immediately.
-     */
-    abstract readonly shutdown: UIO<void>;
-    /**
-     * Retrieves the size of the queue, which is equal to the number of elements
-     * in the queue. This may be negative if fibers are suspended waiting for
-     * elements to be added to the queue.
-     */
-    abstract readonly size: UIO<number>;
+    offerAll(this: this, as: Iterable<A>, __tsplusTrace?: string): UIO<boolean>;
+}
+export interface Dequeue<out A> extends CommonQueue {
+    readonly _Out: (_: never) => A;
     /**
      * Removes the oldest value in the queue. If the queue is empty, this will
      * return a computation that resumes when an item has been added to the queue.
      */
-    abstract readonly take: IO<RB, EB, B>;
+    readonly take: UIO<A>;
     /**
      * Removes all the values in the queue and returns the list of the values. If the queue
      * is empty returns empty list.
      */
-    abstract readonly takeAll: IO<RB, EB, Conc<B>>;
+    readonly takeAll: UIO<Conc<A>>;
     /**
      * Takes up to max number of values in the queue.
      */
-    abstract takeUpTo(n: number, __tsplusTrace?: string): IO<RB, EB, Conc<B>>;
+    takeUpTo(this: this, max: number, __tsplusTrace?: string): UIO<Conc<A>>;
+    /**
+     * Takes the specified number of elements from the queue. If there are fewer
+     * than the specified number of elements available, it suspends until they
+     * become available.
+     */
+    takeN(this: this, n: number, __tsplusTrace?: string): UIO<Conc<A>>;
+    /**
+     * Takes a number of elements from the queue between the specified minimum and
+     * maximum. If there are fewer than the minimum number of elements available,
+     * suspends until at least the minimum number of elements have been collected.
+     */
+    takeBetween(this: this, min: number, max: number, __tsplusTrace?: string): UIO<Conc<A>>;
+    /**
+     * Take the head option of values in the queue.
+     */
+    readonly poll: UIO<Maybe<A>>;
 }
 /**
- * A `Queue<A>` is a lightweight, asynchronous queue into which
- * values of type `A` can be enqueued and dequeued.
+ * A `Queue` is a lightweight, asynchronous queue into which values can be
+ * enqueued and of which elements can be dequeued.
  *
  * @tsplus type fncts.io.Queue
+ * @tsplus companion fncts.io.QueueOps
  */
-export interface Queue<A> extends PQueue<never, never, never, never, A, A> {
-}
-export declare namespace Queue {
-    /**
-     * A queue that can only be dequeued.
-     *
-     * @tsplus type fncts.io.Queue
-     */
-    interface Dequeue<A> extends PQueue<never, never, unknown, never, never, A> {
-    }
-    /**
-     * A queue that can only be enqueued.
-     *
-     * @tsplus type fncts.io.Queue
-     */
-    interface Enqueue<A> extends PQueue<never, never, never, unknown, A, any> {
-    }
+export declare class Queue<A> implements Enqueue<A>, Dequeue<A> {
+    readonly queue: MutableQueue<A>;
+    readonly takers: MutableQueue<Future<never, A>>;
+    readonly shutdownHook: Future<never, void>;
+    readonly shutdownFlag: AtomicBoolean;
+    readonly strategy: Strategy<A>;
+    readonly [QueueTypeId]: typeof QueueTypeId;
+    _In: (_: A) => void;
+    _Out: (_: never) => A;
+    constructor(queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>, shutdownHook: Future<never, void>, shutdownFlag: AtomicBoolean, strategy: Strategy<A>);
+    offer(this: this, a: A, __tsplusTrace?: string): UIO<boolean>;
+    offerAll(this: this, as: Iterable<A>, __tsplusTrace?: string): UIO<boolean>;
+    get capacity(): number;
+    size: UIO<number>;
+    awaitShutdown: import("../IO.js").IO<never, never, void>;
+    isShutdown: UIO<boolean>;
+    shutdown: UIO<void>;
+    isFull: UIO<boolean>;
+    isEmpty: UIO<boolean>;
+    take: UIO<A>;
+    takeAll: UIO<Conc<A>>;
+    takeUpTo(this: this, max: number, __tsplusTrace?: string): UIO<Conc<A>>;
+    private takeRemainder;
+    takeBetween(this: this, min: number, max: number, __tsplusTrace?: string): UIO<Conc<A>>;
+    takeN(this: this, n: number, __tsplusTrace?: string): UIO<Conc<A>>;
+    poll: UIO<Maybe<A>>;
 }

package/Queue/internal.d.ts

@@ -1,12 +1,10 @@
-import { Future } from "@fncts/io/Future";
-import { UIO, IO } from "@fncts/io/IO/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Future } from "@fncts/io/Future";
 import type { MutableQueue } from "@fncts/io/internal/MutableQueue";
-import type { Queue } from "@fncts/io/Queue/definition";
 import type { Strategy } from "@fncts/io/Queue/strategy";
-export declare function _makeQueue<A>(strategy: Strategy<A>): (queue: MutableQueue<A>) => IO<never, never, Queue<A>>;
-export declare function _unsafeOfferAll<A>(q: MutableQueue<A>, as: Conc<A>): Conc<A>;
-export declare function _unsafePollAll<A>(q: MutableQueue<A>): Conc<A>;
-export declare function _unsafeCompletePromise<A>(p: Future<never, A>, a: A): void;
-export declare function _unsafeRemove<A>(q: MutableQueue<A>, a: A): import("@fncts/base/collection/immutable/Conc").Conc<A>;
-export declare function _unsafeCompleteTakers<A>(strategy: Strategy<A>, queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>): void;
+export declare function unsafeOfferAll<A>(q: MutableQueue<A>, as: Conc<A>): Conc<A>;
+export declare function unsafePollAll<A>(q: MutableQueue<A>): Conc<A>;
+export declare function unsafeCompletePromise<A>(p: Future<never, A>, a: A): void;
+export declare function unsafeRemove<A>(q: MutableQueue<A>, a: A): import("@fncts/base/collection/immutable/Conc").Conc<A>;
+export declare function unsafePollN<A>(q: MutableQueue<A>, max: number): Conc<A>;
+export declare function unsafeCompleteTakers<A>(strategy: Strategy<A>, queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>): void;

package/Queue.d.ts

@@ -1,5 +1,3 @@
-export * from "./Queue/api.js";
 export * from "./Queue/constructors.js";
 export * from "./Queue/definition.js";
-export * from "./Queue/internal.js";
 export * from "./Queue/strategy.js";

package/Ref/Atomic.d.ts

@@ -1,2 +1,15 @@
-export * from "./Atomic/api.js";
-export * from "./Atomic/Atomic.js";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Ref } from "./definition.js";
+/**
+ * @tsplus type fncts.io.Ref.Atomic
+ */
+export declare class Atomic<A> extends Ref<A> {
+    private value;
+    readonly _tag = "Atomic";
+    constructor(value: A);
+    get unsafeGet(): A;
+    unsafeSet(a: A): void;
+    get: UIO<A>;
+    set(a: A): UIO<void>;
+    modify<B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): import("../IO.js").UIO<B>;
+}

package/Ref/Synchronized.d.ts

@@ -0,0 +1,72 @@
+import { TSemaphore } from "@fncts/io/TSemaphore/definition";
+import { UIO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { IO } from "@fncts/io/IO";
+import { Ref } from "./definition.js";
+/**
+ * @tsplus type fncts.io.Ref.Synchronized
+ * @tsplus companion fncts.io.Ref.SynchronizedOps
+ * @tsplus static fncts.io.RefOps Synchronized
+ */
+export declare class Synchronized<A> extends Ref<A> {
+    readonly semaphore: TSemaphore;
+    readonly unsafeGet: UIO<A>;
+    readonly unsafeSet: (a: A) => UIO<void>;
+    constructor(semaphore: TSemaphore, unsafeGet: UIO<A>, unsafeSet: (a: A) => UIO<void>);
+    /**
+     * Reads the value from the `Ref`.
+     */
+    get get(): UIO<A>;
+    /**
+     * Writes a new value to the `Ref`, with a guarantee of immediate
+     * consistency (at some cost to performance).
+     */
+    set(a: A, __tsplusTrace?: string): UIO<void>;
+    /**
+     * Atomically modifies the `Ref.Synchronized` with the specified function,
+     * which computes a return value for the modification. This is a more
+     * powerful version of `update`.
+     */
+    modifyIO<R, E, B>(f: (a: A) => IO<R, E, readonly [B, A]>, __tsplusTrace?: string): IO<R, E, B>;
+    modify<B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string | undefined): UIO<B>;
+    /**
+     * Atomically modifies the `Ref.Synchronized` with the specified function,
+     * returning the value immediately before modification.
+     */
+    getAndUpdateIO<R, E>(f: (a: A) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+    /**
+     * Atomically modifies the `Ref.Synchronized` with the specified partial
+     * function, returning the value immediately before modification. If the
+     * function is undefined on the current value it doesn't change it.
+     */
+    getAndUpdateJustIO<R, E>(f: (a: A) => Maybe<IO<R, E, A>>): IO<R, E, A>;
+    /**
+     * Atomically modifies the `Ref.Synchronized` with the specified function,
+     * which computes a return value for the modification if the function is
+     * defined in the current value otherwise it returns a default value. This
+     * is a more powerful version of `updateSome`.
+     */
+    modifyJustIO<R, E, B>(orElse: B, f: (a: A) => Maybe<IO<R, E, readonly [B, A]>>, __tsplusTrace?: string): IO<R, E, B>;
+    /**
+     * Atomically modifies the `Ref.Synchronized` with the specified function.
+     */
+    updateIO<R, E>(f: (a: A) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, void>;
+    /**
+     * Atomically modifies the `Ref.Synchronized` with the specified function,
+     * returning the value immediately after modification.
+     */
+    updateAndGetIO<R, E>(f: (a: A) => IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+    /**
+     * Atomically modifies the `Ref.Synchronized` with the specified partial
+     * function. If the function is undefined on the current value it doesn't
+     * change it.
+     */
+    updateJustIO<R, E>(f: (a: A) => Maybe<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, void>;
+    /**
+     * Atomically modifies the `Ref.Synchronized` with the specified partial
+     * function. If the function is undefined on the current value it returns
+     * the old value without changing it.
+     */
+    updateJustAndGetIO<R, E>(f: (a: A) => Maybe<IO<R, E, A>>, __tsplusTrace?: string): IO<R, E, A>;
+    protected withPermit<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+}

package/Ref/constructors.d.ts

@@ -3,9 +3,16 @@ import { UIO } from "@fncts/io/IO/definition";
 import { Ref } from "@fncts/io/Ref";
 /**
  * @tsplus static fncts.io.RefOps make
+ * @tsplus static fncts.io.RefOps __call
  * @tsplus location "@fncts/io/Ref/constructors"
  */
 export declare function make<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<Ref<A>>;
+/**
+ * @tsplus static fncts.io.Ref.SynchronizedOps make
+ * @tsplus static fncts.io.Ref.SynchronizedOps __call
+ * @tsplus location "@fncts/io/Ref/constructors"
+ */
+export declare function makeSynchronized<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<Ref.Synchronized<A>>;
 /**
  * @tsplus static fncts.io.RefOps unsafeMake
  * @tsplus location "@fncts/io/Ref/constructors"