{

// Generic lambdas

// auto before_generic_lambda = [](int x) { return x; };

auto generic_lambda = [](auto x) { return x; };

auto universal_size = [](const auto& m) { return m.size(); };

auto capture_initializers = [value = 1] { return value; };

unique_ptr<int> ptr(new int(10));

auto capture_by_move = [value = std::move(ptr)] { return *value; };

{

tuple<string, string, int> tuple_by_type("foo", "bar", 7);

int i = get<int>(tuple_by_type);

assert(i == 7);

int j = get<2>(tuple_by_type);

assert(j == 7);

{

assert(pi<int> == 3);

assert(string(pi<const char*>) == "pi");

{

// https://en.cppreference.com/w/cpp/memory/unique_ptr/make_unique

auto u = make_unique<int>(1);

assert(u);

assert(*u == 1);

{

array<int, 10> s = {5, 7, 4, 2, 8, 6, 1, 9, 0, 3};

sort(s.begin(), s.end(),

// sort using a generic lambda expression

[](auto a, auto b)

{ return a > b; }

);

{

auto x = deduced_return_type(1);

int& y = deduced_return_type_lambda(x); // reference to `x`

assert(&y == &x);

assert(y == 1);

tuple_demo();

template_variables::demo();

implicit_return_type();

dynamic_memory_14();

sort_14();

return 0;