@fncts/io 0.0.19 → 0.0.21

package/Queue/api/operations.d.ts

@@ -1,82 +0,0 @@
-import { PQueue } from "@fncts/io/Queue/definition";
-import { UIO, IO } from "@fncts/io/IO/definition";
-/**
- * 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.
- * @tsplus getter fncts.io.Queue awaitShutdown
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function awaitShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<void>;
-/**
- * How many elements can hold in the queue
- * @tsplus getter fncts.io.Queue capacity
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function capacity<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): number;
-/**
- * `true` if `shutdown` has been called.
- * @tsplus getter fncts.io.Queue isShutdown
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function isShutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): UIO<boolean>;
-/**
- * Places one value in the queue.
- * @tsplus fluent fncts.io.Queue offer
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function offer_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, a: A, __tsplusTrace?: string): 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.
- * @tsplus fluent fncts.io.Queue offerAll
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function offerAll_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, as: Iterable<A>, __tsplusTrace?: string): import("../../IO").IO<RA, EA, boolean>;
-/**
- * Interrupts any fibers that are suspended on `offer` or `take`.
- * Future calls to `offer*` and `take*` will be interrupted immediately.
- * @tsplus getter fncts.io.Queue shutdown
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function shutdown<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): import("../../IO").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.
- * @tsplus getter fncts.io.Queue size
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function size<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): import("../../IO").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.
- * @tsplus getter fncts.io.Queue take
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function take<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): 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.
- * @tsplus getter fncts.io.Queue takeAll
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function takeAll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): import("../../IO").IO<RB, EB, import("@fncts/base/collection/immutable/Conc").Conc<B>>;
-/**
- * Takes up to max number of values in the queue.
- * @tsplus fluent fncts.io.Queue takeAllUpTo
- * @tsplus location "@fncts/io/Queue/api/operations"
- */
-export declare function takeAllUpTo_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, n: number, __tsplusTrace?: string): import("../../IO").IO<RB, EB, import("@fncts/base/collection/immutable/Conc").Conc<B>>;

package/Queue/api/poll.d.ts

@@ -1,9 +0,0 @@
-import { PQueue } from "@fncts/io/Queue/definition";
-import { IO } from "@fncts/io/IO/definition";
-import { Maybe } from "@fncts/base/data/Maybe/definition";
-/**
- * Take the head option of values in the queue.
- * @tsplus getter fncts.io.Queue poll
- * @tsplus location "@fncts/io/Queue/api/poll"
- */
-export declare function poll<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<RB, EB, Maybe<B>>;

package/Queue/api/takeBetween.d.ts

@@ -1,11 +0,0 @@
-import { PQueue } from "@fncts/io/Queue/definition";
-import { IO } from "@fncts/io/IO/definition";
-import { Conc } from "@fncts/base/collection/immutable/Conc";
-/**
- * Takes between min and max number of values from the queue. If there
- * is less than min items available, it'll block until the items are
- * collected.
- * @tsplus fluent fncts.io.Queue takeBetween
- * @tsplus location "@fncts/io/Queue/api/takeBetween"
- */
-export declare function takeBetween_<RA, RB, EA, EB, A, B>(queue: PQueue<RA, RB, EA, EB, A, B>, min: number, max: number, __tsplusTrace?: string): IO<RB, EB, Conc<B>>;

package/Queue/api/zipWithIO.d.ts

@@ -1,44 +0,0 @@
-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>, __tsplusTrace?: string): 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, __tsplusTrace?: string): 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>, __tsplusTrace?: string): PQueue<RA | RA1, RB | RB1, EA | EA1, EB | EB1, A1, readonly [B, C]>;

package/Queue/api.d.ts

@@ -1,7 +0,0 @@
-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/Ref/Atomic/Atomic.d.ts

@@ -1,18 +0,0 @@
-import { Either } from "@fncts/base/data/Either/definition";
-import { UIO, IO } 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<never, never, 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<never, never, 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<never, never, 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

@@ -1,53 +0,0 @@
-import { UIO } from "@fncts/io/IO/definition";
-import { Maybe } from "@fncts/base/data/Maybe/definition";
-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, __tsplusTrace?: string): 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, __tsplusTrace?: string): 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>, __tsplusTrace?: string): 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], __tsplusTrace?: string): 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]>, __tsplusTrace?: string): 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, __tsplusTrace?: string): 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, __tsplusTrace?: string): 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>, __tsplusTrace?: string): 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>, __tsplusTrace?: string): 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, __tsplusTrace?: string): void;

package/Ref/Derived.d.ts

