@auto_js/utility 0.0.1

package/CMakeLists.txt

@@ -0,0 +1,45 @@
+add_library(utility_js OBJECT)
+target_compile_features(utility_js PUBLIC cxx_std_23)
+
+# Setup `#include "auto_js/[..]"`
+target_include_directories(utility_js PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/include")
+
+target_sources(utility_js
+	PRIVATE
+		assertions.cc
+		platform/timer.cc
+	PUBLIC FILE_SET CXX_MODULES FILES
+		_module.cc
+		container/mutable_priority_queue.cc
+		container/sealed_map.cc
+		container/segmented_priority_queue.cc
+		container/tinker_queue.cc
+		functional/bind.cc
+		functional/elide.cc
+		functional/flat_tuple.cc
+		functional/function_constant.cc
+		functional/function_ref.cc
+		functional/functional.cc
+		functional/regular_return.cc
+		memory/autorelease_pool.cc
+		memory/comparator.cc
+		memory/memory.cc
+		memory/noinit_allocator.cc
+		meta/algorithm.cc
+		platform/lockable.cc
+		platform/stop_token.cc
+		platform/timer.h.cc
+		type_traits/function_traits.cc
+		type_traits/transform.cc
+		type_traits/type_of.cc
+		type_traits/type_pack.cc
+		type_traits/type_traits.cc
+		utility/constant_wrapper.cc
+		utility/covariant_value.cc
+		utility/facade.cc
+		utility/hash.cc
+		utility/ranges.cc
+		utility/string.cc
+		utility/utility.cc
+		utility/variant.cc
+)

package/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2017 Marcel Laverdet
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/_module.cc

@@ -0,0 +1,14 @@
+export module util;
+export import :container.mutable_priority_queue;
+export import :container.sealed_map;
+export import :container.segmented_priority_queue;
+export import :container.tinker_queue;
+export import :functional;
+export import :memory;
+export import :meta.algorithm;
+export import :platform.lockable;
+export import :platform.stop_token;
+export import :platform.timer;
+export import :type_traits;
+export import :utility;
+export import :utility.variant;

package/assertions.cc

@@ -0,0 +1,32 @@
+#include <tuple> // IWYU pragma: keep
+#include <type_traits>
+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 ])) && ...);
+		 }()) &&
+		 ...)
+	);
+}
+
+[[maybe_unused]] constexpr auto result = []() -> 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">);
+
+	// 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;
+}();

package/container/mutable_priority_queue.cc

@@ -0,0 +1,35 @@
+module;
+#include <concepts>
+#include <queue>
+#include <utility>
+export module util:container.mutable_priority_queue;
+
+namespace util {
+
+template <class Value>
+struct mutable_entry {
+		mutable_entry() = default;
+		explicit mutable_entry(auto&&... args)
+			requires std::constructible_from<Value, decltype(args)...>
+				: value_{std::forward<decltype(args)>(args)...} {}
+		auto operator*() const -> Value& { return value_; }
+		auto operator<=>(const mutable_entry&) const = default;
+
+	private:
+		mutable Value value_;
+};
+
+// Allows the top element of `std::priority_queue` to be mutable
+export template <class Value>
+class mutable_priority_queue : public std::priority_queue<mutable_entry<Value>> {
+	private:
+		using priority_queue = std::priority_queue<mutable_entry<Value>>;
+
+	public:
+		using value_type = Value;
+
+		auto top() -> value_type& { return *priority_queue::top(); }
+		[[nodiscard]] auto top() const -> const value_type& { return *priority_queue::top(); }
+};
+
+} // namespace util

package/container/sealed_map.cc

