Return to callcc CVS log

Up to [Research Unix] / researchv10no / cmd / sml / doc

Annotation of researchv10no/cmd/sml/doc/callcc, revision 1.1.1.1

1.1       root        1: A set of new primitives has been added to ML to give access to continuations:
                      2: 
                      3: type 'a cont
                      4: val callcc : ('a cont -> 'a) -> 'a
                      5: val throw : 'a cont -> 'a -> 'b
                      6: 
                      7: The continuation of an expression is an abstraction of what the system
                      8: will do with the value of the expression. For example in the
                      9: expression:
                     10: 
                     11:                 if a orelse b then foo() else goo()
                     12: 
                     13: the continuation of the expression "a orelse b" can be described in
                     14: words as "if the value is true then compute foo() otherwise compute
                     15: goo()" and then continue in the context of the if-expression. Usually
                     16: the continuation of an expression is implicit, however, the primitive
                     17: callcc allows the programmer to capture and use these continuations.
                     18: 
                     19: The primitive callcc takes a function as an argument and applies it to
                     20: the current continuation.  The continuation of an expression of type 'a
                     21: has type 'a cont and is a first-class object. To capture the
                     22: continuation described above one would write:
                     23: 
                     24:    if callcc(fn k => a orelse b) then foo() else goo
                     25: 
                     26: Here the continuation of the callcc-application is captured by being
                     27: bound to k, but it is not used. Because the continuation is not used
                     28: the result is simply the result of the expression "a orelse b".  To
                     29: use the continuation a value must be supplied, and the computation
                     30: continues as if that value where the result of the callcc-application.
                     31: This is called throwing the continuation a value; it is performed by
                     32: applying "throw" to the continuation and the value.
                     33: 
                     34:  if callcc(fn k => (throw k false) orelse b) then foo() else goo()
                     35: 
                     36: Here, when the continuation k is thrown the value false, "orelse b" is simply
                     37: ignored, the callcc-application returns false, and goo() is then evaluated.
                     38: 
                     39: The type returned by a throw-expression is unconstrained like that of
                     40: a raise-expression and for the same reason:  neither of these
                     41: expressions ever return.
                     42: 
                     43: One of the less interesting uses of callcc is as an alternative to
                     44: exception handlers. For example:
                     45: 
                     46:     exception Prod
                     47: 
                     48:     fun prod l = let fun loop [] = 1
                     49:                       | loop(0::r) = raise Prod
                     50:                       | loop(a::r) = a * loop r
                     51:                 in loop l handle Prod => 0
                     52:                 end
                     53: 
                     54: can be written with callcc as follows:
                     55: 
                     56:     fun prod l = callcc(fn exit => 
                     57:                           let fun loop [] = 1
                     58:                                 | loop(0::r) = throw exit 0
                     59:                                 | loop(a::r) = a * loop r
                     60:                           in loop l
                     61:                           end)
                     62: 
                     63: But continuations are more general than exception handlers and can be
                     64: used to implement sophisticated control structures. These more complex
                     65: uses often involve subtle interactions with the type system.  For just
                     66: a taste of the techniques involved consider the following example
                     67: implementing an infinite loop.
                     68: 
                     69:     datatype State = S of State cont 
                     70:     fun state_throw (S k) = throw k
                     71: 
                     72:     let val s = callcc S
                     73:     in state_throw s s
                     74:     end
                     75: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.