@fncts/io 0.0.21 → 0.0.22

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"

package/Ref/definition.d.ts

@@ -1,76 +1,100 @@
-import { UIO } from "@fncts/io/IO/definition";
-import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Either } from "@fncts/base/data/Either/definition";
 import type { Atomic as Atomic_ } from "./Atomic.js";
-import type { Synchronized as Synchronized_ } from "./Synchronized.js";
+import type * as Synchro from "./Synchronized/definition.js";
+import { _A, _B, _EA, _EB, _RA, _RB } from "./symbols.js";
 export declare const RefTypeId: unique symbol;
 export type RefTypeId = typeof RefTypeId;
+/**
+ * @tsplus type fncts.io.Ref
+ */
+export interface PRef<RA, RB, EA, EB, A, B> {
+    readonly [RefTypeId]: RefTypeId;
+    readonly [_RA]: () => RA;
+    readonly [_RB]: () => RB;
+    readonly [_EA]: () => EA;
+    readonly [_EB]: () => EB;
+    readonly [_A]: (_: A) => void;
+    readonly [_B]: () => B;
+}
+export type Ref<A> = PRef<never, never, never, never, A, A>;
+export type ERef<E, A> = PRef<unknown, unknown, E, E, A, A>;
+export declare namespace PRef {
+    type Synchronized<RA, RB, EA, EB, A, B> = Synchro.PSynchronized<RA, RB, EA, EB, A, B>;
+}
+export declare namespace ERef {
+    type Synchronized<E, A> = Synchro.PSynchronized<never, never, E, E, A, A>;
+}
 export declare namespace Ref {
     type Atomic<A> = Atomic_<A>;
-    type Synchronized<A> = Synchronized_<A>;
+    type Synchronized<A> = Synchro.PSynchronized<never, never, never, never, A, A>;
 }
 /**
- * @tsplus type fncts.io.Ref
- * @tsplus companion fncts.io.RefOps
+ * @tsplus type fncts.io.RefOps
  */
-export declare abstract class Ref<A> {
-    readonly _typeId: RefTypeId;
-    _A: (_: A) => A;
+export interface RefOps {
+}
+export declare const Ref: RefOps;
+export interface ReadableRef<RB, EB, B> {
+    readonly [_RB]: () => RB;
+    readonly [_EB]: () => EB;
+    readonly [_B]: () => B;
+    readonly get: IO<RB, EB, B>;
+}
+export interface WritableRef<RA, EA, A> {
+    readonly [_RA]: () => RA;
+    readonly [_EA]: () => EA;
+    readonly [_A]: (_: A) => void;
+    set(a: A, __tsplusTrace?: string): IO<RA, EA, void>;
+}
+export interface ModifiableRef<RA, RB, EA, EB, A, B> {
+    readonly [_RA]: () => RA;
+    readonly [_RB]: () => RB;
+    readonly [_EA]: () => EA;
+    readonly [_EB]: () => EB;
+    readonly [_A]: (_: A) => void;
+    readonly [_B]: () => B;
+    modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string): IO<RA | RB, EA | EB, C>;
+}
+export declare abstract class RefInternal<RA, RB, EA, EB, A, B> implements PRef<RA, RB, EA, EB, A, B>, ReadableRef<RB, EB, B>, WritableRef<RA, EA, A>, ModifiableRef<RA, RB, EA, EB, A, B> {
+    readonly [RefTypeId]: RefTypeId;
+    [_RA]: () => RA;
+    [_RB]: () => RB;
+    [_EA]: () => EA;
+    [_EB]: () => EB;
+    [_A]: (_: A) => void;
+    [_B]: () => B;
+    /**
+     * 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.
+     */
+    abstract match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<RA, RB, EC, ED, C, D>;
+    /**
+     * Folds over the error and value types ofthe `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.
+     */
+    abstract 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<RA | RB, RB, EC, ED, C, D>;
     /**
      * Reads the value from the `Ref`.
      */
-    abstract get: UIO<A>;
+    abstract get get(): IO<RB, EB, B>;
     /**
      * Writes a new value to the `Ref`, with a guarantee of immediate
      * consistency (at some cost to performance).
      */
-    abstract set(a: A, __tsplusTrace?: string): UIO<void>;
+    abstract set(a: A, __tsplusTrace?: string): IO<RA, EA, void>;
     /**
      * Atomically modifies the `Ref` with the specified function, which
      * computes a return value for the modification. This is a more powerful
      * version of `update`.
      */
-    abstract modify<B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): UIO<B>;
-    /**
-     * Atomically writes the specified value to the `Ref`, returning the value
-     * immediately before modification.
-     */
-    getAndSet(a: A, __tsplusTrace?: string): UIO<A>;
-    /**
-     * Atomically modifies the `Ref` with the specified function, returning the
-     * value immediately before modification.
-     */
-    getAndUpdate(f: (a: A) => A, __tsplusTrace?: string): UIO<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.
-     */
-    getAndUpdateJust(f: (a: A) => Maybe<A>, __tsplusTrace?: string): UIO<A>;
-    /**
-     * 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`.
-     */
-    modifyJust<B>(orElse: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): UIO<B>;
-    /**
-     * Atomically modifies the `Ref` with the specified function.
-     */
-    update(f: (a: A) => A, __tsplusTrace?: string): UIO<void>;
-    /**
-     * Atomically modifies the `Ref` with the specified function and returns the
-     * updated value.
-     */
-    updateAndGet(f: (a: A) => A, __tsplusTrace?: string): UIO<A>;
-    /**
-     * Atomically modifies the `Ref` with the specified partial function. If the
-     * function is undefined on the current value it doesn't change it.
-     */
-    updateJust(f: (a: A) => Maybe<A>, __tsplusTrace?: string): UIO<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.
-     */
-    updateJustAndGet(f: (a: A) => Maybe<A>, __tsplusTrace?: string): UIO<A>;
+    abstract modify<C>(f: (a: B) => readonly [C, A], __tsplusTrace?: string): IO<RA | RB, EA | EB, C>;
 }
