auto a = [](int){};
a(10);

struct __closure_unique_type {
   void operator()(int) {}
};
...
__closure_unique_type a;
a(10);

int main(void) {
    auto x = []{ std::cout <<"hi\n"; };
    decltype(x) y[] = {x, x, x};
    y[1]();
    return 0;
}

assert(typeid([]{}) != typeid([]{}));

АШ>Все же здесь есть некоторое лукавство

class X{};
class Y{};

decltype(X) a[] = { X{}, Y{} };

AG>int main(void) {
AG>    auto x = []{ std::cout <<"hi\n"; };
AG>    decltype(x) y[] = {x, x, x};
AG>    y[1]();
AG>    return 0;
AG>}
AG>

auto x=[]{ std::cout<<"x\n"; };
auto y=[]{ std::cout<<"y\n"; };
auto z=[]{ std::cout<<"z\n"; };
typedef decltype(x) t;
void foo(t); foo(x); foo(y); foo(z);
t a[]={x,y,z};

struct A {
    enum { N=3 };
    int x[N]; double y[N];
    virtual void fn(int x) {}
    virtual void fn(double x) {}
};

АШ>Если у тебя есть определение firts class citizens, как объекта, который может быть передан в качестве аргумента в функцию, возвращен из функции, присвоен переменной, то ты без труда ответишь на свой вопрос

Some authors require it be possible to create new functions at runtime to call them 'first-class'. As a result, functions in C are not first-class objects; instead, they are sometimes called second-class objects, because they can still be manipulated in most of the above fashions (via function pointers).

1. лямбда: https://ideone.com/gxNgiM
   
2. std::function: https://ideone.com/yqVRmo

#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

const a = 1;
const b = 2;

if (a == b) { // Operator == cannot be applied to type '1' and '2'  
}

#include <stdio.h>

struct Callback {
  typedef void (*fn_t)(void *ctx); fn_t fn; void *ctx;
  Callback(fn_t fn=0,void* ctx=0) : fn(fn), ctx(ctx) {}
  operator bool () const { return !!fn; }
  void operator() () const { if (fn) fn(ctx); }
  template<class T>Callback(T t) {
    static struct L{T t;L(const T&t):t(t){}static void f(void*ctx){((L*)ctx)->t();}}c(t);
    fn=L::f;ctx=&c;
  };
};

struct A {
  void fn() { printf("A(0x%016llX).fn()\n",(long long)this); }
  Callback get_fn() {return{[&](){ fn(); }};}
};

int main(int argc,char** argv) {
  A a; Callback list[3];

  list[0]={[&](){ printf("argc=%d argv[0]=%s\n",argc,argv[0]);  }};

  list[1]={[=](){
    printf("sizeof(Callback)=%d sizeof(void*)=%d sizeof(int)=%d\n",(int)sizeof(Callback),(int)sizeof(void*),(int)sizeof(int));
  }};

  list[2]=a.get_fn(); // тут бы просто a.fn, но нет этож c++

  for(auto item:list) item();

  return 0;
}