arrow-streams / arrow.streams.internal

Package arrow.streams.internal


ForFreeC class ForFreeC
FreeC Free Monad with Catch (and Interruption).sealed class FreeC<F, out R> : FreeCOf<F, R>
FreeCApplicative interface FreeCApplicative<F> : Applicative<FreeCPartialOf<F>>
FreeCApplicativeError interface FreeCApplicativeError<F> : ApplicativeError<FreeCPartialOf<F>, Throwable>
FreeCBracket interface FreeCBracket<F> : Bracket<FreeCPartialOf<F>, Throwable>, FreeCMonadError<F>
FreeCEq interface FreeCEq<F, G, A> : Eq<FreeCOf<F, A>>
FreeCFunctor interface FreeCFunctor<F> : Functor<FreeCPartialOf<F>>
FreeCMonad interface FreeCMonad<F> : Monad<FreeCPartialOf<F>>
FreeCMonadDefer interface FreeCMonadDefer<F> : MonadDefer<FreeCPartialOf<F>>, FreeCBracket<F>
FreeCMonadError interface FreeCMonadError<F> : MonadError<FreeCPartialOf<F>, Throwable>
FreeCOf typealias FreeCOf<F, R> = Kind2<ForFreeC, F, R>
FreeCPartialOf typealias FreeCPartialOf<F> = Kind<ForFreeC, F>
ViewL Emulated sealed trait. Never extend this interface! Working with ViewL must be done using ViewL.foldinterface ViewL<F, out R>

Extensions for External Classes



fold fun <F, R, A> FreeC<F, R>.fold(pure: (R) -> A, fail: (Throwable) -> A, interrupted: (Any?, Option<Throwable>) -> A, eval: (Kind<F, R>) -> A, bind: (FreeC<F, Any?>, (Result<Any?>) -> FreeCOf<F, R>) -> A): A
fun <R, A> Result<R>.fold(pure: (R) -> A, fail: (Throwable) -> A, interrupted: (Any?, Option<Throwable>) -> A): A
fun <F, R, A> ViewL<F, R>.fold(pure: (R) -> A, fail: (Throwable) -> A, interrupted: (Any?, Option<Throwable>) -> A, view: (Kind<F, Any?>, (Result<Any?>) -> FreeC<F, R>) -> A): A
freeC fun <F, A> A.freeC(): FreeC<F, A>
recoverWith Applies the given function f if this is a FreeC.Fail, otherwise returns itself. This is like flatMap for the <R> Result<R>.recoverWith(f: (Throwable) -> Result<R>): Result<R>
step Takes one evaluation step in the Free monad, re-associating left-nested binds in the process.tailrec fun <S, A> FreeC<S, A>.step(): FreeC<S, A>

Do you like Arrow?

Arrow Org