Prakaar

Prakaar (hindi for "type") is a type programming language which compiles to and interops with type-level TypeScript. Prakaar itself is also a subset of TypeScript. See this twitter thread for an introduction.

You can install it via npm i -g prakaar. And use it via cli with cat foo.pr.ts | prakaar > foo.ts. Or programmatically with the prakaar/typescript-compiler module.

Currently, this is just a proof-of-concept and made for fun. But it probably could have a use-case as it does make type-level TypeScript way more accessible.

Feel free to open an issue for questions or feedback.

Basic example

// -------------------------
// ./foo.pr.ts

import { Type, O, U, B, T, p, t } from "prakaar/prelude"

export let omitFunctionKey = (t: Type) =>
  O.create(
    p(
      O.key(t),
      U.filter(k =>
        B.not(T.isSubtype(O.get(t, k), T.function))
      )
    ),
    k => O.get(t, k)
  )

let test = omitFunctionKey(t<{
  a: string,
  b: number,
  c: (_: { x: string }) => number,
  d: () => void
}>())


// -------------------------
// ./foo.ts (compiled)

import { T, U, O, B } from "prakaar/typescript-prelude"

export type omitFunctionKey<t> =
  { [_k in T.cast<(
      [O.key<t>] extends [infer _a0] ? 
      [(
        [_a0] extends [infer k] ?
        k extends unknown ?
        (B.not<T.isSubtype<O.get<t, k>, T.function_>>) extends true ?
        k : never : never : never
      )] extends [infer _a1] ? 
      _a1 : never : never
    ), keyof any>]:
      [_k] extends [infer k] ?
      O.get<t, k> : never
  }

type test =
  omitFunctionKey<{
    a: string,
    b: number,
    c: (_: { x: string }) => number,
    d: () => void
  }>

Interop example

// -------------------------
// ./exclude-hello.pr.ts

import { Type, U, B, p, t } from "../src/prelude"
import { IsHello } from "./external/is-hello"

export let ExcludeHello = (x: Type) =>
  p(x, U.filter(x =>
    B.not(t<IsHello<typeof x>>())
  ))


// -------------------------
// ./exclude-hello.ts (compiled)

import { T, U, O, B } from "../src/typescript-prelude"
import { IsHello } from "./external/is-hello"

export type ExcludeHello<x> =
  [x] extends [infer _a0] ? 
  [(
    [_a0] extends [infer x] ?
    x extends unknown ?
    ([x] extends [infer x] ?
    B.not<IsHello<x>> : never) extends true ?
    x : never : never : never
  )] extends [infer _a1] ? 
  _a1 : never : never


// -------------------------
// ./is-hello.ts

export type IsHello<T> =
  T extends "hello" ? true : false


// -------------------------
// ./test.ts

import { ExcludeHello } from "./exclude-hello.ts"

type Test =
  ExcludeHello<"hello" | "world" | "prakaar">

Future

Currently the code is really shabby because I just wanted to make a POC. I might rewrite it in PureScript (if I can make good bindings for babel).
The prelude currently only contains the functions used in the readme examples. After I rewrite this I'd gradually add and implement more prelude functions (and more features in general).
Optimizations. Eg, omitFunctionKey in above output can be optimized to something like this...

export type omitFunctionKey<t> =
  { [k in (
      keyof t extends infer p ?
      p extends unknown ?
        t[p & keyof t] extends ((...a: never[]) => unknown)
          ? never
          : p & keyof t
        : never : never
    )]:
      t[k]
  }

devanshj/prakaar

Prakaar

Basic example

Interop example

Future