@fncts/io 0.0.22 → 0.0.23

package/_src/Layer/definition.ts

@@ -1,3 +1,6 @@
+export const LayerVariance = Symbol.for("fncts.io.Layer.Variance");
+export type LayerVariance = typeof LayerVariance;
+
 export const LayerHash = Symbol.for("fncts.io.Layer.Hash");
 export type LayerHash = typeof LayerHash;
 
@@ -6,9 +9,11 @@ export type LayerHash = typeof LayerHash;
  * @tsplus companion fncts.io.LayerOps
  */
 export abstract class Layer<RIn, E, ROut> {
-  readonly _R!: () => RIn;
-  readonly _E!: () => E;
-  readonly _A!: () => ROut;
+  declare [LayerVariance]: {
+    readonly _RIn: (_: never) => RIn;
+    readonly _E: (_: never) => E;
+    readonly _ROut: (_: never) => ROut;
+  };
 
   [LayerHash]: PropertyKey = Symbol();
 
@@ -25,7 +30,7 @@ export type Concrete =
   | 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>;
+  | ZipWithConcurrent<any, any, any, any, any, any, any>;
 
 /**
  * @tsplus fluent fncts.io.Layer concrete
@@ -35,13 +40,13 @@ export function concrete(self: Layer<any, any, any>): asserts self is Concrete {
 }
 
 export const enum LayerTag {
-  Fold = "Fold",
-  Fresh = "Fresh",
-  Scoped = "Scoped",
-  Defer = "Defer",
-  To = "To",
-  ZipWith = "ZipWith",
-  ZipWithC = "ZipWithC",
+  Fold,
+  Fresh,
+  Scoped,
+  Defer,
+  To,
+  ZipWith,
+  ZipWithConcurrent,
 }
 
 export class Fold<RIn, E, ROut, RIn1, E1, ROut1, RIn2, E2, ROut2> extends Layer<
@@ -100,8 +105,8 @@ export class ZipWith<RIn, E, ROut, RIn1, E1, ROut1, ROut2> extends Layer<RIn | R
   }
 }
 
-export class ZipWithC<RIn, E, ROut, RIn1, E1, ROut1, ROut2> extends Layer<RIn | RIn1, E | E1, ROut2> {
-  readonly _tag = LayerTag.ZipWithC;
+export class ZipWithConcurrent<RIn, E, ROut, RIn1, E1, ROut1, ROut2> extends Layer<RIn | RIn1, E | E1, ROut2> {
+  readonly _tag = LayerTag.ZipWithConcurrent;
   constructor(
     readonly self: Layer<RIn, E, ROut>,
     readonly that: Layer<RIn1, E1, ROut1>,

package/_src/Logger/definition.ts

@@ -1,12 +1,17 @@
 import type { LogSpan } from "@fncts/io/LogSpan";
 
+export const LoggerVariance = Symbol.for("fncts.io.Logger");
+export type LoggerVariance = typeof LoggerVariance;
+
 /**
  * @tsplus type fncts.io.Logger
  * @tsplus companion fncts.io.LoggerOps
  */
-export class Logger<Message, Output> {
-  readonly _Message!: (_: Message) => void;
-  readonly _Output!: () => Output;
+export class Logger<in Message, out Output> {
+  declare LoggerVariance: {
+    readonly _Message: (_: Message) => void;
+    readonly _Output: (_: never) => Output;
+  };
   constructor(
     readonly log: (
       trace: TraceElement,
@@ -14,7 +19,7 @@ export class Logger<Message, Output> {
       logLevel: LogLevel,
       message: () => Message,
       cause: Cause<any>,
-      context: HashMap<FiberRef<unknown>, unknown>,
+      context: HashMap<FiberRef<any>, Cons<readonly [FiberId.Runtime, unknown]>>,
       spans: List<LogSpan>,
       annotations: HashMap<string, string>,
     ) => Output,

package/_src/MVar/api.ts

@@ -0,0 +1,185 @@
+import type { MVar } from "./definition";
+
+import { concrete } from "./definition.js";
+import { MVarInternal } from "./definition.js";
+
+/**
+ * @tsplus static fncts.io.MVarOps empty
+ */
+export function empty<A>(): UIO<MVar<A>> {
+  return TRef.make<Maybe<A>>(Nothing()).map((content) => new MVarInternal(content)).commit;
+}
+
+/**
+ * @tsplus static fncts.io.MVarOps make
+ * @tsplus static fncts.io.MVarOps __call
+ */
+export function make<A>(value: A): UIO<MVar<A>> {
+  return TRef.make(Just(value)).map((content) => new MVarInternal(content)).commit;
+}
+
+/**
+ * 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
+ */
+export function isEmpty<A>(self: MVar<A>): UIO<boolean> {
+  concrete(self);
+  return self.content.get.map((value) => value.isNothing()).commit;
+}
+
+/**
+ * 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
+ */
+export function modify<A, B>(self: MVar<A>, f: (a: A) => readonly [B, A]): UIO<B> {
+  concrete(self);
+  return self.content.get
+    .filterMap((value) =>
+      value.map((a) => {
+        const [b, newA] = f(a);
+        return [b, Just(newA)] as const;
+      }),
+    )
+    .flatMap(([b, newA]) => self.content.set(newA).as(b)).commit;
+}
+
+/**
+ * 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
+ */
+export function put<A>(self: MVar<A>, value: A): UIO<void> {
+  concrete(self);
+  return (
+    self.content.get.filterMap((value) =>
+      value.match(
+        () => Just(undefined),
+        () => Nothing(),
+      ),
+    ) > self.content.set(Just(value))
+  ).commit;
+}
+
+/**
+ * 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
+ */
+export function read<A>(self: MVar<A>): UIO<A> {
+  concrete(self);
+  return self.content.get.filterMap(Function.identity).commit;
+}
+
+/**
+ * Take a value from an `MVar`, put a new value into the `MVar` and return the
+ * value taken.
+ *
+ * @tsplus fluent fncts.io.MVar swap
+ */
+export function swap<A>(self: MVar<A>, value: A): UIO<A> {
+  concrete(self);
+  return Do((Δ) => {
+    const ref = Δ(self.content.get);
+    return Δ(
+      ref.match(
+        () => STM.retry,
+        (y) => self.content.set(Just(value)).as(y),
+      ),
+    );
+  }).commit;
+}
+
+/**
+ * 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
+ */
+export function take<A>(self: MVar<A>): UIO<A> {
+  concrete(self);
+  return self.content.get.filterMap(Function.identity).flatMap((a) => self.content.set(Nothing()).as(a)).commit;
+}
+
+/**
+ * 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
+ */
+export function tryPut<A>(self: MVar<A>, value: A): UIO<boolean> {
+  concrete(self);
+  return self.content.get.flatMap((v) =>
+    v.match(
+      () => self.content.set(Just(value)).as(true),
+      () => STM.succeedNow(false),
+    ),
+  ).commit;
+}
+
+/**
+ * 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
+ */
+export function tryRead<A>(self: MVar<A>): UIO<Maybe<A>> {
+  concrete(self);
+  return self.content.get.commit;
+}
+
+/**
+ * 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
+ */
+export function tryTake<A>(self: MVar<A>): UIO<Maybe<A>> {
+  concrete(self);
+  return Do((Δ) => {
+    const c = Δ(self.content.get);
+    return Δ(
+      c.match(
+        () => STM.succeedNow(Nothing()),
+        (a) => self.content.set(Nothing()) > STM.succeedNow(Just(a)),
+      ),
+    );
+  }).commit;
+}
+
+/**
+ * Replaces the contents of an `MVar` with the result of `f(a)`.
+ *
+ * @tsplus fluent fncts.io.MVar update
+ */
+export function update<A>(self: MVar<A>, f: (a: A) => A): UIO<void> {
+  concrete(self);
+  return self.content.get.filterMap((value) => value.map(f)).flatMap((a) => self.content.set(Just(a))).commit;
+}
+
+/**
+ * @tsplus static fncts.io.MVarOps unsafeEmpty
+ */
+export function unsafeEmpty<A>(): MVar<A> {
+  return new MVarInternal(TRef.unsafeMake<Maybe<A>>(Nothing()));
+}
+
+/**
+ * @tsplus static fncts.io.MVarOps unsafeMake
+ */
+export function unsafeMake<A>(value: A): MVar<A> {
+  return new MVarInternal(TRef.unsafeMake<Maybe<A>>(Just(value)));
+}

package/_src/MVar/definition.ts

@@ -0,0 +1,45 @@
+export const MVarVariance = Symbol.for("fncts.io.MVar.Variance");
+export type MVarVariance = typeof MVarVariance;
+
+export const MVarTypeId = Symbol.for("fncts.io.MVar");
+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 class MVarInternal<in out A> implements MVar<A> {
+  readonly [MVarTypeId]: MVarTypeId = MVarTypeId;
+  declare [MVarVariance]: {
+    _A: (_: A) => A;
+  };
+  constructor(readonly content: TRef<Maybe<A>>) {}
+}
+
+/**
+ * @tsplus static fncts.io.MVarOps concrete
+ * @tsplus macro remove
+ */
+export function concrete<A>(_: MVar<A>): asserts _ is MVarInternal<A> {
+  //
+}

package/_src/MVar.ts

@@ -0,0 +1,4 @@
+// codegen:start { preset: barrel, include: ./MVar/*.ts }
+export * from "./MVar/api.js";
+export * from "./MVar/definition.js";
+// codegen:end

package/_src/Push/api.ts

@@ -2,7 +2,7 @@ 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";
 import { earlyExit, onEarlyExit } from "./internal.js";
 
 /**
@@ -223,9 +223,12 @@ interface MulticastObserver<E, A> {
 }
 
 export class Multicast<R, E, A> implements Push<R, E, A>, Emitter<never, E, A> {
-  declare _R: () => R;
-  declare _E: () => E;
-  declare _A: () => A;
+  readonly [PushTypeId]: PushTypeId = PushTypeId;
+  declare [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(readonly push: Push<R, E, A>) {}

package/_src/Push/definition.ts

@@ -1,11 +1,20 @@
+export const PushVariance = Symbol.for("fncts.io.Push.Variance");
+export type PushVariance = typeof PushVariance;
+
+export const PushTypeId = Symbol.for("fncts.io.Push");
+export type PushTypeId = typeof PushTypeId;
+
 /**
  * @tsplus type fncts.io.Push
  * @tsplus companion fncts.io.PushOps
  */
 export class Push<R, E, A> {
-  declare _R: (_: never) => R;
-  declare _E: (_: never) => E;
-  declare _A: (_: never) => A;
+  readonly [PushTypeId]: PushTypeId = PushTypeId;
+  declare [PushVariance]: {
+    readonly _R: (_: never) => R;
+    readonly _E: (_: never) => E;
+    readonly _A: (_: never) => A;
+  };
   constructor(readonly run: <R1>(emitter: Emitter<R1, E, A>) => IO<R | R1 | Scope, never, unknown>) {}
 }
 

package/_src/Push/internal.ts

@@ -14,11 +14,11 @@ export const EarlyExitTypeId = Symbol.for("fncts.io.Push.EarlyExit");
 export type EarlyExitTypeId = typeof EarlyExitTypeId;
 
 export class EarlyExit {
-  readonly _typeId: EarlyExitTypeId = EarlyExitTypeId;
+  readonly [EarlyExitTypeId]: EarlyExitTypeId = EarlyExitTypeId;
 }
 
 export function isEarlyExit(u: unknown): u is EarlyExit {
-  return hasTypeId(u, EarlyExitTypeId);
+  return isObject(u) && EarlyExitTypeId in u;
 }
 
 export const earlyExit = IO.haltNow(new EarlyExit());

package/_src/Queue/api/dimapIO.ts

@@ -1,7 +1,14 @@
 import type { UIO } from "@fncts/io/IO";
 import type { PDequeue, PDequeueInternal, PEnqueue, PEnqueueInternal } from "@fncts/io/Queue/definition";
 
-import { concrete, DequeueTypeId, EnqueueTypeId, QueueInternal, QueueTypeId } from "@fncts/io/Queue/definition";
+import {
+  concrete,
+  DequeueTypeId,
+  EnqueueTypeId,
+  QueueInternal,
+  QueueTypeId,
+  QueueVariance,
+} from "@fncts/io/Queue/definition";
 
 class DimapIO<RA, RB, EA, EB, A, B, RC, EC, C, RD, ED, D> extends QueueInternal<
   RC | RA,
@@ -125,12 +132,14 @@ export function map<B, C>(f: (b: B) => C, __tsplusTrace?: string) {
 class ContramapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PEnqueueInternal<RA | RC, RB, EA | EC, EB, C, B> {
   readonly [EnqueueTypeId]: EnqueueTypeId = EnqueueTypeId;
   readonly [QueueTypeId]: QueueTypeId     = QueueTypeId;
-  declare _RA: () => RA | RC;
-  declare _RB: () => RB;
-  declare _EA: () => EA | EC;
-  declare _EB: () => EB;
-  declare _A: (_: C) => void;
-  declare _B: () => B;
+  declare [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(readonly queue: PEnqueueInternal<RA, RB, EA, EB, A, B>, readonly f: (c: C) => IO<RC, EC, A>) {}
 
   awaitShutdown: UIO<void> = this.queue.awaitShutdown;
@@ -167,12 +176,14 @@ export function contramapEnqueueIO<A, RC, EC, C>(f: (c: C) => IO<RC, EC, A>, __t
 class MapIO<RA, RB, EA, EB, A, B, RC, EC, C> implements PDequeueInternal<RA, RB | RC, EA, EB | EC, A, C> {
   readonly [DequeueTypeId]: DequeueTypeId = DequeueTypeId;
   readonly [QueueTypeId]: QueueTypeId     = QueueTypeId;
-  declare _RA: () => RA;
-  declare _RB: () => RB | RC;
-  declare _EA: () => EA;
-  declare _EB: () => EB | EC;
-  declare _A: (_: A) => void;
-  declare _B: () => C;
+  declare [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(readonly queue: PDequeueInternal<RA, RB, EA, EB, A, B>, readonly f: (b: B) => IO<RC, EC, C>) {}
 
   awaitShutdown: UIO<void> = this.queue.awaitShutdown;

package/_src/Queue/api/filterInputIO.ts

@@ -1,6 +1,6 @@
 import type { PEnqueue, PEnqueueInternal } from "@fncts/io/Queue/definition";
 
-import { concrete, EnqueueTypeId, QueueInternal, QueueTypeId } from "@fncts/io/Queue/definition";
+import { concrete, EnqueueTypeId, QueueInternal, QueueTypeId , QueueVariance } from "@fncts/io/Queue/definition";
 
 class FilterInputIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2> extends QueueInternal<RA | R2, RB, EA | E2, EB, A1, B> {
   constructor(readonly queue: QueueInternal<RA, RB, EA, EB, A, B>, readonly f: (_: A1) => IO<R2, E2, boolean>) {
@@ -70,12 +70,14 @@ class FilterInputEnqueueIO<RA, RB, EA, EB, B, A, A1 extends A, R2, E2>
 {
   readonly [EnqueueTypeId]: EnqueueTypeId = EnqueueTypeId;
   readonly [QueueTypeId]: QueueTypeId     = QueueTypeId;
-  declare _RA: () => RA | R2;
-  declare _RB: () => RB;
-  declare _EA: () => EA | E2;
-  declare _EB: () => EB;
-  declare _A: (_: A1) => void;
-  declare _B: () => B;
+  declare [QueueVariance]: {
+    readonly _RA: (_: never) => RA | R2;
+    readonly _RB: (_: never) => RB;
+    readonly _EA: (_: never) => EA | E2;
+    readonly _EB: (_: never) => EB;
+    readonly _A: (_: A1) => void;
+    readonly _B: (_: never) => B;
+  };
   constructor(readonly queue: PEnqueueInternal<RA, RB, EA, EB, A, B>, readonly f: (_: A1) => IO<R2, E2, boolean>) {}
 
   awaitShutdown: UIO<void> = this.queue.awaitShutdown;

package/_src/Queue/api/filterOutputIO.ts

@@ -1,6 +1,6 @@
 import type { PDequeue, PDequeueInternal } from "@fncts/io/Queue/definition";
 
-import { concrete, DequeueTypeId, QueueInternal, QueueTypeId } from "@fncts/io/Queue/definition";
+import { concrete, DequeueTypeId, QueueInternal, QueueTypeId , QueueVariance } from "@fncts/io/Queue/definition";
 
 class FilterOutputIO<RA, RB, EA, EB, A, B, RB1, EB1> extends QueueInternal<RA, RB | RB1, EA, EB | EB1, A, B> {
   constructor(readonly queue: QueueInternal<RA, RB, EA, EB, A, B>, readonly f: (b: B) => IO<RB1, EB1, boolean>) {
@@ -78,12 +78,14 @@ class FilterOutputDequeueIO<RA, RB, EA, EB, A, B, RB1, EB1>
 {
   readonly [QueueTypeId]: QueueTypeId     = QueueTypeId;
   readonly [DequeueTypeId]: DequeueTypeId = DequeueTypeId;
-  declare _RA: () => RA;
-  declare _RB: () => RB | RB1;
-  declare _EA: () => EA;
-  declare _EB: () => EB | EB1;
-  declare _A: (_: A) => void;
-  declare _B: () => B;
+  declare [QueueVariance]: {
+    readonly _RA: (_: never) => RA;
+    readonly _RB: (_: never) => RB | RB1;
+    readonly _EA: (_: never) => EA;
+    readonly _EB: (_: never) => EB | EB1;
+    readonly _A: (_: A) => void;
+    readonly _B: (_: never) => B;
+  };
   constructor(readonly queue: PDequeueInternal<RA, RB, EA, EB, A, B>, readonly f: (b: B) => IO<RB1, EB1, boolean>) {}
 
   awaitShutdown: UIO<void> = this.queue.awaitShutdown;

package/_src/Queue/definition.ts

@@ -4,6 +4,9 @@ export type EnqueueTypeId = typeof EnqueueTypeId;
 export const DequeueTypeId = Symbol.for("fncts.io.Queue.Dequeue");
 export type DequeueTypeId = typeof DequeueTypeId;
 
+export const QueueVariance = Symbol.for("fncts.io.Queue.Variance");
+export type QueueVariance = typeof QueueVariance;
+
 export const QueueTypeId = Symbol.for("fncts.io.Queue");
 export type QueueTypeId = typeof QueueTypeId;
 
@@ -23,12 +26,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;
+  };
 }
 
 /**
@@ -86,12 +91,14 @@ export abstract class QueueInternal<RA, RB, EA, EB, A, B>
   readonly [QueueTypeId]: QueueTypeId     = QueueTypeId;
   readonly [DequeueTypeId]: DequeueTypeId = DequeueTypeId;
   readonly [EnqueueTypeId]: EnqueueTypeId = EnqueueTypeId;
-  readonly _RA!: () => RA;
-  readonly _RB!: () => RB;
-  readonly _EA!: () => EA;
-  readonly _EB!: () => EB;
-  readonly _A!: (_: A) => void;
-  readonly _B!: () => B;
+  declare [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.
@@ -176,13 +183,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/_src/Ref/Derived.ts

@@ -7,8 +7,11 @@ import { IO } from "@fncts/io/IO";
 import { RefInternal } from "./definition.js";
 import { DerivedAll } from "./DerivedAll.js";
 
+export const DerivedTypeId = Symbol.for("fncts.io.Ref.Derived");
+export type DerivedTypeId = typeof DerivedTypeId;
+
 export class Derived<EA, EB, A, B> extends RefInternal<never, never, EA, EB, A, B> {
-  readonly _tag = "Derived";
+  readonly [DerivedTypeId]: DerivedTypeId = DerivedTypeId;
 
   constructor(
     readonly use: <X>(

package/_src/Ref/Synchronized/constructors.ts

@@ -1,5 +1,14 @@
 import { PSynchronizedInternal } from "./definition.js";
 
+/**
+ * @tsplus static fncts.io.Ref.SynchronizedOps unsafeMake
+ */
+export function unsafeMakeSynchronized<A>(a: A, __tsplusTrace?: string): Ref.Synchronized<A> {
+  const ref       = Ref.unsafeMake(a);
+  const semaphore = TSemaphore.unsafeMake(1);
+  return new PSynchronizedInternal(semaphore, ref.get, (a: A) => ref.set(a));
+}
+
 /**
  * @tsplus static fncts.io.Ref.SynchronizedOps make
  */

package/_src/Ref/Synchronized/definition.ts

@@ -4,11 +4,14 @@ import { IO } from "@fncts/io/IO";
 
 import { RefInternal } from "../definition.js";
 
+export const SynchronizedTypeId = Symbol.for("fncts.io.Ref.Synchronized");
+export type SynchronizedTypeId = typeof SynchronizedTypeId;
+
 /**
  * @tsplus type fncts.io.Ref.Synchronized
  */
 export interface PSynchronized<RA, RB, EA, EB, A, B> extends PRef<RA, RB, EA, EB, A, B> {
-  readonly _tag: "Synchronized";
+  readonly [SynchronizedTypeId]: SynchronizedTypeId;
 }
 
 /**
@@ -25,7 +28,7 @@ export const Synchronized: PSynchronizedOps = {};
  * @tsplus type fncts.io.Ref.Synchronized
  */
 export class PSynchronizedInternal<RA, RB, EA, EB, A, B> extends RefInternal<RA, RB, EA, EB, A, B> {
-  readonly _tag = "Synchronized";
+  readonly [SynchronizedTypeId]: SynchronizedTypeId = SynchronizedTypeId;
   constructor(
     readonly semaphore: TSemaphore,
     readonly unsafeGet: IO<RB, EB, B>,