From adccb3a8a6ebc6557e42bf5b7874789b319abfee Mon Sep 17 00:00:00 2001
From: Aleksey Loginov <victimsnino@gmail.com>
Date: Sat, 6 Jan 2024 00:19:10 +0300
Subject: [PATCH 1/7] Proper forwarding for subjects

---
 src/rpp/rpp/subjects/fwd.hpp                | 22 ++-------------------
 src/rpp/rpp/subjects/publish_subject.hpp    | 20 ++++++++++++++++++-
 src/rpp/rpp/subjects/serialized_subject.hpp | 14 ++++++++++++-
 3 files changed, 34 insertions(+), 22 deletions(-)

diff --git a/src/rpp/rpp/subjects/fwd.hpp b/src/rpp/rpp/subjects/fwd.hpp
index bc55f27e6..27b90b975 100644
--- a/src/rpp/rpp/subjects/fwd.hpp
+++ b/src/rpp/rpp/subjects/fwd.hpp
@@ -38,29 +38,11 @@ class serialized_strategy;
 
 namespace rpp::subjects
 {
-/**
- * @brief Subject which just multicasts values to observers subscribed on it. It contains two parts: observer and observable at the same time.
- *
- * @details Each observer obtains only values which emitted after corresponding subscribe. on_error/on_completer/unsubscribe cached and provided to new observers if any
- *
- * @warning this subject is not synchronized/serialized! It means, that expected to call callbacks of observer in the serialized way to follow observable contract: "Observables must issue notifications to observers serially (not in parallel).". If you are not sure or need extra serialization, please, use serialized_subject.
- *
- * @tparam Type value provided by this subject
- *
- * @ingroup subjects
- * @see https://reactivex.io/documentation/subject.html
- */
 template<rpp::constraint::decayed_type Type>
-using publish_subject = details::base_subject<Type, details::publish_strategy<Type>>;
+class publish_subject;
 
-/**
- * @brief Same as rpp::subjects::publish_subject, but on_next/on_error/on_completed calls are serialized via mutex
- *
- * @ingroup subjects
- * @see https://reactivex.io/documentation/subject.html
- */
 template<rpp::constraint::decayed_type Type>
-using serialized_subject = details::base_subject<Type, details::serialized_strategy<Type>>;
+class serialized_subject;
 }
 
 namespace rpp::subjects::utils
diff --git a/src/rpp/rpp/subjects/publish_subject.hpp b/src/rpp/rpp/subjects/publish_subject.hpp
index 427e8c763..9461e73eb 100644
--- a/src/rpp/rpp/subjects/publish_subject.hpp
+++ b/src/rpp/rpp/subjects/publish_subject.hpp
@@ -61,4 +61,22 @@ class publish_strategy
 private:
     std::shared_ptr<subject_state<Type>> m_state = std::make_shared<subject_state<Type>>();
 };
-} // namespace rpp::subjects::details
\ No newline at end of file
+} // namespace rpp::subjects::details
+
+namespace rpp::subjects 
+{
+/**
+ * @brief Subject which just multicasts values to observers subscribed on it. It contains two parts: observer and observable at the same time.
+ *
+ * @details Each observer obtains only values which emitted after corresponding subscribe. on_error/on_completer/unsubscribe cached and provided to new observers if any
+ *
+ * @warning this subject is not synchronized/serialized! It means, that expected to call callbacks of observer in the serialized way to follow observable contract: "Observables must issue notifications to observers serially (not in parallel).". If you are not sure or need extra serialization, please, use serialized_subject.
+ *
+ * @tparam Type value provided by this subject
+ *
+ * @ingroup subjects
+ * @see https://reactivex.io/documentation/subject.html
+ */
+template<rpp::constraint::decayed_type Type>
+class publish_subject final : public details::base_subject<Type, details::publish_strategy<Type>>{};
+}
\ No newline at end of file
diff --git a/src/rpp/rpp/subjects/serialized_subject.hpp b/src/rpp/rpp/subjects/serialized_subject.hpp
index b9f8911ff..48c955cec 100644
--- a/src/rpp/rpp/subjects/serialized_subject.hpp
+++ b/src/rpp/rpp/subjects/serialized_subject.hpp
@@ -82,4 +82,16 @@ class serialized_strategy
 private:
     std::shared_ptr<serialized_state> m_state = std::make_shared<serialized_state>();
 };
