Usi per continuazioni di Scala

Question

In che modo le persone usano le continuazioni su scala sempre più piccola in Scala?

Sono presenti parti della libreria standard di Scala scritte in CPS?

Ci sono delle penalità di prestazioni importanti nell'utilizzo di continuazioni?

Answer 1

Sto usando questo per trasformare le funzioni asincrone della forma def func(...)(followup: Result => Unit): Unit in modo che invece di scrivere

foo(args){result1 => 
    bar(result1){result2 => 
    car(result2) {result3 => 
     //etc. 
    } 
    } 
} 

è possibile scrivere

val result1 = foo(args) 
val result2 = bar(result1) 
val result3 = car(result2) 

o

car(bar(foo(args))) 

(nota: le funzioni non sono limitate a un argomento o solo l'uso di risultati precedenti come argomenti)

Vedi http://www.tikalk.com/java/blog/asynchronous-functions-actors-and-cps

continuazioni

Answer 2

Scala-ARM (Automatic-Resource-Management) utilizza delimitato

import java.io._ 
import util.continuations._ 
import resource._ 
def each_line_from(r : BufferedReader) : String @suspendable = 
    shift { k => 
    var line = r.readLine 
    while(line != null) { 
     k(line) 
     line = r.readLine 
    } 
    } 
reset { 
    val server = managed(new ServerSocket(8007)) ! 
    while(true) { 
    // This reset is not needed, however the below denotes a "flow" of execution that can be deferred. 
    // One can envision an asynchronous execuction model that would support the exact same semantics as below. 
    reset { 
     val connection = managed(server.accept) ! 
     val output = managed(connection.getOutputStream) ! 
     val input = managed(connection.getInputStream) ! 
     val writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(output))) 
     val reader = new BufferedReader(new InputStreamReader(input)) 
     writer.println(each_line_from(reader)) 
     writer.flush() 
    } 
    } 
}