diff --git a/.vscode/settings.json b/.vscode/settings.json
index f74ccbc62..9116f6d65 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -3,7 +3,8 @@
       "--header-insertion=never",
       "--background-index",
       "--clang-tidy",
-      "-j=32"
+      "-j=32",
+      "--function-arg-placeholders=0"
     ],
     "sonarlint.pathToCompileCommands": "${workspaceFolder}/build/compile_commands.json",
 }
\ No newline at end of file
diff --git a/docs/readme.md b/docs/readme.md
index bf43eaeeb..5fe7f8e7b 100644
--- a/docs/readme.md
+++ b/docs/readme.md
@@ -269,15 +269,25 @@ There we convert observable to concatenation of original observable and `just(2)
 
 One more posible but a bit more advanced way to implement operators - is to lift observer. To do this, your functor-adapter must to satisfy `rpp::constraint::operator_lift` concept. Actually, your class must to have:
 - member function `lift` accepting downstream observer and returning new upstream observer
-- using `result_value<T>` accepting typename of upstream and providing new value for downstream (== typename of original observable and return new resulting type for new observable)
+- inner `template<rpp::constraint::decayed_type T> struct traits` struct accepting typename of upstream and providing:
+  - `using result_type =` with typename of new resulting type for new observable  
+  - (optionally) `struct requirements` with static_asserts over passed type 
 
 Example:
 ```cpp
 template<typename Fn>
 struct map
 {
-  template<typename T>
-  using result_value = std::invoke_result_t<Fn, T>;
+  template<rpp::constraint::decayed_type T>
+  struct traits
+  {
+    struct requirements
+    {
+      static_assert(std::invocable<Fn, T>, "Fn is not invocable with T");
+    };
+
+    using result_type = std::invoke_result_t<Fn, T>;
+  };
 
   Fn fn{};
 
diff --git a/src/rpp/rpp/observables/details/chain_strategy.hpp b/src/rpp/rpp/observables/details/chain_strategy.hpp
index e50a2c5e3..c03fbf2b6 100644
--- a/src/rpp/rpp/observables/details/chain_strategy.hpp
+++ b/src/rpp/rpp/observables/details/chain_strategy.hpp
@@ -23,7 +23,7 @@ class observable_chain_strategy
 
 public:
     using expected_disposable_strategy = details::observables::deduce_updated_disposable_strategy<TStrategy, typename base::expected_disposable_strategy>;
-    using value_type = typename TStrategy::template result_value<typename base::value_type>;
+    using value_type = typename TStrategy::template operator_traits<typename base::value_type>::result_type;
 
     observable_chain_strategy(const TStrategy& strategy, const TStrategies&... strategies)
         : m_strategy(strategy)
diff --git a/src/rpp/rpp/observables/fwd.hpp b/src/rpp/rpp/observables/fwd.hpp
index 085fd0196..b6e33876e 100644
--- a/src/rpp/rpp/observables/fwd.hpp
+++ b/src/rpp/rpp/observables/fwd.hpp
@@ -91,34 +91,37 @@ concept operator_observable_transform = requires(const Op& op, TObs obs)
 };
 
 template<typename Op, typename Type>
-concept operator_base = requires(const Op& op) {
-    typename std::decay_t<Op>::template result_value<Type>;
-    requires details::observables::constraint::disposable_strategy<details::observables::deduce_updated_disposable_strategy<std::decay_t<Op>, typename observable_chain_strategy<details::observables::fake_strategy<Type>>::expected_disposable_strategy>>;
-};
+concept operator_base = requires(const Op& op) { typename std::decay_t<Op>::template operator_traits<Type>; } && details::observables::constraint::disposable_strategy<details::observables::deduce_updated_disposable_strategy<std::decay_t<Op>, typename observable_chain_strategy<details::observables::fake_strategy<Type>>::expected_disposable_strategy>>;
 
 template<typename Op, typename Type>
-concept operator_subscribe = operator_base<Op, Type> && requires(const Op& op, rpp::details::observers::fake_observer<typename std::decay_t<Op>::template result_value<Type>>&& observer, const observable_chain_strategy<details::observables::fake_strategy<Type>>& chain)
+concept operator_subscribe = operator_base<Op, Type> && requires(const Op& op, rpp::details::observers::fake_observer<typename std::decay_t<Op>::template operator_traits<Type>::result_type>&& observer, const observable_chain_strategy<details::observables::fake_strategy<Type>>& chain)
 {
     {op.subscribe(std::move(observer), chain)};
 };
 
 template<typename Op, typename Type>
-concept operator_lift = operator_base<Op, Type> && requires(const Op& op, rpp::details::observers::fake_observer<typename std::decay_t<Op>::template result_value<Type>>&& observer)
+concept operator_lift = operator_base<Op, Type> && requires(const Op& op, rpp::details::observers::fake_observer<typename std::decay_t<Op>::template operator_traits<Type>::result_type>&& observer)
 {
     {op.template lift<Type>(std::move(observer))} -> rpp::constraint::observer_of_type<Type>;
 };
 
 template<typename Op, typename Type, typename DisposableStrategy>
-concept operator_lift_with_disposable_strategy = operator_base<Op, Type> && requires(const Op& op, rpp::details::observers::fake_observer<typename std::decay_t<Op>::template result_value<Type>>&& observer)
+concept operator_lift_with_disposable_strategy = operator_base<Op, Type> && requires(const Op& op, rpp::details::observers::fake_observer<typename std::decay_t<Op>::template operator_traits<Type>::result_type>&& observer)
 {
     {op.template lift_with_disposable_strategy<Type, DisposableStrategy>(std::move(observer))} -> rpp::constraint::observer_of_type<Type>;
 };
 
 template<typename Op, typename Type, typename DisposableStrategy>
