diff --git a/src/rpp/rpp/disposables/fwd.hpp b/src/rpp/rpp/disposables/fwd.hpp
index 6cfb7344a..eb5bcb7e6 100644
--- a/src/rpp/rpp/disposables/fwd.hpp
+++ b/src/rpp/rpp/disposables/fwd.hpp
@@ -11,6 +11,7 @@
 #pragma once
 
 #include <rpp/utils/constraints.hpp>
+#include <rpp/utils/function_traits.hpp>
 
 namespace rpp::details
 {
diff --git a/src/rpp/rpp/operators/combine_latest.hpp b/src/rpp/rpp/operators/combine_latest.hpp
index 2beeffc94..5c72dd3d9 100644
--- a/src/rpp/rpp/operators/combine_latest.hpp
+++ b/src/rpp/rpp/operators/combine_latest.hpp
@@ -99,7 +99,7 @@ namespace rpp::operators
      * @see https://reactivex.io/documentation/operators/combinelatest.html
      */
     template<typename TSelector, rpp::constraint::observable TObservable, rpp::constraint::observable... TObservables>
-        requires (!rpp::constraint::observable<TSelector> && (!utils::is_not_template_callable<TSelector> || std::invocable<TSelector, rpp::utils::convertible_to_any, utils::extract_observable_type_t<TObservable>, utils::extract_observable_type_t<TObservables>...>))
+        requires (!rpp::constraint::observable<TSelector> && (constraint::template_callable_or_invocable<TSelector, rpp::utils::convertible_to_any, utils::extract_observable_type_t<TObservable>, utils::extract_observable_type_t<TObservables>...>))
     auto combine_latest(TSelector&& selector, TObservable&& observable, TObservables&&... observables)
     {
         return details::combine_latest_t<std::decay_t<TSelector>, std::decay_t<TObservable>, std::decay_t<TObservables>...>{
diff --git a/src/rpp/rpp/operators/distinct_until_changed.hpp b/src/rpp/rpp/operators/distinct_until_changed.hpp
index 91ecf0ccb..0f51c76cb 100644
--- a/src/rpp/rpp/operators/distinct_until_changed.hpp
+++ b/src/rpp/rpp/operators/distinct_until_changed.hpp
@@ -55,7 +55,7 @@ namespace rpp::operators::details
         template<rpp::constraint::decayed_type 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");
+            static_assert(rpp::constraint::invocable_ret<bool, EqualityFn, T, T>, "EqualityFn is not invocable with T and T returning bool");
 
             using result_type = T;
 
@@ -97,9 +97,9 @@ namespace rpp::operators
      * @see https://reactivex.io/documentation/operators/distinct.html
      */
     template<typename EqualityFn>
-        requires (!utils::is_not_template_callable<EqualityFn> || std::same_as<bool, std::invoke_result_t<EqualityFn, rpp::utils::convertible_to_any, rpp::utils::convertible_to_any>>)
     auto distinct_until_changed(EqualityFn&& equality_fn)
     {
+        static_assert(constraint::template_callable_or_invocable_ret<bool, EqualityFn, rpp::utils::convertible_to_any, rpp::utils::convertible_to_any>, "EqualityFn is not invocable with T and T returning bool");
         return details::distinct_until_changed_t<std::decay_t<EqualityFn>>{std::forward<EqualityFn>(equality_fn)};
     }
 } // namespace rpp::operators
diff --git a/src/rpp/rpp/operators/filter.hpp b/src/rpp/rpp/operators/filter.hpp
index 32b842569..ba5ab3af1 100644
--- a/src/rpp/rpp/operators/filter.hpp
+++ b/src/rpp/rpp/operators/filter.hpp
@@ -91,9 +91,9 @@ namespace rpp::operators
     * @see https://reactivex.io/documentation/operators/filter.html
     */
     template<typename Fn>
-        requires (!utils::is_not_template_callable<Fn> || std::same_as<bool, std::invoke_result_t<Fn, rpp::utils::convertible_to_any>>)
     auto filter(Fn&& predicate)
     {
+        static_assert(constraint::template_callable_or_invocable_ret<bool, Fn, rpp::utils::convertible_to_any>, "Fn is not invocable with T returning bool");
         return details::filter_t<std::decay_t<Fn>>{std::forward<Fn>(predicate)};
     }
 } // namespace rpp::operators
diff --git a/src/rpp/rpp/operators/flat_map.hpp b/src/rpp/rpp/operators/flat_map.hpp
index 8044cd752..0c975548d 100644
--- a/src/rpp/rpp/operators/flat_map.hpp
+++ b/src/rpp/rpp/operators/flat_map.hpp
@@ -64,9 +64,9 @@ namespace rpp::operators
      * @see https://reactivex.io/documentation/operators/flatmap.html
      */
     template<typename Fn>
-        requires (!utils::is_not_template_callable<Fn> || rpp::constraint::observable<std::invoke_result_t<Fn, rpp::utils::convertible_to_any>>)
     auto flat_map(Fn&& callable)
     {
+        static_assert(!constraint::is_not_template_callable<Fn> || rpp::constraint::observable<std::invoke_result_t<Fn, rpp::utils::convertible_to_any>>, "Fn is not invocable with T returning observable");
         return details::flat_map_t<std::decay_t<Fn>>{std::forward<Fn>(callable)};
     }
 
diff --git a/src/rpp/rpp/operators/fwd.hpp b/src/rpp/rpp/operators/fwd.hpp
index 131f04036..dd44255a3 100644
--- a/src/rpp/rpp/operators/fwd.hpp
+++ b/src/rpp/rpp/operators/fwd.hpp
@@ -27,7 +27,7 @@ namespace rpp::operators
     auto concat();
 
     template<typename TSelector, rpp::constraint::observable TObservable, rpp::constraint::observable... TObservables>
-        requires (!rpp::constraint::observable<TSelector> && (!utils::is_not_template_callable<TSelector> || std::invocable<TSelector, rpp::utils::convertible_to_any, utils::extract_observable_type_t<TObservable>, utils::extract_observable_type_t<TObservables>...>))
+        requires (!rpp::constraint::observable<TSelector> && (constraint::template_callable_or_invocable<TSelector, rpp::utils::convertible_to_any, utils::extract_observable_type_t<TObservable>, utils::extract_observable_type_t<TObservables>...>))
     auto combine_latest(TSelector&& selector, TObservable&& observable, TObservables&&... observables);
 
     template<rpp::constraint::observable TObservable, rpp::constraint::observable... TObservables>
@@ -42,7 +42,6 @@ namespace rpp::operators
     auto distinct();
 
     template<typename EqualityFn = rpp::utils::equal_to>
-        requires (!utils::is_not_template_callable<EqualityFn> || std::same_as<bool, std::invoke_result_t<EqualityFn, rpp::utils::convertible_to_any, rpp::utils::convertible_to_any>>)
     auto distinct_until_changed(EqualityFn&& equality_fn = {});
 
     auto element_at(size_t index);
@@ -50,27 +49,20 @@ namespace rpp::operators
     auto first();
 
     template<typename Fn>
-        requires (!utils::is_not_template_callable<Fn> || std::same_as<bool, std::invoke_result_t<Fn, rpp::utils::convertible_to_any>>)
     auto filter(Fn&& predicate);
 
     template<std::invocable<> LastFn>
     auto finally(LastFn&& lastFn);
 
     template<typename Fn>
-        requires (!utils::is_not_template_callable<Fn> || rpp::constraint::observable<std::invoke_result_t<Fn, rpp::utils::convertible_to_any>>)
     auto flat_map(Fn&& callable);
 
-    template<typename KeySelector,
-             typename ValueSelector = std::identity,
-             typename KeyComparator = rpp::utils::less>
-        requires (
-            (!utils::is_not_template_callable<KeySelector> || !std::same_as<void, std::invoke_result_t<KeySelector, rpp::utils::convertible_to_any>>) && (!utils::is_not_template_callable<ValueSelector> || !std::same_as<void, std::invoke_result_t<ValueSelector, rpp::utils::convertible_to_any>>) && (!utils::is_not_template_callable<KeyComparator> || std::strict_weak_order<KeyComparator, rpp::utils::convertible_to_any, rpp::utils::convertible_to_any>))
+    template<typename KeySelector, typename ValueSelector = std::identity, typename KeyComparator = rpp::utils::less>
     auto group_by(KeySelector&& key_selector, ValueSelector&& value_selector = {}, KeyComparator&& comparator = {});
 
     auto last();
 
     template<typename Fn>
-        requires (!utils::is_not_template_callable<Fn> || !std::same_as<void, std::invoke_result_t<Fn, rpp::utils::convertible_to_any>>)
     auto map(Fn&& callable);
 
     template<rpp::constraint::subject Subject>
@@ -79,13 +71,9 @@ namespace rpp::operators
     template<template<typename> typename Subject = rpp::subjects::publish_subject>
     auto multicast();
 
-    template<typename Fn>
-        requires (!utils::is_not_template_callable<Fn> || rpp::constraint::observable<std::invoke_result_t<Fn, rpp::utils::convertible_to_any>>)
-    auto flat_map(Fn&& callable);
-
     template<rpp::constraint::observable TObservable, rpp::constraint::observable... TObservables>
-        requires constraint::observables_of_same_type<std::decay_t<TObservable>, std::decay_t<TObservables>...>
     auto merge_with(TObservable&& observable, TObservables&&... observables);
+
     auto merge();
 
     template<rpp::schedulers::constraint::scheduler Scheduler>
@@ -94,7 +82,6 @@ namespace rpp::operators
     auto publish();
 
     template<typename Seed, typename Accumulator>
-        requires (!utils::is_not_template_callable<Accumulator> || std::same_as<std::decay_t<Seed>, std::invoke_result_t<Accumulator, std::decay_t<Seed> &&, rpp::utils::convertible_to_any>>)
     auto reduce(Seed&& seed, Accumulator&& accumulator);
 
     template<typename Accumulator>
@@ -110,9 +97,8 @@ namespace rpp::operators
 
     auto retry();
 
-    template<typename InitialValue, typename Fn>
-        requires (!utils::is_not_template_callable<Fn> || std::same_as<std::decay_t<InitialValue>, std::invoke_result_t<Fn, std::decay_t<InitialValue> &&, rpp::utils::convertible_to_any>>)
-    auto scan(InitialValue&& initial_value, Fn&& accumulator);
+    template<typename Seed, typename Fn>
+    auto scan(Seed&& seed, Fn&& accumulator);
 
     template<typename Fn>
     auto scan(Fn&& accumulator);
@@ -149,14 +135,13 @@ namespace rpp::operators
     auto take_last(size_t count);
 
     template<typename Fn>
-        requires (!utils::is_not_template_callable<Fn> || std::same_as<bool, std::invoke_result_t<Fn, rpp::utils::convertible_to_any>>)
     auto take_while(Fn&& predicate);
 
     template<rpp::constraint::observable TObservable>
     auto take_until(TObservable&& until_observable);
 
     template<std::invocable<const std::exception_ptr&> OnError = rpp::utils::empty_function_t<std::exception_ptr>>
-        requires utils::is_not_template_callable<OnError>
+        requires (constraint::is_not_template_callable<OnError>)
     auto tap(OnError&& on_error);
 
     template<std::invocable<> OnCompleted = rpp::utils::empty_function_t<>>
@@ -170,7 +155,7 @@ namespace rpp::operators
     template<typename OnNext                                       = rpp::utils::empty_function_any_t,
              std::invocable<const std::exception_ptr&> OnError     = rpp::utils::empty_function_t<std::exception_ptr>,
              std::invocable<>                          OnCompleted = rpp::utils::empty_function_t<>>
-        requires utils::is_not_template_callable<OnError>
+        requires (constraint::is_not_template_callable<OnError>)
     auto tap(OnNext&&      on_next      = {},
              OnError&&     on_error     = {},
              OnCompleted&& on_completed = {});
@@ -185,15 +170,13 @@ namespace rpp::operators
     auto throttle(rpp::schedulers::duration period);
 
     template<typename Selector>
-        requires rpp::constraint::observable<std::invoke_result_t<Selector, std::exception_ptr>>
     auto on_error_resume_next(Selector&& selector);
 
     template<typename Notifier>
-        requires rpp::constraint::observable<std::invoke_result_t<Notifier, std::exception_ptr>>
     auto retry_when(Notifier&& notifier);
 
     template<typename TSelector, rpp::constraint::observable TObservable, rpp::constraint::observable... TObservables>
-        requires (!rpp::constraint::observable<TSelector> && (!utils::is_not_template_callable<TSelector> || std::invocable<TSelector, rpp::utils::convertible_to_any, utils::extract_observable_type_t<TObservable>, utils::extract_observable_type_t<TObservables>...>))
+        requires (!rpp::constraint::observable<TSelector> && (constraint::template_callable_or_invocable<TSelector, rpp::utils::convertible_to_any, utils::extract_observable_type_t<TObservable>, utils::extract_observable_type_t<TObservables>...>))
     auto with_latest_from(TSelector&& selector, TObservable&& observable, TObservables&&... observables);
 
     template<rpp::constraint::observable TObservable, rpp::constraint::observable... TObservables>
@@ -206,7 +189,7 @@ namespace rpp::operators
     auto window_toggle(TOpeningsObservable&& openings, TClosingsSelectorFn&& closings_selector);
 
     template<typename TSelector, rpp::constraint::observable TObservable, rpp::constraint::observable... TObservables>
-        requires (!rpp::constraint::observable<TSelector> && (!utils::is_not_template_callable<TSelector> || std::invocable<TSelector, rpp::utils::convertible_to_any, utils::extract_observable_type_t<TObservable>, utils::extract_observable_type_t<TObservables>...>))
+        requires (!rpp::constraint::observable<TSelector> && (constraint::template_callable_or_invocable<TSelector, rpp::utils::convertible_to_any, utils::extract_observable_type_t<TObservable>, utils::extract_observable_type_t<TObservables>...>))
     auto zip(TSelector&& selector, TObservable&& observable, TObservables&&... observables);
 
     template<rpp::constraint::observable TObservable, rpp::constraint::observable... TObservables>
diff --git a/src/rpp/rpp/operators/group_by.hpp b/src/rpp/rpp/operators/group_by.hpp
index 4e1d8d1fc..bd9796679 100644
--- a/src/rpp/rpp/operators/group_by.hpp
+++ b/src/rpp/rpp/operators/group_by.hpp
@@ -215,10 +215,12 @@ namespace rpp::operators
     template<typename KeySelector,
              typename ValueSelector,
              typename KeyComparator>
-        requires (
-            (!utils::is_not_template_callable<KeySelector> || !std::same_as<void, std::invoke_result_t<KeySelector, rpp::utils::convertible_to_any>>) && (!utils::is_not_template_callable<ValueSelector> || !std::same_as<void, std::invoke_result_t<ValueSelector, rpp::utils::convertible_to_any>>) && (!utils::is_not_template_callable<KeyComparator> || std::strict_weak_order<KeyComparator, rpp::utils::convertible_to_any, rpp::utils::convertible_to_any>))
     auto group_by(KeySelector&& key_selector, ValueSelector&& value_selector, KeyComparator&& comparator)
     {
+        static_assert(constraint::template_callable_or_invocable_ret_non_void<KeySelector, rpp::utils::convertible_to_any>, "KeySelector is not invocable with T returning non-void");
+        static_assert(constraint::template_callable_or_invocable_ret_non_void<ValueSelector, rpp::utils::convertible_to_any>, "ValueSelector is not invocable with T returning non-void");
+        static_assert(!constraint::is_not_template_callable<KeyComparator> || std::strict_weak_order<KeyComparator, rpp::utils::convertible_to_any, rpp::utils::convertible_to_any>, "KeyComparator is not invocable with (result of KeySelector, result of KeySelector) returning bool");
+
         return details::group_by_t<std::decay_t<KeySelector>, std::decay_t<ValueSelector>, std::decay_t<KeyComparator>>{
             std::forward<KeySelector>(key_selector),
             std::forward<ValueSelector>(value_selector),
diff --git a/src/rpp/rpp/operators/map.hpp b/src/rpp/rpp/operators/map.hpp
index 74e3fad4d..0baea934a 100644
--- a/src/rpp/rpp/operators/map.hpp
+++ b/src/rpp/rpp/operators/map.hpp
@@ -94,9 +94,9 @@ namespace rpp::operators
      * @see https://reactivex.io/documentation/operators/map.html
      */
     template<typename Fn>
-        requires (!utils::is_not_template_callable<Fn> || !std::same_as<void, std::invoke_result_t<Fn, rpp::utils::convertible_to_any>>)
     auto map(Fn&& callable)
     {
+        static_assert(constraint::template_callable_or_invocable_ret_non_void<Fn, rpp::utils::convertible_to_any>, "Fn is not invocable with T returning non-void");
         return details::map_t<std::decay_t<Fn>>{std::forward<Fn>(callable)};
     }
 } // namespace rpp::operators
diff --git a/src/rpp/rpp/operators/merge.hpp b/src/rpp/rpp/operators/merge.hpp
index 791a65f84..fccbcbf61 100644
--- a/src/rpp/rpp/operators/merge.hpp
+++ b/src/rpp/rpp/operators/merge.hpp
@@ -253,9 +253,9 @@ namespace rpp::operators
      * @see https://reactivex.io/documentation/operators/merge.html
      */
     template<rpp::constraint::observable TObservable, rpp::constraint::observable... TObservables>
-        requires constraint::observables_of_same_type<std::decay_t<TObservable>, std::decay_t<TObservables>...>
     auto merge_with(TObservable&& observable, TObservables&&... observables)
     {
+        static_assert(constraint::observables_of_same_type<std::decay_t<TObservable>, std::decay_t<TObservables>...>, "observables should be of same type");
         return details::merge_with_t<std::decay_t<TObservable>, std::decay_t<TObservables>...>{
             rpp::utils::tuple{std::forward<TObservable>(observable), std::forward<TObservables>(observables)...}};
     }
diff --git a/src/rpp/rpp/operators/on_error_resume_next.hpp b/src/rpp/rpp/operators/on_error_resume_next.hpp
index 23d1c820b..5a91136a5 100644
--- a/src/rpp/rpp/operators/on_error_resume_next.hpp
+++ b/src/rpp/rpp/operators/on_error_resume_next.hpp
@@ -136,9 +136,9 @@ namespace rpp::operators
      * @see https://reactivex.io/documentation/operators/catch.html
      */
     template<typename Selector>
-        requires rpp::constraint::observable<std::invoke_result_t<Selector, std::exception_ptr>>
     auto on_error_resume_next(Selector&& selector)
     {
+        static_assert(rpp::constraint::observable<std::invoke_result_t<Selector, std::exception_ptr>>, "Selector is not invocable with std::exception_ptr returning new observable");
         return details::on_error_resume_next_t<std::decay_t<Selector>>{std::forward<Selector>(selector)};
     }
 } // namespace rpp::operators
diff --git a/src/rpp/rpp/operators/reduce.hpp b/src/rpp/rpp/operators/reduce.hpp
index fd15960ba..18b0a80a8 100644
--- a/src/rpp/rpp/operators/reduce.hpp
+++ b/src/rpp/rpp/operators/reduce.hpp
@@ -131,7 +131,7 @@ namespace rpp::operators
          operator "reduce: s=10, (s,x)=>s+x" : +------16|
      }
      *
