@fncts/io 0.0.22 → 0.0.24

package/_src/Ref/definition.ts

@@ -1,7 +1,8 @@
 import type { Atomic as Atomic_ } from "./Atomic.js";
 import type * as Synchro from "./Synchronized/definition.js";
 
-import { _A, _B, _EA, _EB, _RA, _RB } from "./symbols.js";
+export const RefVariance = Symbol.for("fncts.io.Ref.Variance");
+export type RefVariance = typeof RefVariance;
 
 export const RefTypeId = Symbol.for("fncts.io.Ref");
 export type RefTypeId = typeof RefTypeId;
@@ -11,12 +12,14 @@ export type RefTypeId = typeof RefTypeId;
  */
 export interface PRef<RA, RB, EA, EB, A, B> {
   readonly [RefTypeId]: RefTypeId;
-  readonly [_RA]: () => RA;
-  readonly [_RB]: () => RB;
-  readonly [_EA]: () => EA;
-  readonly [_EB]: () => EB;
-  readonly [_A]: (_: A) => void;
-  readonly [_B]: () => B;
+  readonly [RefVariance]: {
+    readonly _RA: (_: never) => RA;
+    readonly _RB: (_: never) => RB;
+    readonly _EA: (_: never) => EA;
+    readonly _EB: (_: never) => EB;
+    readonly _A: (_: A) => void;
+    readonly _B: (_: never) => B;
+  };
 }
 
 export type Ref<A> = PRef<never, never, never, never, A, A>;
@@ -43,26 +46,32 @@ export interface RefOps {}
 export const Ref: RefOps = {};
 
 export interface ReadableRef<RB, EB, B> {
-  readonly [_RB]: () => RB;
-  readonly [_EB]: () => EB;
-  readonly [_B]: () => B;
+  readonly [RefVariance]: {
+    readonly _RB: (_: never) => RB;
+    readonly _EB: (_: never) => EB;
+    readonly _B: (_: never) => B;
+  };
   readonly get: IO<RB, EB, B>;
 }
 
 export interface WritableRef<RA, EA, A> {
-  readonly [_RA]: () => RA;
-  readonly [_EA]: () => EA;
-  readonly [_A]: (_: A) => void;
+  readonly [RefVariance]: {
+    readonly _RA: (_: never) => RA;
+    readonly _EA: (_: never) => EA;
+    readonly _A: (_: A) => void;
+  };
   set(a: A, __tsplusTrace?: string): IO<RA, EA, void>;
 }
 
 export interface ModifiableRef<RA, RB, EA, EB, A, B> {
-  readonly [_RA]: () => RA;
-  readonly [_RB]: () => RB;
-  readonly [_EA]: () => EA;
-  readonly [_EB]: () => EB;
-  readonly [_A]: (_: A) => void;
-  readonly [_B]: () => B;
+  readonly [RefVariance]: {
+    readonly _RA: (_: never) => RA;
+    readonly _RB: (_: never) => RB;
+    readonly _EA: (_: never) => EA;
+    readonly _EB: (_: never) => EB;
+    readonly _A: (_: A) => void;
+    readonly _B: (_: never) => B;
+  };
   modify<C>(f: (b: B) => readonly [C, A], __tsplusTrace?: string): IO<RA | RB, EA | EB, C>;
 }
 
