Generics: продвинуто

type User = { name: string; age: number };

type UserKeys = keyof User; // 'name' | 'age'

function getValue<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
}

const user = { name: 'Алиса', age: 25 };
const name = getValue(user, 'name'); // string
const age = getValue(user, 'age');   // number
getValue(user, 'email'); // ошибка

const user = { name: 'Алиса', age: 25 };
type User = typeof user;
// { name: string; age: number }

function longest<T extends { length: number }>(a: T, b: T): T {
    return a.length >= b.length ? a : b;
}

type ApiResponse<T = unknown> = {
    data: T;
    status: number;
};

function merge<T extends object, U extends object>(a: T, b: U): T & U {
    return { ...a, ...b };
}

function groupBy<T, K extends keyof T>(items: T[], key: K): Record<string, T[]> {
    return items.reduce((acc, item) => {
        const group = String(item[key]);
        acc[group] = acc[group] ?? [];
        acc[group].push(item);
        return acc;
    }, {} as Record<string, T[]>);
}

type Container<T> = {
    items: T[];
};

type Nested = Container<Container<string>>;

function map<T, U>(items: T[], fn: (item: T) => U): U[] {
    return items.map(fn);
}

map([1, 2, 3], (n) => n.toString()); // string[]

function pluck<T, K extends keyof T>(items: T[], key: K): T[K][] {
    return items.map((item) => item[key]);
}

const users = [
    { name: 'Алиса', age: 25 },
    { name: 'Боб', age: 30 },
];

pluck(users, 'name'); // string[]
pluck(users, 'age');  // number[]

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

type A = IsString<string>;  // true
type B = IsString<number>;  // false

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

type A = ReturnType<() => string>; // string

type NonNullable<T> = T extends null | undefined ? never : T;

type A = NonNullable<string | null>; // string