template<class T> class CList : public std::list<T>
    {
        public:

            template<class Pred> bool Contain(Pred p)
            {
                return std::find_if(begin(), end(), p) != end();
            }


            bool Contain(const T & v)
            {
                return std::find(begin(), end(), v) != end();
            }
    }

CList<int>  a;
a.Contain([](auto i){ return i == 5; }); //ok
a.Contain(5);     //term does not evaluate to a function taking 1 arguments
        // bool CList<int>::Contain<int>(Pred)' being compiled ??????

  template<class P> auto contains(P&& p) ->
    // если существует и приводится к bool выражение p(t), где t - элемент коллекции
    std::enable_if< std::is_convertible< decltype(p(std::declval<T>())), bool >::value, bool >::type
  { return std::find_if(std::begin(*this), std::end(*this), std::forward<T>(p)) != std::end(*this); }

  template<class V> auto contains(V&& v) ->
    // если существует и приводится к bool выражение t == v
    std::enable_if< std::is_convertible< decltype(std::declval<T>() == v), bool >::value, bool >::type
  { return std::find(std::begin(*this), std::end(*this), std::forward<V>(v)) != std::end(*this); }

#include <iostream>
#include <type_traits>
#include <vector>
#include <algorithm>
using namespace std; // это инициатива от ideone.com, пусть будет.
 
template<class T> struct container {
    vector<T> ts;
    template<class F> auto contains(F&& f) const ->
        typename enable_if< is_convertible< decltype(f(declval<T>())), bool >::value, bool >::type
    {
        cout << "predicate\n";
        return find_if(begin(ts), end(ts), f) != end(ts);
    }
    template<class V> auto contains(V&& v) const ->
        typename enable_if< is_convertible< decltype(declval<T>() == v), bool >::value, bool >::type
    {
        cout << "match\n";
        return find(begin(ts), end(ts), v) != end(ts);
    }
};

// чтобы жизнь мёдом не казалась: а вдруг предикат вернёт не bool, а что попало (здесь - указатель на член)
struct XZ { void xz() {} };
typedef void(XZ::*unspecified_bool)(); 
unspecified_bool unspec(bool v) { return v ? &XZ::xz : (unspecified_bool)0; }

// заодно проверим, можно ли искать по ключу, условно-совместимому с типом элементов
struct ONE {};
unspecified_bool operator == (int x, ONE y) {
    cout << "compare " << x << " to ONE...\n";
    return unspec(x == 1);
}

int main() {
    container<int> d { {0, 3, 1, 2} };
    cout << d.contains([](double x) {
        cout << "examine " << x << "...\n";
        return unspec(x==1); })
    << endl;
    cout << d.contains(ONE()) << endl;
}

Мне мама говорила всегда: "не ешь тесто — кишки слипнутся, придётся операцию делать!"
Я верил до... 20 лет. Потом, когда подумал, сказал:
— Мама, так ты меня ВСЮ ЖИЗНЬ обманывала?
— Конечно, зато ты у меня никогда тесто не ел...