John, thanks for commenting.

On 2022-01-16 13:29 -0500, John Cowan wrote:
> On Sat, Jan 8, 2022 at 1:26 PM Marc Nieper-Wißkirchen <xxxxxx@gmail.com>
> wrote:
> >  the existence of SRFI
> > 26 is not really an argument in favor of SRFI 232.
> >
>
> I think it is cited as related work, not as an argument in favor.  It's
> common for "related work" to be quite different from the work that cites it.

Yes.  I think I'll mention in the document that SRFI 232 is not
intended as a replacement for SRFI 26.

> (2) My biggest complaint about the lambda* form is that the behavior
> > is irregular. If I apply as many arguments as there are formals, it
> > would make as much sense to return a thunk. The arbitrariness at such
> > limit points is a source for future programming errors.
>
> I agree.  I think the correct resolution is to disallow nullary procedures
> altogether, with or without tail arguments, since it is entirely unclear
> whether to return the procedure or to invoke it.
>
> In Hemann's terms, this means supporting up to Variant 5 but not 6 or 7,
> but including 8, which is independent of the rest and simply provides for
> multiple expressions in the body.

I think (but I'm not sure) that this is orthogonal to what Marc
is referring to; lambda*'s semantics are still somewhat ambiguous
when it comes to applying vs. returning a procedure:

    (define foo (lambda* (a) a))
    (foo)    ; => procedure
    (foo 4)  ; => 4 (but possibly a procedure?)

Here, (foo 4) *could* evaluate to a thunk instead of the result of
evaluating its body; it's exactly the same ambiguity that you refer to
in the case of directly-created nullary procedures.  I've argued that
the only sensible thing here is application, so it's not a big deal:
lambda* is essentially defined such that it simply never returns a nullary
procedure.  With this guarantee, the support for nullary procedures
added in Hemann & Friedman's Variants 6 & 7 is not a problem; applying
a thunk to zero arguments must result in application, because lambda*
doesn't return thunks.  I might complain about this special-casing
of nullary procedures, but it fits nicely.

(Another lambda-compatibility feature added by Variant 7 is support
for arg-list procedures, e.g. (lambda args ...).  I can't see any
problems arising from this addition.)

On the whole, I think Jason and Daniel put a lot of careful thought
into this design.

--
Wolfgang Corcoran-Mathe  <xxxxxx@sigwinch.xyz>

"The Algol compiler was so poorly implemented that we dared not rely
on it, and working with assembler code was considered dishonorable.
There remained only Fortran." --Niklaus Wirth