Verwendet für Scala Fortsetzungen

Question

Wie verwenden Menschen Fortsetzungen in einem größeren und kleineren Maßstab in Scala?

Sind Teile der Scala-Standardbibliothek in CPS geschrieben?

Gibt es irgendwelche größeren Leistungseinbußen bei der Verwendung von Fortsetzungen?

Answer 1

ich dies mit asynchronen Funktionen der Form drehen def func(...)(followup: Result => Unit): Unit so dass anstelle des Schreibens

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

Sie können

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

oder

car(bar(foo(args))) 

(Anmerkung schreiben: die Funktionen sind nicht auf ein Argument oder nur die Verwendung vorheriger Ergebnisse als Argumente beschränkt)

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

Answer 2

Scala-ARM (Automatic-Ressource-Management) verwendet begrenzte Fortsetzungen

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() 
    } 
    } 
}