@auto_js/utility 0.0.3 → 0.0.5

package/CMakeLists.txt

@@ -19,6 +19,7 @@ target_sources(utility_js
 		functional/function_constant.cc
 		functional/function_ref.cc
 		functional/functional.cc
+		functional/move_only_function.cc
 		functional/regular_return.cc
 		memory/autorelease_pool.cc
 		memory/comparator.cc
@@ -38,6 +39,7 @@ target_sources(utility_js
 		utility/facade.cc
 		utility/hash.cc
 		utility/ranges.cc
+		utility/sequence.cc
 		utility/string.cc
 		utility/utility.cc
 		utility/variant.cc

package/functional/functional.cc

@@ -3,6 +3,7 @@ export import :functional.bind;
 export import :functional.elide;
 export import :functional.function_constant;
 export import :functional.function_ref;
+export import :functional.move_only_function;
 export import :functional.regular_return;
 import std;
 
@@ -14,32 +15,6 @@ 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 {};
 
@@ -63,6 +38,46 @@ constexpr auto invoke_this_as(auto&& func, auto&&... args)
 	return std::forward<decltype(func)>(func).InvokeAsType_::operator()(std::forward<decltype(args)>(args)...);
 }
 
+// Invoke the given function with each value in a pack. The first parameter is a value and the
+// second parameter is a continuation thunk. If it reaches the end it will invoke the function with
+// no parameters, returning that result.
+export constexpr auto template_traverse(auto values_pack, const auto& invoke) -> decltype(auto) {
+	const auto fold = util::overloaded{
+		[ & ]() -> decltype(auto) { return invoke(); },
+		[ & ](this const auto& self, auto value, auto... values) -> decltype(auto) {
+			return invoke(value, [ & ]() -> decltype(auto) { return self(values...); });
+		},
+	};
+	const auto [... values ] = values_pack;
+	return fold(values...);
+}
+
+// Fold operation for template packs. If the pack is empty then `identity` is returned. Otherwise
+// `identity` is ignored.
+export constexpr auto template_fold(auto values_pack, auto identity, const auto& invoke) -> decltype(auto) {
+	const auto fold = util::overloaded{
+		[ & ]() -> decltype(auto) { return identity; },
+		[ & ](auto left) -> decltype(auto) { return left; },
+		[ & ](this const auto& self, auto left, auto right, auto... values) -> decltype(auto) {
+			return self(invoke(left, right), values...);
+		},
+	};
+	const auto [... values ] = values_pack;
+	return fold(values...);
+};
+
+// Template pack reducer
+export constexpr auto template_reduce(auto values_pack, auto accumulator, const auto& invoke) -> decltype(auto) {
+	const auto reduce = util::overloaded{
+		[ & ](auto accumulator) -> decltype(auto) { return accumulator; },
+		[ & ](this const auto& self, auto accumulator, auto value, auto... values) -> decltype(auto) {
+			return self(invoke(accumulator, value), values...);
+		},
+	};
+	const auto [... values ] = values_pack;
+	return reduce(accumulator, values...);
+};
+
 // 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) {
@@ -82,6 +97,23 @@ export constexpr auto template_switch(const auto& value, auto case_pack, auto in
 	return dispatch(cases...);
 }
 
+// It seems like this should work but clang 22.1.6 throws this error:
+// /workspace/packages/auto_js/js/assertions.cc:37:15: error: static assertion expression is not an integral constant expression
+//    37 | static_assert(transfer<double>(std::variant<int, double>{1.1}) == 1.1);
+//       |               ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+// /workspace/packages/utility/functional/functional.cc:73:11: note: subobject of type 'const util::overloaded<(lambda at /workspace/packages/utility/functional/functional.cc:85:4), (lambda at /workspace/packages/utility/functional/functional.cc:86:4)> &const' is not initialized
+//    73 |                         return invoke(value, [ & ]() -> decltype(auto) { return self(values...); });
+//
+// export constexpr auto template_switch(const auto& value, auto case_pack, auto invoke) -> decltype(auto) {
+// 	return template_traverse(
+// 		case_pack,
+// 		util::overloaded{
+// 			[ & ](auto case_, auto next) -> decltype(auto) { return value == case_ ? invoke(case_) : next(); },
+// 			[ & ]() -> decltype(auto) { return invoke(); },
+// 		}
+// 	);
+// }
+
 // libc++'s `std::reference_wrapper` causes a template instantiation while looking for
 // `result_type`. That breaks our transfer machinery.
 export template <class Type>

package/functional/move_only_function.cc

@@ -0,0 +1,95 @@
+export module util:functional.move_only_function;
+import :type_traits;
+import std;
+
+namespace util {
+
+#if defined(__cpp_lib_move_only_function)
+
+export template <class Signature>
+using move_only_function = std::move_only_function<Signature>;
+
+#else
+
+// Virtual base class. There must be two, one for each const/non-const signature because virtual
+// function cannot have explicit this or requirement clauses.
+template <class CvRef, class Signature>
+struct move_only_function_virtual;
+
+template <class... Args, bool Nx, class Result>
+struct move_only_function_virtual<int, auto(Args...) noexcept(Nx)->Result> {
+		virtual constexpr ~move_only_function_virtual() = default;
+		virtual constexpr auto operator()(Args... args) noexcept(Nx) -> Result = 0;
+};
+
+template <class... Args, bool Nx, class Result>
+struct move_only_function_virtual<const int, auto(Args...) noexcept(Nx)->Result> {
+		virtual constexpr ~move_only_function_virtual() = default;
+		virtual constexpr auto operator()(Args... args) const noexcept(Nx) -> Result = 0;
+};
+
+// Instance per underlying function type
+template <class CvRef, class Signature, class Function>
+class move_only_function_instance;
+
+template <class... Args, bool Nx, class Result, class Function>
+class move_only_function_instance<int, auto(Args...) noexcept(Nx)->Result, Function>
+		: public move_only_function_virtual<int, auto(Args...) noexcept(Nx)->Result> {
+	public:
+		explicit constexpr move_only_function_instance(Function function) : function_{std::move(function)} {}
+		virtual constexpr auto operator()(Args... args) noexcept(Nx) -> Result { return function_(std::forward<Args>(args)...); }
+
+	private:
+		Function function_;
+};
+
+template <class... Args, bool Nx, class Result, class Function>
+class move_only_function_instance<const int, auto(Args...) noexcept(Nx)->Result, Function>
+		: public move_only_function_virtual<const int, auto(Args...) noexcept(Nx)->Result> {
+	public:
+		explicit constexpr move_only_function_instance(Function function) : function_{std::move(function)} {}
+		virtual constexpr auto operator()(Args... args) const noexcept(Nx) -> Result { return function_(std::forward<Args>(args)...); }
+
+	private:
+		Function function_;
+};
+
+// std::move_only_function polyfill implementation (separated to split out cvref from signature)
+template <class CvRef, class Signature>
+class move_only_function_handle;
+
+template <class Signature>
+using move_only_function_handle_for =
+	move_only_function_handle<util::extract_function_cvref_t<Signature>, remove_function_cvref_t<Signature>>;
+
+template <class CvRef, class... Args, bool Nx, class Result>
+class move_only_function_handle<CvRef, auto(Args...) noexcept(Nx)->Result> {
+	public:
+		move_only_function_handle() = default;
+
+		template <class Function>
+		// NOLINTNEXTLINE(google-explicit-constructor)
+		constexpr move_only_function_handle(Function function) :
+				instance_{std::make_unique<move_only_function_instance<CvRef, auto(Args...) noexcept(Nx)->Result, Function>>(std::move(function))} {}
+		constexpr auto operator()(this util::apply_cvref_t<CvRef, move_only_function_handle>& self, Args... args) noexcept(Nx) -> Result {
+			return (*self.instance_)(std::forward<Args>(args)...);
+		}
+		constexpr explicit operator bool() const { return bool{instance_}; }
+
+	private:
+		std::unique_ptr<move_only_function_virtual<CvRef, auto(Args...) noexcept(Nx)->Result>> instance_;
+};
+
+// std::move_only_function polyfill
+export template <class Signature>
+struct move_only_function : move_only_function_handle_for<Signature> {
+		move_only_function() = default;
+		using move_only_function_handle_for<Signature>::move_only_function_handle_for;
+};
+
+template <class Function>
+move_only_function(Function) -> move_only_function<util::function_signature_t<Function>>;
+
+#endif
+
+} // namespace util

package/package.json

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

package/type_traits/type_traits.cc

@@ -3,3 +3,48 @@ export import :type_traits.function_traits;
 export import :type_traits.transform;
 export import :type_traits.type_of;
 export import :type_traits.type_pack;
+import std;
+
+namespace util {
+
+// Check if casting from one numeric to another can be done without loss. It is probably missing a
+// plethora of exotic cases but I think this covers the fundamentals.
+export template <class From, class To>
+struct safe_numeric_conversion {
+		using limits_from = std::numeric_limits<From>;
+		using limits_to = std::numeric_limits<To>;
+		constexpr static auto value =
+			// Check signed / floating point compatibility
+			(limits_to::is_signed || !limits_from::is_signed) &&
+			(limits_from::is_integer || !limits_to::is_integer) &&
+			// Check precision
+			(limits_to::digits >= limits_from::digits) &&
+			// Check range
+			(limits_from::lowest() >= limits_to::lowest()) &&
+			(limits_from::max() <= limits_to::max());
+};
+
+export template <class From, class To>
+constexpr auto safe_numeric_conversion_v = safe_numeric_conversion<From, To>::value;
+
+static_assert(safe_numeric_conversion<std::int32_t, std::int64_t>::value);
+static_assert(!safe_numeric_conversion<std::int32_t, std::uint64_t>::value);
+static_assert(!safe_numeric_conversion<std::int64_t, double>::value);
+static_assert(safe_numeric_conversion<std::int32_t, double>::value);
+static_assert(safe_numeric_conversion<float, double>::value);
+static_assert(!safe_numeric_conversion<double, float>::value);
+
+// Resolves to the type of every type in the pack. If any type differs then it is ill-formed.
+template <class... Type>
+struct identical_type;
+
+template <class... Type>
+using identical_type_t = identical_type<Type...>::type;
+
+template <class Type>
+struct identical_type<Type> : std::type_identity<Type> {};
+
+template <class Type, class... Rest>
+struct identical_type<Type, Type, Rest...> : identical_type<Type, Rest...> {};
+
+} // namespace util

package/utility/constant_wrapper.cc

@@ -7,7 +7,7 @@ import std;
 // NOLINTBEGIN(cppcoreguidelines-pro-bounds-array-to-pointer-decay, modernize-avoid-c-arrays)
 namespace util {
 
-template <class Type>
+export template <class Type>
 struct fixed_value {
 		using type = Type;
 		// NOLINTNEXTLINE(google-explicit-constructor)

package/utility/ranges.cc

@@ -55,11 +55,11 @@ export constexpr auto into_range(meta_range auto&& 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) {
+constexpr auto maybe_range_size(const Type& range, auto... if_not) {
 	if constexpr (std::ranges::sized_range<Type>) {
 		return std::tuple{std::ranges::size(range)};
 	} else {
-		return std::tuple{};
+		return std::tuple{if_not...};
 	}
 }
 

package/utility/sequence.cc

@@ -0,0 +1,22 @@
+export module util:utility.sequence;
+import std;
+
+namespace util {
+
+// Return a sequence of index constants
+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 `std::size_t`.
+	// https://clang.llvm.org/cxx_status.html
+
+	// std::array<std::size_t, Size> result{};
+	// 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 {
+		return std::tuple{std::integral_constant<std::size_t, Index>{}...};
+	}(std::make_index_sequence<Size>());
+}();
+
+} // namespace util

package/utility/string.cc

@@ -1,5 +1,7 @@
 export module util:utility.string;
+import :type_traits;
 import :utility.constant_wrapper;
+import :utility.sequence;
 import std;
 
 namespace util {
@@ -16,6 +18,24 @@ consteval auto make_consteval_string_view(constant_wrapper<Value> /*cw*/) -> std
 	return make_consteval_string_view(constant_wrapper<Value>::value);
 }
 
+// Concatenate a pack of util::cw<"xyz">
+// NOLINTBEGIN(cppcoreguidelines-pro-bounds-array-to-pointer-decay, cppcoreguidelines-pro-bounds-pointer-arithmetic, modernize-avoid-c-arrays)
+export template <auto... Strings>
+consteval auto consteval_strcat(constant_wrapper<Strings>... /*strings*/) {
+	using char_type = identical_type_t<std::remove_extent_t<typename constant_wrapper<Strings>::value_type>...>;
+	constexpr auto chars = [ & ]() -> auto {
+		constexpr auto size = (... + (std::extent_v<typename constant_wrapper<Strings>::value_type> - 1));
+		std::array<char_type, size + 1> chars{};
+		std::size_t offset = 0;
+		(..., (std::ranges::copy(Strings.value, chars.data() + offset), offset += std::extent_v<typename constant_wrapper<Strings>::value_type> - 1));
+		return chars;
+	}();
+	auto [... indices ] = sequence<chars.size()>;
+	constexpr char_type string[ chars.size() ] = {chars[ indices ]...};
+	return cw<string>;
+}
+// NOLINTEND(cppcoreguidelines-pro-bounds-array-to-pointer-decay, cppcoreguidelines-pro-bounds-pointer-arithmetic, modernize-avoid-c-arrays)
+
 // 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.
 template <class Char, std::size_t Extent>

package/utility/utility.cc

@@ -4,6 +4,7 @@ export import :utility.covariant_value;
 export import :utility.facade;
 export import :utility.hash;
 export import :utility.ranges;
+export import :utility.sequence;
 export import :utility.string;
 // export import :utility.variant;
 import std;
@@ -31,22 +32,6 @@ export class non_moveable {
 		auto operator=(const non_moveable&) = delete;
 };
 
-// Return a sequence of index constants
-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 `std::size_t`.
-	// https://clang.llvm.org/cxx_status.html
-
-	// std::array<std::size_t, Size> result{};
-	// 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 {
-		return std::tuple{std::integral_constant<std::size_t, Index>{}...};
-	}(std::make_index_sequence<Size>());
-}();
-
 // Checked container / range access for types which don't have `.at()`
 export auto at(auto&& range, std::size_t index) -> decltype(auto) {
 	if (range.size() <= index) {