제네릭 제약 조건

// T extends ConstraintType

interface Lengthwise {
  length: number; // length 속성이 number 타입이어야 한다고 정의
}

// getLength 함수는 T 타입의 인자를 받지만,
// T는 반드시 Lengthwise 인터페이스를 확장(만족)해야 합니다.
function getLength<T extends Lengthwise>(arg: T): number {
  return arg.length; // 이제 arg.length에 안전하게 접근할 수 있습니다.
}

// Lengthwise 인터페이스를 만족하는 타입들:
console.log(getLength("hello world"));     // string은 length 속성을 가짐: 11
console.log(getLength([1, 2, 3, 4, 5]));   // 배열은 length 속성을 가짐: 5
console.log(getLength({ length: 10, value: "test" })); // length 속성을 가진 객체 리터럴: 10

// Lengthwise 인터페이스를 만족하지 않는 타입:
// getLength(123);      // Error: 'number' 형식은 'Lengthwise' 형식에 할당할 수 없습니다.
// getLength(true);     // Error: 'boolean' 형식은 'Lengthwise' 형식에 할당할 수 없습니다.
// getLength({});       // Error: '{}' 형식에 'length' 속성이 없습니다.

// K는 T의 키 타입에 할당 가능해야 함을 제약합니다.
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

interface Person {
  name: string;
  age: number;
}

const person: Person = { name: "철수", age: 30 };

let personName = getProperty(person, "name"); // type personName = string
let personAge = getProperty(person, "age");   // type personAge = number

// getProperty(person, "address"); // Error: 'address' 형식은 'keyof Person' 형식에 할당할 수 없습니다.

class Animal {
  constructor(public name: string) {}
  eat() { console.log(`${this.name}가 먹습니다.`); }
}

class Dog extends Animal {
  constructor(name: string) { super(name); }
  bark() { console.log(`${this.name}가 멍멍 짖습니다.`); }
}

class Cat extends Animal {
  constructor(name: string) { super(name); }
  purr() { console.log(`${this.name}가 야옹거립니다.`); }
}

// createInstance 함수는 T extends Animal 클래스의 생성자를 받습니다.
// new (...args: any[]) => T : T 타입의 인스턴스를 생성하는 생성자 시그니처
function createInstance<T extends Animal>(Constructor: new (...args: any[]) => T, name: string): T {
  return new Constructor(name);
}

const myDog = createInstance(Dog, "바둑이"); // myDog의 타입은 Dog
myDog.bark(); // 바둑이(이)가 멍멍 짖습니다.
myDog.eat();  // 바둑이(이)가 먹습니다.

const myCat = createInstance(Cat, "나비");   // myCat의 타입은 Cat
myCat.purr(); // 나비(이)가 야옹거립니다.

// const myAnimal = createInstance(Animal, "복슬이"); // myAnimal의 타입은 Animal
// myAnimal.bark(); // Error: 'Animal' 형식에 'bark' 속성이 없습니다.

// createInstance(String, "abc"); // Error: 'String' 형식은 'new (...args: any[]) => Animal' 형식에 할당할 수 없습니다.

function createAnimalInstance<Args extends unknown[], T extends Animal>(
  Constructor: new (...args: Args) => T,
  ...args: Args
): T {
  return new Constructor(...args);
}

class TaggedDog extends Animal {
  constructor(name: string, public tag: number) {
    super(name);
  }
}

const taggedDog = createAnimalInstance(TaggedDog, '구름이', 7);
console.log(taggedDog.name, taggedDog.tag); // 구름이 7
// createAnimalInstance(TaggedDog, '구름이');      // 예상 오류: tag 인자가 빠짐
// createAnimalInstance(TaggedDog, '구름이', '7'); // 예상 오류: tag는 number

function printLengthIfString<T extends string | string[]>(data: T): void {
    if (typeof data === 'string') {
        console.log(`문자열 길이: ${data.length}`);
    } else {
        console.log(`배열 길이: ${data.length}`);
    }
}

printLengthIfString("hello"); // 문자열 길이: 5
printLengthIfString(["a", "b", "c"]); // 배열 길이: 3

// printLengthIfString(123); // Error: 'number' 형식은 'string | string[]' 형식에 할당할 수 없습니다.

function mergeObjects<T extends object, U extends object>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 };
}

const merged = mergeObjects({ a: 1, b: "hello" }, { c: true, d: [1, 2] });
// merged의 타입은 { a: number; b: string; } & { c: boolean; d: number[]; }
// 이는 { a: number; b: string; c: boolean; d: number[]; } 와 동일합니다.

// mergeObjects(1, {}); // Error: 'number' 형식은 'object' 형식에 할당할 수 없습니다.