@@ -0,0 +1,121 @@
+module;
+#include <algorithm>
+#include <concepts>
+#include <format>
+#include <ranges>
+#include <type_traits>
+#include <utility>
+export module util:container.sealed_map;
+import :functional;
+
+namespace util {
+
+struct sorted_equivalent_t {};
+
+export template <class Key, class Type, size_t Size>
+class sealed_map {
+	public:
+		using key_type = Key;
+		using value_type = std::pair<const key_type, Type>;
+		using container_type = std::array<value_type, Size>;
+
+	private:
+		// Holder for consteval'd key into the map
+		struct key_for {
+				using value_type = size_t;
+				constexpr key_for() :
+						index_{std::numeric_limits<value_type>::max()} {}
+				explicit constexpr key_for(auto index) :
+						index_{static_cast<value_type>(index)} {}
+
+				constexpr auto operator*() const -> std::size_t { return index_; }
+				explicit constexpr operator bool() const { return index_ != std::numeric_limits<value_type>::max(); }
+
+			private:
+				size_t index_;
+		};
+
+		// Check for duplicates
+		explicit consteval sealed_map(sorted_equivalent_t /*tag*/, container_type values) :
+				values_{std::move(values)} {
+			const auto projection = [](const auto& entry) { return entry.first; };
+			const auto duplicate = std::ranges::adjacent_find(values, std::equal_to{}, projection);
+			if (duplicate != values.end()) {
+				constexpr auto render = util::overloaded{
+					[](const auto& /*value*/) -> std::string { return "[??]"; },
+					[](std::string value) -> std::string { return value; },
+				};
+				// This error message can't actually render in constexpr but it's the thought that counts.
+				throw std::logic_error{std::format("Duplicate key {}", render(projection(*duplicate)))};
+			}
+		}
+
+	public:
+		// Default constructed values
+		explicit consteval sealed_map(std::type_identity<Type> /*default_construct*/, auto... keys)
+			requires std::default_initializable<Type> :
+				sealed_map{
+					sorted_equivalent_t{},
+					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);
+						return {value_type{std::move(sorted_keys), Type{}}...};
+					}}
+				} {}
+
+		// Keys & values provided
+		explicit consteval sealed_map(std::in_place_t /*tag*/, auto... pairs) :
+				sealed_map{
+					sorted_equivalent_t{},
+					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; };
+						std::ranges::sort(indices, std::less{}, projection);
+						const auto [... sorted_indices ] = indices;
+						return {value_type(std::move(entries.at(sorted_indices)))...};
+					}}
+				} {}
+
+		[[nodiscard]] constexpr auto begin(this auto& self) { return self.values_.begin(); }
+		[[nodiscard]] constexpr auto end(this auto& self) { return self.values_.end(); }
+
+		// Returns a reference to the value at the key previously found by `lookup`.
+		[[nodiscard]] constexpr auto at(this auto& self, key_for index) -> auto& {
+			if (!index) {
+				throw std::out_of_range{"Key not found"};
+			}
+			return *std::next(self.values_.begin(), *index);
+		}
+
+		// Find the given key in the map and return a nullable pointer to the value.
+		[[nodiscard]] constexpr auto find(const auto& key) const -> auto* {
+			const auto index = lookup(key);
+			return index ? std::addressof(at(index)) : nullptr;
+		}
+
+		// Return an opaque index type which can be used with `at`. Generally should be used in a
+		// consteval context.
+		[[nodiscard]] constexpr auto lookup(const auto& key) const -> key_for {
+			auto less = overloaded{
+				[](const value_type& left, const auto& right) constexpr { return left.first < right; },
+				[](const auto& left, const value_type& right) constexpr { return left < right.first; },
+			};
+			auto range = std::equal_range(values_.begin(), values_.end(), key, less);
+			return range.first == range.second ? key_for{} : key_for{std::distance(values_.begin(), range.first)};
+		}
+
+	private:
+		container_type values_;
+};
+
+template <class Key, class Type, class... Rest>
+sealed_map(std::type_identity<Type>, Key, Rest...) -> sealed_map<Key, Type, sizeof...(Rest) + 1>;
+
+template <class Key, class Type, class... Rest>
+sealed_map(std::in_place_t, std::pair<Key, Type>, Rest...) -> sealed_map<Key, Type, sizeof...(Rest) + 1>;
+
+} // namespace util

package/container/segmented_priority_queue.cc

