DenkzeitWiki

Main /

Continuations

Closures

WebApplications
SetJmp

Scheme
Exceptions Also: continuations-based (or modal) web applications.

a continuation is a way to represent the execution state (i.e. the stack frame) of a program at a given point [1]

continuations have sometimes been described as `gotos with arguments'.

A continuation is a closure, but not vice versa.

Stack Recursion

gotos with arguments [2]

• http://www.stackless.com/spcpaper.htm --Continuations
  • http://www.ps.uni-sb.de/~duchier/python/continuations.html --Continuations Made Simple and Illustrated
• http://radio.weblogs.com/0102385/2003/08/30.html
• http://lib.store.yahoo.com/lib/paulgraham/bbnexcerpts.txt --viaweb
  
• http://www.phubuh.org/Media/Writing/Continuations/ --sehr gute Erklärung
  • via http://www.tbray.org/ongoing/When/200x/2005/03/24/Continuations

Continuations are variously understood as representations of the current evaluation context and as representations of the rest of the computation, but these understandings contradict each other

• http://lambda-the-ultimate.org/node/view/761 --On Evaluation Contexts, Continuations, and the Rest of Computation
  
• http://lambda-the-ultimate.org/node/view/451 --Use Continuations to Develop Complex Web Applications
  • http://www-106.ibm.com/developerworks/library/j-contin.html --Use continuations to develop complex Web applications
  
  
• Wiki:CallWithCurrentContinuation --call/cc Scheme
  
• SetJmp

A continuation is a program frozen in action: a single functional object containing the state of a computation. When the object is evaluated, the stored computation is restarted where it left off. In solving certain types of problems it can be a great help to be able to save the state of a program and restart it later. In multiprocessing, for example, a continuation conveniently represents a suspended process. In nondeterministic search programs, a continuation can represent a node in the search tree.

• http://kasparov.skife.org/blog-live/src/java/cont-jsr.writeback --Native Java Continuations

One thing that people don’t often tell you about continuations is that they don’t actually resume exactly where you left off. After all, if they did, you would end up in an infinite loop. The only thing that is really restored is a few pointers. Everything that resides on the heap, or is stored externally in places like files and databases, remains unaffected when you invoke a continuation.

• http://www.intertwingly.net/blog/2005/04/13/Continuations-for-Curmudgeons --Continuations for Curmudgeon
  • http://www.sidhe.org/~dan/blog/archives/000156.html --Continuations and VMs
    Extract [3]:
  • There is a chain of lexical scopes, each with local variables. When code needs to lookup a variable, it while search that environment, by iterating up that chain until it finds it.
  • A closure is an function object that references a specific inner scope. It is said to “capture” that lexical scope. For example if you return an routine that references some local variables. Two closures can close over the same scope, thus sharing state as it gets modified.
  • There is a second such chain which represents the chain of control (tracking which instruction you’re at in a given function). When a function is called, an exception occurs,... that chain gets involved. For example, when a function is invoked, a new lexical scope is created and a marker is also added to the control chain.
  • If you take a chain of lexical variable scopes (as found in a closure) and associate it with a chain of control, you could use it these as the context for calling a routine (a set of instructions, defined by an entry address). A continuation is a routine pointer with a lexical scope and a control chain. Usually the lexical scope, control chain and instruction pointer are captured together.
  • All control structures can be implemented with continuations. For example, when you register an exception handler, you capture a continuation; when the exception is thrown that continuation is invoked and you just continue running from the spot in the exception handler.
    
  
  
• Continuations: a concrete approach
• http://www.hutteman.com/weblog/2005/04/26-224.html --C# Continuations useful? Hell yeah!
  
  
• http://pluralsight.com/blogs/dbox/archive/2005/04/27/7780.aspx --Closures and Continuations
  You cannot use real continuations if the language does not support it.
  Continuations are more the lexically scoped variables. Continuations capture control flow.
  

Exceptions are escape continuations.
[4]

continuations are basic building blocks: you can build on top of them exception systems, generators, coroutines, microthreads, etc, and it is an interesting learning experience to understand how this is done. [5]

Continuations are the functional expression of the GOTO statement, and the same caveats apply.[6]!)

• Actor model

The Actor model treats “Actors” as the universal primitives of concurrent digital computation: in response to a message that it receives, an Actor can make local decisions, create more Actors, send more messages, and determine how to respond to the next message received. The Actor model has been used both as a framework within which to develop a theoretical understanding of concurrency, and as the theoretical basis for several practical implementations of concurrent systems.

• Will Continuations continue?
  • Continuations in WebApps.

• http://www.madore.org/~david/computers/callcc.html

---

• Continuation-Passing Style
  • Continuations are the functional counterparts of GOTOs? both in power and inscrutability. They can express arbitrary control flow like coroutines and exceptions while bewildering some of the brightest programmers.

Languages Supporting Continuations

• Scheme
• Ruby
• CSharp (via Delegates)
• C (via SetJmp)
• Stackless Python used to have Continuations
• Languages with Exceptions -> escape continuations