<algorithm>: Implemented ranges::move

stl/inc/algorithm

@@ -1263,6 +1263,43 @@ namespace ranges {
 } // namespace ranges
 #endif // __cpp_lib_concepts
 
+#ifdef __cpp_lib_concepts
+
+namespace ranges {
+    // ALIAS TEMPLATE copy_result
+    template <class _In, class _Out>
+    using move_result = in_out_result<_In, _Out>;
+
+    class _Move_fn : private _Not_quite_object {
+    public:
+        using _Not_quite_object::_Not_quite_object;
+
+        template <input_iterator _It, sentinel_for<_It> _Se, weakly_incrementable _Out>
+        requires indirectly_movable<_It, _Out> constexpr move_result<_It, _Out> operator()(
+            _It _First, _Se _Last, _Out _Result) const {
+            _Adl_verify_range(_First, _Last);
+            auto _UFirst      = _Get_unwrapped(_STD move(_First));
+            const auto _ULast = _Get_unwrapped(_STD move(_Last));
+            for (; _UFirst != _ULast; ++_UFirst, (void) ++_Result) {
+                *_Result = _RANGES iter_move(_UFirst);
+            }
+
+            _Seek_wrapped(_First, _STD move(_UFirst));
+            return {_STD move(_First), _STD move(_Result)};
+        }
+
+        template <input_range _Rng, weakly_incrementable _Out>
+        requires indirectly_movable<iterator_t<_Rng>, _Out> constexpr move_result<borrowed_iterator_t<_Rng>, _Out>
+            operator()(_Rng&& _Range, _Out _Result) const {
+            return (*this)(_RANGES begin(_Range), _RANGES end(_Range), _STD move(_Result));
+        }
+    };
+
+    inline constexpr _Move_fn move{_Not_quite_object::_Construct_tag{}};
+} // namespace ranges
+#endif // __cpp_lib_concepts
+
+
 // FUNCTION TEMPLATE partition_copy
 template <class _InIt, class _OutIt1, class _OutIt2, class _Pr>
 _CONSTEXPR20 pair<_OutIt1, _OutIt2> partition_copy(
@@ -5173,6 +5210,8 @@ _NODISCARD constexpr const _Ty& clamp(const _Ty& _Val, const _Ty& _Min_val, cons
 }
 #endif // _HAS_CXX17
 
+
+
 _STD_END
 #pragma pop_macro("new")
 _STL_RESTORE_CLANG_WARNINGS

tests/std/test.lst

@@ -249,6 +249,7 @@ tests\P0896R4_ranges_alg_find_if_not
 tests\P0896R4_ranges_alg_for_each
 tests\P0896R4_ranges_alg_for_each_n
 tests\P0896R4_ranges_alg_mismatch
+tests\P0896R4_ranges_alg_move
 tests\P0896R4_ranges_alg_none_of
 tests\P0896R4_ranges_iterator_machinery
 tests\P0896R4_ranges_range_machinery

tests/std/tests/P0896R4_ranges_alg_move/env.lst

@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\concepts_matrix.lst

tests/std/tests/P0896R4_ranges_alg_move/test.cpp

@@ -0,0 +1,78 @@
+#include <algorithm>
+#include <cassert>
+#include <concepts>
+#include <ranges>
+#include <utility>
+#include <range_algorithm_support.hpp>
+
+struct int_wrapper {
+    int val = 10;
+    constexpr int_wrapper() = default;
+    constexpr int_wrapper(int x) : val{x} {}
+    constexpr int_wrapper(int_wrapper&& that) : val{std::exchange(that.val, -1)} {}
+    constexpr int_wrapper& operator=(int_wrapper&& that) {
+        val = std::exchange(that.val, -1);
+        return *this;
+    }
+};
+
+constexpr void smoke_test() {
+    using ranges::move, ranges::move_result, ranges::iterator_t;
+    using std::same_as;
+
+    // Validate that move_result aliases in_out_result
+    STATIC_ASSERT(same_as<move_result<int, double>, ranges::in_out_result<int, double>>);
+
+    // Validate dangling story
+    STATIC_ASSERT(same_as<decltype(move(borrowed<false>{}, static_cast<int*>(nullptr))), move_result<ranges::dangling, int*>>);
+    STATIC_ASSERT(same_as<decltype(move(borrowed<true>{}, static_cast<int*>(nullptr))), move_result<int*, int*>>);
+
+    int const input[] = {13, 53, 12435};
+    {
+        int output[] = {-1, -1, -1};
+        auto result = move(move_only_range{input}, move_only_range{output}.begin());
+        STATIC_ASSERT(same_as<decltype(result), 
+            move_result<iterator_t<move_only_range<int const>>, iterator_t<move_only_range<int>>>>);
+        assert(result.in == move_only_range{input}.end());
+        assert(result.out == move_only_range{output}.end());
+        assert(ranges::equal(output, input));
+    }
+    {
+        int output[] = {-1, -1, -1};
+        move_only_range wrapped_input{input};
+        auto result = move(wrapped_input.begin(), wrapped_input.end(), move_only_range{output}.begin());
+        STATIC_ASSERT(same_as<decltype(result), move_result<iterator_t<move_only_range<int const>>, iterator_t<move_only_range<int>>>>);
+        assert(result.in == wrapped_input.end());
+        assert(result.out == move_only_range{output}.end());
+        assert(ranges::equal(output, input));
+    }
+    {
+        int_wrapper input1[3] = {13, 55, 1234};
+        int expected_output[3] = {13, 55, 1234};
+        int_wrapper actual_output[3] = {-1, -1, -1};
+        move_only_range wrapped_input{input1};
+        auto result = move(wrapped_input.begin(), wrapped_input.end(), move_only_range{actual_output}.begin());
+        assert(result.in == wrapped_input.end());
+        assert(result.out == move_only_range{actual_output}.end());
+        for (int i = 0; i < 3; i++) {
+             assert(input1[i].val == -1);
+             assert(actual_output[i].val == expected_output[i]);
+        }
+    }
+
+}
+
+int main() {
+    STATIC_ASSERT((smoke_test(), true));
+    smoke_test();
+}
+
+struct instantiator {
+    template <class In, class Out>
+    static void call(In&& in = {}, Out out = {}) {
+        (void) ranges::move(in, std::move(out));
+        (void) ranges::move(ranges::begin(in), ranges::end(in), std::move(out)); // what is this
+    }
+};
+
+template void test_in_out<instantiator>();