> I like the idea of allowing arbitrary s-exps following "#!" (i.e.
> "#!(precision 25)" instead of "#!precision=25") so that "#!" can be
> parsed as datum comments "#;".

John hasn't had the chance to post to srfi-discuss but sent detailed
comments about the #! proposal. Here they are verbatim:

----------------------------------------------------------------------

1) I would like to stick to the pattern “#!foo” where “foo” is any valid
Scheme identifier.

2) Depending on the value of foo, the reader may take specific action:

· For “#!encoding”, read the next S-expression (which must be a symbol),
set the encoding, and either rewind (skipping the encoding this time) or
carry on if you can change encodings in midstream (lots of systems cannot).

· For “#!fold-case” and “#!no-fold-case”, read nothing and set the
port’s case-folding flag;

· For “#!r6rs” (in R6RS systems), read nothing and set the port’s
strict-R6RS mode if the implementation has one (Larceny does, Guile
doesn’t);

· For “#!” followed by an identifier beginning with “/”, treat the whole
line as a comment.

3) Using the format “#!foo some-s-expression-depending-on-foo” allows
different values of foo to be registered and treated separately with
different rules for each, rather than aggregating them into a single
alist or such.

4) Having a procedure to set the interpretation of “#!foo” for a
specific “foo” is fine if all you want to do is affect the `read`
procedure.  But if you want to affect the compiler, you have to have a
way to run that code *in the compiler*.  Scheme has never messed about
with `eval-when`, and for very good reason.  (This issue also affects
SRFI 10, and is exactly analogous to the phasing problem in R6RS.)  So I
am in favor of standardizing new #!foo directives only by SRFI.  I have
an alternative approach from SRFI 10 in pre-SRFI form at
<https://bitbucket.org/cowan/r7rs-wg1-infra/src/default/LexmacsCowan.md>.

5) In particular, one directive I’d like to have eventually is “#!lang”,
which is followed by a module path.  The compiler/REPL dynamically
imports the module named in the path and uses the `read` procedure
exported from that module in place of its own `read`.  This allows
arbitrary other languages to be compiled/interpreted with any conforming
Scheme system.  It is similar to Racket’s “#lang”, but simpler.  (I
don’t like “#lang” because if we introduce “#l” for some new kind of
external syntax, it might be read as “#l ang”.