@fncts/base 0.0.12 → 0.0.15

package/_src/control/Eval/definition.ts

@@ -1,16 +1,19 @@
-export const EvalTypeId = Symbol.for("@fncts.base/control/Eval");
+export const EvalTypeId = Symbol.for("@fncts/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
@@ -72,7 +60,7 @@ export function bimap_<W, S1, S2, R, E, A, G, B>(
 export function catchAll_<W, S1, S2, R, E, A, S3, R1, E1, B>(
   fa: Z<W, S1, S2, R, E, A>,
   onFailure: (e: E) => Z<W, S1, S3, R1, E1, B>,
-): Z<W, S1, S3, R & R1, E1, A | B> {
+): Z<W, S1, S3, R | R1, E1, A | B> {
   return fa.matchZ(onFailure, Z.succeedNow);
 }
 
@@ -82,7 +70,7 @@ export function catchAll_<W, S1, S2, R, E, A, S3, R1, E1, B>(
 export function catchJust_<W, S1, S2, R, E, A, S3, R1, E1, B>(
   fa: Z<W, S1, S2, R, E, A>,
   f: (e: E) => Maybe<Z<W, S1, S3, R1, E1, B>>,
-): Z<W, S1, S2 | S3, R & R1, E | E1, A | B> {
+): Z<W, S1, S2 | S3, R | R1, E | E1, A | B> {
   return fa.catchAll((e) => f(e).getOrElse(fa));
 }
 
@@ -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);
 }
 
 /**
@@ -196,31 +184,28 @@ export function erase<W, S1, S2, R, E, A>(wa: Z<W, S1, S2, R, E, A>): Z<never, S
 /**
  * @tsplus static fncts.control.ZOps fail
  */
-export function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never> {
+export function fail<E>(e: Lazy<E>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never> {
   return Z.failCause(Cause.fail(e()));
 }
 
 /**
  * @tsplus static fncts.control.ZOps failNow
  */
-export function failNow<E>(e: E, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never> {
+export function failNow<E>(e: E, __tsplusTrace?: string): Z<never, unknown, never, never, E, never> {
   return Z.failCauseNow(Cause.fail(e));
 }
 
 /**
  * @tsplus static fncts.control.ZOps failCause
  */
-export function failCause<E>(
-  cause: Lazy<Cause<E>>,
-  __tsplusTrace?: string,
-): Z<never, unknown, never, unknown, E, never> {
+export function failCause<E>(cause: Lazy<Cause<E>>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never> {
   return Z.defer(Z.failCauseNow(cause()));
 }
 
 /**
  * @tsplus static fncts.control.ZOps failCauseNow
  */
-export function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Z<never, unknown, never, unknown, E, never> {
+export function failCauseNow<E>(cause: Cause<E>, __tsplusTrace?: string): Z<never, unknown, never, never, E, never> {
   return new Fail(cause);
 }
 
@@ -238,14 +223,14 @@ export function flatten<W, S1, S2, R, E, A, W1, S3, R1, E1>(
  *
  * @tsplus static fncts.control.ZOps get
  */
-export function get<S>(): Z<never, S, S, unknown, never, S> {
+export function get<S>(): Z<never, S, S, never, never, S> {
   return Z.modify((s) => [s, s]);
 }
 
 /**
  * @tsplus static fncts.control.ZOps gets
  */
-export function gets<S, A>(f: (s: S) => A): Z<never, S, S, unknown, never, A> {
+export function gets<S, A>(f: (s: S) => A): Z<never, S, S, never, never, A> {
   return Z.modify((s) => [f(s), s]);
 }
 
@@ -259,14 +244,14 @@ export function getsZ<S, W, R, E, A>(f: (s: S) => Z<W, S, S, R, E, A>): Z<W, S,
 /**
  * @tsplus static fncts.control.ZOps halt
  */
-export function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Z<never, unknown, never, unknown, never, never> {
+export function halt(defect: Lazy<unknown>, __tsplusTrace?: string): Z<never, unknown, never, never, never, never> {
   return Z.failCause(Cause.halt(defect()));
 }
 
 /**
  * @tsplus static fncts.control.ZOps haltNow
  */
-export function haltNow(defect: unknown, __tsplusTrace?: string): Z<never, unknown, never, unknown, never, never> {
+export function haltNow(defect: unknown, __tsplusTrace?: string): Z<never, unknown, never, never, never, never> {
   return Z.failCauseNow(Cause.halt(defect));
 }
 
@@ -353,7 +338,7 @@ export function matchZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E
   fa: Z<W, S1, S2, R, E, A>,
   onFailure: (e: E) => Z<W1, S5, S3, R1, E1, B>,
   onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>,
-): Z<W | W1 | W2, S1 & S5, S3 | S4, R & R1 & R2, E1 | E2, B | C> {
+): Z<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C> {
   return fa.matchCauseZ((cause) => cause.failureOrCause.match(onFailure, Z.failCauseNow), onSuccess);
 }
 
@@ -364,7 +349,7 @@ export function matchCauseZ_<W, S1, S2, R, E, A, W1, S0, S3, R1, E1, B, W2, S4,
   fa: Z<W, S1, S2, R, E, A>,
   onFailure: (e: Cause<E>) => Z<W1, S0, S3, R1, E1, B>,
   onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>,
-): Z<W | W1 | W2, S0 & S1, S3 | S4, R & R1 & R2, E1 | E2, B | C> {
+): Z<W | W1 | W2, S0 & S1, S3 | S4, R | R1 | R2, E1 | E2, B | C> {
   return matchLogCauseZ_(
     fa,
     (ws, e) => onFailure(e).mapLog((w1s) => ws.concat(w1s)),
@@ -379,7 +364,7 @@ export function matchLogZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2
   fa: Z<W, S1, S2, R, E, A>,
   onFailure: (ws: Conc<W>, e: E) => Z<W1, S5, S3, R1, E1, B>,
   onSuccess: (ws: Conc<W>, a: A) => Z<W2, S2, S4, R2, E2, C>,
-): Z<W | W1 | W2, S1 & S5, S3 | S4, R & R1 & R2, E1 | E2, B | C> {
+): Z<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C> {
   return matchLogCauseZ_(
     fa,
     (ws, cause) => cause.failureOrCause.match((e) => onFailure(ws, e), Z.failCauseNow),
@@ -410,7 +395,7 @@ export function matchLogCauseZ_<W, S1, S2, R, E, A, W1, S0, S3, R1, E1, B, W2, S
  *
  * @tsplus static fncts.control.ZOps modify
  */
-export function modify<S1, S2, A>(f: (s: S1) => readonly [A, S2]): Z<never, S1, S2, unknown, never, A> {
+export function modify<S1, S2, A>(f: (s: S1) => readonly [A, S2]): Z<never, S1, S2, never, never, A> {
   return new Modify(f);
 }
 
@@ -419,7 +404,7 @@ export function modify<S1, S2, A>(f: (s: S1) => readonly [A, S2]): Z<never, S1,
  *
  * @tsplus static fncts.control.ZOps modifyEither
  */
-export function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, readonly [A, S2]>): Z<never, S1, S2, unknown, E, A> {
+export function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, readonly [A, S2]>): Z<never, S1, S2, never, E, A> {
   return Z.get<S1>()
     .map(f)
     .flatMap((r) => r.match(Z.failNow, ([a, s2]) => Z.succeedNow(a).mapState(() => s2)));
@@ -431,7 +416,7 @@ export function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, readonly [A,
 export function orElse_<W, S1, S2, R, E, A, W1, S3, R1, E1, A1>(
   fa: Z<W, S1, S2, R, E, A>,
   fb: Lazy<Z<W1, S1, S3, R1, E1, A1>>,
-): Z<W | W1, S1, S2 | S3, R & R1, E | E1, A | A1> {
+): Z<W | W1, S1, S2 | S3, R | R1, E | E1, A | A1> {
   return fa.matchZ(() => fb(), Z.succeedNow);
 }
 
@@ -444,7 +429,7 @@ export function orElse_<W, S1, S2, R, E, A, W1, S3, R1, E1, A1>(
 export function orElseEither_<W, S1, S2, R, E, A, S3, S4, R1, E1, A1>(
   fa: Z<W, S1, S2, R, E, A>,
   that: Lazy<Z<W, S3, S4, R1, E1, A1>>,
-): Z<W, S1 & S3, S2 | S4, R & R1, E1, Either<A, A1>> {
+): Z<W, S1 & S3, S2 | S4, R | R1, E1, Either<A, A1>> {
   return fa.matchZ(
     () => that().map(Either.right),
     (a) => Z.succeedNow(Either.left(a)),
@@ -454,7 +439,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);
 }
 
@@ -463,7 +451,7 @@ export function provideEnvironment_<W, S1, S2, R, E, A>(fa: Z<W, S1, S2, R, E, A
  *
  * @tsplus static fncts.control.ZOps put
  */
-export function put<S>(s: S): Z<never, unknown, S, unknown, never, void> {
+export function put<S>(s: S): Z<never, unknown, S, never, never, void> {
   return Z.modify(() => [undefined, s]);
 }
 
@@ -496,7 +484,7 @@ export function repeatUntil_<W, S1, S2 extends S1, R, E, A>(
 export function succeed<A, W = never, S1 = unknown, S2 = never>(
   effect: Lazy<A>,
   __tsplusTrace?: string,
-): Z<W, S1, S2, unknown, never, A> {
+): Z<W, S1, S2, never, never, A> {
   return new Succeed(effect);
 }
 
@@ -506,7 +494,7 @@ export function succeed<A, W = never, S1 = unknown, S2 = never>(
 export function succeedNow<A, W = never, S1 = unknown, S2 = never>(
   a: A,
   __tsplusTrace?: string,
-): Z<W, S1, S2, unknown, never, A> {
+): Z<W, S1, S2, never, never, A> {
   return new SucceedNow(a);
 }
 
@@ -523,14 +511,14 @@ export function tap_<W, S1, S2, R, E, A, W1, S3, R1, E1, B>(
 /**
  * @tsplus static fncts.control.ZOps tell
  */
-export function tell<W>(w: W): Z<W, unknown, never, unknown, never, void> {
+export function tell<W>(w: W): Z<W, unknown, never, never, never, void> {
   return Z.tellAll(Conc.single(w));
 }
 
 /**
  * @tsplus static fncts.control.ZOps tellAll
  */
-export function tellAll<W>(ws: Conc<W>): Z<W, unknown, never, unknown, never, void> {
+export function tellAll<W>(ws: Conc<W>): Z<W, unknown, never, never, never, void> {
   return new Tell(ws);
 }
 
@@ -549,14 +537,14 @@ export function transform_<W, S1, S2, R, E, A, S3, B>(
 /**
  * @tsplus static fncts.control.ZOps unit
  */
-export const unit: Z<never, unknown, never, unknown, never, void> = Z.succeedNow(undefined);
+export const unit: Z<never, unknown, never, never, never, void> = Z.succeedNow(undefined);
 
 /**
  * Constructs a computation from the specified update function.
  *
  * @tsplus static fncts.control.ZOps update
  */
-export function update<S1, S2>(f: (s: S1) => S2): Z<never, S1, S2, unknown, never, void> {
+export function update<S1, S2>(f: (s: S1) => S2): Z<never, S1, S2, never, never, void> {
   return Z.modify((s) => [undefined, f(s)]);
 }
 
@@ -583,8 +571,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;
+  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,21 +68,21 @@ export const enum ZTag {
   Modify = "Modify",
   Chain = "Chain",
   Match = "Match",
-  Environment = "Environment",
+  Access = "Access",
   Provide = "Provide",
   Tell = "Tell",
   Listen = "Listen",
   MapLog = "MapLog",
 }
 
-export class SucceedNow<A> extends Z<never, unknown, never, unknown, never, A> {
+export class SucceedNow<A> extends Z<never, unknown, never, never, never, A> {
   readonly _tag = ZTag.SucceedNow;
   constructor(readonly value: A) {
     super();
   }
 }
 
-export class Succeed<A> extends Z<never, unknown, never, unknown, never, A> {
+export class Succeed<A> extends Z<never, unknown, never, never, never, A> {
   readonly _tag = ZTag.Succeed;
   constructor(readonly effect: () => A) {
     super();
@@ -96,14 +96,14 @@ export class Defer<W, S1, S2, R, E, A> extends Z<W, S1, S2, R, E, A> {
   }
 }
 
-export class Fail<E> extends Z<never, unknown, never, unknown, E, never> {
+export class Fail<E> extends Z<never, unknown, never, never, E, never> {
   readonly _tag = ZTag.Fail;
   constructor(readonly cause: Cause<E>) {
     super();
   }
 }
 
-export class Modify<S1, S2, A> extends Z<never, S1, S2, unknown, never, A> {
+export class Modify<S1, S2, A> extends Z<never, S1, S2, never, never, A> {
   readonly _tag = ZTag.Modify;
   constructor(readonly run: (s1: S1) => readonly [A, S2]) {
     super();
@@ -135,21 +135,21 @@ 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();
   }
 }
 
-export class Tell<W> extends Z<W, unknown, never, unknown, never, void> {
+export class Tell<W> extends Z<W, unknown, never, never, never, void> {
   readonly _tag = ZTag.Tell;
   constructor(readonly log: Conc<W>) {
     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>

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));
 }
 
@@ -246,7 +246,7 @@ export function unsafeRunReader_<W, R, A>(ma: Z<W, unknown, never, R, never, A>,
  *
  * @tsplus fluent fncts.control.Z unsafeRunState
  */
-export function unsafeRunState_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A>, s: S1): S2 {
+export function unsafeRunState_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): S2 {
   return ma.unsafeRun(s)[0];
 }
 
@@ -256,7 +256,7 @@ export function unsafeRunState_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A
  *
  * @tsplus fluent fncts.control.Z unsafeRunStateResult
  */
-export function unsafeRunStateResult_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, never, A>, s: S1): A {
+export function unsafeRunStateResult_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): A {
   return ma.unsafeRunAll(s)[1].match(
     (cause) => {
       // throw cause.squash
@@ -271,7 +271,7 @@ export function unsafeRunStateResult_<W, S1, S2, A>(ma: Z<W, S1, S2, unknown, ne
  *
  * @tsplus getter fncts.control.Z unsafeRunExit
  */
-export function unsafeRunExit<E, A>(ma: Z<never, unknown, unknown, unknown, E, A>): Exit<E, A> {
+export function unsafeRunExit<E, A>(ma: Z<never, unknown, unknown, never, E, A>): Exit<E, A> {
   return ma.unsafeRunAll({} as never)[1].map(([_, a]) => a);
 }
 
@@ -279,7 +279,7 @@ export function unsafeRunExit<E, A>(ma: Z<never, unknown, unknown, unknown, E, A
  *
  * @tsplus getter fncts.control.Z unsafeRunWriter
  */
-export function unsafeRunWriter<W, A>(ma: Z<W, unknown, unknown, unknown, never, A>): readonly [Conc<W>, A] {
+export function unsafeRunWriter<W, A>(ma: Z<W, unknown, unknown, never, never, A>): readonly [Conc<W>, A] {
   const [w, exit] = ma.unsafeRunAll({});
   return exit.match(
     () => {

package/_src/control.ts

@@ -0,0 +1,5 @@
+// codegen:start { preset: type-barrel, include: ./control/*.ts }
+export type {} from "./control/Eval.js";
+export type {} from "./control/LazyValue.js";
+export type {} from "./control/Z.js";
+// codegen:end

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>>;
-}