-concept operator_chain = operator_subscribe<Op, Type> || operator_lift<Op, Type> || operator_lift_with_disposable_strategy<Op, Type, DisposableStrategy>;
+concept operator_chain = operator_base<std::decay_t<Op>, Type>
+    && requires { typename std::decay_t<Op>::template operator_traits<Type>::result_type; }
+    && (operator_subscribe<std::decay_t<Op>, Type> || operator_lift<std::decay_t<Op>, Type> || operator_lift_with_disposable_strategy<std::decay_t<Op>, Type, DisposableStrategy>);
 
 template<typename TObservable, typename... TObservables>
 concept observables_of_same_type = rpp::constraint::observable<TObservable> &&
     (rpp::constraint::observable<TObservables> && ...) &&
     (std::same_as<rpp::utils::extract_observable_type_t<TObservable>, rpp::utils::extract_observable_type_t<TObservables>> && ...);
 }
+
+#define RPP_CHECK_IF_TRAIT_ASSERTS_SATISFIED(Op, Type)                                              \
+    /* operator_traits can be instantiated if all inner static_asserts are fine*/ \
+    if constexpr (requires { { typename std::decay_t<Op>::template operator_traits<Type>{}}; })
diff --git a/src/rpp/rpp/observables/observable.hpp b/src/rpp/rpp/observables/observable.hpp
index 30828eae8..309f9c785 100644
--- a/src/rpp/rpp/observables/observable.hpp
+++ b/src/rpp/rpp/observables/observable.hpp
@@ -36,7 +36,7 @@ class observable
 {
 public:
     using value_type = Type;
-    
+
     using expected_disposable_strategy = rpp::details::observables::deduce_disposable_strategy_t<Strategy>;
 
     template<typename... Args>
@@ -310,16 +310,18 @@ class observable
      */
     auto as_dynamic() && { return rpp::dynamic_observable<Type>{std::move(*this)}; }
 
-    template<constraint::operator_chain<Type, expected_disposable_strategy> Op>
+    template<constraint::operator_base<Type> Op>
     auto operator|(Op&& op) const &
     {
-        return observable<typename std::decay_t<Op>::template result_value<Type>, make_chain_observable_t<std::decay_t<Op>, Strategy>>{std::forward<Op>(op), m_strategy};
+        RPP_CHECK_IF_TRAIT_ASSERTS_SATISFIED(Op, Type)
+        return inner_make_chain_operator(std::forward<Op>(op));
     }
 
-    template<constraint::operator_chain<Type, expected_disposable_strategy> Op>
+    template<constraint::operator_base<Type> Op>
     auto operator|(Op&& op) &&
     {
-        return observable<typename std::decay_t<Op>::template result_value<Type>, make_chain_observable_t<std::decay_t<Op>, Strategy>>{std::forward<Op>(op), std::move(m_strategy)};
+        RPP_CHECK_IF_TRAIT_ASSERTS_SATISFIED(Op, Type)
+        return std::move(*this).inner_make_chain_operator(std::forward<Op>(op));
     }
 
     template<constraint::operator_observable_transform<const observable&> Op>
@@ -358,6 +360,19 @@ class observable
         return std::move(*this) | std::forward<Op>(op);
     }
 
+private:
+    template<constraint::operator_chain<Type, expected_disposable_strategy> Op>
+    auto inner_make_chain_operator(Op&& op) const &
+    {
+        return observable<typename std::decay_t<Op>::template operator_traits<Type>::result_type, make_chain_observable_t<std::decay_t<Op>, Strategy>>{std::forward<Op>(op), m_strategy};
+    }
+
+    template<constraint::operator_chain<Type, expected_disposable_strategy> Op>
+    auto inner_make_chain_operator(Op&& op) &&
+    {
+        return observable<typename std::decay_t<Op>::template operator_traits<Type>::result_type, make_chain_observable_t<std::decay_t<Op>, Strategy>>{std::forward<Op>(op), std::move(m_strategy)};
+    }
+
 private:
     RPP_NO_UNIQUE_ADDRESS Strategy m_strategy;
 };
diff --git a/src/rpp/rpp/operators/buffer.hpp b/src/rpp/rpp/operators/buffer.hpp
index 3e9be1406..de0e9553a 100644
--- a/src/rpp/rpp/operators/buffer.hpp
+++ b/src/rpp/rpp/operators/buffer.hpp
@@ -64,10 +64,16 @@ class buffer_observer_strategy
     mutable std::vector<value_type>  m_bucket;
 };
 
