> 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”.
