If you just want to check the question of which of two tests (the ones
that are called bound-identifier=? and free-identifier=? in the
syntax-case system) are used to compare an identifier in a pattern
with an identifier in a literals list (when determining whether the
identifier is a literal or a pattern variable), then this
definitionless expression may be a better test:

That is a very helpful explanantion. Thanks!

(let-syntax
((m (syntax-rules ()
((m x) (let-syntax
((n (syntax-rules (k)
((n x) 'bound-identifier=?)
((n y) 'free-identifier=?))))
(n z))))))
(m k))

I agree with Will that bound-identifier=? is the better comparison,
and that's the way I implemented it in Alexpander and Eiod. The
literals list is logically a binding construct: it declares that some
identifiers will have a different meaning within the scope of the
declaration. It should therefore follow the hygienic rules for
bindings.

In the expander I wrote for my Rapid Scheme I used free-identifier=?. Now I recall why I made this choice; see below.

I also agree that none of the RnRS specify the answer. It's made
clear that free-identifier=? is to be used for comparing the
identifier in the macro use with the identifier in the pattern, but
that's a different comparison from the one we're talking about
(between the identifier in the pattern and the one in the literals
list).

The R7RS says: "Identifiers that appear in (<literal> ...) are interpreted as literal identifiers..."

So the question is: What does "appear in" means, e.g. whether it uses free-identifier=? or bound-identifier=? as the equality predicate of the set(oid) of <literal>s.

R7RS also says: "If an underscore appears in the <literal>s list, than that takes precedence and underscores in the <pattern> match as literals."

And: "A subpattern followed by <ellipsis> can match zero or more elements of the input, unless <ellipsis> appears in the <literal>s, in which case it is matched as a literal."

Again, the predicate "appear in" is used.

R7RS defines _ and ... as auxiliary syntax that is bound in (scheme base). Disregarding literals for a moment, the presence of _ and ... in patterns is detected by free-identifier=?. (Otherwise it would be meaningless to bind _ and ... in (scheme base) and would also not be how auxiliary syntax is matched in the R7RS; see the definition of case with the auxiliary syntax of else, for example.)

R7RS further says: "An identifier appearing within a <pattern> can be an underscore (_), a literal identifier listed in the list of <literal>s, or the <ellipsis>. All other identifiers appearing within a <pattern> are pattern variables."

Again, "appear in" is used. And here it is clear that is must be "free-identifier=?", otherwise the underscore or the ellipsis would not be matched by their denotation. (Or "appear in" would suddenly change its meaning in the very same sentence, which is absurd.)

I haven't read the R6RS thoroughly enough yet to say something about it; but at least R7RS seems to be definite (leaving aside the question on which choice might have been better).

Hopefully, the R7RS implementers can agree on this (because no agreement is the least desirable outcome). If not, I would have to try and rewrite my sample implementations for SRFI 147 and SRFI 148 for R7RS systems that do not follow section 4.3 of the R7RS literally. (Rewriting would mean to pass around huge numbers of literals in the macro-generating macros.)

If implementers and users of R7RS unanimously agreed on that bound-identifier=? would have been the better choice, we would need some erratum. E.g. "An identifier in a pattern that is the same as one of the identifiers in the <literal>'s list is interpreted as a literal identifier. All other identifiers in a pattern are either bound to the ellipsis, the underscore or are a pattern variable."

Marc