template<typename CONTAINER, typename OBJ_T>
typename CONTAINER::const_iterator  find(const CONTAINER& cont, const OBJ_T& obj)
{
    return std::find(cont.begin(), cont.end(), obj);
}

template<typename K, typename V, typename A, typename C, typename T>
typename std::map<K,V,A,C>::const_iterator  find(const std::map<K,V,A,C>& cont, const T& key)
{
    return cont.find(key);
}

template<typename T, typename V>
concept HasFind = requires (T a, V b) { a.find(b); };

auto find(const auto& container, const auto& key) requires HasFind<decltype(container), decltype(key)>
{
    return container.find(key);
}

auto find(const auto& container, const auto& key) requires (!HasFind<decltype(container), decltype(key)>)
{
    return std::find(container.begin(), container.end(), key);
}

HAS_FUNC_CLASS(elem_dif_save);
template<bool b, typename T>
struct elem_dif_save_helper
{
    static void save(const T& data, const T& old_data, StreamWriter& sw)
    {
        return (data.T::elem_dif_save)(old_data, sw);
    }
};

template<typename T>
struct elem_dif_save_helper<false, T>
{
    static void save(const T& data, const T&  , StreamWriter& sw)
    {
        //    fallback
        return (data.T::elem_save)(sw);
    }
};


template<class T> inline void elem_dif_save(const T& val, const T& old_val, StreamWriter& sw)
{
    return elem_dif_save_helper< HAS_FUNC_VALUE(elem_dif_save, T), T >::save(val, old_val, sw); 
}

template<typename T>
concept has_elem_dif_save = std::is_member_function_pointer_v<decltype(&T::elem_dif_save)>;

inline void elem_dif_save(const auto& val, const auto& old_val, StreamWriter& sw) requires std::same_as<decltype(val), decltype(old_val)>
{
    using T = std::decay_t<decltype(val)>;
    
    if constexpr (has_elem_dif_save<T>)
        return (val.T::elem_dif_save)(old_val, sw);
    else 
        return (val.T::elem_save)(sw);    //    fallback
}

auto find(const auto& container, const auto& key) requires (!HasFind<decltype(container), decltype(key)>) {...}

auto find(const auto& container, const auto& key) {...}

template <class KeyType, HasFind<KeyType> ContainerType>
auto find(const ContainerType& container, const KeyType& key) {
    ...
}

void foo(const std::integral auto value);

template<class T> T& get(auto& var) requires (is_some_variant_v<decltype((var))>) { ..... }

template<size_t N> auto& get(auto& tpl) requires (is_some_tuple_v<decltype((tpl))>) { ..... }

template<size_t... Ns> void do_something_with_all_elements(auto& tpl, std::index_sequence<Ns...>) {
  ( do_something(std::get<Ns>(tpl)) , ... );
}

void do_something_with_all_elements(auto& tpl) {
  do_something_with_all_elements(tpl, std::make_index_sequence<std::tuple_size<decltype((tpl))>());
}

template<class L, class R> struct cons {};
struct nil {};

template<class> struct cons_traits {
  static constexpr bool value = false;
};
template<class L, class R> struct cons_traits<cons<L,R>> {
  static constexpr bool value = true;
  using left = L;
  using right = R;
};
template<class C> static constexpr bool is_cons_v = cons_traits<C>::value;
template<class C> using left_t = cons_traits<C>::left;
template<class C> using right_t = cons_traits<C>::right;

// и уже по месту - никаких template...

void do_something_with_list(auto l) {
  using C = decltype((l));
  if constexpr (is_cons_v<C>) {
    using L = left_t<C>;
    using R = right_t<C>;
    .....
  } else {
    .....
  }
}

К>template<class T> T& get(auto& var) requires (is_some_variant_v<decltype((var))>) { ..... }

К>template<size_t N> auto& get(auto& tpl) requires (is_some_tuple_v<decltype((tpl))>) { ..... }
К>

f() -> return_type {};

f(std::vector<auto>& )

#include <iostream>
#include <type_traits>
#include <concepts>

template <typename T>
concept Number = std::is_arithmetic_v<T>;

template <typename T>
concept RealNumber = Number<T> && std::is_floating_point_v<T>;

void foo(Number auto t) { std::cout << "Number: " << t << std::endl; }

void foo(RealNumber auto t) { std::cout << "Real Number: " << t << std::endl; }

void bar(Number auto t) { std::cout << "This is a Number: " << t << std::endl; }

int main()
{
   foo(42); // Number: 42
   foo(3.14); // Real Number: 3.14

   bar(42); // This is a Number: 42
   bar(3.14); // This is a Number: 3.14
}

К>>template<class T> T& get(auto& var) requires (is_some_variant_v<decltype((var))>) { ..... }

К>>template<size_t N> auto& get(auto& tpl) requires (is_some_tuple_v<decltype((tpl))>) { ..... }
К>>

f() -> return_type {};

decltype(auto) get(auto&& var, auto discriminator)
requires (is_some_variant_v<decltype((var))> && is_type_discriminator_v<decltype(discriminator)>)
{
  using T = decltype(discriminator)::type;
  .....
}
// get(var, std::type_identity<int>{})


decltype(auto) get(auto&& tpl, auto discriminator)
requires (is_some_tuple_v<decltype((var))> && is_index_discriminator_v<decltype(discriminator)>)
{
  static constexpr size_t N = decltype(discriminator)::value;
  .....
}
// get(tpl, std::integral_constant<size_t, 1>{})

f(std::vector<auto>& )

template<class T> struct is_std_vector : std::false_type {};
template<class T> struct is_std_vector<std::vector<T>> : std::true_type {};

template<class T> concept StdVector = is_std_vector<T>::value;

void f(StdVector auto& v);

auto factorial(auto t)
{
   return t ? t * factorial(t - 1) : decltype(t){1}; // error: use of 'auto factorial' before deduction of 'auto'
}

template <typename T>
concept Number = true;

template <typename T>
concept RealNumber = Number<T> && true;

template <typename T>
concept UnrealNumber = Number<T> && true;

template <typename T>
concept SuperNumber = RealNumber<T> && true;

void foo(Number auto t) { std::cout << "Number: " << t << std::endl; }
void foo(RealNumber auto t) { std::cout << "Real Number: " << t << std::endl; }
//void foo(UnrealNumber auto t) { std::cout << "Unreal Number: " << t << std::endl; }  // будет неоднозначность
void foo(SuperNumber auto t) { std::cout << "Super Number: " << t << std::endl; }

int main()
{
    foo(123);
}