std::vector<int> data = {1,2,3,4,5} ;
auto even = [](int v){ return (v & 1) == 0 ;};

std::vector<int> even_numbers ;

std::copy_if(data.begin(), data.end(),
    std::back_insert_iterator(even_numbers),
    even);
//even_numbers => {2,4}

std::vector<int> data = {1,2,3,4,5} ;
auto scale = 1.4 ;

std::vector<double> scaled  ;

std::transform(data.begin(), data.end(),
               std::back_insert_iterator(scaled),
               [scale](int i){return i * scale;});
//scaled => {1.4, 2.8, 4.2, 5.6, 7.0}

std::vector<int> data = {1,2,3,4,5} ;

auto v1 = std::accumulate(data.begin(), data.end(),
                         0, std::plus<>());

auto v2 = std::reduce(data.begin(), data.end(),
                      0, std::plus<>());

std::vector<std::string> values{
  "Forth", "functional",
  "programming", "meetup"
} ;
auto char_cout = std::transform_reduce(
      std::execution::par,
      values.begin(), values.end(),
      0, std::plus<>{},
      [](const std::string& s) {
        return s.size();
      });
// char_cout == 32

std::vector<int> v;
// ...
auto negatives_to_zero = lift::if_then_else(
                lift::less_than(0),
                [](const auto&) { return 0;},
                [](const auto& x) { return x;});
std::vector<int> result;
std::transform(std::begin(v), std::end(v),
               std::back_inserter(result),
               negatives_to_zero);

std::vector<int> a {1,2,3} ;
auto b = a ;   // copy
b.push_back(4);

assert(a.size() == 3) ;
assert(b.size() == 4) ;

// takes by value, copy construction
void f(std::vector<int> v) {
    // my personal,local mutable data
    b.push_back(4);
}

std::vector<int> a {1,2,3} ;
f(a);
assert(a.size() == 3) ;

std::vector<int> a {1,2,3} ;
auto& b = a ; // the '&' is important
b.push_back(4);
assert(a.size() == 4) ;
assert(b.size() == 4) ;

const int num = 42 ; // can not be changed

void f(const std::vector<int>& v) {

    // v.push_back(4);  Compile time error

    // num = 32 ; Compile time error

}

template<class FwdIt, class Comp = std::less<>>
void quick_sort(FwdIt first, FwdIt last,
                      Comp cmp = Comp{}){
    const auto N = std::distance(first, last);
    if (N <= 1) return;
    const auto pivot = *std::next(first, N / 2);
    const auto m1 = std::partition(
        first, last, [=](const auto& elem){
              return cmp(elem, pivot);
    });
    auto const m2 = std::partition(
        m1, last, [=](const auto& elem){
              return !cmp(pivot, elem);
    });
    quick_sort(first, m1, cmp);
    quick_sort(m2, last, cmp);
}

int hash (const char *) __attribute__ ((pure));

int square (int) __attribute__ ((const));

constexpr int hash (const char *) ;

constexpr int square (int) ;

void doSomething(const Data* data) {
  if (data == nullptr) {
      // there is no data
  } else {
      // ... we have data
  }
}

void doSomething(const Data* data) { // scope
  Foo f;
  if (what_ever) {  //scope
    Bar b ;
  } // ~b
  { // scope
    Baz b;
  } // ~b
} // ~f

class Foo{

    // private resources

public:
    Foo(/* arguments* /) {
        /* create*/
    } ;

    ~Foo() { /*release*/} ;
};

std::unique_ptr<Resource> build(int a, int b){
    auto r = std::make_unique<Resource>(a,b) ;
    // whatever with r
    return r ;
}

void fun() {
    auto res = build(1,2);
    res->do_job1() ;
    res->do_job2() ;
}

std::vector<int> ints{0,1,2,3,4,5};
auto even = [](int i){ return 0 == i % 2; };
auto square = [](int i) { return i * i; };

std::ranges::for_each( ints |
    std::views::filter(even) |
    std::views::drop(1) |
    std::views::transform(square) ,
    [](const auto& v) { std::cout << v; }) ;