@auto_js/utility 0.0.1

package/include/auto_js/chunk_view.h

@@ -0,0 +1,363 @@
+// https://github.com/llvm/llvm-project/pull/85741
+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+#include <version>
+#ifdef _LIBCPP_VERSION
+#ifndef _LIBCPP___RANGES_CHUNK_VIEW_H
+#define _LIBCPP___RANGES_CHUNK_VIEW_H
+
+#include <__concepts/constructible.h>
+#include <__concepts/convertible_to.h>
+#include <__functional/bind_back.h>
+#include <__iterator/advance.h>
+#include <__iterator/concepts.h>
+#include <__iterator/default_sentinel.h>
+#include <__iterator/distance.h>
+#include <__iterator/iterator_traits.h>
+#include <__ranges/access.h>
+#include <__ranges/all.h>
+#include <__ranges/concepts.h>
+#include <__ranges/enable_borrowed_range.h>
+#include <__ranges/subrange.h>
+#include <__ranges/take_view.h>
+#include <__ranges/view_interface.h>
+#include <__type_traits/make_unsigned.h>
+#include <__type_traits/maybe_const.h>
+#include <__config>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+#if _LIBCPP_STD_VER >= 23
+
+namespace ranges {
+
+template <class _Integer>
+constexpr _Integer __div_ceil(_Integer __num, _Integer __denom) {
+	_Integer __r = __num / __denom;
+	if (__num % __denom) {
+		++__r;
+	}
+	return __r;
+}
+
+template <view _View>
+	requires input_range<_View>
+class chunk_view : public view_interface<chunk_view<_View>> {};
+
+template <view _View>
+	requires forward_range<_View>
+class chunk_view<_View> : public view_interface<chunk_view<_View>> {
+	private:
+		_LIBCPP_NO_UNIQUE_ADDRESS _View __base_;
+		range_difference_t<_View> __n_;
+
+		template <bool>
+		class __iterator;
+
+	public:
+		constexpr explicit chunk_view(_View __base, range_difference_t<_View> __n) :
+				__base_(std::move(__base)), __n_(__n) {
+			_LIBCPP_ASSERT_UNCATEGORIZED(__n > 0, "__n must be greater than 0");
+		}
+
+		[[nodiscard]] constexpr _View base() const&
+			requires copy_constructible<_View>
+		{
+			return __base_;
+		}
+
+		[[nodiscard]] constexpr _View base() && { return std::move(__base_); }
+
+		[[nodiscard]] constexpr auto begin()
+			requires(!__simple_view<_View>)
+		{
+			return __iterator<false>(this, ranges::begin(__base_));
+		}
+
+		[[nodiscard]] constexpr auto begin() const
+			requires forward_range<const _View>
+		{
+			return __iterator<true>(this, ranges::begin(__base_));
+		}
+
+		[[nodiscard]] constexpr auto end()
+			requires(!__simple_view<_View>)
+		{
+			if constexpr (common_range<_View> && sized_range<_View>) {
+				auto __missing = (__n_ - ranges::distance(__base_) % __n_) % __n_;
+				return __iterator<false>(this, ranges::end(__base_), __missing);
+			} else if constexpr (common_range<_View> && !bidirectional_range<_View>) {
+				return __iterator<false>(this, ranges::end(__base_));
+			} else {
+				return default_sentinel;
+			}
+		}
+
+		[[nodiscard]] constexpr auto end() const
+			requires forward_range<_View>
+		{
+			if constexpr (common_range<const _View> && sized_range<const _View>) {
+				auto __missing = (__n_ - ranges::distance(__base_) % __n_) % __n_;
+				return __iterator<true>(this, ranges::end(__base_), __missing);
+			} else if constexpr (common_range<const _View> && !bidirectional_range<const _View>) {
+				return __iterator<true>(this, ranges::end(__base_));
+			} else {
+				return default_sentinel;
+			}
+		}
+
+		[[nodiscard]] constexpr auto size()
+			requires sized_range<_View>
+		{
+			return std::__to_unsigned_like(__div_ceil(ranges::distance(__base_), __n_));
+		}
+
+		[[nodiscard]] constexpr auto size() const
+			requires sized_range<const _View>
+		{
+			return std::__to_unsigned_like(__div_ceil(ranges::distance(__base_), __n_));
+		}
+};
+
+template <class _View>
+chunk_view(_View&&, range_difference_t<_View>) -> chunk_view<views::all_t<_View>>;
+
+template <class _View>
+constexpr inline bool enable_borrowed_range<chunk_view<_View>> = enable_borrowed_range<_View> && forward_range<_View>;
+
+template <view _View>
+	requires forward_range<_View>
+template <bool _Const>
+class chunk_view<_View>::__iterator {
+	private:
+		friend chunk_view;
+
+		using _Parent = __maybe_const<_Const, chunk_view>;
+		using _Base = __maybe_const<_Const, _View>;
+
+		iterator_t<_Base> __current_ = iterator_t<_Base>();
+		sentinel_t<_Base> __end_ = sentinel_t<_Base>();
+		range_difference_t<_Base> __n_ = 0;
+		range_difference_t<_Base> __missing_ = 0;
+
+		constexpr __iterator(
+			_Parent* __parent,
+			iterator_t<_Base> __current,
+			range_difference_t<_Base> __missing = 0
+		) :
+				__current_(std::move(__current)),
+				__end_(ranges::end(__parent->__base_)),
+				__n_(__parent->__n_),
+				__missing_(__missing) {}
+
+	public:
+		using iterator_category = input_iterator_tag;
+		using iterator_concept =
+			conditional_t<random_access_range<_Base>, random_access_iterator_tag, conditional_t<bidirectional_range<_Base>, bidirectional_iterator_tag, forward_iterator_tag>>;
+		using value_type = decltype(views::take(subrange(__current_, __end_), __n_));
+		using difference_type = range_difference_t<_Base>;
+
+		__iterator() = default;
+
+		constexpr __iterator(__iterator<!_Const> __i)
+			requires _Const && convertible_to<iterator_t<_View>, iterator_t<_Base>> &&
+								 convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
+				:
+				__current_(std::move(__i.__current_)),
+				__end_(std::move(__i.__end_)),
+				__n_(__i.__n_),
+				__missing_(__i.__missing_) {}
+
+		[[nodiscard]] constexpr iterator_t<_Base> base() const { return __current_; }
+
+		[[nodiscard]] constexpr value_type operator*() const {
+			_LIBCPP_ASSERT_PEDANTIC(__current_ != __end_, "Dereferencing past-the-end chunk_view iterator");
+			return views::take(subrange(__current_, __end_), __n_);
+		}
+
+		constexpr __iterator& operator++() {
+			_LIBCPP_ASSERT_PEDANTIC(__current_ != __end_, "Incrementing past-the-end chunk_view iterator");
+			__missing_ = ranges::advance(__current_, __n_, __end_);
+			return *this;
+		}
+
+		constexpr __iterator operator++(int) {
+			auto __tmp = *this;
+			++*this;
+			return __tmp;
+		}
+
+		constexpr __iterator& operator--()
+			requires bidirectional_range<_Base>
+		{
+			ranges::advance(__current_, __missing_ - __n_);
+			__missing_ = 0;
+			return *this;
+		}
+
+		constexpr __iterator operator--(int)
+			requires bidirectional_range<_Base>
+		{
+			auto __tmp = *this;
+			--*this;
+			return __tmp;
+		}
+
+		constexpr __iterator& operator+=(const difference_type __offset)
+			requires random_access_range<_Base>
+		{
+			if (__offset > 0) {
+				ranges::advance(__current_, __n_ * (__offset - 1));
+				__missing_ = ranges::advance(__current_, __n_, __end_);
+			} else if (__offset < 0) {
+				ranges::advance(__current_, __n_ * __offset + __missing_);
+				__missing_ = 0;
+			}
+			return *this;
+		}
+
+		constexpr __iterator& operator-=(const difference_type __offset)
+			requires random_access_range<_Base>
+		{
+			return *this += -__offset;
+		}
+
+		[[nodiscard]] constexpr value_type operator[](const difference_type __offset) const
+			requires random_access_range<_Base>
+		{
+			return *(*this + __offset);
+		}
+
+		[[nodiscard]] constexpr friend bool
+		operator==(const __iterator& __x, const __iterator& __y) {
+			return __x.__current_ == __y.__current_;
+		}
+
+		[[nodiscard]] constexpr friend bool
+		operator==(const __iterator& __x, default_sentinel_t) {
+			return __x.__current_ == __x.__end_;
+		}
+
+		[[nodiscard]] constexpr friend bool
+		operator==(const __iterator& __x, const __iterator& __y)
+			requires random_access_range<_Base>
+		{
+			return __x.__current_ < __y.__current_;
+		}
+
+		[[nodiscard]] constexpr friend bool
+		operator>(const __iterator& __x, const __iterator& __y)
+			requires random_access_range<_Base>
+		{
+			return __y < __x;
+		}
+
+		[[nodiscard]] constexpr friend bool
+		operator<=(const __iterator& __x, const __iterator& __y)
+			requires random_access_range<_Base>
+		{
+			return !(__y < __x);
+		}
+
+		[[nodiscard]] constexpr friend bool
+		operator>=(const __iterator& __x, const __iterator& __y)
+			requires random_access_range<_Base>
+		{
+			return !(__x < __y);
+		}
+
+		[[nodiscard]] constexpr friend auto
+		operator<=>(const __iterator& __x, const __iterator& __y)
+			requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
+		{
+			return __x.__current_ <=> __y.__current_;
+		}
+
+		[[nodiscard]] constexpr friend __iterator
+		operator+(const __iterator& __x, const difference_type __y)
+			requires random_access_range<_Base>
+		{
+			return __iterator{__x} += __y;
+		}
+
+		[[nodiscard]] constexpr friend __iterator
+		operator+(const difference_type __x, const __iterator& __y)
+			requires random_access_range<_Base>
+		{
+			return __y + __x;
+		}
+
+		[[nodiscard]] constexpr friend __iterator
+		operator-(const __iterator& __x, difference_type __y)
+			requires random_access_range<_Base>
+		{
+			return __iterator{__x} -= __y;
+		}
+
+		[[nodiscard]] constexpr friend difference_type
+		operator-(const __iterator& __x, const __iterator& __y)
+			requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
+		{
+			return (__x.__current_ - __y.__current_ + __x.__missing_ - __y.__missing_) / __x.__n_;
+		}
+
+		[[nodiscard]] constexpr friend difference_type
+		operator-(const default_sentinel_t, const __iterator& __x)
+			requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
+		{
+			return __div_ceil(__x.__end_ - __x.__current_, __x.__n_);
+		}
+
+		[[nodiscard]] constexpr friend difference_type
+		operator-(const __iterator& __x, const default_sentinel_t __y)
+			requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<_Base>>
+		{
+			return -(__y - __x);
+		}
+};
+
+namespace views {
+namespace __chunk {
+struct __fn {
+		template <class _Range, convertible_to<range_difference_t<_Range>> _Np>
+		[[nodiscard]] constexpr auto operator()(_Range&& __range, _Np&& __n) const noexcept(noexcept(chunk_view(std::forward<_Range>(__range), std::forward<_Np>(__n))))
+			-> decltype(chunk_view(std::forward<_Range>(__range), std::forward<_Np>(__n))) {
+			return chunk_view(std::forward<_Range>(__range), std::forward<_Np>(__n));
+		}
+
+		template <class _Np>
+			requires constructible_from<decay_t<_Np>, _Np>
+		[[nodiscard]] constexpr auto operator()(_Np&& __n) const noexcept(is_nothrow_constructible_v<decay_t<_Np>, _Np>) {
+			return __pipeable(std::__bind_back(*this, std::forward<_Np>(__n)));
+		}
+};
+} // namespace __chunk
+
+inline namespace __cpo {
+constexpr inline auto chunk = __chunk::__fn{};
+} // namespace __cpo
+} // namespace views
+
+} // namespace ranges
+
+#endif // _LIBCPP_STD_VER >= 23
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif // _LIBCPP___RANGES_CHUNK_VIEW_H
+#endif

