Index: utility.htm
===================================================================
--- utility.htm	(revision 80454)
+++ utility.htm	(working copy)
@@ -260,6 +260,70 @@
                 <code>boost/utility/result_of.hpp</code> will
                 define the macro <code>BOOST_NO_RESULT_OF</code>.</p>
 
+                <h3>Usage guidelines</h3>
+
+                <p>It is important to understand that <code>result_of</code> template (whether <code>decltype</code>-based or not) should be instantiated with the exact types of the
+                function object and arguments used at the call site. This includes the correct <code>const</code>/<code>volatile</code> and reference qualification of the arguments.
+                Failing to do so may affect the deduced result type and create subtle errors. Following are the typical use case examples:</p>
+
+                <blockquote>
+                <pre>typedef boost::result_of&lt; functor(int) &gt;::type type1; // the argument is rvalue
+functor f;
+type1 r1 = f(10);
+
+typedef boost::result_of&lt; const functor(int) &gt;::type type2; // the function object is const
+const functor cf;
+type2 r2 = cf(10);
+
+typedef boost::result_of&lt; functor(int&amp;) &gt;::type type3; // the argument is lvalue
+int a = 10;
+type3 r3 = f(a);
+
+typedef boost::result_of&lt; functor(int const&amp;) &gt;::type type4; // the argument is const lvalue
+const int ca = 10;
+type4 r4 = f(ca);</pre>
+                </blockquote>
+
+                <p>When code is targeted to compliant C++11 compilers and portability is not an issue, one can use <code>std::result_of</code>
+                or <code>decltype</code>-based <code>boost::result_of</code> interchangeably. No additional scaffolding is needed from function objects,
+                the compiler will be able to deduce the result type from the <code>operator()</code> itself.</p>
+
+                <p>If compatibility with C++03 is required, one has to always use <code>boost::result_of</code> which will fall back to TR1 protocol
+                when <code>decltype</code> is not available. This will also require support from function objects as follows.</p>
+                <ul>
+                    <li>When your function object result type does not depend on the <code>operator()</code> argument types, simply define it as the <code>result_type</code> type within the function object.</li>
+                    <li>Otherwise, provide the <code>result</code> template specializations.</li>
+                </ul>
+
+                <p>The latter case is the most complicated. The <code>result</code> template should be specialized to account for every valid calling signature the function object supports.
+                If the <code>operator()</code> accepts arguments by (possibly <code>const</code>) reference and/or the operator itself is <code>const</code>
+                qualified, the <code>result</code> specialization must support it as well. <a href="../type_traits/doc/html/index.html">Type traits</a>
+                and more generic specializations may help to reduce the number of <code>result</code> specializations. For example:</p>
+
+                <blockquote>
+                <pre>struct functor {
+    template&lt;class&gt; struct result;
+
+    // Use template parameter F to match the function object. This will allow result deduction for both const and non-const functor.
+    template&lt;class F, class T&gt;
+    struct result&lt;F(T)&gt; {
+        // 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&lt;typename remove_reference&lt;T&gt;::type&gt;::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&lt;class T&gt;
+    T operator()(T const&amp; x) const
+    {
+        return x;
+    }
+};</pre>
+                </blockquote>
+
+                <p>This way <code>result_of</code> users will be able to specify argument types exactly according to the function object call expression.</p>
+
                 <p>For additional information
                 about <code>result_of</code>, see the C++ Library
                 Technical Report,