template<typename T>
class is_class
{
    typedef char yes[1];
    typedef char no[2];
 
    template<typename C>
    static yes& test(int C::*); // selected if C is a class type
 
    template<typename C>
    static no& test(...);       // selected otherwise
public:
    static bool const value = sizeof(test<T>(0)) == sizeof(yes);
};

М>template<typename T>
М>class is_class
М>{
М>    typedef char yes[1];
М>    typedef char no[2];
 
М>    template<typename C>
М>    static yes& test(int C::*); // selected if C is a class type
 
М>    template<typename C>
М>    static no& test(...);       // selected otherwise
М>public:
М>    static bool const value = sizeof(test<T>(0)) == sizeof(yes);
М>};
М>

template<typename, typename = void>
struct is_class : std::false_type {};

template<typename T>
struct is_class<T, std::void_t<int T::*>> : std::true_type {};

М>Заинтриговали А по какимм критериям можно определить, что контейнер не нуждается в дополнительной сортировке?

#include <iostream>
#include <set>

int main()
{
    std::set<int> set { 3, 5, 2, 9, 1, 7, 4, 8, 0, 6 };
    
    for (const int value : set)
        std::cout << " " << value; // -> 0 1 2 3 4 5 6 7 8 9
}

М>А можете, если есть время, более подробно написать (может пару строчек кода) как такое делается? У меня пока только совсем простые вещи получаются, типа проверок есть ли определенный метод в классе или нет. А те же begin/end в set есть и просто так не отделить set от vector. Что-то типа std::is_set_v<T> вроде нет в библиотеке. Вероятнее всего, я пока просто не понимаю, что такое traits в плюсах . Спасибо за помощь!

#include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <vector>
#include <utility>

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Generic Library Area

template <typename, typename = void>
struct has_sort_member_function : std::false_type {};

template <typename T>
struct has_sort_member_function<T, std::void_t<decltype(std::declval<T&>().sort())>> : std::true_type {};

template <typename, typename = void>
struct is_std_sort_applicable : std::false_type{};

template <typename T>
struct is_std_sort_applicable<T, std::void_t<
   decltype(std::sort(std::begin(std::declval<T&>()), std::end(std::declval<T&>()))),
   decltype(*std::begin(std::declval<T&>()) = *std::begin(std::declval<T&>()))
>> : std::true_type {};

template <typename T>
auto assume_sorted_range(const T&) -> std::false_type;

// For standard containers, the traits must be defined beforehand
template <typename K, typename T, typename C, typename A>
auto assume_sorted_range(const std::map<K, T, C, A>&) -> std::true_type;

template <typename K, typename T, typename C, typename A>
auto assume_sorted_range(const std::multimap<K, T, C, A>&) -> std::true_type;

template <typename T, typename C, typename A>
auto assume_sorted_range(const std::set<T, C, A>&) -> std::true_type;

template <typename T, typename C, typename A>
auto assume_sorted_range(const std::multiset<T, C, A>&) -> std::true_type;

template <typename T>
using is_sorted_container = decltype(assume_sorted_range(std::declval<T>()));

template <typename T, std::enable_if_t<has_sort_member_function<T>::value, int> = 0>
void sort(T& t)
{
   t.sort();
}

template <typename T, std::enable_if_t<
   is_std_sort_applicable<T>::value &&
   !has_sort_member_function<T>::value &&
   !is_sorted_container<T>::value,
int> = 0>
void sort(T& t)
{
   std::sort(std::begin(t), std::end(t));
}

template <typename T, std::enable_if_t<
   is_sorted_container<T>::value &&
   !has_sort_member_function<T>::value,
