fable: Use C++17 type traits with _t and _v suffixes

Author: cassava

fable/include/fable/enum.hpp

@@ -149,22 +149,22 @@ struct EnumSerializerImpl<T, false> {
   }
 };
 
-template <typename T, std::enable_if_t<std::is_enum<T>::value, int> = 0>
+template <typename T, std::enable_if_t<std::is_enum_v<T>, int> = 0>
 const std::map<T, std::string>& enum_serialization() {
   return EnumSerializerImpl<T, has_enum_serializer<T>::value>::serialization_impl();
 }
 
-template <typename T, std::enable_if_t<std::is_enum<T>::value, int> = 0>
+template <typename T, std::enable_if_t<std::is_enum_v<T>, int> = 0>
 const std::map<std::string, T>& enum_deserialization() {
   return EnumSerializerImpl<T, has_enum_serializer<T>::value>::deserialization_impl();
 }
 
-template <typename T, std::enable_if_t<std::is_enum<T>::value, int> = 0>
+template <typename T, std::enable_if_t<std::is_enum_v<T>, int> = 0>
 std::string to_string(T x) {
   return enum_serialization<T>().at(x);
 }
 
-template <typename T, std::enable_if_t<std::is_enum<T>::value, int> = 0>
+template <typename T, std::enable_if_t<std::is_enum_v<T>, int> = 0>
 T from_string(const std::string& s) {
   return enum_deserialization<T>().at(s);
 }

fable/include/fable/schema.hpp

