@fncts/io 0.0.21 → 0.0.23

package/Ref/Synchronized/api.d.ts

@@ -0,0 +1,102 @@
+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 pipeable fncts.io.Ref.Synchronized collectIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function collectIO<B, RC, EC, C>(f: (b: B) => Maybe<IO<RC, EC, C>>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RA, RC | RB, EA, import("@fncts/base/data/Maybe.js").Maybe<EC | EB>, A, C>;
+/**
+ * Transforms the `set` value of the `SRef` with the specified effectual
+ * function.
+ * @tsplus pipeable fncts.io.Ref.Synchronized contramapIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function contramapIO<A, RC, EC, C>(f: (c: C) => IO<RC, EC, A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RC | RA, RB, EC | EA, EB, C, B>;
+/**
+ * Transforms both the `set` and `get` values of the `Synchronized` with the
+ * specified effectual functions.
+ * @tsplus pipeable fncts.io.Ref.Synchronized dimapIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function dimapIO<A, B, RC, EC, RD, ED, C = A, D = B>(f: (c: C) => IO<RC, EC, A>, g: (b: B) => IO<RD, ED, D>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RC | RA, RD | RB, EC | EA, ED | EB, 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 pipeable 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>(f: (a: A1) => IO<RC, EC, boolean>, __tsplusTrace?: string): (self: PRef.Synchronized<RA, RB, EA, EB, A, B>) => 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 pipeable fncts.io.Ref.Synchronized filterOutputIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function filterOutputIO<B, RC, EC>(f: (b: B) => IO<RC, EC, boolean>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(ref: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RA, RC | RB, EA, import("@fncts/base/data/Maybe.js").Maybe<EC | EB>, A, B>;
+/**
+ * Atomically modifies the `Synchronized` with the specified function, returning the
+ * value immediately before modification.
+ * @tsplus pipeable fncts.io.Ref.Synchronized getAndUpdateIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function getAndUpdateIO<A, R1, E1>(f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, A>;
+/**
+ * Atomically modifies the `Synchronized` with the specified function, returning the
+ * value immediately before modification.
+ */
+export declare function getAndUpdateJustIO<A, R1, E1>(f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, A>;
+/**
+ * @tsplus pipeable fncts.io.Ref.Synchronized matchIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function matchIO<EA, EB, A, B, 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): <RA, RB>(self: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RC | RA, RD | RB, EC, ED, C, D>;
+/**
+ * @tsplus pipeable fncts.io.Ref.Synchronized matchAllIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function matchAllIO<EA, EB, A, B, 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): <RA, RB>(self: PRef.Synchronized<RA, RB, EA, EB, A, B>) => PRef.Synchronized<RC | RA | RB, RD | RB, EC, ED, C, D>;
+/**
+ * @tsplus pipeable fncts.io.Ref.Synchronized modifyIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function modifyIO<A, R1, E1, B>(f: (a: A) => IO<R1, E1, readonly [B, A]>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, 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 pipeable fncts.io.Ref.Synchronized modifyJustIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function modifyJustIO<A, R1, E1, B>(def: B, f: (a: A) => Maybe<IO<R1, E1, readonly [B, A]>>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, B>;
+/**
+ * Atomically modifies the `SRef` with the specified function.
+ * @tsplus pipeable fncts.io.Ref.Synchronized updateAndGetIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function updateAndGetIO<A, R1, E1>(f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, void>;
+/**
+ * Atomically modifies the `Synchronized` with the specified function.
+ * @tsplus pipeable fncts.io.Ref.Synchronized updateIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function updateIO<A, R1, E1>(f: (a: A) => IO<R1, E1, A>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, void>;
+/**
+ * Atomically modifies the `SRef` with the specified function.
+ * @tsplus pipeable fncts.io.Ref.Synchronized updateJustAndGetIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function updateJustAndGetIO<A, R1, E1>(f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, A>;
+/**
+ * Atomically modifies the `SRef` with the specified function.
+ * @tsplus pipeable fncts.io.Ref.Synchronized updateJustIO
+ * @tsplus location "@fncts/io/Ref/Synchronized/api"
+ */
+export declare function updateJustIO<A, R1, E1>(f: (a: A) => Maybe<IO<R1, E1, A>>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef.Synchronized<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<R1 | RA | RB, E1 | EA | EB, void>;

package/Ref/Synchronized/constructors.d.ts

@@ -0,0 +1,13 @@
+import { Ref } from "@fncts/io/Ref/definition";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { UIO } from "@fncts/io/IO/definition";
+/**
+ * @tsplus static fncts.io.Ref.SynchronizedOps unsafeMake
+ * @tsplus location "@fncts/io/Ref/Synchronized/constructors"
+ */
+export declare function unsafeMakeSynchronized<A>(a: A, __tsplusTrace?: string): Ref.Synchronized<A>;
+/**
+ * @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

@@ -0,0 +1,46 @@
+import { TSemaphore } from "@fncts/io/TSemaphore/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import type { PRef } from "../definition.js";
+import { IO } from "@fncts/io/IO";
+import { RefInternal } from "../definition.js";
+export declare const SynchronizedTypeId: unique symbol;
+export type SynchronizedTypeId = typeof SynchronizedTypeId;
+/**
+ * @tsplus type fncts.io.Ref.Synchronized
+ */
+export interface PSynchronized<RA, RB, EA, EB, A, B> extends PRef<RA, RB, EA, EB, A, B> {
+    readonly [SynchronizedTypeId]: SynchronizedTypeId;
+}
+/**
+ * @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 semaphore: TSemaphore;
+    readonly unsafeGet: IO<RB, EB, B>;
+    readonly unsafeSet: (a: A) => IO<RA, EA, void>;
+    readonly [SynchronizedTypeId]: SynchronizedTypeId;
+    constructor(semaphore: 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>;
+    modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): IO<RA | RB, EA | EB, C>;
+    modifyIO<R1, E1, C>(f: (b: B) => IO<R1, E1, readonly [C, A]>, __tsplusTrace?: string): IO<RA | RB | R1, EA | EB | E1, C>;
+    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/Synchronized.d.ts

@@ -1,72 +1,3 @@
-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>;
-}
+export * from "./Synchronized/api.js";
+export * from "./Synchronized/constructors.js";
+export * from "./Synchronized/definition.js";

package/Ref/api/collect.d.ts

@@ -0,0 +1,11 @@
+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 pipeable fncts.io.Ref collect
+ * @tsplus pipeable fncts.io.Ref.Synchronized collect
+ * @tsplus location "@fncts/io/Ref/api/collect"
+ */
+export declare function collect<B, C>(pf: (_: B) => Maybe<C>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(ref: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EA, import("@fncts/base/data/Maybe.js").Maybe<EB>, A, C>;

package/Ref/api/dimap.d.ts

@@ -0,0 +1,56 @@
+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 pipeable fncts.io.Ref contramap
+ * @tsplus pipeable fncts.io.Ref.Synchronized contramap
+ * @tsplus location "@fncts/io/Ref/api/dimap"
+ */
+export declare function contramap<A, C>(f: (_: C) => A, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EA, EB, C, B>;
+/**
+ * Transforms the `set` value of the `Ref` with the specified fallible
+ * function.
+ * @tsplus pipeable fncts.io.Ref contramapEither
+ * @tsplus pipeable fncts.io.Ref.Synchronized contramapEither
+ * @tsplus location "@fncts/io/Ref/api/dimap"
+ */
+export declare function contramapEither<A, EC, C>(f: (_: C) => Either<EC, A>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EC | EA, EB, C, B>;
+/**
+ * Transforms both the `set` and `get` values of the `Ref` with the
+ * specified functions.
+ * @tsplus pipeable fncts.io.Ref dimap
+ * @tsplus pipeable fncts.io.Ref.Synchronized dimap
+ * @tsplus location "@fncts/io/Ref/api/dimap"
+ */
+export declare function dimap<A, B, C, D>(f: (_: C) => A, g: (_: B) => D, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EA, EB, C, D>;
+/**
+ * Transforms both the `set` and `get` values of the `Ref` with the
+ * specified fallible functions.
+ * @tsplus pipeable fncts.io.Ref dimapEither
+ * @tsplus pipeable fncts.io.Ref.Synchronized dimapEither
+ * @tsplus location "@fncts/io/Ref/api/dimap"
+ */
+export declare function dimapEither<A, B, C, EC, D, ED>(f: (_: C) => Either<EC, A>, g: (_: B) => Either<ED, D>, __tsplusTrace?: string): <RA, RB, EA, EB>(ref: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EC | EA, ED | EB, C, D>;
+/**
+ * Transforms both the `set` and `get` errors of the `Ref` with the
+ * specified functions.
+ * @tsplus pipeable fncts.io.Ref dimapError
+ * @tsplus pipeable fncts.io.Ref.Synchronized dimapError
+ * @tsplus location "@fncts/io/Ref/api/dimap"
+ */
+export declare function dimapError<EA, EB, EC, ED>(f: (_: EA) => EC, g: (_: EB) => ED, __tsplusTrace?: string): <RA, RB, A, B>(ref: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EC, ED, A, B>;
+/**
+ * Transforms the `get` value of the `Ref` with the specified fallible
+ * function.
+ * @tsplus pipeable fncts.io.Ref mapEither
+ * @tsplus pipeable fncts.io.Ref.Synchronized mapEither
+ * @tsplus location "@fncts/io/Ref/api/dimap"
+ */
+export declare function mapEither<B, EC, C>(f: (_: B) => Either<EC, C>, __tsplusTrace?: string): <RA, RB, EA, EB, A>(ref: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EA, EC | EB, A, C>;
+/**
+ * Transforms the `get` value of the `Ref` with the specified function.
+ * @tsplus pipeable fncts.io.Ref map
+ * @tsplus pipeable fncts.io.Ref.Synchronized map
+ * @tsplus location "@fncts/io/Ref/api/dimap"
+ */
+export declare function map<B, C>(f: (_: B) => C, __tsplusTrace?: string): <RA, RB, EA, EB, A>(ref: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EA, EB, A, C>;

package/Ref/api/filter.d.ts

@@ -0,0 +1,21 @@
+import { Predicate } from "@fncts/base/data/Predicate/definition";
+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 pipeable fncts.io.Ref filterInput
+ * @tsplus pipeable fncts.io.Ref.Synchronized filterInput
+ * @tsplus location "@fncts/io/Ref/api/filter"
+ */
+export declare function filterInput<A, A1 extends A>(p: Predicate<A1>, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, import("@fncts/base/data/Maybe.js").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 pipeable fncts.io.Ref filterOutput
+ * @tsplus pipeable fncts.io.Ref.Synchronized filterOutput
+ * @tsplus location "@fncts/io/Ref/api/filter"
+ */
+export declare function filterOutput<RA, RB, EA, EB, A, B>(p: Predicate<B>, __tsplusTrace?: string): (self: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EA, Maybe<EB>, A, B>;

package/Ref/api/get.d.ts

@@ -0,0 +1,9 @@
+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<RB, EB, B>;

package/Ref/api/match.d.ts

@@ -0,0 +1,13 @@
+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 pipeable fncts.io.Ref match
+ * @tsplus pipeable fncts.io.Ref.Synchronized match
+ * @tsplus location "@fncts/io/Ref/api/match"
+ */
+export declare function match<EA, EB, A, B, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): <RA, RB>(ref: PRef<RA, RB, EA, EB, A, B>) => PRef<RA, RB, EC, ED, C, D>;

package/Ref/api/matchAll.d.ts

@@ -0,0 +1,11 @@
+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<EA, EB, A, B, EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => Either<EC, A>, bd: (_: B) => Either<ED, D>): <RA, RB>(ref: PRef<RA, RB, EA, EB, A, B>) => PRef<RA | RB, RB, EC, ED, C, D>;

package/Ref/api/modify.d.ts

@@ -0,0 +1,79 @@
+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 pipeable fncts.io.Ref modify
+ * @tsplus pipeable fncts.io.Ref.Synchronized modify
+ * @tsplus location "@fncts/io/Ref/api/modify"
+ */
+export declare function modify<B, A>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").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 pipeable fncts.io.Ref modifyJust
+ * @tsplus pipeable fncts.io.Ref.Synchronized modifyJust
+ * @tsplus location "@fncts/io/Ref/api/modify"
+ */
+export declare function modifyJust<A, B>(def: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, B>;
+/**
+ * Atomically writes the specified value to the `Ref`, returning the value
+ * immediately before modification.
+ * @tsplus pipeable fncts.io.Ref getAndSet
+ * @tsplus pipeable fncts.io.Ref.Synchronized getAndSet
+ * @tsplus location "@fncts/io/Ref/api/modify"
+ */
+export declare function getAndSet<A>(a: A, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, A>;
+/**
+ * Atomically modifies the `Ref` with the specified function, returning
+ * the value immediately before modification.
+ * @tsplus pipeable fncts.io.Ref getAndUpdate
+ * @tsplus pipeable fncts.io.Ref.Synchronized getAndUpdate
+ * @tsplus location "@fncts/io/Ref/api/modify"
+ */
+export declare function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").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 pipeable fncts.io.Ref getAndUpdateJust
+ * @tsplus pipeable fncts.io.Ref.Synchronized getAndUpdateJust
+ * @tsplus location "@fncts/io/Ref/api/modify"
+ */
+export declare function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, A>;
+/**
+ * Atomically modifies the `Ref` with the specified function.
+ * @tsplus pipeable fncts.io.Ref update
+ * @tsplus pipeable fncts.io.Ref.Synchronized update
+ * @tsplus location "@fncts/io/Ref/api/modify"
+ */
+export declare function update<A>(f: (a: A) => A, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, void>;
+/**
+ * Atomically modifies the `Ref` with the specified function and returns
+ * the updated value.
+ * @tsplus pipeable fncts.io.Ref updateAndGet
+ * @tsplus pipeable fncts.io.Ref.Synchronized updateAndGet
+ * @tsplus location "@fncts/io/Ref/api/modify"
+ */
+export declare function updateAndGet<A>(f: (a: A) => A, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").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 pipeable fncts.io.Ref updateJust
+ * @tsplus pipeable fncts.io.Ref.Synchronized updateJust
+ * @tsplus location "@fncts/io/Ref/api/modify"
+ */
+export declare function updateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").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 pipeable fncts.io.Ref updateJustAndGet
+ * @tsplus pipeable fncts.io.Ref.Synchronized updateJustAndGet
+ * @tsplus location "@fncts/io/Ref/api/modify"
+ */
+export declare function updateJustAndGet<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <RA, RB, EA, EB>(self: PRef<RA, RB, EA, EB, A, A>) => import("../../IO.js").IO<RA | RB, EA | EB, A>;

package/Ref/api/set.d.ts

@@ -0,0 +1,10 @@
+import { IO } from "@fncts/io/IO/definition";
+import type { PRef } from "../definition.js";
+/**
+ * Writes a new value to the `Ref`, with a guarantee of immediate
+ * consistency (at some cost to performance).
+ * @tsplus pipeable fncts.io.Ref set
+ * @tsplus pipeable fncts.io.Ref.Synchronized set
+ * @tsplus location "@fncts/io/Ref/api/set"
+ */
+export declare function set<A>(a: A, __tsplusTrace?: string): <RA, RB, EA, EB, B>(self: PRef<RA, RB, EA, EB, A, B>) => import("../../IO.js").IO<RA, EA, void>;

package/Ref/api.d.ts

@@ -0,0 +1,23 @@
+import type { PRef } from "./definition.js";
+export * from "./api/collect.js";
+export * from "./api/dimap.js";
+export * from "./api/filter.js";
+export * from "./api/get.js";
+export * from "./api/match.js";
+export * from "./api/matchAll.js";
+export * from "./api/modify.js";
+export * from "./api/set.js";
+/**
+ * Returns a read only view of the `Ref`.
+ * @tsplus getter fncts.io.Ref readOnly
+ * @tsplus getter fncts.io.Ref.Synchronized readOnly
+ * @tsplus location "@fncts/io/Ref/api"
+ */
+export declare function readOnly<RA, RB, EA, EB, A, B>(ref: PRef<RA, RB, EA, EB, A, B>): PRef<RA, RB, EA, EB, never, B>;
+/**
+ * Returns a write only view of the `Ref`.
+ * @tsplus getter fncts.io.Ref writeOnly
+ * @tsplus getter fncts.io.Ref.Synchronized writeOnly
+ * @tsplus location "@fncts/io/Ref/api"
+ */
+export declare function writeOnly<RA, RB, EA, EB, A, B>(ref: PRef<RA, RB, EA, EB, A, B>): PRef<RA, RB, EA, void, A, never>;

package/Ref/constructors.d.ts

@@ -1,18 +1,11 @@
 import { Lazy } from "@fncts/base/data/function/definition";
 import { UIO } from "@fncts/io/IO/definition";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 /**
  * @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"