-struct buffer_t : public operators::details::operator_observable_strategy_different_types<buffer_observer_strategy, rpp::utils::types<>, size_t>
+struct buffer_t  : lift_operator<buffer_t, size_t>
 {
     template<rpp::constraint::decayed_type T>
-    using result_value = std::vector<T>;
+    struct operator_traits
+    {
+        using result_type = std::vector<T>;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = buffer_observer_strategy<TObserver>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = Prev;
diff --git a/src/rpp/rpp/operators/combine_latest.hpp b/src/rpp/rpp/operators/combine_latest.hpp
index 17d62352d..49b74ae0c 100644
--- a/src/rpp/rpp/operators/combine_latest.hpp
+++ b/src/rpp/rpp/operators/combine_latest.hpp
@@ -103,8 +103,12 @@ struct combine_latest_t
     RPP_NO_UNIQUE_ADDRESS TSelector                          selector;
 
     template<rpp::constraint::decayed_type T>
-        requires std::invocable<TSelector, T, rpp::utils::extract_observable_type_t<TObservables>...>
-    using result_value = std::invoke_result_t<TSelector, T, rpp::utils::extract_observable_type_t<TObservables>...>;
+    struct operator_traits
+    {
+        static_assert(std::invocable<TSelector, T, rpp::utils::extract_observable_type_t<TObservables>...>, "Selector is not callable with passed T type");
+
+        using result_type = std::invoke_result_t<TSelector, T, rpp::utils::extract_observable_type_t<TObservables>...>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = rpp::details::observables::fixed_disposable_strategy_selector<1>;
diff --git a/src/rpp/rpp/operators/concat.hpp b/src/rpp/rpp/operators/concat.hpp
index d8de38db9..4f365faa1 100644
--- a/src/rpp/rpp/operators/concat.hpp
+++ b/src/rpp/rpp/operators/concat.hpp
@@ -71,7 +71,7 @@ class concat_state_t final : public rpp::refcount_disposable
     {
         if (handle_observable_impl(observable, refcounted))
             return;
-        
+
         drain(refcounted);
     }
 
@@ -168,12 +168,12 @@ struct concat_observer_strategy : public concat_observer_strategy_base<TObservab
     }
 
     template<typename T>
-    void on_next(T&& v) const 
-    { 
+    void on_next(T&& v) const
+    {
         ConcatStage current = ConcatStage::None;
         if (base::state->stage().compare_exchange_strong(current, ConcatStage::Draining, std::memory_order::seq_cst))
             base::state->handle_observable(std::forward<T>(v), base::state->add_ref());
-        else 
+        else
             base::state->get_queue()->push(std::forward<T>(v));
     }
 
@@ -195,11 +195,18 @@ struct concat_observer_strategy : public concat_observer_strategy_base<TObservab
     }
 };
 
-struct concat_t: public operators::details::template_operator_observable_strategy<concat_observer_strategy>
+struct concat_t  : lift_operator<concat_t>
 {
     template<rpp::constraint::decayed_type T>
-        requires rpp::constraint::observable<T>
-    using result_value = rpp::utils::extract_observable_type_t<T>;
+    struct operator_traits
+    {
+        static_assert(rpp::constraint::observable<T>, "T is not observable");
+
+        using result_type = rpp::utils::extract_observable_type_t<T>;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = concat_observer_strategy<T, TObserver>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = rpp::details::observables::fixed_disposable_strategy_selector<1>;
diff --git a/src/rpp/rpp/operators/debounce.hpp b/src/rpp/rpp/operators/debounce.hpp
index 9541efbc7..6030b1490 100644
--- a/src/rpp/rpp/operators/debounce.hpp
+++ b/src/rpp/rpp/operators/debounce.hpp
@@ -156,7 +156,10 @@ template<rpp::schedulers::constraint::scheduler Scheduler>
 struct debounce_t
 {
     template<rpp::constraint::decayed_type T>
-    using result_value = T;
+    struct operator_traits
+    {
+        using result_type = T;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = rpp::details::observables::fixed_disposable_strategy_selector<1>;
diff --git a/src/rpp/rpp/operators/delay.hpp b/src/rpp/rpp/operators/delay.hpp
index 5959f23a8..61b22ee7b 100644
--- a/src/rpp/rpp/operators/delay.hpp
+++ b/src/rpp/rpp/operators/delay.hpp
@@ -170,7 +170,10 @@ template<rpp::schedulers::constraint::scheduler Scheduler, bool ClearOnError>
 struct delay_t
 {
     template<rpp::constraint::decayed_type T>
-    using result_value = T;
+    struct operator_traits
+    {
+        using result_type = T;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = rpp::details::observables::fixed_disposable_strategy_selector<1>;
diff --git a/src/rpp/rpp/operators/details/strategy.hpp b/src/rpp/rpp/operators/details/strategy.hpp
index ee5737d1a..13778739d 100644
--- a/src/rpp/rpp/operators/details/strategy.hpp
+++ b/src/rpp/rpp/operators/details/strategy.hpp
@@ -23,61 +23,33 @@
 
 namespace rpp::operators::details
 {
-template<typename SubscribeStrategy, rpp::constraint::decayed_type... Args>
-class operator_observable_strategy_base
+template<typename Operator, rpp::constraint::decayed_type... TArgs>
+class lift_operator
 {
 public:
-    template<rpp::constraint::decayed_same_as<Args>... TArgs>
-    operator_observable_strategy_base(TArgs&&... args)
-        : m_vals{std::forward<TArgs>(args)...}
+    template<rpp::constraint::decayed_same_as<TArgs>... TTArgs>
+    lift_operator(TTArgs&&... args)
+        : m_vals{std::forward<TTArgs>(args)...}
     {
     }
 
     template<rpp::constraint::decayed_type Type, rpp::constraint::observer Observer>
     auto lift(Observer&& observer) const
     {
-        return m_vals.apply(&SubscribeStrategy::template apply<Type, Observer, Args...>, std::forward<Observer>(observer));
+        return m_vals.apply(&apply<Type, Observer, TArgs...>, std::forward<Observer>(observer));
     }
 
 private:
-    RPP_NO_UNIQUE_ADDRESS rpp::utils::tuple<Args...> m_vals{};
-};
-
-template<template<typename, typename...> typename Strategy, typename Types>
-struct identity_subscribe_strategy;
-
-template<template<typename, typename...> typename Strategy, typename... Types>
-struct identity_subscribe_strategy<Strategy, rpp::utils::types<Types...>>
-{
-    template<rpp::constraint::decayed_type Type, rpp::constraint::observer Observer, typename... Args>
+    template<rpp::constraint::decayed_type Type,
+             rpp::constraint::observer Observer,
+             typename... Args>
     static auto apply(Observer&& observer, const Args&... vals)
     {
-        return rpp::observer<Type, Strategy<std::decay_t<Observer>, Types...>>{std::forward<Observer>(observer), vals...};
+        static_assert(rpp::constraint::observer_of_type<std::decay_t<Observer>, typename Operator::template operator_traits<Type>::result_type>);
+        return rpp::observer<Type, typename Operator::template operator_traits<Type>::template observer_strategy<std::decay_t<Observer>>>{std::forward<Observer>(observer), vals...};
     }
-};
-
-template<template<typename, typename...> typename Strategy, rpp::constraint::decayed_type... Args>
-using operator_observable_strategy = operator_observable_strategy_base<identity_subscribe_strategy<Strategy, rpp::utils::types<Args...>>, Args...>;
-
-template<template<typename, typename...> typename Strategy, typename Types = rpp::utils::types<>, rpp::constraint::decayed_type... Args>
-using operator_observable_strategy_different_types = operator_observable_strategy_base<identity_subscribe_strategy<Strategy, Types>, Args...>;
-
-template<template<typename, typename, typename...> typename Strategy, typename Types>
-struct template_subscribe_strategy;
 
-template<template<typename, typename, typename...> typename Strategy, typename... Types>
-struct template_subscribe_strategy<Strategy, rpp::utils::types<Types...>>
-{
-    template<rpp::constraint::decayed_type Type, rpp::constraint::observer Observer, typename... Args>
-    static auto apply(Observer&& observer, const Args&... vals)
-    {
-        return rpp::observer<Type, Strategy<Type, std::decay_t<Observer>, Types...>>{std::forward<Observer>(observer), vals...};
-    }
+private:
+    RPP_NO_UNIQUE_ADDRESS rpp::utils::tuple<TArgs...> m_vals{};
 };
-
-template<template<typename, typename, typename...> typename Strategy, rpp::constraint::decayed_type... Args>
-using template_operator_observable_strategy = operator_observable_strategy_base<template_subscribe_strategy<Strategy, rpp::utils::types<Args...>>, Args...>;
-
-template<template<typename, typename, typename...> typename Strategy, typename Types = rpp::utils::types<>, rpp::constraint::decayed_type... Args>
-using template_operator_observable_strategy_different_types = operator_observable_strategy_base<template_subscribe_strategy<Strategy, Types>, Args...>;
 }
diff --git a/src/rpp/rpp/operators/distinct.hpp b/src/rpp/rpp/operators/distinct.hpp
index dcc71d5f3..0446e01d4 100644
--- a/src/rpp/rpp/operators/distinct.hpp
+++ b/src/rpp/rpp/operators/distinct.hpp
@@ -23,8 +23,6 @@ namespace rpp::operators::details
 template<rpp::constraint::decayed_type Type, rpp::constraint::observer TObserver>
 struct distinct_observer_strategy
 {
-    static_assert(rpp::constraint::hashable<Type>, "Distinct operator requires hashable type");
-
     using preferred_disposable_strategy = rpp::details::observers::none_disposable_strategy;
 
     RPP_NO_UNIQUE_ADDRESS TObserver  observer;
@@ -49,10 +47,18 @@ struct distinct_observer_strategy
     bool is_disposed() const { return observer.is_disposed(); }
 };
 
-struct distinct_t : public operators::details::template_operator_observable_strategy<distinct_observer_strategy>
+struct distinct_t  : lift_operator<distinct_t>
 {
     template<rpp::constraint::decayed_type T>
-    using result_value = T;
+    struct operator_traits
+    {
+        static_assert(rpp::constraint::hashable<T>, "T is not hashable");
+
+        using result_type = T;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = distinct_observer_strategy<T, TObserver>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = Prev;
diff --git a/src/rpp/rpp/operators/distinct_until_changed.hpp b/src/rpp/rpp/operators/distinct_until_changed.hpp
index 876bbe016..5caf9aa6a 100644
--- a/src/rpp/rpp/operators/distinct_until_changed.hpp
+++ b/src/rpp/rpp/operators/distinct_until_changed.hpp
@@ -48,11 +48,18 @@ struct distinct_until_changed_observer_strategy
 };
 
 template<rpp::constraint::decayed_type EqualityFn>
-struct distinct_until_changed_t : public operators::details::template_operator_observable_strategy<distinct_until_changed_observer_strategy, EqualityFn>
+struct distinct_until_changed_t : public operators::details::lift_operator<distinct_until_changed_t<EqualityFn>, EqualityFn>
 {
     template<rpp::constraint::decayed_type T>
-        requires rpp::constraint::invocable_r_v<bool, EqualityFn, T, T>
-    using result_value = T;
+    struct operator_traits
+    {
+        static_assert(rpp::constraint::invocable_r_v<bool, EqualityFn, T, T>, "EqualityFn is not invocable with T and T returning bool");
+
+        using result_type = T;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = distinct_until_changed_observer_strategy<T, TObserver, EqualityFn>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = Prev;
diff --git a/src/rpp/rpp/operators/filter.hpp b/src/rpp/rpp/operators/filter.hpp
index d3a16e615..6ebcddb6c 100644
--- a/src/rpp/rpp/operators/filter.hpp
+++ b/src/rpp/rpp/operators/filter.hpp
@@ -44,11 +44,18 @@ struct filter_observer_strategy
 };
 
 template<rpp::constraint::decayed_type Fn>
-struct filter_t : public operators::details::operator_observable_strategy<filter_observer_strategy, Fn>
+struct filter_t  : lift_operator<filter_t<Fn>, Fn>
 {
     template<rpp::constraint::decayed_type T>
-        requires std::is_invocable_r_v<bool, Fn, T>
-    using result_value = T;
+    struct operator_traits
+    {
+        static_assert(std::is_invocable_r_v<bool, Fn, T>, "Fn is not invocable with T returning bool");
+
+        using result_type = T;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = filter_observer_strategy<TObserver, Fn>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = Prev;
diff --git a/src/rpp/rpp/operators/first.hpp b/src/rpp/rpp/operators/first.hpp
index 838960ea7..6fcad3145 100644
--- a/src/rpp/rpp/operators/first.hpp
+++ b/src/rpp/rpp/operators/first.hpp
@@ -43,10 +43,16 @@ struct first_observer_strategy
     bool is_disposed() const { return observer.is_disposed(); }
 };
 
-struct first_t : public operators::details::operator_observable_strategy<first_observer_strategy>
+struct first_t  : lift_operator<first_t>
 {
     template<rpp::constraint::decayed_type T>
-    using result_value = T;
+    struct operator_traits
+    {
+        using result_type = T;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = first_observer_strategy<TObserver>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = Prev;
diff --git a/src/rpp/rpp/operators/group_by.hpp b/src/rpp/rpp/operators/group_by.hpp
index 75de84d6f..6efe5099e 100644
--- a/src/rpp/rpp/operators/group_by.hpp
+++ b/src/rpp/rpp/operators/group_by.hpp
@@ -121,7 +121,7 @@ struct group_by_observer_strategy
     const subject_observer* deduce_observer(const rpp::constraint::observer auto& obs, const TT& val) const
     {
         const auto key = key_selector(utils::as_const(val));
-        
+
         if (const auto itr = key_to_observer.find(key); itr != key_to_observer.cend())
             return &itr->second;
 
@@ -162,13 +162,22 @@ struct group_by_observable_strategy
 };
 
 template<rpp::constraint::decayed_type KeySelector, rpp::constraint::decayed_type ValueSelector, rpp::constraint::decayed_type KeyComparator>
-struct group_by_t : public operators::details::template_operator_observable_strategy<group_by_observer_strategy, KeySelector, ValueSelector, KeyComparator>
+struct group_by_t  : lift_operator<group_by_t<KeySelector, ValueSelector, KeyComparator>, KeySelector, ValueSelector, KeyComparator>
 {
-    using operators::details::template_operator_observable_strategy<group_by_observer_strategy, KeySelector, ValueSelector, KeyComparator>::template_operator_observable_strategy;
+    using operators::details::lift_operator<group_by_t<KeySelector, ValueSelector, KeyComparator>, KeySelector, ValueSelector, KeyComparator>::lift_operator;
 
     template<rpp::constraint::decayed_type T>
-        requires std::invocable<KeySelector, T> && std::invocable<ValueSelector, T> && std::strict_weak_order<KeyComparator, rpp::utils::decayed_invoke_result_t<KeySelector, T>, rpp::utils::decayed_invoke_result_t<KeySelector, T>>
-    using result_value = grouped_observable<utils::decayed_invoke_result_t<KeySelector, T>, rpp::utils::decayed_invoke_result_t<ValueSelector, T>, group_by_observable_strategy<utils::decayed_invoke_result_t<ValueSelector, T>>>;
+    struct operator_traits
+    {
+        static_assert(std::invocable<KeySelector, T>, "KeySelector is not invocacble with T");
+        static_assert(std::invocable<ValueSelector, T>, "ValueSelector is not invocable with T");
+        static_assert(std::strict_weak_order<KeyComparator, rpp::utils::decayed_invoke_result_t<KeySelector, T>, rpp::utils::decayed_invoke_result_t<KeySelector, T>>, "KeyComparator is not invocable with result of KeySelector");
+
+        using result_type = grouped_observable<utils::decayed_invoke_result_t<KeySelector, T>, rpp::utils::decayed_invoke_result_t<ValueSelector, T>, group_by_observable_strategy<utils::decayed_invoke_result_t<ValueSelector, T>>>;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = group_by_observer_strategy<T, TObserver, KeySelector, ValueSelector, KeyComparator>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = rpp::details::observables::fixed_disposable_strategy_selector<1>;
diff --git a/src/rpp/rpp/operators/last.hpp b/src/rpp/rpp/operators/last.hpp
index de187f3ff..e971f3ddf 100644
--- a/src/rpp/rpp/operators/last.hpp
+++ b/src/rpp/rpp/operators/last.hpp
@@ -51,10 +51,16 @@ struct last_observer_strategy
     bool is_disposed() const { return observer.is_disposed(); }
 };
 
-struct last_t : public operators::details::template_operator_observable_strategy<last_observer_strategy>
+struct last_t  : lift_operator<last_t>
 {
     template<rpp::constraint::decayed_type T>
-    using result_value = T;
+    struct operator_traits
+    {
+        using result_type = T;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = last_observer_strategy<T, TObserver>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = Prev;
diff --git a/src/rpp/rpp/operators/map.hpp b/src/rpp/rpp/operators/map.hpp
index 7ae7aa03d..9cf964fd2 100644
--- a/src/rpp/rpp/operators/map.hpp
+++ b/src/rpp/rpp/operators/map.hpp
@@ -43,11 +43,18 @@ struct map_observer_strategy
 };
 
 template<rpp::constraint::decayed_type Fn>
-struct map_t : public operators::details::operator_observable_strategy<map_observer_strategy, Fn>
+struct map_t  : lift_operator<map_t<Fn>, Fn>
 {
     template<rpp::constraint::decayed_type T>
-        requires std::invocable<Fn, T>
-    using result_value = std::invoke_result_t<Fn, T>;
+    struct operator_traits
+    {
+        static_assert(std::invocable<Fn, T>, "Fn is not invocable with T");
+
+        using result_type = std::invoke_result_t<Fn, T>;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = map_observer_strategy<TObserver, Fn>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = Prev;
diff --git a/src/rpp/rpp/operators/merge.hpp b/src/rpp/rpp/operators/merge.hpp
index 0571ebe97..0491ca8c9 100644
--- a/src/rpp/rpp/operators/merge.hpp
+++ b/src/rpp/rpp/operators/merge.hpp
@@ -133,8 +133,12 @@ class merge_observer_strategy final : public merge_observer_base_strategy<TObser
 struct merge_t
 {
     template<rpp::constraint::decayed_type T>
-        requires rpp::constraint::observable<T>
-    using result_value = rpp::utils::extract_observable_type_t<T>;
+    struct operator_traits
+    {
+        static_assert(rpp::constraint::observable<T>, "T is not observable");
+
+        using result_type = rpp::utils::extract_observable_type_t<T>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = rpp::details::observables::fixed_disposable_strategy_selector<1>;
@@ -157,8 +161,12 @@ struct merge_with_t
     RPP_NO_UNIQUE_ADDRESS rpp::utils::tuple<TObservables...> observables{};
 
     template<rpp::constraint::decayed_type T>
-        requires (std::same_as<T, rpp::utils::extract_observable_type_t<TObservables>> && ...)
-    using result_value = T;
+    struct operator_traits
+    {
+        static_assert((std::same_as<T, rpp::utils::extract_observable_type_t<TObservables>> && ...), "T is not same as values of other observables");
+
+        using result_type = T;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = rpp::details::observables::fixed_disposable_strategy_selector<1>;
diff --git a/src/rpp/rpp/operators/reduce.hpp b/src/rpp/rpp/operators/reduce.hpp
index ad69db487..36ab5e04d 100644
--- a/src/rpp/rpp/operators/reduce.hpp
+++ b/src/rpp/rpp/operators/reduce.hpp
@@ -47,13 +47,20 @@ struct reduce_observer_strategy
 };
 
 template<rpp::constraint::decayed_type Seed, rpp::constraint::decayed_type Accumulator>
-struct reduce_t : public operators::details::operator_observable_strategy_different_types<reduce_observer_strategy, rpp::utils::types<Accumulator>, Seed, Accumulator>
+struct reduce_t  : lift_operator<reduce_t<Seed, Accumulator>, Seed, Accumulator>
 {
-    using operators::details::operator_observable_strategy_different_types<reduce_observer_strategy, rpp::utils::types<Accumulator>, Seed, Accumulator>::operator_observable_strategy_different_types;
+    using operators::details::lift_operator<reduce_t<Seed, Accumulator>, Seed, Accumulator>::lift_operator;
 
     template<rpp::constraint::decayed_type T>
-        requires std::is_invocable_r_v<Seed, Accumulator, Seed&&, T>
-    using result_value = Seed;
+    struct operator_traits
+    {
+        static_assert(std::is_invocable_r_v<Seed, Accumulator, Seed&&, T>, "Accumulator is not invocable with Seed&& abnd T returning Seed");
+
+        using result_type = Seed;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = reduce_observer_strategy<TObserver, Accumulator>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = Prev;
@@ -92,11 +99,18 @@ struct reduce_no_seed_observer_strategy
 };
 
 template<rpp::constraint::decayed_type Accumulator>
-struct reduce_no_seed_t : public operators::details::operator_observable_strategy<reduce_no_seed_observer_strategy, Accumulator>
+struct reduce_no_seed_t  : lift_operator<reduce_no_seed_t<Accumulator>, Accumulator>
 {
     template<rpp::constraint::decayed_type T>
-        requires std::is_invocable_r_v<T, Accumulator, T&&, T>
-    using result_value = T;
+    struct operator_traits
+    {
+        static_assert(std::is_invocable_r_v<T, Accumulator, T&&, T>, "Accumulator is not invocable with T&& abnd T returning T");
+
+        using result_type = T;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = reduce_no_seed_observer_strategy<TObserver, Accumulator>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = Prev;
diff --git a/src/rpp/rpp/operators/scan.hpp b/src/rpp/rpp/operators/scan.hpp
index 512619715..005972de8 100644
--- a/src/rpp/rpp/operators/scan.hpp
+++ b/src/rpp/rpp/operators/scan.hpp
@@ -52,23 +52,32 @@ struct scan_observer_strategy
 };
 
 template<rpp::constraint::decayed_type InitialValue, rpp::constraint::decayed_type Fn>
-struct scan_t : public operators::details::operator_observable_strategy<scan_observer_strategy, InitialValue, Fn>
+struct scan_t  : lift_operator<scan_t<InitialValue, Fn>, InitialValue, Fn>
 {
-    using operators::details::operator_observable_strategy<scan_observer_strategy, InitialValue, Fn>::operator_observable_strategy;
+    using operators::details::lift_operator<scan_t<InitialValue, Fn>, InitialValue, Fn>::lift_operator;
 
     template<rpp::constraint::decayed_type T>
-        requires std::is_invocable_r_v<InitialValue, Fn, InitialValue&&, T>
-    using result_value = InitialValue;
+    struct operator_traits
+    {
+        static_assert(std::is_invocable_r_v<InitialValue, Fn, InitialValue&&, T>, "Accumulator is not invocable with Seed&& abnd T returning Seed");
+
+        using result_type = InitialValue;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = scan_observer_strategy<TObserver, InitialValue, Fn>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = Prev;
 };
 
-template<rpp::constraint::decayed_type Seed, rpp::constraint::observer TObserver, rpp::constraint::decayed_type Fn>
+template<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;
 
+    using Seed = rpp::utils::extract_observer_type_t<TObserver>;
+
     RPP_NO_UNIQUE_ADDRESS TObserver observer;
     RPP_NO_UNIQUE_ADDRESS Fn        fn;
     mutable std::optional<Seed>     seed{};
@@ -94,11 +103,18 @@ struct scan_no_seed_observer_strategy
 };
 
 template<rpp::constraint::decayed_type Fn>
-struct scan_no_seed_t : public operators::details::template_operator_observable_strategy<scan_no_seed_observer_strategy, Fn>
+struct scan_no_seed_t  : lift_operator<scan_no_seed_t<Fn>, Fn>
 {
     template<rpp::constraint::decayed_type T>
-        requires std::is_invocable_r_v<T, Fn, T&&, T>
-    using result_value = T;
+    struct operator_traits
+    {
+        static_assert(std::is_invocable_r_v<T, Fn, T&&, T>, "Accumulator is not invocable with T&& abnd T returning T");
+
+        using result_type = T;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = scan_no_seed_observer_strategy<TObserver, Fn>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = Prev;
diff --git a/src/rpp/rpp/operators/skip.hpp b/src/rpp/rpp/operators/skip.hpp
index 6158b887a..7ef47f385 100644
--- a/src/rpp/rpp/operators/skip.hpp
+++ b/src/rpp/rpp/operators/skip.hpp
@@ -45,10 +45,16 @@ struct skip_observer_strategy
     bool is_disposed() const { return observer.is_disposed(); }
 };
 
-struct skip_t : public operators::details::operator_observable_strategy_different_types<skip_observer_strategy, rpp::utils::types<>, size_t>
+struct skip_t  : lift_operator<skip_t, size_t>
 {
     template<rpp::constraint::decayed_type T>
-    using result_value = T;
+    struct operator_traits
+    {
+        using result_type = T;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = skip_observer_strategy<TObserver>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = Prev;
diff --git a/src/rpp/rpp/operators/subscribe_on.hpp b/src/rpp/rpp/operators/subscribe_on.hpp
index 4264a2386..a6b722187 100644
--- a/src/rpp/rpp/operators/subscribe_on.hpp
+++ b/src/rpp/rpp/operators/subscribe_on.hpp
@@ -36,7 +36,10 @@ template<rpp::schedulers::constraint::scheduler TScheduler>
 struct subscribe_on_t
 {
     template<rpp::constraint::decayed_type T>
-    using result_value = T;
+    struct operator_traits
+    {
+        using result_type = T;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = typename Prev::template add<rpp::schedulers::utils::get_worker_t<TScheduler>::is_none_disposable ? 0 : 1>;
diff --git a/src/rpp/rpp/operators/switch_on_next.hpp b/src/rpp/rpp/operators/switch_on_next.hpp
index c2ee5cb35..934036385 100644
--- a/src/rpp/rpp/operators/switch_on_next.hpp
+++ b/src/rpp/rpp/operators/switch_on_next.hpp
@@ -89,7 +89,7 @@ class switch_on_next_observer_strategy
     using preferred_disposable_strategy = rpp::details::observers::none_disposable_strategy;
 
     switch_on_next_observer_strategy(TObserver&& obs)
-        : m_state{init_state(std::move(obs))} 
+        : m_state{init_state(std::move(obs))}
     {
     }
 
@@ -127,17 +127,25 @@ class switch_on_next_observer_strategy
         ptr->get_observer()->set_upstream(d.as_weak());
         return ptr;
     }
-    
+
 private:
     std::shared_ptr<switch_on_next_state_t<TObserver>> m_state;
     rpp::composite_disposable_wrapper                  m_this_refcount = m_state->add_ref();
     mutable rpp::composite_disposable_wrapper          m_last_refcount = composite_disposable_wrapper::empty();
 };
 
-struct switch_on_next_t : public operators::details::operator_observable_strategy<switch_on_next_observer_strategy>
+struct switch_on_next_t  : lift_operator<switch_on_next_t>
 {
-    template<rpp::constraint::observable T>
-    using result_value = rpp::utils::extract_observable_type_t<T>;
+    template<rpp::constraint::decayed_type T>
+    struct operator_traits
+    {
+        static_assert(rpp::constraint::observable<T>, "T is not observable");
+
+        using result_type = rpp::utils::extract_observable_type_t<T>;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = switch_on_next_observer_strategy<TObserver>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = rpp::details::observables::fixed_disposable_strategy_selector<1>;
diff --git a/src/rpp/rpp/operators/take.hpp b/src/rpp/rpp/operators/take.hpp
index 6ac92125c..aed98fe54 100644
--- a/src/rpp/rpp/operators/take.hpp
+++ b/src/rpp/rpp/operators/take.hpp
@@ -49,10 +49,16 @@ struct take_observer_strategy
     bool is_disposed() const { return observer.is_disposed(); }
 };
 
-struct take_t : public operator_observable_strategy_different_types<take_observer_strategy, rpp::utils::types<>, size_t>
+struct take_t  : lift_operator<take_t, size_t>
 {
     template<rpp::constraint::decayed_type T>
-    using result_value = T;
+    struct operator_traits
+    {
+        using result_type = T;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = take_observer_strategy<TObserver>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = Prev;
diff --git a/src/rpp/rpp/operators/take_last.hpp b/src/rpp/rpp/operators/take_last.hpp
index bd37d5e9f..c4ffaf032 100644
--- a/src/rpp/rpp/operators/take_last.hpp
+++ b/src/rpp/rpp/operators/take_last.hpp
@@ -52,15 +52,15 @@ class take_last_observer_strategy
 
     void on_error(const std::exception_ptr& err) const { m_observer.on_error(err); }
 
-    void on_completed() const 
-    { 
+    void on_completed() const
+    {
         for (size_t i =0; i < m_data.size(); ++i)
         {
             m_observer.on_next(std::move(m_data[m_current_end]));
             m_current_end = get_next(m_current_end);
         }
 
-        m_observer.on_completed(); 
+        m_observer.on_completed();
     }
 
     void set_upstream(const disposable_wrapper& d) { m_observer.set_upstream(d); }
@@ -80,10 +80,16 @@ class take_last_observer_strategy
     mutable size_t                                                      m_current_end{};
 };
 
-struct take_last_t : public operator_observable_strategy_different_types<take_last_observer_strategy, rpp::utils::types<>, size_t>
+struct take_last_t  : lift_operator<take_last_t, size_t>
 {
     template<rpp::constraint::decayed_type T>
-    using result_value = T;
+    struct operator_traits
+    {
+        using result_type = T;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = take_last_observer_strategy<TObserver>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = Prev;
@@ -94,7 +100,7 @@ namespace rpp::operators
 {
 /**
  * @brief Emit only last `count` items provided by observable, then send `on_completed`
- * 
+ *
  * @marble take_last
  {
      source observable       : +--1-2-3-4-5-6-|
@@ -105,7 +111,7 @@ namespace rpp::operators
  *
  * @param count amount of last items to be emitted
  * @warning #include <rpp/operators/take_last.hpp>
- * 
+ *
  * @par Example
  * @snippet take_last.cpp take_last
  *
diff --git a/src/rpp/rpp/operators/take_until.hpp b/src/rpp/rpp/operators/take_until.hpp
index 05a92feaf..b8156f79b 100644
--- a/src/rpp/rpp/operators/take_until.hpp
+++ b/src/rpp/rpp/operators/take_until.hpp
@@ -46,13 +46,13 @@ struct take_until_observer_strategy_base
 
     std::shared_ptr<take_until_disposable<TObserver>> state;
 
-    void on_error(const std::exception_ptr& err) const 
+    void on_error(const std::exception_ptr& err) const
     {
         state->dispose();
         state->get_observer()->on_error(err);
     }
 
-    void on_completed() const 
+    void on_completed() const
     {
         state->dispose();
         state->get_observer()->on_completed();
@@ -90,7 +90,10 @@ struct take_until_t
     RPP_NO_UNIQUE_ADDRESS TObservable observable{};
 
     template<rpp::constraint::decayed_type T>
-    using result_value = T;
+    struct operator_traits
+    {
+        using result_type = T;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = rpp::details::observables::fixed_disposable_strategy_selector<1>;
diff --git a/src/rpp/rpp/operators/take_while.hpp b/src/rpp/rpp/operators/take_while.hpp
index 834e8916e..b8acc9867 100644
--- a/src/rpp/rpp/operators/take_while.hpp
+++ b/src/rpp/rpp/operators/take_while.hpp
@@ -44,11 +44,18 @@ struct take_while_observer_strategy
 };
 
 template<rpp::constraint::decayed_type Fn>
-struct take_while_t : public operators::details::operator_observable_strategy<take_while_observer_strategy, Fn>
+struct take_while_t  : lift_operator<take_while_t<Fn>, Fn>
 {
     template<rpp::constraint::decayed_type T>
-        requires std::is_invocable_r_v<bool, Fn, T>
-    using result_value = T;
+    struct operator_traits
+    {
+        static_assert(std::is_invocable_r_v<bool, Fn, T>, "Fn is not invocable with T returning bool");
+
+        using result_type = T;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = take_while_observer_strategy<TObserver, Fn>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = Prev;
diff --git a/src/rpp/rpp/operators/tap.hpp b/src/rpp/rpp/operators/tap.hpp
index 17b44619f..ea4098e4f 100644
--- a/src/rpp/rpp/operators/tap.hpp
+++ b/src/rpp/rpp/operators/tap.hpp
@@ -59,13 +59,20 @@ template<
     rpp::constraint::decayed_type OnNext,
     rpp::constraint::decayed_type OnError,
     rpp::constraint::decayed_type OnCompleted>
-struct tap_t : public operators::details::operator_observable_strategy<tap_observer_strategy, OnNext, OnError, OnCompleted>
+struct tap_t : public operators::details::lift_operator<tap_t<OnNext,OnError,OnCompleted>, OnNext, OnError, OnCompleted>
 {
-    using operators::details::operator_observable_strategy<tap_observer_strategy, OnNext, OnError, OnCompleted>::operator_observable_strategy;
+    using operators::details::lift_operator<tap_t<OnNext,OnError,OnCompleted>, OnNext, OnError, OnCompleted>::lift_operator;
 
     template<rpp::constraint::decayed_type T>
-        requires rpp::constraint::invocable_r_v<void, OnNext, T>
-    using result_value = T;
+    struct operator_traits
+    {
+        static_assert(rpp::constraint::invocable_r_v<void, OnNext, T>, "OnNext is not invocable with T");
+
+        using result_type = T;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = tap_observer_strategy<TObserver, OnNext, OnError, OnCompleted>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = Prev;
diff --git a/src/rpp/rpp/operators/throttle.hpp b/src/rpp/rpp/operators/throttle.hpp
index 2decc7234..55e5aaf56 100644
--- a/src/rpp/rpp/operators/throttle.hpp
+++ b/src/rpp/rpp/operators/throttle.hpp
@@ -51,10 +51,16 @@ struct throttle_observer_strategy
 };
 
 template<rpp::schedulers::constraint::scheduler Scheduler>
-struct throttle_t : public operators::details::operator_observable_strategy_different_types<throttle_observer_strategy, rpp::utils::types<Scheduler>, rpp::schedulers::duration>
+struct throttle_t  : lift_operator<throttle_t<Scheduler>, rpp::schedulers::duration>
 {
     template<rpp::constraint::decayed_type T>
-    using result_value = T;
+    struct operator_traits
+    {
+        using result_type = T;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = throttle_observer_strategy<TObserver, Scheduler>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = Prev;
diff --git a/src/rpp/rpp/operators/window.hpp b/src/rpp/rpp/operators/window.hpp
index 30d6d0ef2..f5d32a074 100644
--- a/src/rpp/rpp/operators/window.hpp
+++ b/src/rpp/rpp/operators/window.hpp
@@ -102,10 +102,16 @@ class window_observer_strategy
     mutable size_t                      m_items_in_current_window = m_window_size;
 };
 
-struct window_t : public operators::details::operator_observable_strategy_different_types<window_observer_strategy, rpp::utils::types<>, size_t>
+struct window_t  : lift_operator<window_t, size_t>
 {
     template<rpp::constraint::decayed_type T>
-    using result_value = window_observable<T>;
+    struct operator_traits
+    {
+        using result_type = window_observable<T>;
+
+        template<rpp::constraint::observer_of_type<result_type> TObserver>
+        using observer_strategy = window_observer_strategy<TObserver>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = rpp::details::observables::fixed_disposable_strategy_selector<1>;
diff --git a/src/rpp/rpp/operators/window_toggle.hpp b/src/rpp/rpp/operators/window_toggle.hpp
index 72e64491b..8517d959e 100644
--- a/src/rpp/rpp/operators/window_toggle.hpp
+++ b/src/rpp/rpp/operators/window_toggle.hpp
@@ -185,13 +185,16 @@ class window_toggle_observer_strategy
 
 template<rpp::constraint::observable TOpeningsObservable, typename TClosingsSelectorFn>
     requires rpp::constraint::observable<std::invoke_result_t<TClosingsSelectorFn, rpp::utils::extract_observable_type_t<TOpeningsObservable>>>
-struct window_toggle_t //: public operators::details::operator_observable_strategy<window_toggle_observer_strategy, TOpeningsObservable, TClosingsSelectorFn>
+struct window_toggle_t
 {
     RPP_NO_UNIQUE_ADDRESS TOpeningsObservable openings;
     RPP_NO_UNIQUE_ADDRESS TClosingsSelectorFn closings_selector;
 
     template<rpp::constraint::decayed_type T>
-    using result_value = rpp::window_toggle_observable<T>;
+    struct operator_traits
+    {
+        using result_type = rpp::window_toggle_observable<T>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = rpp::details::observables::fixed_disposable_strategy_selector<1>;
diff --git a/src/rpp/rpp/operators/with_latest_from.hpp b/src/rpp/rpp/operators/with_latest_from.hpp
index 94900b5fa..ba3814526 100644
--- a/src/rpp/rpp/operators/with_latest_from.hpp
+++ b/src/rpp/rpp/operators/with_latest_from.hpp
@@ -131,8 +131,12 @@ struct with_latest_from_t
     RPP_NO_UNIQUE_ADDRESS TSelector                          selector;
 
     template<rpp::constraint::decayed_type T>
-        requires std::invocable<TSelector, T, rpp::utils::extract_observable_type_t<TObservables>...>
-    using result_value = std::invoke_result_t<TSelector, T, rpp::utils::extract_observable_type_t<TObservables>...>;
+    struct operator_traits
+    {
+        static_assert(std::invocable<TSelector, T, rpp::utils::extract_observable_type_t<TObservables>...>, "TSelector is not invocable with T and types of rest observables");
+
+        using result_type = std::invoke_result_t<TSelector, T, rpp::utils::extract_observable_type_t<TObservables>...>;
+    };
 
     template<rpp::details::observables::constraint::disposable_strategy Prev>
     using updated_disposable_strategy = rpp::details::observables::fixed_disposable_strategy_selector<1>;