Modern C++ Toolkit for Design

#include <array>
#include <concepts>
#include <expected>
#include <numeric>
#include <print>
#include <span>
#include <string>
#include <string_view>
#include <variant>
#include <vector>

// 1. Scoped Enum (enum class) for strongly typed error reasons
enum class RejectReason {
    InsufficientFunds,
    LimitExceeded,
    CircuitBreaker
};

constexpr std::string_view toString(RejectReason reason) noexcept {
    switch (reason) {
        case RejectReason::InsufficientFunds: return "InsufficientFunds";
        case RejectReason::LimitExceeded:     return "LimitExceeded";
        case RejectReason::CircuitBreaker:    return "CircuitBreaker";
    }
    return "Unknown";
}

// Domain value types
struct TradeOrder {
    std::string orderId;
    int quantity;
    int priceRupees;
};

struct TradeReceipt {
    std::string tradeId;
    int executedValue;
};

// 2. C++20 Concept for compile-time contract checking (static polymorphism)
template <typename T>
concept RiskChecker = requires(T checker, const TradeOrder& order) {
    { checker.checkLimit(order) } -> std::convertible_to<bool>;
};

struct NotionalLimitChecker {
    int maxNotionalRupees;

    bool checkLimit(const TradeOrder& order) const noexcept {
        return (order.quantity * order.priceRupees) <= maxNotionalRupees;
    }
};

// 3. std::expected<T, E> (C++23) for explicit non-throwing domain failure handling
[[nodiscard]] std::expected<TradeReceipt, RejectReason>
evaluateTrade(const TradeOrder& order, const RiskChecker auto& checker, int accountBalance) {
    int notional = order.quantity * order.priceRupees;

    if (notional > accountBalance) {
        return std::unexpected(RejectReason::InsufficientFunds);
    }
    if (!checker.checkLimit(order)) {
        return std::unexpected(RejectReason::LimitExceeded);
    }

    return TradeReceipt{
        .tradeId = "TRD-" + order.orderId,
        .executedValue = notional
    };
}

// 4. Closed Polymorphism: std::variant + std::visit for Order State Machine
struct PlacedState {
    std::string placedAt;
};

struct FilledState {
    std::string tradeId;
    int filledValue;
};

struct RejectedState {
    RejectReason reason;
};

using OrderState = std::variant<PlacedState, FilledState, RejectedState>;

// Helper for visitor overload pattern
template <class... Ts>
struct Overloaded : Ts... {
    using Ts::operator()...;
};

void printOrderStatus(const OrderState& state) {
    std::visit(Overloaded{
        [](const PlacedState& s) {
            std::println("Status: PLACED at {}", s.placedAt);
        },
        [](const FilledState& s) {
            std::println("Status: FILLED (Trade: {}, Value: Rs.{})", s.tradeId, s.filledValue);
        },
        [](const RejectedState& s) {
            std::println("Status: REJECTED (Reason: {})", toString(s.reason));
        }
    }, state);
}

// 5. std::span (C++20) for non-owning view over contiguous sequences
[[nodiscard]] int computeTotalQuantity(std::span<const int> quantities) noexcept {
    return std::accumulate(quantities.begin(), quantities.end(), 0);
}

int main() {
    NotionalLimitChecker checker{.maxNotionalRupees = 500'000};

    // Test 1: Successful trade returning std::expected value
    TradeOrder order1{.orderId = "ORD-101", .quantity = 100, .priceRupees = 2500};
    auto result1 = evaluateTrade(order1, checker, 300'000);

    OrderState state1 = PlacedState{"10:00:00 UTC"};
    printOrderStatus(state1);

    if (result1.has_value()) {
        std::println("Order approved: {} for Rs.{}", result1->tradeId, result1->executedValue);
        state1 = FilledState{result1->tradeId, result1->executedValue};
        printOrderStatus(state1);
    }

    // Test 2: Rejected trade returning std::unexpected
    TradeOrder order2{.orderId = "ORD-102", .quantity = 300, .priceRupees = 2500};
    auto result2 = evaluateTrade(order2, checker, 100'000); // 750,000 exceeds balance and limit

    if (!result2.has_value()) {
        std::println("Order rejected: {}", toString(result2.error()));
        OrderState state2 = RejectedState{result2.error()};
        printOrderStatus(state2);
    }

    // Test 3: std::span with vector and array
    std::vector<int> batchVector = {50, 100, 150};
    std::array<int, 2> batchArray = {200, 300};

    std::println("Vector total qty: {}", computeTotalQuantity(batchVector));
    std::println("Array total qty: {}", computeTotalQuantity(batchArray));
    std::println("Subspan qty: {}", computeTotalQuantity(std::span(batchVector).subspan(1)));

    return 0;
}