FindAll

In this medium-level challenge, you'll implement FindAll<T, P> which takes a text string T and a pattern string P, and returns an array of all 0-indexed positions in T where P is found as a substring.

Detailed Explanation

We iterate through the string one character at a time, checking at each position whether the pattern matches at that index. We use a counter tuple to track the current index.

type FindAll<
  T extends string,
  P extends string,
  Index extends any[] = []
> = P extends ''
  ? []
  : T extends `${infer _First}${infer Rest}`
    ? T extends `${P}${string}`
      ? [Index['length'], ...FindAll<Rest, P, [...Index, 1]>]
      : FindAll<Rest, P, [...Index, 1]>
    : []

How it works:

• The first check P extends '' handles the edge case of an empty pattern, returning an empty array
• T extends `${infer _First}${infer Rest}` destructures the string to advance one character at a time
• T extends `${P}${string}` checks whether the current position in T starts with the pattern P
• If it matches, we record Index['length'] (the current position) and continue searching from the next character
• This approach allows overlapping matches (e.g., finding 'AA' in 'AAAA' yields [0, 1, 2]) because we advance by one character regardless of the pattern length
• The Index tuple grows by one element each step, so its length always reflects the current position

This challenge helps you understand template literal type pattern matching with index tracking and how to apply this concept in real-world scenarios.