제네릭 유틸리티 함수 구현

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

interface Product {
  id: string;
  itemName: string;
  price: number;
}

/**
 * 객체 배열에서 특정 키에 해당하는 값들을 추출하여 새로운 배열을 반환하는 함수
 * @param array T 타입 객체들의 배열
 * @param key T 객체의 속성 이름 (K 타입)
 * @returns K 속성에 해당하는 값들의 배열 (T[K] 타입)
 */
function pluck<T, K extends keyof T>(array: T[], key: K): T[K][] {
  return array.map(item => item[key]);
}

const users: User[] = [
  { id: 1, name: "Alice", email: "alice@example.com" },
  { id: 2, name: "Bob", email: "bob@example.com" },
  { id: 3, name: "Charlie", email: "charlie@example.com" },
];

const userNames = pluck(users, "name"); // userNames의 타입은 string[]
console.log(userNames); // [ 'Alice', 'Bob', 'Charlie' ]

const userIds = pluck(users, "id");     // userIds의 타입은 number[]
console.log(userIds);   // [ 1, 2, 3 ]

// pluck(users, "address"); // Error: 'address' 형식은 'keyof User' 형식에 할당할 수 없습니다.

const products: Product[] = [
  { id: "P001", itemName: "Laptop", price: 1200 },
  { id: "P002", itemName: "Mouse", price: 25 },
];

const productNames = pluck(products, "itemName"); // productNames의 타입은 string[]
console.log(productNames); // [ 'Laptop', 'Mouse' ]

/**
 * 두 객체를 병합하여 새로운 객체를 반환하는 함수
 * @param obj1 첫 번째 객체 (T 타입)
 * @param obj2 두 번째 객체 (U 타입)
 * @returns 병합된 새로운 객체 (T & U 타입)
 */
function merge<T extends object, U extends object>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 }; // 스프레드 문법으로 객체 병합
}

const userDetails = { name: "Alice", age: 30 };
const userSettings = { theme: "dark", notifications: true };

const mergedUser = merge(userDetails, userSettings);
/*
// mergedUser의 타입은 다음과 같이 추론됩니다.
type mergedUser = {
    name: string;
    age: number;
} & {
    theme: string;
    notifications: boolean;
};
// 최종적으로 { name: string; age: number; theme: string; notifications: boolean; }
*/
console.log(mergedUser.name);         // Alice
console.log(mergedUser.theme);        // dark
console.log(mergedUser.notifications); // true

// merge(123, userSettings); // Error: 'number' 형식은 'object' 형식에 할당할 수 없습니다.

/**
 * 배열에서 null 또는 undefined 값을 제외하고, 필터링된 배열을 반환하는 함수
 * @param arr T 타입의 배열 (T는 null 또는 undefined를 포함할 수 있음)
 * @returns NonNullable<T> 타입 요소들의 배열
 */
function compact<T>(arr: (T | null | undefined)[]): NonNullable<T>[] {
  // item is NonNullable<T>는 사용자 정의 타입 가드 역할을 합니다.
  // 이 조건이 true일 경우, item의 타입이 NonNullable<T>임을 보증합니다.
  return arr.filter((item): item is NonNullable<T> => item !== null && item !== undefined);
}

const mixedNumbers = [1, null, 2, undefined, 3, 0, 4];
const cleanedNumbers = compact(mixedNumbers); // cleanedNumbers의 타입은 number[]
console.log(cleanedNumbers); // [ 1, 2, 3, 0, 4 ]

const mixedStrings = ["a", "b", undefined, "c", null, "d"];
const cleanedStrings = compact(mixedStrings); // cleanedStrings의 타입은 string[]
console.log(cleanedStrings); // [ 'a', 'b', 'c', 'd' ]

/**
 * 주어진 값의 타입을 기반으로 다른 타입의 결과를 반환하는 함수
 * - 만약 input이 string이면 string의 길이를 number로 반환
 * - 만약 input이 number이면 number를 string으로 변환하여 반환
 * - 그 외의 타입은 그대로 반환
 */
function processValue<T>(input: T): T extends string ? number : (T extends number ? string : T) {
  if (typeof input === 'string') {
    // string -> number 변환 (타입 단언 필요)
    return input.length as any;
  } else if (typeof input === 'number') {
    // number -> string 변환 (타입 단언 필요)
    return String(input) as any;
  } else {
    // 그 외의 타입은 그대로 반환
    return input as any;
  }
}

const len = processValue("hello");    // len의 타입은 number
console.log(len);                     // 5

const strNum = processValue(123);     // strNum의 타입은 string
console.log(strNum);                  // "123"

const bool = processValue(true);      // bool의 타입은 boolean
console.log(bool);                    // true

// const mixed: number | string | boolean = processValue(Math.random() > 0.5 ? "world" : 456);
// console.log(mixed);