-     * @param initial_value initial value for seed
+     * @param seed initial value for seed
      * @param accumulator function which accepts seed value and new value from observable and return new value of seed. Can accept seed by move-reference.
      *
      * @warning #include <rpp/operators/reduce.hpp>
@@ -143,9 +143,9 @@ namespace rpp::operators
      * @see https://reactivex.io/documentation/operators/reduce.html
      */
     template<typename Seed, typename Accumulator>
-        requires (!utils::is_not_template_callable<Accumulator> || std::same_as<std::decay_t<Seed>, std::invoke_result_t<Accumulator, std::decay_t<Seed> &&, rpp::utils::convertible_to_any>>)
     auto reduce(Seed&& seed, Accumulator&& accumulator)
     {
+        static_assert(constraint::template_callable_or_invocable_ret<std::decay_t<Seed>, std::invoke_result_t<Accumulator, std::decay_t<Seed>&&, rpp::utils::convertible_to_any>>, "Accumulator is not invocable with Seed&& and T returning Seed");
         return details::reduce_t<std::decay_t<Seed>, std::decay_t<Accumulator>>{std::forward<Seed>(seed), std::forward<Accumulator>(accumulator)};
     }
 
@@ -160,7 +160,6 @@ namespace rpp::operators
      *
      * @details There is no initial value for seed, so, first value would be used as seed value and forwarded as is.
      *
