Show template style with add function

stan/math/prim/mat/fun/add.hpp

@@ -1,9 +1,10 @@
 #ifndef STAN_MATH_PRIM_MAT_FUN_ADD_HPP
 #define STAN_MATH_PRIM_MAT_FUN_ADD_HPP
 
-#include <boost/math/tools/promotion.hpp>
 #include <stan/math/prim/mat/fun/Eigen.hpp>
+#include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/mat/err/check_matching_dims.hpp>
+#include <boost/math/tools/promotion.hpp>
 
 namespace stan {
 namespace math {
@@ -21,41 +22,42 @@ namespace math {
  * @throw std::invalid_argument if m1 and m2 do not have the same
  * dimensions.
  */
-template <typename T1, typename T2, int R, int C>
-inline Eigen::Matrix<return_type_t<T1, T2>, R, C> add(
-    const Eigen::Matrix<T1, R, C>& m1, const Eigen::Matrix<T2, R, C>& m2) {
+template <typename Mat1, typename Mat2, require_all_eigen_t<is_stan_scalar, Mat1, Mat2>...>
+inline auto add(Mat1&& m1, Mat2&& m2) {
   check_matching_dims("add", "m1", m1, "m2", m2);
-  return m1 + m2;
+  return (m1 + m2).eval();
 }
 
 /**
  * Return the sum of the specified matrix and specified scalar.
  *
- * @tparam T1 Scalar type of matrix.
+ * @tparam T1 Type of matrix.
  * @tparam T2 Type of scalar.
  * @param m Matrix.
  * @param c Scalar.
  * @return The matrix plus the scalar.
  */
-template <typename T1, typename T2, int R, int C>
-inline Eigen::Matrix<return_type_t<T1, T2>, R, C> add(
-    const Eigen::Matrix<T1, R, C>& m, const T2& c) {
-  return m.array() + c;
+ template <typename T1, typename T2,
+ require_eigen_t<is_stan_scalar, T1>...,
+ require_not_eigen_t<is_stan_scalar, T2>...>
+inline auto add(T1&& m, T2&& c) {
+  return (m.array() + c).eval();
 }
 
 /**
  * Return the sum of the specified scalar and specified matrix.
  *
  * @tparam T1 Type of scalar.
- * @tparam T2 Scalar type of matrix.
+ * @tparam T2 Type of matrix.
  * @param c Scalar.
  * @param m Matrix.
  * @return The scalar plus the matrix.
  */
-template <typename T1, typename T2, int R, int C>
-inline Eigen::Matrix<return_type_t<T1, T2>, R, C> add(
-    const T1& c, const Eigen::Matrix<T2, R, C>& m) {
-  return c + m.array();
+ template <typename T1, typename T2,
+ require_not_eigen_t<is_stan_scalar, T1>...,
+ require_eigen_t<is_stan_scalar, T2>...>
+inline auto add(T1&& c, T2& m) {
+  return (c + m.array()).eval();
 }
 
 }  // namespace math

test/unit/math/rev/mat/util.hpp

@@ -1,14 +1,17 @@
 #ifndef TEST_UNIT_MATH_REV_MAT_UTIL_HPP
 #define TEST_UNIT_MATH_REV_MAT_UTIL_HPP
 
+#include <stan/math/prim/mat/fun/Eigen.hpp>
 #include <stan/math/rev/mat.hpp>
-#include <gtest/gtest.h>
+#include <stan/math/prim/meta.hpp>
 #include <test/unit/math/rev/arr/util.hpp>
+#include <gtest/gtest.h>
 
 namespace test {
 
-template <int R, int C>
-void check_varis_on_stack(const Eigen::Matrix<stan::math::var, R, C>& x) {
+  template <typename Mat, stan::require_eigen_t<stan::is_var, Mat>...>
+void check_varis_on_stack(Mat&& x) {
+  x.eval();
   for (int j = 0; j < x.cols(); ++j)
     for (int i = 0; i < x.rows(); ++i)
       EXPECT_TRUE(stan::math::ChainableStack::instance_->memalloc_.in_stack(