I've been learning about continuation marks so that I can implement
them in MIT/GNU Scheme, and I've run across some things I'd like to
discuss.  There are two things: the first is my understanding of the
underlying model, which seems to be different from the one presented;
the second is some quirks about the interface.

Let me prefix the following by saying that I'm not asking for the SRFI
to be changed.  I'm simply looking for some clarity and discussion
about the choices.  Perhaps a future alternative SRFI may come of
this, if there's anything worthwhile here.

1.

Trying to understand the model shown in the code was very confusing,
mostly because of the complicated rules about the FLAG value, which is
supposed to indicate whether the expression being evaluated is in
tail-recursive position.  In the process, I came up with an
alternative model in which the flag is unnecessary.

In the alternative model, the MARKS value is a list of frames, as in
the example code.  Each mark frame is the mark set of the
corresponding continuation frame.  When a continuation frame is
created, it contains the value of MARKS at that point, after which
MARKS is updated by pushing a new empty mark set at the beginning.
When a continuation frame is invoked, MARKS is restored to the stored
value.

Now, the model I describe suffers from creating many empty frames when
continuation marks are used sparingly, so I'd apply a simple
optimization.  When a continuation frame is created, instead of
changing MARKS, it is left as is.  Then, which a continuation mark is
set, the value of MARKS is compared to the one stored in the topmost
continuation frame, and if they're the same, a new mark frame is
created.  This avoids creating empty mark frames, and pushes some of
the cost onto the use of marks.

This seems to me to be a very simple and valid model for continuation
marks, but I'd like some feedback from those who've spent more time
thinking about it than I have.

2.

As for the interface, I have two nits.  While I understand that one
goal of this SRFI is compatibility with Racket, I think that the
original design is flawed.

First, WITH-CONTINUATION-MARK doesn't really make sense, as it misuses
the WITH- pattern generally used in Scheme.  This pattern generally
implies that some change is valid for a particular extent that is
delimited by the WITH- form.  But that's not the case for
with-continuation-mark: once the change is made, it persists past the
end of the form until the enclosing continuation frame is invoked.  As
such, it would make more sense to have SET-CONTINUATION-MARK! which
more clearly indicates what's happening.  As a bonus, the latter
syntax is simpler.

Second, two different names are used for the set of continuation
marks.  The procedure CURRENT-CONTINUATION-MARKS retrieves them, and
CONTINUATION-MARKS? tests for such an object.  But when interrogating
the sets, CONTINUATION-MARK-SET->*** are used.  So what does the
latter mean?  Is CONTINUATION-MARK-SET an alias for
CONTINUATION-MARKS, or is it saying that the parameters specify a
subset of the marks and the procedure is returning those?  And if the
latter, it seems that the procedure CONTINUATION-MARK-SET->LIST*
should be called CONTINUATION-MARK-SETS->LISTS.

Again, I'd appreciate hearing feedback about this.

Thanks,
Chris