All

In this medium-level challenge, you'll implement All<T, V> which returns true if all elements of the tuple T are exactly equal to the type V, and false otherwise.

type Test1 = [1, 1, 1]
type Test2 = [1, 1, 2]
 
type Todo = All<Test1, 1> // should be same as true
type Todo2 = All<Test2, 1> // should be same as false

type cases = [
  Expect<Equal<All<[1, 1, 1], 1>, true>>,
  Expect<Equal<All<[1, 1, 2], 1>, false>>,
  Expect<Equal<All<['1', '1', '1'], '1'>, true>>,
  Expect<Equal<All<['1', '1', '1'], 1>, false>>,
  Expect<Equal<All<[number, number, number], number>, true>>,
  Expect<Equal<All<[number, number, string], number>, false>>,
  Expect<Equal<All<[null, null, null], null>, true>>,
  Expect<Equal<All<[[1], [1], [1]], [1]>, true>>,
  Expect<Equal<All<[{}, {}, {}], {}>, true>>,
  Expect<Equal<All<[never], never>, true>>,
  Expect<Equal<All<[any], any>, true>>,
  Expect<Equal<All<[unknown], unknown>, tr

Detailed Explanation

type All<T extends unknown[], V> = T extends [infer First, ...infer Rest]
  ? Equal<First, V> extends true
    ? All<Rest, V>
    : false
  : true

How it works:

• T extends [infer First, ...infer Rest] recursively deconstructs the tuple, extracting the first element and the remaining elements
• Equal<First, V> extends true uses the Equal utility to perform a strict type equality check between the current element and the target type V, which correctly handles edge cases like any, unknown, never, and union types
• If the first element matches, All<Rest, V> recurses on the remaining elements
• If the first element does not match, the type immediately returns false
• When the tuple is empty (base case), it returns true since all elements have been checked

This challenge helps you understand recursive tuple traversal and strict type equality checking, and how to apply these concepts in real-world scenarios.