-     * @param initial_value initial value for seed
      * @param accumulator function which accepts seed value and new value from observable and return new value of seed. Can accept seed by move-reference.
      *
      * @warning #include <rpp/operators/reduce.hpp>
diff --git a/src/rpp/rpp/operators/retry_when.hpp b/src/rpp/rpp/operators/retry_when.hpp
index d5ad56a69..b67dd5438 100644
--- a/src/rpp/rpp/operators/retry_when.hpp
+++ b/src/rpp/rpp/operators/retry_when.hpp
@@ -190,9 +190,9 @@ namespace rpp::operators
      * @see https://reactivex.io/documentation/operators/retry.html
      */
     template<typename TNotifier>
-        requires rpp::constraint::observable<std::invoke_result_t<TNotifier, std::exception_ptr>>
     auto retry_when(TNotifier&& notifier)
     {
+        static_assert(rpp::constraint::observable<std::invoke_result_t<TNotifier, std::exception_ptr>>, "Notifier is not invocable with std::exception_ptr returning new observable");
         return details::retry_when_t<std::decay_t<TNotifier>>{std::forward<TNotifier>(notifier)};
     }
 } // namespace rpp::operators
diff --git a/src/rpp/rpp/operators/scan.hpp b/src/rpp/rpp/operators/scan.hpp
index 66064e127..3b6c9cf6a 100644
--- a/src/rpp/rpp/operators/scan.hpp
+++ b/src/rpp/rpp/operators/scan.hpp
@@ -138,7 +138,7 @@ namespace rpp::operators
      * - No any heap allocations at all
      * - Keep actual seed/cache inside observable and updating it every emission
      *
