@auto_js/utility 0.0.1

package/platform/timer.cc

@@ -0,0 +1,175 @@
+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;
+
+namespace util {
+
+namespace {
+util::lockable_with<std::weak_ptr<timer_thread>, {.shared = true}> shared_thread;
+}
+
+// Internal thread which manages timers
+class timer_thread : util::non_moveable {
+	public:
+		class timer;
+		using clock_type = timer_stop_token::clock_type;
+
+		timer_thread();
+		auto insert(std::stop_source stop_source, clock_type::duration timeout) -> void;
+		static auto acquire() -> std::shared_ptr<timer_thread>;
+
+	private:
+		using timer_queue_type = std::vector<timer>;
+		using request_type = util::function_ref<auto(timer_queue_type&)->void>;
+		using request_queue_type = std::vector<request_type>;
+
+		template <class Invocable>
+		auto dispatch(Invocable invocable, auto&&... args);
+
+		auto dispatch(request_type request) -> void;
+		auto loop(std::stop_token stop_token) -> void;
+
+		util::lockable_with<request_queue_type, {.interuptable = true, .shared = true}> requests_;
+		timer_queue_type timers_;
+		std::jthread thread_;
+};
+
+// Internal thread-managed timer
+class timer_thread::timer : public util::pointer_facade {
+	public:
+		explicit timer(clock_type::time_point time_point, std::stop_source&& stop_source) :
+				time_point_{time_point},
+				stop_source_{std::move(stop_source)} {}
+
+		auto operator*() & -> std::stop_source& { return stop_source_; }
+		auto operator*() const& -> const std::stop_source& { return stop_source_; }
+
+		[[nodiscard]] auto time_point() const -> clock_type::time_point { return time_point_; }
+
+	private:
+		clock_type::time_point time_point_;
+		std::stop_source stop_source_;
+};
+
+// ---
+
+// `timer_thread`
+timer_thread::timer_thread() :
+		thread_{[ & ](std::stop_token stop_token) -> void { loop(stop_token); }} {}
+
+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 {
+			if (timers_.empty()) {
+				return lock.wait(stop_token);
+			} else {
+				auto next = timers_.back().time_point();
+				return lock.wait(stop_token, next);
+			}
+		}();
+		// dispatch timer requests
+		if (has_requests) {
+			for (const auto& request : *lock) {
+				request(timers_);
+			}
+			lock->clear();
+			lock.notify_all();
+		}
+		// expire timers
+		auto now = clock_type::now();
+		auto expired_timer_view =
+			std::ranges::reverse_view{timers_} |
+			std::views::take_while([ & ](const auto& timer) {
+				return timer.time_point() <= now;
+			});
+		for (auto& timer : expired_timer_view) {
+			timer->request_stop();
+			timers_.pop_back();
+		}
+	}
+}
+
+auto timer_thread::dispatch(request_type request) -> void {
+	requests_.write_notify()->push_back(request);
+	constexpr auto cast = [](const request_type& item) -> auto {
+		return std::bit_cast<std::array<std::byte, sizeof(request_type)>>(item);
+	};
+	auto does_not_contain = [ & ](const auto& queue) -> bool {
+		return !std::ranges::contains(queue, cast(request), cast);
+	};
+	requests_.read_waitable(does_not_contain).wait();
+}
+
+template <class Invocable>
+auto timer_thread::dispatch(Invocable invocable, auto&&... args) {
+	auto implementation = util::regular_return{
+		[ invocable = std::move(invocable),
+			... args = std::forward<decltype(args)>(args) ](
+			timer_queue_type& queue
+		) mutable -> void {
+			return invocable(queue, std::forward<decltype(args)>(args)...);
+		}
+	};
+	using result_type = std::invoke_result_t<decltype(implementation), timer_queue_type&>;
+	std::optional<result_type> result;
+	auto request = [ & ](timer_queue_type& queue) -> void {
+		result = implementation(queue);
+	};
+	dispatch(request_type{request});
+	return *std::move(result).value_or(util::elide{[]() -> result_type {
+		std::unreachable();
+	}});
+}
+
+auto timer_thread::insert(std::stop_source stop_source, clock_type::duration timeout) -> void {
+	dispatch([ & ](timer_queue_type& queue) -> void {
+		auto time_point = clock_type::now() + timeout;
+		constexpr auto projection = [](const timer_thread::timer& timer) -> timer_thread::clock_type::time_point {
+			return timer.time_point();
+		};
+		auto it = std::ranges::upper_bound(queue, time_point, std::greater{}, projection);
+		queue.emplace(it, time_point, std::move(stop_source));
+	});
+}
+
+auto timer_thread::acquire() -> std::shared_ptr<timer_thread> {
+	auto acquired = shared_thread.read()->lock();
+	if (!acquired) {
+		auto lock = shared_thread.write();
+		acquired = lock->lock();
+		if (!acquired) {
+			*lock = acquired = std::make_shared<timer_thread>();
+		}
+	}
+	return acquired;
+}
+
+// `timer_stop_token`
+timer_stop_token::timer_stop_token(clock_type::duration duration) :
+		thread_{timer_thread::acquire()} {
+	thread_->insert(stop_source_, duration);
+}
+
+auto timer_stop_token::get_source() const -> const std::stop_source& {
+	return stop_source_;
+}
+
+auto timer_stop_token::get_token() const -> std::stop_token {
+	return stop_source_.get_token();
+}
+
+} // namespace util

