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

[Rubn]

On Thursday, 29 March 2018 at 20:22:47 UTC, Dgame wrote:
> On Thursday, 29 March 2018 at 20:05:48 UTC, Rubn wrote:
>> On Thursday, 29 March 2018 at 19:11:30 UTC, Dgame wrote:
>>> Just to be sure it does not got los: You know that you can 
>>> avoid the temp/copy if you add one method to your struct, yes?
>>>
>>> ----
>>> import std.stdio;
>>>
>>> struct Big {
>>>     string name;
>>>     float[1000] values;
>>>
>>>     this(string name) {
>>>         this.name = name;
>>>     }
>>>
>>>     @disable
>>>     this(this);
>>>
>>>     ref auto byRef() inout {
>>>         return this;
>>>     }
>>> }
>>>
>>> void foo(ref const Big b) {
>>>     writeln(b.name);
>>> }
>>>
>>> void main() {
>>>     Big b = Big("#1");
>>>     foo(b);
>>>     foo(Big("#2").byRef);
>>> }
>>> ----
>>>
>>> That works like a charm and avoids any need for rvalue 
>>> references. Just add it as mixin template in Phobos or 
>>> something like that.
>>
>> Doesn't work with built-in types like float.
>
> Why would you want to use a float as a rvalue reference?

In templates to avoid template bloat with auto ref.

>> Just adds bloat for operators like opBinary if you want that 
>> to be ref.
>>
>> foo((a.byRef + b.byRef * c.byRef).byRef)
>>
>> // vs
>>
>> foo(a + b * c);
>>
>> It's kind of funny all this talk about allowing temporaries to 
>> bind to refs being messy, yet you can already bind a temporary 
>> to a ref in a messy way using that.
>
> Yeah, it is a bit messy. It is not perfect, but is does avoid 
> any temp var!
> Let's look at a Vector2f example with the following opBinary:
>
> ----
> auto opBinary(string op)(ref const Vector2f v) {
>     return Vector2f(mixin("this.x" ~ op ~ "v.x"), 
> mixin("this.y" ~ op ~ "v.y"));
> }
>
> void foo(ref const Vector2f v) {
>     writeln(v.x, ':', v.y);
> }
>
> foo((Vector2f(2, 4).byRef + Vector2f(4, 6).byRef).byRef);
> ----
>
> Since opBinary needs to be a template, you can combine my 
> solution with auto ref:
>
> ----
> auto opBinary(string op)(auto ref const Vector2f v) {
>     return Vector2f(mixin("this.x" ~ op ~ "v.x"), 
> mixin("this.y" ~ op ~ "v.y"));
> }
>
> void foo(ref const Vector2f v) {
>     writeln(v.x, ':', v.y);
> }
>
> foo((Vector2f(2, 4) + Vector2f(4, 6)).byRef);
> ----
>
> That is cleaner. :)

Just adding more template bloat and it is still messy, it's not 
like we are trying to find a work around to a problem. A solution 
already exists, the cleaner syntax you'd get with rvalue 
references (along with better compatibility with C++ and other 
benefits) can't be beat.