which language allows you to change an argument's value?

[Summercool]

I wonder which language allows you to change an argument's value?
like:

foo(&a) {
a = 3
}

n = 1
print n

foo(n) # passing in n, not &n
print n

and now n will be 3. I think C++ and PHP can let you do that, using
their reference (alias) mechanism. And C, Python, and Ruby probably
won't let you do that. What about Java and Perl?

is there any way to prevent a function from changing the argument's
value?

isn't "what i pass in, the function can modify it" not a desireable
behavior if i am NOT passing in the address of my argument? For one
thing, if we use a module, and call some functions in that module, and
the module's author made some changes to his code, then we have no way
of knowing what we pass in could get changed. Of course, if it is in
Java, Python, and Ruby, and we pass in a reference to object (not C+
+'s meaning of alias reference), so the object can get changed, but
that can be expected, vs passing in n, when n = 1. Even when it is
Ruby, when everything is an object, passing n in when n = 1 won't ever
make n become 3. Is there a way to prevent it from happening in the
languages that allows it?

[blmblm]

In article <1P************ *@newsfe12.lga> ,
John W. Kennedy <jw*****@attglo bal.netwrote:

Dennis Lee Bieber wrote:

On Mon, 01 Oct 2007 01:53:47 GMT, Roedy Green
<se*********@mi ndprod.com.inva liddeclaimed the following in
comp.lang.pytho n:

Seem to me you could in FORTRAN and Pascal, and maybe even Algol. It
has been a while.

Everything in classic FORTRAN is a passed as a reference -- even
constant arguments are passed as a reference to the memory location
containing that constant (which is why it was possible in very early
FORTRANs to have "a = 1 + 1" yield something other than "2" if preceded
by, say, "call mutate(1)" where mutate looks like:

subroutine mutate(arg)
arg = arg * 2
end

)

However, some implementations passed /and returned/ elementary arguments
by value, as Ada does.

In FORTRAN/Fortran, don't they call that "copy-in/copy-out"? Same
thing, just nitpicking a little about terminology, I hope correctly.

(The object code was typically faster that way,
and FORTRAN semantics were such that the difference was almost
impossible to observe.)

--
B. L. Massingill
ObDisclaimer: I don't speak for my employers; they return the favor.

[John W. Kennedy]

bl****@myrealbo x.com wrote:

In article <1P************ *@newsfe12.lga> ,
John W. Kennedy <jw*****@attglo bal.netwrote:

>However, some implementations passed /and returned/ elementary arguments
by value, as Ada does.

In FORTRAN/Fortran, don't they call that "copy-in/copy-out"? Same
thing, just nitpicking a little about terminology, I hope correctly.

Back in the day, IBM called it "by copy". I'm not acquainted with modern
versions of the language.
--
John W. Kennedy
"The whole modern world has divided itself into Conservatives and
Progressives. The business of Progressives is to go on making mistakes.
The business of the Conservatives is to prevent the mistakes from being
corrected."
-- G. K. Chesterton

[blmblm]

In article <mz************ *@newsfe12.lga> ,
John W. Kennedy <jw*****@attglo bal.netwrote:

bl****@myrealbo x.com wrote:

In article <1P************ *@newsfe12.lga> ,
John W. Kennedy <jw*****@attglo bal.netwrote:

However, some implementations passed /and returned/ elementary arguments
by value, as Ada does.

In FORTRAN/Fortran, don't they call that "copy-in/copy-out"? Same
thing, just nitpicking a little about terminology, I hope correctly.

Back in the day, IBM called it "by copy". I'm not acquainted with modern
versions of the language.

Huh. I'd have said I was remembering the terminology from back
when I was actively using the language, when it was still FORTRAN
and my then-current place of employment still regarded the F77
standard as a bit too new-fangled to be relied on. But I'm sure
your memory's at least as good as mine, and I can't quite figure
out how to research which term might have been used when ....

--
B. L. Massingill
ObDisclaimer: I don't speak for my employers; they return the favor.

[James Kanze]

On Oct 4, 12:35 am, "John W. Kennedy" <jwke...@attglo bal.netwrote:

Dennis Lee Bieber wrote:

On Mon, 01 Oct 2007 01:53:47 GMT, Roedy Green
<see_webs...@mi ndprod.com.inva liddeclaimed the following in
comp.lang.pytho n:

Seem to me you could in FORTRAN and Pascal, and maybe even Algol. It
has been a while.

Everything in classic FORTRAN is a passed as a reference -- even
constant arguments are passed as a reference to the memory location
containing that constant (which is why it was possible in very early
FORTRANs to have "a = 1 + 1" yield something other than "2" if preceded
by, say, "call mutate(1)" where mutate looks like:

subroutine mutate(arg)
arg = arg * 2
end
)

However, some implementations passed /and returned/ elementary
arguments by value, as Ada does. (The object code was
typically faster that way, and FORTRAN semantics were such
that the difference was almost impossible to observe.)

The Fortran standard is carefully worded to allow either pass by
reference, or copy-in, copy-out. IIRC, IBM's Fortran-H used
copy-in/copy-out, but most others used call by reference.

Straight copy was never allowed by the standard, and I've never
heard of a pre-standard implementation which used it either.

--
James Kanze (GABI Software) email:ja******* **@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[bbound]

On Oct 7, 2:59 pm, Jerry Coffin <jcof...@taeus. comwrote:

4.7.3.2. Name Replacement (call by name)

Any formal parameter not quoted in the value list is replaced,
throughout the procedure body, by the corresponding actual parameter,
after enclosing this latter in parentheses wherever syntactically
possible. Possible conflicts between identifiers inserted through this
process and other identifiers already present within the procedure will
be avoided by suitable systematic changes of the formal or local
identifiers involved.

This sounds rather like macro expansion as found in languages ranging
from TeX to various flavors of shell and make.

The universe is a figment of its own imagination.

I can't recall -- what was the formal name in philosophy for this
thesis?

[Lew]

Jerry Coffin wrote:

>The universe is a figment of its own imagination.

bb****@gmail.co m wrote:

I can't recall -- what was the formal name in philosophy for this
thesis?

Zen.

--
Lew

[nebulous99]

On Oct 8, 4:14 am, James Kanze <james.ka...@gm ail.comwrote:

On Oct 8, 6:58 am, [e-mail] m wrote:

On Oct 7, 2:59 pm, Jerry Coffin <jcof...@taeus. comwrote:

4.7.3.2. Name Replacement (call by name)
Any formal parameter not quoted in the value list is replaced,
throughout the procedure body, by the corresponding actual parameter,
after enclosing this latter in parentheses wherever syntactically
possible. Possible conflicts between identifiers inserted through this
process and other identifiers already present within the procedure will
be avoided by suitable systematic changes of the formal or local
identifiers involved.

This sounds rather like macro expansion as found in languages ranging
from TeX to various flavors of shell and make.

Not really. [snip loads]

You seem to be meaning to disagree with me, but it's unclear exactly
what you are asserting that contradicts anything that I said.

[James Kanze]

nebulou...@gmai l.com wrote:

On Oct 8, 4:14 am, James Kanze <james.ka...@gm ail.comwrote:

On Oct 8, 6:58 am, [e-mail] m wrote:

On Oct 7, 2:59 pm, Jerry Coffin <jcof...@taeus. comwrote:
4.7.3.2. Name Replacement (call by name)
Any formal parameter not quoted in the value list is replaced,
throughout the procedure body, by the corresponding actual parameter,
after enclosing this latter in parentheses wherever syntactically
possible. Possible conflicts between identifiers inserted through this
process and other identifiers already present within the procedure will
be avoided by suitable systematic changes of the formal or local
identifiers involved.
This sounds rather like macro expansion as found in languages ranging
from TeX to various flavors of shell and make.

Not really. [snip loads]

You seem to be meaning to disagree with me,

Yes and no. Algol's name replacement is definitly different
than the usual macro replacement in shells, make and TeX,
since the argument gets expanded each time it is used, and
not once when the function is called. On the other hand,
such languages often do have the capacity to delay
expansion; they also have the capability of treating any
data string as part of the program, so you can pass an
argument as a string, and then execute it multiple times in
a function. In short, you can easily simulate Algol's name
replacement in such languages.

Of course, if you pass a functional object in C++, you can
also get much of the same effect as well.

--
James Kanze (GABI Software) mailto:ja****** ***@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]