Использование SFINAE с общими лямбда-выражениями

Лямбды — это функциональные объекты под капотом. Общие лямбда-выражения — это функциональные объекты с шаблоном operator()s.

template<class...Fs>
struct funcs_t{};

template<class F0, class...Fs>
struct funcs_t<F0, Fs...>: F0, funcs_t<Fs...> {
  funcs_t(F0 f0, Fs... fs):
    F0(std::move(f0)),
    funcs_t<Fs...>(std::move(fs)...)
  {}
  using F0::operator();
  using funcs_t<Fs...>::operator();
};
template<class F>
struct funcs_t<F>:F {
  funcs_t(F f):F(std::move(f)){};
  using F::operator();
};
template<class...Fs>
funcs_t< std::decay_t<Fs>... > funcs(Fs&&...fs) {
  return {std::forward<Fs>(fs)...};
}

auto f_all = funcs( f1, f2 ) генерирует объект, который является перегрузкой как f1, так и f2.

auto g_integral = 
  [](auto&& func, auto&& param1, auto&&... params) 
    -> std::enable_if_t< std::is_integral<
        std::decay_t<decltype(param1)>
    >{}>
  {
    // ...
  };

auto g_not_integral =  
 [](auto&& func, auto&& param1, auto&&... params) 
    -> std::enable_if_t< !std::is_integral<
        std::decay_t<decltype(param1)>
    >{}>
{
    // ...
};

auto gL = funcs( g_not_integral, g_integral );

и вызов gL выполнит разрешение перегрузки SFINAE для двух лямбда-выражений.

Вышеприведенное делает некоторые ложные ходы, которых можно было бы избежать при линейном наследовании funcs_t. В библиотеке промышленного качества я мог бы сделать наследование бинарным, а не линейным (чтобы ограничить глубину реализации шаблонов и глубину дерева наследования).

Кроме того, я знаю 4 причины, по которым SFINAE включает лямбда-выражения.

Во-первых, с новым std::function вы можете перегружать функцию несколькими разными сигнатурами обратного вызова.

Во-вторых, описанный выше трюк.

В-третьих, каррирование объекта функции, где он оценивает, имеет ли он правильное количество и тип аргументов.

Далее, автоматическая распаковка кортежей и тому подобное. Если я использую стиль передачи продолжения, я могу спросить у переданного в продолжении, примет ли он распакованный кортеж или будущий разобранный и т. д.

Общая лямбда может иметь только одно тело, поэтому SFINAE здесь не очень полезен.

Одним из решений было бы упаковать вызов в класс, который может хранить результат и специализируется на типе возвращаемого значения void, инкапсулируя специальную обработку void вне вашей лямбда-выражения. С очень небольшими накладными расходами вы можете сделать это, используя возможности библиотеки потоков:

auto gL = 
    [](auto&& func, auto&&... params)
    {
        // start a timer
        using Ret = decltype(std::forward<decltype(func)>(func)(
            std::forward<decltype(params)>(params)...));
        std::packaged_task<Ret()> task{[&]{
            return std::forward<decltype(func)>(func)(
                std::forward<decltype(params)>(params)...); }};
        auto fut = task.get_future();
        task();
        // stop timer and print elapsed time
        return fut.get(); 
    };

Если вы хотите избежать накладных расходов на packaged_task и future, легко написать собственную версию:

template<class T>
struct Result
{
    template<class F, class... A> Result(F&& f, A&&... args)
        : t{std::forward<F>(f)(std::forward<A>(args)...)} {}
    T t;
    T&& get() { return std::move(t); }
};
template<>
struct Result<void>
{
    template<class F, class... A> Result(F&& f, A&&... args)
        { std::forward<F>(f)(std::forward<A>(args)...); }
    void get() {}
};

auto gL = 
    [](auto&& func, auto&&... params)
    {
        // start a timer
        using Ret = decltype(std::forward<decltype(func)>(func)(
            std::forward<decltype(params)>(params)...));
        Result<Ret> k{std::forward<decltype(func)>(func),
            std::forward<decltype(params)>(params)...};
        // stop timer and print elapsed time
        return k.get(); 
    };

Использование SFINAE заключается в удалении перегрузки или специализации из набора кандидатов при разрешении данной функции или шаблона. В вашем случае у нас есть лямбда - это функтор с одним operator(). Перегрузки нет, поэтому нет смысла использовать SFINAE¹. Тот факт, что лямбда является универсальной, что делает ее operator() шаблоном функции, не меняет этого факта.

Однако на самом деле вам не нужно различать разные типы возвращаемых значений. Если func возвращает void для заданных аргументов, вы все равно можете return это сделать. Вы просто не можете назначить его временному. Но и этого делать не обязательно:

auto time_func = [](auto&& func, auto&&... params) {
    RaiiTimer t;
    return std::forward<decltype(func)>(func)(
        std::forward<decltype(params)>(params)...); 
};

Просто напишите RaiiTimer, конструктор которого запускает таймер, а деструктор останавливает его и печатает результат. Это будет работать независимо от типа возвращаемого значения func.

Если вам нужно что-то более сложное, то это один из тех случаев, когда вам следует предпочесть функтор лямбде.

¹На самом деле, как указывает Якк, SFINAE все еще может быть весьма удобен, чтобы проверить, является ли ваша функция вызываемой точкой, что не является проблемой, которую вы пытаетесь решить, поэтому в этом случае очень полезно.