package/include/auto_js/no_unique_address.h

@@ -0,0 +1,8 @@
+// See: https://devblogs.microsoft.com/cppblog/msvc-cpp20-and-the-std-cpp20-switch/
+// But the main reason this is a macro is because clang-format clobbers the msvc attribute for some
+// reason.
+#if _MSC_VER
+#define NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
+#else
+#define NO_UNIQUE_ADDRESS [[no_unique_address]]
+#endif

package/memory/autorelease_pool.cc

@@ -0,0 +1,281 @@
+module;
+#include "auto_js/no_unique_address.h"
+#include <algorithm>
+#include <cassert>
+#include <memory>
+#include <utility>
+#include <vector>
+export module util:memory.autorelease_pool;
+import :memory.comparator;
+import :utility;
+
+namespace util {
+
+// v8 may not invoke destructors on `External` objects, but we still want to give it owning
+// references to resources. This provides an allocator to manage those resources. If an
+// `autorelease_pool` goes out of scope then all objects allocated/created will be appropriately
+// destroyed and deallocated.
+//
+// - Not thread safe!
+// - Destroying a collected resourced after the group goes out of scope is UB.
+// - Does not work with non-object types.
+// - Does not work with arrays.
+// - Does not work with anything that uses placement-new (`std::shared_ptr`, `std::optional`,
+//   `std::vector`, actually probably a lot of things)
+
+template <class Type, class Alloc>
+class resource;
+
+// Base class of an allocated resource which knows how to destroy itself at any point in the lifecycle.
+template <class Alloc>
+class releasable {
+	protected:
+		using dtor_type = auto (releasable::*)(Alloc&) -> void;
+
+	private:
+		using allocator_traits = std::allocator_traits<Alloc>;
+
+		// Deleter for `std::unique_ptr` / `unique_pointer_type`
+		class deleter : private Alloc {
+			public:
+				constexpr explicit deleter(const Alloc& alloc) :
+						Alloc(alloc) {}
+
+				constexpr auto operator()(releasable* pointer) -> void {
+					pointer->release(*this);
+				}
+		};
+
+	public:
+		using unique_pointer_type = std::unique_ptr<releasable, deleter>;
+
+		constexpr explicit releasable(dtor_type dtor) noexcept :
+				dtor_{dtor} {}
+
+		// allocate a new `resource<T>` and construct it as `releasable` (which is a base class)
+		template <class Type>
+		constexpr static auto allocate(Alloc& alloc) -> unique_pointer_type {
+			using resource_type = resource<Type, Alloc>;
+			using resource_alloc_type = std::allocator_traits<Alloc>::template rebind_alloc<resource_type>;
+			using resource_alloc_traits = std::allocator_traits<resource_alloc_type>;
+			resource_alloc_type resource_alloc{alloc};
+			// dtor is initialized to destroy<releasable> + dealloc<resource>. `releasable()` ctor won't
+			// throw so this is correct.
+			releasable* ptr = resource_alloc_traits::allocate(resource_alloc, 1);
+			const auto dtor = dtor_type{&releasable::destroy_and_deallocate<Type, releasable>};
+			allocator_traits::construct(alloc, ptr, dtor);
+			return unique_pointer_type{ptr, deleter{alloc}};
+		}
+
+		// can also be invoked from `autorelease_pool::allocator`
+		template <class Type>
+		constexpr auto construct(Alloc& alloc, auto&&... args)
+			requires std::constructible_from<Type, decltype(args)...> {
+			using resource_type = resource<Type, Alloc>;
+			// "destroy" the releasable which should be trivial anyway
+			allocator_traits::destroy(alloc, this);
+			// construct resource on top of the existing allocated memory
+			const auto dtor = dtor_type{&releasable::deallocate<Type>};
+			auto* resource_ptr = static_cast<resource_type*>(this);
+			// dtor is initialized first, so if `Type` throws then dtor will be deallocate<releasable>
+			allocator_traits::construct(alloc, resource_ptr, dtor, std::forward<decltype(args)>(args)...);
+			// update destructor *after* successful construction
+			resource_ptr->dtor_ = &releasable::destroy_and_deallocate<Type, resource_type>;
+		}
+
+		// can also be invoked from `autorelease_pool::allocator`
+		template <class Type, class ConstructedType>
+		constexpr auto destroy(Alloc& alloc) -> void {
+			dtor_ = &releasable::deallocate<Type>;
+			allocator_traits::destroy(alloc, static_cast<ConstructedType*>(this));
+		}
+
+		template <class Type>
+		constexpr auto get() -> Type* {
+			using resource_type = resource<Type, Alloc>;
+			return static_cast<resource_type*>(this)->get();
+		}
+
+	private:
+		// dtor after `construct` is invoked
+		template <class Type, class ConstructedType>
+		constexpr auto destroy_and_deallocate(Alloc& alloc) -> void {
+			destroy<Type, ConstructedType>(alloc);
+			deallocate<Type>(alloc);
+		}
+
+		// dtor after `allocate` but before `construct` is invoked
+		template <class Type>
+		constexpr auto deallocate(Alloc& alloc) -> void {
+			using resource_type = resource<Type, Alloc>;
+			using resource_alloc_type = std::allocator_traits<Alloc>::template rebind_alloc<resource_type>;
+			using resource_alloc_traits = std::allocator_traits<resource_alloc_type>;
+			resource_alloc_type resource_alloc{alloc};
+			dtor_ = nullptr;
+			resource_alloc_traits::deallocate(resource_alloc, static_cast<resource_type*>(this), 1);
+		}
+
+		constexpr auto release(Alloc& alloc) -> void {
+			(this->*dtor_)(alloc);
+		}
+
+		dtor_type dtor_;
+};
+
+// Fully initialized object holder. This is constructed on top of a pre-allocated `releasable`.
+template <class Type, class Alloc>
+class resource : public releasable<Alloc>, private Type {
+	public:
+		constexpr explicit resource(releasable<Alloc>::dtor_type dtor, auto&&... args) :
+				releasable<Alloc>{dtor},
+				Type(std::forward<decltype(args)>(args)...) {}
+
+		constexpr auto get() -> Type* { return this; }
+		constexpr static auto translate(Type* ptr) -> resource* {
+			return static_cast<resource*>(ptr);
+			// Making `Type` a member variable allows instantiation of non-object and `final` classes but raises
+			// `-Wno-invalid-offsetof`.
+			// auto* bytes = reinterpret_cast<std::byte*>(ptr);
+			// // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic)
+			// return reinterpret_cast<resource*>(bytes - offsetof(resource, value_));
+		}
+};
+
+// Container of allocated resources. On destruction of the pool, all resources will be released.
+export class autorelease_pool : util::non_copyable {
+	private:
+		// Deleter for `std::unique_ptr`. This is different than the `releasable::deleter` in that it
+		// simply erases the pointer from the set. That, in turn, invokes the `releasable` destructor.
+		template <class Type>
+		class deleter {
+			public:
+				constexpr explicit deleter(autorelease_pool& pool) :
+						pool_{&pool} {}
+
+				auto operator()(Type* pointer) const -> void {
+					using resource_type = resource<Type, allocator_type>;
+					pool_->erase(resource_type::translate(pointer));
+				}
+
+			private:
+				autorelease_pool* pool_;
+		};
+
+		using allocator_type = std::allocator<void>;
+		using releasable_type = releasable<allocator_type>;
+		using container_type = std::vector<releasable_type::unique_pointer_type>;
+
+	public:
+		template <class> class allocator;
+		template <class Type>
+		using unique_ptr = std::unique_ptr<Type, deleter<Type>>;
+
+		autorelease_pool() = default;
+		explicit autorelease_pool(const allocator_type& alloc) :
+				allocator_{alloc} {}
+
+		auto clear() -> void {
+			releasables_.clear();
+		}
+
+		// Nope!
+		// template <class Type>
+		// constexpr auto make_shared(auto&&... args) -> std::shared_ptr<Type>
+		// 	requires std::constructible_from<Type, decltype(args)...> {
+		// 	return std::allocate_shared<Type>(allocator<Type>{*this}, std::forward<decltype(args)>(args)...);
+		// }
+
+		template <class Type>
+		auto make_unique(auto&&... args) -> unique_ptr<Type>
+			requires std::constructible_from<Type, decltype(args)...> {
+			releasable_type* allocation = emplace<Type>();
+			allocation->construct<Type>(allocator_, std::forward<decltype(args)>(args)...);
+			return reacquire(allocation->get<Type>());
+		}
+
+		constexpr auto resource_alloc() -> allocator_type& {
+			return allocator_;
+		}
+
+		template <class Type>
+		constexpr auto reacquire(Type* pointer) -> unique_ptr<Type> {
+			return unique_ptr<Type>{pointer, deleter<Type>{*this}};
+		}
+
+	protected:
+		template <class> friend class allocator;
+
+		template <class Type>
+		auto emplace() -> releasable_type* {
+			return releasables_.emplace_back(releasable_type::allocate<Type>(allocator_)), releasables_.back().get();
+		}
+
+		auto erase(releasable_type* ptr) -> void {
+			util::swap_and_pop(releasables_, find(ptr));
+		}
+
+		auto find(releasable_type* ptr) -> container_type::iterator {
+			auto iterator = std::ranges::find(releasables_, ptr, util::pointer_projection<releasable_type>{});
+			assert(iterator != releasables_.end());
+			return iterator;
+		}
+
+	private:
+		container_type releasables_;
+		NO_UNIQUE_ADDRESS allocator_type allocator_;
+};
+
+// Allocator which allocates in the underlying autorelease pool.
+template <class Type>
+class autorelease_pool::allocator {
+	private:
+		template <class> friend class allocator;
+		using resource_type = resource<Type, allocator_type>;
+
+	public:
+		using value_type = Type;
+		using pointer = value_type*;
+
+		// Nope!
+		template <class Other>
+		struct rebind {
+				using other = void;
+		};
+
+		// Initialize from pool
+		constexpr explicit allocator(autorelease_pool& pool) :
+				pool_{&pool} {}
+
+		// Copy from other allocator
+		template <class T>
+		constexpr explicit allocator(const allocator<T>& alloc) :
+				pool_{alloc.pool_} {}
+
+		constexpr auto allocate(std::size_t count) -> pointer {
+			if (count != 1) {
+				throw std::bad_array_new_length{};
+			}
+			releasable_type* allocation = pool_->emplace<value_type>();
+			return allocation->get<value_type>();
+		}
+
+		constexpr auto construct(pointer ptr, auto&&... args) -> void
+			requires std::constructible_from<value_type, decltype(args)...> {
+			auto* resource_ptr = resource_type::translate(ptr);
+			resource_ptr->template construct<Type>(pool_->resource_alloc(), std::forward<decltype(args)>(args)...);
+		}
+
+		constexpr auto deallocate(pointer ptr, std::size_t /*count*/) -> void {
+			pool_->erase(resource_type::translate(ptr));
+		}
+
+		constexpr auto destroy(pointer ptr) -> void {
+			resource_type* resource = resource_type::translate(ptr);
+			resource->template destroy<Type, resource_type>(pool_->resource_alloc());
+		}
+
+	private:
+		autorelease_pool* pool_;
+};
+
+} // namespace util

