@auto_js/utility 0.0.9 → 0.0.11

package/package.json

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

package/platform/format.cc

@@ -1,60 +1,62 @@
+module;
+#include <version>
 export module util:platform.format;
 import std;
 
 namespace util {
 
-#if defined(__GNUC__) && !defined(__clang__)
+#if __GLIBCXX__
 
 // Claude-generated `std::format` fill to avoid gcc 16.2.0 libstdc++ requirement.
 
 template <class Type>
 struct printf_arg {
-	static_assert(false, "type is not formattable by the `util::format` polyfill");
+		static_assert(false, "type is not formattable by the `util::format` polyfill");
 };
 
 template <>
 struct printf_arg<bool> {
-	constexpr static auto spec = std::string_view{"%s"};
-	constexpr static auto pass(bool value) { return std::tuple{value ? "true" : "false"}; }
+		constexpr static auto spec = std::string_view{"%s"};
+		constexpr static auto pass(bool value) { return std::tuple{value ? "true" : "false"}; }
 };
 
 template <>
 struct printf_arg<char> {
-	constexpr static auto spec = std::string_view{"%c"};
-	constexpr static auto pass(char value) { return std::tuple{value}; }
+		constexpr static auto spec = std::string_view{"%c"};
+		constexpr static auto pass(char value) { return std::tuple{value}; }
 };
 
 template <class Type>
 	requires std::signed_integral<Type>
 struct printf_arg<Type> {
-	constexpr static auto spec = std::string_view{"%lld"};
-	constexpr static auto pass(Type value) { return std::tuple{static_cast<long long>(value)}; }
+		constexpr static auto spec = std::string_view{"%lld"};
+		constexpr static auto pass(Type value) { return std::tuple{static_cast<long long>(value)}; }
 };
 
 template <class Type>
 	requires std::unsigned_integral<Type>
 struct printf_arg<Type> {
-	constexpr static auto spec = std::string_view{"%llu"};
-	constexpr static auto pass(Type value) { return std::tuple{static_cast<unsigned long long>(value)}; }
+		constexpr static auto spec = std::string_view{"%llu"};
+		constexpr static auto pass(Type value) { return std::tuple{static_cast<unsigned long long>(value)}; }
 };
 
 template <class Type>
-	requires (std::same_as<Type, float> || std::same_as<Type, double>)
+	requires(std::same_as<Type, float> || std::same_as<Type, double>)
 struct printf_arg<Type> {
-	constexpr static auto spec = std::string_view{"%g"};
-	constexpr static auto pass(Type value) { return std::tuple{static_cast<double>(value)}; }
+		constexpr static auto spec = std::string_view{"%g"};
+		constexpr static auto pass(Type value) { return std::tuple{static_cast<double>(value)}; }
 };
 
 template <>
 struct printf_arg<long double> {
-	constexpr static auto spec = std::string_view{"%Lg"};
-	constexpr static auto pass(long double value) { return std::tuple{value}; }
+		constexpr static auto spec = std::string_view{"%Lg"};
+		constexpr static auto pass(long double value) { return std::tuple{value}; }
 };
 
 template <>
 struct printf_arg<const char*> {
-	constexpr static auto spec = std::string_view{"%s"};
-	constexpr static auto pass(const char* value) { return std::tuple{value}; }
+		constexpr static auto spec = std::string_view{"%s"};
+		constexpr static auto pass(const char* value) { return std::tuple{value}; }
 };
 
 template <>
@@ -62,10 +64,10 @@ struct printf_arg<char*> : printf_arg<const char*> {};
 
 template <>
 struct printf_arg<std::string_view> {
-	constexpr static auto spec = std::string_view{"%.*s"};
-	constexpr static auto pass(std::string_view value) {
-		return std::tuple{static_cast<int>(value.size()), value.data()};
-	}
+		constexpr static auto spec = std::string_view{"%.*s"};
+		constexpr static auto pass(std::string_view value) {
+			return std::tuple{static_cast<int>(value.size()), value.data()};
+		}
 };
 
 template <>
@@ -73,8 +75,8 @@ struct printf_arg<std::string> : printf_arg<std::string_view> {};
 
 template <>
 struct printf_arg<const void*> {
-	constexpr static auto spec = std::string_view{"%p"};
-	constexpr static auto pass(const void* value) { return std::tuple{value}; }
+		constexpr static auto spec = std::string_view{"%p"};
+		constexpr static auto pass(const void* value) { return std::tuple{value}; }
 };
 
 template <>
@@ -82,8 +84,8 @@ struct printf_arg<void*> : printf_arg<const void*> {};
 
 template <>
 struct printf_arg<std::nullptr_t> {
-	constexpr static auto spec = std::string_view{"%p"};
-	constexpr static auto pass(std::nullptr_t /*value*/) { return std::tuple{static_cast<const void*>(nullptr)}; }
+		constexpr static auto spec = std::string_view{"%p"};
+		constexpr static auto pass(std::nullptr_t /*value*/) { return std::tuple{static_cast<const void*>(nullptr)}; }
 };
 
 // Checks the format string against the argument types and rewrites `{}` replacement fields into
@@ -160,7 +162,8 @@ export template <class... Args>
 			std::snprintf(result.data(), result.size() + 1, format.get(), values...);
 			return result;
 		},
