Re: quote semantics

William D Clinger <cesura17@xxxxxxxxx> writes:

Ken Tilton wrote:
You are balanced on the edge. If you fall this way STFU and get on
with some useful work on Lisp libraries, if you fall that way GTF
out of here and head over to c.l.scheme.

Last I heard, Common Lisp was still being counted as a member
of the Lisp family, so its relationship to the lambda calculus
is a legitimate topic.

One can discuss this as an abstract matter, certainly, just for color.

But as a matter of both design (that is, how CL got to be) and also of
practicality (whether it's worth fussing over), Ken's post is (as
always) colorfully worded but makes a good point--there's little point
to being upset over how it is. It is what it is.

And, although I never used McCarthy's original Lisp, it was legit to
ask for that one, too, whether it was all that related to the Lambda
calculus. Inspired by it, certainly. But my recollection is that it
came nowhere close to being a literal implementation of lambda
calculus semantics, nor did the numerous dialects that followed over
the subsequent two decades. Scheme seemed pretty explicitly an
attempt to repair that, taking influence both from Alonzo Church's
work and from Algol, and conjuring a new way to do things.

And certainly CL took influence from Scheme, but chose not to be
neither a Scheme dialect nor an attempt to repatriate the Lambda
calculus with Maclisp.

So it's absolutely fine to discuss differences. What's not fine is to
claim that this community, which is entirely composed of people who,
in full knowledge of the available choices, chose to go this path,
must suddenly acknowledge that the whole path was a lie. I think Ken
is quite on track when he says that the most productive path for someone
who wants things to be done otherwise will find a happier life in
the Scheme community ... however one chooses to characterize those
communities.

As to the material part of what Ken was replying to, that is:

Nyang A. Phra wrote:
What does however still kinda confuse me is then the equivalence of
(pure) Lisp and Lambda calculus (with which I'm not too familiar,
though), as it would appear to me that in Lambda calculus there are no
exceptions to function evaluation, whereas there are in Lisp. It kinda
bothers me, though I'm not sure if that's warranted in any way.

The irony is even the Scheme community, which seems a great deal more
concerned about compatibility of this kind, makes some exceptions in
this regard and few complain.

I personally have long said [1] that I think Scheme made an error of
aesthetics in describing its core language with exceptions in the
evaluation rules. I claim that the language would be better served by
rules more like:

* the car of _any_ evaluable form must a special operator
* variable evaluation should be done by a VALUE special operator,
as in (value x) rather than just x.
* function calling should be done by a CALL special operator,
as in (call f x)
* code as written now should be seen as macrology, and a functional
operator should be available by loose analogy to CL's macroexpand
that would prepare a "casual form" for formal evaluation, by rewriting
(lambda (x y) (f y x))
as
(lambda (x y) (call (var y) (var x) (var y)))
and there could even be a reverse expander that re-introduced shorthand.

That would allow anyone doing macro processing on the symbols (not that Scheme
is very fond of that, given the hygiene issue, but that's a separate matter)
to use dispatch that was regular as to how the dispatching went. instead of
something like this (most functions made up, not actual functions, but just
to give the shape):

(define evaluate
(lambda (env form)
(if (symbol? x)
(process-atom env x)
(if (pair? x)
(let ((op (car x)))
(if (special-operator? op)
(process-special env x (car x) (cdr x))
(process-function env x)))
(error)))))

one could just write:

(define evaluate
(lambda (env form)
(if (pair? x)
(process-special env x (car x) (cdr x))
(error))))

I share Nyang's surprise that some dialect of the Lisp/Scheme family has
not appeared to take this path. If your guiding design principle is
aesthetics, it's odd to not notice this gigantic gaping hole in the
set of available names and/or how they are treated. But CL's design
principles [2] explicitly place aesthetics as a lower priority and do not
mention the Lambda calculus, so it's hardly a surprise here. Which is
again why Ken probably suggested this might not be the best group to get
down and dirty in a fight over such matters.

I didn't post my remarks about Scheme on comp.lang.scheme because I
don't see any point to challenging the Scheme community on this matter
either, frankly--they probably have better things to do as well. And
I am not much of a big fan of people showing up from other communities
just to provoke a bunch of happy people into changing something one
doesn't plan to rush out and use.

I hope no one takes any of this post as critical of any community. It's
hard to write anything that's neutrally analytical without the risk of
it being taken personally by someone. I hope follow-ups will also try to
be neutral.

[1] = Mostly just a claim I have made privately, but there are some
allusions to this desire on my part in the (admittedly
quasi-incoherent) SPIEL stuff I put in
http://www.nhplace.com/kent/Half-Baked/

[2] = The best reference I have to X3J13's charter for CL is
http://www.nhplace.com/kent/CL/x3j13-86-020.html
.

Relevant Pages

  • Re: Ideas for an SICP?
    ... Scheme, I believe, would seriously benefit from the addition of language ... Schematic, Mul-T, Symmetric Lisp, NetCLOS, EDS Lisp, ... research projects that never had a community of users. ...
    (comp.lang.scheme)
  • Re: Whats wrong with Common Lisps lambda ?
    ... Scheme, a dialect of Lisp which got lambda right (Guy Steele and Gerald ...
    (comp.lang.lisp)
  • Re: Whats wrong with Common Lisps lambda ?
    ... Scheme, a dialect of Lisp which got lambda right (Guy Steele and Gerald ...
    (comp.lang.lisp)
  • Re: Whats wrong with Common Lisps lambda ?
    ... |> Scheme, a dialect of Lisp which got lambda right (Guy Steele and Gerald ...
    (comp.lang.lisp)
  • Re: Universal Computer Truths
    ... This is the problem with modern Forth community: it is mostly made of people ... Lisp is Church-complete, ... The choice of solution has nothing to do with the language. ... from Scheme and/or Clojure, it'd probably be below Forth for both... ...
    (comp.lang.forth)