package/memory/comparator.cc

@@ -0,0 +1,53 @@
+module;
+#include <memory>
+export module util:memory.comparator;
+
+namespace util {
+
+// Range projection which extract underlying pointer of a type
+export template <class Type>
+struct pointer_projection {
+		[[nodiscard]] constexpr auto operator()(const Type* pointer) const -> const Type* {
+			return pointer;
+		}
+
+		template <class From>
+		[[nodiscard]] constexpr auto operator()(const std::shared_ptr<From>& pointer) const -> const Type* {
+			return pointer.get();
+		}
+
+		template <class From, class Deleter>
+		[[nodiscard]] constexpr auto operator()(const std::unique_ptr<From, Deleter>& pointer) const -> const Type* {
+			return pointer.get();
+		}
+};
+
+// General pointer binary comparison
+template <class Type, class Compare>
+class pointer_compare : private pointer_projection<Type> {
+	private:
+		using pointer_projection<Type>::operator();
+
+	public:
+		using is_transparent = void;
+
+		constexpr explicit pointer_compare(Compare compare = {}) :
+				compare_{std::move(compare)} {}
+
+		template <class Left, class Right>
+		constexpr auto operator()(const Left& left, const Right& right) const -> bool {
+			return compare_(operator()(left), operator()(right));
+		}
+
+	private:
+		Compare compare_;
+};
+
+// Concrete pointer binary comparators
+export template <class Type>
+using pointer_equal_to = pointer_compare<Type, std::equal_to<>>;
+
+export template <class Type>
+using pointer_less = pointer_compare<Type, std::less<>>;
+
+} // namespace util