Loop

org.specs2.control.eff.Loop
trait Loop[M[_], R, A, B, C]

Generalisation of Recurse and StateRecurse

The loop defines some state with an initial value which is maintained at each step of the interpretation.

A is the type of Eff values to interpret, and B is the result of the interpretation (generally an other Eff value)

C is the type of result for "last" actions.

  • the interpretation of a Pure value either returns the final result or possibly one more Eff value to interpret

  • onEffect interprets one effect and possibly uses the continuation to produce the next value to interpret. If no X can be used to run the continuation we might just output one final B value

  • onLastEffect interprets the last effect of an Eff value. The only difference with onEffect is the fact that last actions return Unit values (and not A values)

  • onApplicativeEff interprets a list of effects and possibly uses the continuation to get to the next value to interpret. If no interpretation can be done, a B value might be returned

  • onLastApplicativeEffect does the same thing for last actions

Attributes

Graph
Supertypes
class Object
trait Matchable
class Any

Members list

Type members

Types

type S

Value members

Abstract methods

def onApplicativeEffect[X, T[_] : Traverse](xs: T[M[X]], continuation: Arrs[R, T[X], A], s: S): Either[(Eff[R, A], S), B]
def onEffect[X](x: M[X], continuation: Arrs[R, X, A], s: S): Either[(Eff[R, A], S), B]
def onLastApplicativeEffect[X, T[_] : Traverse](xs: T[M[X]], continuation: Arrs[R, T[X], Unit], s: S): Either[(Eff[R, Unit], S), C]
def onLastEffect[X](x: M[X], continuation: Arrs[R, X, Unit], s: S): Either[(Eff[R, Unit], S), C]
def onPure(a: A, s: S): Either[(Eff[R, A], S), B]

Abstract fields

val init: S