[libcxx][iterator] adds `indirectly_[regular_]unary_invocable` and `projected`

[ldionne]

Summary

Also adds std::iter_common_reference_t and std::indirect_result_t.

Implements parts of:

• P0896R4 The One Ranges Proposal

[Mordante]

libcxx/include/__iterator/indirect_callable.h

31

Please _Uglify and the rest of this file.

libcxx/test/std/iterators/iterator.requirements/indirectcallable/indirectcallable.indirectinvocable/indirect_result_t.compile.pass.cpp

26

I would like to see some tests returning cv-qualified references.
Can you test some other invokable objects?

[zoecarver]

libcxx/test/std/iterators/iterator.requirements/indirectcallable/indirectcallable.indirectinvocable/indirect_result_t.compile.pass.cpp

26

Can you test some other invokable objects?

There are some other interesting types in is_invocable.pass.cpp. Maybe one where we pick the correct overload, where there's a variadic (or even a template) involved, an explicit operator, a deleted overload, etc.

Would it make any sense to have a test where the result is void?

Also, maybe a few more negatives. Right now the only way we check that Is is indirectly_readable is that it's not int. That could be implemented typename std::iter_reference_t only. How about a type that is dereferenceable, but not iter_moveable.

[ldionne]

Rebase, add tests, also implement equivalence_relation and strict_weak_order

[ldionne]

libcxx/test/std/iterators/iterator.requirements/indirectcallable/indirectinvocable/indirect_strict_weak_order.compile.pass.cpp

1 ↗