package/platform/timer.h.cc

@@ -0,0 +1,36 @@
+module;
+#include <chrono>
+#include <memory>
+#include <stop_token>
+export module util:platform.timer;
+
+namespace util {
+
+class timer_thread;
+
+// Manages a `std::stop_token` which is stopped after a duration, using a background thread.
+export class timer_stop_token {
+	public:
+		using clock_type = std::chrono::steady_clock;
+
+		explicit timer_stop_token(clock_type::duration duration);
+
+		template <class Rep, class Period>
+		explicit timer_stop_token(std::chrono::duration<Rep, Period> duration) :
+				timer_stop_token(std::chrono::duration_cast<clock_type::duration>(duration)) {}
+
+		timer_stop_token(const timer_stop_token&) = delete;
+		timer_stop_token(timer_stop_token&&) noexcept = default;
+		~timer_stop_token() = default;
+		auto operator=(const timer_stop_token&) -> timer_stop_token& = delete;
+		auto operator=(timer_stop_token&&) -> timer_stop_token& = delete;
+
+		[[nodiscard]] auto get_source() const -> const std::stop_source&;
+		[[nodiscard]] auto get_token() const -> std::stop_token;
+
+	private:
+		std::shared_ptr<timer_thread> thread_;
+		std::stop_source stop_source_;
+};
+
+} // namespace util

package/type_traits/function_traits.cc

