Generic lambda vs generic function give different behaviour












8















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






c++ lambda c++14







share|improve this question




















  • 4





    Lambdas do not participate in ADL

    – Guillaume Racicot
    2 hours ago






  • 5





    This isn't ADL. An int argument doesn't come from any namespace.

    – chris
    2 hours ago






  • 2





    Should this really be ambiguous, though? std::sort() doesn't take 1 parameter as input, it takes at least 2, so why is the compiler even considering it as a candidate for a call that passes only 1 parameter value?

    – Remy Lebeau
    1 hour ago













  • There must be something about the extra layer of indirection that the lambda introduces. With the first example, the call is made to ::baz::sort, but in the second example, it would have to find ::boot::mystery_lambda_type::operator(). That extra step might be what causes std::sort to be considered first. I don't have the standard in front of me so can't be sure about this.

    – alter igel
    1 hour ago
















8















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






c++ lambda c++14







share|improve this question




















  • 4





    Lambdas do not participate in ADL

    – Guillaume Racicot
    2 hours ago






  • 5





    This isn't ADL. An int argument doesn't come from any namespace.

    – chris
    2 hours ago






  • 2





    Should this really be ambiguous, though? std::sort() doesn't take 1 parameter as input, it takes at least 2, so why is the compiler even considering it as a candidate for a call that passes only 1 parameter value?

    – Remy Lebeau
    1 hour ago













  • There must be something about the extra layer of indirection that the lambda introduces. With the first example, the call is made to ::baz::sort, but in the second example, it would have to find ::boot::mystery_lambda_type::operator(). That extra step might be what causes std::sort to be considered first. I don't have the standard in front of me so can't be sure about this.

    – alter igel
    1 hour ago














8












8








8


1






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






c++ lambda c++14







share|improve this question
















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






c++ lambda c++14




c++ lambda c++14






share|improve this question















share|improve this question













share|improve this question




share|improve this question








edited 2 hours ago







bartop

















asked 2 hours ago









bartopbartop

3,2281030




3,2281030








  • 4





    Lambdas do not participate in ADL

    – Guillaume Racicot
    2 hours ago






  • 5





    This isn't ADL. An int argument doesn't come from any namespace.

    – chris
    2 hours ago






  • 2





    Should this really be ambiguous, though? std::sort() doesn't take 1 parameter as input, it takes at least 2, so why is the compiler even considering it as a candidate for a call that passes only 1 parameter value?

    – Remy Lebeau
    1 hour ago













  • There must be something about the extra layer of indirection that the lambda introduces. With the first example, the call is made to ::baz::sort, but in the second example, it would have to find ::boot::mystery_lambda_type::operator(). That extra step might be what causes std::sort to be considered first. I don't have the standard in front of me so can't be sure about this.

    – alter igel
    1 hour ago














  • 4





    Lambdas do not participate in ADL

    – Guillaume Racicot
    2 hours ago






  • 5





    This isn't ADL. An int argument doesn't come from any namespace.

    – chris
    2 hours ago






  • 2





    Should this really be ambiguous, though? std::sort() doesn't take 1 parameter as input, it takes at least 2, so why is the compiler even considering it as a candidate for a call that passes only 1 parameter value?

    – Remy Lebeau
    1 hour ago













  • There must be something about the extra layer of indirection that the lambda introduces. With the first example, the call is made to ::baz::sort, but in the second example, it would have to find ::boot::mystery_lambda_type::operator(). That extra step might be what causes std::sort to be considered first. I don't have the standard in front of me so can't be sure about this.

    – alter igel
    1 hour ago








4




4





Lambdas do not participate in ADL

– Guillaume Racicot
2 hours ago





Lambdas do not participate in ADL

– Guillaume Racicot
2 hours ago




5




5





This isn't ADL. An int argument doesn't come from any namespace.

– chris
2 hours ago





This isn't ADL. An int argument doesn't come from any namespace.

– chris
2 hours ago




2




2





Should this really be ambiguous, though? std::sort() doesn't take 1 parameter as input, it takes at least 2, so why is the compiler even considering it as a candidate for a call that passes only 1 parameter value?

