import type { IsUnionFn } from "./IsUnion";
import type RangeOfFn from "./RangeOf";
import type RejectFn from "./Reject";
import type ToIntersectionFn from "./ToIntersection";
import type ToListFn from "./ToList";
import type { Fn1, PartialApply } from "../HKT";
// @ts-ignore - Only used in doc comments
import type { List } from "../List";
import type FilterFn from "../Union/Filter";

/***********
 * Methods *
 ***********/
/**
 * Methods for union types.
 */
export namespace Union {
  /**
   * [Fn] Convert a union type to an intersection type.
   *
   * Sig: `<T>(u: UnionOf<T>) => IntersectOf<T>`
   */
  export type ToIntersection = ToIntersectionFn;

  /**
   * [Fn] Convert a union type to a {@link List}.
   *
   * Sig: `<T>(u: UnionOf<T>) => List<T>`
   */
  export type ToList = ToListFn;

  /**
   * [Fn] Filter a union based on a predicate.
   *
   * Sig: `<T>[pred: (x: T) => boolean](u: UnionOf<T>) => UnionOf<T>`
   *
   * @see {@link Reject} for the opposite.
   */
  export type Filter<Pred extends Fn1<never, boolean>> = PartialApply<FilterFn, [Pred]>;
  /**
   * [Fn] Keep elements of a union that do not satisfy a predicate.
   *
   * Sig: `<T>[pred: (x: T) => boolean](u: UnionOf<T>) => UnionOf<T>`
   *
   * @see {@link Filter} for the opposite.
   */
  export type Reject<Pred extends Fn1<never, boolean>> = PartialApply<RejectFn, [Pred]>;
}

/******************
 * Static members *
 ******************/
/**
 * Check whether a type is a union type.
 *
 * Sig: `(x: unknown) => boolean`
 *
 * @example
 * ```typescript
 * type R1 = $<Union$$IsUnion, number | string>;
 * //   ^?: true
 * type R2 = $<Union$$IsUnion, 42>;
 * //   ^?: false
 * type R3 = $<Union$$IsUnion, boolean>; // This may surprise you
 * //   ^?: true <- This is because `boolean` is a union type of `true | false`
 * ```
 */
export type Union$$IsUnion = IsUnionFn;

/**
 * [Fn] Create a union of a range of numbers from `from` to `to` (exclusive).
 *
 * Sig: `(from: Nat, to: Nat) => UnionOf<Nat>`
 */
export type Union$$RangeOf = RangeOfFn;