template argument deduction for overloaded predicates

Hi,

I have problem with template argument deduction when using an
overloaded function as a predicate for std::all_of. What I want to do
is the following:
#include <vector>
#include <algorithm>

struct A {};
struct B {};

bool p(A const&);
bool p(B const&);

void f()
{
   std::vector<A> as;

   bool b = std::all_of( as.begin(), as.end(), p);
}

, but the compiler complains that it cannot deduce the type
of the predicate parameter for std::all_of.
error C2914: 'std::all_of' : cannot deduce template argument as function
argument is ambiguous
error C2784: 'bool std::all_of(_InIt,_InIt,_Pr)' : could not deduce template
argument for '_InIt' from 'std::_Vector_iterator<_Myvec>'
           with
      [
               _Myvec=std::_Vector_val<A,std::allocator<A>>
           ]
  see declaration of 'std::all_of'

I can strip this down to
template<typename T, typename P> void callP(T i, P f)
{
    f(*i);
}

void f()
{
   std::vector<A> as;
   callP( as.begin(), p);
}
which does not compile with the same error, but I do not see the
reasoning behind this. My thinking is: The compiler has two candidates
and substition fails for the B overload because parameter type does
not match. Since substitution is not an error, the compiler should now
go on and consider the next function with the matching parameter and
come up with a single possible match.

Best regards,
   Jens

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]