utils

export declare const Alt: Alt2<'@nll/datum/DatumEither'>

export declare const Alternative: Alternative2<'@nll/datum/DatumEither'>

export declare const Applicative: Applicative2<'@nll/datum/DatumEither'>

export declare const Apply: Apply2<'@nll/datum/DatumEither'>

export declare const Bifunctor: Bifunctor2<'@nll/datum/DatumEither'>

export declare const Chain: Chain2<'@nll/datum/DatumEither'>

export type DatumEither<E, A> = D.Datum<Either<E, A>>

export type Failure<E> = Valued<Left<E>>

export declare const Foldable: Foldable2<'@nll/datum/DatumEither'>

export declare const Functor: Functor2<'@nll/datum/DatumEither'>

export declare const Monad: Monad2<'@nll/datum/DatumEither'>

export declare const MonadThrow: MonadThrow2<'@nll/datum/DatumEither'>

export type Success<A> = Valued<Right<A>>

export type ToLeft<T> = T extends DatumEither<infer L, infer _> ? L : never

export type ToRight<T> = T extends DatumEither<infer _, infer R> ? R : never

export declare const Traversable: Traversable2<'@nll/datum/DatumEither'>

export declare const URI: '@nll/datum/DatumEither'

export type URI = typeof URI

export type Valued<A> = D.Refresh<A> | D.Replete<A>

export declare const alt: <E, A>(
  that: Lazy<D.Datum<Either<E, A>>>
) => (fa: D.Datum<Either<E, A>>) => D.Datum<Either<E, A>>

export declare const ap: <E, A>(
  fa: D.Datum<Either<E, A>>
) => <B>(fab: D.Datum<Either<E, (a: A) => B>>) => D.Datum<Either<E, B>>

export declare const apFirst: <E, B>(
  fb: D.Datum<Either<E, B>>
) => <A>(fa: D.Datum<Either<E, A>>) => D.Datum<Either<E, A>>

export declare const apSecond: <E, B>(
  fb: D.Datum<Either<E, B>>
) => <A>(fa: D.Datum<Either<E, A>>) => D.Datum<Either<E, B>>

export declare const bimap: <E, G, A, B>(
  f: (e: E) => G,
  g: (a: A) => B
) => (fa: D.Datum<Either<E, A>>) => D.Datum<Either<G, B>>

export declare const chain: <E, A, B>(
  f: (a: A) => D.Datum<Either<E, B>>
) => (ma: D.Datum<Either<E, A>>) => D.Datum<Either<E, B>>

export declare const chainFirst: <E, A, B>(
  f: (a: A) => D.Datum<Either<E, B>>
) => (ma: D.Datum<Either<E, A>>) => D.Datum<Either<E, A>>

export declare function constInitial<E = never, D = never>(): DatumEither<E, D>

export declare const constPending: <E = never, D = never>() => D.Datum<Either<E, D>>

export declare const failure: <E = never, A = never>(e: E) => D.Datum<Either<E, A>>

export declare const failureR: <E = never, A = never>(e: E) => D.Datum<Either<E, A>>

export declare const flatten: <E, A>(mma: D.Datum<Either<E, D.Datum<Either<E, A>>>>) => D.Datum<Either<E, A>>

export declare const fold: <E, A, B>(
  onInitial: Lazy<B>,
  onPending: Lazy<B>,
  onRefreshLeft: FunctionN<[E], B>,
  onRefreshRight: FunctionN<[A], B>,
  onRepleteLeft: FunctionN<[E], B>,
  onRepleteRight: FunctionN<[A], B>
) => (fea: D.Datum<Either<E, A>>) => B

export declare const foldMap: <M>(M: Monoid<M>) => <A>(f: (a: A) => M) => <E>(fa: D.Datum<Either<E, A>>) => M

export declare const fromNullable: <E, A>(a: A | null | undefined) => D.Datum<Either<E, A>>

export declare const fromOption: <E, A>(onNone: Lazy<E>) => (o: Option<A>) => D.Datum<Either<E, A>>

export declare const getApplySemigroup: <E, A>(S: Semigroup<Either<E, A>>) => Semigroup<D.Datum<Either<E, A>>>