@@ -0,0 +1,105 @@
+module;
+#include <algorithm>
+#include <array>
+#include <functional>
+#include <iterator>
+#include <span>
+#include <utility>
+export module util:container.segmented_priority_queue;
+
+namespace util {
+
+// Span which expands or contracts to include or possibly exclude the given members.
+export template <class Type>
+class ratchet_span : public std::span<Type> {
+	public:
+		using span_type = std::span<Type>;
+		using span_type::begin;
+		using span_type::end;
+		using span_type::span_type;
+		using iterator = span_type::iterator;
+
+		auto erase(auto it) -> void;
+		auto insert(auto it) -> void;
+		static auto make_iterator(auto it) -> iterator;
+};
+
+// N number of queues, which tracks which ones currently may have elements
+export template <class Queue, size_t Size>
+class segmented_priority_queue {
+	public:
+		using container_type = Queue;
+		using queues_type = std::array<container_type, Size>;
+		using value_type = container_type::value_type;
+
+		[[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); }
+		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_; }
+		auto emplace(unsigned priority, auto&&... args) -> void { at(priority).emplace(std::forward<decltype(args)>(args)...); }
+		auto front(this auto& self) -> auto& { return std::ranges::find_if_not(self.containers(), &Queue::empty)->front(); }
+		auto pop() -> void;
+
+	private:
+		queues_type queues_;
+		ratchet_span<container_type> not_empty_{queues_.end(), queues_.end()};
+};
+
+// ---
+
+// `ratchet_span`
+template <class Type>
+auto ratchet_span<Type>::erase(auto it) -> void {
+	auto local_it = make_iterator(it);
+	auto next = std::next(local_it);
+	if (end() == next) {
+		*this = {begin(), local_it};
+	} else if (begin() == local_it) {
+		*this = {next, end()};
+	}
+}
+
+template <class Type>
+auto ratchet_span<Type>::insert(auto it) -> void {
+	auto local_it = make_iterator(it);
+	*this = {
+		std::min(local_it, begin()),
+		std::max(std::next(local_it), end())
+	};
+}
+
+template <class Type>
+auto ratchet_span<Type>::make_iterator(auto it) -> iterator {
+	// `std::span<Type>::iterator` is implementation-defined, and in libc++ the constructor is
+	// private.
+	auto span = std::span<Type>{it, it};
+	return span.begin();
+}
+
+// `segmented_priority_queue`
+template <class Queue, 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);
+	not_empty_.insert(&queue);
+	return queue;
+}
+
+template <class Queue, size_t Size>
+auto segmented_priority_queue<Queue, Size>::pop() -> void {
+	for (auto& queue : not_empty_) {
+		if (queue.empty()) {
+			not_empty_.erase(&queue);
+		} else {
+			queue.pop();
+			if (queue.empty()) {
+				not_empty_.erase(&queue);
+			}
+			return;
+		}
+	}
+}
+
+} // namespace util

package/container/tinker_queue.cc

@@ -0,0 +1,73 @@
+module;
+#include <algorithm>
+#include <cassert>
+#include <concepts>
+#include <deque>
+#include <utility>
+export module util:container.tinker_queue;
+
+namespace util {
+
+// A queue that lets you pick elements out the middle for some reason
+export template <class Value>
+class tinker_queue {
+	public:
+		static_assert(std::constructible_from<Value>);
+		static_assert(std::constructible_from<bool, Value>);
+
+		using container_type = std::deque<Value>;
+		using value_type = Value;
+
+		[[nodiscard]] auto empty() const -> bool { return size() == 0; }
+		[[nodiscard]] auto size() const -> 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;
+		auto front(this auto& self) -> auto& { return self.queue_.front(); }
+		auto pop() -> void;
+		auto take(std::invocable<const value_type&> auto predicate) -> value_type;
+
+	private:
+		container_type queue_;
+		size_t empty_middle_values_{};
+};
+
+// ---
+
+template <class Value>
+auto tinker_queue<Value>::emplace(auto&&... args) -> void {
+	queue_.emplace_back(std::forward<decltype(args)>(args)...);
+	assert(queue_.back());
+}
+
+template <class Value>
+auto tinker_queue<Value>::pop() -> void {
+	queue_.pop_front();
+	for (auto& value : queue_) {
+		if (value) {
+			return;
+		} else {
+			queue_.pop_front();
+			--empty_middle_values_;
+		}
+	}
+}
+
+template <class Value>
+auto tinker_queue<Value>::take(std::invocable<const value_type&> auto predicate) -> value_type {
+	auto it = std::ranges::find_if(const_cast<const container_type&>(queue_), predicate);
+	if (it == queue_.begin()) {
+		auto result = std::move(*it);
+		pop();
+		return result;
+	} else if (it == queue_.end()) {
+		return {};
+	} else {
+		auto result = std::exchange(std::move(*it), {});
+		assert(result);
+		++empty_middle_values_;
+		return result;
+	}
+}
+
+} // namespace util