– Remy Lebeau
1 hour ago







Should this really be ambiguous, though? std::sort() doesn't take 1 parameter as input, it takes at least 2, so why is the compiler even considering it as a candidate for a call that passes only 1 parameter value?

– Remy Lebeau
1 hour ago















There must be something about the extra layer of indirection that the lambda introduces. With the first example, the call is made to ::baz::sort, but in the second example, it would have to find ::boot::mystery_lambda_type::operator(). That extra step might be what causes std::sort to be considered first. I don't have the standard in front of me so can't be sure about this.

– alter igel
1 hour ago





There must be something about the extra layer of indirection that the lambda introduces. With the first example, the call is made to ::baz::sort, but in the second example, it would have to find ::boot::mystery_lambda_type::operator(). That extra step might be what causes std::sort to be considered first. I don't have the standard in front of me so can't be sure about this.

– alter igel
1 hour ago












1 Answer
1






active

oldest

votes


















2














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 not 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.






share|improve this answer


























  • I think this is actually the right answer. And I would like to add that if both the template function sort and the lambda sort were declared in the same namespace, it would be an error. You cannot have a function and non-function with the same name in the same namespace. So there could never be an overload set that has both true functions and function-like objects.

    – Mike
    2 mins ago











Your Answer






StackExchange.ifUsing("editor", function () {
StackExchange.using("externalEditor", function () {
StackExchange.using("snippets", function () {
StackExchange.snippets.init();
});
});
}, "code-snippets");

StackExchange.ready(function() {
var channelOptions = {
tags: "".split(" "),
id: "1"
};
initTagRenderer("".split(" "), "".split(" "), channelOptions);

StackExchange.using("externalEditor", function() {
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled) {
StackExchange.using("snippets", function() {
createEditor();
});
}
else {
createEditor();
}
});

function createEditor() {
StackExchange.prepareEditor({
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: true,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: 10,
bindNavPrevention: true,
postfix: "",
imageUploader: {
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
},
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
});


}
});














draft saved

draft discarded


















StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55367269%2fgeneric-lambda-vs-generic-function-give-different-behaviour%23new-answer', 'question_page');
}
);

Post as a guest















Required, but never shown

























1 Answer
1






active

oldest

votes








1 Answer
1






active

oldest

votes









active

oldest

votes






active

oldest

votes









2














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 not 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.






share|improve this answer


























  • I think this is actually the right answer. And I would like to add that if both the template function sort and the lambda sort were declared in the same namespace, it would be an error. You cannot have a function and non-function with the same name in the same namespace. So there could never be an overload set that has both true functions and function-like objects.

    – Mike
    2 mins ago
















2














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 not 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.






share|improve this answer


























  • I think this is actually the right answer. And I would like to add that if both the template function sort and the lambda sort were declared in the same namespace, it would be an error. You cannot have a function and non-function with the same name in the same namespace. So there could never be an overload set that has both true functions and function-like objects.

    – Mike
    2 mins ago














2












2








2







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 not 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.






share|improve this answer















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 not 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.







share|improve this answer














share|improve this answer



share|improve this answer








edited 1 min ago

























answered 16 mins ago









Michael KenzelMichael Kenzel

5,04811020




5,04811020













  • I think this is actually the right answer. And I would like to add that if both the template function sort and the lambda sort were declared in the same namespace, it would be an error. You cannot have a function and non-function with the same name in the same namespace. So there could never be an overload set that has both true functions and function-like objects.

    – Mike
    2 mins ago



















  • I think this is actually the right answer. And I would like to add that if both the template function sort and the lambda sort were declared in the same namespace, it would be an error. You cannot have a function and non-function with the same name in the same namespace. So there could never be an overload set that has both true functions and function-like objects.

    – Mike
    2 mins ago

















I think this is actually the right answer. And I would like to add that if both the template function sort and the lambda sort were declared in the same namespace, it would be an error. You cannot have a function and non-function with the same name in the same namespace. So there could never be an overload set that has both true functions and function-like objects.

– Mike
2 mins ago





