diff --git a/test/test_convert.cpp b/test/test_convert.cpp
index ca0b80e..957b969 100644
--- a/test/test_convert.cpp
+++ b/test/test_convert.cpp
@@ -148,6 +148,9 @@ void test_convert_tuple(v8::Isolate* isolate)
 	std::tuple<size_t, size_t, size_t> const tuple_3{ 1, 2, 3 };
 	test_conv(isolate, tuple_3);
 
+	std::pair<bool, char> const pair{ false, 'N' };
+	test_conv(isolate, pair);
+
 	check_ex<v8pp::invalid_argument>("Tuple", [isolate, &tuple_1]()
 	{
 		// incorrect number of elements
diff --git a/test/test_utility.cpp b/test/test_utility.cpp
index b409cce..fdab319 100644
--- a/test/test_utility.cpp
+++ b/test/test_utility.cpp
@@ -6,6 +6,8 @@
 #include <map>
 #include <unordered_map>
 
+namespace {
+
 template<typename Ret, typename F>
 void test_ret(F&&)
 {
@@ -61,11 +63,11 @@ void test_function_traits()
 		char i(float) const volatile { return 0; }
 		void operator()(int, char&) const volatile {}
 
-		float w;
+		float w = 0;
 		const int x = 1;
-		volatile char y;
+		volatile char y = 0;
 		const volatile bool z = true;
-		mutable volatile short zz;
+		mutable volatile short zz = 0;
 	};
 
 	test_ret<float>(&X::f);
@@ -171,83 +173,107 @@ void test_is_callable()
 	static_assert(!is_callable<Y>::value, "Y is not callable");
 }
 
-void test_type_traits()
+void test_concepts()
 {
-	static_assert(v8pp::detail::is_string<std::string>::value, "std::string");
-	static_assert(!v8pp::detail::is_sequence<std::string>::value, "std::string");
-	static_assert(!v8pp::detail::is_mapping<std::string>::value, "std::string");
-	static_assert(!v8pp::detail::is_array<std::string>::value, "std::string");
-
-	static_assert(v8pp::detail::is_string<std::string_view>::value, "std::string_view");
-	static_assert(v8pp::detail::is_string<std::u16string>::value, "std::u16string");
-	static_assert(v8pp::detail::is_string<std::u16string_view>::value, "std::u16string_view");
-	static_assert(v8pp::detail::is_string<std::u32string>::value, "std::u32string");
-	static_assert(v8pp::detail::is_string<std::u32string_view>::value, "std::u32string_view");
-	static_assert(v8pp::detail::is_string<std::wstring>::value, "std::wstring");
-	static_assert(v8pp::detail::is_string<std::wstring_view>::value, "std::wstring_view");
-	static_assert(v8pp::detail::is_string<char const*>::value, "char const*");
-	static_assert(v8pp::detail::is_string<char16_t const*>::value, "char16_t const*");
-	static_assert(v8pp::detail::is_string<char32_t const*>::value, "char32_t const*");
-	static_assert(v8pp::detail::is_string<wchar_t const*>::value, "wchar_t const*");
-
-	static_assert(!v8pp::detail::is_string<std::array<int, 1>>::value, "std::array");
-	static_assert(!v8pp::detail::is_mapping<std::array<int, 1>>::value, "std::array");
-	static_assert(!v8pp::detail::is_sequence<std::array<int, 1>>::value, "std::array");
-	static_assert(!v8pp::detail::is_sequence<std::array<int, 1>>::value, "std::array");
-	static_assert(v8pp::detail::is_array<std::array<int, 1>>::value, "std::array");
-	static_assert(!v8pp::detail::has_reserve<std::array<int, 1>>::value, "std::array");
-
-	static_assert(!v8pp::detail::is_string<std::vector<char>>::value, "std::vector");
-	static_assert(!v8pp::detail::is_mapping<std::vector<char>>::value, "std::vector");
-	static_assert(v8pp::detail::is_sequence<std::vector<char>>::value, "std::vector");
-	static_assert(!v8pp::detail::is_array<std::vector<char>>::value, "std::vector");
-	static_assert(v8pp::detail::has_reserve<std::vector<char>>::value, "std::vector");
-
-	static_assert(!v8pp::detail::is_string<std::deque<int>>::value, "std::deque");
-	static_assert(!v8pp::detail::is_mapping<std::deque<int>>::value, "std::deque");
-	static_assert(v8pp::detail::is_sequence<std::deque<int>>::value, "std::deque");
-	static_assert(!v8pp::detail::is_array<std::deque<int>>::value, "std::deque");
-	static_assert(!v8pp::detail::has_reserve<std::deque<int>>::value, "std::deque");
-
-	static_assert(!v8pp::detail::is_string<std::list<bool>>::value, "std::list");
-	static_assert(!v8pp::detail::is_mapping<std::list<bool>>::value, "std::list");
-	static_assert(v8pp::detail::is_sequence<std::list<bool>>::value, "std::list");
-	static_assert(!v8pp::detail::is_array<std::list<bool>>::value, "std::list");
-	static_assert(!v8pp::detail::has_reserve<std::list<bool>>::value, "std::list");
-
-	static_assert(!v8pp::detail::is_string<std::tuple<int, char>>::value, "std::tuple");
-	static_assert(!v8pp::detail::is_mapping<std::tuple<int, char>>::value, "std::tuple");
-	static_assert(!v8pp::detail::is_sequence<std::tuple<int, char>>::value, "std::tuple");
-	static_assert(!v8pp::detail::is_array<std::tuple<int, char>>::value, "std::tuple");
-	static_assert(v8pp::detail::is_tuple<std::tuple<int, char>>::value, "std::tuple");
-
-	static_assert(!v8pp::detail::is_string<std::map<int, float>>::value, "std::map");
-	static_assert(v8pp::detail::is_mapping<std::map<int, float>>::value, "std::map");
-	static_assert(!v8pp::detail::is_sequence<std::map<int, char>>::value, "std::map");
-	static_assert(!v8pp::detail::is_array<std::map<int, char>>::value, "std::map");
-
-	static_assert(!v8pp::detail::is_string<std::multimap<int, char>>::value, "std::multimap");
-	static_assert(v8pp::detail::is_mapping<std::multimap<bool, std::string, std::greater<>>>::value, "std::multimap");
-	static_assert(!v8pp::detail::is_sequence<std::multimap<int, char>>::value, "std::multimap");
-	static_assert(!v8pp::detail::is_array<std::multimap<int, char>>::value, "std::multimap");
-
-	static_assert(!v8pp::detail::is_string<std::unordered_map<int, char>>::value, "std::unordered_map");
-	static_assert(v8pp::detail::is_mapping<std::unordered_map<std::string, std::string>>::value, "std::unordered_map");
-	static_assert(!v8pp::detail::is_sequence<std::unordered_map<int, char>>::value, "std::unordered_map");
-	static_assert(!v8pp::detail::is_array<std::unordered_map<int, char>>::value, "std::unordered_map");
-
-	static_assert(!v8pp::detail::is_array<std::unordered_multimap<int, char>>::value, "std::unordered_multimap");
-	static_assert(v8pp::detail::is_mapping<std::unordered_multimap<char, std::string>>::value, "std::unordered_multimap");
-	static_assert(!v8pp::detail::is_sequence<std::unordered_multimap<int, char>>::value, "std::unordered_multimap");
-	static_assert(!v8pp::detail::is_array<std::unordered_multimap<int, char>>::value, "std::unordered_multimap");
+	static_assert(v8pp::detail::String<std::string>, "std::string");
+	static_assert(!v8pp::detail::Sequence<std::string>, "std::string");
+	static_assert(!v8pp::detail::Mapping<std::string>, "std::string");
+	static_assert(!v8pp::detail::Array<std::string>, "std::string");
+	static_assert(v8pp::detail::HasReserve<std::string>, "std::string");
+	static_assert(!v8pp::detail::Tuple<std::string>, "std::string");
+
+	static_assert(v8pp::detail::String<std::string_view>, "std::string_view");
+	static_assert(v8pp::detail::String<std::u16string>, "std::u16string");
+	static_assert(v8pp::detail::String<std::u16string_view>, "std::u16string_view");
+	static_assert(v8pp::detail::String<std::u32string>, "std::u32string");
+	static_assert(v8pp::detail::String<std::u32string_view>, "std::u32string_view");
+	static_assert(v8pp::detail::String<std::wstring>, "std::wstring");
+	static_assert(v8pp::detail::String<std::wstring_view>, "std::wstring_view");
+	static_assert(v8pp::detail::String<char const*>, "char const*");
+	static_assert(v8pp::detail::String<char16_t const*>, "char16_t const*");
+	static_assert(v8pp::detail::String<char32_t const*>, "char32_t const*");
+	static_assert(v8pp::detail::String<wchar_t const*>, "wchar_t const*");
+
+	static_assert(!v8pp::detail::String<std::array<int, 1>>, "std::array");
+	static_assert(!v8pp::detail::Mapping<std::array<int, 1>>, "std::array");
+	static_assert(!v8pp::detail::Sequence<std::array<int, 1>>, "std::array");
+	static_assert(!v8pp::detail::Sequence<std::array<int, 1>>, "std::array");
+	static_assert(v8pp::detail::Array<std::array<int, 1>>, "std::array");
+	static_assert(!v8pp::detail::HasReserve<std::array<int, 1>>, "std::array");
+	static_assert(!v8pp::detail::Tuple<std::array<int, 1>>, "std::array");
+
+	static_assert(!v8pp::detail::String<std::vector<char>>, "std::vector");
+	static_assert(!v8pp::detail::Mapping<std::vector<char>>, "std::vector");
+	static_assert(v8pp::detail::Sequence<std::vector<char>>, "std::vector");
+	static_assert(!v8pp::detail::Array<std::vector<char>>, "std::vector");
+	static_assert(v8pp::detail::HasReserve<std::vector<char>>, "std::vector");
+	static_assert(!v8pp::detail::Tuple<std::vector<char>>, "std::vector");
+
+	static_assert(!v8pp::detail::String<std::deque<int>>, "std::deque");
+	static_assert(!v8pp::detail::Mapping<std::deque<int>>, "std::deque");
+	static_assert(v8pp::detail::Sequence<std::deque<int>>, "std::deque");
+	static_assert(!v8pp::detail::Array<std::deque<int>>, "std::deque");
+	static_assert(!v8pp::detail::HasReserve<std::deque<int>>, "std::deque");
+	static_assert(!v8pp::detail::Tuple<std::deque<int>>, "std::deque");
+
+	static_assert(!v8pp::detail::String<std::list<bool>>, "std::list");
+	static_assert(!v8pp::detail::Mapping<std::list<bool>>, "std::list");
+	static_assert(v8pp::detail::Sequence<std::list<bool>>, "std::list");
+	static_assert(!v8pp::detail::Array<std::list<bool>>, "std::list");
+	static_assert(!v8pp::detail::HasReserve<std::list<bool>>, "std::list");
+	static_assert(!v8pp::detail::Tuple<std::list<bool>>, "std::list");
+
+	static_assert(!v8pp::detail::String<std::map<int, float>>, "std::map");
+	static_assert(v8pp::detail::Mapping<std::map<int, float>>, "std::map");
+	static_assert(!v8pp::detail::Sequence<std::map<int, char>>, "std::map");
+	static_assert(!v8pp::detail::Array<std::map<int, char>>, "std::map");
+	static_assert(!v8pp::detail::HasReserve<std::map<int, char>>, "std::map");
+	static_assert(!v8pp::detail::Tuple<std::map<int, char>>, "std::map");
+
+	static_assert(!v8pp::detail::String<std::multimap<int, char>>, "std::multimap");
+	static_assert(v8pp::detail::Mapping<std::multimap<bool, std::string, std::greater<>>>, "std::multimap");
+	static_assert(!v8pp::detail::Sequence<std::multimap<int, char>>, "std::multimap");
+	static_assert(!v8pp::detail::Array<std::multimap<int, char>>, "std::multimap");
+	static_assert(!v8pp::detail::HasReserve<std::multimap<int, char>>, "std::multimap");
+	static_assert(!v8pp::detail::Tuple<std::multimap<int, char>>, "std::multimap");
+
+	static_assert(!v8pp::detail::String<std::unordered_map<int, char>>, "std::unordered_map");
+	static_assert(v8pp::detail::Mapping<std::unordered_map<std::string, std::string>>, "std::unordered_map");
+	static_assert(!v8pp::detail::Sequence<std::unordered_map<int, char>>, "std::unordered_map");
+	static_assert(!v8pp::detail::Array<std::unordered_map<int, char>>, "std::unordered_map");
+	static_assert(v8pp::detail::HasReserve<std::unordered_map<int, char>>, "std::unordered_map");
+	static_assert(!v8pp::detail::Tuple<std::unordered_map<int, char>>, "std::unordered_map");
+
+	static_assert(!v8pp::detail::String<std::unordered_multimap<int, char>>, "std::unordered_multimap");
+	static_assert(v8pp::detail::Mapping<std::unordered_multimap<char, std::string>>, "std::unordered_multimap");
+	static_assert(!v8pp::detail::Sequence<std::unordered_multimap<int, char>>, "std::unordered_multimap");
+	static_assert(!v8pp::detail::Array<std::unordered_multimap<int, char>>, "std::unordered_multimap");
+	static_assert(v8pp::detail::HasReserve<std::unordered_multimap<int, char>>, "std::unordered_multimap");
+	static_assert(!v8pp::detail::Tuple<std::unordered_multimap<int, char>>, "std::unordered_multimap");
+
+	static_assert(v8pp::detail::Tuple<std::tuple<int, char, float>>, "std::tuple");
+	static_assert(v8pp::detail::Tuple<std::tuple<std::tuple<bool>>>, "std::tuple");
+	static_assert(v8pp::detail::Tuple<std::pair<int, int>>, "std::tuple");
+	static_assert(!v8pp::detail::Tuple<std::array<int, 10>>, "std::tuple");
+	static_assert(!v8pp::detail::Tuple<int>, "std::tuple");
+	static_assert(!v8pp::detail::Tuple<int>, "std::tuple");
+	static_assert(!v8pp::detail::String<std::tuple<int, char>>, "std::tuple");
+	static_assert(!v8pp::detail::Mapping<std::tuple<int, char>>, "std::tuple");
+	static_assert(!v8pp::detail::Sequence<std::tuple<int, char>>, "std::tuple");
+	static_assert(!v8pp::detail::Array<std::tuple<int, char>>, "std::tuple");
+	static_assert(!v8pp::detail::HasReserve<std::tuple<int, char>>, "std::tuple");
 
 	static_assert(!v8pp::detail::is_shared_ptr<int>::value, "int");
 	static_assert(v8pp::detail::is_shared_ptr<std::shared_ptr<int>>::value, "int");
+	static_assert(v8pp::detail::is_shared_ptr<std::shared_ptr<std::vector<char>>>::value, "std::vector<char");
+	static_assert(!v8pp::detail::is_shared_ptr<std::string>::value, "std::string");
 }
 
+} // unnamed namespace
+
 void test_utility()
 {
-	test_type_traits();
+	test_concepts();
 	test_function_traits();
 	test_tuple_tail();
 	test_is_callable();
diff --git a/v8pp/convert.hpp b/v8pp/convert.hpp
index 4e68aa6..5600c9d 100644
--- a/v8pp/convert.hpp
+++ b/v8pp/convert.hpp
@@ -44,14 +44,13 @@ struct invalid_argument : std::invalid_argument
 };
 
 // converter specializations for string types
-template<typename String>
-struct convert<String, typename std::enable_if<detail::is_string<String>::value>::type>
+template<detail::String T>
+struct convert<T>
 {
-	using Char = typename String::value_type;
-	using Traits = typename String::traits_type;
+	using Char = typename T::value_type;
+	using Traits = typename T::traits_type;
 
-	static_assert(sizeof(Char) <= sizeof(uint16_t),
-		"only UTF-8 and UTF-16 strings are supported");
+	static_assert(sizeof(Char) <= sizeof(uint16_t), "only UTF-8 and UTF-16 strings are supported");
 
 	// A string that converts to Char const*
 	struct convertible_string : std::basic_string<Char, Traits>
@@ -76,15 +75,22 @@ struct convert<String, typename std::enable_if<detail::is_string<String>::value>
 			throw invalid_argument(isolate, value, "String");
 		}
 
+		v8::HandleScope scope(isolate);
+		v8::Local<v8::String> str = value->ToString(isolate->GetCurrentContext()).ToLocalChecked();
+
 		if constexpr (sizeof(Char) == 1)
 		{
-			v8::String::Utf8Value const str(isolate, value);
-			return from_type(reinterpret_cast<Char const*>(*str), str.length());
+			auto const len = str->Utf8Length(isolate);
+			from_type result(len, 0);
+			result.resize(str->WriteUtf8(isolate, result.data(), len, nullptr, v8::String::NO_NULL_TERMINATION | v8::String::REPLACE_INVALID_UTF8));
+			return result;
 		}
 		else
 		{
-			v8::String::Value const str(isolate, value);
-			return from_type(reinterpret_cast<Char const*>(*str), str.length());
+			auto const len = str->Length();
+			from_type result(len, 0);
+			result.resize(str->Write(isolate, reinterpret_cast<uint16_t*>(result.data()), 0, len, v8::String::NO_NULL_TERMINATION));
+			return result;
 		}
 	}
 
