Trim includes, add docs and tests for tuple overloads

Remove unnecessary <tuple> includes (already available via prim/meta.hpp).
Add doxygen comments matching existing style. Add unit tests for
tuple overloads of deep_copy_vars, save_varis, and accumulate_adjoints
covering tuple<var, int>, tuple<var, double>, and tuple<var, var>.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: nsiccha

stan/math/rev/core/accumulate_adjoints.hpp

@@ -6,7 +6,6 @@
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core/var.hpp>
 
-#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -153,9 +152,17 @@ inline double* accumulate_adjoints(double* dest, Arith&& x, Pargs&&... args) {
 inline double* accumulate_adjoints(double* dest) { return dest; }
 
 /**
- * Unpack a tuple and accumulate adjoints from each element.
+ * Accumulate adjoints from a tuple into storage pointed to by dest
+ * by unpacking the tuple and recursively processing each element.
+ *
+ * @tparam Tuple A std::tuple type
+ * @tparam Pargs Types of remaining arguments
+ * @param dest Pointer to where adjoints are to be accumulated
+ * @param x A tuple potentially containing vars
+ * @param args Further args to accumulate over
+ * @return Final position of adjoint storage pointer
  */
-template <typename Tuple, require_tuple_t<Tuple>* = nullptr, typename... Pargs>
+template <typename Tuple, require_tuple_t<Tuple>*, typename... Pargs>
 inline double* accumulate_adjoints(double* dest, Tuple&& x, Pargs&&... args) {
   dest = stan::math::apply(
       [dest](auto&&... inner_args) {

stan/math/rev/core/deep_copy_vars.hpp

@@ -6,7 +6,6 @@
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core/var.hpp>
 
-#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -84,8 +83,8 @@ inline auto deep_copy_vars(EigT&& arg) {
 }
 
 /**
- * Copy the vars in a tuple but reallocate new varis for them.
- * Non-var elements are forwarded unchanged.
+ * Deep copy vars in a tuple, reallocating new varis for var elements
+ * and forwarding non-var elements unchanged.
  *
  * @tparam Tuple A std::tuple type
  * @param arg A tuple potentially containing vars
@@ -95,8 +94,8 @@ template <typename Tuple, require_tuple_t<Tuple>* = nullptr>
 inline auto deep_copy_vars(Tuple&& arg) {
   return stan::math::apply(
       [](auto&&... args) {
-        return std::make_tuple(deep_copy_vars(
-            std::forward<decltype(args)>(args))...);
+        return std::make_tuple(
+            deep_copy_vars(std::forward<decltype(args)>(args))...);
       },
       std::forward<Tuple>(arg));
 }

stan/math/rev/core/save_varis.hpp

@@ -7,7 +7,6 @@
 #include <stan/math/rev/meta.hpp>
 #include <stan/math/rev/core/var.hpp>
 
-#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -149,13 +148,22 @@ inline vari** save_varis(vari** dest, Arith&& x, Pargs&&... args) {
 inline vari** save_varis(vari** dest) { return dest; }
 
 /**
- * Unpack a tuple and save the varis of each element.
+ * Save the vari pointers in a tuple into the memory pointed to by dest
+ * by unpacking the tuple and recursively processing each element.
+ *
+ * @tparam Tuple A std::tuple type
+ * @tparam Pargs Types of remaining arguments
+ * @param[in, out] dest Pointer to where vari pointers are saved
+ * @param[in] x A tuple potentially containing vars
+ * @param[in] args Additional arguments to have their varis saved
+ * @return Final position of dest pointer
  */
-template <typename Tuple, require_tuple_t<Tuple>* = nullptr, typename... Pargs>
+template <typename Tuple, require_tuple_t<Tuple>*, typename... Pargs>
 inline vari** save_varis(vari** dest, Tuple&& x, Pargs&&... args) {
   dest = stan::math::apply(
       [dest](auto&&... inner_args) {
-        return save_varis(dest, std::forward<decltype(inner_args)>(inner_args)...);
+        return save_varis(
+            dest, std::forward<decltype(inner_args)>(inner_args)...);
       },
       std::forward<Tuple>(x));
   return save_varis(dest, std::forward<Pargs>(args)...);

test/unit/math/rev/core/accumulate_adjoints_test.cpp

@@ -381,6 +381,44 @@ TEST_F(AgradRev, Rev_accumulate_adjoints_std_vector_eigen_matrix_var_arg) {
   stan::math::recover_memory();
 }
 
+TEST_F(AgradRev, Rev_accumulate_adjoints_tuple_var_int_arg) {
+  using stan::math::var;
+  using stan::math::vari;
+  var a(5.0);
+  a.vi_->adj_ = 3.0;
+  int b = 7;
+  auto arg = std::make_tuple(a, b);
+
+  Eigen::VectorXd storage = Eigen::VectorXd::Zero(1000);
+  double* ptr = stan::math::accumulate_adjoints(storage.data(), arg);
+
+  EXPECT_FLOAT_EQ(storage(0), 3.0);
+  for (int i = 1; i < storage.size(); ++i)
+    EXPECT_FLOAT_EQ(storage(i), 0.0);
+  EXPECT_EQ(ptr, storage.data() + 1);
+  stan::math::recover_memory();
+}
+
+TEST_F(AgradRev, Rev_accumulate_adjoints_tuple_var_var_arg) {
+  using stan::math::var;
+  using stan::math::vari;
+  var a(5.0);
+  a.vi_->adj_ = 3.0;
+  var b(7.0);
+  b.vi_->adj_ = 4.0;
+  auto arg = std::make_tuple(a, b);
+
+  Eigen::VectorXd storage = Eigen::VectorXd::Zero(1000);
+  double* ptr = stan::math::accumulate_adjoints(storage.data(), arg);
+
+  EXPECT_FLOAT_EQ(storage(0), 3.0);
+  EXPECT_FLOAT_EQ(storage(1), 4.0);
+  for (int i = 2; i < storage.size(); ++i)
+    EXPECT_FLOAT_EQ(storage(i), 0.0);
+  EXPECT_EQ(ptr, storage.data() + 2);
+  stan::math::recover_memory();
+}
+
 TEST_F(AgradRev, Rev_accumulate_adjoints_sum) {
   using stan::math::var;
   using stan::math::vari;

test/unit/math/rev/core/deep_copy_vars_test.cpp

@@ -283,6 +283,43 @@ TEST_F(AgradRev, Rev_deep_copy_vars_std_vector_eigen_row_vector_var_arg) {
     }
 }
 
+TEST_F(AgradRev, Rev_deep_copy_vars_tuple_var_int_arg) {
+  var a(3.0);
+  int b = 5;
+  auto arg = std::make_tuple(a, b);
+
+  auto out = stan::math::deep_copy_vars(arg);
+
+  EXPECT_EQ(std::get<0>(out).val(), a.val());
+  EXPECT_NE(std::get<0>(out).vi_, a.vi_);
+  EXPECT_EQ(std::get<1>(out), b);
+}
+
+TEST_F(AgradRev, Rev_deep_copy_vars_tuple_var_double_arg) {
+  var a(3.0);
+  double b = 5.0;
+  auto arg = std::make_tuple(a, b);
+
+  auto out = stan::math::deep_copy_vars(arg);
+
+  EXPECT_EQ(std::get<0>(out).val(), a.val());
+  EXPECT_NE(std::get<0>(out).vi_, a.vi_);
+  EXPECT_EQ(std::get<1>(out), b);
+}
+
+TEST_F(AgradRev, Rev_deep_copy_vars_tuple_var_var_arg) {
+  var a(3.0);
+  var b(7.0);
+  auto arg = std::make_tuple(a, b);
+
+  auto out = stan::math::deep_copy_vars(arg);
+
+  EXPECT_EQ(std::get<0>(out).val(), a.val());
+  EXPECT_NE(std::get<0>(out).vi_, a.vi_);
+  EXPECT_EQ(std::get<1>(out).val(), b.val());
+  EXPECT_NE(std::get<1>(out).vi_, b.vi_);
+}
+
 TEST_F(AgradRev, Rev_deep_copy_vars_std_vector_eigen_matrix_var_arg) {
   Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic> arg_(5, 3);
   std::vector<Eigen::Matrix<var, Eigen::Dynamic, Eigen::Dynamic>> arg(2, arg_);

test/unit/math/rev/core/save_varis_test.cpp

@@ -332,6 +332,39 @@ TEST_F(AgradRev, Rev_save_varis_std_vector_eigen_matrix_var_arg) {
   EXPECT_EQ(ptr, storage.data() + num_vars);
 }
 
+TEST_F(AgradRev, Rev_save_varis_tuple_var_int_arg) {
+  var a(5.0);
+  int b = 3;
+  auto arg = std::make_tuple(a, b);
+
+  std::vector<vari*> storage(1000, nullptr);
+  vari** ptr = stan::math::save_varis(storage.data(), arg);
+
+  size_t num_vars = stan::math::count_vars(arg);
+  EXPECT_EQ(num_vars, 1);
+  EXPECT_EQ(storage[0], a.vi_);
+  for (int i = num_vars; i < storage.size(); ++i)
+    EXPECT_EQ(storage[i], nullptr);
+  EXPECT_EQ(ptr, storage.data() + num_vars);
+}
+
+TEST_F(AgradRev, Rev_save_varis_tuple_var_var_arg) {
+  var a(5.0);
+  var b(7.0);
+  auto arg = std::make_tuple(a, b);
+
+  std::vector<vari*> storage(1000, nullptr);
+  vari** ptr = stan::math::save_varis(storage.data(), arg);
+
+  size_t num_vars = stan::math::count_vars(arg);
+  EXPECT_EQ(num_vars, 2);
+  EXPECT_EQ(storage[0], a.vi_);
+  EXPECT_EQ(storage[1], b.vi_);
+  for (int i = num_vars; i < storage.size(); ++i)
+    EXPECT_EQ(storage[i], nullptr);
+  EXPECT_EQ(ptr, storage.data() + num_vars);
+}
+
 TEST_F(AgradRev, Rev_save_varis_sum) {
   int arg1 = 1;
   double arg2 = 1.0;