@fncts/io 0.0.1

package/Queue/api/zipWithIO.d.ts

@@ -0,0 +1,44 @@
+import { IO, UIO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { PQueue } from "@fncts/io/Queue/definition";
+import { QueueInternal } from "@fncts/io/Queue/definition";
+export declare class ZipWithIO<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, R3, E3, D, A> extends QueueInternal<RA & RA1, RB & RB1 & R3, EA | EA1, E3 | EB | EB1, A1, D> {
+    readonly fa: QueueInternal<RA, RB, EA, EB, A, B>;
+    readonly fb: QueueInternal<RA1, RB1, EA1, EB1, A1, C>;
+    readonly f: (b: B, c: C) => IO<R3, E3, D>;
+    constructor(fa: QueueInternal<RA, RB, EA, EB, A, B>, fb: QueueInternal<RA1, RB1, EA1, EB1, A1, C>, f: (b: B, c: C) => IO<R3, E3, D>);
+    awaitShutdown: UIO<void>;
+    capacity: number;
+    isShutdown: UIO<boolean>;
+    offer(a: A1): IO<RA & RA1, EA1 | EA, boolean>;
+    offerAll(as: Iterable<A1>): IO<RA & RA1, EA1 | EA, boolean>;
+    shutdown: UIO<void>;
+    size: UIO<number>;
+    take: IO<RB & RB1 & R3, E3 | EB | EB1, D>;
+    takeAll: IO<RB & RB1 & R3, E3 | EB | EB1, Conc<D>>;
+    takeUpTo(max: number): IO<RB & RB1 & R3, E3 | EB | EB1, Conc<D>>;
+}
+/**
+ * Creates a new queue from this queue and another. Offering to the composite queue
+ * will broadcast the elements to both queues; taking from the composite queue
+ * will dequeue elements from both queues and apply the function point-wise.
+ *
+ * Note that using queues with different strategies may result in surprising behavior.
+ * For example, a dropping queue and a bounded queue composed together may apply `f`
+ * to different elements.
+ * @tsplus fluent fncts.io.Queue zipWithIO
+ * @tsplus location "@fncts/io/Queue/api/zipWithIO"
+ */
+export declare function zipWithIO_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, R3, E3, D, A>(fa: PQueue<RA, RB, EA, EB, A, B>, fb: PQueue<RA1, RB1, EA1, EB1, A1, C>, f: (b: B, c: C) => IO<R3, E3, D>): PQueue<RA & RA1, RB & RB1 & R3, EA | EA1, E3 | EB | EB1, A1, D>;
+/**
+ * Like `zipWithM`, but uses a pure function.
+ * @tsplus fluent fncts.io.Queue zipWith
+ * @tsplus location "@fncts/io/Queue/api/zipWithIO"
+ */
+export declare function zipWith_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, D, A>(queue: PQueue<RA, RB, EA, EB, A, B>, that: PQueue<RA1, RB1, EA1, EB1, A1, C>, f: (b: B, c: C) => D): PQueue<RA & RA1, RB & RB1, EA | EA1, EB | EB1, A1, D>;
+/**
+ * Like `zipWith`, but tuples the elements instead of applying a function.
+ * @tsplus fluent fncts.io.Queue zip
+ * @tsplus location "@fncts/io/Queue/api/zipWithIO"
+ */
+export declare function zip_<RA, RB, EA, EB, RA1, RB1, EA1, EB1, A1 extends A, C, B, A>(queue: PQueue<RA, RB, EA, EB, A, B>, that: PQueue<RA1, RB1, EA1, EB1, A1, C>): PQueue<RA & RA1, RB & RB1, EA | EA1, EB | EB1, A1, readonly [B, C]>;

package/Queue/api.d.ts

@@ -0,0 +1,7 @@
+export * from "./api/dimapIO.js";
+export * from "./api/filterInputIO.js";
+export * from "./api/filterOutputIO.js";
+export * from "./api/operations.js";
+export * from "./api/poll.js";
+export * from "./api/takeBetween.js";
+export * from "./api/zipWithIO.js";

package/Queue/constructors.d.ts

@@ -0,0 +1,22 @@
+import { UIO } from "@fncts/io/IO/definition";
+import type { Queue } from "@fncts/io/Queue/definition";
+/**
+ * @tsplus static fncts.io.QueueOps makeSliding
+ * @tsplus location "@fncts/io/Queue/constructors"
+ */
+export declare function makeSliding<A>(capacity: number): UIO<Queue<A>>;
+/**
+ * @tsplus static fncts.io.QueueOps makeUnbounded
+ * @tsplus location "@fncts/io/Queue/constructors"
+ */
+export declare function makeUnbounded<A>(): UIO<Queue<A>>;
+/**
+ * @tsplus static fncts.io.QueueOps makeDropping
+ * @tsplus location "@fncts/io/Queue/constructors"
+ */
+export declare function makeDropping<A>(capacity: number): UIO<Queue<A>>;
+/**
+ * @tsplus static fncts.io.QueueOps makeBounded
+ * @tsplus location "@fncts/io/Queue/constructors"
+ */
+export declare function makeBounded<A>(capacity: number): UIO<Queue<A>>;

package/Queue/definition.d.ts

@@ -0,0 +1,129 @@
+import { UIO, IO } from "@fncts/io/IO/definition";
+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) => void;
+    readonly _RB: (_: RB) => void;
+    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) => void;
+    readonly _RB: (_: RB) => void;
+    readonly _EA: () => EA;
+    readonly _EB: () => EB;
+    readonly _A: (_: A) => void;
+    readonly _B: () => B;
+    /**
+     * 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>;
+    /**
+     * How many elements can hold in the queue
+     */
+    abstract readonly capacity: number;
+    /**
+     * `true` if `shutdown` has been called.
+     */
+    abstract readonly isShutdown: UIO<boolean>;
+    /**
+     * Places one value in the queue.
+     */
+    abstract offer(a: A): IO<RA, EA, 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
+     * the fiber performing the `offerAll` will be suspended until there is room in
+     * the queue.
+     *
+     * For Unbounded Queue:
+     * Places all values in the queue and returns true.
+     *
+     * For Sliding Queue: uses `Sliding` Strategy
+     * If there is room in the queue, it places the values otherwise it removes the old elements and
+     * enqueues the new ones. Always returns true.
+     *
+     * 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.
+     *
+     */
+    abstract offerAll(as: Iterable<A>): 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>;
+    /**
+     * 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>;
+    /**
+     * 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>>;
+    /**
+     * Takes up to max number of values in the queue.
+     */
+    abstract takeUpTo(n: number): IO<RB, EB, Conc<B>>;
+}
+/**
+ * A `Queue<A>` is a lightweight, asynchronous queue into which
+ * values of type `A` can be enqueued and dequeued.
+ *
+ * @tsplus type fncts.io.Queue
+ */
+export interface Queue<A> extends PQueue<unknown, unknown, 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, unknown, unknown, never, never, A> {
+    }
+    /**
+     * A queue that can only be enqueued.
+     *
+     * @tsplus type fncts.io.Queue
+     */
+    interface Enqueue<A> extends PQueue<unknown, never, never, unknown, A, any> {
+    }
+}

