@fncts/io 0.0.21 → 0.0.23

package/_src/RefSubject/definition.ts

@@ -0,0 +1,69 @@
+import type { Emitter } from "../Push.js";
+import type { Push } from "../Push.js";
+import type { ModifiableRef, ReadableRef, WritableRef } from "../Ref.js";
+import type { SynchronizedRefSubject } from "@fncts/io/RefSubject/Synchronized/definition";
+
+import { PushTypeId } from "../Push.js";
+import { PushVariance } from "../Push.js";
+import { RefVariance } from "../Ref.js";
+
+/**
+ * @tsplus type fncts.io.Push.RefSubject
+ */
+export interface RefSubject<out R, in out E, in A, out B> extends Push<R, E, B>, Emitter<R, E, A> {}
+
+/**
+ * @tsplus type fncts.io.Push.RefSubjectOps
+ */
+export interface RefSubjectOps {}
+
+export const RefSubject: RefSubjectOps = {};
+
+export declare namespace RefSubject {
+  export type Synchronized<R, E, A, B> = SynchronizedRefSubject<R, E, A, B>;
+}
+
+export abstract class RefSubjectInternal<R, E, A, B>
+  implements
+    ReadableRef<R, never, B>,
+    WritableRef<R, never, A>,
+    ModifiableRef<R, R, never, never, A, B>,
+    Push<R, E, B>,
+    Emitter<R, E, A>
+{
+  readonly [PushTypeId]: PushTypeId = PushTypeId;
+  declare [RefVariance]: {
+    readonly _RA: (_: never) => R;
+    readonly _RB: (_: never) => R;
+    readonly _EA: (_: never) => never;
+    readonly _EB: (_: never) => never;
+    readonly _A: (_: A) => void;
+    readonly _B: (_: never) => B;
+  };
+  declare [PushVariance]: {
+    readonly _R: (_: never) => R;
+    readonly _E: (_: never) => E;
+    readonly _A: (_: A) => B;
+  };
+
+  abstract get get(): IO<R, never, B>;
+
+  abstract set(value: A): IO<R, never, void>;
+
+  abstract modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string): IO<R, never, C>;
+
+  abstract run<R1>(emitter: Emitter<R1, E, B>): IO<Scope | R | R1, never, void>;
+
+  abstract failCause(cause: Cause<E>): IO<R, never, void>;
+
+  abstract emit(value: A): IO<R, never, void>;
+
+  abstract end: IO<R, never, void>;
+}
+
+/**
+ * @tsplus macro remove
+ */
+export function concrete<R, E, A, B>(_: RefSubject<R, E, A, B>): asserts _ is RefSubjectInternal<R, E, A, B> {
+  //
+}

package/_src/RefSubject.ts

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

package/_src/Reloadable/definition.ts

@@ -1,11 +1,16 @@
 import { IterableWeakMap } from "@fncts/base/collection/weak/IterableWeakMap";
 