@@ -0,0 +1,173 @@
+module;
+#include <concepts>
+#include <type_traits>
+export module util:type_traits.function_traits;
+import :type_traits.transform;
+
+namespace util {
+
+// Apply the cvref qualifier of `From` to a function signature
+export template <class From, class Fn>
+struct apply_function_cvref;
+
+export template <class From, class Fn>
+using apply_function_cvref_t = apply_function_cvref<From, Fn>::type;
+
+// Extract the cvref qualifier of a function signature applied to `int`. For example:
+// `auto() const& -> void` == `const int&`
+export template <class Fn>
+struct extract_function_cvref;
+
+export template <class Fn>
+using extract_function_cvref_t = extract_function_cvref<Fn>::type;
+
+// Remove cvref qualifier from a function signature. Used as a requirement it approximates
+// `std::is_function`, without support for C-style variadic functions.
+export template <class Fn>
+struct remove_function_cvref;
+
+export template <class Fn>
+using remove_function_cvref_t = remove_function_cvref<Fn>::type;
+
+// Generated specializations for `apply_function_cvref`, `extract_function_cvref`, and `remove_function_cvref`
+// NOLINTBEGIN(bugprone-macro-parentheses, cppcoreguidelines-macro-usage)
+#define MAKE_CVREF(CV, REF)                                                      \
+	template <class From, class... Args, bool Nx, class Result>                    \
+	struct apply_function_cvref<CV From REF, auto(Args...) noexcept(Nx)->Result> { \
+			using type = auto(Args...) CV REF noexcept(Nx) -> Result;                  \
+	};                                                                             \
+	template <class... Args, bool Nx, class Result>                                \
+	struct extract_function_cvref<auto(Args...) CV REF noexcept(Nx)->Result> {     \
+			using type = CV int REF;                                                   \
+	};                                                                             \
+	template <class... Args, bool Nx, class Result>                                \
+	struct remove_function_cvref<auto(Args...) CV REF noexcept(Nx)->Result> {      \
+			using type = auto(Args...) noexcept(Nx) -> Result;                         \
+	};
+// NOLINTEND(bugprone-macro-parentheses, cppcoreguidelines-macro-usage)
+
+MAKE_CVREF(, )
+MAKE_CVREF(, &)
+MAKE_CVREF(, &&)
+MAKE_CVREF(const, )
+MAKE_CVREF(const, &)
+MAKE_CVREF(const, &&)
+MAKE_CVREF(volatile, )
+MAKE_CVREF(volatile, &)
+MAKE_CVREF(volatile, &&)
+MAKE_CVREF(const volatile, )
+MAKE_CVREF(const volatile, &)
+MAKE_CVREF(const volatile, &&)
+#undef MAKE_CVREF
+
+// Add the given arguments to the front of a function signature
+template <class Signature, class... Types>
+struct signature_args_push_front;
+
+template <class... Args, bool Nx, class Result, class... Types>
+struct signature_args_push_front<auto(Args...) noexcept(Nx)->Result, Types...> {
+		using type = auto(Types..., Args...) noexcept(Nx) -> Result;
+};
+
+// Given a member function pointer type, extract the required `this` object type
+template <class Function>
+struct member_invocable_type;
+
+template <class Function>
+using member_invocable_type_t = member_invocable_type<Function>::type;
+
+// Traditional member function pointer
+template <class Type, class Function>
+struct member_invocable_type<Function Type::*>
+		: ensure_reference<apply_cvref_t<extract_function_cvref_t<Function>, Type>> {};
+
+// Explicit-this member function
+template <class Type, class... Args, bool Nx, class Result>
+struct member_invocable_type<auto (*)(Type, Args...) noexcept(Nx)->Result> {
+		using type = Type;
+};
+
+// Convert a member function pointer type to a free function type, with the object type as the first
+// parameter
+template <class Type>
+struct unbound_member_function_signature;
+
+template <class Type>
+using unbound_member_function_signature_t = unbound_member_function_signature<Type>::type;
+
+// Traditional member function pointer
+template <class Type, class Function>
+struct unbound_member_function_signature<Function Type::*>
+		: signature_args_push_front<remove_function_cvref_t<Function>, member_invocable_type_t<Function Type::*>> {};
+
+// Explicit-this member function
+template <class... Args, bool Nx, class Result>
+struct unbound_member_function_signature<auto (*)(Args...) noexcept(Nx)->Result> {
+		using type = auto(Args...) noexcept(Nx) -> Result;
+};
+
+// Function signature of any invocable type
+export template <class Function>
+struct function_signature;
+
+export template <class Function>
+using function_signature_t = function_signature<Function>::type;
+
+template <class Type, class Function>
+struct function_operator_signature;
+
+// Function type. `std::decay_t` performs function-to-pointer conversion.
+template <class Function>
+	requires requires { typename remove_function_cvref_t<std::remove_pointer_t<std::decay_t<Function>>>; }
+struct function_signature<Function>
+		: remove_function_cvref<std::remove_pointer_t<std::decay_t<Function>>> {};
+
+// Struct type with `operator()` (lambda, etc)
+template <class Type>
+	requires requires { &std::remove_cvref_t<Type>::operator(); }
+struct function_signature<Type>
+		: function_operator_signature<Type, unbound_member_function_signature_t<decltype(&std::remove_cvref_t<Type>::operator())>> {};
+
+// Member function pointer
+template <class Type, class Function>
+struct function_signature<Function Type::*>
+		: unbound_member_function_signature<Function Type::*> {};
+
+// Strips the first parameter, which is the unbound object type. Also checks invocability of `Type`,
+// taking into account cvref qualifiers.
+template <class That, class... Args, std::invocable<Args...> Type, bool Nx, class Result>
+struct function_operator_signature<Type, auto(That, Args...) noexcept(Nx)->Result> {
+		using type = auto(Args...) noexcept(Nx) -> Result;
+};
+
+// Canonicalize the cvref type of an invocable. Functions are value types, invocables are whatever
+// `this` expects.
+export template <class Type>
+struct invocable_type;
+
+export template <class Type>
+using invocable_type_t = invocable_type<Type>::type;
+
+template <class Function>
+	requires requires { typename remove_function_cvref_t<std::remove_pointer_t<std::decay_t<Function>>>; }
+struct invocable_type<Function>
+		: remove_function_cvref<std::remove_pointer_t<std::decay_t<Function>>> {};
+
+template <class Type>
+	requires requires { &std::remove_cvref_t<Type>::operator(); }
+struct invocable_type<Type>
+		: member_invocable_type<decltype(&std::remove_cvref_t<Type>::operator())> {};
+
+// Result type of a function signature
+export template <class Type>
+struct signature_result;
+
+export template <class Type>
+using signature_result_t = signature_result<Type>::type;
+
+template <class... Args, bool Nx, class Result>
+struct signature_result<auto(Args...) noexcept(Nx)->Result> {
+		using type = Result;
+};
+
+} // namespace util