package/Queue/internal.d.ts

@@ -0,0 +1,12 @@
+import { Future } from "@fncts/io/Future";
+import { UIO, IO } from "@fncts/io/IO/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+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<unknown, 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;

package/Queue/strategy.d.ts

@@ -0,0 +1,33 @@
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import { Future } from "@fncts/io/Future";
+import { UIO } from "@fncts/io/IO/definition";
+import type { AtomicBoolean } from "@fncts/base/internal/AtomicBoolean";
+import type { MutableQueue } from "@fncts/io/internal/MutableQueue";
+export interface Strategy<A> {
+    readonly handleSurplus: (as: Conc<A>, queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>, isShutdown: AtomicBoolean) => UIO<boolean>;
+    readonly unsafeOnQueueEmptySpace: (queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>) => void;
+    readonly surplusSize: number;
+    readonly shutdown: UIO<void>;
+}
+export declare class BackPressureStrategy<A> implements Strategy<A> {
+    private putters;
+    handleSurplus(as: Conc<A>, queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>, isShutdown: AtomicBoolean): UIO<boolean>;
+    unsafeRemove(p: Future<never, boolean>): void;
+    unsafeOffer(as: Conc<A>, p: Future<never, boolean>): void;
+    unsafeOnQueueEmptySpace(queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>): void;
+    get shutdown(): UIO<void>;
+    get surplusSize(): number;
+}
+export declare class DroppingStrategy<A> implements Strategy<A> {
+    handleSurplus(_as: Conc<A>, _queue: MutableQueue<A>, _takers: MutableQueue<Future<never, A>>, _isShutdown: AtomicBoolean): UIO<boolean>;
+    unsafeOnQueueEmptySpace(_queue: MutableQueue<A>): void;
+    get shutdown(): UIO<void>;
+    get surplusSize(): number;
+}
+export declare class SlidingStrategy<A> implements Strategy<A> {
+    handleSurplus(as: Conc<A>, queue: MutableQueue<A>, takers: MutableQueue<Future<never, A>>, _isShutdown: AtomicBoolean): UIO<boolean>;
+    unsafeOnQueueEmptySpace(_queue: MutableQueue<A>): void;
+    get shutdown(): UIO<void>;
+    get surplusSize(): number;
+    private unsafeSlidingOffer;
+}

