Binding std::function to member functions

I realized that std::function can be bound to member functions without requiring the *this object. Consider the following examples.

// std::string::empty is a const function. All variables from e1 to e5 are fine.
std::function<bool(std::string)> e1 = &std::string::empty;
std::function<bool(std::string &)> e2 = &std::string::empty;
std::function<bool(const std::string &)> e3 = &std::string::empty;
std::function<bool(std::string *)> e4 = &std::string::empty;
std::function<bool(const std::string *)> e5 = &std::string::empty;

// std::string::push_back is not a const function. p4 and p5 don't compile.
std::function<void(std::string, char)> p1 = &std::string::push_back;
std::function<void(std::string &, char)> p2 = &std::string::push_back;
std::function<void(std::string *, char)> p3 = &std::string::push_back;

// These two don't compile because push_back is a non-const function 
std::function<void(const std::string &, char)> p4 = &std::string::push_back;
std::function<void(const std::string *, char)> p5 = &std::string::push_back;

I thought I knew how to do that but this time I found that the syntax is a little different than what I had in mind.

I used tho think (incorrectly) that just like function types for free-standing functions, one would create a member-function type. While, it's straight-forward to create function types for free-standing functions, I think it's not possible to create member function types. Don't get me wrong. One can create pointer-to-member-function type just like pointer-to-a-function type. Here's what I mean.

using F = int(const char *); // a function type of a free standing function.
F f = std::atoi; // error because a there are no instances of a function type.
F* fnew = new F(); //error because new can't be applied to a function type.
F* fptr = &std::atoi; // OK. A pointer to a function type is initialized.

// However, there's no function type for member functions
using GPTR = bool (std::string::*)() const; // OK. This is a pointer-to-member-function-type. 
GPTR gptr = &std::string::empty; // OK. This is a pointer to a member function.
string s;
std::cout << (s.*gptr)(); // OK. prints 1
using H = decltype(*gptr); // error. It makes no sense without a std:string object. Illformed.

bool (*x)(const std::string &) = gptr; // error. Incompatible types.
std::function<bool (const std::string &)> fobj = gptr; // OK! Neat!

Therefore, std::function uses the syntax of free-standing function types to bind to pointer to member functions. That's neat.