Условные типы в TypeScript

type IsString<T> = T extends string ? true : false;

// Примеры использования
type Result1 = IsString<string>;  // true
type Result2 = IsString<number>;  // false
type Result3 = IsString<"hello">; // true (литеральные типы расширяют свои базовые типы)

// Это можно использовать и с переменными
let a: IsString<string>; // a имеет тип 'true'
let b: IsString<number>; // b имеет тип 'false'

type ToArray<T> = T extends any ? T[] : never;

// При использовании с типом-объединением применяется к каждому члену объединения
type StringOrNumberArray = ToArray<string | number>;
// Это превращается в ToArray<string> | ToArray<number>
// Что даёт string[] | number[]

// Из объединения можно также извлечь определённые типы
type ExtractString<T> = T extends string ? T : never;
type StringsOnly = ExtractString<string | number | boolean | "hello">;
// Результат: string | "hello"

// Извлекаем возвращаемый тип типа функции
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : never;

// Примеры
function greet() { return "Hello, world!"; }
function getNumber() { return 42; }

type GreetReturnType = ReturnType<typeof greet>;   // string
type NumberReturnType = ReturnType<typeof getNumber>; // number

// Извлекаем тип элемента из массива
type ElementType<T> = T extends (infer U)[] ? U : never;
type NumberArrayElement = ElementType<number[]>; // number
type StringArrayElement = ElementType<string[]>; // string

// Делаем этот файл модулем, чтобы локальный ReturnType не конфликтовал со встроенным глобальным
export {};

// Extract<T, U> - извлекает из T типы, совместимые по присваиванию с U
type OnlyStrings = Extract<string | number | boolean, string>; // string

// Exclude<T, U> - исключает из T типы, совместимые по присваиванию с U
type NoStrings = Exclude<string | number | boolean, string>; // number | boolean

// NonNullable<T> - убирает из T значения null и undefined
type NotNull = NonNullable<string | null | undefined>; // string

// Parameters<T> - извлекает типы параметров из типа функции
type Params = Parameters<(a: string, b: number) => void>; // [string, number]

// ReturnType<T> - извлекает возвращаемый тип из типа функции
type Return = ReturnType<() => string>; // string

// Полностью разворачиваем типы Promise
type UnwrapPromise<T> = T extends Promise<infer U> ? UnwrapPromise<U> : T;

// Примеры
type A = UnwrapPromise<Promise<string>>;           // string
type B = UnwrapPromise<Promise<Promise<number>>>;   // number
type C = UnwrapPromise<boolean>;                   // boolean

type TypeName<T> =
  T extends string  ? "string" :
  T extends number  ? "number" :
  T extends boolean ? "boolean" :
  T extends undefined ? "undefined" :
  T extends Function ? "function" :
  "object";

// Использование
type T0 = TypeName<string>;      // "string"
type T1 = TypeName<42>;         // "number"
type T2 = TypeName<true>;       // "boolean"
type T3 = TypeName<() => void>; // "function"
type T4 = TypeName<Date[]>;     // "object"

// Функция, которая возвращает разные типы в зависимости от типа аргумента
function processValue<T>(value: T): T extends string
  ? string
  : T extends number
  ? number
  : T extends boolean
  ? boolean
  : never {

  if (typeof value === "string") {
    return value.toUpperCase() as any; // Приведение типа нужно из-за ограничений
  } else if (typeof value === "number") {
    return (value * 2) as any;
  } else if (typeof value === "boolean") {
    return (!value) as any;
  } else {
    throw new Error("Неподдерживаемый тип");
  }
}

// Использование
const stringResult = processValue("hello"); // Возвращает "HELLO" (тип - string)
const numberResult = processValue(10);      // Возвращает 20 (тип - number)
const boolResult = processValue(true);      // Возвращает false (тип - boolean)