functional.hpp

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <functional>  // 可能有用,但compose本身不需要 / Potentially useful, though not strictly required by compose itself
#include <iostream>
#include <iterator>
#include <map>
#include <memory>  // std::shared_ptr, std::make_shared
#include <mutex>  // std::mutex
#include <numeric>
#include <optional>
#include <stdexcept>
#include <string>
#include <type_traits>  // std::invoke_result_t, std::decay_t
#include <typeinfo>
#include <utility>  // std::forward, std::move
#include <variant>
 
#include <cpp-toolbox/cpp-toolbox_export.hpp>
 
#define CPP_TOOLBOX_DEFINE_SIMPLE_FUNCTOR( \
    FunctorName, ReturnType, Params, Body) \
  struct FunctorName \
  { \
    ReturnType operator() Params const \
    { \
      Body \
    } \
  };
 
namespace toolbox::functional
{
 
namespace detail
{
template<class... Fs>
struct overloaded : Fs...
{
  using Fs::operator()...;  // C++17 using包声明 / C++17 using pack declaration
};
 
// C++17类模板参数推导指南 / C++17 class template argument deduction guide
// 允许写overloaded{lambda1, lambda2}而不需要显式模板参数 / Allows writing
// overloaded{lambda1, lambda2} without explicit template args
template<class... Fs>
overloaded(Fs...) -> overloaded<Fs...>;
 
template<typename T>
struct is_optional : std::false_type
{
};
 
template<typename T>
struct is_optional<std::optional<T>> : std::true_type
{
};
 
template<typename T>
inline constexpr bool is_optional_v = is_optional<std::decay_t<T>>::value;
 
template<typename T, typename = void>
struct has_size : std::false_type
{
};
 
template<typename T>
struct has_size<T, std::void_t<decltype(std::declval<T>().size())>>
    : std::true_type
{
};
 
template<typename... Containers>
auto get_min_size(const Containers&... containers) -> size_t
{
  if constexpr (sizeof...(containers) == 0) {
    return 0;  // 显式处理空包 / Handle empty pack explicitly
  } else {
    return std::min({static_cast<size_t>(containers.size())...});
  }
}
 
template<typename Tuple, std::size_t... Is>
void increment_iterators(Tuple& iter_tuple, std::index_sequence<Is...>)
{
  (++(std::get<Is>(iter_tuple)), ...);
}
 
template<typename Tuple, std::size_t... Is>
auto dereference_iterators_as_tuple(Tuple& iter_tuple,
                                    std::index_sequence<Is...>)
{
  return std::forward_as_tuple(*(std::get<Is>(iter_tuple))...);
}
 
template<typename Func, typename R, typename... Args>
struct MemoizeState
{
  using KeyType = std::tuple<std::decay_t<Args>...>;
  using ResultType = R;
 
  Func original_func;
  std::map<KeyType, ResultType> cache;
  std::mutex cache_mutex;
 
