From d91fdf38b8ab3a6c5f5851c1cf8fe5fad32b936d Mon Sep 17 00:00:00 2001
From: Ben Deane <ben@elbeno.com>
Date: Wed, 4 Mar 2026 18:21:24 -0700
Subject: [PATCH 1/3] :sparkles: Add destructurable `integer_sequence`

Problem:
- With clang backporting "structured bindings can introduce a pack", it would be
  very useful to be able to destructure an `integer_sequence`, to avoid having
  to do the usual call of an immediately-invoked lambda expression.

Solution:
- Add `make_integer_sequence` and `make_index_sequence` that can be destructured.

Note:
- This is first available in clang-21.
---
 include/stdx/utility.hpp | 20 ++++++++++++++++++++
 test/utility.cpp         | 20 ++++++++++++++++++++
 2 files changed, 40 insertions(+)

diff --git a/include/stdx/utility.hpp b/include/stdx/utility.hpp
index 20db122..0b9dd43 100644
--- a/include/stdx/utility.hpp
+++ b/include/stdx/utility.hpp
@@ -287,9 +287,29 @@ template <typename T> constexpr auto is_ct_v<type_identity<T>> = true;
 template <typename T> constexpr auto is_ct_v<T const> = is_ct_v<T>;
 
 #endif
+
+template <typename T, T N>
+struct make_integer_sequence : std::make_integer_sequence<T, N> {};
+template <std::size_t N>
+using make_index_sequence = make_integer_sequence<std::size_t, N>;
+template <typename... Ts>
+using index_sequence_for = make_index_sequence<sizeof...(Ts)>;
+
+template <std::size_t I, typename T, T N>
+constexpr auto get(make_integer_sequence<T, N>) {
+    return std::integral_constant<T, I>{};
+}
+
 } // namespace v1
 } // namespace stdx
 
+template <typename T, T N>
+struct std::tuple_size<stdx::make_integer_sequence<T, N>>
+    : std::integral_constant<std::size_t, N> {};
+template <std::size_t I, typename T, T N>
+struct std::tuple_element<I, stdx::make_integer_sequence<T, N>>
+    : stdx::type_identity<std::integral_constant<T, I>> {};
+
 // NOLINTBEGIN(cppcoreguidelines-macro-usage)
 
 #ifndef FWD
diff --git a/test/utility.cpp b/test/utility.cpp
index 1fa2c46..1c02365 100644
--- a/test/utility.cpp
+++ b/test/utility.cpp
@@ -432,3 +432,23 @@ TEST_CASE("CX_WRAP non-constexpr expression", "[utility]") {
 #endif
 
 #endif
+
+STDX_PRAGMA(diagnostic push)
+#ifdef __clang__
+STDX_PRAGMA(diagnostic ignored "-Wunknown-warning-option")
+STDX_PRAGMA(diagnostic ignored "-Wc++26-extensions")
+#endif
+#if __cpp_structured_bindings >= 202411L
+namespace {
+template <std::size_t N> constexpr auto sum() {
+    auto [... Is] = stdx::make_index_sequence<N>{};
+    constexpr auto sum = (0 + ... + decltype(Is)::value);
+    return sum;
+}
+} // namespace
+
+TEST_CASE("destructurable integer_sequence", "[utility]") {
+    STATIC_CHECK(sum<4>() == 6);
+}
+#endif
+STDX_PRAGMA(diagnostic pop)

From c2ad984bd3fe87dae81a071f02b5a7d35184eee1 Mon Sep 17 00:00:00 2001
From: Ben Deane <ben@elbeno.com>
Date: Wed, 4 Mar 2026 21:56:07 -0700
Subject: [PATCH 2/3] :sparkles: Make `integer_sequence` iterable like `tuple`

Problem:
- It's useful to be able to pass an `integer_sequence` into tuple algorithms
  like `unrolled_for_each`.

Solution:
- Change tuple algorithms to use `get` rather than indexing.
- Add specialization of `tuple_size_v` for `integer_sequence`.
- Add specialization of `get` for `span`.
---
 include/stdx/span.hpp             |  6 ++++++
 include/stdx/tuple.hpp            |  3 +++
 include/stdx/tuple_algorithms.hpp |  4 ++--
 test/tuple_algorithms.cpp         | 14 ++++++++++++++
 4 files changed, 25 insertions(+), 2 deletions(-)

diff --git a/include/stdx/span.hpp b/include/stdx/span.hpp
index 87c9f18..c89b561 100644
--- a/include/stdx/span.hpp
+++ b/include/stdx/span.hpp
@@ -236,6 +236,12 @@ class span : public detail::span_base<T, Extent> {
     }
 };
 
