import type MapFn from "./Map";
import type UnwrapFn from "./Unwrap";
import type { Err, ErrL, IsErrFn, IsOkFn, OfErrFn, OfOkFn, Ok, OkL } from "./core";
import type { Fn1, PartialApply } from "../HKT";
import type { Lazied } from "../helpers";

/**
 * A type that represents the result of an operation that may fail.
 */
export type Result<T, E> = Ok<T> | Err<E>;
/**
 * {@link Lazied} version of {@link Result}.
 */
export type ResultL<LT extends Lazied, LE extends Lazied> = OkL<LT> | ErrL<LE>;

export type { Err, ErrL, Ok, OkL };

/***********
 * Methods *
 ***********/
/**
 * Methods for `Result`.
 */
export namespace Result {
  /**
   * [Fn] Check if a {@link Result} is {@link Ok}.
   */
  export type IsOk = IsOkFn;
  /**
   * [Fn] Check if a {@link Result} is {@link Err}.
   */
  export type IsErr = IsErrFn;

  /**
   * [Fn] Apply a function to the value of a {@link Result}.
   *
   * Sig: `<T, U>(f: (x: T) => U) => <E>(r: Result<T, E>) => Result<U, E>`
   */
  export type Map<F extends Fn1> = PartialApply<MapFn, [F]>;

  /**
   * [Fn] Get the inner value of a {@link Result} if it is {@link Ok}, otherwise return `never`.
   *
   * Type safety is **not guaranteed**.
   *
   * Sig: `<T>(o: Result<T, unknown>) => T`
   */
  export type Unwrap = UnwrapFn;
}

/******************
 * Static members *
 ******************/
/**
 * [Fn] Wrap a value in an {@link Ok}.
 *
 * Sig: `<T>(value: T) => Ok<T>`
 *
 * @example
 * ```typescript
 * type R = $<Result$$OfOk, 42>;
 * //   ^?: Ok<42>
 * ```
 */
export type Result$$OfOk = OfOkFn;
/**
 * [Fn] Wrap a value in an {@link Err}.
 *
 * Sig: `<E>(err: E) => Err<E>`
 *
 * @example
 * ```typescript
 * type R = $<Result$$OfErr, "Something went wrong">;
 * //   ^?: Err<"Something went wrong">
 * ```
 */
export type Result$$OfErr = OfErrFn;

/****************
 * Type classes *
 ****************/