[libc++] Implement ranges::move{, _backward}

[philnik]

Summary

This patch also adds a new optimization to std::move. It unwraps three reverse_iterators if the wrapped iterator is a contiguous_iterator and the iterated type is trivially_movable. This allows us to simplify ranges::move_backward to a forward to std::move without any pessimization.

[var-const]

libcxx/include/__algorithm/move.h

37

Nit: you can use std::make_pair.

40–55

Nit: I think we usually don't add T to template type names.

49

Can you provide a bit more context about this workaround?

54

Is this check necessary? Does __builtin_memmove require the argument not to be zero?

73

Question: if _InIter and _OutIter have the same underlying value type, wouldn't __is_trivially_move_assignable_unwrapped always return the same result for both of them?

76

Question: this is a new optimization that isn't directly related to implementing ranges::move, right?

84

Very optional: you can use make_reverse_iterator.

90

Is this used? (same for this function's implementation below)

107–108

Nit: this should be _InIter for consistency (I'd personally prefer _InputIter, but feel free to ignore).

libcxx/include/__algorithm/move_backward.h

28 ↗

(On Diff #432792)

I'd rather keep the previous approach -- it's more verbose, but also straightforward, symmetrical with move.h, and avoiding the extra overhead from using reverse iterators (which includes the additional mental burden when reading the code and more complicated types when debugging).

libcxx/include/__algorithm/ranges_move.h

21

Nit: seems unused (in the other ranges header as well).

41

Question: can you provide more context on this constraint?

56

Nit: move the iterators?

libcxx/include/__algorithm/ranges_move_backward.h

46

Why does this function forward to __move with reverse iterators rather than __move_backward? (I understand that __move_backward would have to be added) While this would be more boilerplate, I think it would be simpler, more consistent, and avoid the extra overhead from using reverse iterators (and probably the need to treat them specially in __move).

73

Nit: move result.

libcxx/include/algorithm

362

Please double-check the synopsis, there are a few mentions of copy that should be move (e.g., s/copy_backward_result/move_backward_result/).

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move.pass.cpp

16

Same as synopsis, there are a few mentions of copy (in the other test file as well).

39

Question: are these types for checking the weakly_incrementable constraint? Just clarifying because the names seem unrelated.

53

Please also check the weakly_incrementable constraint.

95

How about a name like IteratorWithIterMove to make it a little easier to parse?

102

Nit: s/derefernced/dereferenced/.

112

Can you add a test case that deals with a move-only type?

122

Nit: decltype(auto).

139

Nit: s/copied/moved/.

169

Nit: s/canCopy/canMove/.

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move_backward.pass.cpp

4

Comments from the other test file apply here as well.

14

Ultranit: there's an extra blank line.

140

Nit: s/copied/moved/.

141

Nit: s/CopyOnce/MoveOnce/.

[var-const]

Please update the ranges status page.

[philnik]

• Rebased
• Address comments

libcxx/include/__algorithm/move.h

49

What are you asking about exactly? Why I have to check for is_trivially_copyable? That's because __builtin_memmove requires the type to be trivially_copable. Or do you mean something else?

54

AFAIK __builtin_memmove doesn't require the argument to be non-zero. The compiler doesn't eliminate the check either so I'm not sure if it should stay or not. This means potentially less function call, but also a branch more. I don't think it makes a large difference either way, so I'll remove it.

73

__is_trivially_move_assignable_unwrapped also checks that we get a raw pointer. But that's not relevant, since I'm updating the check to be equivalent to the check in copy.

76

It's a new optimization for std::move, but I'm removing a specialization from std::move_backward that would have done the same thing. Without this 'new' optimization I would pessimize std::move_backward and ranges::move_backward. I also think it's a good idea to implement more algorithms in terms of other algorithms to get more optimizations and get the optimizations into a single place instead of duplicating them all over the place. To achieve that I'm using reverse_iterator in quite a few places, so it's getting a lot more likely to have weird things like reverse_iterator<reverse_iterator<T>> or even more wrapped around.

84

make_reverse_iterator requires C++14 and I don't think it's worth to add a new __make_reverse_iterator for relatively little extra convenience.

90

This has been superseded by D127049. Removing it.

107–108

Nope. This is one of the classic STL algorithms where we use _InputIterator and friends. This is specifically to make them easily distinguishable.

libcxx/include/__algorithm/move_backward.h

28 ↗

(On Diff #432792)

I strongly disagree. It's currently a lot of code duplication without any obvious benefit IMO. I don't see how any symmetry is good here. We already have a better implementation of the algorithm, so why not use it? I also don't understand what mental burden you mean. I think it's a lot easier to reason about a forward going algorithm. If that works, a reverse_iterator call to that also works. With a reverse_iterator the types are technically more complicated, but how often do you step into move_backward? Almost never I would think. Forwarding to std::move also allows code sharing if you have std::move(reverse_iterator<T>) and std::move_backward(T) and similar combinations.

libcxx/include/__algorithm/ranges_move.h

41

As you can see below, ranges::move is required to use ranges::iter_move. The overload with __move_deref<_Iter> is the one that uses std::move(*__iter) (effectively). I think this can also be enabled in the __just_deref case, but I'm not sure and I wanted to play it safe for now.

libcxx/include/__algorithm/ranges_move_backward.h

46

See my comment in move_backward.h.

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move.pass.cpp

39

Nope, that's for checking the requires clause. I just forgot to rename it to NotIndirectlyMovable though. weakly_incrementable is checked by WeaklyIncrementableNotMovable.

[var-const]

Please update the ranges status page.

libcxx/include/__algorithm/move.h

49

I'm asking about the preprocessor guard, why the check is only done if the compiler is not GCC.

54

I'd expect 0 to be a very rare case, so I wouldn't add branching to the common case for the sake of it. Moreover, the 0 case will be pretty efficient even without omitting the function call.

76

I think this is useful context, consider adding a condensed version of it to the patch description.

84

Makes sense, thanks for explaining.

107–108

Ah, I must have missed that part of the discussion, thanks for explaining.

libcxx/include/__algorithm/move_backward.h

28 ↗

(On Diff #432792)

Let's say I'm writing a custom iterator and get a crash somewhere further down the stack from move_backward. The mental burden is having to deal with the additional layer of indirection from reverse_iterator. It might be a rare use case, but I don't think we can afford to ignore rare use cases given the size of our user base. Debugging experience is a common complaint about C++.

That said, I understand better why you prefer this approach after seeing the reverse_copy implementation which is quite elegant. Since this is a decision that can affect the implementation of quite a few algorithms, I'd ask @ldionne for guidance and defer to his opinion.

libcxx/include/__algorithm/ranges_move.h

41

Thanks. Can you add a comment like "Checks that std::move(*__iter) is well-formed"? I didn't find it entirely obvious from the name, and the implementation checks for a few different things.

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move.pass.cpp

114

Can you please add a brief comment explaining why cpp17_input_iterator doesn't work?

[ldionne]

libcxx/include/__algorithm/move_backward.h

28 ↗

(On Diff #432792)

I understand Costa's point about debugging and I agree with it to some extent. However, concretely, I don't think users would be stepping through our whole std::move_backward implementation anyways, and if so, they are probably placing breakpoints in strategic places in their code to avoid stepping through our implementation details. Hence, I think there are other ways to mitigate the downsides of this implementation, and I think the optimization in std::move and the removal of duplication in std::move_backward are worth it. Just my .02, but I would err towards the currently-proposed approach. If we gain more experience with this sort of technique (which BTW is akin to expression templates in a really basic way), and if we realize that it has negative effects for our users, we can and should revisit this stance.

[philnik]

• Address comments

libcxx/include/__algorithm/move.h

49

GCC currently doesn't support __builtin_memmove during constant evaluation, so we have to fall back to the naive implementation.

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move.pass.cpp

114

Because I forgot to add it :P

[var-const]

LGTM (didn't review the reverse_iterator changes that come from a different patch).

[philnik]

Rebased

[philnik]

• Undo the changes to move_backward for now

[philnik]

• Try to fix CI

[philnik]

• Fix modulemap

[huixie90]

libcxx/include/__algorithm/ranges_move.h

39–45

Why do we need this overload? shouldn't ranges::move always call ranges::iter_move?

[philnik]

libcxx/include/__algorithm/ranges_move.h

39–45

This isn't needed, but this allows us to unwrap the iterator and call memmove on trivially_copyable types.

[huixie90]

libcxx/include/__algorithm/ranges_move.h

39–45

But this overload has the wrong behaviour for proxy iterators. For example zip_view

see this example: https://godbolt.org/z/fWG6Te69T

if you call ranges::move on two zip_views, because zip_view's reference type is tuple<X&>, std::move(tuple<X&>) gives you tuple<X&>&&>, which will still trigger copy assignment of X. but zip_view customises its iter_move to return tuple<X&&> so if you use iter_move(it), it would trigger the move assignment of X.

I think correctness takes precedence of performance.

[philnik]

libcxx/include/__algorithm/ranges_move.h

39–45

That's why it's guarded with requires __iter_move::__move_deref<_InIter> to ensure that ranges::iter_move would just call std::move. Or am I missing something? Your example also looks correct to me: https://godbolt.org/z/vjchvc11z.

[huixie90]

libcxx/include/__algorithm/ranges_move.h

39–45

I see. I read the comments "// check that we are allowed to std::move() the value" and thought it meant that " std::move(x) is a valid expression". I think what it actually means is "there is no iter_move customisations."

My example is just showing that when there is an iter_move customisation, calling std::move(it, it, o) is the wrong behaviour.

I think your optimisation is ok but the comment can be made more clearer.

BTW, I think you could also turn on this optimisation for both move_deref and just_deref

[philnik]

libcxx/include/__algorithm/ranges_move.h

39–45

Ah OK. I can see that the comment could be interpreted the wrong way. If you're writing a comment yourself it often feels a lot more obvious than it actually is.
I too think that I could also enable it for __just_deref, but I wasn't 100% sure if I'm correct on that, so I wanted to postpone this optimziation to a follow-up PR. Calling std::move either way is a lot easier to ensure than checking all the implications of casting a type to an rvalue.
Anyways, I'm planning to look into that optimization and I'll update the comment.

libcxx/include/CMakeLists.txt

set(files
   __algorithm/ranges_lower_bound.h
   __algorithm/ranges_max.h
   __algorithm/ranges_max_element.h
   __algorithm/ranges_min.h
   __algorithm/ranges_min_element.h
   __algorithm/ranges_minmax.h
   __algorithm/ranges_minmax_element.h
   __algorithm/ranges_mismatch.h
+  __algorithm/ranges_move.h
+  __algorithm/ranges_move_backward.h
   __algorithm/ranges_none_of.h
   __algorithm/ranges_replace.h
   __algorithm/ranges_replace_if.h
   __algorithm/ranges_reverse.h
   __algorithm/ranges_sort.h
   __algorithm/ranges_swap_ranges.h
   __algorithm/ranges_transform.h
   __algorithm/ranges_upper_bound.h

libcxx/include/__algorithm/move.h

 //===----------------------------------------------------------------------===//
 //
 // 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___ALGORITHM_MOVE_H
 #define _LIBCPP___ALGORITHM_MOVE_H
 
 #include <__algorithm/unwrap_iter.h>
 #include <__config>
+#include <__iterator/iterator_traits.h>
+#include <__iterator/reverse_iterator.h>
 #include <__utility/move.h>
+#include <__utility/pair.h>
 #include <cstring>
 #include <type_traits>
 
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // move
 
-template <class _InputIterator, class _OutputIterator>
+template <class _InIter, class _Sent, class _OutIter>
 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-_OutputIterator
-__move_constexpr(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
-{
-    for (; __first != __last; ++__first, (void) ++__result)
-        *__result = _VSTD::move(*__first);
-    return __result;
+pair<_InIter, _OutIter> __move_impl(_InIter __first, _Sent __last, _OutIter __result) {
+  while (__first != __last) {
+    *__result = std::move(*__first);
+    ++__first;
+    ++__result;
   }
-
-template <class _InputIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-_OutputIterator
-__move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
-{
-    return _VSTD::__move_constexpr(__first, __last, __result);
+  return std::make_pair(std::move(__first), std::move(__result));
 }
 
-template <class _Tp, class _Up>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
-typename enable_if
-<
-    is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    is_trivially_move_assignable<_Up>::value,
-    _Up*
->::type
-__move(_Tp* __first, _Tp* __last, _Up* __result)
-{
-    const size_t __n = static_cast<size_t>(__last - __first);
-    if (__n > 0)
-        _VSTD::memmove(__result, __first, __n * sizeof(_Up));
-    return __result + __n;
+template <class _InType,
+          class _OutType,
+          class = __enable_if_t<is_same<typename remove_const<_InType>::type, _OutType>::value
+                             && is_trivially_move_assignable<_OutType>::value> >
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
+pair<_InType*, _OutType*> __move_impl(_InType* __first, _InType* __last, _OutType* __result) {
+  if (__libcpp_is_constant_evaluated()
+// TODO: Remove this once GCC supports __builtin_memmove during constant evaluation
+#ifndef _LIBCPP_COMPILER_GCC
+   && !is_trivially_copyable<_InType>::value
+#endif
+     )
+    return std::__move_impl<_InType*, _InType*, _OutType*>(__first, __last, __result);
+  ::__builtin_memmove(__result, __first, __n * sizeof(_OutType));
+  return std::make_pair(__first + __n, __result + __n);
 }
 
-template <class _InputIterator, class _OutputIterator>
-inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
-_OutputIterator
-move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
-{
-    if (__libcpp_is_constant_evaluated()) {
-        return _VSTD::__move_constexpr(__first, __last, __result);
-    } else {
-        return _VSTD::__rewrap_iter(__result,
-            _VSTD::__move(_VSTD::__unwrap_iter(__first),
-                          _VSTD::__unwrap_iter(__last),
-                          _VSTD::__unwrap_iter(__result)));
-    }
+template <class>
+struct __is_trivially_move_assignable_unwrapped_impl : false_type {};
+
+template <class _Type>
+struct __is_trivially_move_assignable_unwrapped_impl<_Type*> : is_trivially_move_assignable<_Type> {};
+
+template <class _Iter>
+struct __is_trivially_move_assignable_unwrapped
+    : __is_trivially_move_assignable_unwrapped_impl<decltype(std::__unwrap_iter<_Iter>(std::declval<_Iter>()))> {};
+
+template <class _InIter,
+          class _OutIter,
+          __enable_if_t<is_same<typename remove_const<typename iterator_traits<_InIter>::value_type>::type,
+                                typename iterator_traits<_OutIter>::value_type>::value
+                     && __is_cpp17_contiguous_iterator<_InIter>::value
+                     && __is_cpp17_contiguous_iterator<_OutIter>::value
+                     && is_trivially_move_assignable<__iter_value_type<_OutIter> >::value, int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX14
+pair<reverse_iterator<_InIter>, reverse_iterator<_OutIter> >
+__move_impl(reverse_iterator<_InIter> __first,
+            reverse_iterator<_InIter> __last,
+            reverse_iterator<_OutIter> __result) {
+  auto __first_base = std::__unwrap_iter(__first.base());
+  auto __last_base = std::__unwrap_iter(__last.base());
+  auto __result_base = std::__unwrap_iter(__result.base());
+  auto __result_first = __result_base - (__first_base - __last_base);
+  std::__move_impl(__last_base, __first_base, __result_first);
+  return std::make_pair(__last, reverse_iterator<_OutIter>(std::__rewrap_iter(__result.base(), __result_first)));
+}
+
+template <class _InIter, class _Sent, class _OutIter>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
+__enable_if_t<is_copy_constructible<_InIter>::value
+           && is_copy_constructible<_Sent>::value
+           && is_copy_constructible<_OutIter>::value, pair<_InIter, _OutIter> >
+__move(_InIter __first, _Sent __last, _OutIter __result) {
+  auto __ret = std::__move_impl(std::__unwrap_iter(__first), std::__unwrap_iter(__last), std::__unwrap_iter(__result));
+  return std::make_pair(std::__rewrap_iter(__first, __ret.first), std::__rewrap_iter(__result, __ret.second));
+
+template <class _InIter, class _Sent, class _OutIter>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX11
+__enable_if_t<!is_copy_constructible<_InIter>::value
+           || !is_copy_constructible<_Sent>::value
+           || !is_copy_constructible<_OutIter>::value, pair<_InIter, _OutIter> >
+__move(_InIter __first, _Sent __last, _OutIter __result) {
+  return std::__move_impl(std::move(__first), std::move(__last), std::move(__result));
+}
+
+template <class _InputIterator, class _OutputIterator>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_AFTER_CXX17
+_OutputIterator move(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
+  return std::__move(__first, __last, __result).second;
 }
 
 _LIBCPP_END_NAMESPACE_STD
 
 #endif // _LIBCPP___ALGORITHM_MOVE_H

libcxx/include/__algorithm/ranges_move.h

+//===----------------------------------------------------------------------===//
+//
+// 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___ALGORITHM_RANGES_MOVE_H
+#define _LIBCPP___ALGORITHM_RANGES_MOVE_H
+
+#include <__algorithm/in_out_result.h>
+#include <__algorithm/move.h>
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/iter_move.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+template <class _InIter, class _OutIter>
+using move_result = in_out_result<_InIter, _OutIter>;
+
+namespace __move {
+struct __fn {
+
+  template <class _InIter, class _Sent, class _OutIter>
+    requires __iter_move::__move_deref<_InIter> // check that we are allowed to std::move() the value
+  _LIBCPP_HIDE_FROM_ABI constexpr static
+  move_result<_InIter, _OutIter> __move_impl(_InIter __first, _Sent __last, _OutIter __result) {
+    auto __ret = std::__move(std::move(__first), std::move(__last), std::move(__result));
+    return {std::move(__ret.first), std::move(__ret.second)};
+  }
+
+  template <class _InIter, class _Sent, class _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr static
+  move_result<_InIter, _OutIter> __move_impl(_InIter __first, _Sent __last, _OutIter __result) {
+    while (__first != __last) {
+      *__result = ranges::iter_move(__first);
+      ++__first;
+      ++__result;
+    }
+    return {std::move(__first), std::move(__result)};
+  }
+
+  template <input_iterator _InIter, sentinel_for<_InIter> _Sent, weakly_incrementable _OutIter>
+    requires indirectly_movable<_InIter, _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  move_result<_InIter, _OutIter> operator()(_InIter __first, _Sent __last, _OutIter __result) const {
+    return __move_impl(std::move(__first), std::move(__last), std::move(__result));
+  }
+
+  template <input_range _Range, weakly_incrementable _OutIter>
+    requires indirectly_movable<iterator_t<_Range>, _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  move_result<borrowed_iterator_t<_Range>, _OutIter> operator()(_Range&& __range, _OutIter __result) const {
+    return __move_impl(ranges::begin(__range), ranges::end(__range), std::move(__result));
+  }
+
+};
+} // namespace __move
+
+inline namespace __cpo {
+  inline constexpr auto move = __move::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+#endif // _LIBCPP___ALGORITHM_RANGES_MOVE_H

libcxx/include/__algorithm/ranges_move_backward.h

+//===----------------------------------------------------------------------===//
+//
+// 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___ALGORITHM_RANGES_MOVE_BACKWARD_H
+#define _LIBCPP___ALGORITHM_RANGES_MOVE_BACKWARD_H
+
+#include <__algorithm/in_out_result.h>
+#include <__algorithm/ranges_move.h>
+#include <__config>
+#include <__iterator/concepts.h>
+#include <__iterator/iter_move.h>
+#include <__iterator/next.h>
+#include <__iterator/reverse_iterator.h>
+#include <__ranges/access.h>
+#include <__ranges/concepts.h>
+#include <__ranges/dangling.h>
+#include <__utility/move.h>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#  pragma GCC system_header
+#endif
+
+#if _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace ranges {
+
+template <class _InIter, class _OutIter>
+using move_backward_result = in_out_result<_InIter, _OutIter>;
+
+namespace __move_backward {
+struct __fn {
+
+  template <class _InIter, class _Sent, class _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr static
+  move_backward_result<_InIter, _OutIter> __move_backward_impl(_InIter __first, _Sent __last, _OutIter __result) {
+    auto __ret = ranges::move(std::make_reverse_iterator(ranges::next(__first, __last)),
+                              std::make_reverse_iterator(__first),
+                              std::make_reverse_iterator(__result));
+    return {std::move(__ret.in.base()), std::move(__ret.out.base())};
+  }
+
+  template <bidirectional_iterator _InIter, sentinel_for<_InIter> _Sent, bidirectional_iterator _OutIter>
+    requires indirectly_movable<_InIter, _OutIter>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  move_backward_result<_InIter, _OutIter> operator()(_InIter __first, _Sent __last, _OutIter __result) const {
+    return __move_backward_impl(std::move(__first), std::move(__last), std::move(__result));
+  }
+
+  template <bidirectional_range _Range, bidirectional_iterator _Iter>
+    requires indirectly_movable<iterator_t<_Range>, _Iter>
+  _LIBCPP_HIDE_FROM_ABI constexpr
+  move_backward_result<borrowed_iterator_t<_Range>, _Iter> operator()(_Range&& __range, _Iter __result) const {
+    return __move_backward_impl(ranges::begin(__range), ranges::end(__range), std::move(__result));
+  }
+
+};
+} // namespace __move_backward
+
+inline namespace __cpo {
+  inline constexpr auto move_backward = __move_backward::__fn{};
+} // namespace __cpo
+} // namespace ranges
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_STD_VER > 17 && !defined(_LIBCPP_HAS_NO_INCOMPLETE_RANGES)
+
+#endif // _LIBCPP___ALGORITHM_RANGES_MOVE_BACKWARD_H

libcxx/include/algorithm

template<input_range R1, input_range R2, class Pred = ranges::equal_to,
   template<forward_range R, class Proj = identity,
            indirect_strict_weak_order<projected<iterator_t<R>, Proj>> Comp = ranges::less>
     constexpr borrowed_iterator_t<R>
       ranges::is_sorted_until(R&& r, Comp comp = {}, Proj proj = {});                       // since C++20
 
   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
            indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
     constexpr I upper_bound(I first, S last, const T& value, Comp comp = {}, Proj proj = {}); // since C++20
 
   template<forward_range R, class T, class Proj = identity,
            indirect_strict_weak_order<const T*, projected<iterator_t<R>, Proj>> Comp =
              ranges::less>
     constexpr borrowed_iterator_t<R>
       upper_bound(R&& r, const T& value, Comp comp = {}, Proj proj = {});                     // since C++20
 
   template<forward_iterator I, sentinel_for<I> S, class T, class Proj = identity,
            indirect_strict_weak_order<const T*, projected<I, Proj>> Comp = ranges::less>
template<input_range R1, input_range R2, class Pred = ranges::equal_to,
   template<input_range R1, input_range R2, class Proj1 = identity,
            class Proj2 = identity,
            indirect_strict_weak_order<projected<iterator_t<R1>, Proj1>,
                                       projected<iterator_t<R2>, Proj2>> Comp = ranges::less>
     constexpr bool
       ranges::lexicographical_compare(R1&& r1, R2&& r2, Comp comp = {},
                                       Proj1 proj1 = {}, Proj2 proj2 = {});                    // since C++20
 
+  template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
+    requires indirectly_movable<I1, I2>
+    constexpr ranges::move_backward_result<I1, I2>
+      ranges::move_backward(I1 first, S1 last, I2 result);                                          // since C++20
+
+  template<bidirectional_range R, bidirectional_iterator I>
+    requires indirectly_movable<iterator_t<R>, I>
+    constexpr ranges::move_backward_result<borrowed_iterator_t<R>, I>
+      ranges::move_backward(R&& r, I result);                                                       // since C++20
+
+  template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
+    requires indirectly_movable<I, O>
+    constexpr ranges::move_result<I, O>
+      ranges::move(I first, S last, O result);                                                      // since C++20
+
+  template<input_range R, weakly_incrementable O>
+    requires indirectly_movable<iterator_t<R>, O>
+    constexpr ranges::move_result<borrowed_iterator_t<R>, O>
+      ranges::move(R&& r, O result);                                                                // since C++20
+
+
 }
 
     constexpr bool     // constexpr in C++20
     all_of(InputIterator first, InputIterator last, Predicate pred);
 
 template <class InputIterator, class Predicate>
     constexpr bool     // constexpr in C++20
     any_of(InputIterator first, InputIterator last, Predicate pred);

 #include <__algorithm/ranges_lower_bound.h>
 #include <__algorithm/ranges_max.h>
 #include <__algorithm/ranges_max_element.h>
 #include <__algorithm/ranges_min.h>
 #include <__algorithm/ranges_min_element.h>
 #include <__algorithm/ranges_minmax.h>
 #include <__algorithm/ranges_minmax_element.h>
 #include <__algorithm/ranges_mismatch.h>
+#include <__algorithm/ranges_move.h>
+#include <__algorithm/ranges_move_backward.h>
 #include <__algorithm/ranges_none_of.h>
 #include <__algorithm/ranges_replace.h>
 #include <__algorithm/ranges_replace_if.h>
 #include <__algorithm/ranges_reverse.h>
 #include <__algorithm/ranges_sort.h>
 #include <__algorithm/ranges_swap_ranges.h>
 #include <__algorithm/ranges_transform.h>
 #include <__algorithm/ranges_upper_bound.h>

libcxx/include/module.modulemap.in

module __algorithm {
       module ranges_lower_bound              { private header "__algorithm/ranges_lower_bound.h" }
       module ranges_max                      { private header "__algorithm/ranges_max.h" }
       module ranges_max_element              { private header "__algorithm/ranges_max_element.h" }
       module ranges_min                      { private header "__algorithm/ranges_min.h" }
       module ranges_min_element              { private header "__algorithm/ranges_min_element.h" }
       module ranges_minmax                   { private header "__algorithm/ranges_minmax.h" }
       module ranges_minmax_element           { private header "__algorithm/ranges_minmax_element.h" }
       module ranges_mismatch                 { private header "__algorithm/ranges_mismatch.h" }
+      module ranges_move                     { private header "__algorithm/ranges_move.h" }
+      module ranges_move_backward            { private header "__algorithm/ranges_move_backward.h" }
       module ranges_none_of                  { private header "__algorithm/ranges_none_of.h" }
       module ranges_replace                  { private header "__algorithm/ranges_replace.h" }
       module ranges_replace_if               { private header "__algorithm/ranges_replace_if.h" }
       module ranges_reverse                  { private header "__algorithm/ranges_reverse.h" }
       module ranges_sort                     { private header "__algorithm/ranges_sort.h" }
       module ranges_swap_ranges              { private header "__algorithm/ranges_swap_ranges.h" }
       module ranges_transform                { private header "__algorithm/ranges_transform.h" }
       module ranges_upper_bound              { private header "__algorithm/ranges_upper_bound.h" }

libcxx/test/libcxx/private_headers.verify.cpp

 #include <__algorithm/ranges_lower_bound.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_lower_bound.h'}}
 #include <__algorithm/ranges_max.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_max.h'}}
 #include <__algorithm/ranges_max_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_max_element.h'}}
 #include <__algorithm/ranges_min.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_min.h'}}
 #include <__algorithm/ranges_min_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_min_element.h'}}
 #include <__algorithm/ranges_minmax.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_minmax.h'}}
 #include <__algorithm/ranges_minmax_element.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_minmax_element.h'}}
 #include <__algorithm/ranges_mismatch.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_mismatch.h'}}
+#include <__algorithm/ranges_move.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_move.h'}}
+#include <__algorithm/ranges_move_backward.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_move_backward.h'}}
 #include <__algorithm/ranges_none_of.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_none_of.h'}}
 #include <__algorithm/ranges_replace.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_replace.h'}}
 #include <__algorithm/ranges_replace_if.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_replace_if.h'}}
 #include <__algorithm/ranges_reverse.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_reverse.h'}}
 #include <__algorithm/ranges_sort.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_sort.h'}}
 #include <__algorithm/ranges_swap_ranges.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_swap_ranges.h'}}
 #include <__algorithm/ranges_transform.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_transform.h'}}
 #include <__algorithm/ranges_upper_bound.h> // expected-error@*:* {{use of private header from outside its module: '__algorithm/ranges_upper_bound.h'}}

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move.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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<input_iterator I, sentinel_for<I> S, weakly_incrementable O>
+//   requires indirectly_movable<I, O>
+//   constexpr ranges::move_result<I, O>
+//     ranges::move(I first, S last, O result);
+// template<input_range R, weakly_incrementable O>
+//   requires indirectly_movable<iterator_t<R>, O>
+//   constexpr ranges::move_result<borrowed_iterator_t<R>, O>
+//     ranges::move(R&& r, O result);
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "MoveOnly.h"
+#include "test_iterators.h"
+
+template <class In, class Out = In, class Sent = sentinel_wrapper<In>>
+concept HasMoveIt = requires(In in, Sent sent, Out out) { std::ranges::move(in, sent, out); };
+
+static_assert(HasMoveIt<int*>);
+static_assert(!HasMoveIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasMoveIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasMoveIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasMoveIt<int*, WeaklyIncrementableNotMovable>);
+struct NotIndirectlyMovable {};
+static_assert(!HasMoveIt<int*, NotIndirectlyMovable*>);
+static_assert(!HasMoveIt<int*, int*, SentinelForNotSemiregular>);
+static_assert(!HasMoveIt<int*, int*, SentinelForNotWeaklyEqualityComparableWith>);
+
+template <class Range, class Out>
+concept HasMoveR = requires(Range range, Out out) { std::ranges::move(range, out); };
+
+static_assert(HasMoveR<std::array<int, 10>, int*>);
+static_assert(!HasMoveR<InputRangeNotDerivedFrom, int*>);
+static_assert(!HasMoveR<InputRangeNotIndirectlyReadable, int*>);
+static_assert(!HasMoveR<InputRangeNotInputOrOutputIterator, int*>);
+static_assert(!HasMoveR<WeaklyIncrementableNotMovable, int*>);
+static_assert(!HasMoveR<UncheckedRange<NotIndirectlyMovable*>, int*>);
+static_assert(!HasMoveR<InputRangeNotSentinelSemiregular, int*>);
+static_assert(!HasMoveR<InputRangeNotSentinelEqualityComparableWith, int*>);
+static_assert(!HasMoveR<UncheckedRange<int*>, WeaklyIncrementableNotMovable>);
+
+static_assert(std::is_same_v<std::ranges::move_result<int, long>, std::ranges::in_out_result<int, long>>);
+
+template <class In, class Out, class Sent, int N>
+constexpr void test(std::array<int, N> in) {
+  {
+    std::array<int, N> out;
+    std::same_as<std::ranges::in_out_result<In, Out>> decltype(auto) ret =
+      std::ranges::move(In(in.data()), Sent(In(in.data() + in.size())), Out(out.data()));
+    assert(in == out);
+    assert(base(ret.in) == in.data() + in.size());
+    assert(base(ret.out) == out.data() + out.size());
+  }
+  {
+    std::array<int, N> out;
+    auto range = std::ranges::subrange(In(in.data()), Sent(In(in.data() + in.size())));
+    std::same_as<std::ranges::in_out_result<In, Out>> decltype(auto) ret =
+        std::ranges::move(range, Out(out.data()));
+    assert(in == out);
+    assert(base(ret.in) == in.data() + in.size());
+    assert(base(ret.out) == out.data() + out.size());
+  }
+}
+
+template <class In, class Out, class Sent = In>
+constexpr void test_iterators() {
+  // simple test
+  test<In, Out, Sent, 4>({1, 2, 3, 4});
+  // check that an empty range works
+  test<In, Out, Sent, 0>({});
+}
+
+template <class Out>
+constexpr void test_in_iterators() {
+  test_iterators<cpp20_input_iterator<int*>, Out, sentinel_wrapper<cpp20_input_iterator<int*>>>();
+  test_iterators<forward_iterator<int*>, Out>();
+  test_iterators<bidirectional_iterator<int*>, Out>();
+  test_iterators<random_access_iterator<int*>, Out>();
+  test_iterators<contiguous_iterator<int*>, Out>();
+}
+
+struct IteratorWithMoveIter {
+  using value_type = int;
+  using difference_type = int;
+  explicit IteratorWithMoveIter() = default;
+  int* ptr;
+  constexpr IteratorWithMoveIter(int* ptr_) : ptr(ptr_) {}
+
+  constexpr int& operator*() const; // iterator with iter_move should not be dereferenced
+
+  constexpr IteratorWithMoveIter& operator++() { ++ptr; return *this; }
+  constexpr IteratorWithMoveIter operator++(int) { auto ret = *this; ++*this; return ret; }
+
+  friend constexpr int iter_move(const IteratorWithMoveIter&) { return 42; }
+
+  constexpr bool operator==(const IteratorWithMoveIter& other) const = default;
+};
+
+constexpr bool test() {
+  test_in_iterators<cpp17_output_iterator<int*>>();
+  test_in_iterators<cpp20_output_iterator<int*>>();
+  test_in_iterators<cpp17_input_iterator<int*>>();
+  test_in_iterators<cpp20_input_iterator<int*>>();
+  test_in_iterators<forward_iterator<int*>>();
+  test_in_iterators<bidirectional_iterator<int*>>();
+  test_in_iterators<random_access_iterator<int*>>();
+  test_in_iterators<contiguous_iterator<int*>>();
+
+  { // check that a move-only type works
+    {
+      MoveOnly a[] = {1, 2, 3};
+      MoveOnly b[3];
+      std::ranges::move(a, std::begin(b));
+      assert(b[0].get() == 1);
+      assert(b[1].get() == 2);
+      assert(b[2].get() == 3);
+    }
+    {
+      MoveOnly a[] = {1, 2, 3};
+      MoveOnly b[3];
+      std::ranges::move(std::begin(a), std::end(a), std::begin(b));
+      assert(b[0].get() == 1);
+      assert(b[1].get() == 2);
+      assert(b[2].get() == 3);
+    }
+  }
+
+  { // check that ranges::dangling is returned
+    std::array<int, 4> out;
+    std::same_as<std::ranges::in_out_result<std::ranges::dangling, int*>> decltype(auto) ret =
+      std::ranges::move(std::array {1, 2, 3, 4}, out.data());
+    assert(ret.out == out.data() + 4);
+    assert((out == std::array{1, 2, 3, 4}));
+  }
+
+  { // check that an iterator is returned with a borrowing range
+    std::array in {1, 2, 3, 4};
+    std::array<int, 4> out;
+    std::same_as<std::ranges::in_out_result<int*, int*>> decltype(auto) ret =
+        std::ranges::move(std::views::all(in), out.data());
+    assert(ret.in == in.data() + 4);
+    assert(ret.out == out.data() + 4);
+    assert(in == out);
+  }
+
+  { // check that every element is moved exactly once
+    struct MoveOnce {
+      bool moved = false;
+      constexpr MoveOnce() = default;
+      constexpr MoveOnce(const MoveOnce& other) = delete;
+      constexpr MoveOnce& operator=(MoveOnce&& other) {
+        assert(!other.moved);
+        moved = true;
+        return *this;
+      }
+    };
+    {
+      std::array<MoveOnce, 4> in {};
+      std::array<MoveOnce, 4> out {};
+      auto ret = std::ranges::move(in.begin(), in.end(), out.begin());
+      assert(ret.in == in.end());
+      assert(ret.out == out.end());
+      assert(std::all_of(out.begin(), out.end(), [](const auto& e) { return e.moved; }));
+    }
+    {
+      std::array<MoveOnce, 4> in {};
+      std::array<MoveOnce, 4> out {};
+      auto ret = std::ranges::move(in, out.begin());
+      assert(ret.in == in.end());
+      assert(ret.out == out.end());
+      assert(std::all_of(out.begin(), out.end(), [](const auto& e) { return e.moved; }));
+    }
+  }
+
+  { // check that the range is moved forwards
+    struct OnlyForwardsMovable {
+      OnlyForwardsMovable* next = nullptr;
+      bool canMove = false;
+      OnlyForwardsMovable() = default;
+      constexpr OnlyForwardsMovable& operator=(OnlyForwardsMovable&&) {
+        assert(canMove);
+        if (next != nullptr)
+          next->canMove = true;
+        return *this;
+      }
+    };
+    {
+      std::array<OnlyForwardsMovable, 3> in {};
+      std::array<OnlyForwardsMovable, 3> out {};
+      out[0].next = &out[1];
+      out[1].next = &out[2];
+      out[0].canMove = true;
+      auto ret = std::ranges::move(in.begin(), in.end(), out.begin());
+      assert(ret.in == in.end());
+      assert(ret.out == out.end());
+      assert(out[0].canMove);
+      assert(out[1].canMove);
+      assert(out[2].canMove);
+    }
+    {
+      std::array<OnlyForwardsMovable, 3> in {};
+      std::array<OnlyForwardsMovable, 3> out {};
+      out[0].next = &out[1];
+      out[1].next = &out[2];
+      out[0].canMove = true;
+      auto ret = std::ranges::move(in, out.begin());
+      assert(ret.in == in.end());
+      assert(ret.out == out.end());
+      assert(out[0].canMove);
+      assert(out[1].canMove);
+      assert(out[2].canMove);
+    }
+  }
+
+  { // check that iter_move is used properly
+    {
+      int a[] = {1, 2, 3, 4};
+      std::array<int, 4> b;
+      auto ret = std::ranges::move(IteratorWithMoveIter(a), IteratorWithMoveIter(a + 4), b.data());
+      assert(ret.in == a + 4);
+      assert(ret.out == b.data() + 4);
+      assert((b == std::array {42, 42, 42, 42}));
+    }
+    {
+      int a[] = {1, 2, 3, 4};
+      std::array<int, 4> b;
+      auto range = std::ranges::subrange(IteratorWithMoveIter(a), IteratorWithMoveIter(a + 4));
+      auto ret = std::ranges::move(range, b.data());
+      assert(ret.in == a + 4);
+      assert(ret.out == b.data() + 4);
+      assert((b == std::array {42, 42, 42, 42}));
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/algorithms/alg.modifying.operations/alg.move/ranges.move_backward.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
+//
+//===----------------------------------------------------------------------===//
+
+// <algorithm>
+
+// UNSUPPORTED: c++03, c++11, c++14, c++17
+// UNSUPPORTED: libcpp-has-no-incomplete-ranges
+
+// template<bidirectional_iterator I1, sentinel_for<I1> S1, bidirectional_iterator I2>
+//   requires indirectly_movable<I1, I2>
+//   constexpr ranges::move_backward_result<I1, I2>
+//     ranges::move_backward(I1 first, S1 last, I2 result);
+// template<bidirectional_range R, bidirectional_iterator I>
+//   requires indirectly_movable<iterator_t<R>, I>
+//   constexpr ranges::move_backward_result<borrowed_iterator_t<R>, I>
+//     ranges::move_backward(R&& r, I result);
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <ranges>
+
+#include "almost_satisfies_types.h"
+#include "MoveOnly.h"
+#include "test_iterators.h"
+
+template <class In, class Out = In, class Sent = sentinel_wrapper<In>>
+concept HasMoveBackwardIt = requires(In in, Sent sent, Out out) { std::ranges::move_backward(in, sent, out); };
+
+static_assert(HasMoveBackwardIt<int*>);
+static_assert(!HasMoveBackwardIt<InputIteratorNotDerivedFrom>);
+static_assert(!HasMoveBackwardIt<InputIteratorNotIndirectlyReadable>);
+static_assert(!HasMoveBackwardIt<InputIteratorNotInputOrOutputIterator>);
+static_assert(!HasMoveBackwardIt<int*, WeaklyIncrementableNotMovable>);
+struct NotIndirectlyCopyable {};
+static_assert(!HasMoveBackwardIt<int*, NotIndirectlyCopyable*>);
+static_assert(!HasMoveBackwardIt<int*, int*, SentinelForNotSemiregular>);
+static_assert(!HasMoveBackwardIt<int*, int*, SentinelForNotWeaklyEqualityComparableWith>);
+
+template <class Range, class Out>
+concept HasMoveBackwardR = requires(Range range, Out out) { std::ranges::move_backward(range, out); };
+
+static_assert(HasMoveBackwardR<std::array<int, 10>, int*>);
+static_assert(!HasMoveBackwardR<InputRangeNotDerivedFrom, int*>);
+static_assert(!HasMoveBackwardR<InputRangeNotIndirectlyReadable, int*>);
+static_assert(!HasMoveBackwardR<InputRangeNotInputOrOutputIterator, int*>);
+static_assert(!HasMoveBackwardR<WeaklyIncrementableNotMovable, int*>);
+static_assert(!HasMoveBackwardR<UncheckedRange<NotIndirectlyCopyable*>, int*>);
+static_assert(!HasMoveBackwardR<InputRangeNotSentinelSemiregular, int*>);
+static_assert(!HasMoveBackwardR<InputRangeNotSentinelEqualityComparableWith, int*>);
+static_assert(!HasMoveBackwardR<UncheckedRange<int*>, WeaklyIncrementableNotMovable>);
+
+static_assert(std::is_same_v<std::ranges::copy_result<int, long>, std::ranges::in_out_result<int, long>>);
+
+template <class In, class Out, class Sent, int N>
+constexpr void test(std::array<int, N> in) {
+  {
+    std::array<int, N> out;
+    std::same_as<std::ranges::in_out_result<In, Out>> decltype(auto) ret =
+      std::ranges::move_backward(In(in.data()), Sent(In(in.data() + in.size())), Out(out.data() + out.size()));
+    assert(in == out);
+    assert(base(ret.in) == in.data());
+    assert(base(ret.out) == out.data());
+  }
+  {
+    std::array<int, N> out;
+    auto range = std::ranges::subrange(In(in.data()), Sent(In(in.data() + in.size())));
+    std::same_as<std::ranges::in_out_result<In, Out>> decltype(auto) ret =
+        std::ranges::move_backward(range, Out(out.data() + out.size()));
+    assert(in == out);
+    assert(base(ret.in) == in.data());
+    assert(base(ret.out) == out.data());
+  }
+}
+
+template <class In, class Out, class Sent = In>
+constexpr void test_iterators() {
+  // simple test
+  test<In, Out, Sent, 4>({1, 2, 3, 4});
+  // check that an empty range works
+  test<In, Out, Sent, 0>({});
+}
+
+template <class Out>
+constexpr void test_in_iterators() {
+  test_iterators<bidirectional_iterator<int*>, Out, sentinel_wrapper<bidirectional_iterator<int*>>>();
+  test_iterators<bidirectional_iterator<int*>, Out>();
+  test_iterators<random_access_iterator<int*>, Out>();
+  test_iterators<contiguous_iterator<int*>, Out>();
+}
+
+struct IteratorWithMoveIter {
+  using value_type = int;
+  using difference_type = int;
+  explicit IteratorWithMoveIter() = default;
+  int* ptr;
+  constexpr IteratorWithMoveIter(int* ptr_) : ptr(ptr_) {}
+
+  constexpr int& operator*() const; // iterator with iter_move should not be dereferenced
+
+  constexpr IteratorWithMoveIter& operator++() { ++ptr; return *this; }
+  constexpr IteratorWithMoveIter operator++(int) { auto ret = *this; ++*this; return ret; }
+
+  constexpr IteratorWithMoveIter& operator--() { --ptr; return *this; }
+  constexpr IteratorWithMoveIter operator--(int) { auto ret = *this; --*this; return ret; }
+
+  friend constexpr int iter_move(const IteratorWithMoveIter&) { return 42; }
+
+  constexpr bool operator==(const IteratorWithMoveIter& other) const = default;
+};
+
+constexpr bool test() {
+  test_in_iterators<bidirectional_iterator<int*>>();
+  test_in_iterators<random_access_iterator<int*>>();
+  test_in_iterators<contiguous_iterator<int*>>();
+
+  { // check that a move-only type works
+    {
+      MoveOnly a[] = {1, 2, 3};
+      MoveOnly b[3];
+      std::ranges::move_backward(a, std::end(b));
+      assert(b[0].get() == 1);
+      assert(b[1].get() == 2);
+      assert(b[2].get() == 3);
+    }
+    {
+      MoveOnly a[] = {1, 2, 3};
+      MoveOnly b[3];
+      std::ranges::move_backward(std::begin(a), std::end(a), std::end(b));
+      assert(b[0].get() == 1);
+      assert(b[1].get() == 2);
+      assert(b[2].get() == 3);
+    }
+  }
+
+  { // check that ranges::dangling is returned
+    std::array<int, 4> out;
+    std::same_as<std::ranges::in_out_result<std::ranges::dangling, int*>> auto ret =
+      std::ranges::move_backward(std::array {1, 2, 3, 4}, out.data() + out.size());
+    assert(ret.out == out.data());
+    assert((out == std::array{1, 2, 3, 4}));
+  }
+
+  { // check that an iterator is returned with a borrowing range
+    std::array in {1, 2, 3, 4};
+    std::array<int, 4> out;
+    std::same_as<std::ranges::in_out_result<int*, int*>> auto ret =
+        std::ranges::move_backward(std::views::all(in), out.data() + out.size());
+    assert(ret.in == in.data());
+    assert(ret.out == out.data());
+    assert(in == out);
+  }
+
+  { // check that every element is moved exactly once
+    struct MoveOnce {
+      bool moved = false;
+      constexpr MoveOnce() = default;
+      constexpr MoveOnce(const MoveOnce& other) = delete;
+      constexpr MoveOnce& operator=(const MoveOnce& other) {
+        assert(!other.moved);
+        moved = true;
+        return *this;
+      }
+    };
+    {
+      std::array<MoveOnce, 4> in {};
+      std::array<MoveOnce, 4> out {};
+      auto ret = std::ranges::move_backward(in.begin(), in.end(), out.end());
+      assert(ret.in == in.begin());
+      assert(ret.out == out.begin());
+      assert(std::all_of(out.begin(), out.end(), [](const auto& e) { return e.moved; }));
+    }
+    {
+      std::array<MoveOnce, 4> in {};
+      std::array<MoveOnce, 4> out {};
+      auto ret = std::ranges::move_backward(in, out.end());
+      assert(ret.in == in.begin());
+      assert(ret.out == out.begin());
+      assert(std::all_of(out.begin(), out.end(), [](const auto& e) { return e.moved; }));
+    }
+  }
+
+  { // check that the range is moved backwards
+    struct OnlyBackwardsMovable {
+      OnlyBackwardsMovable* next = nullptr;
+      bool canMove = false;
+      OnlyBackwardsMovable() = default;
+      constexpr OnlyBackwardsMovable& operator=(const OnlyBackwardsMovable&) {
+        assert(canMove);
+        if (next != nullptr)
+          next->canMove = true;
+        return *this;
+      }
+    };
+    {
+      std::array<OnlyBackwardsMovable, 3> in {};
+      std::array<OnlyBackwardsMovable, 3> out {};
+      out[1].next = &out[0];
+      out[2].next = &out[1];
+      out[2].canMove = true;
+      auto ret = std::ranges::move_backward(in, out.end());
+      assert(ret.in == in.begin());
+      assert(ret.out == out.begin());
+      assert(out[0].canMove);
+      assert(out[1].canMove);
+      assert(out[2].canMove);
+    }
+    {
+      std::array<OnlyBackwardsMovable, 3> in {};
+      std::array<OnlyBackwardsMovable, 3> out {};
+      out[1].next = &out[0];
+      out[2].next = &out[1];
+      out[2].canMove = true;
+      auto ret = std::ranges::move_backward(in.begin(), in.end(), out.end());
+      assert(ret.in == in.begin());
+      assert(ret.out == out.begin());
+      assert(out[0].canMove);
+      assert(out[1].canMove);
+      assert(out[2].canMove);
+    }
+  }
+
+  { // check that iter_move is used properly
+    {
+      int a[] = {1, 2, 3, 4};
+      std::array<int, 4> b;
+      auto ret = std::ranges::move_backward(IteratorWithMoveIter(a), IteratorWithMoveIter(a + 4), b.data() + b.size());
+      assert(ret.in == a);
+      assert(ret.out == b.data());
+      assert((b == std::array {42, 42, 42, 42}));
+    }
+    {
+      int a[] = {1, 2, 3, 4};
+      std::array<int, 4> b;
+      auto range = std::ranges::subrange(IteratorWithMoveIter(a), IteratorWithMoveIter(a + 4));
+      auto ret = std::ranges::move_backward(range, b.data() + b.size());
+      assert(ret.in == a);
+      assert(ret.out == b.data());
+      assert((b == std::array {42, 42, 42, 42}));
+    }
+  }
+
+  return true;
+}
+
+int main(int, char**) {
+  test();
+  static_assert(test());
+
+  return 0;
+}

libcxx/test/std/library/description/conventions/customization.point.object/niebloid.compile.pass.cpp

 static_assert(test(std::ranges::max, a));
 static_assert(test(std::ranges::max_element, a));
 //static_assert(test(std::ranges::merge, a, a, a));
 static_assert(test(std::ranges::min, a));
 static_assert(test(std::ranges::min_element, a));
 static_assert(test(std::ranges::minmax, a));
 static_assert(test(std::ranges::minmax_element, a));
 static_assert(test(std::ranges::mismatch, a, a));
-//static_assert(test(std::ranges::move, a, a));
-//static_assert(test(std::ranges::move_backward, a, a));
+static_assert(test(std::ranges::move, a, a));
+static_assert(test(std::ranges::move_backward, a, a));
 //static_assert(test(std::ranges::next_permutation, a));
 static_assert(test(std::ranges::none_of, a, odd));
 //static_assert(test(std::ranges::nth_element, a, a+5));
 //static_assert(test(std::ranges::partial_sort, a, a+5));
 //static_assert(test(std::ranges::partial_sort_copy, a, a));
 //static_assert(test(std::ranges::partition, a, odd));
 //static_assert(test(std::ranges::partition_copy, a, a, a, odd));
 //static_assert(test(std::ranges::partition_point, a, odd));