#include <concepts>
#include <iostream>
#include <string>
#include <sstream>

// Концепт для сериализуемых типов
template<typename T>
concept Serializable = requires(T obj, std::ostream& os, std::istream& is) {
    { obj.serialize(os) } -> std::same_as<void>;
    { T::deserialize(is) } -> std::same_as<T>;
};

// Пример сериализуемого класса
struct Person {
    std::string name;
    int age;
    
    void serialize(std::ostream& os) const {
        os << name << " " << age;
    }
    
    static Person deserialize(std::istream& is) {
        Person p;
        is >> p.name >> p.age;
        return p;
    }
};

// Функция для работы с сериализуемыми объектами
template<Serializable T>
void save_and_load(const T& obj) {
    std::stringstream ss;
    
    // Сериализация
    obj.serialize(ss);
    std::cout << "Serialized: " << ss.str() << std::endl;
    
    // Десериализация
    T loaded = T::deserialize(ss);
    std::cout << "Deserialized successfully" << std::endl;
}

// Использование
void example() {
    Person p{"Alice", 25};
    save_and_load(p);  // ✅ Работает
    
    // save_and_load(42);  // ❌ Ошибка компиляции
}

cppstd::vector<std::string> strings;
for (const auto& num : numbers) {
    strings.push_back(std::to_string(num));
}

auto string_view = numbers | std::views::transform([](int x) { 
    return std::to_string(x); 
});

//Verbosity nightmare
std::vector<std::pair<std::string, int> > vec; // пробел обязателен!
for (std::vector<std::pair<std::string, int> >::iterator it = vec.begin(); 
     it != vec.end(); ++it) {
    // работаем с *it
}

// auto и range-based for
std::vector<std::pair<std::string, int>> vec; // >> теперь OK!
for (auto& item : vec) {
    // намного чище!
}

// Не нужно указывать типы
std::vector vec{std::pair{"hello", 42}, {"world", 24}}; // CTAD!
std::optional opt = some_function(); // тип выводится автоматически

// Structured bindings
for (auto [name, value] : vec) {
    std::cout << name << ": " << value << "\n";
}

#include <concepts>

template<std::integral T>  // Концепты!
auto process(T value) {
    return value * 2;
}

// Abbreviated function templates
auto add(std::integral auto a, std::integral auto b) {
    return a + b;
}

// if consteval для compile-time проверок
constexpr auto get_value() {
    if consteval {
        return 42; // compile-time версия
    } else {
        return expensive_runtime_calc(); // runtime версия  
    }
}

// Multidimensional subscript operator
matrix[1, 2, 3] = value; // вместо matrix[1][2][3]

#include "conjure_enum.h"

CONJURE_DEFINE_ENUM(Color, Red, Green, Blue)

int main() {
    Color c = Color::Green;
    std::cout << conjure_enum::to_string(c); // "Green"
    std::cout << conjure_enum::is_valid(42); // false
    for (Color value : conjure_enum::values<Color>()) { ... }
}

class MyString {
private:
    char* data;
    size_t length;
    
public:
    // Правильный operator=
    MyString& operator=(const MyString& other) {
        if (this == &other) return *this; // самоприсваивание
        
        // Создаём временную копию
        char* temp = new char[other.length + 1];
        strcpy(temp, other.data);
        
        // Освобождаем старые данные
        delete[] data;
        
        // Присваиваем новые
        data = temp;
        length = other.length;
        
        return *this;
    }
    
    // Лучше через copy-and-swap
    MyString& operator=(MyString other) { // копия по значению
        swap(*this, other);
        return *this;
    }
};