type AppleLiteral = "Apple";

let name: AppleLiteral = "Apple";
let wrongName: AppleLiteral = "Banana"; // Type Error: Type '"Banana"' is not assignable to type '"Apple"'.
let nameString: string = name; // This works

type LiteralIsStringType<T> = T extends string ? string : never;

type AppleLiteralType = LiteralIsStringType<AppleLiteral>; // type AppleLiteralType = string;
type NeverLiteralType = LiteralIsStringType<0>; // type NeverLiteralType = never;

type LiteralType<T> = T extends string
  ? string
  : T extends number
  ? number
  : T extends boolean
  ? boolean
  : never;

type AppleLiteral = "Apple" | null | undefined;
type NonNullable<T> = T extends null | undefined ? never : T;
type NonNullString = NonNullable<string | null | undefined>; // type NonNullString = string;
type NonNullApple = NonNullable<AppleLiteral> // string | never | never -> string
// conditional types are distributive -> will check against each union member rather than entire union

type Exclude<T, U> = T extends U ? never : T;

type FavoriteLetters = "a" | "l" | "e" | "x";
type Vowels = "a" | "e" | "i" | "o" | "u" | "y";

type NonFavoriteVowels = Exclude<Vowels, FavoriteLetters>;
// type NonFavoriteVowels = "i" | "o" | "u" | "y"

type Extract<T, U> = T extends U ? T : never;

type FavoriteVowels = Extract<Vowels, FavoriteLetters>;
// type FavoriteVowels = "a" | "e"

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

// We have to use `typeof` to extract the type signature of this function.
type ParseIntReturn = ReturnType<typeof Number.parseInt>; // type ParseIntReturn = number

// ParseIntReturn is already a type, so we can directly access its properties without using `typeof`
type ToStringReturn = ReturnType<ParseIntReturn["toString"]>; // type ToStringReturn = string

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

type ParseIntParams = Parameters<typeof Number.parseInt>; // type ParseIntParams = [s: string, radix?: number]

type UnwrapArray<T> = T extends (infer R)[] ? R : T;

type UnwrapPromise<T> = T extends Promise<infer R> ? R : T;

Conditional Types