Flow

turbolift.internals.interpreter.Control$.Flow
abstract class Flow[-A, B, S, F[_], U, V] extends A => Computation[F[B], V]

Delimited continuation.

Accessed from implementations of user-defined Flow interpreters.

Attributes

Graph
Supertypes
trait A => Computation[F[B], V]
class Object
trait Matchable
class Any

Members list

Value members

Concrete methods

final override def apply(a: A): Computation[F[B], V]

Alias for unary resume.

Alias for unary resume.

Attributes

Definition Classes
Function1
final def apply(a: A, s: S): Computation[F[B], V]

Alias for binary resume.

Alias for binary resume.

Attributes

final def escape[X](body: Computation[X, U]): Computation[(X, This), V]

Execute body in the context, where the currently interpreted operation has been encountered.

Execute body in the context, where the currently interpreted operation has been encountered.

Similar to local, but more lightweight, as it doesn't modify scope of the effect.

Attributes

final def escape[X](body: Computation[X, U], s: S): Computation[(X, This, S), V]

Like the unary escape, but also with updating the state.

Like the unary escape, but also with updating the state.

Attributes

final def local[X](body: Computation[X, U]): Computation[(F[X], This), V]

Handles given computation locally.

Handles given computation locally.

Execute body in the context, where the currently interpreted operation has been encountered, as if scope of the current effect was delimited by body.

Returns a pair of:

  1. The result of handling of the effect, in the scope delimited by the body.
  2. A fresh Control object.

The fresh Control should be used for subsequent resumption, because it captures actions, that may have been performed inside the body by other effects.

The stale continuation (this) can be resumed too. However, this introduces semantic fragility. Such that, we may find that some of those other effects are undone, even though we have just got a hold on the value computed with their participation.

This alternative behavior is similar to the known problem of Monad Transformers: "catch resets state".

Attributes

final def local[X](body: Computation[X, U], s: S): Computation[(F[X], This, S), V]

Like the unary local, but also with updating the state.

Like the unary local, but also with updating the state.

Attributes

final def resume(a: A): Computation[F[B], V]

Resumes the continuation.

Resumes the continuation.

Attributes

final def resume(a: A, s: S): Computation[F[B], V]

Resumes the continuation, also updating the state.

Resumes the continuation, also updating the state.

Attributes

final def tupled(a_s: (A, S)): Computation[F[B], V]

Tupled version of binary resume.

Tupled version of binary resume.

Attributes

Inherited methods

def andThen[A](g: Computation[F[B], V] => A): T1 => A

Attributes

Inherited from:
Function1
def compose[A](g: A => A): A => R

Attributes

Inherited from:
Function1
override def toString(): String

Returns a string representation of the object.

Returns a string representation of the object.

The default representation is platform dependent.

Attributes

Returns

a string representation of the object.

Definition Classes
Function1 -> Any
Inherited from:
Function1