@auto_js/utility 0.0.1

package/functional/flat_tuple.cc

@@ -0,0 +1,90 @@
+module;
+#include "auto_js/no_unique_address.h"
+#include <type_traits>
+#include <utility>
+export module util:functional.flat_tuple;
+
+namespace util {
+
+// Internal `flat_tuple` element storage
+template <std::size_t Index, class Type>
+class flat_tuple_element {
+	public:
+		flat_tuple_element() = default;
+		constexpr explicit flat_tuple_element(Type&& value) : value_{std::move(value)} {}
+		constexpr explicit flat_tuple_element(const Type& value) : value_{value} {}
+
+		using index_type = std::integral_constant<std::size_t, Index>;
+		constexpr auto get(index_type /*index*/) & -> Type& { return value_; }
+		constexpr auto get(index_type /*index*/) && -> Type&& { return std::move(value_); }
+		[[nodiscard]] constexpr auto get(index_type /*index*/) const& -> const Type& { return value_; }
+
+	private:
+		NO_UNIQUE_ADDRESS Type value_;
+};
+
+// Specialization for reference types
+template <std::size_t Index, class Type>
+class flat_tuple_element<Index, Type&> {
+	public:
+		flat_tuple_element() = delete;
+		constexpr explicit flat_tuple_element(Type& value) : value_{&value} {}
+
+		using index_type = std::integral_constant<std::size_t, Index>;
+		constexpr auto get(index_type /*index*/) & -> Type& { return *value_; }
+		constexpr auto get(index_type /*index*/) && -> Type& { return *value_; }
+		[[nodiscard]] constexpr auto get(index_type /*index*/) const& -> const Type& { return *value_; }
+
+	private:
+		NO_UNIQUE_ADDRESS Type* value_;
+};
+
+// Internal `flat_tuple` helper providing access into private `flat_tuple_element` via friend
+// visibility
+constexpr auto flat_tuple_get(auto index, auto&& tuple) -> auto&& {
+	return std::forward<decltype(tuple)>(tuple).get(index);
+}
+
+// Internal `flat_tuple_storage` element collection storage
+template <class Indices, class... Types>
+class flat_tuple_storage;
+
+template <class... Types>
+using flat_tuple_storage_t = flat_tuple_storage<std::make_index_sequence<sizeof...(Types)>, Types...>;
+
+template <std::size_t... Index, class... Type>
+class flat_tuple_storage<std::index_sequence<Index...>, Type...> : private flat_tuple_element<Index, Type>... {
+	public:
+		flat_tuple_storage() = default;
+		constexpr explicit flat_tuple_storage(auto&&... values) :
+				flat_tuple_element<Index, Type>{std::forward<decltype(values)>(values)}... {}
+
+	private:
+		constexpr friend auto flat_tuple_get(auto, auto&&) -> auto&&;
+		using flat_tuple_element<Index, Type>::get...;
+};
+
+// Simple replacement for `std::tuple` which is trivially copyable in the case its members are.
+// See: `static_assert(!std::is_trivially_copyable_v<std::tuple<int>>);`
+export template <class... Types>
+struct flat_tuple : flat_tuple_storage_t<Types...> {
+		using flat_tuple_storage_t<Types...>::flat_tuple_storage_t;
+};
+
+// `std::get` replacement for `flat_tuple`
+export template <std::size_t Index, class... Types>
+constexpr auto get(flat_tuple<Types...>& tuple) -> auto& {
+	return flat_tuple_get(std::integral_constant<std::size_t, Index>{}, tuple);
+}
+
+export template <std::size_t Index, class... Types>
+constexpr auto get(flat_tuple<Types...>&& tuple) -> auto&& {
+	return flat_tuple_get(std::integral_constant<std::size_t, Index>{}, std::move(tuple));
+}
+
+export template <std::size_t Index, class... Types>
+constexpr auto get(const flat_tuple<Types...>& tuple) -> const auto& {
+	return flat_tuple_get(std::integral_constant<std::size_t, Index>{}, tuple);
+}
+
+} // namespace util

package/functional/function_constant.cc

