Type Members

1.  trait BoundedParallel[F[_]] extends AnyRef
2.  trait Delay[F[_]] extends AnyRef
3.  trait ErrorBase extends AnyRef

   Base trait for instance search

4.  trait Errors[F[_], E] extends Raise[F, E] with Handle[F, E] with ErrorsTo[F, F, E]

   Allows to throw and handle errors of type ${E} in a ${F}.

   Allows to throw and handle errors of type ${E} in a ${F}.

   Annotations

   @implicitNotFound( ... )

5.  class ErrorsBaseInstances extends ErrorsBaseInstances1
6.  class ErrorsBaseInstances1 extends ErrorsBaseInstances2
7.  class ErrorsBaseInstances2 extends ErrorsBaseInstances3
8.  class ErrorsBaseInstances3 extends AnyRef
9.  trait ErrorsTo[F[_], G[_], E] extends Raise[F, E] with HandleTo[F, G, E]

   Allows to throw and handle errors of type ${E} in a ${F} transiting to a ${G} when recovering.

   Allows to throw and handle errors of type ${E} in a ${F} transiting to a ${G} when recovering. A G can either be the same as F or some "subconstructor" having less errors semantically.

   Annotations

   @implicitNotFound( ... )

10.  trait Fibers[F[_], Exit[_], Fib[_]] extends Race[F]
11.  trait Finally[F[_], Exit[_]] extends Guarantee[F]

    Bracket-like typeclass allowing to match exit of the process

    Bracket-like typeclass allowing to match exit of the process

    F

    effect process

    Exit

    structure, describing process exit like ExitCase or Exit

12.  trait Fire[F[_]] extends AnyRef
13.  trait Guarantee[F[_]] extends AnyRef

    Bracket-like typeclass allowing to understand if operation was succeed

    Bracket-like typeclass allowing to understand if operation was succeed

    F

    effect process

14.  trait Handle[F[_], E] extends HandleTo[F, F, E] with Restore[F]

    Allows to recover after an error of type ${E} in a ${F}.

    Allows to recover after an error of type ${E} in a ${F}.

    Annotations

    @implicitNotFound( ... )

15.  trait HandleTo[F[_], G[_], E] extends RestoreTo[F, G]

    Allows to recover after an error of type ${E} in a ${F} transiting to a ${G} as a result.

    Allows to recover after an error of type ${E} in a ${F} transiting to a ${G} as a result. A G can either be the same as a F or some "subconstructor" having less errors semantically.

    Annotations

    @implicitNotFound( ... )

16.  trait Init[F[_], A] extends AnyRef

    Initialize value of type A in type F

    Initialize value of type A in type F

    F

    initialization effect type

    A

    result type

17.  trait PerformInstance1 extends AnyRef
18.  trait PerformVia[F[_], Cont[_], Cancel] extends WithContext[F, Performer[F, Cont, Cancel]]

    Annotations

    @implicitNotFound( ... )

19.  trait Performer[F[_], -Cont[_], Cancel] extends AnyRef
20.  trait Pull[F[_], A] extends AnyRef

    simply F[A] in a typeclass form

21.  trait PullInstances extends AnyRef
22.  trait Push[F[_], A] extends AnyRef

    simply function A => F[Unit] in a typeclass form

23.  trait PushInstances extends PushInstances1
24.  trait PushInstances1 extends AnyRef
25.  trait Race[F[_]] extends Fire[F]
26.  trait Raise[F[_], E] extends ErrorBase with ContravariantRaise[F, E]

    Allows to raise E inside type F.

    Allows to raise E inside type F.

    Annotations

    @implicitNotFound( ... )

27.  trait Restore[F[_]] extends RestoreTo[F, F]

    Allows to recover after some error in a ${F}.

    Allows to recover after some error in a ${F}.

    Annotations

    @implicitNotFound( ... )

28.  trait RestoreTo[F[_], G[_]] extends Lift[G, F] with ErrorBase

    Allows to recover after some error in a ${F} transiting to a ${G} as a result.

    Allows to recover after some error in a ${F} transiting to a ${G} as a result. A G can either be the same as a F or some "subconstructor" having less errors semantically.

    Annotations

    @implicitNotFound( ... )

