Re: [boost] [result_of] Usage guidelines

Subject: Re: [boost] [result_of] Usage guidelines
From: Andrey Semashev (andrey.semashev_at_[hidden])
Date: 2012-09-08 09:59:01

On Tuesday 04 September 2012 11:07:39 you wrote:
> 
> Jeffrey have suggested a good solution in his reply. I think it can be
> described in the result_of docs to resolve the confusion in the future. I
> can update the docs if noone objects.

I've added a clarification note to the result_of docs in trunk. Here is the 
added section:

<quote>
The result template must be specialized for every valid calling signature of 
the function object. If the operator() accepts arguments by (possibly const) 
reference and/or is const qualified, the result specialization must take this 
into account. Type traits and more generic specializations may help to reduce 
the number of result specializations. This way result_of users will be able to 
specify argument types exactly according to the function object call 
expression. For example:

    struct functor {
        template<class> struct result;

        // Use template parameter F to match the function object. This will 
allow result deduction for both const and non-const functor.
        template<class F, class T>
        struct result<F(T)> {
            // When argument type is matched like above, remember that the 
type may be a (const-qualified) reference.
            // Use type traits to transform the argument type.
            typedef typename remove_cv<typename 
remove_reference<T>::type>::type argument_type;
            typedef argument_type type;
        };

        // The operator can be called on both const and non-const functor. The 
argument can be lvalue or rvalue.
        template<class T>
        T operator()(T const& x) const
        {
            return x;
        }
    };

    // All following result_of uses are valid and result in int
    typedef boost::result_of< functor(int) >::type type1; // the argument is 
rvalue
    functor f;
    type1 r1 = f(10);

    typedef boost::result_of< const functor(int) >::type type2; // the 
function object is const
    const functor cf;
    type2 r2 = cf(10);

    typedef boost::result_of< functor(int&) >::type type3; // the argument is 
lvalue
    int a = 10;
    type3 r3 = f(a);

    typedef boost::result_of< functor(int const&) >::type type4; // the 
argument is const lvalue
    const int ca = 10;
    type4 r4 = f(ca);
</quote>

You can find the complete page tere:

http://svn.boost.org/svn/boost/trunk/libs/utility/utility.htm

If noone objects I will merge it to release branch in a few days.