cpp-lazy-stream/include/stream/streams/fluent.hpp

//
//  fluent.hpp
//  stream
//
//  Created by Sam Jaffe on 1/28/17.
//

#pragma once

#include "../streams.hpp"

namespace stream { namespace traits {
  template <typename T, typename P>
  using is_filter =
      std::is_same<bool, decltype(std::declval<P>()(std::declval<T>()))>;

  template <typename C, typename T, typename = void>
  struct is_collection : public std::false_type {};

  template <typename C, typename T>
  struct is_collection<C, T,
                       typename std::enable_if<std::is_constructible<
                           typename C::value_type, T>::value>::type>
      : public std::true_type {};
}}

namespace stream { namespace detail {
  template <typename T, typename F>
  auto operator||(stream_base<T> const & s, F && f) -> decltype(s.flatmap(f)) {
    return s.flatmap(f);
  }

  template <
      typename T, typename F,
      typename = typename std::enable_if<!traits::is_filter<T, F>::value>::type>
  auto operator|(stream_base<T> const & s, F && f) -> decltype(s.map(f)) {
    return s.map(f);
  }

  template <
      typename T, typename P,
      typename = typename std::enable_if<traits::is_filter<T, P>::value>::type>
  stream_base<T> operator|(stream_base<T> const & s, P && f) {
    return s.filter(f);
  }

  template <typename R> R operator>(stream_base<R> const & s, R const & val) {
    return s.accumulate(val);
  }

  template <typename L, typename R, typename F>
  L operator>(stream_base<R> const & s, std::pair<L, F> const & pair) {
    return s.accumulate(pair.second, pair.first);
  }

  template <typename T, typename F,
            typename = typename std::enable_if<
                !traits::is_collection<F, T>::value>::type>
  typename std::decay<T>::type operator>(stream_base<T> const & s, F && f) {
    return s.accumulate(f, typename std::decay<T>::type());
  }

  template <typename T, typename C,
            typename = typename std::enable_if<
                traits::is_collection<C, T>::value>::type>
  C & operator>(stream_base<T> const & s, C & c) {
    s.collect(c);
    return c;
  }
}}