int> = 0>
void sort(const T&)
{
   // Container is sorted already, so nothing to do.
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Custom Application Area

struct MyContainer
{
   void sort() { std::cout << "MyContainer::sort" << std::endl; }
};

struct MySortedContainer
{

};
auto assume_sorted_range(const MySortedContainer&) -> std::true_type;

int main()
{
   std::string string = "Hello World!";
   sort(string); // call to std::sort
   std::cout << "<" << string << ">" << std::endl;

   int array[] { 3, 5, 2, 9, 1, 7, 4, 8, 0, 6 };
   sort(array); // call to std::sort

   std::vector<int> vector { 3, 5, 2, 9, 1, 7, 4, 8, 0, 6 };
   sort(vector); // call to std::sort

   std::set<int> set { 3, 5, 2, 9, 1, 7, 4, 8, 0, 6 };
   sort(set); // no effect

   MyContainer my_container;
   sort(my_container); // call to MyContainer::sort

   MySortedContainer my_sorted_container;
   sort(my_sorted_container); // no effect

   char str[] = "Hello World!";
   sort(str); // call to std::sort
   // sort("Hello World!"); // error: no matching function for call
}

R>template <typename T>
R>auto consider_sorted_range(const T&) -> std::false_type;

R>// For standard containers, the traits must be defined beforehand
R>template <typename K, typename T, typename C, typename A>
R>auto consider_sorted_range(const std::map<K, T, C, A>&) -> std::true_type;

R>template <typename K, typename T, typename C, typename A>
R>auto consider_sorted_range(const std::multimap<K, T, C, A>&) -> std::true_type;

R>template <typename T, typename C, typename A>
R>auto consider_sorted_range(const std::set<T, C, A>&) -> std::true_type;

R>template <typename T, typename C, typename A>
R>auto consider_sorted_range(const std::multiset<T, C, A>&) -> std::true_type;

R>template <typename T>
R>using is_sorted_container = decltype(consider_sorted_range(std::declval<T>()));

R>

template <typename, template <typename...> typename>
struct is_instance : std::false_type {};

template <typename T, template <typename...> typename U>
struct is_instance<U<T>, U> : std::true_type {};

template <typename T>
using is_sorted_container = std::bool_constant<is_instance<T, std::set>::value
                                            && is_instance<T, std::map>::value
                                            && is_instance<T, std::multi_map>::value
                                            && is_instance<T, std::multi_set>::value>;

SP>template <typename, template <typename...> typename>
SP>struct is_instance : std::false_type {};

SP>template <typename T, template <typename...> typename U>
SP>struct is_instance<U<T>, U> : std::true_type {};

SP>template <typename T>
SP>using is_sorted_container = std::bool_constant<is_instance<T, std::set>::value
SP>                                            && is_instance<T, std::map>::value
SP>                                            && is_instance<T, std::multi_map>::value
SP>                                            && is_instance<T, std::multi_set>::value>;
SP>

struct MySortedContainer
{

};
auto assume_sorted_range(const MySortedContainer&) -> std::true_type;

SP>template <typename, template <typename...> typename>
SP>struct is_instance : std::false_type {};

SP>template <typename T, template <typename...> typename U>
SP>struct is_instance<U<T>, U> : std::true_type {};

SP>template <typename T>
SP>using is_sorted_container = std::bool_constant<is_instance<T, std::set>::value
SP>                                            && is_instance<T, std::map>::value
SP>                                            && is_instance<T, std::multi_map>::value
SP>                                            && is_instance<T, std::multi_set>::value>;
SP>

template <typename T, template <typename...> typename U> struct is_instance<U<T>, U> : std::true_type {}

namespace hl = std;
template <template <typename... > class Tmp> struct holder {};

template <typename T> struct extract : hl::false_type {};

template <typename... Ts, template <typename... > class Tmpl>
struct extract<Tmpl<Ts...>> : hl::true_type
{
    typedef holder<Tmpl> type;
};
 
int main()
{
  enum {v = std::is_same<typename extract<T>::type, holder<std::set>>::value};
}

Б>namespace hl = std;
Б>template <template <typename... > class Tmp> struct holder {};

Б>template <typename T> struct extract : hl::false_type {};

Б>template <typename... Ts, template <typename... > class Tmpl>
Б>struct extract<Tmpl<Ts...>> : hl::true_type
Б>{
Б>    typedef holder<Tmpl> type;
Б>};
 
Б>int main()
Б>{
Б>  enum {v = std::is_same<typename extract<T>::type, holder<std::set>>::value};
Б>}
Б>

namespace lib_01 {

template <typename T>
using is_sorted_container = decltype(assume_sorted_range(std::declval<T>()));

} // namespace lib_01

namespace app_01 {
namespace app_02 {
namespace app_03 {

struct MySortedContainer
{

};
auto assume_sorted_range(const MySortedContainer&) -> std::true_type;

} // namespace app_03
} // namespace app_02
} // namespace app_01

#include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <vector>
#include <utility>

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Generic Library Area

namespace lib
{

template <typename, typename = void>
struct has_sort_member_function : std::false_type {};

template <typename T>
struct has_sort_member_function<T, std::void_t<decltype(std::declval<T&>().sort())>> : std::true_type {};

template <typename, typename = void>
struct is_std_sort_applicable : std::false_type{};

template <typename T>
struct is_std_sort_applicable<T, std::void_t<
   decltype(std::sort(std::begin(std::declval<T&>()), std::end(std::declval<T&>()))),
   decltype(*std::begin(std::declval<T&>()) = *std::begin(std::declval<T&>()))
>> : std::true_type {};

template <typename T>
auto assume_sorted_range(const T&) -> std::false_type;

// For standard containers, the traits must be defined beforehand
template <typename K, typename T, typename C, typename A>
auto assume_sorted_range(const std::map<K, T, C, A>&) -> std::true_type;

template <typename K, typename T, typename C, typename A>
auto assume_sorted_range(const std::multimap<K, T, C, A>&) -> std::true_type;

template <typename T, typename C, typename A>
auto assume_sorted_range(const std::set<T, C, A>&) -> std::true_type;

template <typename T, typename C, typename A>
auto assume_sorted_range(const std::multiset<T, C, A>&) -> std::true_type;

template <typename T>
using is_sorted_container = decltype(assume_sorted_range(std::declval<T>()));

template <typename T, std::enable_if_t<has_sort_member_function<T>::value, int> = 0>
void sort(T& t)
{
   t.sort();
}

template <typename T, std::enable_if_t<
   is_std_sort_applicable<T>::value &&
   !has_sort_member_function<T>::value &&
   !is_sorted_container<T>::value,
int> = 0>
void sort(T& t)
{
   std::sort(std::begin(t), std::end(t));
}

template <typename T, std::enable_if_t<
   is_sorted_container<T>::value &&
   !has_sort_member_function<T>::value,
int> = 0>
void sort(const T&)
{
   // Container is sorted already, so nothing to do.
}

} // namespace lib


namespace app1 {
namespace app2 {
namespace app3 {    
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Custom Application Area

class MySortedContainer
{
public:

    auto begin() const { return m.begin(); }
    auto end() const { return m.end(); }

    void add_element(int key, int value) { m.emplace(key, value); }

private:
    std::map<int, int> m;
};
auto assume_sorted_range(const MySortedContainer&) -> std::true_type;

struct MyContainer
{
   void sort() { std::cout << "MyContainer::sort" << std::endl; }
};

void test()
{
   std::string string = "Hello World!";
   lib::sort(string);
   std::cout << "<" << string << ">" << std::endl;

   int array[] { 3, 5, 2, 9, 1, 7, 4, 8, 0, 6 };
   lib::sort(array);

   std::vector<int> vector { 3, 5, 2, 9, 1, 7, 4, 8, 0, 6 };
   lib::sort(vector);

   std::set<int> set { 3, 5, 2, 9, 1, 7, 4, 8, 0, 6 };
   lib::sort(set); // no effect

   MyContainer my_container;
   lib::sort(my_container);

   MySortedContainer my_sorted_container;
   lib::sort(my_sorted_container); // no effect

   char str[] = "Hello World!";
   lib::sort(str); // Ok
   // lib::sort("Hello World!"); // error: no matching function for call
}

} // namespace app3
} // namespace app2
} // namespace app1

int main()
{
    app1::app2::app3::test();
}

оттолкнуться от std::is_same_v<T, std::set>

для нового продакшин кода, подход rg45 достаточно лаконичен, где стандарт и набор компиляторов практически предопределен и меняется довольно редко (хотя и там будут вопросы по скорости компиляции, иногда короткие лаконичные вещи компилируются дольше). Если же это библиотечный код, то часто предпочтение отдается дедовским версиям SFINAE громоздким, но покрывающим большее количество компиляторов.

data List a = Nil | Cons a (List a)
map _ Nil = Nil
map f Cons(head, tail) = Cons(f(head), map(f, tail))

struct Nil;

template <typename Head, typename Tail>
struct Cons;

template <template <class> typename F, typename List>
struct Map;

template <template <class> typename F>
struct Map<F, Nil> {
    using result = Nil;
};

template <template <class> typename F, typename Head, typename Tail>
struct Map<F, Cons<Head, Tail>>
{
    using result = Cons<typename F<Head>::result, typename Map<F, Tail>::result>;
};

template<class T, T v>
struct integral_constant
{
    static constexpr T value = v;
    using value_type = T;
    using type = integral_constant;
    constexpr operator value_type() const noexcept { return value; }
    constexpr value_type operator()() const noexcept { return value; }
};

template<bool v> using bool_constant = integral_constant<bool, v>;

using true_type = bool_constant<true>;
using false_type = bool_constant<false>;

V>data List a = Nil | Cons a (List a)
V>map _ Nil = Nil
V>map f Cons(head, tail) = Cons(f(head), map(f, tail))
V>

template <typename ... > struct type_list;