title: How to properly forward Invocable types
body: <p>I really like to use <a href="https://github.com/CaseyCarter/cmcstl2" rel="nofollow noreferrer">cmcstl2</a>, an implementation of the Ranges TS. I especially like the optional projections on every STL-algorithm. <code>Invocable</code> types get forwarded (ehm... or not) like this: (<a href="https://github.com/CaseyCarter/cmcstl2/blob/master/include/stl2/detail/algorithm/min_element.hpp" rel="nofollow noreferrer">min_element.hpp</a>)</p>
  
  <pre><code>template &lt;ForwardIterator I, Sentinel&lt;I&gt; S,
      class Comp = less&lt;&gt;, class Proj = identity&gt;
  requires
      IndirectStrictWeakOrder&lt;
          Comp, projected&lt;I, Proj&gt;&gt;()
  I min_element(I first, S last, Comp comp = Comp{}, Proj proj = Proj{});
  
  template &lt;ForwardRange Rng, class Comp = less&lt;&gt;, class Proj = identity&gt;
  requires
      IndirectStrictWeakOrder&lt;
          Comp, projected&lt;iterator_t&lt;Rng&gt;, Proj&gt;&gt;()
  safe_iterator_t&lt;Rng&gt;
  min_element(Rng&amp;&amp; rng, Comp comp = Comp{}, Proj proj = Proj{})
  {
      return __stl2::min_element(__stl2::begin(rng), __stl2::end(rng),
          __stl2::ref(comp), __stl2::ref(proj));
  }
  </code></pre>
  
  <p>As reference: The <a href="https://github.com/ericniebler/range-v3" rel="nofollow noreferrer">range-v3</a> library implements it like this: (<a href="https://github.com/ericniebler/range-v3/blob/master/include/range/v3/algorithm/min_element.hpp" rel="nofollow noreferrer">min_element.hpp</a>)</p>
  
  <pre><code>struct min_element_fn {
          template&lt;typename I, typename S, typename C = ordered_less, typename P = ident,
              CONCEPT_REQUIRES_(ForwardIterator&lt;I&gt;() &amp;&amp; Sentinel&lt;S, I&gt;() &amp;&amp;
                  IndirectRelation&lt;C, projected&lt;I, P&gt;&gt;())&gt;
          I operator()(I begin, S end, C pred = C{}, P proj = P{}) const;
  
          template&lt;typename Rng, typename C = ordered_less, typename P = ident,
              typename I = range_iterator_t&lt;Rng&gt;,
              CONCEPT_REQUIRES_(ForwardRange&lt;Rng&gt;() &amp;&amp;
                  IndirectRelation&lt;C, projected&lt;I, P&gt;&gt;())&gt;
          range_safe_iterator_t&lt;Rng&gt; operator()(Rng &amp;&amp;rng, C pred = C{}, P proj = P{}) const
          {
              return (*this)(begin(rng), end(rng), std::move(pred), std::move(proj));
          }
  };
  </code></pre>
  
  <p>Now I try to understand the difference and reasoning of both approaches.
  Why should I take <code>Invocable</code> types by value anyway?
  Why should I not use perfect forwarding for these types?</p>
  
  <p>I understand the second approach more than I do for the first one, since I understand the methodology of taking sink arguments by value. </p>