ref is unsafe

[Tommi]

On Thursday, 10 January 2013 at 16:42:09 UTC, Tommi wrote:
> ...which won't compile because T(4) is an rvalue, and according 
> to D, rvalues can't be passed as ref (nor const ref). I don't 
> know which one is flawed, my analogy, or the logic of how D is 
> designed.

My analogy is a bit broken in the sense that methods actually see 
their designated object as a reference to lvalue even if it is an 
rvalue. But I don't think that affects the logic of my main 
argument about scope arguments.

A more strict language logic would be inconvenient.

But, this logic does introduce a discrepancy between non-member 
operators and member operators in C++ (which D actually 
side-steps by disallowing non-member operators... and then 
re-introduces by providing UFCS):

// C++:

struct T
{
     int val = 10;

     T& operator--()
     {
         --val;
         return *this;
     }
};

T& operator++(T& t)
{
     ++t.val;
     return t;
}

int main()
{
     _cprintf("%d\n", (--T()).val); // Prints: 9
     _cprintf("%d\n", (++T()).val); // Error: no known conversion
                                    // from 'T' to 'T&'
     return 0;
}

// D:

import std.stdio;

struct T
{
     int val;

     int get()
     {
         ++val;
         return val;
     }
}

int het(ref T t)
{
     ++t.val;
     return t.val;
}

void main()
{
     writeln(T().get());
     writeln(T().het()); // Error: T(0) is not an lvalue
}