Объясните conditional types и `infer` в TypeScript: что это, как работает и когда применять.

type ToArray<T> = T extends any ? T[] : never;
type A = ToArray<string | number>; // string[] | number[]  ← NOT (string | number)[]

type IsString<T> = [T] extends [string] ? true : false; // no distribution

type Elem<T>   = T extends (infer E)[] ? E : never;
type U = Elem<(string | number)[]>;                 // string | number (union)

type Param<T>  = T extends (arg: infer P) => any ? P : never;
type I = Param<((a: string) => void) & ((a: number) => void)>; // string & number

type FirstChar<S> = S extends `${infer C extends string}${string}` ? C : never;

// Rebuild the standard-library conditionals — a frequent whiteboard task
type MyReturnType<T>   = T extends (...args: any[]) => infer R ? R : never;
type MyParameters<T>   = T extends (...args: infer P) => any ? P : never;
type MyNonNullable<T>  = T extends null | undefined ? never : T;
type MyAwaited<T>      = T extends Promise<infer V> ? MyAwaited<V> : T; // recurse to unwrap nesting

type R = MyReturnType<() => string>;         // string
type A = MyAwaited<Promise<Promise<number>>>; // number

// The distribution gotcha, made explicit
type Wrap<T> = T extends any ? { v: T } : never;
type Distributed = Wrap<'a' | 'b'>;      // { v: 'a' } | { v: 'b' }
type Blocked = [('a' | 'b')] extends [any] ? { v: 'a' | 'b' } : never; // { v: 'a' | 'b' }

// Why NonNullable is written with a naked T: it must distribute to filter each member
type Clean = NonNullable<string | null | undefined>; // string