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