import type { ExtractPlucked } from 'match-iz'

/**
 * Element type stored in a **match** bucket when sifting values of type `T`
 * with pattern `P`.
 *
 * - `P` contains `pluck(...)` → plucked payload (`ExtractPlucked<P>`)
 * - `P` is a type guard `(x) => x is U` → `Extract<T, U>`
 * - otherwise → full element `T` (structural match / no transform)
 *
 * Remainder buckets always keep full elements `T` (or `Exclude` via dedicated
 * type-guard overloads).
 */
export type MatchPayload<T, P> = [ExtractPlucked<P>] extends [never]
  ? P extends (value: any) => value is infer U
    ? Extract<T, U>
    : T
  : ExtractPlucked<P>

/**
 * Result of sifting an array of `T` against pattern tuple `P`.
 * - 0 patterns → `[T[], T[]]` (empty matches + full remainder)
 * - N patterns → N match buckets (`MatchPayload` each) + 1 remainder `T[]`
 */
export type ArraySiftResult<
  T,
  P extends readonly unknown[]
> = P extends readonly []
  ? [T[], T[]]
  : [...{ [K in keyof P]: Array<MatchPayload<T, P[K]>> }, T[]]

/**
 * Result of sifting a `Set<T>` against pattern tuple `P`.
 * Match buckets use {@link MatchPayload}; remainder stays `Set<T>`.
 */
export type SetSiftResult<
  T,
  P extends readonly unknown[]
> = P extends readonly []
  ? [Set<T>, Set<T>]
  : [...{ [K in keyof P]: Set<MatchPayload<T, P[K]>> }, Set<T>]

/**
 * Result of sifting a `Map<K, V>` against pattern tuple `P`.
 * Patterns match **values**; match buckets use {@link MatchPayload} on `V`.
 */
export type MapSiftResult<
  K,
  V,
  P extends readonly unknown[]
> = P extends readonly []
  ? [Map<K, V>, Map<K, V>]
  : [...{ [I in keyof P]: Map<K, MatchPayload<V, P[I]>> }, Map<K, V>]

/**
 * Result of sifting an `IterableIterator<T>` (e.g. generator).
 * - 0 patterns → `[undefined, iterator]` (runtime passthru / otherwise)
 * - N patterns → N+1 **arrays** (match arms use {@link MatchPayload})
 */
export type IterableSiftResult<
  T,
  P extends readonly unknown[]
> = P extends readonly []
  ? [undefined, IterableIterator<T>]
  : [...{ [K in keyof P]: Array<MatchPayload<T, P[K]>> }, T[]]

/**
 * One pojo bucket: same keys as `T` may appear, with the same value types.
 * Runtime only copies matching entries, so every key is optional.
 */
export type PojoBucket<T extends object> = {
  [K in keyof T]?: T[K]
}

/**
 * One match bucket for pojo value-patterns: keys optional, values may be
 * {@link MatchPayload} (pluck-aware).
 */
export type PojoPatternBucket<T extends object, P> = {
  [K in keyof T]?: MatchPayload<T[K], P>
}

/**
 * Per-key schema match bucket: each key uses MatchPayload against its schema slot.
 */
export type PojoSchemaMatchBucket<T extends object, S> = {
  [K in keyof T]?: K extends keyof S ? MatchPayload<T[K], S[K]> : T[K]
}

/**
 * Result of sifting a pojo of type `T` against pattern tuple `P`.
 * - 0 patterns → `[{}, T]` passthru (empty matches + full input)
 * - N patterns → N match buckets (pluck-aware) + 1 remainder `PojoBucket<T>`
 *
 * Note: multi-pattern pojo form is `sift(pojo, [p1, p2, …])` (one array arg),
 * not rest args (unlike arrays).
 */
export type PojoSiftResult<
  T extends object,
  P extends readonly unknown[]
> = P extends readonly []
  ? [PojoBucket<T>, T]
  : [...{ [K in keyof P]: PojoPatternBucket<T, P[K]> }, PojoBucket<T>]

/** Type predicate used by single- and multi-guard sift/siftr overloads. */
export type TypeGuard<U = unknown> = (value: any) => value is U

/**
 * Multi type-guard partition of element type `T`.
 * Match buckets are `Extract<T, Ui>`; remainder is `Exclude<T, U1 | U2 | …>`.
 * First matching guard wins at runtime (same order as arguments).
 */
