query.h

Go to the documentation of this file.

 
#ifndef FCPP_QUERY_H
#define FCPP_QUERY_H
 
#include <algorithm>
#include <functional>
#include <iterator>
#include <map>
#include <optional>
#include <random>
#include <set>
#include <tuple>
#include <type_traits>
#include <utility>
#include <valarray>
#include <variant>
#include <vector>
 
#include "asserts.h"
#include "traits.h"
#include "transforms.h"
 
// DO NOT USE
//
// Internal overloads of [CR_]EXPR.
#define __EXPR1__(type, var, expr) [](type var) { return expr; }
#define __EXPR2__(type, var1, var2, expr)                                      \
  [](type var1, type var2) { return expr; }
#define __GET_MACRO__(_1, _2, _3, NAME, ...) NAME
 
#define EXPR(...)                                                              \
  __GET_MACRO__(__VA_ARGS__, __EXPR2__, __EXPR1__)(auto, __VA_ARGS__)
 
#define CR_EXPR(...)                                                           \
  __GET_MACRO__(__VA_ARGS__, __EXPR2__, __EXPR1__)(const auto &, __VA_ARGS__)
 
namespace fcpp {
// Forward declaration. See actual definition below.
template <typename T>
class Queryable;
 
template <typename T>
class WhenTrue;
 
template <typename WhenTrueQueried, typename T>
class WhenFalse;
 
template <typename TrueT, typename FalseT>
class Merge;
 
template <typename T>
Queryable<T> query(std::vector<T> items);
 
template <typename T>
class Queryable final {
public:
  explicit Queryable(std::vector<T> items);
  Queryable() = delete;
  virtual ~Queryable() = default;
  Queryable(Queryable &&) = default;
  Queryable(const Queryable &) = delete;
  Queryable &operator=(const Queryable &) = delete;
  operator const std::vector<T> &&() const { return std::move(items_); }
 
  friend bool operator==(const Queryable<T> &lhs, const std::vector<T> &rhs) {
    return std::equal(lhs.items_.begin(), lhs.items_.end(), rhs.begin());
  }
  friend bool operator==(const Queryable<T> &lhs, const Queryable<T> &rhs) {
    return std::equal(lhs.items_.begin(), lhs.items_.end(), rhs.items_.begin());
  }
 
  typedef T item_type;
 
  template <typename U, typename AccumulateFn>
  U accumulate(U initial, AccumulateFn accumulate_func) const;
 
  template <typename ActionFn>
  Queryable<T> action(ActionFn action_func);
 
  template <typename Predicate>
  bool all(Predicate predicate) const;
 
  template <typename Predicate>
  bool any(Predicate predicate) const;
 
  template <typename Predicate>
  WhenTrue<T> branch(Predicate predicate);
 
  Queryable<T> difference(std::vector<T> rhs_items);
 
  Queryable<T> distinct();
 
  bool empty() const;
 
  template <typename Predicate>
  std::optional<T> first_or_default(Predicate predicate);
 
  auto flatten();
 
  template <typename KeySelector>
  Queryable<std::vector<T>> group_by(KeySelector key_selector);
 
  Queryable<T> intersect(const std::vector<T> &rhs_items);
 
  template <typename U, typename LhsKeySelector, typename RhsKeySelector>
  Queryable<std::tuple<T, U>> join(
      std::vector<U> rhs_items, LhsKeySelector lhs_key_selector,
      RhsKeySelector rhs_key_selector);
 
  template <typename KeySelector>
  auto keyed_group_by(KeySelector key_selector);
 
  T max();
 
  template <typename ValueSelector>
  T max(ValueSelector value_selector);
 
  T min();
 
  template <typename ValueSelector>
  T min(ValueSelector value_selector);
 
  template <typename ValueSelector>
  Queryable<T> order_by(ValueSelector value_selector, bool descending = false);
 
  Queryable<T> reverse();
 
  template <typename Selector>
  auto select(Selector selector);
 
