On 2/15/2022 7:35 AM, Stefan Monnier wrote:
> Does someone know of an article or rationale explaining why `lambda` is
> a macro, i.e. why the fully-expanded code needs to be (function (lambda
> ...)) rather than just (lambda ...)?
>
> I can guess its origin as an accident of history, but I think there's
> been enough years between the introduction of #' to fix the accident and
> the design of Common Lisp to have it fixed, so I'm wondering if there
> were other reasons to keep `lambda` as something that's relegated to
> `function` as opposed to being a special-form.
I just noticed this thread and quickly scanned through it, i.e., I may
have missed that what I'm about to say is redundant. If so, apologies in
advance.

I believe that if (lambda ...) is usable everywhere and is considered a
functional constant, than so must be '(lambda ...). However, you can no
more close a quoted lambda in the current lexical context than you can a
variable. Consider (eval 'v) which accesses the global binding of v, not
a v bound locally.

Consider the differences among the following evaluated at runtime from
compiled code:

1 (eval (lambda ...))

2 (eval '(lambda ...))

3 (eval (function (lambda ...)))

Numbers 1 and 2 should return the lambda closed in the global context
while 3 should return the lambda closed in the current lexical
environment. Their is a "natural" desire to have 1 act like 3 but then
you could not claim that 1 is a functional constant. And 2 can't act
like 3 without mutilating what quote means either.

In any event, I think that the rules concerning lambda forms were
imposed to try smoothing the transition to a lexical language (augmented
with dynamic scope too) from older Lisps. There were also issues of
general semantic compatibility with usages of flet and labels that were
all about fitting in to the lexical scope scheme: so

(function (lambda ...)) => (flet((g ...)) (function g)), where g is an
anonymous symbol.

You simply couldn't consistently achieve this effect if the evaluator
(eval or the compiler) couldn't deal with scoping issues at encounter
time as opposed to application time. Quoting or calling (lambda ...) a
constant makes that impossible.
--
Jeff Barnett

> I believe that if (lambda ...) is usable everywhere and is considered
> a functional constant, than so must be '(lambda ...).

I don't see why. Maybe we don't have the same understanding of "usable
everywhere", but my question was about making lambda a special form, so
that would make it usable anywhere a form can be used, but not
literally everywhere, of course.

Stefan

Madhu <enometh@meer.net> writes:

> I really detest all the source code changes that you check in to elisp
> sources that change perfectly normal uses of (lambda () ...) to
> #'(lambda () ) just to satisfy your perverted aesthetic.

While I agree that most stylistic changes to otherwise working Elisp
code are unwarranted, I've never seen Stefan make that particular change
before.

And "detest" puts it too strongly.