export declare const getMonoid: <E, A>(S: Semigroup<Either<E, A>>) => Monoid<D.Datum<Either<E, A>>>

export declare const getSemigroup: <E, A>(S: Semigroup<Either<E, A>>) => Semigroup<D.Datum<Either<E, A>>>

export declare const initial: D.Datum<Either<never, never>>

export declare const isFailure: <E, A>(fea: D.Datum<Either<E, A>>) => fea is Valued<Left<E>>

export declare const isInitial: <A>(ma: D.Datum<A>) => ma is D.Initial

export declare const isPending: <A>(ma: D.Datum<A>) => ma is D.Pending

export declare const isRefresh: <A>(ma: D.Datum<A>) => ma is D.Refresh<A>

export declare const isRefreshLeft: <E, A>(fea: D.Datum<Either<E, A>>) => fea is D.Refresh<Left<E>>

export declare const isRefreshRight: <E, A>(fea: D.Datum<Either<E, A>>) => fea is D.Refresh<Right<A>>

export declare const isReplete: <A>(ma: D.Datum<A>) => ma is D.Replete<A>

export declare const isRepleteLeft: <E, A>(fea: D.Datum<Either<E, A>>) => fea is D.Replete<Left<E>>

export declare const isRepleteRight: <E, A>(fea: D.Datum<Either<E, A>>) => fea is D.Replete<Right<A>>

export declare const isSuccess: <E, A>(fea: D.Datum<Either<E, A>>) => fea is Valued<Right<A>>

export declare const isValued: <A>(ma: D.Datum<A>) => ma is D.Refresh<A> | D.Replete<A>

export declare const map: <A, B>(f: (a: A) => B) => <E>(fa: D.Datum<Either<E, A>>) => D.Datum<Either<E, B>>

export declare const mapLeft: <E, G>(f: (e: E) => G) => <A>(fa: D.Datum<Either<E, A>>) => D.Datum<Either<G, A>>

export declare const pending: D.Datum<Either<never, never>>

export declare const reduce: <A, B>(b: B, f: (b: B, a: A) => B) => <E>(fa: D.Datum<Either<E, A>>) => B

export declare const reduceRight: <A, B>(b: B, f: (a: A, b: B) => B) => <E>(fa: D.Datum<Either<E, A>>) => B

export declare const refreshFold: <E, A, B>(
  onInitial: () => B,
  onPending: () => B,
  onFailure: (e: E, r?: boolean | undefined) => B,
  onSuccess: (a: A, r?: boolean | undefined) => B
) => (fea: D.Datum<Either<E, A>>) => B

export declare const sequenceStruct: <E, NER>(
  r: (keyof NER extends never ? never : NER) & Record<string, D.Datum<Either<E, any>>>
) => D.Datum<Either<E, { [K in keyof NER]: [NER[K]] extends [D.Datum<Either<any, infer A>>] ? A : never }>>

export declare const sequenceTuple: <E, T>(
  ...t: T & { readonly 0: D.Datum<Either<E, any>> }
) => D.Datum<Either<E, { [K in keyof T]: [T[K]] extends [D.Datum<Either<E, infer A>>] ? A : never }>>

export declare const squash: <E, A, B>(
  onNone: (r?: boolean | undefined) => B,
  onFailure: (e: E, r?: boolean | undefined) => B,
  onSuccess: (a: A, r?: boolean | undefined) => B
) => (fea: D.Datum<Either<E, A>>) => B

export declare const success: <E = never, A = never>(a: A) => D.Datum<Either<E, A>>

export declare const successR: <E = never, A = never>(a: A) => D.Datum<Either<E, A>>

export declare const toRefresh: <E, A>(fea: D.Datum<Either<E, A>>) => D.Datum<Either<E, A>>

export declare const toReplete: <E, A>(fea: D.Datum<Either<E, A>>) => D.Datum<Either<E, A>>

export declare const fromEither2: <E, A>(e: Either<E, A>) => D.Datum<Either<E, A>>

export declare const fromEither: <E, A>(e: Lazy<Either<E, A>>) => D.Datum<Either<E, A>>