ref arguments

[Jeremie Pelletier]

Saaa wrote:
> Thanks Jeremie Pelletier!
> 
> Good to see I'm not going crazy (<none> /  in)  :)
> just a few small questions:
> 
> What exactly is a storage class?
> Is it this:
> C has a concept of 'Storage classes' which are used to define the scope 
> (visability) and life time of variables and/or functions.

That would be it. The storage class is mostly useful to the compiler to 
determine the semantics of the variable, which will determine where it 
is allocated, its lifetime and its mutability.

> Dynamic arrays are always on the heap, right?

That is correct.

> I never use "new (array)"  nor change references in other ways except 
> changing
> the length.
> I suspect, the old array gets garbage collected if no other references point 
> to it :)
> I also suspect "new (array)"  to never allocate in place even if the length
> is equal or smaller and no other pointers point to the old array, because 
> the
> gc needs to run first to check for this.

I myself use a mix of both new and .length:

new is faster to allocate brand new arrays since there are less internal 
function calls. new, just like malloc in C and as the name implies, 
always allocates new memory.

.length is faster to resize arrays since there are good chances the 
resize can be done in place, for example if it fits in the same memory 
block or if there are enough free contiguous pages following the 
allocation, just like C's realloc.

I also change references all the time, depending on the context. For 
example, when working with file paths, you can send a path to a method 
accepting an immutable(char)[] (or its alias, string) which saves the 
reference somewhere without making a copy, then modify your local 
reference and call another function with the new array. The original 
array won't be garbage collected because it is still referenced, and the 
parameter of type immutable(char)[] instead of const(char)[] specifies 
the data will not change at all; const(char)[] means the callee's scope 
should not modify the data, but other references may be mutable.

It can be a bit confusing at first, especially since immutable and const 
have very similar semantics. But you'll get the hang of it after playing 
with them for some time :)

> In stead of a table I made a nice diagram:
> http://bayimg.com/kAEkNAaCA
> Is it correct? 

That looks good! I would use the terms caller and callee instead of call 
and func however, it would be clearer that way. You might want to add 
headers to the different colums (storage class, scope, reference and 
data respectively), it took me a few seconds to figure the meaning of 
the columns there :) Other than that I believe it reflects the semantics 
used in D1.

Jeremie