package/functional/bind.cc

@@ -0,0 +1,151 @@
+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;
+
+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{} ]() {})>);
+export template <class Invocable, class... Bound>
+class bind;
+
+template <class Invocable, class... Bound>
+bind(Invocable, Bound...) -> bind<Invocable, Bound...>;
+
+// Storage for `bind` specializations
+template <class Invocable, class... Bound>
+struct bind_storage {
+	public:
+		explicit constexpr bind_storage()
+			requires std::is_empty_v<Invocable> && (... && std::is_empty_v<Bound>)
+		= default;
+
+		explicit constexpr bind_storage(Invocable invocable, Bound... params) :
+				invocable_{std::move(invocable)},
+				params_{std::forward<Bound>(params)...} {}
+
+		NO_UNIQUE_ADDRESS Invocable invocable_;
+		NO_UNIQUE_ADDRESS flat_tuple<Bound...> params_;
+};
+
+// Overloaded signature `util::bind`
+template <class Invocable, class... Bound>
+class bind_overloaded : private bind_storage<Invocable, Bound...> {
+	private:
+		using storage_type = bind_storage<Invocable, Bound...>;
+		using storage_type::invocable_;
+		using storage_type::params_;
+
+	public:
+		using storage_type::storage_type;
+
+		template <class... Args>
+		constexpr auto operator()(Args&&... args) noexcept(std::is_nothrow_invocable_v<Invocable&, Bound&..., Args...>)
+			-> std::invoke_result_t<Invocable&, Bound&..., Args...> {
+			return invoke(std::forward<Args>(args)...);
+		}
+
+		template <class Self, class... Args>
+		constexpr auto operator()(this Self&& self, Args&&... args) noexcept(std::is_nothrow_invocable_v<apply_cvref_t<Self, Invocable>, apply_cvref_t<Self, Bound>..., Args...>)
+			-> std::invoke_result_t<apply_cvref_t<Self, Invocable>, apply_cvref_t<Self, Bound>..., Args...> {
+			return std::forward<Self>(self).invoke(std::forward<Args>(args)...);
+		}
+
+	private:
+		constexpr auto invoke(this auto&& self, auto&&... args) -> decltype(auto) {
+			const auto [... indices ] = util::sequence<sizeof...(Bound)>;
+			// NOLINTNEXTLINE(bugprone-use-after-move)
+			return std::forward<decltype(self)>(self).invocable_(
+				// NOLINTNEXTLINE(bugprone-use-after-move)
+				get<indices>(std::forward<decltype(self)>(self).params_)...,
+				std::forward<decltype(args)>(args)...
+			);
+		}
+};
+
+// Explicit signature `util::bind`
+template <class Invocable, class Signature, class... Bound>
+class bind_explicit;
+
+template <class Invocable, class... Args, bool Nx, class Result, class... Bound>
+class bind_explicit<Invocable, auto(Args...) noexcept(Nx)->Result, Bound...> : private bind_storage<Invocable, Bound...> {
+	private:
+		using storage_type = bind_storage<Invocable, Bound...>;
+		using storage_type::invocable_;
+		using storage_type::params_;
+
+		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&>;
+		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;
+
+	public:
+		using storage_type::storage_type;
+
+		// This overload allows `std::invocable<bind<...>>` without a reference, which makes concept
+		// parameters work correctly.
+		constexpr auto operator()(Args /*&&*/... args) noexcept(Nx) -> Result
+			requires invoke_as_mutable {
+			return invoke(std::forward<Args>(args)...);
+		}
+
+		// Otherwise, explicit `this` is used
+		constexpr auto operator()(this this_type self, Args /*&&*/... args) noexcept(Nx) -> Result
+			requires invoke_as_forward {
+			return std::forward<this_type>(self).invoke(std::forward<Args>(args)...);
+		}
+
+	private:
+		constexpr auto invoke(this auto&& self, Args /*&&*/... args) noexcept(Nx) -> Result {
+			const auto [... indices ] = util::sequence<sizeof...(Bound)>;
+			// NOLINTNEXTLINE(bugprone-use-after-move)
+			return std::forward<this_type>(self).invocable_(
+				// NOLINTNEXTLINE(bugprone-use-after-move)
+				get<indices>(std::forward<this_type>(self).params_)...,
+				std::forward<decltype(args)>(args)...
+			);
+		}
+};
+
+// Strip the first N parameters from the signature
+template <class Signature, std::size_t Count>
+struct bind_signature;
+
+template <class Signature, std::size_t Count>
+using bind_signature_t = bind_signature<Signature, Count>::type;
+
+template <class First, class... Args, bool Nx, class Result, std::size_t Count>
+	requires(Count > 0)
+struct bind_signature<auto(First, Args...) noexcept(Nx)->Result, Count>
+		: bind_signature<auto(Args...) noexcept(Nx)->Result, Count - 1> {};
+
+template <class... Args, bool Nx, class Result>
+struct bind_signature<auto(Args...) noexcept(Nx)->Result, 0>
+		: std::type_identity<auto(Args...) noexcept(Nx)->Result> {};
+
+template <class Invocable, class... Bound>
+using bind_explicit_params_t =
+	bind_explicit<Invocable, bind_signature_t<function_signature_t<Invocable>, sizeof...(Bound)>, Bound...>;
+
+// Instantiate without known function signature
+template <class Invocable, class... Bound>
+class bind : public bind_overloaded<Invocable, Bound...> {
+		using bind_overloaded<Invocable, Bound...>::bind_overloaded;
+};
+
+// Instantiate with known function signature
+template <class Invocable, class... Bound>
+	requires requires { typename function_signature_t<Invocable>; }
+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