-     * @param initial_value initial value for seed which would be sent during subscription and applied for first value from observable. Then it will be replaced with result and etc.
+     * @param seed initial value for seed which would be sent during subscription and applied for first value from observable. Then it will be replaced with result and etc.
      * @param accumulator function which accepts seed value and new value from observable and return new value of seed. Can accept seed by move-reference.
      *
      * @warning #include <rpp/operators/scan.hpp>
@@ -150,11 +150,11 @@ namespace rpp::operators
      * @ingroup transforming_operators
      * @see https://reactivex.io/documentation/operators/scan.html
      */
-    template<typename InitialValue, typename Fn>
-        requires (!utils::is_not_template_callable<Fn> || std::same_as<std::decay_t<InitialValue>, std::invoke_result_t<Fn, std::decay_t<InitialValue> &&, rpp::utils::convertible_to_any>>)
-    auto scan(InitialValue&& initial_value, Fn&& accumulator)
+    template<typename Seed, typename Fn>
+    auto scan(Seed&& seed, Fn&& accumulator)
     {
-        return details::scan_t<std::decay_t<InitialValue>, std::decay_t<Fn>>{std::forward<InitialValue>(initial_value), std::forward<Fn>(accumulator)};
+        static_assert(constraint::template_callable_or_invocable_ret<std::decay_t<Seed>, std::invoke_result_t<Fn, std::decay_t<Seed>&&, rpp::utils::convertible_to_any>>, "Accumulator is not invocable with Seed and T returning seed");
+        return details::scan_t<std::decay_t<Seed>, std::decay_t<Fn>>{std::forward<Seed>(seed), std::forward<Fn>(accumulator)};
     }
 
     /**
diff --git a/src/rpp/rpp/operators/subscribe.hpp b/src/rpp/rpp/operators/subscribe.hpp
index 9f9c75813..ec87fa8d1 100644
--- a/src/rpp/rpp/operators/subscribe.hpp
+++ b/src/rpp/rpp/operators/subscribe.hpp
@@ -209,7 +209,7 @@ namespace rpp::operators::details
     subscribe_t(const Args&...) -> subscribe_t<Args...>;
 
     template<typename OnNext>
-    concept on_next_like = (!rpp::utils::is_not_template_callable<OnNext> || std::invocable<OnNext, rpp::utils::convertible_to_any>) && (!rpp::constraint::decayed_same_as<OnNext, rpp::composite_disposable_wrapper> && !rpp::constraint::observer_strategy_base<OnNext> && !rpp::constraint::observer<OnNext>);
+    concept on_next_like = (rpp::constraint::template_callable_or_invocable<OnNext, rpp::utils::convertible_to_any>) && (!rpp::constraint::decayed_same_as<OnNext, rpp::composite_disposable_wrapper> && !rpp::constraint::observer_strategy_base<OnNext> && !rpp::constraint::observer<OnNext>);
 } // namespace rpp::operators::details
 
 namespace rpp::operators
diff --git a/src/rpp/rpp/operators/take_while.hpp b/src/rpp/rpp/operators/take_while.hpp
index 9d6d8d8d0..d861c5eaf 100644
--- a/src/rpp/rpp/operators/take_while.hpp
+++ b/src/rpp/rpp/operators/take_while.hpp
@@ -91,9 +91,9 @@ namespace rpp::operators
      * @see https://reactivex.io/documentation/operators/takewhile.html
      */
     template<typename Fn>
