Type Inference with infer

type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

function getUser() {
  return { id: 1, name: "Alice" };
}

type User = ReturnType<typeof getUser>; 
// { id: number; name: string; }

type Parameters<T> = T extends (...args: infer P) => any ? P : never;

function createUser(name: string, age: number) {
  return { name, age };
}

type CreateUserParams = Parameters<typeof createUser>;
// [name: string, age: number]

type ArrayElement<T> = T extends (infer E)[] ? E : never;

type StringArray = string[];
type Element = ArrayElement<StringArray>; // string

type MixedArray = (string | number)[];
type MixedElement = ArrayElement<MixedArray>; // string | number

type Awaited<T> = T extends Promise<infer U> ? U : T;

async function fetchUser() {
  return { id: 1, name: "Alice" };
}

type User = Awaited<ReturnType<typeof fetchUser>>;
// { id: number; name: string; }

type PropType<T, K extends keyof T> = T extends { [P in K]: infer V }
  ? V
  : never;

interface User {
  id: number;
  name: string;
  email: string;
}

type EmailType = PropType<User, "email">; // string

type ConstructorParameters<T> = T extends new (...args: infer P) => any
  ? P
  : never;

class User {
  constructor(public name: string, public age: number) {}
}

type UserConstructorParams = ConstructorParameters<typeof User>;
// [name: string, age: number]

type InstanceType<T> = T extends new (...args: any[]) => infer R ? R : never;

class Database {
  connect() { }
  query(sql: string) { }
}

type DB = InstanceType<typeof Database>;
// Database

type DeepArrayElement<T> = T extends (infer E)[]
  ? E extends (infer F)[]
    ? F
    : E
  : never;

type NestedArray = string[][];
type Element = DeepArrayElement<NestedArray>; // string

type First<T> = T extends [infer F, ...any[]] ? F : never;
type Rest<T> = T extends [any, ...infer R] ? R : never;

type Tuple = [string, number, boolean];
type FirstElement = First<Tuple>; // string
type RestElements = Rest<Tuple>; // [number, boolean]

type ThisType<T> = T extends (this: infer U, ...args: any[]) => any
  ? U
  : never;

interface Database {
  query(this: Database, sql: string): void;
}

type DB = ThisType<Database["query"]>; // Database