-} // namespace rpp::subjects::details
\ No newline at end of file
+} // namespace rpp::subjects::details
+
+namespace rpp::subjects
+{
+/**
+ * @brief Same as rpp::subjects::publish_subject, but on_next/on_error/on_completed calls are serialized via mutex
+ *
+ * @ingroup subjects
+ * @see https://reactivex.io/documentation/subject.html
+ */
+template<rpp::constraint::decayed_type Type>
+class serialized_subject final : public details::base_subject<Type, details::serialized_strategy<Type>>{};
+}
\ No newline at end of file

From 9d6e3a3acfec2b410033c50405485a669e55bfdd Mon Sep 17 00:00:00 2001
From: Aleksey Loginov <victimsnino@gmail.com>
Date: Sat, 6 Jan 2024 01:05:47 +0300
Subject: [PATCH 2/7] allow ctor

---
 src/rpp/rpp/subjects/publish_subject.hpp    | 6 +++++-
 src/rpp/rpp/subjects/serialized_subject.hpp | 6 +++++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/rpp/rpp/subjects/publish_subject.hpp b/src/rpp/rpp/subjects/publish_subject.hpp
index 9461e73eb..bbdb170d9 100644
--- a/src/rpp/rpp/subjects/publish_subject.hpp
+++ b/src/rpp/rpp/subjects/publish_subject.hpp
@@ -78,5 +78,9 @@ namespace rpp::subjects
  * @see https://reactivex.io/documentation/subject.html
  */
 template<rpp::constraint::decayed_type Type>
-class publish_subject final : public details::base_subject<Type, details::publish_strategy<Type>>{};
+class publish_subject final : public details::base_subject<Type, details::publish_strategy<Type>>
+{
+public:
+    using details::base_subject<Type, details::publish_strategy<Type>>::base_subject;
+};
 }
\ No newline at end of file
diff --git a/src/rpp/rpp/subjects/serialized_subject.hpp b/src/rpp/rpp/subjects/serialized_subject.hpp
index 48c955cec..76b28d536 100644
--- a/src/rpp/rpp/subjects/serialized_subject.hpp
+++ b/src/rpp/rpp/subjects/serialized_subject.hpp
@@ -93,5 +93,9 @@ namespace rpp::subjects
  * @see https://reactivex.io/documentation/subject.html
  */
 template<rpp::constraint::decayed_type Type>
-class serialized_subject final : public details::base_subject<Type, details::serialized_strategy<Type>>{};
+class serialized_subject final : public details::base_subject<Type, details::serialized_strategy<Type>>
+{
+public:
+    using details::base_subject<Type, details::serialized_strategy<Type>>::base_subject;
+};
 }
\ No newline at end of file

From 8a4e6252bbd995ff018e8784f38411482b97dd24 Mon Sep 17 00:00:00 2001
From: Aleksey Loginov <victimsnino@gmail.com>
Date: Sun, 7 Jan 2024 19:09:12 +0300
Subject: [PATCH 3/7] fix

---
 src/rpp/rpp/subjects/fwd.hpp | 20 ++++++++++++++------
 1 file changed, 14 insertions(+), 6 deletions(-)

