rvalues -> ref (yup... again!)

[Atila Neves]

On Monday, 26 March 2018 at 19:24:13 UTC, Manu wrote:
> On 26 March 2018 at 07:40, Atila Neves via Digitalmars-d 
> <digitalmars-d at puremagic.com> wrote:
>> On Friday, 23 March 2018 at 22:01:44 UTC, Manu wrote:
>>>
>>> Forked from the x^^y thread...
>>> <snip>
>>
>>
>> C++ T&& (forwarding reference) -> D auto ref T
>> C++ T&& (Rvalue reference) -> D T
>> C++ const T& -> D T
>
> Yeah, no... T may be big. Copying a large thing sucks. Memory 
> copying
> is the slowest thing computers can do.

That's _if_ T is big and _if_ it even gets copied, the 
combination of which I think happens very rarely. When that 
happens I think that the temporary isn't a big deal. This code:

struct Foo { int[1024] data; }
int byValue(Foo f) { return f.data[42]; }

Generates this assembly (ldc2 -O3, clang does the same for C++):

0000000000000000 <_D3foo7byValueFSQo3FooZi>:
    0:   8b 84 24 b0 00 00 00    mov    eax,DWORD PTR [rsp+0xb0]
    7:   c3                      ret

And I wrote a type for which a move and a copy are the same on 
purpose: in "real life" it's more likely that the memory will be 
dynamically allocated, probably held in a slice, and moved 
instead.

Are there cases in which there will be an expensive copy? Yes, 
then pass by ref/pointer. But measure first, and prefer to pass 
by value by default.

It's different in C++ - stick a std::vector or std::string in 
your struct and passing by value (usually) copies the dynamically 
allocated memory. In D it moves.

> As an API author, exactly as in C++, you will make a judgement 
> on a
> case-by-case basis on this matter. It may be by-value, it may 
> be by
> const-ref. It depends on a bunch of things, and they are points 
> for
> consideration by the API author, not the user.

You can still do that in D. There well may be a reason to pass by 
const ref. I'm just saying that there aren't that many, and in 
that in those rare cases a temporary is fine. Especially if the 
alternative are rvalue references.

Atila