From 2508fab7d7ed4a0cdd7ad570e5ca5a5829aa0d05 Mon Sep 17 00:00:00 2001
From: Steven WdV <>
Date: Tue, 16 Jan 2024 13:31:52 +0100
Subject: [PATCH] Fix C++20 compatibility Closes ReactiveX#602

---
 Rx/v2/src/rxcpp/rx-util.hpp | 150 +++++++++++++++++-------------------
 1 file changed, 72 insertions(+), 78 deletions(-)

diff --git a/Rx/v2/src/rxcpp/rx-util.hpp b/Rx/v2/src/rxcpp/rx-util.hpp
index d76fa76a1..c98953c87 100644
--- a/Rx/v2/src/rxcpp/rx-util.hpp
+++ b/Rx/v2/src/rxcpp/rx-util.hpp
@@ -28,6 +28,8 @@
 
 #define RXCPP_MAKE_IDENTIFIER(Prefix) RXCPP_CONCAT_EVALUATE(Prefix, __LINE__)
 
+#define RXCPP_DECLVAL(...) static_cast<__VA_ARGS__ (*)() noexcept>(nullptr)()
+
 // Provide replacements for try/catch keywords, using which is a compilation error
 // when exceptions are disabled with -fno-exceptions.
 #if RXCPP_USE_EXCEPTIONS