diff --git a/src/rpp/rpp/subjects/fwd.hpp b/src/rpp/rpp/subjects/fwd.hpp
index 27b90b975..515384ded 100644
--- a/src/rpp/rpp/subjects/fwd.hpp
+++ b/src/rpp/rpp/subjects/fwd.hpp
@@ -49,15 +49,23 @@ namespace rpp::subjects::utils
 {
 namespace details
 {
-    template<typename T>
-    struct extract_subject_type : std::false_type
+    template<typename TSubject>
+    struct extract_subject_type 
     {
+        template<typename TT, typename Strategy>
+        constexpr static TT deduce(const rpp::subjects::details::base_subject<TT, Strategy>&);
+
+        using type = decltype(deduce(std::declval<std::decay_t<TSubject>>()));
     };
 
-    template<typename TT, typename Strategy>
-    struct extract_subject_type<rpp::subjects::details::base_subject<TT, Strategy>> : std::true_type
+    template<typename TSubject>
+    struct is_subject_t
     {
-        using type = TT;
+        template<typename TT, typename Strategy>
+        constexpr static std::true_type  deduce(const rpp::subjects::details::base_subject<TT, Strategy>&);
+        constexpr static std::false_type deduce(...);
+
+        using type = decltype(deduce(std::declval<std::decay_t<TSubject>*>()));
     };
 
 } // namespace details
@@ -69,5 +77,5 @@ using extract_subject_type_t = typename details::extract_subject_type<std::decay
 namespace rpp::constraint
 {
 template<typename T>
-concept subject = rpp::subjects::utils::details::extract_subject_type<std::decay_t<T>>::value;
+concept subject = rpp::subjects::utils::details::is_subject_t<std::decay_t<T>>::type::value;
 }

From c08e5ee68614ddd53886e1c921685495e6e42e23 Mon Sep 17 00:00:00 2001
From: Aleksey Loginov <victimsnino@gmail.com>
Date: Mon, 8 Jan 2024 01:04:01 +0300
Subject: [PATCH 4/7] fixup

---
 src/rpp/rpp/observables/fwd.hpp       | 32 +++------------------------
 src/rpp/rpp/subjects/fwd.hpp          | 29 ++++--------------------
 src/rpp/rpp/utils/function_traits.hpp | 18 ++++++---------
 src/rpp/rpp/utils/tuple.hpp           | 10 ++++++---
 src/rpp/rpp/utils/utils.hpp           | 22 ++++++++++++++++++
 5 files changed, 43 insertions(+), 68 deletions(-)

diff --git a/src/rpp/rpp/observables/fwd.hpp b/src/rpp/rpp/observables/fwd.hpp
index 804117356..be2c56ba5 100644
--- a/src/rpp/rpp/observables/fwd.hpp
+++ b/src/rpp/rpp/observables/fwd.hpp
@@ -14,6 +14,7 @@
 #include <rpp/subjects/fwd.hpp>
 
 #include <rpp/utils/constraints.hpp>
+#include <rpp/utils/utils.hpp>
 
 namespace rpp::constraint
 {
@@ -52,24 +53,10 @@ template<constraint::decayed_type KeyType, constraint::decayed_type Type, constr
 class grouped_observable;
 }
 
-namespace rpp::utils::details
-{
-template<typename TObservable>
-struct is_observable_t
-{
-    template<typename T, typename Strategy>
-    constexpr static std::true_type  deduce(const rpp::observable<T, Strategy>*);
-    constexpr static std::false_type deduce(...);
-
-    using type = decltype(deduce(std::declval<std::decay_t<TObservable>*>()));
-};
-
-} // namespace rpp::utils::details
-
 namespace rpp::constraint
 {
 template<typename T>
-concept observable = rpp::utils::details::is_observable_t<std::decay_t<T>>::type::value;
+concept observable = rpp::utils::is_base_of_v<T, rpp::observable>;
 }
 
 namespace rpp
@@ -80,21 +67,8 @@ class connectable_observable;
 
 namespace rpp::utils
 {
-namespace details
-{
-    template<rpp::constraint::observable TObservable>
-    struct extract_observable_type
-    {
-        template<typename T, typename Strategy>
-        constexpr static T deduce(const rpp::observable<T, Strategy>&);
-
-        using type = decltype(deduce(std::declval<std::decay_t<TObservable>>()));
-    };
-
-} // namespace details
-
 template<typename T>
-using extract_observable_type_t = typename details::extract_observable_type<std::decay_t<T>>::type;
+using extract_observable_type_t = typename rpp::utils::extract_base_type_params_t<T, rpp::observable>::template type_at_index_t<0>;
 } // namespace rpp::utils
 
 namespace rpp::constraint
diff --git a/src/rpp/rpp/subjects/fwd.hpp b/src/rpp/rpp/subjects/fwd.hpp
index 515384ded..8ecbf4c7c 100644
--- a/src/rpp/rpp/subjects/fwd.hpp
+++ b/src/rpp/rpp/subjects/fwd.hpp
@@ -14,6 +14,8 @@
 
 #include <rpp/utils/constraints.hpp>
 
+#include <rpp/utils/utils.hpp>
+
 namespace rpp::subjects::details
 {
 namespace constraint
@@ -47,35 +49,12 @@ class serialized_subject;
 
 namespace rpp::subjects::utils
 {
-namespace details
-{
-    template<typename TSubject>
-    struct extract_subject_type 
-    {
-        template<typename TT, typename Strategy>
-        constexpr static TT deduce(const rpp::subjects::details::base_subject<TT, Strategy>&);
-
-        using type = decltype(deduce(std::declval<std::decay_t<TSubject>>()));
-    };
-
-    template<typename TSubject>
-    struct is_subject_t
-    {
-        template<typename TT, typename Strategy>
-        constexpr static std::true_type  deduce(const rpp::subjects::details::base_subject<TT, Strategy>&);
-        constexpr static std::false_type deduce(...);
-
-        using type = decltype(deduce(std::declval<std::decay_t<TSubject>*>()));
-    };
-
-} // namespace details
-
 template<typename T>
-using extract_subject_type_t = typename details::extract_subject_type<std::decay_t<T>>::type;
+using extract_subject_type_t = typename rpp::utils::extract_base_type_params_t<T, rpp::subjects::details::base_subject>::template type_at_index_t<0>;
 } // namespace rpp::utils
 
 namespace rpp::constraint
 {
 template<typename T>
-concept subject = rpp::subjects::utils::details::is_subject_t<std::decay_t<T>>::type::value;
+concept subject = rpp::utils::is_base_of_v<T, rpp::subjects::details::base_subject>;
 }
diff --git a/src/rpp/rpp/utils/function_traits.hpp b/src/rpp/rpp/utils/function_traits.hpp
index db53cdd17..cf587a891 100644
--- a/src/rpp/rpp/utils/function_traits.hpp
+++ b/src/rpp/rpp/utils/function_traits.hpp
@@ -10,7 +10,7 @@
 
 #pragma once
 
-#include <tuple>
+#include <rpp/utils/tuple.hpp>
 #include <type_traits>
 
 namespace rpp::utils
@@ -73,19 +73,15 @@ template<class R, class... Args>
 struct function_traits<R (*)(Args...)>
 {
     using result    = R;
-    using arguments = std::tuple<Args...>;
+    using arguments = rpp::utils::tuple<std::decay_t<Args>...>;
 
-    template<std::size_t i = 0>
-        requires (sizeof...(Args) > i)
-    using argument = std::tuple_element_t<i, arguments>;
+    template<std::size_t I = 0>
+        requires (sizeof...(Args) > I)
+    using argument = typename arguments::template type_at_index_t<I>;
 };
 
-template<typename T, std::size_t i = 0>
-using function_argument_t = typename function_traits<T>::template argument<i>;
-
-
-template<typename T, std::size_t i = 0>
-using decayed_function_argument_t = std::decay_t<function_argument_t<T, i>>;
+template<typename T, std::size_t I = 0>
+using decayed_function_argument_t = typename function_traits<T>::template argument<I>;
 
 template<typename Fn, typename... Args>
 using decayed_invoke_result_t = std::decay_t<std::invoke_result_t<Fn, Args...>>;
diff --git a/src/rpp/rpp/utils/tuple.hpp b/src/rpp/rpp/utils/tuple.hpp
index a3f709631..544c9e41c 100644
--- a/src/rpp/rpp/utils/tuple.hpp
+++ b/src/rpp/rpp/utils/tuple.hpp
@@ -84,14 +84,18 @@ class RPP_EMPTY_BASES tuple_impl<std::index_sequence<Indices...>, Args...> : pri
         return static_cast<tuple_leaf<I, type_at_index_t<I>>*>(this)->get();
     }
 
-private:
+// private:
+
     template<size_t I, typename T>
-    constexpr static T type_at_index(const tuple_leaf<I, T>&);
+    constexpr static T type_at_index_impl(const tuple_leaf<I, T>*);
+
+    template<size_t I>
+    constexpr static auto type_at_index() -> decltype(type_at_index_impl<I>(std::declval<tuple_impl*>()));
 
 public:
     template<size_t I>
         requires (I < sizeof...(Args))
-    using type_at_index_t = decltype(type_at_index<I>(std::declval<tuple_impl>()));
+    using type_at_index_t = decltype(type_at_index<I>());
 };
 }
 
