utils

export declare const Alt: Alt1<'@nll/datum/Datum'>

export declare const Alternative: Alternative1<'@nll/datum/Datum'>

export declare const Applicative: Applicative1<'@nll/datum/Datum'>

export declare const Apply: Apply1<'@nll/datum/Datum'>

export declare const Chain: Chain1<'@nll/datum/Datum'>

export declare const Compactable: Compactable1<'@nll/datum/Datum'>

export type Datum<D> = Initial | Pending | Refresh<D> | Replete<D>

export declare const Extend: Extend1<'@nll/datum/Datum'>

export declare const Filterable: Filterable1<'@nll/datum/Datum'>

export declare const Foldable: Foldable1<'@nll/datum/Datum'>

export declare const Functor: Functor1<'@nll/datum/Datum'>

export interface Initial {
  readonly _tag: 'Initial'
}

export declare const Monad: Monad1<'@nll/datum/Datum'>

export declare const MonadThrow: MonadThrow1<'@nll/datum/Datum'>

export interface Pending {
  readonly _tag: 'Pending'
}

export interface Refresh<D> {
  readonly _tag: 'Refresh'
  readonly value: D
}

export interface Replete<D> {
  readonly _tag: 'Replete'
  readonly value: D
}

export declare const Traversable: Traversable1<'@nll/datum/Datum'>

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

export type URI = typeof URI

export declare const Witherable: Witherable1<'@nll/datum/Datum'>

export declare const alt: <A>(that: Lazy<Datum<A>>) => (fa: Datum<A>) => Datum<A>

export declare const ap: <A>(fa: Datum<A>) => <B>(fab: Datum<(a: A) => B>) => Datum<B>

export declare const apFirst: <B>(fb: Datum<B>) => <A>(fa: Datum<A>) => Datum<A>

export declare const apSecond: <B>(fb: Datum<B>) => <A>(fa: Datum<A>) => Datum<B>

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

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

export declare const compact: <A>(fa: Datum<Option<A>>) => Datum<A>

export declare const constInitial: Lazy<Initial>

export declare const constPending: Lazy<Pending>

export declare const duplicate: <A>(wa: Datum<A>) => Datum<Datum<A>>

export declare const elem: <A>(E: Eq<A>) => <E>(a: A, ma: Datum<A>) => boolean

export declare const exists: <A>(predicate: Predicate<A>) => <E>(ma: Datum<A>) => boolean

export declare const extend: <A, B>(f: (wa: Datum<A>) => B) => (wa: Datum<A>) => Datum<B>

export declare const filter: {
  <A, B>(refinement: Refinement<A, B>): (fa: Datum<A>) => Datum<B>
  <A>(predicate: Predicate<A>): (fa: Datum<A>) => Datum<A>
}

export declare const filterMap: <A, B>(f: (a: A) => Option<B>) => (fa: Datum<A>) => Datum<B>

export declare const filterOrElse: {
  <E, A, B>(refinement: Refinement<A, B>, onFalse: (a: A) => E): (ma: Datum<A>) => Datum<B>
  <E, A>(predicate: Predicate<A>, onFalse: (a: A) => E): (ma: Datum<A>) => Datum<A>
}

export declare const flatten: <A>(mma: Datum<Datum<A>>) => Datum<A>

export declare const fold: <A, B>(
  onInitial: () => B,
  onPending: () => B,
  onRefresh: (v: A) => B,
  onReplete: (a: A) => B
) => (ma: Datum<A>) => B

export declare const foldMap: <M>(M: Monoid<M>) => <A>(f: (a: A) => M) => (fa: Datum<A>) => M

export declare const fromEither: <E, A>(ma: Either<E, A>) => Datum<A>

export declare const fromNullable: <A>(a: A | null | undefined) => Datum<A>

export declare const fromOption: <E>(onNone: Lazy<E>) => <A>(ma: Option<A>) => Datum<A>

export declare const fromPredicate: {
  <E, A, B>(refinement: Refinement<A, B>, onFalse: (a: A) => E): (a: A) => Datum<B>
  <E, A>(predicate: Predicate<A>, onFalse: (a: A) => E): (a: A) => Datum<A>
}

export declare const getApplySemigroup: <A>(S: Semigroup<A>) => Semigroup<Datum<A>>

export declare const getEq: <A>(E: Eq<A>) => Eq<Datum<A>>

export declare const getMonoid: <A>(S: Semigroup<A>) => Monoid<Datum<A>>

export declare const getOrElse: <A>(onInitial: () => A, onPending: () => A) => (ma: Datum<A>) => A

export declare function getOrd<A>(O: Ord<A>): Ord<Datum<A>>

export declare const getSemigroup: <A>(S: Semigroup<A>) => Semigroup<Datum<A>>

export declare const getShow: <A>(S: Show<A>) => Show<Datum<A>>

export declare const initial: Datum<never>

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

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

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

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

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

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

export declare const partition: {
  <A, B>(refinement: Refinement<A, B>): (fa: Datum<A>) => Separated<Datum<A>, Datum<B>>
  <A>(predicate: Predicate<A>): (fa: Datum<A>) => Separated<Datum<A>, Datum<A>>
}

export declare const partitionMap: <A, B, C>(
  f: (a: A) => Either<B, C>
) => (fa: Datum<A>) => Separated<Datum<B>, Datum<C>>

export declare const pending: Datum<never>

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

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

export declare const refresh: <A = never>(value: A) => Datum<A>

export declare const replete: <A = never>(value: A) => Datum<A>

export declare const separate: <A, B>(fa: Datum<Either<A, B>>) => Separated<Datum<A>, Datum<B>>