export type GuardPartition<T, U1, U2 = never, U3 = never> = [U3] extends [
  never
]
  ? [U2] extends [never]
    ? [Array<Extract<T, U1>>, Array<Exclude<T, U1>>]
    : [
        Array<Extract<T, U1>>,
        Array<Extract<T, U2>>,
        Array<Exclude<T, U1 | U2>>
      ]
  : [
      Array<Extract<T, U1>>,
      Array<Extract<T, U2>>,
      Array<Extract<T, U3>>,
      Array<Exclude<T, U1 | U2 | U3>>
    ]

export type GuardSetPartition<T, U1, U2 = never, U3 = never> = [U3] extends [
  never
]
  ? [U2] extends [never]
    ? [Set<Extract<T, U1>>, Set<Exclude<T, U1>>]
    : [Set<Extract<T, U1>>, Set<Extract<T, U2>>, Set<Exclude<T, U1 | U2>>]
  : [
      Set<Extract<T, U1>>,
      Set<Extract<T, U2>>,
      Set<Extract<T, U3>>,
      Set<Exclude<T, U1 | U2 | U3>>
    ]

export type GuardMapPartition<
  K,
  V,
  U1,
  U2 = never,
  U3 = never
> = [U3] extends [never]
  ? [U2] extends [never]
    ? [Map<K, Extract<V, U1>>, Map<K, Exclude<V, U1>>]
    : [
        Map<K, Extract<V, U1>>,
        Map<K, Extract<V, U2>>,
        Map<K, Exclude<V, U1 | U2>>
      ]
  : [
      Map<K, Extract<V, U1>>,
      Map<K, Extract<V, U2>>,
      Map<K, Extract<V, U3>>,
      Map<K, Exclude<V, U1 | U2 | U3>>
    ]

/** `[pattern, value]` pair used by binary-array / binary-pojo forms. */
export type BinaryPair<V = unknown> = readonly [unknown, V]

/**
 * Value types from an array of binary pairs.
 * @example UnwrappedBinaryArrayValues<[[P, string], [P, number]]> → string | number
 */
export type UnwrappedBinaryArrayValues<T extends readonly BinaryPair[]> =
  T[number] extends BinaryPair<infer V> ? V : never

/**
 * Pojo of binary pairs → pojo of unwrapped values (same keys).
 * @example UnwrappedBinaryPojo<{ a: [P, number]; b: [P, string] }> → { a: number; b: string }
 */
export type UnwrappedBinaryPojo<T extends object> = {
  [K in keyof T]: T[K] extends BinaryPair<infer V> ? V : never
}

/** True when every property value is a binary `[pattern, value]` pair. */
export type IsBinaryPojo<T extends object> = {
  [K in keyof T]-?: T[K] extends BinaryPair ? true : false
}[keyof T] extends true
  ? true
  : false

/**
 * Map `siftr(...args)` application onto a pojo.
 * - `siftr()(pojo)` → passthru, or binary unwrap when all values are pairs
 * - `siftr(predicate | schema)(pojo)` → two buckets
 * - `siftr([p1, p2, …])(pojo)` → N+1 buckets
 */
export type PojoSiftrResult<
  T extends object,
  P extends readonly unknown[]
> = P extends readonly []
  ? IsBinaryPojo<T> extends true
    ? [
        PojoBucket<UnwrappedBinaryPojo<T>>,
        PojoBucket<UnwrappedBinaryPojo<T>>
      ]
    : [PojoBucket<T>, T]
  : P extends readonly [infer Only]
    ? Only extends readonly unknown[]
      ? PojoSiftResult<T, Only>
      : Only extends TypeGuard<infer U>
        ? [
            { [K in keyof T]?: Extract<T[K], U> },
            { [K in keyof T]?: Exclude<T[K], U> }
          ]
        : Only extends object
          ? [PojoSchemaMatchBucket<T, Only>, PojoBucket<T>]
          : [PojoBucket<T>, PojoBucket<T>]
    : unknown[]

/**
 * @example
 * sift(input, optionalSchemaOrPattern)
 *
 * // Working with plain-objects (pojos)
 * 1: sift({ key: [pattern, value], ... })
 * 2: sift({ key: value }, { key: pattern })
 * 3: sift({ key: value }, pattern)
 * 4: sift({ key: value }, [pattern, pattern, ...])
 *
 * // Working with arrays
 * 5: sift([[pattern, value], [pattern, value], ...])
 * 6: sift([value, value], [pattern, pattern])
 * 7: sift([value, value], value-pattern)
 * 8: sift([value, value], ...value-patterns)
 */

