Use structured bindings to create packs instead of old techniques involving std::index_sequence

Author: davidstone

source/bounded/CMakeLists.txt

@@ -69,6 +69,7 @@ target_sources(bounded PUBLIC
 		function_ptr.cpp
 		hash.cpp
 		homogeneous_equals.cpp
+		index_sequence_struct.cpp
 		integer.cpp
 		integral.cpp
 		integral_constant_of_integral.cpp

source/bounded/bounded.cpp

@@ -31,6 +31,7 @@ export import bounded.destroy;
 export import bounded.equality_comparable;
 export import bounded.function_ptr;
 export import bounded.hash;
+export import bounded.index_sequence_struct;
 export import bounded.integer;
 export import bounded.integral;
 export import bounded.isomorphic_to_integral;

source/bounded/index_sequence_struct.cpp

@@ -0,0 +1,42 @@
+// Copyright David Stone 2025.
+// Distributed under the Boost Software License, Version 1.0.
+// (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+export module bounded.index_sequence_struct;
+
+import bounded.integer;
+import bounded.normalize;
+
+import std_module;
+
+namespace bounded {
+
+export template<std::size_t size>
+struct index_sequence_struct {
+	index_sequence_struct() = default;
+	template<auto size_> requires (size_ == size)
+	constexpr explicit index_sequence_struct(bounded::constant_t<size_>) {}
+	template<std::size_t index>
+	static constexpr auto get() {
+		return bounded::constant<index>;
+	}
+};
+
+template<auto size>
+index_sequence_struct(bounded::constant_t<size>) -> index_sequence_struct<size>;
+
+} // namespace bounded
+
+namespace std {
+
+template<std::size_t size>
+struct tuple_size<bounded::index_sequence_struct<size>> : std::integral_constant<std::size_t, size> {
+};
+
+template<std::size_t index, std::size_t size>
+struct tuple_element<index, bounded::index_sequence_struct<size>> {
+	using type = bounded::constant_t<bounded::normalize<index>>;
+};
+
+} // namespace std

source/containers/algorithms/adjacent.cpp

@@ -73,13 +73,8 @@ struct adjacent_iterator {
 		}
 	}
 	constexpr auto operator*() const {
-		return [&]<std::size_t... indexes>(std::index_sequence<indexes...>) {
-			return tv::tuple<
-				decltype(*m_its[bounded::constant<indexes>])...
-			>(
-				*m_its[bounded::constant<indexes>]...
-			);
-		}(bounded::make_index_sequence(group_size));
+		auto const & [...its] = m_its;
+		return tv::tuple<decltype(*its)...>(*its...);
 	}
 	friend constexpr auto operator+(adjacent_iterator lhs, bounded::bounded_integer auto const offset) -> adjacent_iterator {
 		for (auto & it : lhs.m_its) {

source/containers/algorithms/concatenate_view.cpp

@@ -45,22 +45,18 @@ constexpr auto compare_sentinels(LHS const & lhs, RHS const & rhs) -> bool {
 	}
 }
 
-template<typename LHS, typename RHS, std::size_t... indexes>
-constexpr auto have_same_ends(LHS const & lhs, RHS const & rhs, std::index_sequence<indexes...>) {
+template<typename LHS, typename RHS>
+constexpr auto have_same_ends(LHS const & lhs, RHS const & rhs) -> bool {
+	static_assert(tv::tuple_size<LHS> == tv::tuple_size<RHS>);
+	auto [...indexes] = bounded::index_sequence_struct(tv::tuple_size<LHS>);
 	return (... and (
 		compare_sentinels(
-			containers::end(lhs[bounded::constant<indexes>]),
-			containers::end(rhs[bounded::constant<indexes>])
+			containers::end(lhs[indexes]),
+			containers::end(rhs[indexes])
 		)
 	));
 }
 
-template<typename LHS, typename RHS>
-constexpr auto assert_same_ends(LHS const & lhs, RHS const & rhs) {
-	static_assert(tv::tuple_size<LHS> == tv::tuple_size<RHS>);
-	BOUNDED_ASSERT(have_same_ends(lhs, rhs, bounded::make_index_sequence(tv::tuple_size<LHS>)));
-}
-
 template<typename Category, typename RangeView>
 concept one_is_category = std::same_as<typename iterator_t<RangeView>::iterator_category, Category>;
 
@@ -156,21 +152,20 @@ struct concatenate_view_iterator {
 				);
 			}
 		};
