Chunk

In this medium-level challenge, you'll implement Chunk<T, N> which splits a tuple into groups of size N, similar to Lodash's _.chunk function.

type exp1 = Chunk<[1, 2, 3], 2> // expected to be [[1, 2], [3]]
type exp2 = Chunk<[1, 2, 3], 4> // expected to be [[1, 2, 3]]
type exp3 = Chunk<[1, 2, 3], 1> // expected to be [[1], [2], [3]]

Detailed Explanation

type Chunk<
  T extends any[],
  N extends number,
  Current extends any[] = []
> = T extends [infer First, ...infer Rest]
  ? [...Current, First]['length'] extends N
    ? [[...Current, First], ...Chunk<Rest, N>]
    : Chunk<Rest, N, [...Current, First]>
  : Current extends []
    ? []
    : [Current]

How it works:

• The type takes three parameters: the tuple T to chunk, the chunk size N, and an accumulator Current that builds up the current chunk (defaults to an empty tuple)
• T extends [infer First, ...infer Rest] extracts the first element and the remaining elements from the input tuple
• [...Current, First]['length'] extends N checks if adding the current element to the accumulator would complete a chunk of size N
• If the chunk is complete, it emits [...Current, First] as a finished chunk and recursively processes the remaining elements with a fresh accumulator
• If the chunk is not yet full, it adds the element to the accumulator with Chunk<Rest, N, [...Current, First]> and continues
• When the input tuple is empty, if the accumulator has elements (Current is not empty), it is emitted as the final (potentially smaller) chunk; otherwise an empty tuple is returned

This challenge helps you understand recursive tuple partitioning with accumulator patterns, and how to apply these concepts in real-world scenarios.