// Before: Verbose, error-prone, and painful to refactor
std::vector<std::string>::iterator it = names.begin();

// After: Clean, correct, and adapts automatically if the container type changes
auto it = names.begin();

// auto also prevents accidental narrowing or type mismatches
std::map<std::string, std::vector<int>> data;
// Without auto, this type is absurdly long and easy to get wrong:
// std::map<std::string, std::vector<int>>::const_iterator cit = data.cbegin();
auto cit = data.cbegin();  // Correct, readable, maintainable

auto ptr = std::make_unique<MyClass>();
// Automatically deleted when ptr goes out of scope. No leaks!

std::vector<int> createVector() {
    std::vector<int> v(1'000'000);  // 1 million ints (~4MB)
    // Fill v with data...
    return v; // Move semantics: "steals" v's internal pointer. Zero elements copied.
}

// The caller gets the vector essentially for free
auto data = createVector();  // No copy. The pointer is simply handed over.

std::string name = "Alice";
std::vector<std::string> names;

// names.push_back(name);            // Copies "Alice" (name is still valid)
names.push_back(std::move(name));    // Moves "Alice" (name is now empty)
// After this line, name is in a "valid but unspecified state"
// Do NOT use name's value -- only reassign or destroy it.

std::map<std::string, int> scores = {{"Alice", 10}, {"Bob", 20}};

// Unpack Key and Value directly
for (const auto& [name, score] : scores) {
    std::cout << name << ": " << score << "\n";
}

#include <optional>

std::optional<std::string> findUser(int id) {
    if (id == 1) return "Alice";
    return std::nullopt; // Explicitly return "nothing" -- no ambiguity
}

auto user = findUser(2);
if (user.has_value()) {
    std::cout << user.value();
} else {
    std::cout << "User not found";
}

// Concise alternative using value_or() -- provides a default
std::cout << findUser(2).value_or("Unknown");  // Prints "Unknown"

#include <variant>

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

data = 10;
std::cout << std::get<int>(data); // 10

data = "Hello";
std::cout << std::get<std::string>(data); // Hello
// std::get<int>(data);  // Throws std::bad_variant_access! data holds a string now.

// A variant representing a parsed config value
using ConfigValue = std::variant<int, double, std::string, bool>;

void printConfig(const ConfigValue& val) {
    std::visit([](const auto& v) {
        // The compiler generates a version of this lambda for each type
        std::cout << v << "\n";
    }, val);
}

// More explicit: use an overload set for different handling per type
struct ConfigPrinter {
    void operator()(int v)                const { std::cout << "Integer: " << v << "\n"; }
    void operator()(double v)             const { std::cout << "Float: " << v << "\n"; }
    void operator()(const std::string& v) const { std::cout << "String: " << v << "\n"; }
    void operator()(bool v)               const { std::cout << "Bool: " << (v ? "true" : "false") << "\n"; }
};

ConfigValue cfg = "production";
std::visit(ConfigPrinter{}, cfg);  // Prints "String: production"

#include <concepts>

// Only accept types that are integral (int, long, short, etc.)
template <std::integral T>
T add(T a, T b) {
    return a + b;
}

add(10, 20);    // OK: int is integral
add(1.5, 2.5);  // Compile Error: "double does not satisfy integral" -- clear, one line

// You can define your own concepts
template <typename T>
concept Printable = requires(T t) {
    { std::cout << t } -> std::same_as<std::ostream&>;  // T must support operator<<
};

template <Printable T>
void log(const T& value) {
    std::cout << "[LOG] " << value << "\n";
}

#include <ranges>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> nums = {1, 2, 3, 4, 5, 6};

    // Pipeline: Filter evens -> Square them -> Take first 2
    // No intermediate vectors are created -- this is a single-pass lazy pipeline
    auto result = nums 
        | std::views::filter([](int n) { return n % 2 == 0; })    // 2, 4, 6
        | std::views::transform([](int n) { return n * n; })       // 4, 16, 36
        | std::views::take(2);                                      // 4, 16

    for (int n : result) {
        std::cout << n << " "; // 4 16
    }
}

// Without ranges: imperative, verbose, and creates a temporary vector
std::vector<int> temp;
for (int n : nums) {
    if (n % 2 == 0) {
        temp.push_back(n * n);
        if (temp.size() == 2) break;
    }
}