Concept.mpp

export module CppUtils.Type.Concept;

import std;
export import CppUtils.Type.Specialization;

export namespace CppUtils::Type
{
	template<class T>
	concept Printable = requires (T value) {
		{ std::cout << value } -> std::same_as<std::ostream&>;
	};

	template<class Type, class... Types>
	concept IsOneOf = (std::same_as<Type, Types> or ...);

	template<class T>
	concept Dereferenceable = requires (T value) {
		*value;
	};

	template<class T>
	concept IsHashable = requires (std::remove_cvref_t<T>& a) {
		{ std::hash<std::remove_cvref_t<T>>{}(a) } -> std::convertible_to<std::size_t>;
	};

	template<class T>
	concept Function = std::is_function_v<T>;

	template<class T>
	concept HasReturnValue = not std::same_as<std::invoke_result_t<T>, void>;

	static_assert(HasReturnValue<int()>);
	static_assert(not HasReturnValue<void()>);

	template<class T>
	inline constexpr auto isFunctionPointer = std::is_pointer_v<T> and std::is_function_v<std::remove_pointer_t<T>>;

	template<class T>
	concept FunctionPointer = isFunctionPointer<T>;

	template<class T>
	concept DefaultConstructible = std::is_default_constructible_v<T>;

	template<class T>
	concept TriviallyConstructible = std::is_trivially_constructible_v<T>;

	template<class T>
	concept TriviallyDestructible = std::is_trivially_destructible_v<T>;

	template<class T>
	concept TriviallyCopyable = std::is_trivially_copyable_v<T>;

	template<class T>
	concept TriviallyMoveConstructible = std::is_trivially_move_constructible_v<T>;

	template<class T>
	concept TriviallyMoveAssignable = std::is_trivially_move_assignable_v<T>;

	template<class T>
	concept Trivial = TriviallyConstructible<T> and TriviallyDestructible<T> and TriviallyCopyable<T> and TriviallyMoveConstructible<T> and TriviallyMoveAssignable<T>;

	template<class Function, class... Args>
	concept Callable = std::invocable<Function, Args...>;

	template<class Function, class... Args>
	concept NotCallable = not Callable<Function, Args...>;

	template<class T>
	concept Numeric = std::integral<T> or std::floating_point<T>;
}