Derek Martin <c...@pizzashack.org> wrote:
> I think I have though, not that it matters, since that was never
> really my point. Python's assignment model requires more explanation
> than the traditional one, simply to state what it does. That alone is
> evidence (but not proof).
Hmm. Actually, it's not the assignment model which is strange at all.
It's the data model. What does an expression like
[1, 2, 3]
denote? Is it the list itself, or a /reference/ to the list? If you
answer the first, you'll want Tcl/C/Fortran semantics. If you answer
the second, you'll want Lisp/Python/Javascript semantics. If you answer
`it depends', you'll want to be confused.
Python decided that all values are passed around as and manipulated
through references. (There are no locatives: references are not values,
and you can't have a reference to a reference.) Lists store references;
tuples store references; and so on.
If one is to be able to implement complex data structures which involve
sharing of data (e.g., cyclic graphs) or which allow efficient
reorganization (e.g., various kinds of trees) we need to be able to
manage references to values somehow. There are a number of ways of
doing this.
* Everything is a reference. This is the most uniform. Once you've
got the hang of it, there are no surprises.
* Nothing is a reference. If you want complex data structures, you're
either screwed (e.g., if your data model is too weak) or you have to
invent them yourself using array indices or something wretched like
that. Tcl is in this category: you have to mess with (associative)
arrays or variable names to make complex data structures.
* Some values are references to others. This is like C, and causes
exciting problems when you get confused. C++ makes things more
confusing because dereferencing can happen implicitly. Perl manages
to be in this camp /and/ the first one. It's very strange.
* Some things are references, and some aren't. This is what Java and
C# do. Java says that only simple, atomic things are
non-references, so assignment looks the same either way, but you
can't store primitive things in containers expecting to store
references (until Sun added automatic boxing and unboxing --
eventually). C# makes matters more complicated by letting users
define structured mutable data which aren't handled by reference,
but does the boxing and unboxing thing transparently.
> As for there being no assignment in algebra, is that not really what
> variable substitution is?
No.
> They have different names, but in my estimation they perform exactly
> the same function. You're assigning specific values to the variables
> in an expression so that you can solve for a constant... just like in
> a computer program.
When you do this, you construct a different expression. They might have
equal values, but they're still different. (You can consider
equivalence classes under some appropriate equivalence relation if you
like, but that just makes things more complex.)
> There is even an allocation of memory: it's in your brain. :D
Ahh! You're modifying a memory location in your brain so that it refers
to a different expression. Isn't this the Lisp/Python/Javascript model?
;-)
-- [mdw]
--
http://mail.python.org/mailman/listinfo/python-list
