On Sat, 25 Apr 2009 00:32:26 +0100, Mark Tarver
<dr.mtar...@ukonline.co.uk> wrote:
OK; I think I get it. RPLACA and RPLACD are part of the id of Common
Lisp which I rarely contemplate. However what it seems to be is that
the difference is this. Lisp operates a destructive operation like
RPLACA in such a way that RPLACA on a global G not only changes G, but
all globals that reference G. Python on the other hand has a
destructive operation a[0] = .... which acts a bit like RPLACA but
whose change is local to the global changed. I take it that this is
because Python essentially copies the list, creating a brand new
vector rather than playing with pointers. Is that more or less it?
In the specific case of list concatenation, Python copies the lists
being concatenated. For other list operations this is not necessarily
true. What is different is the concept of "all globals that
reference G". For example:
a = [1, 2, 3]
b = a
a[0] = 0
print b
[0, 2, 3]
Which brings me to my next question. Assuming that we ban the use of
destructive operations like a[0] = ... Lisp's RPLACA and all the
rest. Assuming the following Python encodings, and ignoring questions
of performance, would Python and Lisp lists then be observationally
indistinguishable? i.e. would these then be fair encodings?
def car (x):
return x[0]
def cdr (x):
return x[1:]
def cons (x,y):
return [x] + y
I'm not sure you get a useful language by banning the destructive
operations. In particular, list slicing is another copy operation,
so you're going to run into exactly the same set of problems.
--
Rhodri James *-* Wildebeeste Herder to the Masses
--
http://mail.python.org/mailman/listinfo/python-list
