This is a new (or rather old) strategy for hygienic lexical syntax extension. By "properly phased" I mean in the same sense as macro phasing: extensions are defined by a mechanism that logically precedes macro expansion, much less run time.
The standard CL #. (hash-dot) syntax is followed by an arbitrary CL form which is evaluated at read time, and whatever the inner form returns is the value of the hash-dot form. So for example #.(+ 3 4) is read as 7 (as opposed to evaluating to 7 at macro-expansion time or runtime). CL lacks phasing control, so whatever happens in a hash-dot form affects everything. In this proposal, the language of forms that follow #. is limited to a language called HashDot Scheme, which is described below.
HashDot Scheme is an effect-free (modulo non-termination, allocation, and record type creation) subset of Scheme augmented with a few side effects. The HashDot Scheme evaluator is completely sealed off from the main Scheme evaluator, though it may reuse parts or all of it, but neither global nor lexical bindings from the outer Scheme are visible to HashDot Scheme.
Here are the side-effectful procedures:
1) `set-syntax!` updates an entry in the readtable, and `set-sharp-syntax!` updates a location in the sub-hashtable used for sequences of the form "#" followed by another character (possibly with intervening digits). They return no values.
2) `void!` accepts an optional argument and returns no values, which means nothing is visible to the `read` invocation. (This is not true in CL, where #.(values) evaluates to ().)
3) `read!` and `read-char!` read one S-expression or character from the stream that the outer `read` is using, and return what was read.
Comments? Of course a lot of details need working out.