package/Queue.d.ts

@@ -0,0 +1,5 @@
+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/Random/api.d.ts

@@ -0,0 +1,42 @@
+import { IO, UIO } from "@fncts/io/IO/definition";
+import type { ArrayInt } from "@fncts/base/util/rand";
+/**
+ * @tsplus static fncts.io.RandomOps nextDouble
+ * @tsplus location "@fncts/io/Random/api"
+ */
+export declare const nextDouble: import("../IO").IO<unknown, never, number>;
+/**
+ * @tsplus static fncts.io.RandomOps nextBoolean
+ * @tsplus location "@fncts/io/Random/api"
+ */
+export declare const nextBoolean: import("../IO").IO<unknown, never, boolean>;
+/**
+ * @tsplus static fncts.io.RandomOps nextInt
+ * @tsplus location "@fncts/io/Random/api"
+ */
+export declare const nextInt: import("../IO").IO<unknown, never, number>;
+/**
+ * @tsplus static fncts.io.RandomOps nextRange
+ * @tsplus location "@fncts/io/Random/api"
+ */
+export declare function nextRange(low: number, high: number): IO<unknown, never, number>;
+/**
+ * @tsplus static fncts.io.RandomOps nextIntBetween
+ * @tsplus location "@fncts/io/Random/api"
+ */
+export declare function nextIntBetween(low: number, high: number): UIO<number>;
+/**
+ * @tsplus static fncts.io.RandomOps nextBigIntBetween
+ * @tsplus location "@fncts/io/Random/api"
+ */
+export declare function nextBigIntBetween(low: bigint, high: bigint): UIO<bigint>;
+/**
+ * @tsplus static fncts.io.RandomOps nextArrayIntBetween
+ * @tsplus location "@fncts/io/Random/api"
+ */
+export declare function nextArrayIntBetween(low: ArrayInt, high: ArrayInt): UIO<ArrayInt>;
+/**
+ * @tsplus static fncts.io.RandomOps setSeed
+ * @tsplus location "@fncts/io/Random/api"
+ */
+export declare function setSeed(seed: number): UIO<void>;

package/Random/definition.d.ts

@@ -0,0 +1,21 @@
+import { UIO } from "@fncts/io/IO/definition";
+import type { ArrayInt } from "@fncts/base/util/rand";
+/**
+ * @tsplus static fncts.io.RandomOps Tag
+ * @tsplus location "@fncts/io/Random/definition"
+ */
+export declare const RandomTag: import("@fncts/base/data/Tag").Tag<Random>;
+/**
+ * @tsplus type fncts.io.Random
+ * @tsplus companion fncts.io.RandomOps
+ */
+export declare abstract class Random {
+    abstract readonly nextDouble: UIO<number>;
+    abstract readonly nextBoolean: UIO<boolean>;
+    abstract readonly nextInt: UIO<number>;
+    abstract nextRange(low: number, high: number): UIO<number>;
+    abstract nextIntBetween(low: number, high: number): UIO<number>;
+    abstract nextBigIntBetween(low: bigint, high: bigint): UIO<bigint>;
+    abstract nextArrayIntBetween(low: ArrayInt, high: ArrayInt): UIO<ArrayInt>;
+    abstract setSeed(seed: number): UIO<void>;
+}

