almost there with newer cpp methods

Author: pachadotdev

inst/include/cpp4r/R.hpp

@@ -119,6 +119,21 @@ inline bool r_env_has(SEXP env, SEXP sym) {
 template <typename T>
 inline T na();
 
+// Progressive C++ optimization: Use if constexpr in C++17+ for zero-overhead type dispatch
+#if CPP4R_HAS_CXX17
+template <typename T>
+CPP4R_HOT inline bool is_na(const T& value) {
+  // C++17+: Use if constexpr - compiler only compiles the taken branch
+  if constexpr (std::is_same<typename std::decay<T>::type, double>::value) {
+    return ISNA(value);  // Fast R macro for doubles
+  } else if constexpr (std::is_same<typename std::decay<T>::type, int>::value) {
+    return value == NA_INTEGER;  // Direct comparison for integers
+  } else {
+    return value == na<T>();  // Generic fallback
+  }
+}
+#else
+// C++11/14: Use SFINAE (slower compilation, same runtime performance)
 template <typename T>
 CPP4R_HOT inline typename std::enable_if<!std::is_same<typename std::decay<T>::type, double>::value,
                                bool>::type
@@ -132,5 +147,6 @@ CPP4R_HOT inline typename std::enable_if<std::is_same<typename std::decay<T>::ty
 is_na(const T& value) {
   return ISNA(value);
 }
+#endif
 
 }  // namespace cpp4r

inst/include/cpp4r/r_vector_impl.hpp

@@ -261,12 +261,23 @@ template <typename T>
 inline SEXP r_vector<T>::valid_type(SEXP x) {
   const SEXPTYPE type = get_sexptype();
 
+#if CPP4R_HAS_CXX20
+  // C++20: Use standard [[unlikely]] attribute for error paths
+  if (x == nullptr) [[unlikely]] {
+    throw type_error(type, NILSXP);
+  }
+  if (detail::r_typeof(x) != type) [[unlikely]] {
+    throw type_error(type, detail::r_typeof(x));
+  }
+#else
+  // C++11-17: Use __builtin_expect
   if (CPP4R_UNLIKELY(x == nullptr)) {
     throw type_error(type, NILSXP);
   }
   if (CPP4R_UNLIKELY(detail::r_typeof(x) != type)) {
     throw type_error(type, detail::r_typeof(x));
   }
+#endif
 
   return x;
 }
@@ -319,9 +330,17 @@ r_vector<T>::const_iterator::const_iterator(const r_vector* data, R_xlen_t pos)
 template <typename T>
 CPP4R_ALWAYS_INLINE typename r_vector<T>::const_iterator& r_vector<T>::const_iterator::operator++() {
   ++pos_;
+#if CPP4R_HAS_CXX20
+  // C++20: Use standard [[unlikely]] attribute (better understood by modern optimizers)
+  if (use_buf(data_->is_altrep()) && pos_ >= block_start_ + length_) [[unlikely]] {
+    fill_buf(pos_);
+  }
+#else
+  // C++11-17: Use __builtin_expect
   if (CPP4R_UNLIKELY(use_buf(data_->is_altrep()) && pos_ >= block_start_ + length_)) {
     fill_buf(pos_);
   }
+#endif
   return *this;
 }
 
@@ -398,13 +417,25 @@ inline typename r_vector<T>::const_iterator r_vector<T>::find(
 
 template <typename T>
 CPP4R_ALWAYS_INLINE T r_vector<T>::const_iterator::operator*() const {
+#if CPP4R_HAS_CXX20
+  // C++20: Use standard [[unlikely]] attribute
+  if (use_buf(data_->is_altrep())) [[unlikely]] {
+    // Use pre-loaded buffer for compatible ALTREP types
+    return static_cast<T>(buf_[pos_ - block_start_]);
+  } else {
+    // Otherwise pass through to normal retrieval method (common case)
+    return data_->operator[](pos_);
+  }
+#else
+  // C++11-17: Use __builtin_expect
   if (CPP4R_UNLIKELY(use_buf(data_->is_altrep()))) {
     // Use pre-loaded buffer for compatible ALTREP types
     return static_cast<T>(buf_[pos_ - block_start_]);
   } else {
     // Otherwise pass through to normal retrieval method (common case)
     return data_->operator[](pos_);
   }
+#endif
 }
 
 template <typename T>