#include <cassert>
#include <concepts>
#include <cstddef>
#include <stdexcept>

struct RejectOverflow {
    std::size_t operator()(std::size_t, std::size_t) const {
        throw std::length_error("batch exceeds limit");
    }
};
struct ClampOverflow {
    std::size_t operator()(std::size_t, std::size_t cap) const {
        return cap;
    }
};

template<class P>
concept OverflowPolicy = requires(const P& p, std::size_t n) {
    { p(n, n) } -> std::same_as<std::size_t>;
};

template<OverflowPolicy P>
class BoundedBatch {
    std::size_t cap_;
    P policy_{};
public:
    explicit BoundedBatch(std::size_t cap) : cap_(cap) {}
    std::size_t accepted(std::size_t requested) const {
        return requested <= cap_ ? requested : policy_(requested, cap_);
    }
};

int main() {
    const BoundedBatch<RejectOverflow> strict{5};
    const BoundedBatch<ClampOverflow> partial{5};
    assert(strict.accepted(4) == 4);
    assert(partial.accepted(4) == 4);
    assert(partial.accepted(8) == 5);
    bool rejected = false;
    try { (void)strict.accepted(8); }
    catch (const std::length_error&) { rejected = true; }
    assert(rejected);
}