// ── Primitives (before arrays: string is ArrayLike and can confuse generics) ─

/** Primitive passthru target types. */
export type Primitive =
  | string
  | number
  | boolean
  | symbol
  | bigint
  | null
  | undefined

/**
 * Primitive passthru (no schema).
 * @example sift('string') // [undefined, 'string']
 * @example sift(1) // [undefined, 1]
 */
export function sift<T extends Primitive>(input: T): [undefined, T]

// ── Arrays (must stay before other collections) ───────────────────────────

/**
 * Binary array form: each entry is `[pattern, value]`.
 * Returns two buckets of the unwrapped values (match / remainder).
 * @example sift([[isString, 'a'], [isString, 1]]) // [string[], number[]] union buckets
 */
export function sift<const T extends readonly BinaryPair[]>(
  input: T
): [
  UnwrappedBinaryArrayValues<T>[],
  UnwrappedBinaryArrayValues<T>[]
]

/**
 * Array + type guard: match bucket is `Extract<T, U>`; rest is `Exclude<T, U>`.
 * @example sift(['a', 1] as Array<string|number>, isString) // [string[], number[]]
 */
export function sift<T, U>(
  input: readonly T[],
  guard: TypeGuard<U>
): [Array<Extract<T, U>>, Array<Exclude<T, U>>]

/**
 * Array + two type guards: each match arm narrows; remainder is Exclude of both.
 * @example sift(items, isString, isNumber) // [string[], number[], boolean[]]
 */
export function sift<T, U1, U2>(
  input: readonly T[],
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>
): [
  Array<Extract<T, U1>>,
  Array<Extract<T, U2>>,
  Array<Exclude<T, U1 | U2>>
]

/**
 * Array + three type guards: three match arms + exhaustive remainder.
 */
export function sift<T, U1, U2, U3>(
  input: readonly T[],
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>,
  g3: TypeGuard<U3>
): [
  Array<Extract<T, U1>>,
  Array<Extract<T, U2>>,
  Array<Extract<T, U3>>,
  Array<Exclude<T, U1 | U2 | U3>>
]

/** Array + four type guards. */
export function sift<T, U1, U2, U3, U4>(
  input: readonly T[],
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>,
  g3: TypeGuard<U3>,
  g4: TypeGuard<U4>
): [
  Array<Extract<T, U1>>,
  Array<Extract<T, U2>>,
  Array<Extract<T, U3>>,
  Array<Extract<T, U4>>,
  Array<Exclude<T, U1 | U2 | U3 | U4>>
]

/** Array + five type guards. */
export function sift<T, U1, U2, U3, U4, U5>(
  input: readonly T[],
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>,
  g3: TypeGuard<U3>,
  g4: TypeGuard<U4>,
  g5: TypeGuard<U5>
): [
  Array<Extract<T, U1>>,
  Array<Extract<T, U2>>,
  Array<Extract<T, U3>>,
  Array<Extract<T, U4>>,
  Array<Extract<T, U5>>,
  Array<Exclude<T, U1 | U2 | U3 | U4 | U5>>
]

/**
 * Array + positional schema (one pattern per index).
 * Always two buckets (match / remainder) — not N+1 rest-pattern buckets.
 * Match elements use {@link MatchPayload} so schema slots may `pluck`.
 * @example sift(rows, [{ age: pluck(isNumber) }, isString, …])
 */
export function sift<T, const S extends readonly unknown[]>(
  input: readonly T[],
  schema: S
): [Array<MatchPayload<T, S[number]>>, T[]]

/**
 * Array input with rest patterns: element type preserved;
 * bucket count = patterns + remainder.
 * @example sift(items, patternA, patternB) // three buckets (no type-guard narrowing)
 */
export function sift<T, const P extends readonly unknown[]>(
  input: readonly T[],
  ...patterns: P
): ArraySiftResult<T, P>

// ── Set / Map / Iterable (before pojo: they are objects) ───────────────────

/**
 * Set + type guard: match / remainder Sets with narrowed element types.
 */
export function sift<T, U>(
  input: ReadonlySet<T>,
  guard: TypeGuard<U>
): [Set<Extract<T, U>>, Set<Exclude<T, U>>]

