GetMiddleElement

In this medium-level challenge, you'll implement a GetMiddleElement type that extracts the middle element(s) from a tuple type, returning a single-element tuple for odd-length arrays and a two-element tuple for even-length arrays.

type simple1 = GetMiddleElement<[1, 2, 3, 4, 5]>, // expected to be [3]
type simple2 = GetMiddleElement<[1, 2, 3, 4, 5, 6]> // expected to be [3, 4]

type cases = [
  Expect<Equal<GetMiddleElement<[]>, []>>,
  Expect<Equal<GetMiddleElement<[1, 2, 3, 4, 5]>, [3]>>,
  Expect<Equal<GetMiddleElement<[1, 2, 3, 4, 5, 6]>, [3, 4]>>,
  Expect<Equal<GetMiddleElement<[() => string]>, [() => string]>>,
  Expect<
    Equal<GetMiddleElement<[() => number, '3', [3, 4], 5]>, ['3', [3, 4]]>
  >,
  Expect<
    Equal<
      GetMiddleElement<[() => string, () => number]>,
      [() => string, () => number]
    >
  >,
  Expect<Equal<GetMiddleElement<[never]>, [never]>>,
]
// @ts-expect-error
type error = GetMiddleElement<1, 2, 3>

Detailed Explanation

type GetMiddleElement<T extends unknown[]> =
  T extends []
    ? []
    : T extends [infer Single]
      ? [Single]
      : T extends [infer A, infer B]
        ? [A, B]
        : T extends [unknown, ...infer Middle, unknown]
          ? GetMiddleElement<Middle>
          : never;

How it works:

• The base case handles an empty array by returning an empty tuple [].
• A single-element tuple [Single] is returned as-is, since one element is trivially the middle.
• A two-element tuple [A, B] is also a base case, returning both elements as the "middle" pair.
• For tuples with three or more elements, we strip the first and last elements using [unknown, ...infer Middle, unknown] and recurse on the remaining Middle portion.
• This recursive peeling from both ends continues until we reach either one or two elements, which gives us the middle.

This challenge helps you understand recursive tuple manipulation and variadic tuple inference, and how to apply these concepts in real-world scenarios.