@@ -46,18 +48,13 @@ namespace util {
 
 template<class T> using value_type_t = typename std::decay<T>::type::value_type;
 template<class T> using decay_t = typename std::decay<T>::type;
-#ifdef __cpp_lib_is_invocable
-template <class> struct result_of;
 
-template <class F, class... TN>
-struct result_of<F(TN...)>
-{
-    using type = std::invoke_result_t<F, TN...>;
+template <typename Fn, typename... ArgTypes>
+struct callable_result {
+    using type = decltype(RXCPP_DECLVAL(Fn&&)(RXCPP_DECLVAL(ArgTypes&&)...));
 };
-#else
-template<class... TN> using result_of = std::result_of<TN...>;
-#endif
-template<class... TN> using result_of_t = typename result_of<TN...>::type;
+template <typename Fn, typename... ArgTypes>
+using callable_result_t = typename callable_result<Fn, ArgTypes...>::type;
 
 template<class T, std::size_t size>
 std::vector<T> to_vector(const T (&arr) [size]) {
@@ -70,7 +67,7 @@ std::vector<T> to_vector(std::initializer_list<T> il) {
 }
 
 template<class T0, class... TN>
-typename std::enable_if<!std::is_array<T0>::value && std::is_pod<T0>::value, std::vector<T0>>::type to_vector(T0 t0, TN... tn) {
+typename std::enable_if<!std::is_array<T0>::value && std::is_trivial<T0>::value && std::is_standard_layout<T0>::value, std::vector<T0>>::type to_vector(T0 t0, TN... tn) {
     return to_vector({t0, tn...});
 }
 
@@ -93,13 +90,13 @@ struct values_from;
 template<class T, T Step, T Cursor, T... ValueN>
 struct values_from<T, 0, Step, Cursor, ValueN...>
 {
-    typedef values<T, ValueN...> type;
+    using type = values<T, ValueN...>;
 };
 
 template<class T, std::size_t Remaining, T Step, T Cursor, T... ValueN>
 struct values_from
 {
-    typedef typename values_from<T, Remaining - 1, Step, Cursor + Step, ValueN..., Cursor>::type type;
+    using type = typename values_from<T, Remaining - 1, Step, Cursor + Step, ValueN..., Cursor>::type;
 };
 
 template<bool... BN>
@@ -138,30 +135,30 @@ using enable_if_all_true_type_t = typename std::enable_if<all_true_type<BN...>::
 
 struct all_values_true {
     template<class... ValueN>
-    bool operator()(ValueN... vn) const;
+    bool operator()(const ValueN&... vn) const;
 
     template<class Value0>
-    bool operator()(Value0 v0) const {
+    bool operator()(const Value0& v0) const {
         return v0;
     }
 
     template<class Value0, class... ValueN>
-    bool operator()(Value0 v0, ValueN... vn) const {
+    bool operator()(const Value0& v0, const ValueN&... vn) const {
         return v0 && all_values_true()(vn...);
     }
 };
 
 struct any_value_true {
     template<class... ValueN>
-    bool operator()(ValueN... vn) const;
+    bool operator()(const ValueN&... vn) const;
 
     template<class Value0>
-    bool operator()(Value0 v0) const {
+    bool operator()(const Value0& v0) const {
         return v0;
     }
 
     template<class Value0, class... ValueN>
-    bool operator()(Value0 v0, ValueN... vn) const {
+    bool operator()(const Value0& v0, const ValueN&... vn) const {
         return v0 || any_value_true()(vn...);
     }
 };
@@ -177,11 +174,11 @@ struct types {};
 struct types_checked {};
 
 namespace detail {
-template<class... TN> struct types_checked_from {typedef types_checked type;};
+template<class... TN> struct types_checked_from { using type = types_checked; };
 }
 
 template<class... TN>
-struct types_checked_from {typedef typename detail::types_checked_from<TN...>::type type;};
+struct types_checked_from { using type = typename detail::types_checked_from<TN...>::type; };
 
 template<class... TN>
 using types_checked_t = typename types_checked_from<TN...>::type;
@@ -199,17 +196,17 @@ using value_types_t = typename expand_value_types<types<TN...>>::type;
 
 
 template<class T, class C = types_checked>
-struct value_type_from : public std::false_type {typedef types_checked type;};
+struct value_type_from : public std::false_type { using type = types_checked; };
 
 template<class T>
 struct value_type_from<T, typename types_checked_from<value_type_t<T>>::type>
-    : public std::true_type {typedef value_type_t<T> type;};
+    : public std::true_type { using type = value_type_t<T>; };
 
 namespace detail {
-template<class F, class... ParamN, int... IndexN>
-auto apply(std::tuple<ParamN...> p, values<int, IndexN...>, F&& f)
-    -> decltype(f(std::forward<ParamN>(std::get<IndexN>(p))...)) {
-    return      f(std::forward<ParamN>(std::get<IndexN>(p))...);
+template<class F, class Tuple, int... IndexN>
+auto apply(Tuple&& p, values<int, IndexN...>, F&& f)
+    -> decltype(f(std::get<IndexN>(std::forward<Tuple>(p))...)) {
+    return      f(std::get<IndexN>(std::forward<Tuple>(p))...);
 }
 
 template<class F_inner, class F_outer, class... ParamN, int... IndexN>
@@ -226,11 +223,17 @@ auto apply_to_each(std::tuple<ParamN...>& p, values<int, IndexN...>, const F_inn
 
 }
 template<class F, class... ParamN>
-auto apply(std::tuple<ParamN...> p, F&& f)
+auto apply(std::tuple<ParamN...>&& p, F&& f)
     -> decltype(detail::apply(std::move(p), typename values_from<int, sizeof...(ParamN)>::type(), std::forward<F>(f))) {
     return      detail::apply(std::move(p), typename values_from<int, sizeof...(ParamN)>::type(), std::forward<F>(f));
 }
 
+template<class F, class... ParamN>
+auto apply(const std::tuple<ParamN...>& p, F&& f)
+    -> decltype(detail::apply(p, typename values_from<int, sizeof...(ParamN)>::type(), std::forward<F>(f))) {
+    return      detail::apply(p, typename values_from<int, sizeof...(ParamN)>::type(), std::forward<F>(f));
+}
+
 template<class F_inner, class F_outer, class... ParamN>
 auto apply_to_each(std::tuple<ParamN...>& p, F_inner& f_inner, F_outer& f_outer)
     -> decltype(detail::apply_to_each(p, typename values_from<int, sizeof...(ParamN)>::type(), f_inner, f_outer)) {
@@ -304,14 +307,9 @@ template<int Index>
 struct take_at
 {
     template<class... ParamN>
-    auto operator()(ParamN... pn)
-        -> typename std::tuple_element<Index, std::tuple<decay_t<ParamN>...>>::type {
-        return                std::get<Index>(std::make_tuple(std::move(pn)...));
-    }
-    template<class... ParamN>
-    auto operator()(ParamN... pn) const
+    auto operator()(const ParamN&... pn) const
         -> typename std::tuple_element<Index, std::tuple<decay_t<ParamN>...>>::type {
-        return                std::get<Index>(std::make_tuple(std::move(pn)...));
+        return                std::get<Index>(std::tie(pn...));
     }
 };
 
@@ -332,13 +330,13 @@ struct defer_trait
     template<bool R>
     struct tag_valid {static const bool valid = true; static const bool value = R;};
     struct tag_not_valid {static const bool valid = false; static const bool value = false;};
-    typedef Deferred<typename resolve_type<AN>::type...> resolved_type;
+    using resolved_type = Deferred<typename resolve_type<AN>::type...>;
     template<class... CN>
     static auto check(int) -> tag_valid<resolved_type::value>;
     template<class... CN>
     static tag_not_valid check(...);
 
-    typedef decltype(check<AN...>(0)) tag_type;
+    using tag_type = decltype(check<AN...>(0));
     static const bool valid = tag_type::valid;
     static const bool value = tag_type::value;
     static const bool not_value = valid && !value;
@@ -348,16 +346,16 @@ template <template<class... TN> class Deferred, class... AN>
 struct defer_type
 {
     template<class R>
-    struct tag_valid {typedef R type; static const bool value = true;};
-    struct tag_not_valid {typedef void type; static const bool value = false;};
-    typedef Deferred<typename resolve_type<AN>::type...> resolved_type;
+    struct tag_valid { using type = R; static const bool value = true;};
+    struct tag_not_valid { using type = void; static const bool value = false;};
+    using resolved_type = Deferred<typename resolve_type<AN>::type...>;
     template<class... CN>
     static auto check(int) -> tag_valid<resolved_type>;
     template<class... CN>
     static tag_not_valid check(...);
 
-    typedef decltype(check<AN...>(0)) tag_type;
-    typedef typename tag_type::type type;
+    using tag_type = decltype(check<AN...>(0));
+    using type = typename tag_type::type;
     static const bool value = tag_type::value;
 };
 
@@ -365,16 +363,16 @@ template <template<class... TN> class Deferred, class... AN>
 struct defer_value_type
 {
     template<class R>
-    struct tag_valid {typedef R type; static const bool value = true;};
-    struct tag_not_valid {typedef void type; static const bool value = false;};
-    typedef Deferred<typename resolve_type<AN>::type...> resolved_type;
+    struct tag_valid { using type = R; static const bool value = true;};
+    struct tag_not_valid { using type = void; static const bool value = false;};
+    using resolved_type = Deferred<typename resolve_type<AN>::type...>;
     template<class... CN>
     static auto check(int) -> tag_valid<value_type_t<resolved_type>>;
     template<class... CN>
     static tag_not_valid check(...);
 
-    typedef decltype(check<AN...>(0)) tag_type;
-    typedef typename tag_type::type type;
+    using tag_type = decltype(check<AN...>(0));
+    using type = typename tag_type::type;
     static const bool value = tag_type::value;
 };
 
@@ -382,38 +380,38 @@ template <template<class... TN> class Deferred, class... AN>
 struct defer_seed_type
 {
     template<class R>
-    struct tag_valid {typedef R type; static const bool value = true;};
-    struct tag_not_valid {typedef void type; static const bool value = false;};
-    typedef Deferred<typename resolve_type<AN>::type...> resolved_type;
+    struct tag_valid { using type = R; static const bool value = true;};
+    struct tag_not_valid { using type = void; static const bool value = false;};
+    using resolved_type = Deferred<typename resolve_type<AN>::type...>;
     template<class... CN>
     static auto check(int) -> tag_valid<typename resolved_type::seed_type>;
     template<class... CN>
     static tag_not_valid check(...);
 
-    typedef decltype(check<AN...>(0)) tag_type;
-    typedef typename tag_type::type type;
+    using tag_type = decltype(check<AN...>(0));
+    using type = typename tag_type::type;
     static const bool value = tag_type::value;
 };
 
 template <class D>
 struct resolve_type
 {
-    typedef D type;
+    using type = D;
 };
 template <template<class... TN> class Deferred, class... AN>
 struct resolve_type<defer_type<Deferred, AN...>>
 {
-    typedef typename defer_type<Deferred, AN...>::type type;
+    using type = typename defer_type<Deferred, AN...>::type;
 };
 template <template<class... TN> class Deferred, class... AN>
 struct resolve_type<defer_value_type<Deferred, AN...>>
 {
-    typedef typename defer_value_type<Deferred, AN...>::type type;
+    using type = typename defer_value_type<Deferred, AN...>::type;
 };
 template <template<class... TN> class Deferred, class... AN>
 struct resolve_type<defer_seed_type<Deferred, AN...>>
 {
-    typedef typename defer_seed_type<Deferred, AN...>::type type;
+    using type = typename defer_seed_type<Deferred, AN...>::type;
 };
 
 struct plus
@@ -579,13 +577,20 @@ class maybe
     {
     }
 
-    maybe(T value)
+    maybe(const T& value)
     : is_set(false)
     {
         new (reinterpret_cast<T*>(&storage)) T(value);
         is_set = true;
     }
 
+    maybe(T&& value)
+    : is_set(false)
+    {
+        new (reinterpret_cast<T*>(&storage)) T(std::move(value));
+        is_set = true;
+    }
+
     maybe(const maybe& other)
     : is_set(false)
     {
@@ -609,9 +614,9 @@ class maybe
         reset();
     }
 
-    typedef T value_type;
-    typedef T* iterator;
-    typedef const T* const_iterator;
+    using value_type = T;
+    using iterator = T *;
+    using const_iterator = const T *;
 
     bool empty() const {
         return !is_set;
@@ -699,12 +704,7 @@ namespace detail {
     struct surely
     {
         template<class... T>
-        auto operator()(T... t)
-            -> decltype(std::make_tuple(t.get()...)) {
-            return      std::make_tuple(t.get()...);
-        }
-        template<class... T>
-        auto operator()(T... t) const
+        auto operator()(const T&... t) const
             -> decltype(std::make_tuple(t.get()...)) {
             return      std::make_tuple(t.get()...);
         }
@@ -831,7 +831,7 @@ struct is_duration : detail::is_duration<Decayed> {};
 // C++17 negation
 namespace detail {
     template<class T>
-    struct not_value : std::conditional<T::value, std::false_type, std::true_type>::type {
+    struct not_value : std::conditional_t<T::value, std::false_type, std::true_type> {
     };
 }
 
@@ -996,22 +996,16 @@ struct filtered_hash<T, typename std::enable_if<rxu::is_string<T>::value>::type>
 };
 template <class T>
 struct filtered_hash<T, typename std::enable_if<std::is_convertible<T, std::chrono::duration<typename T::rep, typename T::period>>::value>::type> {
-    using argument_type = T;
-    using result_type = std::size_t;
-
-    result_type operator()(argument_type const & dur) const
+    std::size_t operator()(T const & dur) const
     {
-        return std::hash<typename argument_type::rep>{}(dur.count());
+        return std::hash<typename T::rep>{}(dur.count());
     }
 };
 template <class T>
 struct filtered_hash<T, typename std::enable_if<std::is_convertible<T, std::chrono::time_point<typename T::clock, typename T::duration>>::value>::type> {
-    using argument_type = T;
-    using result_type = std::size_t;
-
-    result_type operator()(argument_type const & tp) const
+    std::size_t operator()(T const & tp) const
     {
-        return std::hash<typename argument_type::rep>{}(tp.time_since_epoch().count());
+        return std::hash<typename T::rep>{}(tp.time_since_epoch().count());
     }
 };
 
@@ -1024,7 +1018,7 @@ struct is_hashable<T,
     typename rxu::types_checked_from<
         typename filtered_hash<T>::result_type,
         typename filtered_hash<T>::argument_type,
-        typename rxu::result_of<filtered_hash<T>(T)>::type>::type>
+        typename rxu::callable_result<filtered_hash<T>, T>::type>::type>
     : std::true_type {};
 
 }