TS Type Challenges · Part 4 — infer Mastery

type MyParameters<T extends (...args: any[]) => any> = T extends (
  ...args: infer P
) => any
  ? P
  : never;

Cơ chế

Ta khớp T với mẫu hàm và đặt infer P ở ô rest-parameter. Bất kỳ thứ gì chiếm ...args trong hàm thật trở thành tuple type P.

Từng dòng

type MyParameters<T extends (...args: any[]) => any> = T extends (
  ...args: infer P
) => any
  ? P
  : never;

1. ràng buộc: chỉ callable type mới vào utility này.
2. conditional thứ hai: khớp hình dạng T; bắt cả tuple tham số thành P.
3. bỏ qua return; any khớp mọi thứ.
4. thành công: đáp án là tuple tham số đã bắt.
5. không nên xảy ra với ràng buộc, nhưng thỏa hình dạng conditional.

Đánh giá type từng bước

type Fn = (a: number, b: string) => void;
type R = MyParameters<Fn>;

// step 1: T = (a: number, b: string) => void
//         constraint passes — it is a function type

// step 2: does (a: number, b: string) => void extend (...args: infer P) => any?
//         Yes. The compiler binds P = [a: number, b: string]

// step 3: true branch → P
type R = [a: number, b: string];

So với MyReturnType ở Phần 1: cùng mẫu, infer chỉ chuyển từ ô return sang ô tham số.

// ReturnType pattern — infer in the RETURN slot
type MyReturnType<T extends (...args: any[]) => any> =
  T extends (...args: any[]) => infer R ? R : never;

// Parameters pattern — infer in the ARGS slot (this challenge)
type MyParameters<T extends (...args: any[]) => any> =
  T extends (...args: infer P) => any ? P : never;

Cạm bẫy

• Ô rest vs từng tham số — ...args: infer P bắt cả danh sách thành một tuple, kể cả label và optional.
• Hàm overload — Parameters (và bản này) resolve theo overload cuối trong quy tắc inference của TypeScript.
• Ràng buộc ngoài rất quan trọng — không có T extends (...args: any[]) => any, truyền non-function sẽ rơi vào hành vi lạ.

Tóm lại: Đặt infer chỗ tuple tham số nằm — vị trí ...args — compiler trả lại thành type có tên.

type Last<T extends any[]> = T extends [...any[], infer L] ? L : never;

Cơ chế — rest đứng đầu trong mẫu tuple

Trong First ta khớp [infer F, ...any[]] — bắt đầu, bỏ đuôi. Ở đây ta lật lại: [...any[], infer L] nghĩa là “bao nhiêu phần tử cũng được, rồi bắt phần tử cuối vào L”.

TypeScript cho phép rest ở đầu mẫu tuple chính là để bóc từ phía cuối.

Từng dòng

type Last<T extends any[]> = T extends [...any[], infer L] ? L : never;

1. T phải là array/tuple.
2. mẫu: không hoặc nhiều phần tử bất kỳ, rồi một phần tử cuối bắt thành L.
3. ô “mọi thứ trước cuối”; ta bỏ.
4. ô cuối; compiler gán type phần tử cuối.
5. thành công trả type cuối; tuple rỗng không khớp → never.

Đánh giá type từng bước

type R = Last<[3, 2, 1]>;

// step 1: T = [3, 2, 1]
// step 2: does [3, 2, 1] extend [...any[], infer L]?
//         Match: ...any[] absorbs [3, 2], infer L binds L = 1
// step 3: true branch → L → 1
type R = 1;

Tuple rỗng:

type E = Last<[]>;

// step 1: T = []
// step 2: does [] extend [...any[], infer L]?
//         No — there is no final element to capture
// step 3: false branch → never
type E = never;

Một phần tử:

type R = Last<['only']>;

// step 2: ...any[] absorbs [] (zero elements), infer L binds L = 'only'
type R = 'only';

Cạm bẫy

• Rest đầu là đối xứng rest cuối — [infer H, ...any[]] cho đầu, [...any[], infer T] cho đuối.
• Tuple độ dài 1 vẫn khớp — rest đầu có thể rỗng.
• Đừng nhầm với T[number] — nó cho union mọi phần tử (3 | 2 | 1), không phải phần tử cuối.

Tóm lại: Lật mẫu First — ...any[] đầu nuốt prefix, infer L cuối bắt ô cuối của suffix.

type Pop<T extends any[]> = T extends [...infer Rest, any] ? Rest : [];

Cơ chế

Giờ infer nằm ở rest còn ô cuối bị bỏ bằng any trần. Vậy Rest bắt mọi thứ trừ phần tử cuối.

Từng dòng

type Pop<T extends any[]> = T extends [...infer Rest, any] ? Rest : [];

