arrow-eval/arrow.eval/Eval/FlatMap

FlatMap

abstract class FlatMap<out A> : Eval<A> (source)

FlatMap is a type of Eval that is used to chain computations involving .map and .flatMap. Along with Eval#flatMap. It implements the trampoline that guarantees stack-safety.

Users should not instantiate FlatMap instances themselves. Instead, they will be automatically created when needed.

Unlike a traditional trampoline, the internal workings of the trampoline are not exposed. This allows a slightly more efficient implementation of the .value method.

Constructors

constructor()

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>

abstract fun <S> run(s: S): Eval<A>

abstract fun <S> start(): Eval<S>

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>