  MemoizeState(Func&& f)
      : original_func(std::forward<Func>(f))
  {
  }
};
}  // namespace detail
 
template<typename G, typename F>
CPP_TOOLBOX_EXPORT auto compose(G&& g, F&& f);
 
template<typename F1, typename... FRest>
CPP_TOOLBOX_EXPORT auto compose(F1&& f1, FRest&&... rest);
 
inline CPP_TOOLBOX_EXPORT auto compose();
 
template<typename F, typename Arg1>
CPP_TOOLBOX_EXPORT auto bind_first(F&& f, Arg1&& arg1);
 
template<typename T, typename F>
CPP_TOOLBOX_EXPORT auto map(const std::optional<T>& opt, F&& f)
    -> std::optional<std::invoke_result_t<F, const T&>>;
 
template<typename T, typename F>
CPP_TOOLBOX_EXPORT auto map(std::optional<T>&& opt, F&& f)
    -> std::optional<std::invoke_result_t<F, T&&>>;
 
template<typename T, typename F>
CPP_TOOLBOX_EXPORT auto flatMap(const std::optional<T>& opt, F&& f)
    -> std::invoke_result_t<F, const T&>;
 
template<typename T, typename F>
CPP_TOOLBOX_EXPORT auto flatMap(std::optional<T>&& opt, F&& f)
    -> std::invoke_result_t<F, T&&>;
 
template<typename T, typename U>
CPP_TOOLBOX_EXPORT auto orElse(const std::optional<T>& opt, U&& default_value)
    -> T;
 
template<typename T, typename F>
CPP_TOOLBOX_EXPORT auto orElseGet(const std::optional<T>& opt, F&& default_func)
    -> T;
 
template<typename T, typename P>
CPP_TOOLBOX_EXPORT auto filter(const std::optional<T>& opt, P&& p)
    -> std::optional<T>;
 
template<typename T, typename P>
CPP_TOOLBOX_EXPORT auto filter(std::optional<T>&& opt, P&& p)
    -> std::optional<T>;
 
template<typename... Ts, typename... Fs>
CPP_TOOLBOX_EXPORT auto match(const std::variant<Ts...>& var, Fs&&... visitors)
    -> decltype(auto);
 
template<typename... Ts, typename... Fs>
CPP_TOOLBOX_EXPORT auto match(std::variant<Ts...>& var, Fs&&... visitors)
    -> decltype(auto);
 
template<typename... Ts, typename... Fs>
CPP_TOOLBOX_EXPORT auto match(std::variant<Ts...>&& var, Fs&&... visitors)
    -> decltype(auto);
 
template<typename ResultVariant, typename... Ts, typename F>
CPP_TOOLBOX_EXPORT auto map(const std::variant<Ts...>& var, F&& f)
    -> ResultVariant;
 
template<typename ResultVariant, typename... Ts, typename F>
CPP_TOOLBOX_EXPORT auto map(std::variant<Ts...>& var, F&& f) -> ResultVariant;
 
template<typename ResultVariant, typename... Ts, typename F>
CPP_TOOLBOX_EXPORT auto map(std::variant<Ts...>&& var, F&& f) -> ResultVariant;
 
template<typename Container, typename Func>
CPP_TOOLBOX_EXPORT auto map(const Container& input, Func&& f) -> std::vector<
    std::invoke_result_t<Func, typename Container::const_reference>>;
 
template<typename Container, typename Predicate>
CPP_TOOLBOX_EXPORT auto filter(const Container& input, Predicate&& p)
    -> std::vector<typename Container::value_type>;
 
template<typename Container, typename T, typename BinaryOp>
CPP_TOOLBOX_EXPORT auto reduce(const Container& input,
                               T identity,
                               BinaryOp&& op) -> T;
 
template<typename Container, typename BinaryOp>
CPP_TOOLBOX_EXPORT auto reduce(const Container& input, BinaryOp&& op) ->
    typename Container::value_type;
 
template<typename... Containers>
CPP_TOOLBOX_EXPORT auto zip(const Containers&... containers) -> std::vector<
    std::tuple<decltype(*std::cbegin(std::declval<const Containers&>()))...>>;
 
template<typename ContainerKeys,
         typename ContainerValues,
         typename Key = typename std::decay_t<ContainerKeys>::value_type,
         typename Value = typename std::decay_t<ContainerValues>::value_type,
         typename Hash = std::hash<Key>,
         typename KeyEqual = std::equal_to<Key>,
         typename Alloc = std::allocator<std::pair<const Key, Value>>>
CPP_TOOLBOX_EXPORT auto zip_to_unordered_map(const ContainerKeys& keys,
                                             const ContainerValues& values)
    -> std::unordered_map<Key, Value, Hash, KeyEqual, Alloc>;
 
template<typename Signature>
class CPP_TOOLBOX_EXPORT MemoizedFunction;  // 前向声明 / Forward declaration
 
template<typename R, typename... Args>
class CPP_TOOLBOX_EXPORT MemoizedFunction<R(Args...)>
{
private:
  using FuncType = std::function<R(Args...)>;
  using KeyType = std::tuple<std::decay_t<Args>...>;
  using ResultType = R;
 
  // 使用pimpl惯用法或shared_ptr隐藏实现细节 / Use pimpl idiom or shared_ptr to
  // hide implementation details 这避免在头文件中包含<map>和<mutex> / This
  // avoids including <map> and <mutex> in the header
  struct State;  // 前向声明状态结构 / Forward declare the state struct
  std::shared_ptr<State>
      state_;  // 指向实现状态的指针 / Pointer to implementation state
 
public:
  explicit MemoizedFunction(FuncType f);
 
  MemoizedFunction(const MemoizedFunction&) = delete;
  MemoizedFunction& operator=(const MemoizedFunction&) = delete;
  // 允许移动 / Allow moving
  MemoizedFunction(MemoizedFunction&&) noexcept = default;
  MemoizedFunction& operator=(MemoizedFunction&&) noexcept = default;
 
  auto operator()(Args... args) -> ResultType;
};
 
template<typename Signature, typename Func>
CPP_TOOLBOX_EXPORT auto memoize(Func&& f);
 
template<typename R, typename... Args, typename Func>
CPP_TOOLBOX_EXPORT auto memoize_explicit(Func&& f) -> std::function<R(Args...)>;
 
}  // namespace toolbox::functional
 
#include <cpp-toolbox/functional/impl/functional_impl.hpp>