@fncts/io 0.0.22 → 0.0.23

package/IO/definition.d.ts

@@ -2,11 +2,14 @@ import { HKT } from "@fncts/typelevel/HKT";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
+import { STM } from "@fncts/io/STM/definition";
 import type { FiberRuntime } from "../Fiber/FiberRuntime.js";
 import type { Running } from "../FiberStatus.js";
 import type { RuntimeFlagsPatch } from "../RuntimeFlags.js";
 import type { Trace } from "@fncts/base/data/Trace";
 import { RuntimeFlags } from "../RuntimeFlags.js";
+export declare const IOVariance: unique symbol;
+export type IOVariance = typeof IOVariance;
 export declare const IOTypeId: unique symbol;
 export type IOTypeId = typeof IOTypeId;
 export interface IOF extends HKT {
@@ -22,10 +25,12 @@ export interface IOF extends HKT {
  * @tsplus companion fncts.io.IOOps
  */
 export declare abstract class IO<R, E, A> {
-    readonly _typeId: IOTypeId;
-    _R: () => R;
-    _E: () => E;
-    _A: () => A;
+    readonly [IOTypeId]: IOTypeId;
+    [IOVariance]: {
+        _R: () => R;
+        _E: () => E;
+        _A: () => A;
+    };
 }
 /**
  * @tsplus type fncts.io.IOAspects
@@ -43,20 +48,26 @@ export declare const IOAspects: IOAspects;
 export declare function unifyIO<X extends IO<any, any, any>>(self: X): IO<[
     X
 ] extends [{
-    _R: () => infer R;
+    [IOVariance]: {
+        _R: () => infer R;
+    };
 }] ? R : never, [
     X
 ] extends [{
-    _E: () => infer E;
+    [IOVariance]: {
+        _E: () => infer E;
+    };
 }] ? E : never, [
     X
 ] extends [{
-    _A: () => infer A;
+    [IOVariance]: {
+        _A: () => infer A;
+    };
 }] ? A : never>;
 export type UIO<A> = IO<never, never, A>;
 export type URIO<R, A> = IO<R, never, A>;
 export type FIO<E, A> = IO<never, E, A>;
-export declare const enum IOTag {
+export declare const enum IOOpCode {
     SucceedNow = 0,
     Fail = 1,
     Sync = 2,
@@ -69,20 +80,23 @@ export declare const enum IOTag {
     GenerateStackTrace = 9,
     Stateful = 10,
     WhileLoop = 11,
-    YieldNow = 12
+    YieldNow = 12,
+    Commit = 13,
+    RevertFlags = 14,
+    UpdateTrace = 15
 }
 export declare function isIO(u: unknown): u is IO<any, any, any>;
 export declare class Sync<A> extends IO<never, never, A> {
     readonly evaluate: () => A;
     readonly trace?: string | undefined;
-    readonly _tag = IOTag.Sync;
+    readonly ioOpCode = IOOpCode.Sync;
     constructor(evaluate: () => A, trace?: string | undefined);
 }
 export declare class Async<R, E, A> extends IO<R, E, A> {
     readonly registerCallback: (f: (_: IO<R, E, A>) => void) => any;
     readonly blockingOn: () => FiberId;
     readonly trace?: string | undefined;
-    readonly _tag = IOTag.Async;
+    readonly ioOpCode = IOOpCode.Async;
     constructor(registerCallback: (f: (_: IO<R, E, A>) => void) => any, blockingOn: () => FiberId, trace?: string | undefined);
 }
 /**
@@ -93,7 +107,7 @@ export declare class OnSuccessAndFailure<R, E, A, R1, E1, B, R2, E2, C> extends
     readonly failureK: (cause: Cause<E>) => IO<R1, E1, B>;
     readonly successK: (a: A) => IO<R2, E2, C>;
     readonly trace?: string | undefined;
-    readonly _tag = IOTag.OnSuccessAndFailure;
+    readonly ioOpCode = IOOpCode.OnSuccessAndFailure;
     constructor(first: IO<R, E, A>, failureK: (cause: Cause<E>) => IO<R1, E1, B>, successK: (a: A) => IO<R2, E2, C>, trace?: string | undefined);
     onFailure(c: Cause<E>): IO<R | R1 | R2, E1 | E2, B | C>;
     onSuccess(a: A): IO<R | R1 | R2, E1 | E2, B | C>;
@@ -102,7 +116,7 @@ export declare class OnFailure<R, E, A, R1, E1, B> extends IO<R | R1, E1, A | B>
     readonly first: IO<R, E, A>;
     readonly failureK: (cause: Cause<E>) => IO<R1, E1, B>;
     readonly trace?: string | undefined;
-    readonly _tag = IOTag.OnFailure;
+    readonly ioOpCode = IOOpCode.OnFailure;
     constructor(first: IO<R, E, A>, failureK: (cause: Cause<E>) => IO<R1, E1, B>, trace?: string | undefined);
     onFailure(c: Cause<E>): IO<R | R1, E1, A | B>;
     onSuccess(a: A): IO<R | R1, E1, A | B>;
@@ -114,7 +128,7 @@ export declare class OnSuccess<R, R1, E, E1, A, A1> extends IO<R | R1, E | E1, A
     readonly first: IO<R, E, A>;
     readonly successK: (a: A) => IO<R1, E1, A1>;
     readonly trace?: string | undefined;
-    readonly _tag = IOTag.OnSuccess;
+    readonly ioOpCode = IOOpCode.OnSuccess;
     constructor(first: IO<R, E, A>, successK: (a: A) => IO<R1, E1, A1>, trace?: string | undefined);
     onFailure(c: Cause<E>): IO<R | R1, E | E1, A1>;
     onSuccess(a: A): IO<R | R1, E | E1, A1>;
@@ -125,19 +139,19 @@ export declare class OnSuccess<R, R1, E, E1, A, A1> extends IO<R | R1, E | E1, A
 export declare class SucceedNow<A> extends IO<never, never, A> {
     readonly value: A;
     readonly trace?: string | undefined;
-    readonly _tag = IOTag.SucceedNow;
+    readonly ioOpCode = IOOpCode.SucceedNow;
     constructor(value: A, trace?: string | undefined);
 }
 export declare class UpdateRuntimeFlags extends IO<never, never, void> {
     readonly update: RuntimeFlags.Patch;
     readonly trace?: string | undefined;
-    readonly _tag = IOTag.UpdateRuntimeFlags;
+    readonly ioOpCode = IOOpCode.UpdateRuntimeFlags;
     constructor(update: RuntimeFlags.Patch, trace?: string | undefined);
 }
 export declare class Interruptible<R, E, A> extends IO<R, E, A> {
     readonly effect: IO<R, E, A>;
     readonly trace?: string | undefined;
-    readonly _tag = IOTag.UpdateRuntimeFlagsWithin;
+    readonly ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
     constructor(effect: IO<R, E, A>, trace?: string | undefined);
     readonly update: RuntimeFlags.Patch;
     scope(oldRuntimeFlags: RuntimeFlags): IO<R, E, A>;
@@ -145,7 +159,7 @@ export declare class Interruptible<R, E, A> extends IO<R, E, A> {
 export declare class Uninterruptible<R, E, A> extends IO<R, E, A> {
     readonly effect: IO<R, E, A>;
     readonly trace?: string | undefined;
-    readonly _tag = IOTag.UpdateRuntimeFlagsWithin;
+    readonly ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
     constructor(effect: IO<R, E, A>, trace?: string | undefined);
     readonly update: RuntimeFlags.Patch;
     scope(oldRuntimeFlags: RuntimeFlags): IO<R, E, A>;
@@ -154,19 +168,19 @@ export declare class Dynamic<R, E, A> extends IO<R, E, A> {
     readonly update: RuntimeFlagsPatch;
     readonly f: (oldRuntimeFlags: RuntimeFlags) => IO<R, E, A>;
     readonly trace?: string | undefined;
-    readonly _tag = IOTag.UpdateRuntimeFlagsWithin;
+    readonly ioOpCode = IOOpCode.UpdateRuntimeFlagsWithin;
     constructor(update: RuntimeFlagsPatch, f: (oldRuntimeFlags: RuntimeFlags) => IO<R, E, A>, trace?: string | undefined);
     scope(oldRuntimeFlags: RuntimeFlags): IO<R, E, A>;
 }
 export declare class GenerateStackTrace extends IO<never, never, Trace> {
     readonly trace?: string | undefined;
-    readonly _tag = IOTag.GenerateStackTrace;
+    readonly ioOpCode = IOOpCode.GenerateStackTrace;
     constructor(trace?: string | undefined);
 }
 export declare class Stateful<R, E, A> extends IO<R, E, A> {
     readonly onState: (fiber: FiberRuntime<E, A>, status: Running) => IO<R, E, A>;
     readonly trace?: string | undefined;
-    readonly _tag = IOTag.Stateful;
+    readonly ioOpCode = IOOpCode.Stateful;
     constructor(onState: (fiber: FiberRuntime<E, A>, status: Running) => IO<R, E, A>, trace?: string | undefined);
 }
 export declare class WhileLoop<R, E, A> extends IO<R, E, void> {
@@ -174,12 +188,12 @@ export declare class WhileLoop<R, E, A> extends IO<R, E, void> {
     readonly body: () => IO<R, E, A>;
     readonly process: (a: A) => any;
     readonly trace?: string | undefined;
-    readonly _tag = IOTag.WhileLoop;
+    readonly ioOpCode = IOOpCode.WhileLoop;
     constructor(check: () => boolean, body: () => IO<R, E, A>, process: (a: A) => any, trace?: string | undefined);
 }
 export declare class YieldNow extends IO<never, never, void> {
     readonly trace?: string | undefined;
-    readonly _tag = IOTag.YieldNow;
+    readonly ioOpCode = IOOpCode.YieldNow;
     constructor(trace?: string | undefined);
 }
 /**
@@ -188,10 +202,10 @@ export declare class YieldNow extends IO<never, never, void> {
 export declare class Fail<E> extends IO<never, E, never> {
     readonly cause: Lazy<Cause<E>>;
     readonly trace?: string | undefined;
-    readonly _tag = IOTag.Fail;
+    readonly ioOpCode = IOOpCode.Fail;
     constructor(cause: Lazy<Cause<E>>, trace?: string | undefined);
 }
-export type Concrete = OnSuccessAndFailure<any, any, any, any, any, any, any, any, any> | OnFailure<any, any, any, any, any, any> | OnSuccess<any, any, any, any, any, any> | UpdateRuntimeFlagsWithin | Sync<any> | Async<any, any, any> | SucceedNow<any> | UpdateRuntimeFlags | GenerateStackTrace | Stateful<any, any, any> | WhileLoop<any, any, any> | YieldNow | Fail<any>;
+export type Concrete = OnSuccessAndFailure<any, any, any, any, any, any, any, any, any> | OnFailure<any, any, any, any, any, any> | OnSuccess<any, any, any, any, any, any> | UpdateRuntimeFlagsWithin | Sync<any> | Async<any, any, any> | SucceedNow<any> | UpdateRuntimeFlags | GenerateStackTrace | Stateful<any, any, any> | WhileLoop<any, any, any> | YieldNow | Fail<any> | STM<any, any, any>;
 /**
  * @tsplus static fncts.io.IOOps concrete
  * @tsplus macro identity
@@ -205,7 +219,7 @@ export declare const IOErrorTypeId: unique symbol;
 export type IOErrorTypeId = typeof IOErrorTypeId;
 export declare class IOError<E> {
     readonly cause: Cause<E>;
-    readonly _typeId: IOErrorTypeId;
+    readonly [IOErrorTypeId]: IOErrorTypeId;
     constructor(cause: Cause<E>);
 }
 export declare function isIOError(u: unknown): u is IOError<unknown>;

package/IO.d.ts

@@ -29,7 +29,6 @@ export * from "./IO/api/fulfill.js";
 export * from "./IO/api/interrupt.js";
 export * from "./IO/api/memoize.js";
 export * from "./IO/api/once.js";
-export * from "./IO/api/onExit.js";
 export * from "./IO/api/onTermination.js";
 export * from "./IO/api/provideLayer.js";
 export * from "./IO/api/provideSomeLayer.js";

package/Layer/definition.d.ts

@@ -2,6 +2,8 @@ import { Cause } from "@fncts/base/data/Cause/definition";
 import { Environment } from "@fncts/base/data/Environment/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 import { IO } from "@fncts/io/IO/definition";
+export declare const LayerVariance: unique symbol;
+export type LayerVariance = typeof LayerVariance;
 export declare const LayerHash: unique symbol;
 export type LayerHash = typeof LayerHash;
 /**
@@ -9,26 +11,28 @@ export type LayerHash = typeof LayerHash;
  * @tsplus companion fncts.io.LayerOps
  */
 export declare abstract class Layer<RIn, E, ROut> {
-    readonly _R: () => RIn;
-    readonly _E: () => E;
-    readonly _A: () => ROut;
+    [LayerVariance]: {
+        readonly _RIn: (_: never) => RIn;
+        readonly _E: (_: never) => E;
+        readonly _ROut: (_: never) => ROut;
+    };
     [LayerHash]: PropertyKey;
     setKey(hash: PropertyKey): this;
 }
-export type Concrete = Fold<any, any, any, any, any, any, any, any, any> | Fresh<any, any, any> | FromScoped<any, any, any> | Defer<any, any, any> | To<any, any, any, any, any> | ZipWith<any, any, any, any, any, any, any> | ZipWithC<any, any, any, any, any, any, any>;
+export type Concrete = Fold<any, any, any, any, any, any, any, any, any> | Fresh<any, any, any> | FromScoped<any, any, any> | Defer<any, any, any> | To<any, any, any, any, any> | ZipWith<any, any, any, any, any, any, any> | ZipWithConcurrent<any, any, any, any, any, any, any>;
 /**
  * @tsplus fluent fncts.io.Layer concrete
  * @tsplus location "@fncts/io/Layer/definition"
  */
 export declare function concrete(self: Layer<any, any, any>): asserts self is Concrete;
 export declare const enum LayerTag {
-    Fold = "Fold",
-    Fresh = "Fresh",
-    Scoped = "Scoped",
-    Defer = "Defer",
-    To = "To",
-    ZipWith = "ZipWith",
-    ZipWithC = "ZipWithC"
+    Fold = 0,
+    Fresh = 1,
+    Scoped = 2,
+    Defer = 3,
+    To = 4,
+    ZipWith = 5,
+    ZipWithConcurrent = 6
 }
 export declare class Fold<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2> extends Layer<RIn & RIn1 & RIn2, E1 | E2, ROut1 | ROut2> {
     readonly self: Layer<RIn, E, ROut>;
@@ -71,11 +75,11 @@ export declare class ZipWith<RIn, E, ROut, RIn1, E1, ROut1, ROut2> extends Layer
     readonly _tag = LayerTag.ZipWith;
     constructor(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>, f: (a: Environment<ROut>, b: Environment<ROut1>) => Environment<ROut2>, trace?: string | undefined);
 }
-export declare class ZipWithC<RIn, E, ROut, RIn1, E1, ROut1, ROut2> extends Layer<RIn | RIn1, E | E1, ROut2> {
+export declare class ZipWithConcurrent<RIn, E, ROut, RIn1, E1, ROut1, ROut2> extends Layer<RIn | RIn1, E | E1, ROut2> {
     readonly self: Layer<RIn, E, ROut>;
     readonly that: Layer<RIn1, E1, ROut1>;
     readonly f: (a: Environment<ROut>, b: Environment<ROut1>) => Environment<ROut2>;
     readonly trace?: string | undefined;
-    readonly _tag = LayerTag.ZipWithC;
+    readonly _tag = LayerTag.ZipWithConcurrent;
     constructor(self: Layer<RIn, E, ROut>, that: Layer<RIn1, E1, ROut1>, f: (a: Environment<ROut>, b: Environment<ROut1>) => Environment<ROut2>, trace?: string | undefined);
 }

package/Logger/definition.d.ts

@@ -4,15 +4,19 @@ import { LogLevel } from "@fncts/io/LogLevel";
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { FiberRef } from "@fncts/io/FiberRef/definition";
-import { List } from "@fncts/base/collection/immutable/List/definition";
+import { Cons, List } from "@fncts/base/collection/immutable/List/definition";
 import type { LogSpan } from "@fncts/io/LogSpan";
+export declare const LoggerVariance: unique symbol;
+export type LoggerVariance = typeof LoggerVariance;
 /**
  * @tsplus type fncts.io.Logger
  * @tsplus companion fncts.io.LoggerOps
  */
-export declare class Logger<Message, Output> {
-    readonly log: (trace: TraceElement, fiberId: FiberId, logLevel: LogLevel, message: () => Message, cause: Cause<any>, context: HashMap<FiberRef<unknown>, unknown>, spans: List<LogSpan>, annotations: HashMap<string, string>) => Output;
-    readonly _Message: (_: Message) => void;
-    readonly _Output: () => Output;
-    constructor(log: (trace: TraceElement, fiberId: FiberId, logLevel: LogLevel, message: () => Message, cause: Cause<any>, context: HashMap<FiberRef<unknown>, unknown>, spans: List<LogSpan>, annotations: HashMap<string, string>) => Output);
+export declare class Logger<in Message, out Output> {
+    readonly log: (trace: TraceElement, fiberId: FiberId, logLevel: LogLevel, message: () => Message, cause: Cause<any>, context: HashMap<FiberRef<any>, Cons<readonly [FiberId.Runtime, unknown]>>, spans: List<LogSpan>, annotations: HashMap<string, string>) => Output;
+    LoggerVariance: {
+        readonly _Message: (_: Message) => void;
+        readonly _Output: (_: never) => Output;
+    };
+    constructor(log: (trace: TraceElement, fiberId: FiberId, logLevel: LogLevel, message: () => Message, cause: Cause<any>, context: HashMap<FiberRef<any>, Cons<readonly [FiberId.Runtime, unknown]>>, spans: List<LogSpan>, annotations: HashMap<string, string>) => Output);
 }

package/MVar/api.d.ts

@@ -0,0 +1,101 @@
+import { UIO } from "@fncts/io/IO/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import type { MVar } from "./definition";
+/**
+ * @tsplus static fncts.io.MVarOps empty
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function empty<A>(): UIO<MVar<A>>;
+/**
+ * @tsplus static fncts.io.MVarOps make
+ * @tsplus static fncts.io.MVarOps __call
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function make<A>(value: A): UIO<MVar<A>>;
+/**
+ * Check whether the `MVar` is empty.
+ *
+ * Notice that the boolean value returned is just a snapshot of the state of
+ * the `MVar`. By the time you get to react on its result, the `MVar` may have
+ * been filled (or emptied) - so be extremely careful when using this
+ * operation. Use `tryTake` instead if possible.
+ * @tsplus getter fncts.io.MVar isEmpty
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function isEmpty<A>(self: MVar<A>): UIO<boolean>;
+/**
+ * A slight variation on `update` that allows a value to be returned (`b`) in
+ * addition to the modified value of the `MVar`.
+ * @tsplus fluent fncts.io.MVar modify
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function modify<A, B>(self: MVar<A>, f: (a: A) => readonly [B, A]): UIO<B>;
+/**
+ * Put a value into an `MVar`. If the `MVar` is currently full, `put` will
+ * wait until it becomes empty.
+ * @tsplus fluent fncts.io.MVar put
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function put<A>(self: MVar<A>, value: A): UIO<void>;
+/**
+ * Atomically read the contents of an `MVar`. If the `MVar` is currently
+ * empty, `read` will wait until it is full. `read` is guaranteed to receive
+ * the next `put`.
+ * @tsplus getter fncts.io.MVar read
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function read<A>(self: MVar<A>): UIO<A>;
+/**
+ * Take a value from an `MVar`, put a new value into the `MVar` and return the
+ * value taken.
+ * @tsplus fluent fncts.io.MVar swap
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function swap<A>(self: MVar<A>, value: A): UIO<A>;
+/**
+ * Return the contents of the `MVar`. If the `MVar` is currently empty, `take`
+ * will wait until it is full. After a `take`, the `MVar` is left empty.
+ * @tsplus getter fncts.io.MVar take
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function take<A>(self: MVar<A>): UIO<A>;
+/**
+ * A non-blocking version of `put`. The `tryPut` function attempts to put the
+ * value into the `MVar`, returning `true` if it was successful, or
+ * `false` otherwise.
+ * @tsplus fluent fncts.io.MVar tryPut
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function tryPut<A>(self: MVar<A>, value: A): UIO<boolean>;
+/**
+ * A non-blocking version of `read`. The `tryRead` function returns
+ * immediately, with `None` if the `MVar` was empty, or `Some(x)` if the
+ * `MVar` was full with contents `x`.
+ * @tsplus getter fncts.io.MVar tryRead
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function tryRead<A>(self: MVar<A>): UIO<Maybe<A>>;
+/**
+ * A non-blocking version of `take`. The `tryTake` action returns immediately,
+ * with `None` if the `MVar` was empty, or `Some(x)` if the `MVar` was full
+ * with contents `x`. After `tryTake`, the `MVar` is left empty.
+ * @tsplus getter fncts.io.MVar tryTake
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function tryTake<A>(self: MVar<A>): UIO<Maybe<A>>;
+/**
+ * Replaces the contents of an `MVar` with the result of `f(a)`.
+ * @tsplus fluent fncts.io.MVar update
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function update<A>(self: MVar<A>, f: (a: A) => A): UIO<void>;
+/**
+ * @tsplus static fncts.io.MVarOps unsafeEmpty
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function unsafeEmpty<A>(): MVar<A>;
+/**
+ * @tsplus static fncts.io.MVarOps unsafeMake
+ * @tsplus location "@fncts/io/MVar/api"
+ */
+export declare function unsafeMake<A>(value: A): MVar<A>;

package/MVar/definition.d.ts

@@ -0,0 +1,43 @@
+import { TRef } from "@fncts/io/TRef/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+export declare const MVarVariance: unique symbol;
+export type MVarVariance = typeof MVarVariance;
+export declare const MVarTypeId: unique symbol;
+export type MVarTypeId = typeof MVarTypeId;
+/**
+ * An `MVar<A>` is a mutable location that is either empty or contains a value
+ * of type `A`. It has two fundamental operations: `put` which fills an `MVar`
+ * if it is empty and blocks otherwise, and `take` which empties an `MVar` if it
+ * is full and blocks otherwise. They can be used in multiple different ways:
+ *
+ *   - As synchronized mutable variables,
+ *   - As channels, with `take` and `put` as `receive` and `send`, and
+ *   - As a binary semaphore `MVar<void>`, with `take` and `put` as `wait` and
+ *     `signal`.
+ *
+ * They were introduced in the paper "Concurrent Haskell" by Simon Peyton Jones,
+ * Andrew Gordon and Sigbjorn Finne.
+ *
+ * @tsplus type fncts.io.MVar
+ * @tsplus companion fncts.io.MVarOps
+ */
+export interface MVar<in out A> {
+    readonly [MVarVariance]: {
+        _A: (_: A) => A;
+    };
+    readonly [MVarTypeId]: MVarTypeId;
+}
+export declare class MVarInternal<in out A> implements MVar<A> {
+    readonly content: TRef<Maybe<A>>;
+    readonly [MVarTypeId]: MVarTypeId;
+    [MVarVariance]: {
+        _A: (_: A) => A;
+    };
+    constructor(content: TRef<Maybe<A>>);
+}
+/**
+ * @tsplus static fncts.io.MVarOps concrete
+ * @tsplus macro remove
+ * @tsplus location "@fncts/io/MVar/definition"
+ */
+export declare function concrete<A>(_: MVar<A>): asserts _ is MVarInternal<A>;

package/MVar.d.ts

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

package/Push/api.d.ts

@@ -12,7 +12,7 @@ import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import type { _A, _E, _R } from "@fncts/base/types";
 import { AtomicReference } from "@fncts/base/internal/AtomicReference";
-import { Emitter, Push } from "./definition.js";
+import { Emitter, Push, PushTypeId, PushVariance } from "./definition.js";
 /**
  * @tsplus pipeable fncts.io.Push as
  * @tsplus location "@fncts/io/Push/api"
@@ -93,9 +93,12 @@ interface MulticastObserver<E, A> {
 }
 export declare class Multicast<R, E, A> implements Push<R, E, A>, Emitter<never, E, A> {
     readonly push: Push<R, E, A>;
-    _R: () => R;
-    _E: () => E;
-    _A: () => A;
+    readonly [PushTypeId]: PushTypeId;
+    [PushVariance]: {
+        readonly _R: (_: never) => R;
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
     protected observers: Array<MulticastObserver<E, A>>;
     protected fiber: Fiber<never, unknown> | undefined;
     constructor(push: Push<R, E, A>);

package/Push/definition.d.ts

@@ -1,15 +1,22 @@
 import { IO } from "@fncts/io/IO/definition";
 import { Scope } from "@fncts/io/Scope/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
+export declare const PushVariance: unique symbol;
+export type PushVariance = typeof PushVariance;
+export declare const PushTypeId: unique symbol;
+export type PushTypeId = typeof PushTypeId;
 /**
  * @tsplus type fncts.io.Push
  * @tsplus companion fncts.io.PushOps
  */
 export declare class Push<R, E, A> {
     readonly run: <R1>(emitter: Emitter<R1, E, A>) => IO<R | R1 | Scope, never, unknown>;
-    _R: (_: never) => R;
-    _E: (_: never) => E;
-    _A: (_: never) => A;
+    readonly [PushTypeId]: PushTypeId;
+    [PushVariance]: {
+        readonly _R: (_: never) => R;
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
     constructor(run: <R1>(emitter: Emitter<R1, E, A>) => IO<R | R1 | Scope, never, unknown>);
 }
 /**

package/Push/internal.d.ts

@@ -4,7 +4,7 @@ export declare function withCountdownLatch<R, E, A, R1, E1, B>(n: number, f: (la
 export declare const EarlyExitTypeId: unique symbol;
 export type EarlyExitTypeId = typeof EarlyExitTypeId;
 export declare class EarlyExit {
-    readonly _typeId: EarlyExitTypeId;
+    readonly [EarlyExitTypeId]: EarlyExitTypeId;
 }
 export declare function isEarlyExit(u: unknown): u is EarlyExit;
 export declare const earlyExit: import("../IO").UIO<never>;

package/Queue/api/dimapIO.d.ts

@@ -3,7 +3,7 @@ import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { PQueue } from "@fncts/io/Queue/definition";
 import type { UIO } from "@fncts/io/IO";
 import type { PDequeue, PDequeueInternal, PEnqueue, PEnqueueInternal } from "@fncts/io/Queue/definition";
-import { DequeueTypeId, EnqueueTypeId, QueueTypeId } from "@fncts/io/Queue/definition";
+import { DequeueTypeId, EnqueueTypeId, QueueTypeId, QueueVariance } from "@fncts/io/Queue/definition";
 /**
  * Transforms elements enqueued into and dequeued from this queue with the
  * specified effectual functions.
@@ -47,12 +47,14 @@ declare class ContramapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PEnqueueIn
     readonly f: (c: C) => IO<RC, EC, A>;
     readonly [EnqueueTypeId]: EnqueueTypeId;
     readonly [QueueTypeId]: QueueTypeId;
-    _RA: () => RA | RC;
-    _RB: () => RB;
-    _EA: () => EA | EC;
-    _EB: () => EB;
-    _A: (_: C) => void;
-    _B: () => B;
+    [QueueVariance]: {
+        readonly _RA: (_: never) => RA | RC;
+        readonly _RB: (_: never) => RB;
+        readonly _EA: (_: never) => EA | EC;
+        readonly _EB: (_: never) => EB;
+        readonly _A: (_: C) => void;
+        readonly _B: (_: never) => B;
+    };
     constructor(queue: PEnqueueInternal<RA, RB, EA, EB, A, B>, f: (c: C) => IO<RC, EC, A>);
     awaitShutdown: UIO<void>;
     capacity: number;
@@ -73,12 +75,14 @@ declare class MapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PDequeueInternal
     readonly f: (b: B) => IO<RC, EC, C>;
     readonly [DequeueTypeId]: DequeueTypeId;
     readonly [QueueTypeId]: QueueTypeId;
-    _RA: () => RA;
-    _RB: () => RB | RC;
-    _EA: () => EA;
-    _EB: () => EB | EC;
-    _A: (_: A) => void;
-    _B: () => C;
+    [QueueVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _RB: (_: never) => RB | RC;
+        readonly _EA: (_: never) => EA;
+        readonly _EB: (_: never) => EB | EC;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => C;
+    };
     constructor(queue: PDequeueInternal<RA, RB, EA, EB, A, B>, f: (b: B) => IO<RC, EC, C>);
     awaitShutdown: UIO<void>;
     capacity: number;

package/Queue/definition.d.ts

@@ -4,6 +4,8 @@ export declare const EnqueueTypeId: unique symbol;
 export type EnqueueTypeId = typeof EnqueueTypeId;
 export declare const DequeueTypeId: unique symbol;
 export type DequeueTypeId = typeof DequeueTypeId;
+export declare const QueueVariance: unique symbol;
+export type QueueVariance = typeof QueueVariance;
 export declare const QueueTypeId: unique symbol;
 export type QueueTypeId = typeof QueueTypeId;
 /**
@@ -22,12 +24,14 @@ export interface PQueue<RA, RB, EA, EB, A, B> extends PEnqueue<RA, RB, EA, EB, A
  */
 export interface PQueueCommon<RA, RB, EA, EB, A, B> {
     readonly [QueueTypeId]: QueueTypeId;
-    readonly _RA: () => RA;
-    readonly _RB: () => RB;
-    readonly _EA: () => EA;
-    readonly _EB: () => EB;
-    readonly _A: (_: A) => void;
-    readonly _B: () => B;
+    readonly [QueueVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _RB: (_: never) => RB;
+        readonly _EA: (_: never) => EA;
+        readonly _EB: (_: never) => EB;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => B;
+    };
 }
 /**
  * @tsplus type fncts.io.Queue
@@ -67,12 +71,14 @@ export declare abstract class QueueInternal<RA, RB, EA, EB, A, B> implements PQu
     readonly [QueueTypeId]: QueueTypeId;
     readonly [DequeueTypeId]: DequeueTypeId;
     readonly [EnqueueTypeId]: EnqueueTypeId;
-    readonly _RA: () => RA;
-    readonly _RB: () => RB;
-    readonly _EA: () => EA;
-    readonly _EB: () => EB;
-    readonly _A: (_: A) => void;
-    readonly _B: () => B;
+    [QueueVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _RB: (_: never) => RB;
+        readonly _EA: (_: never) => EA;
+        readonly _EB: (_: never) => EB;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => B;
+    };
     /**
      * Waits until the queue is shutdown.
      * The `IO` returned by this method will not resume until the queue has been shutdown.
@@ -156,13 +162,15 @@ export declare namespace Queue {
     }
 }
 export interface PQueueCommonInternal<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;
     readonly [QueueTypeId]: QueueTypeId;
+    readonly [QueueVariance]: {
+        readonly _RA: (_: never) => RA;
+        readonly _RB: (_: never) => RB;
+        readonly _EA: (_: never) => EA;
+        readonly _EB: (_: never) => EB;
+        readonly _A: (_: A) => void;
+        readonly _B: (_: never) => B;
+    };
     /**
      * Waits until the queue is shutdown.
      * The `IO` returned by this method will not resume until the queue has been shutdown.

package/Ref/Derived.d.ts

@@ -4,9 +4,11 @@ import type { Atomic } from "./Atomic.js";
 import type { PRef } from "./definition.js";
 import { IO } from "@fncts/io/IO";
 import { RefInternal } from "./definition.js";
+export declare const DerivedTypeId: unique symbol;
+export type DerivedTypeId = typeof DerivedTypeId;
 export declare class Derived<EA, EB, A, B> extends RefInternal<never, never, EA, EB, A, B> {
     readonly use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => Either<EA, S>) => X) => X;
-    readonly _tag = "Derived";
+    readonly [DerivedTypeId]: DerivedTypeId;
     constructor(use: <X>(f: <S>(value: Atomic<S>, getEither: (s: S) => Either<EB, B>, setEither: (a: A) => Either<EA, S>) => X) => X);
     match<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ca: (_: C) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<never, never, EC, ED, C, D>;
     matchAll<EC, ED, C, D>(ea: (_: EA) => EC, eb: (_: EB) => ED, ec: (_: EB) => EC, ca: (_: C) => (_: B) => Either<EC, A>, bd: (_: B) => Either<ED, D>): PRef<never, never, EC, ED, C, D>;