> Two things are conflated here, I think. We have the external
> representation of Scheme syntax on the one hand, and we have "magic
> syntax" like the one you mention that *just happens* to be interpretable
> as Scheme datums. However, such syntax should really be interpreted only
> as a string.

The use of magic comments in other languages a conceptual confusion (an
issue they were inevitably bound to hit sooner or later, given their
overspecialized syntax). A comment is supposed to be the one part of the
syntax that is dedicated to having no machine-parsed meaning, and no
machine-parsed structure. Magic comments turn comments' purpose on its
head by imbuing them with machine-parsed structure and meaning. But
since this is an ad hoc job going against the rules of the language
instead of a planned job cooperating with the rules, the structure and
meaning are hard to discern and quite brittle.

There's a philosophical choice to be made about whether to:

(1) Faithfully replicate that conceptual mistake in Scheme, but seal it
off into its own corner of the Scheme syntax by adding a dedicated magic
comment syntax that is a free-form string after a special prefix.

(2) Try to rectify the mistake by recovering as much structure as we can
from the magic directives that others have invented. It's true that we
can't represent every possible magic comment as Scheme datums, but in
practice, it turns out we can represent most of the useful ones.

The current 220 draft takes approach (2); you suggest approach (1).

> Consider, for example:
>
> #! MY-Licence-Identifier: ,,GPL-4.0-like´´
>
> This is not a sequence of valid external datum representations.
>
> As we have to distinguish between "#!" and "#! " anyway (see below), the
> obvious solution is as follows:
>
> SRFI 220 does not touch the "#!" syntax but introduces the "#! " syntax.
> This is read like ";" but other tools may interpret what follows *as a
> string*.

[Discussed in the other sub-thread]

> I understand this compromise but your use of newlines still seems alien
> to the usual Scheme syntax. When outputting several datums in a row, a
> pretty printer may still decide to insert newlines (which have counted
> just as whitespace), breaking your proposed syntax.

That's a good point.

The problem is that other languages use magic comments in an
intrinsically line-oriented manner.

I started out by trying things like (SPDX-License-Identifier: Foo) but
That kind of thing either doesn't work that well with other people's
parsers, or doesn't look natural in Scheme (e.g. you need to put extra
spaces around parentheses, which we otherwise never do).

>     We should think about whether "#!foo" and "#! foo" should be required
>     mean the same thing. That probably makes sense; it seems confusing if
>     they mean something different.
>
> This won't work with your current proposal. The "#! " syntax has to be
> disjoint from the "#!" syntax. For example
>
> #!r6rs 42
>
> is a Scheme datum
>
> while
>
> #! r6rs 42
>
> under your proposal wouldn't be.
>
> In other words, the proposed syntax of SRFI 220 has to be orthogonal to
> the established "#!" syntax in R6RS and R7RS.

[Also in the other sub-thread]