123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150
import type * as HKT from "./hkt.ts";import type * as TC from "./type_classes.ts";import type { Lazy } from "./types.ts";
import * as E from "./either.ts";import * as R from "./reader.ts";import { createDo } from "./derivations.ts";import { apply, constant, flow, identity, pipe } from "./fns.ts";
/******************************************************************************* * Types ******************************************************************************/
export type ReaderEither<S, L, R> = R.Reader<S, E.Either<L, R>>;
/******************************************************************************* * Kind Registration ******************************************************************************/
export const URI = "ReaderEither";
export type URI = typeof URI;
declare module "./hkt.ts" {  // deno-lint-ignore no-explicit-any  export interface Kinds<_ extends any[]> {    [URI]: ReaderEither<_[2], _[1], _[0]>;  }}
/******************************************************************************* * Constructors ******************************************************************************/
export const ask: <A, E = never>() => ReaderEither<A, E, A> = () => E.right;
export const asks: <R, A, E = never>(  f: (r: R) => A,) => ReaderEither<R, E, A> = (fra) => flow(fra, E.right);
export const left = <B, A = never>(  left: B,): ReaderEither<unknown, B, A> => R.of(E.left(left));
export const right = <A, B = never>(  right: A,): ReaderEither<unknown, B, A> => R.of(E.right(right));
export const tryCatch = <S, E, A>(  f: Lazy<A>,  onError: (e: unknown) => E,): ReaderEither<S, E, A> => {  try {    return R.of(E.right(f()));  } catch (e) {    return R.of(E.left(onError(e)));  }};
export const fromEither = <S, E, A>(  ta: E.Either<E, A>,): ReaderEither<S, E, A> => R.of(ta);
/******************************************************************************* * Modules ******************************************************************************/
export const Functor: TC.Functor<URI> = {  map: (fab) => (ta) => flow(ta, E.map(fab)),};
export const Apply: TC.Apply<URI> = {  ap: (tfab) =>    (ta) => (r) => pipe(tfab(r), E.chain((fab) => pipe(ta(r), E.map(fab)))),  map: Functor.map,};
export const Applicative: TC.Applicative<URI> = {  of: flow(E.right, constant),  ap: Apply.ap,  map: Functor.map,};
export const Chain: TC.Chain<URI> = {  ap: Apply.ap,  map: Functor.map,  chain: (fatb) => R.chain(E.fold(left, fatb)),};
export const Monad: TC.Monad<URI> = {  of: Applicative.of,  ap: Apply.ap,  map: Functor.map,  join: Chain.chain(identity),  chain: Chain.chain,};
export const Bifunctor: TC.Bifunctor<URI> = {  bimap: (fai, fbj) => (tab) => flow(tab, E.bimap(fai, fbj)),  mapLeft: (fbj) => (tab) => flow(tab, E.mapLeft(fbj)),};
export const MonadThrow: TC.MonadThrow<URI> = {  of: Applicative.of,  ap: Apply.ap,  map: Functor.map,  join: Monad.join,  chain: Chain.chain,  throwError: left,};
export const Alt: TC.Alt<URI> = {  map: Monad.map,  alt: (tb) =>    (ta) =>      (r) =>        pipe(          ta(r),          E.fold(() => tb(r), E.right),        ),};
/******************************************************************************* * Pipeables ******************************************************************************/
export const { of, ap, map, join, chain, throwError } = MonadThrow;
export const { bimap, mapLeft } = Bifunctor;
export const { alt } = Alt;
export const chainLeft = <A, B, C, J>(fbtj: (b: B) => ReaderEither<C, J, A>) =>  (ma: ReaderEither<C, B, A>): ReaderEither<C, J, A> =>    pipe(ma, R.chain(E.fold(fbtj, right)));
export const compose = <E, B, C>(rbc: ReaderEither<B, E, C>) =>  <A>(rab: ReaderEither<A, E, B>): ReaderEither<A, E, C> =>    flow(rab, E.chain(rbc));
export const widen: <F>() => <R, E, A>(  ta: ReaderEither<R, E, A>,) => ReaderEither<R, E | F, A> = constant(identity);
/******************************************************************************* * Do ******************************************************************************/
export const { Do, bind, bindTo } = createDo(Monad);