package/Random/live.d.ts

@@ -0,0 +1,20 @@
+import { Random } from "@fncts/io/Random/definition";
+import { UIO } from "@fncts/io/IO/definition";
+import type { ArrayInt } from "@fncts/base/util/rand";
+export declare class LiveRandom implements Random {
+    private prng;
+    constructor(seed: number);
+    setSeed(seed: number): UIO<void>;
+    nextDouble: import("../IO").UIO<number>;
+    nextInt: import("../IO").UIO<number>;
+    nextBoolean: import("../IO").IO<unknown, never, boolean>;
+    nextRange(low: number, high: number): UIO<number>;
+    nextIntBetween(low: number, high: number): UIO<number>;
+    nextBigIntBetween(low: bigint, high: bigint): UIO<bigint>;
+    nextArrayIntBetween(low: ArrayInt, high: ArrayInt): UIO<ArrayInt>;
+}
+/**
+ * @tsplus static fncts.io.RandomOps Live
+ * @tsplus location "@fncts/io/Random/live"
+ */
+export declare const live: Random;

package/Random.d.ts

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

package/Ref/Atomic/Atomic.d.ts

@@ -0,0 +1,18 @@
+import { Either } from "@fncts/base/data/Either";
+import { UIO } from "@fncts/io/IO/definition";
+import type { PRef } from "../definition.js";
+import { RefInternal } from "../definition.js";
+/**
+ * @tsplus type fncts.io.Ref.Atomic
+ */
+export declare class Atomic<A> extends RefInternal<unknown, unknown, never, never, A, A> {
+    private value;
+    readonly _tag = "Atomic";
+    constructor(value: A);
+    match<EC, ED, C, D>(_ea: (_: never) => EC, _eb: (_: never) => ED, ca: (_: C) => Either<EC, A>, bd: (_: A) => Either<ED, D>): PRef<unknown, unknown, EC, ED, C, D>;
+    matchAll<EC, ED, C, D>(_ea: (_: never) => EC, _eb: (_: never) => ED, _ec: (_: never) => EC, ca: (_: C) => (_: A) => Either<EC, A>, bd: (_: A) => Either<ED, D>): PRef<unknown, unknown, EC, ED, C, D>;
+    get unsafeGet(): A;
+    unsafeSet(a: A): void;
+    get get(): UIO<A>;
+    set(a: A): UIO<void>;
+}

package/Ref/Atomic/api.d.ts

@@ -0,0 +1,53 @@
+import { UIO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe";
+import type { Atomic } from "./Atomic.js";
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic getAndSet
+ * @tsplus location "@fncts/io/Ref/Atomic/api"
+ */
+export declare function getAndSet<A>(self: Atomic<A>, a: A): UIO<A>;
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic getAndUpdate
+ * @tsplus location "@fncts/io/Ref/Atomic/api"
+ */
+export declare function getAndUpdate<A>(self: Atomic<A>, f: (a: A) => A): import("../../IO.js").UIO<A>;
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic getAndUpdateJust
+ * @tsplus location "@fncts/io/Ref/Atomic/api"
+ */
+export declare function getAndUpdateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>): import("../../IO.js").UIO<A>;
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic modify
+ * @tsplus location "@fncts/io/Ref/Atomic/api"
+ */
+export declare function modify<A, B>(self: Atomic<A>, f: (a: A) => readonly [B, A]): import("../../IO.js").UIO<B>;
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic modifyJust
+ * @tsplus location "@fncts/io/Ref/Atomic/api"
+ */
+export declare function modifyJust<A, B>(self: Atomic<A>, def: B, f: (a: A) => Maybe<readonly [B, A]>): import("../../IO.js").UIO<B>;
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic update
+ * @tsplus location "@fncts/io/Ref/Atomic/api"
+ */
+export declare function update<A>(self: Atomic<A>, f: (a: A) => A): import("../../IO.js").UIO<void>;
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic updateAndGet
+ * @tsplus location "@fncts/io/Ref/Atomic/api"
+ */
+export declare function updateAndGet<A>(self: Atomic<A>, f: (a: A) => A): import("../../IO.js").UIO<A>;
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic updateJust
+ * @tsplus location "@fncts/io/Ref/Atomic/api"
+ */
+export declare function updateJust<A>(self: Atomic<A>, f: (a: A) => Maybe<A>): import("../../IO.js").UIO<void>;
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic updateJustAndGet
+ * @tsplus location "@fncts/io/Ref/Atomic/api"
+ */
+export declare function updateJustAndGet<A>(self: Atomic<A>, f: (a: A) => Maybe<A>): import("../../IO.js").UIO<A>;
+/**
+ * @tsplus fluent fncts.io.Ref.Atomic unsafeUpdate
+ * @tsplus location "@fncts/io/Ref/Atomic/api"
+ */
+export declare function unsafeUpdate<A>(self: Atomic<A>, f: (a: A) => A): void;

