Mdtryhht

Take following code as an example

#include <algorithm>

namespace baz 
 template<class T>
 void sort(T&&)


namespace boot 
 const auto sort = [](auto &&);


void foo ()
 using namespace std;
 using namespace baz;
 sort(1);


void bar()
 using namespace std;
 using namespace boot;
 sort(1);

I expected that since foo compiled, then bar shall compile as well. To my surprise, the foo compiles correctly and bar has problem with ambiguous call to sort function. Am I doing something illegal here or this is proper way compiler should behave? If so, why is it so different. I though generic lambda can be treated as syntactic sugar for generic function.

live example

The problem here is not that the call to sort is ambiguous, but that the name sort is ambiguous. Name lookup happens before overload resolution.

I believe the relevant section is [basic.lookup]/1, specifically

[…] The declarations found by name lookup shall either all denote the same entity or shall all denote functions or function templates; in the latter case, the declarations are said to form a set of overloaded functions ([over.load]). […]

In your case, the name sort denotes both, the object boot::sort as well as the set of overloaded functions std::sort. Therefore, name lookup fails.

Your code is really no different from if you had written, for example

namespace baz 
 int a;


namespace boot 
 int a;


void foo() 
 using namespace baz;
 using namespace boot;
 a = 42; // error: reference to 'a' is ambiguous

Try it out here; compare this to a case that actually has an ambiguous function call; note how the error message is the same as in your case, specifically referring to the name itself being ambiguous rather than the function call.

I used the function typeid to watch how compiler identify lambda, function, function pointer, std::function, and each in them is different from any other.

I have not clarified why compiler work in this way, but obviously, behavior compiled between lambda and function are different.lambda must check it has the authority to use or change which value declared in this namespace when compiling, so the range compiled is limited, situation that can use all just like a function is precious few. At least there is essential distinction between them.

Consider about when lambda is used anonymously, compiler may not have to remember the initial address of lambda, compare lambda is impossible.I thought that's one of reasons.

And there should be more practical reasons for compiler has no support for distinguish named lambda from function by parameter list or return type, if it appeared in future, it won't be named overload probably.