Name: rmT116609			Date: 07/21/2004


A DESCRIPTION OF THE REQUEST :
Java would greatly benefit from the introduction of pass-by-reference for primitive types.  It might also be useful in the case of mutable classes.

This would fix the problem of what to do when you have a method that must return, for example, two ints.  Currently, your solutions are to make a custom return value object for that one method (ugly) or to return one int and pass the other value in wrapped in an int array (also ugly).

The prototype using refs would look like so:
    void myfunc(ref val1, ref val2);

And calling this method would look like so:
    int a,b;
    myfunc(ref a, ref b);

One could implement a MutableInteger class to fix the above problem, but using a 'ref' keyword as per C#, would have some additional benefits - for a start, we could write a proper scanf function that would look like this:

myStaticClass.scanf("%d %f2.4", ref myInt, ref myFloat);

The C# ref keyword avoids the usual problem with pass-by-reference - namely that you cannot tell by looking at a method call whether the values passed in can be modified.  The requirement to have the 'ref' keyword in the method call ensures that the reader knows that the value is liable to be changed.


JUSTIFICATION :
It removes the neccessity to implement one of two anti-patterns (implementing a class to handle the return type for an  arbitrary method, or boxing an int in an int array to make a mutable return type)

It adds the possiblity to add extremely useful functions like C's scanf (but with safety!) into Java.  The power of this feature would be an immense addition to the language.

Using the C# ref keyword avoids the problem of Pascal and C++'s reference passing - i.e.: that you cannot tell when reading code whether any given value passed to a method will or will not be altered (because the ref keyword is required)

EXPECTED VERSUS ACTUAL BEHAVIOR :
EXPECTED -
Use the C#  ref  keyword.  Protoype example:

    void myfunc(ref val1, ref val2);

Calling example:
    int a,b;
    myfunc(ref a, ref b);

Notes:

  To avoid aliasing issues, references should be non assignable.  One reference cannot be assigned to another reference object, the equivallent of saying (in C or C++):

int *a, *b;
a = b;

The only allowable usage of a reference parameter should be to assign a value to it of the type of the referenced object or primitve. (if we take a reference to an int, only ints can be assigned to the reference).

This would be useful also for mutable classes, such as String.


ACTUAL -
Currently you cannot elegantly handle returning >1 primitive from a method, nor implement a scanf-like function
(Incident Review ID: 281731) 
======================================================================