@fncts/io 0.0.21 → 0.0.22

package/Stream/api.d.ts

@@ -10,16 +10,17 @@ import { Fiber } from "@fncts/io/Fiber/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Exit } from "@fncts/base/data/Exit/definition";
 import { Scope } from "@fncts/io/Scope/definition";
-import { Dequeue, Enqueue } from "@fncts/io/Queue/definition";
 import { Future } from "@fncts/io/Future";
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 import { Environment } from "@fncts/base/data/Environment/definition";
 import { Duration } from "@fncts/base/data/Duration/definition";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Layer } from "@fncts/io/Layer";
+import type { PHub } from "../Hub.js";
 import type { Canceler } from "../IO.js";
+import type { PDequeue, PEnqueue, PQueue } from "../Queue.js";
 import { MergeDecision } from "../Channel/internal/MergeDecision.js";
 import { Hub } from "../Hub.js";
 import { Queue } from "../Queue.js";
@@ -71,18 +72,18 @@ export declare function aggregateAsyncWithinEither<R1, E1, A1, B, R2, C>(sink: S
  * Composes this stream with the specified stream to create a cartesian product of elements,
  * but keeps only elements from this stream.
  * The `that` stream would be run multiple times, for every element in the `this` stream.
- * @tsplus pipeable fncts.io.Stream apFirst
+ * @tsplus pipeable fncts.io.Stream zipLeft
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function apFirst<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
+export declare function zipLeft<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A>;
 /**
  * Composes this stream with the specified stream to create a cartesian product of elements,
  * but keeps only elements from the other stream.
  * The `that` stream would be run multiple times, for every element in the `this` stream.
- * @tsplus pipeable fncts.io.Stream apSecond
+ * @tsplus pipeable fncts.io.Stream zipRight
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function apSecond<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A1>;
+export declare function zipRight<R1, E1, A1>(that: Stream<R1, E1, A1>, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => Stream<R1 | R, E1 | E, A1>;
 /**
  * Maps the success values of this stream to the specified constant value.
  * @tsplus pipeable fncts.io.Stream as
@@ -158,7 +159,7 @@ export declare function broadcastDynamic(maximumLag: number, __tsplusTrace?: str
  * @tsplus pipeable fncts.io.Stream broadcastedQueues
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function broadcastedQueues(n: number, maximumLag: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("@fncts/base/collection/immutable/Conc.js").Conc<import("../Queue.js").Dequeue<Take<E, A>>>>;
+export declare function broadcastedQueues(n: number, maximumLag: number, __tsplusTrace?: string): <R, E, A>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("@fncts/base/collection/immutable/Conc.js").Conc<Queue.Dequeue<Take<E, A>>>>;
 /**
  * Converts the stream to a managed dynamic amount of queues. Every chunk will be replicated to every queue with the
  * slowest queue being allowed to buffer `maximumLag` chunks before the driver is backpressured.
@@ -167,7 +168,7 @@ export declare function broadcastedQueues(n: number, maximumLag: number, __tsplu
  * @tsplus pipeable fncts.io.Stream broadcastedQueuesDynamic
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function broadcastedQueuesDynamic(maximumLag: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../IO.js").IO<import("../Scope.js").Scope, never, import("../Queue.js").Dequeue<Take<E, A>>>>;
+export declare function broadcastedQueuesDynamic(maximumLag: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../IO.js").IO<import("../Scope.js").Scope, never, Queue.Dequeue<Take<E, A>>>>;
 /**
  * Allows a faster producer to progress independently of a slower consumer by buffering
  * up to `capacity` elements in a queue.
@@ -322,7 +323,7 @@ export declare function defaultIfEmpty<R1, E1, B>(fb: Stream<R1, E1, B>, __tsplu
  * @tsplus pipeable fncts.io.Stream distributedWith
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function distributedWith<A>(n: number, maximumLag: number, decide: (_: A) => UIO<(_: number) => boolean>, __tsplusTrace?: string): <R, E>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("@fncts/base/collection/immutable/Conc.js").Conc<import("../Queue.js").Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>>>;
+export declare function distributedWith<A>(n: number, maximumLag: number, decide: (_: A) => UIO<(_: number) => boolean>, __tsplusTrace?: string): <R, E>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("@fncts/base/collection/immutable/Conc.js").Conc<Queue.Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>>>;
 /**
  * More powerful version of `ZStream#distributedWith`. This returns a function that will produce
  * new queues and corresponding indices.
@@ -333,7 +334,7 @@ export declare function distributedWith<A>(n: number, maximumLag: number, decide
  * @tsplus pipeable fncts.io.Stream distributedWithDynamic
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function distributedWithDynamic<E, A>(maximumLag: number, decide: (a: A) => UIO<(_: symbol) => boolean>, done?: (exit: Exit<Maybe<E>, never>) => UIO<any>, __tsplusTrace?: string): <R>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../IO.js").UIO<readonly [symbol, import("../Queue.js").Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>]>>;
+export declare function distributedWithDynamic<E, A>(maximumLag: number, decide: (a: A) => UIO<(_: symbol) => boolean>, done?: (exit: Exit<Maybe<E>, never>) => UIO<any>, __tsplusTrace?: string): <R>(self: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../IO.js").UIO<readonly [symbol, Queue.Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>]>>;
 /**
  * Converts this stream to a stream that executes its effects but emits no
  * elements. Useful for sequencing effects using streams.
@@ -561,12 +562,12 @@ export declare function fromPull<R, E, A>(scopedPull: IO<R, never, IO<R, Maybe<E
  * @tsplus static fncts.io.StreamOps fromQueue
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromQueue<O>(queue: Dequeue<O>, maxChunkSize?: number, __tsplusTrace?: string): Stream<never, never, O>;
+export declare function fromQueue<RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>, maxChunkSize?: number, __tsplusTrace?: string): Stream<RB, EB, B>;
 /**
  * @tsplus static fncts.io.StreamOps fromQueueWithShutdown
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function fromQueueWithShutdown<R, E, A>(queue: Dequeue<A>, maxChunkSize?: number, __tsplusTrace?: string): Stream<never, never, A>;
+export declare function fromQueueWithShutdown<RA, RB, EA, EB, A, B>(queue: PDequeue<RA, RB, EA, EB, A, B>, maxChunkSize?: number, __tsplusTrace?: string): Stream<RB, EB, B>;
 /**
  * @tsplus static fncts.io.StreamOps fromHub
  * @tsplus location "@fncts/io/Stream/api"
@@ -894,21 +895,21 @@ export declare function runForeachScoped<A, R2, E2>(f: (a: A) => IO<R2, E2, any>
  * @tsplus pipeable fncts.io.Stream runIntoElementsScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoElementsScoped<E, A, E1>(queue: Queue<Exit<Maybe<E | E1>, A>>, __tsplusTrace?: string): <R>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, E | E1, void>;
+export declare function runIntoElementsScoped_<E, A, R1, E1>(queue: PQueue<R1, unknown, never, never, Exit<Maybe<E | E1>, A>, unknown>, __tsplusTrace?: string): <R>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R1 | R, E | E1, void>;
 /**
  * Like `Stream#into`, but provides the result as a `Managed` to allow for scope
  * composition.
  * @tsplus pipeable fncts.io.Stream runIntoQueueScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoQueueScoped<E1, A>(queue: Enqueue<Take<E1, A>>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, E1 | E, void>;
+export declare function runIntoQueueScoped<RA, RB, EA, EB, E1, A, B>(queue: PEnqueue<RA, RB, EA, EB, Take<E1, A>, B>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | RA | R, EA | E1 | E, void>;
 /**
  * Like `Stream#runIntoHub`, but provides the result as a `Managed` to allow for scope
  * composition.
  * @tsplus pipeable fncts.io.Stream runIntoHubScoped
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function runIntoHubScoped<E1, A>(hub: Hub<Take<E1, A>>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, E1 | E, void>;
+export declare function runIntoHubScoped<RA, RB, EA, EB, E1, A, B>(hub: PHub<RA, RB, EA, EB, Take<E1, A>, B>, __tsplusTrace?: string): <R, E extends E1>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | RA | R, EA | E1 | E, void>;
 /**
  * Runs the sink on the stream to produce either the sink's result or an error.
  * @tsplus pipeable fncts.io.Stream runScoped
@@ -1015,22 +1016,22 @@ export declare function toPull<R, E, A>(stream: Stream<R, E, A>, __tsplusTrace?:
  * @tsplus pipeable fncts.io.Stream toQueue
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueue(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../Queue.js").Dequeue<Take<E, A>>>;
+export declare function toQueue(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Queue.Dequeue<Take<E, A>>>;
 /**
  * @tsplus pipeable fncts.io.Stream toQueueDropping
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueueDropping(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../Queue.js").Dequeue<Take<E, A>>>;
+export declare function toQueueDropping(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Queue.Dequeue<Take<E, A>>>;
 /**
  * @tsplus pipeable fncts.io.Stream toQueueOfElements
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueueOfElements(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../Queue.js").Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>>;
+export declare function toQueueOfElements(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Queue.Dequeue<import("@fncts/base/data/Exit.js").Exit<import("@fncts/base/data/Maybe.js").Maybe<E>, A>>>;
 /**
  * @tsplus pipeable fncts.io.Stream toQueueSliding
  * @tsplus location "@fncts/io/Stream/api"
  */
-export declare function toQueueSliding(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, import("../Queue.js").Dequeue<Take<E, A>>>;
+export declare function toQueueSliding(capacity?: number, __tsplusTrace?: string): <R, E, A>(stream: Stream<R, E, A>) => import("../IO.js").IO<import("../Scope.js").Scope | R, never, Queue.Dequeue<Take<E, A>>>;
 /**
  * Converts the stream into an unbounded managed queue. After the managed queue
  * is used, the queue will never again produce values and should be discarded.

package/Stream/internal/Handoff.d.ts

@@ -1,4 +1,4 @@
-import { Ref } from "@fncts/io/Ref";
+import { Ref } from "@fncts/io/Ref/definition";
 import { Future } from "@fncts/io/Future";
 import { UIO } from "@fncts/io/IO/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";

package/Stream/internal/Pull.d.ts

@@ -1,8 +1,8 @@
 import { IO, UIO, FIO } from "@fncts/io/IO/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
-import { Dequeue } from "@fncts/io/Queue/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
+import type { Queue } from "../../Queue.js";
 import type { Take } from "./Take.js";
 export type Pull<R, E, A> = IO<R, Maybe<E>, Conc<A>>;
 /**
@@ -25,7 +25,7 @@ export declare function emitChunk<A>(as: Conc<A>): UIO<Conc<A>>;
  * @tsplus static fncts.io.Stream.PullOps fromQueue
  * @tsplus location "@fncts/io/Stream/internal/Pull"
  */
-export declare function fromQueue<E, A>(d: Dequeue<Take<E, A>>): FIO<Maybe<E>, Conc<A>>;
+export declare function fromQueue<E, A>(d: Queue.Dequeue<Take<E, A>>): FIO<Maybe<E>, Conc<A>>;
 /**
  * @tsplus static fncts.io.Stream.PullOps fail
  * @tsplus location "@fncts/io/Stream/internal/Pull"

package/Subject/Atomic.d.ts

@@ -0,0 +1,18 @@
+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 type { Subject } from "@fncts/io/Subject/definition";
+import { Multicast } from "@fncts/io/Push";
+import { SubjectTypeId } from "@fncts/io/Subject/definition";
+export declare class AtomicSubject<E, A> implements Subject<never, E, A> {
+    readonly [SubjectTypeId]: SubjectTypeId;
+    _R: (_: never) => never;
+    _E: (_: never) => E;
+    _A: (_: never) => A;
+    readonly stream: Multicast<never, E, A>;
+    run<R>(emitter: Emitter<R, E, A>): IO<R | Scope, never, unknown>;
+    emit(value: A): IO<never, never, void>;
+    failCause(cause: Cause<E>): IO<never, never, void>;
+    end: import("../IO").IO<never, never, void>;
+}

package/Subject/api.d.ts

@@ -0,0 +1,13 @@
+import { UIO } from "@fncts/io/IO/definition";
+import { Subject } from "./definition.js";
+/**
+ * @tsplus static fncts.io.Push.SubjectOps unsafeMake
+ * @tsplus location "@fncts/io/Subject/api"
+ */
+export declare function unsafeMake<E, A>(): Subject<never, E, A>;
+/**
+ * @tsplus static fncts.io.Push.SubjectOps make
+ * @tsplus static fncts.io.Push.SubjectOps __call
+ * @tsplus location "@fncts/io/Subject/api"
+ */
+export declare function make<E, A>(): UIO<Subject<never, E, A>>;

package/Subject/definition.d.ts

@@ -0,0 +1,15 @@
+import type { Emitter, Push } from "../Push.js";
+export declare const SubjectTypeId: unique symbol;
+export type SubjectTypeId = typeof SubjectTypeId;
+/**
+ * @tsplus type fncts.io.Push.Subject
+ */
+export interface Subject<R, E, A> extends Push<R, E, A>, Emitter<R, E, A> {
+    readonly [SubjectTypeId]: SubjectTypeId;
+}
+/**
+ * @tsplus type fncts.io.Push.SubjectOps
+ */
+export interface SubjectOps {
+}
+export declare const Subject: SubjectOps;

package/Subject.d.ts

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

package/SubscriptionRef.d.ts

@@ -1,17 +1,13 @@
 import { TSemaphore } from "@fncts/io/TSemaphore/definition";
 import { Hub } from "@fncts/io/Hub/definition";
-import { Ref } from "@fncts/io/Ref";
+import { Ref, PRef } from "@fncts/io/Ref/definition";
 import { UIO, IO } from "@fncts/io/IO/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
-import { Synchronized } from "@fncts/io/Ref";
+import { PSynchronizedInternal } from "@fncts/io/Ref";
 import { Stream } from "@fncts/io/Stream";
 export declare const SubscriptionRefTypeId: unique symbol;
 export type SubscriptionRefTypeId = typeof SubscriptionRefTypeId;
-/**
- * @tsplus type fncts.io.SubscriptionRef
- * @tsplus companion fncts.io.SubscriptionRefOps
- */
-export declare class SubscriptionRef<A> extends Synchronized<A> {
+export declare class SubscriptionRefInternal<A> extends PSynchronizedInternal<never, never, never, never, A, A> {
     readonly semaphore: TSemaphore;
     readonly hub: Hub<A>;
     readonly ref: Ref<A>;
@@ -21,6 +17,19 @@ export declare class SubscriptionRef<A> extends Synchronized<A> {
     set(a: A, __tsplusTrace?: string): UIO<void>;
     modifyIO<R1, E1, B>(f: (a: A) => IO<R1, E1, readonly [B, A]>, __tsplusTrace?: string): IO<R1, E1, B>;
 }
+/**
+ * @tsplus type fncts.io.SubscriptionRef
+ */
+export interface SubscriptionRef<A> extends PRef.Synchronized<never, never, never, never, A, A> {
+    readonly [SubscriptionRefTypeId]: SubscriptionRefTypeId;
+}
+/**
+ * @tsplus type fncts.io.SubscriptionRefOps
+ */
+export interface SubscriptionRefOps {
+}
+export declare const SubscriptionRef: SubscriptionRefOps;
+export declare function concrete<A>(_: SubscriptionRef<A>): asserts _ is SubscriptionRefInternal<A>;
 /**
  * @tsplus static fncts.io.SubscriptionRefOps make
  * @tsplus static fncts.io.SubscriptionRefOps __call

package/TExit/definition.d.ts

@@ -1,5 +1,5 @@
-import { Hashable } from "@fncts/base/typeclass/Hashable";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
 /**
  * @tsplus type fncts.TExit

package/TFuture/definition.d.ts

@@ -2,7 +2,7 @@ import { HKT } from "@fncts/typelevel/HKT";
 import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Either } from "@fncts/base/data/Either/definition";
-import type { UTRef } from "../TRef.js";
+import type { TRef } from "../TRef.js";
 interface TFutureN extends HKT {
     readonly type: TFuture<this["E"], this["A"]>;
 }
@@ -11,7 +11,7 @@ interface TFutureN extends HKT {
  */
 export interface TFuture<E, A> extends Newtype<{
     readonly TFuture: unique symbol;
-}, UTRef<Maybe<Either<E, A>>>> {
+}, TRef<Maybe<Either<E, A>>>> {
 }
 /**
  * @tsplus type fncts.io.TFutureOps

package/TReentrantLock/definition.d.ts

@@ -1,4 +1,4 @@
-import { UTRef } from "@fncts/io/TRef/definition";
+import { TRef } from "@fncts/io/TRef/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 /**
@@ -21,8 +21,8 @@ import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
  * @tsplus companion fncts.io.TReentrantLockOps
  */
 export declare class TReentrantLock {
-    readonly data: UTRef<LockState>;
-    constructor(data: UTRef<LockState>);
+    readonly data: TRef<LockState>;
+    constructor(data: TRef<LockState>);
 }
 export interface Lock {
     readonly readLocks: number;

package/TRef/api.d.ts

@@ -1,85 +1,84 @@
 import { STM } from "@fncts/io/STM/definition";
-import { Either } from "@fncts/base/data/Either/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import type { Journal } from "../STM/internal/Journal.js";
-import type { TRef } from "../TRef/definition.js";
+import type { PTRef } from "../TRef/definition.js";
 /**
  * Retrieves the value of the `TRef`.
  * @tsplus getter fncts.io.TRef get
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function get<EA, EB, A, B>(self: TRef<EA, EB, A, B>, __tsplusTrace?: string): STM<never, EB, B>;
+export declare function get<EA, EB, A, B>(self: PTRef<EA, EB, A, B>, __tsplusTrace?: string): STM<never, EB, B>;
 /**
  * Updates the value of the variable, returning a function of the specified
  * value.
  * @tsplus pipeable fncts.io.TRef modify
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function modify<A, B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, B>;
+export declare function modify<A, B>(f: (a: A) => readonly [B, A], __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, B>;
 /**
  * Sets the value of the `TRef`.
  * @tsplus pipeable fncts.io.TRef set
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function set<A>(a: A, __tsplusTrace?: string): <EA, EB, B>(self: TRef<EA, EB, A, B>) => import("../STM/definition.js").STM<never, EA, void>;
+export declare function set<A>(a: A, __tsplusTrace?: string): <EA, EB, B>(self: PTRef<EA, EB, A, B>) => import("../STM.js").STM<never, EA, void>;
 /**
  * Unsafely retrieves the value of the `TRef`.
  * @tsplus pipeable fncts.io.TRef unsafeGet
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function unsafeGet(journal: Journal, __tsplusTrace?: string): <EA, EB, A, B>(self: TRef<EA, EB, A, B>) => A;
+export declare function unsafeGet(journal: Journal, __tsplusTrace?: string): <EA, EB, A, B>(self: PTRef<EA, EB, A, B>) => A;
 /**
  * Updates the value of the variable, returning a function of the specified
  * value.
  * @tsplus pipeable fncts.io.TRef modifyJust
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function modifyJust<A, B>(b: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, B>;
+export declare function modifyJust<A, B>(b: B, f: (a: A) => Maybe<readonly [B, A]>, __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, B>;
 /**
  * Sets the value of the `TRef` and returns the old value.
  * @tsplus pipeable fncts.io.TRef getAndSet
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function getAndSet<A>(a: A, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, A>;
+export declare function getAndSet<A>(a: A, __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, A>;
 /**
  * Updates the value of the variable and returns the old value.
  * @tsplus pipeable fncts.io.TRef getAndUpdate
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, A>;
+export declare function getAndUpdate<A>(f: (a: A) => A, __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, A>;
 /**
  * Updates some values of the variable but leaves others alone, returning the
  * old value.
  * @tsplus pipeable fncts.io.TRef getAndUpdateJust
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, A>;
+export declare function getAndUpdateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, A>;
 /**
  * Updates the value of the variable.
  * @tsplus pipeable fncts.io.TRef update
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function update<A>(f: (a: A) => A, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, void>;
+export declare function update<A>(f: (a: A) => A, __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, void>;
 /**
  * Updates some values of the variable but leaves others alone.
  * @tsplus pipeable fncts.io.TRef updateJust
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function updateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, void>;
+export declare function updateJust<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, void>;
 /**
  * Updates the value of the variable and returns the new value.
  * @tsplus pipeable fncts.io.TRef updateAndGet
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function updateAndGet<A>(f: (a: A) => A, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, A>;
+export declare function updateAndGet<A>(f: (a: A) => A, __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, A>;
 /**
  * Updates some values of the variable but leaves others alone.
  * @tsplus pipeable fncts.io.TRef updateJustAndGet
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function updateJustAndGet<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <E>(self: TRef<E, E, A, A>) => import("../STM/definition.js").STM<never, E, A>;
+export declare function updateJustAndGet<A>(f: (a: A) => Maybe<A>, __tsplusTrace?: string): <E>(self: PTRef<E, E, A, A>) => import("../STM.js").STM<never, E, A>;
 /**
  * @tsplus pipeable fncts.io.TRef unsafeSet
  * @tsplus location "@fncts/io/TRef/api"
  */
-export declare function unsafeSet<A>(journal: Journal, a: A, __tsplusTrace?: string): <EA, EB, B>(self: TRef<EA, EB, A, B>) => void;
+export declare function unsafeSet<A>(journal: Journal, a: A, __tsplusTrace?: string): <EA, EB, B>(self: PTRef<EA, EB, A, B>) => void;

package/TRef/constructors.d.ts

@@ -1,32 +1,32 @@
 import { STM } from "@fncts/io/STM/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { UIO } from "@fncts/io/IO/definition";
-import type { UTRef } from "./definition.js";
+import type { TRef } from "./definition.js";
 /**
  * Makes a new `TRef` that is initialized to the specified value.
  * @tsplus static fncts.io.TRefOps makeNow
  * @tsplus location "@fncts/io/TRef/constructors"
  */
-export declare function makeNow<A>(a: A, __tsplusTrace?: string): STM<never, never, UTRef<A>>;
+export declare function makeNow<A>(a: A, __tsplusTrace?: string): STM<never, never, TRef<A>>;
 /**
  * Makes a new `TRef` that is initialized to the specified value.
  * @tsplus static fncts.io.TRefOps make
  * @tsplus location "@fncts/io/TRef/constructors"
  */
-export declare function make<A>(a: Lazy<A>, __tsplusTrace?: string): STM<never, never, UTRef<A>>;
+export declare function make<A>(a: Lazy<A>, __tsplusTrace?: string): STM<never, never, TRef<A>>;
 /**
  * Unsafely makes a new `TRef` that is initialized to the specified value.
  * @tsplus static fncts.io.TRefOps unsafeMake
  * @tsplus location "@fncts/io/TRef/constructors"
  */
-export declare function unsafeMake<A>(a: A): UTRef<A>;
+export declare function unsafeMake<A>(a: A): TRef<A>;
 /**
  * Makes a new `TRef` that is initialized to the specified value.
  * @tsplus static fncts.io.TRefOps makeCommit
  * @tsplus location "@fncts/io/TRef/constructors"
  */
-export declare function makeCommit<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<UTRef<A>>;
+export declare function makeCommit<A>(a: Lazy<A>, __tsplusTrace?: string): UIO<TRef<A>>;
 /**
  * Makes a new `TRef` that is initialized to the specified value.
  */
-export declare function makeCommitNow<A>(a: A, __tsplusTrace?: string): UIO<UTRef<A>>;
+export declare function makeCommitNow<A>(a: A, __tsplusTrace?: string): UIO<TRef<A>>;

package/TRef/definition.d.ts

@@ -1,9 +1,11 @@
 import { Either } from "@fncts/base/data/Either/definition";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
-import type { Todo } from "../STM/internal/Journal.js";
-import type { Versioned } from "../STM/internal/Versioned.js";
 import type { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import type { Journal, Todo } from "@fncts/io/STM/internal/Journal";
+import type { Versioned } from "@fncts/io/STM/internal/Versioned";
 import type { TxnId } from "@fncts/io/TxnId";
+import { STM } from "@fncts/io/STM";
+import { _A, _B, _EA, _EB } from "@fncts/io/TRef/symbols";
 export declare const TRefTypeId: unique symbol;
 export type TRefTypeId = typeof TRefTypeId;
 /**
@@ -23,65 +25,76 @@ export type TRefTypeId = typeof TRefTypeId;
  *
  * @tsplus type fncts.io.TRef
  */
-export interface TRef<EA, EB, A, B> {
+export interface PTRef<out EA, out EB, in A, out B> {
     readonly _typeId: TRefTypeId;
-    readonly _EA: () => EA;
-    readonly _EB: () => EB;
-    readonly _A: (_: A) => void;
-    readonly _B: () => B;
+    readonly [_EA]: () => EA;
+    readonly [_EB]: () => EB;
+    readonly [_A]: (_: A) => void;
+    readonly [_B]: () => B;
 }
+/**
+ * @tsplus type fncts.io.TRef
+ */
+export type TRef<A> = PTRef<never, never, A, A>;
 /**
  * @tsplus type fncts.io.TRefOps
  */
 export interface TRefOps {
 }
 export declare const TRef: TRefOps;
-export declare abstract class TRefInternal<EA, EB, A, B> implements TRef<EA, EB, A, B> {
+export declare abstract class TRefInternal<EA, EB, A, B> implements PTRef<EA, EB, A, B> {
     readonly _typeId: TRefTypeId;
-    readonly _EA: () => EA;
-    readonly _EB: () => EB;
-    readonly _A: (_: A) => void;
-    readonly _B: () => B;
-    abstract match<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ca: (c: C) => Either<EC, A>, bd: (b: B) => Either<ED, D>): TRef<EC, ED, C, D>;
-    abstract matchAll<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ec: (ea: EB) => EC, ca: (c: C) => (b: B) => Either<EC, A>, bd: (b: B) => Either<ED, D>): TRef<EC, ED, C, D>;
-}
-/**
- * @tsplus type fncts.io.TRef
- */
-export interface UTRef<A> extends TRef<never, never, A, A> {
-}
-/**
- * @tsplus type fncts.io.TRef
- */
-export interface ETRef<E, A> extends TRef<E, E, A, A> {
+    [_EA]: () => EA;
+    [_EB]: () => EB;
+    [_A]: (_: A) => void;
+    [_B]: () => B;
+    abstract get: STM<never, EB, B>;
+    abstract modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string): STM<never, EA | EB, C>;
+    abstract set(a: A, __tsplusTrace?: string): STM<never, EA, void>;
+    abstract unsafeGet(journal: Journal, __tsplusTrace?: string): A;
+    abstract unsafeSet(journal: Journal, a: A, __tsplusTrace?: string): void;
+    abstract match<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ca: (c: C) => Either<EC, A>, bd: (b: B) => Either<ED, D>): PTRef<EC, ED, C, D>;
+    abstract matchAll<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ec: (ea: EB) => EC, ca: (c: C) => (b: B) => Either<EC, A>, bd: (b: B) => Either<ED, D>): PTRef<EC, ED, C, D>;
 }
 export declare class Atomic<A> extends TRefInternal<never, never, A, A> {
     versioned: Versioned<A>;
     readonly todo: AtomicReference<HashMap<TxnId, Todo>>;
     readonly _typeId: TRefTypeId;
-    readonly _tag = "Atomic";
     readonly atomic: Atomic<unknown>;
     constructor(versioned: Versioned<A>, todo: AtomicReference<HashMap<TxnId, Todo>>);
-    match<EC, ED, C, D>(_ea: (ea: never) => EC, _eb: (ea: never) => ED, ca: (c: C) => Either<EC, A>, bd: (b: A) => Either<ED, D>): TRef<EC, ED, C, D>;
-    matchAll<EC, ED, C, D>(_ea: (ea: never) => EC, _eb: (ea: never) => ED, _ec: (ea: never) => EC, ca: (c: C) => (b: A) => Either<EC, A>, bd: (b: A) => Either<ED, D>): TRef<EC, ED, C, D>;
+    match<EC, ED, C, D>(_ea: (ea: never) => EC, _eb: (ea: never) => ED, ca: (c: C) => Either<EC, A>, bd: (b: A) => Either<ED, D>): PTRef<EC, ED, C, D>;
+    matchAll<EC, ED, C, D>(_ea: (ea: never) => EC, _eb: (ea: never) => ED, _ec: (ea: never) => EC, ca: (c: C) => (b: A) => Either<EC, A>, bd: (b: A) => Either<ED, D>): PTRef<EC, ED, C, D>;
+    get get(): STM<never, never, A>;
+    set(a: A, __tsplusTrace?: string | undefined): STM<never, never, void>;
+    modify<C>(f: (b: A) => readonly [C, A], __tsplusTrace?: string | undefined): STM<never, never, C>;
+    unsafeGet(journal: Journal, __tsplusTrace?: string | undefined): A;
+    unsafeSet(journal: Journal, a: A, __tsplusTrace?: string | undefined): void;
 }
 export declare class Derived<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
     readonly use: <X>(f: <S>(getEither: (s: S) => Either<EB, B>, setEither: (a: A) => Either<EA, S>, value: Atomic<S>, atomic: Atomic<unknown>) => X) => X;
     readonly _typeId: TRefTypeId;
-    readonly _tag = "Derived";
     constructor(use: <X>(f: <S>(getEither: (s: S) => Either<EB, B>, setEither: (a: A) => Either<EA, S>, value: Atomic<S>, atomic: Atomic<unknown>) => X) => X);
-    match<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ca: (c: C) => Either<EC, A>, bd: (b: B) => Either<ED, D>): TRef<EC, ED, C, D>;
-    matchAll<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ec: (ea: EB) => EC, ca: (c: C) => (b: B) => Either<EC, A>, bd: (b: B) => Either<ED, D>): TRef<EC, ED, C, D>;
+    match<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ca: (c: C) => Either<EC, A>, bd: (b: B) => Either<ED, D>): PTRef<EC, ED, C, D>;
+    matchAll<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ec: (ea: EB) => EC, ca: (c: C) => (b: B) => Either<EC, A>, bd: (b: B) => Either<ED, D>): PTRef<EC, ED, C, D>;
+    get get(): STM<never, EB, B>;
+    set(a: A, __tsplusTrace?: string | undefined): STM<never, EA, void>;
+    modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): STM<never, EA | EB, C>;
+    unsafeGet(journal: Journal, __tsplusTrace?: string | undefined): A;
+    unsafeSet(journal: Journal, a: A, __tsplusTrace?: string | undefined): void;
 }
 export declare class DerivedAll<EA, EB, A, B> extends TRefInternal<EA, EB, A, B> {
     readonly use: <X>(f: <S>(getEither: (s: S) => Either<EB, B>, setEither: (a: A) => (s: S) => Either<EA, S>, value: Atomic<S>, atomic: Atomic<unknown>) => X) => X;
     readonly _typeId: TRefTypeId;
-    readonly _tag = "DerivedAll";
     constructor(use: <X>(f: <S>(getEither: (s: S) => Either<EB, B>, setEither: (a: A) => (s: S) => Either<EA, S>, value: Atomic<S>, atomic: Atomic<unknown>) => X) => X);
-    match<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ca: (c: C) => Either<EC, A>, bd: (b: B) => Either<ED, D>): TRef<EC, ED, C, D>;
-    matchAll<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ec: (ea: EB) => EC, ca: (c: C) => (b: B) => Either<EC, A>, bd: (b: B) => Either<ED, D>): TRef<EC, ED, C, D>;
+    match<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ca: (c: C) => Either<EC, A>, bd: (b: B) => Either<ED, D>): PTRef<EC, ED, C, D>;
+    matchAll<EC, ED, C, D>(ea: (ea: EA) => EC, eb: (ea: EB) => ED, ec: (ea: EB) => EC, ca: (c: C) => (b: B) => Either<EC, A>, bd: (b: B) => Either<ED, D>): PTRef<EC, ED, C, D>;
+    get get(): STM<never, EB, B>;
+    set(a: A, __tsplusTrace?: string | undefined): STM<never, EA, void>;
+    modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string | undefined): STM<never, EA | EB, C>;
+    unsafeGet(journal: Journal, __tsplusTrace?: string | undefined): A;
+    unsafeSet(journal: Journal, a: A, __tsplusTrace?: string | undefined): void;
 }
 /**
  * @tsplus macro remove
  */