1. bắt tất cả trừ cuối vào Rest; phần cuối phải tồn tại và khớp any.
2. tuple prefix ta muốn trả.
3. không infer — ta vứt type cụ thể của phần tử cuối.
4. tuple rỗng không khớp (không có ô cuối) → trả [], không phải never, vì kết quả vẫn là tuple.

Đánh giá type từng bước

type R = Pop<[3, 2, 1]>;

// step 1: T = [3, 2, 1]
// step 2: does [3, 2, 1] extend [...infer Rest, any]?
//         Rest = [3, 2], last element 1 matches `any`
// step 3: true branch → Rest → [3, 2]
type R = [3, 2];

type R = Pop<['solo']>;

// step 2: Rest = [], last element 'solo' matches `any`
type R = [];

type R = Pop<[]>;

// step 2: pattern requires at least one trailing element — fails
type R = [];

Cạm bẫy

• Đối xứng với Shift — Shift dùng [any, ...infer Rest] bỏ phần tử đầu; cùng mẹo, đầu đối diện.
• never vs [] khi thất bại — Last trả never (không có giá trị); Pop trả [] (tuple rỗng vẫn là kết quả tuple hợp lệ).
• Bốn thao tác bóc tuple — First, Last, Pop, Shift cùng họ mẫu tuple.

Đối xứng, giờ bạn viết được cả Shift ([any, ...infer Rest]) — bốn cái này (First, Last, Pop, Shift) đều là cùng một mẹo mẫu tuple.

Tóm lại: Đổi ô nào có infer — bắt rest prefix, bỏ ô cuối bằng any trần.

type AppendArgument<Fn extends (...args: any[]) => any, A> = Fn extends (
  ...args: infer P
) => infer R
  ? (...args: [...P, A]) => R
  : never;

Cơ chế

Hai infer trong một lần khớp mẫu — compiler gán cả P (tuple tham số) và R (return) cùng lúc. Rồi dựng lại: spread tham số cũ, nối A, giữ R.

Từng dòng

type AppendArgument<Fn extends (...args: any[]) => any, A> = Fn extends (
  ...args: infer P
) => infer R
  ? (...args: [...P, A]) => R
  : never;

1. Fn phải gọi được.
2. bắt tham số hiện có thành tuple P.
3. bắt return thành R.
4. hàm mới: spread tham số cũ, rồi A, cùng return.
5. variadic tuple spread từ Concat (Phần 1).

Đánh giá type từng bước

type Fn = (a: number, b: string) => number;
type R = AppendArgument<Fn, boolean>;

// step 1: Fn = (a: number, b: string) => number, A = boolean

// step 2: does Fn extend (...args: infer P) => infer R?
//         P = [a: number, b: string]
//         R = number

// step 3: rebuild (...args: [...P, A]) => R
//         [...P, A] = [...[a: number, b: string], boolean]
//                 = [a: number, b: string, boolean]

// step 4: result
type R = (a: number, b: string, boolean) => number;
// Note: TypeScript may display the third param without a name — that's cosmetic

Cạm bẫy

• Nhiều infer trong một mẫu — mọi gán xảy ra trong một lần khớp; thứ tự infer P vs infer R không quan trọng.
• Label tham số được giữ qua [...P, A] — (a: number, b: string) vẫn có label.
• Mẫu này mở rộng được — prepend ([A, ...P]), đổi return, curry — đều là bắt-rồi-dựng-lại.

Bài này gộp bắt bằng infer với variadic tuple spread từ Concat (Phần 1) — bắt rồi dựng lại là cốt lõi của hầu hết bài thao tác hàm.

Tóm lại: infer đôi để đọc hàm, tuple spread để viết hàm mới.

type ToNumber<S extends string> = S extends `${infer N extends number}`
  ? N
  : never;

Cơ chế — infer N extends number

Trước TypeScript 4.8 bạn phải đếm ký tự để parse số ở tầng type. Giờ ${infer N extends number} làm hai việc cùng lúc:

1. Khớp cả string như mẫu template literal rồi bắt substring.
2. Ràng buộc phần bắt: N extends number phải đúng, ép string literal số sang type number tương ứng.

Từng dòng

type ToNumber<S extends string> = S extends `${infer N extends number}`
  ? N
  : never;

1. input là string literal type.
2. mẫu: cả string phải infer được thành literal number.
3. bắt N, nhưng chỉ khi text bắt được là literal số hợp lệ và thu hẹp thành number.
4. thành công: N là 42, không phải '42'.
5. string không phải số thì ràng buộc thất bại.

Đánh giá type từng bước

type A = ToNumber<'42'>;

// step 1: S = '42'
// step 2: does '42' extend `${infer N extends number}`?
//         Capture N from the whole string '42'
//         Check: does 42 (as a number literal type) extend number? Yes.
//         N is narrowed to the number literal 42
// step 3: true branch → 42
type A = 42;

Input không hợp lệ:

type B = ToNumber<'abc'>;

// step 2: capture 'abc' as N, then check N extends number — fails
// step 3: false branch → never
type B = never;