package/type_traits/transform.cc

@@ -0,0 +1,60 @@
+module;
+#include <type_traits>
+export module util:type_traits.transform;
+
+namespace util {
+
+// Add lvalue reference qualifier if it is not already a reference
+export template <class Type>
+struct ensure_reference;
+
+export template <class Type>
+using ensure_reference_t = ensure_reference<Type>::type;
+
+template <class Type>
+struct ensure_reference {
+		using type = Type&;
+};
+
+template <class Type>
+struct ensure_reference<Type&&> {
+		using type = Type&&;
+};
+
+// Copy cvref qualifiers of `From` to `To`
+template <class From, class To>
+struct apply_cvref_impl;
+
+export template <class From, class To>
+	requires(!(std::is_const_v<To> || std::is_volatile_v<To> || std::is_reference_v<To>))
+struct apply_cvref : apply_cvref_impl<From, To> {};
+
+export template <class From, class To>
+using apply_cvref_t = apply_cvref<From, To>::type;
+
+template <class From, class To>
+struct apply_cvref_impl : std::type_identity<To> {};
+
+// Generated specializations for `apply_ref_impl`
+// NOLINTBEGIN(bugprone-macro-parentheses, cppcoreguidelines-macro-usage)
+#define MAKE_CVREF(CV, REF)                  \
+	template <class From, class To>            \
+	struct apply_cvref_impl<CV From REF, To> { \
+			using type = CV To REF;                \
+	};                                         \
+	// NOLINTEND(bugprone-macro-parentheses, cppcoreguidelines-macro-usage)
+
+MAKE_CVREF(, &)
+MAKE_CVREF(, &&)
+MAKE_CVREF(const, )
+MAKE_CVREF(const, &)
+MAKE_CVREF(const, &&)
+MAKE_CVREF(volatile, )
+MAKE_CVREF(volatile, &)
+MAKE_CVREF(volatile, &&)
+MAKE_CVREF(const volatile, )
+MAKE_CVREF(const volatile, &)
+MAKE_CVREF(const volatile, &&)
+#undef MAKE_CVREF
+
+} // namespace util

package/type_traits/type_of.cc