package/Ref/Atomic.d.ts

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

package/Ref/Derived.d.ts

@@ -0,0 +1,14 @@
+import { Either } from "@fncts/base/data/Either";
+import { FIO } from "@fncts/io/IO/definition";
+import type { Atomic } from "./Atomic/Atomic.js";
+import type { PRef } from "./definition.js";
+import { RefInternal } from "./definition.js";
+export declare class Derived<EA, EB, A, B> extends RefInternal<unknown, unknown, EA, EB, A, B> {
+    readonly use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => Either<EA, S>) => X) => X;
+    readonly _tag = "Derived";
+    constructor(use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => Either<EA, S>) => X) => X);
+    match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<unknown, unknown, EC, ED, C, D>;
+    matchAll<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<unknown, unknown, EC, ED, C, D>;
+    get get(): FIO<EB, B>;
+    set(a: A): FIO<EA, void>;
+}

package/Ref/DerivedAll.d.ts

@@ -0,0 +1,14 @@
+import { Either } from "@fncts/base/data/Either";
+import { FIO } from "@fncts/io/IO/definition";
+import type { Atomic } from "./Atomic/Atomic.js";
+import type { PRef } from "./definition.js";
+import { RefInternal } from "./definition.js";
+export declare class DerivedAll<EA, EB, A, B> extends RefInternal<unknown, unknown, EA, EB, A, B> {
+    readonly use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => (s: S) => Either<EA, S>) => X) => X;
+    readonly _tag = "DerivedAll";
+    constructor(use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => (s: S) => Either<EA, S>) => X) => X);
+    match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<unknown, unknown, EC, ED, C, D>;
+    matchAll<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<unknown, unknown, EC, ED, C, D>;
+    get get(): FIO<EB, B>;
+    set(a: A): FIO<EA, void>;
+}

package/Ref/Synchronized/api.d.ts