(On Diff #348356)

This is basically copy-pasted from equivalence_relation because both are the same modulo semantic requirements.

libcxx/test/std/iterators/iterator.requirements/indirectcallable/indirectinvocable/indirectly_regular_unary_invocable.compile.pass.cpp

1 ↗

(On Diff #348356)

This is basically copy-pasted from indirect_unary_invocable because both are the same modulo semantic requirements.

[zoecarver]

LGTM. Thanks.

Only suggestion, does it make sense to add one or two tests where we are using this as a user would, instead of just checking the requirements are there? Maybe something like:

template<std::input_iterator I, std::sentinel_for<I> S,
         std::indirectly_unary_invocable<I> Fun>
constexpr auto myForEach(I first, S last, Fun f) const {
  for (; first != last; ++first) {
    std::invoke(f, *first);
  }
  return {first, f};
}

Or you could even test std::projected by projecting f.

I suppose these will come when we implement algs, such as for_each, so maybe it doesn't make sense.

libcxx/test/std/iterators/iterator.requirements/indirectcallable/indirectinvocable/indirectly_regular_unary_invocable.compile.pass.cpp

83 ↗

(On Diff #348356)

I won't object, but I feel that the volatile tests are a bit superfluous. I'm not sure they add much.

[cjdb]

libcxx/docs/OneRangesProposalStatus.csv

20–22

I've got a big change coming for this csv, so I'd prefer to add it in mine (it'll screw up my doc right now).

libcxx/include/__iterator/indirect_concepts.h

94–103 ↗

(On Diff #348356)

This should probably get its own header.

[ldionne]

In D101277#2785970, @zoecarver wrote:

LGTM. Thanks.

Only suggestion, does it make sense to add one or two tests where we are using this as a user would, instead of just checking the requirements are there? Maybe something like:

Yeah, I think it makes sense. I did it somewhat differently though, by adding asserts for a few less artificial predicates like [](int i) { return i % 2 == 0; } and simple things like that.

libcxx/test/std/iterators/iterator.requirements/indirectcallable/indirectinvocable/indirectly_regular_unary_invocable.compile.pass.cpp

83 ↗

(On Diff #348356)

Agreed - they were there in the original patch I commandeered, but I am OK removing them.

[ldionne]

Apply review comments.

libcxx/docs/OneRangesProposalStatus.csv

 [incrementable.traits],,[concepts],Christopher Di Bella,"`D99141 <https://llvm.org/D99141>`_, `D99863 <https://llvm.org/D99863>`_",✅
 [iterator.cust.move],Implement iter_move.,,Christopher Di Bella,`D99873 <https://llvm.org/D99873>`_,
 [iterator.cust.swap],Implement iter_swap.,"[concepts], [readable.traits]: iter_value_t",,,
 [iterator.concepts],"indirectly_readable, indirectly_writable, weakly_incrementable, incrementable, input_or_output_iterator, sentinel_for, sized_sentinel_for, input_iterator, output_iterator, forward_iterator, bidirectional_iterator, random_access_iterator, and contiguous_iterator.","[concepts], [readable.traits]: iter_value_t, [iterator.traits]",Christopher Di Bella,"indirectly_readable: `D100073 <https://llvm.org/D100073>`_
 indirectly_wriatable: `D100078 <https://llvm.org/D100078>`_ weakly_incrementable, incrementable: `D100080 <https://llvm.org/D100080>`_ input_or_output_iterator, sentinel_for: `D100160 <https://llvm.org/D100160>`_
 input_iterator: `D100271 <https://llvm.org/D100271>`_
 forward_iterator: `D100275 <https://llvm.org/D100275>`_
 bidirectional_iterator: `D100278 <https://llvm.org/D100278>`_",
-[indirectcallable.indirectinvocable],"indirectly_unary_invocable, indirectly_regular_unary_invocable, indirectly_unary_predicate, indirectly_binary_predicate, indirectly_equivalence_relation, and indirectly_strict_weak_order.","[concepts], [readable.traits]: iter_value_t, [iterator.traits]",,,
-[projected],,[iterator.concepts],,,
+[indirectcallable.indirectinvocable],"indirectly_unary_invocable, indirectly_regular_unary_invocable, indirectly_unary_predicate, indirectly_binary_predicate, indirectly_equivalence_relation, and indirectly_strict_weak_order.","[concepts], [readable.traits]: iter_value_t, [iterator.traits]",,,In progress
+[projected],,[iterator.concepts],,,✅
 [common.alg.req]: pt. 1,"indirectly_movable, indirectly_movable_storable, indirectly_copyable, and indirectly_copyable_storable.",[iterator.concepts],,,
 [common.alg.req]: pt. 2,indirectly_swappable,"[iterator.concepts], [iterator.cust.swap]",,,
 [common.alg.req]: pt. 3,indirectly_comparable,[projected],,,
 [common.alg.req]: pt. 4,"Note: could be done with pt. 1.           …                              permutable, mergeable, and sortable",[iterator.concepts],,,
 [std.iterator.tags],,[iterator.traits],,,
 [range.iterator.operations.advance],ranges::advance,[iterator.concepts],,,
 [range.iterator.operations.distance],ranges::distance,"[iterator.concepts], [range.range]",,,
 [range.iterator.operations.next],ranges::next,[iterator.concepts],,,
 [range.iterator.operations.prev],ranges::prev,[iterator.concepts],,,

libcxx/include/CMakeLists.txt

 set(files
   __availability
   __bit_reference
   __bits
   __bsd_locale_defaults.h
   __bsd_locale_fallbacks.h
   __config
   __debug
   __errc
   __functional_03
   __functional_base
   __functional_base_03
   __hash_table
   __iterator/concepts.h
   __iterator/incrementable_traits.h
+  __iterator/indirect_callable.h
   __iterator/iter_move.h
   __iterator/iterator_traits.h
   __iterator/readable_traits.h
   __libcpp_version
   __locale
   __memory/addressof.h
   __memory/allocation_guard.h
   __memory/allocator.h

libcxx/include/__iterator/concepts.h

 #define _LIBCPP___ITERATOR_CONCEPTS_H
 
 #include <__config>
 #include <concepts>
 #include <__iterator/iter_move.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/readable_traits.h>
+#include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #pragma GCC system_header
 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
concept __indirectly_readable_impl =
   } &&
   common_reference_with<iter_reference_t<_In>&&, iter_value_t<_In>&> &&
   common_reference_with<iter_reference_t<_In>&&, iter_rvalue_reference_t<_In>&&> &&
   common_reference_with<iter_rvalue_reference_t<_In>&&, const iter_value_t<_In>&>;
 
 template<class _In>
 concept indirectly_readable = __indirectly_readable_impl<remove_cvref_t<_In> >;
 
+template<indirectly_readable _Tp>
+using iter_common_reference_t = common_reference_t<iter_reference_t<_Tp>, iter_value_t<_Tp>&>;
+
 // [iterator.concept.writable]
 template<class _Out, class _Tp>
 concept indirectly_writable =
   requires(_Out&& __o, _Tp&& __t) {
     *__o = _VSTD::forward<_Tp>(__t);                        // not required to be equality-preserving
     *_VSTD::forward<_Out>(__o) = _VSTD::forward<_Tp>(__t);  // not required to be equality-preserving
     const_cast<const iter_reference_t<_Out>&&>(*__o) = _VSTD::forward<_Tp>(__t);                       // not required to be equality-preserving
     const_cast<const iter_reference_t<_Out>&&>(*_VSTD::forward<_Out>(__o)) = _VSTD::forward<_Tp>(__t); // not required to be equality-preserving

libcxx/include/__iterator/indirect_callable.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef _LIBCPP___ITERATOR_INDIRECT_CALLABLE_H
+#define _LIBCPP___ITERATOR_INDIRECT_CALLABLE_H
+
+#include <__config>
+#include <concepts>
+#include <__iterator/concepts.h>
+#include <__iterator/incrementable_traits.h>
+#include <type_traits>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+// clang-format off
+
+#if !defined(_LIBCPP_HAS_NO_RANGES)
+
+// [indirectcallable.indirectinvocable], indirect callables
+template<class F, class I>
+concept indirectly_unary_invocable =
+  indirectly_readable<I> &&
+  copy_constructible<F> &&
+  invocable<F&, iter_value_t<I>&> &&
+  invocable<F&, iter_reference_t<I> > &&
+  invocable<F&, iter_common_reference_t<I> > &&
+  common_reference_with<
+    invoke_result_t<F&, iter_value_t<I>&>,
+    invoke_result_t<F&, iter_reference_t<I> >>;
+
+template<class F, class I>
+concept indirectly_regular_unary_invocable =
+  indirectly_readable<I> &&
+  copy_constructible<F> &&
+  regular_invocable<F&, iter_value_t<I>&> &&
+  regular_invocable<F&, iter_reference_t<I> > &&
+  regular_invocable<F&, iter_common_reference_t<I> > &&
+  common_reference_with<
+    invoke_result_t<F&, iter_value_t<I>&>,
+    invoke_result_t<F&, iter_reference_t<I> >>;
+
+template<class F, class... Is>
+requires (indirectly_readable<Is> && ...) && invocable<F, iter_reference_t<Is>...>
+using indirect_result_t = invoke_result_t<F, iter_reference_t<Is>...>;
+
+// [projected], projected
+template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
+struct projected {
+  using value_type = remove_cvref_t<indirect_result_t<Proj&, I> >;
+  indirect_result_t<Proj&, I> operator*() const; // not defined
+};
+
+template<weakly_incrementable I, class Proj>
+struct incrementable_traits<projected<I, Proj> > {
+  using difference_type = iter_difference_t<I>;
+};
+
+#endif // !defined(_LIBCPP_HAS_NO_RANGES)
+
+// clang-format on
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___ITERATOR_INDIRECT_CALLABLE_H

libcxx/include/iterator

 
 template<dereferenceable T>
   requires ...
 using iter_rvalue_reference_t = decltype(ranges::iter_move(declval<T&>())); // since C++20
 
 // [iterator.concepts], iterator concepts
 // [iterator.concept.readable], concept indirectly_readable
 template<class In>
-  concept indirectly_readable = see below;                // since C++20
+  concept indirectly_readable = see below;                      // since C++20
 
+template<indirectly_readable T>
+  using iter_common_reference_t =
+    common_reference_t<iter_reference_t<T>, iter_value_t<T>&>;  // since C++20
+
 // [iterator.concept.writable], concept indirectly_writable
 template<class Out, class T>
   concept indirectly_writable = see below;                // since C++20
 
 // [iterator.concept.winc], concept weakly_­incrementable
 template<class I>
   concept weakly_incrementable = see below;                // since C++20
 
 // [iterator.concept.inc], concept incrementable
 template<class I>
   concept incrementable = see below;                       // since C++20
 
 // [iterator.concept.iterator], concept input_­or_­output_­iterator
   template<class I>
     concept input_or_output_iterator = see below;          // since C++20
 
 // [iterator.concept.sentinel], concept sentinel_­for
 template<class S, class I>
   concept sentinel_for = see below;                        // since C++20
 
+// [indirectcallable]
+// [indirectcallable.indirectinvocable]
+template<class F, class I>
+  concept indirectly_unary_invocable = see below;         // since C++20
+
+template<class F, class I>
+  concept indirectly_regular_unary_invocable = see below; // since C++20
+
+template<class F, class... Is>
+  requires (indirectly_readable<Is> && ...) && invocable<F, iter_reference_t<Is>...>
+    using indirect_result_t = invoke_result_t<F, iter_reference_t<Is>...>; // since C++20
+
+// [projected], projected
+template<indirectly_readable I, indirectly_regular_unary_invocable<I> Proj>
+  struct projected;                                                           // since C++20
+
+template<weakly_incrementable I, indirectly_regular_unary_invocable<I> Proj>
+  struct incrementable_traits<projected<I, Proj>>;                            // since C++20
+
 template<class Category, class T, class Distance = ptrdiff_t,
          class Pointer = T*, class Reference = T&>
 struct iterator
 {
     typedef T         value_type;
     typedef Distance  difference_type;
     typedef Pointer   pointer;
     typedef Reference reference;

 #include <__functional_base>
 #include <type_traits>
 #include <compare>
 #include <concepts> // Mandated by the Standard.
 #include <cstddef>
 #include <initializer_list>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
+#include <__iterator/indirect_callable.h>
 #include <__iterator/iter_move.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/readable_traits.h>
 #include <__memory/addressof.h>
 #include <__memory/pointer_traits.h>
 #include <version>
 
 #include <__debug>

libcxx/test/std/iterators/iterator.requirements/indirectcallable/indirectcallable.indirectinvocable/indirect_result_t.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// XFAIL: msvc && clang
+
+// indirect_result_t
+
+#include <iterator>
+
+#include <concepts>
+
+static_assert(std::same_as<std::indirect_result_t<int (*)(int), int*>, int>);
+static_assert(std::same_as<std::indirect_result_t<double (*)(int const&, float), int const*, float*>, double>);
+
+struct S {};
+static_assert(std::same_as<std::indirect_result_t<S (&)(int), int*>, S>);
+static_assert(std::same_as<std::indirect_result_t<long S::*, S*>, long&>);
+static_assert(std::same_as<std::indirect_result_t<S && (S::*)(), S*>, S&&>);
+static_assert(std::same_as<std::indirect_result_t<int S::* (S::*)(int) const, S*, int*>, int S::*>);
+
+template <class F, class... Is>
+constexpr bool no_indirect_result = !requires {
+  typename std::indirect_result_t<F, Is...>;
+};
+
+static_assert(no_indirect_result<int (*)(int), int>); // `int` isn't `indirectly_readable`
+static_assert(no_indirect_result<int, int*>);         // `int` isn't `invocable`

libcxx/test/std/iterators/iterator.requirements/indirectcallable/indirectcallable.indirectinvocable/indirectly_regular_unary_invocable.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// XFAIL: msvc && clang
+
+// template<class F, class I>
+// concept indirectly_unary_invocable;
+
+#include <iterator>
+
+#include <concepts>
+
+#include "indirectly_invocable.h"
+
+template <class F, class T>
+[[nodiscard]] consteval bool check_indirectly_unary_invocable() {
+  constexpr auto result = std::indirectly_unary_invocable<F, T>;
+  static_assert(std::indirectly_unary_invocable<F const, T> == result);
+  return result;
+}
+
+static_assert(check_indirectly_unary_invocable<indirectly_invocable<indirectly_readable>, indirectly_readable>());
+static_assert(check_indirectly_unary_invocable<int (*)(int), int*>());
+static_assert(check_indirectly_unary_invocable<int (&)(int), int*>());
+static_assert(check_indirectly_unary_invocable<int S::*, S*>());
+static_assert(check_indirectly_unary_invocable<int (S::*)(), S*>());
+static_assert(check_indirectly_unary_invocable<int (S::*)() const, S*>());
+static_assert(check_indirectly_unary_invocable<int (S::*)() volatile, S*>());
+static_assert(check_indirectly_unary_invocable<int (S::*)() const volatile, S*>());
+
+static_assert(!check_indirectly_unary_invocable<int(int), int*>()); // not move constructible
+static_assert(!check_indirectly_unary_invocable<int (*)(int*, int*), int*>());
+static_assert(!check_indirectly_unary_invocable<int (&)(int*, int*), int*>());
+static_assert(!check_indirectly_unary_invocable<int (S::*)(int*), S*>());
+static_assert(!check_indirectly_unary_invocable<int (S::*)(int*) const, S*>());
+static_assert(!check_indirectly_unary_invocable<int (S::*)(int*) volatile, S*>());
+static_assert(!check_indirectly_unary_invocable<int (S::*)(int*) const volatile, S*>());
+
+static_assert(
+    !check_indirectly_unary_invocable<non_copy_constructible_invocable<indirectly_readable>, indirectly_readable>());
+static_assert(
+    !check_indirectly_unary_invocable<not_invocable_from_iter_value<indirectly_readable>, indirectly_readable>());
+static_assert(
+    !check_indirectly_unary_invocable<rvalue_invocable_from_iter_value<indirectly_readable>, indirectly_readable>());
+static_assert(
+    !check_indirectly_unary_invocable<not_invocable_from_iter_reference<indirectly_readable>, indirectly_readable>());
+static_assert(!check_indirectly_unary_invocable<rvalue_invocable_from_iter_reference<indirectly_readable>,
+                                                indirectly_readable>());
+static_assert(!check_indirectly_unary_invocable<not_invocable_from_iter_common_reference<indirectly_readable>,
+                                                indirectly_readable>());
+static_assert(!check_indirectly_unary_invocable<rvalue_invocable_from_iter_common_reference<indirectly_readable>,
+                                                indirectly_readable>());
+static_assert(!check_indirectly_unary_invocable<unrelated_return_types<indirectly_readable>, indirectly_readable>());

libcxx/test/std/iterators/iterator.requirements/indirectcallable/indirectcallable.indirectinvocable/indirectly_unary_invocable.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// XFAIL: msvc && clang
+
+// template<class F, class I>
+// concept indirectly_regular_unary_invocable;
+
+#include <iterator>
+
+#include <concepts>
+
+#include "indirectly_invocable.h"
+
+template <class F, class T>
+[[nodiscard]] consteval bool check_indirectly_regular_unary_invocable() {
+  constexpr auto result = std::indirectly_regular_unary_invocable<F, T>;
+  static_assert(std::indirectly_regular_unary_invocable<F const, T> == result);
+  return result;
+}
+
+static_assert(
+    check_indirectly_regular_unary_invocable<indirectly_invocable<indirectly_readable>, indirectly_readable>());
+static_assert(check_indirectly_regular_unary_invocable<int (*)(int), int*>());
+static_assert(check_indirectly_regular_unary_invocable<int (&)(int), int*>());
+static_assert(check_indirectly_regular_unary_invocable<int S::*, S*>());
+static_assert(check_indirectly_regular_unary_invocable<int (S::*)(), S*>());
+static_assert(check_indirectly_regular_unary_invocable<int (S::*)() const, S*>());
+static_assert(check_indirectly_regular_unary_invocable<int (S::*)() volatile, S*>());
+static_assert(check_indirectly_regular_unary_invocable<int (S::*)() const volatile, S*>());
+
+static_assert(!check_indirectly_regular_unary_invocable<int(int), int*>()); // not move constructible
+static_assert(!check_indirectly_regular_unary_invocable<int (*)(int*, int*), int*>());
+static_assert(!check_indirectly_regular_unary_invocable<int (&)(int*, int*), int*>());
+static_assert(!check_indirectly_regular_unary_invocable<int (S::*)(int*), S*>());
+static_assert(!check_indirectly_regular_unary_invocable<int (S::*)(int*) const, S*>());
+static_assert(!check_indirectly_regular_unary_invocable<int (S::*)(int*) volatile, S*>());
+static_assert(!check_indirectly_regular_unary_invocable<int (S::*)(int*) const volatile, S*>());
+
+static_assert(!check_indirectly_regular_unary_invocable<non_copy_constructible_invocable<indirectly_readable>,
+                                                        indirectly_readable>());
+static_assert(!check_indirectly_regular_unary_invocable<not_invocable_from_iter_value<indirectly_readable>,
+                                                        indirectly_readable>());
+static_assert(!check_indirectly_regular_unary_invocable<rvalue_invocable_from_iter_value<indirectly_readable>,
+                                                        indirectly_readable>());
+static_assert(!check_indirectly_regular_unary_invocable<not_invocable_from_iter_reference<indirectly_readable>,
+                                                        indirectly_readable>());
+static_assert(!check_indirectly_regular_unary_invocable<rvalue_invocable_from_iter_reference<indirectly_readable>,
+                                                        indirectly_readable>());
+static_assert(!check_indirectly_regular_unary_invocable<not_invocable_from_iter_common_reference<indirectly_readable>,
+                                                        indirectly_readable>());
+static_assert(!check_indirectly_regular_unary_invocable<
+              rvalue_invocable_from_iter_common_reference<indirectly_readable>, indirectly_readable>());
+static_assert(
+    !check_indirectly_regular_unary_invocable<unrelated_return_types<indirectly_readable>, indirectly_readable>());

libcxx/test/std/iterators/iterator.requirements/indirectcallable/indirectcallable.indirectinvocable/subsumption.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// XFAIL: msvc && clang
+
+// template<class F, class I>
+// concept indirectly_unary_invocable;
+
+// template<class F, class I>
+// concept indirectly_regular_unary_invocable;
+
+#include <iterator>
+
+// clang-format off
+
+template<class I, class F>
+requires std::indirectly_readable<I> &&
+         std::copy_constructible<F> &&
+         std::invocable<F&, std::iter_value_t<I>&> &&
+         std::invocable<F&, std::iter_reference_t<I> > &&
+         std::invocable<F&, std::iter_common_reference_t<I> > &&
+         std::common_reference_with<
+           std::invoke_result_t<F&, std::iter_value_t<I>&>,
+           std::invoke_result_t<F&, std::iter_reference_t<I> >>
+[[nodiscard]] consteval bool check_indirectly_unary_invocable() {
+  return false;
+}
+
+template<class I, std::indirectly_unary_invocable<I> F>
+requires true
+[[nodiscard]] consteval bool check_indirectly_unary_invocable() {
+  return true;
+}
+
+// clang-format on
+
+struct S {};
+
+static_assert(check_indirectly_unary_invocable<S*, int S::*>());
+
+// clang-format off
+
+template<class I, class F>
+requires std::indirectly_readable<I> &&
+         std::copy_constructible<F> &&
+         std::regular_invocable<F&, std::iter_value_t<I>&> &&
+         std::regular_invocable<F&, std::iter_reference_t<I> > &&
+         std::regular_invocable<F&, std::iter_common_reference_t<I> > &&
+         std::common_reference_with<
+           std::invoke_result_t<F&, std::iter_value_t<I>&>,
+           std::invoke_result_t<F&, std::iter_reference_t<I> >>
+[[nodiscard]] consteval bool check_regular_indirectly_unary_invocable() {
+  return false;
+}
+
+template<class I, std::indirectly_regular_unary_invocable<I> F>
+requires true
+[[nodiscard]] consteval bool check_indirectly_regular_unary_invocable() {
+  return true;
+}
+
+// clang-format on
+
+static_assert(check_indirectly_regular_unary_invocable<S*, int S::*>());

libcxx/test/std/iterators/iterator.requirements/indirectcallable/projected/projected.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// XFAIL: msvc && clang
+
+// projected
+
+#include <iterator>
+
+#include <concepts>
+#include <functional>
+
+#include "test_iterators.h"
+
+using projected_int_ptr = std::projected<int const*, std::identity>;
+static_assert(std::same_as<typename projected_int_ptr::value_type, int>);
+static_assert(std::same_as<decltype(*std::declval<projected_int_ptr>()), int const&>);
+static_assert(std::same_as<std::iter_difference_t<projected_int_ptr>, std::ptrdiff_t>);
+
+struct S {};
+
+using projected_input_iterator = std::projected<input_iterator<S*>, int S::*>;
+static_assert(std::same_as<typename projected_input_iterator::value_type, int>);
+static_assert(std::same_as<decltype(*std::declval<projected_input_iterator>()), int&>);
+static_assert(std::same_as<std::iter_difference_t<projected_input_iterator>, std::ptrdiff_t>);
+
+using projected_forward_iterator = std::projected<forward_iterator<S*>, int (S::*)()>;
+static_assert(std::same_as<typename projected_forward_iterator::value_type, int>);
+static_assert(std::same_as<decltype(*std::declval<projected_forward_iterator>()), int>);
+static_assert(std::same_as<std::iter_difference_t<projected_forward_iterator>, std::ptrdiff_t>);
+
+using projected_bidirectional_iterator = std::projected<bidirectional_iterator<S*>, S* (S::*)() const>;
+static_assert(std::same_as<typename projected_bidirectional_iterator::value_type, S*>);
+static_assert(std::same_as<decltype(*std::declval<projected_bidirectional_iterator>()), S*>);
+static_assert(std::same_as<std::iter_difference_t<projected_bidirectional_iterator>, std::ptrdiff_t>);
+
+using projected_random_access_iterator = std::projected<random_access_iterator<S*>, S && (S::*)() volatile>;
+static_assert(std::same_as<typename projected_random_access_iterator::value_type, S>);
+static_assert(std::same_as<decltype(*std::declval<projected_random_access_iterator>()), S&&>);
+static_assert(std::same_as<std::iter_difference_t<projected_random_access_iterator>, std::ptrdiff_t>);
+
+using projected_contiguous_iterator = std::projected<contiguous_iterator<S*>, S& (S::*)() const volatile>;
+static_assert(std::same_as<typename projected_contiguous_iterator::value_type, S>);
+static_assert(std::same_as<decltype(*std::declval<projected_contiguous_iterator>()), S&>);
+static_assert(std::same_as<std::iter_difference_t<projected_contiguous_iterator>, std::ptrdiff_t>);
+
+template <class I, class F>
+constexpr bool not_projectable = !requires {
+  typename std::projected<I, F>;
+};
+
+static_assert(not_projectable<int, void (*)(int)>); // `int` isn't `indirectly_readable`
+static_assert(not_projectable<S, void (*)(int)>);   // `S` isn't `weakly_incrementable`
+static_assert(not_projectable<int*, void(int)>);    // `void(int)` doesn't satisfy `indirectly_regular_unary_invcable`

libcxx/test/std/iterators/iterator.requirements/iterator.concepts/iterator.concept.readable/iter_common_reference_t.compile.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-no-concepts
+// UNSUPPORTED: gcc-10
+// XFAIL: msvc && clang
+
+// iter_common_reference_t
+
+#include <iterator>
+
+#include <concepts>
+
+struct value_reference_same {
+  using value_type = int;
+  int operator*() const;
+};
+static_assert(std::same_as<std::iter_common_reference_t<value_reference_same>, int>);
+
+struct value_reference_same_without_qualifiers {
+  using value_type = double;
+  double& operator*() const;
+};
+static_assert(std::same_as<std::iter_common_reference_t<value_reference_same_without_qualifiers>, double&>);
+
+struct S {
+  explicit(false) S(int);
+};
+
+namespace std {
+template <template <class> class TQual, template <class> class QQual>
+struct basic_common_reference<int, S, TQual, QQual> {
+  using type = S;
+};
+
+template <template <class> class TQual, template <class> class QQual>
+struct basic_common_reference<S, int, TQual, QQual> : basic_common_reference<int, S, TQual, QQual> {};
+} // namespace std
+
+struct custom_common_reference {
+  using value_type = int;
+  S&& operator*() const;
+};
+static_assert(std::same_as<std::iter_common_reference_t<custom_common_reference>, S>);
+
+template <class T>
+constexpr bool no_common_reference = !requires {
+  typename std::iter_common_reference_t<T>;
+};
+
+static_assert(no_common_reference<S>); // `S` isn't `indirectly_readable`

libcxx/test/support/indirectly_invocable.h

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#ifndef LIBCXX_TEST_SUPPORT_INDIRECTLY_INVOCABLE_H
+#define LIBCXX_TEST_SUPPORT_INDIRECTLY_INVOCABLE_H
+
+#include <concepts>
+#include <iterator>
+#include <type_traits>
+
+#include "test_macros.h"
+
+#if TEST_STD_VER < 20
+#error "support/indirectly_invocable.h" can only be included in tests that support C++20 or later
+#endif
+
+struct S {
+  explicit(false) operator bool() const;
+};
+
+struct common {
+  explicit(false) common(int);
+  explicit(false) common(S);
+};
+
+namespace std {
+template <template <class> class TQual, template <class> class QQual>
+struct basic_common_reference<int, S, TQual, QQual> {
+  using type = common;
+};
+
+template <template <class> class TQual, template <class> class QQual>
+struct basic_common_reference<S, int, TQual, QQual> : basic_common_reference<int, S, TQual, QQual> {};
+} // namespace std
+
+struct indirectly_readable {
+  using value_type = int;
+  S& operator*() const;
+};
+
+// clang-format off
+template <std::indirectly_readable I>
+struct indirectly_invocable {
+  bool operator()(std::iter_value_t<I>&) const
+  requires (!std::same_as<std::iter_value_t<I>&, std::iter_common_reference_t<I> >);
+
+  int operator()(std::iter_reference_t<I>) const
+  requires (!std::same_as<std::iter_reference_t<I>, std::iter_common_reference_t<I> >);
+  bool operator()(std::iter_common_reference_t<I>) const;
+};
+// clang-format on
+
+template <std::indirectly_readable I>
+struct non_copy_constructible_invocable {
+  non_copy_constructible_invocable(non_copy_constructible_invocable&&) = default;
+  non_copy_constructible_invocable& operator=(non_copy_constructible_invocable&&) = default;
+
+  non_copy_constructible_invocable(non_copy_constructible_invocable const&) = delete;
+  non_copy_constructible_invocable& operator=(non_copy_constructible_invocable const&) = default;
+
+  bool operator()(std::iter_value_t<I>&);
+  bool operator()(std::iter_reference_t<I>);
+  bool operator()(std::same_as<std::iter_common_reference_t<I> > auto);
+};
+
+template <std::indirectly_readable I>
+struct not_invocable_from_iter_value {
+  bool operator()(std::iter_value_t<I>&) = delete;
+  bool operator()(std::iter_reference_t<I>);
+  bool operator()(std::same_as<std::iter_common_reference_t<I> > auto);
+};
+
+template <std::indirectly_readable I>
+struct rvalue_invocable_from_iter_value {
+  bool operator()(std::iter_value_t<I>&) &&;
+  bool operator()(std::iter_reference_t<I>);
+  bool operator()(std::same_as<std::iter_common_reference_t<I> > auto);
+};
+
+template <std::indirectly_readable I>
+struct not_invocable_from_iter_reference {
+  bool operator()(std::iter_value_t<I>&);
+  bool operator()(std::iter_reference_t<I>) = delete;
+  bool operator()(std::same_as<std::iter_common_reference_t<I> > auto);
+};
+
+template <std::indirectly_readable I>
+struct rvalue_invocable_from_iter_reference {
+  bool operator()(std::iter_value_t<I>&);
+  bool operator()(std::iter_reference_t<I>) &&;
+  bool operator()(std::same_as<std::iter_common_reference_t<I> > auto);
+};
+
+template <std::indirectly_readable I>
+struct not_invocable_from_iter_common_reference {
+  bool operator()(std::iter_value_t<I>&);
+  bool operator()(std::iter_reference_t<I>);
+};
+
+template <std::indirectly_readable I>
+struct rvalue_invocable_from_iter_common_reference {
+  bool operator()(std::iter_value_t<I>&);
+  bool operator()(std::iter_reference_t<I>);
+  bool operator()(std::same_as<std::iter_common_reference_t<I> > auto) &&;
+};
+
+template <std::indirectly_readable I>
+struct unrelated_return_types {
+  int* operator()(std::iter_value_t<I>&);
+  int operator()(std::iter_reference_t<I>);
+  int* operator()(std::iter_common_reference_t<I>);
+};
+
+#endif // LIBCXX_TEST_SUPPORT_INDIRECTLY_INVOCABLE_H