Использование лямбда выражения в качестве аргумента функции

int t = [](int x) { return [](int y) { return y * 2; }(x) + 3; }(5);

typedef void (*func)();
 
void f(func t) {
    t();
}
 
int main() {
    f([]() {
        cout<<"Ура, заработало!";
    });
}

typedef bool (*func)(int);
void f(func t) {
    cout<<t(5);
}
int main() {
 
    auto a=[](int y) {
        return y>0;
    };
    f(a);
}

template< typename Func >
void f(Func t,int x) {
    cout<<t(x);
}
int main() {
 
    int x=5;
    auto a=[](int y) {
        return y>0;
    };
    f(a,x);
}

auto l = [] ( auto f ) { f(1); };
auto f = [] ( int n ) { std::cout << n << std::endl; };
l( f );

#include <iostream>
#include <string>
 
using std::string;
using std::cout;
using std::endl;
 
//Эта лямбда обменивает значения x и y
auto lambda1{
    [](auto& x, auto& y)-> void
    {
        auto buf = x;
        x = y;
        y = buf;
    }
};
 
//Эта лямбда cскладывает x и y с самими собой
auto lambda2{
    [](auto& x, auto& y)-> void
    {
        x += x;
        y += y;
    }
};
 
//Это шаблон функции, где Tx и Ty - это некие операнды, которые будут помещены в некую функцию T
template <typename T, typename Tx, typename Ty>
void func(Tx& x, Ty& y, T lambda)
{
    lambda(x, y);
}
 
int main()
{
    //Для примера, сделаем 2 целочисленные переменные
    int x = 1;
    int y = 2;
 
    //Теперь прогоним их через нашу функцию
    func(x, y, lambda1);
 
    cout << "x = " << x << " y = " << y << endl;//Результат: x = 2 y = 1
 
    func(x, y, lambda2);
 
    cout << "x = " << x << " y = " << y << endl;//Результат: x = 4 y = 2
    
    //Всё работает! Используя лишь одну функцию и меняя в ней только подставляемые лямбды, мы можем управлять её функционалом.
    
    //Но это ещё не всё. Так как здесь всё абстрактно, мы можем использовать и другие типы данных, ничего не меняя, например строки
    string x2 = "a";
    string y2 = "b";
 
    func(x2, y2, lambda1);
 
    cout << "x = " << x2 << " y = " << y2 << endl;//Результат: x = b y = a
 
    func(x2, y2, lambda2);
 
    cout << "x = " << x2 << " y = " << y2 << endl;//Результат: x = bb y = aa
    //Этот фокус пройдёт с вообще любым типом данных для первой лямбды, и для любого типа данных, поддерживающего оператор "+", - для второй
    return 0;
}
/*{
 *Такой подход может быть элегантным решением в некоторых случаях, но если премудрить, читабельность кода резко падает и те, кто тоже будет работать с кодом (включая вас из будущего)
 *не выкупят гения вашего полиморфизма.
}*/

#include <iostream>
#include <vector>
#include <algorithm>
 
int main()
{
    std::vector<int> vec{1,2,3,4,5,6,7};
    
    const int to_find = 5;
 
    //лямбда в качестве предиката
    auto it=std::find_if(vec.begin(),vec.end(),[&to_find](auto item)
    {
        return item==to_find;
    });
    
    if(it!=vec.end())
    {
        std::cout<<"found!";
    }
    else
    {
        std::cout<<"not found.";
    }
 
    return 0;
}