diff --git a/src/rpp/rpp/utils/utils.hpp b/src/rpp/rpp/utils/utils.hpp
index 3f122b37e..55e7a82a6 100644
--- a/src/rpp/rpp/utils/utils.hpp
+++ b/src/rpp/rpp/utils/utils.hpp
@@ -12,6 +12,7 @@
 
 #include <rpp/defs.hpp>
 #include <rpp/utils/constraints.hpp>
+#include <rpp/utils/tuple.hpp>
 
 #include <algorithm>
 
@@ -30,6 +31,27 @@ struct types
 template<constraint::iterable T>
 using iterable_value_t = std::iter_value_t<decltype(std::begin(std::declval<T>()))>;
 
+namespace details
+{
+    template<template<typename...> typename Base>
+    struct traits
+    {
+        template<typename... Types>
+        constexpr static std::true_type  convertible_from(const Base<Types...>*);
+        constexpr static std::false_type convertible_from(...);
+
+        template<typename... Types>
+        constexpr static rpp::utils::tuple<Types...> extract_params(const Base<Types...>*);
+    };
+}
+
+template<typename T, template <typename...> typename Base>
+concept is_base_of_v = decltype(details::traits<Base>::convertible_from(std::declval<std::decay_t<T>*>()))::value;
+
+template<typename T, template <typename...> typename Base>
+    requires is_base_of_v<T, Base>
+using extract_base_type_params_t = decltype(details::traits<Base>::extract_params(std::declval<std::decay_t<T>*>()));
+
 template<class T>
 constexpr std::add_const_t<T>& as_const(const T& v) noexcept
 {

From c7d0b651d498acd7bce2b385e33e4c457a09f6fb Mon Sep 17 00:00:00 2001
From: Aleksey Loginov <victimsnino@gmail.com>
Date: Mon, 8 Jan 2024 01:09:56 +0300
Subject: [PATCH 5/7] update

---
 src/rpp/rpp/utils/tuple.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/rpp/rpp/utils/tuple.hpp b/src/rpp/rpp/utils/tuple.hpp
index 544c9e41c..ffd637cc5 100644
--- a/src/rpp/rpp/utils/tuple.hpp
+++ b/src/rpp/rpp/utils/tuple.hpp
@@ -84,15 +84,15 @@ class RPP_EMPTY_BASES tuple_impl<std::index_sequence<Indices...>, Args...> : pri
         return static_cast<tuple_leaf<I, type_at_index_t<I>>*>(this)->get();
     }
 
