@fncts/typelevel 0.0.1

package/_src/Any.ts

@@ -0,0 +1,100 @@
+import type { Boolean, False, True } from "./Boolean.js";
+import type { BuiltIn } from "./BuiltIn.js";
+import type { List } from "./List.js";
+import type { Has } from "./Union.js";
+
+export type Cast<A, B> = A extends B ? A : B;
+
+export type Try<A1 , A2 , Catch = never> =
+    A1 extends A2
+    ? A1
+    : Catch;
+
+export type Extends<A, B> = [A] extends [never] ? False : A extends B ? True : False;
+
+export type Contains<A, B> = Extends<A, B> extends True ? True : False;
+
+export type Equals<A, B> = (<X>() => X extends B ? True : False) extends <X>() => X extends A ? True : False
+  ? True
+  : False;
+
+export type If<B extends Boolean, Then, Else = never> = B extends True ? Then : Else;
+
+export type Match =
+  | "default"
+  // Extends<A, B>
+  | "extends->"
+  // Contains<A, B>
+  | "contains->"
+  // Equals<A, B>
+  | "equals"
+  // Extends<B, A>
+  | "<-extends"
+  // Contains<B, A>
+  | "<-contains";
+
+export type Is<A, B, _ extends Match> = {
+  default: Extends<A, B>;
+  "extends->": Extends<A, B>;
+  "contains->": Contains<A, B>;
+  "<-extends": Extends<B, A>;
+  "<-contains": Contains<B, A>;
+  equals: Equals<A, B>;
+}[_];
+
+export type Key = string | number | symbol;
+
+export type Literal = string | number | bigint | boolean;
+
+export type Keys<A> = A extends List ? Exclude<keyof A, keyof any[]> | number : keyof A;
+
+export type KnownKeys<A> = {
+  [K in keyof A]: string extends K ? never : number extends K ? never : K;
+} extends {
+  [K in keyof A]: infer U;
+}
+  ? U & Keys<A>
+  : never;
+
+export type ComputeRaw<A> = A extends Function ? A : { [K in keyof A]: A[K] } & unknown;
+
+export type ComputeFlat<A> = A extends BuiltIn
+  ? A
+  : A extends Array<any>
+  ? A extends Array<Record<Key, any>>
+    ? Array<{ [K in keyof A[number]]: A[number][K] } & unknown>
+    : A
+  : A extends ReadonlyArray<any>
+  ? A extends ReadonlyArray<Record<Key, any>>
+    ? ReadonlyArray<{ [K in keyof A[number]]: A[number][K] } & unknown>
+    : A
+  : { [K in keyof A]: A[K] } & unknown;
+
+export type ComputeDeep<A, Seen = never> = A extends BuiltIn
+  ? A
+  : {
+      [False]: A extends Array<any>
+        ? A extends Array<Record<Key, any>>
+          ? Array<{ [K in keyof A[number]]: ComputeDeep<A[number][K], A | Seen> } & unknown>
+          : A
+        : A extends ReadonlyArray<any>
+        ? A extends ReadonlyArray<Record<Key, any>>
+          ? ReadonlyArray<{ [K in keyof A[number]]: ComputeDeep<A[number][K], A | Seen> } & unknown>
+          : A
+        : { [K in keyof A]: ComputeDeep<A[K], A | Seen> } & unknown;
+      [True]: A;
+    }[Has<Seen, A>];
+
+export type At<A, K extends Key> = A extends List
+  ? number extends A["length"]
+    ? K extends number | `${number}`
+      ? A[never] | undefined
+      : undefined
+    : K extends keyof A
+    ? A[K]
+    : undefined
+  : unknown extends A
+  ? unknown
+  : K extends keyof A
+  ? A[K]
+  : undefined;

package/_src/Boolean.ts

@@ -0,0 +1,44 @@
+export declare const False: unique symbol;
+export declare const True: unique symbol;
+
+export type False = typeof False;
+export type True = typeof True;
+export type Boolean = True | False;
+
+export type Or<B1 extends Boolean, B2 extends Boolean> = {
+  [False]: {
+    [False]: False;
+    [True]: True;
+  };
+  [True]: {
+    [False]: True;
+    [True]: True;
+  };
+}[B1][B2];
+
+export type And<B1 extends Boolean, B2 extends Boolean> = {
+  [False]: {
+    [False]: False,
+    [True]: False
+  },
+  [True]: {
+    [False]: False,
+    [True]: True
+  }
+}[B1][B2];
+
+export type Xor<B1 extends Boolean, B2 extends Boolean> = {
+  [False]: {
+    [False]: False,
+    [True]: True
+  },
+  [True]: {
+    [False]: True,
+    [True]: False
+  }
+}[B1][B2];
+
+export type Not<B extends Boolean> = {
+  [False]: True,
+  [True]: False
+}[B];