Trường hợp biên:

type C = ToNumber<'3.14'>;
// step 2: '3.14' is a valid numeric literal in TS — N = 3.14
type C = 3.14;

Cạm bẫy

• String literal vs number literal — infer N thuần giữ '42'; infer N extends number có ràng buộc cho 42.
• Ràng buộc có thể thất bại âm thầm — input không hợp lệ không báo lỗi; resolve thành never.
• Cùng mẫu cho primitive khác — `${infer B extends boolean}`, `${infer I extends bigint}` nối thế giới string và giá trị.
• Nền cho Phần 8 — số học tầng type parse chữ số bằng mẹo này.

Nếu string không phải số hợp lệ ('abc'), ràng buộc thất bại, rơi xuống never. Cùng mẫu ép sang bigint, boolean,… — đó là cây cầu giữa thế giới string và số mà ta sẽ dựa nhiều ở Phần 8 (số học tầng type).

Tóm lại: infer có ràng buộc bắt và ép kiểu trong một lần khớp template literal.

type Whitespace = ' ' | '\n' | '\t';

type TrimLeft<S extends string> = S extends `${Whitespace}${infer Rest}`
  ? TrimLeft<Rest>
  : S;

Cơ chế

Mẫu `${Whitespace}${infer Rest}` hỏi: “S có bắt đầu bằng bất kỳ ký tự trắng nào, theo sau là Rest không?”. Nếu có, đệ quy trên Rest; nếu không, trả S (base case).

Từng dòng

type Whitespace = ' ' | '\n' | '\t';

type TrimLeft<S extends string> = S extends `${Whitespace}${infer Rest}`
  ? TrimLeft<Rest>
  : S;

1. union ba ký tự ta coi là “rác đầu”.
2. đoạn đầu phải là một trong các ký tự đó.
3. bắt mọi thứ sau ký tự đầu.
4. đệ quy: thử cắt tiếp từ string ngắn hơn.
5. base case: ký tự đầu không phải trắng → xong.

Đánh giá type từng bước

type R = TrimLeft<'  hello'>;

// ── call 1: TrimLeft<'  hello'>
// step 1: S = '  hello'
// step 2: does '  hello' extend `${Whitespace}${infer Rest}`?
//         Whitespace matches ' ' (first char)
//         Rest = ' hello'
// step 3: recurse → TrimLeft<' hello'>

// ── call 2: TrimLeft<' hello'>
// step 2: Whitespace matches ' ', Rest = 'hello'
// step 3: recurse → TrimLeft<'hello'>

// ── call 3: TrimLeft<'hello'>
// step 2: 'h' is not in Whitespace — pattern fails
// step 3: base case → 'hello'

type R = 'hello';

Khoảng trắng hỗn hợp:

type R = TrimLeft<'\n\thello'>;

// call 1: '\n' matches Whitespace, Rest = '\thello' → recurse
// call 2: '\t' matches Whitespace, Rest = 'hello' → recurse
// call 3: 'h' fails → 'hello'
type R = 'hello';

Cạm bẫy

• Union trong template — `${Whitespace}` thành công nếu ký tự đầu là bất kỳ thành viên union nào.
• Độ sâu đệ quy — khoảng trắng đầu quá dài có thể chạm giới hạn đệ quy của TypeScript (ta xử lý đếm an toàn ở Phần 5).
• TrimRight là đối xứng — đặt infer Rest trước whitespace: S extends `${infer Rest}${Whitespace}`.
• Ghép TrimRight thành Trim — ta đào sâu string type ở Phần 7.

Whitespace là union rất quan trọng: mẫu khớp khi ký tự đầu là bất kỳ một trong ba. Ghép với TrimRight là ra Trim — ta sẽ đào sâu string type ở Phần 7.

Tóm lại: infer trong template literal + đệ quy bóc từng ký tự đầu đến khi mẫu gãy.

type Shift<T extends any[]> = T extends [any, ...infer Rest] ? Rest : [];
type Unshift<T extends any[], E> = [E, ...T];

Shift đối xứng Pop nhưng từ đầu: [any, ...infer Rest] bỏ đầu bằng any trần, bắt đuôi thành Rest. Unshift không cần infer — chỉ là tuple spread, giống [E, ...T] bạn viết ở tầng giá trị.

infer giới thiệu một biến type bằng cách khớp mẫu type đang kiểm tra. Việc khớp chỉ xảy ra ở mệnh đề extends; tới nhánh true thì biến đã được gán và sẵn sàng dùng. Đặt infer sau ? thì chẳng có gì để khớp — compiler không biết destructure hình dạng nào.

// ✅ infer participates in the pattern match
type Ok<T> = T extends Promise<infer V> ? V : T;

// ❌ syntax error — infer is not allowed here
type Bad<T> = T extends Promise<any> ? infer V : T;

Coi extends là vế trái của destructuring type — infer phải nằm chỗ có mẫu.