-// private:
-
+private:
     template<size_t I, typename T>
     constexpr static T type_at_index_impl(const tuple_leaf<I, T>*);
 
+public:
+
     template<size_t I>
     constexpr static auto type_at_index() -> decltype(type_at_index_impl<I>(std::declval<tuple_impl*>()));
 
-public:
     template<size_t I>
         requires (I < sizeof...(Args))
     using type_at_index_t = decltype(type_at_index<I>());

From cda41b968c5574b5d31c386874eb87670efc70de Mon Sep 17 00:00:00 2001
From: Aleksey Loginov <victimsnino@gmail.com>
Date: Mon, 8 Jan 2024 01:23:53 +0300
Subject: [PATCH 6/7] handle observers

---
 src/rpp/rpp/observers/fwd.hpp | 20 +++-----------------
 1 file changed, 3 insertions(+), 17 deletions(-)

diff --git a/src/rpp/rpp/observers/fwd.hpp b/src/rpp/rpp/observers/fwd.hpp
index a51030a1d..020875566 100644
--- a/src/rpp/rpp/observers/fwd.hpp
+++ b/src/rpp/rpp/observers/fwd.hpp
@@ -17,6 +17,7 @@
 #include <rpp/utils/constraints.hpp>
 #include <rpp/utils/function_traits.hpp>
 #include <rpp/utils/functors.hpp>
