Unique

In this medium-level challenge, you'll implement a type-level version of Lodash's uniq function that removes duplicate values from a tuple type, preserving the order of first occurrences.

type Res = Unique<[1, 1, 2, 2, 3, 3]>; // expected to be [1, 2, 3]
type Res1 = Unique<[1, 2, 3, 4, 4, 5, 6, 7]>; // expected to be [1, 2, 3, 4, 5, 6, 7]
type Res2 = Unique<[1, "a", 2, "b", 2, "a"]>; // expected to be [1, "a", 2, "b"]
type Res3 = Unique<[string, number, 1, "a", 1, string, 2, "b", 2, number]>; // expected to be [string, number, 1, "a", 2, "b"]
type Res4 = Unique<[unknown, unknown, any, any, never, never]>; // expected to be [unknown, any, never]

type cases = [
  Expect<Equal<Unique<[1, 1, 2, 2, 3, 3]>, [1, 2, 3]>>,
  Expect<Equal<Unique<[1, 2, 3, 4, 4, 5, 6, 7]>, [1, 2, 3, 4, 5, 6, 7]>>,
  Expect<Equal<Unique<[1, 'a', 2, 'b', 2, 'a']>, [1, 'a', 2, 'b']>>,
  Expect<
    Equal<
      Unique<[string, number, 1, 'a', 1, string, 2, 'b', 2, number]>,
      [string, number, 1, 'a', 2, 'b']
    >
  >,
  Expect<
    Equal<
      Unique<[unknown, unknown, any, any, never, never]>,
      [unknown, any, never]
    >
  >,
]

Detailed Explanation

type IsEqual<A, B> =
  (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2)
    ? true
    : false;
 
type Contains<T extends any[], U> =
  T extends [infer First, ...infer Rest]
    ? IsEqual<First, U> extends true
      ? true
      : Contains<Rest, U>
    : false;
 
type Unique<T extends any[], Acc extends any[] = []> =
  T extends [infer First, ...infer Rest]
    ? Contains<Acc, First> extends true
      ? Unique<Rest, Acc>
      : Unique<Rest, [...Acc, First]>
    : Acc;

How it works:

• The IsEqual helper uses a technique involving deferred conditional types to perform exact type equality checks, correctly distinguishing between any, unknown, never, and literal types
• The Contains helper recursively checks whether a tuple already includes a given type by comparing each element using IsEqual
• The main Unique type iterates through the input tuple T one element at a time, maintaining an accumulator Acc of already-seen unique elements
• For each element First, if it is already in Acc (checked via Contains), it is skipped; otherwise, it is appended to Acc
• When the input tuple is exhausted, the accumulator Acc is returned as the deduplicated result

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