  Queryable<T> shuffle();
 
  size_t size() const;
 
  Queryable<T> skip(size_t value);
 
  Queryable<T> slice(size_t start_index, size_t size, size_t stride = 1);
 
  Queryable<T> sort();
 
  Queryable<T> take(size_t value);
 
  Queryable<T> take_random(size_t value);
 
  Queryable<T> trim(size_t size);
 
  template <typename KeySelector>
  auto to_multi_value_map(KeySelector key_selector);
 
  template <typename KeySelector /* = std::function<K(T)>*/>
  auto to_single_value_map(KeySelector key_selector);
 
  std::set<T> to_set();
 
  std::vector<T> to_vector();
 
  Queryable<T> unionize(std::vector<T> rhs_items);
 
  template <typename Predicate>
  Queryable<T> where(Predicate predicate);
 
  template <typename U>
  Queryable<std::tuple<T, U>>
  zip(std::vector<U> rhs_items, bool truncate = false);
 
  template <typename U>
  Queryable<std::tuple<T, U>>
  zip(std::initializer_list<U> rhs_items, bool truncate);
 
private:
  std::vector<T> items_;
};
 
} // namespace fcpp
 
/******************************************************************************
 *
 * @brief Keep definitions separate to allow the declarations to stay clean and
 * compact.
 *
 *****************************************************************************/
 
