simplify value_of and value_of_rec to just be one function with if constexpr dispatch

Author: SteveBronder

stan/math/prim/fun/value_of.hpp

@@ -32,43 +32,46 @@ template <typename T>
 inline constexpr decltype(auto) value_of(T&& x) {
   using val_t = std::decay_t<T>;
   // ints are cast to doubles, types with base double are passed along
-  if constexpr (std::is_integral_v<val_t> || std::is_floating_point_v<val_t>) {
-    return val_t{x};
-  } else if constexpr (std::is_floating_point_v<base_type_t<
-                           val_t>> || std::is_integral_v<base_type_t<val_t>>) {
-    if constexpr (std::is_rvalue_reference_v<T&&>) {
-      return plain_type_t<T>(std::forward<T>(x));
-    } else {
-      return x;
-    }
-  } else if constexpr (is_complex<val_t>::value) {
-    return std::complex<double>{value_of(x.real()), value_of(x.imag())};
-  } else if constexpr (is_std_vector_v<val_t>) {
-    std::vector<
-        plain_type_t<decltype(value_of(std::declval<value_type_t<T>>()))>>
-        ret;
-    ret.reserve(x.size());
-    for (auto&& x_i : x) {
-      ret.push_back(value_of(std::forward<decltype(x_i)>(x_i)));
-    }
-    return ret;
-  } else if constexpr (is_eigen_v<val_t>) {
-    return make_holder(
-        [](auto& m) {
-          return m.unaryExpr([](auto x_i) { return value_of(x_i); });
-        },
-        std::forward<T>(x));
-  } else if constexpr (is_tuple_v<val_t>) {
+  if constexpr (is_tuple_v<val_t>) {
     return stan::math::apply(
         [](auto&&... args) {
           return partially_forward_as_tuple(
               value_of(std::forward<decltype(args)>(args))...);
         },
         std::forward<T>(x));
-  } else if constexpr (is_var_v<val_t>) {
-    return x.vi_->val_;
-  } else if constexpr (is_fvar<val_t>::value) {
-    return x.val();
+  } else {
+    constexpr bool is_base_float_or_int = std::is_floating_point_v<base_type_t<val_t>> || std::is_integral_v<base_type_t<val_t>>;
+    if constexpr (std::is_integral_v<val_t> || std::is_floating_point_v<val_t>) {
+      return val_t{x};
+    } else if constexpr (is_base_float_or_int) {
+      if constexpr (std::is_rvalue_reference_v<T&&>) {
+        return plain_type_t<T>(std::forward<T>(x));
+      } else {
+        return x;
+      }
+    } else if constexpr (is_complex<val_t>::value) {
+      return std::complex<double>{value_of(x.real()), value_of(x.imag())};
+    } else if constexpr (is_std_vector_v<val_t>) {
+      std::vector<
+          plain_type_t<decltype(value_of(std::declval<value_type_t<T>>()))>>
+          ret;
+      ret.reserve(x.size());
+      for (auto&& x_i : x) {
+        ret.push_back(value_of(std::forward<decltype(x_i)>(x_i)));
+      }
+      return ret;
+    } else if constexpr (is_eigen_v<val_t>) {
+      return make_holder(
+          [](auto& m) {
+            return m.unaryExpr([](auto x_i) { return value_of(x_i); });
+          },
+          std::forward<T>(x));
+    } else if constexpr (is_var_v<val_t>) {
+      return x.vi_->val_;
+    } else if constexpr (is_fvar<val_t>::value) {
+      return x.val();
+    }
+  
   }
 }
 

stan/math/prim/fun/value_of_rec.hpp

@@ -29,40 +29,42 @@ template <typename T>
 inline constexpr decltype(auto) value_of_rec(T&& x) {
   using val_t = std::decay_t<T>;
   // ints are cast to doubles, types with base double are passed along
-  if constexpr (std::is_integral_v<val_t> || std::is_floating_point_v<val_t>) {
-    return static_cast<double>(x);
-  } else if constexpr (std::is_floating_point_v<base_type_t<val_t>>) {
-    if constexpr (std::is_rvalue_reference_v<T&&>) {
-      return plain_type_t<T>(std::forward<T>(x));
-    } else {
-      return x;
-    }
-  } else if constexpr (is_complex<val_t>::value) {
-    return std::complex<double>{value_of_rec(x.real()), value_of_rec(x.imag())};
-  } else if constexpr (is_std_vector_v<val_t>) {
-    promote_scalar_t<double, val_t> ret;
-    ret.reserve(x.size());
-    for (auto&& x_i : x) {
-      ret.push_back(value_of_rec(std::forward<decltype(x_i)>(x_i)));
-    }
-    return ret;
-  } else if constexpr (is_eigen_v<val_t>) {
-    return make_holder(
-        [](auto& m) {
-          return m.unaryExpr([](auto x_i) { return value_of_rec(x_i); });
-        },
-        std::forward<T>(x));
-  } else if constexpr (is_tuple_v<val_t>) {
+  if constexpr (is_tuple_v<val_t>) {
     return stan::math::apply(
         [](auto&&... args) {
           return partially_forward_as_tuple(
               value_of_rec(std::forward<decltype(args)>(args))...);
         },
         std::forward<T>(x));
-  } else if constexpr (is_var_v<val_t>) {
-    return x.vi_->val_;
-  } else if constexpr (is_fvar<val_t>::value) {
-    return value_of_rec(x.val());
+  } else {
+    if constexpr (std::is_integral_v<val_t> || std::is_floating_point_v<val_t>) {
+      return static_cast<double>(x);
+    } else if constexpr (std::is_floating_point_v<base_type_t<val_t>>) {
+      if constexpr (std::is_rvalue_reference_v<T&&>) {
+        return plain_type_t<T>(std::forward<T>(x));
+      } else {
+        return x;
+      }
+    } else if constexpr (is_complex<val_t>::value) {
+      return std::complex<double>{value_of_rec(x.real()), value_of_rec(x.imag())};
+    } else if constexpr (is_std_vector_v<val_t>) {
+      promote_scalar_t<double, val_t> ret;
+      ret.reserve(x.size());
+      for (auto&& x_i : x) {
+        ret.push_back(value_of_rec(std::forward<decltype(x_i)>(x_i)));
+      }
+      return ret;
+    } else if constexpr (is_eigen_v<val_t>) {
+      return make_holder(
+          [](auto& m) {
+            return m.unaryExpr([](auto x_i) { return value_of_rec(x_i); });
+          },
+          std::forward<T>(x));
+    } else if constexpr (is_var_v<val_t>) {
+      return x.vi_->val_;
+    } else if constexpr (is_fvar<val_t>::value) {
+      return value_of_rec(x.val());
+    }
   }
 }