diff --git a/CMakeLists.txt b/CMakeLists.txt
index c7960f6..f52bb8f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -237,6 +237,10 @@ install(EXPORT AthenaTargets DESTINATION ${INSTALL_CMAKE_DIR} COMPONENT athena)
 
 if(NOT GEKKO)
 add_subdirectory(atdna)
+# Test target
+atdna(atdna_test.cpp atdna/test.hpp)
+add_executable(atdna-test atdna/test.cpp atdna_test.cpp atdna/test.hpp)
+target_link_libraries(atdna-test athena-core athena-libyaml)
 endif()
 
 #########
diff --git a/atdna/CMakeLists.txt b/atdna/CMakeLists.txt
index fc92fa7..217c7f2 100644
--- a/atdna/CMakeLists.txt
+++ b/atdna/CMakeLists.txt
@@ -234,9 +234,4 @@ macro(atdna out)
   endif()
 endmacro()
 
-# Test target
-atdna(atdna_test.cpp test.hpp)
-add_executable(atdna-test test.cpp atdna_test.cpp test.hpp)
-target_link_libraries(atdna-test athena-core athena-libyaml)
-
 endif()
diff --git a/include/athena/DNAOp.hpp b/include/athena/DNAOp.hpp
index f10e4ea..e3661c4 100644
--- a/include/athena/DNAOp.hpp
+++ b/include/athena/DNAOp.hpp
@@ -6,6 +6,7 @@
 #include "YAMLDocReader.hpp"
 #include "YAMLDocWriter.hpp"
 #include "ChecksumsLiterals.hpp"
+#include <type_traits>
 
 namespace athena::io
 {
@@ -65,16 +66,15 @@ enum class PropType
 };
 
 template <class T>
-static inline constexpr bool __IsPODType()
-{
-    return std::is_arithmetic_v<T> ||
-           std::is_convertible_v<T&, atVec2f&> ||
-           std::is_convertible_v<T&, atVec3f&> ||
-           std::is_convertible_v<T&, atVec4f&> ||
-           std::is_convertible_v<T&, atVec2d&> ||
-           std::is_convertible_v<T&, atVec3d&> ||
-           std::is_convertible_v<T&, atVec4d&>;
-}
+using __IsPODType = typename std::disjunction<std::is_arithmetic<T>,
+                                              std::is_convertible<T&, atVec2f&>,
+                                              std::is_convertible<T&, atVec3f&>,
+                                              std::is_convertible<T&, atVec4f&>,
+                                              std::is_convertible<T&, atVec2d&>,
+                                              std::is_convertible<T&, atVec3d&>,
+                                              std::is_convertible<T&, atVec4d&>>;
+template <class T>
+inline constexpr bool __IsPODType_v = __IsPODType<T>::value;
 
 template <class T>
 using __CastPODType = typename std::conditional_t<std::is_convertible_v<T&, atVec2f&>, atVec2f,
@@ -139,7 +139,7 @@ struct BinarySize
         BinarySize<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), s);
     }
     template <class T, Endian DNAE>
-    static typename std::enable_if_t<__IsPODType<T>()>
+    static typename std::enable_if_t<__IsPODType_v<T>>
     Do(const PropId& id, T& var, StreamT& s)
     {
         if (PropOp != PropType::None)
@@ -151,7 +151,7 @@ struct BinarySize
         BinarySize<PropType::None>::Do<CastT, DNAE>(id, static_cast<CastT&>(var), s);
     }
     template <class T, Endian DNAE>
-    static typename std::enable_if_t<__IsDNARecord<T>() && PropOp != PropType::None>
+    static typename std::enable_if_t<__IsDNARecord_v<T> && PropOp != PropType::None>
     Do(const PropId& id, T& var, StreamT& s)
     {
         /* Accessed via Enumerate, header */
@@ -159,7 +159,7 @@ struct BinarySize
         var.template Enumerate<BinarySize<PropOp>>(s);
     }
     template <class T, Endian DNAE>
-    static typename std::enable_if_t<__IsDNARecord<T>() && PropOp == PropType::None>
+    static typename std::enable_if_t<__IsDNARecord_v<T> && PropOp == PropType::None>
     Do(const PropId& id, T& var, StreamT& s)
     {
         var.template Enumerate<BinarySize<PropType::None>>(s);
@@ -347,7 +347,7 @@ struct Read
         Read<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), r);
     }
     template <class T, Endian DNAE>
-    static typename std::enable_if_t<__IsPODType<T>()>
+    static typename std::enable_if_t<__IsPODType_v<T>>
     Do(const PropId& id, T& var, StreamT& r)
     {
         using CastT = __CastPODType<T>;
@@ -398,7 +398,7 @@ struct Read
     {
         vector.clear();
         vector.reserve(count);
-        for (size_t i = 0; i < count; ++i)
+        for (size_t i = 0; i < static_cast<size_t>(count); ++i)
         {
             vector.emplace_back();
             Read<PropOp>::Do<T, DNAE>(id, vector.back(), r);
@@ -518,7 +518,7 @@ struct Write
         Write<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), w);
     }
     template <class T, Endian DNAE>
-    static typename std::enable_if_t<__IsPODType<T>()>
+    static typename std::enable_if_t<__IsPODType_v<T>>
     Do(const PropId& id, T& var, StreamT& w)
     {
         using CastT = __CastPODType<T>;
@@ -679,14 +679,14 @@ struct ReadYaml
         ReadYaml<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), r);
     }
     template <class T, Endian DNAE>