@@ -1,14 +0,0 @@
-import { Either } from "@fncts/base/data/Either/definition";
-import { FIO, IO } 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<never, never, 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<never, never, 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<never, never, EC, ED, C, D>;
-    get get(): FIO<EB, B>;
-    set(a: A): FIO<EA, void>;
-}

package/Ref/DerivedAll.d.ts

@@ -1,14 +0,0 @@
-import { Either } from "@fncts/base/data/Either/definition";
-import { FIO, IO } 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<never, never, 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<never, never, 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<never, never, EC, ED, C, D>;
-    get get(): FIO<EB, B>;
-    set(a: A): FIO<EA, void>;
-}

package/Ref/Synchronized/api.d.ts

@@ -1,100 +0,0 @@
-import { Maybe } from "@fncts/base/data/Maybe/definition";
-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>>, __tsplusTrace?: string): 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>, __tsplusTrace?: string): 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>, __tsplusTrace?: string): 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>, __tsplusTrace?: string): 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>, __tsplusTrace?: string): 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>, __tsplusTrace?: string): 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>>, __tsplusTrace?: string): 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]>>, __tsplusTrace?: string): 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>, __tsplusTrace?: string): 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>, __tsplusTrace?: string): 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>>, __tsplusTrace?: string): 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>>, __tsplusTrace?: string): IO<RA | RB | R1, E1 | EA | EB, void>;

package/Ref/Synchronized/constructors.d.ts

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

package/Ref/Synchronized/definition.d.ts

@@ -1,42 +0,0 @@
-import { TSemaphore } from "@fncts/io/TSemaphore/definition";
-import { IO } from "@fncts/io/IO/definition";
-import { Either } from "@fncts/base/data/Either/definition";
-import { STM } from "@fncts/io/STM/definition";
-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

@@ -1,11 +0,0 @@
-import { Maybe } from "@fncts/base/data/Maybe/definition";
-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>, __tsplusTrace?: string): PRef<RA, RB, EA, Maybe<EB>, A, C>;

package/Ref/api/dimap.d.ts

@@ -1,56 +0,0 @@
-import { Either } from "@fncts/base/data/Either/definition";
-import type { PRef } from "../definition.js";
-/**
- * Transforms the `set` value of the `Ref` with the specified function.
- * @tsplus fluent fncts.io.Ref contramap
- * @tsplus fluent fncts.io.Ref.Synchronized contramap
- * @tsplus location "@fncts/io/Ref/api/dimap"
- */
-export declare function contramap_<RA, RB, EA, EB, B, A, C>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: C) => A, __tsplusTrace?: string): PRef<RA, RB, EA, EB, C, B>;
-/**
- * Transforms the `set` value of the `Ref` with the specified fallible
- * function.
- * @tsplus fluent fncts.io.Ref contramapEither
- * @tsplus fluent fncts.io.Ref.Synchronized contramapEither
- * @tsplus location "@fncts/io/Ref/api/dimap"
- */
-export declare function contramapEither_<RA, RB, EA, EB, A, B, EC, C>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: C) => Either<EC, A>, __tsplusTrace?: string): PRef<RA, RB, EC | EA, EB, C, B>;
-/**
- * Transforms both the `set` and `get` values of the `Ref` with the
- * specified functions.
- * @tsplus fluent fncts.io.Ref dimap
- * @tsplus fluent fncts.io.Ref.Synchronized dimap
- * @tsplus location "@fncts/io/Ref/api/dimap"
- */
-export declare function dimap_<RA, RB, EA, EB, A, B, C, D>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: C) => A, g: (_: B) => D, __tsplusTrace?: string): PRef<RA, RB, EA, EB, C, D>;
-/**
- * Transforms both the `set` and `get` values of the `Ref` with the
- * specified fallible functions.
- * @tsplus fluent fncts.io.Ref dimapEither
- * @tsplus fluent fncts.io.Ref.Synchronized dimapEither
- * @tsplus location "@fncts/io/Ref/api/dimap"
- */
-export declare function dimapEither_<RA, RB, EA, EB, A, B, C, EC, D, ED>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: C) => Either<EC, A>, g: (_: B) => Either<ED, D>, __tsplusTrace?: string): PRef<RA, RB, EC | EA, ED | EB, C, D>;
-/**
- * Transforms both the `set` and `get` errors of the `Ref` with the
- * specified functions.
- * @tsplus fluent fncts.io.Ref dimapError
- * @tsplus fluent fncts.io.Ref.Synchronized dimapError
- * @tsplus location "@fncts/io/Ref/api/dimap"
- */
-export declare function dimapError_<RA, RB, EA, EB, A, B, EC, ED>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: EA) => EC, g: (_: EB) => ED, __tsplusTrace?: string): PRef<RA, RB, EC, ED, A, B>;
-/**
- * Transforms the `get` value of the `Ref` with the specified fallible
- * function.
- * @tsplus fluent fncts.io.Ref mapEither
- * @tsplus fluent fncts.io.Ref.Synchronized mapEither
- * @tsplus location "@fncts/io/Ref/api/dimap"
- */
-export declare function mapEither_<RA, RB, EA, EB, A, B, EC, C>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: B) => Either<EC, C>, __tsplusTrace?: string): PRef<RA, RB, EA, EC | EB, A, C>;
-/**
- * Transforms the `get` value of the `Ref` with the specified function.
- * @tsplus fluent fncts.io.Ref map
- * @tsplus fluent fncts.io.Ref.Synchronized map
- * @tsplus location "@fncts/io/Ref/api/dimap"
- */
-export declare function map_<RA, RB, EA, EB, A, B, C>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: B) => C, __tsplusTrace?: string): PRef<RA, RB, EA, EB, A, C>;

