번외편) Typescript와 Generic 비교

Typescript와 Generic 은 거의 동일하다고 봐도 된다.

다만 실무에서 더 정확하게 표현하면

TypeScript Generic은 Java/C# Generic과 매우 유사한 컴파일 타임 타입 시스템이며, Java는 여기에 Type Erasure라는 구현 방식을 사용한다.

이라고 이해하면 된다.

TypeScript                    Java

Array<string>   <===>    List<String>

        │                         │
        │ 컴파일                  │ 컴파일
        ▼                         ▼

Array                  List (Type Erasure)

        │                         │
        │ 런타임                  │ 런타임
        ▼                         ▼

JS 엔진 실행              JVM 실행

---

1. 둘 다 컴파일러를 위한 기능이다. ⭐⭐⭐

TypeScript

 

function identity<T>(value: T): T {
    return value;
}

 

컴파일 후

 

function identity(value) {
    return value;
}

 

T가 사라진다.

---

Java

 

public <T> T identity(T value) {
    return value;
}

 

컴파일 후 JVM에서는

T 정보가 제거(Type Erasure)

 

된다.

즉,

둘 다

실행(Runtime)이 아니라 컴파일러가 타입을 검사하기 위한 문법

이다.

---

2. 둘 다 타입 추론을 한다.

TypeScript

 

identity("hello"); // T = string
identity(100);     // T = number

 

---

Java

 

identity("hello"); // T = String
identity(100);     // T = Integer

 

거의 동일하다.

---

3. 둘 다 실행 시에는 타입 정보가 거의 없다.

그래서

TypeScript도

 

function test<T>() {
    // 런타임에는 T를 알 수 없음
}

 

Java도

 

<T> void test() {
    // 런타임에는 T를 알 수 없음
}

 

이다.

---

진짜 차이점은 여기다.

Java

Generic을 추가하기 전에 이미 Java가 존재했다.

Java 1.0 (1995)

 

↓

수많은 라이브러리와 JVM이 존재

↓

Java 5 (2004)

 

에서 Generic 추가

↓

기존 코드와 JVM을 깨지 않기 위해

Type Erasure

 

를 선택

---

TypeScript

애초에

JavaScript

 

위에 타입 시스템을 얹기 위해 만들어졌다.

그래서

Type은 처음부터 컴파일러만 사용하는 정보

 

라는 철학으로 설계되었다.

 

결과론적으로 철학이 같게 됨

Generic은 컴파일러를 위한 타입 시스템이다.

실행 시에는 타입 정보가 없다.

즉 차이는 "제약"이 아니라 "탄생 배경"이다.

Java	TypeScript
기존 언어에 Generic 추가	기존 JS에 타입 시스템 추가
하위 호환성을 위해 Type Erasure 선택	원래부터 타입은 컴파일 전용
런타임에는 Generic 정보 없음	런타임에는 타입 정보 없음

---

 

구태여 차이를 말하자면 

TypeScript는 Java보다 타입 시스템이 훨씬 강력하다.

예를 들어

조건부 타입

 

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

 

매핑 타입

 

type Readonly<T> = {
    readonly [P in keyof T]: T[P];
}

 

Template Literal Type

 

type EventName<T extends string> = `on${T}`;

 

같은 기능이 있다.

이건 Java Generic에는 없는 기능이다.

---

오히려 더 좋은 표현은

TypeScript Generic은 Java Generic을 훨씬 순수하게 일반화한 타입 시스템이다.

둘 다

컴파일러만 타입을 알고

↓

컴파일 후 타입 정보 제거

↓

런타임은 타입을 모른다.

 

라는 동일한 철학을 가진다.

---

그래서 개인적으로는 Generic을 이렇게 설명하는 게 가장 이해하기 쉽다고 생각한다.

                TypeScript
                     ▲
                     │
      "컴파일러만 아는 타입"

                     │

         Java Generic(Type Erasure)

                     │

      "컴파일러만 아는 타입"

 

즉,

Java Generic과 TypeScript Generic은 생각보다 훨씬 같은 개념이다.

차이점을 찾기보다,

"둘 다 컴파일러를 위한 타입 시스템이고, 런타임에는 대부분 사라진다."

라고 이해하는 것이 훨씬 본질에 가깝고, new T(), T.class, instanceof, static T 같은 모든 제약도 하나의 원리로 자연스럽게 설명된다.

---

개발자 관점에서 기억하면 좋은 한 문장

Java Generic ≒ TypeScript Generic

 

이라고 생각해도 대부분 맞다.

그리고 Generic에서 이해가 안 되는 상황이 나오면 항상

"이건 컴파일러만 아는 정보인가? 런타임에도 존재하는 정보인가?"

를 먼저 생각하면 된다.

---

실제로 이 관점이 왜 좋은가

예를 들어

 

new T();

 

를 보면 예전에는

"외워야 하는 문법"

처럼 보인다.

하지만 TypeScript 관점으로 보면

 

new T();

 

를 상상하는 순간

"어? T는 컴파일러만 아는 타입인데 런타임에서 어떻게 new를 하지?"

라는 생각이 자연스럽게 든다.

그래서 Java Generic을 TypeScript의 타입 시스템과 거의 동일한 개념으로 이해하는 것은 매우 좋은 학습 방법이고, 실무에서도 이런 식으로 설명하는 개발자가 많다.