@@ -200,7 +200,7 @@ class Schema : public schema::Interface {
   Schema(std::string&& desc, schema::BoxVec&& props);
 
   // Interface
-  template <typename T, std::enable_if_t<std::is_base_of<schema::Interface, T>::value, int> = 0>
+  template <typename T, std::enable_if_t<std::is_base_of_v<schema::Interface, T>, int> = 0>
   Schema(const T& value) : impl_(value.clone()) {}                      // NOLINT(runtime/explicit)
   Schema(schema::Interface* i) : impl_(i) { assert(impl_); }            // NOLINT(runtime/explicit)
   Schema(std::shared_ptr<schema::Interface> i) : impl_(std::move(i)) {  // NOLINT(runtime/explicit)

fable/include/fable/schema/confable.hpp

@@ -37,7 +37,7 @@ class Confable;
 
 namespace schema {
 
-template <typename T, std::enable_if_t<std::is_base_of<Confable, T>::value, int> = 0>
+template <typename T, std::enable_if_t<std::is_base_of_v<Confable, T>, int> = 0>
 class FromConfable : public Base<FromConfable<T>> {
  public:  // Types and Constructors
   using Type = T;

fable/include/fable/schema/duration.hpp

@@ -39,17 +39,15 @@ class Duration : public Base<Duration<T, Period>> {
  public:  // Types and Constructors
   using Type = std::chrono::duration<T, Period>;
 
-  template <typename X = T,
-            std::enable_if_t<std::is_integral<X>::value && std::is_unsigned<X>::value, int> = 0>
+  template <typename X = T, std::enable_if_t<std::is_integral_v<X> && std::is_unsigned_v<X>, int> = 0>
   Duration(Type* ptr, std::string&& desc)
       : Base<Duration<T, Period>>(JsonType::number_unsigned, std::move(desc)), ptr_(ptr) {}
 
-  template <typename X = T,
-            std::enable_if_t<std::is_integral<X>::value && std::is_signed<X>::value, int> = 0>
+  template <typename X = T, std::enable_if_t<std::is_integral_v<X> && std::is_signed_v<X>, int> = 0>
   Duration(Type* ptr, std::string&& desc)
-      : Base<Duration<T, Period>>(JsonType::number_integer, std::move(desc)), ptr_(ptr) {}
+        : Base<Duration<T, Period>>(JsonType::number_integer, std::move(desc)), ptr_(ptr) {}
 
-  template <typename X = T, std::enable_if_t<std::is_floating_point<X>::value, int> = 0>
+  template <typename X = T, std::enable_if_t<std::is_floating_point_v<X>, int> = 0>
   Duration(Type* ptr, std::string&& desc)
       : Base<Duration<T, Period>>(JsonType::number_float, std::move(desc)), ptr_(ptr) {}
 

fable/include/fable/schema/factory.hpp

@@ -229,8 +229,8 @@ class FactoryBase : public Base<CRTP> {
    * Most types inheriting from `Confable` will fulfill these requirements.
    */
   template <typename F,
-            std::enable_if_t<(std::is_default_constructible<F>::value &&
-                              std::is_convertible<std::unique_ptr<F>, T>::value),
+            std::enable_if_t<(std::is_default_constructible_v<F> &&
+                              std::is_convertible_v<std::unique_ptr<F>, T>),
                              int> = 0>
   void add_default_factory(const std::string& key) {
     add_factory(key, make_prototype<F>().get_confable_schema(), [](const Conf& c) -> T {

fable/include/fable/schema/interface.hpp

@@ -254,7 +254,7 @@ class Interface {
  *     void foobar(S schema);
  */
 template <typename S>
-using enable_if_schema_t = std::enable_if_t<std::is_base_of<Interface, S>::value>;
+using enable_if_schema_t = std::enable_if_t<std::is_base_of_v<Interface, S>>;
 
 // ------------------------------------------------------------------------- //
 
@@ -444,7 +444,7 @@ class Base : public Interface {
  *     void foobar(T x);
  */
 template <typename T>
-using enable_if_confable_t = std::enable_if_t<std::is_base_of<Confable, T>::value>;
+using enable_if_confable_t = std::enable_if_t<std::is_base_of_v<Confable, T>>;
 
 /**
  * Use SFINAE mechanism to disable a template function when S is a subclass
@@ -455,7 +455,7 @@ using enable_if_confable_t = std::enable_if_t<std::is_base_of<Confable, T>::valu
  *     void foobar(T x);
  */
 template <typename T>
-using enable_if_not_confable_t = std::enable_if_t<!std::is_base_of<Confable, T>::value>;
+using enable_if_not_confable_t = std::enable_if_t<!std::is_base_of_v<Confable, T>>;
 
 template <typename T, typename S = std::string, std::enable_if_t<std::is_base_of_v<Confable, T>, int> = 0>
 auto make_prototype(S&& desc = "");

fable/include/fable/schema/number.hpp

@@ -40,15 +40,15 @@ class Number : public Base<Number<T>> {
  public:  // Types and Constructors
   using Type = T;
 
-  template <typename X = T, std::enable_if_t<std::is_integral<X>::value && std::is_unsigned<X>::value, int> = 0>
+  template <typename X = T, std::enable_if_t<std::is_integral_v<X> && std::is_unsigned_v<X>, int> = 0>
   Number(Type* ptr, std::string&& desc)
       : Base<Number<T>>(JsonType::number_unsigned, std::move(desc)), ptr_(ptr) {}
 
-  template <typename X = T, std::enable_if_t<std::is_integral<X>::value && std::is_signed<X>::value, int> = 0>
+  template <typename X = T, std::enable_if_t<std::is_integral_v<X> && std::is_signed_v<X>, int> = 0>
   Number(Type* ptr, std::string&& desc)
       : Base<Number<T>>(JsonType::number_integer, std::move(desc)), ptr_(ptr) {}
 
-  template <typename X = T, std::enable_if_t<std::is_floating_point<X>::value, int> = 0>
+  template <typename X = T, std::enable_if_t<std::is_floating_point_v<X>, int> = 0>
   Number(Type* ptr, std::string&& desc)
       : Base<Number<T>>(JsonType::number_float, std::move(desc)), ptr_(ptr) {}
 

fable/include/fable/schema/struct.hpp

@@ -55,7 +55,7 @@ template <typename S = Box>
 using PropertyList = std::initializer_list<std::pair<std::string const, S>>;
 
 template <typename T, typename S = Box>
-using enable_if_property_list_t = std::enable_if_t<std::is_same<PropertyList<S>, T>::value>;
+using enable_if_property_list_t = std::enable_if_t<std::is_same_v<PropertyList<S>, T>>;
 
 /**
  * Struct maintains a key-value mapping, where the list of keys is usually