#include <functional>

int fn( std::function<int()> f) { return f(); }

int main(int argc,char** argv) {
    //return fn( argc ?  [=]{return argc;} : [=]{return argc;} ); // облом
    return fn( argc ?  std::function<int()>([=]{return argc;}) : std::function<int()>([=]{return argc;}) );
}

U>по-моему, по сравнению с теми же bind + placeholders, лямбды в язык вписались довольно гармонично (хотя, синтаксис чудноват, имхо) и любителям перформанса не очень больно

Michael L. Scott, Programming Language Pragmatics, 3-rd ed., ELSEVIER 2011
ISBN 13: 978-0-12-374514-9

Page:154

3.6.2 First-Class Values and Unlimited Extent

In general, a value in a programming language is said to have
first-class status if it can be passed as a parameter, returned from a subroutine, or assigned into a variable.
Simple types such as integers and characters are first-class values in most programming languages.
By contrast, a
“second-class” value can be passed as a parameter, but not returned from a subroutine or assigned into a variable,
and a
“third-class” value cannot even be passed as a parameter.

struct A {
  lambda prev;
  virtual lambda fn( lambda a ) {
    if (a==prev) return []{ one };
    prev=a;
    return []{ two };
  }
};

struct A {
  int prev;
  virtual int fn(int a) {
    if (a==prev) return 1;
    prev=a;
    return 2;
  }
};

 char r = flag ? (double) char(65) : (double) char(48);

first-class status if it can be passed as a parameter,

#include <iostream>
#include <memory>
using namespace std;

void f(auto) {}

int main()
{
    f([]{});
}

returned from a subroutine, or assigned into a variable

#include <iostream>
#include <memory>
using namespace std;

auto f() { return []{return 1;}; } // returned from a subroutine

int main()
{
    auto l = f(); // assigned into a variable
    return l();
}

_NN>#include <iostream>
_NN>#include <memory>
_NN>using namespace std;

_NN>void f(auto) {}

_NN>int main()
_NN>{
_NN>    f([]{});
_NN>}
_NN>

_NN>#include <iostream>
_NN>#include <memory>
_NN>using namespace std;

_NN>auto f() { return []{return 1;}; } // returned from a subroutine

auto f(int f) { if (f) return [=]{return f;}; return [=]{return f-1;}; }

 l=f(); l=f(); // не работает

_NN>>#include <iostream>
_NN>>#include <memory>
_NN>>using namespace std;

_NN>>void f(auto) {}

_NN>>int main()
_NN>>{
_NN>>    f([]{});
_NN>>}
_NN>>

int main()
{
    auto x = []{};
    
    auto f = [](decltype(x)) {};
    f(x);
}

class A
{public:
     static constexpr auto x = []{};

     virtual void f(decltype(x)) {} // Объявляем
};

class B:public A
{
  void callf()
  {
    f(x); // Вызываем
  }

  virtual void f(decltype(A::x)) override {}  
};

_NN>>#include <iostream>
_NN>>#include <memory>
_NN>>using namespace std;

_NN>>auto f() { return []{return 1;}; } // returned from a subroutine
_>[c]
_>auto f(int f) { if (f) return [=]{return f;}; return [=]{return f-1;}; }
_>

struct A{};
struct B{};

A x(int f)
{
 if (f) return A();
 return B();
}

_> l=f(); l=f(); // не работает
_>

std::function f([&](int i){ return i/3.0; }); // сигнатура int->double вывелась автоматом
std::cout << f(10) << '\n'; // напечатает 3.33333