@auto_js/utility 0.0.1 → 0.0.3

package/CMakeLists.txt

@@ -6,7 +6,6 @@ target_include_directories(utility_js PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/includ
 
 target_sources(utility_js
 	PRIVATE
-		assertions.cc
 		platform/timer.cc
 	PUBLIC FILE_SET CXX_MODULES FILES
 		_module.cc
@@ -43,3 +42,9 @@ target_sources(utility_js
 		utility/utility.cc
 		utility/variant.cc
 )
+if(CMAKE_BUILD_TYPE STREQUAL Debug)
+	target_sources(utility_js
+		PRIVATE
+			assertions.cc
+	)
+endif()

package/_module.cc

@@ -4,6 +4,7 @@ export import :container.sealed_map;
 export import :container.segmented_priority_queue;
 export import :container.tinker_queue;
 export import :functional;
+export import :functional.flat_tuple;
 export import :memory;
 export import :meta.algorithm;
 export import :platform.lockable;

package/assertions.cc

@@ -1,32 +1,30 @@
-#include <tuple> // IWYU pragma: keep
-#include <type_traits>
+import std;
 import util;
 
 constexpr auto assert_strings_equal(auto... strings) {
-	const auto [... left ] = util::sequence<sizeof...(strings)>;
-	const auto [... right ] = util::sequence<sizeof...(strings)>;
-	static_assert(
-		(([ = ]() -> bool {
-			 auto left_string = strings...[ left ];
-			 using char_type = std::remove_extent_t<typename decltype(left_string)::value_type>;
-			 // NOLINTNEXTLINE(modernize-type-traits)
-			 return ((left_string == util::interpolate_string<char_type>(strings...[ right ])) && ...);
-		 }()) &&
-		 ...)
-	);
+	const auto [... left ] = std::tuple{std::basic_string_view{strings}...};
+	const auto [... right ] = std::tuple{std::basic_string_view{strings}...};
+	(..., ([ = ](auto left) -> void {
+		 using char_type = decltype(left)::value_type;
+		 // NOLINTNEXTLINE(modernize-type-traits)
+		 if ((... || (left != util::transcode_string<char_type>(right)))) {
+			 std::unreachable();
+		 }
+	 }(left)));
 }
 
-[[maybe_unused]] constexpr auto result = []() -> int {
+static_assert([]() -> int {
 	// https://en.cppreference.com/w/cpp/language/string_literal.html
 
 	// Quick check of interpolation matrix
-	assert_strings_equal(util::cw<u8"💖">, util::cw<u"💖">, util::cw<U"💖">);
-	assert_strings_equal(util::cw<"wow">, util::cw<u8"wow">, util::cw<u"wow">, util::cw<U"wow">);
+	assert_strings_equal(u8"💖", u"💖");
+	assert_strings_equal("wow", u8"wow", u"wow", U"wow");
+	assert_strings_equal(std::basic_string_view{"\x00", 1}, std::basic_string_view{u8"\x00", 1}, std::basic_string_view{u"\x00", 1}, std::basic_string_view{U"\x00", 1});
 
 	// Unpaired utf-16 surrogates
-	constexpr auto one_high_surrogate = util::cw<u"\xd83d">;
-	static_assert(one_high_surrogate == util::interpolate_string<char16_t>(one_high_surrogate));
-	constexpr auto two_high_surrogate = util::cw<u"\xd83d\xd83d">;
-	static_assert(two_high_surrogate == util::interpolate_string<char16_t>(two_high_surrogate));
-	return 0;
-}();
+	constexpr auto one_high_surrogate = std::basic_string_view{u"\xd83d"};
+	static_assert(one_high_surrogate == util::transcode_string<char16_t>(one_high_surrogate));
+	constexpr auto two_high_surrogate = std::basic_string_view{u"\xd83d\xd83d"};
+	static_assert(two_high_surrogate == util::transcode_string<char16_t>(two_high_surrogate));
+	return true;
+}());

package/container/mutable_priority_queue.cc

@@ -1,8 +1,5 @@
-module;
-#include <concepts>
-#include <queue>
-#include <utility>
 export module util:container.mutable_priority_queue;
+import std;
 
 namespace util {
 

package/container/sealed_map.cc

@@ -1,18 +1,14 @@
 module;
-#include <algorithm>
 #include <concepts>
-#include <format>
-#include <ranges>
-#include <type_traits>
-#include <utility>
 export module util:container.sealed_map;
 import :functional;
+import std;
 
 namespace util {
 
 struct sorted_equivalent_t {};
 
-export template <class Key, class Type, size_t Size>
+export template <class Key, class Type, std::size_t Size>
 class sealed_map {
 	public:
 		using key_type = Key;
@@ -22,7 +18,7 @@ class sealed_map {
 	private:
 		// Holder for consteval'd key into the map
 		struct key_for {
-				using value_type = size_t;
+				using value_type = std::size_t;
 				constexpr key_for() :
 						index_{std::numeric_limits<value_type>::max()} {}
 				explicit constexpr key_for(auto index) :
@@ -32,7 +28,7 @@ class sealed_map {
 				explicit constexpr operator bool() const { return index_ != std::numeric_limits<value_type>::max(); }
 
 			private:
-				size_t index_;
+				std::size_t index_;
 		};
 
 		// Check for duplicates
@@ -71,9 +67,9 @@ class sealed_map {
 					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<size_t, Size>{};
-						std::ranges::copy(std::ranges::iota_view{size_t{0}, Size}, indices.begin());
-						const auto projection = [ & ](size_t ii) -> const auto& { return entries.at(ii).first; };
+						auto indices = std::array<std::size_t, Size>{};
+						std::ranges::copy(std::ranges::views::iota(std::size_t{0}, Size), indices.begin());
+						const auto projection = [ & ](std::size_t ii) -> const auto& { return entries.at(ii).first; };
 						std::ranges::sort(indices, std::less{}, projection);
 						const auto [... sorted_indices ] = indices;
 						return {value_type(std::move(entries.at(sorted_indices)))...};

package/container/segmented_priority_queue.cc

@@ -1,11 +1,5 @@
-module;
-#include <algorithm>
-#include <array>
-#include <functional>
-#include <iterator>
-#include <span>
-#include <utility>
 export module util:container.segmented_priority_queue;
+import std;
 
 namespace util {
 
@@ -25,7 +19,7 @@ class ratchet_span : public std::span<Type> {
 };
 
 // N number of queues, which tracks which ones currently may have elements
-export template <class Queue, size_t Size>
+export template <class Queue, std::size_t Size>
 class segmented_priority_queue {
 	public:
 		using container_type = Queue;
@@ -34,7 +28,7 @@ class segmented_priority_queue {
 
 		[[nodiscard]] auto containers() const -> std::span<const container_type> { return not_empty_; }
 		[[nodiscard]] auto empty() const -> bool { return std::ranges::all_of(containers(), &Queue::empty); }
-		[[nodiscard]] auto size() const -> size_t { return std::ranges::fold_left(containers(), 0UZ, std::plus{}, &Queue::size); }
+		[[nodiscard]] auto size() const -> std::size_t { return std::ranges::fold_left(containers(), 0UZ, std::plus{}, &Queue::size); }
 		auto at(unsigned priority) -> container_type&;
 		auto at(unsigned priority) const -> const container_type& { return queues_.at(priority); }
 		auto containers() -> std::span<container_type> { return not_empty_; }
@@ -79,7 +73,7 @@ auto ratchet_span<Type>::make_iterator(auto it) -> iterator {
 }
 
 // `segmented_priority_queue`
-template <class Queue, size_t Size>
+template <class Queue, std::size_t Size>
 auto segmented_priority_queue<Queue, Size>::at(unsigned priority) -> container_type& {
 	// We don't know what you're about to do with it, so assume that it will gain an element
 	auto& queue = queues_.at(priority);
@@ -87,7 +81,7 @@ auto segmented_priority_queue<Queue, Size>::at(unsigned priority) -> container_t
 	return queue;
 }
 
-template <class Queue, size_t Size>
+template <class Queue, std::size_t Size>
 auto segmented_priority_queue<Queue, Size>::pop() -> void {
 	for (auto& queue : not_empty_) {
 		if (queue.empty()) {

package/container/tinker_queue.cc

@@ -1,10 +1,7 @@
 module;
-#include <algorithm>
 #include <cassert>
-#include <concepts>
-#include <deque>
-#include <utility>
 export module util:container.tinker_queue;
+import std;
 
 namespace util {
 
@@ -19,7 +16,7 @@ class tinker_queue {
 		using value_type = Value;
 
 		[[nodiscard]] auto empty() const -> bool { return size() == 0; }
-		[[nodiscard]] auto size() const -> size_t { return queue_.size() - empty_middle_values_; }
+		[[nodiscard]] auto size() const -> std::size_t { return queue_.size() - empty_middle_values_; }
 		// nb: You don't want a `clear` method here because you want tasks to be destroyed in the order
 		// they were added
 		auto emplace(auto&&... args) -> void;
@@ -29,7 +26,7 @@ class tinker_queue {
 
 	private:
 		container_type queue_;
-		size_t empty_middle_values_{};
+		std::size_t empty_middle_values_{};
 };
 
 // ---

package/functional/bind.cc

@@ -1,11 +1,9 @@
 module;
 #include "auto_js/no_unique_address.h"
-#include <type_traits>
-#include <utility>
 export module util:functional.bind;
 import :functional.flat_tuple;
-import :type_traits;
 import :utility;
+import std;
 
 namespace util {
 
@@ -83,7 +81,7 @@ class bind_explicit<Invocable, auto(Args...) noexcept(Nx)->Result, Bound...> : p
 
 		using try_cvref_type = apply_cvref_t<ensure_reference_t<invocable_type_t<Invocable>>, Invocable>;
 		using cvref_type =
-			std::conditional_t<std::is_invocable_v<try_cvref_type, apply_cvref_t<try_cvref_type, Bound>...>, try_cvref_type, bind_explicit&>;
+			std::conditional_t<std::is_invocable_v<try_cvref_type, apply_cvref_t<try_cvref_type, Bound>..., Args...>, try_cvref_type, bind_explicit&>;
 		using this_type = apply_cvref_t<cvref_type, bind_explicit>;
 		constexpr static auto invoke_as_mutable = std::is_same_v<this_type, bind_explicit&>;
 		constexpr static auto invoke_as_forward = !invoke_as_mutable;
@@ -148,4 +146,5 @@ template <class Invocable, class... Bound>
 class bind<Invocable, Bound...> : public bind_explicit_params_t<Invocable, Bound...> {
 		using bind_explicit_params_t<Invocable, Bound...>::bind_explicit_params_t;
 };
+
 } // namespace util

package/functional/elide.cc

@@ -1,9 +1,7 @@
 module;
 #include "auto_js/no_unique_address.h"
-#include <concepts>
-#include <tuple>
-#include <utility>
 export module util:functional.elide;
+import std;
 
 namespace util {
 

package/functional/flat_tuple.cc

@@ -1,8 +1,7 @@
 module;
 #include "auto_js/no_unique_address.h"
-#include <type_traits>
-#include <utility>
 export module util:functional.flat_tuple;
+import std;
 
 namespace util {
 

package/functional/function_constant.cc

@@ -1,8 +1,6 @@
-module;
-#include <concepts>
-#include <utility>
 export module util:functional.function_constant;
 import :type_traits;
+import std;
 
 namespace util {
 

package/functional/function_ref.cc

@@ -1,10 +1,7 @@
-module;
-#include <concepts>
-#include <type_traits>
-#include <utility>
 export module util:functional.function_ref;
 import :functional.elide;
 import :type_traits;
+import std;
 
 namespace util {
 
@@ -27,7 +24,11 @@ class function_ref<auto(Args...) noexcept(Nx)->Result> {
 
 		// NOLINTNEXTLINE(google-explicit-constructor)
 		constexpr function_ref(signature_type* function) :
-				function_ref{std::type_identity<signature_type>{}, static_cast<void*>(function)} {}
+				invoke_{[](void* ptr, Args... args) noexcept(Nx) -> Result {
+					auto& fn = *reinterpret_cast<signature_type*>(ptr);
+					return fn(std::forward<Args>(args)...);
+				}},
+				ptr_{reinterpret_cast<void*>(function)} {}
 
 		template <std::invocable<Args...> Object>
 			requires(type<Object> != type<function_ref>)
@@ -54,6 +55,17 @@ class function_ref<auto(Args...) noexcept(Nx)->Result> {
 				// NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
 				ptr_{const_cast<void*>(static_cast<const void*>(&bound))} {}
 
+		template <class Object, std::invocable<Object*, Args...> Function>
+			requires std::is_empty_v<Function>
+		constexpr explicit function_ref(Function /*function*/, Object* bound) :
+				invoke_{[](void* ptr, Args... args) noexcept(Nx) -> Result {
+					auto* object = static_cast<Object*>(ptr);
+					constexpr auto function = Function{};
+					return function(object, std::forward<Args>(args)...);
+				}},
+				// NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
+				ptr_{const_cast<void*>(static_cast<const void*>(bound))} {}
+
 		constexpr auto operator()(Args... args) const noexcept(Nx) -> Result {
 			return invoke_(ptr_, std::forward<Args>(args)...);
 		}
@@ -65,4 +77,19 @@ class function_ref<auto(Args...) noexcept(Nx)->Result> {
 		void* ptr_;
 };
 
+// Deduction guide helper for bound object ref
+template <class Signature>
+struct function_ref_deduction_guide;
+
+template <class Result, bool Nx, class Object, class... Args>
+struct function_ref_deduction_guide<auto(Object, Args...) noexcept(Nx)->Result>
+		: std::type_identity<auto(Args...) noexcept(Nx)->Result> {};
+
+export template <class Function>
+function_ref(Function, auto&&)
+	-> function_ref<typename function_ref_deduction_guide<function_signature_t<Function>>::type>;
+
+export template <class Function>
+function_ref(Function) -> function_ref<function_signature_t<Function>>;
+
 } // namespace util

package/functional/functional.cc

@@ -1,13 +1,10 @@
-module;
-#include <functional>
-#include <utility>
 export module util:functional;
 export import :functional.bind;
 export import :functional.elide;
 export import :functional.function_constant;
 export import :functional.function_ref;
 export import :functional.regular_return;
-import :type_traits;
+import std;
 
 namespace util {
 

package/functional/regular_return.cc

@@ -1,8 +1,6 @@
-module;
-#include <utility>
 export module util:functional.regular_return;
-import :type_traits;
 import :utility;
+import std;
 
 namespace util {
 

package/include/auto_js/export_tag.h

@@ -0,0 +1,17 @@
+#if EXPORT_IS_EXPORT
+
+#if _WIN64
+#define EXPORT __declspec(dllexport)
+#else
+#define EXPORT __attribute__((visibility("default")))
+#endif
+
+#else
+
+#if _WIN64
+#define EXPORT __declspec(dllimport)
+#else
+#define EXPORT
+#endif
+
+#endif

package/include/auto_js/gcc_abi_tag.h

@@ -0,0 +1,6 @@
+#if __GNUC__ > 14
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=124957
+#define GCC_ABI_TAG [[gnu::abi_tag("cxx11")]]
+#else
+#define GCC_ABI_TAG
+#endif

package/memory/autorelease_pool.cc

@@ -1,13 +1,10 @@
 module;
 #include "auto_js/no_unique_address.h"
-#include <algorithm>
 #include <cassert>
-#include <memory>
-#include <utility>
-#include <vector>
 export module util:memory.autorelease_pool;
 import :memory.comparator;
 import :utility;
+import std;
 
 namespace util {
 

package/memory/comparator.cc

@@ -1,6 +1,5 @@
-module;
-#include <memory>
 export module util:memory.comparator;
+import std;
 
 namespace util {
 

package/memory/memory.cc

@@ -1,12 +1,8 @@
-module;
-#include <concepts>
-#include <functional>
-#include <memory>
-#include <type_traits>
 export module util:memory;
 export import :memory.autorelease_pool;
 export import :memory.comparator;
 export import :memory.noinit_allocator;
+import std;
 
 namespace util {
 

package/memory/noinit_allocator.cc

@@ -1,10 +1,7 @@
 module;
 #include "auto_js/no_unique_address.h"
-#include <concepts>
-#include <memory>
-#include <type_traits>
-#include <utility>
 export module util:memory.noinit_allocator;
+import std;
 
 namespace util {
 

package/meta/algorithm.cc

@@ -1,8 +1,6 @@
-module;
-#include <type_traits>
 export module util:meta.algorithm;
 import :functional;
-import :utility;
+import std;
 
 namespace util {
 
@@ -10,11 +8,20 @@ namespace util {
 export constexpr auto make_type_pack = util::overloaded{
 	// nb: Prevent `make_type_pack{type_pack_of{...}}` from turning into a mess of hidden types
 	[]<class... Types>(type_pack_of<Types...> pack) consteval -> auto { return pack; },
-	[]<template <class> class Pack, class... Types>(std::type_identity<Pack<Types...>> /*type*/) consteval -> auto {
+	[]<template <class...> class Pack, class... Types>(std::type_identity<Pack<Types...>> /*type*/) consteval -> auto {
 		return type_pack_of{type<Types>...};
 	},
 };
 
+// Resolves a `Something<T...>` from `SomethingElse<T...>`
+export template <template <class...> class Into>
+constexpr auto spread_type_pack = util::overloaded{
+	[]<class... Hidden>(type_pack_of<Hidden...> /*pack*/) consteval -> auto { return type<Into<typename Hidden::type...>>; },
+	[]<template <class...> class Pack, class... Types>(std::type_identity<Pack<Types...>> /*type*/) consteval -> auto {
+		return type<Into<Types...>>;
+	},
+};
+
 // Concatenate 0..N `util::type_packs` together
 export constexpr auto pack_concat = util::overloaded{
 	[]() consteval -> auto { return type_pack{}; },

package/package.json

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

package/platform/lockable.cc

@@ -1,17 +1,9 @@
 module;
 #include "auto_js/no_unique_address.h"
 #include <cassert>
-#include <concepts>
-#include <condition_variable>
-#include <functional>
-#include <mutex>
-#include <shared_mutex>
-#include <stop_token>
-#include <utility>
-#include <variant>
 export module util:platform.lockable;
-import :type_traits;
 import :utility;
+import std;
 
 namespace util {
 
@@ -237,8 +229,8 @@ struct lockable_traits {
 		bool shared{};
 };
 
-export template <class Resource, lockable_traits Traits = {}>
-using lockable_with = type_t<[]() consteval {
+template <class Resource, lockable_traits Traits = {}>
+constexpr auto make_lockable_traits = []() consteval {
 	using mutex_type = type_t<[]() {
 		if constexpr (Traits.shared) {
 			return type<std::shared_mutex>;
@@ -256,6 +248,9 @@ using lockable_with = type_t<[]() consteval {
 		}
 	}()>;
 	return type<lockable<Resource, mutex_type, cv_type>>;
-}()>;
+};
+export template <class Resource, lockable_traits Traits = {}>
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=124953
+using lockable_with = decltype(make_lockable_traits<Resource, Traits>())::type;
 
 } // namespace util

package/platform/stop_token.cc

@@ -1,25 +1,24 @@
-module;
-#include <stop_token>
-#include <utility>
 export module util:platform.stop_token;
 import :functional;
-import :utility;
+import std;
 
 namespace util {
 
 // Combine multiple `std::stop_token`s into one `std::stop_token` that is stopped when any of the
 // source tokens is stopped.
-export template <size_t Size>
+export template <std::size_t Size>
 class composite_stop_token : private std::stop_source, public std::stop_token {
 	private:
-		static auto make_callback(std::stop_source stop_source) {
-			// I wonder what's better: copying the stop state into each callback, or using function
-			// pointer..
-			return [ stop_source = std::move(stop_source) ]() mutable -> void { stop_source.request_stop(); };
-		}
+		class bound_stop_callback {
+			public:
+				explicit bound_stop_callback(std::stop_source source) : stop_source_{std::move(source)} {}
+				auto operator()() { stop_source_.request_stop(); }
 
-		using callback_type = decltype(make_callback(std::declval<std::stop_source>()));
-		using stop_callback_type = std::stop_callback<callback_type>;
+			private:
+				std::stop_source stop_source_;
+		};
+
+		using stop_callback_type = std::stop_callback<bound_stop_callback>;
 		using callback_pack_type = std::array<stop_callback_type, Size>;
 
 	public:
@@ -76,13 +75,13 @@ class composite_stop_token : private std::stop_source, public std::stop_token {
 						case 0:
 						case 1:
 							{
-								auto callback = make_callback(std::stop_source{});
+								auto callback = bound_stop_callback{std::stop_source{}};
 								return {stop_callback_type{(util::unused(tokens), std::stop_token{}), callback}...};
 							}
 						// Make callback pack
 						default:
 							{
-								auto callback = make_callback(std::move(static_cast<std::stop_source&>(*this)));
+								auto callback = bound_stop_callback{std::move(static_cast<std::stop_source&>(*this))};
 								return {stop_callback_type{std::forward<decltype(tokens)>(tokens), callback}...};
 							}
 					}

package/platform/timer.cc

@@ -1,18 +1,8 @@
-module;
-#include <algorithm>
-#include <array>
-#include <chrono>
-#include <functional>
-#include <memory>
-#include <ranges>
-#include <stop_token>
-#include <thread>
-#include <utility>
-#include <vector>
 module util;
 import :functional;
 import :platform.lockable;
 import :platform.timer;
+import std;
 
 namespace util {
 

package/platform/timer.h.cc

@@ -1,8 +1,5 @@
-module;
-#include <chrono>
-#include <memory>
-#include <stop_token>
 export module util:platform.timer;
+import std;
 
 namespace util {
 

package/type_traits/function_traits.cc

@@ -1,8 +1,6 @@
-module;
-#include <concepts>
-#include <type_traits>
 export module util:type_traits.function_traits;
 import :type_traits.transform;
+import std;
 
 namespace util {
 

package/type_traits/transform.cc

@@ -1,6 +1,5 @@
-module;
-#include <type_traits>
 export module util:type_traits.transform;
+import std;
 
 namespace util {
 

package/type_traits/type_of.cc

@@ -1,6 +1,5 @@
-module;
-#include <type_traits>
 export module util:type_traits.type_of;
+import std;
 
 namespace util {
 

package/type_traits/type_pack.cc

@@ -1,8 +1,6 @@
-module;
-#include <tuple>
-#include <type_traits>
 export module util:type_traits.type_pack;
 import :type_traits.type_of;
+import std;
 
 namespace util {
 

package/utility/constant_wrapper.cc

@@ -1,6 +1,5 @@
-module;
-#include <algorithm>
 export module util:utility.constant_wrapper;
+import std;
 
 // Lifted from P2781R8:
 // https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r8.html

package/utility/covariant_value.cc

@@ -1,9 +1,7 @@
-module;
-#include <utility>
-#include <variant>
 export module util:utility.covariant_value;
-import :utility.facade;
 import :type_traits;
+import :utility.facade;
+import std;
 
 namespace util {
 
@@ -17,7 +15,7 @@ class covariant_value : public pointer_facade {
 		constexpr explicit covariant_value(Derived value) :
 				value_{std::move(value)} {}
 
-		constexpr auto operator*(this auto& self) -> auto& {
+		constexpr auto operator*(this auto& self) noexcept -> auto& {
 			using reference_type = util::apply_cvref_t<decltype(self), Type>;
 			if (self.value_.index() == std::variant_npos) {
 				std::unreachable();

package/utility/facade.cc

@@ -1,35 +1,39 @@
-module;
-#include <memory>
-#include <type_traits>
-#include <utility>
 export module util:utility.facade;
+import std;
 
 namespace util {
 
-// Internal addition facade
-template <class difference_type_>
-class addition_facade {
+// Implements `Type++` via `++Type`
+export class incrementable_facade {
 	public:
-		using difference_type = difference_type_;
-
-		// ++Type
-		auto operator++(this auto& self) -> auto& { return self += 1; }
+		using difference_type = int;
 
 		// Type++
-		auto operator++(this auto& self, int) {
+		constexpr auto operator++(this auto& self, int) {
 			auto result = self;
 			++self;
 			return result;
 		}
+};
+
+// Implements addition operators via `operator+=()`
+export template <class difference_type_>
+class addition_facade : public incrementable_facade {
+	public:
+		using incrementable_facade::operator++;
+		using difference_type = difference_type_;
+
+		// ++Type
+		constexpr auto operator++(this auto& self) -> auto& { return self += 1; }
 
 		// Type + difference_type
-		auto operator+(this const auto& self, difference_type offset) {
+		constexpr auto operator+(this const auto& self, difference_type offset) {
 			auto result = self;
 			return result += offset;
 		}
 
 		// difference_type + Type
-		friend auto operator+(difference_type left, const auto& right) {
+		constexpr friend auto operator+(difference_type left, const auto& right) {
 			return right + left;
 		}
 };
@@ -50,26 +54,26 @@ class subtraction_facade<difference_type_, wide_size_type> {
 		using difference_type = difference_type_;
 
 		// Type -= difference_type
-		auto operator-=(this auto& self, difference_type offset) -> auto& { return self += -offset; }
+		constexpr auto operator-=(this auto& self, difference_type offset) -> auto& { return self += -offset; }
 
 		// --Type
-		auto operator--(this auto& self) -> auto& { return self -= 1; }
+		constexpr auto operator--(this auto& self) -> auto& { return self -= 1; }
 
 		// Type--
-		auto operator--(this auto& self, int) {
+		constexpr auto operator--(this auto& self, int) {
 			auto result = self;
 			--self;
 			return result;
 		}
 
 		// Type - difference_type
-		auto operator-(this const auto& self, difference_type offset) {
+		constexpr auto operator-(this const auto& self, difference_type offset) {
 			auto result = self;
 			return result -= offset;
 		}
 
 		// Type - Type
-		auto operator-(this const auto& self, decltype(self) right) -> difference_type {
+		constexpr auto operator-(this const auto& self, decltype(self) right) -> difference_type {
 			return static_cast<difference_type>(wide_size_type{+self} - wide_size_type{+right});
 		}
 };
@@ -100,7 +104,7 @@ class arithmetic_facade
 export template <class difference_type>
 class array_facade {
 	public:
-		auto operator[](this auto&& self, difference_type offset) -> decltype(auto) {
+		constexpr auto operator[](this auto&& self, difference_type offset) -> decltype(auto) {
 			return *(std::forward<decltype(self)>(self) + offset);
 		}
 };

package/utility/hash.cc

@@ -1,20 +1,15 @@
-module;
-#include <array>
-#include <bit>
-#include <cstdint>
-#include <source_location>
-#include <string_view>
 export module util:utility.hash;
+import std;
 
 namespace util {
 
 // `constexpr` hash for property lookup
 export template <class Char>
-constexpr auto fnv1a_hash(std::basic_string_view<Char> view) -> uint32_t {
-	constexpr uint32_t prime = 0x100'0193;
-	uint32_t hash = 0x811c'9dc5;
+constexpr auto fnv1a_hash(std::basic_string_view<Char> view) -> std::uint32_t {
+	constexpr std::uint32_t prime = 0x100'0193;
+	std::uint32_t hash = 0x811c'9dc5;
 	for (auto character : view) {
-		auto bytes = std::bit_cast<std::array<uint8_t, sizeof(Char)>>(character);
+		auto bytes = std::bit_cast<std::array<std::uint8_t, sizeof(Char)>>(character);
 		for (auto byte : bytes) {
 			hash = hash ^ byte;
 			hash *= prime;
@@ -25,8 +20,8 @@ constexpr auto fnv1a_hash(std::basic_string_view<Char> view) -> uint32_t {
 
 // constexpr `typeid(Type).hash_code()` replacement
 template <class Type>
-consteval auto make_type_hash() -> uint32_t {
-	// "uint32_t make_type_hash() [Type = int]"
+consteval auto make_type_hash() -> std::uint32_t {
+	// "std::uint32_t make_type_hash() [Type = int]"
 	constexpr auto name = std::source_location::current().function_name();
 	return fnv1a_hash(std::string_view{name});
 }

package/utility/ranges.cc

@@ -52,4 +52,15 @@ export constexpr auto into_range(meta_range auto&& range) {
 	return std::forward<decltype(range)>(range).into_range();
 }
 
+// Returns either a `std::tuple<size_type>` with the range's size, or `std::tuple<>` if it can't be
+// determined in constant time.
+export template <class Type>
+constexpr auto maybe_range_size(const Type& range) {
+	if constexpr (std::ranges::sized_range<Type>) {
+		return std::tuple{std::ranges::size(range)};
+	} else {
+		return std::tuple{};
+	}
+}
+
 } // namespace util

package/utility/string.cc

@@ -1,29 +1,20 @@
-module;
-#include <algorithm>
-#include <array>
-#include <bit>
-#include <cstdint>
-#include <limits>
-#include <stdexcept>
-#include <string>
-#include <utility>
 export module util:utility.string;
 import :utility.constant_wrapper;
+import std;
 
 namespace util {
 
-// Helper to make `std::string_view` from a constant_wrapper or string literal
 export template <class Char, std::size_t Size>
-struct consteval_string_view : public std::basic_string_view<Char> {
-		constexpr explicit consteval_string_view(const Char (&string)[ Size + 1 ]) noexcept : std::basic_string_view<Char>{string, Size} {}
-};
-
-template <class Char, std::size_t Size>
 // NOLINTNEXTLINE(modernize-avoid-c-arrays)
-consteval_string_view(const Char (&string)[ Size ]) -> consteval_string_view<Char, Size - 1>;
+consteval auto make_consteval_string_view(const Char (&string)[ Size ]) -> std::basic_string_view<Char> {
+	return std::basic_string_view{string, Size - 1};
+}
 
-template <class Char, std::size_t Extent, fixed_value<Char[ Extent ]> Value>
-consteval_string_view(util::constant_wrapper<Value>) -> consteval_string_view<Char, Extent - 1>;
+// NOLINTNEXTLINE(modernize-avoid-c-arrays)
+export template <class Char, std::size_t Size, fixed_value<Char[ Size ]> Value>
+consteval auto make_consteval_string_view(constant_wrapper<Value> /*cw*/) -> std::basic_string_view<Char> {
+	return make_consteval_string_view(constant_wrapper<Value>::value);
+}
 
 // Helper for `codepoint_char_sequence` which stores an array of the most characters it will take to
 // represent a codepoint in a given character type.
@@ -39,7 +30,7 @@ class codepoint_char_container {
 
 		[[nodiscard]] constexpr auto begin() const -> iterator { return chars_.begin(); }
 		[[nodiscard]] constexpr auto data() -> container_type& { return chars_; }
-		[[nodiscard]] constexpr auto end() const -> iterator { return std::ranges::find(chars_, 0); }
+		[[nodiscard]] constexpr auto end() const -> iterator { return std::find(std::next(chars_.begin()), chars_.end(), 0); }
 		[[nodiscard]] constexpr auto size() const -> std::size_t { return end() - begin(); }
 
 	private:
@@ -113,15 +104,8 @@ class codepoint_char_range<char16_t> : public codepoint_char_container<char16_t,
 				data()[ 1 ] = 0;
 			} else if (codepoint < 0x11'0000) {
 				auto twenty_bits = codepoint - 0x1'0000;
-				// /usr/include/c++/v1/__type_traits/promote.h:38:1: error: redefinition of '__promote_t' as different kind of symbol
-				//    38 | using __promote_t _LIBCPP_NODEBUG =
-				//       | ^
-				// /usr/include/c++/v1/__type_traits/promote.h:38:1: note: previous definition is here
-				//    38 | using __promote_t _LIBCPP_NODEBUG =
-				// nb: `twenty_bits >> 10` == `twenty_bits / 0x400`
-				data()[ 0 ] = static_cast<char16_t>((twenty_bits >> 10) + 0xd800);
-				// nb:  `twenty_bits & 0x3ff` == `twenty_bits % 0x400`
-				data()[ 1 ] = static_cast<char16_t>((twenty_bits & 0x3ff) + 0xdc00);
+				data()[ 0 ] = static_cast<char16_t>((twenty_bits / 0x400) + 0xd800);
+				data()[ 1 ] = static_cast<char16_t>((twenty_bits % 0x400) + 0xdc00);
 			} else {
 				std::unreachable();
 			}
@@ -188,7 +172,7 @@ class codepoint_utf8_forward_view {
 		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 byte0 = std::bit_cast<uint8_t>(*pos_);
+				auto byte0 = std::bit_cast<std::uint8_t>(*pos_);
 				if (byte0 < 0x80) {
 					return 1;
 				} else if (byte0 < 0xe0) {
@@ -213,7 +197,7 @@ class codepoint_utf8_forward_view {
 			std::array<Char, 4> characters{};
 			std::ranges::copy_n(pos_, sequence_length, characters.begin());
 			pos_ += sequence_length;
-			auto [ byte0, byte1, byte2, byte3 ] = std::bit_cast<std::array<uint8_t, 4>>(characters);
+			auto [ byte0, byte1, byte2, byte3 ] = std::bit_cast<std::array<std::uint8_t, 4>>(characters);
 
 			// Convert byte sequence to codepoint
 			switch (sequence_length) {
@@ -249,14 +233,14 @@ class codepoint_forward_view<char16_t> {
 
 		constexpr auto read() -> char32_t {
 			// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-			auto char0 = *pos_++;
+			auto char0 = static_cast<char32_t>(*pos_++);
 			if (char0 >= 0xd800 && char0 < 0xdc00) {
 				if (eof()) {
 					// nb: Unpaired surrogate
 					return char0;
 				}
 				// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-				auto char1 = *pos_++;
+				auto char1 = static_cast<char32_t>(*pos_++);
 				if (char1 >= 0xdc00 && char1 < 0xe000) {
 					return ((char0 - 0xd800) * 0x400) + (char1 - 0xdc00) + 0x1'0000;
 				} else {
@@ -278,7 +262,7 @@ class codepoint_forward_view<char16_t> {
 // Interpolate the given character range to a `std::basic_string<Char>`. If the requested character
 // type is too small to represent a codepoint, a `std::range_error` is thrown.
 export template <class To, class From>
-constexpr auto interpolate_string(std::basic_string_view<From> from) -> std::basic_string<To> {
+constexpr auto transcode_string(std::basic_string_view<From> from) -> std::basic_string<To> {
 	auto reader = codepoint_forward_view{from};
 	std::basic_string<To> result;
 
@@ -297,7 +281,7 @@ constexpr auto interpolate_string(std::basic_string_view<From> from) -> std::bas
 	}();
 
 	// Write string
-	result.resize_and_overwrite(size, [ & ](To* result, size_t /*length*/) -> size_t {
+	result.resize_and_overwrite(size, [ & ](To* result, std::size_t /*length*/) -> std::size_t {
 		auto first = result;
 		while (!reader.eof()) {
 			auto chunk = codepoint_char_range<To>{reader.read()};
@@ -311,14 +295,14 @@ constexpr auto interpolate_string(std::basic_string_view<From> from) -> std::bas
 
 // NOLINTNEXTLINE(modernize-avoid-c-arrays)
 export template <class To, class From, std::size_t Extent, fixed_value<From[ Extent ]> Value>
-constexpr auto interpolate_string(util::constant_wrapper<Value> /*cw*/) {
-	constexpr auto make = []() { return interpolate_string<To>(std::basic_string_view{Value.value, Extent - 1}); };
+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 = [ = ]() {
 		std::array<To, make().size()> result{};
 		std::ranges::copy(make(), result.data());
 		return result;
 	}();
-	return [ = ]<std::size_t... Indices>(std::index_sequence<Indices...>) {
+	return [ & ]<std::size_t... Indices>(std::index_sequence<Indices...>) {
 		// NOLINTNEXTLINE(modernize-avoid-c-arrays)
 		constexpr To string[ chars.size() + 1 ] = {chars[ Indices ]..., 0};
 		return util::cw<string>;

package/utility/utility.cc

@@ -1,8 +1,3 @@
-module;
-#include <concepts>
-#include <stdexcept>
-#include <string_view>
-#include <utility>
 export module util:utility;
 export import :utility.constant_wrapper;
 export import :utility.covariant_value;
@@ -11,7 +6,7 @@ export import :utility.hash;
 export import :utility.ranges;
 export import :utility.string;
 // export import :utility.variant;
-import :type_traits;
+import std;
 
 namespace util {
 
@@ -40,11 +35,11 @@ export class non_moveable {
 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 `size_t`.
+	// `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::iota_view{std::size_t{0}, Size}, result.begin());
+	// std::ranges::copy(std::ranges::views::iota(std::size_t{0}, Size), result.begin());
 	// return result;
 
 	return []<std::size_t... Index>(std::index_sequence<Index...> /*sequence*/) consteval {
@@ -89,7 +84,7 @@ class just : public pointer_facade {
 		Type value_;
 };
 
-export template <class Type>
+template <class Type>
 class just<Type&> : public pointer_facade {
 	public:
 		explicit constexpr just(Type& value) : value_{&value} {}
@@ -143,8 +138,38 @@ struct slice_t<const Type> {
 };
 
 export template <class Type>
-constexpr auto slice(Type& value) {
+constexpr auto slice(const Type& value) {
 	return slice_t<const Type>{value};
 }
 
+// Implements construction of containers with variadic elements
+template <class Type>
+struct inplace_container_constructor {
+		constexpr auto operator()(auto&&... args) const -> Type {
+			return Type{std::in_place, std::forward<decltype(args)>(args)...};
+		}
+};
+
+template <class Type, std::size_t Size>
+struct inplace_container_constructor<std::array<Type, Size>> {
+		constexpr auto operator()(auto&&... args) const -> std::array<Type, Size> {
+			return std::array<Type, Size>{std::forward<decltype(args)>(args)...};
+		}
+};
+
+template <class Type, class Alloc>
+struct inplace_container_constructor<std::vector<Type, Alloc>> {
+		constexpr auto operator()(auto&&... args) const -> std::vector<Type, Alloc> {
+			auto container = std::vector<Type, Alloc>{};
+			container.reserve(sizeof...(args));
+			(..., container.emplace_back(std::forward<decltype(args)>(args)));
+			return container;
+		}
+};
+
+export template <class Type>
+auto make_inplace_container(auto&&... args) -> Type {
+	return inplace_container_constructor<Type>{}(std::forward<decltype(args)>(args)...);
+}
+
 } // namespace util

package/utility/variant.cc

@@ -1,16 +1,13 @@
-module;
-#include <utility>
-#include <variant>
 export module util:utility.variant;
 import :meta.algorithm;
-import :type_traits;
+import std;
 
 namespace util {
 
 // Apply a visitor to a variant and map its result to a new variant type. Repeated types are collapsed.
 export auto map_variant(auto&& variant, auto visit) {
-	constexpr auto result_from = [](auto alternative) {
-		return type<decltype(visit)>(type<util::apply_cvref_t<decltype(variant), type_t<alternative>>>);
+	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)...);