On Thursday, 9 May 2013 at 21:55:51 UTC, Manu wrote:
Umm, what if the non-template counterpart returns ref? Then it
doesn't
behave the same.
Yes, the non-template version cannot ref return an auto ref
param, but I would expect that neither can the template version
unless auto ref is specified as the return value. The key
difference that I think can be understood is that auto ref on the
return value for a template is not the same thing as auto ref on
the param.
For templates, you can enforce exactly the same behavior as the
non-template version by specifying a return of either ref or not,
ie you do not specify auto ref or you specify a return by value.
If you so happen to specify a ref return of an auto ref param, I
would expect the compiler to refuse to compile no matter if it is
a template function or not. Of course you can confuse the
programmer and allow such a thing to compile only for the cases
where it can return ref on the auto ref, but IMO that'll be a big
mistake as it will confuse the s*** out of most people, and
besides allowing something like that has no value at all.
D is a complex language, so stuff like this does take some
getting used to,
but it is very powerful and flexible, no two ways around it.
If this takes 'getting used to', you're basically admitting
that it doesn't
make intuitive sense.
Well, I suppose I cannot disagree with you on that point, so yes
it is confusing, but for sake of a solution, it is not nearly as
confusing so long as auto ref on the parameters will behave the
same for both template and non-template versions in a consistent
way. I know auto ref on the return is potentially confusing, but
it does increase template flexibility as the benefit.
Alternatively, I think Jonathan's argument against scope ref
makes perfect sense. Unless I misread something or he's dead
wrong, how can scope be used without creating even more
confusion? Even if scope has some properties in common with auto
ref, it specifies something entirely different than accepting
rvalues and lvalues. This point reminds me of why we should not
be using bool as an integral type, it's the same reasoning.
--rt
