/**
 * Naive "either or" type implementation.
 *
 * This differs from other implementations mostly in how relaxed the type inferrence is.
 *
 * Again, this could easily be replaced with something from e.g. fp-ts, but the goal is
 * to have a single "prelude/stdlib" here.
 *
 *
 * @module
 * @deprecated use effect instead
 */

import { identity } from "./Function.js";

export type Either<Left, Right> =
  | { __tag: "left"; left: Left }
  | { __tag: "right"; right: Right };

export type Left<E extends Either<any, any>> =
  E extends Either<infer Left, any> ? Left : never;
export type Right<E extends Either<any, any>> =
  E extends Either<any, infer Right> ? Right : never;

export const left = <const Left>(left: Left): Either<Left, never> => ({
  __tag: "left",
  left,
});
export const right = <const Right>(right: Right): Either<never, Right> => ({
  __tag: "right",
  right,
});

export const map =
  <R1, R2, L>(fn: (value: R1) => R2) =>
  (either: Either<L, R1>): Either<L, R2> =>
    either.__tag === "left"
      ? either
      : { __tag: "right", right: fn(either.right) };

export const flatMap =
  <L1, R1, E extends Either<any, any>>(fn: (value: R1) => E) =>
  (either: Either<L1, R1>): Either<L1 | Left<NoInfer<E>>, Right<NoInfer<E>>> =>
    either.__tag === "left" ? either : fn(either.right);

export const match =
  <T, Left, Right>(onLeft: (left: Left) => T, onRight: (right: Right) => T) =>
  (either: Either<Left, Right>): T =>
    either.__tag === "left" ? onLeft(either.left) : onRight(either.right);

export const getOrElse = <L, R, F>(fallback: (left: L) => F) =>
  match(fallback, identity<F | R>);

export const alt =
  <Left, Right>(second: Either<Left, Right>) =>
  (first: Either<Left, Right>) =>
    first.__tag === "right" ? first : second;