Hi, I think I still favor Interlisp over Common Lisp, or so I think.
Wasn't it in Interlisp where you had (de ...) instead of (defun ...)
and (df ....) for "special forms" (where arguments were not evaluated?
Wasn't it that you would say:
(de (a . rest) ...)
instead of (defun (a &rest rest) ...) in common lisp? I guess no big
deal, still I like less special syntactic sugar.
But really I wonder whether the Interlisp Reference Manual is available
electronically somewhere? I have been Googling and searching for it
at the Xerox PARC web site but no luck. Anyone have it?
thanks,
-Gunther
"G. Schadow" <·················@gusw.net> wrote in message news:<························@newssvr28.news.prodigy.com>...
> ... Wasn't it in Interlisp where you had (de ...) instead of (defun ...)
> and (df ....) for "special forms" (where arguments were not evaluated?
> Wasn't it that you would say:
>
> (de (a . rest) ...)
>
> instead of (defun (a &rest rest) ...) in common lisp? ...
Gunther,
I think you're thinking of UCI Lisp, and what you want in the way of
documentation is "The New UCI Lisp Manual" by James Meehan, published
by LEA (Lawrence Erlbaum Associates) in 1979. AFAIK, this never ran
on anything other than the PDP-10 family -- although there might have
been a UCI-like Lisp that ran on mid-80s micros, I don't remember for
sure -- so good luck getting an implementation up and running!
-- rar
* Bob Riemenschneider:
> I think you're thinking of UCI Lisp, and what you want in the way of
> documentation is "The New UCI Lisp Manual" by James Meehan, published
> by LEA (Lawrence Erlbaum Associates) in 1979. AFAIK, this never ran
> on anything other than the PDP-10 family -- although there might have
> been a UCI-like Lisp that ran on mid-80s micros, I don't remember for
> sure -- so good luck getting an implementation up and running!
TLC Lisp saw the eighties. It was dynamically scoped, lived in only
one single namespace, supported object oriented programming (possibly
through a simplified kind of Flavors), had a compiler, an IDE...
It ran on i8080 and i8086.
With DE, DF, DM Lispniks defined EXPR's, FEXPR's and macros. FEXPR's
were not applyable. For a detailed discussion of FEXPR's see the
well-known Special Forms in Lisp by Kent Pitman.
Examples:
(DE FUNCALL (F X)
(F X))
(DF KAR (L)
(CAR L))
(KAR A B C) => A
--
"Hurry if you still want to see something. Everything is vanishing."
-- Paul C�zanne (1839-1906)
·····@gmx.net (Wolfhard Bu�) writes:
> * Bob Riemenschneider:
> > I think you're thinking of UCI Lisp, and what you want in the way of
> > documentation is "The New UCI Lisp Manual" by James Meehan, published
> > by LEA (Lawrence Erlbaum Associates) in 1979. AFAIK, this never ran
> > on anything other than the PDP-10 family -- although there might have
> > been a UCI-like Lisp that ran on mid-80s micros, I don't remember for
> > sure -- so good luck getting an implementation up and running!
There are, I believe, several PDP10 emulators running around on the net
these days, so this shouldn't be as hard as it sounds.
> TLC Lisp saw the eighties. It was dynamically scoped, lived in only
> one single namespace, supported object oriented programming (possibly
> through a simplified kind of Flavors), had a compiler, an IDE...
> It ran on i8080 and i8086.
What is TLC Lisp? I'm not sure if I know that dialect.
> With DE, DF, DM Lispniks defined EXPR's, FEXPR's and macros. FEXPR's
> were not applyable.
FEXPRs _were_ applicable in Maclisp. See my explanation farther below.
> For a detailed discussion of FEXPR's see the
> well-known Special Forms in Lisp by Kent Pitman.
Thanks for the citation. The actual URL is
http://www.nhplace.com/kent/Papers/Special-Forms.html
> Examples:
>
> (DE FUNCALL (F X)
> (F X))
>
> (DF KAR (L)
> (CAR L))
>
> (KAR A B C) => A
Actually, I _suspect_ the thing you were INTENDED to do with it was
(DF KWOTE (L) (CADR L))
(KWOTE X) => X
although I don't know this dialect specifically.
In Interlisp, which at least the subject line was about, the situation
was complicated by the presence of DWIM. Interlisp did not (to my
knowledge, though I only read the manual and never used it personally)
have macros, it had "compiler macros". DWIM was willing to "fix" the
"bug" of using a "compiler macro" in interpreted code, but I believe
this caused a problem for people who didn't like DWIM and wanted to
turn it off. (It was the tower-of-cards nature of Interlisp and its
reliance on DWIM that put me off to it and made me feel strongly that
the Maclisp family was what needed to progress into the coming decades
back when these two families were in conflict. I was fairly confident
that, if necessary, DWIM could be built on Maclisp-like systems, but
not that Maclisp-like systems could be build upon DWIM... even though
we lost a lot of cool user-interface tools and human mindshare in the
process of bludgeoning Interlisp and its associated community to near
death.)
Interlisp also had NLAMBDA, which I believe could be applied. I know that
the comparable technology in Zetalisp (the native-level LispM dialect)
using "E was able to be applied. That is,
(LET ((A 1))
((LAMBDA ("E X) X) A))
=> A
(LET ((A 1))
(APPLY #'(LAMBDA ("E X) X) '(A)))
=> A
That is, "E is effectively ignored in APPLY situations, which is
why I always felt that it never belonged in the lambda list in the
first place. It's really advice about how to use the name that the
LAMBDA gets associated, not about how to apply the LAMBDA itself, and
so it is stored in an unmodular way when it's put in the LAMBDA.
I *think* but am not sure that
(APPLY '(NLAMBDA (X) X) '(A))
would also return A in Interlisp. Maybe someone who knows Interlisp
better could say.
Incidentally, in Maclisp, applying a fexpr _did_ "work" and it was done.
I think FUNCALL worked, too, though I don't think anyone did that.
It would have just seemed weird. I just went and tested it and it on
a pdp10 emulator near me and it seems to produce an answer even using
FUNCALL, though I remember myself and others always using APPLY. By
far the most common situation I can remember where APPLY was used on
a FEXPR is probably for (APPLY 'TRACE X) to trace a bunch of functions
whose names were not known at coding time. (APPLY 'GRINDEF X) was also
a common one, since GRINDEF was the pretty printer and there was no
functional interface...
*l^K!
LISP 2149
Alloc? n
*
(apply 'quote '(A))
A
(apply 'quote '(A B))
;((QUOTE A B) ?) WRONG NUMBER OF ARGS TO FSUBR
;BKPT WRNG-NO-ARGS
$p
;BKPT *RSET-TRAP
$p
*
(funcall 'quote '(a))
A
(funcall 'quote '(a b))
;((QUOTE A B) ?) WRONG NUMBER OF ARGS TO FSUBR
;BKPT WRNG-NO-ARGS
$p
;BKPT *RSET-TRAP
$p
*
(defun f (x) x)
F
(defun g (x) g)
G
(apply 'trace '(f g))
;Loading TRACE 67
(F G)
Kent M Pitman <······@nhplace.com> writes:
> ·····@gmx.net (Wolfhard Bu�) writes:
>
>> * Bob Riemenschneider:
>> > I think you're thinking of UCI Lisp, and what you want in the way of
>> > documentation is "The New UCI Lisp Manual" by James Meehan, published
>> > by LEA (Lawrence Erlbaum Associates) in 1979. AFAIK, this never ran
>> > on anything other than the PDP-10 family -- although there might have
>> > been a UCI-like Lisp that ran on mid-80s micros, I don't remember for
>> > sure -- so good luck getting an implementation up and running!
>
> There are, I believe, several PDP10 emulators running around on the net
> these days, so this shouldn't be as hard as it sounds.
>
>> TLC Lisp saw the eighties. It was dynamically scoped, lived in only
>> one single namespace, supported object oriented programming (possibly
>> through a simplified kind of Flavors), had a compiler, an IDE...
>> It ran on i8080 and i8086.
>
> What is TLC Lisp? I'm not sure if I know that dialect.
The Lisp Company of Anatomy of Lisp John Allen produced TLC Lisp in
the eighties, starting in 1980 in Los Gatos CA. They also produced
TLC Logo.
Don't know if John Allen's TLC Lisp did tail call optimization. There
must be a manual somewhere. ;)
>> With DE, DF, DM Lispniks defined EXPR's, FEXPR's and macros. FEXPR's
>> were not applyable.
>
> FEXPRs _were_ applicable in Maclisp. See my explanation farther below.
TLC Lisp's FEXPRs were not applicable.
>> Examples:
>>
>> (DE FUNCALL (F X)
>> (F X))
>>
>> (DF KAR (L)
>> (CAR L))
>>
>> (KAR A B C) => A
>
> Actually, I _suspect_ the thing you were INTENDED to do with it was
>
> (DF KWOTE (L) (CADR L))
> (KWOTE X) => X
>
> although I don't know this dialect specifically.
TLC Lisp's DF syntax was:
(DF <fname> (<rest-parameter> [&AUX <p1> ... <pn>]) . body)
TLC Lisp:
(DF KWOTE (L) (CAR L)) ; not CADR
(KWOTE X Y Z) => X
--
"Hurry if you still want to see something. Everything is vanishing."
-- Paul C�zanne (1839-1906)
·····@gmx.net (Wolfhard Bu�) writes:
> > What is TLC Lisp? I'm not sure if I know that dialect.
>
> The Lisp Company of Anatomy of Lisp John Allen produced TLC Lisp in
> the eighties, starting in 1980 in Los Gatos CA. They also produced
> TLC Logo.
>
> Don't know if John Allen's TLC Lisp did tail call optimization. There
> must be a manual somewhere. ;)
Ah, yes. It comes back to me now. He and TLC sponsored the first Lisp
Conference in 1980, no?
> >> With DE, DF, DM Lispniks defined EXPR's, FEXPR's and macros. FEXPR's
> >> were not applyable.
> >
> > FEXPRs _were_ applicable in Maclisp. See my explanation farther below.
>
> TLC Lisp's FEXPRs were not applicable.
Good to know. Thanks.
> TLC Lisp's DF syntax was:
>
> (DF <fname> (<rest-parameter> [&AUX <p1> ... <pn>]) . body)
It actually had '&AUX' in there? Or you mean that to be descriptive
of the p1..pn? So the p1..pn are just local vars?
> TLC Lisp:
>
> (DF KWOTE (L) (CAR L)) ; not CADR
> (KWOTE X Y Z) => X
Er, uh, right. Woulda been the same for Maclisp. I goofed on this.
FEXPRs got the cdr of the form
(DEFUN fexpr-name FEXPR ( unevaluated-args-var [ env-var ]) . body-forms )
and macros got the whole form
(DEFUN macro-name MACRO ( macro-form-var ) . body-forms )
I was just so excited to be programming in the old "friendly" format
I got carried away, I guess. ;)
Kent M Pitman writes:
> Wolfhard Bu� writes:
>> The Lisp Company of Anatomy of Lisp John Allen produced TLC Lisp in
>> the eighties, starting in 1980 in Los Gatos CA. They also produced
>> TLC Logo.
:
> Ah, yes. It comes back to me now. He and TLC sponsored the first Lisp
> Conference in 1980, no?
TLC also published the Conference Record of the 1980 LISP Conference,
Stanford, August 1980, edited by Ruth E. Davis and John R. Allen.
>> >> With DE, DF, DM Lispniks defined EXPR's, FEXPR's and macros. FEXPR's
>> >> were not applyable.
>> >
>> > FEXPRs _were_ applicable in Maclisp. See my explanation farther below.
>>
>> TLC Lisp's FEXPRs were not applicable.
>
> Good to know. Thanks.
>
>> TLC Lisp's DF syntax was:
>>
>> (DF <fname> (<rest-parameter> [&AUX <p1> ... <pn>]) . body)
>
> It actually had '&AUX' in there? Or you mean that to be descriptive
> of the p1..pn? So the p1..pn are just local vars?
Yes. TLC Lisp's syntax for optional rest and aux parameter specifiers
differed a bit from Common Lisp's, i.e., (var init-form) instead of
Common Lisp's (var [init-form]).
DF fexpr-name (var [&aux {var | (var init-form)}*]) form*
>> TLC Lisp:
>>
>> (DF KWOTE (L) (CAR L)) ; not CADR
>> (KWOTE X Y Z) => X
>
> Er, uh, right. Woulda been the same for Maclisp. I goofed on this.
> FEXPRs got the cdr of the form
>
> (DEFUN fexpr-name FEXPR ( unevaluated-args-var [ env-var ]) . body-forms )
>
> and macros got the whole form
>
> (DEFUN macro-name MACRO ( macro-form-var ) . body-forms )
The same with TLC's macros:
DM macro-name (whole [&aux {var | (var init-form)}*]) form*
The description of TLC Lisp in Stoyan, Goerz' fine LISP (unfortunately
in german only) might be more `accessible' than the original
documentation.
> I was just so excited to be programming in the old "friendly" format
> I got carried away, I guess. ;)
--
"Hurry if you still want to see something. Everything is vanishing."
-- Paul C�zanne (1839-1906)
·····@gmx.net (Wolfhard Bu�) wrote:
> Kent M Pitman writes:
>
> > Wolfhard Bu� writes:
> >> The Lisp Company of Anatomy of Lisp John Allen produced TLC Lisp in
> >> the eighties, starting in 1980 in Los Gatos CA. They also produced
> >> TLC Logo.
> :
> > Ah, yes. It comes back to me now. He and TLC sponsored the first Lisp
> > Conference in 1980, no?
>
> TLC also published the Conference Record of the 1980 LISP Conference,
> Stanford, August 1980, edited by Ruth E. Davis and John R. Allen.
Wolfhard,
Sorry for the late response, but I've been away for awhile.
I'd completely forgotten that TLC-LISP was suppose to be somewhat
UCI-like. I've never used it, but got curious a couple of years ago
after re-reading John's article "The Death of Creativity: Is Common
LISP a LISP-like Language?", which appeared in the February 1987 issue
of _AI Expert_, -- you can probably guess his answer from the title --
and the review of TLC-LISP 1.51 the following month. One of the
selling points of TLC-LISP was that it was supposed to be "a
reasonable compromise between ... LISP 1.5 and the future LISP-like
languages represented by Scheme". So, when I was chatting with him
about some other subjects, I asked him what he thought of the idea of
reviving TLC-LISP or one of the other small PC-based Lisps as a Lisp
for the Palm Pilot (which was being batted around on comp.lang.lisp at
the time). He admitted that he might have the TLC sources around the
house somewhere, but thought it was a terrible idea, so I never got
the chance to check it out.
Anyway, thanks for the info about TLC!
-- rar
"Kent M Pitman" <······@nhplace.com> wrote in message
····················@shell01.TheWorld.com...
> In Interlisp, which at least the subject line was about, the situation
> was complicated by the presence of DWIM. Interlisp did not (to my
> knowledge, though I only read the manual and never used it personally)
> have macros, it had "compiler macros".
Interlisp did have macro's but before Interlisp-D they were cumbersome to
use. It's been a long time since I lived in that world so can't remember all
the nuances, but I don't recall using macro's very much in those days.
>
> I *think* but am not sure that
>
> (APPLY '(NLAMBDA (X) X) '(A))
>
> would also return A in Interlisp. Maybe someone who knows Interlisp
> better could say.
>
Actually, it would return (A). Interlisp had four function types, in two
broad classes, (Lambda, Nlambda), (Spread, and NoSpread). NoSpread
functions took an arbitrary number of arguments, handed to the function as a
list. This is roughly equivalent to an &REST in CL. Spread had a fixed
number of arguments.
Nlambda's didn't evaluate their arguments.
So a typical CL function without any &-arguments is a lambda-spread.
...arun
"G. Schadow" <·················@gusw.net> wrote:
> But really I wonder whether the Interlisp Reference Manual is available
> electronically somewhere? I have been Googling and searching for it
> at the Xerox PARC web site but no luck. Anyone have it?
http://bitsavers.org/pdf/xerox/interlisp/
(untested)
That site has other lispm docs, including:
http://bitsavers.org/pdf/mit/cadr/chineualJan84/
Yeah! Thanks, that's it!
John Paul Wallington wrote:
> http://bitsavers.org/pdf/xerox/interlisp/
>
> That site has other lispm docs, including:
> http://bitsavers.org/pdf/mit/cadr/chineualJan84/
You probably already have this, but there is an Interlisp interpreter
which is written in portable C (compiles under windows and linux, they
say) available at http://algorithms.us/download.shtml