@fncts/typelevel 0.0.3 → 0.0.6

package/Check.d.ts

@@ -27,7 +27,7 @@ export declare namespace Check {
     /**
      * @tsplus type fncts.Check.Extends
      */
-    type Extends<A, B> = [A] extends [never] ? never : [A] extends [B] ? unknown : never;
+    type Extends<A, B> = [A] extends [B] ? unknown : never;
     /**
      * @tsplus type fncts.Check.IsUnion
      */
@@ -39,11 +39,11 @@ export declare namespace Check {
     /**
      * @tsplus type fncts.Check.IsLiteral
      */
-    type IsLiteral<A extends string | number> = Not<Extends<string, A> | Extends<number, A>>;
+    type IsLiteral<A extends string | number | boolean> = Not<Extends<string, A> | Extends<number, A> | Extends<boolean, A>>;
     /**
      * @tsplus type fncts.Check.IsStruct
      */
-    type IsStruct<A> = Extends<keyof A, string> & Not<IsUnion<A>>;
+    type IsStruct<A> = Check.Extends<keyof A, string> & Check.Not<Check.IsUnion<A>>;
     /**
      * @tsplus type fncts.Check.HaveSameLength
      */

package/HKT.d.ts

@@ -1,186 +1,149 @@
 import type * as Union from "./Union.js";
-export interface HKT {
-    readonly K?: unknown;
-    readonly Q?: unknown;
-    readonly W?: unknown;
-    readonly X?: unknown;
-    readonly I?: unknown;
-    readonly S?: unknown;
-    readonly R?: unknown;
-    readonly E?: unknown;
-    readonly A?: unknown;
-    readonly type?: unknown;
-    readonly index?: unknown;
-    readonly variance: {
-        readonly K?: HKT.Variance;
-        readonly Q?: HKT.Variance;
-        readonly W?: HKT.Variance;
-        readonly X?: HKT.Variance;
-        readonly I?: HKT.Variance;
-        readonly S?: HKT.Variance;
-        readonly R?: HKT.Variance;
-        readonly E?: HKT.Variance;
-        readonly A?: HKT.Variance;
-    };
-}
 export declare namespace HKT {
-    const URI: unique symbol;
-    const CURI: unique symbol;
-    export type Variance = "-" | "+" | "_";
-    export type VarianceOf<F extends HKT, N extends ParamName> = F["variance"][N];
-    export type CovariantE = HKT & {
-        readonly variance: {
-            E: "+";
-        };
-    };
-    export type ContravariantR = HKT & {
-        readonly variance: {
-            R: "-";
-        };
-    };
-    export interface Typeclass<F extends HKT, C = None> {
-        readonly [URI]: F;
-        readonly [CURI]: C;
-    }
-    export interface Typeclass2<F extends HKT, G extends HKT, C = None, D = None> {
-        readonly _F: F;
-        readonly _G: G;
-        readonly _CF: C;
-        readonly _CG: D;
-    }
-    export interface Compose2<F extends HKT, G extends HKT, C = None, D = None> extends HKT {
-        readonly type: Kind<F, C, this["K"], this["Q"], this["W"], this["X"], this["I"], this["S"], this["R"], this["E"], Kind<G, D, this["K"], this["Q"], this["W"], this["X"], this["I"], this["S"], this["R"], this["E"], this["A"]>>;
-    }
-    export interface FK<F, K, Q, W, X, I, S, R, E, A> {
-        readonly _F: F;
-        readonly _K: K;
-        readonly _Q: Q;
-        readonly _W: W;
-        readonly _X: X;
-        readonly _I: I;
-        readonly _S: S;
-        readonly _R: R;
-        readonly _E: E;
-        readonly _A: A;
-    }
-    export interface FK1<F, A> {
-        readonly _F: F;
-        readonly _K: unknown;
-        readonly _Q: unknown;
-        readonly _W: unknown;
-        readonly _X: unknown;
-        readonly _I: unknown;
-        readonly _S: unknown;
-        readonly _R: unknown;
-        readonly _E: unknown;
-        readonly _A: A;
-    }
-    export interface F<F> extends HKT {
-        readonly type: FK<F, this["K"], this["Q"], this["W"], this["X"], this["I"], this["S"], this["R"], this["E"], this["A"]>;
-        readonly variance: {
-            readonly K: "_";
-            readonly Q: "_";
-            readonly W: "_";
-            readonly X: "_";
-            readonly I: "_";
-            readonly S: "_";
-            readonly R: "_";
-            readonly E: "_";
-            readonly A: "_";
-        };
-    }
-    export interface FCoE<F> extends HKT {
-        readonly type: FK<F, this["K"], this["Q"], this["W"], this["X"], this["I"], this["S"], this["R"], this["E"], this["A"]>;
-        readonly variance: {
-            readonly K: "_";
-            readonly Q: "_";
-            readonly W: "_";
-            readonly X: "_";
-            readonly I: "_";
-            readonly S: "_";
-            readonly R: "_";
-            readonly E: "+";
-            readonly A: "_";
-        };
-    }
-    export interface FContraR<F> extends HKT {
-        readonly type: FK<F, this["K"], this["Q"], this["W"], this["X"], this["I"], this["S"], this["R"], this["E"], this["A"]>;
-        readonly variance: {
-            readonly K: "_";
-            readonly Q: "_";
-            readonly W: "_";
-            readonly X: "_";
-            readonly I: "_";
-            readonly S: "_";
-            readonly R: "-";
-            readonly E: "_";
-            readonly A: "_";
-        };
-    }
-    export type ParamName = "K" | "Q" | "W" | "X" | "I" | "S" | "R" | "E" | "A";
-    export type Kind<F extends HKT, C, K, Q, W, X, I, S, R, E, A> = F extends {
-        readonly type: unknown;
-    } ? (F & {
-        readonly K: OrFix<C, "K", K>;
-        readonly Q: OrFix<C, "Q", Q>;
-        readonly W: OrFix<C, "W", W>;
-        readonly X: OrFix<C, "X", X>;
-        readonly I: OrFix<C, "I", I>;
-        readonly S: OrFix<C, "S", S>;
-        readonly R: OrFix<C, "R", R>;
-        readonly E: OrFix<C, "E", E>;
-        readonly A: A;
-    })["type"] : FK<F, K, Q, W, X, I, S, R, E, A>;
-    export type Infer<F extends HKT, C, N extends ParamName | "C", K> = [K] extends [
-        Kind<F, C, infer K, infer Q, infer W, infer X, infer I, infer S, infer R, infer E, infer A>
-    ] ? N extends "C" ? C : N extends "K" ? K : N extends "Q" ? Q : N extends "W" ? W : N extends "X" ? X : N extends "I" ? I : N extends "S" ? S : N extends "R" ? R : N extends "E" ? E : N extends "A" ? A : never : never;
-    export interface Lows {
-        "-": unknown;
-        "+": never;
-        _: any;
-    }
-    export type Low<F extends HKT, N extends ParamName> = F["variance"][N] extends Variance ? Lows[F["variance"][N]] : never;
-    export interface Mixes<P extends ReadonlyArray<unknown>> {
-        "-": P extends [any] ? P[0] : P extends [any, any] ? P[0] & P[1] : P extends [any, any, any] ? P[0] & P[1] & P[2] : P extends [any, any, any, any] ? P[0] & P[1] & P[2] & P[3] : P extends [any, any, any, any, any] ? P[0] & P[1] & P[2] & P[3] & P[4] : Union.IntersectionOf<P[number]>;
-        "+": P[number];
-        _: P[0];
-    }
-    export type Mix<F extends HKT, N extends ParamName, P extends ReadonlyArray<unknown>> = F["variance"][N] extends Variance ? Mixes<P>[F["variance"][N]] : P[0];
-    export type OrNever<K> = unknown extends K ? never : K;
-    export type MixStruct<F extends HKT, N extends ParamName, X, Y> = F["variance"][N] extends "_" ? X : F["variance"][N] extends "+" ? Y[keyof Y] : F["variance"][N] extends "-" ? Union.IntersectionOf<{
-        [k in keyof Y]: OrNever<Y[k]>;
-    }[keyof Y]> : X;
-    export interface Intros<A, B> {
-        "-": B;
-        "+": B;
-        _: A;
-    }
-    export type Intro<F extends HKT, N extends ParamName, A, B> = F["variance"][N] extends Variance ? Intros<A, B>[F["variance"][N]] : A;
+    const F: unique symbol;
+    type F = typeof F;
+    const K: unique symbol;
+    type K = typeof K;
+    const Q: unique symbol;
+    type Q = typeof Q;
+    const W: unique symbol;
+    type W = typeof W;
+    const X: unique symbol;
+    type X = typeof X;
+    const I: unique symbol;
+    type I = typeof I;
+    const S: unique symbol;
+    type S = typeof S;
+    const R: unique symbol;
+    type R = typeof R;
+    const E: unique symbol;
+    type E = typeof E;
+    const A: unique symbol;
+    type A = typeof A;
+    const T: unique symbol;
+    type T = typeof T;
+    const Ix: unique symbol;
+    type Ix = typeof Ix;
+    const C: unique symbol;
+    type C = typeof C;
+    type _K<X extends HKT> = X extends {
+        [K]?: () => infer K;
+    } ? K : never;
+    type _Q<X extends HKT> = X extends {
+        [Q]?: (_: infer Q) => void;
+    } ? Q : never;
+    type _W<X extends HKT> = X extends {
+        [W]?: () => infer W;
+    } ? W : never;
+    type _X<X extends HKT> = X extends {
+        [X]?: () => infer X;
+    } ? X : never;
+    type _I<X extends HKT> = X extends {
+        [I]?: (_: infer I) => void;
+    } ? I : never;
+    type _S<X extends HKT> = X extends {
+        [S]?: () => infer S;
+    } ? S : never;
+    type _R<X extends HKT> = X extends {
+        [R]?: (_: infer R) => void;
+    } ? R : never;
+    type _E<X extends HKT> = X extends {
+        [E]?: () => infer E;
+    } ? E : never;
+    type _A<X extends HKT> = [X] extends [{
+        [A]?: () => infer A;
+    }] ? A : never;
+    type _Ix<X extends HKT> = X extends {
+        [Ix]?: infer Ix;
+    } ? Ix : never;
+    type IndexFor<X extends HKT, K> = X extends {
+        [Ix]?: infer Ix;
+    } ? Ix : K;
     /**
-     * Type parameter constraint
+     * @tsplus type fncts.Kind
      */
-    export type None = {};
-    const Fix: unique symbol;
-    export interface Fix<N extends ParamName, A> {
-        [Fix]: {
-            [K in N]: () => A;
-        };
-    }
-    const Extend: unique symbol;
-    export interface Extend<N extends ParamName, A> {
-        [Extend]: {
-            [K in N]: () => A;
-        };
-    }
-    export type OrFix<C, N extends ParamName, A> = C extends Fix<N, infer X> ? X : A;
-    export type OrExtend<C, N extends ParamName, A> = C extends Extend<N, infer X> ? A extends X ? A : X : A;
-    export type GetExtends<C, N extends ParamName, A> = C extends Extend<N, infer X> ? X : A;
-    export type IndexFor<F extends HKT, K> = F extends {
-        readonly index: unknown;
-    } ? F["index"] : K;
+    type Kind<F extends HKT, K, Q, W, X, I, S, R, E, A> = F & {
+        [F]?: F;
+        [K]?: () => K;
+        [Q]?: (_: Q) => void;
+        [W]?: () => W;
+        [X]?: () => X;
+        [I]?: (_: I) => void;
+        [S]?: () => S;
+        [R]?: (_: R) => void;
+        [E]?: () => E;
+        [A]?: () => A;
+    } extends {
+        [T]?: infer X;
+    } ? X : {
+        [F]?: F;
+        [K]?: () => K;
+        [Q]?: (_: Q) => void;
+        [W]?: () => W;
+        [X]?: () => X;
+        [I]?: (_: I) => void;
+        [S]?: () => S;
+        [R]?: (_: R) => void;
+        [E]?: () => E;
+        [A]?: () => A;
+    };
     /**
-     * @tsplus macro identity
+     * @tsplus type fncts.Typeclass
      */
-    export function instance<F>(_: Omit<F, typeof URI | typeof CURI | "_F" | "_G" | "_CF" | "_CG">): F;
-    export {};
+    interface Typeclass<F extends HKT> {
+        [HKT.F]?: F;
+    }
+    type ParamName = "K" | "Q" | "W" | "X" | "I" | "S" | "R" | "E" | "A";
+    type Mix<N extends ParamName, P extends ReadonlyArray<unknown>> = VarianceToMix<P>[ParamToVariance[N]];
+    type MixStruct<N extends ParamName, X, Y> = ParamToVariance[N] extends "_" ? X : ParamToVariance[N] extends "+" ? Y[keyof Y] : ParamToVariance[N] extends "-" ? Union.IntersectionOf<{
+        [K in keyof Y]: OrNever<Y[K]>;
+    }[keyof Y]> : X;
+    type Intro<N extends ParamName, A, B> = VarianceToIntro<A, B>[ParamToVariance[N]];
+    type Low<N extends ParamName> = VarianceToLow[ParamToVariance[N]];
+    type Infer<F extends HKT, N extends ParamName, K> = [K] extends [
+        Kind<F, infer K, infer Q, infer W, infer X, infer I, infer S, infer R, infer E, infer A>
+    ] ? N extends "K" ? K : N extends "Q" ? Q : N extends "W" ? W : N extends "X" ? X : N extends "I" ? I : N extends "S" ? S : N extends "R" ? R : N extends "E" ? E : N extends "A" ? A : never : never;
+    type ErasedKind<F extends HKT> = HKT.Kind<F, any, any, any, any, any, any, any, any, any>;
+}
+export interface HKT {
+    [HKT.F]?: HKT;
+    [HKT.K]?: () => unknown;
+    [HKT.Q]?: (_: never) => void;
+    [HKT.W]?: () => unknown;
+    [HKT.X]?: () => unknown;
+    [HKT.I]?: (_: never) => void;
+    [HKT.S]?: () => unknown;
+    [HKT.R]?: (_: never) => void;
+    [HKT.E]?: () => unknown;
+    [HKT.A]?: () => unknown;
+    [HKT.T]?: unknown;
+    [HKT.Ix]?: unknown;
+}
+interface VarianceToMix<P extends ReadonlyArray<unknown>> {
+    "-": P extends [any] ? P[0] : P extends [any, any] ? P[0] & P[1] : P extends [any, any, any] ? P[0] & P[1] & P[2] : P extends [any, any, any, any] ? P[0] & P[1] & P[2] & P[3] : P extends [any, any, any, any, any] ? P[0] & P[1] & P[2] & P[3] & P[4] : Union.IntersectionOf<P[number]>;
+    "+": P[number];
+    _: P[0];
+}
+interface VarianceToIntro<A, B> {
+    "-": B;
+    "+": B;
+    _: A;
+}
+interface VarianceToLow {
+    "-": unknown;
+    "+": never;
+    _: any;
+}
+interface ParamToVariance {
+    K: "_";
+    Q: "-";
+    W: "+";
+    X: "+";
+    I: "_";
+    S: "_";
+    R: "-";
+    E: "+";
+    A: "+";
 }
+declare type OrNever<K> = unknown extends K ? never : K;
+export {};

package/_cjs/HKT.cjs

@@ -4,23 +4,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.HKT = void 0;
-// eslint-disable-next-line @typescript-eslint/no-namespace
 var HKT;
 exports.HKT = HKT;
 
-(function (HKT) {
-  /*
-   * Instance util
-   */
-
-  /**
-   * @tsplus macro identity
-   */
-  function instance(_) {
-    // @ts-expect-error: typelevel utility
-    return _;
-  }
-
-  HKT.instance = instance;
-})(HKT || (exports.HKT = HKT = {}));
+(function (HKT) {})(HKT || (exports.HKT = HKT = {}));
 //# sourceMappingURL=HKT.cjs.map

package/_cjs/HKT.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"HKT.cjs","names":["HKT","instance","_"],"sources":["../esm/HKT.js"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-namespace\nexport var HKT;\n(function (HKT) {\n    /*\n     * Instance util\n     */\n    /**\n     * @tsplus macro identity\n     */\n    function instance(_) {\n        // @ts-expect-error: typelevel utility\n        return _;\n    }\n    HKT.instance = instance;\n})(HKT || (HKT = {}));\n"],"mappings":";;;;;;AAAA;AACO,IAAIA,GAAJ;;;AACP,CAAC,UAAUA,GAAV,EAAe;EACZ;AACJ;AACA;;EACI;AACJ;AACA;EACI,SAASC,QAAT,CAAkBC,CAAlB,EAAqB;IACjB;IACA,OAAOA,CAAP;EACH;;EACDF,GAAG,CAACC,QAAJ,GAAeA,QAAf;AACH,CAZD,EAYGD,GAAG,mBAAKA,GAAG,GAAG,EAAX,CAZN"}
+{"version":3,"file":"HKT.cjs","names":["HKT"],"sources":["../esm/HKT.js"],"sourcesContent":["export var HKT;\n(function (HKT) {\n})(HKT || (HKT = {}));\n"],"mappings":";;;;;;AAAO,IAAIA,GAAJ;;;AACP,CAAC,UAAUA,GAAV,EAAe,CACf,CADD,EACGA,GAAG,mBAAKA,GAAG,GAAG,EAAX,CADN"}

package/_mjs/HKT.mjs

@@ -1,19 +1,4 @@
-// eslint-disable-next-line @typescript-eslint/no-namespace
 export var HKT;
 
-(function (HKT) {
-  /*
-   * Instance util
-   */
-
-  /**
-   * @tsplus macro identity
-   */
-  function instance(_) {
-    // @ts-expect-error: typelevel utility
-    return _;
-  }
-
-  HKT.instance = instance;
-})(HKT || (HKT = {}));
+(function (HKT) {})(HKT || (HKT = {}));
 //# sourceMappingURL=HKT.mjs.map

package/_mjs/HKT.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"HKT.mjs","names":["HKT","instance","_"],"sources":["../esm/HKT.js"],"sourcesContent":["// eslint-disable-next-line @typescript-eslint/no-namespace\nexport var HKT;\n(function (HKT) {\n    /*\n     * Instance util\n     */\n    /**\n     * @tsplus macro identity\n     */\n    function instance(_) {\n        // @ts-expect-error: typelevel utility\n        return _;\n    }\n    HKT.instance = instance;\n})(HKT || (HKT = {}));\n"],"mappings":"AAAA;AACA,OAAO,IAAIA,GAAJ;;AACP,CAAC,UAAUA,GAAV,EAAe;EACZ;AACJ;AACA;;EACI;AACJ;AACA;EACI,SAASC,QAAT,CAAkBC,CAAlB,EAAqB;IACjB;IACA,OAAOA,CAAP;EACH;;EACDF,GAAG,CAACC,QAAJ,GAAeA,QAAf;AACH,CAZD,EAYGD,GAAG,KAAKA,GAAG,GAAG,EAAX,CAZN"}
+{"version":3,"file":"HKT.mjs","names":["HKT"],"sources":["../esm/HKT.js"],"sourcesContent":["export var HKT;\n(function (HKT) {\n})(HKT || (HKT = {}));\n"],"mappings":"AAAA,OAAO,IAAIA,GAAJ;;AACP,CAAC,UAAUA,GAAV,EAAe,CACf,CADD,EACGA,GAAG,KAAKA,GAAG,GAAG,EAAX,CADN"}

package/_src/Check.ts

@@ -36,7 +36,7 @@ export declare namespace Check {
   /**
    * @tsplus type fncts.Check.Extends
    */
-  type Extends<A, B> = [A] extends [never] ? never : [A] extends [B] ? unknown : never;
+  type Extends<A, B> = [A] extends [B] ? unknown : never;
 
   /**
    * @tsplus type fncts.Check.IsUnion
@@ -55,12 +55,12 @@ export declare namespace Check {
   /**
    * @tsplus type fncts.Check.IsLiteral
    */
-  type IsLiteral<A extends string | number> = Not<Extends<string, A> | Extends<number, A>>;
+  type IsLiteral<A extends string | number | boolean> = Not<Extends<string, A> | Extends<number, A> | Extends<boolean, A>>;
 
   /**
    * @tsplus type fncts.Check.IsStruct
    */
-  type IsStruct<A> = Extends<keyof A, string> & Not<IsUnion<A>>;
+  type IsStruct<A> = Check.Extends<keyof A, string> & Check.Not<Check.IsUnion<A>>;
 
   /**
    * @tsplus type fncts.Check.HaveSameLength

package/_src/HKT.ts

@@ -1,221 +1,103 @@
 import type * as Union from "./Union.js";
 
-export interface HKT {
-  readonly K?: unknown;
-  readonly Q?: unknown;
-  readonly W?: unknown;
-  readonly X?: unknown;
-  readonly I?: unknown;
-  readonly S?: unknown;
-  readonly R?: unknown;
-  readonly E?: unknown;
-  readonly A?: unknown;
-  readonly type?: unknown;
-
-  readonly index?: unknown;
-
-  readonly variance: {
-    readonly K?: HKT.Variance;
-    readonly Q?: HKT.Variance;
-    readonly W?: HKT.Variance;
-    readonly X?: HKT.Variance;
-    readonly I?: HKT.Variance;
-    readonly S?: HKT.Variance;
-    readonly R?: HKT.Variance;
-    readonly E?: HKT.Variance;
-    readonly A?: HKT.Variance;
-  };
-}
-
-// eslint-disable-next-line @typescript-eslint/no-namespace
 export namespace HKT {
-  declare const URI: unique symbol;
-  declare const CURI: unique symbol;
-
-  export type Variance = "-" | "+" | "_";
-
-  export type VarianceOf<F extends HKT, N extends ParamName> = F["variance"][N];
-
-  export type CovariantE = HKT & {
-    readonly variance: {
-      E: "+";
-    };
-  };
-
-  export type ContravariantR = HKT & {
-    readonly variance: {
-      R: "-";
-    };
-  };
+  export declare const F: unique symbol;
+  export type F = typeof F;
+  export declare const K: unique symbol;
+  export type K = typeof K;
+  export declare const Q: unique symbol;
+  export type Q = typeof Q;
+  export declare const W: unique symbol;
+  export type W = typeof W;
+  export declare const X: unique symbol;
+  export type X = typeof X;
+  export declare const I: unique symbol;
+  export type I = typeof I;
+  export declare const S: unique symbol;
+  export type S = typeof S;
+  export declare const R: unique symbol;
+  export type R = typeof R;
+  export declare const E: unique symbol;
+  export type E = typeof E;
+  export declare const A: unique symbol;
+  export type A = typeof A;
+  export declare const T: unique symbol;
+  export type T = typeof T;
+  export declare const Ix: unique symbol;
+  export type Ix = typeof Ix;
+  export declare const C: unique symbol;
+  export type C = typeof C;
+
+  export type _K<X extends HKT> = X extends { [K]?: () => infer K } ? K : never;
+  export type _Q<X extends HKT> = X extends { [Q]?: (_: infer Q) => void } ? Q : never;
+  export type _W<X extends HKT> = X extends { [W]?: () => infer W } ? W : never;
+  export type _X<X extends HKT> = X extends { [X]?: () => infer X } ? X : never;
+  export type _I<X extends HKT> = X extends { [I]?: (_: infer I) => void } ? I : never;
+  export type _S<X extends HKT> = X extends { [S]?: () => infer S } ? S : never;
+  export type _R<X extends HKT> = X extends { [R]?: (_: infer R) => void } ? R : never;
+  export type _E<X extends HKT> = X extends { [E]?: () => infer E } ? E : never;
+  export type _A<X extends HKT> = [X] extends [{ [A]?: () => infer A }] ? A : never;
+
+  export type _Ix<X extends HKT> = X extends { [Ix]?: infer Ix } ? Ix : never;
+
+  export type IndexFor<X extends HKT, K> = X extends { [Ix]?: infer Ix } ? Ix : K;
 
-  export interface Typeclass<F extends HKT, C = None> {
-    readonly [URI]: F;
-    readonly [CURI]: C;
-  }
-
-  export interface Typeclass2<F extends HKT, G extends HKT, C = None, D = None> {
-    readonly _F: F;
-    readonly _G: G;
-    readonly _CF: C;
-    readonly _CG: D;
-  }
-
-  export interface Compose2<F extends HKT, G extends HKT, C = None, D = None> extends HKT {
-    readonly type: Kind<
-      F,
-      C,
-      this["K"],
-      this["Q"],
-      this["W"],
-      this["X"],
-      this["I"],
-      this["S"],
-      this["R"],
-      this["E"],
-      Kind<
-        G,
-        D,
-        this["K"],
-        this["Q"],
-        this["W"],
-        this["X"],
-        this["I"],
-        this["S"],
-        this["R"],
-        this["E"],
-        this["A"]
-      >
-    >;
-  }
-
-  export interface FK<F, K, Q, W, X, I, S, R, E, A> {
-    readonly _F: F;
-    readonly _K: K;
-    readonly _Q: Q;
-    readonly _W: W;
-    readonly _X: X;
-    readonly _I: I;
-    readonly _S: S;
-    readonly _R: R;
-    readonly _E: E;
-    readonly _A: A;
-  }
+  /**
+   * @tsplus type fncts.Kind
+   */
+  export type Kind<F extends HKT, K, Q, W, X, I, S, R, E, A> = F & {
+    [F]?: F;
+    [K]?: () => K;
+    [Q]?: (_: Q) => void;
+    [W]?: () => W;
+    [X]?: () => X;
+    [I]?: (_: I) => void;
+    [S]?: () => S;
+    [R]?: (_: R) => void;
+    [E]?: () => E;
+    [A]?: () => A;
+  } extends { [T]?: infer X }
+    ? X
+    : {
+        [F]?: F;
+        [K]?: () => K;
+        [Q]?: (_: Q) => void;
+        [W]?: () => W;
+        [X]?: () => X;
+        [I]?: (_: I) => void;
+        [S]?: () => S;
+        [R]?: (_: R) => void;
+        [E]?: () => E;
+        [A]?: () => A;
+      };
 
-  export interface FK1<F, A> {
-    readonly _F: F;
-    readonly _K: unknown;
-    readonly _Q: unknown;
-    readonly _W: unknown;
-    readonly _X: unknown;
-    readonly _I: unknown;
-    readonly _S: unknown;
-    readonly _R: unknown;
-    readonly _E: unknown;
-    readonly _A: A;
+  /**
+   * @tsplus type fncts.Typeclass
+   */
+  export interface Typeclass<F extends HKT> {
+    [HKT.F]?: F;
   }
 
-  export interface F<F> extends HKT {
-    readonly type: FK<
-      F,
-      this["K"],
-      this["Q"],
-      this["W"],
-      this["X"],
-      this["I"],
-      this["S"],
-      this["R"],
-      this["E"],
-      this["A"]
-    >;
-    readonly variance: {
-      readonly K: "_";
-      readonly Q: "_";
-      readonly W: "_";
-      readonly X: "_";
-      readonly I: "_";
-      readonly S: "_";
-      readonly R: "_";
-      readonly E: "_";
-      readonly A: "_";
-    };
-  }
+  export type ParamName = "K" | "Q" | "W" | "X" | "I" | "S" | "R" | "E" | "A";
 
-  export interface FCoE<F> extends HKT {
-    readonly type: FK<
-      F,
-      this["K"],
-      this["Q"],
-      this["W"],
-      this["X"],
-      this["I"],
-      this["S"],
-      this["R"],
-      this["E"],
-      this["A"]
-    >;
-    readonly variance: {
-      readonly K: "_";
-      readonly Q: "_";
-      readonly W: "_";
-      readonly X: "_";
-      readonly I: "_";
-      readonly S: "_";
-      readonly R: "_";
-      readonly E: "+";
-      readonly A: "_";
-    };
-  }
+  export type Mix<N extends ParamName, P extends ReadonlyArray<unknown>> = VarianceToMix<P>[ParamToVariance[N]];
 
-  export interface FContraR<F> extends HKT {
-    readonly type: FK<
-      F,
-      this["K"],
-      this["Q"],
-      this["W"],
-      this["X"],
-      this["I"],
-      this["S"],
-      this["R"],
-      this["E"],
-      this["A"]
-    >;
-    readonly variance: {
-      readonly K: "_";
-      readonly Q: "_";
-      readonly W: "_";
-      readonly X: "_";
-      readonly I: "_";
-      readonly S: "_";
-      readonly R: "-";
-      readonly E: "_";
-      readonly A: "_";
-    };
-  }
+  export type MixStruct<N extends ParamName, X, Y> = ParamToVariance[N] extends "_"
+    ? X
+    : ParamToVariance[N] extends "+"
+    ? Y[keyof Y]
+    : ParamToVariance[N] extends "-"
+    ? Union.IntersectionOf<{ [K in keyof Y]: OrNever<Y[K]> }[keyof Y]>
+    : X;
 
-  export type ParamName = "K" | "Q" | "W" | "X" | "I" | "S" | "R" | "E" | "A";
+  export type Intro<N extends ParamName, A, B> = VarianceToIntro<A, B>[ParamToVariance[N]];
 
-  export type Kind<F extends HKT, C, K, Q, W, X, I, S, R, E, A> = F extends {
-    readonly type: unknown;
-  }
-    ? (F & {
-        readonly K: OrFix<C, "K", K>;
-        readonly Q: OrFix<C, "Q", Q>;
-        readonly W: OrFix<C, "W", W>;
-        readonly X: OrFix<C, "X", X>;
-        readonly I: OrFix<C, "I", I>;
-        readonly S: OrFix<C, "S", S>;
-        readonly R: OrFix<C, "R", R>;
-        readonly E: OrFix<C, "E", E>;
-        readonly A: A;
-      })["type"]
-    : FK<F, K, Q, W, X, I, S, R, E, A>;
+  export type Low<N extends ParamName> = VarianceToLow[ParamToVariance[N]];
 
-  export type Infer<F extends HKT, C, N extends ParamName | "C", K> = [K] extends [
-    Kind<F, C, infer K, infer Q, infer W, infer X, infer I, infer S, infer R, infer E, infer A>,
+  export type Infer<F extends HKT, N extends ParamName, K> = [K] extends [
+    Kind<F, infer K, infer Q, infer W, infer X, infer I, infer S, infer R, infer E, infer A>,
   ]
-    ? N extends "C"
-      ? C
-      : N extends "K"
+    ? N extends "K"
       ? K
       : N extends "Q"
       ? Q
@@ -236,114 +118,64 @@ export namespace HKT {
       : never
     : never;
 
-  /*
-   * Lower bounds for variance
-   */
-
-  export interface Lows {
-    "-": unknown;
-    "+": never;
-    _: any;
-  }
-
-  export type Low<F extends HKT, N extends ParamName> = F["variance"][N] extends Variance
-    ? Lows[F["variance"][N]]
-    : never;
-
-  /*
-   * Type mixing for variance
-   */
-
-  export interface Mixes<P extends ReadonlyArray<unknown>> {
-    "-": P extends [any]
-      ? P[0]
-      : P extends [any, any]
-      ? P[0] & P[1]
-      : P extends [any, any, any]
-      ? P[0] & P[1] & P[2]
-      : P extends [any, any, any, any]
-      ? P[0] & P[1] & P[2] & P[3]
-      : P extends [any, any, any, any, any]
-      ? P[0] & P[1] & P[2] & P[3] & P[4]
-      : Union.IntersectionOf<P[number]>;
-    "+": P[number];
-    _: P[0];
-  }
-  export type Mix<
-    F extends HKT,
-    N extends ParamName,
-    P extends ReadonlyArray<unknown>,
-  > = F["variance"][N] extends Variance ? Mixes<P>[F["variance"][N]] : P[0];
-
-  export type OrNever<K> = unknown extends K ? never : K;
-
-  export type MixStruct<F extends HKT, N extends ParamName, X, Y> = F["variance"][N] extends "_"
-    ? X
-    : F["variance"][N] extends "+"
-    ? Y[keyof Y]
-    : F["variance"][N] extends "-"
-    ? Union.IntersectionOf<{ [k in keyof Y]: OrNever<Y[k]> }[keyof Y]>
-    : X;
-
-  export interface Intros<A, B> {
-    "-": B;
-    "+": B;
-    _: A;
-  }
-
-  /*
-   * Type introduction for variance
-   */
-
-  export type Intro<F extends HKT, N extends ParamName, A, B> = F["variance"][N] extends Variance
-    ? Intros<A, B>[F["variance"][N]]
-    : A;
-
-  /**
-   * Type parameter constraint
-   */
-
-  export type None = {};
-
-  declare const Fix: unique symbol;
-
-  export interface Fix<N extends ParamName, A> {
-    [Fix]: {
-      [K in N]: () => A;
-    };
-  }
-
-  declare const Extend: unique symbol;
+  export type ErasedKind<F extends HKT> = HKT.Kind<F, any, any, any, any, any, any, any, any, any>;
+}
 
-  export interface Extend<N extends ParamName, A> {
-    [Extend]: {
-      [K in N]: () => A;
-    };
-  }
+export interface HKT {
+  [HKT.F]?: HKT;
+  [HKT.K]?: () => unknown;
+  [HKT.Q]?: (_: never) => void;
+  [HKT.W]?: () => unknown;
+  [HKT.X]?: () => unknown;
+  [HKT.I]?: (_: never) => void;
+  [HKT.S]?: () => unknown;
+  [HKT.R]?: (_: never) => void;
+  [HKT.E]?: () => unknown;
+  [HKT.A]?: () => unknown;
+  [HKT.T]?: unknown;
+  [HKT.Ix]?: unknown;
+}
 
-  export type OrFix<C, N extends ParamName, A> = C extends Fix<N, infer X> ? X : A;
+interface VarianceToMix<P extends ReadonlyArray<unknown>> {
+  "-": P extends [any]
+    ? P[0]
+    : P extends [any, any]
+    ? P[0] & P[1]
+    : P extends [any, any, any]
+    ? P[0] & P[1] & P[2]
+    : P extends [any, any, any, any]
+    ? P[0] & P[1] & P[2] & P[3]
+    : P extends [any, any, any, any, any]
+    ? P[0] & P[1] & P[2] & P[3] & P[4]
+    : Union.IntersectionOf<P[number]>;
+  "+": P[number];
+  _: P[0];
+}
 
-  export type OrExtend<C, N extends ParamName, A> = C extends Extend<N, infer X>
-    ? A extends X
-      ? A
-      : X
-    : A;
+interface VarianceToIntro<A, B> {
+  "-": B;
+  "+": B;
+  _: A;
+}
 
-  export type GetExtends<C, N extends ParamName, A> = C extends Extend<N, infer X> ? X : A;
+interface VarianceToLow {
+  "-": unknown;
+  "+": never;
+  _: any;
+}
 
-  export type IndexFor<F extends HKT, K> = F extends { readonly index: unknown } ? F["index"] : K;
+interface ParamToVariance {
+  K: "_";
+  Q: "-";
+  W: "+";
+  X: "+";
+  I: "_";
+  S: "_";
+  R: "-";
+  E: "+";
+  A: "+";
+}
 
-  /*
-   * Instance util
-   */
+type OrNever<K> = unknown extends K ? never : K;
 
-  /**
-   * @tsplus macro identity
-   */
-  export function instance<F>(
-    _: Omit<F, typeof URI | typeof CURI | "_F" | "_G" | "_CF" | "_CG">,
-  ): F {
-    // @ts-expect-error: typelevel utility
-    return _;
-  }
-}
+declare const Fix: unique symbol;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fncts/typelevel",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "exports": {
     "./*": {
       "import": "./_mjs/*.mjs",