🐛 Tuple transform should preserve references

elbeno · elbeno · commit 8993e7a37b1e · 2023-09-22T09:45:17.000-06:00
When using `stdx::transform` on a tuple containing references, those references
would previously be decayed. Now they are preserved.
diff --git a/include/stdx/tuple_algorithms.hpp b/include/stdx/tuple_algorithms.hpp
@@ -92,9 +92,11 @@ template <template <typename> typename... Fs, typename Op, typename T,
 constexpr auto transform(Op &&op, T &&t, Ts &&...ts) {
     return [&]<std::size_t... Is>(std::index_sequence<Is...>) {
         if constexpr (sizeof...(Fs) == 0) {
-            return stdx::make_tuple(
+            return stdx::tuple<decltype(detail::invoke_at<Is>(
+                std::forward<Op>(op), std::forward<T>(t),
+                std::forward<Ts>(ts)...))...>{
                 detail::invoke_at<Is>(std::forward<Op>(op), std::forward<T>(t),
-                                      std::forward<Ts>(ts)...)...);
+                                      std::forward<Ts>(ts)...)...};
         } else {
             return stdx::make_indexed_tuple<Fs...>(
                 detail::invoke_at<Is>(std::forward<Op>(op), std::forward<T>(t),
diff --git a/test/tuple_algorithms.cpp b/test/tuple_algorithms.cpp
@@ -42,6 +42,17 @@ TEST_CASE("rvalue transform", "[tuple_algorithms]") {
     CHECK(u == stdx::tuple{2, 3, 4});
 }
 
+TEST_CASE("transform preserves references", "[tuple_algorithms]") {
+    int value{1};
+    auto const u = stdx::transform(
+        [&](auto i) -> int & {
+            value += i;
+            return value;
+        },
+        stdx::tuple{1});
+    CHECK(std::addressof(value) == std::addressof(u[stdx::index<0>]));
+}
+
 namespace {
 template <typename Key, typename Value> struct map_entry {
     using key_t = Key;
