auto now = std::chrono::system_clock::now();
// Внутри: берётся значение из /dev/rtc или Windows' GetSystemTimeAsFileTime()
// И преобразуется в количество тиков с 1970-01-01 00:00:00 UTC

template<std::ranges::input_range R>
class stride_view : public std::ranges::view_interface<stride_view<R>> {
private:
    // Если R уже view, используем R. Иначе — ref_view для безопасности
    R base_;
    std::ranges::range_difference_t<R> stride_;

public:
    stride_view() = default;

    stride_view(R base, std::ranges::range_difference_t<R> stride)
        : base_(std::move(base)), stride_(stride) {
        // Критическая проверка: stride должен быть положительным!
        if (stride_ <= 0) {
            throw std::invalid_argument("stride must be > 0");
        }
    }

    auto begin() {
        return stride_iterator<R>{ std::ranges::begin(base_),
                              std::ranges::end(base_), stride_ };
    }

    auto begin() const {
        return stride_iterator<R>{ std::ranges::begin(base_),
                              std::ranges::end(base_), stride_ };
    }

    auto end() {
        return stride_sentinel<R>{};
    }

    auto end() const {
        return stride_sentinel<R>{};
    }
};

template<std::ranges::input_range R>
struct stride_sentinel {};

template<std::ranges::input_range R>
struct stride_iterator {
    std::ranges::iterator_t<R> current_;
    std::ranges::sentinel_t<R> end_;
    std::ranges::range_difference_t<R> stride_;

    // Pre-increment: ++it
    stride_iterator& operator++() {
        // 🔴 Критический момент: проверяем, не за пределами ли мы
        for (int i = 0; i < stride_ && current_ != end_; ++i) {
            ++current_;
        }
        return *this;
    }

    // Post-increment: it++
    stride_iterator operator++(int) {
        auto tmp = *this;
        ++(*this);
        return tmp;
    }

    auto operator*() const {
        return *current_;
    }

    // Сравнение с концом диапазона через sentinel
    bool operator==(const stride_sentinel<R>&) const {
        return current_ == end_;
    }
};

std::vector v = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
auto strided = stride_view(v, 2);

for (auto x : strided) {
    std::cout << x << " ";  // 0 2 4 6 8
}

for (auto x : v | std::views::stride(2)) {
    std::cout << x << " ";  // 0 2 4 6 8
}

#include <chrono>
using namespace std::chrono;

bool wait_for_response(Connection& conn, int timeout_ms) {
    auto deadline = system_clock::now() + milliseconds(timeout_ms);
    while (system_clock::now() < deadline) {
        if (conn.has_data()) return true;
        std::this_thread::sleep_for(milliseconds(10));
    }
    return false;
}