+export const ReloadableVariance = Symbol.for("fncts.io.Reloadable");
+export type ReloadableVariance = typeof ReloadableVariance;
+
 /**
  * @tsplus type fncts.io.Reloadable
  * @tsplus companion fncts.io.ReloadableOps
  */
 export class Reloadable<Service> {
-  declare _Service: (_: never) => Service;
+  declare [ReloadableVariance]: {
+    readonly _Service: (_: never) => Service;
+  };
   constructor(readonly scopedRef: ScopedRef<Service>, readonly reload: IO<never, unknown, void>) {}
 
   get get(): UIO<Service> {

package/_src/RuntimeConfig.ts

@@ -1,35 +1,6 @@
-export const RuntimeConfigFlag = {
-  EnableCurrentFiber: Symbol.for("fncta.data.RuntimeConfigFlag.EnableCurrentFiber"),
-  LogRuntime: Symbol.for("fncta.data.RuntimeConfigFlag.LogRuntime"),
-  SuperviseOperations: Symbol.for("fncta.data.RuntimeConfigFlag.SuperviseOperations"),
-  TrackRuntimeMetrics: Symbol.for("fncts.RuntimeConfigFlag.TrackRuntimeMetrics"),
-  EnableFiberRoots: Symbol.for("fncta.data.RuntimeConfigFlag.EnableFiberRoots"),
-} as const;
-
-export type RuntimeConfigFlag = typeof RuntimeConfigFlag[keyof typeof RuntimeConfigFlag];
-
 export class RuntimeConfig extends CaseClass<{
   readonly reportFailure: (e: Cause<unknown>) => void;
   readonly supervisor: Supervisor<any>;
-  readonly flags: RuntimeConfigFlags;
   readonly yieldOpCount: number;
   readonly logger: Logger<string, any>;
 }> {}
-
-/**
- * @tsplus companion fncts.RuntimeConfigFlags
- */
-export class RuntimeConfigFlags {
-  constructor(readonly flags: HashSet<RuntimeConfigFlag>) {}
-  add(flag: RuntimeConfigFlag) {
-    return new RuntimeConfigFlags(this.flags.add(flag));
-  }
-  isEnabled(flag: RuntimeConfigFlag): boolean {
-    return this.flags.has(flag);
-  }
-}
-
-/**
- * @tsplus static fncts.RuntimeConfigFlags empty
- */
-export const empty = new RuntimeConfigFlags(HashSet.makeDefault());

package/_src/RuntimeFlag.ts

@@ -0,0 +1,10 @@
+export const enum RuntimeFlag {
+  Interruption = 1 << 0,
+  CurrentFiber = 1 << 1,
+  OpLog = 1 << 2,
+  OpSupervision = 1 << 3,
+  RuntimeMetrics = 1 << 4,
+  FiberRoots = 1 << 5,
+  WindDown = 1 << 6,
+  CooperativeYielding = 1 << 7,
+}

package/_src/RuntimeFlags/Patch.ts

@@ -0,0 +1,79 @@
+import type { RuntimeFlag } from "../RuntimeFlag.js";
+
+import { RuntimeFlags } from "./RuntimeFlags.js";
+
+/**
+ * @tsplus type fncts.io.RuntimeFlagsPatch
+ */
+export type RuntimeFlagsPatch = number & {
+  readonly RuntimeFlagsPatch: unique symbol;
+};
+
+/**
+ * @tsplus type fncts.io.RuntimeFlagsPatchOps
+ */
+export interface RuntimeFlagsPatchOps {}
+
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps Patch
+ */
+export const RuntimeFlagsPatch: RuntimeFlagsPatchOps = Newtype();
+
+/**
+ * @tsplus static fncts.io.RuntimeFlagsPatchOps __call
+ */
+export function makeRuntimeFlagsPatch(active: number, enabled: number): RuntimeFlags.Patch {
+  return ((active << 0) + ((enabled & active) << 16)) as RuntimeFlags.Patch;
+}
+
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps enable
+ */
+export function mkEnable(flag: RuntimeFlag): RuntimeFlags.Patch {
+  return RuntimeFlags.Patch(flag, flag);
+}
+
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps disable
+ */
+export function mkDisable(flag: RuntimeFlag): RuntimeFlags.Patch {
+  return RuntimeFlags.Patch(flag, 0);
+}
+
+/**
+ * @tsplus fluent fncts.io.RuntimeFlagsPatch isActive
+ */
+export function isActive(patch: RuntimeFlags.Patch, flag: RuntimeFlag): boolean {
+  return (active(patch) & flag) !== 0;
+}
+
+/**
+ * @tsplus fluent fncts.io.RuntimeFlagsPatch isEnabled
+ */
+export function isEnabledPatch(patch: RuntimeFlags.Patch, flag: RuntimeFlag): boolean {
+  return patch.isActive(flag) && (enabled(patch) & flag) !== 0;
+}
+
+/**
+ * @tsplus fluent fncts.io.RuntimeFlagsPatch patch
+ */
+export function patch(patch: RuntimeFlags.Patch, flags: RuntimeFlags): RuntimeFlags {
+  return ((flags & (~active(patch) | enabled(patch))) | (active(patch) & enabled(patch))) as RuntimeFlags;
+}
+
+/**
+ * @tsplus fluent fncts.io.RuntimeFlagsPatch exclude
+ */
+export function exclude(patch: RuntimeFlags.Patch, flag: RuntimeFlag): RuntimeFlags.Patch {
+  return RuntimeFlags.Patch(active(patch) & ~flag, enabled(patch));
+}
+
+const base = 0xffffffff | 0;
+
+function active(patch: RuntimeFlags.Patch): number {
+  return (patch >> 0) & base;
+}
+
+function enabled(patch: RuntimeFlags.Patch): number {
+  return (patch >> 16) & base;
+}

package/_src/RuntimeFlags/RuntimeFlags.ts

@@ -0,0 +1,112 @@
+import type { RuntimeFlagsPatch } from "./Patch.js";
+
+import { RuntimeFlag } from "../RuntimeFlag.js";
+
+/**
+ * @tsplus type fncts.io.RuntimeFlags
+ */
+export type RuntimeFlags = number & {
+  readonly RuntimeFlags: unique symbol;
+};
+
+/**
+ * @tsplus type fncts.io.RuntimeFlagsOps
+ */
+export interface RuntimeFlagsOps {}
+
+export const RuntimeFlags: RuntimeFlagsOps = Newtype();
+
+export declare namespace RuntimeFlags {
+  type Patch = RuntimeFlagsPatch;
+}
+
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps __call
+ */
+export function makeRuntimeFlags(...flags: ReadonlyArray<RuntimeFlag>): RuntimeFlags {
+  return flags.reduce((b, a) => b | a, 0) as RuntimeFlags;
+}
+
+/**
+ * @tsplus fluent fncts.io.RuntimeFlags isEnabled
+ */
+export function isEnabled(flags: RuntimeFlags, flag: RuntimeFlag): boolean {
+  return (flags & flag) !== 0;
+}
+
+/**
+ * @tsplus fluent fncts.io.RuntimeFlags enable
+ */
+export function enable(flags: RuntimeFlags, flag: RuntimeFlag): RuntimeFlags {
+  return (flags | flag) as RuntimeFlags;
+}
+
+/**
+ * @tsplus getter fncts.io.RuntimeFlags cooperativeYielding
+ */
+export function cooperativeYielding(flags: RuntimeFlags): boolean {
+  return flags.isEnabled(RuntimeFlag.CooperativeYielding);
+}
+
+/**
+ * @tsplus getter fncts.io.RuntimeFlags currentFiber
+ */
+export function currentFiber(flags: RuntimeFlags): boolean {
+  return flags.isEnabled(RuntimeFlag.CurrentFiber);
+}
+
+/**
+ * @tsplus getter fncts.io.RuntimeFlags fiberRoots
+ */
+export function fiberRoots(flags: RuntimeFlags): boolean {
+  return flags.isEnabled(RuntimeFlag.FiberRoots);
+}
+
+/**
+ * @tsplus getter fncts.io.RuntimeFlags interruption
+ */
+export function interruption(flags: RuntimeFlags): boolean {
+  return flags.isEnabled(RuntimeFlag.Interruption);
+}
+
+/**
+ * @tsplus getter fncts.io.RuntimeFlags windDown
+ */
+export function windDown(flags: RuntimeFlags): boolean {
+  return flags.isEnabled(RuntimeFlag.WindDown);
+}
+
+/**
+ * @tsplus getter fncts.io.RuntimeFlags opSupervision
+ */
+export function opSpervision(flags: RuntimeFlags): boolean {
+  return flags.isEnabled(RuntimeFlag.OpSupervision);
+}
+
+/**
+ * @tsplus getter fncts.io.RuntimeFlags interruptible
+ */
+export function interruptible(flags: RuntimeFlags): boolean {
+  return interruption(flags) && !windDown(flags);
+}
+
+/**
+ * @tsplus fluent fncts.io.RuntimeFlags diff
+ */
+export function diff(oldValue: RuntimeFlags, newValue: RuntimeFlags) {
+  return RuntimeFlags.Patch(oldValue ^ newValue, newValue);
+}
+
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps none
+ */
+export const none = 0 as RuntimeFlags;
+
+/**
+ * @tsplus static fncts.io.RuntimeFlagsOps default
+ */
+export const defaultRuntimeFlags = RuntimeFlags(
+  RuntimeFlag.FiberRoots,
+  RuntimeFlag.Interruption,
+  RuntimeFlag.CooperativeYielding,
+);

package/_src/RuntimeFlags.ts

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

package/_src/STM/api/atomically.ts

@@ -0,0 +1,43 @@
+import { AtomicReference } from "@fncts/base/internal/AtomicReference";
+import { CommitState } from "@fncts/io/STM/internal/CommitState";
+import { tryCommitAsync, tryCommitSync } from "@fncts/io/STM/internal/Journal";
+import { TryCommitTag } from "@fncts/io/STM/internal/TryCommit";
+import { TxnId } from "@fncts/io/TxnId";
+
+/**
+ * @tsplus static fncts.io.STMOps atomically
+ * @tsplus getter fncts.io.STM commit
+ */
+export function atomically<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
+  return IO.environmentWithIO((r: Environment<R>) =>
+    FiberRef.currentScheduler.getWith((scheduler) =>
+      IO.fiberId.flatMap((fiberId) => {
+        const result = tryCommitSync(fiberId, stm, r, scheduler);
+        switch (result._tag) {
+          case TryCommitTag.Done: {
+            return IO.fromExitNow(result.exit);
+          }
+          case TryCommitTag.Suspend: {
+            const id    = TxnId.make();
+            const state = new AtomicReference<CommitState<E, A>>(CommitState.Running);
+            const async = IO.async(tryCommitAsync(result.journal, fiberId, stm, id, state, r, scheduler));
+            return IO.uninterruptibleMask(({ restore }) =>
+              restore(async).catchAllCause((cause) => {
+                state.compareAndSet(CommitState.Running, CommitState.Interrupted);
+                const newState = state.get;
+                switch (newState._tag) {
+                  case "Done": {
+                    return IO.fromExitNow(newState.exit);
+                  }
+                  default: {
+                    return IO.failCauseNow(cause);
+                  }
+                }
+              }),
+            );
+          }
+        }
+      }),
+    ),
+  );
+}

package/_src/STM/api.ts

@@ -85,44 +85,6 @@ export function environmentWithSTM<R0, R, E, A>(f: (r: Environment<R0>) => STM<R
   return STM.environment<R0>().flatMap(f);
 }
 
-/**
- * @tsplus static fncts.io.STMOps atomically
- * @tsplus getter fncts.io.STM commit
- */
-export function atomically<R, E, A>(stm: STM<R, E, A>, __tsplusTrace?: string): IO<R, E, A> {
-  return IO.environmentWithIO((r: Environment<R>) =>
-    FiberRef.currentScheduler.getWith((scheduler) =>
-      IO.deferWith((_, fiberId) => {
-        const result = tryCommitSync(fiberId, stm, r, scheduler);
-        switch (result._tag) {
-          case TryCommitTag.Done: {
-            return IO.fromExitNow(result.exit);
-          }
-          case TryCommitTag.Suspend: {
-            const id    = TxnId.make();
-            const state = new AtomicReference<CommitState<E, A>>(CommitState.Running);
-            const async = IO.async(tryCommitAsync(result.journal, fiberId, stm, id, state, r, scheduler));
-            return IO.uninterruptibleMask(({ restore }) =>
-              restore(async).catchAllCause((cause) => {
-                state.compareAndSet(CommitState.Running, CommitState.Interrupted);
-                const newState = state.get;
-                switch (newState._tag) {
-                  case "Done": {
-                    return IO.fromExitNow(newState.exit);
-                  }
-                  default: {
-                    return IO.failCauseNow(cause);
-                  }
-                }
-              }),
-            );
-          }
-        }
-      }),
-    ),
-  );
-}
-
 /**
  * Returns an `STM` effect whose failure and success channels have been mapped by
  * the specified pair of functions, `f` and `g`.
@@ -736,3 +698,23 @@ export function zipWith<A, R1, E1, B, C>(that: STM<R1, E1, B>, f: (a: A, b: B) =
     return self.flatMap((a) => that.map((b) => f(a, b)));
   };
 }
+
+/**
+ * @tsplus pipeable fncts.io.STM zipLeft
+ * @tsplus opipeable-operator fncts.io.STM <
+ */
+export function zipLeft<R1, E1, B>(that: STM<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E, A>(self: STM<R, E, A>): STM<R | R1, E | E1, A> => {
+    return self.flatMap((a) => that.as(a));
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.io.STM zipRight
+ * @tsplus pipeable-operator fncts.io.STM >
+ */
+export function zipRight<R1, E1, B>(that: STM<R1, E1, B>, __tsplusTrace?: string) {
+  return <R, E, A>(self: STM<R, E, A>): STM<R | R1, E | E1, B> => {
+    return self.flatMap(() => that);
+  };
+}

package/_src/STM/definition.ts

@@ -1,7 +1,7 @@
 import type { Journal } from "./internal/Journal.js";
 import type { _A, _E, _R } from "@fncts/base/types";
 
-import { hasTypeId } from "@fncts/base/util/predicates";
+import { IOOpCode, IOTypeId, IOVariance } from "@fncts/io/IO/definition";
 
 export const enum STMTag {
   Effect = "Effect",
@@ -13,6 +13,9 @@ export const enum STMTag {
   ContramapEnvironment = "ContramapEnvironment",
 }
 
+export const STMVariance = Symbol.for("fncts.io.STM.Variance");
+export type STMVariance = typeof STMVariance;
+
 export const STMTypeId = Symbol.for("fncts.io.STM");
 export type STMTypeId = typeof STMTypeId;
 
@@ -21,10 +24,20 @@ export type STMTypeId = typeof STMTypeId;
  * @tsplus companion fncts.io.STMOps
  */
 export abstract class STM<R, E, A> {
-  readonly _typeId: STMTypeId = STMTypeId;
-  readonly _R!: () => R;
-  readonly _E!: () => E;
-  readonly _A!: () => A;
+  readonly [IOTypeId]: IOTypeId = IOTypeId;
+  readonly ioOpCode             = IOOpCode.Commit;
+  readonly trace?: string;
+  readonly [STMTypeId]: STMTypeId = STMTypeId;
+  declare [IOVariance]: {
+    _R: () => R;
+    _E: () => E;
+    _A: () => A;
+  };
+  declare [STMVariance]: {
+    _R: () => R;
+    _E: () => E;
+    _A: () => A;
+  };
 }
 
 /**
@@ -40,14 +53,14 @@ export function unifySTM<X extends STM<any, any, any>>(self: X): STM<_R<X>, _E<X
 export interface USTM<A> extends STM<never, never, A> {}
 
 export class Effect<R, E, A> extends STM<R, E, A> {
-  readonly _tag = STMTag.Effect;
+  readonly stmOpCode = STMTag.Effect;
   constructor(readonly f: (journal: Journal, fiberId: FiberId, r: Environment<R>) => A) {
     super();
   }
 }
 
 export class OnFailure<R, E, A, E1> extends STM<R, E1, A> {
-  readonly _tag = STMTag.OnFailure;
+  readonly stmOpCode = STMTag.OnFailure;
   constructor(readonly stm: STM<R, E, A>, readonly onFailure: (e: E) => STM<R, E1, A>) {
     super();
   }
@@ -57,7 +70,7 @@ export class OnFailure<R, E, A, E1> extends STM<R, E1, A> {
 }
 
 export class OnRetry<R, E, A> extends STM<R, E, A> {
-  readonly _tag = STMTag.OnRetry;
+  readonly stmOpCode = STMTag.OnRetry;
   constructor(readonly stm: STM<R, E, A>, readonly onRetry: STM<R, E, A>) {
     super();
   }
@@ -67,28 +80,28 @@ export class OnRetry<R, E, A> extends STM<R, E, A> {
 }
 
 export class OnSuccess<R, E, A, B> extends STM<R, E, B> {
-  readonly _tag = STMTag.OnSuccess;
+  readonly stmOpCode = STMTag.OnSuccess;
   constructor(readonly stm: STM<R, E, A>, readonly apply: (a: A) => STM<R, E, B>) {
     super();
   }
 }
 
 export class Succeed<A> extends STM<never, never, A> {
-  readonly _tag = STMTag.Succeed;
+  readonly stmOpCode = STMTag.Succeed;
   constructor(readonly a: () => A) {
     super();
   }
 }
 
 export class SucceedNow<A> extends STM<never, never, A> {
-  readonly _tag = STMTag.SucceedNow;
+  readonly stmOpCode = STMTag.SucceedNow;
   constructor(readonly a: A) {
     super();
   }
 }
 
 export class ContramapEnvironment<R, E, A, R0> extends STM<R0, E, A> {
-  readonly _tag = STMTag.ContramapEnvironment;
+  readonly stmOpCode = STMTag.ContramapEnvironment;
   constructor(readonly stm: STM<R, E, A>, readonly f: (_: Environment<R0>) => Environment<R>) {
     super();
   }
@@ -111,45 +124,45 @@ export const FailExceptionTypeId = Symbol.for("fncta.control.STM.FailException")
 export type FailExceptionTypeId = typeof FailExceptionTypeId;
 
 export class FailException<E> {
-  readonly _typeId: FailExceptionTypeId = FailExceptionTypeId;
+  readonly [FailExceptionTypeId]: FailExceptionTypeId = FailExceptionTypeId;
   constructor(readonly e: E) {}
 }
 
 export function isFailException(u: unknown): u is FailException<unknown> {
-  return hasTypeId(u, FailExceptionTypeId);
+  return isObject(u) && FailExceptionTypeId in u;
 }
 
 export const HaltExceptionTypeId = Symbol.for("fncts.io.STM.HaltException");
 export type HaltExceptionTypeId = typeof HaltExceptionTypeId;
 
 export class HaltException<E> {
-  readonly _typeId: HaltExceptionTypeId = HaltExceptionTypeId;
+  readonly [HaltExceptionTypeId]: HaltExceptionTypeId = HaltExceptionTypeId;
   constructor(readonly e: E) {}
 }
 
 export function isHaltException(u: unknown): u is HaltException<unknown> {
-  return hasTypeId(u, HaltExceptionTypeId);
+  return isObject(u) && HaltExceptionTypeId in u;
 }
 
 export const InterruptExceptionTypeId = Symbol.for("fncts.io.STM.InterruptException");
 export type InterruptExceptionTypeId = typeof InterruptExceptionTypeId;
 
 export class InterruptException {
-  readonly _typeId: InterruptExceptionTypeId = InterruptExceptionTypeId;
+  readonly [InterruptExceptionTypeId]: InterruptExceptionTypeId = InterruptExceptionTypeId;
   constructor(readonly fiberId: FiberId) {}
 }
 
 export function isInterruptException(u: unknown): u is InterruptException {
-  return hasTypeId(u, InterruptExceptionTypeId);
+  return isObject(u) && InterruptExceptionTypeId in u;
 }
 
 export const RetryExceptionTypeId = Symbol.for("fncts.io.STM.RetryException");
 export type RetryExceptionTypeId = typeof RetryExceptionTypeId;
 
 export class RetryException {
-  readonly _typeId: RetryExceptionTypeId = RetryExceptionTypeId;
+  readonly [RetryExceptionTypeId]: RetryExceptionTypeId = RetryExceptionTypeId;
 }
 
 export function isRetryException(u: unknown): u is RetryException {
-  return hasTypeId(u, RetryExceptionTypeId);
+  return isObject(u) && RetryExceptionTypeId in u;
 }

package/_src/STM/driver.ts

@@ -25,12 +25,12 @@ export class STMDriver<R, E, A> {
     let result: Erased | undefined = undefined;
     while (this.contStack.hasNext && !result) {
       const cont = this.contStack.pop()!;
-      if (cont._tag === STMTag.OnFailure) {
+      if (cont.stmOpCode === STMTag.OnFailure) {
         if (!isRetry) {
           result = cont.onFailure(error);
         }
       }
-      if (cont._tag === STMTag.OnRetry) {
+      if (cont.stmOpCode === STMTag.OnRetry) {
         if (isRetry) {
           result = cont.onRetry;
         }
@@ -46,7 +46,7 @@ export class STMDriver<R, E, A> {
     while (!exit && curr) {
       const k = curr;
       concrete(k);
-      switch (k._tag) {
+      switch (k.stmOpCode) {
         case STMTag.Succeed: {
           const a = k.a();
           if (!this.contStack.hasNext) {

package/_src/STM/internal/Entry.ts

@@ -10,7 +10,7 @@ export type EntryTypeId = typeof EntryTypeId;
  * @tsplus companion fncts.io.EntryOps
  */
 export class Entry {
-  readonly _typeId: EntryTypeId = EntryTypeId;
+  readonly [EntryTypeId]: EntryTypeId = EntryTypeId;
   constructor(readonly use: <X>(f: <S>(entry: ConcreteEntry<S>) => X) => X) {}
 }
 
@@ -27,7 +27,7 @@ export const ConcreteEntryTypeId = Symbol.for("fncts.io.ConcreteEntry");
 export type ConcreteEntryTypeId = typeof ConcreteEntryTypeId;
 
 export class ConcreteEntry<S> {
-  readonly _typeId: ConcreteEntryTypeId = ConcreteEntryTypeId;
+  readonly [ConcreteEntryTypeId]: ConcreteEntryTypeId = ConcreteEntryTypeId;
   constructor(
     readonly tref: Atomic<S>,
     readonly expected: Versioned<S>,

package/_src/STM/internal/Journal.ts

@@ -88,7 +88,7 @@ export function analyzeJournal(journal: Journal): JournalAnalysis {
 /**
  * @tsplus static fncts.io.JournalOps emptyTodoMap
  */
-export const emptyTodoMap = HashMap.makeDefault<TxnId, Todo>();
+export const emptyTodoMap = HashMap.empty<TxnId, Todo>();
 
 /**
  * Atomically collects and clears all the todos from any `TRef` that

package/_src/STM/internal/TryCommit.ts

@@ -11,13 +11,13 @@ export const enum TryCommitTag {
 }
 
 export class Done<E, A> {
-  readonly _typeId: TryCommitTypeId = TryCommitTypeId;
-  readonly _tag                     = TryCommitTag.Done;
+  readonly [TryCommitTypeId]: TryCommitTypeId = TryCommitTypeId;
+  readonly _tag = TryCommitTag.Done;
   constructor(readonly exit: Exit<E, A>) {}
 }
 
 export class Suspend {
-  readonly _typeId: TryCommitTypeId = TryCommitTypeId;
-  readonly _tag                     = TryCommitTag.Suspend;
+  readonly [TryCommitTypeId]: TryCommitTypeId = TryCommitTypeId;
+  readonly _tag = TryCommitTag.Suspend;
   constructor(readonly journal: Journal) {}
 }