namespace fcpp {
 
template <typename T>
Queryable<T> query(std::vector<T> items) {
  return Queryable<T>(std::move(items));
}
 
template <typename T>
Queryable<T>::Queryable(std::vector<T> items) : items_(std::move(items)) {}
 
template <typename T>
bool operator==(const Queryable<T> &lhs, const std::vector<T> &rhs) {
  return std::equal(lhs.items_.begin(), lhs.items_.end(), rhs.begin());
}
 
template <typename T>
bool operator==(const Queryable<T> &lhs, const Queryable<T> &rhs) {
  return std::equal(lhs.items_.begin(), lhs.items_.end(), rhs.items_.begin());
}
 
template <typename T>
template <typename U, typename AccumulateFn>
U Queryable<T>::accumulate(U initial, AccumulateFn accumulate_func) const {
  static_assert(
      traits::is_additive<U>::value, "Initial value type must be additive.");
  // @todo Check that AccumulateFn is a binary operation.
  return std::accumulate(
      std::make_move_iterator(items_.begin()),
      std::make_move_iterator(items_.end()), initial, accumulate_func);
}
 
template <typename T>
template <typename ActionFn>
Queryable<T> Queryable<T>::action(ActionFn action_func) {
  // @todo Check that ActionFn is a unary operation.
  std::for_each(items_.begin(), items_.end(), [&action_func](auto item) {
    action_func(item);
  });
  return Queryable<T>(std::move(items_));
}
 
template <typename T>
template <typename Predicate>
bool Queryable<T>::all(Predicate predicate) const {
  return std::all_of(items_.begin(), items_.end(), predicate);
}
 
template <typename T>
template <typename Predicate>
bool Queryable<T>::any(Predicate predicate) const {
  return std::any_of(items_.begin(), items_.end(), predicate);
}
 
template <typename T>
Queryable<T> Queryable<T>::difference(std::vector<T> rhs_items) {
  static_assert(
      traits::is_equality_comparable<T>::value,
      "T must be equality comparable.");
  // @todo Bubble up concepts for comparisons.
  std::vector<T> difference;
  std::set_difference(
      std::make_move_iterator(items_.begin()),
      std::make_move_iterator(items_.end()),
      std::make_move_iterator(rhs_items.begin()),
      std::make_move_iterator(rhs_items.end()), std::back_inserter(difference));
  return Queryable<T>(std::move(difference));
}
 
template <typename T>
Queryable<T> Queryable<T>::distinct() {
  static_assert(
      traits::is_equality_comparable<T>::value,
      "T must be equality comparable.");
  // @todo Reduce the number of transforms.
  std::set<T> distinguished(
      std::make_move_iterator(items_.begin()),
      std::make_move_iterator(items_.end()));
  return Queryable<T>(transforms::to_vector(std::move(distinguished)));
}
 
template <typename T>
bool Queryable<T>::empty() const {
  return items_.empty();
}
 
template <typename T>
template <typename Predicate>
std::optional<T> Queryable<T>::first_or_default(Predicate predicate) {
  // @todo Require predicate to be a unary operation.
  auto end = std::make_move_iterator(items_.end());
  auto it =
      std::find_if(std::make_move_iterator(items_.begin()), end, predicate);
  return it != end ? std::make_optional(*it) : std::nullopt;
}
 
template <typename T>
auto Queryable<T>::flatten() {
  // @todo asserts::invariant T is a vector.
  using U = T::value_type;
  std::vector<U> flattened;
  for (T &item : items_) {
    for (U &sub_item : item) {
      flattened.push_back(std::move(sub_item));
    }
  }
  return Queryable<U>(std::move(flattened));
}
 
template <typename T>
template <typename KeySelector>
Queryable<std::vector<T>> Queryable<T>::group_by(KeySelector key_selector) {
  using K = decltype(key_selector(*items_.begin()));
  static_assert(
      traits::is_less_than_comparable<K>::value,
      "Key selector must produce a value that is less-than comparable.");
 
  std::map<K, std::vector<T>> keyed_groups;
  std::for_each(
      std::make_move_iterator(items_.begin()),
      std::make_move_iterator(items_.end()), [&](auto item) {
        keyed_groups[key_selector(item)].push_back(std::move(item));
      });
 
  std::vector<std::vector<T>> groups;
  groups.resize(keyed_groups.size());
  std::transform(
      std::make_move_iterator(keyed_groups.begin()),
      std::make_move_iterator(keyed_groups.end()), groups.begin(),
      [this](std::pair<K, std::vector<T>> pair) {
        return std::move(pair.second);
      });
 
  return Queryable<std::vector<T>>(std::move(groups));
}
 
template <typename T>
Queryable<T> Queryable<T>::intersect(const std::vector<T> &rhs_items) {
  // @todo Investigate potential copies of rhs_items when set_intersection
  // called.
  std::vector<T> intersection;
  std::set_intersection(
      std::make_move_iterator(items_.begin()),
      std::make_move_iterator(items_.end()), rhs_items.begin(), rhs_items.end(),
      std::back_inserter(intersection));
  return Queryable<T>(std::move(intersection));
}
 
template <typename T>
template <typename U, typename LhsKeySelector, typename RhsKeySelector>
Queryable<std::tuple<T, U>> Queryable<T>::join(
    std::vector<U> rhs_items, LhsKeySelector lhs_key_selector,
    RhsKeySelector rhs_key_selector) {
  using KU = decltype(rhs_key_selector(*rhs_items.begin()));
  using KT = decltype(rhs_key_selector(*items_.begin()));
  static_assert(
      std::is_same<KU, KT>::value,
      "Left and right hand key selectors must produce the same type.");
 
  using K = KT;
  static_assert(
      traits::is_less_than_comparable<K>::value,
      "Key selectors must produce a type that is less-than compareable.");
 
  std::map<K, std::vector<U>> rhs_mapped;
  std::for_each(
      std::make_move_iterator(rhs_items.begin()),
      std::make_move_iterator(rhs_items.end()), [&, this](U rhs_item) {
        rhs_mapped[rhs_key_selector(rhs_item)].push_back(std::move(rhs_item));
      });
 
  std::vector<std::tuple<T, U>> joined;
  std::for_each(
      std::make_move_iterator(items_.begin()),
      std::make_move_iterator(items_.end()), [&, this](auto lhs_item) {
        auto lhs_key = lhs_key_selector(lhs_item);
        auto rhs_it = rhs_mapped.find(lhs_key);
        if (rhs_it != rhs_mapped.end()) {
          for (U &rhs_item : rhs_it->second) {
            joined.push_back({std::move(lhs_item), std::move(rhs_item)});
          }
        }
      });
 
  return Queryable<std::tuple<T, U>>(std::move(joined));
}
 
template <typename T>
template <typename KeySelector>
auto Queryable<T>::keyed_group_by(KeySelector key_selector) {
  using K = decltype(key_selector(*items_.begin()));
 
  std::map<K, std::vector<T>> mapped;
  for (int i = 0; i < items_.size(); i++) {
    // @todo Avoid a copy of items_[i] on key_selector call for large objects.
    mapped[key_selector(items_[i])].push_back(std::move(items_[i]));
  }
  return Queryable<std::pair<K, std::vector<T>>>(
      {std::make_move_iterator(mapped.begin()),
       std::make_move_iterator(mapped.end())});
}
 
template <typename T>
T Queryable<T>::max() {
  static_assert(
      traits::is_less_than_comparable<T>::value,
      "T must be less-than compareable.");
  asserts::invariant::eval(!items_.empty()) << "Sequence cannot be empty.";
 
  // @todo Investigate performance for large objects.
  return *std::max_element(
      std::make_move_iterator(items_.begin()),
      std::make_move_iterator(items_.end()));
}
 
template <typename T>
template <typename ValueSelector>
T Queryable<T>::max(ValueSelector value_selector) {
  static_assert(
      traits::is_less_than_comparable<decltype(value_selector(
          *items_.begin()))>::value,
      "ValueSelector return type must be less-than compareable.");
  asserts::invariant::eval(!items_.empty()) << "Sequence cannot be empty.";
  // @todo Require unary operation.
 
  return *std::max_element(
      std::make_move_iterator(items_.begin()),
      std::make_move_iterator(items_.end()),
      [&value_selector](const auto &lhs, const auto &rhs) {
        return value_selector(lhs) < value_selector(rhs);
      });
}
 
template <typename T>
T Queryable<T>::min() {
  static_assert(
      traits::is_less_than_comparable<T>::value,
      "T must be less-than compareable.");
  asserts::invariant::eval(!items_.empty()) << "Sequence cannot be empty.";
 
  // @todo Guard with concepts as seen in min_element.
  return *std::min_element(
      std::make_move_iterator(items_.begin()),
      std::make_move_iterator(items_.end()));
}
 
template <typename T>
template <typename ValueSelector /* = std::function<K(T)>*/>
T Queryable<T>::min(ValueSelector value_selector) {
  static_assert(
      traits::is_less_than_comparable<decltype(value_selector(
          *items_.begin()))>::value,
      "ValueSelector return type must be less-than compareable.");
  asserts::invariant::eval(!items_.empty()) << "Sequence cannot be empty.";
  // @todo Require unary operation.
 
  return *std::min_element(
      std::make_move_iterator(items_.begin()),
      std::make_move_iterator(items_.end()),
      [&value_selector](const auto &lhs, const auto &rhs) {
        return value_selector(lhs) < value_selector(rhs);
      });
}
 
template <typename T>
template <typename ValueSelector>
Queryable<T>
Queryable<T>::order_by(ValueSelector value_selector, bool descending) {
  static_assert(
      std::is_copy_assignable_v<T> ||
          (std::is_move_assignable_v<T> && std::is_move_constructible_v<T>),
      "T must either be copy assignable, or move assignable and "
      "constructible.");
  static_assert(
      traits::is_less_than_comparable<decltype(value_selector(
          *items_.begin()))>::value,
      "ValueSelector return type must be less-than compareable.");
 
  using K = decltype(value_selector(*items_.begin()));
  std::sort(
      items_.begin(), items_.end(),
      [&value_selector, descending](const auto &lhs, const auto &rhs) -> bool {
        const K &lhs_value = value_selector(lhs);
        const K &rhs_value = value_selector(rhs);
        return descending ? lhs_value > rhs_value : lhs_value < rhs_value;
      });
 
  return Queryable<T>(std::move(items_));
}
 
template <typename T>
Queryable<T> Queryable<T>::reverse() {
  std::reverse(items_.begin(), items_.end());
  return Queryable<T>(std::move(items_));
}
 
template <typename T>
template <typename Selector /* = std::function<U(T)>*/>
auto Queryable<T>::select(Selector selector) {
  using U = decltype(selector(*items_.begin()));
  std::vector<U> selected;
  selected.reserve(items_.size());
  std::transform(
      std::make_move_iterator(items_.begin()),
      std::make_move_iterator(items_.end()), std::back_inserter(selected),
      selector);
 
  return Queryable<U>(std::move(selected));
}
 
template <typename T>
Queryable<T> Queryable<T>::shuffle() {
  std::shuffle(
      items_.begin(), items_.end(), std::mt19937(std::random_device()()));
  return Queryable<T>(std::move(items_));
}
 
template <typename T>
size_t Queryable<T>::size() const {
  return items_.size();
}
 
template <typename T>
Queryable<T> Queryable<T>::skip(size_t value) {
  asserts::invariant::eval(value <= size())
      << "Skip value " << value
      << " must be less than or equal to sequence size of " << size() << ".";
 
  return Queryable<T>(
      {std::make_move_iterator(items_.begin() + value),
       std::make_move_iterator(items_.end())});
}
 
template <typename T>
Queryable<T>
Queryable<T>::slice(size_t start_index, size_t size, size_t stride) {
  asserts::invariant::eval(start_index < this->size())
      << "Slice start index " << start_index
      << " must be less than sequence size of " << this->size() << ".";
 
  size_t slice_length = (start_index - 1) + (size * stride);
  asserts::invariant::eval(stride == 0 || slice_length <= this->size())
      << "Slice length " << slice_length
      << " must be less than or equal to the sequence size of " << this->size()
      << ".";
 
  std::vector<T> sliced;
  sliced.reserve(size);
 
  int i = start_index;
  for (size_t current_size = 0; current_size < size; current_size++) {
    sliced.push_back(std::move(items_[i]));
    i += stride;
  }
 
  return Queryable<T>(std::move(sliced));
}
 
template <typename T>
Queryable<T> Queryable<T>::sort() {
  std::sort(items_.begin(), items_.end());
  return this;
}
 
template <typename T>
Queryable<T> Queryable<T>::take(size_t value) {
  asserts::invariant::eval(value <= size())
      << "Take value " << value
      << " must be less than or equal to sequence size of " << size() << ".";
 
  return Queryable<T>(
      {std::make_move_iterator(items_.begin()),
       std::make_move_iterator(items_.begin() + value)});
}
 
template <typename T>
Queryable<T> Queryable<T>::take_random(size_t value) {
  asserts::invariant::eval(value <= size())
      << "Take random value " << value
      << " must be less than or equal to sequence size of " << size() << ".";
 
  std::vector<int> indices;
  indices.reserve(items_.size());
  for (int i = 0; i < items_.size(); i++) {
    indices.push_back(i);
  }
  std::shuffle(
      indices.begin(), indices.end(), std::mt19937(std::random_device()()));
  indices.resize(value);
 
  std::vector<T> random_items;
  random_items.reserve(std::min(items_.size(), value));
  std::transform(
      indices.begin(), indices.end(), std::back_inserter(random_items),
      [this](int i) { return std::move(items_[i]); });
 
  return Queryable<T>(std::move(random_items));
}
 
template <typename T>
template <typename KeySelector /* = std::function<K(T)>*/>
auto Queryable<T>::to_multi_value_map(KeySelector key_selector) {
  using K = decltype(key_selector(*items_.begin()));
  std::map<K, std::vector<T>> mapped;
  std::for_each(items_.begin(), items_.end(), [&, this](auto &item) {
    mapped[key_selector(item)].push_back(std::move(item));
  });
  return mapped;
}
 
template <typename T>
template <typename KeySelector /* = std::function<K(T)>*/>
auto Queryable<T>::to_single_value_map(KeySelector key_selector) {
  using K = decltype(key_selector(*items_.begin()));
  static_assert(
      traits::is_less_than_comparable<K>::value,
      "KeySelector return type must be less-than compareable.");
 
  std::map<K, T> mapped;
  std::for_each(
      std::make_move_iterator(items_.begin()),
      std::make_move_iterator(items_.end()), [&, this](auto item) {
        K key = key_selector(item);
        auto it = mapped.find(key);
        if (it == mapped.end()) {
          mapped.insert({std::move(key), std::move(item)});
        }
      });
  return mapped;
}
 
template <typename T>
std::set<T> Queryable<T>::to_set() {
  static_assert(
      traits::is_less_than_comparable<T>::value,
      "T must be less-than compareable.");
  return std::set<T>(
      std::make_move_iterator(items_.begin()),
      std::make_move_iterator(items_.end()));
}
 
template <typename T>
std::vector<T> Queryable<T>::to_vector() {
  return std::move(items_);
}
 
template <typename T>
Queryable<T> Queryable<T>::trim(size_t size) {
  asserts::invariant(items_.size() <= size)
      << "Size " << size << " must be less than or equal to sequence size of "
      << this->size() << ".";
 
  items_.resize(items_.size() - size);
  return Queryable<T>(std::move(items_));
}
 
template <typename T>
Queryable<T> Queryable<T>::unionize(std::vector<T> rhs_items) {
  static_assert(
      traits::is_less_than_comparable<T>::value,
      "T must be less-than compareable.");
 
  std::set<T> unionized(
      std::make_move_iterator(items_.begin()),
      std::make_move_iterator(items_.end()));
  std::move(
      rhs_items.begin(), rhs_items.end(),
      std::inserter(unionized, unionized.end()));
 
  return Queryable<T>(transforms::to_vector(std::move(unionized)));
}
 
template <typename T>
template <typename Predicate>
Queryable<T> Queryable<T>::where(Predicate predicate) {
  std::vector<T> filtered;
  std::copy_if(
      std::make_move_iterator(items_.begin()),
      std::make_move_iterator(items_.end()), std::back_inserter(filtered),
      predicate);
  return Queryable<T>(std::move(filtered));
}
 
template <typename T>
template <typename U>
Queryable<std::tuple<T, U>>
Queryable<T>::zip(std::vector<U> rhs_items, bool truncate) {
  if (!truncate) {
    static_assert(
        std::is_default_constructible_v<T>,
        "T must have a default constructor so default values can "
        "populate the tuple.");
    static_assert(
        std::is_default_constructible_v<U>,
        "U must have a default constructor so default values can "
        "populate the tuple.");
  }
 
  std::vector<std::tuple<T, U>> zipped;
  zipped.reserve(
      truncate ? std::min({items_.size(), rhs_items.size()})
               : std::max({items_.size(), rhs_items.size()}));
 
  int i = 0;
  for (; i < std::min({items_.size(), rhs_items.size()}); i++) {
    zipped.push_back({std::move(items_[i]), std::move(rhs_items[i])});
  }
 
  if (truncate) {
    return Queryable<std::tuple<T, U>>(std::move(zipped));
  }
 
  if (items_.size() > rhs_items.size()) {
    for (; i < items_.size(); i++) {
      zipped.push_back({std::move(items_[i]), U()});
    }
  } else {
    for (; i < rhs_items.size(); i++) {
      zipped.push_back({T(), std::move(rhs_items[i])});
    }
  }
  return Queryable<std::tuple<T, U>>(std::move(zipped));
}
 
template <typename T>
template <typename U>
Queryable<std::tuple<T, U>>
Queryable<T>::zip(std::initializer_list<U> rhs_items, bool truncate) {
  return zip(std::vector<U>(std::move(rhs_items)), truncate);
}
 
template <typename TrueT, typename FalseT>
class Merge {
public:
  explicit Merge(Queryable<TrueT> true_queried, Queryable<FalseT> false_queried)
      : true_queried_(std::move(true_queried)),
        false_queried_(std::move(false_queried)) {}
  Merge() = delete;
  virtual ~Merge() = default;
  Merge(const Merge &) = delete;
  Merge &operator=(const Merge &) = delete;
 