/** Set + two type guards. */
export function sift<T, U1, U2>(
  input: ReadonlySet<T>,
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>
): [Set<Extract<T, U1>>, Set<Extract<T, U2>>, Set<Exclude<T, U1 | U2>>]

/** Set + three type guards. */
export function sift<T, U1, U2, U3>(
  input: ReadonlySet<T>,
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>,
  g3: TypeGuard<U3>
): [
  Set<Extract<T, U1>>,
  Set<Extract<T, U2>>,
  Set<Extract<T, U3>>,
  Set<Exclude<T, U1 | U2 | U3>>
]

/** Set + four type guards. */
export function sift<T, U1, U2, U3, U4>(
  input: ReadonlySet<T>,
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>,
  g3: TypeGuard<U3>,
  g4: TypeGuard<U4>
): [
  Set<Extract<T, U1>>,
  Set<Extract<T, U2>>,
  Set<Extract<T, U3>>,
  Set<Extract<T, U4>>,
  Set<Exclude<T, U1 | U2 | U3 | U4>>
]

/** Set + five type guards. */
export function sift<T, U1, U2, U3, U4, U5>(
  input: ReadonlySet<T>,
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>,
  g3: TypeGuard<U3>,
  g4: TypeGuard<U4>,
  g5: TypeGuard<U5>
): [
  Set<Extract<T, U1>>,
  Set<Extract<T, U2>>,
  Set<Extract<T, U3>>,
  Set<Extract<T, U4>>,
  Set<Extract<T, U5>>,
  Set<Exclude<T, U1 | U2 | U3 | U4 | U5>>
]

/**
 * Set input: element type preserved; each bucket is a `Set`.
 * @example sift(new Set([1, 'a']), isNumber) // [Set<number|string>, Set<…>]
 */
export function sift<T, const P extends readonly unknown[]>(
  input: ReadonlySet<T>,
  ...patterns: P
): SetSiftResult<T, P>

/**
 * Map + type guard on values: match / remainder Maps with narrowed `V`.
 */
export function sift<K, V, U>(
  input: ReadonlyMap<K, V>,
  guard: TypeGuard<U>
): [Map<K, Extract<V, U>>, Map<K, Exclude<V, U>>]

/** Map + two type guards on values. */
export function sift<K, V, U1, U2>(
  input: ReadonlyMap<K, V>,
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>
): [
  Map<K, Extract<V, U1>>,
  Map<K, Extract<V, U2>>,
  Map<K, Exclude<V, U1 | U2>>
]

/** Map + three type guards on values. */
export function sift<K, V, U1, U2, U3>(
  input: ReadonlyMap<K, V>,
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>,
  g3: TypeGuard<U3>
): [
  Map<K, Extract<V, U1>>,
  Map<K, Extract<V, U2>>,
  Map<K, Extract<V, U3>>,
  Map<K, Exclude<V, U1 | U2 | U3>>
]

/** Map + four type guards on values. */
export function sift<K, V, U1, U2, U3, U4>(
  input: ReadonlyMap<K, V>,
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>,
  g3: TypeGuard<U3>,
  g4: TypeGuard<U4>
): [
  Map<K, Extract<V, U1>>,
  Map<K, Extract<V, U2>>,
  Map<K, Extract<V, U3>>,
  Map<K, Extract<V, U4>>,
  Map<K, Exclude<V, U1 | U2 | U3 | U4>>
]

/** Map + five type guards on values. */
export function sift<K, V, U1, U2, U3, U4, U5>(
  input: ReadonlyMap<K, V>,
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>,
  g3: TypeGuard<U3>,
  g4: TypeGuard<U4>,
  g5: TypeGuard<U5>
): [
  Map<K, Extract<V, U1>>,
  Map<K, Extract<V, U2>>,
  Map<K, Extract<V, U3>>,
  Map<K, Extract<V, U4>>,
  Map<K, Extract<V, U5>>,
  Map<K, Exclude<V, U1 | U2 | U3 | U4 | U5>>
]

/**
 * Map input: patterns match **values**; keys + value types preserved.
 * @example sift(new Map([[0, 'a'], [1, 1]]), isString)
 */
export function sift<K, V, const P extends readonly unknown[]>(
  input: ReadonlyMap<K, V>,
  ...patterns: P
): MapSiftResult<K, V, P>

/**
 * IterableIterator + type guard: yielded values narrowed in array buckets.
 */
