New reference type designed to handle templates better

[Jonathan Marler via Digitalmars-d]

I've been thinking about how to handle templates that have 
typically been using the 'ref' parameter attribute because they 
modify the parameter.  For example, the put/doPut functions in 
std.range use the 'ref' attribute for the output range, but in 
many cases the parameter doesn't need to be a reference type and 
the overhead that comes with it.

One idea I had is to have a different type of function argument 
attribute as opposed to "ref".

A "ref" parameter is passed by reference.  Under the hood, a 
reference parameter is equivalent to a pointer to the variable.  
Then the function is free to modify the caller's "version" of the 
variable.  This new type of function parameter, let's call it 
"pref", would instead care about what the variable is "pointing 
to" instead of the variable itself.  In some cases this means 
modifying the caller's version of the variable and in some cases 
it does not.  For example, if a basic value type like int was 
passed in, the variable isn't pointing to anything so a pointer 
to the variable itself would be passed in, but if an int* was 
passed in, then the int* would be passed by value.  I've included 
a table of common types and how "pref" would differ from "ref".

pref: modifying the data the variable is pointing to.  This means 
that if the variable is itself a pointer, then the function won't 
modify the pointer but instead modify what it's pointing to.

BasicDataType (BDT) is bool, all integer types, all float types, 
and all char types

Type     |  ref    |  pref            |  why
--------------------------------------------
BDT      | BDT*      | BDT*      | A BDT is not a pointer, so 
pref must
                                  | modify the variable itself 
which you can
                                  | say is pointing to a location 
in memory
BDT*     | BDT**     | BDT*      | A BDT* is already a pointer, 
pref will
                                  | modify the memory BDT is 
pointing to
BDT[]    | BDT[]*    | BDT[]* or BDT[] | An argument can be made 
for both,
                                  | if the function is modifying 
the contents
                                  | of the array (maybe writing 
data to it),
                                  | then the function might need 
some way of
                                  | returning how much data was 
written so
                                  | it might want to modify the 
given array
                                  | to indicate it has changed.
struct   | struct*   | struct*   | A struct variable is not a 
pointer, so
                                  | pref is a reference type for 
the struct
struct*  | struct**  | struct*   | A struct pointer is already a 
pointer
class    | class*    | class     | A class is already a pointer
function | function* | function  | A function is a pointer to 
code, a
                                  | function is usually used to 
modify data so pref treats the function as what is modifying the 
data.
delegate | delegate* | delegate  | Same as reason for function

Note: A pref modifer to a type that is a pointer to any of these 
types will not do anything to the type