auto f0 = [](int x) { return [=](int y) { return x + y; }; };

error C3499: a lambda that has been specified to have a void return type cannot return a value

auto f1 = [](int x) -> std::function<int(int)> { return [=](int y) { return x + y; }; };

__>А так работает, но приходится обворачивать лямбду в std::function.

__>auto f1 = [](int x) -> std::function<int(int)> { return [=](int y) { return x + y; }; };
__>

auto f1 = [](int x) -> decltype([=](int y) {}) { return [=](int y) { return x + y; }; };

__>>А так работает, но приходится обворачивать лямбду в std::function.

__>>auto f1 = [](int x) -> std::function<int(int)> { return [=](int y) { return x + y; }; };
__>>

R>auto f1 = [](int x) -> decltype([=](int y) {}) { return [=](int y) { return x + y; }; };

R>

R>

auto f = [](int) { return 1;};
typedef decltype(f) a; // OK

typedef decltype([](int) { return 1; }) aa;

error C3477: a lambda cannot appear in an unevaluated context

__>Что говорит стандарт (который еще не вышел) насчет этого :

auto f0 = [](int x) { return [=](int y) { return x + y; }; };

5.1.2/4:
If a lambda-expression does not include a trailing-return-type, it is as if the trailing-return-type denotes the following type:

— if the compound-statement if of the form
    { return attribute-specifier opt expression ; }
the type of the returned expression after lvalue-to-rvalue conversion (4.1), array-to-pointer conversion
(4.2), and function-to-pointer conversion (4.3);

— otherwise, void.

auto f1 = [](int x) -> decltype([=](int y) {}) { return [=](int y) { return x + y; }; };

5.1.2/2:
A lambda-expression shall not appear in an unevaluated operand (Clause 5).

5.1.2/3:
The type of the lambda-expression (which is also the type of the closure object) is a unique, unnamed nonunion class type — called the closure type — whose properties are described below.

#include <iostream>
#include <typeinfo>

int main()
{
    auto f1 = [](int) { return 1;};
    auto f2 = [](int) { return 1;};
    std::cout << int(typeid(f1) == typeid(f2)) << std::endl;
    // должен быть выведен 0
}

#include <iostream>

int main()
{
    auto f0 = [](int x) { return ([=](int y) { return x + y; }); };
    std::cout << f0(11)(22) << std::endl;
}

#include <functional>
#include <iostream>

int main()
{
    // No decltype(lambda)
    // Make a dummy lambda + decltype
    auto q = [](int x) { return x; };
    typedef decltype(q) int_to_int;

    // f1: int -> int    
    auto f1 = [](int x) -> int_to_int
    {
        // f2: int * int -> int
        auto f2 = ([=](int y) { return x + y; });
        // Cast!
        return reinterpret_cast<int_to_int&>(f2);
    };

    // Check :)
    std::cout << f1(1)(2);

    return 0;
}

int main()
{
  auto x = []() { return 1; };

  std::function<int(void)> xx(x);
}

int f() { return 1; }

int main()
{
  int (*x)() = &f;

  boost::function<int(void)> xx(x);
}

5.1.2.6

The closure type for a lambda-expression with no lambda-capture has a public non-virtual non-explicit const
conversion function to pointer to function having the same parameter and return types as the closure type’s
function call operator. The value returned by this conversion function shall be the address of a function
that, when invoked, has the same effect as invoking the closure type’s function call operator.