Pass by reference ?

[Gordon McMillan]

Robert W. Cunningham wrote:

> Gordon McMillan wrote:
> 
> > Robert W. Cunningham wrote:
> > 
> > > The CS models of "Pass By Reference" and "Pass By Value" are fairly well understood,
> > > but they do not seem to map simply and directly to Python.  
> > 
> > Grrr. Pascal causes brain damage. Python is exactly like Java 
> > (with the exception of having no primitive types).
> >  
> > These notions should state *what* is being passed. In Pascal, 
> > that's "value of a slot" or "reference to a slot". To be precise, 
> > in Python it is *always* "value of a reference", (think "pointer 
> > value", not "value of that which is pointed to").
> 
> <sigh>  Let's go back to CS101 and start with at least a MINIMAL set of 
> common words, definitions and concepts.
> 
> 1. Computers contain and operate upon REPRESENTATIONS only.

Nah. They operate on voltage levels represented by 1s and 0s. 
The fact that higher levels of representation are built on top of 
that is a useful fantasy.
 
> That is to say, there is no such thing as the "integer number five" in a 
> computer, only that which we CHOOSE to REPRESENT the VALUE of the purely 
> math-theoretical notion of "5".

See how you take the fantasy for reality? No way does any 
computer ever manipulate or represent an integer. The closest 
you'll come is an element of a finite algebraic group. But 
computer languages let us believe they are integers, for awhile 
at least.
 

>    def Nuke(w):
>      print w,
>      w=None
>      print w
>
> Let's call each of these functions:
> 
>    Nuke(a)
>    Nuke(b)
>    Nuke(c)
>    Nuke(d)
> 
> Look at the output:
> 
>    5 None
>    5 None
>    [5] None
>    {"five":5} None
> 
> And then look at the original values:
> 
>    print a,b,c,d
> 
>    5 5 [5] {"five":5}
> 
> None changed!  Therefore, representations the functions modified were 
> DIFFERENT from those passed, though it is clear that the correct VALUE 
> was passed.

And in each case the VALUE OF THE REFERENCE was 
nuked. You didn't modify any referent. You reassigned.
 
> This behavior meets the classical definition of "Pass By Value".

Yes, the value of the reference. When you say "a=5" in 
Python, a holds a reference to an object. The object holds a 
representation of something we take to be the number 5. 
Passing a to a function is done by copying the value of a (not 
the object a references). Therefor assigning to a in the called 
function has no effect on the caller. If the object is mutable, 
changes to the object will be visible in the caller.

This is NOT unique to Python. Technically, this is "call by 
value", but it's "value of the reference". However, because 
changes to mutable objects are visible to the caller, people 
often call it "call by reference", which, as you've observed, it's 
not.

The real problem is that "call by value" and "call by reference" 
have an unspoken assumption that variables are slots.
 
> What other tests have I omitted, and what do they yield?

You've missed a level of indirection. The label is not the object.

- Gordon