@@ -0,0 +1,100 @@
+import { Maybe } from "@fncts/base/data/Maybe";
+import { IO } from "@fncts/io/IO/definition";
+import type { PRef } from "../definition.js";
+/**
+ * Maps and filters the `get` value of the `SRef` with the specified
+ * effectual partial function, returning a `SRef` with a `get` value that
+ * succeeds with the result of the partial function if it is defined or else
+ * fails with `None`.
+ * @tsplus fluent fncts.io.Ref.Synchronized collectIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function collectIO_<RA, RB, EA, EB, A, B, RC, EC, C>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (b: B) => Maybe<IO<RC, EC, C>>): PRef.Synchronized<RA, RB & RC, EA, Maybe<EB | EC>, A, C>;
+/**
+ * Transforms the `set` value of the `SRef` with the specified effectual
+ * function.
+ * @tsplus fluent fncts.io.Ref.Synchronized contramapIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function contramapIO_<RA, RB, EA, EB, B, A, RC, EC, C>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>): PRef.Synchronized<RA & RC, RB, EC | EA, EB, C, B>;
+/**
+ * Transforms both the `set` and `get` values of the `Synchronized` with the
+ * specified effectual functions.
+ * @tsplus fluent fncts.io.Ref.Synchronized dimapIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function dimapIO_<RA, RB, EA, EB, B, RC, EC, A, RD, ED, C = A, D = B>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>): PRef.Synchronized<RA & RC, RB & RD, EA | EC, EB | ED, C, D>;
+/**
+ * Filters the `set` value of the `SRef` with the specified effectual
+ * predicate, returning a `SRef` with a `set` value that succeeds if the
+ * predicate is satisfied or else fails with `None`.
+ * @tsplus fluent fncts.io.Ref.Synchronized filterInputIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function filterInputIO_<RA, RB, EA, EB, B, A, RC, EC, A1 extends A = A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (a: A1) => IO<RC, EC, boolean>): PRef.Synchronized<RA & RC, RB, Maybe<EC | EA>, EB, A1, B>;
+/**
+ * Filters the `get` value of the `SRef` with the specified effectual predicate,
+ * returning a `SRef` with a `get` value that succeeds if the predicate is
+ * satisfied or else fails with `None`.
+ * @tsplus fluent fncts.io.Ref.Synchronized filterOutputIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function filterOutputIO_<RA, RB, EA, EB, A, B, RC, EC>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RC, EC, boolean>): PRef.Synchronized<RA, RB & RC, EA, Maybe<EC | EB>, A, B>;
+/**
+ * Atomically modifies the `Synchronized` with the specified function, returning the
+ * value immediately before modification.
+ */
+export declare function getAndUpdateIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => IO<R1, E1, A>): IO<RA & RB & R1, EA | EB | E1, A>;
+/**
+ * Atomically modifies the `SRef` with the specified function, returning the
+ * value immediately before modification.
+ */
+export declare function getAndUpdateJustIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<IO<R1, E1, A>>): IO<RA & RB & R1, EA | EB | E1, A>;
+/**
+ * @tsplus fluent fncts.io.Ref.Synchronized matchIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function matchIO_<RA, RB, EA, EB, A, B, RC, RD, EC, ED, C, D>(self: PRef.Synchronized<RA, RB, EA, EB, A, B>, ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PRef.Synchronized<RA & RC, RB & RD, EC, ED, C, D>;
+/**
+ * @tsplus fluent fncts.io.Ref.Synchronized matchAllIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function matchAllIO_<RA, RB, EA, EB, A, B, RC, RD, EC, ED, C, D>(self: PRef.Synchronized<RA, RB, EA, EB, A, B>, ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PRef.Synchronized<RA & RB & RC, RB & RD, EC, ED, C, D>;
+/**
+ * @tsplus fluent fncts.io.Ref.Synchronized modifyIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function modifyIO_<RA, RB, EA, EB, A, R1, E1, B>(self: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => IO<R1, E1, readonly [B, A]>, __tsplusTrace?: string): IO<RA & RB & R1, EA | EB | E1, B>;
+/**
+ * Atomically modifies the `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 `updateJust`.
+ * @tsplus fluent fncts.io.Ref.Synchronized modifyJustIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function modifyJustIO_<RA, RB, EA, EB, R1, E1, A, B>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, def: B, f: (a: A) => Maybe<IO<R1, E1, readonly [B, A]>>): IO<RA & RB & R1, EA | EB | E1, B>;
+/**
+ * Atomically modifies the `SRef` with the specified function.
+ * @tsplus fluent fncts.io.Ref.Synchronized updateAndGetIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function updateAndGetIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => IO<R1, E1, A>): IO<RA & RB & R1, E1 | EA | EB, void>;
+/**
+ * Atomically modifies the `Synchronized` with the specified function.
+ * @tsplus fluent fncts.io.Ref.Synchronized updateIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function updateIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => IO<R1, E1, A>): IO<RA & RB & R1, E1 | EA | EB, void>;
+/**
+ * Atomically modifies the `SRef` with the specified function.
+ * @tsplus fluent fncts.io.Ref.Synchronized updateJustAndGetIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function updateJustAndGetIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<IO<R1, E1, A>>): IO<RA & RB & R1, E1 | EA | EB, A>;
+/**
+ * Atomically modifies the `SRef` with the specified function.
+ * @tsplus fluent fncts.io.Ref.Synchronized updateJustIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function updateJustIO_<RA, RB, EA, EB, R1, E1, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<IO<R1, E1, A>>): IO<RA & RB & R1, E1 | EA | EB, void>;

package/Ref/Synchronized/constructors.d.ts

@@ -0,0 +1,7 @@
+import { Lazy } from "@fncts/base/data/function";
+import { UIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus static fncts.io.Ref.SynchronizedOps make
+ * @tsplus location "@fncts/io/Ref/Synchronized/constructors"
+ */
+export declare function makeSynchronized<A>(a: Lazy<A>): UIO<Ref.Synchronized<A>>;

