From 21bc1aa6806f8dfe5b078ddb1a738481e9bc2851 Mon Sep 17 00:00:00 2001
From: Ben Deane <ben@elbeno.com>
Date: Thu, 30 Jul 2026 18:05:50 -0600
Subject: [PATCH 1/2] :sparkles: Make `filter` work for `std::tuple`

Problem:
- `filter` works on `stdx::tuple` only. It doesn't work on `std::tuple`.

Solution:
- Make it work for `std::tuple` as well.
---
 include/stdx/concepts.hpp         |  1 -
 include/stdx/tuple_algorithms.hpp | 13 +++++++------
 test/tuple_algorithms.cpp         |  9 +++++++++
 3 files changed, 16 insertions(+), 7 deletions(-)

diff --git a/include/stdx/concepts.hpp b/include/stdx/concepts.hpp
index 1e1eb23..f8c74e5 100644
--- a/include/stdx/concepts.hpp
+++ b/include/stdx/concepts.hpp
@@ -156,7 +156,6 @@ template <typename T>
 concept is_vacuous_tuple = tuple_size_v<std::remove_cvref_t<T>> == 0;
 
 constexpr inline auto concept_try_get = [](auto &x) -> decltype(auto) {
-    using std::get;
     return get<0>(x);
 };
 
diff --git a/include/stdx/tuple_algorithms.hpp b/include/stdx/tuple_algorithms.hpp
index 74d8fa0..644bcbd 100644
--- a/include/stdx/tuple_algorithms.hpp
+++ b/include/stdx/tuple_algorithms.hpp
@@ -121,19 +121,19 @@ template <has_tuple_protocol Tup, typename T>
     }(std::make_index_sequence<stdx::tuple_size_v<tuple_t>>{});
 }
 
-template <typename T, tuplelike Tup>
+template <typename T, has_tuple_protocol Tup>
 [[nodiscard]] constexpr auto tuple_push_front(T &&t, Tup &&tup)
     -> decltype(auto) {
     return tuple_cons(std::forward<T>(t), std::forward<Tup>(tup));
 }
 
-template <tuplelike Tup, typename T>
+template <has_tuple_protocol Tup, typename T>
 [[nodiscard]] constexpr auto tuple_push_back(Tup &&tup, T &&t)
     -> decltype(auto) {
     return tuple_snoc(std::forward<Tup>(tup), std::forward<T>(t));
 }
 
-template <template <typename T> typename Pred, tuplelike T>
+template <template <typename T> typename Pred, has_tuple_protocol T>
 [[nodiscard]] constexpr auto filter(T &&t) {
     using tuple_t = std::remove_cvref_t<T>;
     return [&]<std::size_t... Is>(std::index_sequence<Is...>) {
@@ -157,9 +157,10 @@ template <template <typename T> typename Pred, tuplelike T>
         }();
 
         return [&]<std::size_t... Js>(std::index_sequence<Js...>) {
-            using R =
-                stdx::tuple<stdx::tuple_element_t<indices[Js], tuple_t>...>;
-            return R{std::forward<T>(t)[index<indices[Js]>]...};
+            using R = boost::mp11::mp_assign<
+                tuple_t,
+                type_list<stdx::tuple_element_t<indices[Js], tuple_t>...>>;
+            return R{get<indices[Js]>(std::forward<T>(t))...};
         }(std::make_index_sequence<num_matches>{});
     }(std::make_index_sequence<stdx::tuple_size_v<tuple_t>>{});
 }
diff --git a/test/tuple_algorithms.cpp b/test/tuple_algorithms.cpp
index 24519c9..1205ba6 100644
--- a/test/tuple_algorithms.cpp
+++ b/test/tuple_algorithms.cpp
@@ -533,6 +533,15 @@ TEST_CASE("filter", "[tuple_algorithms]") {
                                     std::integral_constant<int, 4>{}});
 }
 