29.  trait Scoped[Tag, F[_]] extends AnyRef

    can be used for scoped transformations

    can be used for scoped transformations

    Tag

    arbitrary type tag f type Execute[F[_]] = ScopedExecute[Scoped.Main, F] type Blocks[F[_]] = Scoped[Scoped.Blocking, F] type BlockExec[F[_]] = ScopedExecute[Scoped.Blocking, F] type Calculates[F[_]] = Scoped[Scoped.Calculation, F] type CalcExec[F[_]] = ScopedExecute[Scoped.Calculation, F]or discriminating scopes

    F

    process type

30.  trait ScopedExecute[Tag, F[_]] extends Scoped[Tag, F]
31.  trait ScopedInstancesMacro extends AnyRef
32.  abstract final class Void extends AnyRef
33.  trait WithContext[F[_], C] extends Context[F]

    Synonym for Context with explicit C as Ctx for better type inference

    Synonym for Context with explicit C as Ctx for better type inference

    There is also a nice type alias:

     import tofu.In
    
    val fHasMyCtx: MyCtx In F = ???

34.  trait WithLocal[F[_], C] extends Local[F] with WithContext[F, C]

    Synonym for Local with explicit C as Ctx for better type inference

35.  trait WithProvide[F[_], G[_], C] extends Provide[F] with Lift[G, F]

    Synonym for Provide with explicit C as Ctx and G as Lower for better type inference

    Synonym for Provide with explicit C as Ctx and G as Lower for better type inference

    Can be seen as transformation F[_] = C => G[_]

36.  trait WithRun[F[_], G[_], C] extends WithProvide[F, G, C] with WithLocal[F, C] with RunContext[F] with Unlift[G, F]

    Synonym for both RunContext and Unlift with explicit C as Ctx and G as Lower for better type inference

    Synonym for both RunContext and Unlift with explicit C as Ctx and G as Lower for better type inference

    Can be seen as transformation F[_] = C => G[_]

37.  trait Context[F[_]] extends ContextBase

    Declares that F can provide value of type Ctx

    Declares that F can provide value of type Ctx

    In other words this trait tells you that F is some kind of Reader or function of type Ctx => F[A]. The best way to use it is through WithContext or In

    This can be seen as global value for your Application or for a part of it.

    Annotations

    @deprecated

    Deprecated

    (Since version 0.10.3) Migrate to With* typeclasses

    Example:

    1. One common use of this is to make contextual logging:

         import tofu.syntax.console._
       
       def contexualConsolling[F[_]: Console: FlatMap](message: String)(implicit hasMyCtx: F HasContext MyCtx): F[Unit] =
         hasMyCtx.askF(ctx => puts"$message (Also context: $ctx)")

       so when you have MyCtx(3) the call of contextualConsolling("Hi!") prints Hi! (Also MyCtx(3))

38.  trait Local[F[_]] extends Context[F]

    Allows to run some computation with notion of altered context consider using WithLocal for better type inference

    Allows to run some computation with notion of altered context consider using WithLocal for better type inference

    Annotations

    @deprecated

    Deprecated

    (Since version 0.10.3) Migrate to With* typeclasses

39.  trait Provide[F[_]] extends ContextBase

    Allows to evaluate contextual computation with some context

    Allows to evaluate contextual computation with some context

    The main use case for it is to obtain some context Lower[Ctx], and then to run another contextual computation F[A] that can use F[Ctx] inside.

    F

    context-aware effect e.g.ReaderT[Lower, Ctx, _]

    Annotations

    @deprecated

    Deprecated

    (Since version 0.10.3) Migrate to With* typeclasses

40.  trait RunContext[F[_]] extends Local[F] with Provide[F]

    Combination of Local and Provide

    Combination of Local and Provide

    F

    context-aware effect e.g.ReaderT[Lower, Ctx, _]

    Annotations

    @deprecated

    Deprecated

    (Since version 0.10.3) Migrate to With* typeclasses