@@ -154,8 +160,8 @@ struct convert<bool>
 	}
 };
 
-template<typename T>
-struct convert<T, typename std::enable_if<std::is_integral<T>::value>::type>
+template<std::integral T>
+struct convert<T>
 {
 	using from_type = T;
 	using to_type = v8::Local<v8::Number>;
@@ -212,10 +218,10 @@ struct convert<T, typename std::enable_if<std::is_integral<T>::value>::type>
 	}
 };
 
-template<typename T>
-struct convert<T, typename std::enable_if<std::is_enum<T>::value>::type>
+template<typename T> requires std::is_enum_v<T>
+struct convert<T>
 {
-	using underlying_type = typename std::underlying_type<T>::type;
+	using underlying_type = typename std::underlying_type_t<T>;
 
 	using from_type = T;
 	using to_type = typename convert<underlying_type>::to_type;
@@ -232,13 +238,12 @@ struct convert<T, typename std::enable_if<std::is_enum<T>::value>::type>
 
 	static to_type to_v8(v8::Isolate* isolate, T value)
 	{
-		return convert<underlying_type>::to_v8(isolate,
-			static_cast<underlying_type>(value));
+		return convert<underlying_type>::to_v8(isolate, static_cast<underlying_type>(value));
 	}
 };
 
