From: ········@bayou.uh.edu
Subject: Re: C++ briar patch (Was: Object IDs are bad)
Date: 
Message-ID: <5midqe$6em$5@Masala.CC.UH.EDU>
Peter da Silva (·····@nmti.com) wrote:
: In article <············@masala.cc.uh.edu>,

[Snip]

: > However car, cdr, etc... implement their operations is a non-issue,

: You're right, but I'm not talking about the implementation.

: It's not that the Lisp cell is implemented as a pair of pointers.

: It's that the lisp cell *is* a pair of pointers.

If this detail is something that we need not be aware of then it is
an implementation issue as far as I am concerned.  My point in
all of this -- and one that I made before, is what we as the
programmers are seeing.  



: You can do everything with these pointers that you can do with pointers in
: any other language, except perform arithmetic on them. Which was the point
: of the message you're responding to in <············@masala.cc.uh.edu>.

It's nice to know that you've kept enough of a handle on this thread
to supply a specific reference, yet it's depressing to know that you
haven't kept enough of a handle on this thread to know what I've
been talking about all along.

I was comparing a generalized pointer ala C with Lisp's generalized
list mechanism.  My entire point was that these were two entirely
different beasts.  The newcomer to Lisp can be told that there
are no pointers in the language and will never be the wiser
(particularly if s/he utilizes a functional style as I do
in Scheme).  This is all that matters and that is my point.


: > This entire genre of operations is abstracted away from us, we are
: > given a view of lists.

: Nonsense. You can build arbitrary structures with these pointers using
: the five basic operations (CONS, CAR, CDR, RPLACA, RPLACD). You obtain
: a pair of pointers with CONS, assign them with RPLACA and RPLACD, and
: dereference them with CAR and CDR.

Arbitrary structures of these _LISTS_ are nothing more than _LISTS_ of
_LISTS_.  Again there is no resemblence to the traditional pointer --
we don't allocate to it, we don't use any stupid dereferencing
symbols, etc...

Lisp is about Lists.  As far as I'm concerned there are no pointers
and until I encounter a situation that breaks the abstraction of
the high level object (lists), then I will not budge.

When you can show me an example of Lisp code that dereferences
pointers ala C or Pascal then I'll believe you, until then,
you have proven nothing.


: There's really not much more to lisp than that. Toss in COND, SET, LAMBDA,
: and EVAL and I think you've got it. (Don't beat me up too hard if I missed
: something, it's been a while since I did a lot of lisp). And I'll bet you
: could implement SET by CARing and CDRing around in OBLIST.

*Sigh*.  Read back a few more articles.


: -- 
: The Reverend Peter da Silva, ULC, COQO, BOFH, 3D0G, KIBO, POPE Ziggy Wotzit II.
: Har du kramat din varg, idag? `-_-'                                Kulanu Kibo.
: Hail Eris! All Hail Discordia!                                 Vi er alle Kibo.
: HEIL KIBO! HEIL KIBO! HEIL KIBO!                            Wir sind alle Kibo.

--
Cya,
Ahmed

Momma, where's your little daughter?
She's here, right here on the altar.
You should never have opened that door,
Now you're never gonna see her no more.
	"You Should Never Have Opened that Door" by the Ramones
From: Mukesh Prasad
Subject: Re: C++ briar patch (Was: Object IDs are bad)
Date: 
Message-ID: <338D689D.55F7@polaroid.com>
········@bayou.uh.edu wrote:

> If this detail is something that we need not be aware of then it is
> an implementation issue as far as I am concerned.  My point in
> all of this -- and one that I made before, is what we as the
> programmers are seeing.

I agree with this -- I think the "Lisp has pointers" position
is not particularly technical a point, merely a reflexive
response to "C's pointers are very good".  The abstraction
level visible to the Lisp programmer is very far removed
from C's pointers.  In real Lisp code, if one were to
do the kind of byte manipulation typical in C, one would
more likely use byte vectors that this so called
"pointer" concept of Lisp.