I used Racket v7.2, and here's the full transcription.  I'm going to check with the newest Racket.

xxxxxx@scherzo:~/src/srfi-226$ racket
Welcome to Racket v7.2.
> (require racket/control)
> (define (print . xs) (for-each display xs) (newline))
> (define m (make-parameter 0))
> (define c #f)
> (define (foo)
    (parameterize ((m 1))
      (reset
       (print 'a: (m))
       (shift k (print 'b: (m)) (set! c k))
       (print 'c: (m)))))
> (define (bar)
    (parameterize ((m 2))
      (c #f)))
> (foo)
a:1
b:1
> (bar)
c:2

On Fri, Nov 18, 2022 at 9:26 AM Marc Nieper-Wißkirchen <xxxxxx@gmail.com> wrote:

Thanks for the report, Shiro!

I have to investigate Racket's behavior.  In 11.3.2 of the Racket
reference, it says: "If a continuation is captured during the
evaluation of parameterize, invoking the continuation effectively
re-introduces the parameterization, since a parameterization is
associated to a continuation via a continuation mark (see Continuation
Marks) using a private key."  This seems to be consistent with SRFI
226 and its sample implementation, but not consistent with your Racket
experiments.

Am Fr., 18. Nov. 2022 um 20:07 Uhr schrieb Shiro Kawai <xxxxxx@gmail.com>:
>
> It seems that there's a disagreement in how a delimited continuation captures dynamic environment, between Racket and srfi-226.
>
> Suppose the following code:
>
> ```
> (define (print . xs) (for-each display xs) (newline))
>
> (define m (make-parameter 0))
>
> (define c #f)
>
> (define (foo)
>   (parameterize ((m 1))
>     (reset
>      (print 'a: (m))
>      (shift k (print 'b: (m)) (set! c k))
>      (print 'c: (m)))))
>
> (define (bar)
>   (parameterize ((m 2))
>     (c #f)))
> ```
>
> With srfi-226 (using reset/shift as given in the srfi) reference implementation on Chez, I get this:
>
> ```
> > (run foo)
> a:1
> b:1
> > (run bar)
> c:1
> ```
>
> With Racket racket/control, I get this:
>
> ```
> > (foo)
> a:1
> b:1
> > (bar)
> c:2
> ```
>
> I'm switching Gauche's internals to srfi-226 based model, and I noticed the difference---the current released version of Gauche (relying on dynamic-wind to handle parameterization) works like Racket, while the srfi-226 based version (using dynamic env chain to keep parameters) works like srfi-226 reference implementation.
>
> I think srfi-226 behavior is more consistent (when the delimited continuation is invoked, it restores the dynamic environment of the continuation of reset), but is there a plausible explanation of Racket behavior?
>
> This difference actually caused a compatibility problem of an existing application so I want to understand it fully.
>
>
>
>
>
>
>