Just as a quick clarification: if, in the scenario below, thread T2
uses parameterize to change P1 and P2 before invoking K1 (instead of
mutation), then the values seen by the whatever's left to be done in
the continuation K1 would be 0 and 1, not 2 and 2, right?
In code, the first program is what Kent describes below in mzscheme
notation and the second is the change I'm asking about (and we see
what he predicts for the first case):
;; program 1, like Kent's below
(define p1 (make-parameter 0))
(define p2 (make-parameter 0))
(define k #f)
(define t
(thread
(? ()
(parameterize ([p1 1])
(write ((call/cc (? (_k) (set! k _k) void))))
(newline)))))
(thread-wait t) ;; wait for t to complete
(thread
(? ()
(p1 2)
(p2 2)
(k (? () (list (p1) (p2))))))
;; program 2, the one I'm asking about:
(define p1 (make-parameter 0))
(define p2 (make-parameter 0))
(define k #f)
(define t
(thread
(? ()
(parameterize ([p1 1])
(write ((call/cc (? (_k) (set! k _k) void))))
(newline)))))
(thread-wait t)
(thread
(? ()
(parameterize ([p1 2]
[p2 2])
(k (? () (list (p1) (p2)))))))
Robby
On 2/21/07, R. Kent Dybvig <dyb_at_cs.indiana.edu> wrote:
> > So the swapping compensates for the effect of side effects, and gets a
> > notion similar to "call/cc captures the contents of the storage
> > associated with the parameters." Except it seems to break down in the
> > presence of threads, as Kent explained here:
> >
> > http://lists.r6rs.org/pipermail/r6rs-discuss/2007-February/001536.html
>
> There's no claim of any break down in that note, just a clarification:
> call/cc effectively captures only the values of the parameters that are
> parameterized in the continuation, rather than the values of all
> parameters. Here's an example illustrating the difference.
>
> Let's assume that:
>
> parameter P1 is defined to be 0
> parameter P2 is defined to be 0
> thread T1 parameterizes P1 to 1 then grabs a continuation K1
> thread T2 assigns P1 to 2 and P2 to 2, then invokes K1
>
> If call/cc were to capture the current contents of *all* parameter
> locations:
>
> code run in K1 by T2 would see P1 = 1 and P2 = 0
>
> Since, however, call/cc actually captures only the current contents of the
> parameters parameterized in the continuation, only the value of P1 is
> captured, and
>
> code run in K1 by T2 actually sees P1 = 1 and P2 = 2
>
> This allows different threads to assign different default values to its
> parameters, with only those that are parameterized by a continuation
> overriding those defaults. For example, I might want each thread to
> redirect its diagnostic output to a different port by setting the
> current-output-port parameter while letting a continuation determine the
> values of other parameters via parameterize.
>
> Kent
>
> _______________________________________________
> r6rs-discuss mailing list
> r6rs-discuss_at_lists.r6rs.org
> http://lists.r6rs.org/cgi-bin/mailman/listinfo/r6rs-discuss
>
Received on Wed Feb 21 2007 - 11:20:00 UTC