package/Ref/api/filter.d.ts

@@ -1,20 +0,0 @@
-import { Maybe } from "@fncts/base/data/Maybe/definition";
-import type { PRef } from "../definition.js";
-/**
- * Filters the `set` value of the `Ref` with the specified predicate,
- * returning a `Ref` with a `set` value that succeeds if the predicate is
- * satisfied or else fails with `None`.
- * @tsplus fluent fncts.io.Ref filterInput
- * @tsplus fluent fncts.io.Ref.Synchronized filterInput
- * @tsplus location "@fncts/io/Ref/api/filter"
- */
-export declare function filterInput_<RA, RB, EA, EB, B, A, A1 extends A>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: A1) => boolean, __tsplusTrace?: string): PRef<RA, RB, Maybe<EA>, EB, A1, B>;
-/**
- * Filters the `get` value of the `Ref` with the specified predicate,
- * returning a `Ref` with a `get` value that succeeds if the predicate is
- * satisfied or else fails with `None`.
- * @tsplus fluent fncts.io.Ref filterOutput
- * @tsplus fluent fncts.io.Ref.Synchronized filterOutput
- * @tsplus location "@fncts/io/Ref/api/filter"
- */
-export declare function filterOutput_<RA, RB, EA, EB, A, B>(ref: PRef<RA, RB, EA, EB, A, B>, f: (_: B) => boolean, __tsplusTrace?: string): PRef<RA, RB, EA, Maybe<EB>, A, B>;

package/Ref/api/get.d.ts

@@ -1,9 +0,0 @@
-import { IO } from "@fncts/io/IO/definition";
-import type { PRef } from "../definition.js";
-/**
- * Reads the value from the `Ref`.
- * @tsplus getter fncts.io.Ref get
- * @tsplus getter fncts.io.Ref.Synchronized get
- * @tsplus location "@fncts/io/Ref/api/get"
- */
-export declare function get<RA, RB, EA, EB, A, B>(self: PRef<RA, RB, EA, EB, A, B>, __tsplusTrace?: string): IO<RA | RB, EA | EB, B>;

package/Ref/api/match.d.ts

