Fun with tuple types in Typescript 3.0

tuples.ts

type Head<T extends unknown[]> = T[0];
type FnWithArgs<T extends unknown[]> = (...args: T) => void;
type TailArgs<T> = T extends (x: unknown, ...args: infer T) => unknown ? T : never;
type Tail<T extends unknown[]> = TailArgs<FnWithArgs<T>>;


// Lol
type Decr<T extends number> =
 T extends 10 ? 9 : 
 T extends 9 ? 8 : 
 T extends 8 ? 7 : 
 T extends 7 ? 6 : 
 T extends 6 ? 5 : 
 T extends 5 ? 4 : 
 T extends 4 ? 3 : 
 T extends 2 ? 1 : 
 T extends 1 ? 0 : 
 never;
type Length<T extends unknown[]> = T['length'];
type Last<T extends unknown[]> = T[Decr<Length<T>>];

type Tuple = [number, string, boolean, string, { a: number }];
type LengthT = Length<Tuple>; // 5
type LastT = Last<Tuple>; // { a: number }
type HeadT = Head<Tuple>; // string
type TailT = Tail<Tuple>; // [string, boolean, string, { a: number }]

Cool, thx for sharing. A couple of issues:

• TailArgs should not reuse T, it does not work as it is.
• HeadT should be // number

With TypeScript 4.0 variadic tuple types, Tail can be simplified as:

type Tail<T extends unknown[]> = T extends [unknown, ...infer TailType] ? TailType : never;