package/Ref/Synchronized/definition.d.ts

@@ -0,0 +1,41 @@
+import { TSemaphore } from "@fncts/io/TSemaphore/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Either } from "@fncts/base/data/Either";
+import type { PRef } from "../definition.js";
+import { RefInternal } from "../definition.js";
+/**
+ * @tsplus type fncts.io.Ref.Synchronized
+ */
+export interface PSynchronized<RA, RB, EA, EB, A, B> extends PRef<RA, RB, EA, EB, A, B> {
+}
+/**
+ * @tsplus type fncts.io.Ref.SynchronizedOps
+ */
+export interface PSynchronizedOps {
+}
+/**
+ * @tsplus static fncts.io.RefOps Synchronized
+ * @tsplus location "@fncts/io/Ref/Synchronized/definition"
+ */
+export declare const Synchronized: PSynchronizedOps;
+/**
+ * @tsplus type fncts.io.Ref.Synchronized
+ */
+export declare class PSynchronizedInternal<RA, RB, EA, EB, A, B> extends RefInternal<RA, RB, EA, EB, A, B> {
+    readonly semaphores: Set<TSemaphore>;
+    readonly unsafeGet: IO<RB, EB, B>;
+    readonly unsafeSet: (a: A) => IO<RA, EA, void>;
+    readonly _tag = "Synchronized";
+    constructor(semaphores: Set<TSemaphore>, unsafeGet: IO<RB, EB, B>, unsafeSet: (a: A) => IO<RA, EA, void>);
+    get get(): IO<RB, EB, B>;
+    set(a: A, __tsplusTrace?: string): IO<RA, EA, void>;
+    matchAllIO<RC, RD, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA & RC & RB, RB & RD, EC, ED, C, D>;
+    matchIO<RC, RD, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => IO<RC, EC, A>, bd: (_: B) => IO<RD, ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA & RC, RB & RD, EC, ED, C, D>;
+    match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA, RB, EC, ED, C, D>;
+    matchAll<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => Either<EC, A>, bd: (_: B) => Either<ED, D>, __tsplusTrace?: string): PSynchronizedInternal<RA, RB, EC, ED, C, D>;
+    withPermit<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+}
+/**
+ * @tsplus macro remove
+ */
+export declare function concreteSynchronized<RA, RB, EA, EB, A, B>(self: PSynchronized<RA, RB, EA, EB, A, B>): asserts self is PSynchronizedInternal<RA, RB, EA, EB, A, B>;

package/Ref/api/collect.d.ts

@@ -0,0 +1,11 @@
+import { Maybe } from "@fncts/base/data/Maybe";
+import type { PRef } from "../definition.js";
+/**
+ * Maps and filters the `get` value of the `Ref` with the specified partial
+ * function, returning a `Ref` with a `get` value that succeeds with the
+ * result of the partial function if it is defined or else fails with `None`.
+ * @tsplus fluent fncts.io.Ref collect
+ * @tsplus fluent fncts.io.Ref.Synchronized collect
+ * @tsplus location "@fncts/io/Ref/api/collect"
+ */
+export declare function collect_<RA, RB, EA, EB, A, B, C>(ref: PRef<RA, RB, EA, EB, A, B>, pf: (_: B) => Maybe<C>): PRef<RA, RB, EA, Maybe<EB>, A, C>;