@@ -0,0 +1,52 @@
+module;
+#include "auto_js/no_unique_address.h"
+#include <concepts>
+#include <tuple>
+#include <utility>
+export module util:functional.elide;
+
+namespace util {
+
+// Lazy value creation. Enables construction of non-movable types via copy elision. Also, can be
+// used for deferred construction for `try_emplace`.
+
+// Adapted from discontinued proposal:
+// https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2024/p3288r0.html
+export template <class Type, class Invocable, class... Args>
+class elide {
+	public:
+		using result_type = Type;
+
+		explicit constexpr elide(Invocable invocable, Args /*&&*/... args) :
+				invocable_{std::move(invocable)},
+				args_{std::forward<decltype(args)>(args)...} {}
+
+		// NOLINTNEXTLINE(google-explicit-constructor)
+		constexpr operator result_type() && {
+			auto [... args ] = std::move(args_);
+			// NOLINTNEXTLINE(clang-analyzer-core.CallAndMessage)
+			return std::move(invocable_)(std::move(args)...);
+		}
+
+	private:
+		NO_UNIQUE_ADDRESS Invocable invocable_;
+		NO_UNIQUE_ADDRESS std::tuple<Args...> args_;
+};
+
+template <class Invocable, class... Args>
+elide(Invocable, Args&&...) -> elide<std::invoke_result_t<Invocable, Args...>, Invocable, Args...>;
+
+// `util::constructor<T>` adapts a constructible type into a callable object. Great for use with
+// `util::elide`.
+template <class Type>
+struct constructor_t {
+		constexpr auto operator()(auto&&... args) const -> Type
+			requires std::constructible_from<Type, decltype(args)...> {
+			return Type(std::forward<decltype(args)>(args)...);
+		}
+};
+
+export template <class Type>
+constexpr inline auto constructor = constructor_t<Type>{};
+
+} // namespace util