rvalue references

[Namespace]

On Sunday, 28 April 2013 at 00:17:53 UTC, Jonathan M Davis wrote:
> On Saturday, April 27, 2013 13:11:54 Namespace wrote:
>> You often say that 'auto ref' can not work for non-templates.
>
> Please quote at least part of the message that you're replying 
> to. The
> threading of the various clients is often wrong, and I have no 
> way of knowing
> who you're talking to here (and some people don't use threading 
> at all). Based
> on the content, I'm guessing that you're talknig to me, but I 
> really don't
> know.
>
>> Why not really?
>> Because the resulting code bloat is not bearable, or because it
>> is technically not possible?
>
> Because the templated solution involves creating new functions, 
> whereas that's
> not going to work for non-templated functions, particularly 
> when you consider
> .di files and prototypes. It also gets particularly nasty when 
> function
> overriding gets added into the mix. Walter himself has said 
> several times in
> the past that the solution used for auto ref and templates 
> can't work with
> non-templated functions.
>
>> Also I would like to see an answer of my overlooked question
>> (just out of curiosity):
>> http://forum.dlang.org/thread/kl4v8r$tkc$1@digitalmars.com?page=7#post-kyicm
>> dsriwnxqiuzkaho:40forum.dlang.org
>
> So, you're asking why the compiler can't just do a move in the 
> rvalue case and
> pass by ref in the lvalue case for auto ref? The semantics are 
> completely
> different. You need _one_ function, and you can't do that with 
> one function.
> That would be like asking the function to be both
>
> auto foo(int* i) {...}
>
> and
>
> auto foo(int i) {...}
>
> only we're talking about ref rather than pointers (but ref is 
> really a pointer
> underneat the hood). A function can only have one signature 
> unless it's a
> template, and the only way that templates can have more is 
> because they
> generate multiple functions (each with only one signature).
>
> Remember that we're dealing with the C linker here, so we're 
> pretty much
> restricted to what you can ultimately do in C as far as 
> function signatures
> go. We have to do name mangling to do function overloading or 
> add additional
> information to function signatures (such as pure or nothrow), 
> and the only
> information you ultimately have is the function signature, so 
> anything
> requiring messing with how the function works either must be 
> done inside the
> function (where it knows nothing about the caller), or you need 
> multiple
> functions, which generally means templates. To get around all 
> of that, we'd
> need to create our own linker which didn't work like C's linker 
> does, which
> would create its own set of problems.
>
> - Jonathan M Davis

Sorry but you're right I meant you. Thanks for explanation.