@@ -0,0 +1,58 @@
+module;
+#include <concepts>
+#include <utility>
+export module util:functional.function_constant;
+import :type_traits;
+
+namespace util {
+
+// Kind of related to P3774 [https://isocpp.org/files/papers/P3774R0.html] but returns an invocable
+// which can be inferred with `function_signature_t`.
+export template <auto Invocable>
+struct function_constant;
+
+export template <auto Invocable>
+constexpr auto fn = function_constant<Invocable>{};
+
+template <auto Invocable, class Function, class Signature>
+struct function_constant_of;
+
+template <auto Invocable, class Function>
+struct function_constant_with;
+
+// Specialization for inferrable signatures
+template <auto Invocable>
+	requires requires { typename function_signature_t<decltype(Invocable)>; }
+struct function_constant<Invocable> : function_constant_of<Invocable, decltype(Invocable), function_signature_t<decltype(Invocable)>> {};
+
+// Overloaded invocable
+template <auto Invocable>
+struct function_constant : function_constant_with<Invocable, decltype(Invocable)> {};
+
+// Free function or invocable object
+template <auto Invocable, class Function, class... Args, bool Nx, class Result>
+struct function_constant_of<Invocable, Function, auto(Args...) noexcept(Nx)->Result> {
+		constexpr auto operator()(Args... args) const noexcept(Nx) -> Result {
+			return Invocable(std::forward<Args>(args)...);
+		}
+};
+
+// Member function pointer
+template <auto Invocable, class Type, class Function, class That, class... Args, bool Nx, class Result>
+struct function_constant_of<Invocable, Function Type::*, auto(That, Args...) noexcept(Nx)->Result> {
+		constexpr auto operator()(That that, Args... args) const noexcept(Nx) -> Result {
+			return (std::forward<That>(that).*Invocable)(std::forward<Args>(args)...);
+		}
+};
+
+// Overloaded function
+template <auto Invocable, class Function>
+struct function_constant_with {
+		template <class... Args>
+		constexpr auto operator()(Args&&... args) const noexcept(std::is_nothrow_invocable_v<Function, Args...>) -> decltype(auto)
+			requires std::invocable<Function, Args...> {
+			return Invocable(std::forward<Args>(args)...);
+		}
+};
+
+} // namespace util

package/functional/function_ref.cc

@@ -0,0 +1,68 @@
+module;
+#include <concepts>
+#include <type_traits>
+#include <utility>
+export module util:functional.function_ref;
+import :functional.elide;
+import :type_traits;
+
+namespace util {
+
+export template <class Signature>
+class function_ref;
+
+template <class Result, bool Nx, class... Args>
+class function_ref<auto(Args...) noexcept(Nx)->Result> {
+	private:
+		template <class Type>
+		constexpr explicit function_ref(std::type_identity<Type> /*tag*/, void* ptr) :
+				invoke_{[](void* ptr, Args... args) noexcept(Nx) -> Result {
+					auto& object = *static_cast<Type*>(ptr);
+					return object(std::forward<Args>(args)...);
+				}},
+				ptr_{ptr} {}
+
+	public:
+		using signature_type = 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)} {}
+
+		template <std::invocable<Args...> Object>
+			requires(type<Object> != type<function_ref>)
+		// NOLINTNEXTLINE(google-explicit-constructor)
+		constexpr function_ref(Object& object) :
+				function_ref{std::type_identity<Object>{}, static_cast<void*>(&object)} {}
+
+		// Explicit to avoid automatic binding to temporary objects
+		template <std::invocable<Args...> Object>
+			requires(type<Object> != type<function_ref>)
+		constexpr explicit function_ref(const Object& object) :
+				// NOLINTNEXTLINE(cppcoreguidelines-pro-type-const-cast)
+				function_ref{std::type_identity<const Object>{}, const_cast<void*>(static_cast<const void*>(&object))} {}
+
+		// Bound function constant
+		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)...);
+		}
+
+	private:
+		using invoke_type = auto(void*, Args...) noexcept(Nx) -> Result;
+
+		invoke_type* invoke_;
+		void* ptr_;
+};
+
+} // namespace util

package/functional/functional.cc

