CheckRepeatedTuple

In this medium-level challenge, you'll implement CheckRepeatedTuple<T> which checks whether a tuple type contains any duplicated members, returning true or false.

type CheckRepeatedTuple<[1, 2, 3]>   // false
type CheckRepeatedTuple<[1, 2, 1]>   // true

type cases = [
  Expect<Equal<CheckRepeatedTuple<[number, number, string, boolean]>, true>>,
  Expect<Equal<CheckRepeatedTuple<[number, string]>, false>>,
  Expect<Equal<CheckRepeatedTuple<[1, 2, 3]>, false>>,
  Expect<Equal<CheckRepeatedTuple<[1, 2, 1]>, true>>,
  Expect<Equal<CheckRepeatedTuple<[]>, false>>,
  Expect<Equal<CheckRepeatedTuple<string[]>, false>>,
  Expect<
    Equal<
      CheckRepeatedTuple<
        [number, 1, string, '1', boolean, true, false, unknown, any]
      >,
      false
    >
  >,
  Expect<Equal<CheckRepeatedTuple<[never, any, never]>, true>>,
]

Detailed Explanation

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

How it works:

• Includes<T, V> is a helper type that checks if a value V exists anywhere in the tuple T using strict Equal comparisons to handle edge cases like any, never, and unknown
• CheckRepeatedTuple<T> processes the tuple by extracting the first element with infer First and the rest with ...infer Rest
• For each element, it checks whether that element appears in the remaining portion of the tuple using Includes<Rest, First>
• If a duplicate is found, it immediately returns true
• If no duplicate is found for the current element, it recurses with CheckRepeatedTuple<Rest> to check subsequent elements
• The base case (empty tuple) returns false, meaning no duplicates were found
• Using Equal instead of extends ensures correct handling of special types -- for example, any and unknown are treated as distinct types

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