[libcxx] applies changes regarding post-commit feedback to llvm#75259

cjdb · cjdb · commit d4ab164dfe35 · 2023-12-28T19:58:14.000Z
Some of the feedback was also relevant to other files, and has been
applied there too.
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/left_folds.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/left_folds.pass.cpp
@@ -56,14 +56,14 @@ concept is_in_value_result =
 template <class Result, class T>
 concept is_dangling_with = std::same_as<Result, std::ranges::fold_left_with_iter_result<std::ranges::dangling, T>>;
 
-struct Long {
+struct Integer {
   int value;
 
-  constexpr Long(int const x) : value(x) {}
+  constexpr Integer(int const x) : value(x) {}
 
-  constexpr Long plus(int const x) const { return Long{value + x}; }
+  constexpr Integer plus(int const x) const { return Integer{value + x}; }
 
-  friend constexpr bool operator==(Long const& x, Long const& y) = default;
+  friend constexpr bool operator==(Integer const& x, Integer const& y) = default;
 };
 
 template <std::ranges::input_range R, class T, class F, std::equality_comparable Expected>
@@ -74,6 +74,7 @@ constexpr void check_iterator(R& r, T const& init, F f, Expected const& expected
     assert(result.in == r.end());
     assert(result.value == expected);
   }
+
   {
     auto telemetry                                        = invocable_telemetry();
     auto f2                                               = invocable_with_telemetry(f, telemetry);
@@ -89,6 +90,7 @@ constexpr void check_iterator(R& r, T const& init, F f, Expected const& expected
     std::same_as<Expected> decltype(auto) result = fold_left(r.begin(), r.end(), init, f);
     assert(result == expected);
   }
+
   {
     auto telemetry                               = invocable_telemetry();
     auto f2                                      = invocable_with_telemetry(f, telemetry);
@@ -108,6 +110,7 @@ constexpr void check_lvalue_range(R& r, T const& init, F f, Expected const& expe
     assert(result.in == r.end());
     assert(result.value == expected);
   }
+
   {
     auto telemetry                               = invocable_telemetry();
     auto f2                                      = invocable_with_telemetry(f, telemetry);
@@ -122,6 +125,7 @@ constexpr void check_lvalue_range(R& r, T const& init, F f, Expected const& expe
     std::same_as<Expected> decltype(auto) result = fold_left(r, init, f);
     assert(result == expected);
   }
+
   {
     auto telemetry                               = invocable_telemetry();
     auto f2                                      = invocable_with_telemetry(f, telemetry);
@@ -141,6 +145,7 @@ constexpr void check_rvalue_range(R& r, T const& init, F f, Expected const& expe
     is_dangling_with<Expected> decltype(auto) result = fold_left_with_iter(std::move(r2), init, f);
     assert(result.value == expected);
   }
+
   {
     auto telemetry                                   = invocable_telemetry();
     auto f2                                          = invocable_with_telemetry(f, telemetry);
@@ -157,6 +162,7 @@ constexpr void check_rvalue_range(R& r, T const& init, F f, Expected const& expe
     std::same_as<Expected> decltype(auto) result = fold_left(std::move(r2), init, f);
     assert(result == expected);
   }
+
   {
     auto telemetry                               = invocable_telemetry();
     auto f2                                      = invocable_with_telemetry(f, telemetry);
@@ -183,7 +189,7 @@ constexpr void empty_range_test_case() {
   check(data, -100, std::multiplies(), -100);
 
   check(data | std::views::take_while([](auto) { return false; }), 1.23, std::plus(), 1.23);
-  check(data, Long(52), &Long::plus, Long(52));
+  check(data, Integer(52), &Integer::plus, Integer(52));
 }
 
 constexpr void common_range_test_case() {
@@ -206,7 +212,7 @@ constexpr void common_range_test_case() {
   };
   check(data, 0, fib, fibonacci(data.back()));
 
-  check(data, Long(0), &Long::plus, Long(triangular_sum(data)));
+  check(data, Integer(0), &Integer::plus, Integer(triangular_sum(data)));
 }
 
 constexpr void non_common_range_test_case() {
@@ -266,6 +272,7 @@ void runtime_only_test_case() {
       assert(result.in == data.end());
       assert(result.value == expected);
     }
+
     {
       auto input = std::istringstream(raw_data);
       auto data  = std::views::istream<std::string>(input);
@@ -274,11 +281,13 @@ void runtime_only_test_case() {
       assert(result.in == data.end());
       assert(result.value == expected);
     }
+
     {
       auto input = std::istringstream(raw_data);
       auto data  = std::views::istream<std::string>(input);
       assert(fold_left(data.begin(), data.end(), init, std::plus()) == expected);
     }
+
     {
       auto input = std::istringstream(raw_data);
       auto data  = std::views::istream<std::string>(input);
diff --git a/libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/requirements.compile.pass.cpp b/libcxx/test/std/algorithms/alg.nonmodifying/alg.fold/requirements.compile.pass.cpp
@@ -10,8 +10,21 @@
 
 // UNSUPPORTED: c++03, c++11, c++14, c++17, c++20
 
-// Checks that `std::ranges::fold_left_with_iter`'s requirements reject parameters that don't meet
-// the overloads' constraints.
+// template<input_iterator I, sentinel_for<I> S, class T,
+//          indirectly-binary-left-foldable<T, I> F>
+//   constexpr see below ranges::fold_left_with_iter(I first, S last, T init, F f);
+//
+// template<input_range R, class T, indirectly-binary-left-foldable<T, iterator_t<R>> F>
+//   constexpr see below ranges::fold_left_with_iter(R&& r, T init, F f);
+
+// template<input_iterator I, sentinel_for<I> S, class T,
+//          indirectly-binary-left-foldable<T, I> F>
+//   constexpr see below ranges::fold_left(I first, S last, T init, F f);
+//
+// template<input_range R, class T, indirectly-binary-left-foldable<T, iterator_t<R>> F>
+//   constexpr see below ranges::fold_left(R&& r, T init, F f);
+
+// Checks that the algorithm requirements reject parameters that don't meet the overloads' constraints.
 
 #include <algorithm>
 #include <concepts>
diff --git a/libcxx/test/std/algorithms/algorithms.results/in_found_result.pass.cpp b/libcxx/test/std/algorithms/algorithms.results/in_found_result.pass.cpp
@@ -64,6 +64,7 @@ struct ConvertibleFrom {
 };
 
 constexpr bool test() {
+  // Checks that conversion operations are correct.
   {
     std::ranges::in_found_result<double> res{10, true};
     assert(res.in == 10);
@@ -72,6 +73,8 @@ constexpr bool test() {
     assert(res2.in.content == 10);
     assert(res2.found == true);
   }
+
+  // Checks that conversions are possible when one of the types is move-only.
   {
     std::ranges::in_found_result<MoveOnly> res{MoveOnly{}, false};
     assert(res.in.get() == 1);
@@ -82,10 +85,13 @@ constexpr bool test() {
     assert(res.in.get() == 0);
     assert(!res.found);
   }
-  auto [in, found] = std::ranges::in_found_result<int>{2, false};
-  assert(in == 2);
-  assert(!found);
 
+  // Checks that structured bindings get the correct values.
+  {
+    auto [in, found] = std::ranges::in_found_result<int>{2, false};
+    assert(in == 2);
+    assert(!found);
+  }
   return true;
 }
 
diff --git a/libcxx/test/std/algorithms/algorithms.results/in_fun_result.pass.cpp b/libcxx/test/std/algorithms/algorithms.results/in_fun_result.pass.cpp
@@ -48,7 +48,7 @@ static_assert(std::is_convertible_v<const std::ranges::in_fun_result<int, int>&&
 static_assert(std::is_move_constructible_v<std::ranges::in_fun_result<MoveOnly, int>>);
 static_assert(std::is_move_constructible_v<std::ranges::in_fun_result<int, MoveOnly>>);
 
-// should not copy constructible with move-only type
+// should not be copy constructible with move-only type
 static_assert(!std::is_copy_constructible_v<std::ranges::in_fun_result<MoveOnly, int>>);
 static_assert(!std::is_copy_constructible_v<std::ranges::in_fun_result<int, MoveOnly>>);
 
@@ -64,6 +64,7 @@ struct ConvertibleFrom {
 };
 
 constexpr bool test() {
+  // Checks that conversion operations are correct.
   {
     std::ranges::in_fun_result<int, double> res{10, 0.};
     assert(res.in == 10);
@@ -72,6 +73,8 @@ constexpr bool test() {
     assert(res2.in.content == 10);
     assert(res2.fun.content == 0.);
   }
+
+  // Checks that conversions are possible when one of the types is move-only.
   {
     std::ranges::in_fun_result<MoveOnly, int> res{MoveOnly{}, 2};
     assert(res.in.get() == 1);
@@ -81,6 +84,8 @@ constexpr bool test() {
     assert(res2.in.get() == 1);
     assert(res2.fun == 2);
   }
+
+  // Checks that structured bindings get the correct values.
   {
     auto [in, fun] = std::ranges::in_fun_result<int, int>{1, 2};
     assert(in == 1);
diff --git a/libcxx/test/std/algorithms/algorithms.results/in_in_out_result.pass.cpp b/libcxx/test/std/algorithms/algorithms.results/in_in_out_result.pass.cpp
@@ -67,6 +67,7 @@ struct ConvertibleFrom {
 };
 
 constexpr bool test() {
+  // Checks that conversion operations are correct.
   {
     std::ranges::in_in_out_result<int, double, float> res{10, 0., 1.f};
     assert(res.in1 == 10);
@@ -77,13 +78,17 @@ constexpr bool test() {
     assert(res2.in2.content == 0.);
     assert(res2.out.content == 1.f);
   }
+
+  // Checks that conversions are possible when one of the types is move-only.
   {
     std::ranges::in_in_out_result<MoveOnly, int, int> res1{MoveOnly{}, 0, 0};
     assert(res1.in1.get() == 1);
     auto res2 = static_cast<std::ranges::in_in_out_result<MoveOnly, int, int>>(std::move(res1));
     assert(res1.in1.get() == 0);
     assert(res2.in1.get() == 1);
   }
+
+  // Checks that structured bindings get the correct values.
   {
     auto [in1, in2, out] = std::ranges::in_in_out_result<int, int, int>{1, 2, 3};
     assert(in1 == 1);
diff --git a/libcxx/test/std/algorithms/algorithms.results/in_in_result.pass.cpp b/libcxx/test/std/algorithms/algorithms.results/in_in_result.pass.cpp
@@ -59,6 +59,7 @@ struct ConstructibleFrom {
 };
 
 constexpr bool test() {
+  // Checks that conversion operations are correct.
   {
     std::ranges::in_in_result<int, double> res{10L, 0.};
     assert(res.in1 == 10);
@@ -67,12 +68,16 @@ constexpr bool test() {
     assert(res2.in1.content == 10);
     assert(res2.in2.content == 0.);
   }
+
+  // Checks that conversions are possible when one of the types is move-only.
   {
     std::ranges::in_in_result<MoveOnly, int> res{MoveOnly{}, 0};
     assert(res.in1.get() == 1);
     [[maybe_unused]] auto res2 = static_cast<std::ranges::in_in_result<MoveOnly, int>>(std::move(res));
     assert(res.in1.get() == 0);
   }
+
+  // Checks that structured bindings get the correct values.
   {
     auto [in1, in2] = std::ranges::in_in_result<int, int>{1, 2};
     assert(in1 == 1);
diff --git a/libcxx/test/std/algorithms/algorithms.results/in_out_out_result.pass.cpp b/libcxx/test/std/algorithms/algorithms.results/in_out_out_result.pass.cpp
@@ -65,6 +65,7 @@ struct ConvertibleFrom {
 };
 
 constexpr bool test() {
+  // Checks that conversion operations are correct.
   {
     std::ranges::in_out_out_result<int, double, float> res{10, 0., 1.f};
     assert(res.in == 10);
@@ -75,13 +76,17 @@ constexpr bool test() {
     assert(res2.out1.content == 0.);
     assert(res2.out2.content == 1.f);
   }
+
+  // Checks that conversions are possible when one of the types is move-only.
   {
     std::ranges::in_out_out_result<MoveOnly, int, int> res1{MoveOnly{}, 0, 0};
     assert(res1.in.get() == 1);
     auto res2 = static_cast<std::ranges::in_out_out_result<MoveOnly, int, int>>(std::move(res1));
     assert(res1.in.get() == 0);
     assert(res2.in.get() == 1);
   }
+
+  // Checks that structured bindings get the correct values.
   {
     auto [in, out1, out2] = std::ranges::in_out_out_result<int, int, int>{1, 2, 3};
     assert(in == 1);
diff --git a/libcxx/test/std/algorithms/algorithms.results/in_out_result.pass.cpp b/libcxx/test/std/algorithms/algorithms.results/in_out_result.pass.cpp
@@ -59,6 +59,7 @@ struct ConvertibleFrom {
 };
 
 constexpr bool test() {
+  // Checks that conversion operations are correct.
   {
     std::ranges::in_out_result<double, int> res{10, 1};
     assert(res.in == 10);
@@ -67,6 +68,8 @@ constexpr bool test() {
     assert(res2.in.content == 10);
     assert(res2.out.content == 1);
   }
+
+  // Checks that conversions are possible when one of the types is move-only.
   {
     std::ranges::in_out_result<MoveOnly, int> res{MoveOnly{}, 10};
     assert(res.in.get() == 1);
@@ -77,6 +80,8 @@ constexpr bool test() {
     assert(res2.in.get() == 1);
     assert(res2.out == 10);
   }
+
+  // Checks that structured bindings get the correct values.
   {
     auto [min, max] = std::ranges::in_out_result<int, int>{1, 2};
     assert(min == 1);
diff --git a/libcxx/test/std/algorithms/algorithms.results/in_value_result.pass.cpp b/libcxx/test/std/algorithms/algorithms.results/in_value_result.pass.cpp
@@ -53,7 +53,7 @@ static_assert(
 static_assert(std::is_move_constructible_v<std::ranges::in_value_result<MoveOnly, int>>);
 static_assert(std::is_move_constructible_v<std::ranges::in_value_result<int, MoveOnly>>);
 
-// should not copy constructible with move-only type
+// should not be copy constructible with move-only type
 static_assert(!std::is_copy_constructible_v<std::ranges::in_value_result<MoveOnly, int>>);
 static_assert(!std::is_copy_constructible_v<std::ranges::in_value_result<int, MoveOnly>>);
 
@@ -71,6 +71,7 @@ struct ConvertibleFrom {
 };
 
 constexpr bool test() {
+  // Checks that conversion operations are correct.
   {
     std::ranges::in_value_result<int, double> res{10, 0.};
     assert(res.in == 10);
@@ -79,6 +80,8 @@ constexpr bool test() {
     assert(res2.in.content == 10);
     assert(res2.value.content == 0.);
   }
+
+  // Checks that conversions are possible when one of the types is move-only.
   {
     std::ranges::in_value_result<MoveOnly, int> res{MoveOnly{}, 2};
     assert(res.in.get() == 1);
@@ -88,6 +91,8 @@ constexpr bool test() {
     assert(res2.in.get() == 1);
     assert(res2.value == 2);
   }
+
+  // Checks that structured bindings get the correct values.
   {
     auto [in, value] = std::ranges::in_value_result<int, int>{1, 2};
     assert(in == 1);
diff --git a/libcxx/test/std/algorithms/algorithms.results/min_max_result.pass.cpp b/libcxx/test/std/algorithms/algorithms.results/min_max_result.pass.cpp
@@ -60,6 +60,7 @@ struct ConvertibleFrom {
 };
 
 constexpr bool test() {
+  // Checks that conversion operations are correct.
   {
     std::ranges::min_max_result<double> res{10, 1};
     assert(res.min == 10);
@@ -68,6 +69,8 @@ constexpr bool test() {
     assert(res2.min.content == 10);
     assert(res2.max.content == 1);
   }
+
+  // Checks that conversions are possible when one of the types is move-only.
   {
     std::ranges::min_max_result<MoveOnly> res{MoveOnly{}, MoveOnly{}};
     assert(res.min.get() == 1);
@@ -78,6 +81,8 @@ constexpr bool test() {
     assert(res2.min.get() == 1);
     assert(res2.max.get() == 1);
   }
+
+  // Checks that structured bindings get the correct values.
   {
     auto [min, max] = std::ranges::min_max_result<int>{1, 2};
     assert(min == 1);

Original file line number	Diff line number	Diff line change
`@@ -56,14 +56,14 @@ concept is_in_value_result =`
`56`	`56`	`template <class Result, class T>`
`57`	`57`	`concept is_dangling_with = std::same_as<Result, std::ranges::fold_left_with_iter_result<std::ranges::dangling, T>>;`
`58`	`58`
`59`		`-struct Long {`
	`59`	`+struct Integer {`
`60`	`60`	`int value;`
`61`	`61`
`62`		`- constexpr Long(int const x) : value(x) {}`
	`62`	`+ constexpr Integer(int const x) : value(x) {}`
`63`	`63`
`64`		`- constexpr Long plus(int const x) const { return Long{value + x}; }`
	`64`	`+ constexpr Integer plus(int const x) const { return Integer{value + x}; }`
`65`	`65`
`66`		`- friend constexpr bool operator==(Long const& x, Long const& y) = default;`
	`66`	`+ friend constexpr bool operator==(Integer const& x, Integer const& y) = default;`
`67`	`67`	`};`
`68`	`68`
`69`	`69`	`template <std::ranges::input_range R, class T, class F, std::equality_comparable Expected>`
`@@ -74,6 +74,7 @@ constexpr void check_iterator(R& r, T const& init, F f, Expected const& expected`
`74`	`74`	`assert(result.in == r.end());`
`75`	`75`	`assert(result.value == expected);`
`76`	`76`	`}`
	`77`	`+`
`77`	`78`	`{`
`78`	`79`	`auto telemetry = invocable_telemetry();`
`79`	`80`	`auto f2 = invocable_with_telemetry(f, telemetry);`
`@@ -89,6 +90,7 @@ constexpr void check_iterator(R& r, T const& init, F f, Expected const& expected`
`89`	`90`	`std::same_as<Expected> decltype(auto) result = fold_left(r.begin(), r.end(), init, f);`
`90`	`91`	`assert(result == expected);`
`91`	`92`	`}`
	`93`	`+`
`92`	`94`	`{`
`93`	`95`	`auto telemetry = invocable_telemetry();`
`94`	`96`	`auto f2 = invocable_with_telemetry(f, telemetry);`
`@@ -108,6 +110,7 @@ constexpr void check_lvalue_range(R& r, T const& init, F f, Expected const& expe`
`108`	`110`	`assert(result.in == r.end());`
`109`	`111`	`assert(result.value == expected);`
`110`	`112`	`}`
	`113`	`+`
`111`	`114`	`{`
`112`	`115`	`auto telemetry = invocable_telemetry();`
`113`	`116`	`auto f2 = invocable_with_telemetry(f, telemetry);`
`@@ -122,6 +125,7 @@ constexpr void check_lvalue_range(R& r, T const& init, F f, Expected const& expe`
`122`	`125`	`std::same_as<Expected> decltype(auto) result = fold_left(r, init, f);`
`123`	`126`	`assert(result == expected);`
`124`	`127`	`}`
	`128`	`+`
`125`	`129`	`{`
`126`	`130`	`auto telemetry = invocable_telemetry();`
`127`	`131`	`auto f2 = invocable_with_telemetry(f, telemetry);`
`@@ -141,6 +145,7 @@ constexpr void check_rvalue_range(R& r, T const& init, F f, Expected const& expe`
`141`	`145`	`is_dangling_with<Expected> decltype(auto) result = fold_left_with_iter(std::move(r2), init, f);`
`142`	`146`	`assert(result.value == expected);`
`143`	`147`	`}`
	`148`	`+`
`144`	`149`	`{`
`145`	`150`	`auto telemetry = invocable_telemetry();`
`146`	`151`	`auto f2 = invocable_with_telemetry(f, telemetry);`
`@@ -157,6 +162,7 @@ constexpr void check_rvalue_range(R& r, T const& init, F f, Expected const& expe`
`157`	`162`	`std::same_as<Expected> decltype(auto) result = fold_left(std::move(r2), init, f);`
`158`	`163`	`assert(result == expected);`
`159`	`164`	`}`
	`165`	`+`
`160`	`166`	`{`
`161`	`167`	`auto telemetry = invocable_telemetry();`
`162`	`168`	`auto f2 = invocable_with_telemetry(f, telemetry);`
`@@ -183,7 +189,7 @@ constexpr void empty_range_test_case() {`
`183`	`189`	`check(data, -100, std::multiplies(), -100);`
`184`	`190`
`185`	`191`	`check(data \| std::views::take_while([](auto) { return false; }), 1.23, std::plus(), 1.23);`
`186`		`- check(data, Long(52), &Long::plus, Long(52));`
	`192`	`+ check(data, Integer(52), &Integer::plus, Integer(52));`
`187`	`193`	`}`
`188`	`194`
`189`	`195`	`constexpr void common_range_test_case() {`
`@@ -206,7 +212,7 @@ constexpr void common_range_test_case() {`
`206`	`212`	`};`
`207`	`213`	`check(data, 0, fib, fibonacci(data.back()));`
`208`	`214`
`209`		`- check(data, Long(0), &Long::plus, Long(triangular_sum(data)));`
	`215`	`+ check(data, Integer(0), &Integer::plus, Integer(triangular_sum(data)));`
`210`	`216`	`}`
`211`	`217`
`212`	`218`	`constexpr void non_common_range_test_case() {`
`@@ -266,6 +272,7 @@ void runtime_only_test_case() {`
`266`	`272`	`assert(result.in == data.end());`
`267`	`273`	`assert(result.value == expected);`
`268`	`274`	`}`
	`275`	`+`
`269`	`276`	`{`
`270`	`277`	`auto input = std::istringstream(raw_data);`
`271`	`278`	`auto data = std::views::istream<std::string>(input);`
`@@ -274,11 +281,13 @@ void runtime_only_test_case() {`
`274`	`281`	`assert(result.in == data.end());`
`275`	`282`	`assert(result.value == expected);`
`276`	`283`	`}`
	`284`	`+`
`277`	`285`	`{`
`278`	`286`	`auto input = std::istringstream(raw_data);`
`279`	`287`	`auto data = std::views::istream<std::string>(input);`
`280`	`288`	`assert(fold_left(data.begin(), data.end(), init, std::plus()) == expected);`
`281`	`289`	`}`
	`290`	`+`
`282`	`291`	`{`
`283`	`292`	`auto input = std::istringstream(raw_data);`
`284`	`293`	`auto data = std::views::istream<std::string>(input);`
Original file line number	Diff line number	Diff line change
`@@ -64,6 +64,7 @@ struct ConvertibleFrom {`
`64`	`64`	`};`
`65`	`65`
`66`	`66`	`constexpr bool test() {`
	`67`	`+ // Checks that conversion operations are correct.`
`67`	`68`	`{`
`68`	`69`	`std::ranges::in_found_result<double> res{10, true};`
`69`	`70`	`assert(res.in == 10);`
`@@ -72,6 +73,8 @@ constexpr bool test() {`
`72`	`73`	`assert(res2.in.content == 10);`
`73`	`74`	`assert(res2.found == true);`
`74`	`75`	`}`
	`76`	`+`
	`77`	`+ // Checks that conversions are possible when one of the types is move-only.`
`75`	`78`	`{`
`76`	`79`	`std::ranges::in_found_result<MoveOnly> res{MoveOnly{}, false};`
`77`	`80`	`assert(res.in.get() == 1);`
`@@ -82,10 +85,13 @@ constexpr bool test() {`
`82`	`85`	`assert(res.in.get() == 0);`
`83`	`86`	`assert(!res.found);`
`84`	`87`	`}`
`85`		`- auto [in, found] = std::ranges::in_found_result<int>{2, false};`
`86`		`- assert(in == 2);`
`87`		`- assert(!found);`
`88`	`88`
	`89`	`+ // Checks that structured bindings get the correct values.`
	`90`	`+ {`
	`91`	`+ auto [in, found] = std::ranges::in_found_result<int>{2, false};`
	`92`	`+ assert(in == 2);`
	`93`	`+ assert(!found);`
	`94`	`+ }`
`89`	`95`	`return true;`
`90`	`96`	`}`
`91`	`97`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ static_assert(std::is_convertible_v<const std::ranges::in_fun_result<int, int>&&`
`48`	`48`	`static_assert(std::is_move_constructible_v<std::ranges::in_fun_result<MoveOnly, int>>);`
`49`	`49`	`static_assert(std::is_move_constructible_v<std::ranges::in_fun_result<int, MoveOnly>>);`
`50`	`50`
`51`		`-// should not copy constructible with move-only type`
	`51`	`+// should not be copy constructible with move-only type`
`52`	`52`	`static_assert(!std::is_copy_constructible_v<std::ranges::in_fun_result<MoveOnly, int>>);`
`53`	`53`	`static_assert(!std::is_copy_constructible_v<std::ranges::in_fun_result<int, MoveOnly>>);`
`54`	`54`
`@@ -64,6 +64,7 @@ struct ConvertibleFrom {`
`64`	`64`	`};`
`65`	`65`
`66`	`66`	`constexpr bool test() {`
	`67`	`+ // Checks that conversion operations are correct.`
`67`	`68`	`{`
`68`	`69`	`std::ranges::in_fun_result<int, double> res{10, 0.};`
`69`	`70`	`assert(res.in == 10);`
`@@ -72,6 +73,8 @@ constexpr bool test() {`
`72`	`73`	`assert(res2.in.content == 10);`
`73`	`74`	`assert(res2.fun.content == 0.);`
`74`	`75`	`}`
	`76`	`+`
	`77`	`+ // Checks that conversions are possible when one of the types is move-only.`
`75`	`78`	`{`
`76`	`79`	`std::ranges::in_fun_result<MoveOnly, int> res{MoveOnly{}, 2};`
`77`	`80`	`assert(res.in.get() == 1);`
`@@ -81,6 +84,8 @@ constexpr bool test() {`
`81`	`84`	`assert(res2.in.get() == 1);`
`82`	`85`	`assert(res2.fun == 2);`
`83`	`86`	`}`
	`87`	`+`
	`88`	`+ // Checks that structured bindings get the correct values.`
`84`	`89`	`{`
`85`	`90`	`auto [in, fun] = std::ranges::in_fun_result<int, int>{1, 2};`
`86`	`91`	`assert(in == 1);`
Original file line number	Diff line number	Diff line change
`@@ -67,6 +67,7 @@ struct ConvertibleFrom {`
`67`	`67`	`};`
`68`	`68`
`69`	`69`	`constexpr bool test() {`
	`70`	`+ // Checks that conversion operations are correct.`
`70`	`71`	`{`
`71`	`72`	`std::ranges::in_in_out_result<int, double, float> res{10, 0., 1.f};`
`72`	`73`	`assert(res.in1 == 10);`
`@@ -77,13 +78,17 @@ constexpr bool test() {`
`77`	`78`	`assert(res2.in2.content == 0.);`
`78`	`79`	`assert(res2.out.content == 1.f);`
`79`	`80`	`}`
	`81`	`+`
	`82`	`+ // Checks that conversions are possible when one of the types is move-only.`
`80`	`83`	`{`
`81`	`84`	`std::ranges::in_in_out_result<MoveOnly, int, int> res1{MoveOnly{}, 0, 0};`
`82`	`85`	`assert(res1.in1.get() == 1);`
`83`	`86`	`auto res2 = static_cast<std::ranges::in_in_out_result<MoveOnly, int, int>>(std::move(res1));`
`84`	`87`	`assert(res1.in1.get() == 0);`
`85`	`88`	`assert(res2.in1.get() == 1);`
`86`	`89`	`}`
	`90`	`+`
	`91`	`+ // Checks that structured bindings get the correct values.`
`87`	`92`	`{`
`88`	`93`	`auto [in1, in2, out] = std::ranges::in_in_out_result<int, int, int>{1, 2, 3};`
`89`	`94`	`assert(in1 == 1);`
Original file line number	Diff line number	Diff line change
`@@ -59,6 +59,7 @@ struct ConstructibleFrom {`
`59`	`59`	`};`
`60`	`60`
`61`	`61`	`constexpr bool test() {`
	`62`	`+ // Checks that conversion operations are correct.`
`62`	`63`	`{`
`63`	`64`	`std::ranges::in_in_result<int, double> res{10L, 0.};`
`64`	`65`	`assert(res.in1 == 10);`
`@@ -67,12 +68,16 @@ constexpr bool test() {`
`67`	`68`	`assert(res2.in1.content == 10);`
`68`	`69`	`assert(res2.in2.content == 0.);`
`69`	`70`	`}`
	`71`	`+`
	`72`	`+ // Checks that conversions are possible when one of the types is move-only.`
`70`	`73`	`{`
`71`	`74`	`std::ranges::in_in_result<MoveOnly, int> res{MoveOnly{}, 0};`
`72`	`75`	`assert(res.in1.get() == 1);`
`73`	`76`	`[[maybe_unused]] auto res2 = static_cast<std::ranges::in_in_result<MoveOnly, int>>(std::move(res));`
`74`	`77`	`assert(res.in1.get() == 0);`
`75`	`78`	`}`
	`79`	`+`
	`80`	`+ // Checks that structured bindings get the correct values.`
`76`	`81`	`{`
`77`	`82`	`auto [in1, in2] = std::ranges::in_in_result<int, int>{1, 2};`
`78`	`83`	`assert(in1 == 1);`
Original file line number	Diff line number	Diff line change
`@@ -65,6 +65,7 @@ struct ConvertibleFrom {`
`65`	`65`	`};`
`66`	`66`
`67`	`67`	`constexpr bool test() {`
	`68`	`+ // Checks that conversion operations are correct.`
`68`	`69`	`{`
`69`	`70`	`std::ranges::in_out_out_result<int, double, float> res{10, 0., 1.f};`
`70`	`71`	`assert(res.in == 10);`
`@@ -75,13 +76,17 @@ constexpr bool test() {`
`75`	`76`	`assert(res2.out1.content == 0.);`
`76`	`77`	`assert(res2.out2.content == 1.f);`
`77`	`78`	`}`
	`79`	`+`
	`80`	`+ // Checks that conversions are possible when one of the types is move-only.`
`78`	`81`	`{`
`79`	`82`	`std::ranges::in_out_out_result<MoveOnly, int, int> res1{MoveOnly{}, 0, 0};`
`80`	`83`	`assert(res1.in.get() == 1);`
`81`	`84`	`auto res2 = static_cast<std::ranges::in_out_out_result<MoveOnly, int, int>>(std::move(res1));`
`82`	`85`	`assert(res1.in.get() == 0);`
`83`	`86`	`assert(res2.in.get() == 1);`
`84`	`87`	`}`
	`88`	`+`
	`89`	`+ // Checks that structured bindings get the correct values.`
`85`	`90`	`{`
`86`	`91`	`auto [in, out1, out2] = std::ranges::in_out_out_result<int, int, int>{1, 2, 3};`
`87`	`92`	`assert(in == 1);`
Original file line number	Diff line number	Diff line change
`@@ -59,6 +59,7 @@ struct ConvertibleFrom {`
`59`	`59`	`};`
`60`	`60`
`61`	`61`	`constexpr bool test() {`
	`62`	`+ // Checks that conversion operations are correct.`
`62`	`63`	`{`
`63`	`64`	`std::ranges::in_out_result<double, int> res{10, 1};`
`64`	`65`	`assert(res.in == 10);`
`@@ -67,6 +68,8 @@ constexpr bool test() {`
`67`	`68`	`assert(res2.in.content == 10);`
`68`	`69`	`assert(res2.out.content == 1);`
`69`	`70`	`}`
	`71`	`+`
	`72`	`+ // Checks that conversions are possible when one of the types is move-only.`
`70`	`73`	`{`
`71`	`74`	`std::ranges::in_out_result<MoveOnly, int> res{MoveOnly{}, 10};`
`72`	`75`	`assert(res.in.get() == 1);`
`@@ -77,6 +80,8 @@ constexpr bool test() {`
`77`	`80`	`assert(res2.in.get() == 1);`
`78`	`81`	`assert(res2.out == 10);`
`79`	`82`	`}`
	`83`	`+`
	`84`	`+ // Checks that structured bindings get the correct values.`
`80`	`85`	`{`
`81`	`86`	`auto [min, max] = std::ranges::in_out_result<int, int>{1, 2};`
`82`	`87`	`assert(min == 1);`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ static_assert(`
`53`	`53`	`static_assert(std::is_move_constructible_v<std::ranges::in_value_result<MoveOnly, int>>);`
`54`	`54`	`static_assert(std::is_move_constructible_v<std::ranges::in_value_result<int, MoveOnly>>);`
`55`	`55`
`56`		`-// should not copy constructible with move-only type`
	`56`	`+// should not be copy constructible with move-only type`
`57`	`57`	`static_assert(!std::is_copy_constructible_v<std::ranges::in_value_result<MoveOnly, int>>);`
`58`	`58`	`static_assert(!std::is_copy_constructible_v<std::ranges::in_value_result<int, MoveOnly>>);`
`59`	`59`
`@@ -71,6 +71,7 @@ struct ConvertibleFrom {`
`71`	`71`	`};`
`72`	`72`
`73`	`73`	`constexpr bool test() {`
	`74`	`+ // Checks that conversion operations are correct.`
`74`	`75`	`{`
`75`	`76`	`std::ranges::in_value_result<int, double> res{10, 0.};`
`76`	`77`	`assert(res.in == 10);`
`@@ -79,6 +80,8 @@ constexpr bool test() {`
`79`	`80`	`assert(res2.in.content == 10);`
`80`	`81`	`assert(res2.value.content == 0.);`
`81`	`82`	`}`
	`83`	`+`
	`84`	`+ // Checks that conversions are possible when one of the types is move-only.`
`82`	`85`	`{`
`83`	`86`	`std::ranges::in_value_result<MoveOnly, int> res{MoveOnly{}, 2};`
`84`	`87`	`assert(res.in.get() == 1);`
`@@ -88,6 +91,8 @@ constexpr bool test() {`
`88`	`91`	`assert(res2.in.get() == 1);`
`89`	`92`	`assert(res2.value == 2);`
`90`	`93`	`}`
	`94`	`+`
	`95`	`+ // Checks that structured bindings get the correct values.`
`91`	`96`	`{`
`92`	`97`	`auto [in, value] = std::ranges::in_value_result<int, int>{1, 2};`
`93`	`98`	`assert(in == 1);`
Original file line number	Diff line number	Diff line change
`@@ -60,6 +60,7 @@ struct ConvertibleFrom {`
`60`	`60`	`};`
`61`	`61`
`62`	`62`	`constexpr bool test() {`
	`63`	`+ // Checks that conversion operations are correct.`
`63`	`64`	`{`
`64`	`65`	`std::ranges::min_max_result<double> res{10, 1};`
`65`	`66`	`assert(res.min == 10);`
`@@ -68,6 +69,8 @@ constexpr bool test() {`
`68`	`69`	`assert(res2.min.content == 10);`
`69`	`70`	`assert(res2.max.content == 1);`
`70`	`71`	`}`
	`72`	`+`
	`73`	`+ // Checks that conversions are possible when one of the types is move-only.`
`71`	`74`	`{`
`72`	`75`	`std::ranges::min_max_result<MoveOnly> res{MoveOnly{}, MoveOnly{}};`
`73`	`76`	`assert(res.min.get() == 1);`
`@@ -78,6 +81,8 @@ constexpr bool test() {`
`78`	`81`	`assert(res2.min.get() == 1);`
`79`	`82`	`assert(res2.max.get() == 1);`
`80`	`83`	`}`
	`84`	`+`
	`85`	`+ // Checks that structured bindings get the correct values.`
`81`	`86`	`{`
`82`	`87`	`auto [min, max] = std::ranges::min_max_result<int>{1, 2};`
`83`	`88`	`assert(min == 1);`