arrow-eval/arrow.eval/Eval/Always

Always

data class Always<out A>(f: () -> A) : Eval<A> (source)

Construct a lazy Eval instance.

This type can be used for "lazy" values. In some sense it is equivalent to using a Function0 value.

This type will evaluate the computation every time the value is required. It should be avoided except when laziness is required and caching must be avoided. Generally, prefer Later.

Constructors

constructor(f: () -> A)

Functions

inline fun <B> coflatMap(crossinline f: (Eval<A>) -> B): Eval<B>

fun <B> flatMap(f: (A) -> Eval<B>): Eval<B>

operator fun invoke(): A

inline fun <B> map(crossinline f: (A) -> B): Eval<B>

open override fun memoize(): Eval<A>

fun <A> Eval<A>.replicate(n: Int): Eval<List<A>>

fun <A, B> Eval<A>.replicate(n: Int, initial: () -> B, combine: (A, B) -> B): Eval<B>

open override fun toString(): String

open override fun value(): A

fun <A, B> Eval<A>.zip(b: Eval<B>): Eval<Pair<A, B>>

fun <A, B, Z> Eval<A>.zip(b: Eval<B>, map: (A, B) -> Z): Eval<Z>

fun <A, B, C, D> Eval<A>.zip(b: Eval<B>, c: Eval<C>, map: (A, B, C) -> D): Eval<D>

fun <A, B, C, D, E> Eval<A>.zip(b: Eval<B>, c: Eval<C>, d: Eval<D>, map: (A, B, C, D) -> E): Eval<E>

fun <A, B, C, D, E, F> Eval<A>.zip(b: Eval<B>, c: Eval<C>, d: Eval<D>, e: Eval<E>, map: (A, B, C, D, E) -> F): Eval<F>

fun <A, B, C, D, E, F, G> Eval<A>.zip(b: Eval<B>, c: Eval<C>, d: Eval<D>, e: Eval<E>, f: Eval<F>, map: (A, B, C, D, E, F) -> G): Eval<G>

fun <A, B, C, D, E, F, G, H> Eval<A>.zip(b: Eval<B>, c: Eval<C>, d: Eval<D>, e: Eval<E>, f: Eval<F>, g: Eval<G>, map: (A, B, C, D, E, F, G) -> H): Eval<H>

fun <A, B, C, D, E, F, G, H, I> Eval<A>.zip(b: Eval<B>, c: Eval<C>, d: Eval<D>, e: Eval<E>, f: Eval<F>, g: Eval<G>, h: Eval<H>, map: (A, B, C, D, E, F, G, H) -> I): Eval<I>

fun <A, B, C, D, E, F, G, H, I, J> Eval<A>.zip(b: Eval<B>, c: Eval<C>, d: Eval<D>, e: Eval<E>, f: Eval<F>, g: Eval<G>, h: Eval<H>, i: Eval<I>, map: (A, B, C, D, E, F, G, H, I) -> J): Eval<J>

fun <A, B, C, D, E, F, G, H, I, J, K> Eval<A>.zip(b: Eval<B>, c: Eval<C>, d: Eval<D>, e: Eval<E>, f: Eval<F>, g: Eval<G>, h: Eval<H>, i: Eval<I>, j: Eval<J>, map: (A, B, C, D, E, F, G, H, I, J) -> K): Eval<K>