-		std::tuple_cat(printf_arg<std::decay_t<Args>>::pass(args)...));
+		std::tuple_cat(printf_arg<std::decay_t<Args>>::pass(args)...)
+	);
 }
 
 #else

package/utility/hash.cc

@@ -1,32 +1,76 @@
 export module util:utility.hash;
+import :utility.string;
 import std;
 
 namespace util {
 
-// `constexpr` hash for property lookup
-export template <class Char>
-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<std::uint8_t, sizeof(Char)>>(character);
-		for (auto byte : bytes) {
-			hash = hash ^ byte;
-			hash *= prime;
+// Dead simple `constexpr` hash for arbitrary data.
+template <class Result>
+struct fnv1a_hash_of {
+		static_assert(std::is_integral_v<Result>);
+		static_assert(std::is_unsigned_v<Result>);
+
+		template <class Type>
+		constexpr auto operator()(std::span<const Type> data) const -> Result {
+			constexpr auto xx = []() -> std::tuple<Result, Result> {
+				if constexpr (sizeof(Result) == 4) {
+					return {0x811c'9dc5, 0x100'0193};
+				} else {
+					static_assert(sizeof(Result) == 8);
+					return {0xcbf2'9ce4'8422'2325, 0x100'0000'01b3};
+				}
+			}();
+			constexpr auto offset_basis = std::get<0>(xx);
+			constexpr auto prime = std::get<1>(xx);
+			auto hash = offset_basis;
+			for (const auto& value : data) {
+				auto bytes = std::bit_cast<std::array<std::uint8_t, sizeof(Type)>>(value);
+				for (auto byte : bytes) {
+					hash = hash ^ byte;
+					hash *= prime;
+				}
+			}
+			return hash;
 		}
-	}
-	return hash;
-}
+
+		template <class Char>
+		constexpr auto operator()(std::basic_string_view<Char> view) const -> Result {
+			return (*this)(std::span<const Char>{view.data(), view.size()});
+		}
+};
+
+export auto fnv1a_hash32 = fnv1a_hash_of<std::uint32_t>{};
+export auto fnv1a_hash64 = fnv1a_hash_of<std::uint64_t>{};
 
 // constexpr `typeid(Type).hash_code()` replacement
-template <class Type>
-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});
+export template <class Result, class Type>
+consteval auto type_hash_of() -> Result {
+#if __clang__
+	constexpr auto name = std::string_view{std::source_location::current().function_name()};
+	// auto util::type_hash_of() [Result = unsigned int, Type = int]
+	// auto util::type_hash_of() [Result = unsigned int, Type = (lambda at /workspace/playground/sandbox.cc:15:12)]
+	if (name.contains("lambda at ")) {
+		throw std::logic_error{"cannot hash a lambda type"};
+	}
+#elif __GNUC__
+	constexpr auto name = std::string_view{__PRETTY_FUNCTION__};
+	// consteval auto util::type_hash_of@util() [with Result = unsigned int; Type = int]
+	// consteval auto util::type_hash_of@util() [with Result = unsigned int; Type = main()::<lambda()>]
+	if (name.contains("lambda(")) {
+		throw std::logic_error{"cannot hash a lambda type"};
+	}
+#else
+#error "Unsupported compiler"
+#endif
+	return fnv1a_hash_of<Result>{}(name);
 }
 
 export template <class Type>
-constexpr auto type_hash = make_type_hash<Type>();
+constexpr auto type_hash32 = type_hash_of<std::uint32_t, Type>();
+
+export template <class Type>
+constexpr auto type_hash64 = type_hash_of<std::uint64_t, Type>();
+
+static_assert(type_hash32<int> != type_hash32<unsigned>);
 
 } // namespace util

package/utility/sequence.cc

@@ -17,7 +17,7 @@ constexpr auto sequence_cw = [] consteval -> auto {
 // Return a sequence of constexpr indices
 export template <std::size_t Size>
 constexpr auto sequence = [] consteval -> auto {
-#if defined(__clang__)
+#if defined(__clang__) && __clang_major__ < 23
 	return sequence_cw<Size>;
 #else
 	constexpr_array<std::size_t, Size> result{};