Here is an example using only the primitives:

(let ((m (make-parameter 0)))
  ((parameterize ((m 4))
     (call-with-continuation-prompt
      (lambda ()
        ((call-with-composable-continuation
          (lambda (k)
            (abort-current-continuation (default-continuation-prompt-tag)
              (lambda () k))))))))
   m))

In Racket, it evaluates to 0 and not to 4.

Am Fr., 18. Nov. 2022 um 20:51 Uhr schrieb Shiro Kawai <xxxxxx@gmail.com>:
>
> Racket v8.6 behaves the same way.
>
> On Fri, Nov 18, 2022 at 9:29 AM Shiro Kawai <xxxxxx@gmail.com> wrote:
>>
>> 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.
>>> >
>>> >
>>> >
>>> >
>>> >
>>> >
>>> >