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

[Jonathan M Davis]

On Friday, March 23, 2018 23:35:29 MattCoder via Digitalmars-d wrote:
> Well, to be honest I still can't understand why would you want to
> pass a RValue as reference.

Well, it's frequently the case that you don't want to copy an object if you
don't have to - especially in the gaming world, where every ounce of
performance matters. If a function accepts an argument by ref, then no copy
is made, but then you have to pass an lvalue, making it really annoying to
call the function when what you have is an rvalue. On the other hand, if the
function doesn't accept its argument by ref, then you can pass an rvalue
(and it will be moved, making that efficient), but then lvalues get copied
when that's often not what you want. C++'s solution to this was rvalue
references. That way, as long as the parameter is const, it can accept both
rvalues and lvalues, and it won't copy unless it has to. The closest
analogue that D has to this is auto ref, which requires templates, which may
or may not be acceptable. In many cases, it works great, whereas in others,
it doesn't work at all (e.g. virtual functions), and it can result in
template bloat.

The whole situation is complicated by the fact that sometimes it's actually
faster to pass by value and copy the argument, even if it's an lvalue.
Passing by const& can often result in unnecessary copies if anywhere in the
chain passes the object by value, whereas if it's passed by value, the same
object can often be moved multiple times, avoiding any copies. It's my
understanding that prior to C++11, it was considered best practice to pass
by const& as much as possible to avoid copies but that after C++11 (which
added move constructors), it's often considered better to pass by value,
because then in many cases, the compiler can move the object instead of
copying it. So, C++ gives you control over which you do, and it's not
necessarily straightforward as to which you should use (though plenty of
older C++ programmers likely just use const& all over the place out of
habit).

D supports moving out of the box without move constructors, so it does a
good job of handling the cases where a move is most appropriate, but it
doesn't have rvalue references, so it doesn't have the same flexibility as
C++ when you want to pass something by reference. So, anyone looking to pass
stuff by reference all over the place (like Manu and his coworkers) is going
to find the lack of rvalue references in D to be really annoying.

- Jonathan M Davis