IndexOf

In this medium-level challenge, you'll implement the type-level version of Array.indexOf, creating an IndexOf<T, U> type that takes a tuple T and a type U, returning the index of the first occurrence of U in T (or -1 if not found).

type Res = IndexOf<[1, 2, 3], 2>; // expected to be 1
type Res1 = IndexOf<[2,6, 3,8,4,1,7, 3,9], 3>; // expected to be 2
type Res2 = IndexOf<[0, 0, 0], 2>; // expected to be -1

type cases = [
  Expect<Equal<IndexOf<[1, 2, 3], 2>, 1>>,
  Expect<Equal<IndexOf<[2, 6, 3, 8, 4, 1, 7, 3, 9], 3>, 2>>,
  Expect<Equal<IndexOf<[0, 0, 0], 2>, -1>>,
  Expect<Equal<IndexOf<[string, 1, number, 'a'], number>, 2>>,
  Expect<Equal<IndexOf<[string, 1, number, 'a', any], any>, 4>>,
  Expect<Equal<IndexOf<[string, 'a'], 'a'>, 1>>,
  Expect<Equal<IndexOf<[any, 1], 1>, 1>>,
]

Detailed Explanation

type IndexOf<T extends unknown[], U, Counter extends unknown[] = []> =
  T extends [infer First, ...infer Rest]
    ? Equal<First, U> extends true
      ? Counter['length']
      : IndexOf<Rest, U, [...Counter, unknown]>
    : -1;

How it works:

• The type recursively walks through the tuple T, examining one element at a time using [infer First, ...infer Rest].
• A Counter tuple accumulates elements to track the current index -- its length property gives us the numeric index.
• For each element, we use Equal<First, U> for strict type equality checking (this correctly distinguishes between any, number, string, etc.).
• If a match is found, we return Counter['length'] as the index.
• If we exhaust the entire tuple without finding a match, we return -1.

This challenge helps you understand recursive tuple traversal with index tracking and strict type equality, and how to apply these patterns in real-world scenarios.