@@ -74,12 +83,14 @@ export abstract class RefInternal<RA, RB, EA, EB, A, B>
     ModifiableRef<RA, RB, EA, EB, A, B>
 {
   readonly [RefTypeId]: RefTypeId = RefTypeId;
-  declare [_RA]: () => RA;
-  declare [_RB]: () => RB;
-  declare [_EA]: () => EA;
-  declare [_EB]: () => EB;
-  declare [_A]: (_: A) => void;
-  declare [_B]: () => B;
+  declare [RefVariance]: {
+    readonly _RA: (_: never) => RA;
+    readonly _RB: (_: never) => RB;
+    readonly _EA: (_: never) => EA;
+    readonly _EB: (_: never) => EB;
+    readonly _A: (_: A) => void;
+    readonly _B: (_: never) => B;
+  };
 
   /**
    * Folds over the error and value types of the `Ref`. This is a highly

package/_src/Ref.ts

@@ -5,7 +5,6 @@ export * from "./Ref/constructors.js";
 export * from "./Ref/definition.js";
 export * from "./Ref/Derived.js";
 export * from "./Ref/DerivedAll.js";
-export * from "./Ref/symbols.js";
 export * from "./Ref/Synchronized.js";
 // codegen:end
 

package/_src/RefSubject/definition.ts

@@ -3,12 +3,14 @@ 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> {
-  readonly _A: (_: A) => B;
-}
+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
@@ -29,15 +31,20 @@ export abstract class RefSubjectInternal<R, E, A, B>
     Push<R, E, B>,
     Emitter<R, E, A>
 {
-  declare [Ref._RA]: () => R;
-  declare [Ref._RB]: () => R;
-  declare [Ref._EA]: () => never;
-  declare [Ref._EB]: () => never;
-  declare [Ref._A]: (_: A) => void;
-  declare [Ref._B]: () => B;
-  declare _R: (_: never) => R;
-  declare _E: (_: never) => E;
-  declare _A: (_: A) => B;
+  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>;
 

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/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.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);
-                  }
-                }
-              }),
-            );
-          }
-        }
-      }),
-    ),
-  );
-}
-
 /**
  * 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/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) {}
 }

package/_src/STM/internal/Versioned.ts

@@ -2,6 +2,6 @@ export const VersionedTypeId = Symbol.for("fncts.io.Versioned");
 export type VersionedTypeId = typeof VersionedTypeId;
 
 export class Versioned<A> {
-  readonly _typeId: VersionedTypeId = VersionedTypeId;
+  readonly [VersionedTypeId]: VersionedTypeId = VersionedTypeId;
   constructor(readonly value: A) {}
 }

package/_src/STM.ts

@@ -4,6 +4,7 @@ export * from "./STM/definition.js";
 export * from "./STM/driver.js";
 // codegen:end
 // codegen:start { preset: barrel, include: STM/api/*.ts }
+export * from "./STM/api/atomically.js";
 export * from "./STM/api/core-api.js";
 export * from "./STM/api/core-constructors.js";
 // codegen:end

package/_src/Schedule/definition.ts

@@ -1,6 +1,9 @@
 import type { Decision } from "./Decision.js";
 import type { Driver as Driver_ } from "./Driver.js";
 
+export const ScheduleVariance = Symbol.for("fncts.io.Schedule.Variance");
+export type ScheduleVariance = typeof ScheduleVariance;
+
 /**
  * A `Schedule<Env, In, Out>` defines a recurring schedule, which consumes
  * values of type `In`, and which returns values of type `Out`.
@@ -32,9 +35,11 @@ import type { Driver as Driver_ } from "./Driver.js";
  * @tsplus companion fncts.io.ScheduleOps
  */
 export abstract class Schedule<Env, In, Out> {
-  readonly _Env!: () => Env;
-  readonly _In!: (_: In) => void;
-  readonly _Out!: () => Out;
+  declare [ScheduleVariance]: {
+    readonly _Env: (_: never) => Env;
+    readonly _In: (_: In) => void;
+    readonly _Out: (_: never) => Out;
+  };
   readonly _State!: unknown;
   abstract readonly initial: this["_State"];
   abstract step(

package/_src/Scope/definition.ts

@@ -1,4 +1,4 @@
-export const ScopeTypeId = Symbol.for("fncts.base.control.Scope");
+export const ScopeTypeId = Symbol.for("fncts.io.Scope");
 export type ScopeTypeId = typeof ScopeTypeId;
 
 /**
@@ -6,7 +6,7 @@ export type ScopeTypeId = typeof ScopeTypeId;
  * @tsplus companion fncts.io.ScopeOps
  */
 export abstract class Scope {
-  readonly _typeId: ScopeTypeId = ScopeTypeId;
+  readonly [ScopeTypeId]: ScopeTypeId = ScopeTypeId;
   abstract addFinalizerExit(finalizer: Finalizer): UIO<void>;
   abstract fork: UIO<Scope.Closeable>;
 }

package/_src/ScopedRef/definition.ts

@@ -6,7 +6,7 @@ export type ScopedRefTypeId = typeof ScopedRefTypeId;
  * @tsplus companion fncts.io.ScopedRefOps
  */
 export abstract class ScopedRef<A> {
-  readonly _typeId: ScopedRefTypeId = ScopedRefTypeId;
+  readonly [ScopedRefTypeId]: ScopedRefTypeId = ScopedRefTypeId;
   abstract set<R, E>(acquire: IO<R | Scope, E, A>, __tsplusTrace?: string): IO<Exclude<R, Scope>, E, void>;
   abstract get: UIO<A>;
 }

package/_src/State/api.ts

@@ -6,7 +6,7 @@ import { StateInternal } from "./internal.js";
 /**
  * @tsplus getter fncts.io.State get
  */
-export function get_<S>(self: State<S>, __tsplusTrace?: string): UIO<S> {
+export function get<S>(self: State<S>, __tsplusTrace?: string): UIO<S> {
   concrete(self);
   return self.get;
 }

package/_src/State/definition.ts

@@ -1,5 +1,6 @@
-import type { StateInternal } from "./internal.js";
+import type { StateInternal} from "./internal.js";
 
+import { StateVariance } from "./internal.js";
 import { StateTypeId } from "./internal.js";
 
 /**
@@ -7,8 +8,10 @@ import { StateTypeId } from "./internal.js";
  * @tsplus companion fncts.io.StateOps
  */
 export abstract class State<S> {
-  readonly _A!: () => S;
-  readonly _typeId: StateTypeId = StateTypeId;
+  readonly [StateTypeId]: StateTypeId = StateTypeId;
+  declare [StateVariance]: {
+    readonly _S: (_: S) => S;
+  };
 }
 
 /**

package/_src/State/internal.ts

@@ -1,9 +1,14 @@
-export const StateTypeId = Symbol.for("fncts.base.control.State");
+export const StateVariance = Symbol.for("fncts.io.State.Variance");
+export type StateVariance = typeof StateVariance;
+
+export const StateTypeId = Symbol.for("fncts.io.State");
 export type StateTypeId = typeof StateTypeId;
 
 export abstract class StateInternal<S> {
-  declare _A: () => S;
-  readonly _typeId: StateTypeId = StateTypeId;
+  readonly [StateTypeId]: StateTypeId = StateTypeId;
+  declare [StateVariance]: {
+    readonly _S: (_: S) => S;
+  };
   abstract get: UIO<S>;
   abstract set(s: S, __tsplusTrace?: string): UIO<void>;
   abstract update(f: (s: S) => S, __tsplusTrace?: string): UIO<void>;

package/_src/Stream/definition.ts

@@ -1,5 +1,9 @@
 import type { _A, _E, _R } from "@fncts/base/types";
-export const StreamTypeId = Symbol.for("@principia/base/IO/Stream");
+
+export const StreamVariance = Symbol.for("fncts.io.Stream.Variance");
+export type StreamVariance = typeof StreamVariance;
+
+export const StreamTypeId = Symbol.for("fncts.io.Steam");
 export type StreamTypeId = typeof StreamTypeId;
 
 /**
@@ -24,16 +28,24 @@ export type StreamTypeId = typeof StreamTypeId;
  */
 export class Stream<R, E, A> {
   readonly [StreamTypeId]: StreamTypeId = StreamTypeId;
-  declare _R: () => R;
-  declare _E: () => E;
-  declare _A: () => A;
+  declare [StreamVariance]: {
+    readonly _R: (_: never) => R;
+    readonly _E: (_: never) => E;
+    readonly _A: (_: never) => A;
+  };
   constructor(readonly channel: Channel<R, unknown, unknown, unknown, E, Conc<A>, unknown>) {}
 }
 
 /**
  * @tsplus unify fncts.io.Stream
  */
-export function unifyStream<X extends Stream<any, any, any>>(_: X): Stream<_R<X>, _E<X>, _A<X>> {
+export function unifyStream<X extends Stream<any, any, any>>(
+  _: X,
+): Stream<
+  [X] extends [{ [StreamVariance]: { _R: (_: never) => infer R } }] ? R : never,
+  [X] extends [{ [StreamVariance]: { _E: (_: never) => infer E } }] ? E : never,
+  [X] extends [{ [StreamVariance]: { _A: (_: never) => infer A } }] ? A : never
+> {
   return _;
 }