package/_src/BuiltIn.ts

@@ -0,0 +1,7 @@
+export type BuiltIn =
+  | Function
+  | Error
+  | Date
+  | { readonly [Symbol.toStringTag]: string }
+  | RegExp
+  | Generator;

package/_src/Check.ts

@@ -0,0 +1,89 @@
+import type { False, True } from "./Boolean.js";
+import type * as Union from "./Union.js";
+
+type EqualsWrapped<T> = T extends infer R & {}
+  ? {
+      [P in keyof R]: R[P];
+    }
+  : never;
+
+/**
+ * @tsplus type fncts.Check
+ */
+export type Check<Condition> = [Condition] extends [never] ? Check.False : Check.True;
+
+export declare namespace Check {
+  /**
+   * @tsplus type fncts.Check.True
+   */
+  type True = typeof True;
+
+  /**
+   * @tsplus type fncts.Check.False
+   */
+  type False = typeof False;
+
+  /**
+   * @tsplus type fncts.Check.Result
+   */
+  type Result = True | False;
+
+  /**
+   * @tsplus type fncts.Check.Not
+   */
+  type Not<A> = [A] extends [never] ? unknown : never;
+
+  /**
+   * @tsplus type fncts.Check.Extends
+   */
+  type Extends<A, B> = [A] extends [never] ? never : [A] extends [B] ? unknown : never;
+
+  /**
+   * @tsplus type fncts.Check.IsUnion
+   */
+  type IsUnion<T> = [T] extends [Union.IntersectionOf<T>] ? never : unknown;
+
+  /**
+   * @tsplus type fncts.Check.IsEqual
+   */
+  type IsEqual<A, B> = (<T>() => T extends EqualsWrapped<A> ? 1 : 2) extends <
+    T,
+  >() => T extends EqualsWrapped<B> ? 1 : 2
+    ? unknown
+    : never;
+
+  /**
+   * @tsplus type fncts.Check.IsLiteral
+   */
+  type IsLiteral<A extends string | number> = Not<Extends<string, A> | Extends<number, A>>;
+
+  /**
+   * @tsplus type fncts.Check.IsStruct
+   */
+  type IsStruct<A> = Extends<keyof A, string> & Not<IsUnion<A>>;
+
+  /**
+   * @tsplus type fncts.Check.HaveSameLength
+   */
+  type HaveSameLength<A extends { length: number }, B extends { length: number }> = IsEqual<
+    A["length"],
+    B["length"]
+  >;
+
+  /**
+   * @tsplus type fncts.Check.IsTagged
+   */
+  type IsTagged<Tag extends PropertyKey, A extends { [k in Tag]: string }> = IsUnion<A[Tag]> &
+    IsUnion<A> &
+    HaveSameLength<Union.ListOf<A[Tag]>, Union.ListOf<A>>;
+
+  /**
+   * @tsplus type fncts.Check.If
+   */
+  type If<B, Then, Else = never> = B extends never ? Else : Then;
+
+  /**
+   * @tsplus type fncts.Check.Or
+   */
+  type Or<A, B> = A extends never ? B : A;
+}

package/_src/Function.ts

@@ -0,0 +1,24 @@
+import type { Try } from "@fncts/typelevel/Any";
+
+export type Narrowable = string | number | boolean | bigint;
+
+export type Exact<A, B> = B extends unknown
+  ? A extends B
+    ? A extends Narrowable
+      ? A
+      : {
+          [K in keyof A]: K extends keyof B ? Exact<A[K], B[K]> : never;
+        }
+    : B
+  : never;
+
+export type NoInfer<A> = [A][A extends any ? 0 : never];
+
+type NarrowRaw<A> =
+  | (A extends [] ? [] : never)
+  | (A extends Narrowable ? A : never)
+  | {
+      [K in keyof A]: A[K] extends Function ? A[K] : NarrowRaw<A[K]>;
+    };
+
+export type Narrow<A> = Try<A, [], NarrowRaw<A>>;

package/_src/HKT.ts

@@ -0,0 +1,349 @@
+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 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;
+
+  /*
+   * 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 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;
+
+  /*
+   * Instance util
+   */
+
+  /**
+   * @tsplus macro identity
+   */
+  export function instance<F>(
+    _: Omit<F, typeof URI | typeof CURI | "_F" | "_G" | "_CF" | "_CG">,
+  ): F {
+    // @ts-expect-error: typelevel utility
+    return _;
+  }
+}

package/_src/Intersection.ts

@@ -0,0 +1 @@
+export type Erase<A, B> = A & B extends B & infer C ? C : A;