#include <iostream>
#include <type_traits>
#include <vector>

template<typename functor_t>
struct map_functor_t
{
    template<typename Arg>
    auto operator()(Arg arg) {
        return func_(arg);
    }

    functor_t func_;
};

template<typename functor_t>
map_functor_t<functor_t> map(functor_t transformer)
{
    return map_functor_t<functor_t>{transformer};
}

//=========================================================

template<typename elem_t>
struct stream_t {
    std::vector<elem_t> elems_;
};

template<typename elem_t>
stream_t<elem_t> make_stream(const std::vector<elem_t>& elems)
{
    return stream_t<elem_t>{elems};
}

template<typename elem_t>
stream_t<elem_t> make_stream(const std::initializer_list<elem_t>& elems)
{
    return stream_t<elem_t>{elems};
}

//=========================================================

template<typename elem_t, typename function_t>
auto operator|(const stream_t<elem_t>& stream, function_t fn)
{
    using result_t = typename std::result_of<function_t(elem_t)>::type;

    stream_t<result_t> result;
    for (const auto& elem: stream.elems_) {
        result.elems_.push_back(fn(elem));
    }
    return result;
}

// ========================================================

struct summator_t {};

summator_t sum() { return summator_t(); }

template<typename elem_t>
auto operator|(const stream_t<elem_t>& stream, summator_t)
{
    if (stream.elems_.empty()) {
        return elem_t();
    }

    auto e = stream.elems_.front();
    for (size_t i = 1; i < stream.elems_.size(); ++i) {
        e += stream.elems_[i];
    }
    return e;
}

int main() {
    std::cout << (make_stream({1, 2, 3})
                | map([] (int x) { return x * x; })
                | map([] (int x) { return x + 1; })
                | sum()) << std::endl;
}