-export declare function concrete<EA, EB, A, B>(_: TRef<EA, EB, A, B>): asserts _ is (Atomic<A> & Atomic<B>) | Derived<EA, EB, A, B> | DerivedAll<EA, EB, A, B>;
+export declare function concrete<EA, EB, A, B>(_: PTRef<EA, EB, A, B>): asserts _ is (Atomic<A> & Atomic<B>) | Derived<EA, EB, A, B> | DerivedAll<EA, EB, A, B>;

package/TRef/symbols.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @tsplus static fncts.io.TRefOps _EA
+ * @tsplus location "@fncts/io/TRef/symbols"
+ */
+export declare const _EA: unique symbol;
+/**
+ * @tsplus static fncts.io.TRefOps _EB
+ * @tsplus location "@fncts/io/TRef/symbols"
+ */
+export declare const _EB: unique symbol;
+/**
+ * @tsplus static fncts.io.TRefOps _A
+ * @tsplus location "@fncts/io/TRef/symbols"
+ */
+export declare const _A: unique symbol;
+/**
+ * @tsplus static fncts.io.TRefOps _B
+ * @tsplus location "@fncts/io/TRef/symbols"
+ */
+export declare const _B: unique symbol;

package/TRef.d.ts

@@ -1,3 +1,4 @@
 export * from "./TRef/api.js";
 export * from "./TRef/constructors.js";
 export * from "./TRef/definition.js";
+export * from "./TRef/symbols.js";