Ограничить тип параметра функтора и константу

Вы можете сделать следующее

template <std::size_t N>
struct overload_priority : overload_priority<N - 1> {};

template <> struct overload_priority<0> {};

using low_priority = overload_priority<0>;
using high_priority = overload_priority<1>;

template <typename T>
class Resource
{
public:
    template <typename F>
    auto apply(F&& f) const
    // -> decltype(apply_impl(std::forward<F>(f), high_priority{}))
    {
        return apply_impl(std::forward<F>(f), high_priority{});
    }

    template <typename F>
    auto apply(F&& f)
    // -> decltype(apply_impl(std::forward<F>(f), high_priority{}))
    {
        return apply_impl(std::forward<F>(f), high_priority{});
    }

private:
    template <typename F>
    auto apply_impl(F&& f, low_priority) -> decltype(f(std::declval<T&>()))
    {
        std::cout << "ReadLock\n";
        return std::forward<F>(f)(this->data);
    }

    template <typename F>
    auto apply_impl(F&& f, high_priority) -> decltype(f(std::declval<const T&>())) const
    {
        std::cout << "WriteLock\n";
        return std::forward<F>(f)(this->data);
    }

private:
    T data;
};

Демо

Джарод предложил обходной путь, но я объясню, почему вы не можете добиться этого обычным способом. Проблема в том, что:

1. Разрешение перегрузки предпочитает неконстантные функции-члены константным функциям-членам при вызове из неконстантного объекта.
2. какой бы объект ни принимала эта подпись void foo(A&), void foo(const A&) также может принять тот же объект. Последний даже имеет более широкий набор привязок, чем первый.

Следовательно, чтобы решить ее, вам нужно как минимум победить пункт 1, прежде чем перейти к пункту 2. Как это сделал Джарод.

Из ваших подписей (см. аннотации к моим комментариям):

template <typename F>
typename std::result_of<F (T &)>::type apply(F &&f)              //non-const member function
{
    return std::forward<F>(f)(this->data);
}

template <typename F>
typename std::result_of<F (const T &)>::type apply(F &&f) const //const member function
{
    return std::forward<F>(f)(this->data);
}

Когда вы называете это так:

resource2.apply([](QList<int> &lst) {lst.append(12); });   //1
resource2.apply([](const QList<int> &lst) { return lst.size(); });   //2

Прежде всего, помните, что resource2 не является ссылкой const. Следовательно, функция non-const membr команды apply всегда будет предпочтительнее при разрешении перегрузки.

Теперь, взяв случай первого вызова //1, независимо от того, с чем эта лямбда может быть вызвана, тогда вторая также может быть вызвана с этим объектом.

Упрощенный макет того, что вы пытаетесь сделать, это:

struct A{
    template<typename Func>
    void foo(Func&& f); //enable if we can call f(B&);

    template<typename Func>
    void foo(Func&& f) const; //enable if we can call f(const B&);
};

void bar1(B&);
void bar2(const B&);

int main(){
    A a;
    a.foo(bar1);
    a.foo(bar2);

    //bar1 and bar2 can be both called with lvalues
    B b;
    bar1(b);
    bar2(b);
}

Насколько я понимаю, вы хотите отличить параметр std::function, который принимает ссылку const, от непостоянной ссылки.

Следующий подход на основе SFINAE, похоже, работает с использованием вспомогательного класса специализации:

#include <functional>
#include <iostream>

template<typename ...Args>
using void_t=void;

template<typename Result,
     typename T,
     typename lambda,
     typename void_t=void> class apply_helper;

template <typename T>
class Resource1
{
public:

    template <typename Result, typename lambda>
    Result apply(lambda &&l)
    {
        return apply_helper<Result, T, lambda>::helper(std::forward<lambda>(l));
    }
};

template<typename Result, typename T, typename lambda, typename void_t>
class apply_helper {

 public:

    static Result helper(lambda &&l)
    {
        std::cout << "T &" << std::endl;

        T t;
        return l(t);
    }
};


template<typename Result, typename T, typename lambda>
class apply_helper<Result, T, lambda,
           void_t<decltype( std::declval<lambda>()( std::declval<T>()))>> {
 public:

    static Result helper(lambda &&l)
    {
        std::cout << "const T &" << std::endl;
        return l( T());
    }
};


Resource1<int> test;

int main()
{
    auto lambda1=std::function<char (const int &)>([](const int &i)
                               {
                                   return (char)i;
                               });
    auto lambda2=std::function<char (int &)>([](int &i)
                               {
                                   return (char)i;
                               });

    auto lambda3=[](const int &i) { return (char)i; };
    auto lambda4=[](int &i) { return (char)i; };

    test.apply<char>(lambda1);
    test.apply<char>(lambda2);
    test.apply<char>(lambda3);
    test.apply<char>(lambda4);
}

Выход:

const T &
T &
const T &
T &

Демо

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

Пока списки захвата ваших лямбд пусты, вы можете полагаться на тот факт, что такая лямбда распадается на указатель функции.
Достаточно различать два типа.

Это следует за минимальным рабочим примером:

#include<iostream>

template <typename T>
class Resource {
public:
    template <typename Result>
    Result apply(Result(*f)(T &)) {
        std::cout << "non-const" << std::endl;
        return f(this->data);
    }

    template <typename Result>
    Result apply(Result(*f)(const T &)) const {
        std::cout << "const" << std::endl;
        return f(this->data);
    }

private:
    T data;
};

int main() {
    Resource<int> resource;
    resource.apply<void>([](int &lst) { });
    resource.apply<int>([](const int &lst) -> int { return 42; });
}