flanchan
/
libexopt
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added better null checks and assumptions. removed `is_boxed()` meta-polymorphism. added Box<T> children (non-virtual) to perform unsafe operations that may invalidate Box<T> invariant.

Browse Source 
Fortune for libexopt's current commit: Future blessing − 末吉
master
Avril 2 years ago
parent 3bdd503cb2
commit e78c765f45
Signed by: flanchan
GPG Key ID: 284488987C31F630
5 changed files with 232 additions and 121 deletions
Show Stats Download Patch File Download Diff File

190
include/boxed.h
Unescape View File

@ -10,7 +10,6 @@
#include "exopt.h" #include "exopt.h"
namespace exopt::types { namespace boxed { namespace exopt::types { namespace boxed {
template<typename T> template<typename T>
struct [[gnu::visibility("internal")]] boxable_value_type { using type = std::conditional_t struct [[gnu::visibility("internal")]] boxable_value_type { using type = std::conditional_t
<std::is_reference_v<T> <std::is_reference_v<T>
@ -31,7 +30,7 @@ namespace exopt::types { namespace boxed {
requires(std::is_copy_constructible_v<T>) requires(std::is_copy_constructible_v<T>)
{ if(__builtin_expect(!bool(c), false)) { if(__builtin_expect(!bool(c), false))
#ifdef DEBUG #ifdef DEBUG
throw ptr::null_exception<T>{}; throw ptr::NullDerefException<T>{};
#else #else
__builtin_unreachable(); __builtin_unreachable();
#endif #endif
@ -63,17 +62,16 @@ namespace exopt::types { namespace boxed {
{ static_cast<std::decay_t<To> &&>(from) } -> std::convertible_to<To>; { static_cast<std::decay_t<To> &&>(from) } -> std::convertible_to<To>;
}; };
struct ErasedTypeDeleter { /*struct ErasedTypeDeleter {
constexpr virtual ~ErasedTypeDeleter() = default; constexpr virtual ~ErasedTypeDeleter() = default;
constexpr ErasedTypeDeleter() noexcept = default; constexpr ErasedTypeDeleter() noexcept = default;
constexpr virtual void apply_delete() = 0; constexpr virtual void apply_delete() = 0;
//TODO: See below... //TODO: See below...
}; };*/
template<polymorphic_castable<void> T> template<polymorphic_castable<void> T>
constexpr auto uniq_erase_type(std::unique_ptr<T>&& from) noexcept { constexpr auto uniq_erase_type(std::unique_ptr<T>&& from) noexcept {
//TODO: Overload case for `unique_ptr<T, D>` for `deleter` to apply (and contain) `D()` on back_cast()ed pointer T* instead of assuming default `delete`.
struct deleter final /*: public ErasedTypeDeleter XXX <- Is this useful, for unerasing the type, maybe?*/ { struct deleter final /*: public ErasedTypeDeleter XXX <- Is this useful, for unerasing the type, maybe?*/ {
typedef T type; typedef T type;
@ -94,18 +92,26 @@ namespace exopt::types { namespace boxed {
delete static_cast<T*>(p); delete static_cast<T*>(p);
} }
constexpr T* back_cast(void *p) noexcept { return static_cast<T*>(p); } constexpr T* back_cast(void *p) noexcept { return static_cast<T*>(p); }
/*constexpr deleter() noexcept = default; constexpr deleter() noexcept = default;
constexpr ~deleter() noexcept = default;*/ constexpr deleter(deleter const&) noexcept = default;
constexpr deleter(deleter &&) noexcept = default;
constexpr deleter& operator=(deleter const&) noexcept = default;
constexpr deleter& operator=(deleter &&) noexcept = default;
constexpr ~deleter() noexcept = default;
}; };
return std::unique_ptr<void, deleter> { return std::unique_ptr<void, deleter> {
//XXX: Cannot retain type information of most-derived class from this: \ // Cannot retain type information of most-derived class from this: \
dynamic_cast<void*> dynamic_cast<void*>
static_cast<void*> static_cast<void*>
(std::move(from).release()) (std::move(from).release())
}; };
} }
template<polymorphic_castable<void> T, typename D> requires(requires{ typename std::unique_ptr<T, D>; }) template<polymorphic_castable<void> T, typename D> requires(requires{
typename std::unique_ptr<T, D>;
requires(!std::is_same_v<std::unique_ptr<T, D>::deleter_type, std::unique_ptr<T>::deleter_type);
})
constexpr auto uniq_erase_type(std::unique_ptr<T, D>&& from) noexcept { constexpr auto uniq_erase_type(std::unique_ptr<T, D>&& from) noexcept {
class deleter final { class deleter final {
D m_del; D m_del;
@ -127,6 +133,7 @@ namespace exopt::types { namespace boxed {
constexpr deleter& operator=(const deleter&) noexcept(std::is_nothrow_copy_assignable_v<D>) = default; constexpr deleter& operator=(const deleter&) noexcept(std::is_nothrow_copy_assignable_v<D>) = default;
constexpr deleter& operator=(deleter&&) noexcept(std::is_nothrow_move_assignable_v<D>) = default; constexpr deleter& operator=(deleter&&) noexcept(std::is_nothrow_move_assignable_v<D>) = default;
constexpr ~deleter() noexcept(std::is_nothrow_destructible_v<D>) requires(std::is_trivially_destructible_v<D>) = default;
constexpr ~deleter() noexcept(std::is_nothrow_destructible_v<D>) {} constexpr ~deleter() noexcept(std::is_nothrow_destructible_v<D>) {}
}; };
if constexpr(std::is_default_constructible_v<D>) if constexpr(std::is_default_constructible_v<D>)
@ -166,72 +173,8 @@ namespace exopt::types { namespace boxed {
else return static_uniq_cast(std::move(from)); else return static_uniq_cast(std::move(from));
} }
#if 0
//TODO: Cannot be implemented with this method
constexpr bool is_boxed_value(auto const& value) noexcept {
return bool(dynamic_cast<ObjectBase const*>(std::addressof(value)));
}
template<typename T>
constexpr bool is_boxed_type() noexcept {
using type = std::remove_reference_t<T>;
constexpr type const* VALUE = nullptr;
return bool(dynamic_cast<ObjectBase const*>(VALUE));
}
// We need either: Tagged pointers (XOR, bit-mangled, manual heap, or GOT (external allocation) kind), \
or (preferred): layout of Box<T> to be `{ aligned<T>(T, box_type_tag) } unique*` \
box_type_tag should be: One pointer width, starting at offset *T+1 (aligned to T within internal tuple struct), provides a way to access RTTI for `*T`, a pointer to static (non-allocated) type information or dynamic_cast used lambda would be ideal.
#endif
/// Base class which is used to store the layout of Box<T>'s allocated memory. Intended for use to determine if a certain `T`'s `this` pointer is inside a `Box<T>` or not.
class dynamic_boxed_layout_base{
using Self = dynamic_boxed_layout_base;
public:
constexpr dynamic_boxed_layout_base() noexcept = default;
constexpr ~dynamic_boxed_layout_base() = default;
typedef void* (dynamic_cast_t)(Self*);
typedef const void* (dynamic_const_cast_t)(Self const*);
constexpr virtual size_t value_byte_offset() const noexcept =0;
[[gnu::returns_nonnull]]
constexpr void* extract_untyped_pointer() noexcept {
return reinterpret_cast<void*>(
reinterpret_cast<this>(unsigned char*) + value_byte_offset()
);
}
[[gnu::returns_nonnull]]
constexpr const void* extract_untyped_pointer() const noexcept {
return reinterpret_cast<void const*>(
reinterpret_cast<this>(const unsigned char*) + value_byte_offset()
);
}
constexpr virtual void* invoke_casting_shim(dynamic_cast_t const*) const noexcept =0;
template<typename T>
constexpr bool is_typeof() const noexcept { return invoke_casting_shim([] (Self* self) { return dynamic_cast<T*>(self)
template<typename T>
[[gnu::returns_nonnull]]
inline T* extract_pointer_unsafe() noexcept {
return reinterpret_cast<T*>(extract_untyped_pointer());
}
template<typename T>
[[gnu::returns_nonnull]]
inline const T* extract_pointer_unsafe() const noexcept {
return reinterpret_cast<const T*>(extract_untyped_pointer());
}
template<typename T>
[[gnu::returns_nonnull]]
inline T* try_extract_pointer() noexcept {
return is_typeof<T>() ? extract_pointer_unsafe<T>() : nullptr;
}
};
template<typename T> template<typename T>
struct Box final { struct alignas(std::unique_ptr<T>) Box {
typedef boxable_value_type<T>::type type; typedef boxable_value_type<T>::type type;
template<std::derived_from<T> U, bool RuntimeCheck=false> template<std::derived_from<T> U, bool RuntimeCheck=false>
@ -277,15 +220,24 @@ namespace exopt::types { namespace boxed {
} }
[[gnu::nonnull(1)]] [[gnu::nonnull(1)]]
constexpr static Box<T> from_raw_ptr(T* ptr) noexcept { constexpr static Box<T> from_raw_ptr(T* ptr) noexcept(!_EO(DEBUG)) {
#if DEBUG
ptr::throw_if_null(ptr);
#endif
return Box<T>{ std::unique_ptr<T>{ ptr } }; return Box<T>{ std::unique_ptr<T>{ ptr } };
} }
constexpr static Box<T> from_raw_ptr(std::unique_ptr<T>&& uniq)
constexpr static Box<T> from_raw_ptr(std::unique_ptr<T>&& uniq) {
if(__builtin_expect(!bool(uniq), false)) ptr::throw_null_exception<T>();
_EO_ASSUME(uniq.get() != nullptr);
return Box<T> { std::move(uniq) };
}
constexpr static Box<T> from_raw_ptr_unchecked(std::unique_ptr<T>&& uniq) noexcept(!_EO(DEBUG)) {
#if DEBUG #if DEBUG
{ if(__builtin_expect(!uniq, false)) throw ptr::NullException{}; if(__builtin_expect(!uniq, false)) ptr::throw_null_exception<T>();
#else #else
noexcept {
_EO_ASSUME(uniq.get() != nullptr); _EO_ASSUME(uniq.get() != nullptr);
#endif #endif
return Box<T>{ std::move(uniq) }; return Box<T>{ std::move(uniq) };
@ -300,49 +252,63 @@ namespace exopt::types { namespace boxed {
//TODO: Accessors, `(explicit?) operator std::unique_ptr<T> const&[&]`?, etc. //TODO: Accessors, `(explicit?) operator std::unique_ptr<T> const&[&]`?, etc.
constexpr ~Box() = default; constexpr ~Box() = default;
private: protected:
constexpr explicit Box(std::unique_ptr<T>&& ptr) // For types that may need to invalidate the Box<T> guarantee without exposing it in API, they can inherit (non-virtual).
: m_ptr(std::move(ptr)) {
_EO_ASSUME(m_ptr.get());
}
// TODO: Identifying if a value `this` pointer is boxed // For unsafe operations, wether or not to apply checks.
struct alignas(type) inner_layout_t final : public dynamic_boxed_layout_base { enum unsafe_t {
using boxed_value_t = type; UNSAFE,
};
enum maybe_unsafe_t {
CHECKED,
DEBUG_CHECKED,
};
constexpr inner_layout_t(type&& v) noexcept(std::is_nothrow_move_constructible_v<type>) constexpr Box(util::exact_type<unsafe_t> auto u, std::unique_ptr<T>&& ptr) noexcept
: value(std::move(v)) {} : m_ptr(std::move(ptr)) { (void)u; }
//TODO: All the ctors, assigns, and operators that can make this newtype wrapper more conveniently useable as a deref-target for accessing `value`.
constexpr /*virtual*/ ~inner_layout_t() = default; constexpr static Box<T> from_raw_ptr(unsafe_t u, std::unique_ptr<T>&& uniq) noexcept {
return Box{u, std::move(uniq)};
}
[[gnu::const]] constexpr std::unique_ptr<T>& as_unique(unsafe_t) & noexcept { return m_ptr; }
constexpr size_t value_byte_offset() const noexcept override { return offsetof(inner_layout_t, value); } constexpr std::unique_ptr<T> const & as_unique(unsafe_t) const& noexcept { return m_ptr; }
type value; constexpr std::unique_ptr<T>&& as_unique(unsafe_t) && noexcept { return std::move(m_ptr); }
}; constexpr std::unique_ptr<T> const&& as_unique(unsafe_t) const&& noexcept { return std::move(m_ptr); }
struct inner_unique_ptr_t final { constexpr T* as_unsafe_ptr(unsafe_t) const noexcept { return m_ptr.get(); }
std::unique_ptr<inner_layout_t> constexpr std::unique_ptr<T> swap_unsafe_ptr(unsafe_t u, T* raw) noexcept
}; { return (void)u; std::exchange(std::move(m_ptr), std::unique_ptr<T>{ raw }); }
constexpr void set_unsafe_ptr(unsafe_t 8, T* raw) noexcept {
inner_unique_ptr_t m_ptr; // Unique<T> m_ptr; (void)u;
}; m_ptr.reset(raw);
}
constexpr decltype(auto) set_unsafe(unsafe_t u, std::unique_ptr<T>&& ptr) noexcept
{ (void)u; return std::exchange(std::move(m_ptr), std::move(ptr)); }
constexpr auto& swap_unsafe(unsafe_t, std::unique_ptr<T>& ptr) noexcept {
using std::swap;
swap(m_ptr, ptr);
return m_ptr;
}
#define _EO_ADD_RV std::add_rvalue_reference_v constexpr T* release_unsafe(unsafe_t) noexcept { return m_ptr.release(); }
private:
constexpr explicit Box(std::unique_ptr<T>&& ptr) noexcept
: m_ptr(std::move(ptr)) {
_EO_ASSUME(m_ptr.get());
}
template<typename Base, typename T = Base> std::unique_ptr<T> m_ptr; // Unique<T> m_ptr;
constexpr inline bool is_boxable_v = binary_convertible<_EO_ADD_RV<T>, _EO_ADD_RV<Base> > and requires(T&& value) {
typename Box<Base>;
typename Box<Base>::type;
{ std::make_unique<T>(std::move(value)) } -> std::same_as<std::unique_ptr<T>>;
}; };
static_assert(util::shares_layout<Box<_Complex double>, _Complex double*>, "Invalid Box<T> memory layout: More than just T*");
static_assert(util::shares_layout<Box<_Complex double>, std::unique_ptr<_Complex double>>, "Invalid Box<T> memory layout: More than just std::unique_ptr<T>");
template<typename T> concept is_boxable = is_boxable_v<T>; template<typename T> concept is_boxable = is_boxable_v<T>;
template<typename T> template<typename T>
constexpr inline bool is_nothrow_boxable_v = is_boxable_v<T> && std::is_nothrow_constructible_v<Box<T>, T>; constexpr inline bool is_nothrow_boxable_v = is_boxable_v<T> && std::is_nothrow_constructible_v<Box<T>, T>;
#undef _EO_ADD_RV
template<typename T, typename U> requires(requires(T&& o) { static_cast<U&&>(o); }) template<typename T, typename U> requires(requires(T&& o) { static_cast<U&&>(o); })
constexpr Box<U> static_box_cast(Box<T>&& b) noexcept { return Box<U>::from_raw_ptr(static_cast<U*>(b.release())); } constexpr Box<U> static_box_cast(Box<T>&& b) noexcept { return Box<U>::from_raw_ptr(static_cast<U*>(b.release())); }
@ -356,7 +322,12 @@ namespace exopt::types { namespace boxed {
delete rel; delete rel;
throw; throw;
} }
} //TODO: Overload for `const&` that does the type check *before* the copy allocation. }
template<typename T, typename U> requires(requires(T const& o) { static_cast<U const&>(o); })
constexpr Box<U> dynamic_box_cast(Box<T> const& b) {
return Box<U>::from_raw_ptr(std::addressof(dynamic_cast<U const&>(*b)));
}
#if 0 #if 0
template<typename T, typename R /*XXX: Maybe remove this, and put the requires after the definition, using `auto&& value` instead of `R&& value`*/> requires(std::derived_from<R, T>) template<typename T, typename R /*XXX: Maybe remove this, and put the requires after the definition, using `auto&& value` instead of `R&& value`*/> requires(std::derived_from<R, T>)
@ -399,6 +370,8 @@ namespace exopt::types { namespace boxed {
using boxed::Box; using boxed::Box;
} }
//TODO: See phone notes on correctly implementing the nullopt for Box<T>
#if 0
namespace exopt::types { namespace optional [[gnu::visibility("internal")]] { namespace exopt::types { namespace optional [[gnu::visibility("internal")]] {
template<typename T> template<typename T>
struct null_optimise<boxed::Box<T> > { constexpr static inline bool value = true; struct null_optimise<boxed::Box<T> > { constexpr static inline bool value = true;
@ -413,3 +386,4 @@ namespace exopt::types { namespace optional [[gnu::visibility("internal")]] {
} }
#endif

21
include/exopt.h
Unescape View File

@ -22,17 +22,36 @@ extern "C" {
#define _exopt__internal __attribute__((visibility("internal"))) #define _exopt__internal __attribute__((visibility("internal")))
#define _exopt__readonly __attribute__((__pure__)) #define _exopt__readonly __attribute__((__pure__))
#define _exopt__pure __attribute__((__const__)) #define _exopt__pure __attribute__((__const__))
#ifdef DEBUG
# define _exopt__DEBUG 1
#else
# define _exopt__DEBUG 0
#endif
#ifdef RELEASE
# define _exopt__RELEASE 1
#else
# define _exopt__RELEASE 0
#endif
#ifdef _EO__OPT_OLD_ASSUME #ifdef _EO__OPT_OLD_ASSUME
# define _EO_ASSUME(X) ({ if(! (X)) __builtin_unreachable(); }) # define _EO_ASSUME(X) ({ if(! (X)) __builtin_unreachable(); })
#endif #endif
#define _EO_FIXED_INT(B) _BitInt(B)
#define _EO_GNU_ATTR(...) __attribute__((__VA_ARGS__))
#if _EO(cpp) #if _EO(cpp)
# define _EO_ATTR(...) [[__VA_ARGS__]]
# define _EO_SHARES_LAYOUT(T, U) (sizeof(T) == sizeof(U) && alignof(T) == alignof(U))
# ifndef _EO_ASSUME # ifndef _EO_ASSUME
# define _EO_ASSUME(X) [[gnu::assume(X)]] # define _EO_ASSUME(X) [[gnu::assume(X)]]
# endif # endif
# define _exopt__restrict __restrict__ # define _exopt__restrict __restrict__
#else #else /* C */
# define _EO_ATTR(...) __attribute__((__VA_ARGS__))
# define _EO_SHARES_LAYOUT(T, U) (sizeof(T) == sizeof(U) && alignof(T) == alignof(U))
# define _EO_SHARES_LAYOUT(T, U) (sizeof(T) == sizeof(U) && _Alignof(T) == _Alignof(U))
# ifndef _EO_ASSUME # ifndef _EO_ASSUME
# define _EO_ASSUME(X) __attribute__((assume(X))) # define _EO_ASSUME(X) __attribute__((assume(X)))
# endif # endif

2
include/optional.h
Unescape View File

@ -31,8 +31,6 @@ namespace exopt::types { namespace optional [[gnu::visibility("internal")]] {
constexpr static inline auto sentinel = nullptr; constexpr static inline auto sentinel = nullptr;
}; };
template<typename T> template<typename T>
struct null_optimise<ptr::Unique<T> > { constexpr static inline bool value = true; struct null_optimise<ptr::Unique<T> > { constexpr static inline bool value = true;
using held_type = T __restrict__*; using held_type = T __restrict__*;

34
include/pointer.h
Unescape View File

@ -104,6 +104,33 @@ namespace exopt::ptr {
return std::forward<decltype(ptr)>(ptr); return std::forward<decltype(ptr)>(ptr);
} }
template<typename E, typename... Args> requires(std::is_constructible_v<E, Args...>)
constexpr decltype(auto) throw_if_null(PointerEqCmp auto const& ptr, Args&&... error) {
auto _throw = [&] [[noreturn, gnu::noinline, gnu::cold]] () {
throw E{std::forward<Args>(error)...};
};
if(ptr == nullptr) _throw();
return std::forward<decltype(ptr)>(ptr);
}
[[gnu::always_inline]]
constexpr decltype(auto) throw_if_null(PointerEqCmp auto const& ptr) {
if(__builtin_expect(ptr == nullptr, false)) throw_null_exception<decltype(ptr)>();
return std::forward<decltype(ptr)>(ptr);
}
// Throws NullDerefException<?> for first type of `ptr` that is null (if any are).
// If: `All == true`: Instead will always throw `NullDerefException<T...> (all types) if any are, and will not assume every pointer is likely to be non-null.
template<bool All = false>
[[gnu::always_inline]]
constexpr void throw_if_null(PointerEqCmp auto const&... ptr) requires(sizeof...(decltype(ptr)) > 1) {
if constexpr(All) {
using E = NullDerefException<decltype(ptr)...>;
((void)throw_if_null<E>(std::forward<decltype(ptr)>(ptr)),...);
} else ((void)throw_if_null(std::forward<decltype(ptr)>(ptr)),...);
}
template<typename E, typename... Args> requires(std::is_constructible_v<E, Args...>) template<typename E, typename... Args> requires(std::is_constructible_v<E, Args...>)
constexpr decltype(auto) deref_or_throw(PointerDeref auto&& ptr, Args&&... error) constexpr decltype(auto) deref_or_throw(PointerDeref auto&& ptr, Args&&... error)
{ {
@ -190,6 +217,13 @@ namespace exopt::ptr {
consteval NullException/*&&*/ null_exception() noexcept { return {}; } consteval NullException/*&&*/ null_exception() noexcept { return {}; }
template<typename... Types>
[[noreturn, gnu::noinline, gnu::cold]]
constexpr void throw_null_exception() { throw null_exception<Types...>(); }
[[noreturn, gnu::noinline, gnu::cold]]
constexpr void throw_null_exception() { throw null_exception(); }
template<typename T> requires(!std::is_reference_v<T>) template<typename T> requires(!std::is_reference_v<T>)
struct NonNull { struct NonNull {

100
include/util.hh
Unescape View File

@ -68,6 +68,12 @@ namespace exopt { namespace util [[gnu::visibility("internal")]] {
static_assert(_EO_CONSTANT_VALUE(std::string_view{"hello world"}) == std::string_view{"hello world"}, "Bad CONSTANT_VALUE()"); static_assert(_EO_CONSTANT_VALUE(std::string_view{"hello world"}) == std::string_view{"hello world"}, "Bad CONSTANT_VALUE()");
template<typename T, typename U>
concept shares_layout = sizeof(T) == sizeof(U) && alignof(T) == alignof(U);
template<typename T, typename U>
concept exact_type = std::is_same_v<T, U>;
template<typename T, size_t N, typename Array= std::array<T, N>, typename _I = std::make_index_sequence<N>> template<typename T, size_t N, typename Array= std::array<T, N>, typename _I = std::make_index_sequence<N>>
constexpr auto array_literal(const T (&a)[N]) noexcept constexpr auto array_literal(const T (&a)[N]) noexcept
-> Array -> Array
@ -178,17 +184,90 @@ namespace exopt { namespace util [[gnu::visibility("internal")]] {
static_assert(concat_str_v< std::string_view{"hello"}, std::string_view{" "}, std::string_view{"view"} > static_assert(concat_str_v< std::string_view{"hello"}, std::string_view{" "}, std::string_view{"view"} >
== std::string_view{"hello view"}, "concat_str_v<>: Concatenated string_view failed"); == std::string_view{"hello view"}, "concat_str_v<>: Concatenated string_view failed");
template<template<typename> P, typename... Values>
struct _EO(internal) is_all_match {
constexpr static inline auto value = (P<Values> && true && ...);
consteval operator auto() const noexcept { return value; }
};
template<template<typename> P, typename... Values>
struct _EO(internal) is_any_match {
constexpr static inline auto value = (P<Values> || false || ...);
consteval operator auto() const noexcept { return value; }
};
//XXX: Idk if template<template<s are allowed in this context...
template<template<typename> P, typename... Values> requires(requires{ typename is_all_match<P, Values>; })
constexpr inline auto is_all_match_v = is_all_match<P, Values...>::value;
template<template<typename> P, typename... Values> requires(requires{ typename is_any_match<P, Values>; })
constexpr inline auto is_any_match_v = is_any_match<P, Values...>::value;
template<auto... Values>
struct _EO(internal) is_all {
constexpr static inline auto value = (Values && true && ...);
};
template<auto... Values>
struct _EO(internal) is_any {
constexpr static inline auto value = (Values || false || ...);
};
template<auto... Values>
constexpr inline auto is_all_v = is_all<Values...>::value;
template<auto... Values>
constexpr inline auto is_any_v = is_any<Values...>::value;
template<typename... Args>
constexpr inline bool is_empty_v = sizeof...(Args) == 0;
template<auto... Values> // auto and typename aren't compatible unfortunately
constexpr inline bool is_empty_vv = sizeof...(Values) == 0;
// Convenience immediate function overloads for checking if a parameter pack *or* a value pack is empty without different names.
template<typename... A>
consteval bool is_empty_pack() noexcept { return sizeof...(A) == 0; }
template<auto... A>
consteval bool is_empty_pack() noexcept { return sizeof...(A) == 0; }
/// Deducable version of `is_empty_pack<typename...>()`
///
/// Can be used as `is_empty_pack(pack...)` instead of the slightly more ugly `is_empty_pack<decltype(pack)...>()` though with (very unlikely, but possible) implications of actually "evaluating" the pack (despite the values themselves are `const&` and never used, they're still passed.)
/// HOWEVER: The latter should likely be preferred, since this function takes possible-nonconstexpr types as arguments, it cannot be immediate like the non-argument taking overload. See below comment for more information on that.
template<typename... A>
[[gnu::const]] //TODO: XXX: This mostly useless function won't mess up overload resolution for `is_empty_pack<types...>()`, right? If it will, either find a way to make sure it comes LAST, or remove it, it's not worth the hassle just so users (i.e. me) can avoid typeing `decltype` for once in my fuckin life... what a stupud keyword name srsl (see static_assert() below.)
constexpr auto is_empty_pack(A const&...) noexcept { return is_empty_pack<A...>(); } // This overload exists for: e.g usage for index_sequence: \
`template<size_t N> f(const auto (&v)[N]) -> \
template<size_t Is...> _f(auto const& v, std::index_sequence<Is...>);`\
Can be used like: \
_f(const auto&v, std::convertible_to<size_t> auto&&... is) \
{ if constexpr(is_empty_pack(is...)) { ... } ... }` \
i.e: for unknown-typed non-type parameter packs `auto...`s packs can be `forward<decltype(pack)>(pack)...`'d (or just passed, as the taken value is always `const&`) to is_empty_pack(...) and `A...` can therefor be deduced. This is not possible for the non-value taking overloads, and also must be non-consteval since any `A` might not be constexpr. \
\
It is a convenience function that is essentially equivelent to `is_empty_pack<decltype(pack)...>()`, which should be preferred, since it is consteval and will always be guaranteed to be consteval regardless of the contents of `pack` itself, but I highly doubt any compiler will actually generate any argument-passing code for this overload either.
static_assert(!is_empty_pack<int, long, float>()
and is_empty_pack<>() //XXX: This might also be ambiguous between the type and value one... Eh.... That's actually useful though, so removing this explicit (and pointless) *usage* of the function from the test would be fine if they don't clash in other ways too.
and !is_empty_pack<0, 1, 2>()
and !is_empty_pack(0u, 1.0, 2l)
and is_empty_pack(), "`is_empty_pack()` overload issues.");
template<typename R, typename... Args> template<typename R, typename... Args>
constexpr auto map(auto const& fun, Args&&... values) noexcept((std::is_nothrow_invocable_v<decltype(fun), Args> && ...)) constexpr auto map(auto const& fun, Args&&... values) noexcept(is_empty_v<Args...> or is_all_v<std::is_nothrow_invocable_v<decltype(fun), Args>...>)
requires((std::is_invocable_v<decltype(fun), Args> && ...) and ( requires(is_empty_v<Args...> or (is_all_v<std::is_invocable_v<decltype(fun), Args>...> and (
(std::is_void_v<std::invoke_result_t<decltype(fun), Args>> || ...) || is_any_v<std::is_void_v<std::invoke_result_t<decltype(fun), Args>>...> ||
std::is_constructible_v<R, std::invoke_result_t<decltype(fun), Args>...>)) std::is_constructible_v<R, std::invoke_result_t<decltype(fun), Args>...>)))
-> std::conditional_t< (std::is_void_v<std::invoke_result_t<decltype(fun), Args>> || ...) -> std::conditional_t< is_empty_v<Args...> || is_any_v<std::is_void_v<std::invoke_result_t<decltype(fun), Args>>...>
, void , std::void_t<std::invoke_result_t<decltype(fun), Args>...>
, R> , R>
{ {
if constexpr( (std::is_void_v<std::invoke_result_t<decltype(fun), Args>> || ...) ) { if constexpr( is_any_v<std::is_void_v<std::invoke_result_t<decltype(fun), Args>>...> ) {
((void)std::invoke(fun, values),...); ((void)std::invoke(fun, values),...);
else if constexpr(sizeof...(Args) == 0)
(void)0;
} else return { std::invoke(fun, values)... }; } else return { std::invoke(fun, values)... };
} }
@ -197,6 +276,13 @@ namespace exopt { namespace util [[gnu::visibility("internal")]] {
template<typename... Args> template<typename... Args>
using map_tuple = map<std::tuple<Args...>, Args...>; using map_tuple = map<std::tuple<Args...>, Args...>;
//TODO: template< is_valid_metafunction_with_two_unknown_type_arguments_and_a_possibly_variable_return_type<R(T1, T2)> Op, typename... Args> \
auto reduce(auto const& fun, Op const& comb, Args&&... values) noexcept(...) \
requires(???) -> std::invoke_result_t<??????> { // TODO: Reframe the call to `comb` as an operator overload in a shim class, and use binary fold to make the call, like: ` \
shim s{comb}; return (s + std::invoke(fun, values) + ...); }`
template<typename Fn, typename... Args> requires((std::is_invocable_v<Fn, Args> && ...)) template<typename Fn, typename... Args> requires((std::is_invocable_v<Fn, Args> && ...))
constexpr void apply(const Fn& fun, Args&&... values) noexcept((std::is_nothrow_invocable_v<Fn, Args> && ...)) constexpr void apply(const Fn& fun, Args&&... values) noexcept((std::is_nothrow_invocable_v<Fn, Args> && ...))
/*-> std::conditional_t< (std::is_void_v<std::invoke_result_t<Fn, Args>> || ...) /*-> std::conditional_t< (std::is_void_v<std::invoke_result_t<Fn, Args>> || ...)

Write Preview
Loading…
Cancel
Save