TypeScript 타입변수 추론 진단
언제 — 함수 호출에서 T 가 엉뚱하게 정해졌을 때. 증상으로 찾아 들어간다.
| 증상 | 원인 | 절 |
|---|---|---|
이상하게 unknown 이 나온다 |
그 변수가 바운드·조건 부분·인자에 안 드러난 위치에만 있다 | §수집 제외, §우회 |
| 형제 타입인데 첫 인자로 고정됐다 | 접기의 “첫 멤버 유지” | §해소 |
| 추론은 됐는데 그 값으로 체크가 깨진다 | 조건부 가지를 평가하지 않는다 | §1.4 |
| union 인자에서만 실패한다 | 분배 후보가 재-union 되지 않는다 | §1.6, §해소 |
모델 — 추론은 딱 2단계다
source 타입(인자 + 기대 반환) ┐
├─▶ ① 수집: 나란히 walk, bare T 만나면 후보 기록
target 타입(매개변수 + 반환) ┘ ├─▶ 공변(출력) 후보 리스트
└─▶ 반변(입력) 후보 리스트
② 해소: 각 리스트를 하나로 접기 → T 주입
③ *그제서야* 일반 타입 체크수집과 타입 체크는 별개 단계다. 이게 조건부 타입에서 폭발한다.
하나만 외운다면 — 후보는 오직 source 타입과 그 구조적 부분에서만 줍는다. extends 바운드·기본값·조건부의 조건 부분·상위 타입은 절대 후보가 안 된다. 기괴한 사례 대부분이 이 한 문장의 따름정리다.
수집 규칙
1.1 기본 — target 에서 벌거벗은 타입변수를 만나면 그 자리 source 를 후보로 기록, 아니면 구조 안으로 walk.
function f<A, B, C>(x: A, y: (a: B) => C) {}
f(true, (it: number) => "hello") // A = boolean, B = number, C = stringB 는 함수 매개변수 위치라 반변, A·C 는 공변. 후보는 두 리스트에 나뉘어 쌓인다.
1.2 타입 별칭 안으로도 walk 한다. type ArrayContainer<T> = T[] | { array: T[] } 에 number[] 를 매칭하면 배열 쪽이 맞아 E = number.
1.3 조건부는 RHS(결과 가지)에서 수집한다. 조건 부분(A extends string)은 후보를 만들지 않는다.
type Pair<A, B> = A extends string ? Map<A, B> : [A, B]
function f<A, B>(x: Pair<A, B>) {}
f([1, 2]) // A = number, B = number (두 번째 가지)
f(new Map([["a",1]])) // A = string, B = number (첫 번째 가지)1.4 ★조건부 타입은 가지를 “평가”하지 않는다.
f(["a", "b"]) // TS2345: string[] is not assignable to Map<string, string>후보는 두 번째 가지에서 수집돼 A = string, B = string 이 되는데, 체크는 A = string 이므로 Pair<string,string> = Map<string,string> 인 첫 번째 가지로 걸어간다. 수집이 걸은 가지 ≠ 체크가 걷는 가지.
1.5 infer T 는 새 타입변수를 추가한다. 조건 부분이라도 infer 만은 예외로 새 변수를 만든다. Awaited<Promise<Promise<number>>> 에서 첫 전개의 U = Promise<number> 와 재귀 전개의 U = number 는 별개 변수다.
1.6 union 은 분배된다. source 가 union 이고 target 이 bare T 가 아니면 각 가지에 대해 독립 재실행하고, 결과 후보들은 같은 리스트에 쌓이고 다시 union 되지 않는다.
1.7 source 의 intersection 은 원칙적으로 유지되지만, 객체 타입({ x: T })에 구조적으로 매칭해야 할 때만 병합된 객체 형태가 생성된다.
1.8 수집에서 제외되는 것 — 조건부의 조건 부분, extends 바운드, 기본값, source 의 상위 타입. Elephant<Savannah> 에서 후보가 될 수 있는 건 Elephant<Savannah> 와 Savannah 뿐이고 Animal·Location 은 절대 안 된다.
따름정리 — number 인자로 string 바인딩을 만들 방법은 없다. 필요하면 §우회.
target intersection 의 특이동작
모호하면 아무것도 기록하지 않는다 — 임의 선택조차 안 한다.
function foo<A, B>(it: A & B) {}
foo(42) // A = unknown, B = unknown (unknown & unknown = unknown)타입변수 “peel off” 는 차집합이 아니라 포획 유용성을 최대화하는 휴리스틱이다.
function foo<A>(it: A & { x: number }) {}
foo({ x: 42, y: 42 }) // A = { x: number, y: number } ← 전체 객체
function bar<A>(it: A & number) {}
bar(42 as number & { brand: "USD" }) // A = { brand: "USD" }
function qux<A>(it: A & "a") {}
qux("a" as "a" & { brand: 1 }) // A = { brand: 1 }A & {객체} 면 전체 객체를, A & 리터럴 이면 정밀 리터럴을 남기는 쪽으로 동작한다. intersection 순서는 source·target 모두 무관.
해소 규칙
철칙 — 해소 결과는 후보 리스트에 없는 타입으로 절대 안 정해진다. [Cat, Dog] → Dog(첫 멤버). 공통 상위인 Animal 도 Cat|Dog 도 아니다.
리스트별 접기 (공변 기준, 반변은 관계 반전)
- 후보가 전부 같은 base 의 리터럴이면 → union
- 아니면 다른 모두의 strict 상위인 후보를 찾으면 → 그것
- 없으면 느슨한 상위 체크로 left-reduce → 상위가 리스트에 없으면 첫 후보 반환
declare function f<T>(x: T, y: T): T
f(d, a) // Animal (Animal 이 Dog 의 strict 상위)
f(d, c) // Dog (형제 → 첫 멤버 유지)
f("a", 1) // "a" (다른 base → 첫 멤버 유지)
f("a","b") // "a"|"b" (같은 base 리터럴 → union)익명 리터럴 객체/배열이 여럿이면(공변 한정) 접기 전에 union 한다. named 타입끼리는 안 된다 — 서로 다른 named 타입을 같은 T 에 맞추려던 건 아닐 거라는 의도 추정이다.
공변·반변이 둘 다 있으면 ① 기본은 반변이 이긴다 ② 반변 결과가 바운드를 못 지키면 공변으로 폴백 ③ 공변 결과가 반변 결과의 하위 타입이면 공변이 이긴다(더 정밀하므로).
function f<T>(x: T, sink: (t: T) => void) { sink(x) }
f(new Dog(), (_: Animal) => {}) // T = Dog (공변이 반변의 하위 → 공변 승)빈 리스트·바운드 — 둘 다 비면 파라미터의 기본값, 없으면 unknown. 해소값이 바운드를 못 지키면 바운드로 교체.
기본값은 별칭이 아니라 “해소 대상 파라미터”에서 찾는다.
type Result<V, E = never> = { okay: V } | { error: E }
function f<V, E>(x: Result<V, E>) {}
f({ okay: 42 }) // E = unknown — never 가 아니다Result 의 never 기본값은 Result<X> 처럼 인자를 생략할 때만 발동한다. 호출부에서 never 를 원하면 function f<V, E = never> 로 선언한다.
우선순위 비트 — 수집 시 후보마다 태그가 붙고, 더 높은 우선순위 후보가 오면 낮은 것들은 전부 지워진다. ReturnType(호출 문맥의 반환 타입 추론, 함수를 인자로 넘길 때), LiteralKeyof(리터럴을 keyof T 에 매칭), MappedTypeConstraint 셋은 “combination” 우선순위라 상위/하위 대신 union(공변)/intersection(반변) 으로 해소한다.
우회 패턴
제네릭 함수 안에서는 타입변수가 미확정이라 조건부를 평가할 수 없다. Exclude 로 특정 타입을 막고 싶으면 파라미터 위치에서 타입변수를 추론하는 형태만 동작한다.
function foo(x: Exclude<unknown, number>) {} // 파라미터가 unknown 으로 축약 → foo(42) 허용
function bar<X>(x: Exclude<X, number>) {} // X = number 추론 → Exclude<number,number> = never
function quz<X, Y extends Exclude<X, number>>(x: Y) {} // X 는 바운드에만 → 추론 불가 → unknown
bar(42) // 에러: 42 not assignable to never ← 이것만 제대로 막는다넘겨 쓸 때는 타입을 그대로 재현한다 — function quuz<V>(x: Exclude<V, number>) { bar(x) } 는 조건을 평가 못 해도 두 x 가 구조적으로 동일해서 통과한다.
NoInfer<T> — 그 위치에서 T 의 후보를 수집하지 않는다. 다른 위치에서 정해진 T 를 그대로 강제할 때.
가장 짜증나는 상황 — 추론하고 싶은 타입변수가 인자에 드러나지 않을 때. extends 바운드는 후보를 안 만들기 때문이다.
function foo<K, V, T extends Map<K, V>>(map: T, key: K): [T, V] { return [map, map.get(key)!] }
foo(new Map([[42, "42"]]), 42) // [Map<number,string>, unknown] ← V = unknown해법 둘, 트레이드오프가 있고 둘 다는 안 된다.
// 1) extractor 타입 — 캐스트 필요, union 지원
type GetV<T extends Map<unknown, unknown>> = T extends Map<unknown, infer V> ? V : never
function foo<K, V, T extends Map<K, V>>(map: T, key: K): [T, GetV<T>] {
return [map, map.get(key) as GetV<T>]
}
// 2) map: T & Map<K, V> — 캐스트 불필요, union 인자에서 깨짐
function foo<K, V, T extends Map<K, V>>(map: T & Map<K, V>, key: K): [T, V] { … }함정 — A extends string ? { [key in A]: B } : … 형태의 매핑드 타입에서는 키/값 추론이 안 된다. [A, B] 같은 구조로 쓴다. 그리고 일부 IDE 는 NoInfer 를 못 뚫고 헛경고를 낸다.