minor concepts fixes

src/rpp/rpp/observables/details/disposable_strategy.hpp

@@ -74,19 +74,25 @@ using atomic_bool_disposable_strategy_selector = fixed_disposable_strategy_selec
 
 namespace details
 {
+    template<typename T>
+    concept has_expected_disposable_strategy = requires { typename T::expected_disposable_strategy; };
+
     template<typename T>
     auto* deduce_disposable_strategy()
     {
-        if constexpr (requires { typename T::expected_disposable_strategy; })
+        if constexpr (has_expected_disposable_strategy<T>)
             return static_cast<typename T::expected_disposable_strategy*>(nullptr);
         else
             return static_cast<default_disposable_strategy_selector*>(nullptr);
     }
 
+    template<typename T, typename Prev>
+    concept has_updated_disposable_strategy = requires { typename T::template updated_disposable_strategy<Prev>; };
+
     template<typename T, typename Prev>
     auto* deduce_updated_disposable_strategy()
     {
-        if constexpr (requires { typename T::template updated_disposable_strategy<Prev>; })
+        if constexpr(has_updated_disposable_strategy<T, Prev>)
             return static_cast<typename T::template updated_disposable_strategy<Prev>*>(nullptr);
         else
             return static_cast<default_disposable_strategy_selector*>(nullptr);

src/rpp/rpp/observables/observable.hpp

@@ -77,7 +77,7 @@ class observable
         requires (!constraint::observer<ObserverStrategy>)
     void subscribe(ObserverStrategy&& observer_strategy) const
     {
-        if constexpr (details::observers::has_disposable_strategy_v<ObserverStrategy>)
+        if constexpr (details::observers::has_disposable_strategy<ObserverStrategy>)
             subscribe(rpp::observer<Type, std::decay_t<ObserverStrategy>>{std::forward<ObserverStrategy>(observer_strategy)});
         else
             subscribe(rpp::observer<Type, details::with_disposable_strategy<std::decay_t<ObserverStrategy>, typename expected_disposable_strategy::disposable_strategy>>{std::forward<ObserverStrategy>(observer_strategy)});

src/rpp/rpp/observers/details/fwd.hpp

@@ -63,14 +63,14 @@ namespace constraint
 }
 
 template<typename T>
-static constexpr bool has_disposable_strategy_v = requires { typename T::preferred_disposable_strategy; };
+concept has_disposable_strategy = requires { typename T::preferred_disposable_strategy; };
 
 namespace details
 {
     template<typename T>
     auto* deduce_disposable_strategy()
     {
-        if constexpr (has_disposable_strategy_v<T>)
+        if constexpr (has_disposable_strategy<T>)
             return static_cast<typename T::preferred_disposable_strategy*>(nullptr);
         else
             return static_cast<dynamic_local_disposable_strategy<0, atomic_bool>*>(nullptr);

src/rpp/rpp/observers/fwd.hpp

@@ -212,6 +212,8 @@ namespace rpp::details
 {
 struct fake_strategy
 {
+    using preferred_disposable_strategy = rpp::details::observers::none_disposable_strategy;
+
     static void on_next(const auto&) noexcept {}
 
     static void on_error(const std::exception_ptr&) noexcept {}

src/rpp/rpp/operators/scan.hpp

@@ -69,6 +69,8 @@ struct scan_t : public operators::details::operator_observable_strategy<scan_obs
 template<rpp::constraint::decayed_type Seed, rpp::constraint::observer TObserver, rpp::constraint::decayed_type Fn>
 struct scan_no_seed_observer_strategy
 {
+    using preferred_disposable_strategy = rpp::details::observers::none_disposable_strategy;
+
     RPP_NO_UNIQUE_ADDRESS TObserver observer;
     RPP_NO_UNIQUE_ADDRESS Fn        fn;
     mutable std::optional<Seed>     seed{};