It's been funny watching this discussion spin wildly out of control.
As one of the people who helped spark the thread, let me clarify my
reasons for discussing the topic:
It's in order to gain some perspective on language design in order to
help me design my own lisp dialect -- a part time project I've been
engaged in for about a decade, with functioning and useful
intermediate products to show.
The thread took off into repeated slanders of all fans of Scheme and
all fans of lisp-1 (Kenny has lead a rough professional life, I
infer). The tone from a few posts seems to indicate that any
_mere_discussion_ on this list of the lisp design space must be
vigorously pushed aside as an unwarranted attack on the CL standard.
If one had to take the thread too seriously, it would be very sad (but
it's just usenet, and cll to boot, so its as much just verbal
fireworks as anything: kudos to the skilled flamers who got to drop in
trivia from the field of linguistics and the other skilled flamers who
shared their first-person insights into the history of the CL
standard). Taking it "just seriously enough", though, it came out
pretty interesting.
From:
http://www-jcsu.jesus.cam.ac.uk/~csr21/lispfaq.html#AEN19
1.1. What is the purpose of comp.lang.lisp?
The charter at ftp://ftp.uu.net/usenet/control/comp/comp.lang.lisp
states that the purpose of comp.lang.lisp is "Discussion about
LISP". It is somewhat in the nature of things that newsgroups'
purposes evolve, as do names. Firstly, the newsgroup has evolved
such that the main topic of discussion is ANSI Common Lisp, though
discussion about other lisp variants is welcome within reasonable
bounds. Secondly, the spelling "LISP" is passe'; while it does
reflect the initial abbreviation, it no longer reflects the actual
language, so "Lisp" is the preferred capitalization.
Lisp is not Common Lisp. Lisp is a vaguely defined collection of
ideas, most of them pretty good.
About my language design and its relation to CL:
One big issues is simple data exchange --- can we read and write each
others s-exps, or at least a large and interesting subset of them?
On that, the nature of the false value (is it nil?) is critical.
Another big issue is lisp-1 vs. lisp-2 -- can we (with glue libraries)
reasonably run each other's libraries?
-t
····@emf.emf.net (Tom Lord) writes:
> ... in order to gain some perspective on language design in order to
> help me design my own lisp dialect ...
> Lisp is not Common Lisp. Lisp is a vaguely defined collection of
> ideas, most of them pretty good.
"I don't make the rules, but..." <-- obligatory disclaimer since every
request I make these days seems to
get taken as if I was ordering people
around. I'm not. I'm just asking...
I'd like it really a lot if, since mostly we do talk about CL, people
who were not talking about CL would label their subject lines to
reflect the alternate topic.
If the load were even among communities, I'd suggest we all do it.
At rec.arts.tv.soaps.cbs, for example, every CBS soap has messages
whose subject line begins with a letter code saying what soap is
being talked about, so that several shows can co-reside on one newsgoup.
(Why they don't spin this off into four or more newsgroups, I don't know.)
Since CL is the most common topic here, I don't personally think it's worth
wasting the horizontal space on every CL-related message to put [CL] at
the start of the subject line.
If you'd just write subject lines like:
[ISLISP] blah blah
or [ARC] blah blah
or even [ISLISP][CL] ...
it would help a lot to set the stage for your text, plus you'd make
filtering a lot easier for those who only want to hear about a certain
dialect, or who don't want to hear about a certain dialect.
I'd have started the trend on my reply here, but since you've not followed
my suggestion (yet), I don't know what you call your lisp. Which highlights
the additional fact that following this suggestion is also a cheap form of
advertising for your dialect. ;)
> About my language design and its relation to CL:
>
> One big issues is simple data exchange --- can we read and write each
> others s-exps, or at least a large and interesting subset of them?
> On that, the nature of the false value (is it nil?) is critical.
I don't think you can just print list data and expect to win.
Because Lisp puns the false value and the empty list, while
Scheme does not, it means that
(print '(defun foo nil nil))
with no language context is going to either print
(DEFUN FOO NIL NIL)
or (DEFUN FOO () ())
or, if you somehow do superhuman things to the printer,
(DEFUN FOO #f #f)
but none of these is going to be satisfactory for Scheme.
You really want
(DEFUN FOO () #f)
and that's going to be hard to achieve without some contextual knowledge.
[You might want to check whether you can tailor the pretty-printer to
do the right thing. It has, or can be made to have, just about enough
contextual knowledge... I think. Then again, even the pretty printer
is unlikely to get
(cons 'nil 'nil)
right, since this probably should print as
(cons 'nil '())
and I'm not sure it's really up to knowing what kind of argument every
function needs or wants.]
> Another big issue is lisp-1 vs. lisp-2 -- can we (with glue libraries)
> reasonably run each other's libraries?
Regarding interchange issues between Lisp1 and Lisp2, this is
something I've given a lot of personal thought to. I don't purport to
have the only possible answer, but I did make a start on implementing
one possible answer and I was hoping sometime to finish that work
before reporting it. But since it's been a really long time (years)
since I had time to work on this project, I'm thinking what I'm going
to do is post my partial work on it and wait for someone with the
time/interest to coordinate with me about any future work that might
be warranted (if any--it's always possible that the entire community
will think it's just junk and no one will want to). Eventually, if
this were more thoroughly worked out, it might lead to something
vendors could implement in order to provide cross-language
interchange, but for right now I think there are some theoretical
issues to resolve.
Then again, I think what you and I mean about interchange is quite
different. So maybe you want something differen than what I, at
least, have to offer.
From: Tom Lord
Subject: [SYS] Re: lisp-1 v lisp-2 (<whine>Can't we all just get along?...
Date:
Message-ID: <vdb6f8the5je66@corp.supernews.com>
Kent:
[Oh, yeah... it was you, not Kenny, that I meant to accuse of
slandering Schemers :-). A mistake which should give you some
idea of just how serious an offense I think is involved. Glad
to see nobody's getting bent about it.]
> I'd like it really a lot if, since mostly we do talk about
> CL, people who were not talking about CL would label their
> subject lines to reflect the alternate topic.
I'll try to remember. Reasonable suggestion.
> Which highlights
> the additional fact that following this suggestion is also a
> cheap form of advertising for your dialect. ;)
Uh... hmm.... [SYS] will do ("Systas Scheme" --- as in Scheme for
systems programming (for some sense of the phrase "systems
programming")).
>> About my language design and its relation to CL:
>> One big issues is simple data exchange --- can we read and
>> write each others s-exps, or at least a large and
>> interesting subset of them? On that, the nature of the
>> false value (is it nil?) is critical.
> I don't think you can just print list data and expect to
> win. Because Lisp puns the false value and the empty list,
> while Scheme does not
Believe me I know. The obnoxious thing you thought I wanted to do
here, change CL, is close to the obnoxious thing I actually wanted to
do on cls -- specifically, get back to the good ol' days when Scheme
permitted nil and false to be the same.
I quite like the CL pun. I think there are deep reasons why it
_might_ make _objective_ good sense -- but I can't prove it
(essentially, it's just a hunch). Not _one_, not a _single_one_ of
the cls hackers agrees.
And meanwhile, the SRFI process continues its slow ramp-up to success
-- and that's hard to ignore.
I think it was you (or Kenny :-) who a while back advised me
(paraphrasing): "Have the balls to design the language _you_ believe
in." Well, that's my default state. I've so far decided to make
nil and false distinct as a kind of social experiment -- deliberately
holding my nose and bowing to the wisdom of the (unanimous) cls crowd,
for which I'll get SRFI compatibility in return.
> [You might want to check whether you can tailor the
> pretty-printer to do the right thing. It has, or can be
> made to have, just about enough contextual knowledge... I
> think. Then again, even the pretty printer is unlikely to
> get (cons 'nil 'nil) right, since this probably should print
> as (cons 'nil '()) and I'm not sure it's really up to
> knowing what kind of argument every function needs or
> wants.]
Another approach: Among the design notes for Guile are some thoughts
about a system that has multiple non-eq false values. It doesn't
work. Whether the pun or the distinction is better -- the split
between them seems irreconcilable.
> Another big issue is lisp-1 vs. lisp-2 -- can we (with glue
> libraries) reasonably run each other's libraries?
>> Regarding interchange issues between Lisp1 and Lisp2, this
>> is something I've given a lot of personal thought to. I
>> don't purport to have the only possible answer, but I did
>> make a start on implementing one possible answer and I was
>> hoping sometime to finish that work before reporting it.
>> But since it's been a really long time (years) since I had
>> time to work on this project, I'm thinking what I'm going to
>> do is post my partial work on it and wait for someone with
>> the time/interest to coordinate with me about any future
>> work that might be warranted (if any--it's always possible
>> that the entire community will think it's just junk and no
>> one will want to). Eventually, if this were more thoroughly
>> worked out, it might lead to something vendors could
>> implement in order to provide cross-language interchange,
>> but for right now I think there are some theoretical issues
>> to resolve.
>> Then again, I think what you and I mean about interchange is
>> quite different. So maybe you want something differen than
>> what I, at least, have to offer.
To be honest, given the computing context in which I navigate, my
biggest concern for data interop (write/read exchanges) is swapping
basic s-exprs with GNU emacs. Sounds trite, I realize.
Ok, there's a secondary heavily predicated concern: I think CLispers
could Win Big by blowing away a lot of the basic web infrastructure
tools with a comprehensive, integrated alternative (e.g, apache).
_If_ that happened, then compatible s-exp exchange would be a big win.
In terms of code interop: nothing very specific in mind. There's a
few famous lisp-2 libraries out there that look casually intersesting
(e.g., macysma forks and emacs calc).
None of the interop stuff is an overriding design concern for me -- it
just seems a shame that, for example, #f/() pedantry complicates
talking to emacs so much.
-t
From: Kenny Tilton
Subject: Re: [SYS] Re: lisp-1 v lisp-2 (<whine>Can't we all just get along?...
Date:
Message-ID: <3ED61CF4.7060505@nyc.rr.com>
Tom Lord wrote:
> Kent:
>
> [Oh, yeah... it was you, not Kenny, that I meant to accuse of
> slandering Schemers :-).
Don't forget the nasty personal attack you bundled with that accusation.
> A mistake which should give you some
> idea of just how serious an offense I think is involved.
Yeah, quickly change the subject away from the gratuitous personal slam,
which does not get any better by changing the target.
But what do I expect? You cannot even apologize to the unintended
insultee. It is frightening to think you could learn better people
skills from Marc Spitzer, who did just that a couple of days ago.
> Glad to see nobody's getting bent about it.
:)
--
kenny tilton
clinisys, inc
http://www.tilton-technology.com/
---------------------------------------------------------------
"Everything is a cell." -- Alan Kay
Kenny Tilton <·······@nyc.rr.com> writes:
>
> But what do I expect? You cannot even apologize to the unintended
> insultee. It is frightening to think you could learn better people
> skills from Marc Spitzer, who did just that a couple of days ago.
Good lord, I am being too nice. Thank you Kenny for pointing it out.
The quite times are over I'm backkkkkkkkkkk!!!!!!
marc
[Perhaps getting a bit silly here, but...]
Kent M Pitman <······@world.std.com> wrote:
+---------------
| (print '(defun foo nil nil))
| with no language context is going to either print
|
| (DEFUN FOO NIL NIL)
+---------------
Which is what CLISP prints.
+---------------
| You really want
| (DEFUN FOO () #f)
| and that's going to be hard to achieve without some contextual knowledge.
+---------------
Well, (unlike CLISP) CMUCL actually *does* print the CL version of that!
> (print '(defun foo nil nil))
(DEFUN FOO () NIL)
(DEFUN FOO () NIL)
>
+---------------
| [You might want to check whether you can tailor the pretty-printer to
| do the right thing. It has, or can be made to have, just about enough
| contextual knowledge... I think.
+---------------
I think so, too. See above. ;-} ;-}
+---------------
| Then again, even the pretty printer is unlikely to get
| (cons 'nil 'nil)
| right, since this probably should print as
| (cons 'nil '())
| and I'm not sure it's really up to knowing what kind of argument
| every function needs or wants.]
+---------------
FWIW, both CLISP & CMUCL print "(NIL)" for that.
[Or were you really asking about (quote (cons 'nil 'nil))?]
-Rob
-----
Rob Warnock, PP-ASEL-IA <····@rpw3.org>
627 26th Avenue <URL:http://rpw3.org/>
San Mateo, CA 94403 (650)572-2607
Kent M Pitman wrote:
> I'd like it really a lot if, since mostly we do talk about CL, people
> who were not talking about CL would label their subject lines to
> reflect the alternate topic.
Kent -
Isn't the fact that enough non-CL posts are coming through that this would
be helpful indicate that it is again time to split the group? For
instance, I could see the value of having comp.lang.lisp.common so that I
no longer have to wade through the other stuff. I guess that this is a
surrender of sorts. So be it...
faa
In article <··············@corp.supernews.com>, ····@emf.emf.net (Tom
Lord) wrote:
> Another big issue is lisp-1 vs. lisp-2 -- can we (with glue libraries)
> reasonably run each other's libraries?
It turns out actually to not be very hard to make CL approximate a Lisp1.
Here's a simple first-order solution:
(defun functify (vars body)
`(flet ,(mapcar (lambda (var)
`(,var (&rest args) (apply ,var args)))
vars)
,@body))
(defmacro lambda1 (vars &body body)
`(lambda ,vars ,(functify vars body)))
(defmacro defun1 (name vars &body body)
`(defun ,name ,vars ,(functify vars body)))
This lets you treat lexical bindings as if they were Lisp1 bindings, e.g.:
(defun1 foo (x y z) (x y z))
(foo (lambda1 (x y) (x y)) (lambda1 (x) (x x)) #'list)
Add a top-level deflexical and you have a pretty decent approximation of
(a useful subset of) Scheme semantics.
The one thing this doesn't let you do is ((f ...) ...) or ((lambda1 ...)
...). That requires a change to the standard.
E.