@fncts/base 0.0.12 → 0.0.13

package/_src/collection/immutable/Vector/api.ts

@@ -1,6 +1,6 @@
 /* eslint-disable prefer-const */
 import type { MutableVector, VectorF } from "@fncts/base/collection/immutable/Vector/definition";
-import type { Eq, Monoid, Ord, Ordering, Traversable, TraversableWithIndex } from "@fncts/base/typeclass";
+import type { Eq, Monoid, Ord, Ordering, Traversable } from "@fncts/base/typeclass";
 
 import {
   affixPush,
@@ -48,6 +48,7 @@ import {
   updateNode,
   zeroOffset,
 } from "@fncts/base/collection/immutable/Vector/internal";
+import { TraversableWithIndex } from "@fncts/base/typeclass";
 
 /**
  * Appends an element to the end of a Vector and returns the new Vector.
@@ -1201,27 +1202,22 @@ export function toList<A>(self: Vector<A>): List<A> {
 }
 
 /**
- * @tsplus fluent fncts.Vector traverseWithIndex
+ * @tsplus getter fncts.Vector traverseWithIndex
  */
-export const traverseWithIndex: TraversableWithIndex<VectorF>["traverseWithIndex"] = (self, f, G) => {
+export const traverseWithIndex = TraversableWithIndex.makeTraverseWithIndex<VectorF>()(() => (self) => (G) => (f) => {
   return self.foldLeftWithIndex(G.pure(Vector.emptyPushable()), (i, b, a) =>
-    b.zipWith(
-      f(i, a),
-      (v, b) => {
-        push(v, b);
-        return v;
-      },
-      G,
-    ),
+    G.zipWith(b, f(i, a), (v, b) => {
+      push(v, b);
+      return v;
+    }),
   );
-};
+});
 
 /**
- * @tsplus fluent fncts.Vector traverse
+ * @tsplus getter fncts.Vector traverse
  */
-export const traverse: Traversable<VectorF>["traverse"] = (self, f, G) => {
-  return self.traverseWithIndex((_, a) => f(a));
-};
+export const traverse: Traversable<VectorF>["traverse"] = (self) => (G) => (f) =>
+  self.traverseWithIndex(G)((_, a) => f(a));
 
 /**
  * Returns a new Vector without repeated elements by using the given

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

@@ -8,7 +8,13 @@ import { ForwardVectorIterator } from "@fncts/base/collection/immutable/Vector/i
 export const VectorTypeId = Symbol.for("fncts.Vector");
 export type VectorTypeId = typeof VectorTypeId;
 
-export interface VectorF extends Vector<any> {}
+export interface VectorF extends HKT {
+  type: Vector<this["A"]>;
+  variance: {
+    A: "+";
+  };
+  index: number;
+}
 
 /**
  * Represents a Vector of elements.
@@ -18,10 +24,7 @@ export interface VectorF extends Vector<any> {}
  */
 export class Vector<A> implements Iterable<A> {
   readonly _typeId: VectorTypeId = VectorTypeId;
-  readonly [HKT.F]!: VectorF;
-  readonly [HKT.A]!: () => A;
-  readonly [HKT.T]!: Vector<HKT._A<this>>;
-  readonly [HKT.Ix]!: number;
+  readonly _A!: () => A;
   constructor(
     /** @private */
     readonly bits: number,
@@ -54,10 +57,7 @@ export class Vector<A> implements Iterable<A> {
  */
 export interface MutableVector<A> {
   readonly _typeId: VectorTypeId;
-  readonly [HKT.F]: VectorF;
-  readonly [HKT.A]: () => A;
-  readonly [HKT.T]: Vector<HKT._A<this>>;
-  readonly [HKT.Ix]: number;
+  readonly _A: () => A;
   bits: number;
   offset: number;
   length: number;

package/_src/collection/weak/IterableWeakMap.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus type fncts.IterableWeakMap
  */
-export class IterableWeakMap<K extends object, V> implements Iterable<readonly [K, V]> {
+export class IterableWeakMap<K extends object, V> implements Iterable<readonly [K, V]>, Map<K, V> {
   private weakMap           = new WeakMap<K, { value: V; ref: WeakRef<K> }>();
   private refSet            = new Set<WeakRef<K>>();
   private finalizationGroup = new FinalizationRegistry<{ ref: WeakRef<K>; set: Set<WeakRef<K>> }>(
@@ -44,11 +44,48 @@ export class IterableWeakMap<K extends object, V> implements Iterable<readonly [
     return true;
   }
 
-  [Symbol.iterator](this: this): IterableIterator<readonly [K, V]> {
+  has(this: this, key: K): boolean {
+    return this.weakMap.has(key);
+  }
+
+  clear(): void {
+    for (const ref of this.refSet) {
+      const key = ref.deref();
+      if (!key) continue;
+      const entry = this.weakMap.get(key)!;
+      this.weakMap.delete(key);
+      this.refSet.delete(entry.ref);
+      this.finalizationGroup.unregister(entry.ref);
+    }
+    this.refSet.clear();
+  }
+
+  forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: IterableWeakMap<K, V>): void {
+    thisArg = thisArg ?? this;
+    for (const kv of this) {
+      callbackfn(kv[1], kv[0], thisArg);
+    }
+  }
+
+  get size(): number {
+    let n = 0;
+    for (const ref of this.refSet) {
+      const key = ref.deref();
+      if (!key) continue;
+      n++;
+    }
+    return n;
+  }
+
+  [Symbol.iterator](this: this): IterableIterator<[K, V]> {
     return this.entries();
   }
 
-  *entries(this: this): IterableIterator<readonly [K, V]> {
+  get [Symbol.toStringTag](): string {
+    return this.weakMap[Symbol.toStringTag];
+  }
+
+  *entries(this: this): IterableIterator<[K, V]> {
     for (const ref of this.refSet) {
       const key = ref.deref();
       if (!key) continue;
@@ -57,7 +94,15 @@ export class IterableWeakMap<K extends object, V> implements Iterable<readonly [
     }
   }
 
-  has(this: this, key: K): boolean {
-    return this.weakMap.has(key);
+  *keys(this: this): IterableIterator<K> {
+    for (const [key] of this) {
+      yield key;
+    }
+  }
+
+  *values(): IterableIterator<V> {
+    for (const [, value] of this) {
+      yield value;
+    }
   }
 }

package/_src/collection/weak/IterableWeakSet.ts

@@ -1,7 +1,7 @@
 /**
  * @tsplus type fncts.IterableWeakSet
  */
-export class IterableWeakSet<A extends object> implements Iterable<A> {
+export class IterableWeakSet<A extends object> implements Iterable<A>, Set<A> {
   private weakMap           = new WeakMap<A, { ref: WeakRef<A> }>();
   private refSet            = new Set<WeakRef<A>>();
   private finalizationGroup = new FinalizationRegistry<{ ref: WeakRef<A>; set: Set<WeakRef<A>> }>(
@@ -12,9 +12,11 @@ export class IterableWeakSet<A extends object> implements Iterable<A> {
     set.delete(ref);
   }
 
-  constructor(iterable: Iterable<A>) {
-    for (const value of iterable) {
-      this.add(value);
+  constructor(iterable?: Iterable<A>) {
+    if (iterable) {
+      for (const value of iterable) {
+        this.add(value);
+      }
     }
   }
 
@@ -35,14 +37,52 @@ export class IterableWeakSet<A extends object> implements Iterable<A> {
 
     this.weakMap.delete(value);
     this.refSet.delete(entry.ref);
+    this.finalizationGroup.unregister(entry.ref);
     return true;
   }
 
-  [Symbol.iterator](this: this): IterableIterator<A> {
-    return this.entries();
+  has(this: this, value: A): boolean {
+    return this.weakMap.has(value);
+  }
+
+  keys(): IterableIterator<A> {
+    return this[Symbol.iterator]();
+  }
+
+  values(): IterableIterator<A> {
+    return this[Symbol.iterator]();
+  }
+
+  forEach(f: (value: A, value2: A, set: Set<A>) => void, thisArg?: Set<A>): void {
+    thisArg = thisArg ?? this;
+    for (const value of this) {
+      f(value, value, thisArg);
+    }
   }
 
-  *entries(this: this): IterableIterator<A> {
+  clear(): void {
+    for (const ref of this.refSet) {
+      const key = ref.deref();
+      if (!key) continue;
+      const entry = this.weakMap.get(key)!;
+      this.weakMap.delete(key);
+      this.refSet.delete(entry.ref);
+      this.finalizationGroup.unregister(entry.ref);
+    }
+    this.refSet.clear();
+  }
+
+  get size(): number {
+    let n = 0;
+    for (const ref of this.refSet) {
+      const value = ref.deref();
+      if (!value) continue;
+      n++;
+    }
+    return n;
+  }
+
+  *[Symbol.iterator](this: this): IterableIterator<A> {
     for (const ref of this.refSet) {
       const key = ref.deref();
       if (!key) continue;
@@ -50,7 +90,15 @@ export class IterableWeakSet<A extends object> implements Iterable<A> {
     }
   }
 
-  has(this: this, value: A): boolean {
-    return this.weakMap.has(value);
+  get [Symbol.toStringTag]() {
+    return this.refSet[Symbol.toStringTag];
+  }
+
+  *entries(this: this): IterableIterator<[A, A]> {
+    for (const ref of this.refSet) {
+      const key = ref.deref();
+      if (!key) continue;
+      yield [key, key];
+    }
   }
 }

package/_src/control/Eval/api.ts

@@ -38,8 +38,11 @@ export function zipWith_<A, B, C>(self: Eval<A>, fb: Eval<B>, f: (a: A, b: B) =>
   return self.flatMap((a) => fb.map((b) => f(a, b)));
 }
 
-export function zip_<A, B>(self: Eval<A>, fb: Eval<B>): Eval<readonly [A, B]> {
-  return self.zipWith(fb, tuple);
+/**
+ * @tsplus fluent fncts.control.Eval zip
+ */
+export function zip_<A, B>(self: Eval<A>, fb: Eval<B>): Eval<Zipped.Make<A, B>> {
+  return self.zipWith(fb, (a, b) => Zipped(a, b));
 }
 
 /**

package/_src/control/Eval/definition.ts

@@ -1,16 +1,19 @@
 export const EvalTypeId = Symbol.for("@fncts.base/control/Eval");
 export type EvalTypeId = typeof EvalTypeId;
 
-export interface EvalF extends Eval<any> {}
+export interface EvalF extends HKT {
+  type: Eval<this["A"]>;
+  variance: {
+    A: "+";
+  };
+}
 
 /**
  * @tsplus type fncts.control.Eval
  */
 export interface Eval<A> {
   readonly _typeId: EvalTypeId;
-  [HKT.F]?: EvalF;
-  [HKT.A]?: () => A;
-  [HKT.T]?: Eval<HKT._A<this>>;
+  readonly _A: () => A;
 }
 
 /**

package/_src/control/Eval/instance.ts

@@ -1,32 +1,32 @@
 import type { EvalF } from "@fncts/base/control/Eval/definition";
 import type * as P from "@fncts/base/typeclass";
 
-import { ap_, map_, zip_, zipWith_ } from "@fncts/base/control/Eval/api";
+import { map_, zip_, zipWith_ } from "@fncts/base/control/Eval/api";
 import { now } from "@fncts/base/control/Eval/constructors";
 
 /**
  * @tsplus static fncts.control.EvalOps Functor
  * @tsplus implicit
  */
-export const Functor: P.Functor<EvalF> = {
+export const Functor = HKT.instance<P.Functor<EvalF>>({
   map: map_,
-};
+});
 
 /**
  * @tsplus static fncts.control.EvalOps Apply
  * @tsplus implicit
  */
-export const Apply: P.Apply<EvalF> = {
+export const Apply = HKT.instance<P.Apply<EvalF>>({
   map: map_,
   zip: zip_,
   zipWith: zipWith_,
-};
+});
 
 /**
  * @tsplus static fncts.control.EvalOps Applicative
  * @tsplus implicit
  */
-export const Applicative: P.Applicative<EvalF> = {
+export const Applicative = HKT.instance<P.Applicative<EvalF>>({
   ...Apply,
   pure: now,
-};
+});

package/_src/control/Z/api.ts

@@ -1,17 +1,5 @@
 import { identity, tuple } from "../../data/function.js";
-import {
-  Chain,
-  Defer,
-  Environment,
-  Fail,
-  MapLog,
-  Match,
-  Modify,
-  Provide,
-  Succeed,
-  SucceedNow,
-  Tell,
-} from "./definition.js";
+import { Access, Chain, Defer, Fail, MapLog, Match, Modify, Provide, Succeed, SucceedNow, Tell } from "./definition.js";
 
 /**
  * @tsplus getter fncts.control.Z absolve
@@ -101,9 +89,9 @@ export function flatMap_<W, S1, S2, R, E, A, W1, S3, R1, E1, B>(
  */
 export function contramapEnvironment_<R0, W, S1, S2, R, E, A>(
   ma: Z<W, S1, S2, R, E, A>,
-  f: (r0: R0) => R,
+  f: (r0: Environment<R0>) => Environment<R>,
 ): Z<W, S1, S2, R0, E, A> {
-  return Z.environmentWithZ((r: R0) => ma.provideEnvironment(f(r)));
+  return Z.environmentWithZ((r) => ma.provideEnvironment(f(r)));
 }
 
 /**
@@ -164,24 +152,24 @@ export function either<W, S1, S2, R, E, A>(fa: Z<W, S1, S2, R, E, A>): Z<W, S1,
 /**
  * @tsplus static fncts.control.ZOps environment
  */
-export function environment<R>(): Z<never, unknown, never, R, never, R> {
-  return new Environment((r: R) => Z.succeedNow(r));
+export function environment<R>(): Z<never, unknown, never, R, never, Environment<R>> {
+  return new Access((r) => Z.succeedNow(r));
 }
 
 /**
  * @tsplus static fncts.control.ZOps environmentWith
  */
-export function environmentWith<R0, A>(f: (r: R0) => A): Z<never, unknown, never, R0, never, A> {
-  return new Environment((r: R0) => succeed(f(r)));
+export function environmentWith<R0, A>(f: (r: Environment<R0>) => A): Z<never, unknown, never, R0, never, A> {
+  return new Access((r) => succeed(f(r)));
 }
 
 /**
  * @tsplus static fncts.control.ZOps environmentWithZ
  */
 export function environmentWithZ<R0, W, S1, S2, R, E, A>(
-  f: (r: R0) => Z<W, S1, S2, R, E, A>,
-): Z<W, S1, S2, R & R0, E, A> {
-  return new Environment(f);
+  f: (r: Environment<R0>) => Z<W, S1, S2, R, E, A>,
+): Z<W, S1, S2, R | R0, E, A> {
+  return new Access(f);
 }
 
 /**
@@ -454,7 +442,10 @@ export function orElseEither_<W, S1, S2, R, E, A, S3, S4, R1, E1, A1>(
 /**
  * @tsplus fluent fncts.control.Z provideEnvironment
  */
-export function provideEnvironment_<W, S1, S2, R, E, A>(fa: Z<W, S1, S2, R, E, A>, r: R): Z<W, S1, S2, unknown, E, A> {
+export function provideEnvironment_<W, S1, S2, R, E, A>(
+  fa: Z<W, S1, S2, R, E, A>,
+  r: Environment<R>,
+): Z<W, S1, S2, never, E, A> {
   return new Provide(fa, r);
 }
 
@@ -583,8 +574,8 @@ export function writeAll_<W, S1, S2, R, E, A, W1>(
 export function zip_<W, S1, S2, R, E, A, W1, S3, Q, D, B>(
   fa: Z<W, S1, S2, R, E, A>,
   fb: Z<W1, S2, S3, Q, D, B>,
-): Z<W | W1, S1, S3, Q & R, D | E, readonly [A, B]> {
-  return fa.zipWith(fb, tuple);
+): Z<W | W1, S1, S3, Q & R, D | E, Zipped.Make<A, B>> {
+  return fa.zipWith(fb, (a, b) => Zipped(a, b));
 }
 
 /**

package/_src/control/Z/definition.ts

@@ -1,8 +1,15 @@
 import { hasTypeId } from "../../util/predicates.js";
 
-export interface ZF extends Z<any, any, any, any, any, any> {}
-
-export interface ZFixedF extends ZFixed<any, any, any, any, any> {}
+export interface ZF extends HKT {
+  type: Z<this["W"], this["S"], this["S"], this["R"], this["E"], this["A"]>;
+  variance: {
+    W: "+";
+    S: "_";
+    R: "-";
+    E: "+";
+    A: "+";
+  };
+}
 
 export const ZTypeId = Symbol.for("@principia/base/Z");
 export type ZTypeId = typeof ZTypeId;
@@ -22,26 +29,12 @@ export type ZTypeId = typeof ZTypeId;
  */
 export abstract class Z<W, S1, S2, R, E, A> {
   readonly _typeId: ZTypeId = ZTypeId;
-  readonly [HKT.F]!: ZF;
-  readonly [HKT.W]!: () => W;
-  readonly [HKT.Q]!: (_: S1) => void;
-  readonly [HKT.S]!: () => S2;
-  readonly [HKT.R]!: (_: R) => void;
-  readonly [HKT.E]!: () => E;
-  readonly [HKT.A]!: () => A;
-  readonly [HKT.T]!: Z<HKT._W<this>, HKT._Q<this>, HKT._S<this>, HKT._R<this>, HKT._E<this>, HKT._A<this>>;
-}
-
-export interface ZFixed<W, S, R, E, A> {
-  readonly _typeId: ZTypeId;
-  readonly [HKT.F]: ZF;
-  readonly [HKT.W]: () => W;
-  readonly [HKT.Q]: (_: S) => void;
-  readonly [HKT.S]: () => S;
-  readonly [HKT.R]: (_: R) => void;
-  readonly [HKT.E]: () => E;
-  readonly [HKT.A]: () => A;
-  readonly [HKT.T]: Z<HKT._W<this>, HKT._S<this>, HKT._S<this>, HKT._R<this>, HKT._E<this>, HKT._A<this>>;
+  readonly _W!: () => W;
+  readonly _S1!: (_: S1) => void;
+  readonly _S2!: () => S2;
+  readonly _R!: (_: R) => void;
+  readonly _E!: () => E;
+  readonly _A!: () => A;
 }
 
 /**
@@ -49,7 +42,14 @@ export interface ZFixed<W, S, R, E, A> {
  */
 export function unifyZ<X extends Z<any, any, any, any, any, any>>(
   _: X,
-): Z<HKT._W<X>, HKT._Q<X>, HKT._S<X>, HKT._R<X>, HKT._E<X>, HKT._A<X>> {
+): Z<
+  [X] extends [Z<infer W, any, any, any, any, any>] ? W : never,
+  [X] extends [Z<any, infer S1, any, any, any, any>] ? S1 : never,
+  [X] extends [Z<any, any, infer S2, any, any, any>] ? S2 : never,
+  [X] extends [Z<any, any, any, infer R, any, any>] ? R : never,
+  [X] extends [Z<any, any, any, any, infer E, any>] ? E : never,
+  [X] extends [Z<any, any, any, any, any, infer A>] ? A : never
+> {
   return _;
 }
 
@@ -68,7 +68,7 @@ export const enum ZTag {
   Modify = "Modify",
   Chain = "Chain",
   Match = "Match",
-  Environment = "Environment",
+  Access = "Access",
   Provide = "Provide",
   Tell = "Tell",
   Listen = "Listen",
@@ -135,16 +135,16 @@ export class Match<W, S1, S2, S5, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>
   }
 }
 
-export class Environment<W, R0, S1, S2, R, E, A> extends Z<W, S1, S2, R0 & R, E, A> {
-  readonly _tag = ZTag.Environment;
-  constructor(readonly asks: (r: R0) => Z<W, S1, S2, R, E, A>) {
+export class Access<W, R0, S1, S2, R, E, A> extends Z<W, S1, S2, R0 | R, E, A> {
+  readonly _tag = ZTag.Access;
+  constructor(readonly asks: (r: Environment<R0>) => Z<W, S1, S2, R, E, A>) {
     super();
   }
 }
 
-export class Provide<W, S1, S2, R, E, A> extends Z<W, S1, S2, unknown, E, A> {
+export class Provide<W, S1, S2, R, E, A> extends Z<W, S1, S2, never, E, A> {
   readonly _tag = ZTag.Provide;
-  constructor(readonly ma: Z<W, S1, S2, R, E, A>, readonly env: R) {
+  constructor(readonly ma: Z<W, S1, S2, R, E, A>, readonly env: Environment<R>) {
     super();
   }
 }
@@ -169,7 +169,7 @@ export type Concrete =
   | Modify<any, any, any>
   | Chain<any, any, any, any, any, any, any, any, any, any, any>
   | Match<any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any, any>
-  | Environment<any, any, any, any, any, any, any>
+  | Access<any, any, any, any, any, any, any>
   | Provide<any, any, any, any, any, any>
   | Defer<any, any, any, any, any, any>
   | Succeed<any>
@@ -179,6 +179,7 @@ export type Concrete =
 /**
  * @tsplus static fncts.control.ZOps concrete
  */
+// @ts-expect-error
 export function concrete(_: Z<any, any, any, any, any, any>): asserts _ is Concrete {
   //
 }

package/_src/control/Z/instances.ts

@@ -1,5 +1,5 @@
 import type * as P from "../../typeclass.js";
-import type { ZFixedF } from "./definition.js";
+import type { ZF } from "./definition.js";
 
 import { map_, succeedNow, zip_, zipWith_ } from "./api.js";
 
@@ -7,9 +7,9 @@ import { map_, succeedNow, zip_, zipWith_ } from "./api.js";
  * @tsplus static fncts.control.ZOps Applicative
  * @tsplus implicit
  */
-export const Applicative: P.Applicative<ZFixedF> = {
+export const Applicative = HKT.instance<P.Applicative<ZF>>({
   map: map_,
   zip: zip_,
   zipWith: zipWith_,
   pure: succeedNow,
-};
+});

package/_src/control/Z/runtime.ts

@@ -24,13 +24,13 @@ type Frame = MatchFrame | ApplyFrame;
  * @tsplus fluent fncts.control.Z unsafeRunAll
  */
 export function unsafeRunAll_<W, S1, S2, E, A>(
-  ma: Z<W, S1, S2, unknown, E, A>,
+  ma: Z<W, S1, S2, never, E, A>,
   s: S1,
 ): readonly [Conc<W>, Exit<E, readonly [S2, A]>] {
   const stack: Stack<Frame> = Stack();
   let s0                    = s as any;
   let result: any           = null;
-  const environment         = Stack<unknown>();
+  const environment         = Stack<Environment<unknown>>();
   let failed                = false;
   let current               = ma as Z<any, any, any, any, any, any> | undefined;
   let log                   = Conc.empty<W>();
@@ -141,8 +141,8 @@ export function unsafeRunAll_<W, S1, S2, E, A>(
             );
             break;
           }
-          case ZTag.Environment: {
-            current = currZ.asks(environment.peek() ?? {});
+          case ZTag.Access: {
+            current = currZ.asks(environment.peek() ?? Environment());
             break;
           }
           case ZTag.Provide: {
@@ -215,7 +215,7 @@ export function unsafeRunAll_<W, S1, S2, E, A>(
  *
  * @tsplus fluent fncts.control.Z unsafeRun
  */
-export function unsafeRun_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A>, s: S1): readonly [S2, A] {
+export function unsafeRun_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): readonly [S2, A] {
   return ma.unsafeRunAll(s)[1].match((cause) => {
     // throw cause.squash
     throw new Error();
@@ -227,7 +227,7 @@ export function unsafeRun_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A>, s:
  *
  * @tsplus getter fncts.control.Z unsafeRunResult
  */
-export function unsafeRunResult<W, A>(ma: Z<W, unknown, unknown, unknown, never, A>): A {
+export function unsafeRunResult<W, A>(ma: Z<W, unknown, unknown, never, never, A>): A {
   return unsafeRun_(ma, {})[1];
 }
 
@@ -236,7 +236,7 @@ export function unsafeRunResult<W, A>(ma: Z<W, unknown, unknown, unknown, never,
  *
  * @tsplus fluent fncts.control.Z unsafeRunReader
  */
-export function unsafeRunReader_<W, R, A>(ma: Z<W, unknown, never, R, never, A>, r: R): A {
+export function unsafeRunReader_<W, R, A>(ma: Z<W, unknown, never, R, never, A>, r: Environment<R>): A {
   return unsafeRunResult(ma.provideEnvironment(r));
 }
 

package/_src/data/Const/definition.ts

@@ -1,28 +1,20 @@
 /**
  * @tsplus type fncts.ConstF
  */
-export interface ConstF extends Const<any, any> {}
-
-/**
- * @tsplus type fncts.ConstF
- */
-export interface Const1F<E> extends Const1<E, any> {}
+export interface ConstF extends HKT {
+  type: Const<this["E"], this["A"]>;
+  variance: {
+    E: "_";
+    A: "+";
+  };
+}
 
 /**
  * @tsplus type fncts.Const
  * @tsplus companion fncts.ConstOps
  */
 export class Const<E, A> {
-  readonly [HKT.F]!: ConstF;
-  readonly [HKT.E]!: () => E;
-  readonly [HKT.A]!: () => A;
-  readonly [HKT.T]!: Const<HKT._E<this>, HKT._A<this>>;
+  readonly _E!: () => E;
+  readonly _A!: () => A;
   constructor(readonly getConst: E) {}
 }
-
-export interface Const1<E, A> {
-  readonly [HKT.F]: ConstF;
-  readonly [HKT.E]: () => E;
-  readonly [HKT.A]: () => A;
-  readonly [HKT.T]: Const<E, HKT._A<this>>;
-}