Without

In this medium-level challenge, you'll implement a type-level version of Lodash's without function that filters elements from a tuple, removing any that appear in a given exclusion list.

type Res = Without<[1, 2], 1>; // expected to be [2]
type Res1 = Without<[1, 2, 4, 1, 5], [1, 2]>; // expected to be [4, 5]
type Res2 = Without<[2, 3, 2, 3, 2, 3, 2, 3], [2, 3]>; // expected to be []

type cases = [
  Expect<Equal<Without<[1, 2], 1>, [2]>>,
  Expect<Equal<Without<[1, 2, 4, 1, 5], [1, 2]>, [4, 5]>>,
  Expect<Equal<Without<[2, 3, 2, 3, 2, 3, 2, 3], [2, 3]>, []>>,
]

Detailed Explanation

type ToUnion<T> = T extends any[] ? T[number] : T;
 
type Without<T extends any[], U, Excluded = ToUnion<U>> =
  T extends [infer First, ...infer Rest]
    ? First extends Excluded
      ? Without<Rest, U, Excluded>
      : [First, ...Without<Rest, U, Excluded>]
    : [];

How it works:

• The ToUnion<T> helper normalizes the exclusion parameter: if T is an array, it converts it to a union via T[number]; otherwise it returns T as-is
• The Excluded default parameter calls ToUnion<U> once upfront, avoiding redundant computation on each recursive step
• The main Without<T, U, Excluded> type recursively destructures the input tuple using T extends [infer First, ...infer Rest]
• For each element, if First extends Excluded (meaning it should be removed), the element is skipped and recursion continues with Without<Rest, U, Excluded>
• If the element does not match, it is kept by spreading it into [First, ...Without<Rest, U, Excluded>]
• When the input tuple is empty, an empty tuple [] is returned as the base case

This challenge helps you understand union type normalization and recursive tuple filtering, and how to apply these concepts in real-world scenarios.