@@ -0,0 +1,72 @@
+module;
+#include <type_traits>
+export module util:type_traits.type_of;
+
+namespace util {
+
+// "ADL firewall"
+// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2538r0.html#solution
+template <class Type>
+struct hidden {
+		struct of {
+				using type = Type;
+		};
+};
+
+template <class Type>
+using hidden_t = hidden<Type>::of;
+
+// Metaprogramming helper
+// nb: Intentionally not exported, it should only be used via the `type` variable template.
+template <class Hidden>
+struct type_of;
+
+} // namespace util
+
+// `util::type_of<Type>{}` alias
+export template <class Type>
+constexpr auto type = util::type_of<util::hidden_t<Type>>{};
+
+// Extract the `type` of a value metatype
+export template <auto Type>
+using type_t = decltype(Type)::type;
+
+namespace util {
+
+// `type_of`
+template <class Hidden>
+struct type_of : std::type_identity<typename Hidden::type> {
+		consteval type_of() = default;
+
+		template <class Type>
+			requires std::is_same_v<typename Type::type, typename Hidden::type>
+		explicit consteval type_of(Type /*type*/){};
+
+		// Equality operators
+		consteval auto operator==(type_of /*op*/) const -> bool { return true; }
+
+		template <class Op>
+		consteval auto operator==(type_of<Op> /*op*/) const -> bool { return false; }
+
+		template <class Op>
+		consteval auto operator==(Op /*op*/) const -> bool { return std::is_same_v<typename Hidden::type, typename Op::type>; }
+
+		// `true` represents a valid type
+		consteval explicit operator bool() const { return true; }
+
+		// Invoke result. Returns `std::false_type` if not invocable.
+		consteval auto operator()(auto... types) const {
+			if constexpr (requires { std::declval<typename Hidden::type>()(std::declval<type_t<types>>()...); }) {
+				return type<decltype(std::declval<typename Hidden::type>()(std::declval<type_t<types>>()...))>;
+			} else {
+				return std::false_type{};
+			}
+		}
+};
+
+export template <class Type>
+consteval auto remove_cvref(Type /*type*/) {
+	return type<std::remove_cvref_t<typename Type::type>>;
+}
+
+} // namespace util

package/type_traits/type_pack.cc

