@auto_js/utility 0.0.8 → 0.0.10

package/CMakeLists.txt

@@ -26,6 +26,7 @@ target_sources(utility_js
 		memory/memory.cc
 		memory/noinit_allocator.cc
 		meta/algorithm.cc
+		platform/format.cc
 		platform/lockable.cc
 		platform/stop_token.cc
 		platform/timer.h.cc
@@ -34,6 +35,7 @@ target_sources(utility_js
 		type_traits/type_of.cc
 		type_traits/type_pack.cc
 		type_traits/type_traits.cc
+		utility/array.cc
 		utility/constant_wrapper.cc
 		utility/covariant_value.cc
 		utility/facade.cc

package/_module.cc

@@ -7,6 +7,7 @@ export import :functional;
 export import :functional.flat_tuple;
 export import :memory;
 export import :meta.algorithm;
+export import :platform.format;
 export import :platform.lockable;
 export import :platform.stop_token;
 export import :platform.timer;

package/assertions.cc

@@ -1,7 +1,7 @@
 import std;
 import util;
 
-constexpr auto assert_strings_equal(auto... strings) {
+consteval auto assert_strings_equal(auto... strings) {
 	const auto [... left ] = std::tuple{std::basic_string_view{strings}...};
 	const auto [... right ] = std::tuple{std::basic_string_view{strings}...};
 	(..., ([ = ](auto left) -> void {
@@ -13,7 +13,7 @@ constexpr auto assert_strings_equal(auto... strings) {
 	 }(left)));
 }
 
-static_assert([]() -> int {
+static_assert([] -> int {
 	// https://en.cppreference.com/w/cpp/language/string_literal.html
 
 	// Quick check of interpolation matrix

package/container/sealed_map.cc

@@ -52,7 +52,7 @@ class sealed_map {
 			requires std::default_initializable<Type> :
 				sealed_map{
 					sorted_equivalent_t{},
-					util::elide{[ & ]() -> container_type {
+					util::elide{[ & ] -> container_type {
 						auto keys_array = std::array<key_type, Size>{std::move(keys)...};
 						std::ranges::sort(keys_array);
 						auto [... sorted_keys ] = std::move(keys_array);
@@ -64,7 +64,7 @@ class sealed_map {
 		explicit consteval sealed_map(std::in_place_t /*tag*/, auto... pairs) :
 				sealed_map{
 					sorted_equivalent_t{},
-					util::elide{[ & ]() -> container_type {
+					util::elide{[ & ] -> container_type {
 						// Sort without invoking `operator()=`, which might not exist on the value type
 						auto entries = std::array<value_type, Size>{std::move(pairs)...};
 						auto indices = std::array<std::size_t, Size>{};

package/functional/bind.cc

@@ -9,8 +9,8 @@ namespace util {
 
 // Captures the given parameters in way such that empty objects yield an empty and
 // default-constructible invocable. See:
-//   static_assert(std::is_empty_v<decltype([]() {})>);
-//   static_assert(!std::is_empty_v<decltype([ a = std::monostate{} ]() {})>);
+//   static_assert(std::is_empty_v<decltype([] {})>);
+//   static_assert(!std::is_empty_v<decltype([ a = std::monostate{} ] {})>);
 export template <class Invocable, class... Bound>
 class bind;
 
@@ -58,7 +58,7 @@ class bind_overloaded : private bind_storage<Invocable, Bound...> {
 
 	private:
 		constexpr auto invoke(this auto&& self, auto&&... args) -> decltype(auto) {
-			const auto [... indices ] = util::sequence<sizeof...(Bound)>;
+			constexpr auto [... indices ] = util::sequence<sizeof...(Bound)>;
 			// NOLINTNEXTLINE(bugprone-use-after-move)
 			return std::forward<decltype(self)>(self).invocable_(
 				// NOLINTNEXTLINE(bugprone-use-after-move)
@@ -106,7 +106,7 @@ class bind_explicit<Invocable, auto(Args...) noexcept(Nx)->Result, Bound...> : p
 
 	private:
 		constexpr auto invoke(this auto&& self, Args /*&&*/... args) noexcept(Nx) -> Result {
-			const auto [... indices ] = util::sequence<sizeof...(Bound)>;
+			constexpr auto [... indices ] = util::sequence<sizeof...(Bound)>;
 			// NOLINTNEXTLINE(bugprone-use-after-move)
 			return std::forward<this_type>(self).invocable_(
 				// NOLINTNEXTLINE(bugprone-use-after-move)

package/functional/flat_tuple.cc

@@ -70,6 +70,9 @@ struct flat_tuple : flat_tuple_storage_t<Types...> {
 		using flat_tuple_storage_t<Types...>::flat_tuple_storage_t;
 };
 
+template <class... Types>
+flat_tuple(Types...) -> flat_tuple<Types...>;
+
 // `std::get` replacement for `flat_tuple`
 export template <std::size_t Index, class... Types>
 constexpr auto get(flat_tuple<Types...>& tuple) -> auto& {
@@ -87,3 +90,16 @@ constexpr auto get(const flat_tuple<Types...>& tuple) -> const auto& {
 }
 
 } // namespace util
+
+namespace std {
+// `util::flat_tuple` destructuring specializations
+template <std::size_t Index, class... Types>
+struct tuple_element<Index, util::flat_tuple<Types...>> {
+		using type = Types...[ Index ];
+};
+
+template <class... Types>
+struct tuple_size<util::flat_tuple<Types...>> {
+		constexpr static auto value = sizeof...(Types);
+};
+} // namespace std

package/functional/functional.cc

@@ -43,9 +43,9 @@ constexpr auto invoke_this_as(auto&& func, auto&&... args)
 // no parameters, returning that result.
 export constexpr auto template_traverse(auto values_pack, const auto& invoke) -> decltype(auto) {
 	const auto fold = util::overloaded{
-		[ & ]() -> decltype(auto) { return invoke(); },
+		[ & ] -> decltype(auto) { return invoke(); },
 		[ & ](this const auto& self, auto value, auto... values) -> decltype(auto) {
-			return invoke(value, [ & ]() -> decltype(auto) { return self(values...); });
+			return invoke(value, [ & ] -> decltype(auto) { return self(values...); });
 		},
 	};
 	const auto [... values ] = values_pack;
@@ -56,7 +56,7 @@ export constexpr auto template_traverse(auto values_pack, const auto& invoke) ->
 // `identity` is ignored.
 export constexpr auto template_fold(auto values_pack, auto identity, const auto& invoke) -> decltype(auto) {
 	const auto fold = util::overloaded{
-		[ & ]() -> decltype(auto) { return identity; },
+		[ & ] -> decltype(auto) { return identity; },
 		[ & ](auto left) -> decltype(auto) { return left; },
 		[ & ](this const auto& self, auto left, auto right, auto... values) -> decltype(auto) {
 			return self(invoke(left, right), values...);
@@ -102,14 +102,14 @@ export constexpr auto template_switch(const auto& value, auto case_pack, auto in
 //    37 | static_assert(transfer<double>(std::variant<int, double>{1.1}) == 1.1);
 //       |               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 // /workspace/packages/utility/functional/functional.cc:73:11: note: subobject of type 'const util::overloaded<(lambda at /workspace/packages/utility/functional/functional.cc:85:4), (lambda at /workspace/packages/utility/functional/functional.cc:86:4)> &const' is not initialized
-//    73 |                         return invoke(value, [ & ]() -> decltype(auto) { return self(values...); });
+//    73 |                         return invoke(value, [ & ] -> decltype(auto) { return self(values...); });
 //
 // export constexpr auto template_switch(const auto& value, auto case_pack, auto invoke) -> decltype(auto) {
 // 	return template_traverse(
 // 		case_pack,
 // 		util::overloaded{
 // 			[ & ](auto case_, auto next) -> decltype(auto) { return value == case_ ? invoke(case_) : next(); },
-// 			[ & ]() -> decltype(auto) { return invoke(); },
+// 			[ & ] -> decltype(auto) { return invoke(); },
 // 		}
 // 	);
 // }

package/memory/noinit_allocator.cc

@@ -32,7 +32,7 @@ class noinit_allocator {
 
 		constexpr auto construct(pointer ptr, auto&&... args) -> void
 			requires std::constructible_from<Type, decltype(args)...> {
-			auto construct = [ & ]() constexpr -> void {
+			auto construct = [ & ] constexpr -> void {
 				std::allocator_traits<Allocator>::construct(allocator_, ptr, std::forward<decltype(args)>(args)...);
 			};
 			if consteval {

package/meta/algorithm.cc

@@ -22,16 +22,10 @@ constexpr auto spread_type_pack = util::overloaded{
 	},
 };
 
-// Concatenate 0..N `util::type_packs` together
-export constexpr auto pack_concat = util::overloaded{
-	[]() consteval -> auto { return type_pack{}; },
-	[](auto&&... packs) consteval -> auto { return (... + make_type_pack(packs)); },
-};
-
 // Apply transformation function to each type in the pack
 export constexpr auto pack_transform = [](auto pack, auto unary) consteval -> auto {
-	const auto [... types ] = pack;
-	return pack_concat(unary(types)...);
+	constexpr auto [... types ] = pack;
+	return (type_pack{} + ... + make_type_pack(unary(types)));
 };
 
 // Return a new `type_pack` with types matching the predicate
@@ -44,37 +38,32 @@ export constexpr auto pack_filter = [](auto pack, auto predicate) consteval -> a
 			return type_pack{};
 		}
 	};
-	return pack_transform(pack, filter);
+	return pack_transform(make_type_pack(pack), filter);
 };
 
-// Return a nested `type_pack` of `tuple_pack`'s containing types filtered by the predicates
-// nb: `predicates` must be `util::fn<...>`
-export constexpr auto pack_partition = util::overloaded{
-	[](auto pack) consteval -> auto { return type_pack{pack}; },
-	[]<class Predicate>(this auto pack_partition, auto pack, Predicate predicate, auto... predicates) consteval -> auto {
-		// `std::not_fn()` doesn't work
-		constexpr auto not_fn = util::fn<[](auto type) -> bool { return !Predicate{}(type); }>;
-		const auto left = pack_filter(pack, predicate);
-		const auto right = pack_filter(pack, not_fn);
-		return pack_concat(pack_partition(left), pack_partition(right, predicates...));
-	},
+// Return a nested `type_pack` of two `tuple_pack`'s containing types filtered by the predicate.
+export constexpr auto pack_partition = []<auto Predicate>(auto pack, function_constant<Predicate> predicate) consteval -> auto {
+	// `std::not_fn()` doesn't work
+	constexpr auto not_fn = util::fn<[](auto type) -> bool { return !Predicate(type); }>;
+	const auto left = pack_filter(pack, predicate);
+	const auto right = pack_filter(pack, not_fn);
+	return type_pack_of{left, right};
 };
 
 // Return unique types from the pack
 export constexpr auto pack_unique = util::overloaded{
-	[]() consteval -> auto { return type_pack{}; },
+	[] consteval -> auto { return type_pack{}; },
 	[](auto... types) consteval -> auto {
-		constexpr auto transform = [ = ](auto index) {
-			constexpr auto subject = types...[ index ];
-			const auto [... indices ] = util::sequence<index>;
-			if constexpr ((... || (subject == types...[ indices ]))) {
+		constexpr auto [... ii ] = util::sequence<sizeof...(types)>;
+		return (... + [ & ] -> auto {
+			constexpr auto subject = types...[ ii ];
+			constexpr auto [... jj ] = util::sequence<ii>;
+			if constexpr ((... || (subject == types...[ jj ]))) {
 				return type_pack_of{};
 			} else {
 				return type_pack_of{subject};
 			}
-		};
-		const auto [... indices ] = util::sequence<sizeof...(types)>;
-		return (... + transform(indices));
+		}());
 	},
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@auto_js/utility",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "author": "https://github.com/laverdet/",
   "homepage": "https://github.com/laverdet/isolated-vm/tree/experimental/packages/utility",
   "license": "ISC",

package/platform/format.cc

@@ -0,0 +1,181 @@
+module;
+#include <version>
+export module util:platform.format;
+import std;
+
+namespace util {
+
+#if __GLIBCXX__
+
+// Claude-generated `std::format` fill to avoid gcc 16.2.0 libstdc++ requirement.
+
+template <class Type>
+struct printf_arg {
+		static_assert(false, "type is not formattable by the `util::format` polyfill");
+};
+
+template <>
+struct printf_arg<bool> {
+		constexpr static auto spec = std::string_view{"%s"};
+		constexpr static auto pass(bool value) { return std::tuple{value ? "true" : "false"}; }
+};
+
+template <>
+struct printf_arg<char> {
+		constexpr static auto spec = std::string_view{"%c"};
+		constexpr static auto pass(char value) { return std::tuple{value}; }
+};
+
+template <class Type>
+	requires std::signed_integral<Type>
+struct printf_arg<Type> {
+		constexpr static auto spec = std::string_view{"%lld"};
+		constexpr static auto pass(Type value) { return std::tuple{static_cast<long long>(value)}; }
+};
+
+template <class Type>
+	requires std::unsigned_integral<Type>
+struct printf_arg<Type> {
+		constexpr static auto spec = std::string_view{"%llu"};
+		constexpr static auto pass(Type value) { return std::tuple{static_cast<unsigned long long>(value)}; }
+};
+
+template <class Type>
+	requires(std::same_as<Type, float> || std::same_as<Type, double>)
+struct printf_arg<Type> {
+		constexpr static auto spec = std::string_view{"%g"};
+		constexpr static auto pass(Type value) { return std::tuple{static_cast<double>(value)}; }
+};
+
+template <>
+struct printf_arg<long double> {
+		constexpr static auto spec = std::string_view{"%Lg"};
+		constexpr static auto pass(long double value) { return std::tuple{value}; }
+};
+
+template <>
+struct printf_arg<const char*> {
+		constexpr static auto spec = std::string_view{"%s"};
+		constexpr static auto pass(const char* value) { return std::tuple{value}; }
+};
+
+template <>
+struct printf_arg<char*> : printf_arg<const char*> {};
+
+template <>
+struct printf_arg<std::string_view> {
+		constexpr static auto spec = std::string_view{"%.*s"};
+		constexpr static auto pass(std::string_view value) {
+			return std::tuple{static_cast<int>(value.size()), value.data()};
+		}
+};
+
+template <>
+struct printf_arg<std::string> : printf_arg<std::string_view> {};
+
+template <>
+struct printf_arg<const void*> {
+		constexpr static auto spec = std::string_view{"%p"};
+		constexpr static auto pass(const void* value) { return std::tuple{value}; }
+};
+
+template <>
+struct printf_arg<void*> : printf_arg<const void*> {};
+
+template <>
+struct printf_arg<std::nullptr_t> {
+		constexpr static auto spec = std::string_view{"%p"};
+		constexpr static auto pass(std::nullptr_t /*value*/) { return std::tuple{static_cast<const void*>(nullptr)}; }
+};
+
+// Checks the format string against the argument types and rewrites `{}` replacement fields into
+// printf conversion specifiers, all at compile time. Only plain `{}` fields are supported --
+// `{0}`-style indices and `{:..}` format specifiers are rejected.
+export template <class... Args>
+class basic_format_string {
+	public:
+		// NOLINTNEXTLINE(modernize-avoid-c-arrays)
+		template <std::size_t Size>
+		consteval basic_format_string(const char (&format)[ Size ]) {
+			auto out = string_.begin();
+			auto put = [ & ](char character) {
+				if (out == string_.end() - 1) {
+					throw std::format_error{"format string exceeds polyfill capacity"};
+				}
+				*out++ = character;
+			};
+			auto emit = [ & ](std::string_view string) {
+				for (auto character : string) {
+					put(character);
+				}
+			};
+			constexpr auto specs = std::array<std::string_view, sizeof...(Args)>{printf_arg<std::decay_t<Args>>::spec...};
+			std::size_t argument = 0;
+			auto view = std::string_view{format, Size - 1};
+			for (auto it = view.begin(); it != view.end(); ++it) {
+				switch (*it) {
+					case '{':
+						if (++it == view.end()) {
+							throw std::format_error{"unmatched '{' in format string"};
+						} else if (*it == '{') {
+							put('{');
+						} else if (*it == '}') {
+							if (argument == specs.size()) {
+								throw std::format_error{"too few arguments for format string"};
+							}
+							emit(specs[ argument++ ]);
+						} else {
+							throw std::format_error{"format specifiers are not supported by the `util::format` polyfill"};
+						}
+						break;
+					case '}':
+						if (++it == view.end() || *it != '}') {
+							throw std::format_error{"unmatched '}' in format string"};
+						}
+						put('}');
+						break;
+					case '%':
+						emit("%%");
+						break;
+					default:
+						put(*it);
+				}
+			}
+		}
+
+		[[nodiscard]] constexpr auto get() const -> const char* { return string_.data(); }
+
+	private:
+		std::array<char, 256> string_{};
+};
+
+export template <class... Args>
+using format_string = basic_format_string<std::type_identity_t<Args>...>;
+
+export template <class... Args>
+[[nodiscard]] auto format(format_string<Args...> format, Args&&... args) -> std::string {
+	return std::apply(
+		[ & ](auto... values) -> std::string {
+			auto length = std::max(0, std::snprintf(nullptr, 0, format.get(), values...));
+			auto result = std::string{};
+			result.resize(static_cast<std::size_t>(length));
+			std::snprintf(result.data(), result.size() + 1, format.get(), values...);
+			return result;
+		},
+		std::tuple_cat(printf_arg<std::decay_t<Args>>::pass(args)...)
+	);
+}
+
+#else
+
+export template <class... Args>
+using format_string = std::format_string<Args...>;
+
+export template <class... Args>
+[[nodiscard]] auto format(std::format_string<std::type_identity_t<Args>...> format, Args&&... args) -> std::string {
+	return std::format(format, std::forward<Args>(args)...);
+}
+
+#endif
+
+} // namespace util

package/platform/lockable.cc

@@ -230,15 +230,15 @@ struct lockable_traits {
 };
 
 template <class Resource, lockable_traits Traits = {}>
-constexpr auto make_lockable_traits = []() consteval {
-	using mutex_type = type_t<[]() {
+constexpr auto make_lockable_traits = [] consteval {
+	using mutex_type = type_t<[] {
 		if constexpr (Traits.shared) {
 			return type<std::shared_mutex>;
 		} else {
 			return type<std::mutex>;
 		}
 	}()>;
-	using cv_type = type_t<[]() {
+	using cv_type = type_t<[] {
 		if constexpr (Traits.interuptable) {
 			return type<std::condition_variable_any>;
 		} else if constexpr (Traits.notifiable) {

package/platform/stop_token.cc

@@ -45,7 +45,7 @@ class composite_stop_token : private std::stop_source, public std::stop_token {
 		template <class Source, class... Tokens>
 		explicit composite_stop_token(Source&& source, int stoppable, Tokens&&... tokens) :
 				std::stop_source{std::forward<Source>(source)},
-				std::stop_token{util::elide{[ & ]() -> std::stop_token {
+				std::stop_token{util::elide{[ & ] -> std::stop_token {
 					switch (stoppable) {
 						// No `stop_token`
 						case 0: return std::stop_token{};
@@ -53,7 +53,7 @@ class composite_stop_token : private std::stop_source, public std::stop_token {
 						case 1:
 							{
 								constexpr auto fold = util::overloaded{
-									[]() -> std::stop_token { std::unreachable(); },
+									[] -> std::stop_token { std::unreachable(); },
 									[](auto&& token) -> std::stop_token { return std::forward<decltype(token)>(token); },
 									[](this auto& fold, auto&& token, auto&&... tokens) -> std::stop_token {
 										if (token.stop_possible()) {
@@ -69,7 +69,7 @@ class composite_stop_token : private std::stop_source, public std::stop_token {
 						default: return std::stop_source::get_token();
 					}
 				}}},
-				callbacks_{[ & ]() -> callback_pack_type {
+				callbacks_{[ & ] -> callback_pack_type {
 					switch (stoppable) {
 						// No-op callback pack
 						case 0:

package/platform/timer.cc

@@ -63,7 +63,7 @@ auto timer_thread::loop(std::stop_token stop_token) -> void {
 	auto lock = requests_.write_waitable(std::not_fn(&request_queue_type::empty));
 	while (!stop_token.stop_requested()) {
 		// wait for requests or timeout
-		const auto has_requests = [ & ]() -> bool {
+		const auto has_requests = [ & ] -> bool {
 			if (timers_.empty()) {
 				return lock.wait(stop_token);
 			} else {
@@ -120,7 +120,7 @@ auto timer_thread::dispatch(Invocable invocable, auto&&... args) {
 		result = implementation(queue);
 	};
 	dispatch(request_type{request});
-	return *std::move(result).value_or(util::elide{[]() -> result_type {
+	return *std::move(result).value_or(util::elide{[] -> result_type {
 		std::unreachable();
 	}});
 }

package/type_traits/type_pack.cc

@@ -42,13 +42,10 @@ struct type_pack : std::type_identity<type_pack<Types...>> {
 		[[nodiscard]] consteval auto at(auto index) const { return get<index>(); }
 
 		// Structured binding accessor
-		// Explicit return type causes error:
-		// "candidate template ignored: substitution failure [with Index = 0]: invalid index 0 for pack 'Types' of size 0"
-		// ...even with `requires(Index < sizeof...(Types))` on the template and/or signature
 		template <std::size_t Index>
-		[[nodiscard]] consteval auto get() const /* -> std::type_identity<Types... [ Index ]> */ {
-			// return {};
-			return type<Types...[ Index ]>;
+		// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=126796
+		[[nodiscard]] consteval auto get() const -> auto {
+			return type_of<hidden_t<Types... [ Index ]>>{};
 		}
 
 		// Find the index of the given type, or `size()` if not found

package/type_traits/type_traits.cc

@@ -27,12 +27,12 @@ struct safe_numeric_conversion {
 export template <class From, class To>
 constexpr auto safe_numeric_conversion_v = safe_numeric_conversion<From, To>::value;
 
-static_assert(safe_numeric_conversion<std::int32_t, std::int64_t>::value);
-static_assert(!safe_numeric_conversion<std::int32_t, std::uint64_t>::value);
-static_assert(!safe_numeric_conversion<std::int64_t, double>::value);
-static_assert(safe_numeric_conversion<std::int32_t, double>::value);
-static_assert(safe_numeric_conversion<float, double>::value);
-static_assert(!safe_numeric_conversion<double, float>::value);
+static_assert(safe_numeric_conversion_v<std::int32_t, std::int64_t>);
+static_assert(!safe_numeric_conversion_v<std::int32_t, std::uint64_t>);
+static_assert(!safe_numeric_conversion_v<std::int64_t, double>);
+static_assert(safe_numeric_conversion_v<std::int32_t, double>);
+static_assert(safe_numeric_conversion_v<float, double>);
+static_assert(!safe_numeric_conversion_v<double, float>);
 
 // Resolves to the type of every type in the pack. If any type differs then it is ill-formed.
 template <class... Type>

package/utility/array.cc

@@ -0,0 +1,40 @@
+export module util:utility.array;
+import std;
+
+namespace util {
+
+// Array value which can be destructured in constexpr
+export template <class Type, std::size_t Size>
+struct constexpr_array {
+		constexpr auto begin() -> Type* { return values; }
+		// NOLINTNEXTLINE(modernize-avoid-c-arrays)
+		Type values[ Size ];
+};
+
+template <class Type>
+struct constexpr_array<Type, 0> {
+		constexpr auto begin() -> Type* { return nullptr; }
+};
+
+template <class... Types>
+constexpr_array(Types...) -> constexpr_array<Types...[ 0 ], sizeof...(Types)>;
+
+export template <std::size_t Index, class Type, std::size_t Size>
+constexpr auto get(const constexpr_array<Type, Size>& array) -> Type {
+	return array.values[ Index ];
+}
+
+} // namespace util
+
+namespace std {
+// `util::constexpr_array` destructuring specializations
+template <std::size_t Index, class Type, std::size_t Size>
+struct tuple_element<Index, util::constexpr_array<Type, Size>> {
+		using type = Type;
+};
+
+template <class Type, std::size_t Size>
+struct tuple_size<util::constexpr_array<Type, Size>> {
+		constexpr static auto value = Size;
+};
+} // namespace std

package/utility/sequence.cc

@@ -1,22 +1,29 @@
 export module util:utility.sequence;
+import :utility.array;
+import :utility.constant_wrapper;
 import std;
 
 namespace util {
 
-// Return a sequence of index constants
+// Return a sequence of `std::integral_constant`.
+// Keep an eye on P1789 and then replace with `std::index_sequence_for`.
 export template <std::size_t Size>
-constexpr auto sequence = []() consteval -> auto {
-	// With C++26 P2686 we can do constexpr decomposition. So instead of the `tuple` of
-	// `integral_constants` it can be an array of `std::size_t`.
-	// https://clang.llvm.org/cxx_status.html
-
-	// std::array<std::size_t, Size> result{};
-	// std::ranges::copy(std::ranges::views::iota(std::size_t{0}, Size), result.begin());
-	// return result;
-
+constexpr auto sequence_cw = [] consteval -> auto {
 	return []<std::size_t... Index>(std::index_sequence<Index...> /*sequence*/) consteval {
-		return std::tuple{std::integral_constant<std::size_t, Index>{}...};
+		return std::tuple{util::cw<Index>...};
 	}(std::make_index_sequence<Size>());
 }();
 
+// Return a sequence of constexpr indices
+export template <std::size_t Size>
+constexpr auto sequence = [] consteval -> auto {
+#if defined(__clang__)
+	return sequence_cw<Size>;
+#else
+	constexpr_array<std::size_t, Size> result{};
+	std::ranges::copy(std::ranges::views::iota(std::size_t{0}, Size), result.begin());
+	return result;
+#endif
+}();
+
 } // namespace util

package/utility/string.cc

@@ -23,14 +23,14 @@ consteval auto make_consteval_string_view(constant_wrapper<Value> /*cw*/) -> std
 export template <auto... Strings>
 consteval auto consteval_strcat(constant_wrapper<Strings>... /*strings*/) {
 	using char_type = identical_type_t<std::remove_extent_t<typename constant_wrapper<Strings>::value_type>...>;
-	constexpr auto chars = [ & ]() -> auto {
+	constexpr auto chars = [ & ] -> auto {
 		constexpr auto size = (... + (std::extent_v<typename constant_wrapper<Strings>::value_type> - 1));
 		std::array<char_type, size + 1> chars{};
 		std::size_t offset = 0;
 		(..., (std::ranges::copy(Strings.value, chars.data() + offset), offset += std::extent_v<typename constant_wrapper<Strings>::value_type> - 1));
 		return chars;
 	}();
-	auto [... indices ] = sequence<chars.size()>;
+	constexpr auto [... indices ] = sequence<chars.size()>;
 	constexpr char_type string[ chars.size() ] = {chars[ indices ]...};
 	return cw<string>;
 }
@@ -191,7 +191,7 @@ class codepoint_utf8_forward_view {
 		[[nodiscard]] constexpr auto eof() const -> bool { return pos_ == end_; }
 		constexpr auto read() -> char32_t {
 			// Check the expected length of the byte sequence from the leading byte's bit pattern
-			auto sequence_length = [ & ]() -> unsigned {
+			auto sequence_length = [ & ] -> unsigned {
 				auto byte0 = std::bit_cast<std::uint8_t>(*pos_);
 				if (byte0 < 0x80) {
 					return 1;
@@ -291,7 +291,7 @@ constexpr auto transcode_string(std::basic_string_view<From> from) -> std::basic
 	// before.
 	// TODO: It may be worth looking at the generated code for common cases and seeing if it needs
 	// optimization.
-	auto size = [ & ]() -> std::size_t {
+	auto size = [ & ] -> std::size_t {
 		auto size_reader = reader;
 		std::size_t size = 0;
 		while (!size_reader.eof()) {
@@ -316,8 +316,8 @@ constexpr auto transcode_string(std::basic_string_view<From> from) -> std::basic
 // NOLINTNEXTLINE(modernize-avoid-c-arrays)
 export template <class To, class From, std::size_t Extent, fixed_value<From[ Extent ]> Value>
 constexpr auto transcode_string(util::constant_wrapper<Value> /*cw*/) {
-	constexpr auto make = []() { return transcode_string<To>(std::basic_string_view{Value.value, Extent - 1}); };
-	constexpr auto chars = [ = ]() {
+	constexpr auto make = [] { return transcode_string<To>(std::basic_string_view{Value.value, Extent - 1}); };
+	constexpr auto chars = [ = ] {
 		std::array<To, make().size()> result{};
 		std::ranges::copy(make(), result.data());
 		return result;

package/utility/utility.cc

@@ -1,4 +1,5 @@
 export module util:utility;
+export import :utility.array;
 export import :utility.constant_wrapper;
 export import :utility.covariant_value;
 export import :utility.facade;

package/utility/variant.cc

@@ -9,8 +9,8 @@ export auto map_variant(auto&& variant, auto visit) {
 	constexpr auto result_from = []<class Type>(std::type_identity<Type> /*alternative*/) {
 		return type<decltype(visit)>(type<util::apply_cvref_t<decltype(variant), Type>>);
 	};
-	const auto [... alternative_types ] = util::make_type_pack(util::remove_cvref(type<decltype(variant)>));
-	const auto [... result_types ] = util::pack_unique(result_from(alternative_types)...);
+	constexpr auto [... alternative_types ] = util::make_type_pack(util::remove_cvref(type<decltype(variant)>));
+	constexpr auto [... result_types ] = util::pack_unique(result_from(alternative_types)...);
 	using result_type = std::variant<type_t<result_types>...>;
 	return std::visit(
 		[ & ](auto&& value) -> result_type {