  // Merges the true and false branches as a zip.
  Queryable<std::tuple<TrueT, FalseT>> merge(bool truncate = false) {
    return true_queried_.zip(std::move(false_queried_.to_vector()), truncate);
  }
 
private:
  Queryable<TrueT> true_queried_;
  Queryable<FalseT> false_queried_;
};
 
template <typename WhenTrueQueriedT, typename T>
class WhenFalse {
public:
  explicit WhenFalse(
      Queryable<WhenTrueQueriedT> when_true_queried,
      std::vector<T> when_false_items)
      : when_true_queried_(std::move(when_true_queried)),
        when_false_items_(std::move(when_false_items)) {}
  WhenFalse() = delete;
  virtual ~WhenFalse() = default;
  WhenFalse(const WhenFalse &) = delete;
  WhenFalse &operator=(const WhenFalse &) = delete;
 
  // Queries the false branched items from the Queryable<T>::branch predicate.
  template <
      typename WhenFalseQuery /* =
                                 std::function<Queryable<WhenFalseQueriedT>(Queryable<T>&)>
                               */
      ,
      typename WhenFalseQueriedT =
          std::invoke_result_t<WhenFalseQuery, Queryable<T>>::item_type>
  Merge<WhenTrueQueriedT, WhenFalseQueriedT>
  when_false(WhenFalseQuery when_false_query) {
    return Merge<WhenTrueQueriedT, WhenFalseQueriedT>(
        Queryable<WhenTrueQueriedT>(when_true_queried_.to_vector()),
        when_false_query(Queryable<T>(std::move(when_false_items_))));
  }
 
private:
  Queryable<WhenTrueQueriedT> when_true_queried_;
  std::vector<T> when_false_items_;
};
 
// True branch from the Queryable<T>::branch predicate.
template <typename T>
class WhenTrue {
public:
  explicit WhenTrue(
      std::vector<T> when_true_items, std::vector<T> when_false_items)
      : when_true_items_(std::move(when_true_items)),
        when_false_items_(std::move(when_false_items)) {}
  WhenTrue() = delete;
  virtual ~WhenTrue() = default;
  WhenTrue(const WhenTrue &) = delete;
  WhenTrue &operator=(const WhenTrue &) = delete;
 
