Typescript Type-level Playground
npm install type-tsTypescript Type-level playground
This project is a playground of type-level operations for TypeScript.
``
npm i type-ts
The stable version is tested against TypeScript 3.1.6+.
#### Extends
Returns true if A extends from B, false otherwise.
`ts`
Extends<'foo', string> // true
Extends
#### Equals
Returns true if A and B are equal types, false otherwise.
`ts`
Equals
Equals
#### And
Returns true if A and B are equal types to true, false otherwise.
`ts`
And
And
#### Or
Returns true if either A or B are true, false otherwise.
`ts`
Or
Or
#### Xor
Returns true if A and B differ, one is true and the other is false. false otherwise.
`ts`
Xor
Xor
Returns true if A is false. false otherwise.
`ts`
Not
Not
#### If
Returns T if C is true. E otherwise.
`ts`
If
If
#### Newtype
Same representation, different type for the typesystem.
`ts
type USD = Newtype
type EUR = Newtype
const usd = 10 as USD;
const eur = 10 as EUR;
function gross(net: USD, tax: USD): USD {
return (net + tax) as USD; // We can treat them like the underlying type
}
gross(usd, usd); // $ExpectType Newtype
// $ExpectError
gross(eur, usd); // Type '"EUR"' is not assignable to type '"USD"'.
// $ExpectError
gross(1, 1.2); // Type 'number' is not assignable to type '"USD"'.
`
#### Omit
Extracts a super-type of A identified by its keys K.
`ts`
Omit<{ a: string; b: number }, 'a'> // { b: number }
#### Overwrite
Overwrites A with the properties in B.
`ts`
Overwrite<{ a: string; b: number }, { b: boolean }> // { a: string; b: boolean }
#### Diff
Make the specified properties K partial in type A.
`ts`
Diff<{ a: string; b: number }, 'b'> // { a: string; b?: number }
#### Lacks
Encodes the constraint that a given object A does not contain specific keys K
`ts`
declare function f(x: Lacks<{ a: string; b: number }, "a">): void;
// $ExpectError
f({ a: "foo", b: 1 });
Encodes that A cannot have extra propeties.
`ts`
type E = Exact<{ a: string; b: number }>;
declare function f(a: E): void;
declare const x: { a: string };
declare const y: { a: string; b: number };
declare const z: { a: string; b: number; c: boolean };
f(x); // $ExpectError
f(y); // Ok
f(z); // $ExpectError
#### KeysOfType
Picks from A only the keys of a certain type B.
`ts`
KeysOfType<{a: string, b: string | boolean, c: boolean, d: string}, string> // "a" | "d"
#### DeepReadonly\, DeepMutable\, DeepRequired\, DeepPartial\
Recursively sets modifiers readonly and ?.
`ts`
interface A {
b: {
c: string;
d: Array<{ e: number }>;
};
}
type ReadonlyA = DeepReadonly;
declare const a: ReadonlyA;
a.b.d[1].e = 1; // $ExpectError
#### Intersection
Extracts from A only the properties found on B.
`ts`
Intersection<{ a: number; b: number }, { b: number; c: number }> // { b: number }
Returns the union of all value types from A.
`ts`
ValuesOf<{ a: number; b: boolean; c: string; d: number }> // number | boolean | string
#### SetIntersection
Intersection of the literal union sets A and B.
`ts`
SetIntersection<"a" | "b", "c" | "d"> // never
SetIntersection<"a" | "b", "b" | "c"> // "b"
SetIntersection<"a" | "b" | "c" , "b" | "c"> // "b" | "c"
#### SetDifference
Difference of the literal union sets A and B.
`ts`
SetDifference<"a" | "b", "c"> // "a" | "b"
SetDifference<"a" | "b", "b"> // "a"
#### SetUnion
Union of the literal union sets A and B.
`ts`
SetUnion<"a" | "b", "b" | "c"> // "a" | "b" | "c"
Display purpouse only. Useful when dealing with complex types and want to see something simpler in the IDE.
`ts`
Pretty<{ a: 1 } & { b: 2 }> // { a: 1, b: 2 }
Use to prevent a usage of type T from being inferred in other generics. See
#### JSONValue
Represents JSON representable types.
Unwraps nested Promises. Typescript does not collapse nested promises. See
`ts`
type x = Awaited
type y = Awaited
type z = Awaited
Peano numbers implementation.
#### Zero
Zero
#### Succ\
`ts`
Succ
#### Digit = \_0 | \_1 | \_2 | \_3 | \_4 | \_5 | \_6 | \_7 | \_8 | \_9
Predefined aliases.
#### Add
`ts`
Add<_4, _3> // _7
Add<_5, _4> // _9
#### Substract
`ts`
Substract<_0, _1> // never
Substract<_4, _3> // _1
Substract<_5, _2> // _3
#### Multiply
`ts`
Multiply<_2, _3> // _6
Multiply<_3, _3> // _9
#### Quotient
`ts`
Quotient<_4, _0> // never
Quotient<_3, _3> // _1
Quotient<_0, _6> // _0
Quotient<_4, _2> // _2
Quotient<_6, _5> // _1
#### Quotient
`ts`
Quotient<_3, _3> // _0
Quotient<_5, _3> // _2
Quotient<_4, _2> // _0
Quotient<_6, _5> // _1
#### GreaterThan
`ts`
GreaterThan<_1, _0> // true
GreaterThan<_5, _2> // true
GreaterThan<_0, _0> // false
GreaterThan<_0, _1> // false
#### LowerThan
`ts`
LowerThan<_1, _0> // false
LowerThan<_5, _2> // false
LowerThan<_0, _0> // false
LowerThan<_0, _1> // true
#### EqualsTo
`ts`
EqualsTo<_0, _1> // false
EqualsTo<_2, _2> // true
#### AsNat\
Convert a number to a Nat. Do not use with negative numbers.
`ts`
AsNat<2> // _2 or Succ
#### AsNumbe\
Convert a Nat to a number.
`ts`
AsNumber<_2> // 2
Non empty tuple.
#### Nil
Empty tuple.
Compile time arrays (aka array literals).
#### AnyStaticArray
Alias for StaticArray.
Returns the first type of the static array.
`ts`
Head<[]> // never
Head<[1, 2, 3]> // 1
Head<[number, 2, 3]> // number
Tail of the static array.
`ts`
Tail<[]> // never
Tail<[1, 2]> // [2]
Tail<[1, 2, 3]> // [2, 3]
Returns the last type of the static array.
`ts`
Last<[]> // never
Last<[1, 2]> // 2
Last<[1, 2, 3]> // 3
#### Cons
Adds a type to the front of the static array.
`ts`
Cons<1, []> // [1]
Cons<1, Cons<2, []>> // [1, 2]
Cons<1, [2, 3]> // [1, 2, 3]
#### Drop
Drops N elements from the front of the static array.
`ts`
Drop<[], _2> // []
Drop<[1, 2], _1> // [2]
Drop<[1, 2, 3], _2> // [3]
Reverses a static array.
`ts`
Reverse<[]> // []
Reverse<[1, 2]> // [2, 1]
Reverse<[1, 2, 3]> // [3, 2, 1]
#### Take
Return the first N types of the static array.
`ts`
Take<[], _2> // []
Take<[1, 2], _1> // [1]
Take<[1, 2, 3], _2> // [1, 2]
#### Concat
Concatenates two static arrays.
`ts`
Concat<[], []> // []
Concat<[], [1]> // [1]
Concat<[2], [1]> // [2, 1]
Concat<[1, 2], [3]> // [1, 2, 3]
Concat<[1], [2, 3]> // [1, 2, 3]
#### Zip
Zips two static arrays into one with length equals to the shortest length where at each position there is a tuple with the types of each one of them.
`ts`
Zip<[], []> // []
Zip<[], [1]> // []
Zip<[2], [1]> // [[2, 1]]
Zip<[1, 2], [3]> // [[1, 3]]
Zip<[1], [2, 3]> // [[1, 2]]
Zip<[1, 2], [3, 4]> // [[1, 3], [2, 4]]
#### Repeat
Returns a static array of length N with A in each position.
`ts`
Repeat<0, _0> // []
Repeat<0, _1> // [0]
Repeat<0, _2> // [0, 0]
Repeat<0, _3> // [0, 0, 0]
Returns the length of a static array.
`ts
Length<[]> // 0
Length<[1]> // 1>
Length<[1, 2]> // 2
Length<[1, 2, 3]> // 3
type _10 = Add<_9, _1>;
type _20 = Multiply<_10, _2>;
Length
`
Same as Length but returns a Nat instead.
`ts`
LengthN<[]> // _0
LengthN<[1]> // _1
LengthN<[1, 2]> // _2
LengthN<[1, 2, 3]> // _3
LengthN
#### Push
Adds a type to the end of a static array.
`ts`
Push<1, []> // [1]
Push<1, Cons<2, []>> // [2, 1]
Push<1, [3, 2]> // [3, 2, 1]
#### Map
Type-level version of this operations.
`ts
declare module "type-ts/list" {
interface Map1 {
AsNat: A extends number ? AsNat : never;
}
interface Reduce2 {
Add: A extends Nat ? (B extends Nat ? Add
}
}
Map<[0, 1, 2], "AsNat"> // [_0, _1, _2]
Reduce<[_1, _2, _3] "Add", _0> // _6
`