+/**
+ * @tsplus macro remove
+ */
+export declare function concrete<RA, RB, EA, EB, A, B>(_: PRef<RA, RB, EA, EB, A, B>): asserts _ is RefInternal<RA, RB, EA, EB, A, B>;

package/Ref/symbols.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @tsplus static fncts.io.RefOps _RA
+ * @tsplus location "@fncts/io/Ref/symbols"
+ */
+export declare const _RA: unique symbol;
+/**
+ * @tsplus static fncts.io.RefOps _RB
+ * @tsplus location "@fncts/io/Ref/symbols"
+ */
+export declare const _RB: unique symbol;
+/**
+ * @tsplus static fncts.io.RefOps _EA
+ * @tsplus location "@fncts/io/Ref/symbols"
+ */
+export declare const _EA: unique symbol;
+/**
+ * @tsplus static fncts.io.RefOps _EB
+ * @tsplus location "@fncts/io/Ref/symbols"
+ */
+export declare const _EB: unique symbol;
+/**
+ * @tsplus static fncts.io.RefOps _A
+ * @tsplus location "@fncts/io/Ref/symbols"
+ */
+export declare const _A: unique symbol;
+/**
+ * @tsplus static fncts.io.RefOps _B
+ * @tsplus location "@fncts/io/Ref/symbols"
+ */
+export declare const _B: unique symbol;

package/Ref.d.ts

@@ -1,4 +1,11 @@
+export * from "./Ref/api.js";
 export * from "./Ref/Atomic.js";
 export * from "./Ref/constructors.js";
 export * from "./Ref/definition.js";
+export * from "./Ref/Derived.js";
+export * from "./Ref/DerivedAll.js";
+export * from "./Ref/symbols.js";
 export * from "./Ref/Synchronized.js";
+export * from "./Ref/Synchronized/api.js";
+export * from "./Ref/Synchronized/constructors.js";
+export * from "./Ref/Synchronized/definition.js";

package/RefSubject/Atomic.d.ts