@@ -0,0 +1,107 @@
+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;
+
+namespace util {
+
+// https://en.cppreference.com/w/cpp/utility/variant/visit
+export template <class... Visitors>
+struct overloaded : Visitors... {
+		using Visitors::operator()...;
+};
+
+// Holder for functions in libc++ which doesn't support std::move_only_function
+#if defined(__cpp_lib_move_only_function) && !defined(DEBUG)
+
+export template <class Signature>
+using maybe_move_only_function = std::move_only_function<Signature>;
+
+export template <class Fn>
+auto make_indirect_moveable_function(Fn fn) {
+	return fn;
+}
+
+#else
+
+export template <class Signature>
+using maybe_move_only_function = std::function<remove_function_cvref_t<Signature>>;
+
+export template <class Fn>
+auto make_indirect_moveable_function(Fn&& fn) {
+	auto fn_ptr = std::make_shared<std::remove_cvref_t<Fn>>(std::forward<Fn>(fn));
+	return [ = ](auto&&... args) -> decltype(auto) {
+		return (*fn_ptr)(std::forward<decltype(args)>(args)...);
+	};
+}
+
+#endif
+
+// Hide `-Wunused-value` warnings
+export constexpr auto unused = [](auto&& /*nothing*/) -> void {};
+
+// Invoke the given callable as a base class of itself. cvref qualifiers are forwarded, so `Type` is
+// expected to be unqualified.
+export template <class Type, class From>
+constexpr auto invoke_as(From&& func, auto&&... args)
+	-> decltype(std::declval<apply_cvref_t<From, Type>>()(std::declval<decltype(args)>()...)) {
+	return static_cast<apply_cvref_t<From, Type>>(std::forward<decltype(func)>(func))(std::forward<decltype(args)>(args)...);
+}
+
+// Invoke the given callable using an explicit and possibly shadowed `operator()()` on a base class,
+// but without erasing the pointer type for deduced `this`. The syntax here is messy, and
+// `InvokeAsType_` can be shadowed by the base class. Also, clang has some really spooky behavior
+// which is resolved by breaking out invocations to deduced-this instances.
+export template <class InvokeAsType_>
+constexpr auto invoke_this_as(auto&& func, auto&&... args)
+	// This is functionally the same as ` -> decltype(auto)` but works around the error:
+	// 'invoke_as<...>' with deduced return type cannot be used before it is defined
+	-> decltype(std::declval<decltype(func)>().InvokeAsType_::operator()(std::declval<decltype(args)>()...)) {
+	return std::forward<decltype(func)>(func).InvokeAsType_::operator()(std::forward<decltype(args)>(args)...);
+}
+
+// Invoke the given function with the constant expression matching a runtime value.
+export constexpr auto template_switch(const auto& value, auto case_pack, auto invoke) -> decltype(auto) {
+	auto dispatch = [ & ](this const auto& self, auto case_, auto... cases) -> decltype(auto) {
+		if (value == case_) {
+			return invoke(case_);
+		} else {
+			if constexpr (sizeof...(cases) == 0) {
+				// default
+				return invoke();
+			} else {
+				return self(cases...);
+			}
+		}
+	};
+	const auto [... cases ] = case_pack;
+	// NOLINTNEXTLINE(clang-analyzer-core.CallAndMessage)
+	return dispatch(cases...);
+}
+
+// libc++'s `std::reference_wrapper` causes a template instantiation while looking for
+// `result_type`. That breaks our transfer machinery.
+export template <class Type>
+class reference_wrapper {
+	public:
+		// NOLINTNEXTLINE(google-explicit-constructor)
+		constexpr reference_wrapper(Type& value) : value_{&value} {}
+
+		constexpr auto operator()(auto&&... args) const
+			-> decltype(std::declval<Type&>()(std::declval<decltype(args)>()...)) {
+			return (*value_)(std::forward<decltype(args)>(args)...);
+		}
+
+		constexpr auto get() const -> Type& { return *value_; }
+
+	private:
+		Type* value_;
+};
+
+} // namespace util

package/functional/regular_return.cc

@@ -0,0 +1,55 @@
+module;
+#include <utility>
+export module util:functional.regular_return;
+import :type_traits;
+import :utility;
+
+namespace util {
+
+// Value wrapper which can accept void values. `operator*` will return the underlying value.
+template <class Type>
+class regular_value {
+	public:
+		constexpr explicit regular_value(Type value) :
+				value_{std::move(value)} {}
+
+		constexpr auto operator*() && -> Type { return std::move(value_); }
+		constexpr auto value_or(const auto& /*nothing*/) && -> Type { return *std::move(*this); };
+
+	private:
+		Type value_;
+};
+
+template <>
+class regular_value<void> {
+	public:
+		constexpr auto operator*() const -> void {}
+
+		template <class Type>
+		constexpr auto value_or(Type value) -> Type { return value; };
+};
+
+// Wraps the given invocable. When invoked it returns `regular_value<T>` of the function return
+// value.
+export template <class Type>
+class regular_return {
+	public:
+		constexpr explicit regular_return(Type invoke) :
+				invoke_{std::move(invoke)} {}
+
+		constexpr auto operator()(this auto&& self, auto&&... args)
+			-> regular_value<std::invoke_result_t<util::apply_cvref_t<decltype(self), Type>, decltype(args)...>> {
+			using result_type = std::invoke_result_t<util::apply_cvref_t<decltype(self), Type>, decltype(args)...>;
+			if constexpr (std::is_void_v<result_type>) {
+				std::forward<decltype(self)>(self).invoke_(std::forward<decltype(args)>(args)...);
+				return regular_value<void>{};
+			} else {
+				return regular_value<result_type>{std::forward<decltype(self)>(self).invoke_(std::forward<decltype(args)>(args)...)};
+			}
+		}
+
+	private:
+		Type invoke_;
+};
+
+} // namespace util