123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304
import type * as HKT from "./hkt.ts";import type * as TC from "./type_classes.ts";import type { Fn, Lazy, Predicate, Refinement } from "./types.ts";
import * as O from "./option.ts";import { constant, identity, isNotNil, pipe } from "./fns.ts";import { createSequenceStruct, createSequenceTuple } from "./sequence.ts";import { createDo } from "./derivations.ts";
/******************************************************************************* * Types ******************************************************************************/
export type Left<L> = { tag: "Left"; left: L };
export type Right<R> = { tag: "Right"; right: R };
export type Either<L, R> = Left<L> | Right<R>;
/******************************************************************************* * Kind Registration ******************************************************************************/
export const URI = "Either";
export type URI = typeof URI;
declare module "./hkt.ts" {  // deno-lint-ignore no-explicit-any  export interface Kinds<_ extends any[]> {    [URI]: Either<_[1], _[0]>;  }}
/******************************************************************************* * Constructors ******************************************************************************/
export const left = <E = never, A = never>(left: E): Either<E, A> => ({  tag: "Left",  left,});
export const right = <E = never, A = never>(right: A): Either<E, A> => ({  tag: "Right",  right,});
export const fromNullable = <E>(e: Lazy<E>) =>  <A>(a: A): Either<E, NonNullable<A>> => (isNotNil(a) ? right(a) : left(e()));
export const tryCatch = <E, A>(  f: Lazy<A>,  onError: (e: unknown) => E,): Either<E, A> => {  try {    return right(f());  } catch (e) {    return left(onError(e));  }};
export const tryCatchWrap = <E, A, AS extends unknown[]>(  fn: Fn<AS, A>,  onError: (e: unknown) => E,): Fn<AS, Either<E, A>> =>  (...as: AS) => {    try {      return right(fn(...as));    } catch (e) {      return left(onError(e));    }  };
export const fromPredicate: {  <E, A, B extends A>(refinement: Refinement<A, B>, onFalse: (a: A) => E): (    a: A,  ) => Either<E, B>;  <E, A>(predicate: Predicate<A>, onFalse: (a: A) => E): (a: A) => Either<E, A>;} = <E, A>(predicate: Predicate<A>, onFalse: (a: A) => E) =>  (a: A) => predicate(a) ? right(a) : left(onFalse(a));
/******************************************************************************* * Destructors ******************************************************************************/
export const fold = <L, R, B>(  onLeft: (left: L) => B,  onRight: (right: R) => B,) => (ma: Either<L, R>): B => isLeft(ma) ? onLeft(ma.left) : onRight(ma.right);
export const getOrElse = <E, A>(onLeft: (e: E) => A) =>  (ma: Either<E, A>): A => isLeft(ma) ? onLeft(ma.left) : ma.right;
export const getRight = <E, A>(ma: Either<E, A>): O.Option<A> =>  pipe(ma, fold(O.constNone, O.some));
export const getLeft = <E, A>(ma: Either<E, A>): O.Option<E> =>  pipe(ma, fold(O.some, O.constNone));
/******************************************************************************* * Guards ******************************************************************************/
export const isLeft = <L, R>(m: Either<L, R>): m is Left<L> => m.tag === "Left";
export const isRight = <L, R>(m: Either<L, R>): m is Right<R> =>  m.tag === "Right";
/******************************************************************************* * Combinators ******************************************************************************/
export const swap = <E, A>(ma: Either<E, A>): Either<A, E> =>  isLeft(ma) ? right(ma.left) : left(ma.right);
export const stringifyJSON = <E>(  u: unknown,  onError: (reason: unknown) => E,): Either<E, string> => tryCatch(() => JSON.stringify(u), onError);
/******************************************************************************* * Module Getters ******************************************************************************/
export const getShow = <E, A>(  SE: TC.Show<E>,  SA: TC.Show<A>,): TC.Show<Either<E, A>> => ({  show: fold(    (left) => `Left(${SE.show(left)})`,    (right) => `Right(${SA.show(right)})`,  ),});
export const getSetoid = <E, A>(  SE: TC.Setoid<E>,  SA: TC.Setoid<A>,): TC.Setoid<Either<E, A>> => ({  equals: (x) =>    (y) => {      if (isLeft(x)) {        if (isLeft(y)) {          return SE.equals(x.left)(y.left);        }        return false;      }
      if (isLeft(y)) {        return false;      }      return SA.equals(x.right)(y.right);    },});
export const getOrd = <E, A>(  OE: TC.Ord<E>,  OA: TC.Ord<A>,): TC.Ord<Either<E, A>> => ({  ...getSetoid(OE, OA),  lte: (x) => {    if (isLeft(x)) {      return fold(OE.lte(x.left), constant(true));    }    return fold(constant(false), OA.lte(x.right));  },});
export const getLeftSemigroup = <E = never, A = never>(  SE: TC.Semigroup<E>,): TC.Semigroup<Either<E, A>> => ({  concat: (x) =>    (y) => isRight(x) ? x : isRight(y) ? y : left(SE.concat(x.left)(y.left)),});
export const getRightSemigroup = <E = never, A = never>(  SA: TC.Semigroup<A>,): TC.Semigroup<Either<E, A>> => ({  concat: (x) =>    (y) => isLeft(x) ? x : isLeft(y) ? y : right(SA.concat(x.right)(y.right)),});
export const getRightMonoid = <E = never, A = never>(  MA: TC.Monoid<A>,): TC.Monoid<Either<E, A>> => ({  ...getRightSemigroup(MA),  empty: () => right(MA.empty()),});
export const getRightMonad = <E>(  { concat }: TC.Semigroup<E>,): TC.Monad<URI, [E]> => ({  ...Monad,  ap: (tfai) =>    // deno-lint-ignore no-explicit-any    (ta): Either<any, any> =>      isLeft(tfai)        ? (isLeft(ta) ? left(concat(tfai.left)(ta.left)) : tfai)        : (isLeft(ta) ? ta : right(tfai.right(ta.right))),});
/******************************************************************************* * Modules ******************************************************************************/
export const Functor: TC.Functor<URI> = {  map: (fai) => (ta) => isLeft(ta) ? ta : right(fai(ta.right)),};
export const Apply: TC.Apply<URI> = {  ap: (tfai) =>    (ta) => isLeft(ta) ? ta : isLeft(tfai) ? tfai : right(tfai.right(ta.right)),  map: Functor.map,};
export const Applicative: TC.Applicative<URI> = {  of: right,  ap: Apply.ap,  map: Functor.map,};
export const Chain: TC.Chain<URI> = {  ap: Apply.ap,  map: Functor.map,  chain: (fati) => (ta) => (isRight(ta) ? fati(ta.right) : ta),};
export const Monad: TC.Monad<URI> = {  of: Applicative.of,  ap: Apply.ap,  map: Functor.map,  join: Chain.chain(identity),  chain: Chain.chain,};
export const MonadThrow: TC.MonadThrow<URI> = ({  ...Monad,  throwError: left,});
export const Bifunctor: TC.Bifunctor<URI> = {  bimap: (fbj, fai) =>    (ta) => isLeft(ta) ? left(fbj(ta.left)) : right(fai(ta.right)),  mapLeft: (fbj) => (ta) => isLeft(ta) ? left(fbj(ta.left)) : ta,};
export const Alt: TC.Alt<URI> = {  map: Functor.map,  alt: (tb) => (ta) => isLeft(ta) ? tb : ta,};
export const Extend: TC.Extend<URI> = {  map: Functor.map,  extend: (ftab) => (ta) => right(ftab(ta)),};
export const Foldable: TC.Foldable<URI> = {  reduce: (fovo, v) => (tb) => (isRight(tb) ? fovo(v, tb.right) : v),};
export const Traversable: TC.Traversable<URI> = {  map: Functor.map,  reduce: Foldable.reduce,  traverse: (A) =>    (fasi) =>      (ta) => {        if (isRight(ta)) {          return pipe(            fasi(ta.right),            // deno-lint-ignore no-explicit-any            A.map((i) => right<any, any>(i)),          );        }        // deno-lint-ignore no-explicit-any        return A.of(ta as Either<any, any>);      },};
/******************************************************************************* * Pipeables ******************************************************************************/
export const { of, ap, map, join, chain, throwError } = MonadThrow;
export const { reduce, traverse } = Traversable;
export const { bimap, mapLeft } = Bifunctor;
export const { extend } = Extend;
export const { alt } = Alt;
export const chainLeft = <E, A, J>(fej: (e: E) => Either<J, A>) =>  (ma: Either<E, A>): Either<J, A> => (isLeft(ma) ? fej(ma.left) : ma);
export const sequenceTuple = createSequenceTuple(Apply);
export const sequenceStruct = createSequenceStruct(Apply);
export const { Do, bind, bindTo } = createDo(Monad);
export const widen: <F>() => <E, A>(ta: Either<E, A>) => Either<E | F, A> =  constant(identity);