-		return [&]<std::size_t... indexes>(std::index_sequence<indexes...>) {
-			// Use {} to enforce initialization order
-			return tv::apply(
-				tv::tuple{specific_range(bounded::constant<indexes>)...},
-				bounded::construct<concatenate_view_iterator>
-			);
-		}(std::make_index_sequence<sizeof...(RangeViews)>());
+		auto [...indexes] = bounded::index_sequence_struct<sizeof...(RangeViews)>();
+		// Use {} to enforce initialization order
+		return tv::apply(
+			tv::tuple{specific_range(indexes)...},
+			bounded::construct<concatenate_view_iterator>
+		);
 	}
 
 	template<typename... RHSRanges> requires(... and subtractable<iterator_t<RangeViews>, iterator_t<RHSRanges>>)
 	friend constexpr auto operator-(
 		concatenate_view_iterator const lhs,
 		concatenate_view_iterator<RHSRanges...> const rhs
 	) {
-		::containers::assert_same_ends(lhs.m_range_views, rhs.m_range_views);
+		BOUNDED_ASSERT(::containers::have_same_ends(lhs.m_range_views, rhs.m_range_views));
 
 		auto transform = [](auto const lhs_range, auto const rhs_range) {
 			return containers::begin(lhs_range) - containers::begin(rhs_range);
@@ -202,7 +197,7 @@ struct concatenate_view_iterator {
 		concatenate_view_iterator const lhs,
 		concatenate_view_iterator<RHSRanges...> const rhs
 	) {
-		::containers::assert_same_ends(lhs.m_range_views, rhs.m_range_views);
+		BOUNDED_ASSERT(::containers::have_same_ends(lhs.m_range_views, rhs.m_range_views));
 		return lhs.begin_iterators() <=> rhs.begin_iterators();
 	}
 
@@ -213,7 +208,7 @@ struct concatenate_view_iterator {
 
 	template<typename... RHSRanges>
 	friend constexpr auto operator==(concatenate_view_iterator const & lhs, concatenate_view_iterator<RHSRanges...> const & rhs) -> bool {
-		::containers::assert_same_ends(lhs.m_range_views, rhs.m_range_views);
+		BOUNDED_ASSERT(::containers::have_same_ends(lhs.m_range_views, rhs.m_range_views));
 		return lhs.begin_iterators() == rhs.begin_iterators();
 	}
 

source/containers/algorithms/sort/double_buffered_ska_sort.cpp

@@ -171,8 +171,15 @@ constexpr auto double_buffered_range_sort(range auto & source, range auto & buff
 	return which;
 }
 
-template<typename OriginalExtractor, typename CurrentExtractor, std::size_t... indexes>
-constexpr auto double_buffered_tuple_sort(range auto & source, range auto & buffer, OriginalExtractor const & original_extractor, CurrentExtractor const & current_extractor, std::index_sequence<indexes...>) -> bool {
+template<typename OriginalExtractor, typename CurrentExtractor>
+constexpr auto double_buffered_tuple_sort(
+	range auto & source,
+	range auto & buffer,
+	OriginalExtractor const & original_extractor,
+	CurrentExtractor const & current_extractor
+) -> bool {
+	using key_t = std::decay_t<decltype(current_extractor(containers::front(source)))>;
+	auto const [...indexes] = bounded::index_sequence_struct<std::tuple_size_v<key_t>>();
 	auto which = false;
 	auto do_iteration = [&]<auto index>(bounded::constant_t<index>) {
 		using std::get;
@@ -186,7 +193,7 @@ constexpr auto double_buffered_tuple_sort(range auto & source, range auto & buff
 			which = ::containers::double_buffered_sort_impl(source, buffer, original_extractor, extract_index);
 		}
 	};
-	(..., do_iteration(bounded::constant<sizeof...(indexes) - indexes - 1>));
+	(..., do_iteration(bounded::constant<sizeof...(indexes)> - indexes - 1_bi));
 	return which;
 }
 
@@ -201,7 +208,7 @@ constexpr auto double_buffered_sort_impl(range auto & source, range auto & buffe
 		return ::containers::double_buffered_range_sort(source, buffer, original_extractor, current_extractor);
 	} else {
 		static_assert(tuple_like<key_t>);
-		return ::containers::double_buffered_tuple_sort(source, buffer, original_extractor, current_extractor, std::make_index_sequence<std::tuple_size_v<key_t>>());
+		return ::containers::double_buffered_tuple_sort(source, buffer, original_extractor, current_extractor);
 	}
 }
 

source/containers/algorithms/zip.cpp

@@ -29,21 +29,6 @@ namespace containers {
 template<typename... Iterators>
 struct zip_iterator;
 
-template<typename... Ts>
-constexpr auto ref_or_value_tuple(Ts && ... args) {
-	return tv::tuple<Ts...>(OPERATORS_FORWARD(args)...);
-}
-
-template<std::size_t... indexes>
-constexpr auto dereference(auto const & tuple, std::index_sequence<indexes...>) {
-	return ref_or_value_tuple(*tuple[bounded::constant<indexes>]...);
-}
-
-template<typename... Iterators, std::size_t... indexes>
-constexpr auto add(tv::tuple<Iterators...> tuple, auto const offset, std::index_sequence<indexes...>) -> zip_iterator<Iterators...> {
-	return zip_iterator<Iterators...>((std::move(tuple)[bounded::constant<indexes>] + offset)...);
-}
-
 template<typename... Iterators>
 struct zip_difference_type_impl {
 	static constexpr auto min_max = bounded::min(
@@ -77,17 +62,20 @@ struct zip_iterator {
 	}
 
 	friend constexpr auto operator*(zip_iterator const & it) {
-		return dereference(it.m_its, indexes);
+		auto const & [...its] = it.m_its;
+		return tv::tuple<decltype(*its)...>(*its...);
 	}
-	friend constexpr auto operator+(zip_iterator it, bounded::constant_t<1>) -> zip_iterator {
+	friend constexpr auto operator+(zip_iterator it, bounded::constant_t<1> const offset) -> zip_iterator {
 		if constexpr (sizeof...(Iterators) == 0) {
 			std::unreachable();
 		} else {
-			return add(std::move(it).m_its, 1_bi, indexes);
+			auto && [...its] = std::move(it).m_its;
+			return zip_iterator((std::move(its) + offset)...);
 		}
 	}
 	friend constexpr auto operator+(zip_iterator it, bounded::convertible_to<difference_type> auto const offset) -> zip_iterator {
-		return add(std::move(it).m_its, offset, indexes);
+		auto && [...its] = std::move(it).m_its;
+		return zip_iterator((std::move(its) + offset)...);
 	}
 
 	friend auto operator<=>(zip_iterator const &, zip_iterator const &) = default;
@@ -96,20 +84,9 @@ struct zip_iterator {
 	friend struct zip_sentinel;
 	template<typename... Sentinels>
 	friend struct zip_smallest_sentinel;
-	static constexpr auto indexes = std::make_index_sequence<sizeof...(Iterators)>();
 	[[no_unique_address]] tv::tuple<Iterators...> m_its;
 };
 
-template<std::size_t... indexes>
-constexpr auto all(auto const & lhs, auto const & rhs, std::index_sequence<indexes...>, auto const predicate) {
-	return (... and predicate(lhs[bounded::constant<indexes>], rhs[bounded::constant<indexes>]));
-}
-
-template<std::size_t... indexes>
-constexpr auto any(auto const & lhs, auto const & rhs, std::index_sequence<indexes...>, auto const predicate) {
-	return (... or predicate(lhs[bounded::constant<indexes>], rhs[bounded::constant<indexes>]));
-}
-
 template<typename... Sentinels>
 struct zip_sentinel {
 	constexpr explicit zip_sentinel(Sentinels... sentinels):
@@ -118,10 +95,10 @@ struct zip_sentinel {
 	}
 	template<typename... Iterators> requires(sizeof...(Iterators) == sizeof...(Sentinels))
 	friend constexpr auto operator==(zip_iterator<Iterators...> const & lhs, zip_sentinel const rhs) -> bool {
-		constexpr auto indexes = std::make_index_sequence<sizeof...(Sentinels)>();
-		if (all(lhs.m_its, rhs.m_sentinels, indexes, std::not_equal_to())) {
+		auto const [...indexes] = bounded::index_sequence_struct<sizeof...(Sentinels)>();
+		if ((... and (lhs.m_its[indexes] != rhs.m_sentinels[indexes]))) {
 			return false;
-		} else if (all(lhs.m_its, rhs.m_sentinels, indexes, std::equal_to())) {
+		} else if ((... and (lhs.m_its[indexes] == rhs.m_sentinels[indexes]))) {
 			return true;
 		} else {
 			throw std::runtime_error("Mismatched sizes for inputs to zip");
@@ -139,8 +116,8 @@ struct zip_smallest_sentinel {
 	}
 	template<typename... Iterators> requires(sizeof...(Iterators) == sizeof...(Sentinels))
 	friend constexpr auto operator==(zip_iterator<Iterators...> const & lhs, zip_smallest_sentinel const rhs) -> bool {
-		constexpr auto indexes = std::make_index_sequence<sizeof...(Sentinels)>();
-		return any(lhs.m_its, rhs.m_sentinels, indexes, std::equal_to());
+		auto const [...indexes] = bounded::index_sequence_struct<sizeof...(Sentinels)>();
+		return (... or (lhs.m_its[indexes] == rhs.m_sentinels[indexes]));
 	}
 private:
 	[[no_unique_address]] tv::tuple<Sentinels...> m_sentinels;
@@ -154,38 +131,6 @@ constexpr auto all_are_equal() -> bool {
 	return true;
 }
 
-template<std::size_t... indexes>
-constexpr auto make_zip_iterator(auto && ranges, std::index_sequence<indexes...>, auto get) {
-	return zip_iterator(
-		get(OPERATORS_FORWARD(ranges)[bounded::constant<indexes>])...
-	);
-}
-
-// https://github.com/llvm/llvm-project/issues/59513
-struct use_begin {
-	static constexpr auto operator()(auto && r) {
-		return containers::begin(OPERATORS_FORWARD(r));
-	}
-};
-struct use_end {
-	static constexpr auto operator()(auto && r) {
-		return containers::end(OPERATORS_FORWARD(r));
-	}
-};
-
-template<bool check_equal_sizes, std::size_t... indexes>
-constexpr auto make_zip_sentinel(auto && ranges, std::index_sequence<indexes...>) {
-	if constexpr (check_equal_sizes) {
-		return zip_sentinel(
-			containers::end(OPERATORS_FORWARD(ranges)[bounded::constant<indexes>])...
-		);
-	} else {
-		return zip_smallest_sentinel(
-			containers::end(OPERATORS_FORWARD(ranges)[bounded::constant<indexes>])...
-		);
-	}
-}
-
 template<typename Range>
 concept supports_begin = requires(Range r) {
 	containers::begin(OPERATORS_FORWARD(r));
@@ -208,7 +153,6 @@ export template<bool check_equal_sizes, range... Ranges>
 struct zip_impl {
 private:
 	static constexpr auto all_are_sized = (... and sized_range<Ranges>);
-	static constexpr auto indexes = std::make_index_sequence<sizeof...(Ranges)>();
 
 	static constexpr auto as_tuple(Ranges && ... ranges) {
 		if constexpr (all_are_sized and !check_equal_sizes and sizeof...(Ranges) != 0) {
@@ -221,18 +165,14 @@ struct zip_impl {
 
 	decltype(as_tuple(bounded::declval<Ranges>()...)) m_ranges;
 
-	static constexpr auto end_impl(auto && ranges) {
+	static constexpr auto end_impl(auto && m_ranges) {
+		auto && [...ranges] = OPERATORS_FORWARD(m_ranges);
 		if constexpr (all_are_sized) {
-			return ::containers::make_zip_iterator(
-				OPERATORS_FORWARD(ranges),
-				indexes,
-				use_end()
-			);
+			return zip_iterator(::containers::end(OPERATORS_FORWARD(ranges))...);
+		} else if constexpr (check_equal_sizes) {
+			return zip_sentinel(containers::end(OPERATORS_FORWARD(ranges))...);
 		} else {
-			return ::containers::make_zip_sentinel<check_equal_sizes>(
-				OPERATORS_FORWARD(ranges),
-				indexes
-			);
+			return zip_smallest_sentinel(containers::end(OPERATORS_FORWARD(ranges))...);
 		}
 	}
 
@@ -255,13 +195,16 @@ struct zip_impl {
 	}
 
 	constexpr auto begin() const & requires all_support_begin<Ranges const &...> {
-		return make_zip_iterator(m_ranges, indexes, use_begin());
+		auto && [...ranges] = m_ranges;
+		return zip_iterator(::containers::begin(OPERATORS_FORWARD(ranges))...);
 	}
 	constexpr auto begin() & requires all_support_begin<Ranges &...> {
-		return make_zip_iterator(m_ranges, indexes, use_begin());
+		auto && [...ranges] = m_ranges;
+		return zip_iterator(::containers::begin(OPERATORS_FORWARD(ranges))...);
 	}
 	constexpr auto begin() && requires all_support_begin<Ranges &&...> {
-		return make_zip_iterator(std::move(m_ranges), indexes, use_begin());
+		auto && [...ranges] = std::move(m_ranges);
+		return zip_iterator(::containers::begin(OPERATORS_FORWARD(ranges))...);
 	}
 
 	constexpr auto end() const & requires all_support_end<Ranges const &...> {