std::indirectly_unary_invocable, std::indirectly_regular_unary_invocable - cppreference.com (original) (raw)

| Defined in header | | | | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ------------- | | std::indirectly_unary_invocable | | | | template< class F, class I > concept indirectly_unary_invocable = std::indirectly_readable<I> && std::copy_constructible<F> && std::invocable<F&, /*indirect-value-t*/<I>> && std::invocable<F&, std::iter_reference_t<I>> && std::common_reference_with< std::invoke_result_t<F&, /*indirect-value-t*/<I>>, std::invoke_result_t<F&, std::iter_reference_t<I>>>; | | (since C++20) | | std::indirectly_regular_unary_invocable | | | | template< class F, class I > concept indirectly_regular_unary_invocable = std::indirectly_readable<I> && std::copy_constructible<F> && std::regular_invocable<F&, /*indirect-value-t*/<I>> && std::regular_invocable<F&, std::iter_reference_t<I>> && std::common_reference_with< std::invoke_result_t<F&, /*indirect-value-t*/<I>>, std::invoke_result_t<F&, std::iter_reference_t<I>>>; | | (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 #include #include #include   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 &' 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:

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.