@@ -0,0 +1,36 @@
+import { Just } from "@fncts/base/data/Maybe/definition";
+import { IO } from "@fncts/io/IO/definition";
+import { Scope } from "@fncts/io/Scope/definition";
+import { Cause } from "@fncts/base/data/Cause/definition";
+import type { Emitter } from "@fncts/io/Push";
+import { Hold } from "@fncts/io/Push";
+import { Atomic } from "@fncts/io/Ref";
+import { RefSubjectInternal } from "@fncts/io/RefSubject";
+export declare class AtomicRefSubject<E, A> extends RefSubjectInternal<never, E, A, A> {
+    readonly initial: A;
+    readonly stream: Hold<never, E, A>;
+    readonly maybeRef: Atomic<import("@fncts/base/data/Maybe").Maybe<A>>;
+    readonly ref: AtomicEmitRef<E, A>;
+    constructor(initial: A);
+    get get(): import("../IO").UIO<A>;
+    set(value: A, __tsplusTrace?: string): import("../IO").IO<never, never, void>;
+    modify<E, A, B>(this: AtomicRefSubject<E, A>, f: (a: A) => readonly [B, A], __tsplusTrace?: string): IO<never, never, B>;
+    run<R>(emitter: Emitter<R, E, A>): IO<Scope | R, never, unknown>;
+    emit(value: A): IO<never, never, void>;
+    failCause(cause: Cause<E>): IO<never, never, void>;
+    end: IO<never, never, void>;
+    unsafeEmit(value: A): void;
+    unsafeFailCause(cause: Cause<E>): void;
+    unsafeEnd(): void;
+}
+declare class AtomicEmitRef<E, A> extends Atomic<A> {
+    readonly ref: Atomic<A>;
+    readonly emitter: Emitter<never, E, A>;
+    constructor(ref: Atomic<A>, emitter: Emitter<never, E, A>);
+    get get(): import("../IO").UIO<A>;
+    get unsafeGet(): A;
+    unsafeSet(value: A): void;
+    set(value: A, __tsplusTrace?: string): import("../IO").IO<never, never, void>;
+    modify<B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): import("../IO").IO<never, never, B>;
+}
+export {};

package/RefSubject/Synchronized/api.d.ts

@@ -0,0 +1,9 @@
+import { Lazy } from "@fncts/base/data/function/definition";
+import { UIO } from "@fncts/io/IO/definition";
+import { RefSubject } from "@fncts/io/RefSubject";
+/**
+ * @tsplus static fncts.io.Push.RefSubject.SynchronizedOps make
+ * @tsplus static fncts.io.Push.RefSubject.SynchronizedOps __call
+ * @tsplus location "@fncts/io/RefSubject/Synchronized/api"
+ */
+export declare function make<A>(initial: Lazy<A>): UIO<RefSubject.Synchronized<never, never, A, A>>;

package/RefSubject/Synchronized/definition.d.ts

@@ -0,0 +1,40 @@
+import { TSemaphore } from "@fncts/io/TSemaphore/definition";
+import type { RefSubject } from "../definition.js";
+import type { Cause } from "@fncts/base/data/Cause";
+import type { Emitter } from "@fncts/io/Push";
+import type { Scope } from "@fncts/io/Scope";
+import { IO } from "@fncts/io/IO";
+import { RefSubjectInternal } from "../definition.js";
+export declare const SynchronizedRefSubjectTypeId: unique symbol;
+export type SynchronizedRefSubjectTypeId = typeof SynchronizedRefSubjectTypeId;
+/**
+ * @tsplus type fncts.io.Push.RefSubject.Synchronized
+ */
+export interface SynchronizedRefSubject<R, E, A, B> extends RefSubject<R, E, A, B> {
+    readonly [SynchronizedRefSubjectTypeId]: SynchronizedRefSubjectTypeId;
+}
+/**
+ * @tsplus type fncts.io.Push.RefSubject.SynchronizedOps
+ */
+export interface SynchronizedRefSubjectOps {
+}
+/**
+ * @tsplus static fncts.io.Push.RefSubjectOps Synchronized
+ * @tsplus location "@fncts/io/RefSubject/Synchronized/definition"
+ */
+export declare const Synchronized: SynchronizedRefSubjectOps;
+export declare class SynchronizedRefSubjectInternal<R, E, A, B> extends RefSubjectInternal<R, E, A, B> implements SynchronizedRefSubject<R, E, A, B> {
+    readonly semaphore: TSemaphore;
+    readonly ref: RefSubjectInternal<R, E, A, B>;
+    readonly [SynchronizedRefSubjectTypeId]: SynchronizedRefSubjectTypeId;
+    constructor(semaphore: TSemaphore, ref: RefSubjectInternal<R, E, A, B>);
+    get get(): IO<R, never, B>;
+    set(a: A, __tsplusTrace?: string | undefined): IO<R, never, void>;
+    run<R1>(emitter: Emitter<R1, E, B>): IO<Scope | R | R1, never, void>;
+    modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): IO<R, never, C>;
+    modifyIO<R1, E1, C>(f: (b: B) => IO<R1, E1, readonly [C, A]>, __tsplusTrace?: string): IO<R | R1, E1, C>;
+    emit(value: A): IO<R, never, void>;
+    failCause(cause: Cause<E>): IO<R, never, void>;
+    end: IO<R, never, void>;
+    withPermit<R, E, A>(io: IO<R, E, A>, __tsplusTrace?: string): IO<R, E, A>;
+}