// How do you make a vector of sequential numbers?

auto v0 = from_to(0,10) | collect<std::vector>;


// How do you make one of floats from 0.0..0.9 by 0.1?

auto v1 = from_to(0.0f, 1.0f, 0.1f) | collect <std::vector>;


// Take a string "a,b,c" and make a map like {{"a": 1}, {"b": 2}, ...}.
// Use one line of code.

auto m0 = zip("a,b,c" | split(","), from(1)) | collect<std::map>;


// How do you split a string by *regex*, and join it with ","?

auto s0 = "a,b:c,d#e" | split("[,:#]"_re) | join(",");


// Split the same string but iterate until you find "c", without doing extra
// work (e.g. splitting/matching more of the string than necessary)

auto g = "a,b:c,d#e" | split("[,:#]"_re);

for(auto s : g)
   if(s == "c") break;


// Write a visitor for a std::variant<int,float,std::string> that
// adds or appends 1.

std::variant<int,float,std::string> va0 = 42.0f;

va0
| match<int>         <= [](auto& i) { i += 1; }
| match<float>       <= [](auto& f) { f += 1.0f; }
| match<std::string> <= [](auto& s) { s += "1"; }
;

// ^- for a template: same code

for(auto i : from(1)) { ... }

// =

for(auto i = 1; ; ++i) { ... }

// This is not cpp-pipedream

struct from_end { };

template<typename T>
struct from_iterator {
    using iterator_category = std::forward_iterator_tag;
    using value_type = T;
    using difference_type = T;
    using pointer = T*;
    using reference = T&;

    from_iterator(T v, T i) : _v(v), _i(i) { }

    T& operator*() { return _v; }
    T* operator->() { return &_v; }

    from_iterator& operator++() { _v += _i; return *this; }

    bool operator==(const from_iterator &i) const { return _v == i._v; }
    bool operator!=(const from_iterator &i) const { return _v != i._v; }
    bool operator==(const from_end &) const { return false; }
    bool operator!=(const from_end &) const { return true; }

private:
    T _v;
    T _i;
};

template<typename T>
struct from {
    using iterator = from_iterator<T>;

    from(T v, T i = T(1)) : _v(v), _i(i) { }

    iterator begin() const { return iterator(_v, _i); }
    from_end end() const { return {}; }

private:
    T _v;
    T _i;
};

// Pipe dream

template<typename T>
struct generator_from : public generator<generator_from<T>> {
    using value_type = T;
    using option_type = std::optional<T>;

    T cur{};
    const T incr{1};

    option_type next() { auto v = cur; cur += incr; return v; }
    bool empty() const { return false; }
};

template<typename T>
inline generator_from<T> from(T n, T by = T{1}) {
    return {{}, n, by};
}

auto v = from(1) | take(3) | collect<std::vector>;

for(auto i : from(1))
    if(i > 5) break;