export function sift<T, U>(
  input: IterableIterator<T>,
  guard: TypeGuard<U>
): [Array<Extract<T, U>>, Array<Exclude<T, U>>]

/** IterableIterator + two type guards. */
export function sift<T, U1, U2>(
  input: IterableIterator<T>,
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>
): [
  Array<Extract<T, U1>>,
  Array<Extract<T, U2>>,
  Array<Exclude<T, U1 | U2>>
]

/** IterableIterator + three type guards. */
export function sift<T, U1, U2, U3>(
  input: IterableIterator<T>,
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>,
  g3: TypeGuard<U3>
): [
  Array<Extract<T, U1>>,
  Array<Extract<T, U2>>,
  Array<Extract<T, U3>>,
  Array<Exclude<T, U1 | U2 | U3>>
]

/** IterableIterator + four type guards. */
export function sift<T, U1, U2, U3, U4>(
  input: IterableIterator<T>,
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>,
  g3: TypeGuard<U3>,
  g4: TypeGuard<U4>
): [
  Array<Extract<T, U1>>,
  Array<Extract<T, U2>>,
  Array<Extract<T, U3>>,
  Array<Extract<T, U4>>,
  Array<Exclude<T, U1 | U2 | U3 | U4>>
]

/** IterableIterator + five type guards. */
export function sift<T, U1, U2, U3, U4, U5>(
  input: IterableIterator<T>,
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>,
  g3: TypeGuard<U3>,
  g4: TypeGuard<U4>,
  g5: TypeGuard<U5>
): [
  Array<Extract<T, U1>>,
  Array<Extract<T, U2>>,
  Array<Extract<T, U3>>,
  Array<Extract<T, U4>>,
  Array<Extract<T, U5>>,
  Array<Exclude<T, U1 | U2 | U3 | U4 | U5>>
]

/**
 * IterableIterator (generators, etc.): yielded values collected into arrays.
 * Requires patterns at runtime (same as implementation).
 * @example sift(generator(), patternA, patternB)
 */
export function sift<T, const P extends readonly unknown[]>(
  input: IterableIterator<T>,
  ...patterns: P
): IterableSiftResult<T, P>

// ── Pojo ──────────────────────────────────────────────────────────────────

/**
 * Binary pojo form: each property is `[pattern, value]`.
 * Returns two partials of the unwrapped value types.
 * @example sift({ title: [isString, 'header'], slug: [isString, 1] })
 */
export function sift<
  const T extends { [K in keyof T]: BinaryPair }
>(
  input: T
): [
  PojoBucket<UnwrappedBinaryPojo<T>>,
  PojoBucket<UnwrappedBinaryPojo<T>>
]

/**
 * Pojo + array of value-patterns → N match buckets + remainder.
 * Match values use {@link MatchPayload} (pluck-aware).
 * @example sift({ a: 1, b: 'x' }, [isNumber, isString])
 */
export function sift<T extends object, const P extends readonly unknown[]>(
  input: T,
  patterns: readonly [...P]
): PojoSiftResult<T, P>

/**
 * Pojo + type guard on values: per-key Extract / Exclude in partial buckets.
 * @example sift(data, isString)
 */
export function sift<T extends object, U>(
  input: T,
  guard: TypeGuard<U>
): [
  { [K in keyof T]?: Extract<T[K], U> },
  { [K in keyof T]?: Exclude<T[K], U> }
]

/**
 * Pojo + value predicate applied to every entry → match / remainder.
 * @example sift(data, (v) => typeof v === 'string')
 */
export function sift<T extends object>(
  input: T,
  predicate: (value: T[keyof T]) => unknown
): [PojoBucket<T>, PojoBucket<T>]

/**
 * Pojo + per-key schema object → match / remainder partials.
 * Schema slots may `pluck`; match values use {@link MatchPayload}.
 * Placed after function overloads so predicates are not treated as schemas.
 * @example sift(data, { title: isString, age: pluck(isNumber) })
 */
export function sift<
  T extends object,
  const S extends Record<PropertyKey, unknown>
>(
  input: T,
  schema: S
): [PojoSchemaMatchBucket<T, S>, PojoBucket<T>]

/**
 * Pojo passthru (no schema): empty matches + full input.
 * @example sift({ a: 1 }) // [{}, { a: 1 }]
 */
export function sift<T extends object>(input: T): [PojoBucket<T>, T]

// ── Fallback ──────────────────────────────────────────────────────────────

