Packages

  • package root
    Definition Classes
    root
  • package scala
    Definition Classes
    root
  • package util
    Definition Classes
    scala
  • package continuations

    Delimited continuations are a feature for modifying the usual control flow of a program.

    Delimited continuations are a feature for modifying the usual control flow of a program. To use continuations, provide the option -P:continuations:enable to the Scala compiler or REPL to activate the compiler plugin.

    Below is an example of using continuations to suspend execution while awaiting user input. Similar facilities are used in so-called continuation-based web frameworks.

    def go =
  reset {
    println("Welcome!")
    val first = ask("Please give me a number")
    val second = ask("Please enter another number")
    printf("The sum of your numbers is: %d\n", first + second)
  }

    The reset is provided by this package and delimits the extent of the transformation. The ask is a function that will be defined below. Its effect is to issue a prompt and then suspend execution awaiting user input. Once the user provides an input value, execution of the suspended block resumes.

    val sessions = new HashMap[UUID, Int=>Unit]
def ask(prompt: String): Int @cps[Unit] =
  shift {
    k: (Int => Unit) => {
      val id = uuidGen
      printf("%s\nrespond with: submit(0x%x, ...)\n", prompt, id)
      sessions += id -> k
    }
  }

    The type of ask includes a @cps annotation which drives the transformation. The type signature Int @cps[Unit] means that ask should be used in a context requiring an Int, but actually it will suspend and return Unit.

    The computation leading up to the first ask is executed normally. The remainder of the reset block is wrapped into a closure that is passed as the parameter k to the shift function, which can then decide whether and how to execute the continuation. In this example, the continuation is stored in a sessions map for later execution. This continuation includes a second call to ask, which is treated likewise once the execution resumes.

    CPS Annotation

    The aforementioned @cps[A] annotation is an alias for the more general @cpsParam[B,C] where B=C. The type A @cpsParam[B,C] describes a term which yields a value of type A within an evaluation context producing a value of type B. After the CPS transformation, this return type is modified to C.

    The @cpsParam annotations are introduced by shift blocks, and propagate via the return types to the dynamically enclosing context. The propagation stops upon reaching a reset block.

    Definition Classes
    util
  • ControlContext
  • cpsParam
c

scala.util.continuations

ControlContext

final class ControlContext[+A, -B, +C] extends Serializable

This class represent a portion of computation that has a 'hole' in it. The class has the ability to compute state up until a certain point where the state has the A type. If this context is given a function of type A => B to move the state to the B type, then the entire computation can be completed resulting in a value of type C.

An Example: 

 val cc = new ControlContext[String, String, String](
    fun = { (f: String=>String, err: Exception => String) =>
      val updatedState =
        try f("State")
        catch {
          case e: Exception => err(e)
        }
      updatedState + "-Complete!"
    },
    x = null.asIntanceOf[String]
}
cc.foreach(_ + "-Continued")  // Results in "State-Continued-Complete!"

This class is used to transform calls to shift in the continuations package. Direct use and instantiation is possible, but usually reserved for advanced cases.

A context may either be trivial or non-trivial. A trivial context just has a state of type A. When completing the computation, it's only necessary to use the function of type A => B directly against the trivial value. A non-trivial value stores a computation around the state transformation of type A => B and cannot be short-circuited.

A

The type of the state currently held in the context.

B

The type of the transformed state needed to complete this computation.

C

The return type of the entire computation stored in this context.

Note

fun and x are allowed to be null.

See also

scala.util.continutations.shiftR

Linear Supertypes
Serializable, java.io.Serializable, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. ControlContext
  2. Serializable
  3. Serializable
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Instance Constructors

  1. new ControlContext(fun: ((A) ⇒ B, (Exception) ⇒ B) ⇒ C, x: A)

    fun

    The captured computation so far. The type (A => B, Exception => B) => C is a function where:

    • The first parameter A=>B represents the computation defined against the current state held in the ControlContext.
    • The second parameter Exception => B represents a computation to perform if an exception is thrown from the first parameter's computation.
    • The return value is the result of the entire computation contained in this ControlContext.
    x

    The current state stored in this context. Allowed to be null if the context is non-trivial.

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  6. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  7. def equals(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  8. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )
  9. final def flatMap[A1, B1, C1 <: B](f: (A) ⇒ ControlContext[A1, B1, C1]): ControlContext[A1, B1, C]

    Maps and flattens this ControlContext with another ControlContext generated from the current state.

    Maps and flattens this ControlContext with another ControlContext generated from the current state.

    A1

    The new type of the contained state.

    B1

    The new type of the state after the stored continuation has executed.

    C1

    The result type of the nested ControlContext. Because the nested ControlContext is executed within the outer ControlContext, this type must >: B so that the resulting nested computation can be fed through the current continuation.

    f

    A transformation function from the current state to a nested ControlContext.

    returns

    The transformed ControlContext.

    Annotations
    @noinline()
    Note

    The resulting comuptation is still the type C.

  10. final def flatMapCatch[A1 >: A, B1 <: B, C1 >: C <: B1](pf: PartialFunction[Exception, ControlContext[A1, B1, C1]]): ControlContext[A1, B1, C1]
  11. final def foreach(f: (A) ⇒ B): C

    Runs the computation against the state stored in this ControlContext.

    Runs the computation against the state stored in this ControlContext.

    f

    the computation that modifies the current state of the context.

    Note

    This method could throw exceptions from the computations.

  12. def foreachFull(f: (A) ⇒ B, g: (Exception) ⇒ B): C
  13. val fun: ((A) ⇒ B, (Exception) ⇒ B) ⇒ C
  14. final def getClass(): Class[_]
    Definition Classes
    AnyRef → Any
  15. final def getTrivialValue: A

    returns

    The current state value.

  16. def hashCode(): Int
    Definition Classes
    AnyRef → Any
  17. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  18. final def isTrivial: Boolean

    returns

    true if this context only stores a state value and not any deferred computation.

  19. final def map[A1](f: (A) ⇒ A1): ControlContext[A1, B, C]

    Modifies the currently captured state in this ControlContext.

    Modifies the currently captured state in this ControlContext.

    A1

    The new type of state in this context.

    f

    A transformation function on the current state of the ControlContext.

    returns

    The new ControlContext.

    Annotations
    @noinline()
  20. final def mapFinally(f: () ⇒ Unit): ControlContext[A, B, C]
  21. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  22. final def notify(): Unit
    Definition Classes
    AnyRef
  23. final def notifyAll(): Unit
    Definition Classes
    AnyRef
  24. final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
    AnyRef
  25. def toString(): String
    Definition Classes
    AnyRef → Any
  26. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  27. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  28. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )
  29. val x: A

Inherited from Serializable

Inherited from java.io.Serializable

Inherited from AnyRef

Inherited from Any

Ungrouped