@fncts/base 0.0.22 → 0.0.24

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;

package/control/Eval/definition.d.ts

@@ -1,4 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
+export declare const EvalVariance: unique symbol;
+export type EvalVariance = typeof EvalVariance;
 export declare const EvalTypeId: unique symbol;
 export type EvalTypeId = typeof EvalTypeId;
 export interface EvalF extends HKT {
@@ -11,8 +13,10 @@ export interface EvalF extends HKT {
  * @tsplus type fncts.control.Eval
  */
 export interface Eval<A> {
-    readonly _typeId: EvalTypeId;
-    readonly _A: () => A;
+    readonly [EvalTypeId]: EvalTypeId;
+    readonly [EvalVariance]: {
+        readonly _A: (_: never) => A;
+    };
 }
 /**
  * @tsplus type fncts.control.EvalOps
@@ -28,13 +32,18 @@ export declare const enum EvalTag {
 export declare class Value<A> implements Eval<A> {
     readonly value: A;
     readonly _tag = EvalTag.Value;
-    readonly _typeId: EvalTypeId;
-    readonly _A: () => A;
+    readonly [EvalTypeId]: EvalTypeId;
+    [EvalVariance]: {
+        readonly _A: (_: never) => A;
+    };
     constructor(value: A);
 }
 export declare class Defer<A> implements Eval<A> {
     readonly make: () => Eval<A>;
-    readonly _typeId: EvalTypeId;
+    readonly [EvalTypeId]: EvalTypeId;
+    [EvalVariance]: {
+        readonly _A: (_: never) => A;
+    };
     readonly _tag = EvalTag.Defer;
     readonly _A: () => A;
     constructor(make: () => Eval<A>);
@@ -42,9 +51,11 @@ export declare class Defer<A> implements Eval<A> {
 export declare class Chain<A, B> implements Eval<B> {
     readonly self: Eval<A>;
     readonly f: (a: A) => Eval<B>;
-    readonly _typeId: EvalTypeId;
+    readonly [EvalTypeId]: EvalTypeId;
+    [EvalVariance]: {
+        readonly _A: (_: never) => B;
+    };
     readonly _tag = EvalTag.Chain;
-    readonly _A: () => B;
     constructor(self: Eval<A>, f: (a: A) => Eval<B>);
 }
 type Concrete = Value<any> | Defer<any> | Chain<any, any>;

package/control/Z/definition.d.ts

@@ -12,6 +12,8 @@ export interface ZF extends HKT {
         A: "+";
     };
 }
+export declare const ZVariance: unique symbol;
+export type ZVariance = typeof ZVariance;
 export declare const ZTypeId: unique symbol;
 export type ZTypeId = typeof ZTypeId;
 /**
@@ -28,13 +30,15 @@ export type ZTypeId = typeof ZTypeId;
  * @tsplus companion fncts.control.ZOps
  */
 export declare abstract class Z<W, S1, S2, R, E, A> {
-    readonly _typeId: ZTypeId;
-    readonly _W: () => W;
-    readonly _S1: (_: S1) => void;
-    readonly _S2: () => S2;
-    readonly _R: () => R;
-    readonly _E: () => E;
-    readonly _A: () => A;
+    readonly [ZTypeId]: ZTypeId;
+    [ZVariance]: {
+        readonly _W: (_: never) => W;
+        readonly _S1: (_: S1) => void;
+        readonly _S2: (_: never) => S2;
+        readonly _R: (_: never) => R;
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
 }
 /**
  * @tsplus unify fncts.control.Z
@@ -141,7 +145,7 @@ export declare const ZErrorTypeId: unique symbol;
 export type ZErrorTypeId = typeof ZErrorTypeId;
 export declare class ZError<E> {
     readonly cause: Cause<E>;
-    readonly _typeId: ZErrorTypeId;
+    readonly [ZErrorTypeId]: ZErrorTypeId;
     constructor(cause: Cause<E>);
 }
 export declare function isZError(u: unknown): u is ZError<unknown>;

package/data/Cause/api.d.ts

@@ -194,6 +194,18 @@ export declare function isInterrupt<E>(self: Cause<E>): self is Interrupt;
  * @tsplus location "@fncts/base/data/Cause/api"
  */
 export declare function isInterrupted<E>(self: Cause<E>): boolean;
+/**
+ * Determines if the `Cause` contains only interruptions and not any `Die` or
+ * `Fail` causes.
+ * @tsplus getter fncts.Cause isInterruptedOnly
+ * @tsplus location "@fncts/base/data/Cause/api"
+ */
+export declare function isInterruptedOnly<E>(self: Cause<E>): boolean;
+/**
+ * @tsplus getter fncts.Cause isFailure
+ * @tsplus location "@fncts/base/data/Cause/api"
+ */
+export declare function isFailure<E>(self: Cause<E>): boolean;
 /**
  * A type-guard matching `Traced`
  * @tsplus getter fncts.Cause isTraced

package/data/Cause/definition.d.ts

@@ -4,6 +4,8 @@ import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { List } from "@fncts/base/collection/immutable/List/definition";
 import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
+export declare const CauseVariance: unique symbol;
+export type CauseVariance = typeof CauseVariance;
 export declare const CauseTypeId: unique symbol;
 export type CauseTypeId = typeof CauseTypeId;
 /**
@@ -30,8 +32,10 @@ export declare const enum CauseTag {
  * @tsplus companion fncts.Cause.EmptyOps
  */
 export declare class Empty {
-    readonly _E: () => never;
     readonly [CauseTypeId]: CauseTypeId;
+    [CauseVariance]: {
+        readonly _E: (_: never) => never;
+    };
     readonly _tag = CauseTag.Empty;
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
@@ -44,8 +48,10 @@ export declare const _Empty: Empty;
 export declare class Fail<E> {
     readonly value: E;
     readonly trace: Trace;
-    readonly _E: () => E;
     readonly [CauseTypeId]: CauseTypeId;
+    [CauseVariance]: {
+        readonly _E: (_: never) => E;
+    };
     readonly _tag = CauseTag.Fail;
     constructor(value: E, trace: Trace);
     get [Symbol.hash](): number;
@@ -58,8 +64,10 @@ export declare class Fail<E> {
 export declare class Halt {
     readonly value: unknown;
     readonly trace: Trace;
-    readonly _E: () => never;
     readonly [CauseTypeId]: CauseTypeId;
+    [CauseVariance]: {
+        readonly _E: (_: never) => never;
+    };
     readonly _tag = CauseTag.Halt;
     constructor(value: unknown, trace: Trace);
     get [Symbol.hash](): number;
@@ -72,8 +80,10 @@ export declare class Halt {
 export declare class Interrupt {
     readonly id: FiberId;
     readonly trace: Trace;
-    readonly _E: () => never;
     readonly [CauseTypeId]: CauseTypeId;
+    [CauseVariance]: {
+        readonly _E: (_: never) => never;
+    };
     readonly _tag = CauseTag.Interrupt;
     constructor(id: FiberId, trace: Trace);
     get [Symbol.hash](): number;
@@ -86,8 +96,10 @@ export declare class Interrupt {
 export declare class Then<E> {
     readonly left: Cause<E>;
     readonly right: Cause<E>;
-    readonly _E: () => E;
     readonly [CauseTypeId]: CauseTypeId;
+    [CauseVariance]: {
+        readonly _E: (_: never) => E;
+    };
     readonly _tag = CauseTag.Then;
     constructor(left: Cause<E>, right: Cause<E>);
     get [Symbol.hash](): number;
@@ -100,8 +112,10 @@ export declare class Then<E> {
 export declare class Both<E> {
     readonly left: Cause<E>;
     readonly right: Cause<E>;
-    readonly _E: () => E;
     readonly [CauseTypeId]: CauseTypeId;
+    [CauseVariance]: {
+        readonly _E: (_: never) => E;
+    };
     readonly _tag = CauseTag.Both;
     constructor(left: Cause<E>, right: Cause<E>);
     get [Symbol.hash](): number;
@@ -114,8 +128,10 @@ export declare class Both<E> {
 export declare class Stackless<E> {
     readonly cause: Cause<E>;
     readonly stackless: boolean;
-    readonly _E: () => E;
     readonly [CauseTypeId]: CauseTypeId;
+    [CauseVariance]: {
+        readonly _E: (_: never) => E;
+    };
     readonly _tag = CauseTag.Stackless;
     constructor(cause: Cause<E>, stackless: boolean);
     get [Symbol.hash](): number;

package/data/Datum/definition.d.ts

@@ -31,6 +31,7 @@ export declare const Datum: DatumOps;
  */
 export declare class Initial implements Hashable, Equatable {
     readonly _tag = DatumTag.Initial;
+    readonly [DatumTypeId]: DatumTypeId;
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
 }
@@ -39,7 +40,7 @@ export declare class Initial implements Hashable, Equatable {
  * @tsplus companion fncts.Datum.PendingOps
  */
 export declare class Pending implements Hashable, Equatable {
-    readonly _typeId: DatumTypeId;
+    readonly [DatumTypeId]: DatumTypeId;
     readonly _tag = DatumTag.Pending;
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
@@ -50,7 +51,7 @@ export declare class Pending implements Hashable, Equatable {
  */
 export declare class Refresh<A> implements Hashable, Equatable {
     readonly value: A;
-    readonly _typeId: DatumTypeId;
+    readonly [DatumTypeId]: DatumTypeId;
     readonly _tag = DatumTag.Refresh;
     constructor(value: A);
     get [Symbol.hash](): number;
@@ -62,7 +63,7 @@ export declare class Refresh<A> implements Hashable, Equatable {
  */
 export declare class Replete<A> implements Hashable, Equatable {
     readonly value: A;
-    readonly _typeId: DatumTypeId;
+    readonly [DatumTypeId]: DatumTypeId;
     readonly _tag = DatumTag.Replete;
     constructor(value: A);
     get [Symbol.hash](): number;

package/data/DatumEither/definition.d.ts

@@ -10,7 +10,6 @@ export interface DatumEitherF extends HKT {
 }
 /**
  * @tsplus type fncts.DatumEither
- * @tsplus no-inherit fncts.Datum
  */
 export type DatumEither<E, A> = Datum<Either<E, A>>;
 /**

package/data/DatumEither.d.ts

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

package/data/DecodeError/definition.d.ts

@@ -5,7 +5,7 @@ import type { Literal } from "@fncts/typelevel/Any";
 export declare const DecodeErrorTypeId: unique symbol;
 export type DecodeErrorTypeId = typeof DecodeErrorTypeId;
 export declare abstract class DecodeError {
-    readonly _typeId: DecodeErrorTypeId;
+    readonly [DecodeErrorTypeId]: DecodeErrorTypeId;
     abstract render: Eval<RoseTree<string>>;
 }
 export declare class RequiredKeyError extends DecodeError {

package/data/Decoder/definition.d.ts

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

package/data/Duration/definition.d.ts

@@ -8,7 +8,7 @@ export type DurationTypeId = typeof DurationTypeId;
  */
 export declare class Duration implements Equatable, Hashable {
     readonly milliseconds: number;
-    readonly _typeId: DurationTypeId;
+    readonly [DurationTypeId]: DurationTypeId;
     constructor(milliseconds: number);
     [Symbol.equals](that: unknown): boolean;
     get [Symbol.hash](): number;

package/data/Either/definition.d.ts

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

package/data/EitherT/api.d.ts

@@ -32,7 +32,7 @@ export declare function leftF<F extends HKT, FC>(F: P.Functor<F, FC>): <K, Q, W,
  * @tsplus static fncts.EitherTOps map
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function map<F extends HKT, FC>(F: P.Functor<F, FC>): <A, B>(f: (a: A) => B) => <K, Q, W, X, I, S, R, FE, E>(self: import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E, A>>) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E, B>>;
+export declare function map<F extends HKT, FC>(F: P.Functor<F, FC>): <A, B>(f: (a: A) => B) => <K, Q, W, X, I, S, R, FE, E>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, B>;
 /**
  * @tsplus static fncts.EitherTOps mapLeft
  * @tsplus location "@fncts/base/data/EitherT/api"
@@ -47,7 +47,7 @@ export declare function bimap<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>)
  * @tsplus static fncts.EitherTOps flatMap
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>): <K, Q, W, X, I, S, R, FE, A, K1, Q1, W1, X1, I1, S1, R1, FE1, E1, B>(f: (a: A) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "K", K, K1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "Q", Q, Q1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "W", W, W1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "X", X, X1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "I", I, I1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "S", S, S1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "R", R, R1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "E", FE, FE1>, import("../Either.js").Either<E1, B>>) => <E>(self: import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E, A>>) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "K", [K, K1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "Q", [Q, Q1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "W", [W, W1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "X", [X, X1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "I", [I, I1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "S", [S, S1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "R", [R, R1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "E", [FE, FE1]>, import("../Either.js").Either<E1 | E, B>>;
+export declare function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>): <K, Q, W, X, I, S, R, FE, A, K1, Q1, W1, X1, I1, S1, R1, FE1, E1, B>(f: (a: A) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "K", K, K1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "Q", Q, Q1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "W", W, W1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "X", X, X1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "I", I, I1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "S", S, S1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "R", R, R1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "E", FE, FE1>, import("../Either.js").Either<E1, B>>) => <E>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<F, FC, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "K", [K, K1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "Q", [Q, Q1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "W", [W, W1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "X", [X, X1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "I", [I, I1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "S", [S, S1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "R", [R, R1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "E", [FE, FE1]>, E1 | E, B>;
 /**
  * @tsplus static fncts.EitherTOps zipWith
  * @tsplus location "@fncts/base/data/EitherT/api"

package/data/Encoder/definition.d.ts

@@ -8,7 +8,7 @@ export type EncoderTypeId = typeof EncoderTypeId;
  */
 export declare class Encoder<in out A> {
     readonly encode: (inp: A) => unknown;
-    readonly _typeId: EncoderTypeId;
+    readonly [EncoderTypeId]: EncoderTypeId;
     constructor(encode: (inp: A) => unknown);
 }
 export interface EncoderF extends HKT {

package/data/Environment/api.d.ts

@@ -34,11 +34,6 @@ export declare function make(): Environment<never>;
  * @tsplus location "@fncts/base/data/Environment/api"
  */
 export declare function union<R1>(that: Environment<R1>): <R>(self: import("./definition").Environment<R>) => import("./definition").Environment<R & R1>;
-/**
- * @tsplus getter fncts.Environment clean
- * @tsplus location "@fncts/base/data/Environment/api"
- */
-export declare function clean<R>(self: Environment<R>): Environment<R>;
 /**
  * @tsplus pipeable fncts.Environment unsafeGet
  * @tsplus location "@fncts/base/data/Environment/api"

package/data/Environment/definition.d.ts

@@ -3,12 +3,10 @@ import { Equatable } from "@fncts/base/data/Equatable";
 import { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { Tag } from "@fncts/base/data/Tag/definition";
 import type { EnvironmentPatch } from "@fncts/base/data/EnvironmentPatch";
-/**
- * @tsplus static fncts.prelude.builtin.SymbolOps env
- * @tsplus location "@fncts/base/data/Environment/definition"
- */
-export declare const EnvSymbol: unique symbol;
-export type EnvSymbol = typeof EnvSymbol;
+export declare const EnvironmentVariance: unique symbol;
+export type EnvironmentVariance = typeof EnvironmentVariance;
+export declare const EnvironmentTypeId: unique symbol;
+export type EnvironmentTypeId = typeof EnvironmentTypeId;
 /**
  * @tsplus type fncts.Environment
  * @tsplus companion fncts.EnvironmentOps
@@ -16,8 +14,10 @@ export type EnvSymbol = typeof EnvSymbol;
 export declare class Environment<R> implements Hashable, Equatable {
     readonly map: HashMap<Tag<any>, unknown>;
     cache: HashMap<Tag<any>, unknown>;
-    readonly _typeId: EnvSymbol;
-    readonly [EnvSymbol]: (_: never) => R;
+    readonly [EnvironmentTypeId]: EnvironmentTypeId;
+    [EnvironmentVariance]: {
+        _R: (_: never) => R;
+    };
     constructor(map: HashMap<Tag<any>, unknown>, cache?: HashMap<Tag<any>, unknown>);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;

package/data/EnvironmentPatch.d.ts

@@ -9,6 +9,8 @@ export declare const enum EnvironmentPatchTag {
     Combine = 3,
     Empty = 4
 }
+export declare const EnvironmentPatchVariance: unique symbol;
+export type EnvironmentPatchVariance = typeof EnvironmentPatchVariance;
 export declare const EnvironmentPatchTypeId: unique symbol;
 export type EnvironmentPatchTypeId = typeof EnvironmentPatchTypeId;
 /**
@@ -16,9 +18,11 @@ export type EnvironmentPatchTypeId = typeof EnvironmentPatchTypeId;
  * @tsplus companion fncts.Environment.PatchOps
  */
 export declare abstract class EnvironmentPatch<In, Out> {
-    readonly _typeId: EnvironmentPatchTypeId;
-    readonly _R: (_: In) => void;
-    readonly _A: () => Out;
+    readonly [EnvironmentPatchTypeId]: EnvironmentPatchTypeId;
+    [EnvironmentPatchVariance]: {
+        readonly _R: (_: In) => void;
+        readonly _A: (_: never) => Out;
+    };
 }
 export declare class AddService<Env, Service> extends EnvironmentPatch<Env, Env & Has<Service>> {
     readonly service: Service;

package/data/Exit/definition.d.ts

@@ -1,6 +1,8 @@
 import { Cause } from "@fncts/base/data/Cause/definition";
 import { Hashable } from "@fncts/base/data/Hashable";
 import * as P from "../../typeclass.js";
+export declare const ExitVariance: unique symbol;
+export type ExitVariance = typeof ExitVariance;
 export declare const ExitTypeId: unique symbol;
 export type ExitTypeId = typeof ExitTypeId;
 /**
@@ -23,9 +25,11 @@ export declare const enum ExitTag {
  */
 export declare class Failure<E> {
     readonly cause: Cause<E>;
-    readonly _E: () => E;
-    readonly _A: () => never;
-    readonly _typeId: ExitTypeId;
+    readonly [ExitTypeId]: ExitTypeId;
+    [ExitVariance]: {
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => never;
+    };
     readonly _tag = ExitTag.Failure;
     constructor(cause: Cause<E>);
     get [Symbol.hash](): number;
@@ -37,9 +41,11 @@ export declare class Failure<E> {
  */
 export declare class Success<A> implements P.Hashable, P.Equatable {
     readonly value: A;
-    readonly _E: () => never;
-    readonly _A: () => A;
-    readonly _typeId: ExitTypeId;
+    readonly [ExitTypeId]: ExitTypeId;
+    [ExitVariance]: {
+        readonly _E: (_: never) => never;
+        readonly _A: (_: never) => A;
+    };
     readonly _tag = ExitTag.Success;
     constructor(value: A);
     get [Symbol.hash](): number;

package/data/FiberId/definition.d.ts

@@ -4,7 +4,7 @@ import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 export declare const FiberIdTypeId: unique symbol;
 export type FiberIdTypeId = typeof FiberIdTypeId;
 export declare class None implements Hashable, Equatable {
-    readonly _typeId: FiberIdTypeId;
+    readonly [FiberIdTypeId]: FiberIdTypeId;
     readonly _tag = "None";
     [Symbol.equals](that: unknown): boolean;
     get [Symbol.hash](): number;
@@ -13,7 +13,7 @@ export declare class Runtime implements Hashable, Equatable {
     readonly id: number;
     readonly startTime: number;
     readonly location?: string | undefined;
-    readonly _typeId: FiberIdTypeId;
+    readonly [FiberIdTypeId]: FiberIdTypeId;
     readonly _tag = "Runtime";
     constructor(id: number, startTime: number, location?: string | undefined);
     get [Symbol.hash](): number;
@@ -21,7 +21,7 @@ export declare class Runtime implements Hashable, Equatable {
 }
 export declare class Composite implements Hashable, Equatable {
     readonly fiberIds: HashSet<Runtime>;
-    readonly _typeId: FiberIdTypeId;
+    readonly [FiberIdTypeId]: FiberIdTypeId;
     readonly _tag = "Composite";
     constructor(fiberIds: HashSet<Runtime>);
     [Symbol.equals](that: unknown): boolean;

package/data/Guard/definition.d.ts

@@ -3,6 +3,8 @@ import { Refinement } from "@fncts/base/data/Refinement/definition";
 export interface GuardF extends HKT {
     readonly type: Guard<this["A"]>;
 }
+export declare const GuardVariance: unique symbol;
+export type GuardVariance = typeof GuardVariance;
 export declare const GuardTypeId: unique symbol;
 export type GuardTypeId = typeof GuardTypeId;
 /**
@@ -11,8 +13,10 @@ export type GuardTypeId = typeof GuardTypeId;
  */
 export declare class Guard<A> {
     readonly is: Refinement<unknown, A>;
-    readonly _typeId: GuardTypeId;
-    _A: () => A;
+    readonly [GuardTypeId]: GuardTypeId;
+    [GuardVariance]: {
+        readonly _A: (_: never) => A;
+    };
     constructor(is: Refinement<unknown, A>);
 }
 /**

package/data/Maybe/definition.d.ts

@@ -5,8 +5,10 @@ export declare const enum MaybeTag {
     Just = "Just",
     Nothing = "Nothing"
 }
+export declare const MaybeVariance: unique symbol;
+export type MaybeVariance = typeof MaybeVariance;
 export declare const MaybeTypeId: unique symbol;
-export type MaybeTypdId = typeof MaybeTypeId;
+export type MaybeTypeId = typeof MaybeTypeId;
 export interface MaybeF extends HKT {
     type: Maybe<this["A"]>;
     variance: {
@@ -17,9 +19,11 @@ export interface MaybeF extends HKT {
  * @tsplus type fncts.Maybe
  * @tsplus companion fncts.MaybeOps
  */
-export declare class Maybe<A> {
-    _A: () => A;
-    readonly _typeId: MaybeTypdId;
+export declare abstract class Maybe<A> {
+    [MaybeVariance]: {
+        readonly _A: (_: never) => A;
+    };
+    readonly [MaybeTypeId]: MaybeTypeId;
 }
 /**
  * @tsplus type fncts.Just
@@ -44,13 +48,11 @@ export declare class Nothing extends Maybe<never> {
 /**
  * @tsplus unify fncts.Maybe
  */
-export declare function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[
-    X
-] extends [
-    {
-        _A: () => infer A;
-    }
-] ? A : never>;
+export declare function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[X] extends [{
+    [MaybeVariance]: {
+        _A: (_: never) => infer A;
+    };
+}] ? A : never>;
 /**
  * @tsplus static fncts.MaybeOps isMaybe
  * @tsplus location "@fncts/base/data/Maybe/definition"

package/data/Struct.d.ts

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