/** Other untyped inputs (plain iterators without patterns, …). */
export function sift(
  input: unknown,
  ...optionalSchemaOrPattern: unknown[]
): unknown[]

/**
 * Curried form of `sift`: fix the schema first, apply to input later.
 *
 * @example
 * const partition = siftr(isString, isNumber)
 * partition(['a', 1, 'b']) // [['a', 'b'], [1], []]
 *
 * const byType = siftr([isString, isNumber])
 * byType({ a: 1, b: 'x' }) // partial pojo buckets
 */
/** Single type guard: narrow match bucket via Extract; remainder via Exclude. */
export function siftr<U>(
  guard: TypeGuard<U>
): {
  <T>(input: readonly T[]): [Array<Extract<T, U>>, Array<Exclude<T, U>>]
  <T>(input: ReadonlySet<T>): [Set<Extract<T, U>>, Set<Exclude<T, U>>]
  <K, V>(
    input: ReadonlyMap<K, V>
  ): [Map<K, Extract<V, U>>, Map<K, Exclude<V, U>>]
  <T>(
    input: IterableIterator<T>
  ): [Array<Extract<T, U>>, Array<Exclude<T, U>>]
  <O extends object>(
    input: O
  ): [
    { [K in keyof O]?: Extract<O[K], U> },
    { [K in keyof O]?: Exclude<O[K], U> }
  ]
}

/** Two type guards: match arms + remainder Exclude of both. */
export function siftr<U1, U2>(
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>
): {
  <T>(
    input: readonly T[]
  ): [
    Array<Extract<T, U1>>,
    Array<Extract<T, U2>>,
    Array<Exclude<T, U1 | U2>>
  ]
  <T>(
    input: ReadonlySet<T>
  ): [Set<Extract<T, U1>>, Set<Extract<T, U2>>, Set<Exclude<T, U1 | U2>>]
  <K, V>(
    input: ReadonlyMap<K, V>
  ): [
    Map<K, Extract<V, U1>>,
    Map<K, Extract<V, U2>>,
    Map<K, Exclude<V, U1 | U2>>
  ]
  <T>(
    input: IterableIterator<T>
  ): [
    Array<Extract<T, U1>>,
    Array<Extract<T, U2>>,
    Array<Exclude<T, U1 | U2>>
  ]
}

/** Three type guards: three match arms + exhaustive remainder. */
export function siftr<U1, U2, U3>(
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>,
  g3: TypeGuard<U3>
): {
  <T>(
    input: readonly T[]
  ): [
    Array<Extract<T, U1>>,
    Array<Extract<T, U2>>,
    Array<Extract<T, U3>>,
    Array<Exclude<T, U1 | U2 | U3>>
  ]
  <T>(
    input: ReadonlySet<T>
  ): [
    Set<Extract<T, U1>>,
    Set<Extract<T, U2>>,
    Set<Extract<T, U3>>,
    Set<Exclude<T, U1 | U2 | U3>>
  ]
  <K, V>(
    input: ReadonlyMap<K, V>
  ): [
    Map<K, Extract<V, U1>>,
    Map<K, Extract<V, U2>>,
    Map<K, Extract<V, U3>>,
    Map<K, Exclude<V, U1 | U2 | U3>>
  ]
  <T>(
    input: IterableIterator<T>
  ): [
    Array<Extract<T, U1>>,
    Array<Extract<T, U2>>,
    Array<Extract<T, U3>>,
    Array<Exclude<T, U1 | U2 | U3>>
  ]
}

/** Four type guards. */
export function siftr<U1, U2, U3, U4>(
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>,
  g3: TypeGuard<U3>,
  g4: TypeGuard<U4>
): {
  <T>(
    input: readonly T[]
  ): [
    Array<Extract<T, U1>>,
    Array<Extract<T, U2>>,
    Array<Extract<T, U3>>,
    Array<Extract<T, U4>>,
    Array<Exclude<T, U1 | U2 | U3 | U4>>
  ]
  <T>(
    input: ReadonlySet<T>
  ): [
    Set<Extract<T, U1>>,
    Set<Extract<T, U2>>,
    Set<Extract<T, U3>>,
    Set<Extract<T, U4>>,
    Set<Exclude<T, U1 | U2 | U3 | U4>>
  ]
  <K, V>(
    input: ReadonlyMap<K, V>
  ): [
    Map<K, Extract<V, U1>>,
    Map<K, Extract<V, U2>>,
    Map<K, Extract<V, U3>>,
    Map<K, Extract<V, U4>>,
    Map<K, Exclude<V, U1 | U2 | U3 | U4>>
  ]
  <T>(
    input: IterableIterator<T>
  ): [
    Array<Extract<T, U1>>,
    Array<Extract<T, U2>>,
    Array<Extract<T, U3>>,
    Array<Extract<T, U4>>,
    Array<Exclude<T, U1 | U2 | U3 | U4>>
  ]
}