I think this is actually the right answer. And I would like to add that if both the template function sort and the lambda sort were declared in the same namespace, it would be an error. You cannot have a function and non-function with the same name in the same namespace. So there could never be an overload set that has both true functions and function-like objects.

– Mike
2 mins ago




















draft saved

draft discarded




















































Thanks for contributing an answer to Stack Overflow!


  • Please be sure to answer the question. Provide details and share your research!

But avoid …



  • Asking for help, clarification, or responding to other answers.

  • Making statements based on opinion; back them up with references or personal experience.


To learn more, see our tips on writing great answers.




draft saved


draft discarded














StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f55367269%2fgeneric-lambda-vs-generic-function-give-different-behaviour%23new-answer', 'question_page');
}
);

Post as a guest















Required, but never shown





















































Required, but never shown














Required, but never shown












Required, but never shown







Required, but never shown

































Required, but never shown














Required, but never shown












Required, but never shown







Required, but never shown







-

Popular posts from this blog

Cosme II de Mèdici

Image
Cosme II de Mèdici Cosme II de Medici Nom original (it) Cosimo II de' Medici Biografia Naixement 12 de maig de 1590 Florència Mort 28 de febrer de 1621 ( 1621-02-28 ) (als 30 anys) Florència Causa de mort Tuberculosi Lloc d'enterrament Capella funerària dels Mèdici, Florència    Gran Duc de Toscana 1609 – 1621 ← Ferran I de Mèdici Ferran II de Mèdici → Religió Església Catòlica i catolicisme Activitat Ocupació Polític Altres Títol Duc Dinastia Mèdici Cònjuge Maria Magdalena d'Àustria Fills Maria Cristina, Ferran, Joan Carles, Margarida, Mateu, Francesc, Anna, Leopold Pares Ferran I de Mèdici Cristina de Lorena Germans Caterina de Mèdici, Maria Maddalena de' Medici , Clàudia de Mèdici, Carles de Mèdici, Llorenç de Mèdici (1599-1648), Elionor de Mèdici (1591-1617) i Francesc de Ferran I de Mèdici Cosme II de Mèdici o Cosme II de Toscana (Florència, Gran...
Read more

Hivernacle

Image
Hivernacle Hivernacle a les cases del Salt a Alcoi Un hivernacle és una construcció més o menys permanent que permet modificar el microclima del seu interior i permetre el conreu de vegetals en millors condicions o fora d'època. [1] Són el nivell superior de l'anomenat conreu protegit que va des d'un mínim que correspon a l'ús de plàstics que cobreixen el terra (mulching) fins al màxim que serien els hivernacles de vidre i amb un sistema complet de calefacció. Etimològicament la paraula hivernacle es refereix al lloc on passen l'hivern les plantes. En la pràctica actual s'hi mantenen tota la temporada de conreu o més. Contingut 1 Funcionament 2 Evolució en l'ús dels hivernacles 3 Característiques constructives dels hivernacles 4 Hivernacles als Països Baixos 5 Referències Funcionament Els que no tenen calefacció aprofiten precisament l'efecte hivernacle que produeix un escalfame...
Read more

Eisenach

Image
Eisenach Localització 50° 58′ 29″ N, 10° 19′ 28″ E  /  50.974722222222°N , 10.324444444444°E  / 50.974722222222; 10.324444444444 Estat Alemanya Estat federat Turíngia Capital de Ducat de Saxònia-Eisenach Q1787273 Conté la localitat Berteroda Hötzelsroda Madelungen Neuenhof Hörschel Neukirchen Stedtfeld Stockhausen Stregda Wartha (Eisenach) Göringen Població Total 42.417 (2015) • Densitat 407,19 hab/km² Geografia Part de Q2098401 Superfície 104,17 km² Banyat per Hörsel i Werra Altitud 215 m Limita amb Wartburgkreis Werra-Meißner-Kreis Ilmenau Meiningen Organització política • Cap de govern Katja Wolf  (2012) Membre de Q27862084 Aliança per el medi ambient (1995) Identificador descriptiu Codi postal 99817 Zona horària UTC+01:00 UTC+02:00 Prefix telefònic 03691, 036920 i 036928 Codi NUTS DEG0N Clau d...
Read more