C++11: std::result_of<> template argument vs std::function<>

Question

I did do some research on std::result_of<>, and am aware how it's used on a high level, but am still pretty confused on this magical thing.

So, if I understand it correctly, the form R (Args..) should be interpreted by the compiler as a function type taking the arguments of types Args... and returning type R, and the usage is very much justified when specifying std::function<int(int)>, which declares a function type taking int as its only argument, and returning int.

However, the meaning of the above suddenly changes when the same notion is used in the context of std::result_of<F(Args...)> (note that I changed R to F, and removed the (space) between F and ( to signify the difference - according to cppreference, the meaning of F(Args...) becomes a compile time INVOKE expression - I mean, I kind of understand that the main purpose of std::result_of<F(Args...)> is to use the notion of INVOKE to select the correct overload (if more than one overloads are present), and of course deduce the return type of such invocation (during compile time resolution) - effectively, this would roughly be similar to: decltype(std::declval<F>()(std::declval<Args>()...)) - however, the notion of F (Args...) - comparing to the std::function<R (Args...)> case - would have been interpreted by the compiler as a function type taking Args... and returning the type F, where now F is the function type that we are trying to get the return type of!

Of course, with the help of decltype and std::declval, the implementation of std::result_of seems reasonable, but I read that boost somehow implemented result_of in C++98/03 where decltype and std::declval were not existing - I'm wondering how would that be possible (maybe with some very hack'ish tricks)?

So to re-iterate: is the notion of R (Args...) in the context of being a template argument always interpreted / deduced as a function type with a return type R, regardless if the enclosing template is std::function<> or std::result_of<>? while std::result_of<> somehow does some kind of reinterpretation of the "return type" F, and "returns" the actual return type as defined by std::result_of<F(Args...)>::type? Or std::result_of<F(Args...)> just interprets F(Args...) differently, so it knows it's a magical INVOKE expression?

Thanks for your upcoming clarification!

Answer 1

To implement it without decltype—well, a simple carcass oldschool implementation that covers few basic cases would probably be something like

template<class F> struct MemberRetVal;
template<class C,typename R> struct MemberRetVal<R (C::*)()> {
    using type = R;
};
template<class C,typename R> struct MemberRetVal<R (C::*)() const> {
    using type = R;
};
template<class C,typename R, typename A1> struct MemberRetVal<R (C::*)(A1)> {
    using type = R;
};
template<class C,typename R, typename A1> struct MemberRetVal<R (C::*)(A1) const> {
    using type = R;
};
// ...
// A few more member function arities
// ...

template<typename F> struct ResultOf;
template<typename F> struct ResultOf<F (*)()> {
    using type = typename MemberRetVal<&F::operator()>::type;
};
template<typename R> struct ResultOf<(R (*)())(*)()> {
    using type = R;
};
template<typename F, typename A1> struct ResultOf<F (*)(A1)> {
    using type = typename MemberRetVal<&F::operator()>::type;
};
template<typename R, typename A1> struct ResultOf<(R (*)(A1))(*)(A1)> {
    using type = R;
};
// and so forth

Somewhat more sophisticated dispatch is required for operator() case, but otherwise—this is the approximate way to go.

Answer 2

Z(A,B,C) is just a type. It is a function type.

You can pass types to templates. What the template does with a type is up to the template.

std::function<X> expects a function type. It converts it into the signature of its operator().

std::result_of<X> expects a function type. If given A(Ts...), it calculates the result of using () to call an object of type A with the arguments Ts....

It was marked depricated in c++17 because function types do funny things sometimes (decay arguments, strip const, etc). There is now invoke_result<F, Ts...> that behaves much like result_of<F(Ts...)> with a few corner case differences.

result_of was always an abuse of function type syntax. But there is no deep magic here; templates do whatever they want with types passed in.

In c++03 you can get limited "result_of" like functionality by pattern matching function pointer types and examining &T::operator(). There is no way to get the entire capabilities you want in c++03 without decltype/declval, compiler extensions, or TR pre-c++11 headers.