@auto_js/utility 0.0.2 → 0.0.4

package/functional/function_ref.cc

@@ -24,7 +24,11 @@ class function_ref<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)} {}
+				invoke_{[](void* ptr, Args... args) noexcept(Nx) -> Result {
+					auto& fn = *reinterpret_cast<signature_type*>(ptr);
+					return fn(std::forward<Args>(args)...);
+				}},
+				ptr_{reinterpret_cast<void*>(function)} {}
 
 		template <std::invocable<Args...> Object>
 			requires(type<Object> != type<function_ref>)

package/package.json

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

package/utility/facade.cc

@@ -3,30 +3,37 @@ import std;
 
 namespace util {
 
-// Internal addition facade
-template <class difference_type_>
-class addition_facade {
+// Implements `Type++` via `++Type`
+export class incrementable_facade {
 	public:
-		using difference_type = difference_type_;
-
-		// ++Type
-		auto operator++(this auto& self) -> auto& { return self += 1; }
+		using difference_type = int;
 
 		// Type++
-		auto operator++(this auto& self, int) {
+		constexpr auto operator++(this auto& self, int) {
 			auto result = self;
 			++self;
 			return result;
 		}
+};
+
+// Implements addition operators via `operator+=()`
+export template <class difference_type_>
+class addition_facade : public incrementable_facade {
+	public:
+		using incrementable_facade::operator++;
+		using difference_type = difference_type_;
+
+		// ++Type
+		constexpr auto operator++(this auto& self) -> auto& { return self += 1; }
 
 		// Type + difference_type
-		auto operator+(this const auto& self, difference_type offset) {
+		constexpr auto operator+(this const auto& self, difference_type offset) {
 			auto result = self;
 			return result += offset;
 		}
 
 		// difference_type + Type
-		friend auto operator+(difference_type left, const auto& right) {
+		constexpr friend auto operator+(difference_type left, const auto& right) {
 			return right + left;
 		}
 };
@@ -47,26 +54,26 @@ class subtraction_facade<difference_type_, wide_size_type> {
 		using difference_type = difference_type_;
 
 		// Type -= difference_type
-		auto operator-=(this auto& self, difference_type offset) -> auto& { return self += -offset; }
+		constexpr auto operator-=(this auto& self, difference_type offset) -> auto& { return self += -offset; }
 
 		// --Type
-		auto operator--(this auto& self) -> auto& { return self -= 1; }
+		constexpr auto operator--(this auto& self) -> auto& { return self -= 1; }
 
 		// Type--
-		auto operator--(this auto& self, int) {
+		constexpr auto operator--(this auto& self, int) {
 			auto result = self;
 			--self;
 			return result;
 		}
 
 		// Type - difference_type
-		auto operator-(this const auto& self, difference_type offset) {
+		constexpr auto operator-(this const auto& self, difference_type offset) {
 			auto result = self;
 			return result -= offset;
 		}
 
 		// Type - Type
-		auto operator-(this const auto& self, decltype(self) right) -> difference_type {
+		constexpr auto operator-(this const auto& self, decltype(self) right) -> difference_type {
 			return static_cast<difference_type>(wide_size_type{+self} - wide_size_type{+right});
 		}
 };
@@ -97,7 +104,7 @@ class arithmetic_facade
 export template <class difference_type>
 class array_facade {
 	public:
-		auto operator[](this auto&& self, difference_type offset) -> decltype(auto) {
+		constexpr auto operator[](this auto&& self, difference_type offset) -> decltype(auto) {
 			return *(std::forward<decltype(self)>(self) + offset);
 		}
 };

package/utility/ranges.cc

@@ -52,4 +52,15 @@ export constexpr auto into_range(meta_range auto&& range) {
 	return std::forward<decltype(range)>(range).into_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) {
+	if constexpr (std::ranges::sized_range<Type>) {
+		return std::tuple{std::ranges::size(range)};
+	} else {
+		return std::tuple{};
+	}
+}
+
 } // namespace util

package/utility/string.cc

@@ -233,14 +233,14 @@ class codepoint_forward_view<char16_t> {
 
 		constexpr auto read() -> char32_t {
 			// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-			auto char0 = char32_t{*pos_++};
+			auto char0 = static_cast<char32_t>(*pos_++);
 			if (char0 >= 0xd800 && char0 < 0xdc00) {
 				if (eof()) {
 					// nb: Unpaired surrogate
 					return char0;
 				}
 				// NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
-				auto char1 = char32_t{*pos_++};
+				auto char1 = static_cast<char32_t>(*pos_++);
 				if (char1 >= 0xdc00 && char1 < 0xe000) {
 					return ((char0 - 0xd800) * 0x400) + (char1 - 0xdc00) + 0x1'0000;
 				} else {

package/utility/utility.cc

@@ -142,4 +142,34 @@ constexpr auto slice(const Type& value) {
 	return slice_t<const Type>{value};
 }
 
+// Implements construction of containers with variadic elements
+template <class Type>
+struct inplace_container_constructor {
+		constexpr auto operator()(auto&&... args) const -> Type {
+			return Type{std::in_place, std::forward<decltype(args)>(args)...};
+		}
+};
+
+template <class Type, std::size_t Size>
+struct inplace_container_constructor<std::array<Type, Size>> {
+		constexpr auto operator()(auto&&... args) const -> std::array<Type, Size> {
+			return std::array<Type, Size>{std::forward<decltype(args)>(args)...};
+		}
+};
+
+template <class Type, class Alloc>
+struct inplace_container_constructor<std::vector<Type, Alloc>> {
+		constexpr auto operator()(auto&&... args) const -> std::vector<Type, Alloc> {
+			auto container = std::vector<Type, Alloc>{};
+			container.reserve(sizeof...(args));
+			(..., container.emplace_back(std::forward<decltype(args)>(args)));
+			return container;
+		}
+};
+
+export template <class Type>
+auto make_inplace_container(auto&&... args) -> Type {
+	return inplace_container_constructor<Type>{}(std::forward<decltype(args)>(args)...);
+}
+
 } // namespace util