-        requires (!utils::is_not_template_callable<Fn> || std::same_as<bool, std::invoke_result_t<Fn, rpp::utils::convertible_to_any>>)
     auto take_while(Fn&& predicate)
     {
+        static_assert(constraint::template_callable_or_invocable_ret<bool, Fn, rpp::utils::convertible_to_any>, "Fn is not invocable with T returning bool");
         return details::take_while_t<std::decay_t<Fn>>{std::forward<Fn>(predicate)};
     }
 } // namespace rpp::operators
diff --git a/src/rpp/rpp/operators/tap.hpp b/src/rpp/rpp/operators/tap.hpp
index be29f9117..ce6ea617a 100644
--- a/src/rpp/rpp/operators/tap.hpp
+++ b/src/rpp/rpp/operators/tap.hpp
@@ -66,7 +66,7 @@ namespace rpp::operators::details
         template<rpp::constraint::decayed_type T>
         struct operator_traits
         {
-            static_assert(rpp::constraint::invocable_r_v<void, OnNext, T>, "OnNext is not invocable with T");
+            static_assert(rpp::constraint::invocable_ret<void, OnNext, T>, "OnNext is not invocable with T");
 
             using result_type = T;
 
@@ -90,7 +90,7 @@ namespace rpp::operators
      * @see https://reactivex.io/documentation/operators/do.html
      */
     template<std::invocable<const std::exception_ptr&> OnError /* = rpp::utils::empty_function_t<std::exception_ptr> */>
-        requires utils::is_not_template_callable<OnError>
+        requires (constraint::is_not_template_callable<OnError>)
     auto tap(OnError&& on_error)
     {
         using OnNext      = rpp::utils::empty_function_any_t;
@@ -157,7 +157,7 @@ namespace rpp::operators
     template<typename OnNext /* = rpp::utils::empty_function_any_t */,
              std::invocable<const std::exception_ptr&> OnError /* = rpp::utils::empty_function_t<std::exception_ptr> */,
              std::invocable<>                          OnCompleted /* = rpp::utils::empty_function_t<> */>
-        requires utils::is_not_template_callable<OnError>
+        requires (constraint::is_not_template_callable<OnError>)
     auto tap(OnNext&&      on_next /* = {} */,
              OnError&&     on_error /* = {} */,
              OnCompleted&& on_completed /* = {} */)
diff --git a/src/rpp/rpp/operators/with_latest_from.hpp b/src/rpp/rpp/operators/with_latest_from.hpp
index 1e0eff555..ead3c02aa 100644
--- a/src/rpp/rpp/operators/with_latest_from.hpp
+++ b/src/rpp/rpp/operators/with_latest_from.hpp
@@ -198,7 +198,7 @@ namespace rpp::operators
      * @see https://reactivex.io/documentation/operators/combinelatest.html
      */
     template<typename TSelector, rpp::constraint::observable TObservable, rpp::constraint::observable... TObservables>
-        requires (!rpp::constraint::observable<TSelector> && (!utils::is_not_template_callable<TSelector> || std::invocable<TSelector, rpp::utils::convertible_to_any, utils::extract_observable_type_t<TObservable>, utils::extract_observable_type_t<TObservables>...>))
+        requires (!rpp::constraint::observable<TSelector> && (constraint::template_callable_or_invocable<TSelector, rpp::utils::convertible_to_any, utils::extract_observable_type_t<TObservable>, utils::extract_observable_type_t<TObservables>...>))
     auto with_latest_from(TSelector&& selector, TObservable&& observable, TObservables&&... observables)
     {
         return details::with_latest_from_t<std::decay_t<TSelector>, std::decay_t<TObservable>, std::decay_t<TObservables>...>{
diff --git a/src/rpp/rpp/operators/zip.hpp b/src/rpp/rpp/operators/zip.hpp
index f785dc7ad..2d06bcdbb 100644
--- a/src/rpp/rpp/operators/zip.hpp
+++ b/src/rpp/rpp/operators/zip.hpp
@@ -99,7 +99,7 @@ namespace rpp::operators
      * @see https://reactivex.io/documentation/operators/zip.html
      */
     template<typename TSelector, rpp::constraint::observable TObservable, rpp::constraint::observable... TObservables>
-        requires (!rpp::constraint::observable<TSelector> && (!utils::is_not_template_callable<TSelector> || std::invocable<TSelector, rpp::utils::convertible_to_any, utils::extract_observable_type_t<TObservable>, utils::extract_observable_type_t<TObservables>...>))
+        requires (!rpp::constraint::observable<TSelector> && (constraint::template_callable_or_invocable<TSelector, rpp::utils::convertible_to_any, utils::extract_observable_type_t<TObservable>, utils::extract_observable_type_t<TObservables>...>))
     auto zip(TSelector&& selector, TObservable&& observable, TObservables&&... observables)
     {
         return details::zip_t<std::decay_t<TSelector>, std::decay_t<TObservable>, std::decay_t<TObservables>...>{
diff --git a/src/rpp/rpp/sources/fwd.hpp b/src/rpp/rpp/sources/fwd.hpp
index feb77ae56..5837448fb 100644
--- a/src/rpp/rpp/sources/fwd.hpp
+++ b/src/rpp/rpp/sources/fwd.hpp
@@ -36,7 +36,7 @@ namespace rpp::source
     template<constraint::decayed_type Type, constraint::on_subscribe<Type> OnSubscribe>
     auto create(OnSubscribe&& on_subscribe);
 
-    template<utils::is_not_template_callable OnSubscribe, constraint::decayed_type Type = rpp::utils::extract_observer_type_t<rpp::utils::decayed_function_argument_t<OnSubscribe>>>
+    template<constraint::is_not_template_callable OnSubscribe, constraint::decayed_type Type = rpp::utils::extract_observer_type_t<rpp::utils::decayed_function_argument_t<OnSubscribe>>>
     auto create(OnSubscribe&& on_subscribe);
 
     template<constraint::memory_model MemoryModel = memory_model::use_stack, constraint::iterable Iterable, schedulers::constraint::scheduler TScheduler = rpp::schedulers::defaults::iteration_scheduler>
diff --git a/src/rpp/rpp/utils/constraints.hpp b/src/rpp/rpp/utils/constraints.hpp
index 87e9d5792..0de24e899 100644
--- a/src/rpp/rpp/utils/constraints.hpp
+++ b/src/rpp/rpp/utils/constraints.hpp
@@ -46,12 +46,6 @@ namespace rpp::constraint
         } -> std::same_as<T>;
     };
 
-    template<typename Ret, typename Fn, typename... Args>
-    concept invocable_r_v = std::invocable<Fn, Args...> && std::same_as<Ret, std::invoke_result_t<Fn, Args...>>;
-
-    template<typename Fn, typename... Args>
-    concept is_nothrow_invocable = std::is_nothrow_invocable_v<Fn, Args...>;
-
     template<typename T>
     concept hashable = requires(T a) {
         {
diff --git a/src/rpp/rpp/utils/function_traits.hpp b/src/rpp/rpp/utils/function_traits.hpp
index 5d4a3205b..07d4eaa0b 100644
--- a/src/rpp/rpp/utils/function_traits.hpp
+++ b/src/rpp/rpp/utils/function_traits.hpp
@@ -41,11 +41,38 @@ namespace rpp::utils
     {
     };
 
+} // namespace rpp::utils
+
+namespace rpp::constraint
+{
+
     template<typename T>
-    concept is_not_template_callable = is_not_template_callable_t<T>::value;
+    concept is_not_template_callable = utils::is_not_template_callable_t<T>::value;
+
+    template<typename Fn, typename... Args>
+    concept invocable = std::invocable<Fn, Args...>;
+
+    template<typename Ret, typename Fn, typename... Args>
+    concept invocable_ret = invocable<Fn, Args...> && std::same_as<Ret, std::invoke_result_t<Fn, Args...>>;
+
+    template<typename Fn, typename... Args>
+    concept template_callable_or_invocable = !is_not_template_callable<Fn> || invocable<Fn, Args...>;
+
+    template<typename Fn, typename... Args>
+    concept template_callable_or_invocable_ret_non_void = !is_not_template_callable<Fn> || (invocable<Fn, Args...> && !invocable_ret<void, Fn, Args...>);
+
+    template<typename Ret, typename Fn, typename... Args>
+    concept template_callable_or_invocable_ret = !is_not_template_callable<Fn> || invocable_ret<Ret, Fn, Args...>;
+
+    template<typename Fn, typename... Args>
+    concept is_nothrow_invocable = std::is_nothrow_invocable_v<Fn, Args...>;
+} // namespace rpp::constraint
+
+namespace rpp::utils
+{
 
     // Lambda
-    template<is_not_template_callable T>
+    template<constraint::is_not_template_callable T>
     struct function_traits : function_traits<decltype(&T::operator())>
     {
     };