+template <std::size_t I, typename T, std::size_t E>
+[[nodiscard]] constexpr auto get(span<T, E> s) -> decltype(s[I]) {
+    static_assert(E == dynamic_extent or I < E, "get() out of range on span");
+    return s[I];
+}
+
 // NOLINTBEGIN(cppcoreguidelines-pro-type-reinterpret-cast)
 template <class T, std::size_t N> auto as_bytes(span<T, N> s) noexcept {
     if constexpr (N == dynamic_extent) {
diff --git a/include/stdx/tuple.hpp b/include/stdx/tuple.hpp
index dd7b792..c5d2edc 100644
--- a/include/stdx/tuple.hpp
+++ b/include/stdx/tuple.hpp
@@ -3,6 +3,7 @@
 #if __cplusplus >= 202002L
 
 #include <stdx/udls.hpp>
+#include <stdx/utility.hpp>
 
 #include <array>
 #include <concepts>
@@ -408,6 +409,8 @@ tuple_impl(Ts...)
 template <typename T> constexpr auto tuple_size_v = T::size();
 template <typename T, std::size_t N>
 constexpr auto tuple_size_v<std::array<T, N>> = N;
+template <typename T, T N>
+constexpr auto tuple_size_v<make_integer_sequence<T, N>> = std::size_t{N};
 
 template <std::size_t I, typename T>
 using tuple_element_t = typename T::template element_t<I>;
diff --git a/include/stdx/tuple_algorithms.hpp b/include/stdx/tuple_algorithms.hpp
index a1ba123..f886b18 100644
--- a/include/stdx/tuple_algorithms.hpp
+++ b/include/stdx/tuple_algorithms.hpp
@@ -140,7 +140,7 @@ template <template <typename T> typename Pred, tuplelike T>
 namespace detail {
 template <std::size_t I, typename... Ts>
 constexpr auto invoke_at(auto &&op, Ts &&...ts) -> decltype(auto) {
-    return op(std::forward<Ts>(ts)[index<I>]...);
+    return op(get<I>(std::forward<Ts>(ts))...);
 }
 
 template <typename... Ts>
@@ -181,7 +181,7 @@ constexpr auto for_each(Op &&op, Ts &&...ts) -> Op {
 namespace detail {
 template <std::size_t I, typename... Ts>
 constexpr auto invoke_with_idx_at(auto &&op, Ts &&...ts) -> decltype(auto) {
-    return op.template operator()<I>(std::forward<Ts>(ts)[index<I>]...);
+    return op.template operator()<I>(get<I>(std::forward<Ts>(ts))...);
 }
 } // namespace detail
 
diff --git a/test/tuple_algorithms.cpp b/test/tuple_algorithms.cpp
index 2e50fb5..b9cecef 100644
--- a/test/tuple_algorithms.cpp
+++ b/test/tuple_algorithms.cpp
@@ -2,6 +2,7 @@
 
 #include <stdx/span.hpp>
 #include <stdx/tuple_algorithms.hpp>
+#include <stdx/utility.hpp>
 
 #include <catch2/catch_template_test_macros.hpp>
 #include <catch2/catch_test_macros.hpp>
@@ -246,6 +247,19 @@ TEST_CASE("unrolled_for_each on spans", "[tuple_algorithms]") {
     CHECK(a == std::array{0, 1, 2});
 }
 
+TEST_CASE("unrolled_for_each on index_sequence", "[tuple_algorithms]") {
+    auto a = std::array{1u, 2u, 3u};
+    auto sum = std::size_t{};
+    stdx::unrolled_for_each(
+        [&](auto &x, auto y) {
+            sum += x + y;
+            x--;
+        },
+        a, stdx::make_index_sequence<stdx::ct_capacity(a)>{});
+    CHECK(sum == 9u);
+    CHECK(a == std::array{0u, 1u, 2u});
+}
+
 TEST_CASE("tuple_cat", "[tuple_algorithms]") {
     STATIC_REQUIRE(stdx::tuple_cat() == stdx::tuple{});
     STATIC_REQUIRE(stdx::tuple_cat(stdx::tuple{}, stdx::tuple{}) ==

From bc45b57a69604091a091586fa90c6182e8c87f91 Mon Sep 17 00:00:00 2001
From: Ben Deane <ben@elbeno.com>
Date: Thu, 5 Mar 2026 07:45:04 -0700
Subject: [PATCH 3/3] :books: Add documentation for `make_integer_sequence`

Problem:
- There is no documentation explaining `stdx::make_integer_sequence` and
  friends.

Solution:
- Add the docs.
---
 docs/utility.adoc | 43 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/docs/utility.adoc b/docs/utility.adoc
index a83d8ad..2e742a9 100644
--- a/docs/utility.adoc
+++ b/docs/utility.adoc
@@ -116,6 +116,49 @@ std::uint32_t i;
 assert(stdx::is_aligned_with<std::uint32_t>(&i));
 ----
 
+=== `make_integer_sequence`
+
+`make_integer_sequence` is a class template that derives from
+https://en.cppreference.com/w/cpp/utility/integer_sequence.html[`std::make_integer_sequence`].
+Likewise, `make_index_sequence` and `index_sequence_for` are analogous with
+their standard counterparts. In fact each `stdx` version derives from the `std`
+version, so can be used in exactly the same way, for instance:
+
+[source,cpp]
+----
+auto sum = []<std::size_t... Is>(std::index_sequence<Is...>) {
+  return (std::size_t{} + ... + Is);
+}(stdx::make_index_sequence<3>{});
+
+// sum is 6
+----
+The difference is that `stdx::make_integer_sequence` implements the tuple
+protocol. This means that it is usable with
+xref:tuple_algorithms.adoc#_tuple_algorithms_hpp[tuple algorithms]. And when
+using the tuple protocol, `stdx::make_index_sequence` produces
+`std::integral_constant<std::size_t, I>` rather than `std::size_t{I}`.
+
+[source,cpp]
+----
+template <std::size_t N>
+auto f() {
+  // use make_index_sequence with tuple algorithms
+  stdx::unrolled_for_each(
+    [](auto x) {
+      // x is std::integral_constant<std::size_t, I> for each I
+    },
+    stdx::make_index_sequence<N>{});
+
+  // or with C++26, destructure into a pack (optionally constexpr here)
+  auto [...Is] = stdx::make_index_sequence<N>{};
+
+  // std::integral_constant implicitly converts to its contained type...
+  auto rt_sum = (std::size_t{} + ... + Is);
+  // ...or can be used at compile time
+  constexpr auto ct_sum = (std::size_t{} + ... + decltype(Is)::value);
+}
+----
+
 === `overload`
 
 `overload` is a struct designed to encapsulate an overload set. It inherits from