Difference between revisions of "cpp/iterator/indirectly unary invocable"
m (~ fmt) |
(~ apply P2997R1 as DR20) |
||
Line 4: | Line 4: | ||
{{dcl header|iterator}} | {{dcl header|iterator}} | ||
{{dcl h|{{tt|std::indirectly_unary_invocable}}}} | {{dcl h|{{tt|std::indirectly_unary_invocable}}}} | ||
− | + | {{dcl|since=c++20|1= | |
− | {{dcl|since=c++20 | + | |
template< class F, class I > | template< class F, class I > | ||
concept indirectly_unary_invocable = | concept indirectly_unary_invocable = | ||
Line 12: | Line 11: | ||
std::invocable<F&, /*indirect-value-t*/<I>> && | std::invocable<F&, /*indirect-value-t*/<I>> && | ||
std::invocable<F&, std::iter_reference_t<I>> && | std::invocable<F&, std::iter_reference_t<I>> && | ||
− | |||
std::common_reference_with< | std::common_reference_with< | ||
std::invoke_result_t<F&, /*indirect-value-t*/<I>>, | std::invoke_result_t<F&, /*indirect-value-t*/<I>>, | ||
std::invoke_result_t<F&, std::iter_reference_t<I>>>; | std::invoke_result_t<F&, std::iter_reference_t<I>>>; | ||
}} | }} | ||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
− | |||
{{dcl h|{{tt|std::indirectly_regular_unary_invocable}}}} | {{dcl h|{{tt|std::indirectly_regular_unary_invocable}}}} | ||
− | + | {{dcl|since=c++20|1= | |
− | {{dcl|since=c++20 | + | |
− | + | ||
− | + | ||
− | + | ||
− | + | ||
− | + | ||
− | + | ||
− | + | ||
− | + | ||
− | + | ||
− | + | ||
− | + | ||
− | + | ||
template< class F, class I > | template< class F, class I > | ||
concept indirectly_regular_unary_invocable = | concept indirectly_regular_unary_invocable = | ||
Line 54: | Line 27: | ||
std::invoke_result_t<F&, std::iter_reference_t<I>>>; | std::invoke_result_t<F&, std::iter_reference_t<I>>>; | ||
}} | }} | ||
− | |||
{{dcl end}} | {{dcl end}} | ||
Line 102: | Line 74: | ||
{{dr list begin}} | {{dr list begin}} | ||
{{dr list item|paper=P2609R3|std=C++20|before=some requirements were defined in terms of {{c|std::iter_value_t<I>&}}<br>which mishandled projections resulting in incompatibility with invocable {{c|F&}}|after=defined in terms of {{c|/*indirect-value-t*/<I>}}<br>to correctly handle such projections}} | {{dr list item|paper=P2609R3|std=C++20|before=some requirements were defined in terms of {{c|std::iter_value_t<I>&}}<br>which mishandled projections resulting in incompatibility with invocable {{c|F&}}|after=defined in terms of {{c|/*indirect-value-t*/<I>}}<br>to correctly handle such projections}} | ||
+ | {{dr list item|paper=P2997R1|std=C++20|before=corresponding concepts required {{c|F&}} to satisfy {{lconcept|invocable}} and<br>{{lconcept|regular_invocable}}, respectively, with {{c|std::iter_common_reference_t<I>}}|after=does not require}} | ||
{{dr list end}} | {{dr list end}} | ||
{{langlinks|es|ja|zh}} | {{langlinks|es|ja|zh}} |
Latest revision as of 17:54, 23 August 2024
Defined in header <iterator>
|
||
std::indirectly_unary_invocable |
||
template< class F, class I > concept indirectly_unary_invocable = |
(since C++20) | |
std::indirectly_regular_unary_invocable |
||
template< class F, class I > concept indirectly_regular_unary_invocable = |
(since C++20) | |
The concepts indirectly_unary_invocable
and indirectly_regular_unary_invocable
specify requirements for algorithms that call (regular) unary invocables as their arguments. The key difference between these concepts and std::invocable is that they are applied to the type the I
references, rather than I
itself.
[edit] Notes
The distinction between indirectly_unary_invocable
and indirectly_regular_unary_invocable
is purely semantic.
[edit] Example
#include <algorithm> #include <iterator> #include <print> #include <ranges> struct IntWrapper { int i; explicit IntWrapper(int i) : i(i) {} IntWrapper(IntWrapper&&) = default; IntWrapper& operator=(IntWrapper&&) = default; }; int main() { auto ints = std::views::iota(1, 10); auto print = [] (IntWrapper w) { std::print("{} ", w.i); }; auto wrap = [] (int i) { return IntWrapper{i}; }; using Proj = std::projected<decltype(ints.begin()), decltype(wrap)>; // error (evaluated to false) until P2609R3: // this was because 'std::iter_value_t<Proj> &' is the same as 'IntWrapper&' // which is not convertible to 'IntWrapper' (implicitly deleted copy ctor) static_assert(std::indirectly_unary_invocable<decltype(print), Proj>); // if the compile-time check above evaluates to true, then this is well-formed: std::ranges::for_each(ints, print, wrap); }
Output:
1 2 3 4 5 6 7 8 9
[edit] Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR | Applied to | Behavior as published | Correct behavior |
---|---|---|---|
P2609R3 | C++20 | some requirements were defined in terms of std::iter_value_t<I>& which mishandled projections resulting in incompatibility with invocable F& |
defined in terms of /*indirect-value-t*/<I> to correctly handle such projections |
P2997R1 | C++20 | corresponding concepts required F& to satisfy invocable andregular_invocable , respectively, with std::iter_common_reference_t<I>
|
does not require |