-template<typename T>
-struct convert<T, typename std::enable_if<std::is_floating_point<T>::value>::type>
+template<std::floating_point T>
+struct convert<T>
 {
 	using from_type = T;
 	using to_type = v8::Local<v8::Number>;
@@ -265,18 +270,17 @@ struct convert<T, typename std::enable_if<std::is_floating_point<T>::value>::typ
 };
 
 // convert std::tuple <-> Array
-template<typename... Ts>
-struct convert<std::tuple<Ts...>>
+template<detail::Tuple T>
+struct convert<T>
 {
-	using from_type = std::tuple<Ts...>;
+	using from_type = T;
 	using to_type = v8::Local<v8::Array>;
 
-	static constexpr size_t N = sizeof...(Ts);
+	static constexpr size_t N = std::tuple_size_v<T>;
 
 	static bool is_valid(v8::Isolate*, v8::Local<v8::Value> value)
 	{
-		return !value.IsEmpty() && value->IsArray()
-			&& value.As<v8::Array>()->Length() == N;
+		return !value.IsEmpty() && value->IsArray() && value.As<v8::Array>()->Length() == N;
 	}
 
 	static from_type from_v8(v8::Isolate* isolate, v8::Local<v8::Value> value)
@@ -295,24 +299,23 @@ struct convert<std::tuple<Ts...>>
 
 private:
 	template<size_t... Is>
-	static from_type from_v8_impl(v8::Isolate* isolate, v8::Local<v8::Value> value,
-		std::index_sequence<Is...>)
+	static from_type from_v8_impl(v8::Isolate* isolate, v8::Local<v8::Value> value, std::index_sequence<Is...>)
 	{
 		v8::HandleScope scope(isolate);
 		v8::Local<v8::Context> context = isolate->GetCurrentContext();
 		v8::Local<v8::Array> array = value.As<v8::Array>();
 
-		return std::tuple<Ts...>{ v8pp::convert<Ts>::from_v8(isolate, array->Get(context, Is).ToLocalChecked())... };
+		return T{ v8pp::convert<std::tuple_element_t<Is, T>>::from_v8(isolate, array->Get(context, Is).ToLocalChecked())... };
 	}
 
 	template<size_t... Is>
-	static to_type to_v8_impl(v8::Isolate* isolate, std::tuple<Ts...> const& value, std::index_sequence<Is...>)
+	static to_type to_v8_impl(v8::Isolate* isolate, T const& value, std::index_sequence<Is...>)
 	{
 		v8::EscapableHandleScope scope(isolate);
 		v8::Local<v8::Context> context = isolate->GetCurrentContext();
 		v8::Local<v8::Array> result = v8::Array::New(isolate, N);
 
-		(void)std::initializer_list<bool>{ result->Set(context, Is, convert<Ts>::to_v8(isolate, std::get<Is>(value))).FromJust()... };
+		(void)std::initializer_list<bool>{ result->Set(context, Is, convert<std::tuple_element_t<Is, T>>::to_v8(isolate, std::get<Is>(value))).FromJust()... };
 
 		return scope.Escape(result);
 	}
@@ -322,7 +325,6 @@ struct convert<std::tuple<Ts...>>
 template<typename... Ts>
 struct convert<std::variant<Ts...>>
 {
-public:
 	using from_type = std::variant<Ts...>;
 	using to_type = v8::Local<v8::Value>;
 
@@ -472,12 +474,12 @@ struct convert<std::variant<Ts...>>
 };
 
 // convert Array <-> std::array, vector, deque, list
-template<typename Sequence>
-struct convert<Sequence, typename std::enable_if<detail::is_sequence<Sequence>::value || detail::is_array<Sequence>::value>::type>
+template<typename T> requires detail::Sequence<T> || detail::Array<T>
+struct convert<T>
 {
-	using from_type = Sequence;
+	using from_type = T;
 	using to_type = v8::Local<v8::Array>;
-	using item_type = typename Sequence::value_type;
+	using item_type = typename T::value_type;
 
 	static bool is_valid(v8::Isolate*, v8::Local<v8::Value> value)
 	{
@@ -497,10 +499,9 @@ struct convert<Sequence, typename std::enable_if<detail::is_sequence<Sequence>::
 
 		from_type result{};
 
-		constexpr bool is_array = detail::is_array<Sequence>::value;
-		if constexpr (is_array)
+		if constexpr (detail::Array<T>)
 		{
-			constexpr size_t length = detail::is_array<Sequence>::length;
+			constexpr size_t length = std::tuple_size_v<T>;
 			if (array->Length() != length)
 			{
 				throw std::runtime_error("Invalid array length: expected "
@@ -508,7 +509,7 @@ struct convert<Sequence, typename std::enable_if<detail::is_sequence<Sequence>::
 					+ std::to_string(array->Length()));
 			}
 		}
-		else if constexpr (detail::has_reserve<Sequence>::value)
+		else if constexpr (detail::HasReserve<T>)
 		{
 			result.reserve(array->Length());
 		}
@@ -516,7 +517,7 @@ struct convert<Sequence, typename std::enable_if<detail::is_sequence<Sequence>::
 		for (uint32_t i = 0, count = array->Length(); i < count; ++i)
 		{
 			v8::Local<v8::Value> item = array->Get(context, i).ToLocalChecked();
-			if constexpr (is_array)
+			if constexpr (detail::Array<T>)
 			{
 				result[i] = convert<item_type>::from_v8(isolate, item);
 			}
@@ -551,14 +552,14 @@ struct convert<Sequence, typename std::enable_if<detail::is_sequence<Sequence>::
 };
 
 // convert Object <-> std::{unordered_}{multi}map
-template<typename Mapping>
-struct convert<Mapping, typename std::enable_if<detail::is_mapping<Mapping>::value>::type>
+template<detail::Mapping T>
+struct convert<T>
 {
-	using from_type = Mapping;
+	using from_type = T;
 	using to_type = v8::Local<v8::Object>;
 
-	using Key = typename Mapping::key_type;
-	using Value = typename Mapping::mapped_type;
+	using Key = typename T::key_type;
+	using Value = typename T::mapped_type;
 
 	static bool is_valid(v8::Isolate*, v8::Local<v8::Value> value)
 	{
@@ -582,9 +583,7 @@ struct convert<Mapping, typename std::enable_if<detail::is_mapping<Mapping>::val
 		{
 			v8::Local<v8::Value> key = prop_names->Get(context, i).ToLocalChecked();
 			v8::Local<v8::Value> val = object->Get(context, key).ToLocalChecked();
-			const auto k = convert<Key>::from_v8(isolate, key);
-			const auto v = convert<Value>::from_v8(isolate, val);
-			result.emplace(k, v);
+			result.emplace(convert<Key>::from_v8(isolate, key), convert<Value>::from_v8(isolate, val));
 		}
 		return result;
 	}
@@ -596,9 +595,7 @@ struct convert<Mapping, typename std::enable_if<detail::is_mapping<Mapping>::val
 		v8::Local<v8::Object> result = v8::Object::New(isolate);
 		for (auto const& item : value)
 		{
-			const auto k = convert<Key>::to_v8(isolate, item.first);
-			const auto v = convert<Value>::to_v8(isolate, item.second);
-			result->Set(context, k, v).FromJust();
+			result->Set(context, convert<Key>::to_v8(isolate, item.first), convert<Value>::to_v8(isolate, item.second)).FromJust();
 		}
 		return scope.Escape(result);
 	}
@@ -654,12 +651,12 @@ struct is_wrapped_class<std::variant<Ts...>> : std::false_type
 {
 };
 
-template<typename T>
-struct convert<T*, typename std::enable_if<is_wrapped_class<T>::value>::type>
+template<typename T> requires is_wrapped_class<T>::value
+struct convert<T*>
 {
 	using from_type = T*;
 	using to_type = v8::Local<v8::Object>;
-	using class_type = typename std::remove_cv<T>::type;
+	using class_type = typename std::remove_cv_t<T>;
 
 	static bool is_valid(v8::Isolate*, v8::Local<v8::Value> value)
 	{
@@ -681,8 +678,8 @@ struct convert<T*, typename std::enable_if<is_wrapped_class<T>::value>::type>
 	}
 };
 
-template<typename T>
-struct convert<T, typename std::enable_if<is_wrapped_class<T>::value>::type>
+template<typename T> requires is_wrapped_class<T>::value
+struct convert<T>
 {
 	using from_type = T&;
 	using to_type = v8::Local<v8::Object>;
@@ -715,8 +712,8 @@ struct convert<T, typename std::enable_if<is_wrapped_class<T>::value>::type>
 	}
 };
 
-template<typename T>
-struct convert<std::shared_ptr<T>, typename std::enable_if<is_wrapped_class<T>::value>::type>
+template<typename T> requires is_wrapped_class<T>::value
+struct convert<std::shared_ptr<T>>
 {
 	using from_type = std::shared_ptr<T>;
 	using to_type = v8::Local<v8::Object>;
@@ -789,14 +786,12 @@ struct convert<T const&> : convert<T>
 
 template<typename T>
 auto from_v8(v8::Isolate* isolate, v8::Local<v8::Value> value)
-	-> decltype(convert<T>::from_v8(isolate, value))
 {
 	return convert<T>::from_v8(isolate, value);
 }
 
 template<typename T, typename U>
 auto from_v8(v8::Isolate* isolate, v8::Local<v8::Value> value, U const& default_value)
-	-> decltype(convert<T>::from_v8(isolate, value))
 {
 	using return_type = decltype(convert<T>::from_v8(isolate, value));
 	return convert<T>::is_valid(isolate, value) ?
@@ -814,8 +809,7 @@ inline v8::Local<v8::String> to_v8(v8::Isolate* isolate, char const* str, size_t
 }
 
 template<size_t N>
-v8::Local<v8::String> to_v8(v8::Isolate* isolate,
-	char const (&str)[N], size_t len = N - 1)
+v8::Local<v8::String> to_v8(v8::Isolate* isolate, char const (&str)[N], size_t len = N - 1)
 {
 	return convert<std::string_view>::to_v8(isolate, std::string_view(str, len));
 }
@@ -831,8 +825,7 @@ inline v8::Local<v8::String> to_v8(v8::Isolate* isolate, char16_t const* str, si
 }
 
 template<size_t N>
-v8::Local<v8::String> to_v8(v8::Isolate* isolate,
-	char16_t const (&str)[N], size_t len = N - 1)
+v8::Local<v8::String> to_v8(v8::Isolate* isolate, char16_t const (&str)[N], size_t len = N - 1)
 {
 	return convert<std::u16string_view>::to_v8(isolate, std::u16string_view(str, len));
 }
@@ -849,8 +842,7 @@ inline v8::Local<v8::String> to_v8(v8::Isolate* isolate, wchar_t const* str, siz
 }
 
 template<size_t N>
-v8::Local<v8::String> to_v8(v8::Isolate* isolate,
-	wchar_t const (&str)[N], size_t len = N - 1)
+v8::Local<v8::String> to_v8(v8::Isolate* isolate, wchar_t const (&str)[N], size_t len = N - 1)
 {
 	return convert<std::wstring_view>::to_v8(isolate, std::wstring_view(str, len));
 }
diff --git a/v8pp/utility.hpp b/v8pp/utility.hpp
index 1fcee57..d0cb544 100644
--- a/v8pp/utility.hpp
+++ b/v8pp/utility.hpp
@@ -26,141 +26,75 @@ struct none
 template<typename Char>
 concept WideChar = std::same_as<Char, char16_t> || std::same_as<Char, char32_t> || std::same_as<Char, wchar_t>;
 
-/////////////////////////////////////////////////////////////////////////////
-//
-// is_string<T>
-//
 template<typename T>
-struct is_string : std::false_type
-{
-};
-
-template<typename Char, typename Traits, typename Alloc>
-struct is_string<std::basic_string<Char, Traits, Alloc>> : std::true_type
-{
-};
-
-template<typename Char, typename Traits>
-struct is_string<std::basic_string_view<Char, Traits>> : std::true_type
-{
-};
+concept String = std::same_as<T, std::string> || std::same_as<T, std::string_view>
+	|| std::same_as<T, std::wstring> || std::same_as<T, std::wstring_view>
+	|| std::same_as<T, std::u16string> || std::same_as<T, std::u16string_view>
+	|| std::same_as<T, std::u32string> || std::same_as<T, std::u32string_view>
+	|| std::same_as<T, char const*> || std::same_as<T, char16_t const*>
+	||	std::same_as<T, char32_t const*> || std::same_as<T, wchar_t const*>;
 
-template<>
-struct is_string<char const*> : std::true_type
-{
-};
-
-template<>
-struct is_string<char16_t const*> : std::true_type
-{
-};
-
-template<>
-struct is_string<char32_t const*> : std::true_type
-{
+template<typename T>
+concept Mapping = requires(T t) {
+	typename T::key_type;
+	typename T::mapped_type;
+	t.begin();
+	t.end();
 };
 
-template<>
-struct is_string<wchar_t const*> : std::true_type
-{
-};
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// is_mapping<T>
-//
-template<typename T, typename U = void>
-struct is_mapping_impl : std::false_type
-{
-};
 
 template<typename T>
-struct is_mapping_impl<T, std::void_t<typename T::key_type, typename T::mapped_type,
-	decltype(std::declval<T>().begin()), decltype(std::declval<T>().end())>> : std::true_type
-{
-};
+concept Sequence = requires(T t) {
+	typename T::value_type;
+	t.begin();
+	t.end();
+	t.emplace_back(std::declval<typename T::value_type>());
+} && !String<T>;
 
 template<typename T>
-using is_mapping = is_mapping_impl<T>;
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// is_sequence<T>
-//
-template<typename T, typename U = void>
-struct is_sequence_impl : std::false_type
-{
+concept HasReserve = requires(T t) {
+	t.reserve(0);
 };
 
 template<typename T>
-struct is_sequence_impl<T, std::void_t<typename T::value_type,
-	decltype(std::declval<T>().begin()), decltype(std::declval<T>().end()),
-	decltype(std::declval<T>().emplace_back(std::declval<typename T::value_type>()))>> : std::negation<is_string<T>>
-{
+concept Array = requires(T t) {
+	typename std::tuple_size<T>::type;
+	typename T::value_type;
+	t.begin();
+	t.end();
 };
 
 template<typename T>
-using is_sequence = is_sequence_impl<T>;
-
-/////////////////////////////////////////////////////////////////////////////
-//
-// has_reserve<T>
-//
-template<typename T, typename U = void>
-struct has_reserve_impl : std::false_type
-{
-};
+concept Tuple = requires(T t) {
+	typename std::tuple_size<T>::type;
+	typename std::tuple_element<0, T>::type;
+	typename std::tuple_element_t<0, T>;
+	std::get<0>(t);
+} && !Array<T>;
 
 template<typename T>
-struct has_reserve_impl<T, std::void_t<decltype(std::declval<T>().reserve(0))>> : std::true_type
-{
-};
+concept SharedPtr = std::same_as<T, std::shared_ptr<typename T::element_type>>;
 
 template<typename T>
-using has_reserve = has_reserve_impl<T>;
+using is_string = std::bool_constant<String<T>>;
 
-/////////////////////////////////////////////////////////////////////////////
-//
-// is_array<T>
-//
 template<typename T>
-struct is_array : std::false_type
-{
-};
+using is_mapping = std::bool_constant<Mapping<T>>;
 
-template<typename T, std::size_t N>
-struct is_array<std::array<T, N>> : std::true_type
-{
-	static constexpr size_t length = N;
-};
+template<typename T>
+using is_sequence = std::bool_constant<Sequence<T>>;
 
-/////////////////////////////////////////////////////////////////////////////
-//
-// is_tuple<T>
-//
 template<typename T>
-struct is_tuple : std::false_type
-{
-};
+using has_reserve = std::bool_constant<HasReserve<T>>;
 
-template<typename... Ts>
-struct is_tuple<std::tuple<Ts...>> : std::true_type
-{
-};
+template<typename T>
+using is_array = std::bool_constant<Array<T>>;
 
-/////////////////////////////////////////////////////////////////////////////
-//
-// is_shared_ptr<T>
-//
 template<typename T>
-struct is_shared_ptr : std::false_type
-{
-};
+using is_tuple = std::bool_constant<Tuple<T>>;
 
 template<typename T>
-struct is_shared_ptr<std::shared_ptr<T>> : std::true_type
-{
-};
+using is_shared_ptr = std::bool_constant<SharedPtr<T>>;
 
 /////////////////////////////////////////////////////////////////////////////
 //