cpp-lazy-stream/include/stream/map.hpp

#pragma once

#include <iterator/proxy.h>

namespace stream::detail {
template <typename T, typename R>
class map_iterator : public ::iterator::proxy<iterator<T>, map_iterator<T, R>> {
public:
  using projection_t = std::function<R(T const &)>;
  using super_t = ::iterator::proxy<iterator<T>, map_iterator<T, R>>;

public:
  map_iterator(projection_t proj, iterator<T> && impl)
      : proj_(std::move(proj)), super_t(std::move(impl)) {}

  R dereference() const { return proj_(super_t::dereference()); }

private:
  std::function<R(T const &)> proj_;
};

template <typename T, typename R> class map_stream {
public:
  template <typename F>
  map_stream(F && func, stream_base<T> const & sb) : fun_(func), source_(sb) {}

  iterator<R> begin() { return {map_iterator<T, R>{fun_, source_.begin()}}; }

  iterator<R> end() { return {map_iterator<T, R>{fun_, source_.end()}}; }

private:
  std::function<R(T const &)> fun_;
  stream_base<T> source_;
};

template <typename T>
template <typename F>
stream_base<traits::mapped_t<T, F>> stream_base<T>::map(F && func) && {
  return std::make_shared<map_stream<T, traits::mapped_t<T, F>>>(
      func, std::move(*this));
}

template <typename T>
template <typename F>
stream_base<traits::mapped_t<T, F>> stream_base<T>::map(F && func) const & {
  return std::make_shared<map_stream<T, traits::mapped_t<T, F>>>(func, *this);
}
}