@@ -1,13 +0,0 @@
-import { Either } from "@fncts/base/data/Either/definition";
-import type { PRef } from "../definition.js";
-/**
- * Folds over the error and value types of the `Ref`. This is a highly
- * polymorphic method that is capable of arbitrarily transforming the error
- * and value types of the `Ref`. For most use cases one of the more specific
- * combinators implemented in terms of `match` will be more ergonomic but this
- * method is extremely useful for implementing new combinators.
- * @tsplus fluent fncts.io.Ref match
- * @tsplus fluent fncts.io.Ref.Synchronized match
- * @tsplus location "@fncts/io/Ref/api/match"
- */
-export declare function match_<RA, RB, EA, EB, A, B, EC, ED, C, D>(ref: PRef<RA, RB, EA, EB, A, B>, ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<RA, RB, EC, ED, C, D>;

package/Ref/api/matchAll.d.ts

@@ -1,11 +0,0 @@
-import { Either } from "@fncts/base/data/Either/definition";
-import type { PRef } from "../definition.js";
-/**
- * Folds over the error and value types of the `Ref`, allowing access to
- * the state in transforming the `set` value. This is a more powerful version
- * of `match` but requires unifying the error types.
- * @tsplus fluent fncts.io.Ref matchAll
- * @tsplus fluent fncts.io.Ref.Synchronized matchAll
- * @tsplus location "@fncts/io/Ref/api/matchAll"
- */
-export declare function matchAll_<RA, RB, EA, EB, A, B, EC, ED, C, D>(ref: PRef<RA, RB, EA, EB, A, B>, ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<RA, RB, EC, ED, C, D>;

package/Ref/api/modify.d.ts

@@ -1,79 +0,0 @@
-import { IO } from "@fncts/io/IO/definition";
-import { Maybe } from "@fncts/base/data/Maybe/definition";
-import type { PRef } from "../definition.js";
-/**
- * Atomically modifies the `Ref` with the specified function, which
- * computes a return value for the modification. This is a more powerful
- * version of `update`.
- * @tsplus fluent fncts.io.Ref modify
- * @tsplus fluent fncts.io.Ref.Synchronized modify
- * @tsplus location "@fncts/io/Ref/api/modify"
- */
-export declare function modify_<RA, RB, EA, EB, B, A>(ref: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => readonly [B, A], __tsplusTrace?: string): IO<RA | RB, EA | EB, B>;
-/**
- * Atomically modifies the `Ref` with the specified partial function,
- * which computes a return value for the modification if the function is
- * defined on the current value otherwise it returns a default value. This
- * is a more powerful version of `updateJust`.
- * @tsplus fluent fncts.io.Ref modifyJust
- * @tsplus fluent fncts.io.Ref.Synchronized modifyJust
- * @tsplus location "@fncts/io/Ref/api/modify"
- */
-export declare function modifyJust_<RA, RB, EA, EB, A, B>(self: PRef<RA, RB, EA, EB, A, A>, def: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): IO<RA | RB, EA | EB, B>;
-/**
- * Atomically writes the specified value to the `Ref`, returning the value
- * immediately before modification.
- * @tsplus fluent fncts.io.Ref getAndSet
- * @tsplus fluent fncts.io.Ref.Synchronized getAndSet
- * @tsplus location "@fncts/io/Ref/api/modify"
- */
-export declare function getAndSet_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, a: A, __tsplusTrace?: string): IO<RA | RB, EA | EB, A>;
-/**
- * Atomically modifies the `Ref` with the specified function, returning
- * the value immediately before modification.
- * @tsplus fluent fncts.io.Ref getAndUpdate
- * @tsplus fluent fncts.io.Ref.Synchronized getAndUpdate
- * @tsplus location "@fncts/io/Ref/api/modify"
- */
-export declare function getAndUpdate_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => A, __tsplusTrace?: string): IO<RA | RB, EA | EB, A>;
-/**
- * Atomically modifies the `Ref` 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.
- * @tsplus fluent fncts.io.Ref getAndUpdateJust
- * @tsplus fluent fncts.io.Ref.Synchronized getAndUpdateJust
- * @tsplus location "@fncts/io/Ref/api/modify"
- */
-export declare function getAndUpdateJust_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): IO<RA | RB, EA | EB, A>;
-/**
- * Atomically modifies the `Ref` with the specified function.
- * @tsplus fluent fncts.io.Ref update
- * @tsplus fluent fncts.io.Ref.Synchronized update
- * @tsplus location "@fncts/io/Ref/api/modify"
- */
-export declare function update_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => A, __tsplusTrace?: string): IO<RA | RB, EA | EB, void>;
-/**
- * Atomically modifies the `Ref` with the specified function and returns
- * the updated value.
- * @tsplus fluent fncts.io.Ref updateAndGet
- * @tsplus fluent fncts.io.Ref.Synchronized updateAndGet
- * @tsplus location "@fncts/io/Ref/api/modify"
- */
-export declare function updateAndGet_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => A, __tsplusTrace?: string): IO<RA | RB, EA | EB, A>;
-/**
- * Atomically modifies the `Ref` with the specified partial function. If
- * the function is undefined on the current value it doesn't change it.
- * @tsplus fluent fncts.io.Ref updateJust
- * @tsplus fluent fncts.io.Ref.Synchronized updateJust
- * @tsplus location "@fncts/io/Ref/api/modify"
- */
-export declare function updateJust_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): IO<RA | RB, EA | EB, void>;
-/**
- * Atomically modifies the `Ref` with the specified partial function. If
- * the function is undefined on the current value it returns the old value
- * without changing it.
- * @tsplus fluent fncts.io.Ref updateJustAndGet
- * @tsplus fluent fncts.io.Ref.Synchronized updateJustAndGet
- * @tsplus location "@fncts/io/Ref/api/modify"
- */
-export declare function updateJustAndGet_<RA, RB, EA, EB, A>(self: PRef<RA, RB, EA, EB, A, A>, f: (a: A) => Maybe<A>, __tsplusTrace?: string): IO<RA | RB, EA | EB, A>;