+#include <rpp/utils/utils.hpp>
 
 #include <exception>
 
@@ -231,29 +232,14 @@ using fake_observer = rpp::observer<T, fake_strategy>;
 
 namespace rpp::utils
 {
-namespace details
-{
-    template<typename T>
-    struct extract_observer_type : std::false_type
-    {
-    };
-
-    template<typename TT, typename Strategy>
-    struct extract_observer_type<rpp::observer<TT, Strategy>> : std::true_type
-    {
-        using type = TT;
-    };
-
-} // namespace details
-
 template<typename T>
-using extract_observer_type_t = typename details::extract_observer_type<T>::type;
+using extract_observer_type_t = typename rpp::utils::extract_base_type_params_t<T, rpp::observer>::template type_at_index_t<0>;
 } // namespace rpp::utils
 
 namespace rpp::constraint
 {
 template<typename T>
-concept observer = rpp::utils::details::extract_observer_type<std::decay_t<T>>::value;
+concept observer = rpp::utils::is_base_of_v<T, rpp::observer>;
 
 template<typename T, typename Type>
 concept observer_of_type = observer<std::decay_t<T>> && std::same_as<rpp::utils::extract_observer_type_t<std::decay_t<T>>, Type>;

From 12e97289e30841907748c3099b9364cc3dadb2dc Mon Sep 17 00:00:00 2001
From: Aleksey Loginov <victimsnino@gmail.com>
Date: Mon, 8 Jan 2024 10:52:43 +0300
Subject: [PATCH 7/7] simplify

---
 src/rpp/rpp/utils/utils.hpp | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/rpp/rpp/utils/utils.hpp b/src/rpp/rpp/utils/utils.hpp
index 55e7a82a6..a9483bf4c 100644
--- a/src/rpp/rpp/utils/utils.hpp
+++ b/src/rpp/rpp/utils/utils.hpp
@@ -36,17 +36,14 @@ namespace details
     template<template<typename...> typename Base>
     struct traits
     {
-        template<typename... Types>
-        constexpr static std::true_type  convertible_from(const Base<Types...>*);
-        constexpr static std::false_type convertible_from(...);
-
         template<typename... Types>
         constexpr static rpp::utils::tuple<Types...> extract_params(const Base<Types...>*);
+        constexpr static std::false_type             extract_params(...);
     };
 }
 
 template<typename T, template <typename...> typename Base>
-concept is_base_of_v = decltype(details::traits<Base>::convertible_from(std::declval<std::decay_t<T>*>()))::value;
+concept is_base_of_v = !std::is_same_v<decltype(details::traits<Base>::extract_params(std::declval<std::decay_t<T>*>())), std::false_type>;
 
 template<typename T, template <typename...> typename Base>
     requires is_base_of_v<T, Base>