+TEST_CASE("filter on std::tuple", "[tuple_algorithms]") {
+    constexpr auto t = std::tuple{
+        std::integral_constant<int, 1>{}, std::integral_constant<int, 2>{},
+        std::integral_constant<int, 3>{}, std::integral_constant<int, 4>{}};
+    constexpr auto u = stdx::filter<is_even>(t);
+    STATIC_REQUIRE(u == std::tuple{std::integral_constant<int, 2>{},
+                                   std::integral_constant<int, 4>{}});
+}
+
 TEST_CASE("copy/move behavior for tuple_cat", "[tuple_algorithms]") {
     auto t1 = stdx::tuple{counter{}};
     auto t2 = stdx::tuple{counter{}};

From 8fe7d31bf70ae73d25d265bbeb0f71e152e08a30 Mon Sep 17 00:00:00 2001
From: Ben Deane <ben@elbeno.com>
Date: Thu, 30 Jul 2026 21:24:42 -0600
Subject: [PATCH 2/2] :sparkles: Make `transform` work for `std::tuple`

Problem:
- `transform` works on `stdx::tuple` only. It doesn't work on `std::tuple`.

Solution:
- Make it work for `std::tuple` as well.
---
 include/stdx/tuple.hpp            | 24 +++++++++++++-----------
 include/stdx/tuple_algorithms.hpp | 24 +++++++++++++++---------
 test/tuple_algorithms.cpp         |  9 +++++++++
 3 files changed, 37 insertions(+), 20 deletions(-)

diff --git a/include/stdx/tuple.hpp b/include/stdx/tuple.hpp
index adfacb9..dbb76c2 100644
--- a/include/stdx/tuple.hpp
+++ b/include/stdx/tuple.hpp
@@ -418,6 +418,18 @@ struct tuple_impl<std::index_sequence<Is...>, index_function_list<Fs...>, Ts...>
 template <typename... Ts>
 tuple_impl(Ts...)
     -> tuple_impl<std::index_sequence_for<Ts...>, index_function_list<>, Ts...>;
+
+template <std::size_t I, tuplelike Tuple>
+[[nodiscard]] constexpr auto get(Tuple &&t LIFETIMEBOUND)
+    -> decltype(std::forward<Tuple>(t)[index<I>]) {
+    return std::forward<Tuple>(t)[index<I>];
+}
+
+template <typename T, tuplelike Tuple>
+[[nodiscard]] constexpr auto get(Tuple &&t LIFETIMEBOUND)
+    -> decltype(std::forward<Tuple>(t).get(tag<T>)) {
+    return std::forward<Tuple>(t).get(tag<T>);
+}
 } // namespace detail
 
 template <std::size_t I, tuplelike T> struct tuple_element<I, T> {
@@ -456,17 +468,7 @@ class indexed_tuple : public detail::tuple_impl<std::index_sequence_for<Ts...>,
 template <typename... Ts>
 indexed_tuple(Ts...) -> indexed_tuple<detail::index_function_list<>, Ts...>;
 
-template <std::size_t I, tuplelike Tuple>
-[[nodiscard]] constexpr auto get(Tuple &&t LIFETIMEBOUND)
-    -> decltype(std::forward<Tuple>(t)[index<I>]) {
-    return std::forward<Tuple>(t)[index<I>];
-}
-
-template <typename T, tuplelike Tuple>
-[[nodiscard]] constexpr auto get(Tuple &&t LIFETIMEBOUND)
-    -> decltype(std::forward<Tuple>(t).get(tag<T>)) {
-    return std::forward<Tuple>(t).get(tag<T>);
-}
+using detail::get;
 
 template <typename... Ts> [[nodiscard]] constexpr auto make_tuple(Ts &&...ts) {
     return tuple<std::decay_t<Ts>...>{std::forward<Ts>(ts)...};
diff --git a/include/stdx/tuple_algorithms.hpp b/include/stdx/tuple_algorithms.hpp
index 644bcbd..be86d1f 100644
--- a/include/stdx/tuple_algorithms.hpp
+++ b/include/stdx/tuple_algorithms.hpp
@@ -178,19 +178,25 @@ constexpr std::size_t zip_length_for =
         : std::min({stdx::tuple_size_v<std::remove_cvref_t<Ts>>...});
 } // namespace detail
 
-template <template <typename> typename... Fs, typename Op, tuplelike... Ts>
-constexpr auto transform(Op &&op, Ts &&...ts) {
+template <template <typename> typename... Fs, typename Op, has_tuple_protocol T,
+          has_tuple_protocol... Ts>
+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::tuple<decltype(detail::invoke_at<Is>(
-                std::forward<Op>(op), std::forward<Ts>(ts)...))...>{
-                detail::invoke_at<Is>(std::forward<Op>(op),
-                                      std::forward<Ts>(ts)...)...};
+            using R = boost::mp11::mp_assign<
+                std::remove_cvref_t<T>,
+                type_list<decltype(detail::invoke_at<Is>(
+                    std::forward<Op>(op), std::forward<T>(t),
+                    std::forward<Ts>(ts)...))...>>;
+            return R{detail::invoke_at<Is>(std::forward<Op>(op),
+                                           std::forward<T>(t),
+                                           std::forward<Ts>(ts)...)...};
         } else {
-            return stdx::make_indexed_tuple<Fs...>(detail::invoke_at<Is>(
-                std::forward<Op>(op), std::forward<Ts>(ts)...)...);
+            return stdx::make_indexed_tuple<Fs...>(
+                detail::invoke_at<Is>(std::forward<Op>(op), std::forward<T>(t),
+                                      std::forward<Ts>(ts)...)...);
         }
-    }(std::make_index_sequence<detail::zip_length_for<Ts...>>{});
+    }(std::make_index_sequence<detail::zip_length_for<T, Ts...>>{});
 }
 
 namespace detail {
diff --git a/test/tuple_algorithms.cpp b/test/tuple_algorithms.cpp
index 1205ba6..e3732f1 100644
--- a/test/tuple_algorithms.cpp
+++ b/test/tuple_algorithms.cpp
@@ -68,6 +68,15 @@ TEST_CASE("n-ary transform", "[tuple_algorithms]") {
     STATIC_REQUIRE(u == stdx::tuple{2, 4, 6});
 }
 
+TEST_CASE("n-ary transform on std::tuple", "[tuple_algorithms]") {
+    STATIC_REQUIRE(stdx::transform([](auto, auto) { return 1; }, std::tuple{},
+                                   std::tuple{}) == std::tuple{});
+    constexpr auto t = std::tuple{1, 2, 3};
+    constexpr auto u =
+        stdx::transform([](auto x, auto y) { return x + y; }, t, t);
+    STATIC_REQUIRE(u == std::tuple{2, 4, 6});
+}
+
 TEST_CASE("rvalue transform", "[tuple_algorithms]") {
     auto t = stdx::tuple{1, 2, 3};
     auto const u = stdx::transform([](int &&x) { return x + 1; }, std::move(t));