Replace First

In this medium-level challenge, you'll implement ReplaceFirst<T, S, R> which replaces the first occurrence of S in a tuple T with R, returning the original tuple if no match is found.

type cases = [
  Expect<Equal<ReplaceFirst<[1, 2, 3], 3, 4>, [1, 2, 4]>>,
  Expect<Equal<ReplaceFirst<['A', 'B', 'C'], 'C', 'D'>, ['A', 'B', 'D']>>,
  Expect<
    Equal<ReplaceFirst<[true, true, true], true, false>, [false, true, true]>
  >,
  Expect<
    Equal<
      ReplaceFirst<[string, boolean, number], boolean, string>,
      [string, string, number]
    >
  >,
  Expect<Equal<ReplaceFirst<[1, 'two', 3], string, 2>, [1, 2, 3]>>,
  Expect<
    Equal<
      ReplaceFirst<['six', 'eight', 'ten'], 'eleven', 'twelve'>,
      ['six', 'eight', 'ten']
    >
  >,
]

Detailed Explanation

type ReplaceFirst<T extends readonly unknown[], S, R> =
  T extends [infer F, ...infer Rest]
    ? F extends S
      ? [R, ...Rest]
      : [F, ...ReplaceFirst<Rest, S, R>]
    : []

How it works:

• We use conditional types with infer to destructure the tuple into its first element F and the remaining elements Rest.
• If the first element F extends S (matches the search type), we return a new tuple with R replacing F, followed by the unmodified Rest. This ensures only the first occurrence is replaced.
• If F does not match S, we keep F as-is and recursively apply ReplaceFirst to the Rest of the tuple.
• The base case T extends [infer F, ...infer Rest] fails when the tuple is empty, returning [] and stopping the recursion.

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