// Разный синтаксис для разных типов
func();                    // функция
obj.method();              // метод
(obj.*ptr_to_member)();    // указатель на метод
lambda();                  // лямбда

// Единый синтаксис для всех callable
std::invoke(func);
std::invoke(&Class::method, obj);
std::invoke(lambda);
std::invoke(ptr_to_member, obj);

if (error_code != 0) {
    handle_error(); // редкий случай
} else {
    normal_processing(); // частый случай
}

if (error_code != 0) [[unlikely]] {
    handle_error(); // компилятор оптимизирует как редкий случай
} else [[likely]] {
    normal_processing(); // оптимизируется как частый случай
}

void mainLogic(const std::string& user) {
    // До рефакторинга
    if (user.size() > 3 && user[0] == 'A') {
        std::cout << "Valid user: " << user << std::endl;
    }
}

bool shouldProcessUser(const std::string& user) {
    return user.size() > 3 && user[0] == 'A';
}

void mainLogic(const std::string& user) {
    if (shouldProcessUser(user)) {
        std::cout << "Valid user: " << user << std::endl;
    }
}

template<typename T>
struct type_identity { using type = T; };

template<typename T>
using type_identity_t = typename type_identity<T>::type;

// БЕЗ type_identity - тип T выводится автоматически
template<typename T>
void convert_and_print(T from, T to) { /* ... */ }

convert_and_print(1, 2.5); // Ошибка: T не может быть int и double

// С type_identity - принуждаем указать тип явно
template<typename T>
void convert_and_print(T from, std::type_identity_t<T> to) { 
    std::cout << static_cast<T>(to) << std::endl;
}

convert_and_print<double>(1, 2.5); // OK: T = double}

template<typename T>
bool equal(const T& a, std::type_identity_t<const T&> b) {
    return a == b;
}

std::string str = "hello";
equal(str, "hello"); // OK: T = std::string, второй параметр - const char*

template<typename T>
std::unique_ptr<T> make_initialized(std::type_identity_t<T> init_value) {
    return std::make_unique<T>(init_value);
}

// Тип нужно указать явно
auto ptr = make_initialized<std::string>("Hello World");

std::vector<int> nums = {3, 1, 4, 1, 5};
auto it = std::find(nums.begin(), nums.end(), 4);
if (it != nums.end()) {
    std::cout << "Found at position " << std::distance(nums.begin(), it);
}

std::vector<int> sorted_nums = {1, 2, 3, 4, 5};
if (std::binary_search(sorted_nums.begin(), sorted_nums.end(), 3)) {
    std::cout << "Found!";
}

std::unordered_set<int> lookup = {1, 3, 5, 7, 9};
if (lookup.find(5) != lookup.end()) {
    std::cout << "Found instantly!";
}

auto even = std::find_if(nums.begin(), nums.end(), 
                        [](int n) { return n % 2 == 0; });

struct Point {
    int x, y, z;
};

Point p{.x = 10, .y = 20, .z = 30};

struct Config {
    std::string host = "localhost";
    int port = 8080;
    bool ssl_enabled = false;
    int timeout_ms = 5000;
};

// Указываем только нужные поля
Config cfg{
    .host = "example.com",
    .ssl_enabled = true
}; // port и timeout_ms получат значения по умолчанию

struct Database {
    std::string connection_string;
    int max_connections = 10;
};

struct AppConfig {
    Database db;
    std::string log_level = "INFO";
};

AppConfig config{
    .db = {.connection_string = "postgresql://...", .max_connections = 20},
    .log_level = "DEBUG"
};

struct DrawOptions {
    bool fill = false;
    int line_width = 1;
    std::string color = "black";
    float opacity = 1.0f;
};

void draw_rectangle(int x, int y, int w, int h, DrawOptions opts = {}) {
    // implementation
}

// Явно указываем только нужные опции
draw_rectangle(10, 20, 100, 50, {
    .fill = true,
    .color = "red",
    .opacity = 0.8f
});

// C-style union — опасно!
union Data {
    int i;
    double d;
    char* str;
};

Data data;
data.i = 42;
std::cout << data.d; // ❌ Читаем не то, что записали

std::variant<int, double, std::string> data;

data = 42;                    // Хранит int
data = 3.14;                  // Теперь хранит double
data = "hello";               // Теперь хранит string

// Безопасное получение значения
if (auto* val = std::get_if<int>(&data)) {
    std::cout << "int: " << *val << '\n';
}

std::variant<int, std::string, double> v;

// Установка значения
v = 100;
v = "text";
v.emplace<std::string>("constructed in place");

// Проверка текущего типа
std::cout << v.index(); // Индекс типа: 0, 1, или 2

if (std::holds_alternative<int>(v)) {
    std::cout << "Содержит int\n";
}

// Получение значения
try {
    auto val = std::get<int>(v); // Бросит std::bad_variant_access
} catch (const std::bad_variant_access&) {
    std::cerr << "Неверный тип!\n";
}

auto* ptr = std::get_if<std::string>(&v); // nullptr если не string

std::variant<int, double, std::string> v = 42;

// Обработка всех возможных типов
std::visit([](auto&& arg) {
    using T = std::decay_t<decltype(arg)>;
    
    if constexpr (std::is_same_v<T, int>) {
        std::cout << "int: " << arg << '\n';
    } else if constexpr (std::is_same_v<T, double>) {
        std::cout << "double: " << arg << '\n';
    } else {
        std::cout << "string: " << arg << '\n';
    }
}, v);

cpptemplate<class... Ts>
struct overloaded : Ts... { 
    using Ts::operator()...; 
};

template<class... Ts>
overloaded(Ts...) -> overloaded<Ts...>;

// Элегантная обработка!
std::visit(overloaded{
    [](int i) { std::cout << "int: " << i << '\n'; },
    [](double d) { std::cout << "double: " << d << '\n'; },
    [](const std::string& s) { std::cout << "string: " << s << '\n'; }
}, v);

template<typename T>
using Result = std::variant<T, std::string>; // Value или Error

Result<int> divide(int a, int b) {
    if (b == 0) return "Division by zero";
    return a / b;
}

auto result = divide(10, 0);
std::visit(overloaded{
    [](int value) { std::cout << "Result: " << value << '\n'; },
    [](const std::string& err) { std::cerr << "Error: " << err << '\n'; }
}, result);

Write a regular expression that matches / Write a RegEx pattern for:

[ваше описание]

std::regex email_pattern(
    R"([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,})"
);