제네릭 클래스와 인터페이스

// Box 클래스는 어떤 타입이든 담을 수 있는 제네릭 클래스입니다.
class Box<T> {
  private _value: T; // _value 속성의 타입은 T에 의해 결정됩니다.

  constructor(value: T) {
    this._value = value;
  }

  // T 타입의 값을 반환하는 getter 메서드
  getValue(): T {
    return this._value;
  }

  // T 타입의 값을 설정하는 setter 메서드
  setValue(newValue: T): void {
    this._value = newValue;
  }

  // 다른 타입의 값을 받아서 T 타입과 비교하는 메서드
  isSameAs(otherValue: T): boolean {
    return this._value === otherValue;
  }
}

// 인스턴스 생성 시 타입 인자를 명시하여 T의 타입을 결정합니다.
const stringBox = new Box<string>("Hello TypeScript!");
console.log(stringBox.getValue());     // "Hello TypeScript!"
stringBox.setValue("New String");
console.log(stringBox.isSameAs("New String")); // true

const numberBox = new Box<number>(123);
console.log(numberBox.getValue());     // 123
numberBox.setValue(456);
console.log(numberBox.isSameAs(456)); // true

// numberBox.setValue("abc"); // Error: '"abc"' 형식은 'number' 형식에 할당할 수 없습니다.

const booleanBox = new Box<boolean>(true);
console.log(booleanBox.getValue()); // true

// 타입 추론: 생성자 매개변수를 통해 제네릭 타입을 자동으로 추론할 수도 있습니다.
const inferredBox = new Box(789); // inferredBox의 타입은 Box<number>로 추론됩니다.
console.log(inferredBox.getValue()); // 789

// KeyValuePair 인터페이스는 어떤 타입이든 key와 value로 가질 수 있습니다.
interface KeyValuePair<K, V> {
  key: K;
  value: V;
}

// StringValuePair는 K가 string, V가 string인 KeyValuePair를 나타냅니다.
type StringValuePair = KeyValuePair<string, string>;
const pair1: StringValuePair = { key: "name", value: "Alice" };

// NumberAndBooleanPair는 K가 number, V가 boolean인 KeyValuePair를 나타냅니다.
type NumberAndBooleanPair = KeyValuePair<number, boolean>;
const pair2: NumberAndBooleanPair = { key: 1, value: true };

// 인터페이스를 클래스에서 구현할 때 제네릭 타입 인자를 지정할 수 있습니다.
class DataStore<T> implements KeyValuePair<string, T> {
  key: string;
  value: T;

  constructor(key: string, value: T) {
    this.key = key;
    this.value = value;
  }

  print(): void {
    console.log(`Key: ${this.key}, Value: ${this.value}`);
  }
}

const userStore = new DataStore<string>("user_id", "u12345");
userStore.print(); // Key: user_id, Value: u12345

const productStore = new DataStore<number>("product_code", 98765);
productStore.print(); // Key: product_code, Value: 98765

// ProcessCallback 인터페이스는 T 타입의 데이터를 받고 V 타입의 결과를 반환하는 함수를 정의합니다.
interface ProcessCallback<T, V> {
  (data: T): V;
}

// StringProcessor는 string을 받아 string을 반환하는 함수를 의미합니다.
const stringProcessor: ProcessCallback<string, string> = (input) => input.toUpperCase();
console.log(stringProcessor("hello")); // "HELLO"

// NumberProcessor는 number 배열을 받아 number를 반환하는 함수를 의미합니다.
const numberProcessor: ProcessCallback<number[], number> = (numbers) => numbers.reduce((sum, num) => sum + num, 0);
console.log(numberProcessor([1, 2, 3, 4, 5])); // 15

interface HasId {
  id: string | number;
}

// IdentifiableRepository 클래스는 HasId 인터페이스를 만족하는 T 타입만 다룰 수 있습니다.
class IdentifiableRepository<T extends HasId> {
  private items: T[] = [];

  add(item: T): void {
    this.items.push(item);
  }

  findById(id: string | number): T | undefined {
    return this.items.find(item => item.id === id);
  }
}

interface User extends HasId {
  name: string;
  email: string;
}

interface Product extends HasId {
  name: string;
  price: number;
}

const userRepository = new IdentifiableRepository<User>();
userRepository.add({ id: 1, name: "Alice", email: "alice@example.com" });
console.log(userRepository.findById(1)); // { id: 1, name: 'Alice', email: 'alice@example.com' }

const productRepository = new IdentifiableRepository<Product>();
productRepository.add({ id: "P001", name: "Laptop", price: 1200 });
console.log(productRepository.findById("P001")); // { id: 'P001', name: 'Laptop', price: 1200 }

// const invalidRepository = new IdentifiableRepository<string>();
// Error: 'string' 형식은 'HasId' 형식에 할당할 수 없습니다.