type-ts

    1.1.0 • Public • Published

    type-ts

    Typescript Type-level playground

    This project is a playground of type-level operations for TypeScript.

    Installation

    npm i type-ts
    

    TypeScript compatibility

    The stable version is tested against TypeScript 3.1.6+.

    API

    Logic

    Extends<A, B>

    Returns true if A extends from B, false otherwise.

    Extends<'foo', string> // true
    Extends<string, number> // false

    Equals<A, B>

    Returns true if A and B are equal types, false otherwise.

    Equals<string, string> // true
    Equals<string, number> // false

    And<A, B>

    Returns true if A and B are equal types to true, false otherwise.

    And<true, true> // true
    And<true, false> // false

    Or<A, B>

    Returns true if either A or B are true, false otherwise.

    Or<false, true> // true
    Or<false, false> // false

    Xor<A, B>

    Returns true if A and B differ, one is true and the other is false. false otherwise.

    Xor<false, true> // true
    Xor<true, true> // false

    Not<A>

    Returns true if A is false. false otherwise.

    Not<false> // true
    Not<true> // false

    If<C, T, E>

    Returns T if C is true. E otherwise.

    If<true, number, string> // number
    If<false, number, string> // string

    Newtype

    Newtype<T, NAME>

    Same representation, different type for the typesystem.

    type USD = Newtype<number, "USD">;
    type EUR = Newtype<number, "EUR">;
     
    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<number, "USD">
    // $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"'.

    Type

    Omit<A, K>

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

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

    Overwrite<A, B>

    Overwrites A with the properties in B.

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

    Diff<A, K>

    Make the specified properties K partial in type A.

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

    Lacks<A, K>

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

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

    Exact<A>

    Encodes that A cannot have extra propeties.

    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<A, B>

    Picks from A only the keys of a certain type B.

    KeysOfType<{astring, bstring | boolean, cboolean, dstring}, string> // "a" | "d"

    DeepReadonly<A>, DeepMutable<A>, DeepRequired<A>, DeepPartial<A>

    Recursively sets modifiers readonly and ?.

    interface A {
      b: {
        c: string;
        d: Array<{ e: number }>;
      };
    }
    type ReadonlyA = DeepReadonly<A>;
    declare const a: ReadonlyA;
    a.b.d[1].e = 1; // $ExpectError

    Intersection<A, B>

    Extracts from A only the properties found on B.

    Intersection<{ anumber; bnumber }, { b: numbercnumber }> // { b: number }

    ValuesOf<A>

    Returns the union of all value types from A.

    ValuesOf<{ anumber; bboolean; cstring; dnumber }> // number | boolean | string

    SetIntersection<A, B>

    Intersection of the literal union sets A and B.

    SetIntersection<"a" | "b", "c" | "d"> // never
    SetIntersection<"a" | "b", "b" | "c"> // "b"
    SetIntersection<"a" | "b" | "c" , "b" | "c"> // "b" | "c"

    SetDifference<A, B>

    Difference of the literal union sets A and B.

    SetDifference<"a" | "b", "c"> // "a" | "b"
    SetDifference<"a" | "b", "b"> // "a"

    SetUnion<A, B>

    Union of the literal union sets A and B.

    SetUnion<"a" | "b", "b" | "c"> // "a" | "b" | "c"

    Pretty<A>

    Display purpouse only. Useful when dealing with complex types and want to see something simpler in the IDE.

    Pretty<{ a1 } & { b2 }> // { a: 1, b: 2 }

    NoInfer<A>

    Use to prevent a usage of type T from being inferred in other generics. See

    JSONValue

    Represents JSON representable types.

    Awaited<A>

    Unwraps nested Promises. Typescript does not collapse nested promises. See

    type x = Awaited<number>; // Promise<number>
    type y = Awaited<Promise<Promise<Promise<string>>>>; // Promise<string>
    type z = Awaited<Awaited<Awaited<boolean>>>; // Promise<boolean>

    Number

    Peano numbers implementation.

    Zero

    Zero

    Succ<N>

    Succ<Zero> // _1

    Digit = _0 | _1 | _2 | _3 | _4 | _5 | _6 | _7 | _8 | _9

    Predefined aliases.

    Add<A, B>

    Add<_4, _3> // _7
    Add<_5, _4> // _9

    Substract<A, B>

    Substract<_0, _1> // never
    Substract<_4, _3> // _1
    Substract<_5, _2> // _3

    Multiply<A, B>

    Multiply<_2, _3> // _6
    Multiply<_3, _3> // _9

    Quotient<A, B>

    Quotient<_4, _0> // never
    Quotient<_3, _3> // _1
    Quotient<_0, _6> // _0
    Quotient<_4, _2> // _2
    Quotient<_6, _5> // _1

    Quotient<A, B>

    Quotient<_3, _3> // _0
    Quotient<_5, _3> // _2
    Quotient<_4, _2> // _0
    Quotient<_6, _5> // _1

    GreaterThan<A, B>

    GreaterThan<_1, _0> // true
    GreaterThan<_5, _2> // true
    GreaterThan<_0, _0> // false
    GreaterThan<_0, _1> // false

    LowerThan<A, B>

    LowerThan<_1, _0> // false
    LowerThan<_5, _2> // false
    LowerThan<_0, _0> // false
    LowerThan<_0, _1> // true

    EqualsTo<A, B>

    EqualsTo<_0, _1> // false
    EqualsTo<_2, _2> // true

    AsNat<N>

    Convert a number to a Nat. Do not use with negative numbers.

    AsNat<2> // _2 or Succ<Succ<_0>>

    AsNumbe<N>

    Convert a Nat to a number.

    AsNumber<_2> // 2

    List

    Tuple<A>

    Non empty tuple.

    Nil

    Empty tuple.

    StaticArray<A>

    Compile time arrays (aka array literals).

    AnyStaticArray

    Alias for StaticArray<any>.

    Head<A>

    Returns the first type of the static array.

    Head<[]> // never
    Head<[1, 2, 3]> // 1
    Head<[number, 2, 3]> // number

    Tail<A>

    Tail of the static array.

    Tail<[]> // never
    Tail<[1, 2]> // [2]
    Tail<[1, 2, 3]> // [2, 3]

    Last<A>

    Returns the last type of the static array.

    Last<[]> // never
    Last<[1, 2]> // 2
    Last<[1, 2, 3]> // 3

    Cons<H, L>

    Adds a type to the front of the static array.

    Cons<1, []> // [1]
    Cons<1, Cons<2, []>> // [1, 2]
    Cons<1, [2, 3]> // [1, 2, 3]

    Drop<A, N>

    Drops N elements from the front of the static array.

    Drop<[], _2> // []
    Drop<[1, 2], _1> // [2]
    Drop<[1, 2, 3], _2> // [3]

    Reverse<A>

    Reverses a static array.

    Reverse<[]> // []
    Reverse<[1, 2]> // [2, 1]
    Reverse<[1, 2, 3]> // [3, 2, 1]

    Take<A, N>

    Return the first N types of the static array.

    Take<[], _2> // []
    Take<[1, 2], _1> // [1]
    Take<[1, 2, 3], _2> // [1, 2]

    Concat<A, B>

    Concatenates two static arrays.

    Concat<[], []> // []
    Concat<[], [1]> // [1]
    Concat<[2], [1]> // [2, 1]
    Concat<[1, 2], [3]> // [1, 2, 3]
    Concat<[1], [2, 3]> // [1, 2, 3]

    Zip<A, B>

    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.

    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<A, N>

    Returns a static array of length N with A in each position.

    Repeat<0, _0> // []
    Repeat<0, _1> // [0]
    Repeat<0, _2> // [0, 0]
    Repeat<0, _3> // [0, 0, 0]

    Length<A>

    Returns the length of a static array.

    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<Repeat<0, _20>> // 20

    LengthN<A>

    Same as Length but returns a Nat instead.

    LengthN<[]> // _0
    LengthN<[1]> // _1
    LengthN<[1, 2]> // _2
    LengthN<[1, 2, 3]> // _3
    LengthN<Repeat<0, _20>> // _20

    Push<A, B>

    Adds a type to the end of a static array.

    Push<1, []> // [1]
    Push<1, Cons<2, []>> // [2, 1]
    Push<1, [3, 2]> // [3, 2, 1]

    Map<A, B> and Reduce<A, B>

    Type-level version of this operations.

    declare module "type-ts/list" {
      interface Map1<A = unknown> {
        AsNat: A extends number ? AsNat<A> : never;
      }
     
      interface Reduce2<A = unknown, B = unknown> {
        Add: A extends Nat ? (B extends Nat ? Add<A, B> : never) : never;
      }
    }
     
    Map<[0, 1, 2], "AsNat"> // [_0, _1, _2]
    Reduce<[_1, _2, _3] "Add", _0> // _6

    Similar projects

    Install

    npm i type-ts

    DownloadsWeekly Downloads

    9

    Version

    1.1.0

    License

    MIT

    Unpacked Size

    37.1 kB

    Total Files

    20

    Last publish

    Collaborators

    • ivivona