#include <cassert>
#include <concepts>
#include <cstddef>
#include <iostream>

struct Snapshot { std::size_t rows; };
class Batch {
    std::size_t rows_;
public:
    explicit Batch(std::size_t rows) : rows_(rows) {}
    std::size_t size() const { return rows_; }
};

template<class T> struct count_traits;
template<> struct count_traits<Snapshot> {
    static std::size_t get(const Snapshot& v) { return v.rows; }
};
template<> struct count_traits<Batch> {
    static std::size_t get(const Batch& v) { return v.size(); }
};
template<class T>
concept RecordCount = requires(const T& v) {
    { count_traits<T>::get(v) } -> std::same_as<std::size_t>;
};
template<RecordCount T>
std::size_t count_of(const T& v) { return count_traits<T>::get(v); }

int main() {
    static_assert(RecordCount<Snapshot>);
    static_assert(RecordCount<Batch>);
    static_assert(!RecordCount<int>);
    Snapshot a{3};
    Batch b{5};
    assert(count_of(a) == 3);
    assert(count_of(b) == 5);
    std::cout << count_of(a) + count_of(b) << "\n";
}