@@ -0,0 +1,116 @@
+module;
+#include <tuple>
+#include <type_traits>
+export module util:type_traits.type_pack;
+import :type_traits.type_of;
+
+namespace util {
+
+// Capture a pack of types into a single type
+export template <class... Types>
+struct type_pack;
+
+// Prevent `type_pack{type_pack{}}` from flattening itself via copy construction
+template <class... Types>
+type_pack(type_pack<Types...>) -> type_pack<type_pack<Types...>>;
+
+// Accept any `T::type` producing structure
+template <class... Types>
+type_pack(Types...) -> type_pack<typename Types::type...>;
+
+// ADL-safe pack (not exported)
+template <class... Hidden>
+struct type_pack_of : type_pack<typename Hidden::type...> {
+		using type_pack<typename Hidden::type...>::type_pack;
+};
+
+// Prevent `type_pack_of{type_pack_of{}}` from flattening itself via copy construction
+template <class... Types>
+type_pack_of(type_pack_of<Types...>) -> type_pack_of<hidden_t<type_pack_of<Types...>>>;
+
+// Accept any `T::type` producing structure
+template <class... Types>
+type_pack_of(Types...) -> type_pack_of<hidden_t<typename Types::type>...>;
+
+// Capture a pack of types into a single type
+export template <class... Types>
+struct type_pack : std::type_identity<type_pack<Types...>> {
+		consteval type_pack() = default;
+
+		template <class... Args>
+		explicit consteval type_pack(Args... /*types*/)
+			requires((... && (type<typename Args::type> == type<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 ]>;
+		}
+
+		// Find the index of the given type, or `size()` if not found
+		template <class Type>
+		[[nodiscard]] consteval auto find(std::type_identity<Type> subject) const -> std::size_t {
+			constexpr auto type_switch = [ = ]<std::size_t Index>(this const auto& self, std::integral_constant<std::size_t, Index> /*index*/) -> std::size_t {
+				if constexpr (Index == sizeof...(Types)) {
+					return sizeof...(Types);
+				} else if constexpr (type<Types...[ Index ]> == subject) {
+					return Index;
+				} else {
+					return self(std::integral_constant<std::size_t, Index + 1>{});
+				}
+			};
+			return type_switch(std::integral_constant<std::size_t, 0>{});
+		}
+
+		[[nodiscard]] consteval auto size() const -> std::size_t { return sizeof...(Types); }
+
+		// Concatenate two `type_pack`s (into a `type_pack_of`)
+		template <class... Right>
+		[[nodiscard]] consteval auto operator+(type_pack<Right...> /*right*/) const
+			-> type_pack_of<hidden_t<Types>..., hidden_t<Right>...> {
+			return {};
+		}
+
+		template <class... Right>
+		[[nodiscard]] consteval auto operator==(type_pack<Right...> /*right*/) const -> bool {
+			if constexpr (sizeof...(Types) == 0 && sizeof...(Right) == 0) {
+				return true;
+			} else if constexpr (sizeof...(Types) != sizeof...(Right)) {
+				return false;
+			} else {
+				return ((type<Types> == type<Right>) && ...);
+			}
+		}
+};
+
+} // namespace util
+
+namespace std {
+
+// `util::type_pack` destructuring specializations
+template <std::size_t Index, class... Types>
+struct tuple_element<Index, util::type_pack<Types...>> {
+		using type = util::type_of<util::hidden_t<Types...[ Index ]>>;
+};
+
+template <class... Types>
+struct tuple_size<util::type_pack<Types...>> {
+		constexpr static auto value = sizeof...(Types);
+};
+
+// `util::type_pack_of` destructuring specializations
+template <std::size_t Index, class... Hidden>
+struct tuple_element<Index, util::type_pack_of<Hidden...>>
+		: tuple_element<Index, util::type_pack<typename Hidden::type...>> {};
+
+template <class... Hidden>
+struct tuple_size<util::type_pack_of<Hidden...>>
+		: tuple_size<util::type_pack<typename Hidden::type...>> {};
+
+} // namespace std

package/type_traits/type_traits.cc

@@ -0,0 +1,5 @@
+export module util:type_traits;
+export import :type_traits.function_traits;
+export import :type_traits.transform;
+export import :type_traits.type_of;
+export import :type_traits.type_pack;

package/utility/constant_wrapper.cc

@@ -0,0 +1,57 @@
+module;
+#include <algorithm>
+export module util:utility.constant_wrapper;
+
+// Lifted from P2781R8:
+// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2781r8.html
+
+// NOLINTBEGIN(cppcoreguidelines-pro-bounds-array-to-pointer-decay, modernize-avoid-c-arrays)
+namespace util {
+
+template <class Type>
+struct fixed_value {
+		using type = Type;
+		// NOLINTNEXTLINE(google-explicit-constructor)
+		consteval fixed_value(type value) noexcept : value{value} {}
+		type value;
+};
+
+template <class Type, std::size_t Extent>
+struct fixed_value<Type[ Extent ]> {
+		using type = Type[ Extent ];
+		// NOLINTNEXTLINE(google-explicit-constructor)
+		consteval fixed_value(const type& init) noexcept { std::copy_n(init, Extent, value); }
+		// NOLINTNEXTLINE(cppcoreguidelines-avoid-const-or-ref-data-members)
+		type value;
+};
+
+template <class Type, std::size_t Extent>
+fixed_value(const Type (&)[ Extent ]) -> fixed_value<Type[ Extent ]>;
+
+export template <fixed_value Value>
+struct constant_wrapper;
+
+template <class Value>
+concept constexpr_param = requires { typename constant_wrapper<Value::value>; };
+
+struct cw_operators {
+		template <constexpr_param Left, constexpr_param Right>
+		constexpr friend auto operator==(Left, Right) noexcept -> constant_wrapper<(Left::value == Right::value)> { return {}; }
+};
+
+template <fixed_value Value>
+struct constant_wrapper : cw_operators {
+		using value_type = decltype(Value)::type;
+		using type = constant_wrapper;
+
+		constexpr static auto& value = Value.value;
+
+		// NOLINTNEXTLINE(google-explicit-constructor)
+		consteval operator const value_type&() const noexcept { return value; }
+};
+
+export template <fixed_value Value>
+constexpr auto cw = constant_wrapper<Value>{};
+
+} // namespace util
+// NOLINTEND(cppcoreguidelines-pro-bounds-array-to-pointer-decay, modernize-avoid-c-arrays)