  // Queries the true branched items from the Queryable<T>::branch predicate.
  template <
      typename WhenTrueQuery /* =
                                std::function<Queryable<WhenTrueQueriedT>(Queryable<T>)>
                              */
      ,
      typename WhenTrueQueriedT =
          std::invoke_result_t<WhenTrueQuery, Queryable<T>>::item_type>
  WhenFalse<WhenTrueQueriedT, T> when_true(WhenTrueQuery when_true_query) {
    return WhenFalse<WhenTrueQueriedT, T>(
        std::move(when_true_query(Queryable<T>(std::move(when_true_items_)))),
        std::move(when_false_items_));
  }
 
private:
  std::vector<T> when_true_items_;
  std::vector<T> when_false_items_;
};
 
template <typename T>
template <typename Predicate>
WhenTrue<T> Queryable<T>::branch(Predicate predicate) {
  std::vector<T> when_true_items;
  std::vector<T> when_false_items;
  std::for_each(
      std::make_move_iterator(items_.begin()),
      std::make_move_iterator(items_.end()), [&](auto item) {
        if (predicate(item)) {
          when_true_items.push_back(std::move(item));
        } else {
          when_false_items.push_back(std::move(item));
        }
      });
 
  return WhenTrue<T>(std::move(when_true_items), std::move(when_false_items));
}
 
} // namespace fcpp
 
#endif // FCPP_QUERY_H