Boost C++ Libraries: Ticket #4540: fold() instantiates result_of::fold

Steven Watanabe — Fri, 13 Aug 2010 18:12:15 GMT

The const overload is necessary to catch non-const rvalues.

anonymous — Fri, 13 Aug 2010 18:40:10 GMT

I see. but I guess there is another solution, because the following works:

struct A{};
template<typename T>
struct fresult;
template<>
struct fresult<A>{
    typedef void type;
};
template<typename T>
typename fresult<T>::type f(T &){}
template<typename T>
typename fresult<T const>::type f(T const &){}
int main(){
    A a;
    f(a);
}

the undefined fresult<T const> is not instantiated for the call to the non-const overload. I don't know what exactly causes the instantiation of result_of::fold<Seq const>, but this suggests there might a solution other than removing the const overload.

status changed; resolution set

Christopher Schmidt — Tue, 17 Aug 2010 22:53:06 GMT

status new → closed
resolution → wontfix

Replying to anonymous:

I see. but I guess there is another solution, because the following works:
struct A{};
template<typename T>
struct fresult;
template<>
struct fresult<A>{
    typedef void type;
};
template<typename T>
typename fresult<T>::type f(T &){}
template<typename T>
typename fresult<T const>::type f(T const &){}
int main(){
    A a;
    f(a);
}
the undefined fresult<T const> is not instantiated for the call to the non-const overload. I don't know what exactly causes the instantiation of result_of::fold<Seq const>, but this suggests there might a solution other than removing the const overload.

That sample compiles fine as SFINAE is taking care of the non-existing specialization. SFINAE does not help in your fusion usecase, though. There is simply no specialization of F::result that matches the template arguments in the first place - and that very instantiation is directly referenced by the boost::result_of implementation. I do not think that this issue can be worked-around.

Here is a minimal non-fusion testcase.

#include <boost/utility/result_of.hpp>
struct A{};
struct F
{
	template<typename> struct result;
	template<typename Self>struct F::result<Self(A&)>
	{typedef void type;};
#if 0
	template<typename Self>struct F::result<Self(A const&)>
	{typedef void type;};
#endif
};
template<typename C>
typename boost::result_of<F(C const&)>::type
bub(C const&){}
template<typename C>
typename boost::result_of<F(C&)>::type
bub(C&){}
int main()
{
	A a;
	bub(a);
}

status changed; resolution deleted

anonymous — Wed, 18 Aug 2010 08:58:39 GMT

status closed → reopened
resolution wontfix

reopening this ticket for now, as I think it can be fixed, even though "component" might have to be changed:

BOOST_MPL_HAS_XXX_TRAIT_DEF(type)
struct invalid;
template<typename F,typename Args>
struct result_of_impl{
    typedef typename boost::mpl::eval_if<
        has_type<typename F::template result<Args> >,
        typename F::template result<Args>,
        boost::mpl::identity<invalid>
    >::type type;
};

with this fix to result_of your code above yields these results:

    A a;
    bub(a); //ok
    bub(A()); //error: use of undefined type "invalid"

do you see any problems with this? "invalid" could be further extended to give a meaningful error message, e.g. undefined_result_type<FArgs>

type, component changed

Christopher Schmidt — Wed, 18 Aug 2010 16:49:13 GMT

type Bugs → Feature Requests
component fusion → utility

Well, I am not sure about that. Anyway, lets change the component to utility.

BTW. the upcoming c++11 port solves this issue by implementing fold as

template<typename Seq, ...> typename result_of::fold<...>::type fold(Seq&&, ...)

owner, status changed; cc set

Christopher Schmidt — Wed, 18 Aug 2010 16:51:15 GMT

cc mr.chr.schmidt@… added
owner changed from Joel de Guzman to Douglas Gregor
status reopened → new

component changed

viboes — Sat, 13 Apr 2013 16:50:35 GMT

component utility → result_of