Modern Cpp

#include <expected>

enum class ParseError { empty_input, invalid_format, overflow };

std::expected<int, ParseError> parse_int(std::string_view s) {
    if (s.empty())
        return std::unexpected(ParseError::empty_input);
    // ... parsing logic ...
    return 42;
}

// Caller must handle both paths
auto result = parse_int("123");
if (result) {
    use(*result);  // or result.value()
} else {
    handle(result.error());
}

std::expected<Config, Error> load_config(const Path& p) {
    return read_file(p)                    // expected<string, Error>
        .and_then(parse_toml)              // expected<TomlValue, Error>
        .and_then(validate_config)         // expected<Config, Error>
        .transform(apply_defaults);        // expected<Config, Error>
}

#include <print>

std::println("Hello, {}!", name);              // with newline
std::print("x = {}, y = {}\n", x, y);         // without auto-newline
std::println("{:>10.2f}", 3.14159);            // format spec: right-aligned, 2 decimal
std::println("{0} is {0}", value);             // reuse argument by index

// BEFORE: printf (type-unsafe, format string vulnerabilities)
printf("Name: %s, Age: %d\n", name.c_str(), age);

// BEFORE: iostream (verbose, stateful, slow)
std::cout << "Name: " << name << ", Age: " << age << std::endl;

// AFTER: type-safe, readable, fast
std::println("Name: {}, Age: {}", name, age);

// BEFORE: duplicated logic for const and non-const
class Buffer {
    std::vector<char> data_;
public:
    char& operator[](size_t i) { return data_[i]; }
    const char& operator[](size_t i) const { return data_[i]; }
    // Often 4 overloads: const/non-const x lvalue/rvalue
};

// AFTER: one function handles all qualifications
class Buffer {
    std::vector<char> data_;
public:
    template <typename Self>
    auto&& operator[](this Self&& self, size_t i) {
        // forward_like, not forward: vector::operator[] is not ref-qualified,
        // so forwarding the object alone would drop the rvalue case
        return std::forward_like<Self>(self.data_[i]);
    }
};

// BEFORE: arcane template pattern
template <typename Derived>
struct Base {
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

// AFTER: no template parameter needed
struct Base {
    void interface(this auto&& self) {
        self.implementation();
    }
};

// BEFORE: std::function or Y-combinator
std::function<int(int)> fib = [&](int n) {
    return n <= 1 ? n : fib(n-1) + fib(n-2);
};

// AFTER: direct recursion
auto fib = [](this auto&& self, int n) -> int {
    return n <= 1 ? n : self(n-1) + self(n-2);
};

#include <ranges>

auto vec = data
    | std::views::filter(is_valid)
    | std::views::transform(process)
    | std::ranges::to<std::vector>();  // materialize into a vector

// Works with any container
auto set = data
    | std::views::transform(normalize)
    | std::ranges::to<std::set>();

#include <flat_map>

std::flat_map<std::string, int> scores;
scores["alice"] = 100;
scores["bob"] = 85;

auto it = scores.find("alice");  // fast binary search on sorted vector

#include <generator>

std::generator<int> fibonacci() {
    int a = 0, b = 1;
    while (true) {
        co_yield a;
        auto next = a + b;
        a = b;
        b = next;
    }
}

// Lazy — only computes as many values as consumed
for (auto val : fibonacci() | std::views::take(10)) {
    std::println("{}", val);
}

import std;  // replaces ALL #include <...> for standard headers

int main() {
    std::println("Hello from modules!");
}