#include <functional>
#include <memory>
#include <type_traits>

struct A {};

template <auto Value>
struct type_constant;

template <auto F, typename R, typename... Args>
struct invocable_base {
	constexpr R operator()(Args... args) const {
		return std::invoke(F, std::forward<Args>(args)...);
	}
};

template <auto F>
constexpr bool is_noexcept = noexcept(F());
#if __clang__
#elif __GCC__
template <typename R, typename... Args, R(F)(Args...)>
constexpr bool is_noexcept<F> = false;
template <typename R, typename... Args, R(F)(Args...) noexcept>
constexpr bool is_noexcept<F> = true;

#endif

template <typename R, typename... Args, R (*Fun)(Args...)>
struct type_constant<Fun> {
	static constexpr bool is_noexcept = noexcept(Fun(std::declval<Args>()...));
	constexpr R operator()(Args... args) const noexcept(is_noexcept) {
		return Fun(std::forward<Args>(args)...);
	}
	constexpr operator decltype(Fun)() const noexcept { return Fun; }
};
#if 0 && __clang__

template <typename R, typename... Args, R (*Fun)(Args...) noexcept>
struct type_constant<Fun> {
	static constexpr bool is_noexcept = true;
	constexpr R operator()(Args... args) const noexcept(is_noexcept) {
		return Fun(std::forward<Args>(args)...);
	}
	constexpr operator decltype(Fun)() const noexcept { return Fun; }
};
#endif

extern "C" void free_a(A* a) noexcept { delete a; }

using free_a_t = type_constant<free_a>;

void non_except() noexcept(true) {}
void except() noexcept(false) {}

static_assert(sizeof(free_a_t) == 1);
// static_assert(free_a_t::is_noexcept);
static_assert(!type_constant<except>::is_noexcept);
static_assert(is_noexcept<non_except>);
static_assert(!is_noexcept<except>);

static_assert(sizeof(std::unique_ptr<A, free_a_t>) ==
              sizeof(std::unique_ptr<A>));
// static_assert(std::is_same_v<decltype(&free_a), decltype(+free_a_t{})>);

static_assert(std::is_same_v<void(A*) noexcept, decltype(free_a)>);

int deleter_main(int, char**) {
	free_a_t f;
	f(nullptr);
	A* a = nullptr;
	f(a);
	f(new A);
	return 0;
}

namespace a {
namespace {
	template <auto F>
	struct is_noexcept;
	template <typename R, typename... Args, R (*F)(Args...)>
	struct is_noexcept<F> {
		constexpr static bool value = noexcept(F(std::declval<Args>()...));
	};
	template <auto F>
	constexpr bool is_noexcept_v = is_noexcept<F>::value;

	void non_except() noexcept(true) {}
	void except() noexcept(false) {}

	// static_assert(is_noexcept_v<non_except>);
	static_assert(!is_noexcept_v<except>);
} // namespace
} // namespace a