/** Five type guards. */
export function siftr<U1, U2, U3, U4, U5>(
  g1: TypeGuard<U1>,
  g2: TypeGuard<U2>,
  g3: TypeGuard<U3>,
  g4: TypeGuard<U4>,
  g5: TypeGuard<U5>
): {
  <T>(
    input: readonly T[]
  ): [
    Array<Extract<T, U1>>,
    Array<Extract<T, U2>>,
    Array<Extract<T, U3>>,
    Array<Extract<T, U4>>,
    Array<Extract<T, U5>>,
    Array<Exclude<T, U1 | U2 | U3 | U4 | U5>>
  ]
  <T>(
    input: ReadonlySet<T>
  ): [
    Set<Extract<T, U1>>,
    Set<Extract<T, U2>>,
    Set<Extract<T, U3>>,
    Set<Extract<T, U4>>,
    Set<Extract<T, U5>>,
    Set<Exclude<T, U1 | U2 | U3 | U4 | U5>>
  ]
  <K, V>(
    input: ReadonlyMap<K, V>
  ): [
    Map<K, Extract<V, U1>>,
    Map<K, Extract<V, U2>>,
    Map<K, Extract<V, U3>>,
    Map<K, Extract<V, U4>>,
    Map<K, Extract<V, U5>>,
    Map<K, Exclude<V, U1 | U2 | U3 | U4 | U5>>
  ]
  <T>(
    input: IterableIterator<T>
  ): [
    Array<Extract<T, U1>>,
    Array<Extract<T, U2>>,
    Array<Extract<T, U3>>,
    Array<Extract<T, U4>>,
    Array<Extract<T, U5>>,
    Array<Exclude<T, U1 | U2 | U3 | U4 | U5>>
  ]
}

export function siftr<const P extends readonly unknown[]>(
  ...patterns: P
): {
  <T extends readonly BinaryPair[]>(
    input: T
  ): P extends readonly []
    ? [
        UnwrappedBinaryArrayValues<T>[],
        UnwrappedBinaryArrayValues<T>[]
      ]
    : ArraySiftResult<UnwrappedBinaryArrayValues<T>, P>
  <T>(
    input: readonly T[]
  ): P extends readonly [readonly unknown[]]
    ? [Array<MatchPayload<T, P[0][number]>>, T[]] // positional schema (+ pluck)
    : ArraySiftResult<T, P>
  <T>(input: ReadonlySet<T>): SetSiftResult<T, P>
  <K, V>(input: ReadonlyMap<K, V>): MapSiftResult<K, V, P>
  <T>(input: IterableIterator<T>): IterableSiftResult<T, P>
  <T extends object>(input: T): PojoSiftrResult<T, P>
  <T extends Primitive>(
    input: T
  ): P extends readonly [] ? [undefined, T] : unknown[]
  (input: unknown): unknown[]
}

/**
 * Build a matcher suitable for `Array#filter` / `Array#map`.
 * On match returns the value (or a pluck transform at runtime); otherwise `undefined`.
 *
 * @example
 * items.filter(byPattern({ age: 36 }))
 * items.map(byPattern({ age: pluck(isNumber) })) // number | undefined
 */
export function byPattern<T, U extends T>(
  pattern: (value: T) => value is U
): (input: T) => U | undefined

/**
 * Structural / pluck patterns: element type inferred at the call site
 * (e.g. from `array.map` / `array.filter`). Match result is {@link MatchPayload}.
 * @example users.map(byPattern({ age: pluck(isNumber) }))
 */
export function byPattern<const P>(
  pattern: P
): <T>(input: T) => MatchPayload<T, P> | undefined

/**
 * Explicit element type (e.g. `byPattern&lt;User&gt;({ age: 36 })` for filter).
 * Prefer the overload above when using `pluck` so the payload type is preserved.
 */
export function byPattern<T>(
  pattern: unknown
): (input: T) => T | undefined