> Again, fine, but I think that having an API for (somehow) working with
> comments is a pre-requisite for an srfi on directives.
> With comments that are like #!fold-case, I don't even know how to do that.
> For example, if some Scheme implements one of those non-sexpy syntax
> srfis, and especially if a file switches the syntax in the middle of a
> file.
> ```
> #!/usr/bin/env my-scheme
> #!r7rs
> (display "hello world1\n")
> #;(comment number one)
> #!my-funky-syntax
> display:
>    "hello world 1\n"
>    /* comment number 2*/
> ```
>
> How would you read that?

The reader has to understand all the directives that change syntax.
#!r6rs the most famous example of such a directive. A reader that
doesn't know what to do about #!my-funky-syntax could not read that file
properly.

IMHO changing syntax in the middle of a file is a really bad idea in
general (PHP and HTML being good examples), and pursuing it leads to
more bad ideas on top, but not everyone agrees, and in theory Scheme
allows something like #!my-funky-syntax to change everything.

>>> I don't see a value in that.
> I see value in that, but I agree that adding "directives" as a
> disjoint entity means needlessly increasing complexity.
>
> I see an IDE reading a file with "read" and getting "something reasonable".

Directives are fundamentally intended to have an effect, and comments
are fundamentally intended to have no effect. That's quite
irreconcilable if we want to have a rational foundation for the
different parts of the syntax.

I agree that directive syntax and comment syntax can look similar, and
that uniformity in surface syntax can be exploited to simplify reading /
processing.

>>> The point of comments is to be ignored by the computer.
> Well, nothing on a computer is truly ignored.

A comment shouldn't affect the semantics of reading or running the
program. (It affects the reader's idea of line and column numbers, but
that's about it.)

> To me, it makes sense to help an IDE as much as possible, even though
> there is not that much that can be done.
> Still, you can keep things valid in the present Schemes, while helping
> and IDE (who is the primary user of those structured comments), a bit,
> without changing the existing syntax.

I agree that parsers and IDEs that can keep comments around and do
things to them are very useful in some cases.
https://github.com/weinholt/laesare is one Scheme reader that reads
comments.

However, comments and directives fundamentally serve a different purpose
(save for the magic comments hack that some languages have embraced; but
then again, JavaScript has done magic strings by having the literal "use
strict;" have special meaning; there's no end to what can be done with
duct tape and bubble gum :)

Many Lisp systems have a code walker that can help do transformations to
the source code beyond what ordinary macros can. It would probably make
sense to have one for Scheme as well.