@fncts/base 0.0.22 → 0.0.23

package/_src/data/DatumEither.ts

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

package/_src/data/DecodeError/definition.ts

@@ -6,7 +6,7 @@ export const DecodeErrorTypeId = Symbol.for("fncts.DecodeError");
 export type DecodeErrorTypeId = typeof DecodeErrorTypeId;
 
 export abstract class DecodeError {
-  readonly _typeId: DecodeErrorTypeId = DecodeErrorTypeId;
+  readonly [DecodeErrorTypeId]: DecodeErrorTypeId = DecodeErrorTypeId;
   abstract render: Eval<RoseTree<string>>;
 }
 

package/_src/data/Decoder/definition.ts

@@ -16,7 +16,7 @@ export interface DecoderF extends HKT {
  * @tsplus derive nominal
  */
 export class Decoder<in out A> {
-  readonly _typeId: DecoderTypeId = DecoderTypeId;
+  readonly [DecoderTypeId]: DecoderTypeId = DecoderTypeId;
   constructor(readonly decode: (input: unknown) => These<DecodeError, A>, readonly label: string) {}
 }
 

package/_src/data/Duration/definition.ts

@@ -1,5 +1,3 @@
-import { hasTypeId } from "../../util/predicates.js";
-
 export const DurationTypeId = Symbol.for("fncts.Duration");
 export type DurationTypeId = typeof DurationTypeId;
 
@@ -8,7 +6,7 @@ export type DurationTypeId = typeof DurationTypeId;
  * @tsplus companion fncts.DurationOps
  */
 export class Duration implements Equatable, Hashable {
-  readonly _typeId: DurationTypeId = DurationTypeId;
+  readonly [DurationTypeId]: DurationTypeId = DurationTypeId;
   constructor(readonly milliseconds: number) {}
 
   [Symbol.equals](that: unknown): boolean {
@@ -21,5 +19,5 @@ export class Duration implements Equatable, Hashable {
 }
 
 export function isDuration(u: unknown): u is Duration {
-  return hasTypeId(u, DurationTypeId);
+  return isObject(u) && DurationTypeId in u;
 }

package/_src/data/Either/api.ts

@@ -1,9 +1,7 @@
 import type * as P from "../../typeclass.js";
 import type { EitherF } from "./definition.js";
 
-import { hasTypeId } from "../../util/predicates.js";
 import { identity } from "../function.js";
-import { concrete } from "./definition.js";
 import { EitherTag, EitherTypeId, Left, Right } from "./definition.js";
 
 /**
@@ -128,7 +126,7 @@ export function getOrElse<E, B>(orElse: (e: E) => B) {
  * @tsplus static fncts.EitherOps isEither
  */
 export function isEither(u: unknown): u is Either<unknown, unknown> {
-  return hasTypeId(u, EitherTypeId);
+  return isObject(u) && EitherTypeId in u;
 }
 
 /**

package/_src/data/Either/definition.ts

@@ -3,6 +3,9 @@ export const enum EitherTag {
   Right = "Right",
 }
 
+export const EitherVariance = Symbol.for("fncts.Either.Variance");
+export type EitherVariance = typeof EitherVariance;
+
 export const EitherTypeId = Symbol.for("fncts.data.Either");
 export type EitherTypeId = typeof EitherTypeId;
 
@@ -19,9 +22,11 @@ export interface EitherF extends HKT {
  * @tsplus companion fncts.EitherOps
  */
 export class Either<E, A> {
-  readonly _typeId: EitherTypeId = EitherTypeId;
-  readonly _E!: () => E;
-  readonly _A!: () => A;
+  readonly [EitherTypeId]: EitherTypeId = EitherTypeId;
+  declare [EitherVariance]: {
+    readonly _E: (_: never) => E;
+    readonly _A: (_: never) => A;
+  };
 }
 
 /**

package/_src/data/Encoder/definition.ts

@@ -7,7 +7,7 @@ export type EncoderTypeId = typeof EncoderTypeId;
  * @tsplus derive nominal
  */
 export class Encoder<in out A> {
-  readonly _typeId: EncoderTypeId = EncoderTypeId;
+  readonly [EncoderTypeId]: EncoderTypeId = EncoderTypeId;
   constructor(readonly encode: (inp: A) => unknown) {}
 }
 

package/_src/data/Environment/api.ts

@@ -49,17 +49,6 @@ export function union<R1>(that: Environment<R1>) {
   };
 }
 
-/**
- * @tsplus getter fncts.Environment clean
- */
-export function clean<R>(self: Environment<R>): Environment<R> {
-  const [map, index] = self.map.toList.foldLeft(
-    [HashMap.empty<Tag<unknown>, readonly [unknown, number]>(), 0],
-    ([map, index], [tag, service]) => [map.set(tag, [service, index] as const), index + 1],
-  );
-  return new Environment(map);
-}
-
 /**
  * @tsplus pipeable fncts.Environment unsafeGet
  */

package/_src/data/Environment/definition.ts

@@ -1,19 +1,20 @@
 import type { EnvironmentPatch } from "@fncts/base/data/EnvironmentPatch";
 
-/**
- * @tsplus static fncts.prelude.builtin.SymbolOps env
- */
-export const EnvSymbol = Symbol.for("fncts.Env");
+export const EnvironmentVariance = Symbol.for("fncts.Environment.Variance");
+export type EnvironmentVariance = typeof EnvironmentVariance;
 
-export type EnvSymbol = typeof EnvSymbol;
+export const EnvironmentTypeId = Symbol.for("fncts.Environment");
+export type EnvironmentTypeId = typeof EnvironmentTypeId;
 
 /**
  * @tsplus type fncts.Environment
  * @tsplus companion fncts.EnvironmentOps
  */
 export class Environment<R> implements Hashable, Equatable {
-  readonly _typeId: EnvSymbol = EnvSymbol;
-  readonly [EnvSymbol]!: (_: never) => R;
+  readonly [EnvironmentTypeId]: EnvironmentTypeId = EnvironmentTypeId;
+  declare [EnvironmentVariance]: {
+    _R: (_: never) => R;
+  };
   constructor(readonly map: HashMap<Tag<any>, unknown>, public cache: HashMap<Tag<any>, unknown> = HashMap.empty()) {}
 
   get [Symbol.hash](): number {
@@ -30,5 +31,5 @@ export declare namespace Environment {
 }
 
 export function isEnvironment(u: unknown): u is Environment<unknown> {
-  return hasTypeId(u, EnvSymbol);
+  return isObject(u) && EnvironmentTypeId in u;
 }

package/_src/data/EnvironmentPatch.ts

@@ -6,6 +6,9 @@ export const enum EnvironmentPatchTag {
   Empty,
 }
 
+export const EnvironmentPatchVariance = Symbol.for("fncts.Environment.Patch.Variance");
+export type EnvironmentPatchVariance = typeof EnvironmentPatchVariance;
+
 export const EnvironmentPatchTypeId = Symbol.for("fncts.Environment.Patch");
 export type EnvironmentPatchTypeId = typeof EnvironmentPatchTypeId;
 
@@ -14,9 +17,11 @@ export type EnvironmentPatchTypeId = typeof EnvironmentPatchTypeId;
  * @tsplus companion fncts.Environment.PatchOps
  */
 export abstract class EnvironmentPatch<In, Out> {
-  readonly _typeId: EnvironmentPatchTypeId = EnvironmentPatchTypeId;
-  readonly _R!: (_: In) => void;
-  readonly _A!: () => Out;
+  readonly [EnvironmentPatchTypeId]: EnvironmentPatchTypeId = EnvironmentPatchTypeId;
+  declare [EnvironmentPatchVariance]: {
+    readonly _R: (_: In) => void;
+    readonly _A: (_: never) => Out;
+  };
 }
 
 export class AddService<Env, Service> extends EnvironmentPatch<Env, Env & Has<Service>> {

package/_src/data/Exit/definition.ts

@@ -1,5 +1,7 @@
 import * as P from "../../typeclass.js";
-import { hasTypeId } from "../../util/predicates.js";
+
+export const ExitVariance = Symbol.for("fncts.Exit");
+export type ExitVariance = typeof ExitVariance;
 
 export const ExitTypeId = Symbol.for("fncts.Exit");
 export type ExitTypeId = typeof ExitTypeId;
@@ -29,11 +31,12 @@ const _successHash = Hashable.string("fncts.Exit.Success");
  * @tsplus companion fncts.Exit.FailureOps
  */
 export class Failure<E> {
-  readonly _E!: () => E;
-  readonly _A!: () => never;
-
-  readonly _typeId: ExitTypeId = ExitTypeId;
-  readonly _tag                = ExitTag.Failure;
+  readonly [ExitTypeId]: ExitTypeId = ExitTypeId;
+  declare [ExitVariance]: {
+    readonly _E: (_: never) => E;
+    readonly _A: (_: never) => never;
+  };
+  readonly _tag = ExitTag.Failure;
   constructor(readonly cause: Cause<E>) {}
 
   get [Symbol.hash](): number {
@@ -49,11 +52,12 @@ export class Failure<E> {
  * @tsplus companion fncts.Exit.SuccessOps
  */
 export class Success<A> implements P.Hashable, P.Equatable {
-  readonly _E!: () => never;
-  readonly _A!: () => A;
-
-  readonly _typeId: ExitTypeId = ExitTypeId;
-  readonly _tag                = ExitTag.Success;
+  readonly [ExitTypeId]: ExitTypeId = ExitTypeId;
+  declare [ExitVariance]: {
+    readonly _E: (_: never) => never;
+    readonly _A: (_: never) => A;
+  };
+  readonly _tag = ExitTag.Success;
   constructor(readonly value: A) {}
 
   get [Symbol.hash](): number {
@@ -68,7 +72,7 @@ export class Success<A> implements P.Hashable, P.Equatable {
  * @tsplus static fncts.ExitOps isExit
  */
 export function isExit(u: unknown): u is Exit<unknown, unknown> {
-  return hasTypeId(u, ExitTypeId);
+  return isObject(u) && ExitTypeId in u;
 }
 
 /**

package/_src/data/FiberId/definition.ts

@@ -1,13 +1,11 @@
-import { hasTypeId } from "../../util/predicates.js";
-
 export const FiberIdTypeId = Symbol.for("fncts.FiberId");
 export type FiberIdTypeId = typeof FiberIdTypeId;
 
 const _hashNone = Hashable.string("fncts.FiberId.None");
 
 export class None implements Hashable, Equatable {
-  readonly _typeId: FiberIdTypeId = FiberIdTypeId;
-  readonly _tag                   = "None";
+  readonly [FiberIdTypeId]: FiberIdTypeId = FiberIdTypeId;
+  readonly _tag = "None";
   [Symbol.equals](that: unknown) {
     return isFiberId(that) && isNone(that);
   }
@@ -19,8 +17,8 @@ export class None implements Hashable, Equatable {
 const _hashRuntime = Hashable.string("fncts.FiberId.Runtime");
 
 export class Runtime implements Hashable, Equatable {
-  readonly _typeId: FiberIdTypeId = FiberIdTypeId;
-  readonly _tag                   = "Runtime";
+  readonly [FiberIdTypeId]: FiberIdTypeId = FiberIdTypeId;
+  readonly _tag = "Runtime";
   constructor(readonly id: number, readonly startTime: number, readonly location?: string) {}
   get [Symbol.hash]() {
     return Hashable.combine(Hashable.combine(_hashRuntime, Hashable.number(this.id)), Hashable.unknown(this.location));
@@ -33,8 +31,8 @@ export class Runtime implements Hashable, Equatable {
 const _hashComposite = Hashable.string("fncts.FiberId.Composite");
 
 export class Composite implements Hashable, Equatable {
-  readonly _typeId: FiberIdTypeId = FiberIdTypeId;
-  readonly _tag                   = "Composite";
+  readonly [FiberIdTypeId]: FiberIdTypeId = FiberIdTypeId;
+  readonly _tag = "Composite";
   constructor(readonly fiberIds: HashSet<Runtime>) {}
   [Symbol.equals](that: unknown) {
     return isFiberId(that) && isComposite(that) && this.fiberIds == that.fiberIds;
@@ -66,7 +64,7 @@ export declare namespace FiberId {
  * @tsplus static fncts.FiberIdOps isFiberId
  */
 export function isFiberId(u: unknown): u is FiberId {
-  return hasTypeId(u, FiberIdTypeId);
+  return isObject(u) && FiberIdTypeId in u;
 }
 
 /**

package/_src/data/Guard/definition.ts

@@ -2,6 +2,9 @@ export interface GuardF extends HKT {
   readonly type: Guard<this["A"]>;
 }
 
+export const GuardVariance = Symbol.for("fncts.Guard.Variance");
+export type GuardVariance = typeof GuardVariance;
+
 export const GuardTypeId = Symbol.for("fncts.Guard");
 export type GuardTypeId = typeof GuardTypeId;
 
@@ -10,8 +13,10 @@ export type GuardTypeId = typeof GuardTypeId;
  * @tsplus companion fncts.GuardOps
  */
 export class Guard<A> {
-  readonly _typeId: GuardTypeId = GuardTypeId;
-  declare _A: () => A;
+  readonly [GuardTypeId]: GuardTypeId = GuardTypeId;
+  declare [GuardVariance]: {
+    readonly _A: (_: never) => A;
+  };
   constructor(readonly is: Refinement<unknown, A>) {}
 }
 

package/_src/data/Maybe/definition.ts

@@ -5,8 +5,11 @@ export const enum MaybeTag {
   Nothing = "Nothing",
 }
 
+export const MaybeVariance = Symbol.for("fncts.Maybe.Variance");
+export type MaybeVariance = typeof MaybeVariance;
+
 export const MaybeTypeId = Symbol.for("fncts.Maybe");
-export type MaybeTypdId = typeof MaybeTypeId;
+export type MaybeTypeId = typeof MaybeTypeId;
 
 export interface MaybeF extends HKT {
   type: Maybe<this["A"]>;
@@ -22,9 +25,11 @@ const _nothingHash = Hashable.string("fncts.Nothing");
  * @tsplus type fncts.Maybe
  * @tsplus companion fncts.MaybeOps
  */
-export class Maybe<A> {
-  declare _A: () => A;
-  readonly _typeId: MaybeTypdId = MaybeTypeId;
+export abstract class Maybe<A> {
+  declare [MaybeVariance]: {
+    readonly _A: (_: never) => A;
+  };
+  readonly [MaybeTypeId]: MaybeTypeId = MaybeTypeId;
 }
 
 /**
@@ -63,15 +68,7 @@ export class Nothing extends Maybe<never> {
  */
 export function unifyMaybe<X extends Maybe<any>>(
   self: X,
-): Maybe<
-  [X] extends [
-    {
-      _A: () => infer A;
-    },
-  ]
-    ? A
-    : never
-> {
+): Maybe<[X] extends [{ [MaybeVariance]: { _A: (_: never) => infer A } }] ? A : never> {
   return self;
 }
 
@@ -79,11 +76,7 @@ export function unifyMaybe<X extends Maybe<any>>(
  * @tsplus static fncts.MaybeOps isMaybe
  */
 export function isMaybe(u: unknown): u is Maybe<unknown> {
-  return (
-    isObject(u) &&
-    (MaybeTypeId in u ||
-      ("_tag" in u && typeof u["_tag"] === "string" && (u["_tag"] === "Nothing" || u["_tag"] === "Just")))
-  );
+  return isObject(u) && MaybeTypeId in u;
 }
 
 /**

package/_src/data/Tag/definition.ts

@@ -1,4 +1,5 @@
-import { AtomicNumber } from "@fncts/base/internal/AtomicNumber";
+export const TagVariance = Symbol.for("fncts.Tag.Variance");
+export type TagVariance = typeof TagVariance;
 
 export const TagTypeId = Symbol.for("fncts.Tag");
 export type TagTypeId = typeof TagTypeId;
@@ -12,8 +13,10 @@ const _tagHash = Hashable.string("fncts.Tag");
  * @tsplus companion fncts.TagOps
  */
 export class Tag<in out T> implements Hashable, Equatable {
-  declare _T: (_: T) => T;
-  readonly _typeId: TagTypeId = TagTypeId;
+  readonly [TagTypeId]: TagTypeId = TagTypeId;
+  declare [TagVariance]: {
+    readonly _T: (_: T) => T;
+  };
 
   constructor(readonly id: string) {}
 
@@ -27,5 +30,5 @@ export class Tag<in out T> implements Hashable, Equatable {
 }
 
 export function isTag(u: unknown): u is Tag<unknown> {
-  return hasTypeId(u, TagTypeId);
+  return isObject(u) && TagTypeId in u;
 }

package/_src/data/These/definition.ts

@@ -11,8 +11,8 @@ export type TheseTypeId = typeof TheseTypeId;
  * @tsplus type fncts.These.Left
  */
 export class Left<E> {
-  readonly _typeId: TheseTypeId = TheseTypeId;
-  readonly _tag                 = TheseTag.Left;
+  readonly [TheseTypeId]: TheseTypeId = TheseTypeId;
+  readonly _tag = TheseTag.Left;
   constructor(readonly left: E) {}
 }
 
@@ -20,8 +20,8 @@ export class Left<E> {
  * @tsplus type fncts.These.Right
  */
 export class Right<A> {
-  readonly _typeId: TheseTypeId = TheseTypeId;
-  readonly _tag                 = TheseTag.Right;
+  readonly [TheseTypeId]: TheseTypeId = TheseTypeId;
+  readonly _tag = TheseTag.Right;
   constructor(readonly right: A) {}
 }
 
@@ -29,8 +29,8 @@ export class Right<A> {
  * @tsplus type fncts.These.Both
  */
 export class Both<E, A> {
-  readonly _typeId: TheseTypeId = TheseTypeId;
-  readonly _tag                 = TheseTag.Both;
+  readonly [TheseTypeId]: TheseTypeId = TheseTypeId;
+  readonly _tag = TheseTag.Both;
   constructor(readonly left: E, readonly right: A) {}
 }
 
@@ -50,5 +50,5 @@ export const These: TheseOps = {};
  * @tsplus static fncts.TheseOps isThese
  */
 export function isThese(u: unknown): u is These<unknown, unknown> {
-  return hasTypeId(u, TheseTypeId);
+  return isObject(u) && TheseTypeId in u;
 }

package/_src/data/exceptions/InterruptedException.ts

@@ -1,13 +1,11 @@
-import { hasTypeId } from "../../util/predicates.js";
-
 export const InterruptedExceptionTypeId = Symbol.for("fncts.InterruptedException");
 export type InterruptedExceptionTypeId = typeof InterruptedExceptionTypeId;
 
 export class InterruptedException {
-  readonly _typeId: InterruptedExceptionTypeId = InterruptedExceptionTypeId;
+  readonly [InterruptedExceptionTypeId]: InterruptedExceptionTypeId = InterruptedExceptionTypeId;
   constructor(readonly message?: string) {}
 }
 
 export function isInterruptedException(u: unknown): u is InterruptedException {
-  return hasTypeId(u, InterruptedExceptionTypeId);
+  return isObject(u) && InterruptedExceptionTypeId in u;
 }

package/_src/data.ts

@@ -6,6 +6,7 @@ export type {} from "./data/Byte.js";
 export type {} from "./data/CaseClass.js";
 export type {} from "./data/Cause.js";
 export type {} from "./data/Const.js";
+export type {} from "./data/DatumEither.js";
 export type {} from "./data/DecodeError.js";
 export type {} from "./data/Decoder.js";
 export type {} from "./data/Duration.js";

package/_src/util/predicates.ts

@@ -45,9 +45,9 @@ export function hasTypeId<X extends symbol>(
   value: unknown,
   typeId: X,
 ): value is {
-  readonly _typeId: X;
+  readonly [K in X]: X;
 } & Record<PropertyKey, unknown> {
-  return isObject(value) && "_typeId" in value && value["_typeId"] === typeId;
+  return isObject(value) && typeId in value;
 }
 
 export function isFunction(value: unknown): value is Function {

package/collection/immutable/Conc/definition.d.ts

@@ -32,14 +32,14 @@ export interface ConcF extends HKT {
  */
 export declare abstract class Conc<A> implements Iterable<A>, Hashable, Equatable {
     _A: () => A;
-    readonly _typeId: ConcTypeId;
+    readonly [ConcTypeId]: ConcTypeId;
     abstract readonly length: number;
     abstract [Symbol.iterator](): Iterator<A>;
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
 }
 declare abstract class ConcImplementation<A> implements Iterable<A> {
-    readonly _typeId: ConcTypeId;
+    readonly [ConcTypeId]: ConcTypeId;
     _A: () => A;
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;

package/collection/immutable/HashMap/definition.d.ts

@@ -12,21 +12,25 @@ export interface HashMapF extends HKT {
     };
     index: this["K"];
 }
-export declare const TypeId: unique symbol;
-export type TypeId = typeof TypeId;
+export declare const HashMapVariance: unique symbol;
+export type HashMapVariance = typeof HashMapVariance;
+export declare const HashMapTypeId: unique symbol;
+export type HashMapTypeId = typeof HashMapTypeId;
 /**
  * @tsplus type fncts.HashMap
  * @tsplus companion fncts.HashMapOps
  */
-export declare class HashMap<K, V> implements Iterable<readonly [K, V]>, Hashable, Equatable {
+export declare class HashMap<in out K, in out V> implements Iterable<readonly [K, V]>, Hashable, Equatable {
     editable: boolean;
     edit: number;
     readonly config: HashEq<K>;
     root: Node<K, V>;
     size: number;
-    readonly _typeId: TypeId;
-    _K: () => K;
-    _A: () => V;
+    readonly [HashMapTypeId]: HashMapTypeId;
+    [HashMapVariance]: {
+        readonly _K: (_: K) => K;
+        readonly _A: (_: V) => V;
+    };
     constructor(editable: boolean, edit: number, config: HashEq<K>, root: Node<K, V>, size: number);
     [Symbol.iterator](): Iterator<readonly [K, V]>;
     get [Symbol.hash](): number;

package/collection/immutable/HashSet/definition.d.ts

@@ -1,12 +1,14 @@
 import { Hashable } from "@fncts/base/data/Hashable";
 import * as P from "@fncts/base/typeclass";
-export declare const TypeId: unique symbol;
-export type TypeId = typeof TypeId;
+export declare const HashSetVariance: unique symbol;
+export type HashSetVariance = typeof HashSetVariance;
+export declare const HashSetTypeId: unique symbol;
+export type HashSetTypeId = typeof HashSetTypeId;
 /**
  * @tsplus type fncts.HashSet
  * @tsplus companion fncts.HashSetOps
  */
-export declare class HashSet<A> implements Iterable<A>, P.Hashable, P.Equatable {
+export declare class HashSet<in out A> implements Iterable<A>, P.Hashable, P.Equatable {
     /**
      * @internal
      */
@@ -27,7 +29,10 @@ export declare class HashSet<A> implements Iterable<A>, P.Hashable, P.Equatable
      * @internal
      */
     _size: number;
-    readonly _typeId: TypeId;
+    readonly [HashSetTypeId]: HashSetTypeId;
+    [HashSetVariance]: {
+        readonly _A: (_: A) => A;
+    };
     constructor(
     /**
      * @internal

package/collection/immutable/ImmutableArray/definition.d.ts

@@ -1,6 +1,8 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { Equatable } from "@fncts/base/data/Equatable";
 import { Hashable } from "@fncts/base/data/Hashable";
+export declare const ImmutableArrayVariance: unique symbol;
+export type ImmutableArrayVariance = typeof ImmutableArrayVariance;
 export declare const ImmutableArrayTypeId: unique symbol;
 export type ImmutableArrayTypeId = typeof ImmutableArrayTypeId;
 export interface ImmutableArrayF extends HKT {
@@ -16,8 +18,10 @@ export interface ImmutableArrayF extends HKT {
  */
 export declare class ImmutableArray<A> implements Equatable, Hashable, Iterable<A> {
     readonly _array: ReadonlyArray<A>;
-    readonly _typeId: ImmutableArrayTypeId;
-    readonly _A: () => A;
+    readonly [ImmutableArrayTypeId]: ImmutableArrayTypeId;
+    [ImmutableArrayVariance]: {
+        readonly _A: (_: never) => A;
+    };
     constructor(_array: ReadonlyArray<A>);
     [Symbol.equals](that: unknown): boolean;
     get [Symbol.hash](): number;

package/collection/immutable/RoseTree/definition.d.ts

@@ -2,6 +2,8 @@ import { HKT } from "@fncts/typelevel/HKT";
 import { Hashable } from "@fncts/base/data/Hashable";
 import { Equatable } from "@fncts/base/data/Equatable";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
+export declare const RoseTreeVariance: unique symbol;
+export type RoseTreeVariance = typeof RoseTreeVariance;
 export declare const RoseTreeTypeId: unique symbol;
 export type RoseTreeTypeId = typeof RoseTreeTypeId;
 export interface RoseTreeF extends HKT {
@@ -17,8 +19,10 @@ export interface RoseTreeF extends HKT {
 export declare class RoseTree<A> implements Hashable, Equatable {
     readonly value: A;
     readonly forest: Vector<RoseTree<A>>;
-    readonly _typeId: RoseTreeTypeId;
-    _A: () => A;
+    readonly [RoseTreeTypeId]: RoseTreeTypeId;
+    [RoseTreeVariance]: {
+        readonly _A: (_: never) => A;
+    };
     constructor(value: A, forest: Vector<RoseTree<A>>);
     [Symbol.equals](that: unknown): boolean;
     get [Symbol.hash](): number;

package/collection/immutable/SortedMap/definition.d.ts

@@ -10,7 +10,7 @@ export type TypeId = typeof TypeId;
 export declare class SortedMap<K, V> implements SortedMapIterable<K, V> {
     readonly ord: Ord<K>;
     readonly root: RBNode<K, V>;
-    readonly _typeId: TypeId;
+    readonly [TypeId]: TypeId;
     constructor(ord: Ord<K>, root: RBNode<K, V>);
     [Symbol.iterator](): SortedMapIterator<K, V>;
 }

package/collection/immutable/Vector/definition.d.ts

@@ -2,6 +2,8 @@ import { HKT } from "@fncts/typelevel/HKT";
 import { Hashable } from "@fncts/base/data/Hashable";
 import { Equatable } from "@fncts/base/data/Equatable";
 import type { Node } from "@fncts/base/collection/immutable/Vector/internal";
+export declare const VectorVariance: unique symbol;
+export type VectorVariance = typeof VectorVariance;
 export declare const VectorTypeId: unique symbol;
 export type VectorTypeId = typeof VectorTypeId;
 export interface VectorF extends HKT {
@@ -29,8 +31,10 @@ export declare class Vector<A> implements Iterable<A> {
     readonly root: Node | undefined;
     /** @private */
     readonly suffix: A[];
-    readonly _typeId: VectorTypeId;
-    readonly _A: () => A;
+    readonly [VectorTypeId]: VectorTypeId;
+    [VectorVariance]: {
+        readonly _A: (_: never) => A;
+    };
     constructor(
     /** @private */
     bits: number, 
@@ -50,8 +54,10 @@ export declare class Vector<A> implements Iterable<A> {
  * @tsplus type fncts.MutableVector
  */
 export interface MutableVector<A> {
-    readonly _typeId: VectorTypeId;
-    readonly _A: () => A;
+    readonly [VectorTypeId]: VectorTypeId;
+    readonly [VectorVariance]: {
+        readonly _A: (_: never) => A;
+    };
     bits: number;
     offset: number;
     length: number;