-    static typename std::enable_if_t<__IsPODType<T>()>
+    static typename std::enable_if_t<__IsPODType_v<T>>
     Do(const PropId& id, T& var, StreamT& r)
     {
         using CastT = __CastPODType<T>;
         ReadYaml<PropType::None>::Do<CastT, DNAE>(id, static_cast<CastT&>(var), r);
     }
     template <class T, Endian DNAE>
-    static typename std::enable_if_t<__IsDNARecord<T>()>
+    static typename std::enable_if_t<__IsDNARecord_v<T>>
     Do(const PropId& id, T& var, StreamT& r)
     {
         if (auto rec = r.enterSubRecord(id.name))
@@ -818,14 +818,14 @@ struct WriteYaml
         WriteYaml<PropType::None>::Do<PODType, DNAE>(id, *reinterpret_cast<PODType*>(&var), w);
     }
     template <class T, Endian DNAE>
-    static typename std::enable_if_t<__IsPODType<T>()>
+    static typename std::enable_if_t<__IsPODType_v<T>>
     Do(const PropId& id, T& var, StreamT& w)
     {
         using CastT = __CastPODType<T>;
         WriteYaml<PropType::None>::Do<CastT, DNAE>(id, static_cast<CastT&>(var), w);
     }
     template <class T, Endian DNAE>
-    static typename std::enable_if_t<__IsDNARecord<T>()>
+    static typename std::enable_if_t<__IsDNARecord_v<T>>
     Do(const PropId& id, T& var, StreamT& w)
     {
         if (auto rec = w.enterSubRecord(id.name))
diff --git a/include/athena/DNAYaml.hpp b/include/athena/DNAYaml.hpp
index a511cd7..d45afba 100644
--- a/include/athena/DNAYaml.hpp
+++ b/include/athena/DNAYaml.hpp
@@ -12,14 +12,14 @@ namespace athena::io
 
 template <class T>
 static inline const char* __GetDNAName(const T& dna,
-    typename std::enable_if_t<athena::io::__IsDNAVRecord<T>()>* = 0)
+    typename std::enable_if_t<athena::io::__IsDNAVRecord_v<T>>* = 0)
 {
     return dna.DNATypeV();
 }
 
 template <class T>
 static inline const char* __GetDNAName(const T& dna,
-    typename std::enable_if_t<!athena::io::__IsDNAVRecord<T>()>* = 0)
+    typename std::enable_if_t<!athena::io::__IsDNAVRecord_v<T>>* = 0)
 {
     return dna.DNAType();
 }
diff --git a/include/athena/Global.hpp b/include/athena/Global.hpp
index 4f3ae1a..14da238 100644
--- a/include/athena/Global.hpp
+++ b/include/athena/Global.hpp
@@ -146,17 +146,16 @@ template <Endian DNAE>
 struct DNAV;
 
 template <class T>
-static inline constexpr bool __IsDNARecord()
-{
-    return std::is_base_of_v<DNA<Endian::Big>, T> ||
-           std::is_base_of_v<DNA<Endian::Little>, T>;
-}
+using __IsDNARecord = typename std::disjunction<std::is_base_of<DNA<Endian::Big>, T>,
+                                                std::is_base_of<DNA<Endian::Little>, T>>;
 template <class T>
-static inline constexpr bool __IsDNAVRecord()
-{
-    return std::is_base_of_v<DNAV<Endian::Big>, T> ||
-           std::is_base_of_v<DNAV<Endian::Little>, T>;
-}
+inline constexpr bool __IsDNARecord_v = __IsDNARecord<T>::value;
+
+template <class T>
+using __IsDNAVRecord = typename std::disjunction<std::is_base_of<DNAV<Endian::Big>, T>,
+                                                 std::is_base_of<DNAV<Endian::Little>, T>>;
+template <class T>
+inline constexpr bool __IsDNAVRecord_v = __IsDNAVRecord<T>::value;
 }
 } // Athena
 
diff --git a/include/athena/YAMLCommon.hpp b/include/athena/YAMLCommon.hpp
index 96b79ae..2170688 100644
--- a/include/athena/YAMLCommon.hpp
+++ b/include/athena/YAMLCommon.hpp
@@ -9,6 +9,8 @@
 #include <yaml.h>
 #include <utf8proc.h>
 #include <vector>
+#include <memory>
+#include <functional>
 #include "Global.hpp"
 
 namespace athena::io
diff --git a/include/athena/YAMLDocReader.hpp b/include/athena/YAMLDocReader.hpp
index e6dc994..0bbd214 100644
--- a/include/athena/YAMLDocReader.hpp
+++ b/include/athena/YAMLDocReader.hpp
@@ -49,7 +49,7 @@ public:
 
     template <class T>
     void enumerate(const char* name, T& record,
-                   typename std::enable_if_t<__IsDNARecord<T>()>* = 0)
+                   typename std::enable_if_t<__IsDNARecord_v<T>>* = 0)
     {
         if (auto rec = enterSubRecord(name))
             record.read(*this);
diff --git a/include/athena/YAMLDocWriter.hpp b/include/athena/YAMLDocWriter.hpp
index 8e15199..6915619 100644
--- a/include/athena/YAMLDocWriter.hpp
+++ b/include/athena/YAMLDocWriter.hpp
@@ -40,7 +40,7 @@ public:
 
     template <class T>
     void enumerate(const char* name, T& record,
-                   typename std::enable_if_t<__IsDNARecord<T>()>* = 0)
+                   typename std::enable_if_t<__IsDNARecord_v<T>>* = 0)
     {
         if (auto rec = enterSubRecord(name))
             record.write(*this);