Type level programming in TypeScript
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.


TypeScript compatibility

The stable version is tested against TypeScript 2.9.1+


Equals<A, B>

Returns the string literal 'T' if A and B are equal types, 'F' otherwise

Equals<string, string> // "T"
Equals<string, number> // "F"

Omit<A extends object, K extends string | number | symbol>

Extracts a super-type of A identified by its keys K

Omit<{ a: string; b: number }, 'a'> // { b: number }

Overwrite<A extends object, B extends object>

Overwrite<{ a: string; b: number }, { b: boolean }> // { a: string; b: boolean }

Diff<A extends object, K extends keyof A>

Diff<{ a: string; b: number }, 'b'> // { a: string; b?: number }

RowLacks<A extends object, K extends string | number | symbol>

Encodes the constraint that a given object A does not contain specific keys K

declare function f(x: RowLacks<{ a: string; b: number }, 'a'>): void
// $ExpectError
f({ a: 'foo', b: 1 })

Exact<A extends object, B extends A>

declare function f<T extends Exact<{ a: string }, T>>(a: T): void
declare const x: { a: string }
declare const y: { a: string; b: number }
// $ExpectError

KeysOfType<A extends object, B>

Picks only the keys of a certain type

KeysOfType<{a: string, b: string | boolean, c: boolean, d: string}, string> // "a" | "d"


declare function f<T extends AnyTuple>(x: T): T
declare const x: [number]
declare const y: [number, string]
declare const z: [number, string, boolean]
declare const t: Array<number>
// $ExpectError


interface Foo {
  bar: {
    baz: string
    quux: Array<{ barbaz: number }>

type ReadonlyFoo = DeepReadonly<Foo>
declare const x: ReadonlyFoo
// $ExpectError
x.bar.quux[1].barbaz = 1

TaggedUnionMember<A extends object, Tag extends keyof A, Value extends A[Tag]>

Extracts the type of a member of a tagged union

type A = { tag: 'A'; a: string }
type B = { tag: 'B'; b: number }
type C = A | B
TaggedUnionMember<C, 'tag', 'A'> // A