> For sure, they do. Just install the Chez package for Debian. You can use
> `update-alternatives' if you have two R6RS installations, but everything
> would break down if some script in the system relied on `scheme-script'
> being something different than an implementation of R6RS.

OK, so there are implementations in Debian that install a scheme-script.
This is useful to know.

> Again, the set of possible names is virtually infinite, so (if you allow
> me to be so frank) it would just be stupid to insist on using the very
> same name.

It's not stupid. I've been under the impression it's widely recognized
that the R6RS "scheme-script" is non-normative and broken as designed,
since it gives so few guarantees about what features the script can use.
It specifies strict R6RS conformance, but nothing about what Scheme
implementation, OS, or libraries are available. The latter are probably
much more useful guarantees to most scripts, than strict R6RS semantics
are. The priorities are backwards.

Since the priorities are backwards, it's reasonable to start from the
assumption that not many practical scripts are using this mechanism
outside of a site-specific environment. After all, if you need Chez
Scheme, why not just run `chezscheme`?

We could pick another name, but `scheme-script` is the natural name for
Scheme scripts, so it pays to exhaust all the avenues for reclaiming
that one. `scheme` is another natural name, but that's effectively taken
too (contentious between Chez, MIT, and some others).

The usability of the Scheme "ecosystem" (like RMS, I find that word is
imprecise, but can't think of anything better) is improved if we manage
reclaim the simple names for the purpose that the name suggests.
Usability is weakened if things have misleading semantics, and the
problem is compounded with each decade.

> Ah, okay. But what is the meaning of the declarations then? Will they
> change the semantics of the top-level program? If it is so, it won't be
> a top-level program anymore but something more. And if not, I don't
> understand your objection against the usability of a bare R6RS or R7RS
> for scripts.

I'm getting confused about the semantics of the word "semantics" here :)

This is the most promising approach I can think of right now:

- scheme-script is a small launcher program written in C.

- The script file contains an S-expression that gives declarations read
by the launcher program.

- The S-expression can be #; commented where compatibility with Scheme
implementations that cannot parse the declarations is needed. (At the
start, this would be most Scheme implementations; maybe later, some of
them would natively be able to skip the declaration.)

- The launcher reads the declarations, and figures out the right command
line flags to run the script in a compatible and installed Scheme
implementation. If the Scheme implementation has a "run as RnRS program"
flag (e.g. `chezscheme --program`), that one should probably be used.

- If the declarations specify things like Chicken eggs, the launcher
should probably set up a cache directory, run `chicken-install` in that
directory to install the eggs, then run `csi` to run the script. Similar
maneuvers for other implementations that support packages of some kind.