Add some explicit return types

davidstone · davidstone · commit 1311cd4c54f0 · 2025-05-23T12:26:02.000-06:00
diff --git a/source/bounded/arithmetic/modulus.cpp b/source/bounded/arithmetic/modulus.cpp
@@ -58,7 +58,7 @@ constexpr auto modulo_round = [](auto const dividend, umax_t const divisor) {
 		);
 };
 
-constexpr auto sign_free_value = [](auto const dividend, auto divisor) {
+constexpr auto sign_free_value = [](auto const dividend, auto divisor) -> min_max<umax_t, umax_t> {
 	if (divisor.min > dividend.max) {
 		return dividend;
 	}
diff --git a/source/bounded/relocate.cpp b/source/bounded/relocate.cpp
@@ -14,7 +14,7 @@ import std_module;
 namespace bounded_relocate_adl_detail {
 
 template<typename T>
-constexpr auto relocate(T & ref) noexcept {
+constexpr auto relocate(T & ref) noexcept -> T {
 	static_assert(std::is_nothrow_move_constructible_v<T>, "Please provide a noexcept relocate overload for your type or mark its move constructor noexcept.");
 	static_assert(std::is_nothrow_destructible_v<T>, "Do not mark your destructor as noexcept(false)");
 	auto result = std::move(ref);
diff --git a/source/bounded/to_integer.cpp b/source/bounded/to_integer.cpp
@@ -34,7 +34,7 @@ constexpr auto as_digit(char const c) -> integer<0, 9> {
 }
 
 template<auto maximum>
-constexpr auto to_integer_positive_impl(std::string_view const str) {
+constexpr auto to_integer_positive_impl(std::string_view const str) -> integer<0, normalize<maximum>> {
 	auto positive_result = integer<0, normalize<maximum>>(0_bi);
 	for (auto const c : str) {
 		auto const shifted = positive_result * 10_bi;
diff --git a/source/containers/algorithms/accumulate.cpp b/source/containers/algorithms/accumulate.cpp
@@ -61,7 +61,7 @@ using accumulate_t = typename accumulate_c<Range, std::decay_t<Initial>, BinaryF
 
 
 export template<typename Result>
-constexpr auto accumulate(range auto && source, auto && initial, auto function) {
+constexpr auto accumulate(range auto && source, auto && initial, auto function) -> Result {
 	auto result = static_cast<Result>(OPERATORS_FORWARD(initial));
 	for (decltype(auto) value : OPERATORS_FORWARD(source)) {
 		// Not ideal to have this `if` here
@@ -103,7 +103,7 @@ constexpr auto initial_product_value() {
 }
 
 export template<typename Result>
-constexpr auto sum(range auto && source) {
+constexpr auto sum(range auto && source) -> Result {
 	return ::containers::accumulate<Result>(
 		OPERATORS_FORWARD(source),
 		initial_sum_value<range_value_t<decltype(source)>>(),
@@ -120,7 +120,7 @@ export constexpr auto sum(range auto && source) {
 }
 
 export template<typename Result>
-constexpr auto product(range auto && source) {
+constexpr auto product(range auto && source) -> Result {
 	return ::containers::accumulate<Result>(
 		OPERATORS_FORWARD(source),
 		initial_product_value<range_value_t<decltype(source)>>(),
diff --git a/source/containers/algorithms/copy_or_relocate_from.cpp b/source/containers/algorithms/copy_or_relocate_from.cpp
@@ -13,6 +13,7 @@ import containers.begin_end;
 import containers.can_set_size;
 import containers.dereference;
 import containers.is_container;
+import containers.iterator_t;
 import containers.range;
 import containers.range_value_t;
 
@@ -23,7 +24,7 @@ using namespace bounded::literal;
 
 namespace containers {
 
-export constexpr auto copy_or_relocate_from = []<range Input>(Input && input, auto function) {
+export constexpr auto copy_or_relocate_from = []<range Input>(Input && input, auto function) -> iterator_t<Input> {
 	// We do not relocate trivially copyable types because that requires setting
 	// the size of the source range to 0. This is extra work that is not
 	// necessary -- we don't want to make operations on rvalues more expensive
diff --git a/source/containers/algorithms/count.cpp b/source/containers/algorithms/count.cpp
@@ -20,7 +20,7 @@ using namespace bounded::literal;
 namespace containers {
 
 export template<range Range>
-constexpr auto count_if(Range && r, auto predicate) {
+constexpr auto count_if(Range && r, auto predicate) -> count_type<Range> {
 	auto sum = count_type<Range>(0_bi);
 	for (decltype(auto) value : OPERATORS_FORWARD(r)) {
 		if (predicate(OPERATORS_FORWARD(value))) {
diff --git a/source/containers/algorithms/distance.cpp b/source/containers/algorithms/distance.cpp
@@ -17,7 +17,7 @@ namespace containers {
 using namespace bounded::literal;
 
 export template<iterator InputIterator>
-constexpr auto distance(InputIterator first, sentinel_for<InputIterator> auto const last) {
+constexpr auto distance(InputIterator first, sentinel_for<InputIterator> auto const last) -> iter_difference_t<InputIterator> {
 	if constexpr (requires { last - first; }) {
 		return last - first;
 	} else {
diff --git a/source/containers/algorithms/erase.cpp b/source/containers/algorithms/erase.cpp
@@ -33,18 +33,18 @@ using namespace bounded::literal;
 namespace containers {
 
 export template<erasable Container>
-constexpr auto erase(Container & container, iterator_t<Container const &> const first, iterator_t<Container const &> const middle_) {
+constexpr auto erase(Container & container, iterator_t<Container const &> const first, iterator_t<Container const &> const middle_) -> iterator_t<Container &> {
 	if constexpr (member_erasable<Container>) {
 		return container.erase(first, middle_);
 	} else if constexpr (splicable<Container>) {
 		auto temp = Container();
 		::containers::splice(temp, containers::begin(temp), container, first, middle_);
-		return mutable_iterator(container, middle_);
+		return ::containers::mutable_iterator(container, middle_);
 	} else {
-		auto const middle = ::containers::mutable_iterator(container, middle_);
-		if (first == middle) {
-			return middle;
+		if (first == middle_) {
+			return ::containers::mutable_iterator(container, middle_);
 		}
+		auto const middle = ::containers::mutable_iterator(container, middle_);
 		auto const offset = first - containers::begin(container);
 		auto const count = middle - first;
 		auto const last = containers::end(container);
@@ -68,13 +68,13 @@ constexpr auto erase(Container & container, iterator_t<Container const &> const
 }
 
 export template<erasable Container>
-constexpr auto erase(Container & container, iterator_t<Container const &> const it) {
+constexpr auto erase(Container & container, iterator_t<Container const &> const it) -> iterator_t<Container &> {
 	BOUNDED_ASSERT(it != containers::end(container));
 	return erase(container, it, ::containers::next(it));
 }
 
 export template<erasable Container>
-constexpr void erase_to_end(Container & container, iterator_t<Container const &> const_position) {
+constexpr auto erase_to_end(Container & container, iterator_t<Container const &> const_position) -> void {
 	auto const last = containers::end(container);
 	if constexpr (can_set_size<Container>) {
 		auto const count = last - const_position;
@@ -87,7 +87,7 @@ constexpr void erase_to_end(Container & container, iterator_t<Container const &>
 }
 
 export template<erasable Container>
-constexpr auto erase_if(Container & container, auto predicate) {
+constexpr auto erase_if(Container & container, auto predicate) -> count_type<Container> {
 	auto result = count_type<Container>(0_bi);
 	if constexpr (constant_time_erasable<Container>) {
 		for (auto it = containers::begin(container); it != containers::end(container); ) {
@@ -119,7 +119,7 @@ constexpr auto erase_if(Container & container, auto predicate) {
 }
 
 export template<has_member_erase_after Container>
-constexpr void erase_after(Container & container, iterator_t<Container const &> const before_first, iterator_t<Container const &> const last) {
+constexpr auto erase_after(Container & container, iterator_t<Container const &> const before_first, iterator_t<Container const &> const last) -> void {
 	auto it = containers::next(before_first);
 	while (it != last) {
 		it = container.erase_after(before_first);
diff --git a/source/containers/algorithms/find.cpp b/source/containers/algorithms/find.cpp
@@ -24,7 +24,7 @@ using namespace bounded::literal;
 namespace containers {
 
 export template<iterator Iterator>
-constexpr auto find_if(Iterator first, sentinel_for<Iterator> auto const last, auto predicate) {
+constexpr auto find_if(Iterator first, sentinel_for<Iterator> auto const last, auto predicate) -> Iterator {
 	for (; first != last; ++first) {
 		if (predicate(*first)) {
 			break;
@@ -43,7 +43,7 @@ export constexpr auto find_if(range auto && range, auto predicate) {
 
 
 export template<bidirectional_iterator Iterator>
-constexpr auto find_last_if(Iterator const first, Iterator const last, auto predicate) {
+constexpr auto find_last_if(Iterator const first, Iterator const last, auto predicate) -> Iterator {
 	for (auto it = last; it != first; ) {
 		--it;
 		if (predicate(*it)) {
@@ -63,7 +63,7 @@ export constexpr auto find_last_if(bidirectional_range auto && range, auto predi
 
 
 export template<iterator Iterator>
-constexpr auto find_if_not(Iterator first, sentinel_for<Iterator> auto const last, auto predicate) {
+constexpr auto find_if_not(Iterator first, sentinel_for<Iterator> auto const last, auto predicate) -> Iterator {
 	return ::containers::find_if(std::move(first), last, std::not_fn(std::move(predicate)));
 }
 
@@ -77,7 +77,7 @@ export constexpr auto find_if_not(range auto && range, auto predicate) {
 
 
 export template<bidirectional_iterator Iterator>
-constexpr auto find_last_if_not(Iterator const first, Iterator const last, auto predicate) {
+constexpr auto find_last_if_not(Iterator const first, Iterator const last, auto predicate) -> Iterator {
 	return ::containers::find_last_if(first, last, std::not_fn(std::move(predicate)));
 }
 
@@ -91,7 +91,7 @@ export constexpr auto find_last_if_not(bidirectional_range auto && range, auto p
 
 
 export template<iterator Iterator>
-constexpr auto find(Iterator first, sentinel_for<Iterator> auto const last, auto const & value) {
+constexpr auto find(Iterator first, sentinel_for<Iterator> auto const last, auto const & value) -> Iterator {
 	return ::containers::find_if(std::move(first), last, bounded::equal_to(value));
 }
 
@@ -105,7 +105,7 @@ export constexpr auto find(range auto && range, auto const & value) {
 
 
 export template<bidirectional_iterator Iterator>
-constexpr auto find_last(Iterator const first, Iterator const last, auto const & value) {
+constexpr auto find_last(Iterator const first, Iterator const last, auto const & value) -> Iterator {
 	return ::containers::find_last_if(first, last, bounded::equal_to(value));
 }
 
diff --git a/source/containers/algorithms/minmax_element.cpp b/source/containers/algorithms/minmax_element.cpp
@@ -12,6 +12,7 @@ export module containers.algorithms.minmax_element;
 import containers.algorithms.advance;
 import containers.array;
 import containers.begin_end;
+import containers.iterator_t;
 import containers.range;
 
 import bounded;
@@ -21,7 +22,8 @@ namespace containers {
 
 // TODO: minmax_element
 
-export constexpr auto min_element(range auto && source, auto compare) {
+export template<range Range>
+constexpr auto min_element(Range && source, auto compare) -> iterator_t<Range> {
 	auto smallest = containers::begin(OPERATORS_FORWARD(source));
 	auto const last = containers::end(OPERATORS_FORWARD(source));
 	if (smallest == last) {
diff --git a/source/containers/algorithms/sort/inplace_radix_sort.cpp b/source/containers/algorithms/sort/inplace_radix_sort.cpp
@@ -64,7 +64,7 @@ struct BaseListSortData {
 };
 
 template<view View, typename ExtractKey>
-using NextSort = void (&)(View, ExtractKey const &, BaseListSortData *);
+using NextSort = auto (&)(View, ExtractKey const &, BaseListSortData *) -> void;
 
 template<view View, typename ExtractKey>
 struct ListSortData : BaseListSortData {
@@ -76,7 +76,7 @@ template<typename T>
 struct SubKey {
 	// TODO: Should this use the user-provided `extract_key`?
 	using base = SubKey<decltype(to_radix_sort_key(bounded::declval<T>()))>;
-	static constexpr decltype(auto) sub_key(auto && value, BaseListSortData * data) {
+	static constexpr auto sub_key(auto && value, BaseListSortData * data) -> decltype(auto) {
 		return base::sub_key(to_radix_sort_key(OPERATORS_FORWARD(value)), data);
 	}
 
@@ -95,7 +95,7 @@ struct SubKey<T &&> : SubKey<T> {
 
 template<typename T> requires bounded::unsigned_builtin<T> or std::same_as<T, bool>
 struct SubKey<T> {
-	static constexpr auto sub_key(T const value, BaseListSortData *) {
+	static constexpr auto sub_key(T const value, BaseListSortData *) -> T {
 		return value;
 	}
 
@@ -123,7 +123,7 @@ struct NextTupleSubKey<index, SubKey<void>> {
 
 template<std::size_t index, typename Current, typename... More>
 struct TupleSubKey {
-	static constexpr decltype(auto) sub_key(auto && value, BaseListSortData * sort_data) {
+	static constexpr auto sub_key(auto && value, BaseListSortData * sort_data) -> decltype(auto) {
 		using std::get;
 		return Current::sub_key(get<index>(OPERATORS_FORWARD(value)), sort_data);
 	}
@@ -152,10 +152,10 @@ struct SubKey<Tuple> : TupleSubKeyWrapper<
 
 template<indexable_range T>
 struct SubKey<T> {
-	static constexpr const T & sub_key(T const & value, BaseListSortData *) {
+	static constexpr auto sub_key(T const & value, BaseListSortData *) -> T const & {
 		return value;
 	}
-	static constexpr T sub_key(T && value, BaseListSortData *) {
+	static constexpr auto sub_key(T && value, BaseListSortData *) -> T {
 		return value;
 	}
 
@@ -172,17 +172,17 @@ template<std::ptrdiff_t std_sort_threshold, std::ptrdiff_t american_flag_sort_th
 struct UnsignedInplaceSorter {
 	// Must have this exact signature, no defaulted arguments
 	template<view View, typename ExtractKey>
-	static constexpr void sort(View to_sort, ExtractKey const & extract_key, NextSort<View, ExtractKey> next_sort, BaseListSortData * sort_data) {
+	static constexpr auto sort(View to_sort, ExtractKey const & extract_key, NextSort<View, ExtractKey> next_sort, BaseListSortData * sort_data) -> void {
 		sort_selector(to_sort, extract_key, next_sort, sort_data, 0U);
 	}
 private:
 
-	constexpr static auto current_byte(auto const & elem, BaseListSortData * sort_data, std::size_t const offset) {
+	constexpr static auto current_byte(auto const & elem, BaseListSortData * sort_data, std::size_t const offset) -> std::uint8_t {
 		auto const shift_amount = (number_of_bytes - 1U - offset) * 8U;
 		return static_cast<std::uint8_t>(CurrentSubKey::sub_key(elem, sort_data) >> shift_amount);
 	}
 
-	static constexpr auto partition_counts(view auto to_sort, auto const & extract_key, BaseListSortData * sort_data, std::size_t const offset) {
+	static constexpr auto partition_counts(view auto to_sort, auto const & extract_key, BaseListSortData * sort_data, std::size_t const offset) -> PartitionCounts {
 		auto result = PartitionCounts();
 		for (auto const & value : to_sort) {
 			++result.partitions[current_byte(extract_key(value), sort_data, offset)].count;
@@ -203,7 +203,7 @@ struct UnsignedInplaceSorter {
 	}
 
 	template<view View, typename ExtractKey>
-	static constexpr void sort_selector(View to_sort, ExtractKey const & extract_key, NextSort<View, ExtractKey> next_sort, BaseListSortData * sort_data, std::size_t const offset) {
+	static constexpr auto sort_selector(View to_sort, ExtractKey const & extract_key, NextSort<View, ExtractKey> next_sort, BaseListSortData * sort_data, std::size_t const offset) -> void {
 		if (number_of_bytes == offset) {
 			next_sort(to_sort, extract_key, sort_data);
 		} else if (containers::size(to_sort) <= bounded::constant<std_sort_threshold>) {
@@ -215,7 +215,7 @@ struct UnsignedInplaceSorter {
 		}
 	}
 	template<view View, typename ExtractKey>
-	static constexpr void american_flag_sort(View to_sort, ExtractKey const & extract_key, NextSort<View, ExtractKey> next_sort, BaseListSortData * sort_data, std::size_t const offset) {
+	static constexpr auto american_flag_sort(View to_sort, ExtractKey const & extract_key, NextSort<View, ExtractKey> next_sort, BaseListSortData * sort_data, std::size_t const offset) -> void {
 		auto partitions = partition_counts(to_sort, extract_key, sort_data, offset);
 		auto const first = containers::begin(to_sort);
 		using difference_type = iter_difference_t<decltype(first)>;
@@ -272,7 +272,7 @@ struct UnsignedInplaceSorter {
 	}
 
 	template<view View, typename ExtractKey>
-	static constexpr void ska_byte_sort(View to_sort, ExtractKey const & extract_key, NextSort<View, ExtractKey> next_sort, BaseListSortData * sort_data, std::size_t const offset) {
+	static constexpr auto ska_byte_sort(View to_sort, ExtractKey const & extract_key, NextSort<View, ExtractKey> next_sort, BaseListSortData * sort_data, std::size_t const offset) -> void {
 		auto partitions = partition_counts(to_sort, extract_key, sort_data, offset);
 		auto const first = containers::begin(to_sort);
 		using difference_type = iter_difference_t<decltype(first)>;
@@ -319,7 +319,7 @@ template<std::ptrdiff_t std_sort_threshold, std::ptrdiff_t american_flag_sort_th
 struct ListInplaceSorter;
 
 template<std::ptrdiff_t std_sort_threshold, std::ptrdiff_t american_flag_sort_threshold, typename CurrentSubKey, view View, typename ExtractKey>
-constexpr void inplace_sort(View to_sort, ExtractKey const & extract_key, NextSort<View, ExtractKey> next_sort, BaseListSortData * sort_data) {
+constexpr auto inplace_sort(View to_sort, ExtractKey const & extract_key, NextSort<View, ExtractKey> next_sort, BaseListSortData * sort_data) -> void {
 	using SubKeyType = decltype(CurrentSubKey::sub_key(extract_key(containers::front(to_sort)), sort_data));
 	if constexpr (std::same_as<SubKeyType, bool>) {
 		auto middle = containers::partition(to_sort, [&](auto && a){ return !CurrentSubKey::sub_key(extract_key(a), sort_data); });
@@ -343,7 +343,7 @@ constexpr void inplace_sort(View to_sort, ExtractKey const & extract_key, NextSo
 template<std::ptrdiff_t std_sort_threshold, std::ptrdiff_t american_flag_sort_threshold, typename CurrentSubKey, typename ListType>
 struct ListInplaceSorter {
 	template<view View, typename ExtractKey>
-	static constexpr void sort(View to_sort, ExtractKey const & extract_key, NextSort<View, ExtractKey> next_sort, BaseListSortData * next_sort_data) {
+	static constexpr auto sort(View to_sort, ExtractKey const & extract_key, NextSort<View, ExtractKey> next_sort, BaseListSortData * next_sort_data) -> void {
 		constexpr auto current_index = 0U;
 		constexpr auto recursion_limit = 16U;
 		auto const offset = ListSortData<View, ExtractKey>{
@@ -363,7 +363,7 @@ struct ListInplaceSorter {
 
 		using next = ElementSubKey;
 
-		static constexpr decltype(auto) sub_key(auto && value, BaseListSortData * sort_data) {
+		static constexpr auto sub_key(auto && value, BaseListSortData * sort_data) -> decltype(auto) {
 			auto && list = CurrentSubKey::sub_key(OPERATORS_FORWARD(value), sort_data->next_sort_data);
 			return base::sub_key(
 				containers::at(OPERATORS_FORWARD(list), sort_data->current_index),
@@ -373,7 +373,7 @@ struct ListInplaceSorter {
 	};
 
 	template<view View, typename ExtractKey>
-	static constexpr void sort(View to_sort, ExtractKey const & extract_key, ListSortData<View, ExtractKey> sort_data) {
+	static constexpr auto sort(View to_sort, ExtractKey const & extract_key, ListSortData<View, ExtractKey> sort_data) -> void {
 		auto current_key = [&](auto const & elem) -> decltype(auto) {
 			return CurrentSubKey::sub_key(extract_key(elem), sort_data.next_sort_data);
 		};
@@ -409,7 +409,7 @@ struct ListInplaceSorter {
 	}
 
 	template<view View, typename ExtractKey>
-	static constexpr void sort_from_recursion(View to_sort, ExtractKey const & extract_key, BaseListSortData * next_sort_data) {
+	static constexpr auto sort_from_recursion(View to_sort, ExtractKey const & extract_key, BaseListSortData * next_sort_data) -> void {
 		auto offset = *static_cast<ListSortData<View, ExtractKey> *>(next_sort_data);
 		++offset.current_index;
 		--offset.recursion_limit;
@@ -422,7 +422,7 @@ struct ListInplaceSorter {
 };
 
 template<std::ptrdiff_t std_sort_threshold, std::ptrdiff_t american_flag_sort_threshold, typename CurrentSubKey, view View, typename ExtractKey>
-constexpr void sort_starter(View to_sort, ExtractKey const & extract_key, BaseListSortData * next_sort_data) {
+constexpr auto sort_starter(View to_sort, ExtractKey const & extract_key, BaseListSortData * next_sort_data) -> void {
 	if constexpr (!std::same_as<CurrentSubKey, SubKey<void>>) {
 		if (containers::size(to_sort) <= 1_bi) {
 			return;
@@ -438,7 +438,7 @@ constexpr void sort_starter(View to_sort, ExtractKey const & extract_key, BaseLi
 }
 
 export template<std::ptrdiff_t std_sort_threshold, std::ptrdiff_t american_flag_sort_threshold>
-constexpr void inplace_radix_sort(view auto to_sort, auto const & extract_key) {
+constexpr auto inplace_radix_sort(view auto to_sort, auto const & extract_key) -> void {
 	using SubKey = SubKey<decltype(extract_key(containers::front(to_sort)))>;
 	sort_starter<std_sort_threshold, american_flag_sort_threshold, SubKey>(to_sort, extract_key, nullptr);
 }
diff --git a/source/containers/algorithms/unique.cpp b/source/containers/algorithms/unique.cpp
diff --git a/source/containers/insert.cpp b/source/containers/insert.cpp

Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ constexpr auto modulo_round = [](auto const dividend, umax_t const divisor) {`
`58`	`58`	`);`
`59`	`59`	`};`
`60`	`60`
`61`		`-constexpr auto sign_free_value = [](auto const dividend, auto divisor) {`
	`61`	`+constexpr auto sign_free_value = [](auto const dividend, auto divisor) -> min_max<umax_t, umax_t> {`
`62`	`62`	`if (divisor.min > dividend.max) {`
`63`	`63`	`return dividend;`
`64`	`64`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,7 +34,7 @@ constexpr auto as_digit(char const c) -> integer<0, 9> {`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`template<auto maximum>`
`37`		`-constexpr auto to_integer_positive_impl(std::string_view const str) {`
	`37`	`+constexpr auto to_integer_positive_impl(std::string_view const str) -> integer<0, normalize<maximum>> {`
`38`	`38`	`auto positive_result = integer<0, normalize<maximum>>(0_bi);`
`39`	`39`	`for (auto const c : str) {`
`40`	`40`	`auto const shifted = positive_result * 10_bi;`