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.
