ADL

[Walter Bright via Digitalmars-d]

On 9/3/2016 8:51 AM, Manu via Digitalmars-d wrote:
> This is exactly the difference between std.algorithm, and what I was
> trying to express as an algorithm that 'does work'. It's not the
> business of the API for the user to supply the work to do (ie, via
> lambda); the function is meant to do the work, which means it needs to
> call other functions. There are no lambdas to be seen in this
> situation.

This is purely a stylistic issue. I, on the other hand, think lambdas are a 
superior design, as ADL lookups never sat well with me because it can be quite 
difficult for the user to figure out where 'func' is coming from.


>> (Besides, I showed how other scopes can be imported based on a type, and
>> then things can be looked up in those scopes, and UFCS applied.)
> I still think that's unnecessarily complicated, and multiple arguments
> leads to static if-ing and __traits(compiles,...). The fact the user
> needs to intervene at all is already too much.

I already showed how your previous objection to this could be folded away inside 
a nice template.


> Apparently I need to stress again, this is a *core value proposition
> of D*... It's presented as "this is modern D code", and yet it's
> awkward and requires careful handling or you get hard to understand
> name-resolution issues.

As mentioned, I don't see anything hard to understand about it - it makes it 
clear to the reader where names are coming from. ADL pulls names in from who 
knows where.


> UFCS *is* modern D. Algorithms and ranges *is* modern D.
> Seriously, this is the style that modern D aspires to, and it doesn't
> 'just work'. There should be ear-piercing alarms and flashing red
> everywhere.
> This comes up for me frequently, yet ADL has never caused me a single
> moments trouble, in 15+ years. I didn't even know ADL existed until I
> started running into this problem in D and then wondered to myself why
> I never encountered the same issue in C++. It worked so seamlessly and
> intuitively, I didn't even know it was there.
>
> I don't care if the solution is ADL like C++, or something else that
> works, just that this problem is real; it's a massive fly in the
> ointment of modern D style, and I don't think it's acceptable. It
> needs a seamless solution, not manual intervention at every case. D
> depends on this so much more than C++ does.

You've used ADL for 15 years. You're obviously very comfortable with it. I 
suggest trying out using lambdas enough to feel comfortable with it before 
deciding that ADL is better. New coding styles are rarely comfortable right off 
the bat.