From 4eb5681999cb8402269f5345d3a301b29ab69006 Mon Sep 17 00:00:00 2001
From: Steve Bronder <Stevo15025@gmail.com>
Date: Fri, 13 Jun 2025 16:33:01 -0400
Subject: [PATCH 01/31] perfect forward container math overloads

---
 stan/math/prim/fun/Phi.hpp                    |  4 ++--
 stan/math/prim/fun/Phi_approx.hpp             |  4 ++--
 stan/math/prim/fun/abs.hpp                    | 14 ++++++++-----
 stan/math/prim/fun/acos.hpp                   | 14 ++++++++-----
 stan/math/prim/fun/acosh.hpp                  |  8 +++----
 stan/math/prim/fun/asin.hpp                   | 14 ++++++++-----
 stan/math/prim/fun/asinh.hpp                  |  8 +++----
 stan/math/prim/fun/atan.hpp                   | 14 ++++++++-----
 stan/math/prim/fun/atan2.hpp                  |  8 +++++--
 stan/math/prim/fun/atanh.hpp                  |  8 +++----
 stan/math/prim/fun/bessel_first_kind.hpp      |  9 +++++---
 stan/math/prim/fun/bessel_second_kind.hpp     |  9 +++++---
 stan/math/prim/fun/beta.hpp                   |  8 +++++--
 stan/math/prim/fun/binary_log_loss.hpp        |  8 +++++--
 .../prim/fun/binomial_coefficient_log.hpp     |  9 ++++----
 stan/math/prim/fun/cbrt.hpp                   |  4 ++--
 stan/math/prim/fun/ceil.hpp                   | 14 ++++++++-----
 stan/math/prim/fun/choose.hpp                 |  8 +++++--
 stan/math/prim/fun/cos.hpp                    | 14 ++++++++-----
 stan/math/prim/fun/cosh.hpp                   | 11 +++++-----
 stan/math/prim/fun/digamma.hpp                |  4 ++--
 stan/math/prim/fun/erf.hpp                    |  4 ++--
 stan/math/prim/fun/erfc.hpp                   |  4 ++--
 stan/math/prim/fun/exp.hpp                    | 12 ++++++-----
 stan/math/prim/fun/exp2.hpp                   |  4 ++--
 stan/math/prim/fun/expm1.hpp                  |  4 ++--
 stan/math/prim/fun/fabs.hpp                   | 11 +++++-----
 stan/math/prim/fun/falling_factorial.hpp      |  9 +++++---
 stan/math/prim/fun/fdim.hpp                   |  8 +++++--
 stan/math/prim/fun/floor.hpp                  | 11 +++++-----
 stan/math/prim/fun/fmax.hpp                   |  8 +++++--
 stan/math/prim/fun/fmin.hpp                   |  8 +++++--
 stan/math/prim/fun/fmod.hpp                   |  9 ++++----
 stan/math/prim/fun/gamma_p.hpp                |  7 +++++--
 stan/math/prim/fun/gamma_q.hpp                |  8 +++++--
 stan/math/prim/fun/hypot.hpp                  |  8 +++++--
 stan/math/prim/fun/inv.hpp                    | 11 +++++-----
 stan/math/prim/fun/inv_Phi.hpp                |  4 ++--
 stan/math/prim/fun/inv_cloglog.hpp            | 13 +++++++-----
 stan/math/prim/fun/inv_erfc.hpp               |  4 ++--
 stan/math/prim/fun/inv_sqrt.hpp               | 14 +++++++------
 stan/math/prim/fun/inv_square.hpp             |  9 +++++---
 stan/math/prim/fun/lambert_w.hpp              |  8 +++----
 stan/math/prim/fun/lbeta.hpp                  |  8 +++++--
 stan/math/prim/fun/ldexp.hpp                  |  8 +++++--
 stan/math/prim/fun/lgamma.hpp                 |  4 ++--
 stan/math/prim/fun/lmgamma.hpp                |  8 +++++--
 stan/math/prim/fun/lmultiply.hpp              |  8 +++++--
 stan/math/prim/fun/log.hpp                    | 12 ++++++-----
 stan/math/prim/fun/log10.hpp                  | 11 +++++-----
 stan/math/prim/fun/log1m.hpp                  |  4 ++--
 stan/math/prim/fun/log1m_exp.hpp              |  4 ++--
 stan/math/prim/fun/log1m_inv_logit.hpp        |  7 ++++---
 stan/math/prim/fun/log1p.hpp                  |  4 ++--
 stan/math/prim/fun/log1p_exp.hpp              |  4 ++--
 stan/math/prim/fun/log2.hpp                   |  4 ++--
 stan/math/prim/fun/log_diff_exp.hpp           |  8 +++++--
 stan/math/prim/fun/log_falling_factorial.hpp  |  9 +++++---
 stan/math/prim/fun/log_inv_logit.hpp          |  4 ++--
 stan/math/prim/fun/log_inv_logit_diff.hpp     |  9 +++++---
 .../fun/log_modified_bessel_first_kind.hpp    |  9 ++++----
 stan/math/prim/fun/log_rising_factorial.hpp   |  9 +++++---
 stan/math/prim/fun/log_softmax.hpp            | 13 +++++++-----
 stan/math/prim/fun/log_sum_exp.hpp            | 13 ++++++++----
 stan/math/prim/fun/logit.hpp                  | 21 ++++++++++++-------
 stan/math/prim/fun/minus.hpp                  |  5 +++--
 .../prim/fun/modified_bessel_first_kind.hpp   |  9 ++++----
 .../prim/fun/modified_bessel_second_kind.hpp  |  9 ++++----
 stan/math/prim/fun/multiply_log.hpp           |  8 +++++--
 stan/math/prim/fun/norm1.hpp                  |  7 ++++---
 stan/math/prim/fun/norm2.hpp                  |  7 ++++---
 stan/math/prim/fun/owens_t.hpp                |  8 +++++--
 stan/math/prim/fun/pow.hpp                    |  5 +++--
 stan/math/prim/fun/rising_factorial.hpp       |  9 +++++---
 stan/math/prim/fun/round.hpp                  | 11 +++++-----
 stan/math/prim/fun/sd.hpp                     |  5 +++--
 stan/math/prim/fun/select.hpp                 | 20 +++++++++---------
 stan/math/prim/fun/sign.hpp                   |  4 ++--
 stan/math/prim/fun/sin.hpp                    | 12 ++++++-----
 stan/math/prim/fun/sinh.hpp                   | 11 +++++-----
 stan/math/prim/fun/sqrt.hpp                   | 11 +++++-----
 stan/math/prim/fun/square.hpp                 | 11 +++++-----
 stan/math/prim/fun/step.hpp                   |  4 ++--
 stan/math/prim/fun/tan.hpp                    | 14 ++++++++-----
 stan/math/prim/fun/tanh.hpp                   | 11 +++++-----
 stan/math/prim/fun/tgamma.hpp                 |  4 ++--
 stan/math/prim/fun/to_complex.hpp             |  9 +++++---
 stan/math/prim/fun/to_int.hpp                 |  4 ++--
 stan/math/prim/fun/trigamma.hpp               |  4 ++--
 stan/math/prim/fun/trunc.hpp                  |  4 ++--
 90 files changed, 463 insertions(+), 296 deletions(-)

diff --git a/stan/math/prim/fun/Phi.hpp b/stan/math/prim/fun/Phi.hpp
index 152ab151bcf..6c21789468c 100644
--- a/stan/math/prim/fun/Phi.hpp
+++ b/stan/math/prim/fun/Phi.hpp
@@ -67,8 +67,8 @@ template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
-inline auto Phi(const T& x) {
-  return apply_scalar_unary<Phi_fun, T>::apply(x);
+inline auto Phi(T&& x) {
+  return apply_scalar_unary<Phi_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/Phi_approx.hpp b/stan/math/prim/fun/Phi_approx.hpp
index 555a06a2c41..a806c765153 100644
--- a/stan/math/prim/fun/Phi_approx.hpp
+++ b/stan/math/prim/fun/Phi_approx.hpp
@@ -66,8 +66,8 @@ template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
-inline auto Phi_approx(const T& x) {
-  return apply_scalar_unary<Phi_approx_fun, T>::apply(x);
+inline auto Phi_approx(T&& x) {
+  return apply_scalar_unary<Phi_approx_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/abs.hpp b/stan/math/prim/fun/abs.hpp
index fca073133ec..7ef05d9d23f 100644
--- a/stan/math/prim/fun/abs.hpp
+++ b/stan/math/prim/fun/abs.hpp
@@ -63,8 +63,9 @@ struct abs_fun {
  * @return Absolute value of each variable in the container.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto abs(const Container& x) {
-  return apply_scalar_unary<abs_fun, Container>::apply(x);
+inline auto abs(Container&& x) {
+  return apply_scalar_unary<abs_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
@@ -77,9 +78,12 @@ inline auto abs(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto abs(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [&](const auto& v) { return v.array().abs(); });
+inline auto abs(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [&](const auto& v) {
+        return std::forward<decltype(v)>(v).array().abs();
+      });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/acos.hpp b/stan/math/prim/fun/acos.hpp
index 1efa76b5174..8d35f36c994 100644
--- a/stan/math/prim/fun/acos.hpp
+++ b/stan/math/prim/fun/acos.hpp
@@ -65,8 +65,9 @@ struct acos_fun {
  * @return Arc cosine of each variable in the container, in radians.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto acos(const Container& x) {
-  return apply_scalar_unary<acos_fun, Container>::apply(x);
+inline auto acos(Container&& x) {
+  return apply_scalar_unary<acos_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
@@ -79,9 +80,12 @@ inline auto acos(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto acos(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().acos(); });
+inline auto acos(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) {
+        return std::forward<decltype(v)>(v).array().acos();
+      });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/acosh.hpp b/stan/math/prim/fun/acosh.hpp
index 5580e9e1e73..c3821b69fca 100644
--- a/stan/math/prim/fun/acosh.hpp
+++ b/stan/math/prim/fun/acosh.hpp
@@ -78,8 +78,8 @@ struct acosh_fun {
  * @return Elementwise acosh of members of container.
  */
 template <typename T, require_ad_container_t<T>* = nullptr>
-inline auto acosh(const T& x) {
-  return apply_scalar_unary<acosh_fun, T>::apply(x);
+inline auto acosh(T&& x) {
+  return apply_scalar_unary<acosh_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 /**
@@ -94,8 +94,8 @@ inline auto acosh(const T& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto acosh(const Container& x) {
-  return apply_scalar_unary<acosh_fun, Container>::apply(x);
+inline auto acosh(Container&& x) {
+  return apply_scalar_unary<acosh_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/asin.hpp b/stan/math/prim/fun/asin.hpp
index f620a24d2af..287cddf467b 100644
--- a/stan/math/prim/fun/asin.hpp
+++ b/stan/math/prim/fun/asin.hpp
@@ -63,8 +63,9 @@ struct asin_fun {
  * @return Arcsine of each variable in the container, in radians.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto asin(const Container& x) {
-  return apply_scalar_unary<asin_fun, Container>::apply(x);
+inline auto asin(Container&& x) {
+  return apply_scalar_unary<asin_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
@@ -77,9 +78,12 @@ inline auto asin(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto asin(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().asin(); });
+inline auto asin(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) {
+        return std::forward<decltype(v)>(v).array().asin();
+      });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/asinh.hpp b/stan/math/prim/fun/asinh.hpp
index ab72065efae..63a53caf255 100644
--- a/stan/math/prim/fun/asinh.hpp
+++ b/stan/math/prim/fun/asinh.hpp
@@ -66,8 +66,8 @@ struct asinh_fun {
  * @return Inverse hyperbolic sine of each value in the container.
  */
 template <typename T, require_ad_container_t<T>* = nullptr>
-inline auto asinh(const T& x) {
-  return apply_scalar_unary<asinh_fun, T>::apply(x);
+inline auto asinh(T&& x) {
+  return apply_scalar_unary<asinh_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 /**
@@ -80,8 +80,8 @@ inline auto asinh(const T& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto asinh(const Container& x) {
-  return apply_scalar_unary<asinh_fun, Container>::apply(x);
+inline auto asinh(Container&& x) {
+  return apply_scalar_unary<asinh_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/atan.hpp b/stan/math/prim/fun/atan.hpp
index 9e7099b7d43..ac505f0cd2b 100644
--- a/stan/math/prim/fun/atan.hpp
+++ b/stan/math/prim/fun/atan.hpp
@@ -61,8 +61,9 @@ struct atan_fun {
  * @return Arctan of each value in x, in radians.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto atan(const Container& x) {
-  return apply_scalar_unary<atan_fun, Container>::apply(x);
+inline auto atan(Container&& x) {
+  return apply_scalar_unary<atan_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
@@ -75,9 +76,12 @@ inline auto atan(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto atan(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().atan(); });
+inline auto atan(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) {
+        return std::forward<decltype(v)>(v).array().atan();
+      });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/atan2.hpp b/stan/math/prim/fun/atan2.hpp
index 7909afdf0d4..060c99ea314 100644
--- a/stan/math/prim/fun/atan2.hpp
+++ b/stan/math/prim/fun/atan2.hpp
@@ -36,9 +36,13 @@ double atan2(T1 y, T2 x) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_not_var_matrix_t<T1, T2>* = nullptr>
-inline auto atan2(const T1& a, const T2& b) {
+inline auto atan2(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return atan2(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return atan2(std::forward<decltype(c)>(c),
+                      std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/atanh.hpp b/stan/math/prim/fun/atanh.hpp
index fdf6c4df9b5..4d1802b1ab6 100644
--- a/stan/math/prim/fun/atanh.hpp
+++ b/stan/math/prim/fun/atanh.hpp
@@ -77,8 +77,8 @@ struct atanh_fun {
  * @return Elementwise atanh of members of container.
  */
 template <typename T, require_ad_container_t<T>* = nullptr>
-inline auto atanh(const T& x) {
-  return apply_scalar_unary<atanh_fun, T>::apply(x);
+inline auto atanh(T&& x) {
+  return apply_scalar_unary<atanh_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 /**
@@ -93,8 +93,8 @@ inline auto atanh(const T& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto atanh(const Container& x) {
-  return apply_scalar_unary<atanh_fun, Container>::apply(x);
+inline auto atanh(Container&& x) {
+  return apply_scalar_unary<atanh_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/bessel_first_kind.hpp b/stan/math/prim/fun/bessel_first_kind.hpp
index e28cd8e3e0c..ba76708d233 100644
--- a/stan/math/prim/fun/bessel_first_kind.hpp
+++ b/stan/math/prim/fun/bessel_first_kind.hpp
@@ -53,10 +53,13 @@ inline T2 bessel_first_kind(int v, const T2 z) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_not_var_matrix_t<T2>* = nullptr>
-inline auto bessel_first_kind(const T1& a, const T2& b) {
+inline auto bessel_first_kind(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return bessel_first_kind(c, d); }, a,
-      b);
+      [](auto&& c, auto&& d) {
+        return bessel_first_kind(std::forward<decltype(c)>(c),
+                                 std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/bessel_second_kind.hpp b/stan/math/prim/fun/bessel_second_kind.hpp
index e7a711c24e4..377badca7f8 100644
--- a/stan/math/prim/fun/bessel_second_kind.hpp
+++ b/stan/math/prim/fun/bessel_second_kind.hpp
@@ -53,10 +53,13 @@ inline T2 bessel_second_kind(int v, const T2 z) {
  * @return Bessel second kind function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto bessel_second_kind(const T1& a, const T2& b) {
+inline auto bessel_second_kind(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return bessel_second_kind(c, d); }, a,
-      b);
+      [](auto&& c, auto&& d) {
+        return bessel_second_kind(std::forward<decltype(c)>(c),
+                                  std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/beta.hpp b/stan/math/prim/fun/beta.hpp
index 969ce5e0efc..58512cb631d 100644
--- a/stan/math/prim/fun/beta.hpp
+++ b/stan/math/prim/fun/beta.hpp
@@ -67,9 +67,13 @@ inline return_type_t<T1, T2> beta(const T1 a, const T2 b) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_not_var_matrix_t<T1, T2>* = nullptr>
-inline auto beta(const T1& a, const T2& b) {
+inline auto beta(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return beta(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return beta(std::forward<decltype(c)>(c),
+                    std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/binary_log_loss.hpp b/stan/math/prim/fun/binary_log_loss.hpp
index 2fba8a37b8d..ba097e56574 100644
--- a/stan/math/prim/fun/binary_log_loss.hpp
+++ b/stan/math/prim/fun/binary_log_loss.hpp
@@ -44,9 +44,13 @@ inline T binary_log_loss(int y, const T& y_hat) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_not_var_matrix_t<T2>* = nullptr>
-inline auto binary_log_loss(const T1& a, const T2& b) {
+inline auto binary_log_loss(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return binary_log_loss(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return binary_log_loss(std::forward<decltype(c)>(c),
+                               std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/binomial_coefficient_log.hpp b/stan/math/prim/fun/binomial_coefficient_log.hpp
index 986807a55f8..f9c70facedc 100644
--- a/stan/math/prim/fun/binomial_coefficient_log.hpp
+++ b/stan/math/prim/fun/binomial_coefficient_log.hpp
@@ -161,12 +161,13 @@ inline return_type_t<T_n, T_k> binomial_coefficient_log(const T_n n,
  * @return Binomial coefficient log function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto binomial_coefficient_log(const T1& a, const T2& b) {
+inline auto binomial_coefficient_log(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) {
-        return binomial_coefficient_log(c, d);
+      [](auto&& c, auto&& d) {
+        return binomial_coefficient_log(std::forward<decltype(c)>(c),
+                                        std::forward<decltype(d)>(d));
       },
-      a, b);
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/cbrt.hpp b/stan/math/prim/fun/cbrt.hpp
index 090105f25aa..0a5d1ae3a71 100644
--- a/stan/math/prim/fun/cbrt.hpp
+++ b/stan/math/prim/fun/cbrt.hpp
@@ -34,8 +34,8 @@ struct cbrt_fun {
 template <
     typename T, require_not_var_matrix_t<T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
-inline auto cbrt(const T& x) {
-  return apply_scalar_unary<cbrt_fun, T>::apply(x);
+inline auto cbrt(T&& x) {
+  return apply_scalar_unary<cbrt_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/ceil.hpp b/stan/math/prim/fun/ceil.hpp
index c257837250e..fc25d99955a 100644
--- a/stan/math/prim/fun/ceil.hpp
+++ b/stan/math/prim/fun/ceil.hpp
@@ -37,8 +37,9 @@ template <typename Container,
           require_not_container_st<std::is_arithmetic, Container>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               Container>* = nullptr>
-inline auto ceil(const Container& x) {
-  return apply_scalar_unary<ceil_fun, Container>::apply(x);
+inline auto ceil(Container&& x) {
+  return apply_scalar_unary<ceil_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
@@ -52,9 +53,12 @@ inline auto ceil(const Container& x) {
 template <typename Container,
           require_container_st<std::is_arithmetic, Container>* = nullptr,
           require_not_var_matrix_t<Container>* = nullptr>
-inline auto ceil(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().ceil(); });
+inline auto ceil(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) {
+        return std::forward<decltype(v)>(v).array().ceil();
+      });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/choose.hpp b/stan/math/prim/fun/choose.hpp
index 92528cc676b..05ac3911b13 100644
--- a/stan/math/prim/fun/choose.hpp
+++ b/stan/math/prim/fun/choose.hpp
@@ -49,9 +49,13 @@ inline int choose(int n, int k) {
  * @return Binomial coefficient function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto choose(const T1& a, const T2& b) {
+inline auto choose(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return choose(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return choose(std::forward<decltype(c)>(c),
+                      std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/cos.hpp b/stan/math/prim/fun/cos.hpp
index 0a3b044ccdc..5f111a9c7b0 100644
--- a/stan/math/prim/fun/cos.hpp
+++ b/stan/math/prim/fun/cos.hpp
@@ -60,8 +60,9 @@ struct cos_fun {
  * @return Cosine of each value in x.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto cos(const Container& x) {
-  return apply_scalar_unary<cos_fun, Container>::apply(x);
+inline auto cos(Container&& x) {
+  return apply_scalar_unary<cos_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
@@ -74,9 +75,12 @@ inline auto cos(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto cos(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [&](const auto& v) { return v.array().cos(); });
+inline auto cos(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [&](const auto& v) {
+        return std::forward<decltype(v)>(v).array().cos();
+      });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/cosh.hpp b/stan/math/prim/fun/cosh.hpp
index ae60c233a68..96734fe39d3 100644
--- a/stan/math/prim/fun/cosh.hpp
+++ b/stan/math/prim/fun/cosh.hpp
@@ -59,8 +59,8 @@ struct cosh_fun {
  * @return Hyberbolic cosine of x.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto cosh(const Container& x) {
-  return apply_scalar_unary<cosh_fun, Container>::apply(x);
+inline auto cosh(Container&& x) {
+  return apply_scalar_unary<cosh_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
 }
 
 /**
@@ -73,9 +73,10 @@ inline auto cosh(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto cosh(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().cosh(); });
+inline auto cosh(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) { return std::forward<decltype(v)>(v).array().cosh(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/digamma.hpp b/stan/math/prim/fun/digamma.hpp
index 05032782e8c..71ccd014b4d 100644
--- a/stan/math/prim/fun/digamma.hpp
+++ b/stan/math/prim/fun/digamma.hpp
@@ -74,8 +74,8 @@ struct digamma_fun {
 template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
-inline auto digamma(const T& x) {
-  return apply_scalar_unary<digamma_fun, T>::apply(x);
+inline auto digamma(T&& x) {
+  return apply_scalar_unary<digamma_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/erf.hpp b/stan/math/prim/fun/erf.hpp
index 9f3526bcafa..683205ded17 100644
--- a/stan/math/prim/fun/erf.hpp
+++ b/stan/math/prim/fun/erf.hpp
@@ -35,8 +35,8 @@ template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
-inline auto erf(const T& x) {
-  return apply_scalar_unary<erf_fun, T>::apply(x);
+inline auto erf(T&& x) {
+  return apply_scalar_unary<erf_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/erfc.hpp b/stan/math/prim/fun/erfc.hpp
index a9599b42b2c..92f3c904cf4 100644
--- a/stan/math/prim/fun/erfc.hpp
+++ b/stan/math/prim/fun/erfc.hpp
@@ -36,8 +36,8 @@ template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
-inline auto erfc(const T& x) {
-  return apply_scalar_unary<erfc_fun, T>::apply(x);
+inline auto erfc(T&& x) {
+  return apply_scalar_unary<erfc_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/exp.hpp b/stan/math/prim/fun/exp.hpp
index d12d82cb556..1524bfca246 100644
--- a/stan/math/prim/fun/exp.hpp
+++ b/stan/math/prim/fun/exp.hpp
@@ -68,8 +68,9 @@ struct exp_fun {
  * @return Elementwise application of exponentiation to the argument.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto exp(const Container& x) {
-  return apply_scalar_unary<exp_fun, Container>::apply(x);
+inline auto exp(Container&& x) {
+  return apply_scalar_unary<exp_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
@@ -82,9 +83,10 @@ inline auto exp(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto exp(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().exp(); });
+inline auto exp(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) { return std::forward<decltype(v)>(v).array().exp(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/exp2.hpp b/stan/math/prim/fun/exp2.hpp
index f5f491cb926..6bea1ff00fb 100644
--- a/stan/math/prim/fun/exp2.hpp
+++ b/stan/math/prim/fun/exp2.hpp
@@ -39,8 +39,8 @@ template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
-inline auto exp2(const T& x) {
-  return apply_scalar_unary<exp2_fun, T>::apply(x);
+inline auto exp2(T&& x) {
+  return apply_scalar_unary<exp2_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/expm1.hpp b/stan/math/prim/fun/expm1.hpp
index 62d6cab97f7..da737a6539e 100644
--- a/stan/math/prim/fun/expm1.hpp
+++ b/stan/math/prim/fun/expm1.hpp
@@ -36,8 +36,8 @@ template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
-inline auto expm1(const T& x) {
-  return apply_scalar_unary<expm1_fun, T>::apply(x);
+inline auto expm1(T&& x) {
+  return apply_scalar_unary<expm1_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/fabs.hpp b/stan/math/prim/fun/fabs.hpp
index 71a1d521656..4b9e5651e4f 100644
--- a/stan/math/prim/fun/fabs.hpp
+++ b/stan/math/prim/fun/fabs.hpp
@@ -48,8 +48,8 @@ template <typename Container,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               Container>* = nullptr,
           require_not_stan_scalar_t<Container>* = nullptr>
-inline auto fabs(const Container& x) {
-  return apply_scalar_unary<fabs_fun, Container>::apply(x);
+inline auto fabs(Container&& x) {
+  return apply_scalar_unary<fabs_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
 }
 
 /**
@@ -62,9 +62,10 @@ inline auto fabs(const Container& x) {
  */
 template <typename Container,
           require_container_st<std::is_arithmetic, Container>* = nullptr>
-inline auto fabs(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().abs(); });
+inline auto fabs(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) { return std::forward<decltype(v)>(v).array().abs(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/falling_factorial.hpp b/stan/math/prim/fun/falling_factorial.hpp
index 0a79f0c4a7c..4040a53150a 100644
--- a/stan/math/prim/fun/falling_factorial.hpp
+++ b/stan/math/prim/fun/falling_factorial.hpp
@@ -80,10 +80,13 @@ inline return_type_t<T> falling_factorial(const T& x, int n) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_not_var_matrix_t<T1, T2>* = nullptr>
-inline auto falling_factorial(const T1& a, const T2& b) {
+inline auto falling_factorial(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return falling_factorial(c, d); }, a,
-      b);
+      [](auto&& c, auto&& d) {
+        return falling_factorial(std::forward<decltype(c)>(c),
+                                 std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/fdim.hpp b/stan/math/prim/fun/fdim.hpp
index 4ed2d8231c7..4e602bfcc7e 100644
--- a/stan/math/prim/fun/fdim.hpp
+++ b/stan/math/prim/fun/fdim.hpp
@@ -35,9 +35,13 @@ inline double fdim(T1 x, T2 y) {
  * @return Fdim function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto fdim(const T1& a, const T2& b) {
+inline auto fdim(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return fdim(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return fdim(std::forward<decltype(c)>(c),
+                    std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/floor.hpp b/stan/math/prim/fun/floor.hpp
index 3845bee34b2..8f5b1a952c2 100644
--- a/stan/math/prim/fun/floor.hpp
+++ b/stan/math/prim/fun/floor.hpp
@@ -42,8 +42,8 @@ struct floor_fun {
  * @return Greatest integer <= each value in x.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto floor(const Container& x) {
-  return apply_scalar_unary<floor_fun, Container>::apply(x);
+inline auto floor(Container&& x) {
+  return apply_scalar_unary<floor_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
 }
 
 /**
@@ -57,9 +57,10 @@ inline auto floor(const Container& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr,
           require_not_var_matrix_t<Container>* = nullptr>
-inline auto floor(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().floor(); });
+inline auto floor(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) { return std::forward<decltype(v)>(v).array().floor(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/fmax.hpp b/stan/math/prim/fun/fmax.hpp
index 43790df1272..620a7f5f4f7 100644
--- a/stan/math/prim/fun/fmax.hpp
+++ b/stan/math/prim/fun/fmax.hpp
@@ -33,9 +33,13 @@ inline double fmax(T1 x, T2 y) {
  * @return fmax function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto fmax(const T1& a, const T2& b) {
+inline auto fmax(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return fmax(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return fmax(std::forward<decltype(c)>(c),
+                    std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/fmin.hpp b/stan/math/prim/fun/fmin.hpp
index c7011c00a2c..7bf25f93be9 100644
--- a/stan/math/prim/fun/fmin.hpp
+++ b/stan/math/prim/fun/fmin.hpp
@@ -33,9 +33,13 @@ inline double fmin(T1 x, T2 y) {
  * @return fmin function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto fmin(const T1& a, const T2& b) {
+inline auto fmin(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return fmin(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return fmin(std::forward<decltype(c)>(c),
+                    std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/fmod.hpp b/stan/math/prim/fun/fmod.hpp
index 53c575c12d8..26f916df7b5 100644
--- a/stan/math/prim/fun/fmod.hpp
+++ b/stan/math/prim/fun/fmod.hpp
@@ -34,13 +34,14 @@ inline double fmod(const T1& a, const T2& b) {
  * @return fmod function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto fmod(const T1& a, const T2& b) {
+inline auto fmod(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) {
+      [](auto&& c, auto&& d) {
         using std::fmod;
-        return fmod(c, d);
+        return fmod(std::forward<decltype(c)>(c),
+                    std::forward<decltype(d)>(d));
       },
-      a, b);
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/gamma_p.hpp b/stan/math/prim/fun/gamma_p.hpp
index de21249ca37..512d3c48526 100644
--- a/stan/math/prim/fun/gamma_p.hpp
+++ b/stan/math/prim/fun/gamma_p.hpp
@@ -87,9 +87,12 @@ inline double gamma_p(double z, double a) {
  * @return gamma_p function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto gamma_p(const T1& a, const T2& b) {
+inline auto gamma_p(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return gamma_p(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return gamma_p(std::forward<decltype(c)>(c), std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/gamma_q.hpp b/stan/math/prim/fun/gamma_q.hpp
index 2b4e2494305..17b9ceb92da 100644
--- a/stan/math/prim/fun/gamma_q.hpp
+++ b/stan/math/prim/fun/gamma_q.hpp
@@ -65,9 +65,13 @@ inline double gamma_q(double x, double a) { return boost::math::gamma_q(x, a); }
  * @return gamma_q function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto gamma_q(const T1& a, const T2& b) {
+inline auto gamma_q(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return gamma_q(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return gamma_q(std::forward<decltype(c)>(c),
+                       std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/hypot.hpp b/stan/math/prim/fun/hypot.hpp
index 07fe51d1857..c074b730f17 100644
--- a/stan/math/prim/fun/hypot.hpp
+++ b/stan/math/prim/fun/hypot.hpp
@@ -39,9 +39,13 @@ inline double hypot(T1 x, T2 y) {
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               T1, T2>* = nullptr>
-inline auto hypot(const T1& a, const T2& b) {
+inline auto hypot(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return hypot(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return hypot(std::forward<decltype(c)>(c),
+                     std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/inv.hpp b/stan/math/prim/fun/inv.hpp
index fe09a75e6df..c798ea20b1c 100644
--- a/stan/math/prim/fun/inv.hpp
+++ b/stan/math/prim/fun/inv.hpp
@@ -34,8 +34,8 @@ struct inv_fun {
 template <
     typename T, require_not_container_st<std::is_arithmetic, T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
-inline auto inv(const T& x) {
-  return apply_scalar_unary<inv_fun, T>::apply(x);
+inline auto inv(T&& x) {
+  return apply_scalar_unary<inv_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 /**
@@ -50,9 +50,10 @@ template <typename Container,
           require_container_st<std::is_arithmetic, Container>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               Container>* = nullptr>
-inline auto inv(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().inverse(); });
+inline auto inv(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) { return std::forward<decltype(v)>(v).array().inverse(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/inv_Phi.hpp b/stan/math/prim/fun/inv_Phi.hpp
index 0ec72de8062..15b11207edc 100644
--- a/stan/math/prim/fun/inv_Phi.hpp
+++ b/stan/math/prim/fun/inv_Phi.hpp
@@ -177,8 +177,8 @@ template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
-inline auto inv_Phi(const T& x) {
-  return apply_scalar_unary<inv_Phi_fun, T>::apply(x);
+inline auto inv_Phi(T&& x) {
+  return apply_scalar_unary<inv_Phi_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/inv_cloglog.hpp b/stan/math/prim/fun/inv_cloglog.hpp
index f197d49c24e..05d057f0386 100644
--- a/stan/math/prim/fun/inv_cloglog.hpp
+++ b/stan/math/prim/fun/inv_cloglog.hpp
@@ -90,8 +90,8 @@ struct inv_cloglog_fun {
  * @return 1 - exp(-exp()) applied to each value in x.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto inv_cloglog(const Container& x) {
-  return apply_scalar_unary<inv_cloglog_fun, Container>::apply(x);
+inline auto inv_cloglog(Container&& x) {
+  return apply_scalar_unary<inv_cloglog_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
 }
 
 /**
@@ -104,9 +104,12 @@ inline auto inv_cloglog(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto inv_cloglog(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return 1 - (-v.array().exp()).exp(); });
+inline auto inv_cloglog(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) {
+        return 1 - (-std::forward<decltype(v)>(v).array().exp()).exp();
+      });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/inv_erfc.hpp b/stan/math/prim/fun/inv_erfc.hpp
index 4eca9e1b8cd..1afba170442 100644
--- a/stan/math/prim/fun/inv_erfc.hpp
+++ b/stan/math/prim/fun/inv_erfc.hpp
@@ -48,8 +48,8 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr,
     require_not_arithmetic_t<T>* = nullptr>
-inline auto inv_erfc(const T& x) {
-  return apply_scalar_unary<inv_erfc_fun, T>::apply(x);
+inline auto inv_erfc(T&& x) {
+  return apply_scalar_unary<inv_erfc_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/inv_sqrt.hpp b/stan/math/prim/fun/inv_sqrt.hpp
index 00fa616a45f..80fc7431880 100644
--- a/stan/math/prim/fun/inv_sqrt.hpp
+++ b/stan/math/prim/fun/inv_sqrt.hpp
@@ -45,8 +45,8 @@ struct inv_sqrt_fun {
  * @return inverse square root of each value in x.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto inv_sqrt(const Container& x) {
-  return apply_scalar_unary<inv_sqrt_fun, Container>::apply(x);
+inline auto inv_sqrt(Container&& x) {
+  return apply_scalar_unary<inv_sqrt_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
 }
 
 /**
@@ -59,14 +59,16 @@ inline auto inv_sqrt(const Container& x) {
  */
 template <typename Container, require_not_var_matrix_t<Container>* = nullptr,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto inv_sqrt(const Container& x) {
+inline auto inv_sqrt(Container&& x) {
 // Eigen 3.4.0 has precision issues on ARM64 with vectorised rsqrt
 // Resolved in current master branch, below can be removed on next release
 #ifdef __aarch64__
-  return apply_scalar_unary<inv_sqrt_fun, Container>::apply(x);
+  return apply_scalar_unary<inv_sqrt_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 #else
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().rsqrt(); });
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) { return std::forward<decltype(v)>(v).array().rsqrt(); });
 #endif
 }
 
diff --git a/stan/math/prim/fun/inv_square.hpp b/stan/math/prim/fun/inv_square.hpp
index 0793e054c3d..074afbde47d 100644
--- a/stan/math/prim/fun/inv_square.hpp
+++ b/stan/math/prim/fun/inv_square.hpp
@@ -34,9 +34,12 @@ inline auto inv_square(const Container& x) {
  */
 template <typename Container,
           require_container_st<std::is_arithmetic, Container>* = nullptr>
-inline auto inv_square(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().square().inverse(); });
+inline auto inv_square(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) {
+        return std::forward<decltype(v)>(v).array().square().inverse();
+      });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/lambert_w.hpp b/stan/math/prim/fun/lambert_w.hpp
index 2af6cf9e55f..9fedeee69d2 100644
--- a/stan/math/prim/fun/lambert_w.hpp
+++ b/stan/math/prim/fun/lambert_w.hpp
@@ -80,8 +80,8 @@ struct lambert_wm1_fun {
  */
 template <typename T, require_not_stan_scalar_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
-inline auto lambert_w0(const T& x) {
-  return apply_scalar_unary<internal::lambert_w0_fun, T>::apply(x);
+inline auto lambert_w0(T&& x) {
+  return apply_scalar_unary<internal::lambert_w0_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 /**
@@ -95,8 +95,8 @@ inline auto lambert_w0(const T& x) {
  */
 template <typename T, require_not_stan_scalar_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
-inline auto lambert_wm1(const T& x) {
-  return apply_scalar_unary<internal::lambert_wm1_fun, T>::apply(x);
+inline auto lambert_wm1(T&& x) {
+  return apply_scalar_unary<internal::lambert_wm1_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/lbeta.hpp b/stan/math/prim/fun/lbeta.hpp
index 82b4a507bea..5716c290b8c 100644
--- a/stan/math/prim/fun/lbeta.hpp
+++ b/stan/math/prim/fun/lbeta.hpp
@@ -127,9 +127,13 @@ return_type_t<T1, T2> lbeta(const T1 a, const T2 b) {
  * @return lbeta function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto lbeta(const T1& a, const T2& b) {
+inline auto lbeta(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return lbeta(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return lbeta(std::forward<decltype(c)>(c),
+                     std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/ldexp.hpp b/stan/math/prim/fun/ldexp.hpp
index 01f6856032a..4430559ec5b 100644
--- a/stan/math/prim/fun/ldexp.hpp
+++ b/stan/math/prim/fun/ldexp.hpp
@@ -36,9 +36,13 @@ inline double ldexp(T1 a, int b) {
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               T1, T2>* = nullptr>
-inline auto ldexp(const T1& a, const T2& b) {
+inline auto ldexp(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return ldexp(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return ldexp(std::forward<decltype(c)>(c),
+                     std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/lgamma.hpp b/stan/math/prim/fun/lgamma.hpp
index 8c5fec86e79..6cfb99d20ec 100644
--- a/stan/math/prim/fun/lgamma.hpp
+++ b/stan/math/prim/fun/lgamma.hpp
@@ -116,8 +116,8 @@ struct lgamma_fun {
  */
 template <typename T, require_not_var_matrix_t<T>* = nullptr,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
-inline auto lgamma(const T& x) {
-  return apply_scalar_unary<lgamma_fun, T>::apply(x);
+inline auto lgamma(T&& x) {
+  return apply_scalar_unary<lgamma_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/lmgamma.hpp b/stan/math/prim/fun/lmgamma.hpp
index 5d1b946f7e8..9f4381deaf0 100644
--- a/stan/math/prim/fun/lmgamma.hpp
+++ b/stan/math/prim/fun/lmgamma.hpp
@@ -70,9 +70,13 @@ inline return_type_t<T> lmgamma(int k, T x) {
  * inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto lmgamma(const T1& a, const T2& b) {
+inline auto lmgamma(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return lmgamma(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return lmgamma(std::forward<decltype(c)>(c),
+                       std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/lmultiply.hpp b/stan/math/prim/fun/lmultiply.hpp
index e7de4468f81..8e38dc0695d 100644
--- a/stan/math/prim/fun/lmultiply.hpp
+++ b/stan/math/prim/fun/lmultiply.hpp
@@ -43,9 +43,13 @@ inline return_type_t<T1, T2> lmultiply(const T1 a, const T2 b) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_not_var_matrix_t<T1, T2>* = nullptr>
-inline auto lmultiply(const T1& a, const T2& b) {
+inline auto lmultiply(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return lmultiply(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return lmultiply(std::forward<decltype(c)>(c),
+                         std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log.hpp b/stan/math/prim/fun/log.hpp
index 8216cee2aa6..1402ecd3fea 100644
--- a/stan/math/prim/fun/log.hpp
+++ b/stan/math/prim/fun/log.hpp
@@ -67,8 +67,9 @@ struct log_fun {
  * @return Elementwise application of natural log to the argument.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto log(const Container& x) {
-  return apply_scalar_unary<log_fun, Container>::apply(x);
+inline auto log(Container&& x) {
+  return apply_scalar_unary<log_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
@@ -81,9 +82,10 @@ inline auto log(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto log(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().log(); });
+inline auto log(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) { return std::forward<decltype(v)>(v).array().log(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/log10.hpp b/stan/math/prim/fun/log10.hpp
index f7d81343ea5..59e07b9cf30 100644
--- a/stan/math/prim/fun/log10.hpp
+++ b/stan/math/prim/fun/log10.hpp
@@ -58,8 +58,8 @@ struct log10_fun {
  * @return Log base-10 applied to each value in x.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto log10(const Container& x) {
-  return apply_scalar_unary<log10_fun, Container>::apply(x);
+inline auto log10(Container&& x) {
+  return apply_scalar_unary<log10_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
 }
 
 /**
@@ -72,9 +72,10 @@ inline auto log10(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto log10(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().log10(); });
+inline auto log10(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) { return std::forward<decltype(v)>(v).array().log10(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/log1m.hpp b/stan/math/prim/fun/log1m.hpp
index 702ee7f20fb..c092ea8873a 100644
--- a/stan/math/prim/fun/log1m.hpp
+++ b/stan/math/prim/fun/log1m.hpp
@@ -70,8 +70,8 @@ struct log1m_fun {
 template <
     typename T, require_not_var_matrix_t<T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
-inline auto log1m(const T& x) {
-  return apply_scalar_unary<log1m_fun, T>::apply(x);
+inline auto log1m(T&& x) {
+  return apply_scalar_unary<log1m_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log1m_exp.hpp b/stan/math/prim/fun/log1m_exp.hpp
index 89d1a4d6af6..c79aed1b725 100644
--- a/stan/math/prim/fun/log1m_exp.hpp
+++ b/stan/math/prim/fun/log1m_exp.hpp
@@ -80,8 +80,8 @@ struct log1m_exp_fun {
 template <
     typename T, require_not_var_matrix_t<T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
-inline auto log1m_exp(const T& x) {
-  return apply_scalar_unary<log1m_exp_fun, T>::apply(x);
+inline auto log1m_exp(T&& x) {
+  return apply_scalar_unary<log1m_exp_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log1m_inv_logit.hpp b/stan/math/prim/fun/log1m_inv_logit.hpp
index 0128aa7804e..d6717a431af 100644
--- a/stan/math/prim/fun/log1m_inv_logit.hpp
+++ b/stan/math/prim/fun/log1m_inv_logit.hpp
@@ -82,9 +82,10 @@ struct log1m_inv_logit_fun {
  */
 template <typename T, require_not_var_matrix_t<T>* = nullptr,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
-inline typename apply_scalar_unary<log1m_inv_logit_fun, T>::return_t
-log1m_inv_logit(const T& x) {
-  return apply_scalar_unary<log1m_inv_logit_fun, T>::apply(x);
+inline typename apply_scalar_unary<log1m_inv_logit_fun, std::decay_t<T>>::return_t
+log1m_inv_logit(T&& x) {
+  return apply_scalar_unary<log1m_inv_logit_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log1p.hpp b/stan/math/prim/fun/log1p.hpp
index 3bcbc205a54..e4d15264ec7 100644
--- a/stan/math/prim/fun/log1p.hpp
+++ b/stan/math/prim/fun/log1p.hpp
@@ -79,8 +79,8 @@ struct log1p_fun {
 template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
-inline auto log1p(const T& x) {
-  return apply_scalar_unary<log1p_fun, T>::apply(x);
+inline auto log1p(T&& x) {
+  return apply_scalar_unary<log1p_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log1p_exp.hpp b/stan/math/prim/fun/log1p_exp.hpp
index de658ae3885..02df5805859 100644
--- a/stan/math/prim/fun/log1p_exp.hpp
+++ b/stan/math/prim/fun/log1p_exp.hpp
@@ -75,8 +75,8 @@ struct log1p_exp_fun {
 template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
-inline auto log1p_exp(const T& x) {
-  return apply_scalar_unary<log1p_exp_fun, T>::apply(x);
+inline auto log1p_exp(T&& x) {
+  return apply_scalar_unary<log1p_exp_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log2.hpp b/stan/math/prim/fun/log2.hpp
index 52a0674b8f1..ecd11406c56 100644
--- a/stan/math/prim/fun/log2.hpp
+++ b/stan/math/prim/fun/log2.hpp
@@ -46,8 +46,8 @@ struct log2_fun {
  */
 template <typename T, require_not_var_matrix_t<T>* = nullptr,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
-inline auto log2(const T& x) {
-  return apply_scalar_unary<log2_fun, T>::apply(x);
+inline auto log2(T&& x) {
+  return apply_scalar_unary<log2_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_diff_exp.hpp b/stan/math/prim/fun/log_diff_exp.hpp
index a393015582e..463220d5ee7 100644
--- a/stan/math/prim/fun/log_diff_exp.hpp
+++ b/stan/math/prim/fun/log_diff_exp.hpp
@@ -66,9 +66,13 @@ inline return_type_t<T1, T2> log_diff_exp(const T1 x, const T2 y) {
  * @return log_diff_exp function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto log_diff_exp(const T1& a, const T2& b) {
+inline auto log_diff_exp(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return log_diff_exp(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return log_diff_exp(std::forward<decltype(c)>(c),
+                            std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_falling_factorial.hpp b/stan/math/prim/fun/log_falling_factorial.hpp
index 7180e42ab6f..f1770d66e70 100644
--- a/stan/math/prim/fun/log_falling_factorial.hpp
+++ b/stan/math/prim/fun/log_falling_factorial.hpp
@@ -72,10 +72,13 @@ inline return_type_t<T1, T2> log_falling_factorial(const T1 x, const T2 n) {
  * @return log_falling_factorial function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto log_falling_factorial(const T1& a, const T2& b) {
+inline auto log_falling_factorial(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return log_falling_factorial(c, d); },
-      a, b);
+      [](auto&& c, auto&& d) {
+        return log_falling_factorial(std::forward<decltype(c)>(c),
+                                     std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_inv_logit.hpp b/stan/math/prim/fun/log_inv_logit.hpp
index d63d8ccf36a..a02d4f376ae 100644
--- a/stan/math/prim/fun/log_inv_logit.hpp
+++ b/stan/math/prim/fun/log_inv_logit.hpp
@@ -81,8 +81,8 @@ struct log_inv_logit_fun {
 template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
-inline auto log_inv_logit(const T& x) {
-  return apply_scalar_unary<log_inv_logit_fun, T>::apply(x);
+inline auto log_inv_logit(T&& x) {
+  return apply_scalar_unary<log_inv_logit_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_inv_logit_diff.hpp b/stan/math/prim/fun/log_inv_logit_diff.hpp
index 9843583d3fc..96bce37601b 100644
--- a/stan/math/prim/fun/log_inv_logit_diff.hpp
+++ b/stan/math/prim/fun/log_inv_logit_diff.hpp
@@ -52,10 +52,13 @@ inline return_type_t<T1, T2> log_inv_logit_diff(const T1& x, const T2& y) {
  * @return log_inv_logit_diff function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto log_inv_logit_diff(const T1& a, const T2& b) {
+inline auto log_inv_logit_diff(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return log_inv_logit_diff(c, d); }, a,
-      b);
+      [](auto&& c, auto&& d) {
+        return log_inv_logit_diff(std::forward<decltype(c)>(c),
+                                  std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_modified_bessel_first_kind.hpp b/stan/math/prim/fun/log_modified_bessel_first_kind.hpp
index 7607560a08d..49a17ac36bf 100644
--- a/stan/math/prim/fun/log_modified_bessel_first_kind.hpp
+++ b/stan/math/prim/fun/log_modified_bessel_first_kind.hpp
@@ -232,12 +232,13 @@ inline return_type_t<T1, T2, double> log_modified_bessel_first_kind(
  * @return log_modified_bessel_first_kind function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto log_modified_bessel_first_kind(const T1& a, const T2& b) {
+inline auto log_modified_bessel_first_kind(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) {
-        return log_modified_bessel_first_kind(c, d);
+      [](auto&& c, auto&& d) {
+        return log_modified_bessel_first_kind(std::forward<decltype(c)>(c),
+                                              std::forward<decltype(d)>(d));
       },
-      a, b);
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_rising_factorial.hpp b/stan/math/prim/fun/log_rising_factorial.hpp
index bff1df3d9e1..24bc73533ea 100644
--- a/stan/math/prim/fun/log_rising_factorial.hpp
+++ b/stan/math/prim/fun/log_rising_factorial.hpp
@@ -70,10 +70,13 @@ inline return_type_t<T1, T2> log_rising_factorial(const T1& x, const T2& n) {
  * @return log_rising_factorial function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto log_rising_factorial(const T1& a, const T2& b) {
+inline auto log_rising_factorial(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return log_rising_factorial(c, d); },
-      a, b);
+      [](auto&& c, auto&& d) {
+        return log_rising_factorial(std::forward<decltype(c)>(c),
+                                    std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_softmax.hpp b/stan/math/prim/fun/log_softmax.hpp
index 62d753293f6..8471c2646ae 100644
--- a/stan/math/prim/fun/log_softmax.hpp
+++ b/stan/math/prim/fun/log_softmax.hpp
@@ -41,14 +41,17 @@ namespace math {
  */
 template <typename Container, require_st_arithmetic<Container>* = nullptr,
           require_container_t<Container>* = nullptr>
-inline auto log_softmax(const Container& x) {
+inline auto log_softmax(Container&& x) {
   check_nonzero_size("log_softmax", "v", x);
   return make_holder(
-      [](const auto& a) {
-        return apply_vector_unary<ref_type_t<Container>>::apply(
-            a, [](const auto& v) { return v.array() - log_sum_exp(v); });
+      [](auto&& a) {
+        return apply_vector_unary<ref_type_t<std::decay_t<Container>>>::apply(
+            std::forward<decltype(a)>(a),
+            [](const auto& v) {
+              return std::forward<decltype(v)>(v).array() - log_sum_exp(v);
+            });
       },
-      to_ref(x));
+      to_ref(std::forward<Container>(x)));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_sum_exp.hpp b/stan/math/prim/fun/log_sum_exp.hpp
index 128b9cd8189..7d732b47c26 100644
--- a/stan/math/prim/fun/log_sum_exp.hpp
+++ b/stan/math/prim/fun/log_sum_exp.hpp
@@ -79,8 +79,9 @@ inline return_type_t<T1, T2> log_sum_exp(const T2& a, const T1& b) {
  * @return The log of the sum of the exponentiated vector values.
  */
 template <typename T, require_container_st<std::is_arithmetic, T>* = nullptr>
-inline auto log_sum_exp(const T& x) {
-  return apply_vector_unary<T>::reduce(x, [&](const auto& v) {
+inline auto log_sum_exp(T&& x) {
+  return apply_vector_unary<std::decay_t<T>>::reduce(
+      std::forward<T>(x), [&](auto&& v) {
     if (v.size() == 0) {
       return NEGATIVE_INFTY;
     }
@@ -104,9 +105,13 @@ inline auto log_sum_exp(const T& x) {
  * @return log_sum_exp function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto log_sum_exp(const T1& a, const T2& b) {
+inline auto log_sum_exp(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return log_sum_exp(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return log_sum_exp(std::forward<decltype(c)>(c),
+                           std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/logit.hpp b/stan/math/prim/fun/logit.hpp
index 3f6f7ce7a8c..82498e42135 100644
--- a/stan/math/prim/fun/logit.hpp
+++ b/stan/math/prim/fun/logit.hpp
@@ -87,8 +87,8 @@ struct logit_fun {
  * @return elementwise logit of container elements
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto logit(const Container& x) {
-  return apply_scalar_unary<logit_fun, Container>::apply(x);
+inline auto logit(Container&& x) {
+  return apply_scalar_unary<logit_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
 }
 
 /**
@@ -104,14 +104,19 @@ inline auto logit(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto logit(const Container& x) {
+inline auto logit(Container&& x) {
   return make_holder(
-      [](const auto& v_ref) {
-        return apply_vector_unary<ref_type_t<Container>>::apply(
-            v_ref,
-            [](const auto& v) { return (v.array() / (1 - v.array())).log(); });
+      [](auto&& v_ref) {
+        return apply_vector_unary<ref_type_t<std::decay_t<Container>>>::apply(
+            std::forward<decltype(v_ref)>(v_ref),
+            [](const auto& v) {
+              return (
+                         std::forward<decltype(v)>(v).array()
+                         / (1 - std::forward<decltype(v)>(v).array()))
+                  .log();
+            });
       },
-      to_ref(x));
+      to_ref(std::forward<Container>(x)));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/minus.hpp b/stan/math/prim/fun/minus.hpp
index b2830183ad3..02e8ddd5bc3 100644
--- a/stan/math/prim/fun/minus.hpp
+++ b/stan/math/prim/fun/minus.hpp
@@ -27,9 +27,10 @@ inline auto minus(const T& x) {
  * @return Container where each element is negated.
  */
 template <typename T>
-inline auto minus(const std::vector<T>& x) {
+inline auto minus(std::vector<T>&& x) {
   return apply_vector_unary<std::vector<T>>::apply(
-      x, [](const auto& v) { return -v; });
+      std::forward<std::vector<T>>(x),
+      [](auto&& v) { return -std::forward<decltype(v)>(v); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/modified_bessel_first_kind.hpp b/stan/math/prim/fun/modified_bessel_first_kind.hpp
index 25a6f214726..448787662a7 100644
--- a/stan/math/prim/fun/modified_bessel_first_kind.hpp
+++ b/stan/math/prim/fun/modified_bessel_first_kind.hpp
@@ -63,12 +63,13 @@ inline double modified_bessel_first_kind(int v, int z) {
  * @return modified_bessel_first_kind function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto modified_bessel_first_kind(const T1& a, const T2& b) {
+inline auto modified_bessel_first_kind(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) {
-        return modified_bessel_first_kind(c, d);
+      [](auto&& c, auto&& d) {
+        return modified_bessel_first_kind(std::forward<decltype(c)>(c),
+                                          std::forward<decltype(d)>(d));
       },
-      a, b);
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/modified_bessel_second_kind.hpp b/stan/math/prim/fun/modified_bessel_second_kind.hpp
index cfb00030ae8..1f4bf7edfe0 100644
--- a/stan/math/prim/fun/modified_bessel_second_kind.hpp
+++ b/stan/math/prim/fun/modified_bessel_second_kind.hpp
@@ -55,12 +55,13 @@ inline T2 modified_bessel_second_kind(int v, const T2 z) {
  * @return modified_bessel_second_kind function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto modified_bessel_second_kind(const T1& a, const T2& b) {
+inline auto modified_bessel_second_kind(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) {
-        return modified_bessel_second_kind(c, d);
+      [](auto&& c, auto&& d) {
+        return modified_bessel_second_kind(std::forward<decltype(c)>(c),
+                                           std::forward<decltype(d)>(d));
       },
-      a, b);
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/multiply_log.hpp b/stan/math/prim/fun/multiply_log.hpp
index 6dcd8909999..fb5010d9e27 100644
--- a/stan/math/prim/fun/multiply_log.hpp
+++ b/stan/math/prim/fun/multiply_log.hpp
@@ -67,9 +67,13 @@ inline return_type_t<T_a, T_b> multiply_log(const T_a a, const T_b b) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_not_var_matrix_t<T1, T2>* = nullptr>
-inline auto multiply_log(const T1& a, const T2& b) {
+inline auto multiply_log(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return multiply_log(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return multiply_log(std::forward<decltype(c)>(c),
+                            std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/norm1.hpp b/stan/math/prim/fun/norm1.hpp
index c842ff27917..a6dd7e08507 100644
--- a/stan/math/prim/fun/norm1.hpp
+++ b/stan/math/prim/fun/norm1.hpp
@@ -31,9 +31,10 @@ inline double norm1(const T& v) {
  * @return L1 norm of v.
  */
 template <typename Container, require_std_vector_t<Container>* = nullptr>
-inline auto norm1(const Container& x) {
-  return apply_vector_unary<Container>::reduce(
-      x, [](const auto& v) { return norm1(v); });
+inline auto norm1(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::reduce(
+      std::forward<Container>(x),
+      [](auto&& v) { return norm1(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/norm2.hpp b/stan/math/prim/fun/norm2.hpp
index 07040003943..235782f9ad5 100644
--- a/stan/math/prim/fun/norm2.hpp
+++ b/stan/math/prim/fun/norm2.hpp
@@ -31,9 +31,10 @@ inline double norm2(const T& v) {
  * @return L2 norm of v.
  */
 template <typename Container, require_std_vector_t<Container>* = nullptr>
-inline auto norm2(const Container& x) {
-  return apply_vector_unary<Container>::reduce(
-      x, [](const auto& v) { return norm2(v); });
+inline auto norm2(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::reduce(
+      std::forward<Container>(x),
+      [](auto&& v) { return norm2(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/owens_t.hpp b/stan/math/prim/fun/owens_t.hpp
index 88f4302e8aa..8ddd9fabf56 100644
--- a/stan/math/prim/fun/owens_t.hpp
+++ b/stan/math/prim/fun/owens_t.hpp
@@ -74,9 +74,13 @@ inline double owens_t(double h, double a) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_not_var_and_matrix_types<T1, T2>* = nullptr>
-inline auto owens_t(const T1& a, const T2& b) {
+inline auto owens_t(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return owens_t(c, d); }, a, b);
+      [](auto&& c, auto&& d) {
+        return owens_t(std::forward<decltype(c)>(c),
+                       std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/pow.hpp b/stan/math/prim/fun/pow.hpp
index b93957891c6..d0ea2470718 100644
--- a/stan/math/prim/fun/pow.hpp
+++ b/stan/math/prim/fun/pow.hpp
@@ -108,10 +108,11 @@ inline auto pow(const T1& a, const T2& b) {
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_not_matrix_st<is_var, T1, T2>* = nullptr,
           require_all_arithmetic_t<base_type_t<T1>, base_type_t<T2>>* = nullptr>
-inline auto pow(const T1& a, const T2& b) {
+inline auto pow(T1&& a, T2&& b) {
   return apply_scalar_binary(
       // Qualified pow since only Arithmetic types are accepted here
-      [](const auto& c, const auto& d) { return stan::math::pow(c, d); }, a, b);
+      [](const auto& c, const auto& d) { return stan::math::pow(c, d); },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 }  // namespace math
 }  // namespace stan
diff --git a/stan/math/prim/fun/rising_factorial.hpp b/stan/math/prim/fun/rising_factorial.hpp
index 5a93b9f079f..c3288b9e7b0 100644
--- a/stan/math/prim/fun/rising_factorial.hpp
+++ b/stan/math/prim/fun/rising_factorial.hpp
@@ -78,10 +78,13 @@ inline return_type_t<T> rising_factorial(const T& x, int n) {
  * @return rising_factorial function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto rising_factorial(const T1& a, const T2& b) {
+inline auto rising_factorial(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return rising_factorial(c, d); }, a,
-      b);
+      [](auto&& c, auto&& d) {
+        return rising_factorial(std::forward<decltype(c)>(c),
+                                std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/round.hpp b/stan/math/prim/fun/round.hpp
index 5ed3649bc47..1b196cceee3 100644
--- a/stan/math/prim/fun/round.hpp
+++ b/stan/math/prim/fun/round.hpp
@@ -36,8 +36,8 @@ template <typename Container,
           require_not_container_st<std::is_arithmetic, Container>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               Container>* = nullptr>
-inline auto round(const Container& x) {
-  return apply_scalar_unary<round_fun, Container>::apply(x);
+inline auto round(Container&& x) {
+  return apply_scalar_unary<round_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
 }
 
 /**
@@ -50,9 +50,10 @@ inline auto round(const Container& x) {
  */
 template <typename Container,
           require_container_st<std::is_arithmetic, Container>* = nullptr>
-inline auto round(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().round(); });
+inline auto round(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) { return std::forward<decltype(v)>(v).array().round(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sd.hpp b/stan/math/prim/fun/sd.hpp
index 39223a6135b..b2b928403af 100644
--- a/stan/math/prim/fun/sd.hpp
+++ b/stan/math/prim/fun/sd.hpp
@@ -23,10 +23,11 @@ namespace math {
  */
 template <typename T, require_container_t<T>* = nullptr,
           require_not_st_var<T>* = nullptr>
-inline auto sd(const T& m) {
+inline auto sd(T&& m) {
   using std::sqrt;
 
-  return apply_vector_unary<T>::reduce(m, [](const auto& x) {
+  return apply_vector_unary<std::decay_t<T>>::reduce(
+      std::forward<T>(m), [](auto&& x) {
     check_nonzero_size("sd", "x", x);
 
     if (x.size() == 1) {
diff --git a/stan/math/prim/fun/select.hpp b/stan/math/prim/fun/select.hpp
index def8bd3d67c..7968d65a12b 100644
--- a/stan/math/prim/fun/select.hpp
+++ b/stan/math/prim/fun/select.hpp
@@ -23,8 +23,8 @@ namespace math {
 template <typename T_true, typename T_false,
           typename ReturnT = return_type_t<T_true, T_false>,
           require_all_stan_scalar_t<T_true, T_false>* = nullptr>
-inline ReturnT select(const bool c, const T_true y_true,
-                      const T_false y_false) {
+inline ReturnT select(const bool c, T_true&& y_true,
+                      T_false&& y_false) {
   return c ? ReturnT(y_true) : ReturnT(y_false);
 }
 
@@ -80,16 +80,16 @@ template <typename T_true, typename T_false,
                                               plain_type_t<T_true>>,
           require_container_t<T_true>* = nullptr,
           require_stan_scalar_t<T_false>* = nullptr>
-inline ReturnT select(const bool c, const T_true& y_true,
-                      const T_false& y_false) {
+inline ReturnT select(const bool c, T_true&& y_true,
+                      T_false&& y_false) {
   if (c) {
     return y_true;
   } else {
     return apply_scalar_binary(
-        [](const auto& y_true_inner, const auto& y_false_inner) {
-          return y_false_inner;
+        [](auto&& y_true_inner, auto&& y_false_inner) {
+          return std::forward<decltype(y_false_inner)>(y_false_inner);
         },
-        y_true, y_false);
+        std::forward<T_true>(y_true), std::forward<T_false>(y_false));
   }
 }
 
@@ -119,10 +119,10 @@ inline ReturnT select(const bool c, const T_true y_true,
                       const T_false y_false) {
   if (c) {
     return apply_scalar_binary(
-        [](const auto& y_true_inner, const auto& y_false_inner) {
-          return y_true_inner;
+        [](auto&& y_true_inner, auto&& y_false_inner) {
+          return std::forward<decltype(y_true_inner)>(y_true_inner);
         },
-        y_true, y_false);
+        std::forward<T_true>(y_true), std::forward<T_false>(y_false));
   } else {
     return y_false;
   }
diff --git a/stan/math/prim/fun/sign.hpp b/stan/math/prim/fun/sign.hpp
index 0651030f0eb..50449bd0e2e 100644
--- a/stan/math/prim/fun/sign.hpp
+++ b/stan/math/prim/fun/sign.hpp
@@ -39,8 +39,8 @@ struct sign_fun {
  * @return Elementwise sign of members of container.
  */
 template <typename T, require_container_t<T>* = nullptr>
-inline auto sign(const T& x) {
-  return apply_scalar_unary<sign_fun, T>::apply(x);
+inline auto sign(T&& x) {
+  return apply_scalar_unary<sign_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sin.hpp b/stan/math/prim/fun/sin.hpp
index a0145dd4c6b..0a1678a38bf 100644
--- a/stan/math/prim/fun/sin.hpp
+++ b/stan/math/prim/fun/sin.hpp
@@ -59,8 +59,9 @@ struct sin_fun {
  * @return Sine of each value in x.
  */
 template <typename T, require_ad_container_t<T>* = nullptr>
-inline auto sin(const T& x) {
-  return apply_scalar_unary<sin_fun, T>::apply(x);
+inline auto sin(T&& x) {
+  return apply_scalar_unary<sin_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 /**
@@ -73,9 +74,10 @@ inline auto sin(const T& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto sin(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [&](const auto& v) { return v.array().sin(); });
+inline auto sin(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [&](const auto& v) { return std::forward<decltype(v)>(v).array().sin(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/sinh.hpp b/stan/math/prim/fun/sinh.hpp
index e3e55fa7477..dd34a48145a 100644
--- a/stan/math/prim/fun/sinh.hpp
+++ b/stan/math/prim/fun/sinh.hpp
@@ -57,8 +57,8 @@ struct sinh_fun {
  * @return Hyperbolic sine of each variable in x.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto sinh(const Container& x) {
-  return apply_scalar_unary<sinh_fun, Container>::apply(x);
+inline auto sinh(Container&& x) {
+  return apply_scalar_unary<sinh_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
 }
 
 /**
@@ -71,9 +71,10 @@ inline auto sinh(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto sinh(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().sinh(); });
+inline auto sinh(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) { return std::forward<decltype(v)>(v).array().sinh(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/sqrt.hpp b/stan/math/prim/fun/sqrt.hpp
index 3e1620d2a61..d70307bbed4 100644
--- a/stan/math/prim/fun/sqrt.hpp
+++ b/stan/math/prim/fun/sqrt.hpp
@@ -57,8 +57,8 @@ struct sqrt_fun {
  * @return Square root of each value in x.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto sqrt(const Container& x) {
-  return apply_scalar_unary<sqrt_fun, Container>::apply(x);
+inline auto sqrt(Container&& x) {
+  return apply_scalar_unary<sqrt_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
 }
 
 /**
@@ -72,9 +72,10 @@ inline auto sqrt(const Container& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr,
           require_not_var_matrix_t<Container>* = nullptr>
-inline auto sqrt(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().sqrt(); });
+inline auto sqrt(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) { return std::forward<decltype(v)>(v).array().sqrt(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/square.hpp b/stan/math/prim/fun/square.hpp
index cb14bd77c8b..7462934ef65 100644
--- a/stan/math/prim/fun/square.hpp
+++ b/stan/math/prim/fun/square.hpp
@@ -50,8 +50,8 @@ struct square_fun {
  * @return Each value in x squared.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto square(const Container& x) {
-  return apply_scalar_unary<square_fun, Container>::apply(x);
+inline auto square(Container&& x) {
+  return apply_scalar_unary<square_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
 }
 
 /**
@@ -64,9 +64,10 @@ inline auto square(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto square(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().square(); });
+inline auto square(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) { return std::forward<decltype(v)>(v).array().square(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/step.hpp b/stan/math/prim/fun/step.hpp
index c75d164fd2b..7398b4ba707 100644
--- a/stan/math/prim/fun/step.hpp
+++ b/stan/math/prim/fun/step.hpp
@@ -58,8 +58,8 @@ struct step_fun {
  * @return Elementwise step of members of container.
  */
 template <typename T, require_container_t<T>* = nullptr>
-inline auto step(const T& x) {
-  return apply_scalar_unary<step_fun, T>::apply(x);
+inline auto step(T&& x) {
+  return apply_scalar_unary<step_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/tan.hpp b/stan/math/prim/fun/tan.hpp
index 373672eb0c8..e11f500010b 100644
--- a/stan/math/prim/fun/tan.hpp
+++ b/stan/math/prim/fun/tan.hpp
@@ -59,8 +59,9 @@ struct tan_fun {
  * @return Tangent of each value in x.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto tan(const Container& x) {
-  return apply_scalar_unary<tan_fun, Container>::apply(x);
+inline auto tan(Container&& x) {
+  return apply_scalar_unary<tan_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
@@ -73,9 +74,12 @@ inline auto tan(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto tan(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().tan(); });
+inline auto tan(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) {
+        return std::forward<decltype(v)>(v).array().tan();
+      });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/tanh.hpp b/stan/math/prim/fun/tanh.hpp
index 1ae3faff087..3a26a16797a 100644
--- a/stan/math/prim/fun/tanh.hpp
+++ b/stan/math/prim/fun/tanh.hpp
@@ -59,8 +59,8 @@ struct tanh_fun {
  * @return Hyperbolic tangent of each value in x.
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
-inline auto tanh(const Container& x) {
-  return apply_scalar_unary<tanh_fun, Container>::apply(x);
+inline auto tanh(Container&& x) {
+  return apply_scalar_unary<tanh_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
 }
 
 /**
@@ -73,9 +73,10 @@ inline auto tanh(const Container& x) {
  */
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
-inline auto tanh(const Container& x) {
-  return apply_vector_unary<Container>::apply(
-      x, [](const auto& v) { return v.array().tanh(); });
+inline auto tanh(Container&& x) {
+  return apply_vector_unary<std::decay_t<Container>>::apply(
+      std::forward<Container>(x),
+      [](const auto& v) { return std::forward<decltype(v)>(v).array().tanh(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/tgamma.hpp b/stan/math/prim/fun/tgamma.hpp
index c038b699ab7..40d9249615e 100644
--- a/stan/math/prim/fun/tgamma.hpp
+++ b/stan/math/prim/fun/tgamma.hpp
@@ -50,8 +50,8 @@ template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
-inline auto tgamma(const T& x) {
-  return apply_scalar_unary<tgamma_fun, T>::apply(x);
+inline auto tgamma(T&& x) {
+  return apply_scalar_unary<tgamma_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/to_complex.hpp b/stan/math/prim/fun/to_complex.hpp
index ea0122595c1..f5777bfc17c 100644
--- a/stan/math/prim/fun/to_complex.hpp
+++ b/stan/math/prim/fun/to_complex.hpp
@@ -37,10 +37,13 @@ constexpr inline std::complex<stan::real_return_t<T, S>> to_complex(
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_st_stan_scalar<T1, T2>* = nullptr>
-inline auto to_complex(const T1& re, const T2& im) {
+inline auto to_complex(T1&& re, T2&& im) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return stan::math::to_complex(c, d); },
-      re, im);
+      [](auto&& c, auto&& d) {
+        return stan::math::to_complex(std::forward<decltype(c)>(c),
+                                      std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(re), std::forward<T2>(im));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/to_int.hpp b/stan/math/prim/fun/to_int.hpp
index ea286f55925..0a1d54a4efc 100644
--- a/stan/math/prim/fun/to_int.hpp
+++ b/stan/math/prim/fun/to_int.hpp
@@ -71,8 +71,8 @@ struct to_int_fun {
  */
 template <typename Container,
           require_std_vector_st<std::is_arithmetic, Container>* = nullptr>
-inline auto to_int(const Container& x) {
-  return apply_scalar_unary<to_int_fun, Container>::apply(x);
+inline auto to_int(Container&& x) {
+  return apply_scalar_unary<to_int_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/trigamma.hpp b/stan/math/prim/fun/trigamma.hpp
index 9a30daab99b..fd62dfaab91 100644
--- a/stan/math/prim/fun/trigamma.hpp
+++ b/stan/math/prim/fun/trigamma.hpp
@@ -155,8 +155,8 @@ struct trigamma_fun {
  */
 template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
-inline auto trigamma(const T& x) {
-  return apply_scalar_unary<trigamma_fun, T>::apply(x);
+inline auto trigamma(T&& x) {
+  return apply_scalar_unary<trigamma_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/trunc.hpp b/stan/math/prim/fun/trunc.hpp
index 4a5b1c1d79b..941461ea8e2 100644
--- a/stan/math/prim/fun/trunc.hpp
+++ b/stan/math/prim/fun/trunc.hpp
@@ -39,8 +39,8 @@ struct trunc_fun {
  */
 template <typename T, require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
                           T>* = nullptr>
-inline auto trunc(const T& x) {
-  return apply_scalar_unary<trunc_fun, T>::apply(x);
+inline auto trunc(T&& x) {
+  return apply_scalar_unary<trunc_fun, std::decay_t<T>>::apply(std::forward<T>(x));
 }
 
 }  // namespace math

From 81bd2d0a74cd94573e9bca928a3d66d8229f2710 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Mon, 30 Jun 2025 16:27:27 -0400
Subject: [PATCH 02/31] use perfect forwarding for functions that use apply

---
 stan/math/fwd/fun/log_softmax.hpp             |  4 +-
 stan/math/fwd/fun/log_sum_exp.hpp             |  4 +-
 stan/math/fwd/fun/norm1.hpp                   |  4 +-
 stan/math/fwd/fun/norm2.hpp                   |  4 +-
 stan/math/fwd/fun/pow.hpp                     |  4 +-
 .../constraint/cholesky_corr_constrain.hpp    | 18 +++----
 .../prim/constraint/cholesky_corr_free.hpp    |  6 +--
 .../constraint/cholesky_factor_constrain.hpp  | 18 +++----
 .../prim/constraint/cholesky_factor_free.hpp  |  6 +--
 stan/math/prim/constraint/corr_constrain.hpp  | 12 ++---
 stan/math/prim/constraint/corr_free.hpp       |  4 +-
 .../prim/constraint/corr_matrix_constrain.hpp | 30 ++++++------
 .../math/prim/constraint/corr_matrix_free.hpp |  6 +--
 .../prim/constraint/cov_matrix_constrain.hpp  | 30 ++++++------
 .../constraint/cov_matrix_constrain_lkj.hpp   | 20 ++++----
 stan/math/prim/constraint/cov_matrix_free.hpp | 10 ++--
 .../prim/constraint/cov_matrix_free_lkj.hpp   |  6 +--
 .../prim/constraint/identity_constrain.hpp    |  2 +-
 stan/math/prim/constraint/identity_free.hpp   |  2 +-
 stan/math/prim/constraint/lb_constrain.hpp    |  2 +-
 stan/math/prim/constraint/lb_free.hpp         |  2 +-
 stan/math/prim/constraint/lub_free.hpp        |  6 +--
 .../offset_multiplier_constrain.hpp           |  6 +--
 .../constraint/offset_multiplier_free.hpp     | 39 +++++++--------
 .../prim/constraint/ordered_constrain.hpp     | 24 ++++-----
 stan/math/prim/constraint/ordered_free.hpp    |  6 +--
 .../prim/constraint/positive_constrain.hpp    | 20 ++++----
 stan/math/prim/constraint/positive_free.hpp   |  4 +-
 .../constraint/positive_ordered_constrain.hpp | 25 +++++-----
 .../prim/constraint/positive_ordered_free.hpp |  6 +--
 stan/math/prim/constraint/prob_constrain.hpp  | 20 ++++----
 stan/math/prim/constraint/prob_free.hpp       |  4 +-
 .../prim/constraint/simplex_constrain.hpp     | 18 +++----
 stan/math/prim/constraint/simplex_free.hpp    |  6 +--
 .../stochastic_column_constrain.hpp           | 22 ++++-----
 .../constraint/stochastic_column_free.hpp     | 10 ++--
 .../constraint/stochastic_row_constrain.hpp   | 26 +++++-----
 .../prim/constraint/stochastic_row_free.hpp   | 10 ++--
 .../prim/constraint/sum_to_zero_constrain.hpp | 22 ++++-----
 .../math/prim/constraint/sum_to_zero_free.hpp |  6 +--
 stan/math/prim/constraint/ub_constrain.hpp    | 22 ++++-----
 .../prim/constraint/unit_vector_constrain.hpp | 18 +++----
 .../math/prim/constraint/unit_vector_free.hpp |  6 +--
 stan/math/prim/fun/abs.hpp                    |  2 +-
 stan/math/prim/fun/acos.hpp                   |  2 +-
 stan/math/prim/fun/asin.hpp                   |  2 +-
 stan/math/prim/fun/atan.hpp                   |  2 +-
 stan/math/prim/fun/ceil.hpp                   |  2 +-
 stan/math/prim/fun/cos.hpp                    |  2 +-
 stan/math/prim/fun/cosh.hpp                   |  2 +-
 stan/math/prim/fun/exp.hpp                    |  2 +-
 stan/math/prim/fun/fabs.hpp                   |  2 +-
 stan/math/prim/fun/floor.hpp                  |  2 +-
 stan/math/prim/fun/inv.hpp                    |  2 +-
 stan/math/prim/fun/inv_cloglog.hpp            |  2 +-
 stan/math/prim/fun/inv_logit.hpp              |  2 +-
 stan/math/prim/fun/inv_sqrt.hpp               |  2 +-
 stan/math/prim/fun/inv_square.hpp             |  2 +-
 stan/math/prim/fun/log.hpp                    |  2 +-
 stan/math/prim/fun/log10.hpp                  |  2 +-
 stan/math/prim/fun/log1m_inv_logit.hpp        |  7 ++-
 stan/math/prim/fun/max.hpp                    |  6 +--
 stan/math/prim/fun/mean.hpp                   |  4 +-
 stan/math/prim/fun/min.hpp                    |  6 +--
 stan/math/prim/fun/minus.hpp                  | 19 ++++---
 stan/math/prim/fun/pow.hpp                    |  2 +-
 stan/math/prim/fun/rank.hpp                   |  7 ++-
 stan/math/prim/fun/round.hpp                  |  2 +-
 stan/math/prim/fun/select.hpp                 | 12 ++---
 stan/math/prim/fun/sin.hpp                    |  2 +-
 stan/math/prim/fun/sinh.hpp                   |  2 +-
 stan/math/prim/fun/sqrt.hpp                   |  2 +-
 stan/math/prim/fun/square.hpp                 |  2 +-
 stan/math/prim/fun/tan.hpp                    |  2 +-
 stan/math/prim/fun/tanh.hpp                   |  2 +-
 .../math/prim/functor/apply_scalar_binary.hpp |  4 +-
 .../prim/functor/apply_scalar_ternary.hpp     | 21 ++++----
 stan/math/prim/functor/apply_scalar_unary.hpp | 20 +++++---
 stan/math/prim/functor/apply_vector_unary.hpp | 49 ++++++++++++-------
 stan/math/prim/prob/std_normal_log_qf.hpp     |  4 +-
 stan/math/rev/fun/floor.hpp                   |  2 +-
 stan/math/rev/fun/log_softmax.hpp             |  6 +--
 stan/math/rev/fun/log_sum_exp.hpp             |  6 +--
 stan/math/rev/fun/pow.hpp                     |  4 +-
 stan/math/rev/fun/sd.hpp                      |  4 +-
 stan/math/rev/functor/apply_scalar_unary.hpp  |  3 +-
 stan/math/rev/functor/apply_vector_unary.hpp  | 18 +++----
 87 files changed, 396 insertions(+), 376 deletions(-)

diff --git a/stan/math/fwd/fun/log_softmax.hpp b/stan/math/fwd/fun/log_softmax.hpp
index 82d1f7b0204..48e7be01f82 100644
--- a/stan/math/fwd/fun/log_softmax.hpp
+++ b/stan/math/fwd/fun/log_softmax.hpp
@@ -19,8 +19,8 @@ namespace math {
  * @throw std::domain_error If the input vector is size 0.
  */
 template <typename T, require_vector_st<is_fvar, T>* = nullptr>
-inline auto log_softmax(const T& x) {
-  return apply_vector_unary<T>::apply(x, [&](const auto& alpha) {
+inline auto log_softmax(T&& x) {
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [&](const auto& alpha) {
     using T_alpha = decltype(alpha);
     using T_fvar = value_type_t<T_alpha>;
     using T_fvar_inner = typename T_fvar::Scalar;
diff --git a/stan/math/fwd/fun/log_sum_exp.hpp b/stan/math/fwd/fun/log_sum_exp.hpp
index 30795b8f99b..cf61b472cc8 100644
--- a/stan/math/fwd/fun/log_sum_exp.hpp
+++ b/stan/math/fwd/fun/log_sum_exp.hpp
@@ -50,9 +50,9 @@ inline fvar<T> log_sum_exp(const fvar<T>& x1, double x2) {
  * @return The log of the sum of the exponentiated vector values.
  */
 template <typename T, require_container_st<is_fvar, T>* = nullptr>
-inline auto log_sum_exp(const T& x) {
+inline auto log_sum_exp(T&& x) {
   return apply_vector_unary<ref_type_t<T>>::reduce(
-      to_ref(x), [&](const auto& v) {
+      to_ref(std::forward<T>(x)), [&](const auto& v) {
         using T_fvar_inner = typename value_type_t<decltype(v)>::Scalar;
         using mat_type = Eigen::Matrix<T_fvar_inner, -1, -1>;
         mat_type vals = v.val();
diff --git a/stan/math/fwd/fun/norm1.hpp b/stan/math/fwd/fun/norm1.hpp
index 151216f2f12..a4026988dee 100644
--- a/stan/math/fwd/fun/norm1.hpp
+++ b/stan/math/fwd/fun/norm1.hpp
@@ -20,9 +20,9 @@ namespace math {
  * @return L1 norm of x.
  */
 template <typename Container, require_eigen_vt<is_fvar, Container>* = nullptr>
-inline auto norm1(const Container& x) {
+inline auto norm1(Container&& x) {
   return apply_vector_unary<ref_type_t<Container>>::reduce(
-      to_ref(x), [&](const auto& v) {
+      to_ref(std::forward<Container>(x)), [&](const auto& v) {
         using T_fvar_inner = typename value_type_t<decltype(v)>::Scalar;
         return fvar<T_fvar_inner>(norm1(v.val()),
                                   v.d().cwiseProduct(sign(v.val())).sum());
diff --git a/stan/math/fwd/fun/norm2.hpp b/stan/math/fwd/fun/norm2.hpp
index 3ba8200363a..61129a3709b 100644
--- a/stan/math/fwd/fun/norm2.hpp
+++ b/stan/math/fwd/fun/norm2.hpp
@@ -19,9 +19,9 @@ namespace math {
  * @return L2 norm of x.
  */
 template <typename Container, require_eigen_vt<is_fvar, Container>* = nullptr>
-inline auto norm2(const Container& x) {
+inline auto norm2(Container&& x) {
   return apply_vector_unary<ref_type_t<Container>>::reduce(
-      to_ref(x), [&](const auto& v) {
+      to_ref(std::forward<Container>(x)), [&](const auto& v) {
         using T_fvar_inner = typename value_type_t<decltype(v)>::Scalar;
         T_fvar_inner res = norm2(v.val());
         return fvar<T_fvar_inner>(res,
diff --git a/stan/math/fwd/fun/pow.hpp b/stan/math/fwd/fun/pow.hpp
index 1a23514727a..2a29557dad5 100644
--- a/stan/math/fwd/fun/pow.hpp
+++ b/stan/math/fwd/fun/pow.hpp
@@ -73,9 +73,9 @@ inline auto pow(const T1& x1, const T2& x2) {
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_not_matrix_st<is_var, T1, T2>* = nullptr,
           require_any_fvar_t<base_type_t<T1>, base_type_t<T2>>* = nullptr>
-inline auto pow(const T1& a, const T2& b) {
+inline auto pow(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return stan::math::pow(c, d); }, a, b);
+      [](auto&& c, auto&& d) { return stan::math::pow(std::forward<decltype(c)>(c), std::forward<decltype(d)>(d)); }, std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/cholesky_corr_constrain.hpp b/stan/math/prim/constraint/cholesky_corr_constrain.hpp
index 3a55e04b3f2..7e868080ebd 100644
--- a/stan/math/prim/constraint/cholesky_corr_constrain.hpp
+++ b/stan/math/prim/constraint/cholesky_corr_constrain.hpp
@@ -87,9 +87,9 @@ cholesky_corr_constrain(const EigVec& y, int K, Lp& lp) {
  * @param K The size of the matrix to return
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto cholesky_corr_constrain(const T& y, int K) {
-  return apply_vector_unary<T>::apply(
-      y, [K](auto&& v) { return cholesky_corr_constrain(v, K); });
+inline auto cholesky_corr_constrain(T&& y, int K) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(y), [K](auto&& v) { return cholesky_corr_constrain(std::forward<decltype(v)>(v), K); });
 }
 
 /**
@@ -107,9 +107,9 @@ inline auto cholesky_corr_constrain(const T& y, int K) {
  */
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto cholesky_corr_constrain(const T& y, int K, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      y, [&lp, K](auto&& v) { return cholesky_corr_constrain(v, K, lp); });
+inline auto cholesky_corr_constrain(T&& y, int K, Lp& lp) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(y), [&lp, K](auto&& v) { return cholesky_corr_constrain(std::forward<decltype(v)>(v), K, lp); });
 }
 
 /**
@@ -132,11 +132,11 @@ inline auto cholesky_corr_constrain(const T& y, int K, Lp& lp) {
  */
 template <bool Jacobian, typename T, typename Lp,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto cholesky_corr_constrain(const T& y, int K, Lp& lp) {
+inline auto cholesky_corr_constrain(T&& y, int K, Lp& lp) {
   if constexpr (Jacobian) {
-    return cholesky_corr_constrain(y, K, lp);
+    return cholesky_corr_constrain(std::forward<T>(y), K, lp);
   } else {
-    return cholesky_corr_constrain(y, K);
+    return cholesky_corr_constrain(std::forward<T>(y), K);
   }
 }
 
diff --git a/stan/math/prim/constraint/cholesky_corr_free.hpp b/stan/math/prim/constraint/cholesky_corr_free.hpp
index b359f677313..40fde2cd559 100644
--- a/stan/math/prim/constraint/cholesky_corr_free.hpp
+++ b/stan/math/prim/constraint/cholesky_corr_free.hpp
@@ -42,9 +42,9 @@ inline auto cholesky_corr_free(const T& x) {
  * @param x The standard vector to untransform.
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto cholesky_corr_free(const T& x) {
-  return apply_vector_unary<T>::apply(
-      x, [](auto&& v) { return cholesky_corr_free(v); });
+inline auto cholesky_corr_free(T&& x) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [](auto&& v) { return cholesky_corr_free(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/cholesky_factor_constrain.hpp b/stan/math/prim/constraint/cholesky_factor_constrain.hpp
index 61356d2a897..1ec88c90c25 100644
--- a/stan/math/prim/constraint/cholesky_factor_constrain.hpp
+++ b/stan/math/prim/constraint/cholesky_factor_constrain.hpp
@@ -101,9 +101,9 @@ cholesky_factor_constrain(const T& x, int M, int N, Lp& lp) {
  * @return Cholesky factor
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto cholesky_factor_constrain(const T& x, int M, int N) {
-  return apply_vector_unary<T>::apply(
-      x, [M, N](auto&& v) { return cholesky_factor_constrain(v, M, N); });
+inline auto cholesky_factor_constrain(T&& x, int M, int N) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [M, N](auto&& v) { return cholesky_factor_constrain(std::forward<decltype(v)>(v), M, N); });
 }
 
 /**
@@ -125,9 +125,9 @@ inline auto cholesky_factor_constrain(const T& x, int M, int N) {
  */
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto cholesky_factor_constrain(const T& x, int M, int N, Lp& lp) {
-  return apply_vector_unary<T>::apply(x, [&lp, M, N](auto&& v) {
-    return cholesky_factor_constrain(v, M, N, lp);
+inline auto cholesky_factor_constrain(T&& x, int M, int N, Lp& lp) {
+  return apply_vector_unary<std::decay_t<T>>::apply(std::forward<T>(x), [&lp, M, N](auto&& v) {
+    return cholesky_factor_constrain(std::forward<decltype(v)>(v), M, N, lp);
   });
 }
 
@@ -155,11 +155,11 @@ inline auto cholesky_factor_constrain(const T& x, int M, int N, Lp& lp) {
  */
 template <bool Jacobian, typename T, typename Lp,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto cholesky_factor_constrain(const T& x, int M, int N, Lp& lp) {
+inline auto cholesky_factor_constrain(T&& x, int M, int N, Lp& lp) {
   if constexpr (Jacobian) {
-    return cholesky_factor_constrain(x, M, N, lp);
+    return cholesky_factor_constrain(std::forward<T>(x), M, N, lp);
   } else {
-    return cholesky_factor_constrain(x, M, N);
+    return cholesky_factor_constrain(std::forward<T>(x), M, N);
   }
 }
 
diff --git a/stan/math/prim/constraint/cholesky_factor_free.hpp b/stan/math/prim/constraint/cholesky_factor_free.hpp
index e3be04e2589..b4827a8131a 100644
--- a/stan/math/prim/constraint/cholesky_factor_free.hpp
+++ b/stan/math/prim/constraint/cholesky_factor_free.hpp
@@ -56,9 +56,9 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cholesky_factor_free(
  * @param x The standard vector to untransform.
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto cholesky_factor_free(const T& x) {
-  return apply_vector_unary<T>::apply(
-      x, [](auto&& v) { return cholesky_factor_free(v); });
+inline auto cholesky_factor_free(T&& x) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [](auto&& v) { return cholesky_factor_free(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/corr_constrain.hpp b/stan/math/prim/constraint/corr_constrain.hpp
index 8366132f9f9..f19f2ea8669 100644
--- a/stan/math/prim/constraint/corr_constrain.hpp
+++ b/stan/math/prim/constraint/corr_constrain.hpp
@@ -24,8 +24,8 @@ namespace math {
  * @return tanh transform
  */
 template <typename T>
-inline plain_type_t<T> corr_constrain(const T& x) {
-  return tanh(x);
+inline plain_type_t<T> corr_constrain(T&& x) {
+  return tanh(std::forward<T>(x));
 }
 
 /**
@@ -43,7 +43,7 @@ inline plain_type_t<T> corr_constrain(const T& x) {
  * @param[in,out] lp log density accumulator
  */
 template <typename T_x, typename T_lp>
-inline auto corr_constrain(const T_x& x, T_lp& lp) {
+inline auto corr_constrain(T_x&& x, T_lp& lp) {
   plain_type_t<T_x> tanh_x = tanh(x);
   lp += sum(log1m(square(tanh_x)));
   return tanh_x;
@@ -65,11 +65,11 @@ inline auto corr_constrain(const T_x& x, T_lp& lp) {
  * @param[in,out] lp log density accumulator
  */
 template <bool Jacobian, typename T_x, typename T_lp>
-inline auto corr_constrain(const T_x& x, T_lp& lp) {
+inline auto corr_constrain(T_x&& x, T_lp& lp) {
   if constexpr (Jacobian) {
-    return corr_constrain(x, lp);
+    return corr_constrain(std::forward<T_x>(x), lp);
   } else {
-    return corr_constrain(x);
+    return corr_constrain(std::forward<T_x>(x));
   }
 }
 
diff --git a/stan/math/prim/constraint/corr_free.hpp b/stan/math/prim/constraint/corr_free.hpp
index 3714b26f4f1..5e0b542c758 100644
--- a/stan/math/prim/constraint/corr_free.hpp
+++ b/stan/math/prim/constraint/corr_free.hpp
@@ -25,9 +25,9 @@ namespace math {
  * @return free scalar that transforms to the specified input
  */
 template <typename T>
-inline plain_type_t<T> corr_free(const T& y) {
+inline plain_type_t<T> corr_free(T&& y) {
   check_bounded("lub_free", "Correlation variable", y, -1.0, 1.0);
-  return atanh(y);
+  return atanh(std::forward<T>(y));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/corr_matrix_constrain.hpp b/stan/math/prim/constraint/corr_matrix_constrain.hpp
index 060b1d5f6a3..4c44f60b2cd 100644
--- a/stan/math/prim/constraint/corr_matrix_constrain.hpp
+++ b/stan/math/prim/constraint/corr_matrix_constrain.hpp
@@ -38,11 +38,11 @@ namespace math {
  */
 template <typename T, require_eigen_col_vector_t<T>* = nullptr>
 inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic>
-corr_matrix_constrain(const T& x, Eigen::Index k) {
-  Eigen::Index k_choose_2 = (k * (k - 1)) / 2;
+corr_matrix_constrain(T&& x, Eigen::Index k) {
+  const Eigen::Index k_choose_2 = (k * (k - 1)) / 2;
   check_size_match("cov_matrix_constrain", "x.size()", x.size(), "k_choose_2",
                    k_choose_2);
-  return read_corr_matrix(corr_constrain(x), k);
+  return read_corr_matrix(corr_constrain(std::forward<T>(x)), k);
 }
 
 /**
@@ -70,11 +70,11 @@ corr_matrix_constrain(const T& x, Eigen::Index k) {
 template <typename T, typename Lp, require_eigen_col_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic>
-corr_matrix_constrain(const T& x, Eigen::Index k, Lp& lp) {
-  Eigen::Index k_choose_2 = (k * (k - 1)) / 2;
+corr_matrix_constrain(T&& x, Eigen::Index k, Lp& lp) {
+  const Eigen::Index k_choose_2 = (k * (k - 1)) / 2;
   check_size_match("cov_matrix_constrain", "x.size()", x.size(), "k_choose_2",
                    k_choose_2);
-  return read_corr_matrix(corr_constrain(x, lp), k, lp);
+  return read_corr_matrix(corr_constrain(std::forward<T>(x), lp), k, lp);
 }
 
 /**
@@ -91,9 +91,9 @@ corr_matrix_constrain(const T& x, Eigen::Index k, Lp& lp) {
  * @param K Dimensionality of returned correlation matrix
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto corr_matrix_constrain(const T& y, int K) {
-  return apply_vector_unary<T>::apply(
-      y, [K](auto&& v) { return corr_matrix_constrain(v, K); });
+inline auto corr_matrix_constrain(T&& y, int K) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(y), [K](auto&& v) { return corr_matrix_constrain(std::forward<decltype(v)>(v), K); });
 }
 
 /**
@@ -114,9 +114,9 @@ inline auto corr_matrix_constrain(const T& y, int K) {
  */
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto corr_matrix_constrain(const T& y, int K, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      y, [&lp, K](auto&& v) { return corr_matrix_constrain(v, K, lp); });
+inline auto corr_matrix_constrain(T&& y, int K, Lp& lp) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(y), [&lp, K](auto&& v) { return corr_matrix_constrain(std::forward<decltype(v)>(v), K, lp); });
 }
 
 /**
@@ -142,11 +142,11 @@ inline auto corr_matrix_constrain(const T& y, int K, Lp& lp) {
  */
 template <bool Jacobian, typename T, typename Lp,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto corr_matrix_constrain(const T& x, Eigen::Index k, Lp& lp) {
+inline auto corr_matrix_constrain(T&& x, Eigen::Index k, Lp& lp) {
   if constexpr (Jacobian) {
-    return corr_matrix_constrain(x, k, lp);
+    return corr_matrix_constrain(std::forward<T>(x), k, lp);
   } else {
-    return corr_matrix_constrain(x, k);
+    return corr_matrix_constrain(std::forward<T>(x), k);
   }
 }
 
diff --git a/stan/math/prim/constraint/corr_matrix_free.hpp b/stan/math/prim/constraint/corr_matrix_free.hpp
index 7ddb1230e62..76f46f11c7e 100644
--- a/stan/math/prim/constraint/corr_matrix_free.hpp
+++ b/stan/math/prim/constraint/corr_matrix_free.hpp
@@ -60,9 +60,9 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> corr_matrix_free(const T& y) {
  * @param x The standard vector to untransform.
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto corr_matrix_free(const T& x) {
-  return apply_vector_unary<T>::apply(
-      x, [](auto&& v) { return corr_matrix_free(v); });
+inline auto corr_matrix_free(T&& x) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [](auto&& v) { return corr_matrix_free(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/cov_matrix_constrain.hpp b/stan/math/prim/constraint/cov_matrix_constrain.hpp
index 3f2c67b3741..26bc919e29f 100644
--- a/stan/math/prim/constraint/cov_matrix_constrain.hpp
+++ b/stan/math/prim/constraint/cov_matrix_constrain.hpp
@@ -29,7 +29,7 @@ namespace math {
  */
 template <typename T, require_eigen_col_vector_t<T>* = nullptr>
 inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic>
-cov_matrix_constrain(const T& x, Eigen::Index K) {
+cov_matrix_constrain(T&& x, Eigen::Index K) {
   using Eigen::Dynamic;
   using Eigen::Matrix;
   using std::exp;
@@ -37,7 +37,7 @@ cov_matrix_constrain(const T& x, Eigen::Index K) {
   Matrix<value_type_t<T>, Dynamic, Dynamic> L(K, K);
   check_size_match("cov_matrix_constrain", "x.size()", x.size(),
                    "K + (K choose 2)", (K * (K + 1)) / 2);
-  const auto& x_ref = to_ref(x);
+  auto&& x_ref = to_ref(std::forward<T>(x));
   int i = 0;
   for (Eigen::Index m = 0; m < K; ++m) {
     L.row(m).head(m) = x_ref.segment(i, m);
@@ -45,7 +45,7 @@ cov_matrix_constrain(const T& x, Eigen::Index K) {
     L.coeffRef(m, m) = exp(x_ref.coeff(i++));
     L.row(m).tail(K - m - 1).setZero();
   }
-  return multiply_lower_tri_self_transpose(L);
+  return multiply_lower_tri_self_transpose(std::move(L));
 }
 
 /**
@@ -65,7 +65,7 @@ cov_matrix_constrain(const T& x, Eigen::Index K) {
 template <typename T, typename Lp, require_eigen_col_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic>
-cov_matrix_constrain(const T& x, Eigen::Index K, Lp& lp) {
+cov_matrix_constrain(T&& x, Eigen::Index K, Lp& lp) {
   using Eigen::Dynamic;
   using Eigen::Matrix;
   using std::exp;
@@ -73,7 +73,7 @@ cov_matrix_constrain(const T& x, Eigen::Index K, Lp& lp) {
   check_size_match("cov_matrix_constrain", "x.size()", x.size(),
                    "K + (K choose 2)", (K * (K + 1)) / 2);
   Matrix<value_type_t<T>, Dynamic, Dynamic> L(K, K);
-  const auto& x_ref = to_ref(x);
+  auto&& x_ref = to_ref(std::forward<T>(x));
   int i = 0;
   for (Eigen::Index m = 0; m < K; ++m) {
     L.row(m).head(m) = x_ref.segment(i, m);
@@ -86,7 +86,7 @@ cov_matrix_constrain(const T& x, Eigen::Index K, Lp& lp) {
   for (Eigen::Index k = 0; k < K; ++k) {
     lp += (K - k + 1) * log(L.coeff(k, k));  // only +1 because index from 0
   }
-  return multiply_lower_tri_self_transpose(L);
+  return multiply_lower_tri_self_transpose(std::move(L));
 }
 
 /**
@@ -102,9 +102,9 @@ cov_matrix_constrain(const T& x, Eigen::Index K, Lp& lp) {
  * @throws std::domain_error if (x.size() != K + (K choose 2)).
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto cov_matrix_constrain(const T& x, Eigen::Index K) {
-  return apply_vector_unary<T>::apply(
-      x, [K](auto&& v) { return cov_matrix_constrain(v, K); });
+inline auto cov_matrix_constrain(T&& x, Eigen::Index K) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [K](auto&& v) { return cov_matrix_constrain(std::forward<decltype(v)>(v), K); });
 }
 
 /**
@@ -124,9 +124,9 @@ inline auto cov_matrix_constrain(const T& x, Eigen::Index K) {
  */
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto cov_matrix_constrain(const T& x, Eigen::Index K, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      x, [&lp, K](auto&& v) { return cov_matrix_constrain(v, K, lp); });
+inline auto cov_matrix_constrain(T&& x, Eigen::Index K, Lp& lp) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [&lp, K](auto&& v) { return cov_matrix_constrain(std::forward<decltype(v)>(v), K, lp); });
 }
 
 /**
@@ -151,11 +151,11 @@ inline auto cov_matrix_constrain(const T& x, Eigen::Index K, Lp& lp) {
  */
 template <bool Jacobian, typename T, typename Lp,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto cov_matrix_constrain(const T& x, Eigen::Index K, Lp& lp) {
+inline auto cov_matrix_constrain(T&& x, Eigen::Index K, Lp& lp) {
   if constexpr (Jacobian) {
-    return cov_matrix_constrain(x, K, lp);
+    return cov_matrix_constrain(std::forward<T>(x), K, lp);
   } else {
-    return cov_matrix_constrain(x, K);
+    return cov_matrix_constrain(std::forward<T>(x), K);
   }
 }
 
diff --git a/stan/math/prim/constraint/cov_matrix_constrain_lkj.hpp b/stan/math/prim/constraint/cov_matrix_constrain_lkj.hpp
index 7f30b7c11c0..825a98ddc3c 100644
--- a/stan/math/prim/constraint/cov_matrix_constrain_lkj.hpp
+++ b/stan/math/prim/constraint/cov_matrix_constrain_lkj.hpp
@@ -32,9 +32,9 @@ namespace math {
  */
 template <typename T, require_eigen_vector_t<T>* = nullptr>
 inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic>
-cov_matrix_constrain_lkj(const T& x, size_t k) {
+cov_matrix_constrain_lkj(T&& x, size_t k) {
   size_t k_choose_2 = (k * (k - 1)) / 2;
-  const auto& x_ref = to_ref(x);
+  auto&& x_ref = to_ref(std::forward<T>(x));
   return read_cov_matrix(corr_constrain(x_ref.head(k_choose_2)),
                          positive_constrain(x_ref.tail(k)));
 }
@@ -56,9 +56,9 @@ cov_matrix_constrain_lkj(const T& x, size_t k) {
  */
 template <typename T, require_eigen_vector_t<T>* = nullptr>
 inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic>
-cov_matrix_constrain_lkj(const T& x, size_t k, return_type_t<T>& lp) {
+cov_matrix_constrain_lkj(T&& x, size_t k, return_type_t<T>& lp) {
   size_t k_choose_2 = (k * (k - 1)) / 2;
-  const auto& x_ref = x;
+  auto&& x_ref = to_ref(std::forward<T>(x));
   return read_cov_matrix(corr_constrain(x_ref.head(k_choose_2)),
                          positive_constrain(x_ref.tail(k)), lp);
 }
@@ -84,12 +84,12 @@ cov_matrix_constrain_lkj(const T& x, size_t k, return_type_t<T>& lp) {
  * correlations and deviations.
  */
 template <bool Jacobian, typename T, require_not_std_vector_t<T>* = nullptr>
-inline auto cov_matrix_constrain_lkj(const T& x, size_t k,
+inline auto cov_matrix_constrain_lkj(T&& x, size_t k,
                                      return_type_t<T>& lp) {
   if constexpr (Jacobian) {
-    return cov_matrix_constrain_lkj(x, k, lp);
+    return cov_matrix_constrain_lkj(std::forward<T>(x), k, lp);
   } else {
-    return cov_matrix_constrain_lkj(x, k);
+    return cov_matrix_constrain_lkj(std::forward<T>(x), k);
   }
 }
 
@@ -114,10 +114,10 @@ inline auto cov_matrix_constrain_lkj(const T& x, size_t k,
  * correlations and deviations.
  */
 template <bool Jacobian, typename T, require_std_vector_t<T>* = nullptr>
-inline auto cov_matrix_constrain_lkj(const T& x, size_t k,
+inline auto cov_matrix_constrain_lkj(T&& x, size_t k,
                                      return_type_t<T>& lp) {
-  return apply_vector_unary<T>::apply(x, [&lp, k](auto&& v) {
-    return cov_matrix_constrain_lkj<Jacobian>(v, k, lp);
+  return apply_vector_unary<std::decay_t<T>>::apply(std::forward<T>(x), [&lp, k](auto&& v) {
+    return cov_matrix_constrain_lkj<Jacobian>(std::forward<decltype(v)>(v), k, lp);
   });
 }
 
diff --git a/stan/math/prim/constraint/cov_matrix_free.hpp b/stan/math/prim/constraint/cov_matrix_free.hpp
index 4fcff40b647..04c5f388bec 100644
--- a/stan/math/prim/constraint/cov_matrix_free.hpp
+++ b/stan/math/prim/constraint/cov_matrix_free.hpp
@@ -35,8 +35,8 @@ namespace math {
  * has zero dimensionality, or has a non-positive diagonal element.
  */
 template <typename T, require_eigen_t<T>* = nullptr>
-Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cov_matrix_free(const T& y) {
-  const auto& y_ref = to_ref(y);
+Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cov_matrix_free(T&& y) {
+  auto&& y_ref = to_ref(std::forward<T>(y));
   check_square("cov_matrix_free", "y", y_ref);
   check_nonzero_size("cov_matrix_free", "y", y_ref);
 
@@ -66,9 +66,9 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cov_matrix_free(const T& y) {
  * @param x The standard vector to untransform.
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto cov_matrix_free(const T& x) {
-  return apply_vector_unary<T>::apply(
-      x, [](auto&& v) { return cov_matrix_free(v); });
+inline auto cov_matrix_free(T&& x) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [](auto&& v) { return cov_matrix_free(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/cov_matrix_free_lkj.hpp b/stan/math/prim/constraint/cov_matrix_free_lkj.hpp
index b0d6c94f7a8..f77e05bf1c8 100644
--- a/stan/math/prim/constraint/cov_matrix_free_lkj.hpp
+++ b/stan/math/prim/constraint/cov_matrix_free_lkj.hpp
@@ -57,9 +57,9 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cov_matrix_free_lkj(
  * @param x The standard vector to untransform.
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-auto cov_matrix_free_lkj(const T& x) {
-  return apply_vector_unary<T>::apply(
-      x, [](auto&& v) { return cov_matrix_free_lkj(v); });
+auto cov_matrix_free_lkj(T&& x) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [](auto&& v) { return cov_matrix_free_lkj(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/identity_constrain.hpp b/stan/math/prim/constraint/identity_constrain.hpp
index 00590438700..4d5ae105b4d 100644
--- a/stan/math/prim/constraint/identity_constrain.hpp
+++ b/stan/math/prim/constraint/identity_constrain.hpp
@@ -21,7 +21,7 @@ namespace math {
 template <bool Jacobian = false, typename T, typename... Types,
           require_all_not_var_matrix_t<T, Types...>* = nullptr>
 inline auto identity_constrain(T&& x, Types&&... /* args */) {
-  return promote_scalar_t<return_type_t<T, Types...>, T>(x);
+  return promote_scalar_t<return_type_t<T, Types...>, T>(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/identity_free.hpp b/stan/math/prim/constraint/identity_free.hpp
index ef5925c2355..2686d8fae5c 100644
--- a/stan/math/prim/constraint/identity_free.hpp
+++ b/stan/math/prim/constraint/identity_free.hpp
@@ -20,7 +20,7 @@ namespace math {
 template <typename T, typename... Types,
           require_all_not_var_matrix_t<T, Types...>* = nullptr>
 inline auto identity_free(T&& x, Types&&... /* args */) {
-  return promote_scalar_t<return_type_t<T, Types...>, T>(x);
+  return promote_scalar_t<return_type_t<T, Types...>, T>(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/lb_constrain.hpp b/stan/math/prim/constraint/lb_constrain.hpp
index 8f09c7733aa..f77c4056033 100644
--- a/stan/math/prim/constraint/lb_constrain.hpp
+++ b/stan/math/prim/constraint/lb_constrain.hpp
@@ -34,7 +34,7 @@ namespace math {
  */
 template <typename T, typename L, require_all_stan_scalar_t<T, L>* = nullptr,
           require_all_not_st_var<T, L>* = nullptr>
-inline auto lb_constrain(const T& x, const L& lb) {
+inline auto lb_constrain(T&& x, const L& lb) {
   if (unlikely(value_of_rec(lb) == NEGATIVE_INFTY)) {
     return identity_constrain(x, lb);
   } else {
diff --git a/stan/math/prim/constraint/lb_free.hpp b/stan/math/prim/constraint/lb_free.hpp
index f5e80d700e6..5542be2505c 100644
--- a/stan/math/prim/constraint/lb_free.hpp
+++ b/stan/math/prim/constraint/lb_free.hpp
@@ -29,7 +29,7 @@ template <typename T, typename L, require_not_std_vector_t<T>* = nullptr,
           require_stan_scalar_t<L>* = nullptr>
 inline auto lb_free(T&& y, L&& lb) {
   if (value_of_rec(lb) == NEGATIVE_INFTY) {
-    return identity_free(y, lb);
+    return identity_free(std::forward<T>(y), lb);
   } else {
     auto&& y_ref = to_ref(std::forward<T>(y));
     auto&& lb_ref = to_ref(std::forward<L>(lb));
diff --git a/stan/math/prim/constraint/lub_free.hpp b/stan/math/prim/constraint/lub_free.hpp
index 15cb46beb7e..15323e1eac2 100644
--- a/stan/math/prim/constraint/lub_free.hpp
+++ b/stan/math/prim/constraint/lub_free.hpp
@@ -47,11 +47,11 @@ inline auto lub_free(T&& y, L&& lb, U&& ub) {
   const bool is_lb_inf = value_of(lb) == NEGATIVE_INFTY;
   const bool is_ub_inf = value_of(ub) == INFTY;
   if (unlikely(is_ub_inf && is_lb_inf)) {
-    return identity_free(y, lb, ub);
+    return identity_free(std::forward<T>(y), lb, ub);
   } else if (unlikely(is_ub_inf)) {
-    return lb_free(identity_free(y, ub), lb);
+    return lb_free(identity_free(std::forward<T>(y), ub), lb);
   } else if (unlikely(is_lb_inf)) {
-    return ub_free(identity_free(y, lb), ub);
+    return ub_free(identity_free(std::forward<T>(y), lb), ub);
   } else {
     auto&& y_ref = to_ref(std::forward<T>(y));
     check_bounded("lub_free", "Bounded variable", value_of(y_ref), value_of(lb),
diff --git a/stan/math/prim/constraint/offset_multiplier_constrain.hpp b/stan/math/prim/constraint/offset_multiplier_constrain.hpp
index 186c8f38988..ca781b76e25 100644
--- a/stan/math/prim/constraint/offset_multiplier_constrain.hpp
+++ b/stan/math/prim/constraint/offset_multiplier_constrain.hpp
@@ -303,12 +303,12 @@ inline auto offset_multiplier_constrain(const std::vector<T>& x,
  */
 template <bool Jacobian, typename T, typename M, typename S, typename Lp,
           require_convertible_t<return_type_t<T, M, S>, Lp>* = nullptr>
-inline auto offset_multiplier_constrain(const T& x, const M& mu, const S& sigma,
+inline auto offset_multiplier_constrain(T&& x, M&& mu, S&& sigma,
                                         Lp& lp) {
   if constexpr (Jacobian) {
-    return offset_multiplier_constrain(x, mu, sigma, lp);
+    return offset_multiplier_constrain(std::forward<T>(x), std::forward<M>(mu), std::forward<S>(sigma), lp);
   } else {
-    return offset_multiplier_constrain(x, mu, sigma);
+    return offset_multiplier_constrain(std::forward<T>(x), std::forward<M>(mu), std::forward<S>(sigma));
   }
 }
 
diff --git a/stan/math/prim/constraint/offset_multiplier_free.hpp b/stan/math/prim/constraint/offset_multiplier_free.hpp
index 372d5095d23..f4cb5153330 100644
--- a/stan/math/prim/constraint/offset_multiplier_free.hpp
+++ b/stan/math/prim/constraint/offset_multiplier_free.hpp
@@ -39,10 +39,11 @@ namespace math {
  * @throw std::domain_error if mu is not finite
  * @throw std::invalid_argument if non-scalar arguments don't match in size
  */
-template <typename T, typename M, typename S>
-inline auto offset_multiplier_free(const T& y, const M& mu, const S& sigma) {
-  auto&& mu_ref = to_ref(mu);
-  auto&& sigma_ref = to_ref(sigma);
+template <typename T, typename M, typename S, require_all_not_std_vector_t<T, M, S>* = nullptr,
+          require_all_not_st_var<T, M, S>* = nullptr>
+inline auto offset_multiplier_free(T&& y, M&& mu, S&& sigma) {
+  auto&& mu_ref = to_ref(std::forward<M>(mu));
+  auto&& sigma_ref = to_ref(std::forward<S>(sigma));
   if (is_matrix<T>::value && is_matrix<M>::value) {
     check_matching_dims("offset_multiplier_constrain", "y", y, "mu", mu);
   }
@@ -56,21 +57,21 @@ inline auto offset_multiplier_free(const T& y, const M& mu, const S& sigma) {
   check_finite("offset_multiplier_constrain", "offset", value_of(mu_ref));
   check_positive_finite("offset_multiplier_constrain", "multiplier",
                         value_of(sigma_ref));
-  return stan::math::eval(divide(subtract(y, mu_ref), sigma_ref));
+  return stan::math::eval(divide(subtract(std::forward<T>(y), std::forward<M>(mu_ref)), std::forward<S>(sigma_ref)));
 }
 
 /**
  * Overload for array of x and non-array mu and sigma
  */
-template <typename T, typename M, typename S,
+template <typename T, typename M, typename S, require_std_vector_t<T>* = nullptr,
           require_all_not_std_vector_t<M, S>* = nullptr>
-inline auto offset_multiplier_free(const std::vector<T>& x, const M& mu,
-                                   const S& sigma) {
+inline auto offset_multiplier_free(T&& x, M&& mu,
+                                   S&& sigma) {
   std::vector<plain_type_t<decltype(offset_multiplier_free(x[0], mu, sigma))>>
       ret;
   ret.reserve(x.size());
-  const auto& mu_ref = to_ref(mu);
-  const auto& sigma_ref = to_ref(sigma);
+  auto&& mu_ref = to_ref(std::forward<M>(mu));
+  auto&& sigma_ref = to_ref(std::forward<S>(sigma));
   for (size_t i = 0; i < x.size(); ++i) {
     ret.emplace_back(offset_multiplier_free(x[i], mu_ref, sigma_ref));
   }
@@ -80,10 +81,10 @@ inline auto offset_multiplier_free(const std::vector<T>& x, const M& mu,
 /**
  * Overload for array of x and sigma and non-array mu
  */
-template <typename T, typename M, typename S,
+template <typename T, typename M, typename S, require_all_std_vector_t<T, S>* = nullptr,
           require_not_std_vector_t<M>* = nullptr>
-inline auto offset_multiplier_free(const std::vector<T>& x, const M& mu,
-                                   const std::vector<S>& sigma) {
+inline auto offset_multiplier_free(T&& x, const M& mu,
+                                   S&& sigma) {
   check_matching_dims("offset_multiplier_free", "x", x, "sigma", sigma);
   std::vector<
       plain_type_t<decltype(offset_multiplier_free(x[0], mu, sigma[0]))>>
@@ -99,10 +100,10 @@ inline auto offset_multiplier_free(const std::vector<T>& x, const M& mu,
 /**
  * Overload for array of x and mu and non-array sigma
  */
-template <typename T, typename M, typename S,
+template <typename T, typename M, typename S, require_all_std_vector_t<T, M>* = nullptr,
           require_not_std_vector_t<S>* = nullptr>
-inline auto offset_multiplier_free(const std::vector<T>& x,
-                                   const std::vector<M>& mu, const S& sigma) {
+inline auto offset_multiplier_free(T&& x,
+                                   M&& mu, const S& sigma) {
   check_matching_dims("offset_multiplier_free", "x", x, "mu", mu);
   std::vector<
       plain_type_t<decltype(offset_multiplier_free(x[0], mu[0], sigma))>>
@@ -118,10 +119,8 @@ inline auto offset_multiplier_free(const std::vector<T>& x,
 /**
  * Overload for array of x, mu, and sigma
  */
-template <typename T, typename M, typename S>
-inline auto offset_multiplier_free(const std::vector<T>& x,
-                                   const std::vector<M>& mu,
-                                   const std::vector<S>& sigma) {
+template <typename T, typename M, typename S, require_all_std_vector_t<T, M, S>* = nullptr>
+inline auto offset_multiplier_free(T&& x, M&& mu, S&& sigma) {
   check_matching_dims("offset_multiplier_free", "x", x, "mu", mu);
   check_matching_dims("offset_multiplier_free", "x", x, "sigma", sigma);
   std::vector<
diff --git a/stan/math/prim/constraint/ordered_constrain.hpp b/stan/math/prim/constraint/ordered_constrain.hpp
index 9fab8f2225d..4f10137a766 100644
--- a/stan/math/prim/constraint/ordered_constrain.hpp
+++ b/stan/math/prim/constraint/ordered_constrain.hpp
@@ -55,12 +55,12 @@ inline plain_type_t<EigVec> ordered_constrain(const EigVec& x) {
 template <typename EigVec, typename Lp,
           require_eigen_col_vector_t<EigVec>* = nullptr,
           require_convertible_t<value_type_t<EigVec>, Lp>* = nullptr>
-inline auto ordered_constrain(const EigVec& x, Lp& lp) {
-  const auto& x_ref = to_ref(x);
+inline auto ordered_constrain(EigVec&& x, Lp& lp) {
+  auto&& x_ref = to_ref(std::forward<EigVec>(x));
   if (likely(x.size() > 1)) {
     lp += sum(x_ref.tail(x.size() - 1));
   }
-  return ordered_constrain(x_ref);
+  return ordered_constrain(std::forward<decltype(x_ref)>(x_ref));
 }
 
 /**
@@ -76,9 +76,9 @@ inline auto ordered_constrain(const EigVec& x, Lp& lp) {
  * @return Positive, increasing ordered vector.
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto ordered_constrain(const T& x) {
-  return apply_vector_unary<T>::apply(
-      x, [](auto&& v) { return ordered_constrain(v); });
+inline auto ordered_constrain(T&& x) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [](auto&& v) { return ordered_constrain(std::forward<decltype(v)>(v)); });
 }
 
 /**
@@ -98,9 +98,9 @@ inline auto ordered_constrain(const T& x) {
  */
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto ordered_constrain(const T& x, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      x, [&lp](auto&& v) { return ordered_constrain(v, lp); });
+inline auto ordered_constrain(T&& x, Lp& lp) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [&lp](auto&& v) { return ordered_constrain(std::forward<decltype(v)>(v), lp); });
 }
 
 /**
@@ -125,11 +125,11 @@ inline auto ordered_constrain(const T& x, Lp& lp) {
  */
 template <bool Jacobian, typename T, typename Lp,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto ordered_constrain(const T& x, Lp& lp) {
+inline auto ordered_constrain(T&& x, Lp& lp) {
   if constexpr (Jacobian) {
-    return ordered_constrain(x, lp);
+    return ordered_constrain(std::forward<T>(x), lp);
   } else {
-    return ordered_constrain(x);
+    return ordered_constrain(std::forward<T>(x));
   }
 }
 
diff --git a/stan/math/prim/constraint/ordered_free.hpp b/stan/math/prim/constraint/ordered_free.hpp
index 297bae0b062..43354174e39 100644
--- a/stan/math/prim/constraint/ordered_free.hpp
+++ b/stan/math/prim/constraint/ordered_free.hpp
@@ -49,9 +49,9 @@ plain_type_t<EigVec> ordered_free(const EigVec& y) {
  * @param x The standard vector to untransform.
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto ordered_free(const T& x) {
-  return apply_vector_unary<T>::apply(x,
-                                      [](auto&& v) { return ordered_free(v); });
+inline auto ordered_free(T&& x) {
+  return apply_vector_unary<std::decay_t<T>>::apply(std::forward<T>(x),
+                                      [](auto&& v) { return ordered_free(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/positive_constrain.hpp b/stan/math/prim/constraint/positive_constrain.hpp
index cd8147ec78f..35602b449ee 100644
--- a/stan/math/prim/constraint/positive_constrain.hpp
+++ b/stan/math/prim/constraint/positive_constrain.hpp
@@ -20,8 +20,8 @@ namespace math {
  * @return Input transformed to be positive.
  */
 template <typename T>
-inline auto positive_constrain(const T& x) {
-  return exp(x);
+inline auto positive_constrain(T&& x) {
+  return exp(std::forward<T>(x));
 }
 
 /**
@@ -41,9 +41,9 @@ inline auto positive_constrain(const T& x) {
  * @return positive constrained version of unconstrained value(s)
  */
 template <typename T, typename S>
-inline auto positive_constrain(const T& x, S& lp) {
+inline auto positive_constrain(T&& x, S& lp) {
   lp += sum(x);
-  return exp(x);
+  return exp(std::forward<T>(x));
 }
 
 /**
@@ -66,11 +66,11 @@ inline auto positive_constrain(const T& x, S& lp) {
 template <bool Jacobian, typename T, typename Lp,
           require_not_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto positive_constrain(const T& x, Lp& lp) {
+inline auto positive_constrain(T&& x, Lp& lp) {
   if constexpr (Jacobian) {
-    return positive_constrain(x, lp);
+    return positive_constrain(std::forward<T>(x), lp);
   } else {
-    return positive_constrain(x);
+    return positive_constrain(std::forward<T>(x));
   }
 }
 
@@ -95,9 +95,9 @@ inline auto positive_constrain(const T& x, Lp& lp) {
 template <bool Jacobian, typename T, typename Lp,
           require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto positive_constrain(const T& x, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      x, [&lp](auto&& v) { return positive_constrain<Jacobian>(v, lp); });
+inline auto positive_constrain(T&& x, Lp& lp) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [&lp](auto&& v) { return positive_constrain<Jacobian>(std::forward<decltype(v)>(v), lp); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/positive_free.hpp b/stan/math/prim/constraint/positive_free.hpp
index ba76d16123f..55e184c8254 100644
--- a/stan/math/prim/constraint/positive_free.hpp
+++ b/stan/math/prim/constraint/positive_free.hpp
@@ -26,9 +26,9 @@ namespace math {
  * @throw std::domain_error if the variable is negative
  */
 template <typename T>
-inline plain_type_t<T> positive_free(const T& y) {
+inline plain_type_t<T> positive_free(T&& y) {
   check_positive("positive_free", "Positive variable", y);
-  return log(y);
+  return log(std::forward<T>(y));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/positive_ordered_constrain.hpp b/stan/math/prim/constraint/positive_ordered_constrain.hpp
index 4d1f228814f..172bd0ed8e0 100644
--- a/stan/math/prim/constraint/positive_ordered_constrain.hpp
+++ b/stan/math/prim/constraint/positive_ordered_constrain.hpp
@@ -52,11 +52,10 @@ inline auto positive_ordered_constrain(const EigVec& x) {
  */
 template <typename Vec, typename Lp, require_col_vector_t<Vec>* = nullptr,
           require_convertible_t<return_type_t<Vec>, Lp>* = nullptr>
-
-inline auto positive_ordered_constrain(const Vec& x, Lp& lp) {
-  const auto& x_ref = to_ref(x);
+inline auto positive_ordered_constrain(Vec&& x, Lp& lp) {
+  auto&& x_ref = to_ref(std::forward<Vec>(x));
   lp += sum(x_ref);
-  return positive_ordered_constrain(x_ref);
+  return positive_ordered_constrain(std::forward<decltype(x_ref)>(x_ref));
 }
 
 /**
@@ -71,9 +70,9 @@ inline auto positive_ordered_constrain(const Vec& x, Lp& lp) {
  * @return Positive, increasing ordered vector
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto positive_ordered_constrain(const T& x) {
-  return apply_vector_unary<T>::apply(
-      x, [](auto&& v) { return positive_ordered_constrain(v); });
+inline auto positive_ordered_constrain(T&& x) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [](auto&& v) { return positive_ordered_constrain(std::forward<decltype(v)>(v)); });
 }
 
 /**
@@ -92,9 +91,9 @@ inline auto positive_ordered_constrain(const T& x) {
  */
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto positive_ordered_constrain(const T& x, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      x, [&lp](auto&& v) { return positive_ordered_constrain(v, lp); });
+inline auto positive_ordered_constrain(T&& x, Lp& lp) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [&lp](auto&& v) { return positive_ordered_constrain(std::forward<decltype(v)>(v), lp); });
 }
 
 /**
@@ -118,11 +117,11 @@ inline auto positive_ordered_constrain(const T& x, Lp& lp) {
  */
 template <bool Jacobian, typename Vec, typename Lp,
           require_convertible_t<return_type_t<Vec>, Lp>* = nullptr>
-inline auto positive_ordered_constrain(const Vec& x, Lp& lp) {
+inline auto positive_ordered_constrain(Vec&& x, Lp& lp) {
   if constexpr (Jacobian) {
-    return positive_ordered_constrain(x, lp);
+    return positive_ordered_constrain(std::forward<decltype(x)>(x), lp);
   } else {
-    return positive_ordered_constrain(x);
+    return positive_ordered_constrain(std::forward<decltype(x)>(x));
   }
 }
 
diff --git a/stan/math/prim/constraint/positive_ordered_free.hpp b/stan/math/prim/constraint/positive_ordered_free.hpp
index a28052ec89e..b3adacf604f 100644
--- a/stan/math/prim/constraint/positive_ordered_free.hpp
+++ b/stan/math/prim/constraint/positive_ordered_free.hpp
@@ -49,9 +49,9 @@ inline auto positive_ordered_free(const EigVec& y) {
  * @param x The standard vector to untransform.
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto positive_ordered_free(const T& x) {
-  return apply_vector_unary<T>::apply(
-      x, [](auto&& v) { return positive_ordered_free(v); });
+inline auto positive_ordered_free(T&& x) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [](auto&& v) { return positive_ordered_free(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/prob_constrain.hpp b/stan/math/prim/constraint/prob_constrain.hpp
index d05193c8648..7bc61dd7a87 100644
--- a/stan/math/prim/constraint/prob_constrain.hpp
+++ b/stan/math/prim/constraint/prob_constrain.hpp
@@ -23,8 +23,8 @@ namespace math {
  * @return result constrained to fall in (0, 1)
  */
 template <typename T>
-inline T prob_constrain(const T& x) {
-  return inv_logit(x);
+inline auto prob_constrain(T&& x) {
+  return inv_logit(std::forward<T>(x));
 }
 
 /**
@@ -48,10 +48,10 @@ inline T prob_constrain(const T& x) {
  * @return result constrained to fall in (0, 1)
  */
 template <typename T>
-inline T prob_constrain(const T& x, T& lp) {
-  T log_inv_logit_x = log_inv_logit(x);
-  lp += log_inv_logit_x + log1m_inv_logit(x);
-  return exp(log_inv_logit_x);
+inline auto prob_constrain(T&& x, return_type_t<T>& lp) {
+  plain_type_t<T> log_inv_logit_x = log_inv_logit(x);
+  lp += log_inv_logit_x + log1m_inv_logit(std::forward<T>(x));
+  return exp(std::move(log_inv_logit_x));
 }
 
 /**
@@ -69,11 +69,11 @@ inline T prob_constrain(const T& x, T& lp) {
  * @return result constrained to fall in (0, 1)
  */
 template <bool Jacobian, typename T>
-inline auto prob_constrain(const T& x, T& lp) {
-  if (Jacobian) {
-    return prob_constrain(x, lp);
+inline auto prob_constrain(T&& x, return_type_t<T>& lp) {
+  if constexpr (Jacobian) {
+    return prob_constrain(std::forward<T>(x), lp);
   } else {
-    return prob_constrain(x);
+    return prob_constrain(std::forward<T>(x));
   }
 }
 }  // namespace math
diff --git a/stan/math/prim/constraint/prob_free.hpp b/stan/math/prim/constraint/prob_free.hpp
index 0f980ab87cd..adb2b5d6c61 100644
--- a/stan/math/prim/constraint/prob_free.hpp
+++ b/stan/math/prim/constraint/prob_free.hpp
@@ -24,10 +24,10 @@ namespace math {
  * @throw std::domain_error if y is not in (0, 1)
  */
 template <typename T>
-inline T prob_free(const T& y) {
+inline auto prob_free(T&& y) {
   check_bounded<T, double, double>("prob_free", "Probability variable", y, 0,
                                    1);
-  return logit(y);
+  return logit(std::forward<T>(y));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/simplex_constrain.hpp b/stan/math/prim/constraint/simplex_constrain.hpp
index cdae665c1e8..0bcdd1afda9 100644
--- a/stan/math/prim/constraint/simplex_constrain.hpp
+++ b/stan/math/prim/constraint/simplex_constrain.hpp
@@ -145,9 +145,9 @@ inline plain_type_t<Vec> simplex_constrain(const Vec& y, Lp& lp) {
  * @return simplex of dimensionality one greater than `y`
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto simplex_constrain(const T& y) {
-  return apply_vector_unary<T>::apply(
-      y, [](auto&& v) { return simplex_constrain(v); });
+inline auto simplex_constrain(T&& y) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(y), [](auto&& v) { return simplex_constrain(std::forward<decltype(v)>(v)); });
 }
 
 /**
@@ -165,9 +165,9 @@ inline auto simplex_constrain(const T& y) {
  */
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto simplex_constrain(const T& y, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      y, [&lp](auto&& v) { return simplex_constrain(v, lp); });
+inline auto simplex_constrain(T&& y, Lp& lp) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(y), [&lp](auto&& v) { return simplex_constrain(std::forward<decltype(v)>(v), lp); });
 }
 
 /**
@@ -190,11 +190,11 @@ inline auto simplex_constrain(const T& y, Lp& lp) {
  */
 template <bool Jacobian, typename Vec, typename Lp,
           require_convertible_t<return_type_t<Vec>, Lp>* = nullptr>
-inline plain_type_t<Vec> simplex_constrain(const Vec& y, Lp& lp) {
+inline plain_type_t<Vec> simplex_constrain(Vec&& y, Lp& lp) {
   if constexpr (Jacobian) {
-    return simplex_constrain(y, lp);
+    return simplex_constrain(std::forward<decltype(y)>(y), lp);
   } else {
-    return simplex_constrain(y);
+    return simplex_constrain(std::forward<decltype(y)>(y));
   }
 }
 
diff --git a/stan/math/prim/constraint/simplex_free.hpp b/stan/math/prim/constraint/simplex_free.hpp
index 4c4a27c33bd..3b1d242b5cd 100644
--- a/stan/math/prim/constraint/simplex_free.hpp
+++ b/stan/math/prim/constraint/simplex_free.hpp
@@ -53,9 +53,9 @@ inline plain_type_t<Vec> simplex_free(const Vec& x) {
  * @param x The standard vector to untransform.
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto simplex_free(const T& x) {
-  return apply_vector_unary<T>::apply(x,
-                                      [](auto&& v) { return simplex_free(v); });
+inline auto simplex_free(T&& x) {
+  return apply_vector_unary<std::decay_t<T>>::apply(std::forward<T>(x),
+                                      [](auto&& v) { return simplex_free(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/stochastic_column_constrain.hpp b/stan/math/prim/constraint/stochastic_column_constrain.hpp
index 58ef35ea0f6..84a442834b2 100644
--- a/stan/math/prim/constraint/stochastic_column_constrain.hpp
+++ b/stan/math/prim/constraint/stochastic_column_constrain.hpp
@@ -21,8 +21,8 @@ namespace math {
  */
 template <typename Mat, require_eigen_matrix_dynamic_t<Mat>* = nullptr,
           require_not_st_var<Mat>* = nullptr>
-inline plain_type_t<Mat> stochastic_column_constrain(const Mat& y) {
-  auto&& y_ref = to_ref(y);
+inline plain_type_t<Mat> stochastic_column_constrain(Mat&& y) {
+  auto&& y_ref = to_ref(std::forward<Mat>(y));
   const Eigen::Index M = y_ref.cols();
   plain_type_t<Mat> ret(y_ref.rows() + 1, M);
   for (Eigen::Index i = 0; i < M; ++i) {
@@ -71,9 +71,9 @@ inline plain_type_t<Mat> stochastic_column_constrain(const Mat& y, Lp& lp) {
  * dimensionality (K, M).
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto stochastic_column_constrain(const T& y) {
-  return apply_vector_unary<T>::apply(
-      y, [](auto&& v) { return stochastic_column_constrain(v); });
+inline auto stochastic_column_constrain(T&& y) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(y), [](auto&& v) { return stochastic_column_constrain(std::forward<decltype(v)>(v)); });
 }
 
 /**
@@ -92,9 +92,9 @@ inline auto stochastic_column_constrain(const T& y) {
  */
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto stochastic_column_constrain(const T& y, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      y, [&lp](auto&& v) { return stochastic_column_constrain(v, lp); });
+inline auto stochastic_column_constrain(T&& y, Lp& lp) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(y), [&lp](auto&& v) { return stochastic_column_constrain(std::forward<decltype(v)>(v), lp); });
 }
 
 /**
@@ -117,11 +117,11 @@ inline auto stochastic_column_constrain(const T& y, Lp& lp) {
  */
 template <bool Jacobian, typename Mat, typename Lp,
           require_convertible_t<return_type_t<Mat>, Lp>* = nullptr>
-inline plain_type_t<Mat> stochastic_column_constrain(const Mat& y, Lp& lp) {
+inline plain_type_t<Mat> stochastic_column_constrain(Mat&& y, Lp& lp) {
   if constexpr (Jacobian) {
-    return stochastic_column_constrain(y, lp);
+    return stochastic_column_constrain(std::forward<decltype(y)>(y), lp);
   } else {
-    return stochastic_column_constrain(y);
+    return stochastic_column_constrain(std::forward<decltype(y)>(y));
   }
 }
 
diff --git a/stan/math/prim/constraint/stochastic_column_free.hpp b/stan/math/prim/constraint/stochastic_column_free.hpp
index 988a579d2d3..f7e64aacd77 100644
--- a/stan/math/prim/constraint/stochastic_column_free.hpp
+++ b/stan/math/prim/constraint/stochastic_column_free.hpp
@@ -18,8 +18,8 @@ namespace math {
  * @param y Columnwise stochastic matrix input of dimensionality (N, K)
  */
 template <typename Mat, require_eigen_matrix_dynamic_t<Mat>* = nullptr>
-inline plain_type_t<Mat> stochastic_column_free(const Mat& y) {
-  auto&& y_ref = to_ref(y);
+inline plain_type_t<Mat> stochastic_column_free(Mat&& y) {
+  auto&& y_ref = to_ref(std::forward<Mat>(y));
   const Eigen::Index M = y_ref.cols();
   plain_type_t<Mat> ret(y_ref.rows() - 1, M);
   for (Eigen::Index i = 0; i < M; ++i) {
@@ -36,9 +36,9 @@ inline plain_type_t<Mat> stochastic_column_free(const Mat& y) {
  * @param[in] y vector of columnwise stochastic matrix of size (N, K)
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto stochastic_column_free(const T& y) {
-  return apply_vector_unary<T>::apply(
-      y, [](auto&& v) { return stochastic_column_free(v); });
+inline auto stochastic_column_free(T&& y) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(y), [](auto&& v) { return stochastic_column_free(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/stochastic_row_constrain.hpp b/stan/math/prim/constraint/stochastic_row_constrain.hpp
index 290f3d3b72f..e14a23121d9 100644
--- a/stan/math/prim/constraint/stochastic_row_constrain.hpp
+++ b/stan/math/prim/constraint/stochastic_row_constrain.hpp
@@ -21,8 +21,8 @@ namespace math {
  */
 template <typename Mat, require_eigen_matrix_dynamic_t<Mat>* = nullptr,
           require_not_st_var<Mat>* = nullptr>
-inline plain_type_t<Mat> stochastic_row_constrain(const Mat& y) {
-  auto&& y_ref = to_ref(y);
+inline plain_type_t<Mat> stochastic_row_constrain(Mat&& y) {
+  auto&& y_ref = to_ref(std::forward<Mat>(y));
   const Eigen::Index N = y_ref.rows();
   plain_type_t<Mat> ret(N, y_ref.cols() + 1);
   for (Eigen::Index i = 0; i < N; ++i) {
@@ -47,8 +47,8 @@ template <typename Mat, typename Lp,
           require_eigen_matrix_dynamic_t<Mat>* = nullptr,
           require_not_st_var<Mat>* = nullptr,
           require_convertible_t<value_type_t<Mat>, Lp>* = nullptr>
-inline plain_type_t<Mat> stochastic_row_constrain(const Mat& y, Lp& lp) {
-  auto&& y_ref = to_ref(y);
+inline plain_type_t<Mat> stochastic_row_constrain(Mat&& y, Lp& lp) {
+  auto&& y_ref = to_ref(std::forward<Mat>(y));
   const Eigen::Index N = y_ref.rows();
   plain_type_t<Mat> ret(N, y_ref.cols() + 1);
   for (Eigen::Index i = 0; i < N; ++i) {
@@ -68,9 +68,9 @@ inline plain_type_t<Mat> stochastic_row_constrain(const Mat& y, Lp& lp) {
  * @return vector of matrices with simplex rows of dimensionality (N, K)
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto stochastic_row_constrain(const T& y) {
-  return apply_vector_unary<T>::apply(
-      y, [](auto&& v) { return stochastic_row_constrain(v); });
+inline auto stochastic_row_constrain(T&& y) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(y), [](auto&& v) { return stochastic_row_constrain(std::forward<decltype(v)>(v)); });
 }
 
 /**
@@ -88,9 +88,9 @@ inline auto stochastic_row_constrain(const T& y) {
  */
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto stochastic_row_constrain(const T& y, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      y, [&lp](auto&& v) { return stochastic_row_constrain(v, lp); });
+inline auto stochastic_row_constrain(T&& y, Lp& lp) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(y), [&lp](auto&& v) { return stochastic_row_constrain(std::forward<decltype(v)>(v), lp); });
 }
 
 /**
@@ -113,11 +113,11 @@ inline auto stochastic_row_constrain(const T& y, Lp& lp) {
  */
 template <bool Jacobian, typename Mat, typename Lp,
           require_convertible_t<return_type_t<Mat>, Lp>* = nullptr>
-inline plain_type_t<Mat> stochastic_row_constrain(const Mat& y, Lp& lp) {
+inline plain_type_t<Mat> stochastic_row_constrain(Mat&& y, Lp& lp) {
   if constexpr (Jacobian) {
-    return stochastic_row_constrain(y, lp);
+    return stochastic_row_constrain(std::forward<decltype(y)>(y), lp);
   } else {
-    return stochastic_row_constrain(y);
+    return stochastic_row_constrain(std::forward<decltype(y)>(y));
   }
 }
 
diff --git a/stan/math/prim/constraint/stochastic_row_free.hpp b/stan/math/prim/constraint/stochastic_row_free.hpp
index 069db772d66..c9122aba00f 100644
--- a/stan/math/prim/constraint/stochastic_row_free.hpp
+++ b/stan/math/prim/constraint/stochastic_row_free.hpp
@@ -17,8 +17,8 @@ namespace math {
  * @param y Rowwise simplex Matrix input of dimensionality (N, K)
  */
 template <typename Mat, require_eigen_matrix_dynamic_t<Mat>* = nullptr>
-inline plain_type_t<Mat> stochastic_row_free(const Mat& y) {
-  auto&& y_ref = to_ref(y);
+inline plain_type_t<Mat> stochastic_row_free(Mat&& y) {
+  auto&& y_ref = to_ref(std::forward<Mat>(y));
   const Eigen::Index N = y_ref.rows();
   plain_type_t<Mat> ret(N, y_ref.cols() - 1);
   for (Eigen::Index i = 0; i < N; ++i) {
@@ -35,9 +35,9 @@ inline plain_type_t<Mat> stochastic_row_free(const Mat& y) {
  * @param[in] y vector of rowwise simplex matrices each of size (N, K)
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto stochastic_row_free(const T& y) {
-  return apply_vector_unary<T>::apply(
-      y, [](auto&& v) { return stochastic_row_free(v); });
+inline auto stochastic_row_free(T&& y) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(y), [](auto&& v) { return stochastic_row_free(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/sum_to_zero_constrain.hpp b/stan/math/prim/constraint/sum_to_zero_constrain.hpp
index 19f330c5692..8b1c4798d91 100644
--- a/stan/math/prim/constraint/sum_to_zero_constrain.hpp
+++ b/stan/math/prim/constraint/sum_to_zero_constrain.hpp
@@ -122,9 +122,9 @@ inline plain_type_t<Mat> sum_to_zero_constrain(const Mat& x) {
  * @param lp unused
  * @return Zero-sum vector or matrix which is one larger in each dimension
  */
-template <typename T, typename Lp, require_not_st_var<T>* = nullptr>
-inline plain_type_t<T> sum_to_zero_constrain(const T& y, Lp& lp) {
-  return sum_to_zero_constrain(y);
+template <typename T, typename Lp, require_not_std_vector_t<T>* = nullptr>
+inline plain_type_t<T> sum_to_zero_constrain(T&& y, Lp& lp) {
+  return sum_to_zero_constrain(std::forward<T>(y));
 }
 
 /**
@@ -138,9 +138,9 @@ inline plain_type_t<T> sum_to_zero_constrain(const T& y, Lp& lp) {
  * @return Zero-sum vectors or matrices which are one larger in each dimension
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto sum_to_zero_constrain(const T& y) {
-  return apply_vector_unary<T>::apply(
-      y, [](auto&& v) { return sum_to_zero_constrain(v); });
+inline auto sum_to_zero_constrain(T&& y) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(y), [](auto&& v) { return sum_to_zero_constrain(std::forward<decltype(v)>(v)); });
 }
 
 /**
@@ -157,9 +157,9 @@ inline auto sum_to_zero_constrain(const T& y) {
  */
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto sum_to_zero_constrain(const T& y, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      y, [](auto&& v) { return sum_to_zero_constrain(v); });
+inline auto sum_to_zero_constrain(T&& y, Lp& lp) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(y), [&lp](auto&& v) { return sum_to_zero_constrain(std::forward<decltype(v)>(v), lp); });
 }
 
 /**
@@ -175,8 +175,8 @@ inline auto sum_to_zero_constrain(const T& y, Lp& lp) {
  * @return Zero-sum vector or matrix which is one larger in each dimension
  */
 template <bool Jacobian, typename T, typename Lp>
-inline plain_type_t<T> sum_to_zero_constrain(const T& y, Lp& lp) {
-  return sum_to_zero_constrain(y);
+inline plain_type_t<T> sum_to_zero_constrain(T&& y, Lp& lp) {
+  return sum_to_zero_constrain(std::forward<T>(y), lp);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/sum_to_zero_free.hpp b/stan/math/prim/constraint/sum_to_zero_free.hpp
index 4acbbdfacdd..936a6f37204 100644
--- a/stan/math/prim/constraint/sum_to_zero_free.hpp
+++ b/stan/math/prim/constraint/sum_to_zero_free.hpp
@@ -115,9 +115,9 @@ inline plain_type_t<Mat> sum_to_zero_free(const Mat& z) {
  * @param z The standard vector to untransform.
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto sum_to_zero_free(const T& z) {
-  return apply_vector_unary<T>::apply(
-      z, [](auto&& v) { return sum_to_zero_free(v); });
+inline auto sum_to_zero_free(T&& z) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(z), [](auto&& v) { return sum_to_zero_free(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/ub_constrain.hpp b/stan/math/prim/constraint/ub_constrain.hpp
index fe836471456..749104b164f 100644
--- a/stan/math/prim/constraint/ub_constrain.hpp
+++ b/stan/math/prim/constraint/ub_constrain.hpp
@@ -88,8 +88,8 @@ inline auto ub_constrain(const T& x, const U& ub, Lp& lp) {
 template <typename T, typename U, require_eigen_t<T>* = nullptr,
           require_stan_scalar_t<U>* = nullptr,
           require_all_not_st_var<T, U>* = nullptr>
-inline auto ub_constrain(const T& x, const U& ub) {
-  return eval(x.unaryExpr([ub](auto&& xx) { return ub_constrain(xx, ub); }));
+inline auto ub_constrain(T&& x, const U& ub) {
+  return eval(std::forward<T>(x).unaryExpr([ub](auto&& xx) { return ub_constrain(xx, ub); }));
 }
 
 /**
@@ -108,9 +108,9 @@ template <typename T, typename U, typename Lp, require_eigen_t<T>* = nullptr,
           require_stan_scalar_t<U>* = nullptr,
           require_all_not_st_var<T, U>* = nullptr,
           require_convertible_t<return_type_t<T, U>, Lp>* = nullptr>
-inline auto ub_constrain(const T& x, const U& ub, Lp& lp) {
+inline auto ub_constrain(T&& x, const U& ub, Lp& lp) {
   return eval(
-      x.unaryExpr([ub, &lp](auto&& xx) { return ub_constrain(xx, ub, lp); }));
+      std::forward<T>(x).unaryExpr([ub, &lp](auto&& xx) { return ub_constrain(xx, ub, lp); }));
 }
 
 /**
@@ -125,9 +125,9 @@ inline auto ub_constrain(const T& x, const U& ub, Lp& lp) {
  */
 template <typename T, typename U, require_all_eigen_t<T, U>* = nullptr,
           require_all_not_st_var<T, U>* = nullptr>
-inline auto ub_constrain(const T& x, const U& ub) {
+inline auto ub_constrain(T&& x, const U& ub) {
   check_matching_dims("ub_constrain", "x", x, "ub", ub);
-  return eval(x.binaryExpr(
+  return eval(std::forward<T>(x).binaryExpr(
       ub, [](auto&& xx, auto&& ubb) { return ub_constrain(xx, ubb); }));
 }
 
@@ -147,9 +147,9 @@ template <typename T, typename U, typename Lp,
           require_all_eigen_t<T, U>* = nullptr,
           require_all_not_st_var<T, U>* = nullptr,
           require_convertible_t<return_type_t<T, U>, Lp>* = nullptr>
-inline auto ub_constrain(const T& x, const U& ub, Lp& lp) {
+inline auto ub_constrain(T&& x, const U& ub, Lp& lp) {
   check_matching_dims("ub_constrain", "x", x, "ub", ub);
-  return eval(x.binaryExpr(
+  return eval(std::forward<T>(x).binaryExpr(
       ub, [&lp](auto&& xx, auto&& ubb) { return ub_constrain(xx, ubb, lp); }));
 }
 
@@ -261,11 +261,11 @@ inline auto ub_constrain(const std::vector<T>& x, const std::vector<U>& ub,
  */
 template <bool Jacobian, typename T, typename U, typename Lp,
           require_convertible_t<return_type_t<T, U>, Lp>* = nullptr>
-inline auto ub_constrain(const T& x, const U& ub, Lp& lp) {
+inline auto ub_constrain(T&& x, U&& ub, Lp& lp) {
   if constexpr (Jacobian) {
-    return ub_constrain(x, ub, lp);
+    return ub_constrain(std::forward<T>(x), std::forward<U>(ub), lp);
   } else {
-    return ub_constrain(x, ub);
+    return ub_constrain(std::forward<T>(x), std::forward<U>(ub));
   }
 }
 
diff --git a/stan/math/prim/constraint/unit_vector_constrain.hpp b/stan/math/prim/constraint/unit_vector_constrain.hpp
index ae72f6277a1..5a18366200c 100644
--- a/stan/math/prim/constraint/unit_vector_constrain.hpp
+++ b/stan/math/prim/constraint/unit_vector_constrain.hpp
@@ -66,9 +66,9 @@ inline plain_type_t<T1> unit_vector_constrain(const T1& y, T2& lp) {
  * @return Unit length vector of dimension K
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto unit_vector_constrain(const T& y) {
-  return apply_vector_unary<T>::apply(
-      y, [](auto&& v) { return unit_vector_constrain(v); });
+inline auto unit_vector_constrain(T&& y) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(y), [](auto&& v) { return unit_vector_constrain(std::forward<decltype(v)>(v)); });
 }
 
 /**
@@ -86,9 +86,9 @@ inline auto unit_vector_constrain(const T& y) {
  */
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto unit_vector_constrain(const T& y, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      y, [&lp](auto&& v) { return unit_vector_constrain(v, lp); });
+inline auto unit_vector_constrain(T&& y, Lp& lp) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(y), [&lp](auto&& v) { return unit_vector_constrain(std::forward<decltype(v)>(v), lp); });
 }
 
 /**
@@ -111,11 +111,11 @@ inline auto unit_vector_constrain(const T& y, Lp& lp) {
  */
 template <bool Jacobian, typename T, typename Lp,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
-inline auto unit_vector_constrain(const T& y, Lp& lp) {
+inline auto unit_vector_constrain(T&& y, Lp& lp) {
   if constexpr (Jacobian) {
-    return unit_vector_constrain(y, lp);
+    return unit_vector_constrain(std::forward<T>(y), lp);
   } else {
-    return unit_vector_constrain(y);
+    return unit_vector_constrain(std::forward<T>(y));
   }
 }
 
diff --git a/stan/math/prim/constraint/unit_vector_free.hpp b/stan/math/prim/constraint/unit_vector_free.hpp
index c0debd3429e..a1c5d52e01c 100644
--- a/stan/math/prim/constraint/unit_vector_free.hpp
+++ b/stan/math/prim/constraint/unit_vector_free.hpp
@@ -36,9 +36,9 @@ inline auto unit_vector_free(EigVec&& x) {
  * @param x The standard vector to untransform.
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
-inline auto unit_vector_free(const T& x) {
-  return apply_vector_unary<T>::apply(
-      x, [](auto&& v) { return unit_vector_free(v); });
+inline auto unit_vector_free(T&& x) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [](auto&& v) { return unit_vector_free(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/abs.hpp b/stan/math/prim/fun/abs.hpp
index 7ef05d9d23f..5d7571167be 100644
--- a/stan/math/prim/fun/abs.hpp
+++ b/stan/math/prim/fun/abs.hpp
@@ -81,7 +81,7 @@ template <typename Container,
 inline auto abs(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [&](const auto& v) {
+      [&](auto&& v) {
         return std::forward<decltype(v)>(v).array().abs();
       });
 }
diff --git a/stan/math/prim/fun/acos.hpp b/stan/math/prim/fun/acos.hpp
index 8d35f36c994..1b22d4299bf 100644
--- a/stan/math/prim/fun/acos.hpp
+++ b/stan/math/prim/fun/acos.hpp
@@ -83,7 +83,7 @@ template <typename Container,
 inline auto acos(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) {
+      [](auto&& v) {
         return std::forward<decltype(v)>(v).array().acos();
       });
 }
diff --git a/stan/math/prim/fun/asin.hpp b/stan/math/prim/fun/asin.hpp
index 287cddf467b..8dfd7aca987 100644
--- a/stan/math/prim/fun/asin.hpp
+++ b/stan/math/prim/fun/asin.hpp
@@ -81,7 +81,7 @@ template <typename Container,
 inline auto asin(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) {
+      [](auto&& v) {
         return std::forward<decltype(v)>(v).array().asin();
       });
 }
diff --git a/stan/math/prim/fun/atan.hpp b/stan/math/prim/fun/atan.hpp
index ac505f0cd2b..08b2da5cb78 100644
--- a/stan/math/prim/fun/atan.hpp
+++ b/stan/math/prim/fun/atan.hpp
@@ -79,7 +79,7 @@ template <typename Container,
 inline auto atan(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) {
+      [](auto&& v) {
         return std::forward<decltype(v)>(v).array().atan();
       });
 }
diff --git a/stan/math/prim/fun/ceil.hpp b/stan/math/prim/fun/ceil.hpp
index fc25d99955a..ac9a59e8541 100644
--- a/stan/math/prim/fun/ceil.hpp
+++ b/stan/math/prim/fun/ceil.hpp
@@ -56,7 +56,7 @@ template <typename Container,
 inline auto ceil(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) {
+      [](auto&& v) {
         return std::forward<decltype(v)>(v).array().ceil();
       });
 }
diff --git a/stan/math/prim/fun/cos.hpp b/stan/math/prim/fun/cos.hpp
index 5f111a9c7b0..8bdeffd12c3 100644
--- a/stan/math/prim/fun/cos.hpp
+++ b/stan/math/prim/fun/cos.hpp
@@ -78,7 +78,7 @@ template <typename Container,
 inline auto cos(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [&](const auto& v) {
+      [&](auto&& v) {
         return std::forward<decltype(v)>(v).array().cos();
       });
 }
diff --git a/stan/math/prim/fun/cosh.hpp b/stan/math/prim/fun/cosh.hpp
index 96734fe39d3..dda708c9f9e 100644
--- a/stan/math/prim/fun/cosh.hpp
+++ b/stan/math/prim/fun/cosh.hpp
@@ -76,7 +76,7 @@ template <typename Container,
 inline auto cosh(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) { return std::forward<decltype(v)>(v).array().cosh(); });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().cosh(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/exp.hpp b/stan/math/prim/fun/exp.hpp
index 1524bfca246..51e37f9e559 100644
--- a/stan/math/prim/fun/exp.hpp
+++ b/stan/math/prim/fun/exp.hpp
@@ -86,7 +86,7 @@ template <typename Container,
 inline auto exp(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) { return std::forward<decltype(v)>(v).array().exp(); });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().exp(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/fabs.hpp b/stan/math/prim/fun/fabs.hpp
index 4b9e5651e4f..9db7205c1b6 100644
--- a/stan/math/prim/fun/fabs.hpp
+++ b/stan/math/prim/fun/fabs.hpp
@@ -65,7 +65,7 @@ template <typename Container,
 inline auto fabs(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) { return std::forward<decltype(v)>(v).array().abs(); });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().abs(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/floor.hpp b/stan/math/prim/fun/floor.hpp
index 8f5b1a952c2..11529d21df6 100644
--- a/stan/math/prim/fun/floor.hpp
+++ b/stan/math/prim/fun/floor.hpp
@@ -60,7 +60,7 @@ template <typename Container,
 inline auto floor(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) { return std::forward<decltype(v)>(v).array().floor(); });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().floor(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/inv.hpp b/stan/math/prim/fun/inv.hpp
index c798ea20b1c..1c05385df37 100644
--- a/stan/math/prim/fun/inv.hpp
+++ b/stan/math/prim/fun/inv.hpp
@@ -53,7 +53,7 @@ template <typename Container,
 inline auto inv(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) { return std::forward<decltype(v)>(v).array().inverse(); });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().inverse(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/inv_cloglog.hpp b/stan/math/prim/fun/inv_cloglog.hpp
index 05d057f0386..cb31db2e6c2 100644
--- a/stan/math/prim/fun/inv_cloglog.hpp
+++ b/stan/math/prim/fun/inv_cloglog.hpp
@@ -108,7 +108,7 @@ inline auto inv_cloglog(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
       [](const auto& v) {
-        return 1 - (-std::forward<decltype(v)>(v).array().exp()).exp();
+        return (1 - (-std::forward<decltype(v)>(v).array().exp()).exp());
       });
 }
 
diff --git a/stan/math/prim/fun/inv_logit.hpp b/stan/math/prim/fun/inv_logit.hpp
index 08f2a940a7f..1db746d7f8a 100644
--- a/stan/math/prim/fun/inv_logit.hpp
+++ b/stan/math/prim/fun/inv_logit.hpp
@@ -106,7 +106,7 @@ template <typename Container,
 inline auto inv_logit(Container&& x) {
   return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
-      [](const auto& v) { return v.array().logistic(); });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().logistic(); });
 }
 }  // namespace math
 }  // namespace stan
diff --git a/stan/math/prim/fun/inv_sqrt.hpp b/stan/math/prim/fun/inv_sqrt.hpp
index 80fc7431880..bd8cc17904f 100644
--- a/stan/math/prim/fun/inv_sqrt.hpp
+++ b/stan/math/prim/fun/inv_sqrt.hpp
@@ -68,7 +68,7 @@ inline auto inv_sqrt(Container&& x) {
 #else
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) { return std::forward<decltype(v)>(v).array().rsqrt(); });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().rsqrt(); });
 #endif
 }
 
diff --git a/stan/math/prim/fun/inv_square.hpp b/stan/math/prim/fun/inv_square.hpp
index 074afbde47d..96ecdb3b877 100644
--- a/stan/math/prim/fun/inv_square.hpp
+++ b/stan/math/prim/fun/inv_square.hpp
@@ -37,7 +37,7 @@ template <typename Container,
 inline auto inv_square(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) {
+      [](auto&& v) {
         return std::forward<decltype(v)>(v).array().square().inverse();
       });
 }
diff --git a/stan/math/prim/fun/log.hpp b/stan/math/prim/fun/log.hpp
index 1402ecd3fea..45621a07594 100644
--- a/stan/math/prim/fun/log.hpp
+++ b/stan/math/prim/fun/log.hpp
@@ -85,7 +85,7 @@ template <typename Container,
 inline auto log(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) { return std::forward<decltype(v)>(v).array().log(); });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().log(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/log10.hpp b/stan/math/prim/fun/log10.hpp
index 59e07b9cf30..fecc2368759 100644
--- a/stan/math/prim/fun/log10.hpp
+++ b/stan/math/prim/fun/log10.hpp
@@ -75,7 +75,7 @@ template <typename Container,
 inline auto log10(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) { return std::forward<decltype(v)>(v).array().log10(); });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().log10(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/log1m_inv_logit.hpp b/stan/math/prim/fun/log1m_inv_logit.hpp
index d6717a431af..3554fe33f7d 100644
--- a/stan/math/prim/fun/log1m_inv_logit.hpp
+++ b/stan/math/prim/fun/log1m_inv_logit.hpp
@@ -65,8 +65,8 @@ struct log1m_inv_logit_fun {
    * @return natural log of one minus inverse logit of argument
    */
   template <typename T>
-  static inline auto fun(const T& x) {
-    return log1m_inv_logit(x);
+  static inline auto fun(T&& x) {
+    return log1m_inv_logit(std::forward<T>(x));
   }
 };
 
@@ -82,8 +82,7 @@ struct log1m_inv_logit_fun {
  */
 template <typename T, require_not_var_matrix_t<T>* = nullptr,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
-inline typename apply_scalar_unary<log1m_inv_logit_fun, std::decay_t<T>>::return_t
-log1m_inv_logit(T&& x) {
+inline auto log1m_inv_logit(T&& x) {
   return apply_scalar_unary<log1m_inv_logit_fun, std::decay_t<T>>::apply(
       std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/max.hpp b/stan/math/prim/fun/max.hpp
index 7ca81daa8f6..0fa8ec8419f 100644
--- a/stan/math/prim/fun/max.hpp
+++ b/stan/math/prim/fun/max.hpp
@@ -39,14 +39,14 @@ auto max(T1 x, T2 y) {
  * scalar type in the container is integer
  */
 template <typename T, require_container_t<T>* = nullptr>
-inline value_type_t<T> max(const T& m) {
+inline value_type_t<T> max(T&& m) {
   if (std::is_integral<value_type_t<T>>::value) {
     check_nonzero_size("max", "int vector", m);
   } else if (m.size() == 0) {
     return NEGATIVE_INFTY;
   }
-  return apply_vector_unary<T>::reduce(
-      m, [](const auto& x) { return x.maxCoeff(); });
+  return apply_vector_unary<std::decay_t<T>>::reduce(
+      std::forward<T>(m), [](const auto& x) { return x.maxCoeff(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/mean.hpp b/stan/math/prim/fun/mean.hpp
index aff32358d41..d9568fce905 100644
--- a/stan/math/prim/fun/mean.hpp
+++ b/stan/math/prim/fun/mean.hpp
@@ -19,9 +19,9 @@ namespace math {
  * @return Sample mean of container coefficients.
  */
 template <typename T, require_container_t<T>* = nullptr>
-inline return_type_t<T> mean(const T& m) {
+inline return_type_t<T> mean(T&& m) {
   check_nonzero_size("mean", "m", m);
-  return apply_vector_unary<T>::reduce(m,
+  return apply_vector_unary<std::decay_t<T>>::reduce(std::forward<T>(m),
                                        [](const auto& a) { return a.mean(); });
 }
 
diff --git a/stan/math/prim/fun/min.hpp b/stan/math/prim/fun/min.hpp
index 9d84a38ac93..ae1e14b44f5 100644
--- a/stan/math/prim/fun/min.hpp
+++ b/stan/math/prim/fun/min.hpp
@@ -38,14 +38,14 @@ auto min(T1 x, T2 y) {
  * scalar type in the container is integer
  */
 template <typename T, require_container_t<T>* = nullptr>
-inline value_type_t<T> min(const T& m) {
+inline value_type_t<T> min(T&& m) {
   if (std::is_integral<value_type_t<T>>::value) {
     check_nonzero_size("min", "int vector", m);
   } else if (m.size() == 0) {
     return INFTY;
   }
-  return apply_vector_unary<T>::reduce(
-      m, [](const auto& x) { return x.minCoeff(); });
+  return apply_vector_unary<std::decay_t<T>>::reduce(
+      std::forward<T>(m), [](const auto& x) { return x.minCoeff(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/minus.hpp b/stan/math/prim/fun/minus.hpp
index 02e8ddd5bc3..4feae5426a2 100644
--- a/stan/math/prim/fun/minus.hpp
+++ b/stan/math/prim/fun/minus.hpp
@@ -15,8 +15,14 @@ namespace math {
  * @return Negation of subtrahend.
  */
 template <typename T, require_not_std_vector_t<T>* = nullptr>
-inline auto minus(const T& x) {
-  return -x;
+inline auto minus(T&& x) {
+  if constexpr (is_eigen_v<T>) {
+    return make_holder([](auto&& xx) {
+      return -std::forward<decltype(xx)>(xx);
+    }, std::forward<T>(x));
+  } else {
+    return -x;
+  }
 }
 
 /**
@@ -26,13 +32,12 @@ inline auto minus(const T& x) {
  * @param x Container.
  * @return Container where each element is negated.
  */
-template <typename T>
-inline auto minus(std::vector<T>&& x) {
-  return apply_vector_unary<std::vector<T>>::apply(
-      std::forward<std::vector<T>>(x),
+template <typename T, require_std_vector_t<T>* = nullptr>
+inline auto minus(T&& x) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x),
       [](auto&& v) { return -std::forward<decltype(v)>(v); });
 }
-
 }  // namespace math
 }  // namespace stan
 
diff --git a/stan/math/prim/fun/pow.hpp b/stan/math/prim/fun/pow.hpp
index d0ea2470718..46d60cb00ef 100644
--- a/stan/math/prim/fun/pow.hpp
+++ b/stan/math/prim/fun/pow.hpp
@@ -111,7 +111,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
 inline auto pow(T1&& a, T2&& b) {
   return apply_scalar_binary(
       // Qualified pow since only Arithmetic types are accepted here
-      [](const auto& c, const auto& d) { return stan::math::pow(c, d); },
+      [](auto&& c, auto&& d) { return stan::math::pow(std::forward<decltype(c)>(c), std::forward<decltype(d)>(d)); },
       std::forward<T1>(a), std::forward<T2>(b));
 }
 }  // namespace math
diff --git a/stan/math/prim/fun/rank.hpp b/stan/math/prim/fun/rank.hpp
index 9378a5c120b..f3357d0424b 100644
--- a/stan/math/prim/fun/rank.hpp
+++ b/stan/math/prim/fun/rank.hpp
@@ -17,12 +17,11 @@ namespace math {
  * @throw std::out_of_range if s is out of range.
  */
 template <typename C, require_container_t<C>* = nullptr>
-inline int rank(const C& v, int s) {
+inline int rank(C&& v, int s) {
   check_range("rank", "v", v.size(), s);
   --s;  // adjust for indexing by one
-  return apply_vector_unary<C>::reduce(v, [s](const auto& vec) {
-    const auto& vec_ref = to_ref(vec);
-
+  return apply_vector_unary<std::decay_t<C>>::reduce(std::forward<C>(v), [s](const auto& vec) {
+    auto&& vec_ref = to_ref(std::forward<decltype(vec)>(vec));
     return (vec_ref.array() < vec_ref.coeff(s)).template cast<int>().sum();
   });
 }
diff --git a/stan/math/prim/fun/round.hpp b/stan/math/prim/fun/round.hpp
index 1b196cceee3..c91673aea36 100644
--- a/stan/math/prim/fun/round.hpp
+++ b/stan/math/prim/fun/round.hpp
@@ -53,7 +53,7 @@ template <typename Container,
 inline auto round(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) { return std::forward<decltype(v)>(v).array().round(); });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().round(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/select.hpp b/stan/math/prim/fun/select.hpp
index 7968d65a12b..0b551a1da6e 100644
--- a/stan/math/prim/fun/select.hpp
+++ b/stan/math/prim/fun/select.hpp
@@ -116,13 +116,13 @@ template <typename T_true, typename T_false,
           require_stan_scalar_t<T_true>* = nullptr,
           require_container_t<T_false>* = nullptr>
 inline ReturnT select(const bool c, const T_true y_true,
-                      const T_false y_false) {
+                      T_false&& y_false) {
   if (c) {
     return apply_scalar_binary(
         [](auto&& y_true_inner, auto&& y_false_inner) {
           return std::forward<decltype(y_true_inner)>(y_true_inner);
         },
-        std::forward<T_true>(y_true), std::forward<T_false>(y_false));
+        T_true(y_true), std::forward<T_false>(y_false));
   } else {
     return y_false;
   }
@@ -146,9 +146,9 @@ inline ReturnT select(const bool c, const T_true y_true,
 template <typename T_bool, typename T_true, typename T_false,
           require_eigen_array_vt<std::is_integral, T_bool>* = nullptr,
           require_all_stan_scalar_t<T_true, T_false>* = nullptr>
-inline auto select(const T_bool c, const T_true y_true, const T_false y_false) {
+inline auto select(T_bool&& c, const T_true y_true, const T_false y_false) {
   using ret_t = return_type_t<T_true, T_false>;
-  return c
+  return std::forward<T_bool>(c)
       .unaryExpr([y_true, y_false](bool cond) {
         return cond ? ret_t(y_true) : ret_t(y_false);
       })
@@ -170,11 +170,11 @@ inline auto select(const T_bool c, const T_true y_true, const T_false y_false) {
 template <typename T_bool, typename T_true, typename T_false,
           require_eigen_array_t<T_bool>* = nullptr,
           require_any_eigen_array_t<T_true, T_false>* = nullptr>
-inline auto select(const T_bool c, const T_true y_true, const T_false y_false) {
+inline auto select(T_bool&& c, T_true&& y_true, T_false&& y_false) {
   check_consistent_sizes("select", "boolean", c, "left hand side", y_true,
                          "right hand side", y_false);
   using ret_t = return_type_t<T_true, T_false>;
-  return c.select(y_true, y_false).template cast<ret_t>().eval();
+  return std::forward<T_bool>(c).select(std::forward<T_true>(y_true), std::forward<T_false>(y_false)).template cast<ret_t>().eval();
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sin.hpp b/stan/math/prim/fun/sin.hpp
index 0a1678a38bf..f9b05bdc91d 100644
--- a/stan/math/prim/fun/sin.hpp
+++ b/stan/math/prim/fun/sin.hpp
@@ -77,7 +77,7 @@ template <typename Container,
 inline auto sin(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [&](const auto& v) { return std::forward<decltype(v)>(v).array().sin(); });
+      [&](auto&& v) { return std::forward<decltype(v)>(v).array().sin(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/sinh.hpp b/stan/math/prim/fun/sinh.hpp
index dd34a48145a..c5bcb3c2f09 100644
--- a/stan/math/prim/fun/sinh.hpp
+++ b/stan/math/prim/fun/sinh.hpp
@@ -74,7 +74,7 @@ template <typename Container,
 inline auto sinh(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) { return std::forward<decltype(v)>(v).array().sinh(); });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().sinh(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/sqrt.hpp b/stan/math/prim/fun/sqrt.hpp
index d70307bbed4..b62a9f18aad 100644
--- a/stan/math/prim/fun/sqrt.hpp
+++ b/stan/math/prim/fun/sqrt.hpp
@@ -75,7 +75,7 @@ template <typename Container,
 inline auto sqrt(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) { return std::forward<decltype(v)>(v).array().sqrt(); });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().sqrt(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/square.hpp b/stan/math/prim/fun/square.hpp
index 7462934ef65..a958b83b18a 100644
--- a/stan/math/prim/fun/square.hpp
+++ b/stan/math/prim/fun/square.hpp
@@ -67,7 +67,7 @@ template <typename Container,
 inline auto square(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) { return std::forward<decltype(v)>(v).array().square(); });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().square(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/tan.hpp b/stan/math/prim/fun/tan.hpp
index e11f500010b..ec0387365dd 100644
--- a/stan/math/prim/fun/tan.hpp
+++ b/stan/math/prim/fun/tan.hpp
@@ -77,7 +77,7 @@ template <typename Container,
 inline auto tan(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) {
+      [](auto&& v) {
         return std::forward<decltype(v)>(v).array().tan();
       });
 }
diff --git a/stan/math/prim/fun/tanh.hpp b/stan/math/prim/fun/tanh.hpp
index 3a26a16797a..cc5ee6b9cd3 100644
--- a/stan/math/prim/fun/tanh.hpp
+++ b/stan/math/prim/fun/tanh.hpp
@@ -76,7 +76,7 @@ template <typename Container,
 inline auto tanh(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](const auto& v) { return std::forward<decltype(v)>(v).array().tanh(); });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().tanh(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/functor/apply_scalar_binary.hpp b/stan/math/prim/functor/apply_scalar_binary.hpp
index a896df33914..77ea8369d27 100644
--- a/stan/math/prim/functor/apply_scalar_binary.hpp
+++ b/stan/math/prim/functor/apply_scalar_binary.hpp
@@ -203,7 +203,7 @@ inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   return make_holder(
       [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
         return x_inner.unaryExpr(
-            [f_inner, y_inner](const auto& v) { return f_inner(v, y_inner); });
+            [f_inner_ = std::forward<decltype(f_inner)>(f_inner), y_inner](const auto& v) { return f_inner_(v, y_inner); });
       },
       std::forward<F>(f), std::forward<T1>(x), std::forward<T2>(y));
 }
@@ -229,7 +229,7 @@ inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   return make_holder(
       [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
         return y_inner.unaryExpr(
-            [f_inner, x_inner](const auto& v) { return f_inner(x_inner, v); });
+            [f_inner_ = std::forward<decltype(f_inner)>(f_inner), x_inner](auto&& v) { return f_inner_(x_inner, std::forward<decltype(v)>(v)); });
       },
       std::forward<F>(f), std::forward<T1>(x), std::forward<T2>(y));
 }
diff --git a/stan/math/prim/functor/apply_scalar_ternary.hpp b/stan/math/prim/functor/apply_scalar_ternary.hpp
index 7876c72895d..e9dfcdab834 100644
--- a/stan/math/prim/functor/apply_scalar_ternary.hpp
+++ b/stan/math/prim/functor/apply_scalar_ternary.hpp
@@ -126,8 +126,7 @@ inline auto apply_scalar_ternary(const F& f, const T1& x, const T2& y,
 template <typename F, typename T1, typename T2, typename T3,
           require_all_std_vector_vt<is_container_or_var_matrix, T1, T2,
                                     T3>* = nullptr>
-inline auto apply_scalar_ternary(const F& f, const T1& x, const T2& y,
-                                 const T3& z) {
+inline auto apply_scalar_ternary(F&& f, T1&& x, T2&& y, T3&& z) {
   check_matching_sizes("Ternary function", "x", x, "y", y);
   check_matching_sizes("Ternary function", "y", y, "z", z);
   using T_return
@@ -159,10 +158,10 @@ inline auto apply_scalar_ternary(const F& f, const T1& x, const T2& y,
 template <typename F, typename T1, typename T2, typename T3,
           require_any_container_t<T1, T2>* = nullptr,
           require_stan_scalar_t<T3>* = nullptr>
-inline auto apply_scalar_ternary(const F& f, const T1& x, const T2& y,
-                                 const T3& z) {
+inline auto apply_scalar_ternary(F&& f, T1&& x, T2&& y,
+                                 T3&& z) {
   return apply_scalar_binary(
-      [f, z](const auto& a, const auto& b) { return f(a, b, z); }, x, y);
+      [f_ = std::forward<F>(f), z](auto&& a, auto&& b) { return f_(std::forward<decltype(a)>(a), std::forward<decltype(b)>(b), z); }, std::forward<T1>(x), std::forward<T2>(y));
 }
 
 /**
@@ -184,10 +183,10 @@ inline auto apply_scalar_ternary(const F& f, const T1& x, const T2& y,
 template <typename F, typename T1, typename T2, typename T3,
           require_all_container_t<T1, T3>* = nullptr,
           require_stan_scalar_t<T2>* = nullptr>
-inline auto apply_scalar_ternary(const F& f, const T1& x, const T2& y,
-                                 const T3& z) {
+inline auto apply_scalar_ternary(const F& f, T1&& x, T2&& y,
+                                 T3&& z) {
   return apply_scalar_binary(
-      [f, y](const auto& a, const auto& c) { return f(a, y, c); }, x, z);
+      [f, y](auto&& a, auto&& c) { return f(std::forward<decltype(a)>(a), y, std::forward<decltype(c)>(c)); }, std::forward<T1>(x), std::forward<T3>(z));
 }
 
 /**
@@ -209,10 +208,10 @@ inline auto apply_scalar_ternary(const F& f, const T1& x, const T2& y,
 template <typename F, typename T1, typename T2, typename T3,
           require_container_t<T3>* = nullptr,
           require_stan_scalar_t<T1>* = nullptr>
-inline auto apply_scalar_ternary(const F& f, const T1& x, const T2& y,
-                                 const T3& z) {
+inline auto apply_scalar_ternary(const F& f, T1&& x, T2&& y,
+                                 T3&& z) {
   return apply_scalar_binary(
-      [f, x](const auto& b, const auto& c) { return f(x, b, c); }, y, z);
+      [f, x](auto&& b, auto&& c) { return f(x, std::forward<decltype(b)>(b), std::forward<decltype(c)>(c)); }, std::forward<T2>(y), std::forward<T3>(z));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/functor/apply_scalar_unary.hpp b/stan/math/prim/functor/apply_scalar_unary.hpp
index 2cbcae179aa..2fae2be79f1 100644
--- a/stan/math/prim/functor/apply_scalar_unary.hpp
+++ b/stan/math/prim/functor/apply_scalar_unary.hpp
@@ -58,10 +58,13 @@ struct apply_scalar_unary<F, T, require_eigen_t<T>> {
    * @return Componentwise application of the function specified
    * by F to the specified matrix.
    */
-  static inline auto apply(const std::decay_t<T>& x) {
-    return x.unaryExpr([](auto&& x) {
-      return apply_scalar_unary<F, std::decay_t<decltype(x)>>::apply(x);
-    });
+  template <typename TT>
+  static inline auto apply(TT&& x) {
+    return make_holder([](auto&& xx) {
+      return std::forward<decltype(xx)>(xx).unaryExpr([](auto&& xxx) {
+        return apply_scalar_unary<F, std::decay_t<decltype(xxx)>>::apply(xxx);
+      });
+    }, std::forward<TT>(x));
   }
 
   /**
@@ -176,10 +179,15 @@ struct apply_scalar_unary<F, T, require_std_vector_t<T>> {
    * @return Elementwise application of F to the elements of the
    * container.
    */
-  static inline auto apply(const std::decay_t<T>& x) {
+  template <typename TT>
+  static inline auto apply(TT&& x) {
     return_t fx(x.size());
     for (size_t i = 0; i < x.size(); ++i) {
-      fx[i] = apply_scalar_unary<F, value_type_t<T>>::apply(x[i]);
+      if constexpr (std::is_rvalue_reference_v<TT&&>) {
+        fx[i] = apply_scalar_unary<F, value_type_t<TT>>::apply(std::move(x[i]));
+      } else {
+        fx[i] = apply_scalar_unary<F, value_type_t<TT>>::apply(x[i]);
+      }
     }
     return fx;
   }
diff --git a/stan/math/prim/functor/apply_vector_unary.hpp b/stan/math/prim/functor/apply_vector_unary.hpp
index 5787043a385..2472e77c7d7 100644
--- a/stan/math/prim/functor/apply_vector_unary.hpp
+++ b/stan/math/prim/functor/apply_vector_unary.hpp
@@ -42,15 +42,26 @@ struct apply_vector_unary<T, require_eigen_t<T>> {
    */
   template <typename F, typename T2 = T,
             require_t<is_eigen_matrix_base<plain_type_t<T2>>>* = nullptr>
-  static inline auto apply(const T& x, const F& f) {
-    return make_holder([](const auto& a) { return a.matrix().derived(); },
-                       f(x));
+  static inline auto apply(T2&& x, F&& f) {
+    if constexpr (is_eigen_array<decltype(f(x))>::value) {
+      return make_holder([](auto&& xx) {
+        return std::forward<decltype(xx)>(xx).matrix();
+      }, make_holder(std::forward<F>(f), std::forward<T2>(x)));
+    } else {
+      return make_holder(std::forward<F>(f), std::forward<T2>(x));
+    }
   }
 
   template <typename F, typename T2 = T,
             require_t<is_eigen_array<plain_type_t<T2>>>* = nullptr>
-  static inline auto apply(const T& x, const F& f) {
-    return make_holder([](const auto& a) { return a.array().derived(); }, f(x));
+  static inline auto apply(T2&& x, F&& f) {
+    if constexpr (is_eigen_array<decltype(f(x))>::value) {
+      return make_holder(std::forward<F>(f), std::forward<T2>(x));
+    } else {
+      return make_holder([](auto&& xx) {
+        return std::forward<decltype(xx)>(xx).array();
+      }, make_holder(std::forward<F>(f), std::forward<T2>(x)));
+    }
   }
 
   /**
@@ -67,14 +78,14 @@ struct apply_vector_unary<T, require_eigen_t<T>> {
    */
   template <typename F, typename T2 = T,
             require_t<is_eigen_matrix_base<plain_type_t<T2>>>* = nullptr>
-  static inline auto apply_no_holder(const T& x, const F& f) {
-    return f(x).matrix().derived();
+  static inline auto apply_no_holder(T2& x, F&& f) {
+    return std::forward<F>(f)(std::forward<T2>(x));
   }
 
   template <typename F, typename T2 = T,
             require_t<is_eigen_array<plain_type_t<T2>>>* = nullptr>
-  static inline auto apply_no_holder(const T& x, const F& f) {
-    return f(x).array().derived();
+  static inline auto apply_no_holder(T2&& x, F&& f) {
+    return std::forward<F>(f)(std::forward<T2>(x));
   }
 
   /**
@@ -88,9 +99,9 @@ struct apply_vector_unary<T, require_eigen_t<T>> {
    * @param f functor to apply to Eigen input.
    * @return scalar result of applying functor to input.
    */
-  template <typename F>
-  static inline auto reduce(const T& x, const F& f) {
-    return f(x);
+  template <typename T2, typename F>
+  static inline auto reduce(T2&& x, F&& f) {
+    return make_holder(std::forward<F>(f), std::forward<T2>(x));
   }
 };
 
@@ -138,9 +149,9 @@ struct apply_vector_unary<T, require_std_vector_vt<is_stan_scalar, T>> {
    * @return std::vector of containers with result of applying functor to
    *         input.
    */
-  template <typename F>
-  static inline auto apply_no_holder(const T& x, const F& f) {
-    return apply(x, f);
+  template <typename T2, typename F>
+  static inline auto apply_no_holder(T2&& x, F&& f) {
+    return apply(std::forward<T2>(x), std::forward<F>(f));
   }
 
   /**
@@ -153,9 +164,9 @@ struct apply_vector_unary<T, require_std_vector_vt<is_stan_scalar, T>> {
    * @param f functor to apply to std::vector input.
    * @return scalar result of applying functor to input vector.
    */
-  template <typename F>
-  static inline auto reduce(const T& x, const F& f) {
-    return apply_vector_unary<T_map>::reduce(as_column_vector_or_scalar(x), f);
+  template <typename T2, typename F>
+  static inline auto reduce(T2&& x, F&& f) {
+    return apply_vector_unary<T_map>::reduce(as_column_vector_or_scalar(std::forward<T2>(x)), std::forward<F>(f));
   }
 };
 
@@ -191,7 +202,7 @@ struct apply_vector_unary<
         = plain_type_t<decltype(apply_vector_unary<T_vt>::apply(x[0], f))>;
     std::vector<T_return> result(x.size());
     std::transform(x.begin(), x.end(), result.begin(), [&f](auto&& xx) {
-      return apply_vector_unary<T_vt>::apply_no_holder(xx, f);
+      return apply_vector_unary<T_vt>::apply(xx, f);
     });
     return result;
   }
diff --git a/stan/math/prim/prob/std_normal_log_qf.hpp b/stan/math/prim/prob/std_normal_log_qf.hpp
index 895b4997a0a..62c881674d1 100644
--- a/stan/math/prim/prob/std_normal_log_qf.hpp
+++ b/stan/math/prim/prob/std_normal_log_qf.hpp
@@ -150,8 +150,8 @@ template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
-inline auto std_normal_log_qf(const T& x) {
-  return apply_scalar_unary<std_normal_log_qf_fun, T>::apply(x);
+inline auto std_normal_log_qf(T&& x) {
+  return apply_scalar_unary<std_normal_log_qf_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/rev/fun/floor.hpp b/stan/math/rev/fun/floor.hpp
index bac9ab778ed..89a5fe76e4d 100644
--- a/stan/math/rev/fun/floor.hpp
+++ b/stan/math/rev/fun/floor.hpp
@@ -49,7 +49,7 @@ inline var floor(const var& a) { return var(std::floor(a.val())); }
 
 template <typename T, require_eigen_t<T>* = nullptr>
 inline auto floor(const var_value<T>& a) {
-  return var_value<T>(a.val().array().floor().matrix());
+  return var_value<T>(a.val().array().floor());
 }
 
 }  // namespace math
diff --git a/stan/math/rev/fun/log_softmax.hpp b/stan/math/rev/fun/log_softmax.hpp
index d41a567156b..3015bb12b3e 100644
--- a/stan/math/rev/fun/log_softmax.hpp
+++ b/stan/math/rev/fun/log_softmax.hpp
@@ -120,9 +120,9 @@ inline auto log_softmax(const T& x) {
  * @throw std::domain_error if the input size is 0
  */
 template <typename T, require_std_vector_st<is_var, T>* = nullptr>
-inline auto log_softmax(const T& x) {
-  return apply_vector_unary<T>::apply(
-      x, [](const auto& alpha) { return log_softmax(alpha); });
+inline auto log_softmax(T&& x) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [](const auto& alpha) { return log_softmax(alpha); });
 }
 
 }  // namespace math
diff --git a/stan/math/rev/fun/log_sum_exp.hpp b/stan/math/rev/fun/log_sum_exp.hpp
index 69299560616..b61e06be30e 100644
--- a/stan/math/rev/fun/log_sum_exp.hpp
+++ b/stan/math/rev/fun/log_sum_exp.hpp
@@ -99,9 +99,9 @@ inline var log_sum_exp(const T& x) {
  * @param x matrix
  */
 template <typename T, require_std_vector_st<is_var, T>* = nullptr>
-inline auto log_sum_exp(const T& x) {
-  return apply_vector_unary<T>::reduce(
-      x, [](const auto& v) { return log_sum_exp(v); });
+inline auto log_sum_exp(T&& x) {
+  return apply_vector_unary<std::decay_t<T>>::reduce(
+      std::forward<T>(x), [](const auto& v) { return log_sum_exp(v); });
 }
 
 }  // namespace math
diff --git a/stan/math/rev/fun/pow.hpp b/stan/math/rev/fun/pow.hpp
index d525e00a04b..a72b5f04226 100644
--- a/stan/math/rev/fun/pow.hpp
+++ b/stan/math/rev/fun/pow.hpp
@@ -287,9 +287,9 @@ inline auto pow(Scal1 base, const Mat1& exponent) {
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_not_matrix_st<is_var, T1, T2>* = nullptr,
           require_any_var_t<base_type_t<T1>, base_type_t<T2>>* = nullptr>
-inline auto pow(const T1& a, const T2& b) {
+inline auto pow(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](const auto& c, const auto& d) { return stan::math::pow(c, d); }, a, b);
+      [](auto&& c, auto&& d) { return stan::math::pow(std::forward<decltype(c)>(c), std::forward<decltype(d)>(d)); }, std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/rev/fun/sd.hpp b/stan/math/rev/fun/sd.hpp
index e3db2d1651f..f143930802e 100644
--- a/stan/math/rev/fun/sd.hpp
+++ b/stan/math/rev/fun/sd.hpp
@@ -94,8 +94,8 @@ var sd(const T& x) {
  * @throw domain error  size is not greater than zero.
  */
 template <typename T, require_std_vector_st<is_var, T>* = nullptr>
-auto sd(const T& m) {
-  return apply_vector_unary<T>::reduce(m, [](const auto& x) { return sd(x); });
+auto sd(T&& m) {
+  return apply_vector_unary<std::decay_t<T>>::reduce(std::forward<T>(m), [](const auto& x) { return sd(x); });
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/apply_scalar_unary.hpp b/stan/math/rev/functor/apply_scalar_unary.hpp
index d68bd344335..4213559b5db 100644
--- a/stan/math/rev/functor/apply_scalar_unary.hpp
+++ b/stan/math/rev/functor/apply_scalar_unary.hpp
@@ -44,7 +44,8 @@ struct apply_scalar_unary<F, T, require_var_matrix_t<T>> {
    * @param x Argument variable.
    * @return Function applied to the variable.
    */
-  static inline return_t apply(const T& x) { return F::fun(x); }
+  template <typename T2>
+  static inline return_t apply(T2&& x) { return F::fun(std::forward<T2>(x)); }
 };
 
 }  // namespace math
diff --git a/stan/math/rev/functor/apply_vector_unary.hpp b/stan/math/rev/functor/apply_vector_unary.hpp
index 01cad885a70..8c74c3dec5e 100644
--- a/stan/math/rev/functor/apply_vector_unary.hpp
+++ b/stan/math/rev/functor/apply_vector_unary.hpp
@@ -24,9 +24,9 @@ struct apply_vector_unary<T, require_var_matrix_t<T>> {
    * @param f functor to apply to Eigen input.
    * @return object with result of applying functor to input
    */
-  template <typename F>
-  static inline plain_type_t<T> apply(const T& x, const F& f) {
-    return f(x);
+  template <typename T2, typename F>
+  static inline plain_type_t<T> apply(T2&& x, F&& f) {
+    return std::forward<F>(f)(std::forward<T2>(x));
   }
 
   /**
@@ -39,9 +39,9 @@ struct apply_vector_unary<T, require_var_matrix_t<T>> {
    * @param f functor to apply to Eigen input.
    * @return object with result of applying functor to input
    */
-  template <typename F>
-  static inline plain_type_t<T> apply_no_holder(const T& x, const F& f) {
-    return f(x);
+  template <typename T2, typename F>
+  static inline plain_type_t<T> apply_no_holder(T2&& x, F&& f) {
+    return std::forward<F>(f)(std::forward<T2>(x));
   }
 
   /**
@@ -55,9 +55,9 @@ struct apply_vector_unary<T, require_var_matrix_t<T>> {
    * @param f functor to apply to input.
    * @return scalar result of applying functor to input.
    */
-  template <typename F>
-  static inline var reduce(const T& x, const F& f) {
-    return f(x);
+  template <typename T2, typename F>
+  static inline var reduce(T2& x, F&& f) {
+    return std::forward<F>(f)(std::forward<T2>(x));
   }
 };
 

From e40bd1eb54d709e95b9e31ffbd5dfa1f74a82d42 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Mon, 30 Jun 2025 17:12:21 -0400
Subject: [PATCH 03/31] [Jenkins] auto-formatting by clang-format version
 10.0.0-4ubuntu1

---
 stan/math/fwd/fun/log_softmax.hpp             | 56 ++++++++++---------
 stan/math/fwd/fun/pow.hpp                     |  6 +-
 .../constraint/cholesky_corr_constrain.hpp    |  8 ++-
 .../prim/constraint/cholesky_corr_free.hpp    |  4 +-
 .../constraint/cholesky_factor_constrain.hpp  | 12 ++--
 .../prim/constraint/cholesky_factor_free.hpp  |  4 +-
 .../prim/constraint/corr_matrix_constrain.hpp |  8 ++-
 .../math/prim/constraint/corr_matrix_free.hpp |  3 +-
 .../prim/constraint/cov_matrix_constrain.hpp  |  8 ++-
 .../constraint/cov_matrix_constrain_lkj.hpp   | 14 ++---
 stan/math/prim/constraint/cov_matrix_free.hpp |  3 +-
 .../prim/constraint/cov_matrix_free_lkj.hpp   |  4 +-
 .../offset_multiplier_constrain.hpp           |  9 +--
 .../constraint/offset_multiplier_free.hpp     | 28 ++++++----
 .../prim/constraint/ordered_constrain.hpp     |  7 ++-
 stan/math/prim/constraint/ordered_free.hpp    |  5 +-
 .../prim/constraint/positive_constrain.hpp    |  4 +-
 .../constraint/positive_ordered_constrain.hpp |  8 ++-
 .../prim/constraint/positive_ordered_free.hpp |  4 +-
 .../prim/constraint/simplex_constrain.hpp     |  7 ++-
 stan/math/prim/constraint/simplex_free.hpp    |  5 +-
 .../stochastic_column_constrain.hpp           |  8 ++-
 .../constraint/stochastic_column_free.hpp     |  4 +-
 .../constraint/stochastic_row_constrain.hpp   |  8 ++-
 .../prim/constraint/stochastic_row_free.hpp   |  4 +-
 .../prim/constraint/sum_to_zero_constrain.hpp |  8 ++-
 .../math/prim/constraint/sum_to_zero_free.hpp |  3 +-
 stan/math/prim/constraint/ub_constrain.hpp    |  7 ++-
 .../prim/constraint/unit_vector_constrain.hpp |  8 ++-
 .../math/prim/constraint/unit_vector_free.hpp |  3 +-
 stan/math/prim/fun/Phi.hpp                    |  3 +-
 stan/math/prim/fun/Phi_approx.hpp             |  3 +-
 stan/math/prim/fun/abs.hpp                    |  4 +-
 stan/math/prim/fun/acos.hpp                   |  4 +-
 stan/math/prim/fun/acosh.hpp                  |  6 +-
 stan/math/prim/fun/asin.hpp                   |  4 +-
 stan/math/prim/fun/asinh.hpp                  |  6 +-
 stan/math/prim/fun/atan.hpp                   |  4 +-
 stan/math/prim/fun/atan2.hpp                  |  2 +-
 stan/math/prim/fun/atanh.hpp                  |  6 +-
 stan/math/prim/fun/beta.hpp                   |  3 +-
 stan/math/prim/fun/cbrt.hpp                   |  3 +-
 stan/math/prim/fun/ceil.hpp                   |  4 +-
 stan/math/prim/fun/cos.hpp                    |  4 +-
 stan/math/prim/fun/cosh.hpp                   |  3 +-
 stan/math/prim/fun/digamma.hpp                |  3 +-
 stan/math/prim/fun/erf.hpp                    |  3 +-
 stan/math/prim/fun/erfc.hpp                   |  3 +-
 stan/math/prim/fun/exp2.hpp                   |  3 +-
 stan/math/prim/fun/expm1.hpp                  |  3 +-
 stan/math/prim/fun/fabs.hpp                   |  3 +-
 stan/math/prim/fun/fdim.hpp                   |  3 +-
 stan/math/prim/fun/floor.hpp                  |  3 +-
 stan/math/prim/fun/fmax.hpp                   |  3 +-
 stan/math/prim/fun/fmin.hpp                   |  3 +-
 stan/math/prim/fun/fmod.hpp                   |  3 +-
 stan/math/prim/fun/gamma_p.hpp                |  3 +-
 stan/math/prim/fun/inv.hpp                    |  3 +-
 stan/math/prim/fun/inv_Phi.hpp                |  3 +-
 stan/math/prim/fun/inv_cloglog.hpp            |  6 +-
 stan/math/prim/fun/inv_erfc.hpp               |  3 +-
 stan/math/prim/fun/inv_sqrt.hpp               |  3 +-
 stan/math/prim/fun/inv_square.hpp             |  3 +-
 stan/math/prim/fun/lambert_w.hpp              |  6 +-
 stan/math/prim/fun/lgamma.hpp                 |  3 +-
 stan/math/prim/fun/log10.hpp                  |  3 +-
 stan/math/prim/fun/log1m.hpp                  |  3 +-
 stan/math/prim/fun/log1m_exp.hpp              |  3 +-
 stan/math/prim/fun/log1p.hpp                  |  3 +-
 stan/math/prim/fun/log1p_exp.hpp              |  3 +-
 stan/math/prim/fun/log2.hpp                   |  3 +-
 stan/math/prim/fun/log_inv_logit.hpp          |  3 +-
 stan/math/prim/fun/log_softmax.hpp            |  3 +-
 stan/math/prim/fun/log_sum_exp.hpp            | 20 +++----
 stan/math/prim/fun/logit.hpp                  | 11 ++--
 stan/math/prim/fun/mean.hpp                   |  4 +-
 stan/math/prim/fun/minus.hpp                  |  6 +-
 stan/math/prim/fun/pow.hpp                    |  5 +-
 stan/math/prim/fun/rank.hpp                   |  9 +--
 stan/math/prim/fun/round.hpp                  |  3 +-
 stan/math/prim/fun/sd.hpp                     | 12 ++--
 stan/math/prim/fun/select.hpp                 | 14 ++---
 stan/math/prim/fun/sign.hpp                   |  3 +-
 stan/math/prim/fun/sinh.hpp                   |  3 +-
 stan/math/prim/fun/sqrt.hpp                   |  3 +-
 stan/math/prim/fun/square.hpp                 |  3 +-
 stan/math/prim/fun/step.hpp                   |  3 +-
 stan/math/prim/fun/tan.hpp                    |  4 +-
 stan/math/prim/fun/tanh.hpp                   |  3 +-
 stan/math/prim/fun/tgamma.hpp                 |  3 +-
 stan/math/prim/fun/to_int.hpp                 |  3 +-
 stan/math/prim/fun/trigamma.hpp               |  3 +-
 stan/math/prim/fun/trunc.hpp                  |  3 +-
 .../math/prim/functor/apply_scalar_binary.hpp |  8 ++-
 .../prim/functor/apply_scalar_ternary.hpp     | 25 ++++++---
 stan/math/prim/functor/apply_scalar_unary.hpp | 13 +++--
 stan/math/prim/functor/apply_vector_unary.hpp | 15 ++---
 stan/math/prim/prob/std_normal_log_qf.hpp     |  3 +-
 stan/math/rev/fun/pow.hpp                     |  6 +-
 stan/math/rev/fun/sd.hpp                      |  3 +-
 stan/math/rev/functor/apply_scalar_unary.hpp  |  4 +-
 101 files changed, 363 insertions(+), 241 deletions(-)

diff --git a/stan/math/fwd/fun/log_softmax.hpp b/stan/math/fwd/fun/log_softmax.hpp
index 48e7be01f82..8e52ebb0fdd 100644
--- a/stan/math/fwd/fun/log_softmax.hpp
+++ b/stan/math/fwd/fun/log_softmax.hpp
@@ -20,35 +20,37 @@ namespace math {
  */
 template <typename T, require_vector_st<is_fvar, T>* = nullptr>
 inline auto log_softmax(T&& x) {
-  return apply_vector_unary<T>::apply(std::forward<T>(x), [&](const auto& alpha) {
-    using T_alpha = decltype(alpha);
-    using T_fvar = value_type_t<T_alpha>;
-    using T_fvar_inner = typename T_fvar::Scalar;
-
-    const Eigen::Ref<const plain_type_t<T_alpha>>& alpha_ref = alpha;
-    Eigen::Matrix<T_fvar_inner, -1, 1> alpha_t = alpha_ref.val();
-    Eigen::Matrix<T_fvar_inner, -1, 1> softmax_alpha_t = softmax(alpha_t);
-
-    Eigen::Matrix<T_fvar, -1, 1> log_softmax_alpha(alpha.size());
-    log_softmax_alpha.val() = log_softmax(alpha_t);
-    log_softmax_alpha.d().setZero();
-
-    for (int m = 0; m < alpha.size(); ++m) {
-      T_fvar_inner negative_alpha_m_d_times_softmax_alpha_t_m
-          = -alpha_ref.coeff(m).d_ * softmax_alpha_t(m);
-      for (int k = 0; k < alpha.size(); ++k) {
-        if (m == k) {
-          log_softmax_alpha(k).d_
-              += alpha_ref.coeff(m).d_
-                 + negative_alpha_m_d_times_softmax_alpha_t_m;
-        } else {
-          log_softmax_alpha(k).d_ += negative_alpha_m_d_times_softmax_alpha_t_m;
+  return apply_vector_unary<T>::apply(
+      std::forward<T>(x), [&](const auto& alpha) {
+        using T_alpha = decltype(alpha);
+        using T_fvar = value_type_t<T_alpha>;
+        using T_fvar_inner = typename T_fvar::Scalar;
+
+        const Eigen::Ref<const plain_type_t<T_alpha>>& alpha_ref = alpha;
+        Eigen::Matrix<T_fvar_inner, -1, 1> alpha_t = alpha_ref.val();
+        Eigen::Matrix<T_fvar_inner, -1, 1> softmax_alpha_t = softmax(alpha_t);
+
+        Eigen::Matrix<T_fvar, -1, 1> log_softmax_alpha(alpha.size());
+        log_softmax_alpha.val() = log_softmax(alpha_t);
+        log_softmax_alpha.d().setZero();
+
+        for (int m = 0; m < alpha.size(); ++m) {
+          T_fvar_inner negative_alpha_m_d_times_softmax_alpha_t_m
+              = -alpha_ref.coeff(m).d_ * softmax_alpha_t(m);
+          for (int k = 0; k < alpha.size(); ++k) {
+            if (m == k) {
+              log_softmax_alpha(k).d_
+                  += alpha_ref.coeff(m).d_
+                     + negative_alpha_m_d_times_softmax_alpha_t_m;
+            } else {
+              log_softmax_alpha(k).d_
+                  += negative_alpha_m_d_times_softmax_alpha_t_m;
+            }
+          }
         }
-      }
-    }
 
-    return log_softmax_alpha;
-  });
+        return log_softmax_alpha;
+      });
 }
 
 }  // namespace math
diff --git a/stan/math/fwd/fun/pow.hpp b/stan/math/fwd/fun/pow.hpp
index 2a29557dad5..21a0bf36380 100644
--- a/stan/math/fwd/fun/pow.hpp
+++ b/stan/math/fwd/fun/pow.hpp
@@ -75,7 +75,11 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_any_fvar_t<base_type_t<T1>, base_type_t<T2>>* = nullptr>
 inline auto pow(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](auto&& c, auto&& d) { return stan::math::pow(std::forward<decltype(c)>(c), std::forward<decltype(d)>(d)); }, std::forward<T1>(a), std::forward<T2>(b));
+      [](auto&& c, auto&& d) {
+        return stan::math::pow(std::forward<decltype(c)>(c),
+                               std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/cholesky_corr_constrain.hpp b/stan/math/prim/constraint/cholesky_corr_constrain.hpp
index 7e868080ebd..63cd1b22271 100644
--- a/stan/math/prim/constraint/cholesky_corr_constrain.hpp
+++ b/stan/math/prim/constraint/cholesky_corr_constrain.hpp
@@ -89,7 +89,9 @@ cholesky_corr_constrain(const EigVec& y, int K, Lp& lp) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cholesky_corr_constrain(T&& y, int K) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(y), [K](auto&& v) { return cholesky_corr_constrain(std::forward<decltype(v)>(v), K); });
+      std::forward<T>(y), [K](auto&& v) {
+        return cholesky_corr_constrain(std::forward<decltype(v)>(v), K);
+      });
 }
 
 /**
@@ -109,7 +111,9 @@ template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto cholesky_corr_constrain(T&& y, int K, Lp& lp) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(y), [&lp, K](auto&& v) { return cholesky_corr_constrain(std::forward<decltype(v)>(v), K, lp); });
+      std::forward<T>(y), [&lp, K](auto&& v) {
+        return cholesky_corr_constrain(std::forward<decltype(v)>(v), K, lp);
+      });
 }
 
 /**
diff --git a/stan/math/prim/constraint/cholesky_corr_free.hpp b/stan/math/prim/constraint/cholesky_corr_free.hpp
index 40fde2cd559..daba71ac14d 100644
--- a/stan/math/prim/constraint/cholesky_corr_free.hpp
+++ b/stan/math/prim/constraint/cholesky_corr_free.hpp
@@ -44,7 +44,9 @@ inline auto cholesky_corr_free(const T& x) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cholesky_corr_free(T&& x) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(x), [](auto&& v) { return cholesky_corr_free(std::forward<decltype(v)>(v)); });
+      std::forward<T>(x), [](auto&& v) {
+        return cholesky_corr_free(std::forward<decltype(v)>(v));
+      });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/cholesky_factor_constrain.hpp b/stan/math/prim/constraint/cholesky_factor_constrain.hpp
index 1ec88c90c25..6a273e88d94 100644
--- a/stan/math/prim/constraint/cholesky_factor_constrain.hpp
+++ b/stan/math/prim/constraint/cholesky_factor_constrain.hpp
@@ -103,7 +103,9 @@ cholesky_factor_constrain(const T& x, int M, int N, Lp& lp) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cholesky_factor_constrain(T&& x, int M, int N) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(x), [M, N](auto&& v) { return cholesky_factor_constrain(std::forward<decltype(v)>(v), M, N); });
+      std::forward<T>(x), [M, N](auto&& v) {
+        return cholesky_factor_constrain(std::forward<decltype(v)>(v), M, N);
+      });
 }
 
 /**
@@ -126,9 +128,11 @@ inline auto cholesky_factor_constrain(T&& x, int M, int N) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto cholesky_factor_constrain(T&& x, int M, int N, Lp& lp) {
-  return apply_vector_unary<std::decay_t<T>>::apply(std::forward<T>(x), [&lp, M, N](auto&& v) {
-    return cholesky_factor_constrain(std::forward<decltype(v)>(v), M, N, lp);
-  });
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [&lp, M, N](auto&& v) {
+        return cholesky_factor_constrain(std::forward<decltype(v)>(v), M, N,
+                                         lp);
+      });
 }
 
 /**
diff --git a/stan/math/prim/constraint/cholesky_factor_free.hpp b/stan/math/prim/constraint/cholesky_factor_free.hpp
index b4827a8131a..affe6d32d04 100644
--- a/stan/math/prim/constraint/cholesky_factor_free.hpp
+++ b/stan/math/prim/constraint/cholesky_factor_free.hpp
@@ -58,7 +58,9 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cholesky_factor_free(
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cholesky_factor_free(T&& x) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(x), [](auto&& v) { return cholesky_factor_free(std::forward<decltype(v)>(v)); });
+      std::forward<T>(x), [](auto&& v) {
+        return cholesky_factor_free(std::forward<decltype(v)>(v));
+      });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/corr_matrix_constrain.hpp b/stan/math/prim/constraint/corr_matrix_constrain.hpp
index 4c44f60b2cd..1df645f7ff3 100644
--- a/stan/math/prim/constraint/corr_matrix_constrain.hpp
+++ b/stan/math/prim/constraint/corr_matrix_constrain.hpp
@@ -93,7 +93,9 @@ corr_matrix_constrain(T&& x, Eigen::Index k, Lp& lp) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto corr_matrix_constrain(T&& y, int K) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(y), [K](auto&& v) { return corr_matrix_constrain(std::forward<decltype(v)>(v), K); });
+      std::forward<T>(y), [K](auto&& v) {
+        return corr_matrix_constrain(std::forward<decltype(v)>(v), K);
+      });
 }
 
 /**
@@ -116,7 +118,9 @@ template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto corr_matrix_constrain(T&& y, int K, Lp& lp) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(y), [&lp, K](auto&& v) { return corr_matrix_constrain(std::forward<decltype(v)>(v), K, lp); });
+      std::forward<T>(y), [&lp, K](auto&& v) {
+        return corr_matrix_constrain(std::forward<decltype(v)>(v), K, lp);
+      });
 }
 
 /**
diff --git a/stan/math/prim/constraint/corr_matrix_free.hpp b/stan/math/prim/constraint/corr_matrix_free.hpp
index 76f46f11c7e..b482e88d9f8 100644
--- a/stan/math/prim/constraint/corr_matrix_free.hpp
+++ b/stan/math/prim/constraint/corr_matrix_free.hpp
@@ -62,7 +62,8 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> corr_matrix_free(const T& y) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto corr_matrix_free(T&& x) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(x), [](auto&& v) { return corr_matrix_free(std::forward<decltype(v)>(v)); });
+      std::forward<T>(x),
+      [](auto&& v) { return corr_matrix_free(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/cov_matrix_constrain.hpp b/stan/math/prim/constraint/cov_matrix_constrain.hpp
index 26bc919e29f..785016872ef 100644
--- a/stan/math/prim/constraint/cov_matrix_constrain.hpp
+++ b/stan/math/prim/constraint/cov_matrix_constrain.hpp
@@ -104,7 +104,9 @@ cov_matrix_constrain(T&& x, Eigen::Index K, Lp& lp) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cov_matrix_constrain(T&& x, Eigen::Index K) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(x), [K](auto&& v) { return cov_matrix_constrain(std::forward<decltype(v)>(v), K); });
+      std::forward<T>(x), [K](auto&& v) {
+        return cov_matrix_constrain(std::forward<decltype(v)>(v), K);
+      });
 }
 
 /**
@@ -126,7 +128,9 @@ template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto cov_matrix_constrain(T&& x, Eigen::Index K, Lp& lp) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(x), [&lp, K](auto&& v) { return cov_matrix_constrain(std::forward<decltype(v)>(v), K, lp); });
+      std::forward<T>(x), [&lp, K](auto&& v) {
+        return cov_matrix_constrain(std::forward<decltype(v)>(v), K, lp);
+      });
 }
 
 /**
diff --git a/stan/math/prim/constraint/cov_matrix_constrain_lkj.hpp b/stan/math/prim/constraint/cov_matrix_constrain_lkj.hpp
index 825a98ddc3c..9e630a91b39 100644
--- a/stan/math/prim/constraint/cov_matrix_constrain_lkj.hpp
+++ b/stan/math/prim/constraint/cov_matrix_constrain_lkj.hpp
@@ -84,8 +84,7 @@ cov_matrix_constrain_lkj(T&& x, size_t k, return_type_t<T>& lp) {
  * correlations and deviations.
  */
 template <bool Jacobian, typename T, require_not_std_vector_t<T>* = nullptr>
-inline auto cov_matrix_constrain_lkj(T&& x, size_t k,
-                                     return_type_t<T>& lp) {
+inline auto cov_matrix_constrain_lkj(T&& x, size_t k, return_type_t<T>& lp) {
   if constexpr (Jacobian) {
     return cov_matrix_constrain_lkj(std::forward<T>(x), k, lp);
   } else {
@@ -114,11 +113,12 @@ inline auto cov_matrix_constrain_lkj(T&& x, size_t k,
  * correlations and deviations.
  */
 template <bool Jacobian, typename T, require_std_vector_t<T>* = nullptr>
-inline auto cov_matrix_constrain_lkj(T&& x, size_t k,
-                                     return_type_t<T>& lp) {
-  return apply_vector_unary<std::decay_t<T>>::apply(std::forward<T>(x), [&lp, k](auto&& v) {
-    return cov_matrix_constrain_lkj<Jacobian>(std::forward<decltype(v)>(v), k, lp);
-  });
+inline auto cov_matrix_constrain_lkj(T&& x, size_t k, return_type_t<T>& lp) {
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x), [&lp, k](auto&& v) {
+        return cov_matrix_constrain_lkj<Jacobian>(std::forward<decltype(v)>(v),
+                                                  k, lp);
+      });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/cov_matrix_free.hpp b/stan/math/prim/constraint/cov_matrix_free.hpp
index 04c5f388bec..310bf897b14 100644
--- a/stan/math/prim/constraint/cov_matrix_free.hpp
+++ b/stan/math/prim/constraint/cov_matrix_free.hpp
@@ -68,7 +68,8 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cov_matrix_free(T&& y) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cov_matrix_free(T&& x) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(x), [](auto&& v) { return cov_matrix_free(std::forward<decltype(v)>(v)); });
+      std::forward<T>(x),
+      [](auto&& v) { return cov_matrix_free(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/cov_matrix_free_lkj.hpp b/stan/math/prim/constraint/cov_matrix_free_lkj.hpp
index f77e05bf1c8..d547261b814 100644
--- a/stan/math/prim/constraint/cov_matrix_free_lkj.hpp
+++ b/stan/math/prim/constraint/cov_matrix_free_lkj.hpp
@@ -59,7 +59,9 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cov_matrix_free_lkj(
 template <typename T, require_std_vector_t<T>* = nullptr>
 auto cov_matrix_free_lkj(T&& x) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(x), [](auto&& v) { return cov_matrix_free_lkj(std::forward<decltype(v)>(v)); });
+      std::forward<T>(x), [](auto&& v) {
+        return cov_matrix_free_lkj(std::forward<decltype(v)>(v));
+      });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/offset_multiplier_constrain.hpp b/stan/math/prim/constraint/offset_multiplier_constrain.hpp
index ca781b76e25..640110f56d3 100644
--- a/stan/math/prim/constraint/offset_multiplier_constrain.hpp
+++ b/stan/math/prim/constraint/offset_multiplier_constrain.hpp
@@ -303,12 +303,13 @@ inline auto offset_multiplier_constrain(const std::vector<T>& x,
  */
 template <bool Jacobian, typename T, typename M, typename S, typename Lp,
           require_convertible_t<return_type_t<T, M, S>, Lp>* = nullptr>
-inline auto offset_multiplier_constrain(T&& x, M&& mu, S&& sigma,
-                                        Lp& lp) {
+inline auto offset_multiplier_constrain(T&& x, M&& mu, S&& sigma, Lp& lp) {
   if constexpr (Jacobian) {
-    return offset_multiplier_constrain(std::forward<T>(x), std::forward<M>(mu), std::forward<S>(sigma), lp);
+    return offset_multiplier_constrain(std::forward<T>(x), std::forward<M>(mu),
+                                       std::forward<S>(sigma), lp);
   } else {
-    return offset_multiplier_constrain(std::forward<T>(x), std::forward<M>(mu), std::forward<S>(sigma));
+    return offset_multiplier_constrain(std::forward<T>(x), std::forward<M>(mu),
+                                       std::forward<S>(sigma));
   }
 }
 
diff --git a/stan/math/prim/constraint/offset_multiplier_free.hpp b/stan/math/prim/constraint/offset_multiplier_free.hpp
index f4cb5153330..e61c1046f4a 100644
--- a/stan/math/prim/constraint/offset_multiplier_free.hpp
+++ b/stan/math/prim/constraint/offset_multiplier_free.hpp
@@ -39,7 +39,8 @@ namespace math {
  * @throw std::domain_error if mu is not finite
  * @throw std::invalid_argument if non-scalar arguments don't match in size
  */
-template <typename T, typename M, typename S, require_all_not_std_vector_t<T, M, S>* = nullptr,
+template <typename T, typename M, typename S,
+          require_all_not_std_vector_t<T, M, S>* = nullptr,
           require_all_not_st_var<T, M, S>* = nullptr>
 inline auto offset_multiplier_free(T&& y, M&& mu, S&& sigma) {
   auto&& mu_ref = to_ref(std::forward<M>(mu));
@@ -57,16 +58,18 @@ inline auto offset_multiplier_free(T&& y, M&& mu, S&& sigma) {
   check_finite("offset_multiplier_constrain", "offset", value_of(mu_ref));
   check_positive_finite("offset_multiplier_constrain", "multiplier",
                         value_of(sigma_ref));
-  return stan::math::eval(divide(subtract(std::forward<T>(y), std::forward<M>(mu_ref)), std::forward<S>(sigma_ref)));
+  return stan::math::eval(
+      divide(subtract(std::forward<T>(y), std::forward<M>(mu_ref)),
+             std::forward<S>(sigma_ref)));
 }
 
 /**
  * Overload for array of x and non-array mu and sigma
  */
-template <typename T, typename M, typename S, require_std_vector_t<T>* = nullptr,
+template <typename T, typename M, typename S,
+          require_std_vector_t<T>* = nullptr,
           require_all_not_std_vector_t<M, S>* = nullptr>
-inline auto offset_multiplier_free(T&& x, M&& mu,
-                                   S&& sigma) {
+inline auto offset_multiplier_free(T&& x, M&& mu, S&& sigma) {
   std::vector<plain_type_t<decltype(offset_multiplier_free(x[0], mu, sigma))>>
       ret;
   ret.reserve(x.size());
@@ -81,10 +84,10 @@ inline auto offset_multiplier_free(T&& x, M&& mu,
 /**
  * Overload for array of x and sigma and non-array mu
  */
-template <typename T, typename M, typename S, require_all_std_vector_t<T, S>* = nullptr,
+template <typename T, typename M, typename S,
+          require_all_std_vector_t<T, S>* = nullptr,
           require_not_std_vector_t<M>* = nullptr>
-inline auto offset_multiplier_free(T&& x, const M& mu,
-                                   S&& sigma) {
+inline auto offset_multiplier_free(T&& x, const M& mu, S&& sigma) {
   check_matching_dims("offset_multiplier_free", "x", x, "sigma", sigma);
   std::vector<
       plain_type_t<decltype(offset_multiplier_free(x[0], mu, sigma[0]))>>
@@ -100,10 +103,10 @@ inline auto offset_multiplier_free(T&& x, const M& mu,
 /**
  * Overload for array of x and mu and non-array sigma
  */
-template <typename T, typename M, typename S, require_all_std_vector_t<T, M>* = nullptr,
+template <typename T, typename M, typename S,
+          require_all_std_vector_t<T, M>* = nullptr,
           require_not_std_vector_t<S>* = nullptr>
-inline auto offset_multiplier_free(T&& x,
-                                   M&& mu, const S& sigma) {
+inline auto offset_multiplier_free(T&& x, M&& mu, const S& sigma) {
   check_matching_dims("offset_multiplier_free", "x", x, "mu", mu);
   std::vector<
       plain_type_t<decltype(offset_multiplier_free(x[0], mu[0], sigma))>>
@@ -119,7 +122,8 @@ inline auto offset_multiplier_free(T&& x,
 /**
  * Overload for array of x, mu, and sigma
  */
-template <typename T, typename M, typename S, require_all_std_vector_t<T, M, S>* = nullptr>
+template <typename T, typename M, typename S,
+          require_all_std_vector_t<T, M, S>* = nullptr>
 inline auto offset_multiplier_free(T&& x, M&& mu, S&& sigma) {
   check_matching_dims("offset_multiplier_free", "x", x, "mu", mu);
   check_matching_dims("offset_multiplier_free", "x", x, "sigma", sigma);
diff --git a/stan/math/prim/constraint/ordered_constrain.hpp b/stan/math/prim/constraint/ordered_constrain.hpp
index 4f10137a766..e2a2280d842 100644
--- a/stan/math/prim/constraint/ordered_constrain.hpp
+++ b/stan/math/prim/constraint/ordered_constrain.hpp
@@ -78,7 +78,8 @@ inline auto ordered_constrain(EigVec&& x, Lp& lp) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto ordered_constrain(T&& x) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(x), [](auto&& v) { return ordered_constrain(std::forward<decltype(v)>(v)); });
+      std::forward<T>(x),
+      [](auto&& v) { return ordered_constrain(std::forward<decltype(v)>(v)); });
 }
 
 /**
@@ -100,7 +101,9 @@ template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto ordered_constrain(T&& x, Lp& lp) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(x), [&lp](auto&& v) { return ordered_constrain(std::forward<decltype(v)>(v), lp); });
+      std::forward<T>(x), [&lp](auto&& v) {
+        return ordered_constrain(std::forward<decltype(v)>(v), lp);
+      });
 }
 
 /**
diff --git a/stan/math/prim/constraint/ordered_free.hpp b/stan/math/prim/constraint/ordered_free.hpp
index 43354174e39..609d8a8f9f9 100644
--- a/stan/math/prim/constraint/ordered_free.hpp
+++ b/stan/math/prim/constraint/ordered_free.hpp
@@ -50,8 +50,9 @@ plain_type_t<EigVec> ordered_free(const EigVec& y) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto ordered_free(T&& x) {
-  return apply_vector_unary<std::decay_t<T>>::apply(std::forward<T>(x),
-                                      [](auto&& v) { return ordered_free(std::forward<decltype(v)>(v)); });
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x),
+      [](auto&& v) { return ordered_free(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/positive_constrain.hpp b/stan/math/prim/constraint/positive_constrain.hpp
index 35602b449ee..193b9721890 100644
--- a/stan/math/prim/constraint/positive_constrain.hpp
+++ b/stan/math/prim/constraint/positive_constrain.hpp
@@ -97,7 +97,9 @@ template <bool Jacobian, typename T, typename Lp,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto positive_constrain(T&& x, Lp& lp) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(x), [&lp](auto&& v) { return positive_constrain<Jacobian>(std::forward<decltype(v)>(v), lp); });
+      std::forward<T>(x), [&lp](auto&& v) {
+        return positive_constrain<Jacobian>(std::forward<decltype(v)>(v), lp);
+      });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/positive_ordered_constrain.hpp b/stan/math/prim/constraint/positive_ordered_constrain.hpp
index 172bd0ed8e0..608da90af22 100644
--- a/stan/math/prim/constraint/positive_ordered_constrain.hpp
+++ b/stan/math/prim/constraint/positive_ordered_constrain.hpp
@@ -72,7 +72,9 @@ inline auto positive_ordered_constrain(Vec&& x, Lp& lp) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto positive_ordered_constrain(T&& x) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(x), [](auto&& v) { return positive_ordered_constrain(std::forward<decltype(v)>(v)); });
+      std::forward<T>(x), [](auto&& v) {
+        return positive_ordered_constrain(std::forward<decltype(v)>(v));
+      });
 }
 
 /**
@@ -93,7 +95,9 @@ template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto positive_ordered_constrain(T&& x, Lp& lp) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(x), [&lp](auto&& v) { return positive_ordered_constrain(std::forward<decltype(v)>(v), lp); });
+      std::forward<T>(x), [&lp](auto&& v) {
+        return positive_ordered_constrain(std::forward<decltype(v)>(v), lp);
+      });
 }
 
 /**
diff --git a/stan/math/prim/constraint/positive_ordered_free.hpp b/stan/math/prim/constraint/positive_ordered_free.hpp
index b3adacf604f..3602f405810 100644
--- a/stan/math/prim/constraint/positive_ordered_free.hpp
+++ b/stan/math/prim/constraint/positive_ordered_free.hpp
@@ -51,7 +51,9 @@ inline auto positive_ordered_free(const EigVec& y) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto positive_ordered_free(T&& x) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(x), [](auto&& v) { return positive_ordered_free(std::forward<decltype(v)>(v)); });
+      std::forward<T>(x), [](auto&& v) {
+        return positive_ordered_free(std::forward<decltype(v)>(v));
+      });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/simplex_constrain.hpp b/stan/math/prim/constraint/simplex_constrain.hpp
index 0bcdd1afda9..0f9c9fc4af4 100644
--- a/stan/math/prim/constraint/simplex_constrain.hpp
+++ b/stan/math/prim/constraint/simplex_constrain.hpp
@@ -147,7 +147,8 @@ inline plain_type_t<Vec> simplex_constrain(const Vec& y, Lp& lp) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto simplex_constrain(T&& y) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(y), [](auto&& v) { return simplex_constrain(std::forward<decltype(v)>(v)); });
+      std::forward<T>(y),
+      [](auto&& v) { return simplex_constrain(std::forward<decltype(v)>(v)); });
 }
 
 /**
@@ -167,7 +168,9 @@ template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto simplex_constrain(T&& y, Lp& lp) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(y), [&lp](auto&& v) { return simplex_constrain(std::forward<decltype(v)>(v), lp); });
+      std::forward<T>(y), [&lp](auto&& v) {
+        return simplex_constrain(std::forward<decltype(v)>(v), lp);
+      });
 }
 
 /**
diff --git a/stan/math/prim/constraint/simplex_free.hpp b/stan/math/prim/constraint/simplex_free.hpp
index 3b1d242b5cd..2b2bd9ae68c 100644
--- a/stan/math/prim/constraint/simplex_free.hpp
+++ b/stan/math/prim/constraint/simplex_free.hpp
@@ -54,8 +54,9 @@ inline plain_type_t<Vec> simplex_free(const Vec& x) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto simplex_free(T&& x) {
-  return apply_vector_unary<std::decay_t<T>>::apply(std::forward<T>(x),
-                                      [](auto&& v) { return simplex_free(std::forward<decltype(v)>(v)); });
+  return apply_vector_unary<std::decay_t<T>>::apply(
+      std::forward<T>(x),
+      [](auto&& v) { return simplex_free(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/stochastic_column_constrain.hpp b/stan/math/prim/constraint/stochastic_column_constrain.hpp
index 84a442834b2..104877f0dbf 100644
--- a/stan/math/prim/constraint/stochastic_column_constrain.hpp
+++ b/stan/math/prim/constraint/stochastic_column_constrain.hpp
@@ -73,7 +73,9 @@ inline plain_type_t<Mat> stochastic_column_constrain(const Mat& y, Lp& lp) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto stochastic_column_constrain(T&& y) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(y), [](auto&& v) { return stochastic_column_constrain(std::forward<decltype(v)>(v)); });
+      std::forward<T>(y), [](auto&& v) {
+        return stochastic_column_constrain(std::forward<decltype(v)>(v));
+      });
 }
 
 /**
@@ -94,7 +96,9 @@ template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto stochastic_column_constrain(T&& y, Lp& lp) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(y), [&lp](auto&& v) { return stochastic_column_constrain(std::forward<decltype(v)>(v), lp); });
+      std::forward<T>(y), [&lp](auto&& v) {
+        return stochastic_column_constrain(std::forward<decltype(v)>(v), lp);
+      });
 }
 
 /**
diff --git a/stan/math/prim/constraint/stochastic_column_free.hpp b/stan/math/prim/constraint/stochastic_column_free.hpp
index f7e64aacd77..c1cd90ece06 100644
--- a/stan/math/prim/constraint/stochastic_column_free.hpp
+++ b/stan/math/prim/constraint/stochastic_column_free.hpp
@@ -38,7 +38,9 @@ inline plain_type_t<Mat> stochastic_column_free(Mat&& y) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto stochastic_column_free(T&& y) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(y), [](auto&& v) { return stochastic_column_free(std::forward<decltype(v)>(v)); });
+      std::forward<T>(y), [](auto&& v) {
+        return stochastic_column_free(std::forward<decltype(v)>(v));
+      });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/stochastic_row_constrain.hpp b/stan/math/prim/constraint/stochastic_row_constrain.hpp
index e14a23121d9..0b0c1fa2723 100644
--- a/stan/math/prim/constraint/stochastic_row_constrain.hpp
+++ b/stan/math/prim/constraint/stochastic_row_constrain.hpp
@@ -70,7 +70,9 @@ inline plain_type_t<Mat> stochastic_row_constrain(Mat&& y, Lp& lp) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto stochastic_row_constrain(T&& y) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(y), [](auto&& v) { return stochastic_row_constrain(std::forward<decltype(v)>(v)); });
+      std::forward<T>(y), [](auto&& v) {
+        return stochastic_row_constrain(std::forward<decltype(v)>(v));
+      });
 }
 
 /**
@@ -90,7 +92,9 @@ template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto stochastic_row_constrain(T&& y, Lp& lp) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(y), [&lp](auto&& v) { return stochastic_row_constrain(std::forward<decltype(v)>(v), lp); });
+      std::forward<T>(y), [&lp](auto&& v) {
+        return stochastic_row_constrain(std::forward<decltype(v)>(v), lp);
+      });
 }
 
 /**
diff --git a/stan/math/prim/constraint/stochastic_row_free.hpp b/stan/math/prim/constraint/stochastic_row_free.hpp
index c9122aba00f..068d287435d 100644
--- a/stan/math/prim/constraint/stochastic_row_free.hpp
+++ b/stan/math/prim/constraint/stochastic_row_free.hpp
@@ -37,7 +37,9 @@ inline plain_type_t<Mat> stochastic_row_free(Mat&& y) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto stochastic_row_free(T&& y) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(y), [](auto&& v) { return stochastic_row_free(std::forward<decltype(v)>(v)); });
+      std::forward<T>(y), [](auto&& v) {
+        return stochastic_row_free(std::forward<decltype(v)>(v));
+      });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/sum_to_zero_constrain.hpp b/stan/math/prim/constraint/sum_to_zero_constrain.hpp
index 8b1c4798d91..f928f14e67e 100644
--- a/stan/math/prim/constraint/sum_to_zero_constrain.hpp
+++ b/stan/math/prim/constraint/sum_to_zero_constrain.hpp
@@ -140,7 +140,9 @@ inline plain_type_t<T> sum_to_zero_constrain(T&& y, Lp& lp) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto sum_to_zero_constrain(T&& y) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(y), [](auto&& v) { return sum_to_zero_constrain(std::forward<decltype(v)>(v)); });
+      std::forward<T>(y), [](auto&& v) {
+        return sum_to_zero_constrain(std::forward<decltype(v)>(v));
+      });
 }
 
 /**
@@ -159,7 +161,9 @@ template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto sum_to_zero_constrain(T&& y, Lp& lp) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(y), [&lp](auto&& v) { return sum_to_zero_constrain(std::forward<decltype(v)>(v), lp); });
+      std::forward<T>(y), [&lp](auto&& v) {
+        return sum_to_zero_constrain(std::forward<decltype(v)>(v), lp);
+      });
 }
 
 /**
diff --git a/stan/math/prim/constraint/sum_to_zero_free.hpp b/stan/math/prim/constraint/sum_to_zero_free.hpp
index 936a6f37204..85a679cad2d 100644
--- a/stan/math/prim/constraint/sum_to_zero_free.hpp
+++ b/stan/math/prim/constraint/sum_to_zero_free.hpp
@@ -117,7 +117,8 @@ inline plain_type_t<Mat> sum_to_zero_free(const Mat& z) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto sum_to_zero_free(T&& z) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(z), [](auto&& v) { return sum_to_zero_free(std::forward<decltype(v)>(v)); });
+      std::forward<T>(z),
+      [](auto&& v) { return sum_to_zero_free(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/ub_constrain.hpp b/stan/math/prim/constraint/ub_constrain.hpp
index 749104b164f..bef8aee2324 100644
--- a/stan/math/prim/constraint/ub_constrain.hpp
+++ b/stan/math/prim/constraint/ub_constrain.hpp
@@ -89,7 +89,8 @@ template <typename T, typename U, require_eigen_t<T>* = nullptr,
           require_stan_scalar_t<U>* = nullptr,
           require_all_not_st_var<T, U>* = nullptr>
 inline auto ub_constrain(T&& x, const U& ub) {
-  return eval(std::forward<T>(x).unaryExpr([ub](auto&& xx) { return ub_constrain(xx, ub); }));
+  return eval(std::forward<T>(x).unaryExpr(
+      [ub](auto&& xx) { return ub_constrain(xx, ub); }));
 }
 
 /**
@@ -109,8 +110,8 @@ template <typename T, typename U, typename Lp, require_eigen_t<T>* = nullptr,
           require_all_not_st_var<T, U>* = nullptr,
           require_convertible_t<return_type_t<T, U>, Lp>* = nullptr>
 inline auto ub_constrain(T&& x, const U& ub, Lp& lp) {
-  return eval(
-      std::forward<T>(x).unaryExpr([ub, &lp](auto&& xx) { return ub_constrain(xx, ub, lp); }));
+  return eval(std::forward<T>(x).unaryExpr(
+      [ub, &lp](auto&& xx) { return ub_constrain(xx, ub, lp); }));
 }
 
 /**
diff --git a/stan/math/prim/constraint/unit_vector_constrain.hpp b/stan/math/prim/constraint/unit_vector_constrain.hpp
index 5a18366200c..7b3f29e2d5e 100644
--- a/stan/math/prim/constraint/unit_vector_constrain.hpp
+++ b/stan/math/prim/constraint/unit_vector_constrain.hpp
@@ -68,7 +68,9 @@ inline plain_type_t<T1> unit_vector_constrain(const T1& y, T2& lp) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto unit_vector_constrain(T&& y) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(y), [](auto&& v) { return unit_vector_constrain(std::forward<decltype(v)>(v)); });
+      std::forward<T>(y), [](auto&& v) {
+        return unit_vector_constrain(std::forward<decltype(v)>(v));
+      });
 }
 
 /**
@@ -88,7 +90,9 @@ template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto unit_vector_constrain(T&& y, Lp& lp) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(y), [&lp](auto&& v) { return unit_vector_constrain(std::forward<decltype(v)>(v), lp); });
+      std::forward<T>(y), [&lp](auto&& v) {
+        return unit_vector_constrain(std::forward<decltype(v)>(v), lp);
+      });
 }
 
 /**
diff --git a/stan/math/prim/constraint/unit_vector_free.hpp b/stan/math/prim/constraint/unit_vector_free.hpp
index a1c5d52e01c..6c8a9f19091 100644
--- a/stan/math/prim/constraint/unit_vector_free.hpp
+++ b/stan/math/prim/constraint/unit_vector_free.hpp
@@ -38,7 +38,8 @@ inline auto unit_vector_free(EigVec&& x) {
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto unit_vector_free(T&& x) {
   return apply_vector_unary<std::decay_t<T>>::apply(
-      std::forward<T>(x), [](auto&& v) { return unit_vector_free(std::forward<decltype(v)>(v)); });
+      std::forward<T>(x),
+      [](auto&& v) { return unit_vector_free(std::forward<decltype(v)>(v)); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/Phi.hpp b/stan/math/prim/fun/Phi.hpp
index 6c21789468c..14454e98baf 100644
--- a/stan/math/prim/fun/Phi.hpp
+++ b/stan/math/prim/fun/Phi.hpp
@@ -68,7 +68,8 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto Phi(T&& x) {
-  return apply_scalar_unary<Phi_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<Phi_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/Phi_approx.hpp b/stan/math/prim/fun/Phi_approx.hpp
index a806c765153..465b738abd1 100644
--- a/stan/math/prim/fun/Phi_approx.hpp
+++ b/stan/math/prim/fun/Phi_approx.hpp
@@ -67,7 +67,8 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto Phi_approx(T&& x) {
-  return apply_scalar_unary<Phi_approx_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<Phi_approx_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/abs.hpp b/stan/math/prim/fun/abs.hpp
index 5d7571167be..113471b2367 100644
--- a/stan/math/prim/fun/abs.hpp
+++ b/stan/math/prim/fun/abs.hpp
@@ -81,9 +81,7 @@ template <typename Container,
 inline auto abs(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [&](auto&& v) {
-        return std::forward<decltype(v)>(v).array().abs();
-      });
+      [&](auto&& v) { return std::forward<decltype(v)>(v).array().abs(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/acos.hpp b/stan/math/prim/fun/acos.hpp
index 1b22d4299bf..097350a292b 100644
--- a/stan/math/prim/fun/acos.hpp
+++ b/stan/math/prim/fun/acos.hpp
@@ -83,9 +83,7 @@ template <typename Container,
 inline auto acos(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](auto&& v) {
-        return std::forward<decltype(v)>(v).array().acos();
-      });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().acos(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/acosh.hpp b/stan/math/prim/fun/acosh.hpp
index c3821b69fca..4ff5f7a3df9 100644
--- a/stan/math/prim/fun/acosh.hpp
+++ b/stan/math/prim/fun/acosh.hpp
@@ -79,7 +79,8 @@ struct acosh_fun {
  */
 template <typename T, require_ad_container_t<T>* = nullptr>
 inline auto acosh(T&& x) {
-  return apply_scalar_unary<acosh_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<acosh_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 /**
@@ -95,7 +96,8 @@ inline auto acosh(T&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto acosh(Container&& x) {
-  return apply_scalar_unary<acosh_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
+  return apply_scalar_unary<acosh_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/asin.hpp b/stan/math/prim/fun/asin.hpp
index 8dfd7aca987..ad6b03285a3 100644
--- a/stan/math/prim/fun/asin.hpp
+++ b/stan/math/prim/fun/asin.hpp
@@ -81,9 +81,7 @@ template <typename Container,
 inline auto asin(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](auto&& v) {
-        return std::forward<decltype(v)>(v).array().asin();
-      });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().asin(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/asinh.hpp b/stan/math/prim/fun/asinh.hpp
index 63a53caf255..6db8b657b0a 100644
--- a/stan/math/prim/fun/asinh.hpp
+++ b/stan/math/prim/fun/asinh.hpp
@@ -67,7 +67,8 @@ struct asinh_fun {
  */
 template <typename T, require_ad_container_t<T>* = nullptr>
 inline auto asinh(T&& x) {
-  return apply_scalar_unary<asinh_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<asinh_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 /**
@@ -81,7 +82,8 @@ inline auto asinh(T&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto asinh(Container&& x) {
-  return apply_scalar_unary<asinh_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
+  return apply_scalar_unary<asinh_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/atan.hpp b/stan/math/prim/fun/atan.hpp
index 08b2da5cb78..976298b1a62 100644
--- a/stan/math/prim/fun/atan.hpp
+++ b/stan/math/prim/fun/atan.hpp
@@ -79,9 +79,7 @@ template <typename Container,
 inline auto atan(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](auto&& v) {
-        return std::forward<decltype(v)>(v).array().atan();
-      });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().atan(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/atan2.hpp b/stan/math/prim/fun/atan2.hpp
index 060c99ea314..54b50d551cd 100644
--- a/stan/math/prim/fun/atan2.hpp
+++ b/stan/math/prim/fun/atan2.hpp
@@ -40,7 +40,7 @@ inline auto atan2(T1&& a, T2&& b) {
   return apply_scalar_binary(
       [](auto&& c, auto&& d) {
         return atan2(std::forward<decltype(c)>(c),
-                      std::forward<decltype(d)>(d));
+                     std::forward<decltype(d)>(d));
       },
       std::forward<T1>(a), std::forward<T2>(b));
 }
diff --git a/stan/math/prim/fun/atanh.hpp b/stan/math/prim/fun/atanh.hpp
index 4d1802b1ab6..0105fe66d02 100644
--- a/stan/math/prim/fun/atanh.hpp
+++ b/stan/math/prim/fun/atanh.hpp
@@ -78,7 +78,8 @@ struct atanh_fun {
  */
 template <typename T, require_ad_container_t<T>* = nullptr>
 inline auto atanh(T&& x) {
-  return apply_scalar_unary<atanh_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<atanh_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 /**
@@ -94,7 +95,8 @@ inline auto atanh(T&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto atanh(Container&& x) {
-  return apply_scalar_unary<atanh_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
+  return apply_scalar_unary<atanh_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/beta.hpp b/stan/math/prim/fun/beta.hpp
index 58512cb631d..fefcf44b479 100644
--- a/stan/math/prim/fun/beta.hpp
+++ b/stan/math/prim/fun/beta.hpp
@@ -70,8 +70,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
 inline auto beta(T1&& a, T2&& b) {
   return apply_scalar_binary(
       [](auto&& c, auto&& d) {
-        return beta(std::forward<decltype(c)>(c),
-                    std::forward<decltype(d)>(d));
+        return beta(std::forward<decltype(c)>(c), std::forward<decltype(d)>(d));
       },
       std::forward<T1>(a), std::forward<T2>(b));
 }
diff --git a/stan/math/prim/fun/cbrt.hpp b/stan/math/prim/fun/cbrt.hpp
index 0a5d1ae3a71..900ddb1178a 100644
--- a/stan/math/prim/fun/cbrt.hpp
+++ b/stan/math/prim/fun/cbrt.hpp
@@ -35,7 +35,8 @@ template <
     typename T, require_not_var_matrix_t<T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto cbrt(T&& x) {
-  return apply_scalar_unary<cbrt_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<cbrt_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/ceil.hpp b/stan/math/prim/fun/ceil.hpp
index ac9a59e8541..74fb7f4d097 100644
--- a/stan/math/prim/fun/ceil.hpp
+++ b/stan/math/prim/fun/ceil.hpp
@@ -56,9 +56,7 @@ template <typename Container,
 inline auto ceil(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](auto&& v) {
-        return std::forward<decltype(v)>(v).array().ceil();
-      });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().ceil(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/cos.hpp b/stan/math/prim/fun/cos.hpp
index 8bdeffd12c3..d35764ebcfb 100644
--- a/stan/math/prim/fun/cos.hpp
+++ b/stan/math/prim/fun/cos.hpp
@@ -78,9 +78,7 @@ template <typename Container,
 inline auto cos(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [&](auto&& v) {
-        return std::forward<decltype(v)>(v).array().cos();
-      });
+      [&](auto&& v) { return std::forward<decltype(v)>(v).array().cos(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/cosh.hpp b/stan/math/prim/fun/cosh.hpp
index dda708c9f9e..f909bbf859e 100644
--- a/stan/math/prim/fun/cosh.hpp
+++ b/stan/math/prim/fun/cosh.hpp
@@ -60,7 +60,8 @@ struct cosh_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto cosh(Container&& x) {
-  return apply_scalar_unary<cosh_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
+  return apply_scalar_unary<cosh_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/digamma.hpp b/stan/math/prim/fun/digamma.hpp
index 71ccd014b4d..7fd91478025 100644
--- a/stan/math/prim/fun/digamma.hpp
+++ b/stan/math/prim/fun/digamma.hpp
@@ -75,7 +75,8 @@ template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
 inline auto digamma(T&& x) {
-  return apply_scalar_unary<digamma_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<digamma_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/erf.hpp b/stan/math/prim/fun/erf.hpp
index 683205ded17..1a91648a42d 100644
--- a/stan/math/prim/fun/erf.hpp
+++ b/stan/math/prim/fun/erf.hpp
@@ -36,7 +36,8 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto erf(T&& x) {
-  return apply_scalar_unary<erf_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<erf_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/erfc.hpp b/stan/math/prim/fun/erfc.hpp
index 92f3c904cf4..9195b970e96 100644
--- a/stan/math/prim/fun/erfc.hpp
+++ b/stan/math/prim/fun/erfc.hpp
@@ -37,7 +37,8 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto erfc(T&& x) {
-  return apply_scalar_unary<erfc_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<erfc_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/exp2.hpp b/stan/math/prim/fun/exp2.hpp
index 6bea1ff00fb..ce5fd964e92 100644
--- a/stan/math/prim/fun/exp2.hpp
+++ b/stan/math/prim/fun/exp2.hpp
@@ -40,7 +40,8 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto exp2(T&& x) {
-  return apply_scalar_unary<exp2_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<exp2_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/expm1.hpp b/stan/math/prim/fun/expm1.hpp
index da737a6539e..1cdbdde4ed7 100644
--- a/stan/math/prim/fun/expm1.hpp
+++ b/stan/math/prim/fun/expm1.hpp
@@ -37,7 +37,8 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto expm1(T&& x) {
-  return apply_scalar_unary<expm1_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<expm1_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/fabs.hpp b/stan/math/prim/fun/fabs.hpp
index 9db7205c1b6..476fb1e7ed7 100644
--- a/stan/math/prim/fun/fabs.hpp
+++ b/stan/math/prim/fun/fabs.hpp
@@ -49,7 +49,8 @@ template <typename Container,
               Container>* = nullptr,
           require_not_stan_scalar_t<Container>* = nullptr>
 inline auto fabs(Container&& x) {
-  return apply_scalar_unary<fabs_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
+  return apply_scalar_unary<fabs_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/fdim.hpp b/stan/math/prim/fun/fdim.hpp
index 4e602bfcc7e..c940a79ffbf 100644
--- a/stan/math/prim/fun/fdim.hpp
+++ b/stan/math/prim/fun/fdim.hpp
@@ -38,8 +38,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto fdim(T1&& a, T2&& b) {
   return apply_scalar_binary(
       [](auto&& c, auto&& d) {
-        return fdim(std::forward<decltype(c)>(c),
-                    std::forward<decltype(d)>(d));
+        return fdim(std::forward<decltype(c)>(c), std::forward<decltype(d)>(d));
       },
       std::forward<T1>(a), std::forward<T2>(b));
 }
diff --git a/stan/math/prim/fun/floor.hpp b/stan/math/prim/fun/floor.hpp
index 11529d21df6..f683c5e5130 100644
--- a/stan/math/prim/fun/floor.hpp
+++ b/stan/math/prim/fun/floor.hpp
@@ -43,7 +43,8 @@ struct floor_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto floor(Container&& x) {
-  return apply_scalar_unary<floor_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
+  return apply_scalar_unary<floor_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/fmax.hpp b/stan/math/prim/fun/fmax.hpp
index 620a7f5f4f7..77c0319ede5 100644
--- a/stan/math/prim/fun/fmax.hpp
+++ b/stan/math/prim/fun/fmax.hpp
@@ -36,8 +36,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto fmax(T1&& a, T2&& b) {
   return apply_scalar_binary(
       [](auto&& c, auto&& d) {
-        return fmax(std::forward<decltype(c)>(c),
-                    std::forward<decltype(d)>(d));
+        return fmax(std::forward<decltype(c)>(c), std::forward<decltype(d)>(d));
       },
       std::forward<T1>(a), std::forward<T2>(b));
 }
diff --git a/stan/math/prim/fun/fmin.hpp b/stan/math/prim/fun/fmin.hpp
index 7bf25f93be9..5b2ffe63643 100644
--- a/stan/math/prim/fun/fmin.hpp
+++ b/stan/math/prim/fun/fmin.hpp
@@ -36,8 +36,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto fmin(T1&& a, T2&& b) {
   return apply_scalar_binary(
       [](auto&& c, auto&& d) {
-        return fmin(std::forward<decltype(c)>(c),
-                    std::forward<decltype(d)>(d));
+        return fmin(std::forward<decltype(c)>(c), std::forward<decltype(d)>(d));
       },
       std::forward<T1>(a), std::forward<T2>(b));
 }
diff --git a/stan/math/prim/fun/fmod.hpp b/stan/math/prim/fun/fmod.hpp
index 26f916df7b5..b3cc51bb65d 100644
--- a/stan/math/prim/fun/fmod.hpp
+++ b/stan/math/prim/fun/fmod.hpp
@@ -38,8 +38,7 @@ inline auto fmod(T1&& a, T2&& b) {
   return apply_scalar_binary(
       [](auto&& c, auto&& d) {
         using std::fmod;
-        return fmod(std::forward<decltype(c)>(c),
-                    std::forward<decltype(d)>(d));
+        return fmod(std::forward<decltype(c)>(c), std::forward<decltype(d)>(d));
       },
       std::forward<T1>(a), std::forward<T2>(b));
 }
diff --git a/stan/math/prim/fun/gamma_p.hpp b/stan/math/prim/fun/gamma_p.hpp
index 512d3c48526..59ca71a2e42 100644
--- a/stan/math/prim/fun/gamma_p.hpp
+++ b/stan/math/prim/fun/gamma_p.hpp
@@ -90,7 +90,8 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto gamma_p(T1&& a, T2&& b) {
   return apply_scalar_binary(
       [](auto&& c, auto&& d) {
-        return gamma_p(std::forward<decltype(c)>(c), std::forward<decltype(d)>(d));
+        return gamma_p(std::forward<decltype(c)>(c),
+                       std::forward<decltype(d)>(d));
       },
       std::forward<T1>(a), std::forward<T2>(b));
 }
diff --git a/stan/math/prim/fun/inv.hpp b/stan/math/prim/fun/inv.hpp
index 1c05385df37..0d710bf32bb 100644
--- a/stan/math/prim/fun/inv.hpp
+++ b/stan/math/prim/fun/inv.hpp
@@ -35,7 +35,8 @@ template <
     typename T, require_not_container_st<std::is_arithmetic, T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto inv(T&& x) {
-  return apply_scalar_unary<inv_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<inv_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/inv_Phi.hpp b/stan/math/prim/fun/inv_Phi.hpp
index 15b11207edc..4664c3e4944 100644
--- a/stan/math/prim/fun/inv_Phi.hpp
+++ b/stan/math/prim/fun/inv_Phi.hpp
@@ -178,7 +178,8 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto inv_Phi(T&& x) {
-  return apply_scalar_unary<inv_Phi_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<inv_Phi_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/inv_cloglog.hpp b/stan/math/prim/fun/inv_cloglog.hpp
index cb31db2e6c2..33176f5181d 100644
--- a/stan/math/prim/fun/inv_cloglog.hpp
+++ b/stan/math/prim/fun/inv_cloglog.hpp
@@ -91,7 +91,8 @@ struct inv_cloglog_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto inv_cloglog(Container&& x) {
-  return apply_scalar_unary<inv_cloglog_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
+  return apply_scalar_unary<inv_cloglog_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
@@ -106,8 +107,7 @@ template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto inv_cloglog(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
-      std::forward<Container>(x),
-      [](const auto& v) {
+      std::forward<Container>(x), [](const auto& v) {
         return (1 - (-std::forward<decltype(v)>(v).array().exp()).exp());
       });
 }
diff --git a/stan/math/prim/fun/inv_erfc.hpp b/stan/math/prim/fun/inv_erfc.hpp
index 1afba170442..ffc560cf543 100644
--- a/stan/math/prim/fun/inv_erfc.hpp
+++ b/stan/math/prim/fun/inv_erfc.hpp
@@ -49,7 +49,8 @@ template <
     require_not_var_matrix_t<T>* = nullptr,
     require_not_arithmetic_t<T>* = nullptr>
 inline auto inv_erfc(T&& x) {
-  return apply_scalar_unary<inv_erfc_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<inv_erfc_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/inv_sqrt.hpp b/stan/math/prim/fun/inv_sqrt.hpp
index bd8cc17904f..fe7163a4040 100644
--- a/stan/math/prim/fun/inv_sqrt.hpp
+++ b/stan/math/prim/fun/inv_sqrt.hpp
@@ -46,7 +46,8 @@ struct inv_sqrt_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto inv_sqrt(Container&& x) {
-  return apply_scalar_unary<inv_sqrt_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
+  return apply_scalar_unary<inv_sqrt_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/inv_square.hpp b/stan/math/prim/fun/inv_square.hpp
index 96ecdb3b877..79a2c755f35 100644
--- a/stan/math/prim/fun/inv_square.hpp
+++ b/stan/math/prim/fun/inv_square.hpp
@@ -36,8 +36,7 @@ template <typename Container,
           require_container_st<std::is_arithmetic, Container>* = nullptr>
 inline auto inv_square(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
-      std::forward<Container>(x),
-      [](auto&& v) {
+      std::forward<Container>(x), [](auto&& v) {
         return std::forward<decltype(v)>(v).array().square().inverse();
       });
 }
diff --git a/stan/math/prim/fun/lambert_w.hpp b/stan/math/prim/fun/lambert_w.hpp
index 9fedeee69d2..7353a265c2e 100644
--- a/stan/math/prim/fun/lambert_w.hpp
+++ b/stan/math/prim/fun/lambert_w.hpp
@@ -81,7 +81,8 @@ struct lambert_wm1_fun {
 template <typename T, require_not_stan_scalar_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
 inline auto lambert_w0(T&& x) {
-  return apply_scalar_unary<internal::lambert_w0_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<internal::lambert_w0_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 /**
@@ -96,7 +97,8 @@ inline auto lambert_w0(T&& x) {
 template <typename T, require_not_stan_scalar_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
 inline auto lambert_wm1(T&& x) {
-  return apply_scalar_unary<internal::lambert_wm1_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<internal::lambert_wm1_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/lgamma.hpp b/stan/math/prim/fun/lgamma.hpp
index 6cfb99d20ec..6ce3826e504 100644
--- a/stan/math/prim/fun/lgamma.hpp
+++ b/stan/math/prim/fun/lgamma.hpp
@@ -117,7 +117,8 @@ struct lgamma_fun {
 template <typename T, require_not_var_matrix_t<T>* = nullptr,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto lgamma(T&& x) {
-  return apply_scalar_unary<lgamma_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<lgamma_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log10.hpp b/stan/math/prim/fun/log10.hpp
index fecc2368759..5d1dc4e4f12 100644
--- a/stan/math/prim/fun/log10.hpp
+++ b/stan/math/prim/fun/log10.hpp
@@ -59,7 +59,8 @@ struct log10_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto log10(Container&& x) {
-  return apply_scalar_unary<log10_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
+  return apply_scalar_unary<log10_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/log1m.hpp b/stan/math/prim/fun/log1m.hpp
index c092ea8873a..92d49c20118 100644
--- a/stan/math/prim/fun/log1m.hpp
+++ b/stan/math/prim/fun/log1m.hpp
@@ -71,7 +71,8 @@ template <
     typename T, require_not_var_matrix_t<T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto log1m(T&& x) {
-  return apply_scalar_unary<log1m_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<log1m_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log1m_exp.hpp b/stan/math/prim/fun/log1m_exp.hpp
index c79aed1b725..9771ed9734f 100644
--- a/stan/math/prim/fun/log1m_exp.hpp
+++ b/stan/math/prim/fun/log1m_exp.hpp
@@ -81,7 +81,8 @@ template <
     typename T, require_not_var_matrix_t<T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto log1m_exp(T&& x) {
-  return apply_scalar_unary<log1m_exp_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<log1m_exp_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log1p.hpp b/stan/math/prim/fun/log1p.hpp
index e4d15264ec7..4f337a0dedc 100644
--- a/stan/math/prim/fun/log1p.hpp
+++ b/stan/math/prim/fun/log1p.hpp
@@ -80,7 +80,8 @@ template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
 inline auto log1p(T&& x) {
-  return apply_scalar_unary<log1p_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<log1p_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log1p_exp.hpp b/stan/math/prim/fun/log1p_exp.hpp
index 02df5805859..2180f24e2ea 100644
--- a/stan/math/prim/fun/log1p_exp.hpp
+++ b/stan/math/prim/fun/log1p_exp.hpp
@@ -76,7 +76,8 @@ template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
 inline auto log1p_exp(T&& x) {
-  return apply_scalar_unary<log1p_exp_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<log1p_exp_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log2.hpp b/stan/math/prim/fun/log2.hpp
index ecd11406c56..d77bec26820 100644
--- a/stan/math/prim/fun/log2.hpp
+++ b/stan/math/prim/fun/log2.hpp
@@ -47,7 +47,8 @@ struct log2_fun {
 template <typename T, require_not_var_matrix_t<T>* = nullptr,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto log2(T&& x) {
-  return apply_scalar_unary<log2_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<log2_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_inv_logit.hpp b/stan/math/prim/fun/log_inv_logit.hpp
index a02d4f376ae..11d0fa215fc 100644
--- a/stan/math/prim/fun/log_inv_logit.hpp
+++ b/stan/math/prim/fun/log_inv_logit.hpp
@@ -82,7 +82,8 @@ template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
 inline auto log_inv_logit(T&& x) {
-  return apply_scalar_unary<log_inv_logit_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<log_inv_logit_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_softmax.hpp b/stan/math/prim/fun/log_softmax.hpp
index 8471c2646ae..61ada1bb62c 100644
--- a/stan/math/prim/fun/log_softmax.hpp
+++ b/stan/math/prim/fun/log_softmax.hpp
@@ -46,8 +46,7 @@ inline auto log_softmax(Container&& x) {
   return make_holder(
       [](auto&& a) {
         return apply_vector_unary<ref_type_t<std::decay_t<Container>>>::apply(
-            std::forward<decltype(a)>(a),
-            [](const auto& v) {
+            std::forward<decltype(a)>(a), [](const auto& v) {
               return std::forward<decltype(v)>(v).array() - log_sum_exp(v);
             });
       },
diff --git a/stan/math/prim/fun/log_sum_exp.hpp b/stan/math/prim/fun/log_sum_exp.hpp
index 7d732b47c26..e58ab40a4ed 100644
--- a/stan/math/prim/fun/log_sum_exp.hpp
+++ b/stan/math/prim/fun/log_sum_exp.hpp
@@ -82,16 +82,16 @@ template <typename T, require_container_st<std::is_arithmetic, T>* = nullptr>
 inline auto log_sum_exp(T&& x) {
   return apply_vector_unary<std::decay_t<T>>::reduce(
       std::forward<T>(x), [&](auto&& v) {
-    if (v.size() == 0) {
-      return NEGATIVE_INFTY;
-    }
-    const auto& v_ref = to_ref(v);
-    const double max = v_ref.maxCoeff();
-    if (!std::isfinite(max)) {
-      return max;
-    }
-    return max + std::log((v_ref.array() - max).exp().sum());
-  });
+        if (v.size() == 0) {
+          return NEGATIVE_INFTY;
+        }
+        const auto& v_ref = to_ref(v);
+        const double max = v_ref.maxCoeff();
+        if (!std::isfinite(max)) {
+          return max;
+        }
+        return max + std::log((v_ref.array() - max).exp().sum());
+      });
 }
 
 /**
diff --git a/stan/math/prim/fun/logit.hpp b/stan/math/prim/fun/logit.hpp
index 82498e42135..f9e6bc3fb30 100644
--- a/stan/math/prim/fun/logit.hpp
+++ b/stan/math/prim/fun/logit.hpp
@@ -88,7 +88,8 @@ struct logit_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto logit(Container&& x) {
-  return apply_scalar_unary<logit_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
+  return apply_scalar_unary<logit_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
@@ -108,11 +109,9 @@ inline auto logit(Container&& x) {
   return make_holder(
       [](auto&& v_ref) {
         return apply_vector_unary<ref_type_t<std::decay_t<Container>>>::apply(
-            std::forward<decltype(v_ref)>(v_ref),
-            [](const auto& v) {
-              return (
-                         std::forward<decltype(v)>(v).array()
-                         / (1 - std::forward<decltype(v)>(v).array()))
+            std::forward<decltype(v_ref)>(v_ref), [](const auto& v) {
+              return (std::forward<decltype(v)>(v).array()
+                      / (1 - std::forward<decltype(v)>(v).array()))
                   .log();
             });
       },
diff --git a/stan/math/prim/fun/mean.hpp b/stan/math/prim/fun/mean.hpp
index d9568fce905..6101263c91b 100644
--- a/stan/math/prim/fun/mean.hpp
+++ b/stan/math/prim/fun/mean.hpp
@@ -21,8 +21,8 @@ namespace math {
 template <typename T, require_container_t<T>* = nullptr>
 inline return_type_t<T> mean(T&& m) {
   check_nonzero_size("mean", "m", m);
-  return apply_vector_unary<std::decay_t<T>>::reduce(std::forward<T>(m),
-                                       [](const auto& a) { return a.mean(); });
+  return apply_vector_unary<std::decay_t<T>>::reduce(
+      std::forward<T>(m), [](const auto& a) { return a.mean(); });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/minus.hpp b/stan/math/prim/fun/minus.hpp
index 4feae5426a2..58c8c682677 100644
--- a/stan/math/prim/fun/minus.hpp
+++ b/stan/math/prim/fun/minus.hpp
@@ -17,9 +17,9 @@ namespace math {
 template <typename T, require_not_std_vector_t<T>* = nullptr>
 inline auto minus(T&& x) {
   if constexpr (is_eigen_v<T>) {
-    return make_holder([](auto&& xx) {
-      return -std::forward<decltype(xx)>(xx);
-    }, std::forward<T>(x));
+    return make_holder(
+        [](auto&& xx) { return -std::forward<decltype(xx)>(xx); },
+        std::forward<T>(x));
   } else {
     return -x;
   }
diff --git a/stan/math/prim/fun/pow.hpp b/stan/math/prim/fun/pow.hpp
index 46d60cb00ef..90db4a4fc85 100644
--- a/stan/math/prim/fun/pow.hpp
+++ b/stan/math/prim/fun/pow.hpp
@@ -111,7 +111,10 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
 inline auto pow(T1&& a, T2&& b) {
   return apply_scalar_binary(
       // Qualified pow since only Arithmetic types are accepted here
-      [](auto&& c, auto&& d) { return stan::math::pow(std::forward<decltype(c)>(c), std::forward<decltype(d)>(d)); },
+      [](auto&& c, auto&& d) {
+        return stan::math::pow(std::forward<decltype(c)>(c),
+                               std::forward<decltype(d)>(d));
+      },
       std::forward<T1>(a), std::forward<T2>(b));
 }
 }  // namespace math
diff --git a/stan/math/prim/fun/rank.hpp b/stan/math/prim/fun/rank.hpp
index f3357d0424b..2b8fd90544d 100644
--- a/stan/math/prim/fun/rank.hpp
+++ b/stan/math/prim/fun/rank.hpp
@@ -20,10 +20,11 @@ template <typename C, require_container_t<C>* = nullptr>
 inline int rank(C&& v, int s) {
   check_range("rank", "v", v.size(), s);
   --s;  // adjust for indexing by one
-  return apply_vector_unary<std::decay_t<C>>::reduce(std::forward<C>(v), [s](const auto& vec) {
-    auto&& vec_ref = to_ref(std::forward<decltype(vec)>(vec));
-    return (vec_ref.array() < vec_ref.coeff(s)).template cast<int>().sum();
-  });
+  return apply_vector_unary<std::decay_t<C>>::reduce(
+      std::forward<C>(v), [s](const auto& vec) {
+        auto&& vec_ref = to_ref(std::forward<decltype(vec)>(vec));
+        return (vec_ref.array() < vec_ref.coeff(s)).template cast<int>().sum();
+      });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/round.hpp b/stan/math/prim/fun/round.hpp
index c91673aea36..120e2fa8aec 100644
--- a/stan/math/prim/fun/round.hpp
+++ b/stan/math/prim/fun/round.hpp
@@ -37,7 +37,8 @@ template <typename Container,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               Container>* = nullptr>
 inline auto round(Container&& x) {
-  return apply_scalar_unary<round_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
+  return apply_scalar_unary<round_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/sd.hpp b/stan/math/prim/fun/sd.hpp
index b2b928403af..bee70a57c32 100644
--- a/stan/math/prim/fun/sd.hpp
+++ b/stan/math/prim/fun/sd.hpp
@@ -28,14 +28,14 @@ inline auto sd(T&& m) {
 
   return apply_vector_unary<std::decay_t<T>>::reduce(
       std::forward<T>(m), [](auto&& x) {
-    check_nonzero_size("sd", "x", x);
+        check_nonzero_size("sd", "x", x);
 
-    if (x.size() == 1) {
-      return scalar_type_t<T>(0.0);
-    }
+        if (x.size() == 1) {
+          return scalar_type_t<T>(0.0);
+        }
 
-    return sqrt(variance(x));
-  });
+        return sqrt(variance(x));
+      });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/select.hpp b/stan/math/prim/fun/select.hpp
index 0b551a1da6e..99f3a461061 100644
--- a/stan/math/prim/fun/select.hpp
+++ b/stan/math/prim/fun/select.hpp
@@ -23,8 +23,7 @@ namespace math {
 template <typename T_true, typename T_false,
           typename ReturnT = return_type_t<T_true, T_false>,
           require_all_stan_scalar_t<T_true, T_false>* = nullptr>
-inline ReturnT select(const bool c, T_true&& y_true,
-                      T_false&& y_false) {
+inline ReturnT select(const bool c, T_true&& y_true, T_false&& y_false) {
   return c ? ReturnT(y_true) : ReturnT(y_false);
 }
 
@@ -80,8 +79,7 @@ template <typename T_true, typename T_false,
                                               plain_type_t<T_true>>,
           require_container_t<T_true>* = nullptr,
           require_stan_scalar_t<T_false>* = nullptr>
-inline ReturnT select(const bool c, T_true&& y_true,
-                      T_false&& y_false) {
+inline ReturnT select(const bool c, T_true&& y_true, T_false&& y_false) {
   if (c) {
     return y_true;
   } else {
@@ -115,8 +113,7 @@ template <typename T_true, typename T_false,
                                               plain_type_t<T_false>>,
           require_stan_scalar_t<T_true>* = nullptr,
           require_container_t<T_false>* = nullptr>
-inline ReturnT select(const bool c, const T_true y_true,
-                      T_false&& y_false) {
+inline ReturnT select(const bool c, const T_true y_true, T_false&& y_false) {
   if (c) {
     return apply_scalar_binary(
         [](auto&& y_true_inner, auto&& y_false_inner) {
@@ -174,7 +171,10 @@ inline auto select(T_bool&& c, T_true&& y_true, T_false&& y_false) {
   check_consistent_sizes("select", "boolean", c, "left hand side", y_true,
                          "right hand side", y_false);
   using ret_t = return_type_t<T_true, T_false>;
-  return std::forward<T_bool>(c).select(std::forward<T_true>(y_true), std::forward<T_false>(y_false)).template cast<ret_t>().eval();
+  return std::forward<T_bool>(c)
+      .select(std::forward<T_true>(y_true), std::forward<T_false>(y_false))
+      .template cast<ret_t>()
+      .eval();
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sign.hpp b/stan/math/prim/fun/sign.hpp
index 50449bd0e2e..24e2f07b126 100644
--- a/stan/math/prim/fun/sign.hpp
+++ b/stan/math/prim/fun/sign.hpp
@@ -40,7 +40,8 @@ struct sign_fun {
  */
 template <typename T, require_container_t<T>* = nullptr>
 inline auto sign(T&& x) {
-  return apply_scalar_unary<sign_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<sign_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sinh.hpp b/stan/math/prim/fun/sinh.hpp
index c5bcb3c2f09..b7258a0622a 100644
--- a/stan/math/prim/fun/sinh.hpp
+++ b/stan/math/prim/fun/sinh.hpp
@@ -58,7 +58,8 @@ struct sinh_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto sinh(Container&& x) {
-  return apply_scalar_unary<sinh_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
+  return apply_scalar_unary<sinh_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/sqrt.hpp b/stan/math/prim/fun/sqrt.hpp
index b62a9f18aad..f68dd39d2a8 100644
--- a/stan/math/prim/fun/sqrt.hpp
+++ b/stan/math/prim/fun/sqrt.hpp
@@ -58,7 +58,8 @@ struct sqrt_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto sqrt(Container&& x) {
-  return apply_scalar_unary<sqrt_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
+  return apply_scalar_unary<sqrt_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/square.hpp b/stan/math/prim/fun/square.hpp
index a958b83b18a..c16f8bd7ad0 100644
--- a/stan/math/prim/fun/square.hpp
+++ b/stan/math/prim/fun/square.hpp
@@ -51,7 +51,8 @@ struct square_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto square(Container&& x) {
-  return apply_scalar_unary<square_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
+  return apply_scalar_unary<square_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/step.hpp b/stan/math/prim/fun/step.hpp
index 7398b4ba707..dcc7a8263bc 100644
--- a/stan/math/prim/fun/step.hpp
+++ b/stan/math/prim/fun/step.hpp
@@ -59,7 +59,8 @@ struct step_fun {
  */
 template <typename T, require_container_t<T>* = nullptr>
 inline auto step(T&& x) {
-  return apply_scalar_unary<step_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<step_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/tan.hpp b/stan/math/prim/fun/tan.hpp
index ec0387365dd..9e73c8ffcfe 100644
--- a/stan/math/prim/fun/tan.hpp
+++ b/stan/math/prim/fun/tan.hpp
@@ -77,9 +77,7 @@ template <typename Container,
 inline auto tan(Container&& x) {
   return apply_vector_unary<std::decay_t<Container>>::apply(
       std::forward<Container>(x),
-      [](auto&& v) {
-        return std::forward<decltype(v)>(v).array().tan();
-      });
+      [](auto&& v) { return std::forward<decltype(v)>(v).array().tan(); });
 }
 
 namespace internal {
diff --git a/stan/math/prim/fun/tanh.hpp b/stan/math/prim/fun/tanh.hpp
index cc5ee6b9cd3..c5fe4930240 100644
--- a/stan/math/prim/fun/tanh.hpp
+++ b/stan/math/prim/fun/tanh.hpp
@@ -60,7 +60,8 @@ struct tanh_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto tanh(Container&& x) {
-  return apply_scalar_unary<tanh_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
+  return apply_scalar_unary<tanh_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/tgamma.hpp b/stan/math/prim/fun/tgamma.hpp
index 40d9249615e..354eb55de21 100644
--- a/stan/math/prim/fun/tgamma.hpp
+++ b/stan/math/prim/fun/tgamma.hpp
@@ -51,7 +51,8 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto tgamma(T&& x) {
-  return apply_scalar_unary<tgamma_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<tgamma_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/to_int.hpp b/stan/math/prim/fun/to_int.hpp
index 0a1d54a4efc..a08474faa8a 100644
--- a/stan/math/prim/fun/to_int.hpp
+++ b/stan/math/prim/fun/to_int.hpp
@@ -72,7 +72,8 @@ struct to_int_fun {
 template <typename Container,
           require_std_vector_st<std::is_arithmetic, Container>* = nullptr>
 inline auto to_int(Container&& x) {
-  return apply_scalar_unary<to_int_fun, std::decay_t<Container>>::apply(std::forward<Container>(x));
+  return apply_scalar_unary<to_int_fun, std::decay_t<Container>>::apply(
+      std::forward<Container>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/trigamma.hpp b/stan/math/prim/fun/trigamma.hpp
index fd62dfaab91..07dae79ef85 100644
--- a/stan/math/prim/fun/trigamma.hpp
+++ b/stan/math/prim/fun/trigamma.hpp
@@ -156,7 +156,8 @@ struct trigamma_fun {
 template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto trigamma(T&& x) {
-  return apply_scalar_unary<trigamma_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<trigamma_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/trunc.hpp b/stan/math/prim/fun/trunc.hpp
index 941461ea8e2..71c417a91fd 100644
--- a/stan/math/prim/fun/trunc.hpp
+++ b/stan/math/prim/fun/trunc.hpp
@@ -40,7 +40,8 @@ struct trunc_fun {
 template <typename T, require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
                           T>* = nullptr>
 inline auto trunc(T&& x) {
-  return apply_scalar_unary<trunc_fun, std::decay_t<T>>::apply(std::forward<T>(x));
+  return apply_scalar_unary<trunc_fun, std::decay_t<T>>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/functor/apply_scalar_binary.hpp b/stan/math/prim/functor/apply_scalar_binary.hpp
index 77ea8369d27..b0f60807031 100644
--- a/stan/math/prim/functor/apply_scalar_binary.hpp
+++ b/stan/math/prim/functor/apply_scalar_binary.hpp
@@ -203,7 +203,8 @@ inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   return make_holder(
       [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
         return x_inner.unaryExpr(
-            [f_inner_ = std::forward<decltype(f_inner)>(f_inner), y_inner](const auto& v) { return f_inner_(v, y_inner); });
+            [f_inner_ = std::forward<decltype(f_inner)>(f_inner),
+             y_inner](const auto& v) { return f_inner_(v, y_inner); });
       },
       std::forward<F>(f), std::forward<T1>(x), std::forward<T2>(y));
 }
@@ -229,7 +230,10 @@ inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   return make_holder(
       [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
         return y_inner.unaryExpr(
-            [f_inner_ = std::forward<decltype(f_inner)>(f_inner), x_inner](auto&& v) { return f_inner_(x_inner, std::forward<decltype(v)>(v)); });
+            [f_inner_ = std::forward<decltype(f_inner)>(f_inner),
+             x_inner](auto&& v) {
+              return f_inner_(x_inner, std::forward<decltype(v)>(v));
+            });
       },
       std::forward<F>(f), std::forward<T1>(x), std::forward<T2>(y));
 }
diff --git a/stan/math/prim/functor/apply_scalar_ternary.hpp b/stan/math/prim/functor/apply_scalar_ternary.hpp
index e9dfcdab834..81dc4bf081e 100644
--- a/stan/math/prim/functor/apply_scalar_ternary.hpp
+++ b/stan/math/prim/functor/apply_scalar_ternary.hpp
@@ -158,10 +158,13 @@ inline auto apply_scalar_ternary(F&& f, T1&& x, T2&& y, T3&& z) {
 template <typename F, typename T1, typename T2, typename T3,
           require_any_container_t<T1, T2>* = nullptr,
           require_stan_scalar_t<T3>* = nullptr>
-inline auto apply_scalar_ternary(F&& f, T1&& x, T2&& y,
-                                 T3&& z) {
+inline auto apply_scalar_ternary(F&& f, T1&& x, T2&& y, T3&& z) {
   return apply_scalar_binary(
-      [f_ = std::forward<F>(f), z](auto&& a, auto&& b) { return f_(std::forward<decltype(a)>(a), std::forward<decltype(b)>(b), z); }, std::forward<T1>(x), std::forward<T2>(y));
+      [f_ = std::forward<F>(f), z](auto&& a, auto&& b) {
+        return f_(std::forward<decltype(a)>(a), std::forward<decltype(b)>(b),
+                  z);
+      },
+      std::forward<T1>(x), std::forward<T2>(y));
 }
 
 /**
@@ -183,10 +186,12 @@ inline auto apply_scalar_ternary(F&& f, T1&& x, T2&& y,
 template <typename F, typename T1, typename T2, typename T3,
           require_all_container_t<T1, T3>* = nullptr,
           require_stan_scalar_t<T2>* = nullptr>
-inline auto apply_scalar_ternary(const F& f, T1&& x, T2&& y,
-                                 T3&& z) {
+inline auto apply_scalar_ternary(const F& f, T1&& x, T2&& y, T3&& z) {
   return apply_scalar_binary(
-      [f, y](auto&& a, auto&& c) { return f(std::forward<decltype(a)>(a), y, std::forward<decltype(c)>(c)); }, std::forward<T1>(x), std::forward<T3>(z));
+      [f, y](auto&& a, auto&& c) {
+        return f(std::forward<decltype(a)>(a), y, std::forward<decltype(c)>(c));
+      },
+      std::forward<T1>(x), std::forward<T3>(z));
 }
 
 /**
@@ -208,10 +213,12 @@ inline auto apply_scalar_ternary(const F& f, T1&& x, T2&& y,
 template <typename F, typename T1, typename T2, typename T3,
           require_container_t<T3>* = nullptr,
           require_stan_scalar_t<T1>* = nullptr>
-inline auto apply_scalar_ternary(const F& f, T1&& x, T2&& y,
-                                 T3&& z) {
+inline auto apply_scalar_ternary(const F& f, T1&& x, T2&& y, T3&& z) {
   return apply_scalar_binary(
-      [f, x](auto&& b, auto&& c) { return f(x, std::forward<decltype(b)>(b), std::forward<decltype(c)>(c)); }, std::forward<T2>(y), std::forward<T3>(z));
+      [f, x](auto&& b, auto&& c) {
+        return f(x, std::forward<decltype(b)>(b), std::forward<decltype(c)>(c));
+      },
+      std::forward<T2>(y), std::forward<T3>(z));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/functor/apply_scalar_unary.hpp b/stan/math/prim/functor/apply_scalar_unary.hpp
index 2fae2be79f1..73deb13b607 100644
--- a/stan/math/prim/functor/apply_scalar_unary.hpp
+++ b/stan/math/prim/functor/apply_scalar_unary.hpp
@@ -60,11 +60,14 @@ struct apply_scalar_unary<F, T, require_eigen_t<T>> {
    */
   template <typename TT>
   static inline auto apply(TT&& x) {
-    return make_holder([](auto&& xx) {
-      return std::forward<decltype(xx)>(xx).unaryExpr([](auto&& xxx) {
-        return apply_scalar_unary<F, std::decay_t<decltype(xxx)>>::apply(xxx);
-      });
-    }, std::forward<TT>(x));
+    return make_holder(
+        [](auto&& xx) {
+          return std::forward<decltype(xx)>(xx).unaryExpr([](auto&& xxx) {
+            return apply_scalar_unary<F, std::decay_t<decltype(xxx)>>::apply(
+                xxx);
+          });
+        },
+        std::forward<TT>(x));
   }
 
   /**
diff --git a/stan/math/prim/functor/apply_vector_unary.hpp b/stan/math/prim/functor/apply_vector_unary.hpp
index 2472e77c7d7..f4c1b2f00b4 100644
--- a/stan/math/prim/functor/apply_vector_unary.hpp
+++ b/stan/math/prim/functor/apply_vector_unary.hpp
@@ -44,9 +44,9 @@ struct apply_vector_unary<T, require_eigen_t<T>> {
             require_t<is_eigen_matrix_base<plain_type_t<T2>>>* = nullptr>
   static inline auto apply(T2&& x, F&& f) {
     if constexpr (is_eigen_array<decltype(f(x))>::value) {
-      return make_holder([](auto&& xx) {
-        return std::forward<decltype(xx)>(xx).matrix();
-      }, make_holder(std::forward<F>(f), std::forward<T2>(x)));
+      return make_holder(
+          [](auto&& xx) { return std::forward<decltype(xx)>(xx).matrix(); },
+          make_holder(std::forward<F>(f), std::forward<T2>(x)));
     } else {
       return make_holder(std::forward<F>(f), std::forward<T2>(x));
     }
@@ -58,9 +58,9 @@ struct apply_vector_unary<T, require_eigen_t<T>> {
     if constexpr (is_eigen_array<decltype(f(x))>::value) {
       return make_holder(std::forward<F>(f), std::forward<T2>(x));
     } else {
-      return make_holder([](auto&& xx) {
-        return std::forward<decltype(xx)>(xx).array();
-      }, make_holder(std::forward<F>(f), std::forward<T2>(x)));
+      return make_holder(
+          [](auto&& xx) { return std::forward<decltype(xx)>(xx).array(); },
+          make_holder(std::forward<F>(f), std::forward<T2>(x)));
     }
   }
 
@@ -166,7 +166,8 @@ struct apply_vector_unary<T, require_std_vector_vt<is_stan_scalar, T>> {
    */
   template <typename T2, typename F>
   static inline auto reduce(T2&& x, F&& f) {
-    return apply_vector_unary<T_map>::reduce(as_column_vector_or_scalar(std::forward<T2>(x)), std::forward<F>(f));
+    return apply_vector_unary<T_map>::reduce(
+        as_column_vector_or_scalar(std::forward<T2>(x)), std::forward<F>(f));
   }
 };
 
diff --git a/stan/math/prim/prob/std_normal_log_qf.hpp b/stan/math/prim/prob/std_normal_log_qf.hpp
index 62c881674d1..d4815b38809 100644
--- a/stan/math/prim/prob/std_normal_log_qf.hpp
+++ b/stan/math/prim/prob/std_normal_log_qf.hpp
@@ -151,7 +151,8 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto std_normal_log_qf(T&& x) {
-  return apply_scalar_unary<std_normal_log_qf_fun, T>::apply(std::forward<T>(x));
+  return apply_scalar_unary<std_normal_log_qf_fun, T>::apply(
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/rev/fun/pow.hpp b/stan/math/rev/fun/pow.hpp
index a72b5f04226..641272bd9cf 100644
--- a/stan/math/rev/fun/pow.hpp
+++ b/stan/math/rev/fun/pow.hpp
@@ -289,7 +289,11 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_any_var_t<base_type_t<T1>, base_type_t<T2>>* = nullptr>
 inline auto pow(T1&& a, T2&& b) {
   return apply_scalar_binary(
-      [](auto&& c, auto&& d) { return stan::math::pow(std::forward<decltype(c)>(c), std::forward<decltype(d)>(d)); }, std::forward<T1>(a), std::forward<T2>(b));
+      [](auto&& c, auto&& d) {
+        return stan::math::pow(std::forward<decltype(c)>(c),
+                               std::forward<decltype(d)>(d));
+      },
+      std::forward<T1>(a), std::forward<T2>(b));
 }
 
 }  // namespace math
diff --git a/stan/math/rev/fun/sd.hpp b/stan/math/rev/fun/sd.hpp
index f143930802e..02c5bc7c609 100644
--- a/stan/math/rev/fun/sd.hpp
+++ b/stan/math/rev/fun/sd.hpp
@@ -95,7 +95,8 @@ var sd(const T& x) {
  */
 template <typename T, require_std_vector_st<is_var, T>* = nullptr>
 auto sd(T&& m) {
-  return apply_vector_unary<std::decay_t<T>>::reduce(std::forward<T>(m), [](const auto& x) { return sd(x); });
+  return apply_vector_unary<std::decay_t<T>>::reduce(
+      std::forward<T>(m), [](const auto& x) { return sd(x); });
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/apply_scalar_unary.hpp b/stan/math/rev/functor/apply_scalar_unary.hpp
index 4213559b5db..eeba3e8cab9 100644
--- a/stan/math/rev/functor/apply_scalar_unary.hpp
+++ b/stan/math/rev/functor/apply_scalar_unary.hpp
@@ -45,7 +45,9 @@ struct apply_scalar_unary<F, T, require_var_matrix_t<T>> {
    * @return Function applied to the variable.
    */
   template <typename T2>
-  static inline return_t apply(T2&& x) { return F::fun(std::forward<T2>(x)); }
+  static inline return_t apply(T2&& x) {
+    return F::fun(std::forward<T2>(x));
+  }
 };
 
 }  // namespace math

From 3c9462e09848493ef348c683918861dd1bc83de7 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Mon, 30 Jun 2025 17:49:41 -0400
Subject: [PATCH 04/31] cleanup apply_scalar_unary

---
 stan/math/fwd/functor/apply_scalar_unary.hpp  |  7 ++++---
 stan/math/prim/fun/Phi.hpp                    |  2 +-
 stan/math/prim/fun/Phi_approx.hpp             |  2 +-
 stan/math/prim/fun/abs.hpp                    |  2 +-
 stan/math/prim/fun/acos.hpp                   |  2 +-
 stan/math/prim/fun/acosh.hpp                  |  4 ++--
 stan/math/prim/fun/asin.hpp                   |  2 +-
 stan/math/prim/fun/asinh.hpp                  |  4 ++--
 stan/math/prim/fun/atan.hpp                   |  2 +-
 stan/math/prim/fun/atanh.hpp                  |  4 ++--
 stan/math/prim/fun/cbrt.hpp                   |  2 +-
 stan/math/prim/fun/ceil.hpp                   |  2 +-
 stan/math/prim/fun/cos.hpp                    |  2 +-
 stan/math/prim/fun/cosh.hpp                   |  2 +-
 stan/math/prim/fun/digamma.hpp                |  2 +-
 stan/math/prim/fun/erf.hpp                    |  2 +-
 stan/math/prim/fun/erfc.hpp                   |  2 +-
 stan/math/prim/fun/exp.hpp                    |  2 +-
 stan/math/prim/fun/exp2.hpp                   |  2 +-
 stan/math/prim/fun/expm1.hpp                  |  2 +-
 stan/math/prim/fun/fabs.hpp                   |  2 +-
 stan/math/prim/fun/floor.hpp                  |  2 +-
 stan/math/prim/fun/inv.hpp                    |  2 +-
 stan/math/prim/fun/inv_Phi.hpp                |  2 +-
 stan/math/prim/fun/inv_cloglog.hpp            |  2 +-
 stan/math/prim/fun/inv_erfc.hpp               |  2 +-
 stan/math/prim/fun/inv_sqrt.hpp               |  4 ++--
 stan/math/prim/fun/lambert_w.hpp              |  4 ++--
 stan/math/prim/fun/lgamma.hpp                 |  2 +-
 stan/math/prim/fun/log.hpp                    |  2 +-
 stan/math/prim/fun/log10.hpp                  |  2 +-
 stan/math/prim/fun/log1m.hpp                  |  2 +-
 stan/math/prim/fun/log1m_exp.hpp              |  2 +-
 stan/math/prim/fun/log1m_inv_logit.hpp        |  2 +-
 stan/math/prim/fun/log1p.hpp                  |  2 +-
 stan/math/prim/fun/log1p_exp.hpp              |  2 +-
 stan/math/prim/fun/log2.hpp                   |  2 +-
 stan/math/prim/fun/log_inv_logit.hpp          |  2 +-
 stan/math/prim/fun/logit.hpp                  |  2 +-
 stan/math/prim/fun/round.hpp                  |  2 +-
 stan/math/prim/fun/sign.hpp                   |  2 +-
 stan/math/prim/fun/sin.hpp                    |  2 +-
 stan/math/prim/fun/sinh.hpp                   |  2 +-
 stan/math/prim/fun/sqrt.hpp                   |  2 +-
 stan/math/prim/fun/square.hpp                 |  2 +-
 stan/math/prim/fun/step.hpp                   |  2 +-
 stan/math/prim/fun/tan.hpp                    |  2 +-
 stan/math/prim/fun/tanh.hpp                   |  2 +-
 stan/math/prim/fun/tgamma.hpp                 |  2 +-
 stan/math/prim/fun/to_int.hpp                 |  2 +-
 stan/math/prim/fun/trigamma.hpp               |  2 +-
 stan/math/prim/fun/trunc.hpp                  |  2 +-
 stan/math/prim/functor/apply_scalar_unary.hpp | 14 ++++++++------
 stan/math/rev/functor/apply_scalar_unary.hpp  |  8 ++++----
 test/unit/math/test_ad_test.cpp               |  5 ++---
 55 files changed, 74 insertions(+), 72 deletions(-)

diff --git a/stan/math/fwd/functor/apply_scalar_unary.hpp b/stan/math/fwd/functor/apply_scalar_unary.hpp
index 8f37e8f8a65..a26289f836d 100644
--- a/stan/math/fwd/functor/apply_scalar_unary.hpp
+++ b/stan/math/fwd/functor/apply_scalar_unary.hpp
@@ -18,12 +18,12 @@ namespace math {
  * autodiff variable.
  */
 template <typename F, typename T>
-struct apply_scalar_unary<F, fvar<T> > {
+struct apply_scalar_unary<F, T, require_fvar_t<T>> {
   /**
    * Function return type, which is same as the argument type for
    * the function, <code>fvar&lt;T&gt;</code>.
    */
-  using return_t = fvar<T>;
+  using return_t = std::decay_t<T>;
 
   /**
    * Apply the function specified by F to the specified argument.
@@ -31,7 +31,8 @@ struct apply_scalar_unary<F, fvar<T> > {
    * @param x Argument variable.
    * @return Function applied to the variable.
    */
-  static inline return_t apply(const fvar<T>& x) { return F::fun(x); }
+  template <typename T2>
+  static inline auto apply(const T2& x) { return F::fun(x); }
 };
 
 }  // namespace math
diff --git a/stan/math/prim/fun/Phi.hpp b/stan/math/prim/fun/Phi.hpp
index 14454e98baf..c64523f232a 100644
--- a/stan/math/prim/fun/Phi.hpp
+++ b/stan/math/prim/fun/Phi.hpp
@@ -68,7 +68,7 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto Phi(T&& x) {
-  return apply_scalar_unary<Phi_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<Phi_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/Phi_approx.hpp b/stan/math/prim/fun/Phi_approx.hpp
index 465b738abd1..51a7956f578 100644
--- a/stan/math/prim/fun/Phi_approx.hpp
+++ b/stan/math/prim/fun/Phi_approx.hpp
@@ -67,7 +67,7 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto Phi_approx(T&& x) {
-  return apply_scalar_unary<Phi_approx_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<Phi_approx_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/abs.hpp b/stan/math/prim/fun/abs.hpp
index 113471b2367..fa13ff2b853 100644
--- a/stan/math/prim/fun/abs.hpp
+++ b/stan/math/prim/fun/abs.hpp
@@ -64,7 +64,7 @@ struct abs_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto abs(Container&& x) {
-  return apply_scalar_unary<abs_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<abs_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/acos.hpp b/stan/math/prim/fun/acos.hpp
index 097350a292b..b78663a587a 100644
--- a/stan/math/prim/fun/acos.hpp
+++ b/stan/math/prim/fun/acos.hpp
@@ -66,7 +66,7 @@ struct acos_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto acos(Container&& x) {
-  return apply_scalar_unary<acos_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<acos_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/acosh.hpp b/stan/math/prim/fun/acosh.hpp
index 4ff5f7a3df9..cc17dc4f8da 100644
--- a/stan/math/prim/fun/acosh.hpp
+++ b/stan/math/prim/fun/acosh.hpp
@@ -79,7 +79,7 @@ struct acosh_fun {
  */
 template <typename T, require_ad_container_t<T>* = nullptr>
 inline auto acosh(T&& x) {
-  return apply_scalar_unary<acosh_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<acosh_fun, T>::apply(
       std::forward<T>(x));
 }
 
@@ -96,7 +96,7 @@ inline auto acosh(T&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto acosh(Container&& x) {
-  return apply_scalar_unary<acosh_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<acosh_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/asin.hpp b/stan/math/prim/fun/asin.hpp
index ad6b03285a3..feb756fb4fd 100644
--- a/stan/math/prim/fun/asin.hpp
+++ b/stan/math/prim/fun/asin.hpp
@@ -64,7 +64,7 @@ struct asin_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto asin(Container&& x) {
-  return apply_scalar_unary<asin_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<asin_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/asinh.hpp b/stan/math/prim/fun/asinh.hpp
index 6db8b657b0a..499b8a14d16 100644
--- a/stan/math/prim/fun/asinh.hpp
+++ b/stan/math/prim/fun/asinh.hpp
@@ -67,7 +67,7 @@ struct asinh_fun {
  */
 template <typename T, require_ad_container_t<T>* = nullptr>
 inline auto asinh(T&& x) {
-  return apply_scalar_unary<asinh_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<asinh_fun, T>::apply(
       std::forward<T>(x));
 }
 
@@ -82,7 +82,7 @@ inline auto asinh(T&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto asinh(Container&& x) {
-  return apply_scalar_unary<asinh_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<asinh_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/atan.hpp b/stan/math/prim/fun/atan.hpp
index 976298b1a62..8366ba41428 100644
--- a/stan/math/prim/fun/atan.hpp
+++ b/stan/math/prim/fun/atan.hpp
@@ -62,7 +62,7 @@ struct atan_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto atan(Container&& x) {
-  return apply_scalar_unary<atan_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<atan_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/atanh.hpp b/stan/math/prim/fun/atanh.hpp
index 0105fe66d02..1d36ed9b469 100644
--- a/stan/math/prim/fun/atanh.hpp
+++ b/stan/math/prim/fun/atanh.hpp
@@ -78,7 +78,7 @@ struct atanh_fun {
  */
 template <typename T, require_ad_container_t<T>* = nullptr>
 inline auto atanh(T&& x) {
-  return apply_scalar_unary<atanh_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<atanh_fun, T>::apply(
       std::forward<T>(x));
 }
 
@@ -95,7 +95,7 @@ inline auto atanh(T&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto atanh(Container&& x) {
-  return apply_scalar_unary<atanh_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<atanh_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/cbrt.hpp b/stan/math/prim/fun/cbrt.hpp
index 900ddb1178a..7282bd6bb33 100644
--- a/stan/math/prim/fun/cbrt.hpp
+++ b/stan/math/prim/fun/cbrt.hpp
@@ -35,7 +35,7 @@ template <
     typename T, require_not_var_matrix_t<T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto cbrt(T&& x) {
-  return apply_scalar_unary<cbrt_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<cbrt_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/ceil.hpp b/stan/math/prim/fun/ceil.hpp
index 74fb7f4d097..2185a50b313 100644
--- a/stan/math/prim/fun/ceil.hpp
+++ b/stan/math/prim/fun/ceil.hpp
@@ -38,7 +38,7 @@ template <typename Container,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               Container>* = nullptr>
 inline auto ceil(Container&& x) {
-  return apply_scalar_unary<ceil_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<ceil_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/cos.hpp b/stan/math/prim/fun/cos.hpp
index d35764ebcfb..ae8eb3b275e 100644
--- a/stan/math/prim/fun/cos.hpp
+++ b/stan/math/prim/fun/cos.hpp
@@ -61,7 +61,7 @@ struct cos_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto cos(Container&& x) {
-  return apply_scalar_unary<cos_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<cos_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/cosh.hpp b/stan/math/prim/fun/cosh.hpp
index f909bbf859e..8a6bae2571b 100644
--- a/stan/math/prim/fun/cosh.hpp
+++ b/stan/math/prim/fun/cosh.hpp
@@ -60,7 +60,7 @@ struct cosh_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto cosh(Container&& x) {
-  return apply_scalar_unary<cosh_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<cosh_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/digamma.hpp b/stan/math/prim/fun/digamma.hpp
index 7fd91478025..10247dcb178 100644
--- a/stan/math/prim/fun/digamma.hpp
+++ b/stan/math/prim/fun/digamma.hpp
@@ -75,7 +75,7 @@ template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
 inline auto digamma(T&& x) {
-  return apply_scalar_unary<digamma_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<digamma_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/erf.hpp b/stan/math/prim/fun/erf.hpp
index 1a91648a42d..3b123411da4 100644
--- a/stan/math/prim/fun/erf.hpp
+++ b/stan/math/prim/fun/erf.hpp
@@ -36,7 +36,7 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto erf(T&& x) {
-  return apply_scalar_unary<erf_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<erf_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/erfc.hpp b/stan/math/prim/fun/erfc.hpp
index 9195b970e96..549ca8a94b5 100644
--- a/stan/math/prim/fun/erfc.hpp
+++ b/stan/math/prim/fun/erfc.hpp
@@ -37,7 +37,7 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto erfc(T&& x) {
-  return apply_scalar_unary<erfc_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<erfc_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/exp.hpp b/stan/math/prim/fun/exp.hpp
index 51e37f9e559..01ec45e5888 100644
--- a/stan/math/prim/fun/exp.hpp
+++ b/stan/math/prim/fun/exp.hpp
@@ -69,7 +69,7 @@ struct exp_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto exp(Container&& x) {
-  return apply_scalar_unary<exp_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<exp_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/exp2.hpp b/stan/math/prim/fun/exp2.hpp
index ce5fd964e92..ec2ae69bcc4 100644
--- a/stan/math/prim/fun/exp2.hpp
+++ b/stan/math/prim/fun/exp2.hpp
@@ -40,7 +40,7 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto exp2(T&& x) {
-  return apply_scalar_unary<exp2_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<exp2_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/expm1.hpp b/stan/math/prim/fun/expm1.hpp
index 1cdbdde4ed7..c37ff036a8a 100644
--- a/stan/math/prim/fun/expm1.hpp
+++ b/stan/math/prim/fun/expm1.hpp
@@ -37,7 +37,7 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto expm1(T&& x) {
-  return apply_scalar_unary<expm1_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<expm1_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/fabs.hpp b/stan/math/prim/fun/fabs.hpp
index 476fb1e7ed7..51bb3f554bd 100644
--- a/stan/math/prim/fun/fabs.hpp
+++ b/stan/math/prim/fun/fabs.hpp
@@ -49,7 +49,7 @@ template <typename Container,
               Container>* = nullptr,
           require_not_stan_scalar_t<Container>* = nullptr>
 inline auto fabs(Container&& x) {
-  return apply_scalar_unary<fabs_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<fabs_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/floor.hpp b/stan/math/prim/fun/floor.hpp
index f683c5e5130..09e7828acab 100644
--- a/stan/math/prim/fun/floor.hpp
+++ b/stan/math/prim/fun/floor.hpp
@@ -43,7 +43,7 @@ struct floor_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto floor(Container&& x) {
-  return apply_scalar_unary<floor_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<floor_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/inv.hpp b/stan/math/prim/fun/inv.hpp
index 0d710bf32bb..5789f3792a8 100644
--- a/stan/math/prim/fun/inv.hpp
+++ b/stan/math/prim/fun/inv.hpp
@@ -35,7 +35,7 @@ template <
     typename T, require_not_container_st<std::is_arithmetic, T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto inv(T&& x) {
-  return apply_scalar_unary<inv_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<inv_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/inv_Phi.hpp b/stan/math/prim/fun/inv_Phi.hpp
index 4664c3e4944..b7a81c4d86f 100644
--- a/stan/math/prim/fun/inv_Phi.hpp
+++ b/stan/math/prim/fun/inv_Phi.hpp
@@ -178,7 +178,7 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto inv_Phi(T&& x) {
-  return apply_scalar_unary<inv_Phi_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<inv_Phi_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/inv_cloglog.hpp b/stan/math/prim/fun/inv_cloglog.hpp
index 33176f5181d..714cef57b7c 100644
--- a/stan/math/prim/fun/inv_cloglog.hpp
+++ b/stan/math/prim/fun/inv_cloglog.hpp
@@ -91,7 +91,7 @@ struct inv_cloglog_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto inv_cloglog(Container&& x) {
-  return apply_scalar_unary<inv_cloglog_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<inv_cloglog_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/inv_erfc.hpp b/stan/math/prim/fun/inv_erfc.hpp
index ffc560cf543..9dce6761221 100644
--- a/stan/math/prim/fun/inv_erfc.hpp
+++ b/stan/math/prim/fun/inv_erfc.hpp
@@ -49,7 +49,7 @@ template <
     require_not_var_matrix_t<T>* = nullptr,
     require_not_arithmetic_t<T>* = nullptr>
 inline auto inv_erfc(T&& x) {
-  return apply_scalar_unary<inv_erfc_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<inv_erfc_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/inv_sqrt.hpp b/stan/math/prim/fun/inv_sqrt.hpp
index fe7163a4040..97602360827 100644
--- a/stan/math/prim/fun/inv_sqrt.hpp
+++ b/stan/math/prim/fun/inv_sqrt.hpp
@@ -46,7 +46,7 @@ struct inv_sqrt_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto inv_sqrt(Container&& x) {
-  return apply_scalar_unary<inv_sqrt_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<inv_sqrt_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
@@ -64,7 +64,7 @@ inline auto inv_sqrt(Container&& x) {
 // Eigen 3.4.0 has precision issues on ARM64 with vectorised rsqrt
 // Resolved in current master branch, below can be removed on next release
 #ifdef __aarch64__
-  return apply_scalar_unary<inv_sqrt_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<inv_sqrt_fun, Container>::apply(
       std::forward<Container>(x));
 #else
   return apply_vector_unary<std::decay_t<Container>>::apply(
diff --git a/stan/math/prim/fun/lambert_w.hpp b/stan/math/prim/fun/lambert_w.hpp
index 7353a265c2e..11be58201c9 100644
--- a/stan/math/prim/fun/lambert_w.hpp
+++ b/stan/math/prim/fun/lambert_w.hpp
@@ -81,7 +81,7 @@ struct lambert_wm1_fun {
 template <typename T, require_not_stan_scalar_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
 inline auto lambert_w0(T&& x) {
-  return apply_scalar_unary<internal::lambert_w0_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<internal::lambert_w0_fun, T>::apply(
       std::forward<T>(x));
 }
 
@@ -97,7 +97,7 @@ inline auto lambert_w0(T&& x) {
 template <typename T, require_not_stan_scalar_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
 inline auto lambert_wm1(T&& x) {
-  return apply_scalar_unary<internal::lambert_wm1_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<internal::lambert_wm1_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/lgamma.hpp b/stan/math/prim/fun/lgamma.hpp
index 6ce3826e504..bba400f83cd 100644
--- a/stan/math/prim/fun/lgamma.hpp
+++ b/stan/math/prim/fun/lgamma.hpp
@@ -117,7 +117,7 @@ struct lgamma_fun {
 template <typename T, require_not_var_matrix_t<T>* = nullptr,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto lgamma(T&& x) {
-  return apply_scalar_unary<lgamma_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<lgamma_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/log.hpp b/stan/math/prim/fun/log.hpp
index 45621a07594..d3df5d3c82d 100644
--- a/stan/math/prim/fun/log.hpp
+++ b/stan/math/prim/fun/log.hpp
@@ -68,7 +68,7 @@ struct log_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto log(Container&& x) {
-  return apply_scalar_unary<log_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<log_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/log10.hpp b/stan/math/prim/fun/log10.hpp
index 5d1dc4e4f12..6b928c39fd1 100644
--- a/stan/math/prim/fun/log10.hpp
+++ b/stan/math/prim/fun/log10.hpp
@@ -59,7 +59,7 @@ struct log10_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto log10(Container&& x) {
-  return apply_scalar_unary<log10_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<log10_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/log1m.hpp b/stan/math/prim/fun/log1m.hpp
index 92d49c20118..d2bb1d99d77 100644
--- a/stan/math/prim/fun/log1m.hpp
+++ b/stan/math/prim/fun/log1m.hpp
@@ -71,7 +71,7 @@ template <
     typename T, require_not_var_matrix_t<T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto log1m(T&& x) {
-  return apply_scalar_unary<log1m_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<log1m_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/log1m_exp.hpp b/stan/math/prim/fun/log1m_exp.hpp
index 9771ed9734f..ceb2ac42b98 100644
--- a/stan/math/prim/fun/log1m_exp.hpp
+++ b/stan/math/prim/fun/log1m_exp.hpp
@@ -81,7 +81,7 @@ template <
     typename T, require_not_var_matrix_t<T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto log1m_exp(T&& x) {
-  return apply_scalar_unary<log1m_exp_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<log1m_exp_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/log1m_inv_logit.hpp b/stan/math/prim/fun/log1m_inv_logit.hpp
index 3554fe33f7d..c43590d646d 100644
--- a/stan/math/prim/fun/log1m_inv_logit.hpp
+++ b/stan/math/prim/fun/log1m_inv_logit.hpp
@@ -83,7 +83,7 @@ struct log1m_inv_logit_fun {
 template <typename T, require_not_var_matrix_t<T>* = nullptr,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto log1m_inv_logit(T&& x) {
-  return apply_scalar_unary<log1m_inv_logit_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<log1m_inv_logit_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/log1p.hpp b/stan/math/prim/fun/log1p.hpp
index 4f337a0dedc..45318dac93b 100644
--- a/stan/math/prim/fun/log1p.hpp
+++ b/stan/math/prim/fun/log1p.hpp
@@ -80,7 +80,7 @@ template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
 inline auto log1p(T&& x) {
-  return apply_scalar_unary<log1p_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<log1p_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/log1p_exp.hpp b/stan/math/prim/fun/log1p_exp.hpp
index 2180f24e2ea..59809a69726 100644
--- a/stan/math/prim/fun/log1p_exp.hpp
+++ b/stan/math/prim/fun/log1p_exp.hpp
@@ -76,7 +76,7 @@ template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
 inline auto log1p_exp(T&& x) {
-  return apply_scalar_unary<log1p_exp_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<log1p_exp_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/log2.hpp b/stan/math/prim/fun/log2.hpp
index d77bec26820..d90012d6a68 100644
--- a/stan/math/prim/fun/log2.hpp
+++ b/stan/math/prim/fun/log2.hpp
@@ -47,7 +47,7 @@ struct log2_fun {
 template <typename T, require_not_var_matrix_t<T>* = nullptr,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto log2(T&& x) {
-  return apply_scalar_unary<log2_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<log2_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/log_inv_logit.hpp b/stan/math/prim/fun/log_inv_logit.hpp
index 11d0fa215fc..12f709d5081 100644
--- a/stan/math/prim/fun/log_inv_logit.hpp
+++ b/stan/math/prim/fun/log_inv_logit.hpp
@@ -82,7 +82,7 @@ template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
 inline auto log_inv_logit(T&& x) {
-  return apply_scalar_unary<log_inv_logit_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<log_inv_logit_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/logit.hpp b/stan/math/prim/fun/logit.hpp
index f9e6bc3fb30..22fab56a3b1 100644
--- a/stan/math/prim/fun/logit.hpp
+++ b/stan/math/prim/fun/logit.hpp
@@ -88,7 +88,7 @@ struct logit_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto logit(Container&& x) {
-  return apply_scalar_unary<logit_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<logit_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/round.hpp b/stan/math/prim/fun/round.hpp
index 120e2fa8aec..09e8a7d8ac6 100644
--- a/stan/math/prim/fun/round.hpp
+++ b/stan/math/prim/fun/round.hpp
@@ -37,7 +37,7 @@ template <typename Container,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               Container>* = nullptr>
 inline auto round(Container&& x) {
-  return apply_scalar_unary<round_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<round_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/sign.hpp b/stan/math/prim/fun/sign.hpp
index 24e2f07b126..bebe18b6861 100644
--- a/stan/math/prim/fun/sign.hpp
+++ b/stan/math/prim/fun/sign.hpp
@@ -40,7 +40,7 @@ struct sign_fun {
  */
 template <typename T, require_container_t<T>* = nullptr>
 inline auto sign(T&& x) {
-  return apply_scalar_unary<sign_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<sign_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/sin.hpp b/stan/math/prim/fun/sin.hpp
index f9b05bdc91d..185efbb18ee 100644
--- a/stan/math/prim/fun/sin.hpp
+++ b/stan/math/prim/fun/sin.hpp
@@ -60,7 +60,7 @@ struct sin_fun {
  */
 template <typename T, require_ad_container_t<T>* = nullptr>
 inline auto sin(T&& x) {
-  return apply_scalar_unary<sin_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<sin_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/sinh.hpp b/stan/math/prim/fun/sinh.hpp
index b7258a0622a..a6a8f93c09d 100644
--- a/stan/math/prim/fun/sinh.hpp
+++ b/stan/math/prim/fun/sinh.hpp
@@ -58,7 +58,7 @@ struct sinh_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto sinh(Container&& x) {
-  return apply_scalar_unary<sinh_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<sinh_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/sqrt.hpp b/stan/math/prim/fun/sqrt.hpp
index f68dd39d2a8..75c680373a2 100644
--- a/stan/math/prim/fun/sqrt.hpp
+++ b/stan/math/prim/fun/sqrt.hpp
@@ -58,7 +58,7 @@ struct sqrt_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto sqrt(Container&& x) {
-  return apply_scalar_unary<sqrt_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<sqrt_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/square.hpp b/stan/math/prim/fun/square.hpp
index c16f8bd7ad0..10859a54beb 100644
--- a/stan/math/prim/fun/square.hpp
+++ b/stan/math/prim/fun/square.hpp
@@ -51,7 +51,7 @@ struct square_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto square(Container&& x) {
-  return apply_scalar_unary<square_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<square_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/step.hpp b/stan/math/prim/fun/step.hpp
index dcc7a8263bc..fe5f1ce2ca6 100644
--- a/stan/math/prim/fun/step.hpp
+++ b/stan/math/prim/fun/step.hpp
@@ -59,7 +59,7 @@ struct step_fun {
  */
 template <typename T, require_container_t<T>* = nullptr>
 inline auto step(T&& x) {
-  return apply_scalar_unary<step_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<step_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/tan.hpp b/stan/math/prim/fun/tan.hpp
index 9e73c8ffcfe..9c1d758bc3a 100644
--- a/stan/math/prim/fun/tan.hpp
+++ b/stan/math/prim/fun/tan.hpp
@@ -60,7 +60,7 @@ struct tan_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto tan(Container&& x) {
-  return apply_scalar_unary<tan_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<tan_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/tanh.hpp b/stan/math/prim/fun/tanh.hpp
index c5fe4930240..bcc25653ab3 100644
--- a/stan/math/prim/fun/tanh.hpp
+++ b/stan/math/prim/fun/tanh.hpp
@@ -60,7 +60,7 @@ struct tanh_fun {
  */
 template <typename Container, require_ad_container_t<Container>* = nullptr>
 inline auto tanh(Container&& x) {
-  return apply_scalar_unary<tanh_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<tanh_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/tgamma.hpp b/stan/math/prim/fun/tgamma.hpp
index 354eb55de21..fcee0906258 100644
--- a/stan/math/prim/fun/tgamma.hpp
+++ b/stan/math/prim/fun/tgamma.hpp
@@ -51,7 +51,7 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto tgamma(T&& x) {
-  return apply_scalar_unary<tgamma_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<tgamma_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/to_int.hpp b/stan/math/prim/fun/to_int.hpp
index a08474faa8a..29db2daa96b 100644
--- a/stan/math/prim/fun/to_int.hpp
+++ b/stan/math/prim/fun/to_int.hpp
@@ -72,7 +72,7 @@ struct to_int_fun {
 template <typename Container,
           require_std_vector_st<std::is_arithmetic, Container>* = nullptr>
 inline auto to_int(Container&& x) {
-  return apply_scalar_unary<to_int_fun, std::decay_t<Container>>::apply(
+  return apply_scalar_unary<to_int_fun, Container>::apply(
       std::forward<Container>(x));
 }
 
diff --git a/stan/math/prim/fun/trigamma.hpp b/stan/math/prim/fun/trigamma.hpp
index 07dae79ef85..0f0b2e5a23c 100644
--- a/stan/math/prim/fun/trigamma.hpp
+++ b/stan/math/prim/fun/trigamma.hpp
@@ -156,7 +156,7 @@ struct trigamma_fun {
 template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto trigamma(T&& x) {
-  return apply_scalar_unary<trigamma_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<trigamma_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/fun/trunc.hpp b/stan/math/prim/fun/trunc.hpp
index 71c417a91fd..bce409943fa 100644
--- a/stan/math/prim/fun/trunc.hpp
+++ b/stan/math/prim/fun/trunc.hpp
@@ -40,7 +40,7 @@ struct trunc_fun {
 template <typename T, require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
                           T>* = nullptr>
 inline auto trunc(T&& x) {
-  return apply_scalar_unary<trunc_fun, std::decay_t<T>>::apply(
+  return apply_scalar_unary<trunc_fun, T>::apply(
       std::forward<T>(x));
 }
 
diff --git a/stan/math/prim/functor/apply_scalar_unary.hpp b/stan/math/prim/functor/apply_scalar_unary.hpp
index 73deb13b607..94d0ea6838a 100644
--- a/stan/math/prim/functor/apply_scalar_unary.hpp
+++ b/stan/math/prim/functor/apply_scalar_unary.hpp
@@ -63,8 +63,7 @@ struct apply_scalar_unary<F, T, require_eigen_t<T>> {
     return make_holder(
         [](auto&& xx) {
           return std::forward<decltype(xx)>(xx).unaryExpr([](auto&& xxx) {
-            return apply_scalar_unary<F, std::decay_t<decltype(xxx)>>::apply(
-                xxx);
+            return apply_scalar_unary<F, decltype(xxx)>::apply(xxx);
           });
         },
         std::forward<TT>(x));
@@ -75,7 +74,7 @@ struct apply_scalar_unary<F, T, require_eigen_t<T>> {
    * expression template of type T.
    */
   using return_t = std::decay_t<decltype(
-      apply_scalar_unary<F, std::decay_t<T>>::apply(std::declval<T>()))>;
+      apply_scalar_unary<F, T>::apply(std::declval<T>()))>;
 };
 
 /**
@@ -101,7 +100,8 @@ struct apply_scalar_unary<F, T, require_floating_point_t<T>> {
    * @param x Argument scalar.
    * @return Result of applying F to the scalar.
    */
-  static inline auto apply(T x) { return F::fun(x); }
+  template <typename T2>
+  static inline auto apply(T2 x) { return F::fun(x); }
 };
 
 /**
@@ -121,7 +121,8 @@ struct apply_scalar_unary<F, T, require_complex_t<T>> {
    * @param x Argument scalar.
    * @return Result of applying F to the scalar.
    */
-  static inline auto apply(const std::decay_t<T>& x) { return F::fun(x); }
+  template <typename T2>
+  static inline auto apply(const T2& x) { return F::fun(x); }
   /**
    * The return type
    */
@@ -148,7 +149,8 @@ struct apply_scalar_unary<F, T, require_integral_t<T>> {
    * @param x Argument scalar.
    * @return Result of applying F to the scalar.
    */
-  static inline auto apply(T x) { return F::fun(x); }
+  template <typename T2>
+  static inline auto apply(T2 x) { return F::fun(x); }
   /**
    * The return type, double.
    */
diff --git a/stan/math/rev/functor/apply_scalar_unary.hpp b/stan/math/rev/functor/apply_scalar_unary.hpp
index eeba3e8cab9..78b159e6549 100644
--- a/stan/math/rev/functor/apply_scalar_unary.hpp
+++ b/stan/math/rev/functor/apply_scalar_unary.hpp
@@ -15,8 +15,8 @@ namespace math {
  *
  * @tparam F Type of function to apply.
  */
-template <typename F>
-struct apply_scalar_unary<F, var> {
+template <typename F, typename T>
+struct apply_scalar_unary<F, T, std::enable_if_t<is_var<T>::value && is_stan_scalar<T>::value>> {
   /**
    * Function return type, which is <code>var</code>.
    */
@@ -28,7 +28,7 @@ struct apply_scalar_unary<F, var> {
    * @param x Argument variable.
    * @return Function applied to the variable.
    */
-  static inline return_t apply(const var& x) { return F::fun(x); }
+  static inline auto apply(const var& x) { return F::fun(x); }
 };
 
 template <typename F, typename T>
@@ -45,7 +45,7 @@ struct apply_scalar_unary<F, T, require_var_matrix_t<T>> {
    * @return Function applied to the variable.
    */
   template <typename T2>
-  static inline return_t apply(T2&& x) {
+  static inline auto apply(T2&& x) {
     return F::fun(std::forward<T2>(x));
   }
 };
diff --git a/test/unit/math/test_ad_test.cpp b/test/unit/math/test_ad_test.cpp
index 65d42abc3f1..d77fdaafd30 100644
--- a/test/unit/math/test_ad_test.cpp
+++ b/test/unit/math/test_ad_test.cpp
@@ -274,9 +274,8 @@ struct baz_fun {
 };
 
 template <typename T>
-inline typename stan::math::apply_scalar_unary<baz_fun, T>::return_t baz(
-    const T& x) {
-  return stan::math::apply_scalar_unary<baz_fun, T>::apply(x);
+inline auto baz(T&& x) {
+  return stan::math::apply_scalar_unary<baz_fun, T>::apply(std::forward<T>(x));
 }
 
 TEST(testAd, integerGetsPassedVectorized) {

From 5dd0f62fbdc02d5e21c757742bac67abd65dc174 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Mon, 30 Jun 2025 17:51:21 -0400
Subject: [PATCH 05/31] [Jenkins] auto-formatting by clang-format version
 10.0.0-4ubuntu1

---
 stan/math/fwd/functor/apply_scalar_unary.hpp  |  4 +++-
 stan/math/prim/fun/Phi.hpp                    |  3 +--
 stan/math/prim/fun/Phi_approx.hpp             |  3 +--
 stan/math/prim/fun/acosh.hpp                  |  3 +--
 stan/math/prim/fun/asinh.hpp                  |  3 +--
 stan/math/prim/fun/atanh.hpp                  |  3 +--
 stan/math/prim/fun/cbrt.hpp                   |  3 +--
 stan/math/prim/fun/digamma.hpp                |  3 +--
 stan/math/prim/fun/erf.hpp                    |  3 +--
 stan/math/prim/fun/erfc.hpp                   |  3 +--
 stan/math/prim/fun/exp2.hpp                   |  3 +--
 stan/math/prim/fun/expm1.hpp                  |  3 +--
 stan/math/prim/fun/inv.hpp                    |  3 +--
 stan/math/prim/fun/inv_Phi.hpp                |  3 +--
 stan/math/prim/fun/inv_erfc.hpp               |  3 +--
 stan/math/prim/fun/inv_sqrt.hpp               |  2 +-
 stan/math/prim/fun/lgamma.hpp                 |  3 +--
 stan/math/prim/fun/log1m.hpp                  |  3 +--
 stan/math/prim/fun/log1m_exp.hpp              |  3 +--
 stan/math/prim/fun/log1m_inv_logit.hpp        |  3 +--
 stan/math/prim/fun/log1p.hpp                  |  3 +--
 stan/math/prim/fun/log1p_exp.hpp              |  3 +--
 stan/math/prim/fun/log2.hpp                   |  3 +--
 stan/math/prim/fun/log_inv_logit.hpp          |  3 +--
 stan/math/prim/fun/sign.hpp                   |  3 +--
 stan/math/prim/fun/sin.hpp                    |  3 +--
 stan/math/prim/fun/step.hpp                   |  3 +--
 stan/math/prim/fun/tgamma.hpp                 |  3 +--
 stan/math/prim/fun/trigamma.hpp               |  3 +--
 stan/math/prim/fun/trunc.hpp                  |  3 +--
 stan/math/prim/functor/apply_scalar_unary.hpp | 12 +++++++++---
 stan/math/rev/functor/apply_scalar_unary.hpp  |  3 ++-
 32 files changed, 43 insertions(+), 62 deletions(-)

diff --git a/stan/math/fwd/functor/apply_scalar_unary.hpp b/stan/math/fwd/functor/apply_scalar_unary.hpp
index a26289f836d..ac9b067ee55 100644
--- a/stan/math/fwd/functor/apply_scalar_unary.hpp
+++ b/stan/math/fwd/functor/apply_scalar_unary.hpp
@@ -32,7 +32,9 @@ struct apply_scalar_unary<F, T, require_fvar_t<T>> {
    * @return Function applied to the variable.
    */
   template <typename T2>
-  static inline auto apply(const T2& x) { return F::fun(x); }
+  static inline auto apply(const T2& x) {
+    return F::fun(x);
+  }
 };
 
 }  // namespace math
diff --git a/stan/math/prim/fun/Phi.hpp b/stan/math/prim/fun/Phi.hpp
index c64523f232a..5c43bf30df1 100644
--- a/stan/math/prim/fun/Phi.hpp
+++ b/stan/math/prim/fun/Phi.hpp
@@ -68,8 +68,7 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto Phi(T&& x) {
-  return apply_scalar_unary<Phi_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<Phi_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/Phi_approx.hpp b/stan/math/prim/fun/Phi_approx.hpp
index 51a7956f578..0fd1ce6a5ae 100644
--- a/stan/math/prim/fun/Phi_approx.hpp
+++ b/stan/math/prim/fun/Phi_approx.hpp
@@ -67,8 +67,7 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto Phi_approx(T&& x) {
-  return apply_scalar_unary<Phi_approx_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<Phi_approx_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/acosh.hpp b/stan/math/prim/fun/acosh.hpp
index cc17dc4f8da..a85097c236b 100644
--- a/stan/math/prim/fun/acosh.hpp
+++ b/stan/math/prim/fun/acosh.hpp
@@ -79,8 +79,7 @@ struct acosh_fun {
  */
 template <typename T, require_ad_container_t<T>* = nullptr>
 inline auto acosh(T&& x) {
-  return apply_scalar_unary<acosh_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<acosh_fun, T>::apply(std::forward<T>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/asinh.hpp b/stan/math/prim/fun/asinh.hpp
index 499b8a14d16..fda581b1c86 100644
--- a/stan/math/prim/fun/asinh.hpp
+++ b/stan/math/prim/fun/asinh.hpp
@@ -67,8 +67,7 @@ struct asinh_fun {
  */
 template <typename T, require_ad_container_t<T>* = nullptr>
 inline auto asinh(T&& x) {
-  return apply_scalar_unary<asinh_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<asinh_fun, T>::apply(std::forward<T>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/atanh.hpp b/stan/math/prim/fun/atanh.hpp
index 1d36ed9b469..c879135575c 100644
--- a/stan/math/prim/fun/atanh.hpp
+++ b/stan/math/prim/fun/atanh.hpp
@@ -78,8 +78,7 @@ struct atanh_fun {
  */
 template <typename T, require_ad_container_t<T>* = nullptr>
 inline auto atanh(T&& x) {
-  return apply_scalar_unary<atanh_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<atanh_fun, T>::apply(std::forward<T>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/cbrt.hpp b/stan/math/prim/fun/cbrt.hpp
index 7282bd6bb33..5cbe85b6276 100644
--- a/stan/math/prim/fun/cbrt.hpp
+++ b/stan/math/prim/fun/cbrt.hpp
@@ -35,8 +35,7 @@ template <
     typename T, require_not_var_matrix_t<T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto cbrt(T&& x) {
-  return apply_scalar_unary<cbrt_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<cbrt_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/digamma.hpp b/stan/math/prim/fun/digamma.hpp
index 10247dcb178..dc9d3e57645 100644
--- a/stan/math/prim/fun/digamma.hpp
+++ b/stan/math/prim/fun/digamma.hpp
@@ -75,8 +75,7 @@ template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
 inline auto digamma(T&& x) {
-  return apply_scalar_unary<digamma_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<digamma_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/erf.hpp b/stan/math/prim/fun/erf.hpp
index 3b123411da4..51cab1c72f0 100644
--- a/stan/math/prim/fun/erf.hpp
+++ b/stan/math/prim/fun/erf.hpp
@@ -36,8 +36,7 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto erf(T&& x) {
-  return apply_scalar_unary<erf_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<erf_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/erfc.hpp b/stan/math/prim/fun/erfc.hpp
index 549ca8a94b5..53955a11161 100644
--- a/stan/math/prim/fun/erfc.hpp
+++ b/stan/math/prim/fun/erfc.hpp
@@ -37,8 +37,7 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto erfc(T&& x) {
-  return apply_scalar_unary<erfc_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<erfc_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/exp2.hpp b/stan/math/prim/fun/exp2.hpp
index ec2ae69bcc4..4f6dff50e9e 100644
--- a/stan/math/prim/fun/exp2.hpp
+++ b/stan/math/prim/fun/exp2.hpp
@@ -40,8 +40,7 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto exp2(T&& x) {
-  return apply_scalar_unary<exp2_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<exp2_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/expm1.hpp b/stan/math/prim/fun/expm1.hpp
index c37ff036a8a..ce0fefa8b91 100644
--- a/stan/math/prim/fun/expm1.hpp
+++ b/stan/math/prim/fun/expm1.hpp
@@ -37,8 +37,7 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto expm1(T&& x) {
-  return apply_scalar_unary<expm1_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<expm1_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/inv.hpp b/stan/math/prim/fun/inv.hpp
index 5789f3792a8..72d2cd26733 100644
--- a/stan/math/prim/fun/inv.hpp
+++ b/stan/math/prim/fun/inv.hpp
@@ -35,8 +35,7 @@ template <
     typename T, require_not_container_st<std::is_arithmetic, T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto inv(T&& x) {
-  return apply_scalar_unary<inv_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<inv_fun, T>::apply(std::forward<T>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/inv_Phi.hpp b/stan/math/prim/fun/inv_Phi.hpp
index b7a81c4d86f..b4f295bd315 100644
--- a/stan/math/prim/fun/inv_Phi.hpp
+++ b/stan/math/prim/fun/inv_Phi.hpp
@@ -178,8 +178,7 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto inv_Phi(T&& x) {
-  return apply_scalar_unary<inv_Phi_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<inv_Phi_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/inv_erfc.hpp b/stan/math/prim/fun/inv_erfc.hpp
index 9dce6761221..1b105c1ba87 100644
--- a/stan/math/prim/fun/inv_erfc.hpp
+++ b/stan/math/prim/fun/inv_erfc.hpp
@@ -49,8 +49,7 @@ template <
     require_not_var_matrix_t<T>* = nullptr,
     require_not_arithmetic_t<T>* = nullptr>
 inline auto inv_erfc(T&& x) {
-  return apply_scalar_unary<inv_erfc_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<inv_erfc_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/inv_sqrt.hpp b/stan/math/prim/fun/inv_sqrt.hpp
index 97602360827..527751a709a 100644
--- a/stan/math/prim/fun/inv_sqrt.hpp
+++ b/stan/math/prim/fun/inv_sqrt.hpp
@@ -67,7 +67,7 @@ inline auto inv_sqrt(Container&& x) {
   return apply_scalar_unary<inv_sqrt_fun, Container>::apply(
       std::forward<Container>(x));
 #else
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<std::decay_t<Container> >::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().rsqrt(); });
 #endif
diff --git a/stan/math/prim/fun/lgamma.hpp b/stan/math/prim/fun/lgamma.hpp
index bba400f83cd..4540a341e2c 100644
--- a/stan/math/prim/fun/lgamma.hpp
+++ b/stan/math/prim/fun/lgamma.hpp
@@ -117,8 +117,7 @@ struct lgamma_fun {
 template <typename T, require_not_var_matrix_t<T>* = nullptr,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto lgamma(T&& x) {
-  return apply_scalar_unary<lgamma_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<lgamma_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log1m.hpp b/stan/math/prim/fun/log1m.hpp
index d2bb1d99d77..3943c16dbb5 100644
--- a/stan/math/prim/fun/log1m.hpp
+++ b/stan/math/prim/fun/log1m.hpp
@@ -71,8 +71,7 @@ template <
     typename T, require_not_var_matrix_t<T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto log1m(T&& x) {
-  return apply_scalar_unary<log1m_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<log1m_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log1m_exp.hpp b/stan/math/prim/fun/log1m_exp.hpp
index ceb2ac42b98..737a0bc4080 100644
--- a/stan/math/prim/fun/log1m_exp.hpp
+++ b/stan/math/prim/fun/log1m_exp.hpp
@@ -81,8 +81,7 @@ template <
     typename T, require_not_var_matrix_t<T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto log1m_exp(T&& x) {
-  return apply_scalar_unary<log1m_exp_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<log1m_exp_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log1m_inv_logit.hpp b/stan/math/prim/fun/log1m_inv_logit.hpp
index c43590d646d..fed956ea3bd 100644
--- a/stan/math/prim/fun/log1m_inv_logit.hpp
+++ b/stan/math/prim/fun/log1m_inv_logit.hpp
@@ -83,8 +83,7 @@ struct log1m_inv_logit_fun {
 template <typename T, require_not_var_matrix_t<T>* = nullptr,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto log1m_inv_logit(T&& x) {
-  return apply_scalar_unary<log1m_inv_logit_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<log1m_inv_logit_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log1p.hpp b/stan/math/prim/fun/log1p.hpp
index 45318dac93b..66752bfeca6 100644
--- a/stan/math/prim/fun/log1p.hpp
+++ b/stan/math/prim/fun/log1p.hpp
@@ -80,8 +80,7 @@ template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
 inline auto log1p(T&& x) {
-  return apply_scalar_unary<log1p_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<log1p_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log1p_exp.hpp b/stan/math/prim/fun/log1p_exp.hpp
index 59809a69726..d69a1d1c059 100644
--- a/stan/math/prim/fun/log1p_exp.hpp
+++ b/stan/math/prim/fun/log1p_exp.hpp
@@ -76,8 +76,7 @@ template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
 inline auto log1p_exp(T&& x) {
-  return apply_scalar_unary<log1p_exp_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<log1p_exp_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log2.hpp b/stan/math/prim/fun/log2.hpp
index d90012d6a68..ab294e80a5b 100644
--- a/stan/math/prim/fun/log2.hpp
+++ b/stan/math/prim/fun/log2.hpp
@@ -47,8 +47,7 @@ struct log2_fun {
 template <typename T, require_not_var_matrix_t<T>* = nullptr,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto log2(T&& x) {
-  return apply_scalar_unary<log2_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<log2_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_inv_logit.hpp b/stan/math/prim/fun/log_inv_logit.hpp
index 12f709d5081..002a02a22c1 100644
--- a/stan/math/prim/fun/log_inv_logit.hpp
+++ b/stan/math/prim/fun/log_inv_logit.hpp
@@ -82,8 +82,7 @@ template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
           require_not_var_matrix_t<T>* = nullptr>
 inline auto log_inv_logit(T&& x) {
-  return apply_scalar_unary<log_inv_logit_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<log_inv_logit_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sign.hpp b/stan/math/prim/fun/sign.hpp
index bebe18b6861..3d525c1afef 100644
--- a/stan/math/prim/fun/sign.hpp
+++ b/stan/math/prim/fun/sign.hpp
@@ -40,8 +40,7 @@ struct sign_fun {
  */
 template <typename T, require_container_t<T>* = nullptr>
 inline auto sign(T&& x) {
-  return apply_scalar_unary<sign_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<sign_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sin.hpp b/stan/math/prim/fun/sin.hpp
index 185efbb18ee..850bbcabc9f 100644
--- a/stan/math/prim/fun/sin.hpp
+++ b/stan/math/prim/fun/sin.hpp
@@ -60,8 +60,7 @@ struct sin_fun {
  */
 template <typename T, require_ad_container_t<T>* = nullptr>
 inline auto sin(T&& x) {
-  return apply_scalar_unary<sin_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<sin_fun, T>::apply(std::forward<T>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/step.hpp b/stan/math/prim/fun/step.hpp
index fe5f1ce2ca6..d2663f0b2ee 100644
--- a/stan/math/prim/fun/step.hpp
+++ b/stan/math/prim/fun/step.hpp
@@ -59,8 +59,7 @@ struct step_fun {
  */
 template <typename T, require_container_t<T>* = nullptr>
 inline auto step(T&& x) {
-  return apply_scalar_unary<step_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<step_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/tgamma.hpp b/stan/math/prim/fun/tgamma.hpp
index fcee0906258..a37da4ef511 100644
--- a/stan/math/prim/fun/tgamma.hpp
+++ b/stan/math/prim/fun/tgamma.hpp
@@ -51,8 +51,7 @@ template <
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr>
 inline auto tgamma(T&& x) {
-  return apply_scalar_unary<tgamma_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<tgamma_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/trigamma.hpp b/stan/math/prim/fun/trigamma.hpp
index 0f0b2e5a23c..372eb6cbc6c 100644
--- a/stan/math/prim/fun/trigamma.hpp
+++ b/stan/math/prim/fun/trigamma.hpp
@@ -156,8 +156,7 @@ struct trigamma_fun {
 template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
 inline auto trigamma(T&& x) {
-  return apply_scalar_unary<trigamma_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<trigamma_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/trunc.hpp b/stan/math/prim/fun/trunc.hpp
index bce409943fa..631e7e44deb 100644
--- a/stan/math/prim/fun/trunc.hpp
+++ b/stan/math/prim/fun/trunc.hpp
@@ -40,8 +40,7 @@ struct trunc_fun {
 template <typename T, require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
                           T>* = nullptr>
 inline auto trunc(T&& x) {
-  return apply_scalar_unary<trunc_fun, T>::apply(
-      std::forward<T>(x));
+  return apply_scalar_unary<trunc_fun, T>::apply(std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/functor/apply_scalar_unary.hpp b/stan/math/prim/functor/apply_scalar_unary.hpp
index 94d0ea6838a..cad17ca8301 100644
--- a/stan/math/prim/functor/apply_scalar_unary.hpp
+++ b/stan/math/prim/functor/apply_scalar_unary.hpp
@@ -101,7 +101,9 @@ struct apply_scalar_unary<F, T, require_floating_point_t<T>> {
    * @return Result of applying F to the scalar.
    */
   template <typename T2>
-  static inline auto apply(T2 x) { return F::fun(x); }
+  static inline auto apply(T2 x) {
+    return F::fun(x);
+  }
 };
 
 /**
@@ -122,7 +124,9 @@ struct apply_scalar_unary<F, T, require_complex_t<T>> {
    * @return Result of applying F to the scalar.
    */
   template <typename T2>
-  static inline auto apply(const T2& x) { return F::fun(x); }
+  static inline auto apply(const T2& x) {
+    return F::fun(x);
+  }
   /**
    * The return type
    */
@@ -150,7 +154,9 @@ struct apply_scalar_unary<F, T, require_integral_t<T>> {
    * @return Result of applying F to the scalar.
    */
   template <typename T2>
-  static inline auto apply(T2 x) { return F::fun(x); }
+  static inline auto apply(T2 x) {
+    return F::fun(x);
+  }
   /**
    * The return type, double.
    */
diff --git a/stan/math/rev/functor/apply_scalar_unary.hpp b/stan/math/rev/functor/apply_scalar_unary.hpp
index 78b159e6549..d00f8092d9a 100644
--- a/stan/math/rev/functor/apply_scalar_unary.hpp
+++ b/stan/math/rev/functor/apply_scalar_unary.hpp
@@ -16,7 +16,8 @@ namespace math {
  * @tparam F Type of function to apply.
  */
 template <typename F, typename T>
-struct apply_scalar_unary<F, T, std::enable_if_t<is_var<T>::value && is_stan_scalar<T>::value>> {
+struct apply_scalar_unary<
+    F, T, std::enable_if_t<is_var<T>::value && is_stan_scalar<T>::value>> {
   /**
    * Function return type, which is <code>var</code>.
    */

From 589895dff3d7a184d678ea62c86f485ba7e55ab0 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Mon, 30 Jun 2025 20:08:33 -0400
Subject: [PATCH 06/31] update sum_to_zero

---
 .../rev/constraint/sum_to_zero_constrain.hpp  | 29 -------------------
 1 file changed, 29 deletions(-)

diff --git a/stan/math/rev/constraint/sum_to_zero_constrain.hpp b/stan/math/rev/constraint/sum_to_zero_constrain.hpp
index 5e62b560894..e0288e7370e 100644
--- a/stan/math/rev/constraint/sum_to_zero_constrain.hpp
+++ b/stan/math/rev/constraint/sum_to_zero_constrain.hpp
@@ -138,35 +138,6 @@ inline auto sum_to_zero_constrain(T&& x) {
   return arena_z;
 }
 
-/**
- * Return a vector with sum zero corresponding to the specified
- * free vector.
- *
- * The sum-to-zero transform is defined using a modified version of
- * the inverse of the isometric log ratio transform (ILR).
- * See:
- * Egozcue, Juan Jose; Pawlowsky-Glahn, Vera; Mateu-Figueras, Gloria;
- * Barcelo-Vidal, Carles (2003), "Isometric logratio transformations for
- * compositional data analysis", Mathematical Geology, 35 (3): 279–300,
- * doi:10.1023/A:1023818214614, S2CID 122844634
- *
- * This implementation is closer to the description of the same using "pivot
- * coordinates" in
- * Filzmoser, P., Hron, K., Templ, M. (2018). Geometrical Properties of
- * Compositional Data. In: Applied Compositional Data Analysis. Springer Series
- * in Statistics. Springer, Cham. https://doi.org/10.1007/978-3-319-96422-5_3
- *
- * This is a linear transform, with no Jacobian.
- *
- * @tparam T type of the vector or matrix
- * @param y Free vector or matrix.
- * @param lp unused
- * @return Zero-sum vector or matrix which is one larger in each dimension
- */
-template <typename T, typename Lp, is_rev_matrix<T>* = nullptr>
-inline auto sum_to_zero_constrain(T&& y, Lp& lp) {
-  return sum_to_zero_constrain(std::forward<T>(y));
-}
 
 }  // namespace math
 }  // namespace stan

From deec65ae52c3e50a2b3025e6583246cd804a09d6 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Mon, 30 Jun 2025 20:09:36 -0400
Subject: [PATCH 07/31] [Jenkins] auto-formatting by clang-format version
 10.0.0-4ubuntu1

---
 stan/math/rev/constraint/sum_to_zero_constrain.hpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/stan/math/rev/constraint/sum_to_zero_constrain.hpp b/stan/math/rev/constraint/sum_to_zero_constrain.hpp
index e0288e7370e..6a06d215814 100644
--- a/stan/math/rev/constraint/sum_to_zero_constrain.hpp
+++ b/stan/math/rev/constraint/sum_to_zero_constrain.hpp
@@ -138,7 +138,6 @@ inline auto sum_to_zero_constrain(T&& x) {
   return arena_z;
 }
 
-
 }  // namespace math
 }  // namespace stan
 #endif

From 8a824c916032385caebc086eff329953a9f63dc9 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Tue, 1 Jul 2025 00:17:06 -0400
Subject: [PATCH 08/31] fix mu and sigma ref

---
 stan/math/prim/constraint/offset_multiplier_free.hpp | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/stan/math/prim/constraint/offset_multiplier_free.hpp b/stan/math/prim/constraint/offset_multiplier_free.hpp
index e61c1046f4a..d7e7161c953 100644
--- a/stan/math/prim/constraint/offset_multiplier_free.hpp
+++ b/stan/math/prim/constraint/offset_multiplier_free.hpp
@@ -59,8 +59,7 @@ inline auto offset_multiplier_free(T&& y, M&& mu, S&& sigma) {
   check_positive_finite("offset_multiplier_constrain", "multiplier",
                         value_of(sigma_ref));
   return stan::math::eval(
-      divide(subtract(std::forward<T>(y), std::forward<M>(mu_ref)),
-             std::forward<S>(sigma_ref)));
+      divide(subtract(std::forward<T>(y), mu_ref), sigma_ref));
 }
 
 /**

From 5fffe240de6db59900bd1379f0751b0e92c35bea Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Tue, 1 Jul 2025 09:06:42 -0400
Subject: [PATCH 09/31] update offset_multiplier_free requires

---
 stan/math/prim/constraint/offset_multiplier_free.hpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/stan/math/prim/constraint/offset_multiplier_free.hpp b/stan/math/prim/constraint/offset_multiplier_free.hpp
index d7e7161c953..90d81a1745a 100644
--- a/stan/math/prim/constraint/offset_multiplier_free.hpp
+++ b/stan/math/prim/constraint/offset_multiplier_free.hpp
@@ -40,8 +40,7 @@ namespace math {
  * @throw std::invalid_argument if non-scalar arguments don't match in size
  */
 template <typename T, typename M, typename S,
-          require_all_not_std_vector_t<T, M, S>* = nullptr,
-          require_all_not_st_var<T, M, S>* = nullptr>
+          require_all_not_std_vector_t<T, M, S>* = nullptr>
 inline auto offset_multiplier_free(T&& y, M&& mu, S&& sigma) {
   auto&& mu_ref = to_ref(std::forward<M>(mu));
   auto&& sigma_ref = to_ref(std::forward<S>(sigma));
@@ -86,13 +85,13 @@ inline auto offset_multiplier_free(T&& x, M&& mu, S&& sigma) {
 template <typename T, typename M, typename S,
           require_all_std_vector_t<T, S>* = nullptr,
           require_not_std_vector_t<M>* = nullptr>
-inline auto offset_multiplier_free(T&& x, const M& mu, S&& sigma) {
+inline auto offset_multiplier_free(T&& x, M&& mu, S&& sigma) {
   check_matching_dims("offset_multiplier_free", "x", x, "sigma", sigma);
   std::vector<
       plain_type_t<decltype(offset_multiplier_free(x[0], mu, sigma[0]))>>
       ret;
   ret.reserve(x.size());
-  const auto& mu_ref = to_ref(mu);
+  auto&& mu_ref = to_ref(std::forward<M>(mu));
   for (size_t i = 0; i < x.size(); ++i) {
     ret.emplace_back(offset_multiplier_free(x[i], mu_ref, sigma[i]));
   }

From 80dbe6c35d5fe6aa5a840c30539f34301ede647a Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Tue, 1 Jul 2025 15:36:24 -0400
Subject: [PATCH 10/31] update functions with holder

---
 stan/math/fwd/fun/log_softmax.hpp             | 19 +++----
 stan/math/fwd/functor/apply_scalar_unary.hpp  |  4 +-
 .../constraint/cholesky_corr_constrain.hpp    | 12 ++---
 .../prim/constraint/cholesky_corr_free.hpp    | 10 ++--
 .../constraint/cholesky_factor_constrain.hpp  | 14 ++---
 .../prim/constraint/cholesky_factor_free.hpp  | 17 +++---
 stan/math/prim/constraint/corr_constrain.hpp  |  2 +-
 .../prim/constraint/corr_matrix_constrain.hpp |  4 +-
 .../math/prim/constraint/corr_matrix_free.hpp |  6 +--
 .../prim/constraint/cov_matrix_constrain.hpp  |  4 +-
 .../constraint/cov_matrix_constrain_lkj.hpp   |  2 +-
 stan/math/prim/constraint/cov_matrix_free.hpp |  2 +-
 .../prim/constraint/cov_matrix_free_lkj.hpp   |  7 ++-
 stan/math/prim/constraint/lb_constrain.hpp    |  6 +--
 .../offset_multiplier_constrain.hpp           | 28 +++++-----
 .../constraint/offset_multiplier_free.hpp     | 18 ++++---
 .../prim/constraint/ordered_constrain.hpp     |  4 +-
 stan/math/prim/constraint/ordered_free.hpp    |  2 +-
 .../prim/constraint/positive_constrain.hpp    |  2 +-
 .../constraint/positive_ordered_constrain.hpp |  4 +-
 .../prim/constraint/positive_ordered_free.hpp |  2 +-
 .../prim/constraint/simplex_constrain.hpp     |  8 +--
 stan/math/prim/constraint/simplex_free.hpp    |  2 +-
 .../stochastic_column_constrain.hpp           |  8 +--
 .../constraint/stochastic_column_free.hpp     |  2 +-
 .../constraint/stochastic_row_constrain.hpp   |  8 +--
 .../prim/constraint/stochastic_row_free.hpp   |  2 +-
 .../prim/constraint/sum_to_zero_constrain.hpp |  4 +-
 .../math/prim/constraint/sum_to_zero_free.hpp |  2 +-
 stan/math/prim/constraint/ub_constrain.hpp    | 25 +++++----
 stan/math/prim/constraint/ub_free.hpp         |  2 +-
 .../prim/constraint/unit_vector_constrain.hpp | 18 ++++---
 .../math/prim/constraint/unit_vector_free.hpp |  4 +-
 stan/math/prim/fun/abs.hpp                    |  2 +-
 stan/math/prim/fun/acos.hpp                   |  2 +-
 stan/math/prim/fun/asin.hpp                   |  2 +-
 stan/math/prim/fun/atan.hpp                   |  2 +-
 stan/math/prim/fun/ceil.hpp                   |  2 +-
 stan/math/prim/fun/cos.hpp                    |  2 +-
 stan/math/prim/fun/cosh.hpp                   |  2 +-
 stan/math/prim/fun/exp.hpp                    |  2 +-
 stan/math/prim/fun/fabs.hpp                   |  2 +-
 stan/math/prim/fun/floor.hpp                  |  2 +-
 stan/math/prim/fun/inv.hpp                    |  2 +-
 stan/math/prim/fun/inv_cloglog.hpp            |  2 +-
 stan/math/prim/fun/inv_square.hpp             |  2 +-
 stan/math/prim/fun/log.hpp                    |  2 +-
 stan/math/prim/fun/log10.hpp                  |  2 +-
 stan/math/prim/fun/minus.hpp                  |  2 +-
 stan/math/prim/fun/quad_form.hpp              |  8 +--
 stan/math/prim/fun/quad_form_sym.hpp          | 21 ++++----
 stan/math/prim/fun/read_corr_L.hpp            |  8 +--
 stan/math/prim/fun/read_corr_matrix.hpp       | 14 +++--
 stan/math/prim/fun/read_cov_matrix.hpp        |  4 +-
 stan/math/prim/fun/rep_matrix.hpp             | 12 +++--
 stan/math/prim/fun/reverse.hpp                |  7 ++-
 stan/math/prim/fun/round.hpp                  |  2 +-
 stan/math/prim/fun/row.hpp                    |  7 +--
 stan/math/prim/fun/rows.hpp                   |  6 ++-
 stan/math/prim/fun/rows_dot_product.hpp       |  8 +--
 stan/math/prim/fun/rows_dot_self.hpp          |  8 +--
 .../prim/fun/scale_matrix_exp_multiply.hpp    |  9 ++--
 stan/math/prim/fun/sd.hpp                     |  3 +-
 stan/math/prim/fun/segment.hpp                |  6 ++-
 stan/math/prim/fun/select.hpp                 | 23 ++++----
 stan/math/prim/fun/sin.hpp                    |  2 +-
 stan/math/prim/fun/sinh.hpp                   |  2 +-
 stan/math/prim/fun/sqrt.hpp                   |  2 +-
 stan/math/prim/fun/square.hpp                 |  6 +--
 stan/math/prim/fun/tan.hpp                    |  2 +-
 stan/math/prim/fun/tanh.hpp                   |  2 +-
 .../math/prim/functor/apply_scalar_binary.hpp | 47 +++++++++--------
 .../prim/functor/apply_scalar_ternary.hpp     | 22 ++++----
 stan/math/prim/functor/apply_scalar_unary.hpp |  4 +-
 stan/math/prim/functor/apply_vector_unary.hpp |  8 +--
 stan/math/prim/meta/conjunction.hpp           |  4 ++
 stan/math/prim/meta/disjunction.hpp           |  3 ++
 stan/math/prim/meta/holder.hpp                | 52 ++++++++++++++++++-
 stan/math/prim/prob/loglogistic_cdf.hpp       | 28 +++++-----
 stan/math/rev/fun/log_softmax.hpp             |  2 +-
 stan/math/rev/fun/multiply_log.hpp            | 12 ++---
 stan/math/rev/functor/apply_scalar_binary.hpp | 16 +++---
 stan/math/rev/functor/apply_scalar_unary.hpp  |  3 +-
 stan/math/rev/functor/apply_vector_unary.hpp  |  6 +--
 84 files changed, 368 insertions(+), 287 deletions(-)

diff --git a/stan/math/fwd/fun/log_softmax.hpp b/stan/math/fwd/fun/log_softmax.hpp
index 8e52ebb0fdd..3e97183dca1 100644
--- a/stan/math/fwd/fun/log_softmax.hpp
+++ b/stan/math/fwd/fun/log_softmax.hpp
@@ -6,6 +6,7 @@
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/fun/softmax.hpp>
 #include <stan/math/prim/fun/log_softmax.hpp>
+#include <stan/math/prim/fun/to_ref.hpp>
 
 namespace stan {
 namespace math {
@@ -21,23 +22,23 @@ namespace math {
 template <typename T, require_vector_st<is_fvar, T>* = nullptr>
 inline auto log_softmax(T&& x) {
   return apply_vector_unary<T>::apply(
-      std::forward<T>(x), [&](const auto& alpha) {
+      std::forward<T>(x), [](auto&& alpha) {
         using T_alpha = decltype(alpha);
         using T_fvar = value_type_t<T_alpha>;
         using T_fvar_inner = typename T_fvar::Scalar;
 
-        const Eigen::Ref<const plain_type_t<T_alpha>>& alpha_ref = alpha;
-        Eigen::Matrix<T_fvar_inner, -1, 1> alpha_t = alpha_ref.val();
-        Eigen::Matrix<T_fvar_inner, -1, 1> softmax_alpha_t = softmax(alpha_t);
+        auto&& alpha_ref = to_ref(std::forward<decltype(alpha)>(alpha));
+        Eigen::Matrix<T_fvar_inner, -1, 1> alpha_v = alpha_ref.val();
+        Eigen::Matrix<T_fvar_inner, -1, 1> softmax_alpha_v = softmax(alpha_v);
 
-        Eigen::Matrix<T_fvar, -1, 1> log_softmax_alpha(alpha.size());
-        log_softmax_alpha.val() = log_softmax(alpha_t);
+        Eigen::Matrix<T_fvar, -1, 1> log_softmax_alpha(alpha_ref.size());
+        log_softmax_alpha.val() = log_softmax(alpha_v);
         log_softmax_alpha.d().setZero();
 
-        for (int m = 0; m < alpha.size(); ++m) {
+        for (int m = 0; m < alpha_ref.size(); ++m) {
           T_fvar_inner negative_alpha_m_d_times_softmax_alpha_t_m
-              = -alpha_ref.coeff(m).d_ * softmax_alpha_t(m);
-          for (int k = 0; k < alpha.size(); ++k) {
+              = -alpha_ref.coeff(m).d_ * softmax_alpha_v(m);
+          for (int k = 0; k < alpha_ref.size(); ++k) {
             if (m == k) {
               log_softmax_alpha(k).d_
                   += alpha_ref.coeff(m).d_
diff --git a/stan/math/fwd/functor/apply_scalar_unary.hpp b/stan/math/fwd/functor/apply_scalar_unary.hpp
index ac9b067ee55..425eb2af15e 100644
--- a/stan/math/fwd/functor/apply_scalar_unary.hpp
+++ b/stan/math/fwd/functor/apply_scalar_unary.hpp
@@ -32,8 +32,8 @@ struct apply_scalar_unary<F, T, require_fvar_t<T>> {
    * @return Function applied to the variable.
    */
   template <typename T2>
-  static inline auto apply(const T2& x) {
-    return F::fun(x);
+  static inline auto apply(T2&& x) {
+    return F::fun(std::forward<T2>(x));
   }
 };
 
diff --git a/stan/math/prim/constraint/cholesky_corr_constrain.hpp b/stan/math/prim/constraint/cholesky_corr_constrain.hpp
index 63cd1b22271..061e514735a 100644
--- a/stan/math/prim/constraint/cholesky_corr_constrain.hpp
+++ b/stan/math/prim/constraint/cholesky_corr_constrain.hpp
@@ -14,7 +14,7 @@ namespace math {
 
 template <typename EigVec, require_eigen_col_vector_t<EigVec>* = nullptr>
 inline Eigen::Matrix<value_type_t<EigVec>, Eigen::Dynamic, Eigen::Dynamic>
-cholesky_corr_constrain(const EigVec& y, int K) {
+cholesky_corr_constrain(EigVec&& y, int K) {
   using Eigen::Dynamic;
   using Eigen::Matrix;
   using std::sqrt;
@@ -22,7 +22,7 @@ cholesky_corr_constrain(const EigVec& y, int K) {
   int k_choose_2 = (K * (K - 1)) / 2;
   check_size_match("cholesky_corr_constrain", "constrain size", y.size(),
                    "k_choose_2", k_choose_2);
-  Matrix<T_scalar, Dynamic, 1> z = corr_constrain(y);
+  Matrix<T_scalar, Dynamic, 1> z = corr_constrain(std::forward<EigVec>(y));
   Matrix<T_scalar, Dynamic, Dynamic> x(K, K);
   if (K == 0) {
     return x;
@@ -47,7 +47,7 @@ template <typename EigVec, typename Lp,
           require_eigen_vector_t<EigVec>* = nullptr,
           require_convertible_t<return_type_t<EigVec>, Lp>* = nullptr>
 inline Eigen::Matrix<value_type_t<EigVec>, Eigen::Dynamic, Eigen::Dynamic>
-cholesky_corr_constrain(const EigVec& y, int K, Lp& lp) {
+cholesky_corr_constrain(EigVec&& y, int K, Lp& lp) {
   using Eigen::Dynamic;
   using Eigen::Matrix;
   using std::sqrt;
@@ -55,7 +55,7 @@ cholesky_corr_constrain(const EigVec& y, int K, Lp& lp) {
   int k_choose_2 = (K * (K - 1)) / 2;
   check_size_match("cholesky_corr_constrain", "y.size()", y.size(),
                    "k_choose_2", k_choose_2);
-  Matrix<T_scalar, Dynamic, 1> z = corr_constrain(y, lp);
+  Matrix<T_scalar, Dynamic, 1> z = corr_constrain(std::forward<EigVec>(y), lp);
   Matrix<T_scalar, Dynamic, Dynamic> x(K, K);
   if (K == 0) {
     return x;
@@ -88,7 +88,7 @@ cholesky_corr_constrain(const EigVec& y, int K, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cholesky_corr_constrain(T&& y, int K) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(y), [K](auto&& v) {
         return cholesky_corr_constrain(std::forward<decltype(v)>(v), K);
       });
@@ -110,7 +110,7 @@ inline auto cholesky_corr_constrain(T&& y, int K) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto cholesky_corr_constrain(T&& y, int K, Lp& lp) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(y), [&lp, K](auto&& v) {
         return cholesky_corr_constrain(std::forward<decltype(v)>(v), K, lp);
       });
diff --git a/stan/math/prim/constraint/cholesky_corr_free.hpp b/stan/math/prim/constraint/cholesky_corr_free.hpp
index daba71ac14d..68cf1c63057 100644
--- a/stan/math/prim/constraint/cholesky_corr_free.hpp
+++ b/stan/math/prim/constraint/cholesky_corr_free.hpp
@@ -11,7 +11,7 @@ namespace stan {
 namespace math {
 
 template <typename T, require_eigen_t<T>* = nullptr>
-inline auto cholesky_corr_free(const T& x) {
+inline auto cholesky_corr_free(T&& x) {
   using Eigen::Dynamic;
   using Eigen::Matrix;
   using std::sqrt;
@@ -19,11 +19,11 @@ inline auto cholesky_corr_free(const T& x) {
   check_square("cholesky_corr_free", "x", x);
   // should validate lower-triangular, unit lengths
 
-  const auto& x_ref = to_ref(x);
-  int K = (x.rows() * (x.rows() - 1)) / 2;
+  auto&& x_ref = to_ref(std::forward<T>(x));
+  int K = (x_ref.rows() * (x_ref.rows() - 1)) / 2;
   Matrix<value_type_t<T>, Dynamic, 1> z(K);
   int k = 0;
-  for (int i = 1; i < x.rows(); ++i) {
+  for (int i = 1; i < x_ref.rows(); ++i) {
     z.coeffRef(k++) = corr_free(x_ref.coeff(i, 0));
     auto sum_sqs = square(x_ref.coeff(i, 0));
     for (int j = 1; j < i; ++j) {
@@ -43,7 +43,7 @@ inline auto cholesky_corr_free(const T& x) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cholesky_corr_free(T&& x) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x), [](auto&& v) {
         return cholesky_corr_free(std::forward<decltype(v)>(v));
       });
diff --git a/stan/math/prim/constraint/cholesky_factor_constrain.hpp b/stan/math/prim/constraint/cholesky_factor_constrain.hpp
index 6a273e88d94..ec3d2611871 100644
--- a/stan/math/prim/constraint/cholesky_factor_constrain.hpp
+++ b/stan/math/prim/constraint/cholesky_factor_constrain.hpp
@@ -27,7 +27,7 @@ namespace math {
  */
 template <typename T, require_eigen_col_vector_t<T>* = nullptr>
 inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic>
-cholesky_factor_constrain(const T& x, int M, int N) {
+cholesky_factor_constrain(T&& x, int M, int N) {
   using std::exp;
   using T_scalar = value_type_t<T>;
   check_greater_or_equal("cholesky_factor_constrain",
@@ -39,7 +39,7 @@ cholesky_factor_constrain(const T& x, int M, int N) {
   Eigen::Matrix<T_scalar, Eigen::Dynamic, Eigen::Dynamic> y(M, N);
   int pos = 0;
 
-  const auto& x_ref = to_ref(x);
+  auto&& x_ref = to_ref(std::forward<T>(x));
   for (int m = 0; m < N; ++m) {
     y.row(m).head(m) = x_ref.segment(pos, m);
     pos += m;
@@ -73,17 +73,17 @@ cholesky_factor_constrain(const T& x, int M, int N) {
 template <typename T, typename Lp, require_eigen_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic>
-cholesky_factor_constrain(const T& x, int M, int N, Lp& lp) {
+cholesky_factor_constrain(T&& x, int M, int N, Lp& lp) {
   check_size_match("cholesky_factor_constrain", "x.size()", x.size(),
                    "((N * (N + 1)) / 2 + (M - N) * N)",
                    ((N * (N + 1)) / 2 + (M - N) * N));
   int pos = 0;
-  const auto& x_ref = to_ref(x);
+  auto&& x_ref = to_ref(std::forward<T>(x));
   for (int n = 0; n < N; ++n) {
     pos += n;
     lp += x_ref.coeff(pos++);
   }
-  return cholesky_factor_constrain(x_ref, M, N);
+  return cholesky_factor_constrain(std::forward<decltype(x_ref)>(x_ref), M, N);
 }
 
 /**
@@ -102,7 +102,7 @@ cholesky_factor_constrain(const T& x, int M, int N, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cholesky_factor_constrain(T&& x, int M, int N) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x), [M, N](auto&& v) {
         return cholesky_factor_constrain(std::forward<decltype(v)>(v), M, N);
       });
@@ -128,7 +128,7 @@ inline auto cholesky_factor_constrain(T&& x, int M, int N) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto cholesky_factor_constrain(T&& x, int M, int N, Lp& lp) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x), [&lp, M, N](auto&& v) {
         return cholesky_factor_constrain(std::forward<decltype(v)>(v), M, N,
                                          lp);
diff --git a/stan/math/prim/constraint/cholesky_factor_free.hpp b/stan/math/prim/constraint/cholesky_factor_free.hpp
index affe6d32d04..ad693ec5044 100644
--- a/stan/math/prim/constraint/cholesky_factor_free.hpp
+++ b/stan/math/prim/constraint/cholesky_factor_free.hpp
@@ -23,25 +23,24 @@ namespace math {
  * @throw std::domain_error If the matrix is not a Cholesky factor.
  */
 template <typename T, require_eigen_t<T>* = nullptr>
-Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cholesky_factor_free(
-    const T& y) {
+Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cholesky_factor_free(T&& y) {
   using std::log;
 
-  const auto& y_ref = to_ref(y);
+  auto&& y_ref = to_ref(std::forward<T>(y));
   check_cholesky_factor("cholesky_factor_free", "y", y_ref);
-  int M = y.rows();
-  int N = y.cols();
+  const auto M = y_ref.rows();
+  const auto N = y_ref.cols();
   Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> x((N * (N + 1)) / 2
                                                       + (M - N) * N);
-  int pos = 0;
+  Eigen::Index pos = 0;
 
-  for (int m = 0; m < N; ++m) {
+  for (Eigen::Index m = 0; m < N; ++m) {
     x.segment(pos, m) = y_ref.row(m).head(m);
     pos += m;
     x.coeffRef(pos++) = log(y_ref.coeff(m, m));
   }
 
-  for (int m = N; m < M; ++m) {
+  for (Eigen::Index m = N; m < M; ++m) {
     x.segment(pos, N) = y_ref.row(m);
     pos += N;
   }
@@ -57,7 +56,7 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cholesky_factor_free(
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cholesky_factor_free(T&& x) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x), [](auto&& v) {
         return cholesky_factor_free(std::forward<decltype(v)>(v));
       });
diff --git a/stan/math/prim/constraint/corr_constrain.hpp b/stan/math/prim/constraint/corr_constrain.hpp
index f19f2ea8669..c5cd1862139 100644
--- a/stan/math/prim/constraint/corr_constrain.hpp
+++ b/stan/math/prim/constraint/corr_constrain.hpp
@@ -44,7 +44,7 @@ inline plain_type_t<T> corr_constrain(T&& x) {
  */
 template <typename T_x, typename T_lp>
 inline auto corr_constrain(T_x&& x, T_lp& lp) {
-  plain_type_t<T_x> tanh_x = tanh(x);
+  plain_type_t<T_x> tanh_x = tanh(std::forward<T_x>(x));
   lp += sum(log1m(square(tanh_x)));
   return tanh_x;
 }
diff --git a/stan/math/prim/constraint/corr_matrix_constrain.hpp b/stan/math/prim/constraint/corr_matrix_constrain.hpp
index 1df645f7ff3..4d56edd954a 100644
--- a/stan/math/prim/constraint/corr_matrix_constrain.hpp
+++ b/stan/math/prim/constraint/corr_matrix_constrain.hpp
@@ -92,7 +92,7 @@ corr_matrix_constrain(T&& x, Eigen::Index k, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto corr_matrix_constrain(T&& y, int K) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(y), [K](auto&& v) {
         return corr_matrix_constrain(std::forward<decltype(v)>(v), K);
       });
@@ -117,7 +117,7 @@ inline auto corr_matrix_constrain(T&& y, int K) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto corr_matrix_constrain(T&& y, int K, Lp& lp) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(y), [&lp, K](auto&& v) {
         return corr_matrix_constrain(std::forward<decltype(v)>(v), K, lp);
       });
diff --git a/stan/math/prim/constraint/corr_matrix_free.hpp b/stan/math/prim/constraint/corr_matrix_free.hpp
index b482e88d9f8..96f6a6a9a51 100644
--- a/stan/math/prim/constraint/corr_matrix_free.hpp
+++ b/stan/math/prim/constraint/corr_matrix_free.hpp
@@ -31,7 +31,7 @@ namespace math {
  *    factor_cov_matrix() on log scale are unconstrained.
  */
 template <typename T, require_eigen_t<T>* = nullptr>
-Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> corr_matrix_free(const T& y) {
+Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> corr_matrix_free(T&& y) {
   using Eigen::Array;
   using Eigen::Dynamic;
 
@@ -42,7 +42,7 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> corr_matrix_free(const T& y) {
   Eigen::Index k_choose_2 = (k * (k - 1)) / 2;
   Eigen::Matrix<value_type_t<T>, Dynamic, 1> x(k_choose_2);
   Array<value_type_t<T>, Dynamic, 1> sds(k);
-  bool successful = factor_cov_matrix(y, x.array(), sds);
+  bool successful = factor_cov_matrix(std::forward<T>(y), x.array(), sds);
   if (!successful) {
     throw_domain_error("corr_matrix_free", "factor_cov_matrix failed on y", y,
                        "");
@@ -61,7 +61,7 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> corr_matrix_free(const T& y) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto corr_matrix_free(T&& x) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x),
       [](auto&& v) { return corr_matrix_free(std::forward<decltype(v)>(v)); });
 }
diff --git a/stan/math/prim/constraint/cov_matrix_constrain.hpp b/stan/math/prim/constraint/cov_matrix_constrain.hpp
index 785016872ef..f9ead70d76f 100644
--- a/stan/math/prim/constraint/cov_matrix_constrain.hpp
+++ b/stan/math/prim/constraint/cov_matrix_constrain.hpp
@@ -103,7 +103,7 @@ cov_matrix_constrain(T&& x, Eigen::Index K, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cov_matrix_constrain(T&& x, Eigen::Index K) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x), [K](auto&& v) {
         return cov_matrix_constrain(std::forward<decltype(v)>(v), K);
       });
@@ -127,7 +127,7 @@ inline auto cov_matrix_constrain(T&& x, Eigen::Index K) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto cov_matrix_constrain(T&& x, Eigen::Index K, Lp& lp) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x), [&lp, K](auto&& v) {
         return cov_matrix_constrain(std::forward<decltype(v)>(v), K, lp);
       });
diff --git a/stan/math/prim/constraint/cov_matrix_constrain_lkj.hpp b/stan/math/prim/constraint/cov_matrix_constrain_lkj.hpp
index 9e630a91b39..9b4cedef02c 100644
--- a/stan/math/prim/constraint/cov_matrix_constrain_lkj.hpp
+++ b/stan/math/prim/constraint/cov_matrix_constrain_lkj.hpp
@@ -114,7 +114,7 @@ inline auto cov_matrix_constrain_lkj(T&& x, size_t k, return_type_t<T>& lp) {
  */
 template <bool Jacobian, typename T, require_std_vector_t<T>* = nullptr>
 inline auto cov_matrix_constrain_lkj(T&& x, size_t k, return_type_t<T>& lp) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x), [&lp, k](auto&& v) {
         return cov_matrix_constrain_lkj<Jacobian>(std::forward<decltype(v)>(v),
                                                   k, lp);
diff --git a/stan/math/prim/constraint/cov_matrix_free.hpp b/stan/math/prim/constraint/cov_matrix_free.hpp
index 310bf897b14..876adf3980e 100644
--- a/stan/math/prim/constraint/cov_matrix_free.hpp
+++ b/stan/math/prim/constraint/cov_matrix_free.hpp
@@ -67,7 +67,7 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cov_matrix_free(T&& y) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cov_matrix_free(T&& x) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x),
       [](auto&& v) { return cov_matrix_free(std::forward<decltype(v)>(v)); });
 }
diff --git a/stan/math/prim/constraint/cov_matrix_free_lkj.hpp b/stan/math/prim/constraint/cov_matrix_free_lkj.hpp
index d547261b814..fcf6768203b 100644
--- a/stan/math/prim/constraint/cov_matrix_free_lkj.hpp
+++ b/stan/math/prim/constraint/cov_matrix_free_lkj.hpp
@@ -28,8 +28,7 @@ namespace math {
  *    factorized by factor_cov_matrix()
  */
 template <typename T, require_eigen_t<T>* = nullptr>
-Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cov_matrix_free_lkj(
-    const T& y) {
+Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cov_matrix_free_lkj(T&& y) {
   using Eigen::Array;
   using Eigen::Dynamic;
   using Eigen::Matrix;
@@ -41,7 +40,7 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cov_matrix_free_lkj(
   Eigen::Index k_choose_2 = (k * (k - 1)) / 2;
   Matrix<T_scalar, Dynamic, 1> x(k_choose_2 + k);
   bool successful
-      = factor_cov_matrix(y, x.head(k_choose_2).array(), x.tail(k).array());
+      = factor_cov_matrix(std::forward<T>(y), x.head(k_choose_2).array(), x.tail(k).array());
   if (!successful) {
     throw_domain_error("cov_matrix_free_lkj", "factor_cov_matrix failed on y",
                        "", "");
@@ -58,7 +57,7 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cov_matrix_free_lkj(
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 auto cov_matrix_free_lkj(T&& x) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x), [](auto&& v) {
         return cov_matrix_free_lkj(std::forward<decltype(v)>(v));
       });
diff --git a/stan/math/prim/constraint/lb_constrain.hpp b/stan/math/prim/constraint/lb_constrain.hpp
index f77c4056033..11ce3a52471 100644
--- a/stan/math/prim/constraint/lb_constrain.hpp
+++ b/stan/math/prim/constraint/lb_constrain.hpp
@@ -255,11 +255,11 @@ inline auto lb_constrain(const std::vector<T>& x, const std::vector<L>& lb,
  */
 template <bool Jacobian, typename T, typename L, typename Lp,
           require_convertible_t<return_type_t<T, L>, Lp>* = nullptr>
-inline auto lb_constrain(const T& x, const L& lb, Lp& lp) {
+inline auto lb_constrain(T&& x, L&& lb, Lp& lp) {
   if constexpr (Jacobian) {
-    return lb_constrain(x, lb, lp);
+    return lb_constrain(std::forward<T>(x), std::forward<L>(lb), lp);
   } else {
-    return lb_constrain(x, lb);
+    return lb_constrain(std::forward<T>(x), std::forward<L>(lb));
   }
 }
 
diff --git a/stan/math/prim/constraint/offset_multiplier_constrain.hpp b/stan/math/prim/constraint/offset_multiplier_constrain.hpp
index 640110f56d3..a6e8f68d039 100644
--- a/stan/math/prim/constraint/offset_multiplier_constrain.hpp
+++ b/stan/math/prim/constraint/offset_multiplier_constrain.hpp
@@ -42,24 +42,24 @@ namespace math {
 template <typename T, typename M, typename S,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               T, M, S>* = nullptr>
-inline auto offset_multiplier_constrain(const T& x, const M& mu,
-                                        const S& sigma) {
-  const auto& mu_ref = to_ref(mu);
-  const auto& sigma_ref = to_ref(sigma);
+inline auto offset_multiplier_constrain(T&& x, M&& mu, S&& sigma) {
+  auto&& mu_ref = to_ref(std::forward<M>(mu));
+  auto&& sigma_ref = to_ref(std::forward<S>(sigma));
   if (is_matrix<T>::value && is_matrix<M>::value) {
-    check_matching_dims("offset_multiplier_constrain", "x", x, "mu", mu);
+    check_matching_dims("offset_multiplier_constrain", "x", x, "mu", mu_ref);
   }
   if (is_matrix<T>::value && is_matrix<S>::value) {
-    check_matching_dims("offset_multiplier_constrain", "x", x, "sigma", sigma);
+    check_matching_dims("offset_multiplier_constrain", "x", x, "sigma", sigma_ref);
   } else if (is_matrix<M>::value && is_matrix<S>::value) {
-    check_matching_dims("offset_multiplier_constrain", "mu", mu, "sigma",
-                        sigma);
+    check_matching_dims("offset_multiplier_constrain", "mu", mu_ref, "sigma",
+                        sigma_ref);
   }
 
   check_finite("offset_multiplier_constrain", "offset", value_of_rec(mu_ref));
   check_positive_finite("offset_multiplier_constrain", "multiplier",
                         value_of_rec(sigma_ref));
-  return stan::math::eval(fma(sigma_ref, x, mu_ref));
+  return stan::math::eval(fma(std::forward<decltype(sigma_ref)>(sigma_ref),
+    std::forward<T>(x), std::forward<decltype(mu_ref)>(mu_ref)));
 }
 
 /**
@@ -93,10 +93,9 @@ template <typename T, typename M, typename S, typename Lp,
           require_convertible_t<return_type_t<T, M, S>, Lp>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               T, M, S>* = nullptr>
-inline auto offset_multiplier_constrain(const T& x, const M& mu, const S& sigma,
-                                        Lp& lp) {
-  const auto& mu_ref = to_ref(mu);
-  const auto& sigma_ref = to_ref(sigma);
+inline auto offset_multiplier_constrain(T&& x, M&& mu, S&& sigma, Lp& lp) {
+  auto&& mu_ref = to_ref(std::forward<M>(mu));
+  auto&& sigma_ref = to_ref(std::forward<S>(sigma));
   if (is_matrix<T>::value && is_matrix<M>::value) {
     check_matching_dims("offset_multiplier_constrain", "x", x, "mu", mu);
   }
@@ -115,7 +114,8 @@ inline auto offset_multiplier_constrain(const T& x, const M& mu, const S& sigma,
   } else {
     lp += sum(log(sigma_ref));
   }
-  return stan::math::eval(fma(sigma_ref, x, mu_ref));
+  return stan::math::eval(fma(std::forward<decltype(sigma_ref)>(sigma_ref),
+    std::forward<T>(x), std::forward<decltype(mu_ref)>(mu_ref)));
 }
 
 /**
diff --git a/stan/math/prim/constraint/offset_multiplier_free.hpp b/stan/math/prim/constraint/offset_multiplier_free.hpp
index 90d81a1745a..4bfc6acd12d 100644
--- a/stan/math/prim/constraint/offset_multiplier_free.hpp
+++ b/stan/math/prim/constraint/offset_multiplier_free.hpp
@@ -44,21 +44,23 @@ template <typename T, typename M, typename S,
 inline auto offset_multiplier_free(T&& y, M&& mu, S&& sigma) {
   auto&& mu_ref = to_ref(std::forward<M>(mu));
   auto&& sigma_ref = to_ref(std::forward<S>(sigma));
-  if (is_matrix<T>::value && is_matrix<M>::value) {
-    check_matching_dims("offset_multiplier_constrain", "y", y, "mu", mu);
+  if constexpr (is_matrix<T>::value && is_matrix<M>::value) {
+    check_matching_dims("offset_multiplier_constrain", "y", y, "mu", mu_ref);
   }
-  if (is_matrix<T>::value && is_matrix<S>::value) {
-    check_matching_dims("offset_multiplier_constrain", "y", y, "sigma", sigma);
-  } else if (is_matrix<M>::value && is_matrix<S>::value) {
-    check_matching_dims("offset_multiplier_constrain", "mu", mu, "sigma",
-                        sigma);
+  if constexpr (is_matrix<T>::value && is_matrix<S>::value) {
+    check_matching_dims("offset_multiplier_constrain", "y", y, "sigma", sigma_ref);
+  } else if constexpr (is_matrix<M>::value && is_matrix<S>::value) {
+    check_matching_dims("offset_multiplier_constrain", "mu", mu_ref, "sigma",
+                        sigma_ref);
   }
 
   check_finite("offset_multiplier_constrain", "offset", value_of(mu_ref));
   check_positive_finite("offset_multiplier_constrain", "multiplier",
                         value_of(sigma_ref));
   return stan::math::eval(
-      divide(subtract(std::forward<T>(y), mu_ref), sigma_ref));
+      divide(subtract(std::forward<T>(y),
+        std::forward<decltype(mu_ref)>(mu_ref)),
+        std::forward<decltype(sigma_ref)>(sigma_ref)));
 }
 
 /**
diff --git a/stan/math/prim/constraint/ordered_constrain.hpp b/stan/math/prim/constraint/ordered_constrain.hpp
index e2a2280d842..e585c523e25 100644
--- a/stan/math/prim/constraint/ordered_constrain.hpp
+++ b/stan/math/prim/constraint/ordered_constrain.hpp
@@ -77,7 +77,7 @@ inline auto ordered_constrain(EigVec&& x, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto ordered_constrain(T&& x) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x),
       [](auto&& v) { return ordered_constrain(std::forward<decltype(v)>(v)); });
 }
@@ -100,7 +100,7 @@ inline auto ordered_constrain(T&& x) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto ordered_constrain(T&& x, Lp& lp) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x), [&lp](auto&& v) {
         return ordered_constrain(std::forward<decltype(v)>(v), lp);
       });
diff --git a/stan/math/prim/constraint/ordered_free.hpp b/stan/math/prim/constraint/ordered_free.hpp
index 609d8a8f9f9..f06db3693d7 100644
--- a/stan/math/prim/constraint/ordered_free.hpp
+++ b/stan/math/prim/constraint/ordered_free.hpp
@@ -50,7 +50,7 @@ plain_type_t<EigVec> ordered_free(const EigVec& y) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto ordered_free(T&& x) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x),
       [](auto&& v) { return ordered_free(std::forward<decltype(v)>(v)); });
 }
diff --git a/stan/math/prim/constraint/positive_constrain.hpp b/stan/math/prim/constraint/positive_constrain.hpp
index 193b9721890..7551f8afb76 100644
--- a/stan/math/prim/constraint/positive_constrain.hpp
+++ b/stan/math/prim/constraint/positive_constrain.hpp
@@ -96,7 +96,7 @@ template <bool Jacobian, typename T, typename Lp,
           require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto positive_constrain(T&& x, Lp& lp) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x), [&lp](auto&& v) {
         return positive_constrain<Jacobian>(std::forward<decltype(v)>(v), lp);
       });
diff --git a/stan/math/prim/constraint/positive_ordered_constrain.hpp b/stan/math/prim/constraint/positive_ordered_constrain.hpp
index 608da90af22..dc517fcb91e 100644
--- a/stan/math/prim/constraint/positive_ordered_constrain.hpp
+++ b/stan/math/prim/constraint/positive_ordered_constrain.hpp
@@ -71,7 +71,7 @@ inline auto positive_ordered_constrain(Vec&& x, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto positive_ordered_constrain(T&& x) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x), [](auto&& v) {
         return positive_ordered_constrain(std::forward<decltype(v)>(v));
       });
@@ -94,7 +94,7 @@ inline auto positive_ordered_constrain(T&& x) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto positive_ordered_constrain(T&& x, Lp& lp) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x), [&lp](auto&& v) {
         return positive_ordered_constrain(std::forward<decltype(v)>(v), lp);
       });
diff --git a/stan/math/prim/constraint/positive_ordered_free.hpp b/stan/math/prim/constraint/positive_ordered_free.hpp
index 3602f405810..d2013ef4de8 100644
--- a/stan/math/prim/constraint/positive_ordered_free.hpp
+++ b/stan/math/prim/constraint/positive_ordered_free.hpp
@@ -50,7 +50,7 @@ inline auto positive_ordered_free(const EigVec& y) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto positive_ordered_free(T&& x) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x), [](auto&& v) {
         return positive_ordered_free(std::forward<decltype(v)>(v));
       });
diff --git a/stan/math/prim/constraint/simplex_constrain.hpp b/stan/math/prim/constraint/simplex_constrain.hpp
index 0f9c9fc4af4..01dbabe93a4 100644
--- a/stan/math/prim/constraint/simplex_constrain.hpp
+++ b/stan/math/prim/constraint/simplex_constrain.hpp
@@ -146,7 +146,7 @@ inline plain_type_t<Vec> simplex_constrain(const Vec& y, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto simplex_constrain(T&& y) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(y),
       [](auto&& v) { return simplex_constrain(std::forward<decltype(v)>(v)); });
 }
@@ -167,7 +167,7 @@ inline auto simplex_constrain(T&& y) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto simplex_constrain(T&& y, Lp& lp) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(y), [&lp](auto&& v) {
         return simplex_constrain(std::forward<decltype(v)>(v), lp);
       });
@@ -195,9 +195,9 @@ template <bool Jacobian, typename Vec, typename Lp,
           require_convertible_t<return_type_t<Vec>, Lp>* = nullptr>
 inline plain_type_t<Vec> simplex_constrain(Vec&& y, Lp& lp) {
   if constexpr (Jacobian) {
-    return simplex_constrain(std::forward<decltype(y)>(y), lp);
+    return simplex_constrain(std::forward<Vec>(y), lp);
   } else {
-    return simplex_constrain(std::forward<decltype(y)>(y));
+    return simplex_constrain(std::forward<Vec>(y));
   }
 }
 
diff --git a/stan/math/prim/constraint/simplex_free.hpp b/stan/math/prim/constraint/simplex_free.hpp
index 2b2bd9ae68c..649212d9590 100644
--- a/stan/math/prim/constraint/simplex_free.hpp
+++ b/stan/math/prim/constraint/simplex_free.hpp
@@ -54,7 +54,7 @@ inline plain_type_t<Vec> simplex_free(const Vec& x) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto simplex_free(T&& x) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x),
       [](auto&& v) { return simplex_free(std::forward<decltype(v)>(v)); });
 }
diff --git a/stan/math/prim/constraint/stochastic_column_constrain.hpp b/stan/math/prim/constraint/stochastic_column_constrain.hpp
index 104877f0dbf..61cbbed193c 100644
--- a/stan/math/prim/constraint/stochastic_column_constrain.hpp
+++ b/stan/math/prim/constraint/stochastic_column_constrain.hpp
@@ -72,7 +72,7 @@ inline plain_type_t<Mat> stochastic_column_constrain(const Mat& y, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto stochastic_column_constrain(T&& y) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(y), [](auto&& v) {
         return stochastic_column_constrain(std::forward<decltype(v)>(v));
       });
@@ -95,7 +95,7 @@ inline auto stochastic_column_constrain(T&& y) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto stochastic_column_constrain(T&& y, Lp& lp) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(y), [&lp](auto&& v) {
         return stochastic_column_constrain(std::forward<decltype(v)>(v), lp);
       });
@@ -123,9 +123,9 @@ template <bool Jacobian, typename Mat, typename Lp,
           require_convertible_t<return_type_t<Mat>, Lp>* = nullptr>
 inline plain_type_t<Mat> stochastic_column_constrain(Mat&& y, Lp& lp) {
   if constexpr (Jacobian) {
-    return stochastic_column_constrain(std::forward<decltype(y)>(y), lp);
+    return stochastic_column_constrain(std::forward<Mat>(y), lp);
   } else {
-    return stochastic_column_constrain(std::forward<decltype(y)>(y));
+    return stochastic_column_constrain(std::forward<Mat>(y));
   }
 }
 
diff --git a/stan/math/prim/constraint/stochastic_column_free.hpp b/stan/math/prim/constraint/stochastic_column_free.hpp
index c1cd90ece06..7be689e4f10 100644
--- a/stan/math/prim/constraint/stochastic_column_free.hpp
+++ b/stan/math/prim/constraint/stochastic_column_free.hpp
@@ -37,7 +37,7 @@ inline plain_type_t<Mat> stochastic_column_free(Mat&& y) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto stochastic_column_free(T&& y) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(y), [](auto&& v) {
         return stochastic_column_free(std::forward<decltype(v)>(v));
       });
diff --git a/stan/math/prim/constraint/stochastic_row_constrain.hpp b/stan/math/prim/constraint/stochastic_row_constrain.hpp
index 0b0c1fa2723..cda1ee27402 100644
--- a/stan/math/prim/constraint/stochastic_row_constrain.hpp
+++ b/stan/math/prim/constraint/stochastic_row_constrain.hpp
@@ -69,7 +69,7 @@ inline plain_type_t<Mat> stochastic_row_constrain(Mat&& y, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto stochastic_row_constrain(T&& y) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(y), [](auto&& v) {
         return stochastic_row_constrain(std::forward<decltype(v)>(v));
       });
@@ -91,7 +91,7 @@ inline auto stochastic_row_constrain(T&& y) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto stochastic_row_constrain(T&& y, Lp& lp) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(y), [&lp](auto&& v) {
         return stochastic_row_constrain(std::forward<decltype(v)>(v), lp);
       });
@@ -119,9 +119,9 @@ template <bool Jacobian, typename Mat, typename Lp,
           require_convertible_t<return_type_t<Mat>, Lp>* = nullptr>
 inline plain_type_t<Mat> stochastic_row_constrain(Mat&& y, Lp& lp) {
   if constexpr (Jacobian) {
-    return stochastic_row_constrain(std::forward<decltype(y)>(y), lp);
+    return stochastic_row_constrain(std::forward<Mat>(y), lp);
   } else {
-    return stochastic_row_constrain(std::forward<decltype(y)>(y));
+    return stochastic_row_constrain(std::forward<Mat>(y));
   }
 }
 
diff --git a/stan/math/prim/constraint/stochastic_row_free.hpp b/stan/math/prim/constraint/stochastic_row_free.hpp
index 068d287435d..003bef0f47e 100644
--- a/stan/math/prim/constraint/stochastic_row_free.hpp
+++ b/stan/math/prim/constraint/stochastic_row_free.hpp
@@ -36,7 +36,7 @@ inline plain_type_t<Mat> stochastic_row_free(Mat&& y) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto stochastic_row_free(T&& y) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(y), [](auto&& v) {
         return stochastic_row_free(std::forward<decltype(v)>(v));
       });
diff --git a/stan/math/prim/constraint/sum_to_zero_constrain.hpp b/stan/math/prim/constraint/sum_to_zero_constrain.hpp
index f928f14e67e..d615aa3925c 100644
--- a/stan/math/prim/constraint/sum_to_zero_constrain.hpp
+++ b/stan/math/prim/constraint/sum_to_zero_constrain.hpp
@@ -139,7 +139,7 @@ inline plain_type_t<T> sum_to_zero_constrain(T&& y, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto sum_to_zero_constrain(T&& y) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(y), [](auto&& v) {
         return sum_to_zero_constrain(std::forward<decltype(v)>(v));
       });
@@ -160,7 +160,7 @@ inline auto sum_to_zero_constrain(T&& y) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto sum_to_zero_constrain(T&& y, Lp& lp) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(y), [&lp](auto&& v) {
         return sum_to_zero_constrain(std::forward<decltype(v)>(v), lp);
       });
diff --git a/stan/math/prim/constraint/sum_to_zero_free.hpp b/stan/math/prim/constraint/sum_to_zero_free.hpp
index 85a679cad2d..06340b8224f 100644
--- a/stan/math/prim/constraint/sum_to_zero_free.hpp
+++ b/stan/math/prim/constraint/sum_to_zero_free.hpp
@@ -116,7 +116,7 @@ inline plain_type_t<Mat> sum_to_zero_free(const Mat& z) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto sum_to_zero_free(T&& z) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(z),
       [](auto&& v) { return sum_to_zero_free(std::forward<decltype(v)>(v)); });
 }
diff --git a/stan/math/prim/constraint/ub_constrain.hpp b/stan/math/prim/constraint/ub_constrain.hpp
index bef8aee2324..fe836471456 100644
--- a/stan/math/prim/constraint/ub_constrain.hpp
+++ b/stan/math/prim/constraint/ub_constrain.hpp
@@ -88,9 +88,8 @@ inline auto ub_constrain(const T& x, const U& ub, Lp& lp) {
 template <typename T, typename U, require_eigen_t<T>* = nullptr,
           require_stan_scalar_t<U>* = nullptr,
           require_all_not_st_var<T, U>* = nullptr>
-inline auto ub_constrain(T&& x, const U& ub) {
-  return eval(std::forward<T>(x).unaryExpr(
-      [ub](auto&& xx) { return ub_constrain(xx, ub); }));
+inline auto ub_constrain(const T& x, const U& ub) {
+  return eval(x.unaryExpr([ub](auto&& xx) { return ub_constrain(xx, ub); }));
 }
 
 /**
@@ -109,9 +108,9 @@ template <typename T, typename U, typename Lp, require_eigen_t<T>* = nullptr,
           require_stan_scalar_t<U>* = nullptr,
           require_all_not_st_var<T, U>* = nullptr,
           require_convertible_t<return_type_t<T, U>, Lp>* = nullptr>
-inline auto ub_constrain(T&& x, const U& ub, Lp& lp) {
-  return eval(std::forward<T>(x).unaryExpr(
-      [ub, &lp](auto&& xx) { return ub_constrain(xx, ub, lp); }));
+inline auto ub_constrain(const T& x, const U& ub, Lp& lp) {
+  return eval(
+      x.unaryExpr([ub, &lp](auto&& xx) { return ub_constrain(xx, ub, lp); }));
 }
 
 /**
@@ -126,9 +125,9 @@ inline auto ub_constrain(T&& x, const U& ub, Lp& lp) {
  */
 template <typename T, typename U, require_all_eigen_t<T, U>* = nullptr,
           require_all_not_st_var<T, U>* = nullptr>
-inline auto ub_constrain(T&& x, const U& ub) {
+inline auto ub_constrain(const T& x, const U& ub) {
   check_matching_dims("ub_constrain", "x", x, "ub", ub);
-  return eval(std::forward<T>(x).binaryExpr(
+  return eval(x.binaryExpr(
       ub, [](auto&& xx, auto&& ubb) { return ub_constrain(xx, ubb); }));
 }
 
@@ -148,9 +147,9 @@ template <typename T, typename U, typename Lp,
           require_all_eigen_t<T, U>* = nullptr,
           require_all_not_st_var<T, U>* = nullptr,
           require_convertible_t<return_type_t<T, U>, Lp>* = nullptr>
-inline auto ub_constrain(T&& x, const U& ub, Lp& lp) {
+inline auto ub_constrain(const T& x, const U& ub, Lp& lp) {
   check_matching_dims("ub_constrain", "x", x, "ub", ub);
-  return eval(std::forward<T>(x).binaryExpr(
+  return eval(x.binaryExpr(
       ub, [&lp](auto&& xx, auto&& ubb) { return ub_constrain(xx, ubb, lp); }));
 }
 
@@ -262,11 +261,11 @@ inline auto ub_constrain(const std::vector<T>& x, const std::vector<U>& ub,
  */
 template <bool Jacobian, typename T, typename U, typename Lp,
           require_convertible_t<return_type_t<T, U>, Lp>* = nullptr>
-inline auto ub_constrain(T&& x, U&& ub, Lp& lp) {
+inline auto ub_constrain(const T& x, const U& ub, Lp& lp) {
   if constexpr (Jacobian) {
-    return ub_constrain(std::forward<T>(x), std::forward<U>(ub), lp);
+    return ub_constrain(x, ub, lp);
   } else {
-    return ub_constrain(std::forward<T>(x), std::forward<U>(ub));
+    return ub_constrain(x, ub);
   }
 }
 
diff --git a/stan/math/prim/constraint/ub_free.hpp b/stan/math/prim/constraint/ub_free.hpp
index 05a3acce775..415fe38ff5d 100644
--- a/stan/math/prim/constraint/ub_free.hpp
+++ b/stan/math/prim/constraint/ub_free.hpp
@@ -34,7 +34,7 @@ template <typename T, typename U, require_not_std_vector_t<T>* = nullptr,
           require_stan_scalar_t<U>* = nullptr>
 inline auto ub_free(T&& y, U&& ub) {
   if (value_of_rec(ub) == INFTY) {
-    return identity_free(y, ub);
+    return identity_free(std::forward<T>(y), std::forward<U>(ub));
   } else {
     auto&& y_ref = to_ref(std::forward<T>(y));
     auto&& ub_ref = to_ref(std::forward<U>(ub));
diff --git a/stan/math/prim/constraint/unit_vector_constrain.hpp b/stan/math/prim/constraint/unit_vector_constrain.hpp
index 7b3f29e2d5e..66828e74fa9 100644
--- a/stan/math/prim/constraint/unit_vector_constrain.hpp
+++ b/stan/math/prim/constraint/unit_vector_constrain.hpp
@@ -24,13 +24,15 @@ namespace math {
  */
 template <typename T, require_eigen_col_vector_t<T>* = nullptr,
           require_not_vt_autodiff<T>* = nullptr>
-inline plain_type_t<T> unit_vector_constrain(const T& y) {
+inline auto unit_vector_constrain(T&& y) {
   using std::sqrt;
   check_nonzero_size("unit_vector_constrain", "y", y);
-  auto&& y_ref = to_ref(y);
+  auto&& y_ref = to_ref(std::forward<T>(y));
   value_type_t<T> SN = dot_self(y_ref);
   check_positive_finite("unit_vector_constrain", "norm", SN);
-  return y_ref.array() / sqrt(SN);
+  return make_holder([SN](auto&& y_) {
+    return std::forward<decltype(y_)>(y_).array() / sqrt(SN);
+  }, std::forward<decltype(y_ref)>(y_ref));
 }
 
 /**
@@ -46,14 +48,16 @@ inline plain_type_t<T> unit_vector_constrain(const T& y) {
  */
 template <typename T1, typename T2, require_eigen_col_vector_t<T1>* = nullptr,
           require_all_not_vt_autodiff<T1, T2>* = nullptr>
-inline plain_type_t<T1> unit_vector_constrain(const T1& y, T2& lp) {
+inline auto unit_vector_constrain(T1&& y, T2& lp) {
   using std::sqrt;
   check_nonzero_size("unit_vector_constrain", "y", y);
   auto&& y_ref = to_ref(y);
   value_type_t<T1> SN = dot_self(y_ref);
   check_positive_finite("unit_vector_constrain", "norm", SN);
   lp -= 0.5 * SN;
-  return y_ref.array() / sqrt(SN);
+  return make_holder([SN](auto&& y_) {
+    return std::forward<decltype(y_)>(y_).array() / sqrt(SN);
+  }, std::forward<decltype(y_ref)>(y_ref));
 }
 /**
  * Return the unit length vector corresponding to the free vector y.
@@ -67,7 +71,7 @@ inline plain_type_t<T1> unit_vector_constrain(const T1& y, T2& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto unit_vector_constrain(T&& y) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(y), [](auto&& v) {
         return unit_vector_constrain(std::forward<decltype(v)>(v));
       });
@@ -89,7 +93,7 @@ inline auto unit_vector_constrain(T&& y) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto unit_vector_constrain(T&& y, Lp& lp) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(y), [&lp](auto&& v) {
         return unit_vector_constrain(std::forward<decltype(v)>(v), lp);
       });
diff --git a/stan/math/prim/constraint/unit_vector_free.hpp b/stan/math/prim/constraint/unit_vector_free.hpp
index 6c8a9f19091..c7df0615f29 100644
--- a/stan/math/prim/constraint/unit_vector_free.hpp
+++ b/stan/math/prim/constraint/unit_vector_free.hpp
@@ -25,7 +25,7 @@ inline auto unit_vector_free(EigVec&& x) {
   auto&& x_ref = to_ref(std::forward<EigVec>(x));
   check_unit_vector("stan::math::unit_vector_free", "Unit vector variable",
                     x_ref);
-  return x_ref;
+  return std::forward<decltype(x_ref)>(x_ref);
 }
 
 /**
@@ -37,7 +37,7 @@ inline auto unit_vector_free(EigVec&& x) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto unit_vector_free(T&& x) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x),
       [](auto&& v) { return unit_vector_free(std::forward<decltype(v)>(v)); });
 }
diff --git a/stan/math/prim/fun/abs.hpp b/stan/math/prim/fun/abs.hpp
index fa13ff2b853..e0cb2acd74f 100644
--- a/stan/math/prim/fun/abs.hpp
+++ b/stan/math/prim/fun/abs.hpp
@@ -79,7 +79,7 @@ inline auto abs(Container&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto abs(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [&](auto&& v) { return std::forward<decltype(v)>(v).array().abs(); });
 }
diff --git a/stan/math/prim/fun/acos.hpp b/stan/math/prim/fun/acos.hpp
index b78663a587a..868f1a424b4 100644
--- a/stan/math/prim/fun/acos.hpp
+++ b/stan/math/prim/fun/acos.hpp
@@ -81,7 +81,7 @@ inline auto acos(Container&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto acos(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().acos(); });
 }
diff --git a/stan/math/prim/fun/asin.hpp b/stan/math/prim/fun/asin.hpp
index feb756fb4fd..60821a5abd3 100644
--- a/stan/math/prim/fun/asin.hpp
+++ b/stan/math/prim/fun/asin.hpp
@@ -79,7 +79,7 @@ inline auto asin(Container&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto asin(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().asin(); });
 }
diff --git a/stan/math/prim/fun/atan.hpp b/stan/math/prim/fun/atan.hpp
index 8366ba41428..7cb08d4e89e 100644
--- a/stan/math/prim/fun/atan.hpp
+++ b/stan/math/prim/fun/atan.hpp
@@ -77,7 +77,7 @@ inline auto atan(Container&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto atan(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().atan(); });
 }
diff --git a/stan/math/prim/fun/ceil.hpp b/stan/math/prim/fun/ceil.hpp
index 2185a50b313..b9bf9e2691a 100644
--- a/stan/math/prim/fun/ceil.hpp
+++ b/stan/math/prim/fun/ceil.hpp
@@ -54,7 +54,7 @@ template <typename Container,
           require_container_st<std::is_arithmetic, Container>* = nullptr,
           require_not_var_matrix_t<Container>* = nullptr>
 inline auto ceil(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().ceil(); });
 }
diff --git a/stan/math/prim/fun/cos.hpp b/stan/math/prim/fun/cos.hpp
index ae8eb3b275e..00c866db87f 100644
--- a/stan/math/prim/fun/cos.hpp
+++ b/stan/math/prim/fun/cos.hpp
@@ -76,7 +76,7 @@ inline auto cos(Container&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto cos(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [&](auto&& v) { return std::forward<decltype(v)>(v).array().cos(); });
 }
diff --git a/stan/math/prim/fun/cosh.hpp b/stan/math/prim/fun/cosh.hpp
index 8a6bae2571b..6782e9856b5 100644
--- a/stan/math/prim/fun/cosh.hpp
+++ b/stan/math/prim/fun/cosh.hpp
@@ -75,7 +75,7 @@ inline auto cosh(Container&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto cosh(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().cosh(); });
 }
diff --git a/stan/math/prim/fun/exp.hpp b/stan/math/prim/fun/exp.hpp
index 01ec45e5888..8298467d498 100644
--- a/stan/math/prim/fun/exp.hpp
+++ b/stan/math/prim/fun/exp.hpp
@@ -84,7 +84,7 @@ inline auto exp(Container&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto exp(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().exp(); });
 }
diff --git a/stan/math/prim/fun/fabs.hpp b/stan/math/prim/fun/fabs.hpp
index 51bb3f554bd..95533450b8b 100644
--- a/stan/math/prim/fun/fabs.hpp
+++ b/stan/math/prim/fun/fabs.hpp
@@ -64,7 +64,7 @@ inline auto fabs(Container&& x) {
 template <typename Container,
           require_container_st<std::is_arithmetic, Container>* = nullptr>
 inline auto fabs(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().abs(); });
 }
diff --git a/stan/math/prim/fun/floor.hpp b/stan/math/prim/fun/floor.hpp
index 09e7828acab..d6f38484776 100644
--- a/stan/math/prim/fun/floor.hpp
+++ b/stan/math/prim/fun/floor.hpp
@@ -59,7 +59,7 @@ template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr,
           require_not_var_matrix_t<Container>* = nullptr>
 inline auto floor(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().floor(); });
 }
diff --git a/stan/math/prim/fun/inv.hpp b/stan/math/prim/fun/inv.hpp
index 72d2cd26733..bcdec1defbe 100644
--- a/stan/math/prim/fun/inv.hpp
+++ b/stan/math/prim/fun/inv.hpp
@@ -51,7 +51,7 @@ template <typename Container,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               Container>* = nullptr>
 inline auto inv(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().inverse(); });
 }
diff --git a/stan/math/prim/fun/inv_cloglog.hpp b/stan/math/prim/fun/inv_cloglog.hpp
index 714cef57b7c..499dcc7d926 100644
--- a/stan/math/prim/fun/inv_cloglog.hpp
+++ b/stan/math/prim/fun/inv_cloglog.hpp
@@ -106,7 +106,7 @@ inline auto inv_cloglog(Container&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto inv_cloglog(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x), [](const auto& v) {
         return (1 - (-std::forward<decltype(v)>(v).array().exp()).exp());
       });
diff --git a/stan/math/prim/fun/inv_square.hpp b/stan/math/prim/fun/inv_square.hpp
index 79a2c755f35..73cba9e0e65 100644
--- a/stan/math/prim/fun/inv_square.hpp
+++ b/stan/math/prim/fun/inv_square.hpp
@@ -35,7 +35,7 @@ inline auto inv_square(const Container& x) {
 template <typename Container,
           require_container_st<std::is_arithmetic, Container>* = nullptr>
 inline auto inv_square(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x), [](auto&& v) {
         return std::forward<decltype(v)>(v).array().square().inverse();
       });
diff --git a/stan/math/prim/fun/log.hpp b/stan/math/prim/fun/log.hpp
index d3df5d3c82d..25a78453216 100644
--- a/stan/math/prim/fun/log.hpp
+++ b/stan/math/prim/fun/log.hpp
@@ -83,7 +83,7 @@ inline auto log(Container&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto log(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().log(); });
 }
diff --git a/stan/math/prim/fun/log10.hpp b/stan/math/prim/fun/log10.hpp
index 6b928c39fd1..7ef368fa77e 100644
--- a/stan/math/prim/fun/log10.hpp
+++ b/stan/math/prim/fun/log10.hpp
@@ -74,7 +74,7 @@ inline auto log10(Container&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto log10(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().log10(); });
 }
diff --git a/stan/math/prim/fun/minus.hpp b/stan/math/prim/fun/minus.hpp
index 58c8c682677..c7e8b7c9585 100644
--- a/stan/math/prim/fun/minus.hpp
+++ b/stan/math/prim/fun/minus.hpp
@@ -34,7 +34,7 @@ inline auto minus(T&& x) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto minus(T&& x) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x),
       [](auto&& v) { return -std::forward<decltype(v)>(v); });
 }
diff --git a/stan/math/prim/fun/quad_form.hpp b/stan/math/prim/fun/quad_form.hpp
index 46cabbe601a..e4d7fa8066c 100644
--- a/stan/math/prim/fun/quad_form.hpp
+++ b/stan/math/prim/fun/quad_form.hpp
@@ -52,11 +52,13 @@ template <typename EigMat, typename ColVec, require_eigen_t<EigMat>* = nullptr,
           require_eigen_col_vector_t<ColVec>* = nullptr,
           require_vt_same<EigMat, ColVec>* = nullptr,
           require_all_vt_arithmetic<EigMat, ColVec>* = nullptr>
-inline value_type_t<EigMat> quad_form(const EigMat& A, const ColVec& B) {
+inline value_type_t<EigMat> quad_form(EigMat&& A, ColVec&& B) {
   check_square("quad_form", "A", A);
   check_multiplicable("quad_form", "A", A, "B", B);
-  const auto& B_ref = to_ref(B);
-  return B_ref.dot(A * B_ref);
+  return make_holder([](auto&& b, auto&& a) {
+    auto&& b_ref = to_ref(std::forward<decltype(b)>(b));
+    return b_ref.dot(a * b_ref);
+  }, std::forward<ColVec>(B), std::forward<EigMat>(A));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/quad_form_sym.hpp b/stan/math/prim/fun/quad_form_sym.hpp
index 7b9359d82ae..2b6d5f78613 100644
--- a/stan/math/prim/fun/quad_form_sym.hpp
+++ b/stan/math/prim/fun/quad_form_sym.hpp
@@ -27,14 +27,14 @@ template <typename EigMat1, typename EigMat2,
           require_not_eigen_col_vector_t<EigMat2>* = nullptr,
           require_vt_same<EigMat1, EigMat2>* = nullptr,
           require_all_vt_arithmetic<EigMat1, EigMat2>* = nullptr>
-inline plain_type_t<EigMat2> quad_form_sym(const EigMat1& A, const EigMat2& B) {
+inline plain_type_t<EigMat2> quad_form_sym(EigMat1&& A, EigMat2&& B) {
   check_multiplicable("quad_form_sym", "A", A, "B", B);
-  const auto& A_ref = to_ref(A);
-  const auto& B_ref = to_ref(B);
+  auto&& A_ref = to_ref(std::forward<EigMat1>(A));
   check_symmetric("quad_form_sym", "A", A_ref);
-  return make_holder(
-      [](const auto& ret) { return 0.5 * (ret + ret.transpose()); },
-      (B_ref.transpose() * A_ref * B_ref).eval());
+  return make_holder([](auto&& a, auto&& b) {
+    auto ret = (a.transpose() * a * b).eval();
+    return 0.5 * (ret + ret.transpose());
+  }, std::forward<decltype(A_ref)>(A_ref), to_ref(std::forward<EigMat2>(B)));
 }
 
 /**
@@ -53,12 +53,13 @@ template <typename EigMat, typename ColVec, require_eigen_t<EigMat>* = nullptr,
           require_eigen_col_vector_t<ColVec>* = nullptr,
           require_vt_same<EigMat, ColVec>* = nullptr,
           require_all_vt_arithmetic<EigMat, ColVec>* = nullptr>
-inline value_type_t<EigMat> quad_form_sym(const EigMat& A, const ColVec& B) {
+inline value_type_t<EigMat> quad_form_sym(EigMat&& A, ColVec&& B) {
   check_multiplicable("quad_form_sym", "A", A, "B", B);
-  const auto& A_ref = to_ref(A);
-  const auto& B_ref = to_ref(B);
+  auto&& A_ref = to_ref(std::forward<EigMat>(A));
   check_symmetric("quad_form_sym", "A", A_ref);
-  return B_ref.dot(A_ref * B_ref);
+  return make_holder([](auto&& a, auto&& b) {
+    return b.dot(a * b);
+  }, std::forward<decltype(A_ref)>(A_ref), to_ref(std::forward<ColVec>(B)));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/read_corr_L.hpp b/stan/math/prim/fun/read_corr_L.hpp
index 5e646ef82ae..53194e855a0 100644
--- a/stan/math/prim/fun/read_corr_L.hpp
+++ b/stan/math/prim/fun/read_corr_L.hpp
@@ -34,7 +34,7 @@ namespace math {
  * canonical partial correlations.
  */
 template <typename T, require_eigen_vector_t<T>* = nullptr>
-Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic> read_corr_L(
+inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic> read_corr_L(
     const T& CPCs,  // on (-1, 1)
     size_t K) {
   using T_scalar = value_type_t<T>;
@@ -101,8 +101,8 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic> read_corr_L(
  */
 template <typename T, typename Lp, require_eigen_vector_t<T>* = nullptr,
           require_convertible_t<value_type_t<T>, Lp>* = nullptr>
-Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic> read_corr_L(
-    const T& CPCs, size_t K, Lp& log_prob) {
+inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic> read_corr_L(
+    T&& CPCs, size_t K, Lp& log_prob) {
   using T_scalar = value_type_t<T>;
   if (K == 0) {
     return {};
@@ -112,7 +112,7 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic> read_corr_L(
                                                                              1);
   }
 
-  const Eigen::Ref<const plain_type_t<T>>& CPCs_ref = CPCs;
+  auto&& CPCs_ref = to_ref(std::forward<T>(CPCs));
   size_t pos = 0;
   T_scalar acc = 0;
   // no need to abs() because this Jacobian determinant
diff --git a/stan/math/prim/fun/read_corr_matrix.hpp b/stan/math/prim/fun/read_corr_matrix.hpp
index 53b6e2cdff8..fe8c3d01917 100644
--- a/stan/math/prim/fun/read_corr_matrix.hpp
+++ b/stan/math/prim/fun/read_corr_matrix.hpp
@@ -23,13 +23,12 @@ namespace math {
  * canonical partial correlations.
  */
 template <typename T_CPCs, require_eigen_vector_t<T_CPCs>* = nullptr>
-Eigen::Matrix<value_type_t<T_CPCs>, Eigen::Dynamic, Eigen::Dynamic>
-read_corr_matrix(const T_CPCs& CPCs, size_t K) {
+inline Eigen::Matrix<value_type_t<T_CPCs>, Eigen::Dynamic, Eigen::Dynamic>
+read_corr_matrix(T_CPCs&& CPCs, size_t K) {
   if (K == 0) {
     return {};
   }
-
-  return multiply_lower_tri_self_transpose(read_corr_L(CPCs, K));
+  return multiply_lower_tri_self_transpose(read_corr_L(std::forward<T_CPCs>(CPCs), K));
 }
 
 /**
@@ -56,13 +55,12 @@ read_corr_matrix(const T_CPCs& CPCs, size_t K) {
 template <typename T_CPCs, typename Lp,
           require_eigen_vector_t<T_CPCs>* = nullptr,
           require_convertible_t<value_type_t<T_CPCs>, Lp>* = nullptr>
-Eigen::Matrix<value_type_t<T_CPCs>, Eigen::Dynamic, Eigen::Dynamic>
-read_corr_matrix(const T_CPCs& CPCs, size_t K, Lp& log_prob) {
+inline Eigen::Matrix<value_type_t<T_CPCs>, Eigen::Dynamic, Eigen::Dynamic>
+read_corr_matrix(T_CPCs&& CPCs, size_t K, Lp& log_prob) {
   if (K == 0) {
     return {};
   }
-
-  return multiply_lower_tri_self_transpose(read_corr_L(CPCs, K, log_prob));
+  return multiply_lower_tri_self_transpose(read_corr_L(std::forward<T_CPCs>(CPCs), K, log_prob));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/read_cov_matrix.hpp b/stan/math/prim/fun/read_cov_matrix.hpp
index 0e7e629845d..b7043d20666 100644
--- a/stan/math/prim/fun/read_cov_matrix.hpp
+++ b/stan/math/prim/fun/read_cov_matrix.hpp
@@ -30,7 +30,7 @@ read_cov_matrix(const T_CPCs& CPCs, const T_sds& sds,
                 value_type_t<T_CPCs>& log_prob) {
   Eigen::Matrix<value_type_t<T_CPCs>, Eigen::Dynamic, Eigen::Dynamic> L
       = read_cov_L(CPCs, sds, log_prob);
-  return multiply_lower_tri_self_transpose(L);
+  return multiply_lower_tri_self_transpose(std::move(L));
 }
 
 /**
@@ -53,7 +53,7 @@ read_cov_matrix(const T_CPCs& CPCs, const T_sds& sds) {
   D.diagonal() = sds;
   Eigen::Matrix<value_type_t<T_CPCs>, Eigen::Dynamic, Eigen::Dynamic> L
       = D * read_corr_L(CPCs, K);
-  return multiply_lower_tri_self_transpose(L);
+  return multiply_lower_tri_self_transpose(std::move(L));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/rep_matrix.hpp b/stan/math/prim/fun/rep_matrix.hpp
index 7333ec3833d..3bd3dab0775 100644
--- a/stan/math/prim/fun/rep_matrix.hpp
+++ b/stan/math/prim/fun/rep_matrix.hpp
@@ -51,13 +51,17 @@ inline auto rep_matrix(const T& x, int m, int n) {
  * @param n Number of rows or columns.
  */
 template <typename Vec, require_eigen_vector_t<Vec>* = nullptr>
-inline auto rep_matrix(const Vec& x, int n) {
-  if (is_eigen_row_vector<Vec>::value) {
+inline auto rep_matrix(Vec&& x, int n) {
+  if constexpr (is_eigen_row_vector<Vec>::value) {
     check_nonnegative("rep_matrix", "rows", n);
-    return x.replicate(n, 1);
+    return make_holder([n](auto&& xx) {
+      return xx.replicate(n, 1);
+    }, std::forward<Vec>(x));
   } else {
     check_nonnegative("rep_matrix", "cols", n);
-    return x.replicate(1, n);
+    return make_holder([n](auto&& xx) {
+      return xx.replicate(1, n);
+    }, std::forward<Vec>(x));
   }
 }
 
diff --git a/stan/math/prim/fun/reverse.hpp b/stan/math/prim/fun/reverse.hpp
index 82c58ca1d70..5062cb9a4e3 100644
--- a/stan/math/prim/fun/reverse.hpp
+++ b/stan/math/prim/fun/reverse.hpp
@@ -32,8 +32,11 @@ inline std::vector<T> reverse(const std::vector<T>& x) {
  * @return Vector or row vector in reversed order.
  */
 template <typename T, typename = require_vector_t<T>>
-inline auto reverse(const T& x) {
-  return x.reverse();
+inline auto reverse(T&& x) {
+  return make_holder(
+      [](auto&& xx) {
+          return xx.reverse();
+      }, std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/round.hpp b/stan/math/prim/fun/round.hpp
index 09e8a7d8ac6..74b9191370e 100644
--- a/stan/math/prim/fun/round.hpp
+++ b/stan/math/prim/fun/round.hpp
@@ -52,7 +52,7 @@ inline auto round(Container&& x) {
 template <typename Container,
           require_container_st<std::is_arithmetic, Container>* = nullptr>
 inline auto round(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().round(); });
 }
diff --git a/stan/math/prim/fun/row.hpp b/stan/math/prim/fun/row.hpp
index 9e4ce94f33a..fea6571143e 100644
--- a/stan/math/prim/fun/row.hpp
+++ b/stan/math/prim/fun/row.hpp
@@ -21,10 +21,11 @@ namespace math {
  * @throw std::out_of_range if i is out of range.
  */
 template <typename T, require_matrix_t<T>* = nullptr>
-inline auto row(const T& m, size_t i) {
+inline auto row(T&& m, size_t i) {
   check_row_index("row", "i", m, i);
-
-  return m.row(i - 1);
+  return make_holder([i](auto&& mm) {
+        return std::forward<decltype(mm)>(mm).row(i - 1);
+  }, std::forward<T>(m), i);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/rows.hpp b/stan/math/prim/fun/rows.hpp
index b6e5f9925fe..d9a3ef980bc 100644
--- a/stan/math/prim/fun/rows.hpp
+++ b/stan/math/prim/fun/rows.hpp
@@ -17,8 +17,10 @@ namespace math {
  * @return Number of rows.
  */
 template <typename T, require_matrix_t<T>* = nullptr>
-inline int64_t rows(const T& m) {
-  return m.rows();
+inline int64_t rows(T&& m) {
+  return make_holder(
+      [](auto&& mm) { return std::forward<decltype(mm)>(mm).rows(); },
+      std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/rows_dot_product.hpp b/stan/math/prim/fun/rows_dot_product.hpp
index 29bdc14e647..80d29388e21 100644
--- a/stan/math/prim/fun/rows_dot_product.hpp
+++ b/stan/math/prim/fun/rows_dot_product.hpp
@@ -24,10 +24,12 @@ namespace math {
 template <typename Mat1, typename Mat2,
           require_all_eigen_t<Mat1, Mat2>* = nullptr,
           require_all_not_eigen_vt<is_var, Mat1, Mat2>* = nullptr>
-inline Eigen::Matrix<return_type_t<Mat1, Mat2>, Mat1::RowsAtCompileTime, 1>
-rows_dot_product(const Mat1& v1, const Mat2& v2) {
+inline auto rows_dot_product(Mat1&& v1, Mat2&& v2) {
   check_matching_sizes("rows_dot_product", "v1", v1, "v2", v2);
-  return (v1.cwiseProduct(v2)).rowwise().sum();
+  return make_holder(
+      [](auto&& v1, auto&& v2) {
+        return (std::forward<decltype(v1)>(v1).cwiseProduct(std::forward<decltype(v2)>(v2))).rowwise().sum();
+      }, std::forward<Mat1>(v1), std::forward<Mat2>(v2));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/rows_dot_self.hpp b/stan/math/prim/fun/rows_dot_self.hpp
index 06d0af10de0..0f3c8465485 100644
--- a/stan/math/prim/fun/rows_dot_self.hpp
+++ b/stan/math/prim/fun/rows_dot_self.hpp
@@ -17,9 +17,11 @@ namespace math {
  */
 template <typename T, require_eigen_t<T>* = nullptr,
           require_not_st_var<T>* = nullptr>
-inline Eigen::Matrix<value_type_t<T>, T::RowsAtCompileTime, 1> rows_dot_self(
-    const T& x) {
-  return x.rowwise().squaredNorm();
+inline auto rows_dot_self(
+    T&& x) {
+  return make_holder([](const auto& xx) {
+        return std::forward<decltype(xx)>(xx).rowwise().squaredNorm();
+  }, std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/scale_matrix_exp_multiply.hpp b/stan/math/prim/fun/scale_matrix_exp_multiply.hpp
index 7901aafc80e..9e7e859f2eb 100644
--- a/stan/math/prim/fun/scale_matrix_exp_multiply.hpp
+++ b/stan/math/prim/fun/scale_matrix_exp_multiply.hpp
@@ -55,16 +55,17 @@ template <typename Tt, typename EigMat1, typename EigMat2,
           require_all_eigen_t<EigMat1, EigMat2>* = nullptr,
           require_any_autodiff_t<Tt, value_type_t<EigMat1>,
                                  value_type_t<EigMat2>>* = nullptr>
-inline Eigen::Matrix<return_type_t<Tt, EigMat1, EigMat2>, Eigen::Dynamic,
-                     EigMat2::ColsAtCompileTime>
-scale_matrix_exp_multiply(const Tt& t, const EigMat1& A, const EigMat2& B) {
+inline auto scale_matrix_exp_multiply(Tt&& t, EigMat1&& A, EigMat2&& B) {
   check_square("scale_matrix_exp_multiply", "input matrix", A);
   check_multiplicable("scale_matrix_exp_multiply", "A", A, "B", B);
   if (A.size() == 0) {
     return {0, B.cols()};
   }
 
-  return multiply(matrix_exp(multiply(A, t)), B);
+  return make_holder([t](auto&& A_, auto&& B_) {
+    return multiply(matrix_exp(multiply(std::forward<decltype(A_)>(A_), t)),
+      std::forward<decltype(B_)>(B_));
+  }, std::forward<EigMat1>(A), std::forward<EigMat2>(B));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sd.hpp b/stan/math/prim/fun/sd.hpp
index bee70a57c32..8eb4292cfa2 100644
--- a/stan/math/prim/fun/sd.hpp
+++ b/stan/math/prim/fun/sd.hpp
@@ -25,7 +25,6 @@ template <typename T, require_container_t<T>* = nullptr,
           require_not_st_var<T>* = nullptr>
 inline auto sd(T&& m) {
   using std::sqrt;
-
   return apply_vector_unary<std::decay_t<T>>::reduce(
       std::forward<T>(m), [](auto&& x) {
         check_nonzero_size("sd", "x", x);
@@ -34,7 +33,7 @@ inline auto sd(T&& m) {
           return scalar_type_t<T>(0.0);
         }
 
-        return sqrt(variance(x));
+        return sqrt(variance(std::forward<decltype(x)>(x)));
       });
 }
 
diff --git a/stan/math/prim/fun/segment.hpp b/stan/math/prim/fun/segment.hpp
index 38ef04a1697..ebd197c733e 100644
--- a/stan/math/prim/fun/segment.hpp
+++ b/stan/math/prim/fun/segment.hpp
@@ -15,7 +15,7 @@ namespace math {
  * @tparam T type of the vector
  */
 template <typename Vec, require_vector_t<Vec>* = nullptr>
-inline auto segment(const Vec& v, size_t i, size_t n) {
+inline auto segment(Vec&& v, size_t i, size_t n) {
   check_greater("segment", "n", i, 0.0);
   check_less_or_equal("segment", "n", i, static_cast<size_t>(v.size()));
   if (n != 0) {
@@ -23,7 +23,9 @@ inline auto segment(const Vec& v, size_t i, size_t n) {
     check_less_or_equal("segment", "n", i + n - 1,
                         static_cast<size_t>(v.size()));
   }
-  return v.segment(i - 1, n);
+  return make_holder([i, n](auto&& v_) {
+    return v_.segment(i - 1, n);
+  }, std::forward<Vec>(v));
 }
 
 template <typename T>
diff --git a/stan/math/prim/fun/select.hpp b/stan/math/prim/fun/select.hpp
index 99f3a461061..b4dcac58d01 100644
--- a/stan/math/prim/fun/select.hpp
+++ b/stan/math/prim/fun/select.hpp
@@ -121,7 +121,7 @@ inline ReturnT select(const bool c, const T_true y_true, T_false&& y_false) {
         },
         T_true(y_true), std::forward<T_false>(y_false));
   } else {
-    return y_false;
+    return std::forward<T_false>(y_false);
   }
 }
 
@@ -145,11 +145,11 @@ template <typename T_bool, typename T_true, typename T_false,
           require_all_stan_scalar_t<T_true, T_false>* = nullptr>
 inline auto select(T_bool&& c, const T_true y_true, const T_false y_false) {
   using ret_t = return_type_t<T_true, T_false>;
-  return std::forward<T_bool>(c)
-      .unaryExpr([y_true, y_false](bool cond) {
-        return cond ? ret_t(y_true) : ret_t(y_false);
-      })
-      .eval();
+  return make_holder([y_true, y_false](auto&& c_){
+    return std::forward<decltype(c_)>(c_).unaryExpr([y_true, y_false](bool cond) {
+          return cond ? ret_t(y_true) : ret_t(y_false);
+        });
+  }, std::forward<T_bool>(c));
 }
 
 /**
@@ -171,10 +171,13 @@ inline auto select(T_bool&& c, T_true&& y_true, T_false&& y_false) {
   check_consistent_sizes("select", "boolean", c, "left hand side", y_true,
                          "right hand side", y_false);
   using ret_t = return_type_t<T_true, T_false>;
-  return std::forward<T_bool>(c)
-      .select(std::forward<T_true>(y_true), std::forward<T_false>(y_false))
-      .template cast<ret_t>()
-      .eval();
+  return make_holder([](auto&& c_, auto&& y_true_, auto&& y_false_){
+    return std::forward<decltype(c_)>(c_)
+        .select(std::forward<decltype(y_true_)>(y_true_),
+                 std::forward<decltype(y_false_)>(y_false_))
+        .template cast<ret_t>().eval();
+  }, std::forward<T_bool>(c), std::forward<T_true>(y_true),
+      std::forward<T_false>(y_false));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sin.hpp b/stan/math/prim/fun/sin.hpp
index 850bbcabc9f..15349da0455 100644
--- a/stan/math/prim/fun/sin.hpp
+++ b/stan/math/prim/fun/sin.hpp
@@ -74,7 +74,7 @@ inline auto sin(T&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto sin(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [&](auto&& v) { return std::forward<decltype(v)>(v).array().sin(); });
 }
diff --git a/stan/math/prim/fun/sinh.hpp b/stan/math/prim/fun/sinh.hpp
index a6a8f93c09d..7a5c744d97d 100644
--- a/stan/math/prim/fun/sinh.hpp
+++ b/stan/math/prim/fun/sinh.hpp
@@ -73,7 +73,7 @@ inline auto sinh(Container&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto sinh(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().sinh(); });
 }
diff --git a/stan/math/prim/fun/sqrt.hpp b/stan/math/prim/fun/sqrt.hpp
index 75c680373a2..343a8ae4492 100644
--- a/stan/math/prim/fun/sqrt.hpp
+++ b/stan/math/prim/fun/sqrt.hpp
@@ -74,7 +74,7 @@ template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr,
           require_not_var_matrix_t<Container>* = nullptr>
 inline auto sqrt(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().sqrt(); });
 }
diff --git a/stan/math/prim/fun/square.hpp b/stan/math/prim/fun/square.hpp
index 10859a54beb..53dd3b68076 100644
--- a/stan/math/prim/fun/square.hpp
+++ b/stan/math/prim/fun/square.hpp
@@ -37,8 +37,8 @@ inline double square(const T x) {
  */
 struct square_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return square(x);
+  static inline auto fun(T&& x) {
+    return square(std::forward<T>(x));
   }
 };
 
@@ -66,7 +66,7 @@ inline auto square(Container&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto square(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().square(); });
 }
diff --git a/stan/math/prim/fun/tan.hpp b/stan/math/prim/fun/tan.hpp
index 9c1d758bc3a..e7b4b1796d9 100644
--- a/stan/math/prim/fun/tan.hpp
+++ b/stan/math/prim/fun/tan.hpp
@@ -75,7 +75,7 @@ inline auto tan(Container&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto tan(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().tan(); });
 }
diff --git a/stan/math/prim/fun/tanh.hpp b/stan/math/prim/fun/tanh.hpp
index bcc25653ab3..5aaa2016801 100644
--- a/stan/math/prim/fun/tanh.hpp
+++ b/stan/math/prim/fun/tanh.hpp
@@ -75,7 +75,7 @@ inline auto tanh(Container&& x) {
 template <typename Container,
           require_container_bt<std::is_arithmetic, Container>* = nullptr>
 inline auto tanh(Container&& x) {
-  return apply_vector_unary<std::decay_t<Container>>::apply(
+  return apply_vector_unary<Container>::apply(
       std::forward<Container>(x),
       [](auto&& v) { return std::forward<decltype(v)>(v).array().tanh(); });
 }
diff --git a/stan/math/prim/functor/apply_scalar_binary.hpp b/stan/math/prim/functor/apply_scalar_binary.hpp
index b0f60807031..7ee18d0ec01 100644
--- a/stan/math/prim/functor/apply_scalar_binary.hpp
+++ b/stan/math/prim/functor/apply_scalar_binary.hpp
@@ -34,8 +34,8 @@ namespace math {
  */
 template <typename F, typename T1, typename T2,
           require_all_stan_scalar_t<T1, T2>* = nullptr>
-inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
-  return f(x, y);
+inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
+  return std::forward<F>(f)(std::forward<T1>(x), std::forward<T2>(y));
 }
 
 /**
@@ -57,7 +57,8 @@ inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   check_matching_dims("Binary function", "x", x, "y", y);
   return make_holder(
       [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
-        return x_inner.binaryExpr(y_inner, f_inner);
+        return std::forward<decltype(x_inner)>(x_inner).binaryExpr(
+          std::forward<decltype(y_inner)>(y_inner), std::forward<decltype(f_inner)>(f_inner));
       },
       std::forward<F>(f), std::forward<T1>(x), std::forward<T2>(y));
 }
@@ -84,7 +85,8 @@ inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
         using int_vec_t = promote_scalar_t<value_type_t<decltype(y_inner)>,
                                            plain_type_t<decltype(x_inner)>>;
         Eigen::Map<const int_vec_t> y_map(y_inner.data(), y_inner.size());
-        return x_inner.binaryExpr(y_map, f_inner);
+        return std::forward<decltype(x_inner)>(x_inner).binaryExpr(
+          y_map, std::forward<decltype(f_inner)>(f_inner));
       },
       std::forward<F>(f), std::forward<T1>(x), std::forward<T2>(y));
 }
@@ -111,7 +113,8 @@ inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
         using int_vec_t = promote_scalar_t<value_type_t<decltype(x_inner)>,
                                            plain_type_t<decltype(y_inner)>>;
         Eigen::Map<const int_vec_t> x_map(x_inner.data(), x_inner.size());
-        return x_map.binaryExpr(y_inner, f_inner);
+        return x_map.binaryExpr(std::forward<decltype(y_inner)>(y_inner),
+          std::forward<decltype(f_inner)>(f_inner));
       },
       std::forward<F>(f), std::forward<T1>(x), std::forward<T2>(y));
 }
@@ -132,7 +135,7 @@ template <typename F, typename T1, typename T2,
           require_eigen_matrix_dynamic_vt<is_stan_scalar, T1>* = nullptr,
           require_std_vector_vt<is_std_vector, T2>* = nullptr,
           require_std_vector_st<std::is_integral, T2>* = nullptr>
-inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
+inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   if (num_elements(x) != num_elements(y)) {
     std::ostringstream msg;
     msg << "Inputs to vectorized binary function must match in"
@@ -165,7 +168,7 @@ template <typename F, typename T1, typename T2,
           require_std_vector_vt<is_std_vector, T1>* = nullptr,
           require_std_vector_st<std::is_integral, T1>* = nullptr,
           require_eigen_matrix_dynamic_vt<is_stan_scalar, T2>* = nullptr>
-inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
+inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   if (num_elements(x) != num_elements(y)) {
     std::ostringstream msg;
     msg << "Inputs to vectorized binary function must match in"
@@ -202,9 +205,9 @@ template <typename F, typename T1, typename T2, require_eigen_t<T1>* = nullptr,
 inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   return make_holder(
       [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
-        return x_inner.unaryExpr(
+        return std::forward<decltype(x_inner)>(x_inner).unaryExpr(
             [f_inner_ = std::forward<decltype(f_inner)>(f_inner),
-             y_inner](const auto& v) { return f_inner_(v, y_inner); });
+             y_inner](auto&& v) { return f_inner_(v, y_inner); });
       },
       std::forward<F>(f), std::forward<T1>(x), std::forward<T2>(y));
 }
@@ -229,7 +232,7 @@ template <typename F, typename T1, typename T2,
 inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   return make_holder(
       [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
-        return y_inner.unaryExpr(
+        return std::forward<decltype(y_inner)>(y_inner).unaryExpr(
             [f_inner_ = std::forward<decltype(f_inner)>(f_inner),
              x_inner](auto&& v) {
               return f_inner_(x_inner, std::forward<decltype(v)>(v));
@@ -257,14 +260,14 @@ inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
  */
 template <typename F, typename T1, typename T2,
           require_all_std_vector_vt<is_stan_scalar, T1, T2>* = nullptr>
-inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
+inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   check_matching_sizes("Binary function", "x", x, "y", y);
-  decltype(auto) x_vec = as_column_vector_or_scalar(x);
-  decltype(auto) y_vec = as_column_vector_or_scalar(y);
+  decltype(auto) x_vec = as_column_vector_or_scalar(std::forward<T1>(x));
+  decltype(auto) y_vec = as_column_vector_or_scalar(std::forward<T2>(y));
   using T_return = std::decay_t<decltype(f(x[0], y[0]))>;
   std::vector<T_return> result(x.size());
   Eigen::Map<Eigen::Matrix<T_return, -1, 1>>(result.data(), result.size())
-      = x_vec.binaryExpr(y_vec, f);
+      = x_vec.binaryExpr(y_vec, std::forward<F>(f));
   return result;
 }
 
@@ -289,12 +292,12 @@ inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
 template <typename F, typename T1, typename T2,
           require_std_vector_vt<is_stan_scalar, T1>* = nullptr,
           require_stan_scalar_t<T2>* = nullptr>
-inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
-  decltype(auto) x_vec = as_column_vector_or_scalar(x);
+inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
+  decltype(auto) x_vec = as_column_vector_or_scalar(std::forward<T1>(x));
   using T_return = std::decay_t<decltype(f(x[0], y))>;
   std::vector<T_return> result(x.size());
   Eigen::Map<Eigen::Matrix<T_return, -1, 1>>(result.data(), result.size())
-      = x_vec.unaryExpr([f, y](const auto& v) { return f(v, y); });
+      = x_vec.unaryExpr([f_ = std::forward<F>(f), y](auto&& v) { return f_(v, y); });
   return result;
 }
 
@@ -319,12 +322,12 @@ inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
 template <typename F, typename T1, typename T2,
           require_stan_scalar_t<T1>* = nullptr,
           require_std_vector_vt<is_stan_scalar, T2>* = nullptr>
-inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
+inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   decltype(auto) y_vec = as_column_vector_or_scalar(y);
   using T_return = std::decay_t<decltype(f(x, y[0]))>;
   std::vector<T_return> result(y.size());
   Eigen::Map<Eigen::Matrix<T_return, -1, 1>>(result.data(), result.size())
-      = y_vec.unaryExpr([f, x](const auto& v) { return f(x, v); });
+      = y_vec.unaryExpr([f_ = std::forward<F>(f), x](auto&& v) { return f_(x, v); });
   return result;
 }
 
@@ -345,7 +348,7 @@ inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
 template <
     typename F, typename T1, typename T2,
     require_all_std_vector_vt<is_container_or_var_matrix, T1, T2>* = nullptr>
-inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
+inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   check_matching_sizes("Binary function", "x", x, "y", y);
   using T_return = plain_type_t<decltype(apply_scalar_binary(f, x[0], y[0]))>;
   size_t y_size = y.size();
@@ -373,7 +376,7 @@ inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
 template <typename F, typename T1, typename T2,
           require_std_vector_vt<is_container_or_var_matrix, T1>* = nullptr,
           require_stan_scalar_t<T2>* = nullptr>
-inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
+inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   using T_return = plain_type_t<decltype(apply_scalar_binary(f, x[0], y))>;
   size_t x_size = x.size();
   std::vector<T_return> result(x_size);
@@ -400,7 +403,7 @@ inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
 template <typename F, typename T1, typename T2,
           require_stan_scalar_t<T1>* = nullptr,
           require_std_vector_vt<is_container_or_var_matrix, T2>* = nullptr>
-inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
+inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   using T_return = plain_type_t<decltype(apply_scalar_binary(f, x, y[0]))>;
   size_t y_size = y.size();
   std::vector<T_return> result(y_size);
diff --git a/stan/math/prim/functor/apply_scalar_ternary.hpp b/stan/math/prim/functor/apply_scalar_ternary.hpp
index 81dc4bf081e..b1f4ff797e6 100644
--- a/stan/math/prim/functor/apply_scalar_ternary.hpp
+++ b/stan/math/prim/functor/apply_scalar_ternary.hpp
@@ -36,9 +36,8 @@ namespace math {
  */
 template <typename F, typename T1, typename T2, typename T3,
           require_all_stan_scalar_t<T1, T2, T3>* = nullptr>
-inline auto apply_scalar_ternary(const F& f, const T1& x, const T2& y,
-                                 const T3& z) {
-  return f(x, y, z);
+inline auto apply_scalar_ternary(F&& f, T1&& x, T2&& y, T3&& z) {
+  return std::forward<F>(f)(std::forward<T1>(x), std::forward<T2>(y), std::forward<T3>(z));
 }
 
 /**
@@ -93,8 +92,7 @@ inline auto apply_scalar_ternary(F&& f, T1&& x, T2&& y, T3&& z) {
  */
 template <typename F, typename T1, typename T2, typename T3,
           require_all_std_vector_vt<is_stan_scalar, T1, T2, T3>* = nullptr>
-inline auto apply_scalar_ternary(const F& f, const T1& x, const T2& y,
-                                 const T3& z) {
+inline auto apply_scalar_ternary(F&& f, T1&& x, T2&& y, T3&& z) {
   check_matching_sizes("Ternary function", "x", x, "y", y);
   check_matching_sizes("Ternary function", "y", y, "z", z);
   decltype(auto) x_vec = as_column_vector_or_scalar(x);
@@ -103,7 +101,7 @@ inline auto apply_scalar_ternary(const F& f, const T1& x, const T2& y,
   using T_return = std::decay_t<decltype(f(x[0], y[0], z[0]))>;
   std::vector<T_return> result(x.size());
   Eigen::Map<Eigen::Matrix<T_return, -1, 1>>(result.data(), result.size())
-      = apply_scalar_ternary(f, x_vec, y_vec, z_vec);
+      = apply_scalar_ternary(std::forward<F>(f), x_vec, y_vec, z_vec);
   return result;
 }
 
@@ -186,10 +184,10 @@ inline auto apply_scalar_ternary(F&& f, T1&& x, T2&& y, T3&& z) {
 template <typename F, typename T1, typename T2, typename T3,
           require_all_container_t<T1, T3>* = nullptr,
           require_stan_scalar_t<T2>* = nullptr>
-inline auto apply_scalar_ternary(const F& f, T1&& x, T2&& y, T3&& z) {
+inline auto apply_scalar_ternary(F&& f, T1&& x, T2&& y, T3&& z) {
   return apply_scalar_binary(
-      [f, y](auto&& a, auto&& c) {
-        return f(std::forward<decltype(a)>(a), y, std::forward<decltype(c)>(c));
+      [f_ = std::forward<F>(f), y](auto&& a, auto&& c) {
+        return f_(std::forward<decltype(a)>(a), y, std::forward<decltype(c)>(c));
       },
       std::forward<T1>(x), std::forward<T3>(z));
 }
@@ -213,10 +211,10 @@ inline auto apply_scalar_ternary(const F& f, T1&& x, T2&& y, T3&& z) {
 template <typename F, typename T1, typename T2, typename T3,
           require_container_t<T3>* = nullptr,
           require_stan_scalar_t<T1>* = nullptr>
-inline auto apply_scalar_ternary(const F& f, T1&& x, T2&& y, T3&& z) {
+inline auto apply_scalar_ternary(F&& f, T1&& x, T2&& y, T3&& z) {
   return apply_scalar_binary(
-      [f, x](auto&& b, auto&& c) {
-        return f(x, std::forward<decltype(b)>(b), std::forward<decltype(c)>(c));
+      [f_ = std::forward<F>(f), x](auto&& b, auto&& c) {
+        return f_(x, std::forward<decltype(b)>(b), std::forward<decltype(c)>(c));
       },
       std::forward<T2>(y), std::forward<T3>(z));
 }
diff --git a/stan/math/prim/functor/apply_scalar_unary.hpp b/stan/math/prim/functor/apply_scalar_unary.hpp
index cad17ca8301..58312c1ac56 100644
--- a/stan/math/prim/functor/apply_scalar_unary.hpp
+++ b/stan/math/prim/functor/apply_scalar_unary.hpp
@@ -124,8 +124,8 @@ struct apply_scalar_unary<F, T, require_complex_t<T>> {
    * @return Result of applying F to the scalar.
    */
   template <typename T2>
-  static inline auto apply(const T2& x) {
-    return F::fun(x);
+  static inline auto apply(T2&& x) {
+    return F::fun(std::forward<T2>(x));
   }
   /**
    * The return type
diff --git a/stan/math/prim/functor/apply_vector_unary.hpp b/stan/math/prim/functor/apply_vector_unary.hpp
index f4c1b2f00b4..8d9b8a8a1d4 100644
--- a/stan/math/prim/functor/apply_vector_unary.hpp
+++ b/stan/math/prim/functor/apply_vector_unary.hpp
@@ -129,12 +129,12 @@ struct apply_vector_unary<T, require_std_vector_vt<is_stan_scalar, T>> {
    * @param f functor to apply to vector input.
    * @return std::vector with result of applying functor to input.
    */
-  template <typename F>
-  static inline auto apply(const T& x, const F& f) {
-    using T_return = value_type_t<decltype(f(as_column_vector_or_scalar(x)))>;
+  template <typename T2, typename F>
+  static inline auto apply(T2&& x, F&& f) {
+    using T_return = value_type_t<decltype(f(as_column_vector_or_scalar(std::forward<T2>(x))))>;
     std::vector<T_return> result(x.size());
     Eigen::Map<Eigen::Matrix<T_return, -1, 1>>(result.data(), result.size())
-        = f(as_column_vector_or_scalar(x)).matrix();
+        = std::forward<F>(f)(as_column_vector_or_scalar(std::forward<T2>(x))).matrix();
     return result;
   }
 
diff --git a/stan/math/prim/meta/conjunction.hpp b/stan/math/prim/meta/conjunction.hpp
index 19733e3ee90..d9025860220 100644
--- a/stan/math/prim/meta/conjunction.hpp
+++ b/stan/math/prim/meta/conjunction.hpp
@@ -17,6 +17,10 @@ template <typename T, typename... Ts>
 struct conjunction<T, Ts...>
     : std::conditional_t<T::value, conjunction<Ts...>, std::false_type> {};
 
+
+template <template <typename...> class Cond, typename... Args>
+using all_v = conjunction<Cond<Args>...>;
+
 }  // namespace math
 }  // namespace stan
 #endif
diff --git a/stan/math/prim/meta/disjunction.hpp b/stan/math/prim/meta/disjunction.hpp
index 508e95eb02a..5ccc8657114 100644
--- a/stan/math/prim/meta/disjunction.hpp
+++ b/stan/math/prim/meta/disjunction.hpp
@@ -17,6 +17,9 @@ template <typename Cond, typename... Conds>
 struct disjunction<Cond, Conds...>
     : std::conditional_t<Cond::value, std::true_type, disjunction<Conds...>> {};
 
+template <template <typename...> class Cond, typename... Args>
+using any_v = disjunction<Cond<Args>...>;
+
 }  // namespace math
 }  // namespace stan
 #endif
diff --git a/stan/math/prim/meta/holder.hpp b/stan/math/prim/meta/holder.hpp
index a9b3e4afbce..ae637f9e348 100644
--- a/stan/math/prim/meta/holder.hpp
+++ b/stan/math/prim/meta/holder.hpp
@@ -116,6 +116,24 @@ inline constexpr bool is_holder_v = is_holder<T>::value;
 
 namespace math {
 
+template <
+    typename F, typename... Args,
+    require_not_plain_type_t<std::invoke_result_t<F, Args&&...>>* = nullptr>
+inline auto make_holder(F&& func, Args&&... args);
+
+/**
+ * Calls given function with given arguments. No `holder` is necessary if the
+ * function is not returning Eigen expression.
+ *
+ * @tparam F type of the functor
+ * @tparam Args types of the arguments
+ * @param func the functor
+ * @param args arguments for the functor
+ * @return `holder` referencing expression constructed by given functor
+ */
+template <typename F, typename... Args,
+          require_plain_type_t<std::invoke_result_t<F, Args&&...>>* = nullptr>
+inline auto make_holder(F&& func, Args&&... args);
 /**
  * A no-op Eigen operation. This object also owns pointers to dynamically
  * allocated objects used in its argument expression. When this object is
@@ -169,6 +187,36 @@ class Holder
     m_arg = std::move(other.m_arg);
     return *this;
   }
+
+  inline auto operator-() {
+    return make_holder(
+        [](const auto& arg) { return -arg; }, m_arg);
+  }
+  inline auto operator+() {
+    return make_holder(
+        [](const auto& arg) { return arg; }, m_arg);
+  }
+  template <typename Other>
+  inline auto operator+(Other&& other) {
+    return make_holder(
+        [](const auto& arg, auto&& other_) { return arg + std::forward<decltype(other_)>(other_); }, m_arg, std::forward<Other>(other));
+  }
+  template <typename Other>
+  inline auto operator-(Other&& other) {
+    return make_holder(
+        [](const auto& arg, auto&& other_) { return arg - std::forward<decltype(other_)>(other_); }, m_arg, std::forward<Other>(other));
+  }
+  template <typename Other>
+  inline auto operator*(Other&& other) {
+    return make_holder(
+        [](const auto& arg, auto&& other_) { return arg * std::forward<decltype(other_)>(other_); }, m_arg, std::forward<Other>(other));
+  }
+  template <typename Other>
+  inline auto operator/(Other&& other) {
+    return make_holder(
+        [](const auto& arg, auto&& other_) { return arg / std::forward<decltype(other_)>(other_); }, m_arg, std::forward<Other>(other));
+  }
+
 };
 
 }  // namespace math
@@ -364,7 +412,7 @@ inline auto make_holder_impl(F&& func, std::index_sequence<Is...>,
  */
 template <
     typename F, typename... Args,
-    require_not_plain_type_t<std::invoke_result_t<F, Args&&...>>* = nullptr>
+    require_not_plain_type_t<std::invoke_result_t<F, Args&&...>>*>
 inline auto make_holder(F&& func, Args&&... args) {
   return internal::make_holder_impl(std::forward<F>(func),
                                     std::make_index_sequence<sizeof...(Args)>(),
@@ -382,7 +430,7 @@ inline auto make_holder(F&& func, Args&&... args) {
  * @return `holder` referencing expression constructed by given functor
  */
 template <typename F, typename... Args,
-          require_plain_type_t<std::invoke_result_t<F, Args&&...>>* = nullptr>
+          require_plain_type_t<std::invoke_result_t<F, Args&&...>>*>
 inline auto make_holder(F&& func, Args&&... args) {
   return std::forward<F>(func)(std::forward<Args>(args)...);
 }
diff --git a/stan/math/prim/prob/loglogistic_cdf.hpp b/stan/math/prim/prob/loglogistic_cdf.hpp
index 86b261cad19..b6dfa4cbbb8 100644
--- a/stan/math/prim/prob/loglogistic_cdf.hpp
+++ b/stan/math/prim/prob/loglogistic_cdf.hpp
@@ -43,7 +43,7 @@ namespace math {
 template <typename T_y, typename T_scale, typename T_shape,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               T_y, T_scale, T_shape>* = nullptr>
-return_type_t<T_y, T_scale, T_shape> loglogistic_cdf(const T_y& y,
+inline return_type_t<T_y, T_scale, T_shape> loglogistic_cdf(const T_y& y,
                                                      const T_scale& alpha,
                                                      const T_shape& beta) {
   using T_partials_return = partials_return_t<T_y, T_scale, T_shape>;
@@ -58,9 +58,9 @@ return_type_t<T_y, T_scale, T_shape> loglogistic_cdf(const T_y& y,
   T_alpha_ref alpha_ref = alpha;
   T_beta_ref beta_ref = beta;
 
-  decltype(auto) y_val = to_ref(as_value_column_array_or_scalar(y_ref));
-  decltype(auto) alpha_val = to_ref(as_value_column_array_or_scalar(alpha_ref));
-  decltype(auto) beta_val = to_ref(as_value_column_array_or_scalar(beta_ref));
+  decltype(auto) y_val = as_value_column_array_or_scalar(to_ref(y_ref));
+  decltype(auto) alpha_val = as_value_column_array_or_scalar(to_ref(alpha_ref));
+  decltype(auto) beta_val = as_value_column_array_or_scalar(to_ref(beta_ref));
 
   check_nonnegative(function, "Random variable", y_val);
   check_positive_finite(function, "Scale parameter", alpha_val);
@@ -76,42 +76,42 @@ return_type_t<T_y, T_scale, T_shape> loglogistic_cdf(const T_y& y,
     return ops_partials.build(0.0);
   }
 
-  const auto& alpha_div_y
+  auto&& alpha_div_y
       = to_ref_if<!is_constant_all<T_shape>::value>(alpha_val / y_val);
-  const auto& alpha_div_y_pow_beta
+  auto&& alpha_div_y_pow_beta
       = to_ref_if<!is_constant_all<T_y, T_scale, T_shape>::value>(
           pow(alpha_div_y, beta_val));
-  const auto& prod_all
+  auto&& prod_all
       = to_ref_if<!is_constant_all<T_y, T_scale, T_shape>::value>(
-          1 / (1 + alpha_div_y_pow_beta));
+          1.0 / (1.0 + alpha_div_y_pow_beta));
 
   T_partials_return cdf = prod(prod_all);
 
   if (!is_constant_all<T_y, T_scale, T_shape>::value) {
-    const auto& prod_all_sq = to_ref_if<!is_constant_all<T_y>::value
+    auto&& prod_all_sq = to_ref_if<!is_constant_all<T_y>::value
                                             + !is_constant_all<T_scale>::value
                                             + !is_constant_all<T_shape>::value
                                         >= 2>(square(prod_all));
-    const auto& cdf_div_elt = to_ref_if<!is_constant_all<T_y>::value
+    auto&& cdf_div_elt = to_ref_if<!is_constant_all<T_y>::value
                                             + !is_constant_all<T_scale>::value
                                             + !is_constant_all<T_shape>::value
                                         >= 2>(cdf / prod_all);
     if (!is_constant_all<T_y, T_scale>::value) {
-      const auto& alpha_div_times_beta = to_ref_if<
+      auto&& alpha_div_times_beta = to_ref_if<
           !is_constant_all<T_y>::value + !is_constant_all<T_scale>::value == 2>(
           alpha_div_y_pow_beta * beta_val);
       if (!is_constant_all<T_y>::value) {
-        const auto& y_deriv = alpha_div_times_beta / y_val * prod_all_sq;
+        auto y_deriv = alpha_div_times_beta / y_val * prod_all_sq;
         partials<0>(ops_partials) = y_deriv * cdf_div_elt;
       }
       if (!is_constant_all<T_scale>::value) {
-        const auto& alpha_deriv
+        auto alpha_deriv
             = -alpha_div_times_beta / alpha_val * prod_all_sq;
         partials<1>(ops_partials) = alpha_deriv * cdf_div_elt;
       }
     }
     if (!is_constant_all<T_shape>::value) {
-      const auto& beta_deriv
+      auto beta_deriv
           = -multiply_log(alpha_div_y_pow_beta, alpha_div_y) * prod_all_sq;
       partials<2>(ops_partials) = beta_deriv * cdf_div_elt;
     }
diff --git a/stan/math/rev/fun/log_softmax.hpp b/stan/math/rev/fun/log_softmax.hpp
index 3015bb12b3e..30207a6dcd8 100644
--- a/stan/math/rev/fun/log_softmax.hpp
+++ b/stan/math/rev/fun/log_softmax.hpp
@@ -121,7 +121,7 @@ inline auto log_softmax(const T& x) {
  */
 template <typename T, require_std_vector_st<is_var, T>* = nullptr>
 inline auto log_softmax(T&& x) {
-  return apply_vector_unary<std::decay_t<T>>::apply(
+  return apply_vector_unary<T>::apply(
       std::forward<T>(x), [](const auto& alpha) { return log_softmax(alpha); });
 }
 
diff --git a/stan/math/rev/fun/multiply_log.hpp b/stan/math/rev/fun/multiply_log.hpp
index 293cb1856cb..3ecac456f2d 100644
--- a/stan/math/rev/fun/multiply_log.hpp
+++ b/stan/math/rev/fun/multiply_log.hpp
@@ -102,7 +102,7 @@ template <typename T1, typename T2, require_all_matrix_t<T1, T2>* = nullptr,
           require_any_var_matrix_t<T1, T2>* = nullptr>
 inline auto multiply_log(const T1& a, const T2& b) {
   check_matching_dims("multiply_log", "a", a, "b", b);
-  if (!is_constant<T1>::value && !is_constant<T2>::value) {
+  if constexpr (!is_constant<T1>::value && !is_constant<T2>::value) {
     arena_t<promote_scalar_t<var, T1>> arena_a = a;
     arena_t<promote_scalar_t<var, T2>> arena_b = b;
 
@@ -114,7 +114,7 @@ inline auto multiply_log(const T1& a, const T2& b) {
           arena_b.adj().array() += res.adj().array() * arena_a.val().array()
                                    / arena_b.val().array();
         });
-  } else if (!is_constant<T1>::value) {
+  } else if constexpr (!is_constant<T1>::value) {
     arena_t<promote_scalar_t<var, T1>> arena_a = a;
     arena_t<promote_scalar_t<double, T2>> arena_b = value_of(b);
 
@@ -151,7 +151,7 @@ template <typename T1, typename T2, require_var_matrix_t<T1>* = nullptr,
 inline auto multiply_log(const T1& a, const T2& b) {
   using std::log;
 
-  if (!is_constant<T1>::value && !is_constant<T2>::value) {
+  if constexpr (!is_constant<T1>::value && !is_constant<T2>::value) {
     arena_t<promote_scalar_t<var, T1>> arena_a = a;
     var arena_b = b;
 
@@ -162,7 +162,7 @@ inline auto multiply_log(const T1& a, const T2& b) {
           arena_b.adj() += (res.adj().array() * arena_a.val().array()).sum()
                            / arena_b.val();
         });
-  } else if (!is_constant<T1>::value) {
+  } else if constexpr (!is_constant<T1>::value) {
     arena_t<promote_scalar_t<var, T1>> arena_a = a;
 
     return make_callback_var(multiply_log(arena_a.val(), value_of(b)),
@@ -195,7 +195,7 @@ inline auto multiply_log(const T1& a, const T2& b) {
 template <typename T1, typename T2, require_stan_scalar_t<T1>* = nullptr,
           require_var_matrix_t<T2>* = nullptr>
 inline auto multiply_log(const T1& a, const T2& b) {
-  if (!is_constant<T1>::value && !is_constant<T2>::value) {
+  if constexpr (!is_constant<T1>::value && !is_constant<T2>::value) {
     var arena_a = a;
     arena_t<promote_scalar_t<var, T2>> arena_b = b;
 
@@ -207,7 +207,7 @@ inline auto multiply_log(const T1& a, const T2& b) {
           arena_b.adj().array()
               += arena_a.val() * res.adj().array() / arena_b.val().array();
         });
-  } else if (!is_constant<T1>::value) {
+  } else if constexpr (!is_constant<T1>::value) {
     var arena_a = a;
     arena_t<promote_scalar_t<double, T2>> arena_b = value_of(b);
 
diff --git a/stan/math/rev/functor/apply_scalar_binary.hpp b/stan/math/rev/functor/apply_scalar_binary.hpp
index a1f20d7caaf..48e4479e3f3 100644
--- a/stan/math/rev/functor/apply_scalar_binary.hpp
+++ b/stan/math/rev/functor/apply_scalar_binary.hpp
@@ -28,9 +28,9 @@ namespace math {
 template <typename F, typename T1, typename T2,
           require_any_var_matrix_t<T1, T2>* = nullptr,
           require_all_matrix_t<T1, T2>* = nullptr>
-inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
+inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   check_matching_dims("Binary function", "x", x, "y", y);
-  return f(x, y);
+  return std::forward<F>(f)(std::forward<T1>(x), std::forward<T2>(y));
 }
 
 /**
@@ -48,9 +48,9 @@ inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
 template <typename F, typename T1, typename T2,
           require_any_var_matrix_t<T1, T2>* = nullptr,
           require_any_std_vector_vt<std::is_integral, T1, T2>* = nullptr>
-inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
+inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   check_matching_sizes("Binary function", "x", x, "y", y);
-  return f(x, y);
+  return std::forward<F>(f)(std::forward<T1>(x), std::forward<T2>(y));
 }
 
 /**
@@ -71,8 +71,8 @@ template <typename F, typename T1, typename T2,
           require_any_std_vector_vt<is_std_vector, T1, T2>* = nullptr,
           require_any_std_vector_st<std::is_integral, T1, T2>* = nullptr,
           require_any_var_matrix_t<T1, T2>* = nullptr>
-inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
-  return f(x, y);
+inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
+  return std::forward<F>(f)(std::forward<T1>(x), std::forward<T2>(y));
 }
 
 /**
@@ -93,8 +93,8 @@ inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
 template <typename F, typename T1, typename T2,
           require_any_stan_scalar_t<T1, T2>* = nullptr,
           require_any_var_matrix_t<T1, T2>* = nullptr>
-inline auto apply_scalar_binary(const F& f, const T1& x, const T2& y) {
-  return f(x, y);
+inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
+  return std::forward<F>(f)(std::forward<T1>(x), std::forward<T2>(y));
 }
 
 }  // namespace math
diff --git a/stan/math/rev/functor/apply_scalar_unary.hpp b/stan/math/rev/functor/apply_scalar_unary.hpp
index d00f8092d9a..dfe0620d033 100644
--- a/stan/math/rev/functor/apply_scalar_unary.hpp
+++ b/stan/math/rev/functor/apply_scalar_unary.hpp
@@ -29,7 +29,8 @@ struct apply_scalar_unary<
    * @param x Argument variable.
    * @return Function applied to the variable.
    */
-  static inline auto apply(const var& x) { return F::fun(x); }
+  template <typename T2>
+  static inline auto apply(T2&& x) { return F::fun(std::forward<T2>(x)); }
 };
 
 template <typename F, typename T>
diff --git a/stan/math/rev/functor/apply_vector_unary.hpp b/stan/math/rev/functor/apply_vector_unary.hpp
index 8c74c3dec5e..af5627dfdde 100644
--- a/stan/math/rev/functor/apply_vector_unary.hpp
+++ b/stan/math/rev/functor/apply_vector_unary.hpp
@@ -25,7 +25,7 @@ struct apply_vector_unary<T, require_var_matrix_t<T>> {
    * @return object with result of applying functor to input
    */
   template <typename T2, typename F>
-  static inline plain_type_t<T> apply(T2&& x, F&& f) {
+  static inline auto apply(T2&& x, F&& f) {
     return std::forward<F>(f)(std::forward<T2>(x));
   }
 
@@ -40,7 +40,7 @@ struct apply_vector_unary<T, require_var_matrix_t<T>> {
    * @return object with result of applying functor to input
    */
   template <typename T2, typename F>
-  static inline plain_type_t<T> apply_no_holder(T2&& x, F&& f) {
+  static inline auto apply_no_holder(T2&& x, F&& f) {
     return std::forward<F>(f)(std::forward<T2>(x));
   }
 
@@ -56,7 +56,7 @@ struct apply_vector_unary<T, require_var_matrix_t<T>> {
    * @return scalar result of applying functor to input.
    */
   template <typename T2, typename F>
-  static inline var reduce(T2& x, F&& f) {
+  static inline auto reduce(T2& x, F&& f) {
     return std::forward<F>(f)(std::forward<T2>(x));
   }
 };

From 50052d98c6a2f67823bd353f8f3d2c8dde80bc9f Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Tue, 1 Jul 2025 17:44:17 -0400
Subject: [PATCH 11/31] make all recursive vector functions pf so that value
 information is carried through them

---
 stan/math/fwd/fun/Phi.hpp                     |  7 ++---
 stan/math/fwd/fun/cbrt.hpp                    |  6 ++--
 stan/math/fwd/fun/digamma.hpp                 |  7 ++---
 stan/math/prim/constraint/ub_constrain.hpp    | 25 ++++++++-------
 stan/math/prim/fun/Phi.hpp                    |  7 +++--
 stan/math/prim/fun/Phi_approx.hpp             |  7 +++--
 stan/math/prim/fun/abs.hpp                    |  4 +--
 stan/math/prim/fun/acos.hpp                   |  4 +--
 stan/math/prim/fun/acosh.hpp                  |  4 +--
 stan/math/prim/fun/add.hpp                    | 19 ++++++++----
 stan/math/prim/fun/asin.hpp                   |  4 +--
 stan/math/prim/fun/asinh.hpp                  |  4 +--
 stan/math/prim/fun/atan.hpp                   |  4 +--
 stan/math/prim/fun/atanh.hpp                  |  4 +--
 stan/math/prim/fun/block.hpp                  |  6 ++--
 stan/math/prim/fun/cbrt.hpp                   | 13 +++++---
 stan/math/prim/fun/ceil.hpp                   | 14 ++++++---
 stan/math/prim/fun/cols.hpp                   |  4 +--
 stan/math/prim/fun/cos.hpp                    |  4 +--
 stan/math/prim/fun/cosh.hpp                   |  4 +--
 stan/math/prim/fun/determinant.hpp            |  6 ++--
 stan/math/prim/fun/diagonal.hpp               |  6 ++--
 stan/math/prim/fun/digamma.hpp                |  6 ++--
 stan/math/prim/fun/dot_self.hpp               |  6 ++--
 stan/math/prim/fun/erf.hpp                    | 13 +++++---
 stan/math/prim/fun/erfc.hpp                   | 13 +++++---
 stan/math/prim/fun/exp.hpp                    |  4 +--
 stan/math/prim/fun/exp2.hpp                   | 12 +++++--
 stan/math/prim/fun/expm1.hpp                  | 13 +++++---
 stan/math/prim/fun/fabs.hpp                   |  4 +--
 stan/math/prim/fun/floor.hpp                  |  4 +--
 stan/math/prim/fun/fma.hpp                    |  3 +-
 stan/math/prim/fun/fmin.hpp                   |  3 +-
 stan/math/prim/fun/hypot.hpp                  |  3 +-
 stan/math/prim/fun/inv.hpp                    | 11 +++++--
 stan/math/prim/fun/inv_Phi.hpp                |  7 +++--
 stan/math/prim/fun/inv_cloglog.hpp            |  4 +--
 stan/math/prim/fun/inv_erfc.hpp               |  7 +++--
 stan/math/prim/fun/inv_sqrt.hpp               |  4 +--
 stan/math/prim/fun/inv_square.hpp             | 12 +++++--
 stan/math/prim/fun/lambert_w.hpp              | 14 +++++----
 stan/math/prim/fun/ldexp.hpp                  |  3 +-
 stan/math/prim/fun/lgamma.hpp                 |  7 +++--
 stan/math/prim/fun/log.hpp                    |  4 +--
 stan/math/prim/fun/log10.hpp                  |  4 +--
 stan/math/prim/fun/log1m.hpp                  |  7 +++--
 stan/math/prim/fun/log1m_exp.hpp              |  7 +++--
 stan/math/prim/fun/log1m_inv_logit.hpp        |  3 +-
 stan/math/prim/fun/log1p.hpp                  |  7 +++--
 stan/math/prim/fun/log1p_exp.hpp              |  7 +++--
 stan/math/prim/fun/log2.hpp                   | 13 +++++---
 stan/math/prim/fun/log_inv_logit.hpp          |  7 +++--
 stan/math/prim/fun/log_sum_exp.hpp            | 31 ++++++++-----------
 stan/math/prim/fun/logit.hpp                  |  4 +--
 stan/math/prim/fun/mdivide_left.hpp           | 14 ++++-----
 stan/math/prim/fun/mdivide_left_ldlt.hpp      |  8 ++---
 stan/math/prim/fun/mdivide_left_spd.hpp       | 17 +++++-----
 stan/math/prim/fun/mdivide_left_tri.hpp       |  9 +++---
 stan/math/prim/fun/mdivide_left_tri_low.hpp   | 14 ++++-----
 stan/math/prim/fun/mdivide_right.hpp          | 12 +++----
 stan/math/prim/fun/mdivide_right_ldlt.hpp     | 10 +++---
 stan/math/prim/fun/mdivide_right_spd.hpp      |  8 ++---
 stan/math/prim/fun/mdivide_right_tri.hpp      |  6 ++--
 stan/math/prim/fun/mdivide_right_tri_low.hpp  |  6 ++--
 stan/math/prim/fun/round.hpp                  | 13 +++++---
 stan/math/prim/fun/row.hpp                    |  2 +-
 .../prim/fun/scale_matrix_exp_multiply.hpp    |  9 +++---
 stan/math/prim/fun/sin.hpp                    |  4 +--
 stan/math/prim/fun/sinh.hpp                   |  4 +--
 stan/math/prim/fun/sqrt.hpp                   |  4 +--
 stan/math/prim/fun/step.hpp                   |  4 +--
 stan/math/prim/fun/tan.hpp                    |  4 +--
 stan/math/prim/fun/tanh.hpp                   |  4 +--
 stan/math/prim/fun/tgamma.hpp                 |  7 +++--
 stan/math/prim/fun/to_int.hpp                 |  4 +--
 stan/math/prim/fun/trigamma.hpp               |  7 +++--
 stan/math/prim/fun/trunc.hpp                  | 13 +++++---
 stan/math/prim/prob/std_normal_log_qf.hpp     |  7 +++--
 stan/math/rev/fun/Phi.hpp                     |  3 +-
 stan/math/rev/fun/cbrt.hpp                    | 28 +++++++----------
 stan/math/rev/fun/digamma.hpp                 |  5 +--
 81 files changed, 353 insertions(+), 283 deletions(-)

diff --git a/stan/math/fwd/fun/Phi.hpp b/stan/math/fwd/fun/Phi.hpp
index 70c1c38249e..d73b6af8449 100644
--- a/stan/math/fwd/fun/Phi.hpp
+++ b/stan/math/fwd/fun/Phi.hpp
@@ -12,10 +12,9 @@
 namespace stan {
 namespace math {
 
-template <typename T>
-inline fvar<T> Phi(const fvar<T>& x) {
-  T xv = x.val_;
-  return fvar<T>(Phi(xv), x.d_ * exp(xv * xv / -2.0) * INV_SQRT_TWO_PI);
+template <typename T, require_fvar_t<T>* = nullptr>
+inline auto Phi(T&& x) {
+  return std::decay_t<T>(Phi(x.val_), x.d_ * exp(x.val_ * x.val_ / -2.0) * INV_SQRT_TWO_PI);
 }
 
 }  // namespace math
diff --git a/stan/math/fwd/fun/cbrt.hpp b/stan/math/fwd/fun/cbrt.hpp
index bfdec65d9c9..8b915006dcb 100644
--- a/stan/math/fwd/fun/cbrt.hpp
+++ b/stan/math/fwd/fun/cbrt.hpp
@@ -16,9 +16,9 @@ namespace math {
  * @param x Argument.
  * @return Cube root of argument.
  */
-template <typename T>
-inline fvar<T> cbrt(const fvar<T>& x) {
-  return fvar<T>(cbrt(x.val_), x.d_ / (3 * square(cbrt(x.val_))));
+template <typename T, require_fvar_t<T>* = nullptr>
+inline auto cbrt(T&& x) {
+  return std::decay_t<T>(cbrt(x.val_), x.d_ / (3 * square(cbrt(x.val_))));
 }
 
 }  // namespace math
diff --git a/stan/math/fwd/fun/digamma.hpp b/stan/math/fwd/fun/digamma.hpp
index ede447b685a..4f49be49378 100644
--- a/stan/math/fwd/fun/digamma.hpp
+++ b/stan/math/fwd/fun/digamma.hpp
@@ -4,7 +4,6 @@
 #include <stan/math/fwd/meta.hpp>
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/fun/trigamma.hpp>
-
 #include <stan/math/prim/fun/digamma.hpp>
 
 namespace stan {
@@ -19,9 +18,9 @@ namespace math {
  * @return derivative of the log gamma function at the specified
  * argument
  */
-template <typename T>
-inline fvar<T> digamma(const fvar<T>& x) {
-  return fvar<T>(digamma(x.val_), x.d_ * trigamma(x.val_));
+template <typename T, require_fvar_t<T>* = nullptr>
+inline auto digamma(T&& x) {
+  return std::decay_t<T>(digamma(x.val_), x.d_ * trigamma(x.val_));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/ub_constrain.hpp b/stan/math/prim/constraint/ub_constrain.hpp
index fe836471456..bef8aee2324 100644
--- a/stan/math/prim/constraint/ub_constrain.hpp
+++ b/stan/math/prim/constraint/ub_constrain.hpp
@@ -88,8 +88,9 @@ inline auto ub_constrain(const T& x, const U& ub, Lp& lp) {
 template <typename T, typename U, require_eigen_t<T>* = nullptr,
           require_stan_scalar_t<U>* = nullptr,
           require_all_not_st_var<T, U>* = nullptr>
-inline auto ub_constrain(const T& x, const U& ub) {
-  return eval(x.unaryExpr([ub](auto&& xx) { return ub_constrain(xx, ub); }));
+inline auto ub_constrain(T&& x, const U& ub) {
+  return eval(std::forward<T>(x).unaryExpr(
+      [ub](auto&& xx) { return ub_constrain(xx, ub); }));
 }
 
 /**
@@ -108,9 +109,9 @@ template <typename T, typename U, typename Lp, require_eigen_t<T>* = nullptr,
           require_stan_scalar_t<U>* = nullptr,
           require_all_not_st_var<T, U>* = nullptr,
           require_convertible_t<return_type_t<T, U>, Lp>* = nullptr>
-inline auto ub_constrain(const T& x, const U& ub, Lp& lp) {
-  return eval(
-      x.unaryExpr([ub, &lp](auto&& xx) { return ub_constrain(xx, ub, lp); }));
+inline auto ub_constrain(T&& x, const U& ub, Lp& lp) {
+  return eval(std::forward<T>(x).unaryExpr(
+      [ub, &lp](auto&& xx) { return ub_constrain(xx, ub, lp); }));
 }
 
 /**
@@ -125,9 +126,9 @@ inline auto ub_constrain(const T& x, const U& ub, Lp& lp) {
  */
 template <typename T, typename U, require_all_eigen_t<T, U>* = nullptr,
           require_all_not_st_var<T, U>* = nullptr>
-inline auto ub_constrain(const T& x, const U& ub) {
+inline auto ub_constrain(T&& x, const U& ub) {
   check_matching_dims("ub_constrain", "x", x, "ub", ub);
-  return eval(x.binaryExpr(
+  return eval(std::forward<T>(x).binaryExpr(
       ub, [](auto&& xx, auto&& ubb) { return ub_constrain(xx, ubb); }));
 }
 
@@ -147,9 +148,9 @@ template <typename T, typename U, typename Lp,
           require_all_eigen_t<T, U>* = nullptr,
           require_all_not_st_var<T, U>* = nullptr,
           require_convertible_t<return_type_t<T, U>, Lp>* = nullptr>
-inline auto ub_constrain(const T& x, const U& ub, Lp& lp) {
+inline auto ub_constrain(T&& x, const U& ub, Lp& lp) {
   check_matching_dims("ub_constrain", "x", x, "ub", ub);
-  return eval(x.binaryExpr(
+  return eval(std::forward<T>(x).binaryExpr(
       ub, [&lp](auto&& xx, auto&& ubb) { return ub_constrain(xx, ubb, lp); }));
 }
 
@@ -261,11 +262,11 @@ inline auto ub_constrain(const std::vector<T>& x, const std::vector<U>& ub,
  */
 template <bool Jacobian, typename T, typename U, typename Lp,
           require_convertible_t<return_type_t<T, U>, Lp>* = nullptr>
-inline auto ub_constrain(const T& x, const U& ub, Lp& lp) {
+inline auto ub_constrain(T&& x, U&& ub, Lp& lp) {
   if constexpr (Jacobian) {
-    return ub_constrain(x, ub, lp);
+    return ub_constrain(std::forward<T>(x), std::forward<U>(ub), lp);
   } else {
-    return ub_constrain(x, ub);
+    return ub_constrain(std::forward<T>(x), std::forward<U>(ub));
   }
 }
 
diff --git a/stan/math/prim/fun/Phi.hpp b/stan/math/prim/fun/Phi.hpp
index 5c43bf30df1..9bde705db7e 100644
--- a/stan/math/prim/fun/Phi.hpp
+++ b/stan/math/prim/fun/Phi.hpp
@@ -51,8 +51,8 @@ inline double Phi(double x) {
  */
 struct Phi_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return Phi(x);
+  static inline auto fun(T&& x) {
+  return Phi(std::forward<T>(x));
   }
 };
 
@@ -66,7 +66,8 @@ struct Phi_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr,
+    require_container_t<T>* = nullptr>
 inline auto Phi(T&& x) {
   return apply_scalar_unary<Phi_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/Phi_approx.hpp b/stan/math/prim/fun/Phi_approx.hpp
index 0fd1ce6a5ae..40fcad97711 100644
--- a/stan/math/prim/fun/Phi_approx.hpp
+++ b/stan/math/prim/fun/Phi_approx.hpp
@@ -47,8 +47,8 @@ struct Phi_approx_fun {
    * @return approximate value of Phi applied to argument
    */
   template <typename T>
-  static inline auto fun(const T& x) {
-    return Phi_approx(x);
+  static inline auto fun(T&& x) {
+  return Phi_approx(std::forward<T>(x));
   }
 };
 
@@ -65,7 +65,8 @@ struct Phi_approx_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr,
+    require_container_t<T>* = nullptr>
 inline auto Phi_approx(T&& x) {
   return apply_scalar_unary<Phi_approx_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/abs.hpp b/stan/math/prim/fun/abs.hpp
index e0cb2acd74f..25f491b9987 100644
--- a/stan/math/prim/fun/abs.hpp
+++ b/stan/math/prim/fun/abs.hpp
@@ -49,8 +49,8 @@ inline auto abs(T x) {
  */
 struct abs_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return abs(x);
+  static inline auto fun(T&& x) {
+  return abs(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/acos.hpp b/stan/math/prim/fun/acos.hpp
index 868f1a424b4..e58b99e6c8e 100644
--- a/stan/math/prim/fun/acos.hpp
+++ b/stan/math/prim/fun/acos.hpp
@@ -51,8 +51,8 @@ inline auto acos(const T x) {
  */
 struct acos_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return acos(x);
+  static inline auto fun(T&& x) {
+  return acos(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/acosh.hpp b/stan/math/prim/fun/acosh.hpp
index a85097c236b..3bef060a729 100644
--- a/stan/math/prim/fun/acosh.hpp
+++ b/stan/math/prim/fun/acosh.hpp
@@ -62,8 +62,8 @@ struct acosh_fun {
    * @return Inverse hyperbolic cosine of the argument.
    */
   template <typename T>
-  static inline auto fun(const T& x) {
-    return acosh(x);
+  static inline auto fun(T&& x) {
+  return acosh(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/add.hpp b/stan/math/prim/fun/add.hpp
index 763c51da1e9..e2dac0258de 100644
--- a/stan/math/prim/fun/add.hpp
+++ b/stan/math/prim/fun/add.hpp
@@ -40,9 +40,12 @@ inline return_type_t<ScalarA, ScalarB> add(const ScalarA& a, const ScalarB& b) {
 template <typename Mat1, typename Mat2,
           require_all_eigen_t<Mat1, Mat2>* = nullptr,
           require_all_not_st_var<Mat1, Mat2>* = nullptr>
-inline auto add(const Mat1& m1, const Mat2& m2) {
+inline auto add(Mat1&& m1, Mat2&& m2) {
   check_matching_dims("add", "m1", m1, "m2", m2);
-  return m1 + m2;
+  return make_holder([](auto&& m1_, auto&& m2_) {
+    return std::forward<decltype(m1_)>(m1_)
+           + std::forward<decltype(m2_)>(m2_);
+  }, std::forward<Mat1>(m1), std::forward<Mat2>(m2));
 }
 
 /**
@@ -57,8 +60,10 @@ inline auto add(const Mat1& m1, const Mat2& m2) {
 template <typename Mat, typename Scal, require_eigen_t<Mat>* = nullptr,
           require_stan_scalar_t<Scal>* = nullptr,
           require_all_not_st_var<Mat, Scal>* = nullptr>
-inline auto add(const Mat& m, const Scal c) {
-  return (m.array() + c).matrix();
+inline auto add(Mat&& m, const Scal c) {
+  return make_holder([c](auto&& m_) {
+    return (std::forward<decltype(m_)>(m_).array() + c).matrix();
+  }, std::forward<Mat>(m));
 }
 
 /**
@@ -73,8 +78,10 @@ inline auto add(const Mat& m, const Scal c) {
 template <typename Scal, typename Mat, require_stan_scalar_t<Scal>* = nullptr,
           require_eigen_t<Mat>* = nullptr,
           require_all_not_st_var<Scal, Mat>* = nullptr>
-inline auto add(const Scal c, const Mat& m) {
-  return (c + m.array()).matrix();
+inline auto add(const Scal c, Mat&& m) {
+  return make_holder([c](auto&& m_) {
+    return (c + std::forward<decltype(m_)>(m_).array()).matrix();
+  }, std::forward<Mat>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/asin.hpp b/stan/math/prim/fun/asin.hpp
index 60821a5abd3..43ed5b1c3c0 100644
--- a/stan/math/prim/fun/asin.hpp
+++ b/stan/math/prim/fun/asin.hpp
@@ -49,8 +49,8 @@ inline auto asin(const T x) {
  */
 struct asin_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return asin(x);
+  static inline auto fun(T&& x) {
+  return asin(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/asinh.hpp b/stan/math/prim/fun/asinh.hpp
index fda581b1c86..7991ed169bc 100644
--- a/stan/math/prim/fun/asinh.hpp
+++ b/stan/math/prim/fun/asinh.hpp
@@ -52,8 +52,8 @@ inline auto asinh(const T x) {
  */
 struct asinh_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return asinh(x);
+  static inline auto fun(T&& x) {
+  return asinh(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/atan.hpp b/stan/math/prim/fun/atan.hpp
index 7cb08d4e89e..9b422a07f58 100644
--- a/stan/math/prim/fun/atan.hpp
+++ b/stan/math/prim/fun/atan.hpp
@@ -47,8 +47,8 @@ inline auto atan(const T x) {
  */
 struct atan_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return atan(x);
+  static inline auto fun(T&& x) {
+  return atan(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/atanh.hpp b/stan/math/prim/fun/atanh.hpp
index c879135575c..5bde533c2ee 100644
--- a/stan/math/prim/fun/atanh.hpp
+++ b/stan/math/prim/fun/atanh.hpp
@@ -61,8 +61,8 @@ struct atanh_fun {
    * @return Inverse hyperbolic tangent of the argument.
    */
   template <typename T>
-  static inline auto fun(const T& x) {
-    return atanh(x);
+  static inline auto fun(T&& x) {
+  return atanh(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/block.hpp b/stan/math/prim/fun/block.hpp
index 7f5b2aaa850..b39c3e85418 100644
--- a/stan/math/prim/fun/block.hpp
+++ b/stan/math/prim/fun/block.hpp
@@ -19,12 +19,14 @@ namespace math {
  * @throw std::out_of_range if either index is out of range.
  */
 template <typename T, require_matrix_t<T>* = nullptr>
-inline auto block(const T& m, size_t i, size_t j, size_t nrows, size_t ncols) {
+inline auto block(T&& m, size_t i, size_t j, size_t nrows, size_t ncols) {
   check_row_index("block", "i", m, i);
   check_row_index("block", "i+nrows-1", m, i + nrows - 1);
   check_column_index("block", "j", m, j);
   check_column_index("block", "j+ncols-1", m, j + ncols - 1);
-  return m.block(i - 1, j - 1, nrows, ncols);
+  return make_holder([i, j, nrows, ncols](auto&& m_) {
+    return std::forward<decltype(m_)>(m_).block(i - 1, j - 1, nrows, ncols);
+  }, std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/cbrt.hpp b/stan/math/prim/fun/cbrt.hpp
index 5cbe85b6276..22f71fd934d 100644
--- a/stan/math/prim/fun/cbrt.hpp
+++ b/stan/math/prim/fun/cbrt.hpp
@@ -8,6 +8,11 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto cbrt(T x) {
+  return std::cbrt(std::forward<T>(x));
+}
+
 /**
  * Structure to wrap `cbrt()` so it can be vectorized.
  *
@@ -17,9 +22,8 @@ namespace math {
  */
 struct cbrt_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    using std::cbrt;
-    return cbrt(x);
+  static inline auto fun(T&& x) {
+    return cbrt(std::forward<T>(x));
   }
 };
 
@@ -33,7 +37,8 @@ struct cbrt_fun {
  */
 template <
     typename T, require_not_var_matrix_t<T>* = nullptr,
-    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
+    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
+    require_container_t<T>* = nullptr>
 inline auto cbrt(T&& x) {
   return apply_scalar_unary<cbrt_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/ceil.hpp b/stan/math/prim/fun/ceil.hpp
index b9bf9e2691a..ff0dd584f6b 100644
--- a/stan/math/prim/fun/ceil.hpp
+++ b/stan/math/prim/fun/ceil.hpp
@@ -10,6 +10,12 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto ceil(T x) {
+  return std::ceil(x);
+}
+
+
 /**
  * Structure to wrap `ceil()` so it can be vectorized.
  *
@@ -19,9 +25,8 @@ namespace math {
  */
 struct ceil_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    using std::ceil;
-    return ceil(x);
+  static inline auto fun(T&& x) {
+    return ceil(std::forward<T>(x));
   }
 };
 
@@ -36,7 +41,8 @@ struct ceil_fun {
 template <typename Container,
           require_not_container_st<std::is_arithmetic, Container>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              Container>* = nullptr>
+              Container>* = nullptr,
+              require_container_t<Container>* = nullptr>
 inline auto ceil(Container&& x) {
   return apply_scalar_unary<ceil_fun, Container>::apply(
       std::forward<Container>(x));
diff --git a/stan/math/prim/fun/cols.hpp b/stan/math/prim/fun/cols.hpp
index 07a24d5867a..c1069a723b9 100644
--- a/stan/math/prim/fun/cols.hpp
+++ b/stan/math/prim/fun/cols.hpp
@@ -17,8 +17,8 @@ namespace math {
  * @return Number of columns.
  */
 template <typename T, require_matrix_t<T>* = nullptr>
-inline int64_t cols(const T& m) {
-  return m.cols();
+inline Eigen::Index cols(T&& m) {
+  return make_holder([](auto&& arg) { return arg.cols(); }, std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/cos.hpp b/stan/math/prim/fun/cos.hpp
index 00c866db87f..f35f14a44c3 100644
--- a/stan/math/prim/fun/cos.hpp
+++ b/stan/math/prim/fun/cos.hpp
@@ -46,8 +46,8 @@ inline auto cos(const T x) {
  */
 struct cos_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return cos(x);
+  static inline auto fun(T&& x) {
+  return cos(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/cosh.hpp b/stan/math/prim/fun/cosh.hpp
index 6782e9856b5..5610acff36b 100644
--- a/stan/math/prim/fun/cosh.hpp
+++ b/stan/math/prim/fun/cosh.hpp
@@ -45,8 +45,8 @@ inline auto cosh(const T x) {
  */
 struct cosh_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return cosh(x);
+  static inline auto fun(T&& x) {
+  return cosh(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/determinant.hpp b/stan/math/prim/fun/determinant.hpp
index fb26b80e2a5..5661892031b 100644
--- a/stan/math/prim/fun/determinant.hpp
+++ b/stan/math/prim/fun/determinant.hpp
@@ -18,9 +18,11 @@ namespace math {
  * @throw std::domain_error if matrix is not square.
  */
 template <typename T, require_eigen_vt<std::is_arithmetic, T>* = nullptr>
-inline value_type_t<T> determinant(const T& m) {
+inline value_type_t<T> determinant(T&& m) {
   check_square("determinant", "m", m);
-  return m.determinant();
+  return make_holder([](auto&& m_){
+    return m_.determinant();
+  }, std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/diagonal.hpp b/stan/math/prim/fun/diagonal.hpp
index 49be724814b..4965893e1ad 100644
--- a/stan/math/prim/fun/diagonal.hpp
+++ b/stan/math/prim/fun/diagonal.hpp
@@ -16,8 +16,10 @@ namespace math {
  * @return Diagonal of the matrix.
  */
 template <typename T, require_matrix_t<T>* = nullptr>
-inline auto diagonal(const T& m) {
-  return m.diagonal();
+inline auto diagonal(T&& m) {
+  return make_holder([](auto&& m_) {
+    return std::forward<decltype(m_)>(m_).diagonal();
+  }, std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/digamma.hpp b/stan/math/prim/fun/digamma.hpp
index dc9d3e57645..fd69bcda98f 100644
--- a/stan/math/prim/fun/digamma.hpp
+++ b/stan/math/prim/fun/digamma.hpp
@@ -58,8 +58,8 @@ inline double digamma(double x) {
  */
 struct digamma_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return digamma(x);
+  static inline auto fun(T&& x) {
+    return digamma(std::forward<T>(x));
   }
 };
 
@@ -73,7 +73,7 @@ struct digamma_fun {
  */
 template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-          require_not_var_matrix_t<T>* = nullptr>
+          require_container_t<T>* = nullptr>
 inline auto digamma(T&& x) {
   return apply_scalar_unary<digamma_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/dot_self.hpp b/stan/math/prim/fun/dot_self.hpp
index c9d67f56e86..d84790ef809 100644
--- a/stan/math/prim/fun/dot_self.hpp
+++ b/stan/math/prim/fun/dot_self.hpp
@@ -32,8 +32,10 @@ inline double dot_self(const std::vector<double>& x) {
  */
 template <typename T, require_eigen_t<T>* = nullptr,
           require_not_eigen_vt<is_var, T>* = nullptr>
-inline value_type_t<T> dot_self(const T& v) {
-  return v.squaredNorm();
+inline value_type_t<T> dot_self(T&& v) {
+  return make_holder([](auto&& v_) {
+    return v_.squaredNorm();
+  }, std::forward<T>(v));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/erf.hpp b/stan/math/prim/fun/erf.hpp
index 51cab1c72f0..00a37e6d8d4 100644
--- a/stan/math/prim/fun/erf.hpp
+++ b/stan/math/prim/fun/erf.hpp
@@ -8,6 +8,11 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto erf(T x) {
+  return std::erf(std::forward<T>(x));
+}
+
 /**
  * Structure to wrap `erf()` so it can be vectorized.
  *
@@ -17,9 +22,8 @@ namespace math {
  */
 struct erf_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    using std::erf;
-    return erf(x);
+  static inline auto fun(T&& x) {
+    return erf(std::forward<T>(x));
   }
 };
 
@@ -34,7 +38,8 @@ struct erf_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr,
+    require_container_t<T>* = nullptr>
 inline auto erf(T&& x) {
   return apply_scalar_unary<erf_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/erfc.hpp b/stan/math/prim/fun/erfc.hpp
index 53955a11161..d46a61e9f97 100644
--- a/stan/math/prim/fun/erfc.hpp
+++ b/stan/math/prim/fun/erfc.hpp
@@ -8,6 +8,11 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto erfc(T x) {
+  return std::erfc(x);
+}
+
 /**
  * Structure to wrap the `erfc()`
  * so that it can be vectorized.
@@ -18,9 +23,8 @@ namespace math {
  */
 struct erfc_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    using std::erfc;
-    return erfc(x);
+  static inline auto fun(T&& x) {
+    return erfc(std::forward<T>(x));
   }
 };
 
@@ -35,7 +39,8 @@ struct erfc_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr,
+    require_container_t<T>* = nullptr>
 inline auto erfc(T&& x) {
   return apply_scalar_unary<erfc_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/exp.hpp b/stan/math/prim/fun/exp.hpp
index 8298467d498..824d673c204 100644
--- a/stan/math/prim/fun/exp.hpp
+++ b/stan/math/prim/fun/exp.hpp
@@ -53,8 +53,8 @@ struct exp_fun {
    * @return Exponential of argument.
    */
   template <typename T>
-  static inline auto fun(const T& x) {
-    return exp(x);
+  static inline auto fun(T&& x) {
+  return exp(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/exp2.hpp b/stan/math/prim/fun/exp2.hpp
index 4f6dff50e9e..378cf378b8f 100644
--- a/stan/math/prim/fun/exp2.hpp
+++ b/stan/math/prim/fun/exp2.hpp
@@ -8,6 +8,12 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto exp2(T x) {
+  return std::exp2(x);
+}
+
+
 /**
  * Structure to wrap `exp2()` so it can be vectorized.
  */
@@ -20,8 +26,7 @@ struct exp2_fun {
    * @return Base two exponent of the argument.
    */
   template <typename T>
-  static inline auto fun(const T& x) {
-    using std::exp2;
+  static inline auto fun(T&& x) {
     return exp2(x);
   }
 };
@@ -38,7 +43,8 @@ struct exp2_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr,
+    require_container_t<T>* = nullptr>
 inline auto exp2(T&& x) {
   return apply_scalar_unary<exp2_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/expm1.hpp b/stan/math/prim/fun/expm1.hpp
index ce0fefa8b91..89c12fc8b8f 100644
--- a/stan/math/prim/fun/expm1.hpp
+++ b/stan/math/prim/fun/expm1.hpp
@@ -8,6 +8,11 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto expm1(T x) {
+  return std::expm1(x);
+}
+
 /**
  * Structure to wrap `expm1()` so that it can be vectorized.
  *
@@ -17,9 +22,8 @@ namespace math {
  */
 struct expm1_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    using std::expm1;
-    return expm1(x);
+  static inline auto fun(T&& x) {
+    return expm1(std::forward<T>(x));
   }
 };
 
@@ -35,7 +39,8 @@ struct expm1_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr,
+    require_container_t<T>* = nullptr>
 inline auto expm1(T&& x) {
   return apply_scalar_unary<expm1_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/fabs.hpp b/stan/math/prim/fun/fabs.hpp
index 95533450b8b..dc6e33eff7b 100644
--- a/stan/math/prim/fun/fabs.hpp
+++ b/stan/math/prim/fun/fabs.hpp
@@ -29,8 +29,8 @@ inline auto fabs(T x) {
  */
 struct fabs_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return fabs(x);
+  static inline auto fun(T&& x) {
+  return fabs(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/floor.hpp b/stan/math/prim/fun/floor.hpp
index d6f38484776..888c9d7c0ca 100644
--- a/stan/math/prim/fun/floor.hpp
+++ b/stan/math/prim/fun/floor.hpp
@@ -28,8 +28,8 @@ inline auto floor(const T x) {
  */
 struct floor_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return floor(x);
+  static inline auto fun(T&& x) {
+  return floor(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/fma.hpp b/stan/math/prim/fun/fma.hpp
index 428dff3d810..2cc8cd7dbc2 100644
--- a/stan/math/prim/fun/fma.hpp
+++ b/stan/math/prim/fun/fma.hpp
@@ -24,8 +24,7 @@ namespace math {
 template <typename T1, typename T2, typename T3,
           require_all_arithmetic_t<T1, T2, T3>* = nullptr>
 inline double fma(T1 x, T2 y, T3 z) {
-  using std::fma;
-  return fma(x, y, z);
+  return std::fma(x, y, z);
 }
 
 template <typename T1, typename T2, typename T3,
diff --git a/stan/math/prim/fun/fmin.hpp b/stan/math/prim/fun/fmin.hpp
index 5b2ffe63643..ef6ac3f6de4 100644
--- a/stan/math/prim/fun/fmin.hpp
+++ b/stan/math/prim/fun/fmin.hpp
@@ -18,8 +18,7 @@ namespace math {
  */
 template <typename T1, typename T2, require_all_arithmetic_t<T1, T2>* = nullptr>
 inline double fmin(T1 x, T2 y) {
-  using std::fmin;
-  return fmin(x, y);
+  return std::fmin(x, y);
 }
 
 /**
diff --git a/stan/math/prim/fun/hypot.hpp b/stan/math/prim/fun/hypot.hpp
index c074b730f17..7e598ea2da2 100644
--- a/stan/math/prim/fun/hypot.hpp
+++ b/stan/math/prim/fun/hypot.hpp
@@ -22,8 +22,7 @@ namespace math {
  */
 template <typename T1, typename T2, require_all_arithmetic_t<T1, T2>* = nullptr>
 inline double hypot(T1 x, T2 y) {
-  using std::hypot;
-  return hypot(x, y);
+  return std::hypot(x, y);
 }
 
 /**
diff --git a/stan/math/prim/fun/inv.hpp b/stan/math/prim/fun/inv.hpp
index bcdec1defbe..d57a5bb7668 100644
--- a/stan/math/prim/fun/inv.hpp
+++ b/stan/math/prim/fun/inv.hpp
@@ -9,6 +9,10 @@
 namespace stan {
 namespace math {
 
+inline double inv(double x) {
+  return 1.0 / x;
+}
+
 /**
  * Structure to wrap 1.0 / x so that it can be vectorized.
  *
@@ -18,8 +22,8 @@ namespace math {
  */
 struct inv_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return 1.0 / x;
+  static inline auto fun(T&& x) {
+    return inv(std::forward<T>(x));
   }
 };
 
@@ -33,7 +37,8 @@ struct inv_fun {
  */
 template <
     typename T, require_not_container_st<std::is_arithmetic, T>* = nullptr,
-    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
+    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
+    require_container_t<T>* = nullptr>
 inline auto inv(T&& x) {
   return apply_scalar_unary<inv_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/inv_Phi.hpp b/stan/math/prim/fun/inv_Phi.hpp
index b4f295bd315..fa14d612633 100644
--- a/stan/math/prim/fun/inv_Phi.hpp
+++ b/stan/math/prim/fun/inv_Phi.hpp
@@ -160,8 +160,8 @@ inline double inv_Phi(double p) {
  */
 struct inv_Phi_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return inv_Phi(x);
+  static inline auto fun(T&& x) {
+  return inv_Phi(std::forward<T>(x));
   }
 };
 
@@ -176,7 +176,8 @@ struct inv_Phi_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr,
+    require_container_t<T>* = nullptr>
 inline auto inv_Phi(T&& x) {
   return apply_scalar_unary<inv_Phi_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/inv_cloglog.hpp b/stan/math/prim/fun/inv_cloglog.hpp
index 499dcc7d926..4b0cc7ce374 100644
--- a/stan/math/prim/fun/inv_cloglog.hpp
+++ b/stan/math/prim/fun/inv_cloglog.hpp
@@ -77,8 +77,8 @@ inline auto inv_cloglog(const T& x) {
  */
 struct inv_cloglog_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return inv_cloglog(x);
+  static inline auto fun(T&& x) {
+  return inv_cloglog(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/inv_erfc.hpp b/stan/math/prim/fun/inv_erfc.hpp
index 1b105c1ba87..e7f70cd744a 100644
--- a/stan/math/prim/fun/inv_erfc.hpp
+++ b/stan/math/prim/fun/inv_erfc.hpp
@@ -30,8 +30,8 @@ inline auto inv_erfc(const T& x) {
  */
 struct inv_erfc_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return inv_erfc(x);
+  static inline auto fun(T&& x) {
+  return inv_erfc(std::forward<T>(x));
   }
 };
 
@@ -47,7 +47,8 @@ template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr,
-    require_not_arithmetic_t<T>* = nullptr>
+    require_not_arithmetic_t<T>* = nullptr,
+    require_container_t<T>* = nullptr>
 inline auto inv_erfc(T&& x) {
   return apply_scalar_unary<inv_erfc_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/inv_sqrt.hpp b/stan/math/prim/fun/inv_sqrt.hpp
index 527751a709a..c3a4f4d9bec 100644
--- a/stan/math/prim/fun/inv_sqrt.hpp
+++ b/stan/math/prim/fun/inv_sqrt.hpp
@@ -31,8 +31,8 @@ inline auto inv_sqrt(const T x) {
  */
 struct inv_sqrt_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return inv_sqrt(x);
+  static inline auto fun(T&& x) {
+  return inv_sqrt(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/inv_square.hpp b/stan/math/prim/fun/inv_square.hpp
index 73cba9e0e65..84faf162519 100644
--- a/stan/math/prim/fun/inv_square.hpp
+++ b/stan/math/prim/fun/inv_square.hpp
@@ -9,6 +9,11 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto inv_square(T x) {
+  return 1.0 / std::pow(x, 2);
+}
+
 /**
  * Returns `1 / square(x)`.
  *
@@ -19,9 +24,10 @@ namespace math {
 template <typename Container,
           require_not_container_st<std::is_arithmetic, Container>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              Container>* = nullptr>
-inline auto inv_square(const Container& x) {
-  return inv(square(x));
+              Container>* = nullptr,
+              require_not_stan_scalar_t<Container>* = nullptr>
+inline auto inv_square(Container&& x) {
+  return inv(square(std::forward<Container>(x)));
 }
 
 /**
diff --git a/stan/math/prim/fun/lambert_w.hpp b/stan/math/prim/fun/lambert_w.hpp
index 11be58201c9..d83d1a5ec50 100644
--- a/stan/math/prim/fun/lambert_w.hpp
+++ b/stan/math/prim/fun/lambert_w.hpp
@@ -48,8 +48,8 @@ namespace internal {
  */
 struct lambert_w0_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return lambert_w0(x);
+  static inline auto fun(T&& x) {
+  return lambert_w0(std::forward<T>(x));
   }
 };
 
@@ -64,8 +64,8 @@ struct lambert_w0_fun {
  */
 struct lambert_wm1_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return lambert_wm1(x);
+  static inline auto fun(T&& x) {
+  return lambert_wm1(std::forward<T>(x));
   }
 };
 }  // namespace internal
@@ -79,7 +79,8 @@ struct lambert_wm1_fun {
  * @throw std::domain_error if x is less than or equal to `-e^(-1)`
  */
 template <typename T, require_not_stan_scalar_t<T>* = nullptr,
-          require_not_var_matrix_t<T>* = nullptr>
+          require_not_var_matrix_t<T>* = nullptr,
+          require_container_t<T>* = nullptr>
 inline auto lambert_w0(T&& x) {
   return apply_scalar_unary<internal::lambert_w0_fun, T>::apply(
       std::forward<T>(x));
@@ -95,7 +96,8 @@ inline auto lambert_w0(T&& x) {
  * than or equal to 0
  */
 template <typename T, require_not_stan_scalar_t<T>* = nullptr,
-          require_not_var_matrix_t<T>* = nullptr>
+          require_not_var_matrix_t<T>* = nullptr,
+          require_container_t<T>* = nullptr>
 inline auto lambert_wm1(T&& x) {
   return apply_scalar_unary<internal::lambert_wm1_fun, T>::apply(
       std::forward<T>(x));
diff --git a/stan/math/prim/fun/ldexp.hpp b/stan/math/prim/fun/ldexp.hpp
index 4430559ec5b..f634bbd8304 100644
--- a/stan/math/prim/fun/ldexp.hpp
+++ b/stan/math/prim/fun/ldexp.hpp
@@ -19,8 +19,7 @@ namespace math {
  */
 template <typename T1, require_arithmetic_t<T1>* = nullptr>
 inline double ldexp(T1 a, int b) {
-  using std::ldexp;
-  return ldexp(a, b);
+  return std::ldexp(a, b);
 }
 
 /**
diff --git a/stan/math/prim/fun/lgamma.hpp b/stan/math/prim/fun/lgamma.hpp
index 4540a341e2c..a29e2b7f79e 100644
--- a/stan/math/prim/fun/lgamma.hpp
+++ b/stan/math/prim/fun/lgamma.hpp
@@ -100,8 +100,8 @@ inline double lgamma(int x) {
  */
 struct lgamma_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return lgamma(x);
+  static inline auto fun(T&& x) {
+  return lgamma(std::forward<T>(x));
   }
 };
 
@@ -115,7 +115,8 @@ struct lgamma_fun {
  * @throw std::domain_error if any value is a negative integer or 0.
  */
 template <typename T, require_not_var_matrix_t<T>* = nullptr,
-          require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
+          require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
+          require_container_t<T>* = nullptr>
 inline auto lgamma(T&& x) {
   return apply_scalar_unary<lgamma_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/log.hpp b/stan/math/prim/fun/log.hpp
index 25a78453216..2c3a0d331a1 100644
--- a/stan/math/prim/fun/log.hpp
+++ b/stan/math/prim/fun/log.hpp
@@ -52,8 +52,8 @@ struct log_fun {
    * @return Natural log of x.
    */
   template <typename T>
-  static inline auto fun(const T& x) {
-    return log(x);
+  static inline auto fun(T&& x) {
+  return log(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/log10.hpp b/stan/math/prim/fun/log10.hpp
index 7ef368fa77e..e8a5c81bed5 100644
--- a/stan/math/prim/fun/log10.hpp
+++ b/stan/math/prim/fun/log10.hpp
@@ -45,8 +45,8 @@ inline auto log10(const T x) {
  */
 struct log10_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return log10(x);
+  static inline auto fun(T&& x) {
+  return log10(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/log1m.hpp b/stan/math/prim/fun/log1m.hpp
index 3943c16dbb5..ea6ffa75e30 100644
--- a/stan/math/prim/fun/log1m.hpp
+++ b/stan/math/prim/fun/log1m.hpp
@@ -55,8 +55,8 @@ inline double log1m(double x) {
  */
 struct log1m_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return log1m(x);
+  static inline auto fun(T&& x) {
+  return log1m(std::forward<T>(x));
   }
 };
 
@@ -69,7 +69,8 @@ struct log1m_fun {
  */
 template <
     typename T, require_not_var_matrix_t<T>* = nullptr,
-    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
+    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
+          require_container_t<T>* = nullptr>
 inline auto log1m(T&& x) {
   return apply_scalar_unary<log1m_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/log1m_exp.hpp b/stan/math/prim/fun/log1m_exp.hpp
index 737a0bc4080..d118ebf5d2f 100644
--- a/stan/math/prim/fun/log1m_exp.hpp
+++ b/stan/math/prim/fun/log1m_exp.hpp
@@ -65,8 +65,8 @@ inline double log1m_exp(double a) {
  */
 struct log1m_exp_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return log1m_exp(x);
+  static inline auto fun(T&& x) {
+  return log1m_exp(std::forward<T>(x));
   }
 };
 
@@ -79,7 +79,8 @@ struct log1m_exp_fun {
  */
 template <
     typename T, require_not_var_matrix_t<T>* = nullptr,
-    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
+    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
+          require_container_t<T>* = nullptr>
 inline auto log1m_exp(T&& x) {
   return apply_scalar_unary<log1m_exp_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/log1m_inv_logit.hpp b/stan/math/prim/fun/log1m_inv_logit.hpp
index fed956ea3bd..f2d11ff0c0b 100644
--- a/stan/math/prim/fun/log1m_inv_logit.hpp
+++ b/stan/math/prim/fun/log1m_inv_logit.hpp
@@ -81,7 +81,8 @@ struct log1m_inv_logit_fun {
  * @return Elementwise log1m_inv_logit of members of container.
  */
 template <typename T, require_not_var_matrix_t<T>* = nullptr,
-          require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
+          require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
+          require_container_t<T>* = nullptr>
 inline auto log1m_inv_logit(T&& x) {
   return apply_scalar_unary<log1m_inv_logit_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/log1p.hpp b/stan/math/prim/fun/log1p.hpp
index 66752bfeca6..1d95b9d41b6 100644
--- a/stan/math/prim/fun/log1p.hpp
+++ b/stan/math/prim/fun/log1p.hpp
@@ -61,8 +61,8 @@ struct log1p_fun {
    * @return natural log of one plus the argument
    */
   template <typename T>
-  static inline auto fun(const T& x) {
-    return log1p(x);
+  static inline auto fun(T&& x) {
+  return log1p(std::forward<T>(x));
   }
 };
 
@@ -78,7 +78,8 @@ struct log1p_fun {
  */
 template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-          require_not_var_matrix_t<T>* = nullptr>
+          require_not_var_matrix_t<T>* = nullptr,
+          require_container_t<T>* = nullptr>
 inline auto log1p(T&& x) {
   return apply_scalar_unary<log1p_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/log1p_exp.hpp b/stan/math/prim/fun/log1p_exp.hpp
index d69a1d1c059..e7f49011dcd 100644
--- a/stan/math/prim/fun/log1p_exp.hpp
+++ b/stan/math/prim/fun/log1p_exp.hpp
@@ -60,8 +60,8 @@ inline double log1p_exp(double a) {
  */
 struct log1p_exp_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return log1p_exp(x);
+  static inline auto fun(T&& x) {
+  return log1p_exp(std::forward<T>(x));
   }
 };
 
@@ -74,7 +74,8 @@ struct log1p_exp_fun {
  */
 template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-          require_not_var_matrix_t<T>* = nullptr>
+          require_not_var_matrix_t<T>* = nullptr,
+          require_container_t<T>* = nullptr>
 inline auto log1p_exp(T&& x) {
   return apply_scalar_unary<log1p_exp_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/log2.hpp b/stan/math/prim/fun/log2.hpp
index ab294e80a5b..60bc0fc13ec 100644
--- a/stan/math/prim/fun/log2.hpp
+++ b/stan/math/prim/fun/log2.hpp
@@ -16,6 +16,11 @@ namespace math {
  */
 inline constexpr double log2() { return LOG_TWO; }
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto log2(T x) {
+  return std::log2(x);
+}
+
 /**
  * Structure to wrap `log2()` so it can be vectorized.
  */
@@ -28,9 +33,8 @@ struct log2_fun {
    * @return base two log of the argument
    */
   template <typename T>
-  static inline auto fun(const T& x) {
-    using std::log2;
-    return log2(x);
+  static inline auto fun(T&& x) {
+    return log2(std::forward<T>(x));
   }
 };
 
@@ -45,7 +49,8 @@ struct log2_fun {
  * @return elementwise log2 of container elements
  */
 template <typename T, require_not_var_matrix_t<T>* = nullptr,
-          require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
+          require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
+          require_container_t<T>* = nullptr>
 inline auto log2(T&& x) {
   return apply_scalar_unary<log2_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/log_inv_logit.hpp b/stan/math/prim/fun/log_inv_logit.hpp
index 002a02a22c1..4aebb384535 100644
--- a/stan/math/prim/fun/log_inv_logit.hpp
+++ b/stan/math/prim/fun/log_inv_logit.hpp
@@ -63,8 +63,8 @@ struct log_inv_logit_fun {
    * @return natural log of inverse logit of argument
    */
   template <typename T>
-  static inline auto fun(const T& x) {
-    return log_inv_logit(x);
+  static inline auto fun(T&& x) {
+  return log_inv_logit(std::forward<T>(x));
   }
 };
 
@@ -80,7 +80,8 @@ struct log_inv_logit_fun {
  */
 template <typename T,
           require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-          require_not_var_matrix_t<T>* = nullptr>
+          require_not_var_matrix_t<T>* = nullptr,
+          require_container_t<T>* = nullptr>
 inline auto log_inv_logit(T&& x) {
   return apply_scalar_unary<log_inv_logit_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/log_sum_exp.hpp b/stan/math/prim/fun/log_sum_exp.hpp
index e58ab40a4ed..b430671a399 100644
--- a/stan/math/prim/fun/log_sum_exp.hpp
+++ b/stan/math/prim/fun/log_sum_exp.hpp
@@ -80,18 +80,17 @@ inline return_type_t<T1, T2> log_sum_exp(const T2& a, const T1& b) {
  */
 template <typename T, require_container_st<std::is_arithmetic, T>* = nullptr>
 inline auto log_sum_exp(T&& x) {
-  return apply_vector_unary<std::decay_t<T>>::reduce(
-      std::forward<T>(x), [&](auto&& v) {
-        if (v.size() == 0) {
-          return NEGATIVE_INFTY;
-        }
-        const auto& v_ref = to_ref(v);
-        const double max = v_ref.maxCoeff();
-        if (!std::isfinite(max)) {
-          return max;
-        }
-        return max + std::log((v_ref.array() - max).exp().sum());
-      });
+  return apply_vector_unary<T>::reduce(std::forward<T>(x), [](const auto& v) {
+    if (v.size() == 0) {
+      return NEGATIVE_INFTY;
+    }
+    const auto& v_ref = to_ref(v);
+    const double max = v_ref.maxCoeff();
+    if (!std::isfinite(max)) {
+      return max;
+    }
+    return max + std::log((v_ref.array() - max).exp().sum());
+  });
 }
 
 /**
@@ -105,13 +104,9 @@ inline auto log_sum_exp(T&& x) {
  * @return log_sum_exp function applied to the two inputs.
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
-inline auto log_sum_exp(T1&& a, T2&& b) {
+inline auto log_sum_exp(T1&& a, const T2& b) {
   return apply_scalar_binary(
-      [](auto&& c, auto&& d) {
-        return log_sum_exp(std::forward<decltype(c)>(c),
-                           std::forward<decltype(d)>(d));
-      },
-      std::forward<T1>(a), std::forward<T2>(b));
+      [](const auto& c, const auto& d) { return log_sum_exp(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/logit.hpp b/stan/math/prim/fun/logit.hpp
index 22fab56a3b1..dfafa6daf22 100644
--- a/stan/math/prim/fun/logit.hpp
+++ b/stan/math/prim/fun/logit.hpp
@@ -71,8 +71,8 @@ struct logit_fun {
    * @return log odds of the argument
    */
   template <typename T>
-  static inline auto fun(const T& x) {
-    return logit(x);
+  static inline auto fun(T&& x) {
+  return logit(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/mdivide_left.hpp b/stan/math/prim/fun/mdivide_left.hpp
index 14bcbe55ed6..8441b855bd3 100644
--- a/stan/math/prim/fun/mdivide_left.hpp
+++ b/stan/math/prim/fun/mdivide_left.hpp
@@ -22,20 +22,20 @@ namespace math {
  */
 template <typename T1, typename T2,
           require_all_eigen_vt<std::is_arithmetic, T1, T2>* = nullptr>
-inline Eigen::Matrix<return_type_t<T1, T2>, T1::RowsAtCompileTime,
-                     T2::ColsAtCompileTime>
-mdivide_left(const T1& A, const T2& b) {
+inline Eigen::Matrix<return_type_t<T1, T2>, std::decay_t<T1>::RowsAtCompileTime,
+                     std::decay_t<T2>::ColsAtCompileTime>
+mdivide_left(T1&& A, T2&& b) {
   check_square("mdivide_left", "A", A);
   check_multiplicable("mdivide_left", "A", A, "b", b);
   if (A.size() == 0) {
     return {0, b.cols()};
   }
 
-  return Eigen::Matrix<return_type_t<T1, T2>, T1::RowsAtCompileTime,
-                       T1::ColsAtCompileTime>(A)
+  return Eigen::Matrix<return_type_t<T1, T2>, std::decay_t<T1>::RowsAtCompileTime,
+                       std::decay_t<T1>::ColsAtCompileTime>(std::forward<T1>(A))
       .lu()
-      .solve(Eigen::Matrix<return_type_t<T1, T2>, T2::RowsAtCompileTime,
-                           T2::ColsAtCompileTime>(b));
+      .solve(Eigen::Matrix<return_type_t<T1, T2>, std::decay_t<T2>::RowsAtCompileTime,
+                           std::decay_t<T2>::ColsAtCompileTime>(std::forward<T2>(b)));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/mdivide_left_ldlt.hpp b/stan/math/prim/fun/mdivide_left_ldlt.hpp
index 0472dc4ca76..e0c75e5d342 100644
--- a/stan/math/prim/fun/mdivide_left_ldlt.hpp
+++ b/stan/math/prim/fun/mdivide_left_ldlt.hpp
@@ -26,8 +26,8 @@ template <typename T, typename EigMat, require_eigen_t<EigMat>* = nullptr,
           require_any_not_t<std::is_arithmetic<value_type_t<T>>,
                             is_fvar<value_type_t<EigMat>>>* = nullptr>
 inline Eigen::Matrix<return_type_t<T, EigMat>, Eigen::Dynamic,
-                     EigMat::ColsAtCompileTime>
-mdivide_left_ldlt(LDLT_factor<T>& A, const EigMat& b) {
+                     std::decay_t<EigMat>::ColsAtCompileTime>
+mdivide_left_ldlt(LDLT_factor<T>& A, EigMat&& b) {
   check_multiplicable("mdivide_left_ldlt", "A", A.matrix(), "b", b);
 
   if (A.matrix().cols() == 0) {
@@ -35,8 +35,8 @@ mdivide_left_ldlt(LDLT_factor<T>& A, const EigMat& b) {
   }
 
   return A.ldlt().solve(
-      Eigen::Matrix<return_type_t<T, EigMat>, EigMat::RowsAtCompileTime,
-                    EigMat::ColsAtCompileTime>(b));
+      Eigen::Matrix<return_type_t<T, EigMat>, std::decay_t<EigMat>::RowsAtCompileTime,
+                    std::decay_t<EigMat>::ColsAtCompileTime>(std::forward<EigMat>(b)));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/mdivide_left_spd.hpp b/stan/math/prim/fun/mdivide_left_spd.hpp
index 25b0f404fa0..88a8e02a84c 100644
--- a/stan/math/prim/fun/mdivide_left_spd.hpp
+++ b/stan/math/prim/fun/mdivide_left_spd.hpp
@@ -26,11 +26,11 @@ template <typename EigMat1, typename EigMat2,
           require_all_eigen_t<EigMat1, EigMat2>* = nullptr,
           require_all_not_vt_var<EigMat1, EigMat2>* = nullptr>
 inline Eigen::Matrix<return_type_t<EigMat1, EigMat2>,
-                     EigMat1::RowsAtCompileTime, EigMat2::ColsAtCompileTime>
-mdivide_left_spd(const EigMat1& A, const EigMat2& b) {
+                     std::decay_t<EigMat1>::RowsAtCompileTime, std::decay_t<EigMat2>::ColsAtCompileTime>
+mdivide_left_spd(EigMat1&& A, EigMat2&& b) {
   static constexpr const char* function = "mdivide_left_spd";
   check_multiplicable(function, "A", A, "b", b);
-  const auto& A_ref = to_ref(A);
+  auto&& A_ref = to_ref(std::forward<EigMat1>(A));
   check_symmetric(function, "A", A_ref);
   check_not_nan(function, "A", A_ref);
   if (A.size() == 0) {
@@ -39,13 +39,12 @@ mdivide_left_spd(const EigMat1& A, const EigMat2& b) {
 
   auto llt
       = Eigen::Matrix<return_type_t<EigMat1, EigMat2>,
-                      EigMat1::RowsAtCompileTime, EigMat1::ColsAtCompileTime>(
-            A_ref)
-            .llt();
+                      std::decay_t<EigMat1>::RowsAtCompileTime, std::decay_t<EigMat1>::ColsAtCompileTime>(
+            std::forward<decltype(A_ref)>(A_ref)).llt();
   check_pos_definite(function, "A", llt);
-  return llt.solve(
-      Eigen::Matrix<return_type_t<EigMat1, EigMat2>, EigMat2::RowsAtCompileTime,
-                    EigMat2::ColsAtCompileTime>(b));
+  return std::move(llt).solve(
+      Eigen::Matrix<return_type_t<EigMat1, EigMat2>, std::decay_t<EigMat2>::RowsAtCompileTime,
+                    std::decay_t<EigMat2>::ColsAtCompileTime>(std::forward<EigMat2>(b)));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/mdivide_left_tri.hpp b/stan/math/prim/fun/mdivide_left_tri.hpp
index 695981e78ca..88085e6f211 100644
--- a/stan/math/prim/fun/mdivide_left_tri.hpp
+++ b/stan/math/prim/fun/mdivide_left_tri.hpp
@@ -26,7 +26,7 @@ namespace math {
 template <Eigen::UpLoType TriView, typename T1, typename T2,
           require_all_eigen_t<T1, T2> * = nullptr,
           require_all_not_eigen_vt<is_var, T1, T2> * = nullptr>
-inline auto mdivide_left_tri(const T1 &A, const T2 &b) {
+inline auto mdivide_left_tri(T1&& A, T2&& b) {
   using T_return = return_type_t<T1, T2>;
   using ret_type = Eigen::Matrix<T_return, Eigen::Dynamic, Eigen::Dynamic>;
   check_square("mdivide_left_tri", "A", A);
@@ -34,10 +34,9 @@ inline auto mdivide_left_tri(const T1 &A, const T2 &b) {
   if (A.rows() == 0) {
     return ret_type(0, b.cols());
   }
-
-  return ret_type(A)
+  return ret_type(std::forward<T1>(A))
       .template triangularView<TriView>()
-      .solve(ret_type(b))
+      .solve(ret_type(std::forward<T2>(b)))
       .eval();
 }
 
@@ -51,7 +50,7 @@ inline auto mdivide_left_tri(const T1 &A, const T2 &b) {
  * @throws std::domain_error if A is not square
  */
 template <Eigen::UpLoType TriView, typename T, require_eigen_t<T> * = nullptr>
-inline plain_type_t<T> mdivide_left_tri(const T &A) {
+inline plain_type_t<T> mdivide_left_tri(T&& A) {
   check_square("mdivide_left_tri", "A", A);
   if (A.rows() == 0) {
     return {};
diff --git a/stan/math/prim/fun/mdivide_left_tri_low.hpp b/stan/math/prim/fun/mdivide_left_tri_low.hpp
index 19079549ae9..1eaeebf6ca7 100644
--- a/stan/math/prim/fun/mdivide_left_tri_low.hpp
+++ b/stan/math/prim/fun/mdivide_left_tri_low.hpp
@@ -28,27 +28,25 @@ namespace math {
  */
 template <typename T1, typename T2, require_all_eigen_t<T1, T2>* = nullptr,
           require_all_not_eigen_vt<is_fvar, T1, T2>* = nullptr>
-inline Eigen::Matrix<return_type_t<T1, T2>, T1::RowsAtCompileTime,
-                     T2::ColsAtCompileTime>
-mdivide_left_tri_low(const T1& A, const T2& b) {
+inline Eigen::Matrix<return_type_t<T1, T2>, std::decay_t<T1>::RowsAtCompileTime,
+                     std::decay_t<T2>::ColsAtCompileTime>
+mdivide_left_tri_low(T1&& A, T2&& b) {
   check_square("mdivide_left_tri_low", "A", A);
   check_multiplicable("mdivide_left_tri_low", "A", A, "b", b);
   if (A.rows() == 0) {
     return {0, b.cols()};
   }
-
-  return mdivide_left_tri<Eigen::Lower>(A, b);
+  return mdivide_left_tri<Eigen::Lower>(std::forward<T1>(A), std::forward<T2>(b));
 }
 
 template <typename T, require_eigen_t<T>* = nullptr,
           require_not_eigen_vt<is_fvar, T>* = nullptr>
-inline plain_type_t<T> mdivide_left_tri_low(const T& A) {
+inline plain_type_t<T> mdivide_left_tri_low(T&& A) {
   check_square("mdivide_left_tri_low", "A", A);
   if (A.rows() == 0) {
     return {};
   }
-
-  return mdivide_left_tri<Eigen::Lower>(A);
+  return mdivide_left_tri<Eigen::Lower>(std::forward<T>(A));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/mdivide_right.hpp b/stan/math/prim/fun/mdivide_right.hpp
index fd699846792..e0febad43c3 100644
--- a/stan/math/prim/fun/mdivide_right.hpp
+++ b/stan/math/prim/fun/mdivide_right.hpp
@@ -24,24 +24,22 @@ template <typename EigMat1, typename EigMat2,
           require_all_eigen_t<EigMat1, EigMat2>* = nullptr,
           require_all_not_vt_fvar<EigMat1, EigMat2>* = nullptr>
 inline Eigen::Matrix<return_type_t<EigMat1, EigMat2>,
-                     EigMat1::RowsAtCompileTime, EigMat2::ColsAtCompileTime>
-mdivide_right(const EigMat1& b, const EigMat2& A) {
+                     std::decay_t<EigMat1>::RowsAtCompileTime, std::decay_t<EigMat2>::ColsAtCompileTime>
+mdivide_right(EigMat1&& b, EigMat2&& A) {
   using T_return = return_type_t<EigMat1, EigMat2>;
   check_square("mdivide_right", "A", A);
   check_multiplicable("mdivide_right", "b", b, "A", A);
   if (A.size() == 0) {
     return {b.rows(), 0};
   }
-
-  return Eigen::Matrix<T_return, EigMat2::RowsAtCompileTime,
-                       EigMat2::ColsAtCompileTime>(A)
+  return Eigen::Matrix<T_return, std::decay_t<EigMat2>::RowsAtCompileTime,
+                       std::decay_t<EigMat2>::ColsAtCompileTime>(std::forward<EigMat2>(A))
       .transpose()
       .lu()
-      .solve(Eigen::Matrix<T_return, Eigen::Dynamic, Eigen::Dynamic>(b)
+      .solve(Eigen::Matrix<T_return, Eigen::Dynamic, Eigen::Dynamic>(std::forward<EigMat1>(b))
                  .transpose())
       .transpose();
 }
-
 }  // namespace math
 }  // namespace stan
 
diff --git a/stan/math/prim/fun/mdivide_right_ldlt.hpp b/stan/math/prim/fun/mdivide_right_ldlt.hpp
index 8ad77393a03..5bc6855ba21 100644
--- a/stan/math/prim/fun/mdivide_right_ldlt.hpp
+++ b/stan/math/prim/fun/mdivide_right_ldlt.hpp
@@ -24,11 +24,11 @@ namespace math {
 template <typename EigMat, typename T,
           require_all_matrix_t<EigMat, T>* = nullptr,
           require_any_not_st_arithmetic<EigMat, T>* = nullptr>
-inline auto mdivide_right_ldlt(const EigMat& b, LDLT_factor<T>& A) {
+inline auto mdivide_right_ldlt(EigMat&& b, LDLT_factor<T>& A) {
   check_multiplicable("mdivide_right_ldlt", "b", b, "A", A.matrix());
   check_ldlt_factor("mdivide_right_ldlt", "A", A);
 
-  return mdivide_left_ldlt(A, b.transpose()).transpose().eval();
+  return mdivide_left_ldlt(A, std::forward<EigMat>(b).transpose()).transpose().eval();
 }
 
 /**
@@ -47,8 +47,8 @@ inline auto mdivide_right_ldlt(const EigMat& b, LDLT_factor<T>& A) {
 template <typename EigMat, typename T,
           require_all_matrix_t<EigMat, T>* = nullptr,
           require_all_st_arithmetic<EigMat, T>* = nullptr>
-inline Eigen::Matrix<double, EigMat::RowsAtCompileTime, T::ColsAtCompileTime>
-mdivide_right_ldlt(const EigMat& b, LDLT_factor<T>& A) {
+inline Eigen::Matrix<double, std::decay_t<EigMat>::RowsAtCompileTime, std::decay_t<T>::ColsAtCompileTime>
+mdivide_right_ldlt(EigMat&& b, LDLT_factor<T>& A) {
   check_multiplicable("mdivide_right_ldlt", "b", b, "A", A.matrix());
   check_ldlt_factor("mdivide_right_ldlt", "A", A);
 
@@ -56,7 +56,7 @@ mdivide_right_ldlt(const EigMat& b, LDLT_factor<T>& A) {
     return {b.rows(), 0};
   }
 
-  return A.ldlt().solve(b.transpose()).transpose();
+  return A.ldlt().solve(std::forward<EigMat>(b).transpose()).transpose();
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/mdivide_right_spd.hpp b/stan/math/prim/fun/mdivide_right_spd.hpp
index c3c177dbb26..3dfb604233d 100644
--- a/stan/math/prim/fun/mdivide_right_spd.hpp
+++ b/stan/math/prim/fun/mdivide_right_spd.hpp
@@ -26,18 +26,18 @@ namespace math {
 template <typename EigMat1, typename EigMat2,
           require_all_eigen_t<EigMat1, EigMat2>* = nullptr>
 inline Eigen::Matrix<return_type_t<EigMat1, EigMat2>,
-                     EigMat1::RowsAtCompileTime, EigMat2::ColsAtCompileTime>
-mdivide_right_spd(const EigMat1& b, const EigMat2& A) {
+                     std::decay_t<EigMat1>::RowsAtCompileTime, std::decay_t<EigMat2>::ColsAtCompileTime>
+mdivide_right_spd(EigMat1&& b, EigMat2&& A) {
   static constexpr const char* function = "mdivide_right_spd";
   check_multiplicable(function, "b", b, "A", A);
-  const auto& A_ref = to_ref(A);
+  auto&& A_ref = to_ref(std::forward<EigMat2>(A));
   check_symmetric(function, "A", A_ref);
   check_not_nan(function, "A", A_ref);
   if (A.size() == 0) {
     return {b.rows(), 0};
   }
 
-  return mdivide_left_spd(A_ref, b.transpose()).transpose();
+  return mdivide_left_spd(std::forward<decltype(A_ref)>(A_ref), std::forward<EigMat1>(b).transpose()).transpose();
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/mdivide_right_tri.hpp b/stan/math/prim/fun/mdivide_right_tri.hpp
index 41ce153bf2a..ee68b1acd0b 100644
--- a/stan/math/prim/fun/mdivide_right_tri.hpp
+++ b/stan/math/prim/fun/mdivide_right_tri.hpp
@@ -26,7 +26,7 @@ namespace math {
  */
 template <Eigen::UpLoType TriView, typename EigMat1, typename EigMat2,
           require_all_eigen_t<EigMat1, EigMat2>* = nullptr>
-inline auto mdivide_right_tri(const EigMat1& b, const EigMat2& A) {
+inline auto mdivide_right_tri(EigMat1&& b, EigMat2&& A) {
   check_square("mdivide_right_tri", "A", A);
   check_multiplicable("mdivide_right_tri", "b", b, "A", A);
   if (TriView != Eigen::Lower && TriView != Eigen::Upper) {
@@ -40,10 +40,10 @@ inline auto mdivide_right_tri(const EigMat1& b, const EigMat2& A) {
     return ret_type(b.rows(), 0);
   }
 
-  return ret_type(A)
+  return ret_type(std::forward<EigMat2>(A))
       .template triangularView<TriView>()
       .transpose()
-      .solve(ret_type(b).transpose())
+      .solve(ret_type(std::forward<EigMat1>(b)).transpose())
       .transpose()
       .eval();
 }
diff --git a/stan/math/prim/fun/mdivide_right_tri_low.hpp b/stan/math/prim/fun/mdivide_right_tri_low.hpp
index 6a01573a016..78e57b643f9 100644
--- a/stan/math/prim/fun/mdivide_right_tri_low.hpp
+++ b/stan/math/prim/fun/mdivide_right_tri_low.hpp
@@ -25,9 +25,9 @@ template <typename EigMat1, typename EigMat2,
           require_all_eigen_t<EigMat1, EigMat2>* = nullptr,
           require_all_not_vt_fvar<EigMat1, EigMat2>* = nullptr>
 inline Eigen::Matrix<return_type_t<EigMat1, EigMat2>,
-                     EigMat1::RowsAtCompileTime, EigMat2::ColsAtCompileTime>
-mdivide_right_tri_low(const EigMat1& b, const EigMat2& A) {
-  return mdivide_right_tri<Eigen::Lower>(b, A);
+                     std::decay_t<EigMat1>::RowsAtCompileTime, std::decay_t<EigMat2>::ColsAtCompileTime>
+mdivide_right_tri_low(EigMat1&& b, EigMat2&& A) {
+  return mdivide_right_tri<Eigen::Lower>(std::forward<EigMat1>(b), std::forward<EigMat2>(A));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/round.hpp b/stan/math/prim/fun/round.hpp
index 74b9191370e..e9c11a4356e 100644
--- a/stan/math/prim/fun/round.hpp
+++ b/stan/math/prim/fun/round.hpp
@@ -10,6 +10,11 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto round(T x) {
+  return std::round(x);
+}
+
 /**
  * Structure to wrap `round()` so it can be vectorized.
  *
@@ -19,9 +24,8 @@ namespace math {
  */
 struct round_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    using std::round;
-    return round(x);
+  static inline auto fun(T&& x) {
+    return round(std::forward<T>(x));
   }
 };
 
@@ -35,7 +39,8 @@ struct round_fun {
 template <typename Container,
           require_not_container_st<std::is_arithmetic, Container>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              Container>* = nullptr>
+              Container>* = nullptr,
+              require_container_t<Container>* = nullptr>
 inline auto round(Container&& x) {
   return apply_scalar_unary<round_fun, Container>::apply(
       std::forward<Container>(x));
diff --git a/stan/math/prim/fun/row.hpp b/stan/math/prim/fun/row.hpp
index fea6571143e..4a3593ef318 100644
--- a/stan/math/prim/fun/row.hpp
+++ b/stan/math/prim/fun/row.hpp
@@ -25,7 +25,7 @@ inline auto row(T&& m, size_t i) {
   check_row_index("row", "i", m, i);
   return make_holder([i](auto&& mm) {
         return std::forward<decltype(mm)>(mm).row(i - 1);
-  }, std::forward<T>(m), i);
+  }, std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/scale_matrix_exp_multiply.hpp b/stan/math/prim/fun/scale_matrix_exp_multiply.hpp
index 9e7e859f2eb..7901aafc80e 100644
--- a/stan/math/prim/fun/scale_matrix_exp_multiply.hpp
+++ b/stan/math/prim/fun/scale_matrix_exp_multiply.hpp
@@ -55,17 +55,16 @@ template <typename Tt, typename EigMat1, typename EigMat2,
           require_all_eigen_t<EigMat1, EigMat2>* = nullptr,
           require_any_autodiff_t<Tt, value_type_t<EigMat1>,
                                  value_type_t<EigMat2>>* = nullptr>
-inline auto scale_matrix_exp_multiply(Tt&& t, EigMat1&& A, EigMat2&& B) {
+inline Eigen::Matrix<return_type_t<Tt, EigMat1, EigMat2>, Eigen::Dynamic,
+                     EigMat2::ColsAtCompileTime>
+scale_matrix_exp_multiply(const Tt& t, const EigMat1& A, const EigMat2& B) {
   check_square("scale_matrix_exp_multiply", "input matrix", A);
   check_multiplicable("scale_matrix_exp_multiply", "A", A, "B", B);
   if (A.size() == 0) {
     return {0, B.cols()};
   }
 
-  return make_holder([t](auto&& A_, auto&& B_) {
-    return multiply(matrix_exp(multiply(std::forward<decltype(A_)>(A_), t)),
-      std::forward<decltype(B_)>(B_));
-  }, std::forward<EigMat1>(A), std::forward<EigMat2>(B));
+  return multiply(matrix_exp(multiply(A, t)), B);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sin.hpp b/stan/math/prim/fun/sin.hpp
index 15349da0455..4ee414c2a99 100644
--- a/stan/math/prim/fun/sin.hpp
+++ b/stan/math/prim/fun/sin.hpp
@@ -46,8 +46,8 @@ inline auto sin(const T x) {
  */
 struct sin_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return sin(x);
+  static inline auto fun(T&& x) {
+  return sin(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/sinh.hpp b/stan/math/prim/fun/sinh.hpp
index 7a5c744d97d..b24538848e9 100644
--- a/stan/math/prim/fun/sinh.hpp
+++ b/stan/math/prim/fun/sinh.hpp
@@ -44,8 +44,8 @@ inline auto sinh(const T x) {
  */
 struct sinh_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return sinh(x);
+  static inline auto fun(T&& x) {
+  return sinh(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/sqrt.hpp b/stan/math/prim/fun/sqrt.hpp
index 343a8ae4492..c90351546e3 100644
--- a/stan/math/prim/fun/sqrt.hpp
+++ b/stan/math/prim/fun/sqrt.hpp
@@ -44,8 +44,8 @@ inline auto sqrt(const T x) {
  */
 struct sqrt_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return sqrt(x);
+  static inline auto fun(T&& x) {
+  return sqrt(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/step.hpp b/stan/math/prim/fun/step.hpp
index d2663f0b2ee..15d9b405b2c 100644
--- a/stan/math/prim/fun/step.hpp
+++ b/stan/math/prim/fun/step.hpp
@@ -44,8 +44,8 @@ struct step_fun {
    * @return step(y)
    */
   template <typename T>
-  static inline auto fun(const T& y) {
-    return step(y);
+  static inline auto fun(T&& y) {
+  return step(std::forward<T>(y));
   }
 };
 
diff --git a/stan/math/prim/fun/tan.hpp b/stan/math/prim/fun/tan.hpp
index e7b4b1796d9..7f59b1bc765 100644
--- a/stan/math/prim/fun/tan.hpp
+++ b/stan/math/prim/fun/tan.hpp
@@ -46,8 +46,8 @@ inline auto tan(const T x) {
  */
 struct tan_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return tan(x);
+  static inline auto fun(T&& x) {
+  return tan(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/tanh.hpp b/stan/math/prim/fun/tanh.hpp
index 5aaa2016801..140ab321258 100644
--- a/stan/math/prim/fun/tanh.hpp
+++ b/stan/math/prim/fun/tanh.hpp
@@ -46,8 +46,8 @@ inline auto tanh(const T x) {
  */
 struct tanh_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return tanh(x);
+  static inline auto fun(T&& x) {
+  return tanh(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/tgamma.hpp b/stan/math/prim/fun/tgamma.hpp
index a37da4ef511..840b070d1d2 100644
--- a/stan/math/prim/fun/tgamma.hpp
+++ b/stan/math/prim/fun/tgamma.hpp
@@ -33,8 +33,8 @@ inline double tgamma(double x) {
  */
 struct tgamma_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return tgamma(x);
+  static inline auto fun(T&& x) {
+  return tgamma(std::forward<T>(x));
   }
 };
 
@@ -49,7 +49,8 @@ struct tgamma_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr,
+    require_container_t<T>* = nullptr>
 inline auto tgamma(T&& x) {
   return apply_scalar_unary<tgamma_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/to_int.hpp b/stan/math/prim/fun/to_int.hpp
index 29db2daa96b..d18f89f3f6a 100644
--- a/stan/math/prim/fun/to_int.hpp
+++ b/stan/math/prim/fun/to_int.hpp
@@ -56,8 +56,8 @@ inline int to_int(T x) {
  */
 struct to_int_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return to_int(x);
+  static inline auto fun(T&& x) {
+  return to_int(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/trigamma.hpp b/stan/math/prim/fun/trigamma.hpp
index 372eb6cbc6c..63e0d9f8e94 100644
--- a/stan/math/prim/fun/trigamma.hpp
+++ b/stan/math/prim/fun/trigamma.hpp
@@ -138,8 +138,8 @@ struct trigamma_fun {
    * @return trigamma applied to argument.
    */
   template <typename T>
-  static inline auto fun(const T& x) {
-    return trigamma(x);
+  static inline auto fun(T&& x) {
+  return trigamma(std::forward<T>(x));
   }
 };
 
@@ -154,7 +154,8 @@ struct trigamma_fun {
  * @return elementwise trigamma of container elements
  */
 template <typename T,
-          require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
+          require_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
+          require_container_t<T>* = nullptr>
 inline auto trigamma(T&& x) {
   return apply_scalar_unary<trigamma_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/trunc.hpp b/stan/math/prim/fun/trunc.hpp
index 631e7e44deb..494f114a168 100644
--- a/stan/math/prim/fun/trunc.hpp
+++ b/stan/math/prim/fun/trunc.hpp
@@ -8,6 +8,11 @@
 namespace stan {
 namespace math {
 
+template <typename T, require_arithmetic_t<T>* = nullptr>
+inline auto trunc(T x) {
+  return std::trunc(x);
+}
+
 /**
  * Structure to wrap `trunc()` so it can be vectorized.
  */
@@ -21,9 +26,8 @@ struct trunc_fun {
    * @return truncation of the argument
    */
   template <typename T>
-  static inline auto fun(const T& x) {
-    using std::trunc;
-    return trunc(x);
+  static inline auto fun(T&& x) {
+    return trunc(std::forward<T>(x));
   }
 };
 
@@ -38,7 +42,8 @@ struct trunc_fun {
  * @return elementwise trunc of container elements
  */
 template <typename T, require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-                          T>* = nullptr>
+                          T>* = nullptr,
+                          require_container_t<T>* = nullptr>
 inline auto trunc(T&& x) {
   return apply_scalar_unary<trunc_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/prob/std_normal_log_qf.hpp b/stan/math/prim/prob/std_normal_log_qf.hpp
index d4815b38809..47c9292e13c 100644
--- a/stan/math/prim/prob/std_normal_log_qf.hpp
+++ b/stan/math/prim/prob/std_normal_log_qf.hpp
@@ -132,8 +132,8 @@ inline double std_normal_log_qf(double log_p) {
  */
 struct std_normal_log_qf_fun {
   template <typename T>
-  static inline auto fun(const T& x) {
-    return std_normal_log_qf(x);
+  static inline auto fun(T&& x) {
+  return std_normal_log_qf(std::forward<T>(x));
   }
 };
 
@@ -149,7 +149,8 @@ struct std_normal_log_qf_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr,
+    require_container_t<T>* = nullptr>
 inline auto std_normal_log_qf(T&& x) {
   return apply_scalar_unary<std_normal_log_qf_fun, T>::apply(
       std::forward<T>(x));
diff --git a/stan/math/rev/fun/Phi.hpp b/stan/math/rev/fun/Phi.hpp
index 06f62cb885a..4a89c9e3634 100644
--- a/stan/math/rev/fun/Phi.hpp
+++ b/stan/math/rev/fun/Phi.hpp
@@ -50,7 +50,8 @@ namespace math {
  * @param a Variable argument.
  * @return The unit normal cdf evaluated at the specified argument.
  */
-inline var Phi(const var& a) {
+template <typename T, require_var_t<T>* = nullptr, require_stan_scalar_t<T>* = nullptr>
+inline auto Phi(T&& a) {
   return make_callback_var(Phi(a.val()), [a](auto& vi) mutable {
     a.adj() += vi.adj() * INV_SQRT_TWO_PI * std::exp(-0.5 * a.val() * a.val());
   });
diff --git a/stan/math/rev/fun/cbrt.hpp b/stan/math/rev/fun/cbrt.hpp
index 2c4b10d0884..e6a4248fe2e 100644
--- a/stan/math/rev/fun/cbrt.hpp
+++ b/stan/math/rev/fun/cbrt.hpp
@@ -31,28 +31,24 @@ namespace math {
    \end{cases}
    \f]
  *
- * @param a Specified variable.
- * @return Cube root of the variable.
- */
-inline var cbrt(const var& a) {
-  return make_callback_var(cbrt(a.val()), [a](const auto& vi) mutable {
-    a.adj() += vi.adj() / (3.0 * vi.val() * vi.val());
-  });
-}
-
-/**
  * Returns the cube root of the specified variable (C99).
- * @tparam Varmat a `var_value` with inner Eigen type
+ * @tparam Varmat a `var_value`
  * @param a Specified variable.
  * @return Cube root of the variable.
  */
-template <typename VarMat, require_var_matrix_t<VarMat>* = nullptr>
-inline auto cbrt(const VarMat& a) {
-  return make_callback_var(
-      a.val().unaryExpr([](const auto x) { return cbrt(x); }),
+template <typename Var, require_var_t<Var>* = nullptr>
+inline auto cbrt(Var&& a) {
+  if constexpr (is_stan_scalar_v<Var>) {
+    return make_callback_var(cbrt(a.val()), [a](const auto& vi) mutable {
+      a.adj() += vi.adj() / (3.0 * vi.val() * vi.val());
+    });
+  } else {
+    return make_callback_var(
+      a.val().unaryExpr([](auto&& x) { return cbrt(x); }),
       [a](const auto& vi) mutable {
         a.adj().array() += vi.adj().array() / (3.0 * vi.val().array().square());
-      });
+    });
+  }
 }
 
 }  // namespace math
diff --git a/stan/math/rev/fun/digamma.hpp b/stan/math/rev/fun/digamma.hpp
index be4cbda9a47..cf3bf15d688 100644
--- a/stan/math/rev/fun/digamma.hpp
+++ b/stan/math/rev/fun/digamma.hpp
@@ -16,7 +16,8 @@ namespace math {
  * @param[in] a argument
  * @return derivative of log gamma function at argument
  */
-inline var digamma(const var& a) {
+template <typename T, require_var_t<T>* = nullptr, require_stan_scalar_t<T>* = nullptr>
+inline auto digamma(T&& a) {
   return make_callback_var(digamma(a.val()), [a](auto&& vi) {
     a.adj() += vi.adj() * trigamma(a.val());
   });
@@ -31,7 +32,7 @@ inline var digamma(const var& a) {
  * @return elementwise derivative of log gamma function
  */
 template <typename T, require_var_matrix_t<T>* = nullptr>
-inline auto digamma(const T& a) {
+inline auto digamma(T&& a) {
   return make_callback_var(a.val()
                                .array()
                                .unaryExpr([](auto&& x) { return digamma(x); })

From 67a15d501243a0d41e8a677cbffdad05a11271b4 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Tue, 1 Jul 2025 17:47:51 -0400
Subject: [PATCH 12/31] [Jenkins] auto-formatting by clang-format version
 10.0.0-4ubuntu1

---
 stan/math/fwd/fun/Phi.hpp                     |  3 +-
 stan/math/fwd/fun/log_softmax.hpp             | 56 +++++++++----------
 .../constraint/cholesky_corr_constrain.hpp    | 14 ++---
 .../prim/constraint/cholesky_corr_free.hpp    |  7 +--
 .../constraint/cholesky_factor_constrain.hpp  | 16 +++---
 .../prim/constraint/cholesky_factor_free.hpp  |  7 +--
 .../prim/constraint/corr_matrix_constrain.hpp | 14 ++---
 .../math/prim/constraint/corr_matrix_free.hpp |  6 +-
 .../prim/constraint/cov_matrix_constrain.hpp  | 14 ++---
 .../constraint/cov_matrix_constrain_lkj.hpp   |  9 ++-
 stan/math/prim/constraint/cov_matrix_free.hpp |  6 +-
 .../prim/constraint/cov_matrix_free_lkj.hpp   | 11 ++--
 .../offset_multiplier_constrain.hpp           |  9 ++-
 .../constraint/offset_multiplier_free.hpp     | 10 ++--
 .../prim/constraint/ordered_constrain.hpp     | 13 ++---
 stan/math/prim/constraint/ordered_free.hpp    |  6 +-
 .../prim/constraint/positive_constrain.hpp    |  7 +--
 .../constraint/positive_ordered_constrain.hpp | 14 ++---
 .../prim/constraint/positive_ordered_free.hpp |  7 +--
 .../prim/constraint/simplex_constrain.hpp     | 13 ++---
 stan/math/prim/constraint/simplex_free.hpp    |  6 +-
 .../stochastic_column_constrain.hpp           | 14 ++---
 .../constraint/stochastic_column_free.hpp     |  7 +--
 .../constraint/stochastic_row_constrain.hpp   | 14 ++---
 .../prim/constraint/stochastic_row_free.hpp   |  7 +--
 .../prim/constraint/sum_to_zero_constrain.hpp | 14 ++---
 .../math/prim/constraint/sum_to_zero_free.hpp |  6 +-
 .../prim/constraint/unit_vector_constrain.hpp | 30 +++++-----
 .../math/prim/constraint/unit_vector_free.hpp |  6 +-
 stan/math/prim/fun/Phi.hpp                    |  5 +-
 stan/math/prim/fun/Phi_approx.hpp             |  5 +-
 stan/math/prim/fun/abs.hpp                    |  2 +-
 stan/math/prim/fun/acos.hpp                   |  2 +-
 stan/math/prim/fun/acosh.hpp                  |  2 +-
 stan/math/prim/fun/add.hpp                    | 26 +++++----
 stan/math/prim/fun/asin.hpp                   |  2 +-
 stan/math/prim/fun/asinh.hpp                  |  2 +-
 stan/math/prim/fun/atan.hpp                   |  2 +-
 stan/math/prim/fun/atanh.hpp                  |  2 +-
 stan/math/prim/fun/block.hpp                  |  8 ++-
 stan/math/prim/fun/ceil.hpp                   |  3 +-
 stan/math/prim/fun/cos.hpp                    |  2 +-
 stan/math/prim/fun/cosh.hpp                   |  2 +-
 stan/math/prim/fun/determinant.hpp            |  5 +-
 stan/math/prim/fun/diagonal.hpp               |  6 +-
 stan/math/prim/fun/dot_self.hpp               |  5 +-
 stan/math/prim/fun/erf.hpp                    |  3 +-
 stan/math/prim/fun/erfc.hpp                   |  3 +-
 stan/math/prim/fun/exp.hpp                    |  2 +-
 stan/math/prim/fun/exp2.hpp                   |  4 +-
 stan/math/prim/fun/expm1.hpp                  |  3 +-
 stan/math/prim/fun/fabs.hpp                   |  2 +-
 stan/math/prim/fun/floor.hpp                  |  2 +-
 stan/math/prim/fun/inv.hpp                    |  4 +-
 stan/math/prim/fun/inv_Phi.hpp                |  5 +-
 stan/math/prim/fun/inv_cloglog.hpp            |  2 +-
 stan/math/prim/fun/inv_erfc.hpp               |  5 +-
 stan/math/prim/fun/inv_sqrt.hpp               |  2 +-
 stan/math/prim/fun/inv_square.hpp             |  2 +-
 stan/math/prim/fun/lambert_w.hpp              |  4 +-
 stan/math/prim/fun/lgamma.hpp                 |  2 +-
 stan/math/prim/fun/log.hpp                    |  2 +-
 stan/math/prim/fun/log10.hpp                  |  2 +-
 stan/math/prim/fun/log1m.hpp                  |  4 +-
 stan/math/prim/fun/log1m_exp.hpp              |  4 +-
 stan/math/prim/fun/log1p.hpp                  |  2 +-
 stan/math/prim/fun/log1p_exp.hpp              |  2 +-
 stan/math/prim/fun/log_inv_logit.hpp          |  2 +-
 stan/math/prim/fun/logit.hpp                  |  2 +-
 stan/math/prim/fun/mdivide_left.hpp           |  9 ++-
 stan/math/prim/fun/mdivide_left_ldlt.hpp      |  7 ++-
 stan/math/prim/fun/mdivide_left_spd.hpp       | 18 +++---
 stan/math/prim/fun/mdivide_left_tri.hpp       |  6 +-
 stan/math/prim/fun/mdivide_left_tri_low.hpp   |  3 +-
 stan/math/prim/fun/mdivide_right.hpp          |  9 ++-
 stan/math/prim/fun/mdivide_right_ldlt.hpp     |  7 ++-
 stan/math/prim/fun/mdivide_right_spd.hpp      |  7 ++-
 stan/math/prim/fun/mdivide_right_tri_low.hpp  |  6 +-
 stan/math/prim/fun/minus.hpp                  |  6 +-
 stan/math/prim/fun/quad_form.hpp              | 10 ++--
 stan/math/prim/fun/quad_form_sym.hpp          | 16 +++---
 stan/math/prim/fun/read_corr_L.hpp            | 10 ++--
 stan/math/prim/fun/read_corr_matrix.hpp       |  6 +-
 stan/math/prim/fun/rep_matrix.hpp             | 10 ++--
 stan/math/prim/fun/reverse.hpp                |  6 +-
 stan/math/prim/fun/round.hpp                  |  2 +-
 stan/math/prim/fun/row.hpp                    |  6 +-
 stan/math/prim/fun/rows_dot_product.hpp       |  8 ++-
 stan/math/prim/fun/rows_dot_self.hpp          |  9 +--
 stan/math/prim/fun/segment.hpp                |  5 +-
 stan/math/prim/fun/select.hpp                 | 28 ++++++----
 stan/math/prim/fun/sin.hpp                    |  2 +-
 stan/math/prim/fun/sinh.hpp                   |  2 +-
 stan/math/prim/fun/sqrt.hpp                   |  2 +-
 stan/math/prim/fun/step.hpp                   |  2 +-
 stan/math/prim/fun/tan.hpp                    |  2 +-
 stan/math/prim/fun/tanh.hpp                   |  2 +-
 stan/math/prim/fun/tgamma.hpp                 |  5 +-
 stan/math/prim/fun/to_int.hpp                 |  2 +-
 stan/math/prim/fun/trigamma.hpp               |  2 +-
 stan/math/prim/fun/trunc.hpp                  |  7 ++-
 .../math/prim/functor/apply_scalar_binary.hpp | 13 +++--
 .../prim/functor/apply_scalar_ternary.hpp     |  9 ++-
 stan/math/prim/functor/apply_vector_unary.hpp |  6 +-
 stan/math/prim/meta/conjunction.hpp           |  1 -
 stan/math/prim/meta/holder.hpp                | 32 +++++++----
 stan/math/prim/prob/loglogistic_cdf.hpp       | 25 ++++-----
 stan/math/prim/prob/std_normal_log_qf.hpp     |  5 +-
 stan/math/rev/fun/Phi.hpp                     |  3 +-
 stan/math/rev/fun/cbrt.hpp                    |  9 +--
 stan/math/rev/fun/digamma.hpp                 |  3 +-
 stan/math/rev/functor/apply_scalar_unary.hpp  |  4 +-
 112 files changed, 422 insertions(+), 402 deletions(-)

diff --git a/stan/math/fwd/fun/Phi.hpp b/stan/math/fwd/fun/Phi.hpp
index d73b6af8449..042e8222f17 100644
--- a/stan/math/fwd/fun/Phi.hpp
+++ b/stan/math/fwd/fun/Phi.hpp
@@ -14,7 +14,8 @@ namespace math {
 
 template <typename T, require_fvar_t<T>* = nullptr>
 inline auto Phi(T&& x) {
-  return std::decay_t<T>(Phi(x.val_), x.d_ * exp(x.val_ * x.val_ / -2.0) * INV_SQRT_TWO_PI);
+  return std::decay_t<T>(Phi(x.val_),
+                         x.d_ * exp(x.val_ * x.val_ / -2.0) * INV_SQRT_TWO_PI);
 }
 
 }  // namespace math
diff --git a/stan/math/fwd/fun/log_softmax.hpp b/stan/math/fwd/fun/log_softmax.hpp
index 3e97183dca1..609fb0daeb8 100644
--- a/stan/math/fwd/fun/log_softmax.hpp
+++ b/stan/math/fwd/fun/log_softmax.hpp
@@ -21,37 +21,35 @@ namespace math {
  */
 template <typename T, require_vector_st<is_fvar, T>* = nullptr>
 inline auto log_softmax(T&& x) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x), [](auto&& alpha) {
-        using T_alpha = decltype(alpha);
-        using T_fvar = value_type_t<T_alpha>;
-        using T_fvar_inner = typename T_fvar::Scalar;
-
-        auto&& alpha_ref = to_ref(std::forward<decltype(alpha)>(alpha));
-        Eigen::Matrix<T_fvar_inner, -1, 1> alpha_v = alpha_ref.val();
-        Eigen::Matrix<T_fvar_inner, -1, 1> softmax_alpha_v = softmax(alpha_v);
-
-        Eigen::Matrix<T_fvar, -1, 1> log_softmax_alpha(alpha_ref.size());
-        log_softmax_alpha.val() = log_softmax(alpha_v);
-        log_softmax_alpha.d().setZero();
-
-        for (int m = 0; m < alpha_ref.size(); ++m) {
-          T_fvar_inner negative_alpha_m_d_times_softmax_alpha_t_m
-              = -alpha_ref.coeff(m).d_ * softmax_alpha_v(m);
-          for (int k = 0; k < alpha_ref.size(); ++k) {
-            if (m == k) {
-              log_softmax_alpha(k).d_
-                  += alpha_ref.coeff(m).d_
-                     + negative_alpha_m_d_times_softmax_alpha_t_m;
-            } else {
-              log_softmax_alpha(k).d_
-                  += negative_alpha_m_d_times_softmax_alpha_t_m;
-            }
-          }
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [](auto&& alpha) {
+    using T_alpha = decltype(alpha);
+    using T_fvar = value_type_t<T_alpha>;
+    using T_fvar_inner = typename T_fvar::Scalar;
+
+    auto&& alpha_ref = to_ref(std::forward<decltype(alpha)>(alpha));
+    Eigen::Matrix<T_fvar_inner, -1, 1> alpha_v = alpha_ref.val();
+    Eigen::Matrix<T_fvar_inner, -1, 1> softmax_alpha_v = softmax(alpha_v);
+
+    Eigen::Matrix<T_fvar, -1, 1> log_softmax_alpha(alpha_ref.size());
+    log_softmax_alpha.val() = log_softmax(alpha_v);
+    log_softmax_alpha.d().setZero();
+
+    for (int m = 0; m < alpha_ref.size(); ++m) {
+      T_fvar_inner negative_alpha_m_d_times_softmax_alpha_t_m
+          = -alpha_ref.coeff(m).d_ * softmax_alpha_v(m);
+      for (int k = 0; k < alpha_ref.size(); ++k) {
+        if (m == k) {
+          log_softmax_alpha(k).d_
+              += alpha_ref.coeff(m).d_
+                 + negative_alpha_m_d_times_softmax_alpha_t_m;
+        } else {
+          log_softmax_alpha(k).d_ += negative_alpha_m_d_times_softmax_alpha_t_m;
         }
+      }
+    }
 
-        return log_softmax_alpha;
-      });
+    return log_softmax_alpha;
+  });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/cholesky_corr_constrain.hpp b/stan/math/prim/constraint/cholesky_corr_constrain.hpp
index 061e514735a..9f489dc08f7 100644
--- a/stan/math/prim/constraint/cholesky_corr_constrain.hpp
+++ b/stan/math/prim/constraint/cholesky_corr_constrain.hpp
@@ -88,10 +88,9 @@ cholesky_corr_constrain(EigVec&& y, int K, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cholesky_corr_constrain(T&& y, int K) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(y), [K](auto&& v) {
-        return cholesky_corr_constrain(std::forward<decltype(v)>(v), K);
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(y), [K](auto&& v) {
+    return cholesky_corr_constrain(std::forward<decltype(v)>(v), K);
+  });
 }
 
 /**
@@ -110,10 +109,9 @@ inline auto cholesky_corr_constrain(T&& y, int K) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto cholesky_corr_constrain(T&& y, int K, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(y), [&lp, K](auto&& v) {
-        return cholesky_corr_constrain(std::forward<decltype(v)>(v), K, lp);
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(y), [&lp, K](auto&& v) {
+    return cholesky_corr_constrain(std::forward<decltype(v)>(v), K, lp);
+  });
 }
 
 /**
diff --git a/stan/math/prim/constraint/cholesky_corr_free.hpp b/stan/math/prim/constraint/cholesky_corr_free.hpp
index 68cf1c63057..1f93fb3d965 100644
--- a/stan/math/prim/constraint/cholesky_corr_free.hpp
+++ b/stan/math/prim/constraint/cholesky_corr_free.hpp
@@ -43,10 +43,9 @@ inline auto cholesky_corr_free(T&& x) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cholesky_corr_free(T&& x) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x), [](auto&& v) {
-        return cholesky_corr_free(std::forward<decltype(v)>(v));
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [](auto&& v) {
+    return cholesky_corr_free(std::forward<decltype(v)>(v));
+  });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/cholesky_factor_constrain.hpp b/stan/math/prim/constraint/cholesky_factor_constrain.hpp
index ec3d2611871..056871f23be 100644
--- a/stan/math/prim/constraint/cholesky_factor_constrain.hpp
+++ b/stan/math/prim/constraint/cholesky_factor_constrain.hpp
@@ -102,10 +102,9 @@ cholesky_factor_constrain(T&& x, int M, int N, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cholesky_factor_constrain(T&& x, int M, int N) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x), [M, N](auto&& v) {
-        return cholesky_factor_constrain(std::forward<decltype(v)>(v), M, N);
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [M, N](auto&& v) {
+    return cholesky_factor_constrain(std::forward<decltype(v)>(v), M, N);
+  });
 }
 
 /**
@@ -128,11 +127,10 @@ inline auto cholesky_factor_constrain(T&& x, int M, int N) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto cholesky_factor_constrain(T&& x, int M, int N, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x), [&lp, M, N](auto&& v) {
-        return cholesky_factor_constrain(std::forward<decltype(v)>(v), M, N,
-                                         lp);
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [&lp, M,
+                                                           N](auto&& v) {
+    return cholesky_factor_constrain(std::forward<decltype(v)>(v), M, N, lp);
+  });
 }
 
 /**
diff --git a/stan/math/prim/constraint/cholesky_factor_free.hpp b/stan/math/prim/constraint/cholesky_factor_free.hpp
index ad693ec5044..8b9a39bb548 100644
--- a/stan/math/prim/constraint/cholesky_factor_free.hpp
+++ b/stan/math/prim/constraint/cholesky_factor_free.hpp
@@ -56,10 +56,9 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cholesky_factor_free(T&& y) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cholesky_factor_free(T&& x) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x), [](auto&& v) {
-        return cholesky_factor_free(std::forward<decltype(v)>(v));
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [](auto&& v) {
+    return cholesky_factor_free(std::forward<decltype(v)>(v));
+  });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/corr_matrix_constrain.hpp b/stan/math/prim/constraint/corr_matrix_constrain.hpp
index 4d56edd954a..36ded2854ca 100644
--- a/stan/math/prim/constraint/corr_matrix_constrain.hpp
+++ b/stan/math/prim/constraint/corr_matrix_constrain.hpp
@@ -92,10 +92,9 @@ corr_matrix_constrain(T&& x, Eigen::Index k, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto corr_matrix_constrain(T&& y, int K) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(y), [K](auto&& v) {
-        return corr_matrix_constrain(std::forward<decltype(v)>(v), K);
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(y), [K](auto&& v) {
+    return corr_matrix_constrain(std::forward<decltype(v)>(v), K);
+  });
 }
 
 /**
@@ -117,10 +116,9 @@ inline auto corr_matrix_constrain(T&& y, int K) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto corr_matrix_constrain(T&& y, int K, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(y), [&lp, K](auto&& v) {
-        return corr_matrix_constrain(std::forward<decltype(v)>(v), K, lp);
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(y), [&lp, K](auto&& v) {
+    return corr_matrix_constrain(std::forward<decltype(v)>(v), K, lp);
+  });
 }
 
 /**
diff --git a/stan/math/prim/constraint/corr_matrix_free.hpp b/stan/math/prim/constraint/corr_matrix_free.hpp
index 96f6a6a9a51..1c7046767db 100644
--- a/stan/math/prim/constraint/corr_matrix_free.hpp
+++ b/stan/math/prim/constraint/corr_matrix_free.hpp
@@ -61,9 +61,9 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> corr_matrix_free(T&& y) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto corr_matrix_free(T&& x) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x),
-      [](auto&& v) { return corr_matrix_free(std::forward<decltype(v)>(v)); });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [](auto&& v) {
+    return corr_matrix_free(std::forward<decltype(v)>(v));
+  });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/cov_matrix_constrain.hpp b/stan/math/prim/constraint/cov_matrix_constrain.hpp
index f9ead70d76f..ec23cda3492 100644
--- a/stan/math/prim/constraint/cov_matrix_constrain.hpp
+++ b/stan/math/prim/constraint/cov_matrix_constrain.hpp
@@ -103,10 +103,9 @@ cov_matrix_constrain(T&& x, Eigen::Index K, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cov_matrix_constrain(T&& x, Eigen::Index K) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x), [K](auto&& v) {
-        return cov_matrix_constrain(std::forward<decltype(v)>(v), K);
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [K](auto&& v) {
+    return cov_matrix_constrain(std::forward<decltype(v)>(v), K);
+  });
 }
 
 /**
@@ -127,10 +126,9 @@ inline auto cov_matrix_constrain(T&& x, Eigen::Index K) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto cov_matrix_constrain(T&& x, Eigen::Index K, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x), [&lp, K](auto&& v) {
-        return cov_matrix_constrain(std::forward<decltype(v)>(v), K, lp);
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [&lp, K](auto&& v) {
+    return cov_matrix_constrain(std::forward<decltype(v)>(v), K, lp);
+  });
 }
 
 /**
diff --git a/stan/math/prim/constraint/cov_matrix_constrain_lkj.hpp b/stan/math/prim/constraint/cov_matrix_constrain_lkj.hpp
index 9b4cedef02c..798b930247f 100644
--- a/stan/math/prim/constraint/cov_matrix_constrain_lkj.hpp
+++ b/stan/math/prim/constraint/cov_matrix_constrain_lkj.hpp
@@ -114,11 +114,10 @@ inline auto cov_matrix_constrain_lkj(T&& x, size_t k, return_type_t<T>& lp) {
  */
 template <bool Jacobian, typename T, require_std_vector_t<T>* = nullptr>
 inline auto cov_matrix_constrain_lkj(T&& x, size_t k, return_type_t<T>& lp) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x), [&lp, k](auto&& v) {
-        return cov_matrix_constrain_lkj<Jacobian>(std::forward<decltype(v)>(v),
-                                                  k, lp);
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [&lp, k](auto&& v) {
+    return cov_matrix_constrain_lkj<Jacobian>(std::forward<decltype(v)>(v), k,
+                                              lp);
+  });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/cov_matrix_free.hpp b/stan/math/prim/constraint/cov_matrix_free.hpp
index 876adf3980e..360353180ef 100644
--- a/stan/math/prim/constraint/cov_matrix_free.hpp
+++ b/stan/math/prim/constraint/cov_matrix_free.hpp
@@ -67,9 +67,9 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cov_matrix_free(T&& y) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto cov_matrix_free(T&& x) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x),
-      [](auto&& v) { return cov_matrix_free(std::forward<decltype(v)>(v)); });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [](auto&& v) {
+    return cov_matrix_free(std::forward<decltype(v)>(v));
+  });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/cov_matrix_free_lkj.hpp b/stan/math/prim/constraint/cov_matrix_free_lkj.hpp
index fcf6768203b..fccc40a881a 100644
--- a/stan/math/prim/constraint/cov_matrix_free_lkj.hpp
+++ b/stan/math/prim/constraint/cov_matrix_free_lkj.hpp
@@ -39,8 +39,8 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cov_matrix_free_lkj(T&& y) {
   Eigen::Index k = y.rows();
   Eigen::Index k_choose_2 = (k * (k - 1)) / 2;
   Matrix<T_scalar, Dynamic, 1> x(k_choose_2 + k);
-  bool successful
-      = factor_cov_matrix(std::forward<T>(y), x.head(k_choose_2).array(), x.tail(k).array());
+  bool successful = factor_cov_matrix(
+      std::forward<T>(y), x.head(k_choose_2).array(), x.tail(k).array());
   if (!successful) {
     throw_domain_error("cov_matrix_free_lkj", "factor_cov_matrix failed on y",
                        "", "");
@@ -57,10 +57,9 @@ Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, 1> cov_matrix_free_lkj(T&& y) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 auto cov_matrix_free_lkj(T&& x) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x), [](auto&& v) {
-        return cov_matrix_free_lkj(std::forward<decltype(v)>(v));
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [](auto&& v) {
+    return cov_matrix_free_lkj(std::forward<decltype(v)>(v));
+  });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/offset_multiplier_constrain.hpp b/stan/math/prim/constraint/offset_multiplier_constrain.hpp
index a6e8f68d039..d417fd09325 100644
--- a/stan/math/prim/constraint/offset_multiplier_constrain.hpp
+++ b/stan/math/prim/constraint/offset_multiplier_constrain.hpp
@@ -49,7 +49,8 @@ inline auto offset_multiplier_constrain(T&& x, M&& mu, S&& sigma) {
     check_matching_dims("offset_multiplier_constrain", "x", x, "mu", mu_ref);
   }
   if (is_matrix<T>::value && is_matrix<S>::value) {
-    check_matching_dims("offset_multiplier_constrain", "x", x, "sigma", sigma_ref);
+    check_matching_dims("offset_multiplier_constrain", "x", x, "sigma",
+                        sigma_ref);
   } else if (is_matrix<M>::value && is_matrix<S>::value) {
     check_matching_dims("offset_multiplier_constrain", "mu", mu_ref, "sigma",
                         sigma_ref);
@@ -59,7 +60,8 @@ inline auto offset_multiplier_constrain(T&& x, M&& mu, S&& sigma) {
   check_positive_finite("offset_multiplier_constrain", "multiplier",
                         value_of_rec(sigma_ref));
   return stan::math::eval(fma(std::forward<decltype(sigma_ref)>(sigma_ref),
-    std::forward<T>(x), std::forward<decltype(mu_ref)>(mu_ref)));
+                              std::forward<T>(x),
+                              std::forward<decltype(mu_ref)>(mu_ref)));
 }
 
 /**
@@ -115,7 +117,8 @@ inline auto offset_multiplier_constrain(T&& x, M&& mu, S&& sigma, Lp& lp) {
     lp += sum(log(sigma_ref));
   }
   return stan::math::eval(fma(std::forward<decltype(sigma_ref)>(sigma_ref),
-    std::forward<T>(x), std::forward<decltype(mu_ref)>(mu_ref)));
+                              std::forward<T>(x),
+                              std::forward<decltype(mu_ref)>(mu_ref)));
 }
 
 /**
diff --git a/stan/math/prim/constraint/offset_multiplier_free.hpp b/stan/math/prim/constraint/offset_multiplier_free.hpp
index 4bfc6acd12d..01a61fc4c9f 100644
--- a/stan/math/prim/constraint/offset_multiplier_free.hpp
+++ b/stan/math/prim/constraint/offset_multiplier_free.hpp
@@ -48,7 +48,8 @@ inline auto offset_multiplier_free(T&& y, M&& mu, S&& sigma) {
     check_matching_dims("offset_multiplier_constrain", "y", y, "mu", mu_ref);
   }
   if constexpr (is_matrix<T>::value && is_matrix<S>::value) {
-    check_matching_dims("offset_multiplier_constrain", "y", y, "sigma", sigma_ref);
+    check_matching_dims("offset_multiplier_constrain", "y", y, "sigma",
+                        sigma_ref);
   } else if constexpr (is_matrix<M>::value && is_matrix<S>::value) {
     check_matching_dims("offset_multiplier_constrain", "mu", mu_ref, "sigma",
                         sigma_ref);
@@ -57,10 +58,9 @@ inline auto offset_multiplier_free(T&& y, M&& mu, S&& sigma) {
   check_finite("offset_multiplier_constrain", "offset", value_of(mu_ref));
   check_positive_finite("offset_multiplier_constrain", "multiplier",
                         value_of(sigma_ref));
-  return stan::math::eval(
-      divide(subtract(std::forward<T>(y),
-        std::forward<decltype(mu_ref)>(mu_ref)),
-        std::forward<decltype(sigma_ref)>(sigma_ref)));
+  return stan::math::eval(divide(
+      subtract(std::forward<T>(y), std::forward<decltype(mu_ref)>(mu_ref)),
+      std::forward<decltype(sigma_ref)>(sigma_ref)));
 }
 
 /**
diff --git a/stan/math/prim/constraint/ordered_constrain.hpp b/stan/math/prim/constraint/ordered_constrain.hpp
index e585c523e25..d88f87630f7 100644
--- a/stan/math/prim/constraint/ordered_constrain.hpp
+++ b/stan/math/prim/constraint/ordered_constrain.hpp
@@ -77,9 +77,9 @@ inline auto ordered_constrain(EigVec&& x, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto ordered_constrain(T&& x) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x),
-      [](auto&& v) { return ordered_constrain(std::forward<decltype(v)>(v)); });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [](auto&& v) {
+    return ordered_constrain(std::forward<decltype(v)>(v));
+  });
 }
 
 /**
@@ -100,10 +100,9 @@ inline auto ordered_constrain(T&& x) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto ordered_constrain(T&& x, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x), [&lp](auto&& v) {
-        return ordered_constrain(std::forward<decltype(v)>(v), lp);
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [&lp](auto&& v) {
+    return ordered_constrain(std::forward<decltype(v)>(v), lp);
+  });
 }
 
 /**
diff --git a/stan/math/prim/constraint/ordered_free.hpp b/stan/math/prim/constraint/ordered_free.hpp
index f06db3693d7..03058fb57cf 100644
--- a/stan/math/prim/constraint/ordered_free.hpp
+++ b/stan/math/prim/constraint/ordered_free.hpp
@@ -50,9 +50,9 @@ plain_type_t<EigVec> ordered_free(const EigVec& y) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto ordered_free(T&& x) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x),
-      [](auto&& v) { return ordered_free(std::forward<decltype(v)>(v)); });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [](auto&& v) {
+    return ordered_free(std::forward<decltype(v)>(v));
+  });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/positive_constrain.hpp b/stan/math/prim/constraint/positive_constrain.hpp
index 7551f8afb76..dcdec38b7a2 100644
--- a/stan/math/prim/constraint/positive_constrain.hpp
+++ b/stan/math/prim/constraint/positive_constrain.hpp
@@ -96,10 +96,9 @@ template <bool Jacobian, typename T, typename Lp,
           require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto positive_constrain(T&& x, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x), [&lp](auto&& v) {
-        return positive_constrain<Jacobian>(std::forward<decltype(v)>(v), lp);
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [&lp](auto&& v) {
+    return positive_constrain<Jacobian>(std::forward<decltype(v)>(v), lp);
+  });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/positive_ordered_constrain.hpp b/stan/math/prim/constraint/positive_ordered_constrain.hpp
index dc517fcb91e..d0dcdbd1949 100644
--- a/stan/math/prim/constraint/positive_ordered_constrain.hpp
+++ b/stan/math/prim/constraint/positive_ordered_constrain.hpp
@@ -71,10 +71,9 @@ inline auto positive_ordered_constrain(Vec&& x, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto positive_ordered_constrain(T&& x) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x), [](auto&& v) {
-        return positive_ordered_constrain(std::forward<decltype(v)>(v));
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [](auto&& v) {
+    return positive_ordered_constrain(std::forward<decltype(v)>(v));
+  });
 }
 
 /**
@@ -94,10 +93,9 @@ inline auto positive_ordered_constrain(T&& x) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto positive_ordered_constrain(T&& x, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x), [&lp](auto&& v) {
-        return positive_ordered_constrain(std::forward<decltype(v)>(v), lp);
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [&lp](auto&& v) {
+    return positive_ordered_constrain(std::forward<decltype(v)>(v), lp);
+  });
 }
 
 /**
diff --git a/stan/math/prim/constraint/positive_ordered_free.hpp b/stan/math/prim/constraint/positive_ordered_free.hpp
index d2013ef4de8..face9f638e4 100644
--- a/stan/math/prim/constraint/positive_ordered_free.hpp
+++ b/stan/math/prim/constraint/positive_ordered_free.hpp
@@ -50,10 +50,9 @@ inline auto positive_ordered_free(const EigVec& y) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto positive_ordered_free(T&& x) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x), [](auto&& v) {
-        return positive_ordered_free(std::forward<decltype(v)>(v));
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [](auto&& v) {
+    return positive_ordered_free(std::forward<decltype(v)>(v));
+  });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/simplex_constrain.hpp b/stan/math/prim/constraint/simplex_constrain.hpp
index 01dbabe93a4..d3a9c49834e 100644
--- a/stan/math/prim/constraint/simplex_constrain.hpp
+++ b/stan/math/prim/constraint/simplex_constrain.hpp
@@ -146,9 +146,9 @@ inline plain_type_t<Vec> simplex_constrain(const Vec& y, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto simplex_constrain(T&& y) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(y),
-      [](auto&& v) { return simplex_constrain(std::forward<decltype(v)>(v)); });
+  return apply_vector_unary<T>::apply(std::forward<T>(y), [](auto&& v) {
+    return simplex_constrain(std::forward<decltype(v)>(v));
+  });
 }
 
 /**
@@ -167,10 +167,9 @@ inline auto simplex_constrain(T&& y) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto simplex_constrain(T&& y, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(y), [&lp](auto&& v) {
-        return simplex_constrain(std::forward<decltype(v)>(v), lp);
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(y), [&lp](auto&& v) {
+    return simplex_constrain(std::forward<decltype(v)>(v), lp);
+  });
 }
 
 /**
diff --git a/stan/math/prim/constraint/simplex_free.hpp b/stan/math/prim/constraint/simplex_free.hpp
index 649212d9590..8a6340a0431 100644
--- a/stan/math/prim/constraint/simplex_free.hpp
+++ b/stan/math/prim/constraint/simplex_free.hpp
@@ -54,9 +54,9 @@ inline plain_type_t<Vec> simplex_free(const Vec& x) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto simplex_free(T&& x) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x),
-      [](auto&& v) { return simplex_free(std::forward<decltype(v)>(v)); });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [](auto&& v) {
+    return simplex_free(std::forward<decltype(v)>(v));
+  });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/stochastic_column_constrain.hpp b/stan/math/prim/constraint/stochastic_column_constrain.hpp
index 61cbbed193c..e1c7f0c0451 100644
--- a/stan/math/prim/constraint/stochastic_column_constrain.hpp
+++ b/stan/math/prim/constraint/stochastic_column_constrain.hpp
@@ -72,10 +72,9 @@ inline plain_type_t<Mat> stochastic_column_constrain(const Mat& y, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto stochastic_column_constrain(T&& y) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(y), [](auto&& v) {
-        return stochastic_column_constrain(std::forward<decltype(v)>(v));
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(y), [](auto&& v) {
+    return stochastic_column_constrain(std::forward<decltype(v)>(v));
+  });
 }
 
 /**
@@ -95,10 +94,9 @@ inline auto stochastic_column_constrain(T&& y) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto stochastic_column_constrain(T&& y, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(y), [&lp](auto&& v) {
-        return stochastic_column_constrain(std::forward<decltype(v)>(v), lp);
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(y), [&lp](auto&& v) {
+    return stochastic_column_constrain(std::forward<decltype(v)>(v), lp);
+  });
 }
 
 /**
diff --git a/stan/math/prim/constraint/stochastic_column_free.hpp b/stan/math/prim/constraint/stochastic_column_free.hpp
index 7be689e4f10..39d17042064 100644
--- a/stan/math/prim/constraint/stochastic_column_free.hpp
+++ b/stan/math/prim/constraint/stochastic_column_free.hpp
@@ -37,10 +37,9 @@ inline plain_type_t<Mat> stochastic_column_free(Mat&& y) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto stochastic_column_free(T&& y) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(y), [](auto&& v) {
-        return stochastic_column_free(std::forward<decltype(v)>(v));
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(y), [](auto&& v) {
+    return stochastic_column_free(std::forward<decltype(v)>(v));
+  });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/stochastic_row_constrain.hpp b/stan/math/prim/constraint/stochastic_row_constrain.hpp
index cda1ee27402..0b34bd25d7c 100644
--- a/stan/math/prim/constraint/stochastic_row_constrain.hpp
+++ b/stan/math/prim/constraint/stochastic_row_constrain.hpp
@@ -69,10 +69,9 @@ inline plain_type_t<Mat> stochastic_row_constrain(Mat&& y, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto stochastic_row_constrain(T&& y) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(y), [](auto&& v) {
-        return stochastic_row_constrain(std::forward<decltype(v)>(v));
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(y), [](auto&& v) {
+    return stochastic_row_constrain(std::forward<decltype(v)>(v));
+  });
 }
 
 /**
@@ -91,10 +90,9 @@ inline auto stochastic_row_constrain(T&& y) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto stochastic_row_constrain(T&& y, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(y), [&lp](auto&& v) {
-        return stochastic_row_constrain(std::forward<decltype(v)>(v), lp);
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(y), [&lp](auto&& v) {
+    return stochastic_row_constrain(std::forward<decltype(v)>(v), lp);
+  });
 }
 
 /**
diff --git a/stan/math/prim/constraint/stochastic_row_free.hpp b/stan/math/prim/constraint/stochastic_row_free.hpp
index 003bef0f47e..9934eeb10e0 100644
--- a/stan/math/prim/constraint/stochastic_row_free.hpp
+++ b/stan/math/prim/constraint/stochastic_row_free.hpp
@@ -36,10 +36,9 @@ inline plain_type_t<Mat> stochastic_row_free(Mat&& y) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto stochastic_row_free(T&& y) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(y), [](auto&& v) {
-        return stochastic_row_free(std::forward<decltype(v)>(v));
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(y), [](auto&& v) {
+    return stochastic_row_free(std::forward<decltype(v)>(v));
+  });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/sum_to_zero_constrain.hpp b/stan/math/prim/constraint/sum_to_zero_constrain.hpp
index d615aa3925c..2bd72669599 100644
--- a/stan/math/prim/constraint/sum_to_zero_constrain.hpp
+++ b/stan/math/prim/constraint/sum_to_zero_constrain.hpp
@@ -139,10 +139,9 @@ inline plain_type_t<T> sum_to_zero_constrain(T&& y, Lp& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto sum_to_zero_constrain(T&& y) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(y), [](auto&& v) {
-        return sum_to_zero_constrain(std::forward<decltype(v)>(v));
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(y), [](auto&& v) {
+    return sum_to_zero_constrain(std::forward<decltype(v)>(v));
+  });
 }
 
 /**
@@ -160,10 +159,9 @@ inline auto sum_to_zero_constrain(T&& y) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto sum_to_zero_constrain(T&& y, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(y), [&lp](auto&& v) {
-        return sum_to_zero_constrain(std::forward<decltype(v)>(v), lp);
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(y), [&lp](auto&& v) {
+    return sum_to_zero_constrain(std::forward<decltype(v)>(v), lp);
+  });
 }
 
 /**
diff --git a/stan/math/prim/constraint/sum_to_zero_free.hpp b/stan/math/prim/constraint/sum_to_zero_free.hpp
index 06340b8224f..b7c5e44e004 100644
--- a/stan/math/prim/constraint/sum_to_zero_free.hpp
+++ b/stan/math/prim/constraint/sum_to_zero_free.hpp
@@ -116,9 +116,9 @@ inline plain_type_t<Mat> sum_to_zero_free(const Mat& z) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto sum_to_zero_free(T&& z) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(z),
-      [](auto&& v) { return sum_to_zero_free(std::forward<decltype(v)>(v)); });
+  return apply_vector_unary<T>::apply(std::forward<T>(z), [](auto&& v) {
+    return sum_to_zero_free(std::forward<decltype(v)>(v));
+  });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/constraint/unit_vector_constrain.hpp b/stan/math/prim/constraint/unit_vector_constrain.hpp
index 66828e74fa9..3fcdd598166 100644
--- a/stan/math/prim/constraint/unit_vector_constrain.hpp
+++ b/stan/math/prim/constraint/unit_vector_constrain.hpp
@@ -30,9 +30,11 @@ inline auto unit_vector_constrain(T&& y) {
   auto&& y_ref = to_ref(std::forward<T>(y));
   value_type_t<T> SN = dot_self(y_ref);
   check_positive_finite("unit_vector_constrain", "norm", SN);
-  return make_holder([SN](auto&& y_) {
-    return std::forward<decltype(y_)>(y_).array() / sqrt(SN);
-  }, std::forward<decltype(y_ref)>(y_ref));
+  return make_holder(
+      [SN](auto&& y_) {
+        return std::forward<decltype(y_)>(y_).array() / sqrt(SN);
+      },
+      std::forward<decltype(y_ref)>(y_ref));
 }
 
 /**
@@ -55,9 +57,11 @@ inline auto unit_vector_constrain(T1&& y, T2& lp) {
   value_type_t<T1> SN = dot_self(y_ref);
   check_positive_finite("unit_vector_constrain", "norm", SN);
   lp -= 0.5 * SN;
-  return make_holder([SN](auto&& y_) {
-    return std::forward<decltype(y_)>(y_).array() / sqrt(SN);
-  }, std::forward<decltype(y_ref)>(y_ref));
+  return make_holder(
+      [SN](auto&& y_) {
+        return std::forward<decltype(y_)>(y_).array() / sqrt(SN);
+      },
+      std::forward<decltype(y_ref)>(y_ref));
 }
 /**
  * Return the unit length vector corresponding to the free vector y.
@@ -71,10 +75,9 @@ inline auto unit_vector_constrain(T1&& y, T2& lp) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto unit_vector_constrain(T&& y) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(y), [](auto&& v) {
-        return unit_vector_constrain(std::forward<decltype(v)>(v));
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(y), [](auto&& v) {
+    return unit_vector_constrain(std::forward<decltype(v)>(v));
+  });
 }
 
 /**
@@ -93,10 +96,9 @@ inline auto unit_vector_constrain(T&& y) {
 template <typename T, typename Lp, require_std_vector_t<T>* = nullptr,
           require_convertible_t<return_type_t<T>, Lp>* = nullptr>
 inline auto unit_vector_constrain(T&& y, Lp& lp) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(y), [&lp](auto&& v) {
-        return unit_vector_constrain(std::forward<decltype(v)>(v), lp);
-      });
+  return apply_vector_unary<T>::apply(std::forward<T>(y), [&lp](auto&& v) {
+    return unit_vector_constrain(std::forward<decltype(v)>(v), lp);
+  });
 }
 
 /**
diff --git a/stan/math/prim/constraint/unit_vector_free.hpp b/stan/math/prim/constraint/unit_vector_free.hpp
index c7df0615f29..01624e01a4e 100644
--- a/stan/math/prim/constraint/unit_vector_free.hpp
+++ b/stan/math/prim/constraint/unit_vector_free.hpp
@@ -37,9 +37,9 @@ inline auto unit_vector_free(EigVec&& x) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto unit_vector_free(T&& x) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x),
-      [](auto&& v) { return unit_vector_free(std::forward<decltype(v)>(v)); });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [](auto&& v) {
+    return unit_vector_free(std::forward<decltype(v)>(v));
+  });
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/Phi.hpp b/stan/math/prim/fun/Phi.hpp
index 9bde705db7e..ea2de28f896 100644
--- a/stan/math/prim/fun/Phi.hpp
+++ b/stan/math/prim/fun/Phi.hpp
@@ -52,7 +52,7 @@ inline double Phi(double x) {
 struct Phi_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return Phi(std::forward<T>(x));
+    return Phi(std::forward<T>(x));
   }
 };
 
@@ -66,8 +66,7 @@ struct Phi_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr,
-    require_container_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr, require_container_t<T>* = nullptr>
 inline auto Phi(T&& x) {
   return apply_scalar_unary<Phi_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/Phi_approx.hpp b/stan/math/prim/fun/Phi_approx.hpp
index 40fcad97711..5dd82dd85a9 100644
--- a/stan/math/prim/fun/Phi_approx.hpp
+++ b/stan/math/prim/fun/Phi_approx.hpp
@@ -48,7 +48,7 @@ struct Phi_approx_fun {
    */
   template <typename T>
   static inline auto fun(T&& x) {
-  return Phi_approx(std::forward<T>(x));
+    return Phi_approx(std::forward<T>(x));
   }
 };
 
@@ -65,8 +65,7 @@ struct Phi_approx_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr,
-    require_container_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr, require_container_t<T>* = nullptr>
 inline auto Phi_approx(T&& x) {
   return apply_scalar_unary<Phi_approx_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/abs.hpp b/stan/math/prim/fun/abs.hpp
index 25f491b9987..9d91fd19f4c 100644
--- a/stan/math/prim/fun/abs.hpp
+++ b/stan/math/prim/fun/abs.hpp
@@ -50,7 +50,7 @@ inline auto abs(T x) {
 struct abs_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return abs(std::forward<T>(x));
+    return abs(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/acos.hpp b/stan/math/prim/fun/acos.hpp
index e58b99e6c8e..57644a690e2 100644
--- a/stan/math/prim/fun/acos.hpp
+++ b/stan/math/prim/fun/acos.hpp
@@ -52,7 +52,7 @@ inline auto acos(const T x) {
 struct acos_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return acos(std::forward<T>(x));
+    return acos(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/acosh.hpp b/stan/math/prim/fun/acosh.hpp
index 3bef060a729..28a10719326 100644
--- a/stan/math/prim/fun/acosh.hpp
+++ b/stan/math/prim/fun/acosh.hpp
@@ -63,7 +63,7 @@ struct acosh_fun {
    */
   template <typename T>
   static inline auto fun(T&& x) {
-  return acosh(std::forward<T>(x));
+    return acosh(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/add.hpp b/stan/math/prim/fun/add.hpp
index e2dac0258de..4433baca56d 100644
--- a/stan/math/prim/fun/add.hpp
+++ b/stan/math/prim/fun/add.hpp
@@ -42,10 +42,12 @@ template <typename Mat1, typename Mat2,
           require_all_not_st_var<Mat1, Mat2>* = nullptr>
 inline auto add(Mat1&& m1, Mat2&& m2) {
   check_matching_dims("add", "m1", m1, "m2", m2);
-  return make_holder([](auto&& m1_, auto&& m2_) {
-    return std::forward<decltype(m1_)>(m1_)
-           + std::forward<decltype(m2_)>(m2_);
-  }, std::forward<Mat1>(m1), std::forward<Mat2>(m2));
+  return make_holder(
+      [](auto&& m1_, auto&& m2_) {
+        return std::forward<decltype(m1_)>(m1_)
+               + std::forward<decltype(m2_)>(m2_);
+      },
+      std::forward<Mat1>(m1), std::forward<Mat2>(m2));
 }
 
 /**
@@ -61,9 +63,11 @@ template <typename Mat, typename Scal, require_eigen_t<Mat>* = nullptr,
           require_stan_scalar_t<Scal>* = nullptr,
           require_all_not_st_var<Mat, Scal>* = nullptr>
 inline auto add(Mat&& m, const Scal c) {
-  return make_holder([c](auto&& m_) {
-    return (std::forward<decltype(m_)>(m_).array() + c).matrix();
-  }, std::forward<Mat>(m));
+  return make_holder(
+      [c](auto&& m_) {
+        return (std::forward<decltype(m_)>(m_).array() + c).matrix();
+      },
+      std::forward<Mat>(m));
 }
 
 /**
@@ -79,9 +83,11 @@ template <typename Scal, typename Mat, require_stan_scalar_t<Scal>* = nullptr,
           require_eigen_t<Mat>* = nullptr,
           require_all_not_st_var<Scal, Mat>* = nullptr>
 inline auto add(const Scal c, Mat&& m) {
-  return make_holder([c](auto&& m_) {
-    return (c + std::forward<decltype(m_)>(m_).array()).matrix();
-  }, std::forward<Mat>(m));
+  return make_holder(
+      [c](auto&& m_) {
+        return (c + std::forward<decltype(m_)>(m_).array()).matrix();
+      },
+      std::forward<Mat>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/asin.hpp b/stan/math/prim/fun/asin.hpp
index 43ed5b1c3c0..fd06356cb0f 100644
--- a/stan/math/prim/fun/asin.hpp
+++ b/stan/math/prim/fun/asin.hpp
@@ -50,7 +50,7 @@ inline auto asin(const T x) {
 struct asin_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return asin(std::forward<T>(x));
+    return asin(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/asinh.hpp b/stan/math/prim/fun/asinh.hpp
index 7991ed169bc..32089403e8b 100644
--- a/stan/math/prim/fun/asinh.hpp
+++ b/stan/math/prim/fun/asinh.hpp
@@ -53,7 +53,7 @@ inline auto asinh(const T x) {
 struct asinh_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return asinh(std::forward<T>(x));
+    return asinh(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/atan.hpp b/stan/math/prim/fun/atan.hpp
index 9b422a07f58..497a024d39e 100644
--- a/stan/math/prim/fun/atan.hpp
+++ b/stan/math/prim/fun/atan.hpp
@@ -48,7 +48,7 @@ inline auto atan(const T x) {
 struct atan_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return atan(std::forward<T>(x));
+    return atan(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/atanh.hpp b/stan/math/prim/fun/atanh.hpp
index 5bde533c2ee..616a381ba72 100644
--- a/stan/math/prim/fun/atanh.hpp
+++ b/stan/math/prim/fun/atanh.hpp
@@ -62,7 +62,7 @@ struct atanh_fun {
    */
   template <typename T>
   static inline auto fun(T&& x) {
-  return atanh(std::forward<T>(x));
+    return atanh(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/block.hpp b/stan/math/prim/fun/block.hpp
index b39c3e85418..936de76522f 100644
--- a/stan/math/prim/fun/block.hpp
+++ b/stan/math/prim/fun/block.hpp
@@ -24,9 +24,11 @@ inline auto block(T&& m, size_t i, size_t j, size_t nrows, size_t ncols) {
   check_row_index("block", "i+nrows-1", m, i + nrows - 1);
   check_column_index("block", "j", m, j);
   check_column_index("block", "j+ncols-1", m, j + ncols - 1);
-  return make_holder([i, j, nrows, ncols](auto&& m_) {
-    return std::forward<decltype(m_)>(m_).block(i - 1, j - 1, nrows, ncols);
-  }, std::forward<T>(m));
+  return make_holder(
+      [i, j, nrows, ncols](auto&& m_) {
+        return std::forward<decltype(m_)>(m_).block(i - 1, j - 1, nrows, ncols);
+      },
+      std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/ceil.hpp b/stan/math/prim/fun/ceil.hpp
index ff0dd584f6b..612ad29fd1e 100644
--- a/stan/math/prim/fun/ceil.hpp
+++ b/stan/math/prim/fun/ceil.hpp
@@ -15,7 +15,6 @@ inline auto ceil(T x) {
   return std::ceil(x);
 }
 
-
 /**
  * Structure to wrap `ceil()` so it can be vectorized.
  *
@@ -42,7 +41,7 @@ template <typename Container,
           require_not_container_st<std::is_arithmetic, Container>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               Container>* = nullptr,
-              require_container_t<Container>* = nullptr>
+          require_container_t<Container>* = nullptr>
 inline auto ceil(Container&& x) {
   return apply_scalar_unary<ceil_fun, Container>::apply(
       std::forward<Container>(x));
diff --git a/stan/math/prim/fun/cos.hpp b/stan/math/prim/fun/cos.hpp
index f35f14a44c3..e7067f6d092 100644
--- a/stan/math/prim/fun/cos.hpp
+++ b/stan/math/prim/fun/cos.hpp
@@ -47,7 +47,7 @@ inline auto cos(const T x) {
 struct cos_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return cos(std::forward<T>(x));
+    return cos(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/cosh.hpp b/stan/math/prim/fun/cosh.hpp
index 5610acff36b..59f305adb65 100644
--- a/stan/math/prim/fun/cosh.hpp
+++ b/stan/math/prim/fun/cosh.hpp
@@ -46,7 +46,7 @@ inline auto cosh(const T x) {
 struct cosh_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return cosh(std::forward<T>(x));
+    return cosh(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/determinant.hpp b/stan/math/prim/fun/determinant.hpp
index 5661892031b..851ce460c92 100644
--- a/stan/math/prim/fun/determinant.hpp
+++ b/stan/math/prim/fun/determinant.hpp
@@ -20,9 +20,8 @@ namespace math {
 template <typename T, require_eigen_vt<std::is_arithmetic, T>* = nullptr>
 inline value_type_t<T> determinant(T&& m) {
   check_square("determinant", "m", m);
-  return make_holder([](auto&& m_){
-    return m_.determinant();
-  }, std::forward<T>(m));
+  return make_holder([](auto&& m_) { return m_.determinant(); },
+                     std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/diagonal.hpp b/stan/math/prim/fun/diagonal.hpp
index 4965893e1ad..7e22d87ad43 100644
--- a/stan/math/prim/fun/diagonal.hpp
+++ b/stan/math/prim/fun/diagonal.hpp
@@ -17,9 +17,9 @@ namespace math {
  */
 template <typename T, require_matrix_t<T>* = nullptr>
 inline auto diagonal(T&& m) {
-  return make_holder([](auto&& m_) {
-    return std::forward<decltype(m_)>(m_).diagonal();
-  }, std::forward<T>(m));
+  return make_holder(
+      [](auto&& m_) { return std::forward<decltype(m_)>(m_).diagonal(); },
+      std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/dot_self.hpp b/stan/math/prim/fun/dot_self.hpp
index d84790ef809..1ac13c8ffda 100644
--- a/stan/math/prim/fun/dot_self.hpp
+++ b/stan/math/prim/fun/dot_self.hpp
@@ -33,9 +33,8 @@ inline double dot_self(const std::vector<double>& x) {
 template <typename T, require_eigen_t<T>* = nullptr,
           require_not_eigen_vt<is_var, T>* = nullptr>
 inline value_type_t<T> dot_self(T&& v) {
-  return make_holder([](auto&& v_) {
-    return v_.squaredNorm();
-  }, std::forward<T>(v));
+  return make_holder([](auto&& v_) { return v_.squaredNorm(); },
+                     std::forward<T>(v));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/erf.hpp b/stan/math/prim/fun/erf.hpp
index 00a37e6d8d4..e0e40a93cd7 100644
--- a/stan/math/prim/fun/erf.hpp
+++ b/stan/math/prim/fun/erf.hpp
@@ -38,8 +38,7 @@ struct erf_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr,
-    require_container_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr, require_container_t<T>* = nullptr>
 inline auto erf(T&& x) {
   return apply_scalar_unary<erf_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/erfc.hpp b/stan/math/prim/fun/erfc.hpp
index d46a61e9f97..fdc2f419bb4 100644
--- a/stan/math/prim/fun/erfc.hpp
+++ b/stan/math/prim/fun/erfc.hpp
@@ -39,8 +39,7 @@ struct erfc_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr,
-    require_container_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr, require_container_t<T>* = nullptr>
 inline auto erfc(T&& x) {
   return apply_scalar_unary<erfc_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/exp.hpp b/stan/math/prim/fun/exp.hpp
index 824d673c204..e3fe876d7e5 100644
--- a/stan/math/prim/fun/exp.hpp
+++ b/stan/math/prim/fun/exp.hpp
@@ -54,7 +54,7 @@ struct exp_fun {
    */
   template <typename T>
   static inline auto fun(T&& x) {
-  return exp(std::forward<T>(x));
+    return exp(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/exp2.hpp b/stan/math/prim/fun/exp2.hpp
index 378cf378b8f..ee61b7dc684 100644
--- a/stan/math/prim/fun/exp2.hpp
+++ b/stan/math/prim/fun/exp2.hpp
@@ -13,7 +13,6 @@ inline auto exp2(T x) {
   return std::exp2(x);
 }
 
-
 /**
  * Structure to wrap `exp2()` so it can be vectorized.
  */
@@ -43,8 +42,7 @@ struct exp2_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr,
-    require_container_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr, require_container_t<T>* = nullptr>
 inline auto exp2(T&& x) {
   return apply_scalar_unary<exp2_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/expm1.hpp b/stan/math/prim/fun/expm1.hpp
index 89c12fc8b8f..da367400991 100644
--- a/stan/math/prim/fun/expm1.hpp
+++ b/stan/math/prim/fun/expm1.hpp
@@ -39,8 +39,7 @@ struct expm1_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr,
-    require_container_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr, require_container_t<T>* = nullptr>
 inline auto expm1(T&& x) {
   return apply_scalar_unary<expm1_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/fabs.hpp b/stan/math/prim/fun/fabs.hpp
index dc6e33eff7b..b41fece9fa3 100644
--- a/stan/math/prim/fun/fabs.hpp
+++ b/stan/math/prim/fun/fabs.hpp
@@ -30,7 +30,7 @@ inline auto fabs(T x) {
 struct fabs_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return fabs(std::forward<T>(x));
+    return fabs(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/floor.hpp b/stan/math/prim/fun/floor.hpp
index 888c9d7c0ca..3ca7398986d 100644
--- a/stan/math/prim/fun/floor.hpp
+++ b/stan/math/prim/fun/floor.hpp
@@ -29,7 +29,7 @@ inline auto floor(const T x) {
 struct floor_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return floor(std::forward<T>(x));
+    return floor(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/inv.hpp b/stan/math/prim/fun/inv.hpp
index d57a5bb7668..016e884fd7e 100644
--- a/stan/math/prim/fun/inv.hpp
+++ b/stan/math/prim/fun/inv.hpp
@@ -9,9 +9,7 @@
 namespace stan {
 namespace math {
 
-inline double inv(double x) {
-  return 1.0 / x;
-}
+inline double inv(double x) { return 1.0 / x; }
 
 /**
  * Structure to wrap 1.0 / x so that it can be vectorized.
diff --git a/stan/math/prim/fun/inv_Phi.hpp b/stan/math/prim/fun/inv_Phi.hpp
index fa14d612633..ed6f12e2c19 100644
--- a/stan/math/prim/fun/inv_Phi.hpp
+++ b/stan/math/prim/fun/inv_Phi.hpp
@@ -161,7 +161,7 @@ inline double inv_Phi(double p) {
 struct inv_Phi_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return inv_Phi(std::forward<T>(x));
+    return inv_Phi(std::forward<T>(x));
   }
 };
 
@@ -176,8 +176,7 @@ struct inv_Phi_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr,
-    require_container_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr, require_container_t<T>* = nullptr>
 inline auto inv_Phi(T&& x) {
   return apply_scalar_unary<inv_Phi_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/inv_cloglog.hpp b/stan/math/prim/fun/inv_cloglog.hpp
index 4b0cc7ce374..e021472a417 100644
--- a/stan/math/prim/fun/inv_cloglog.hpp
+++ b/stan/math/prim/fun/inv_cloglog.hpp
@@ -78,7 +78,7 @@ inline auto inv_cloglog(const T& x) {
 struct inv_cloglog_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return inv_cloglog(std::forward<T>(x));
+    return inv_cloglog(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/inv_erfc.hpp b/stan/math/prim/fun/inv_erfc.hpp
index e7f70cd744a..2893534b275 100644
--- a/stan/math/prim/fun/inv_erfc.hpp
+++ b/stan/math/prim/fun/inv_erfc.hpp
@@ -31,7 +31,7 @@ inline auto inv_erfc(const T& x) {
 struct inv_erfc_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return inv_erfc(std::forward<T>(x));
+    return inv_erfc(std::forward<T>(x));
   }
 };
 
@@ -47,8 +47,7 @@ template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
     require_not_var_matrix_t<T>* = nullptr,
-    require_not_arithmetic_t<T>* = nullptr,
-    require_container_t<T>* = nullptr>
+    require_not_arithmetic_t<T>* = nullptr, require_container_t<T>* = nullptr>
 inline auto inv_erfc(T&& x) {
   return apply_scalar_unary<inv_erfc_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/inv_sqrt.hpp b/stan/math/prim/fun/inv_sqrt.hpp
index c3a4f4d9bec..d57fb76b367 100644
--- a/stan/math/prim/fun/inv_sqrt.hpp
+++ b/stan/math/prim/fun/inv_sqrt.hpp
@@ -32,7 +32,7 @@ inline auto inv_sqrt(const T x) {
 struct inv_sqrt_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return inv_sqrt(std::forward<T>(x));
+    return inv_sqrt(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/inv_square.hpp b/stan/math/prim/fun/inv_square.hpp
index 84faf162519..e3664f0e75b 100644
--- a/stan/math/prim/fun/inv_square.hpp
+++ b/stan/math/prim/fun/inv_square.hpp
@@ -25,7 +25,7 @@ template <typename Container,
           require_not_container_st<std::is_arithmetic, Container>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               Container>* = nullptr,
-              require_not_stan_scalar_t<Container>* = nullptr>
+          require_not_stan_scalar_t<Container>* = nullptr>
 inline auto inv_square(Container&& x) {
   return inv(square(std::forward<Container>(x)));
 }
diff --git a/stan/math/prim/fun/lambert_w.hpp b/stan/math/prim/fun/lambert_w.hpp
index d83d1a5ec50..bd89070eb6e 100644
--- a/stan/math/prim/fun/lambert_w.hpp
+++ b/stan/math/prim/fun/lambert_w.hpp
@@ -49,7 +49,7 @@ namespace internal {
 struct lambert_w0_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return lambert_w0(std::forward<T>(x));
+    return lambert_w0(std::forward<T>(x));
   }
 };
 
@@ -65,7 +65,7 @@ struct lambert_w0_fun {
 struct lambert_wm1_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return lambert_wm1(std::forward<T>(x));
+    return lambert_wm1(std::forward<T>(x));
   }
 };
 }  // namespace internal
diff --git a/stan/math/prim/fun/lgamma.hpp b/stan/math/prim/fun/lgamma.hpp
index a29e2b7f79e..7b37c5535b0 100644
--- a/stan/math/prim/fun/lgamma.hpp
+++ b/stan/math/prim/fun/lgamma.hpp
@@ -101,7 +101,7 @@ inline double lgamma(int x) {
 struct lgamma_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return lgamma(std::forward<T>(x));
+    return lgamma(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/log.hpp b/stan/math/prim/fun/log.hpp
index 2c3a0d331a1..99e36c84025 100644
--- a/stan/math/prim/fun/log.hpp
+++ b/stan/math/prim/fun/log.hpp
@@ -53,7 +53,7 @@ struct log_fun {
    */
   template <typename T>
   static inline auto fun(T&& x) {
-  return log(std::forward<T>(x));
+    return log(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/log10.hpp b/stan/math/prim/fun/log10.hpp
index e8a5c81bed5..7e827137247 100644
--- a/stan/math/prim/fun/log10.hpp
+++ b/stan/math/prim/fun/log10.hpp
@@ -46,7 +46,7 @@ inline auto log10(const T x) {
 struct log10_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return log10(std::forward<T>(x));
+    return log10(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/log1m.hpp b/stan/math/prim/fun/log1m.hpp
index ea6ffa75e30..d19201cde04 100644
--- a/stan/math/prim/fun/log1m.hpp
+++ b/stan/math/prim/fun/log1m.hpp
@@ -56,7 +56,7 @@ inline double log1m(double x) {
 struct log1m_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return log1m(std::forward<T>(x));
+    return log1m(std::forward<T>(x));
   }
 };
 
@@ -70,7 +70,7 @@ struct log1m_fun {
 template <
     typename T, require_not_var_matrix_t<T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-          require_container_t<T>* = nullptr>
+    require_container_t<T>* = nullptr>
 inline auto log1m(T&& x) {
   return apply_scalar_unary<log1m_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/log1m_exp.hpp b/stan/math/prim/fun/log1m_exp.hpp
index d118ebf5d2f..69d9d1156c7 100644
--- a/stan/math/prim/fun/log1m_exp.hpp
+++ b/stan/math/prim/fun/log1m_exp.hpp
@@ -66,7 +66,7 @@ inline double log1m_exp(double a) {
 struct log1m_exp_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return log1m_exp(std::forward<T>(x));
+    return log1m_exp(std::forward<T>(x));
   }
 };
 
@@ -80,7 +80,7 @@ struct log1m_exp_fun {
 template <
     typename T, require_not_var_matrix_t<T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-          require_container_t<T>* = nullptr>
+    require_container_t<T>* = nullptr>
 inline auto log1m_exp(T&& x) {
   return apply_scalar_unary<log1m_exp_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/log1p.hpp b/stan/math/prim/fun/log1p.hpp
index 1d95b9d41b6..be59b8d2958 100644
--- a/stan/math/prim/fun/log1p.hpp
+++ b/stan/math/prim/fun/log1p.hpp
@@ -62,7 +62,7 @@ struct log1p_fun {
    */
   template <typename T>
   static inline auto fun(T&& x) {
-  return log1p(std::forward<T>(x));
+    return log1p(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/log1p_exp.hpp b/stan/math/prim/fun/log1p_exp.hpp
index e7f49011dcd..38c80bf4581 100644
--- a/stan/math/prim/fun/log1p_exp.hpp
+++ b/stan/math/prim/fun/log1p_exp.hpp
@@ -61,7 +61,7 @@ inline double log1p_exp(double a) {
 struct log1p_exp_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return log1p_exp(std::forward<T>(x));
+    return log1p_exp(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/log_inv_logit.hpp b/stan/math/prim/fun/log_inv_logit.hpp
index 4aebb384535..bf2fd125a03 100644
--- a/stan/math/prim/fun/log_inv_logit.hpp
+++ b/stan/math/prim/fun/log_inv_logit.hpp
@@ -64,7 +64,7 @@ struct log_inv_logit_fun {
    */
   template <typename T>
   static inline auto fun(T&& x) {
-  return log_inv_logit(std::forward<T>(x));
+    return log_inv_logit(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/logit.hpp b/stan/math/prim/fun/logit.hpp
index dfafa6daf22..4288f23e054 100644
--- a/stan/math/prim/fun/logit.hpp
+++ b/stan/math/prim/fun/logit.hpp
@@ -72,7 +72,7 @@ struct logit_fun {
    */
   template <typename T>
   static inline auto fun(T&& x) {
-  return logit(std::forward<T>(x));
+    return logit(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/mdivide_left.hpp b/stan/math/prim/fun/mdivide_left.hpp
index 8441b855bd3..0d6b8cb83eb 100644
--- a/stan/math/prim/fun/mdivide_left.hpp
+++ b/stan/math/prim/fun/mdivide_left.hpp
@@ -31,11 +31,14 @@ mdivide_left(T1&& A, T2&& b) {
     return {0, b.cols()};
   }
 
-  return Eigen::Matrix<return_type_t<T1, T2>, std::decay_t<T1>::RowsAtCompileTime,
+  return Eigen::Matrix<return_type_t<T1, T2>,
+                       std::decay_t<T1>::RowsAtCompileTime,
                        std::decay_t<T1>::ColsAtCompileTime>(std::forward<T1>(A))
       .lu()
-      .solve(Eigen::Matrix<return_type_t<T1, T2>, std::decay_t<T2>::RowsAtCompileTime,
-                           std::decay_t<T2>::ColsAtCompileTime>(std::forward<T2>(b)));
+      .solve(Eigen::Matrix<return_type_t<T1, T2>,
+                           std::decay_t<T2>::RowsAtCompileTime,
+                           std::decay_t<T2>::ColsAtCompileTime>(
+          std::forward<T2>(b)));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/mdivide_left_ldlt.hpp b/stan/math/prim/fun/mdivide_left_ldlt.hpp
index e0c75e5d342..c007ba8919e 100644
--- a/stan/math/prim/fun/mdivide_left_ldlt.hpp
+++ b/stan/math/prim/fun/mdivide_left_ldlt.hpp
@@ -34,9 +34,10 @@ mdivide_left_ldlt(LDLT_factor<T>& A, EigMat&& b) {
     return {0, b.cols()};
   }
 
-  return A.ldlt().solve(
-      Eigen::Matrix<return_type_t<T, EigMat>, std::decay_t<EigMat>::RowsAtCompileTime,
-                    std::decay_t<EigMat>::ColsAtCompileTime>(std::forward<EigMat>(b)));
+  return A.ldlt().solve(Eigen::Matrix<return_type_t<T, EigMat>,
+                                      std::decay_t<EigMat>::RowsAtCompileTime,
+                                      std::decay_t<EigMat>::ColsAtCompileTime>(
+      std::forward<EigMat>(b)));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/mdivide_left_spd.hpp b/stan/math/prim/fun/mdivide_left_spd.hpp
index 88a8e02a84c..d6d27f4274a 100644
--- a/stan/math/prim/fun/mdivide_left_spd.hpp
+++ b/stan/math/prim/fun/mdivide_left_spd.hpp
@@ -26,7 +26,8 @@ template <typename EigMat1, typename EigMat2,
           require_all_eigen_t<EigMat1, EigMat2>* = nullptr,
           require_all_not_vt_var<EigMat1, EigMat2>* = nullptr>
 inline Eigen::Matrix<return_type_t<EigMat1, EigMat2>,
-                     std::decay_t<EigMat1>::RowsAtCompileTime, std::decay_t<EigMat2>::ColsAtCompileTime>
+                     std::decay_t<EigMat1>::RowsAtCompileTime,
+                     std::decay_t<EigMat2>::ColsAtCompileTime>
 mdivide_left_spd(EigMat1&& A, EigMat2&& b) {
   static constexpr const char* function = "mdivide_left_spd";
   check_multiplicable(function, "A", A, "b", b);
@@ -37,14 +38,17 @@ mdivide_left_spd(EigMat1&& A, EigMat2&& b) {
     return {0, b.cols()};
   }
 
-  auto llt
-      = Eigen::Matrix<return_type_t<EigMat1, EigMat2>,
-                      std::decay_t<EigMat1>::RowsAtCompileTime, std::decay_t<EigMat1>::ColsAtCompileTime>(
-            std::forward<decltype(A_ref)>(A_ref)).llt();
+  auto llt = Eigen::Matrix<return_type_t<EigMat1, EigMat2>,
+                           std::decay_t<EigMat1>::RowsAtCompileTime,
+                           std::decay_t<EigMat1>::ColsAtCompileTime>(
+                 std::forward<decltype(A_ref)>(A_ref))
+                 .llt();
   check_pos_definite(function, "A", llt);
   return std::move(llt).solve(
-      Eigen::Matrix<return_type_t<EigMat1, EigMat2>, std::decay_t<EigMat2>::RowsAtCompileTime,
-                    std::decay_t<EigMat2>::ColsAtCompileTime>(std::forward<EigMat2>(b)));
+      Eigen::Matrix<return_type_t<EigMat1, EigMat2>,
+                    std::decay_t<EigMat2>::RowsAtCompileTime,
+                    std::decay_t<EigMat2>::ColsAtCompileTime>(
+          std::forward<EigMat2>(b)));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/mdivide_left_tri.hpp b/stan/math/prim/fun/mdivide_left_tri.hpp
index 88085e6f211..65bf893333c 100644
--- a/stan/math/prim/fun/mdivide_left_tri.hpp
+++ b/stan/math/prim/fun/mdivide_left_tri.hpp
@@ -24,8 +24,8 @@ namespace math {
  * match the size of A.
  */
 template <Eigen::UpLoType TriView, typename T1, typename T2,
-          require_all_eigen_t<T1, T2> * = nullptr,
-          require_all_not_eigen_vt<is_var, T1, T2> * = nullptr>
+          require_all_eigen_t<T1, T2>* = nullptr,
+          require_all_not_eigen_vt<is_var, T1, T2>* = nullptr>
 inline auto mdivide_left_tri(T1&& A, T2&& b) {
   using T_return = return_type_t<T1, T2>;
   using ret_type = Eigen::Matrix<T_return, Eigen::Dynamic, Eigen::Dynamic>;
@@ -49,7 +49,7 @@ inline auto mdivide_left_tri(T1&& A, T2&& b) {
  * @return x = A^-1 .
  * @throws std::domain_error if A is not square
  */
-template <Eigen::UpLoType TriView, typename T, require_eigen_t<T> * = nullptr>
+template <Eigen::UpLoType TriView, typename T, require_eigen_t<T>* = nullptr>
 inline plain_type_t<T> mdivide_left_tri(T&& A) {
   check_square("mdivide_left_tri", "A", A);
   if (A.rows() == 0) {
diff --git a/stan/math/prim/fun/mdivide_left_tri_low.hpp b/stan/math/prim/fun/mdivide_left_tri_low.hpp
index 1eaeebf6ca7..8f7c43f0394 100644
--- a/stan/math/prim/fun/mdivide_left_tri_low.hpp
+++ b/stan/math/prim/fun/mdivide_left_tri_low.hpp
@@ -36,7 +36,8 @@ mdivide_left_tri_low(T1&& A, T2&& b) {
   if (A.rows() == 0) {
     return {0, b.cols()};
   }
-  return mdivide_left_tri<Eigen::Lower>(std::forward<T1>(A), std::forward<T2>(b));
+  return mdivide_left_tri<Eigen::Lower>(std::forward<T1>(A),
+                                        std::forward<T2>(b));
 }
 
 template <typename T, require_eigen_t<T>* = nullptr,
diff --git a/stan/math/prim/fun/mdivide_right.hpp b/stan/math/prim/fun/mdivide_right.hpp
index e0febad43c3..33384296c14 100644
--- a/stan/math/prim/fun/mdivide_right.hpp
+++ b/stan/math/prim/fun/mdivide_right.hpp
@@ -24,7 +24,8 @@ template <typename EigMat1, typename EigMat2,
           require_all_eigen_t<EigMat1, EigMat2>* = nullptr,
           require_all_not_vt_fvar<EigMat1, EigMat2>* = nullptr>
 inline Eigen::Matrix<return_type_t<EigMat1, EigMat2>,
-                     std::decay_t<EigMat1>::RowsAtCompileTime, std::decay_t<EigMat2>::ColsAtCompileTime>
+                     std::decay_t<EigMat1>::RowsAtCompileTime,
+                     std::decay_t<EigMat2>::ColsAtCompileTime>
 mdivide_right(EigMat1&& b, EigMat2&& A) {
   using T_return = return_type_t<EigMat1, EigMat2>;
   check_square("mdivide_right", "A", A);
@@ -33,10 +34,12 @@ mdivide_right(EigMat1&& b, EigMat2&& A) {
     return {b.rows(), 0};
   }
   return Eigen::Matrix<T_return, std::decay_t<EigMat2>::RowsAtCompileTime,
-                       std::decay_t<EigMat2>::ColsAtCompileTime>(std::forward<EigMat2>(A))
+                       std::decay_t<EigMat2>::ColsAtCompileTime>(
+             std::forward<EigMat2>(A))
       .transpose()
       .lu()
-      .solve(Eigen::Matrix<T_return, Eigen::Dynamic, Eigen::Dynamic>(std::forward<EigMat1>(b))
+      .solve(Eigen::Matrix<T_return, Eigen::Dynamic, Eigen::Dynamic>(
+                 std::forward<EigMat1>(b))
                  .transpose())
       .transpose();
 }
diff --git a/stan/math/prim/fun/mdivide_right_ldlt.hpp b/stan/math/prim/fun/mdivide_right_ldlt.hpp
index 5bc6855ba21..4d56be1b32c 100644
--- a/stan/math/prim/fun/mdivide_right_ldlt.hpp
+++ b/stan/math/prim/fun/mdivide_right_ldlt.hpp
@@ -28,7 +28,9 @@ inline auto mdivide_right_ldlt(EigMat&& b, LDLT_factor<T>& A) {
   check_multiplicable("mdivide_right_ldlt", "b", b, "A", A.matrix());
   check_ldlt_factor("mdivide_right_ldlt", "A", A);
 
-  return mdivide_left_ldlt(A, std::forward<EigMat>(b).transpose()).transpose().eval();
+  return mdivide_left_ldlt(A, std::forward<EigMat>(b).transpose())
+      .transpose()
+      .eval();
 }
 
 /**
@@ -47,7 +49,8 @@ inline auto mdivide_right_ldlt(EigMat&& b, LDLT_factor<T>& A) {
 template <typename EigMat, typename T,
           require_all_matrix_t<EigMat, T>* = nullptr,
           require_all_st_arithmetic<EigMat, T>* = nullptr>
-inline Eigen::Matrix<double, std::decay_t<EigMat>::RowsAtCompileTime, std::decay_t<T>::ColsAtCompileTime>
+inline Eigen::Matrix<double, std::decay_t<EigMat>::RowsAtCompileTime,
+                     std::decay_t<T>::ColsAtCompileTime>
 mdivide_right_ldlt(EigMat&& b, LDLT_factor<T>& A) {
   check_multiplicable("mdivide_right_ldlt", "b", b, "A", A.matrix());
   check_ldlt_factor("mdivide_right_ldlt", "A", A);
diff --git a/stan/math/prim/fun/mdivide_right_spd.hpp b/stan/math/prim/fun/mdivide_right_spd.hpp
index 3dfb604233d..d86e4f248f2 100644
--- a/stan/math/prim/fun/mdivide_right_spd.hpp
+++ b/stan/math/prim/fun/mdivide_right_spd.hpp
@@ -26,7 +26,8 @@ namespace math {
 template <typename EigMat1, typename EigMat2,
           require_all_eigen_t<EigMat1, EigMat2>* = nullptr>
 inline Eigen::Matrix<return_type_t<EigMat1, EigMat2>,
-                     std::decay_t<EigMat1>::RowsAtCompileTime, std::decay_t<EigMat2>::ColsAtCompileTime>
+                     std::decay_t<EigMat1>::RowsAtCompileTime,
+                     std::decay_t<EigMat2>::ColsAtCompileTime>
 mdivide_right_spd(EigMat1&& b, EigMat2&& A) {
   static constexpr const char* function = "mdivide_right_spd";
   check_multiplicable(function, "b", b, "A", A);
@@ -37,7 +38,9 @@ mdivide_right_spd(EigMat1&& b, EigMat2&& A) {
     return {b.rows(), 0};
   }
 
-  return mdivide_left_spd(std::forward<decltype(A_ref)>(A_ref), std::forward<EigMat1>(b).transpose()).transpose();
+  return mdivide_left_spd(std::forward<decltype(A_ref)>(A_ref),
+                          std::forward<EigMat1>(b).transpose())
+      .transpose();
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/mdivide_right_tri_low.hpp b/stan/math/prim/fun/mdivide_right_tri_low.hpp
index 78e57b643f9..f67e79b153b 100644
--- a/stan/math/prim/fun/mdivide_right_tri_low.hpp
+++ b/stan/math/prim/fun/mdivide_right_tri_low.hpp
@@ -25,9 +25,11 @@ template <typename EigMat1, typename EigMat2,
           require_all_eigen_t<EigMat1, EigMat2>* = nullptr,
           require_all_not_vt_fvar<EigMat1, EigMat2>* = nullptr>
 inline Eigen::Matrix<return_type_t<EigMat1, EigMat2>,
-                     std::decay_t<EigMat1>::RowsAtCompileTime, std::decay_t<EigMat2>::ColsAtCompileTime>
+                     std::decay_t<EigMat1>::RowsAtCompileTime,
+                     std::decay_t<EigMat2>::ColsAtCompileTime>
 mdivide_right_tri_low(EigMat1&& b, EigMat2&& A) {
-  return mdivide_right_tri<Eigen::Lower>(std::forward<EigMat1>(b), std::forward<EigMat2>(A));
+  return mdivide_right_tri<Eigen::Lower>(std::forward<EigMat1>(b),
+                                         std::forward<EigMat2>(A));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/minus.hpp b/stan/math/prim/fun/minus.hpp
index c7e8b7c9585..3822bdc0e22 100644
--- a/stan/math/prim/fun/minus.hpp
+++ b/stan/math/prim/fun/minus.hpp
@@ -34,9 +34,9 @@ inline auto minus(T&& x) {
  */
 template <typename T, require_std_vector_t<T>* = nullptr>
 inline auto minus(T&& x) {
-  return apply_vector_unary<T>::apply(
-      std::forward<T>(x),
-      [](auto&& v) { return -std::forward<decltype(v)>(v); });
+  return apply_vector_unary<T>::apply(std::forward<T>(x), [](auto&& v) {
+    return -std::forward<decltype(v)>(v);
+  });
 }
 }  // namespace math
 }  // namespace stan
diff --git a/stan/math/prim/fun/quad_form.hpp b/stan/math/prim/fun/quad_form.hpp
index e4d7fa8066c..dff80db1bd4 100644
--- a/stan/math/prim/fun/quad_form.hpp
+++ b/stan/math/prim/fun/quad_form.hpp
@@ -55,10 +55,12 @@ template <typename EigMat, typename ColVec, require_eigen_t<EigMat>* = nullptr,
 inline value_type_t<EigMat> quad_form(EigMat&& A, ColVec&& B) {
   check_square("quad_form", "A", A);
   check_multiplicable("quad_form", "A", A, "B", B);
-  return make_holder([](auto&& b, auto&& a) {
-    auto&& b_ref = to_ref(std::forward<decltype(b)>(b));
-    return b_ref.dot(a * b_ref);
-  }, std::forward<ColVec>(B), std::forward<EigMat>(A));
+  return make_holder(
+      [](auto&& b, auto&& a) {
+        auto&& b_ref = to_ref(std::forward<decltype(b)>(b));
+        return b_ref.dot(a * b_ref);
+      },
+      std::forward<ColVec>(B), std::forward<EigMat>(A));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/quad_form_sym.hpp b/stan/math/prim/fun/quad_form_sym.hpp
index 2b6d5f78613..b872285ad95 100644
--- a/stan/math/prim/fun/quad_form_sym.hpp
+++ b/stan/math/prim/fun/quad_form_sym.hpp
@@ -31,10 +31,12 @@ inline plain_type_t<EigMat2> quad_form_sym(EigMat1&& A, EigMat2&& B) {
   check_multiplicable("quad_form_sym", "A", A, "B", B);
   auto&& A_ref = to_ref(std::forward<EigMat1>(A));
   check_symmetric("quad_form_sym", "A", A_ref);
-  return make_holder([](auto&& a, auto&& b) {
-    auto ret = (a.transpose() * a * b).eval();
-    return 0.5 * (ret + ret.transpose());
-  }, std::forward<decltype(A_ref)>(A_ref), to_ref(std::forward<EigMat2>(B)));
+  return make_holder(
+      [](auto&& a, auto&& b) {
+        auto ret = (a.transpose() * a * b).eval();
+        return 0.5 * (ret + ret.transpose());
+      },
+      std::forward<decltype(A_ref)>(A_ref), to_ref(std::forward<EigMat2>(B)));
 }
 
 /**
@@ -57,9 +59,9 @@ inline value_type_t<EigMat> quad_form_sym(EigMat&& A, ColVec&& B) {
   check_multiplicable("quad_form_sym", "A", A, "B", B);
   auto&& A_ref = to_ref(std::forward<EigMat>(A));
   check_symmetric("quad_form_sym", "A", A_ref);
-  return make_holder([](auto&& a, auto&& b) {
-    return b.dot(a * b);
-  }, std::forward<decltype(A_ref)>(A_ref), to_ref(std::forward<ColVec>(B)));
+  return make_holder([](auto&& a, auto&& b) { return b.dot(a * b); },
+                     std::forward<decltype(A_ref)>(A_ref),
+                     to_ref(std::forward<ColVec>(B)));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/read_corr_L.hpp b/stan/math/prim/fun/read_corr_L.hpp
index 53194e855a0..152f1ad3d95 100644
--- a/stan/math/prim/fun/read_corr_L.hpp
+++ b/stan/math/prim/fun/read_corr_L.hpp
@@ -34,9 +34,9 @@ namespace math {
  * canonical partial correlations.
  */
 template <typename T, require_eigen_vector_t<T>* = nullptr>
-inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic> read_corr_L(
-    const T& CPCs,  // on (-1, 1)
-    size_t K) {
+inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic>
+read_corr_L(const T& CPCs,  // on (-1, 1)
+            size_t K) {
   using T_scalar = value_type_t<T>;
   if (K == 0) {
     return {};
@@ -101,8 +101,8 @@ inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic> read_corr_
  */
 template <typename T, typename Lp, require_eigen_vector_t<T>* = nullptr,
           require_convertible_t<value_type_t<T>, Lp>* = nullptr>
-inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic> read_corr_L(
-    T&& CPCs, size_t K, Lp& log_prob) {
+inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic>
+read_corr_L(T&& CPCs, size_t K, Lp& log_prob) {
   using T_scalar = value_type_t<T>;
   if (K == 0) {
     return {};
diff --git a/stan/math/prim/fun/read_corr_matrix.hpp b/stan/math/prim/fun/read_corr_matrix.hpp
index fe8c3d01917..7be0f328793 100644
--- a/stan/math/prim/fun/read_corr_matrix.hpp
+++ b/stan/math/prim/fun/read_corr_matrix.hpp
@@ -28,7 +28,8 @@ read_corr_matrix(T_CPCs&& CPCs, size_t K) {
   if (K == 0) {
     return {};
   }
-  return multiply_lower_tri_self_transpose(read_corr_L(std::forward<T_CPCs>(CPCs), K));
+  return multiply_lower_tri_self_transpose(
+      read_corr_L(std::forward<T_CPCs>(CPCs), K));
 }
 
 /**
@@ -60,7 +61,8 @@ read_corr_matrix(T_CPCs&& CPCs, size_t K, Lp& log_prob) {
   if (K == 0) {
     return {};
   }
-  return multiply_lower_tri_self_transpose(read_corr_L(std::forward<T_CPCs>(CPCs), K, log_prob));
+  return multiply_lower_tri_self_transpose(
+      read_corr_L(std::forward<T_CPCs>(CPCs), K, log_prob));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/rep_matrix.hpp b/stan/math/prim/fun/rep_matrix.hpp
index 3bd3dab0775..4b4154a71cf 100644
--- a/stan/math/prim/fun/rep_matrix.hpp
+++ b/stan/math/prim/fun/rep_matrix.hpp
@@ -54,14 +54,12 @@ template <typename Vec, require_eigen_vector_t<Vec>* = nullptr>
 inline auto rep_matrix(Vec&& x, int n) {
   if constexpr (is_eigen_row_vector<Vec>::value) {
     check_nonnegative("rep_matrix", "rows", n);
-    return make_holder([n](auto&& xx) {
-      return xx.replicate(n, 1);
-    }, std::forward<Vec>(x));
+    return make_holder([n](auto&& xx) { return xx.replicate(n, 1); },
+                       std::forward<Vec>(x));
   } else {
     check_nonnegative("rep_matrix", "cols", n);
-    return make_holder([n](auto&& xx) {
-      return xx.replicate(1, n);
-    }, std::forward<Vec>(x));
+    return make_holder([n](auto&& xx) { return xx.replicate(1, n); },
+                       std::forward<Vec>(x));
   }
 }
 
diff --git a/stan/math/prim/fun/reverse.hpp b/stan/math/prim/fun/reverse.hpp
index 5062cb9a4e3..ba98bde8407 100644
--- a/stan/math/prim/fun/reverse.hpp
+++ b/stan/math/prim/fun/reverse.hpp
@@ -33,10 +33,8 @@ inline std::vector<T> reverse(const std::vector<T>& x) {
  */
 template <typename T, typename = require_vector_t<T>>
 inline auto reverse(T&& x) {
-  return make_holder(
-      [](auto&& xx) {
-          return xx.reverse();
-      }, std::forward<T>(x));
+  return make_holder([](auto&& xx) { return xx.reverse(); },
+                     std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/round.hpp b/stan/math/prim/fun/round.hpp
index e9c11a4356e..7fe488adceb 100644
--- a/stan/math/prim/fun/round.hpp
+++ b/stan/math/prim/fun/round.hpp
@@ -40,7 +40,7 @@ template <typename Container,
           require_not_container_st<std::is_arithmetic, Container>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               Container>* = nullptr,
-              require_container_t<Container>* = nullptr>
+          require_container_t<Container>* = nullptr>
 inline auto round(Container&& x) {
   return apply_scalar_unary<round_fun, Container>::apply(
       std::forward<Container>(x));
diff --git a/stan/math/prim/fun/row.hpp b/stan/math/prim/fun/row.hpp
index 4a3593ef318..a48f343e8ef 100644
--- a/stan/math/prim/fun/row.hpp
+++ b/stan/math/prim/fun/row.hpp
@@ -23,9 +23,9 @@ namespace math {
 template <typename T, require_matrix_t<T>* = nullptr>
 inline auto row(T&& m, size_t i) {
   check_row_index("row", "i", m, i);
-  return make_holder([i](auto&& mm) {
-        return std::forward<decltype(mm)>(mm).row(i - 1);
-  }, std::forward<T>(m));
+  return make_holder(
+      [i](auto&& mm) { return std::forward<decltype(mm)>(mm).row(i - 1); },
+      std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/rows_dot_product.hpp b/stan/math/prim/fun/rows_dot_product.hpp
index 406da146bbf..4d8d1e2371a 100644
--- a/stan/math/prim/fun/rows_dot_product.hpp
+++ b/stan/math/prim/fun/rows_dot_product.hpp
@@ -29,8 +29,12 @@ rows_dot_product(const Mat1& v1, const Mat2& v2) {
   check_matching_dims("rows_dot_product", "v1", v1, "v2", v2);
   return make_holder(
       [](auto&& v1, auto&& v2) {
-        return (std::forward<decltype(v1)>(v1).cwiseProduct(std::forward<decltype(v2)>(v2))).rowwise().sum();
-      }, std::forward<Mat1>(v1), std::forward<Mat2>(v2));
+        return (std::forward<decltype(v1)>(v1).cwiseProduct(
+                    std::forward<decltype(v2)>(v2)))
+            .rowwise()
+            .sum();
+      },
+      std::forward<Mat1>(v1), std::forward<Mat2>(v2));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/rows_dot_self.hpp b/stan/math/prim/fun/rows_dot_self.hpp
index 0f3c8465485..0f89aa0963e 100644
--- a/stan/math/prim/fun/rows_dot_self.hpp
+++ b/stan/math/prim/fun/rows_dot_self.hpp
@@ -17,11 +17,12 @@ namespace math {
  */
 template <typename T, require_eigen_t<T>* = nullptr,
           require_not_st_var<T>* = nullptr>
-inline auto rows_dot_self(
-    T&& x) {
-  return make_holder([](const auto& xx) {
+inline auto rows_dot_self(T&& x) {
+  return make_holder(
+      [](const auto& xx) {
         return std::forward<decltype(xx)>(xx).rowwise().squaredNorm();
-  }, std::forward<T>(x));
+      },
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/segment.hpp b/stan/math/prim/fun/segment.hpp
index ebd197c733e..978788b7e7e 100644
--- a/stan/math/prim/fun/segment.hpp
+++ b/stan/math/prim/fun/segment.hpp
@@ -23,9 +23,8 @@ inline auto segment(Vec&& v, size_t i, size_t n) {
     check_less_or_equal("segment", "n", i + n - 1,
                         static_cast<size_t>(v.size()));
   }
-  return make_holder([i, n](auto&& v_) {
-    return v_.segment(i - 1, n);
-  }, std::forward<Vec>(v));
+  return make_holder([i, n](auto&& v_) { return v_.segment(i - 1, n); },
+                     std::forward<Vec>(v));
 }
 
 template <typename T>
diff --git a/stan/math/prim/fun/select.hpp b/stan/math/prim/fun/select.hpp
index b4dcac58d01..7f4ae51d151 100644
--- a/stan/math/prim/fun/select.hpp
+++ b/stan/math/prim/fun/select.hpp
@@ -145,11 +145,14 @@ template <typename T_bool, typename T_true, typename T_false,
           require_all_stan_scalar_t<T_true, T_false>* = nullptr>
 inline auto select(T_bool&& c, const T_true y_true, const T_false y_false) {
   using ret_t = return_type_t<T_true, T_false>;
-  return make_holder([y_true, y_false](auto&& c_){
-    return std::forward<decltype(c_)>(c_).unaryExpr([y_true, y_false](bool cond) {
-          return cond ? ret_t(y_true) : ret_t(y_false);
-        });
-  }, std::forward<T_bool>(c));
+  return make_holder(
+      [y_true, y_false](auto&& c_) {
+        return std::forward<decltype(c_)>(c_).unaryExpr(
+            [y_true, y_false](bool cond) {
+              return cond ? ret_t(y_true) : ret_t(y_false);
+            });
+      },
+      std::forward<T_bool>(c));
 }
 
 /**
@@ -171,12 +174,15 @@ inline auto select(T_bool&& c, T_true&& y_true, T_false&& y_false) {
   check_consistent_sizes("select", "boolean", c, "left hand side", y_true,
                          "right hand side", y_false);
   using ret_t = return_type_t<T_true, T_false>;
-  return make_holder([](auto&& c_, auto&& y_true_, auto&& y_false_){
-    return std::forward<decltype(c_)>(c_)
-        .select(std::forward<decltype(y_true_)>(y_true_),
-                 std::forward<decltype(y_false_)>(y_false_))
-        .template cast<ret_t>().eval();
-  }, std::forward<T_bool>(c), std::forward<T_true>(y_true),
+  return make_holder(
+      [](auto&& c_, auto&& y_true_, auto&& y_false_) {
+        return std::forward<decltype(c_)>(c_)
+            .select(std::forward<decltype(y_true_)>(y_true_),
+                    std::forward<decltype(y_false_)>(y_false_))
+            .template cast<ret_t>()
+            .eval();
+      },
+      std::forward<T_bool>(c), std::forward<T_true>(y_true),
       std::forward<T_false>(y_false));
 }
 
diff --git a/stan/math/prim/fun/sin.hpp b/stan/math/prim/fun/sin.hpp
index 4ee414c2a99..85b3f79dd57 100644
--- a/stan/math/prim/fun/sin.hpp
+++ b/stan/math/prim/fun/sin.hpp
@@ -47,7 +47,7 @@ inline auto sin(const T x) {
 struct sin_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return sin(std::forward<T>(x));
+    return sin(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/sinh.hpp b/stan/math/prim/fun/sinh.hpp
index b24538848e9..d080ff78339 100644
--- a/stan/math/prim/fun/sinh.hpp
+++ b/stan/math/prim/fun/sinh.hpp
@@ -45,7 +45,7 @@ inline auto sinh(const T x) {
 struct sinh_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return sinh(std::forward<T>(x));
+    return sinh(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/sqrt.hpp b/stan/math/prim/fun/sqrt.hpp
index c90351546e3..59f15adaafe 100644
--- a/stan/math/prim/fun/sqrt.hpp
+++ b/stan/math/prim/fun/sqrt.hpp
@@ -45,7 +45,7 @@ inline auto sqrt(const T x) {
 struct sqrt_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return sqrt(std::forward<T>(x));
+    return sqrt(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/step.hpp b/stan/math/prim/fun/step.hpp
index 15d9b405b2c..c8eb85b470a 100644
--- a/stan/math/prim/fun/step.hpp
+++ b/stan/math/prim/fun/step.hpp
@@ -45,7 +45,7 @@ struct step_fun {
    */
   template <typename T>
   static inline auto fun(T&& y) {
-  return step(std::forward<T>(y));
+    return step(std::forward<T>(y));
   }
 };
 
diff --git a/stan/math/prim/fun/tan.hpp b/stan/math/prim/fun/tan.hpp
index 7f59b1bc765..71ad4a04bbb 100644
--- a/stan/math/prim/fun/tan.hpp
+++ b/stan/math/prim/fun/tan.hpp
@@ -47,7 +47,7 @@ inline auto tan(const T x) {
 struct tan_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return tan(std::forward<T>(x));
+    return tan(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/tanh.hpp b/stan/math/prim/fun/tanh.hpp
index 140ab321258..543c6d923fd 100644
--- a/stan/math/prim/fun/tanh.hpp
+++ b/stan/math/prim/fun/tanh.hpp
@@ -47,7 +47,7 @@ inline auto tanh(const T x) {
 struct tanh_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return tanh(std::forward<T>(x));
+    return tanh(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/tgamma.hpp b/stan/math/prim/fun/tgamma.hpp
index 840b070d1d2..64dad1b7a6d 100644
--- a/stan/math/prim/fun/tgamma.hpp
+++ b/stan/math/prim/fun/tgamma.hpp
@@ -34,7 +34,7 @@ inline double tgamma(double x) {
 struct tgamma_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return tgamma(std::forward<T>(x));
+    return tgamma(std::forward<T>(x));
   }
 };
 
@@ -49,8 +49,7 @@ struct tgamma_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr,
-    require_container_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr, require_container_t<T>* = nullptr>
 inline auto tgamma(T&& x) {
   return apply_scalar_unary<tgamma_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/fun/to_int.hpp b/stan/math/prim/fun/to_int.hpp
index d18f89f3f6a..d8f84c76e6c 100644
--- a/stan/math/prim/fun/to_int.hpp
+++ b/stan/math/prim/fun/to_int.hpp
@@ -57,7 +57,7 @@ inline int to_int(T x) {
 struct to_int_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return to_int(std::forward<T>(x));
+    return to_int(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/trigamma.hpp b/stan/math/prim/fun/trigamma.hpp
index 63e0d9f8e94..45b2d534d3b 100644
--- a/stan/math/prim/fun/trigamma.hpp
+++ b/stan/math/prim/fun/trigamma.hpp
@@ -139,7 +139,7 @@ struct trigamma_fun {
    */
   template <typename T>
   static inline auto fun(T&& x) {
-  return trigamma(std::forward<T>(x));
+    return trigamma(std::forward<T>(x));
   }
 };
 
diff --git a/stan/math/prim/fun/trunc.hpp b/stan/math/prim/fun/trunc.hpp
index 494f114a168..b6fbd0db071 100644
--- a/stan/math/prim/fun/trunc.hpp
+++ b/stan/math/prim/fun/trunc.hpp
@@ -41,9 +41,10 @@ struct trunc_fun {
  * @param x container
  * @return elementwise trunc of container elements
  */
-template <typename T, require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-                          T>* = nullptr,
-                          require_container_t<T>* = nullptr>
+template <
+    typename T,
+    require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
+    require_container_t<T>* = nullptr>
 inline auto trunc(T&& x) {
   return apply_scalar_unary<trunc_fun, T>::apply(std::forward<T>(x));
 }
diff --git a/stan/math/prim/functor/apply_scalar_binary.hpp b/stan/math/prim/functor/apply_scalar_binary.hpp
index 7ee18d0ec01..56ee43c0802 100644
--- a/stan/math/prim/functor/apply_scalar_binary.hpp
+++ b/stan/math/prim/functor/apply_scalar_binary.hpp
@@ -58,7 +58,8 @@ inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   return make_holder(
       [](auto&& f_inner, auto&& x_inner, auto&& y_inner) {
         return std::forward<decltype(x_inner)>(x_inner).binaryExpr(
-          std::forward<decltype(y_inner)>(y_inner), std::forward<decltype(f_inner)>(f_inner));
+            std::forward<decltype(y_inner)>(y_inner),
+            std::forward<decltype(f_inner)>(f_inner));
       },
       std::forward<F>(f), std::forward<T1>(x), std::forward<T2>(y));
 }
@@ -86,7 +87,7 @@ inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
                                            plain_type_t<decltype(x_inner)>>;
         Eigen::Map<const int_vec_t> y_map(y_inner.data(), y_inner.size());
         return std::forward<decltype(x_inner)>(x_inner).binaryExpr(
-          y_map, std::forward<decltype(f_inner)>(f_inner));
+            y_map, std::forward<decltype(f_inner)>(f_inner));
       },
       std::forward<F>(f), std::forward<T1>(x), std::forward<T2>(y));
 }
@@ -114,7 +115,7 @@ inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
                                            plain_type_t<decltype(y_inner)>>;
         Eigen::Map<const int_vec_t> x_map(x_inner.data(), x_inner.size());
         return x_map.binaryExpr(std::forward<decltype(y_inner)>(y_inner),
-          std::forward<decltype(f_inner)>(f_inner));
+                                std::forward<decltype(f_inner)>(f_inner));
       },
       std::forward<F>(f), std::forward<T1>(x), std::forward<T2>(y));
 }
@@ -297,7 +298,8 @@ inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   using T_return = std::decay_t<decltype(f(x[0], y))>;
   std::vector<T_return> result(x.size());
   Eigen::Map<Eigen::Matrix<T_return, -1, 1>>(result.data(), result.size())
-      = x_vec.unaryExpr([f_ = std::forward<F>(f), y](auto&& v) { return f_(v, y); });
+      = x_vec.unaryExpr(
+          [f_ = std::forward<F>(f), y](auto&& v) { return f_(v, y); });
   return result;
 }
 
@@ -327,7 +329,8 @@ inline auto apply_scalar_binary(F&& f, T1&& x, T2&& y) {
   using T_return = std::decay_t<decltype(f(x, y[0]))>;
   std::vector<T_return> result(y.size());
   Eigen::Map<Eigen::Matrix<T_return, -1, 1>>(result.data(), result.size())
-      = y_vec.unaryExpr([f_ = std::forward<F>(f), x](auto&& v) { return f_(x, v); });
+      = y_vec.unaryExpr(
+          [f_ = std::forward<F>(f), x](auto&& v) { return f_(x, v); });
   return result;
 }
 
diff --git a/stan/math/prim/functor/apply_scalar_ternary.hpp b/stan/math/prim/functor/apply_scalar_ternary.hpp
index b1f4ff797e6..e50b558d3af 100644
--- a/stan/math/prim/functor/apply_scalar_ternary.hpp
+++ b/stan/math/prim/functor/apply_scalar_ternary.hpp
@@ -37,7 +37,8 @@ namespace math {
 template <typename F, typename T1, typename T2, typename T3,
           require_all_stan_scalar_t<T1, T2, T3>* = nullptr>
 inline auto apply_scalar_ternary(F&& f, T1&& x, T2&& y, T3&& z) {
-  return std::forward<F>(f)(std::forward<T1>(x), std::forward<T2>(y), std::forward<T3>(z));
+  return std::forward<F>(f)(std::forward<T1>(x), std::forward<T2>(y),
+                            std::forward<T3>(z));
 }
 
 /**
@@ -187,7 +188,8 @@ template <typename F, typename T1, typename T2, typename T3,
 inline auto apply_scalar_ternary(F&& f, T1&& x, T2&& y, T3&& z) {
   return apply_scalar_binary(
       [f_ = std::forward<F>(f), y](auto&& a, auto&& c) {
-        return f_(std::forward<decltype(a)>(a), y, std::forward<decltype(c)>(c));
+        return f_(std::forward<decltype(a)>(a), y,
+                  std::forward<decltype(c)>(c));
       },
       std::forward<T1>(x), std::forward<T3>(z));
 }
@@ -214,7 +216,8 @@ template <typename F, typename T1, typename T2, typename T3,
 inline auto apply_scalar_ternary(F&& f, T1&& x, T2&& y, T3&& z) {
   return apply_scalar_binary(
       [f_ = std::forward<F>(f), x](auto&& b, auto&& c) {
-        return f_(x, std::forward<decltype(b)>(b), std::forward<decltype(c)>(c));
+        return f_(x, std::forward<decltype(b)>(b),
+                  std::forward<decltype(c)>(c));
       },
       std::forward<T2>(y), std::forward<T3>(z));
 }
diff --git a/stan/math/prim/functor/apply_vector_unary.hpp b/stan/math/prim/functor/apply_vector_unary.hpp
index 8d9b8a8a1d4..61affed66a8 100644
--- a/stan/math/prim/functor/apply_vector_unary.hpp
+++ b/stan/math/prim/functor/apply_vector_unary.hpp
@@ -131,10 +131,12 @@ struct apply_vector_unary<T, require_std_vector_vt<is_stan_scalar, T>> {
    */
   template <typename T2, typename F>
   static inline auto apply(T2&& x, F&& f) {
-    using T_return = value_type_t<decltype(f(as_column_vector_or_scalar(std::forward<T2>(x))))>;
+    using T_return = value_type_t<decltype(
+        f(as_column_vector_or_scalar(std::forward<T2>(x))))>;
     std::vector<T_return> result(x.size());
     Eigen::Map<Eigen::Matrix<T_return, -1, 1>>(result.data(), result.size())
-        = std::forward<F>(f)(as_column_vector_or_scalar(std::forward<T2>(x))).matrix();
+        = std::forward<F>(f)(as_column_vector_or_scalar(std::forward<T2>(x)))
+              .matrix();
     return result;
   }
 
diff --git a/stan/math/prim/meta/conjunction.hpp b/stan/math/prim/meta/conjunction.hpp
index d9025860220..213decb1a13 100644
--- a/stan/math/prim/meta/conjunction.hpp
+++ b/stan/math/prim/meta/conjunction.hpp
@@ -17,7 +17,6 @@ template <typename T, typename... Ts>
 struct conjunction<T, Ts...>
     : std::conditional_t<T::value, conjunction<Ts...>, std::false_type> {};
 
-
 template <template <typename...> class Cond, typename... Args>
 using all_v = conjunction<Cond<Args>...>;
 
diff --git a/stan/math/prim/meta/holder.hpp b/stan/math/prim/meta/holder.hpp
index ae637f9e348..8debde1cbb9 100644
--- a/stan/math/prim/meta/holder.hpp
+++ b/stan/math/prim/meta/holder.hpp
@@ -189,34 +189,43 @@ class Holder
   }
 
   inline auto operator-() {
-    return make_holder(
-        [](const auto& arg) { return -arg; }, m_arg);
+    return make_holder([](const auto& arg) { return -arg; }, m_arg);
   }
   inline auto operator+() {
-    return make_holder(
-        [](const auto& arg) { return arg; }, m_arg);
+    return make_holder([](const auto& arg) { return arg; }, m_arg);
   }
   template <typename Other>
   inline auto operator+(Other&& other) {
     return make_holder(
-        [](const auto& arg, auto&& other_) { return arg + std::forward<decltype(other_)>(other_); }, m_arg, std::forward<Other>(other));
+        [](const auto& arg, auto&& other_) {
+          return arg + std::forward<decltype(other_)>(other_);
+        },
+        m_arg, std::forward<Other>(other));
   }
   template <typename Other>
   inline auto operator-(Other&& other) {
     return make_holder(
-        [](const auto& arg, auto&& other_) { return arg - std::forward<decltype(other_)>(other_); }, m_arg, std::forward<Other>(other));
+        [](const auto& arg, auto&& other_) {
+          return arg - std::forward<decltype(other_)>(other_);
+        },
+        m_arg, std::forward<Other>(other));
   }
   template <typename Other>
   inline auto operator*(Other&& other) {
     return make_holder(
-        [](const auto& arg, auto&& other_) { return arg * std::forward<decltype(other_)>(other_); }, m_arg, std::forward<Other>(other));
+        [](const auto& arg, auto&& other_) {
+          return arg * std::forward<decltype(other_)>(other_);
+        },
+        m_arg, std::forward<Other>(other));
   }
   template <typename Other>
   inline auto operator/(Other&& other) {
     return make_holder(
-        [](const auto& arg, auto&& other_) { return arg / std::forward<decltype(other_)>(other_); }, m_arg, std::forward<Other>(other));
+        [](const auto& arg, auto&& other_) {
+          return arg / std::forward<decltype(other_)>(other_);
+        },
+        m_arg, std::forward<Other>(other));
   }
-
 };
 
 }  // namespace math
@@ -410,9 +419,8 @@ inline auto make_holder_impl(F&& func, std::index_sequence<Is...>,
  * @param args arguments for the functor
  * @return `holder` referencing expression constructed by given functor
  */
-template <
-    typename F, typename... Args,
-    require_not_plain_type_t<std::invoke_result_t<F, Args&&...>>*>
+template <typename F, typename... Args,
+          require_not_plain_type_t<std::invoke_result_t<F, Args&&...>>*>
 inline auto make_holder(F&& func, Args&&... args) {
   return internal::make_holder_impl(std::forward<F>(func),
                                     std::make_index_sequence<sizeof...(Args)>(),
diff --git a/stan/math/prim/prob/loglogistic_cdf.hpp b/stan/math/prim/prob/loglogistic_cdf.hpp
index b6dfa4cbbb8..6c7ce43fde5 100644
--- a/stan/math/prim/prob/loglogistic_cdf.hpp
+++ b/stan/math/prim/prob/loglogistic_cdf.hpp
@@ -43,9 +43,8 @@ namespace math {
 template <typename T_y, typename T_scale, typename T_shape,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               T_y, T_scale, T_shape>* = nullptr>
-inline return_type_t<T_y, T_scale, T_shape> loglogistic_cdf(const T_y& y,
-                                                     const T_scale& alpha,
-                                                     const T_shape& beta) {
+inline return_type_t<T_y, T_scale, T_shape> loglogistic_cdf(
+    const T_y& y, const T_scale& alpha, const T_shape& beta) {
   using T_partials_return = partials_return_t<T_y, T_scale, T_shape>;
   using T_y_ref = ref_type_t<T_y>;
   using T_alpha_ref = ref_type_t<T_scale>;
@@ -81,21 +80,20 @@ inline return_type_t<T_y, T_scale, T_shape> loglogistic_cdf(const T_y& y,
   auto&& alpha_div_y_pow_beta
       = to_ref_if<!is_constant_all<T_y, T_scale, T_shape>::value>(
           pow(alpha_div_y, beta_val));
-  auto&& prod_all
-      = to_ref_if<!is_constant_all<T_y, T_scale, T_shape>::value>(
-          1.0 / (1.0 + alpha_div_y_pow_beta));
+  auto&& prod_all = to_ref_if<!is_constant_all<T_y, T_scale, T_shape>::value>(
+      1.0 / (1.0 + alpha_div_y_pow_beta));
 
   T_partials_return cdf = prod(prod_all);
 
   if (!is_constant_all<T_y, T_scale, T_shape>::value) {
     auto&& prod_all_sq = to_ref_if<!is_constant_all<T_y>::value
-                                            + !is_constant_all<T_scale>::value
-                                            + !is_constant_all<T_shape>::value
-                                        >= 2>(square(prod_all));
+                                       + !is_constant_all<T_scale>::value
+                                       + !is_constant_all<T_shape>::value
+                                   >= 2>(square(prod_all));
     auto&& cdf_div_elt = to_ref_if<!is_constant_all<T_y>::value
-                                            + !is_constant_all<T_scale>::value
-                                            + !is_constant_all<T_shape>::value
-                                        >= 2>(cdf / prod_all);
+                                       + !is_constant_all<T_scale>::value
+                                       + !is_constant_all<T_shape>::value
+                                   >= 2>(cdf / prod_all);
     if (!is_constant_all<T_y, T_scale>::value) {
       auto&& alpha_div_times_beta = to_ref_if<
           !is_constant_all<T_y>::value + !is_constant_all<T_scale>::value == 2>(
@@ -105,8 +103,7 @@ inline return_type_t<T_y, T_scale, T_shape> loglogistic_cdf(const T_y& y,
         partials<0>(ops_partials) = y_deriv * cdf_div_elt;
       }
       if (!is_constant_all<T_scale>::value) {
-        auto alpha_deriv
-            = -alpha_div_times_beta / alpha_val * prod_all_sq;
+        auto alpha_deriv = -alpha_div_times_beta / alpha_val * prod_all_sq;
         partials<1>(ops_partials) = alpha_deriv * cdf_div_elt;
       }
     }
diff --git a/stan/math/prim/prob/std_normal_log_qf.hpp b/stan/math/prim/prob/std_normal_log_qf.hpp
index 47c9292e13c..fa463779a89 100644
--- a/stan/math/prim/prob/std_normal_log_qf.hpp
+++ b/stan/math/prim/prob/std_normal_log_qf.hpp
@@ -133,7 +133,7 @@ inline double std_normal_log_qf(double log_p) {
 struct std_normal_log_qf_fun {
   template <typename T>
   static inline auto fun(T&& x) {
-  return std_normal_log_qf(std::forward<T>(x));
+    return std_normal_log_qf(std::forward<T>(x));
   }
 };
 
@@ -149,8 +149,7 @@ struct std_normal_log_qf_fun {
 template <
     typename T,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr,
-    require_not_var_matrix_t<T>* = nullptr,
-    require_container_t<T>* = nullptr>
+    require_not_var_matrix_t<T>* = nullptr, require_container_t<T>* = nullptr>
 inline auto std_normal_log_qf(T&& x) {
   return apply_scalar_unary<std_normal_log_qf_fun, T>::apply(
       std::forward<T>(x));
diff --git a/stan/math/rev/fun/Phi.hpp b/stan/math/rev/fun/Phi.hpp
index 4a89c9e3634..3f0f9aee1ca 100644
--- a/stan/math/rev/fun/Phi.hpp
+++ b/stan/math/rev/fun/Phi.hpp
@@ -50,7 +50,8 @@ namespace math {
  * @param a Variable argument.
  * @return The unit normal cdf evaluated at the specified argument.
  */
-template <typename T, require_var_t<T>* = nullptr, require_stan_scalar_t<T>* = nullptr>
+template <typename T, require_var_t<T>* = nullptr,
+          require_stan_scalar_t<T>* = nullptr>
 inline auto Phi(T&& a) {
   return make_callback_var(Phi(a.val()), [a](auto& vi) mutable {
     a.adj() += vi.adj() * INV_SQRT_TWO_PI * std::exp(-0.5 * a.val() * a.val());
diff --git a/stan/math/rev/fun/cbrt.hpp b/stan/math/rev/fun/cbrt.hpp
index e6a4248fe2e..4198f2a85e6 100644
--- a/stan/math/rev/fun/cbrt.hpp
+++ b/stan/math/rev/fun/cbrt.hpp
@@ -44,10 +44,11 @@ inline auto cbrt(Var&& a) {
     });
   } else {
     return make_callback_var(
-      a.val().unaryExpr([](auto&& x) { return cbrt(x); }),
-      [a](const auto& vi) mutable {
-        a.adj().array() += vi.adj().array() / (3.0 * vi.val().array().square());
-    });
+        a.val().unaryExpr([](auto&& x) { return cbrt(x); }),
+        [a](const auto& vi) mutable {
+          a.adj().array()
+              += vi.adj().array() / (3.0 * vi.val().array().square());
+        });
   }
 }
 
diff --git a/stan/math/rev/fun/digamma.hpp b/stan/math/rev/fun/digamma.hpp
index cf3bf15d688..b2625423ccf 100644
--- a/stan/math/rev/fun/digamma.hpp
+++ b/stan/math/rev/fun/digamma.hpp
@@ -16,7 +16,8 @@ namespace math {
  * @param[in] a argument
  * @return derivative of log gamma function at argument
  */
-template <typename T, require_var_t<T>* = nullptr, require_stan_scalar_t<T>* = nullptr>
+template <typename T, require_var_t<T>* = nullptr,
+          require_stan_scalar_t<T>* = nullptr>
 inline auto digamma(T&& a) {
   return make_callback_var(digamma(a.val()), [a](auto&& vi) {
     a.adj() += vi.adj() * trigamma(a.val());
diff --git a/stan/math/rev/functor/apply_scalar_unary.hpp b/stan/math/rev/functor/apply_scalar_unary.hpp
index dfe0620d033..338350dd5bd 100644
--- a/stan/math/rev/functor/apply_scalar_unary.hpp
+++ b/stan/math/rev/functor/apply_scalar_unary.hpp
@@ -30,7 +30,9 @@ struct apply_scalar_unary<
    * @return Function applied to the variable.
    */
   template <typename T2>
-  static inline auto apply(T2&& x) { return F::fun(std::forward<T2>(x)); }
+  static inline auto apply(T2&& x) {
+    return F::fun(std::forward<T2>(x));
+  }
 };
 
 template <typename F, typename T>

From ebb2dbde19acb7babd05b15a093ec6eef7b5f810 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Wed, 2 Jul 2025 13:09:25 -0400
Subject: [PATCH 13/31] fix functions that return expressions

---
 stan/math/prim/fun/columns_dot_product.hpp    |  8 ++--
 stan/math/prim/fun/columns_dot_self.hpp       |  7 ++--
 stan/math/prim/fun/crossprod.hpp              |  4 +-
 stan/math/prim/fun/diag_matrix.hpp            |  6 ++-
 stan/math/prim/fun/diag_post_multiply.hpp     |  6 ++-
 stan/math/prim/fun/diag_pre_multiply.hpp      |  7 ++--
 stan/math/prim/fun/distance.hpp               |  4 +-
 stan/math/prim/fun/divide.hpp                 |  6 ++-
 stan/math/prim/fun/dot_product.hpp            |  6 ++-
 stan/math/prim/fun/dot_self.hpp               |  2 +-
 stan/math/prim/fun/elt_divide.hpp             | 17 +++++---
 stan/math/prim/fun/elt_multiply.hpp           | 10 +++--
 stan/math/prim/fun/eval.hpp                   |  4 +-
 stan/math/prim/fun/fft.hpp                    |  8 ++--
 stan/math/prim/fun/multiply.hpp               | 41 ++++++++++++-------
 stan/math/prim/fun/norm1.hpp                  |  7 ++--
 stan/math/prim/fun/norm2.hpp                  |  7 ++--
 stan/math/prim/fun/pseudo_eigenvalues.hpp     |  2 +-
 stan/math/prim/fun/quad_form_diag.hpp         | 10 ++---
 stan/math/prim/fun/quad_form_sym.hpp          | 21 ++++------
 stan/math/prim/fun/rep_matrix.hpp             |  6 ++-
 stan/math/prim/fun/rep_row_vector.hpp         |  6 ++-
 stan/math/prim/fun/rows_dot_product.hpp       |  4 +-
 stan/math/prim/fun/rows_dot_self.hpp          |  8 ++--
 stan/math/prim/fun/sd.hpp                     |  2 -
 stan/math/prim/fun/singular_values.hpp        |  9 ++--
 stan/math/prim/fun/sub_col.hpp                |  6 ++-
 stan/math/prim/fun/sub_row.hpp                |  6 ++-
 stan/math/prim/fun/subtract.hpp               | 19 ++++++---
 .../prim/fun/symmetrize_from_lower_tri.hpp    |  7 ++--
 .../prim/fun/symmetrize_from_upper_tri.hpp    |  7 ++--
 stan/math/prim/fun/tail.hpp                   |  6 ++-
 stan/math/prim/fun/trace_gen_quad_form.hpp    |  9 ++--
 stan/math/prim/fun/transpose.hpp              |  6 ++-
 stan/math/prim/fun/uniform_simplex.hpp        |  4 +-
 stan/math/prim/fun/variance.hpp               |  4 +-
 stan/math/prim/fun/zeros_vector.hpp           |  3 +-
 test/unit/math/test_ad.hpp                    |  2 +-
 38 files changed, 175 insertions(+), 122 deletions(-)

diff --git a/stan/math/prim/fun/columns_dot_product.hpp b/stan/math/prim/fun/columns_dot_product.hpp
index 2dcb69e2d17..9b92fd8dabd 100644
--- a/stan/math/prim/fun/columns_dot_product.hpp
+++ b/stan/math/prim/fun/columns_dot_product.hpp
@@ -24,10 +24,12 @@ namespace math {
 template <typename Mat1, typename Mat2,
           require_all_eigen_t<Mat1, Mat2>* = nullptr,
           require_all_not_eigen_vt<is_var, Mat1, Mat2>* = nullptr>
-inline Eigen::Matrix<return_type_t<Mat1, Mat2>, 1, Mat1::ColsAtCompileTime>
-columns_dot_product(const Mat1& v1, const Mat2& v2) {
+inline auto columns_dot_product(Mat1&& v1, Mat2&& v2) {
   check_matching_dims("columns_dot_product", "v1", v1, "v2", v2);
-  return v1.cwiseProduct(v2).colwise().sum();
+  return make_holder(
+    [](auto&& v1_, auto&& v2_) {
+      return std::forward<decltype(v1_)>(v1_).cwiseProduct(std::forward<decltype(v2_)>(v2_)).colwise().sum();
+    }, std::forward<Mat1>(v1), std::forward<Mat2>(v2));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/columns_dot_self.hpp b/stan/math/prim/fun/columns_dot_self.hpp
index 3baa49047f1..e444b0c8fe5 100644
--- a/stan/math/prim/fun/columns_dot_self.hpp
+++ b/stan/math/prim/fun/columns_dot_self.hpp
@@ -18,9 +18,10 @@ namespace math {
  */
 template <typename T, require_eigen_t<T>* = nullptr,
           require_not_eigen_vt<is_var, T>* = nullptr>
-inline Eigen::Matrix<value_type_t<T>, 1, T::ColsAtCompileTime> columns_dot_self(
-    const T& x) {
-  return x.colwise().squaredNorm();
+inline auto columns_dot_self(T&& x) {
+  return make_holder([](auto&& x_) {
+    return std::forward<decltype(x_)>(x_).colwise().squaredNorm();
+  }, std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/crossprod.hpp b/stan/math/prim/fun/crossprod.hpp
index d9e868aceed..d83ea697d8b 100644
--- a/stan/math/prim/fun/crossprod.hpp
+++ b/stan/math/prim/fun/crossprod.hpp
@@ -17,8 +17,8 @@ namespace math {
  * @return Transpose of M times M
  */
 template <typename EigMat, require_eigen_t<EigMat>* = nullptr>
-inline auto crossprod(const EigMat& M) {
-  return tcrossprod(M.transpose());
+inline auto crossprod(EigMat&& M) {
+  return tcrossprod(std::forward<EigMat>(M).transpose());
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/diag_matrix.hpp b/stan/math/prim/fun/diag_matrix.hpp
index 89b978e655e..414061ce915 100644
--- a/stan/math/prim/fun/diag_matrix.hpp
+++ b/stan/math/prim/fun/diag_matrix.hpp
@@ -18,8 +18,10 @@ namespace math {
  */
 template <typename EigVec, require_eigen_vector_t<EigVec>* = nullptr>
 inline Eigen::Matrix<value_type_t<EigVec>, Eigen::Dynamic, Eigen::Dynamic>
-diag_matrix(const EigVec& v) {
-  return v.asDiagonal();
+diag_matrix(EigVec&& v) {
+  return make_holder([](auto&& v_) {
+    return v_.asDiagonal();
+  }, std::forward<EigVec>(v));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/diag_post_multiply.hpp b/stan/math/prim/fun/diag_post_multiply.hpp
index 5564618660d..e265f7a8bb6 100644
--- a/stan/math/prim/fun/diag_post_multiply.hpp
+++ b/stan/math/prim/fun/diag_post_multiply.hpp
@@ -22,10 +22,12 @@ namespace math {
 template <typename T1, typename T2, require_eigen_t<T1>* = nullptr,
           require_eigen_vector_t<T2>* = nullptr,
           require_all_not_st_var<T1, T2>* = nullptr>
-auto diag_post_multiply(const T1& m1, const T2& m2) {
+auto diag_post_multiply(T1&& m1, T2&& m2) {
   check_size_match("diag_post_multiply", "m2.size()", m2.size(), "m1.cols()",
                    m1.cols());
-  return m1 * m2.asDiagonal();
+  return make_holder([](auto&& m1_, auto&& m2_) {
+    return std::forward<decltype(m1_)>(m1_) * std::forward<decltype(m2_)>(m2_).asDiagonal();
+  }, std::forward<T1>(m1), std::forward<T2>(m2));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/diag_pre_multiply.hpp b/stan/math/prim/fun/diag_pre_multiply.hpp
index a3ed197b6e2..bd6ce9a627f 100644
--- a/stan/math/prim/fun/diag_pre_multiply.hpp
+++ b/stan/math/prim/fun/diag_pre_multiply.hpp
@@ -22,11 +22,12 @@ namespace math {
 template <typename T1, typename T2, require_eigen_vector_t<T1>* = nullptr,
           require_eigen_t<T2>* = nullptr,
           require_all_not_st_var<T1, T2>* = nullptr>
-auto diag_pre_multiply(const T1& m1, const T2& m2) {
+auto diag_pre_multiply(T1&& m1, T2&& m2) {
   check_size_match("diag_pre_multiply", "m1.size()", m1.size(), "m2.rows()",
                    m2.rows());
-
-  return m1.asDiagonal() * m2;
+  return make_holder([](auto&& m1_, auto&& m2_) {
+    return std::forward<decltype(m1_)>(m1_).asDiagonal() * std::forward<decltype(m2_)>(m2_);
+  }, std::forward<T1>(m1), std::forward<T2>(m2));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/distance.hpp b/stan/math/prim/fun/distance.hpp
index c46e9eed6c4..ec9552a4f49 100644
--- a/stan/math/prim/fun/distance.hpp
+++ b/stan/math/prim/fun/distance.hpp
@@ -44,10 +44,10 @@ inline return_type_t<T1, T2> distance(const T1& x1, const T2& x2) {
  * size.
  */
 template <typename T1, typename T2, require_all_vector_t<T1, T2>* = nullptr>
-inline return_type_t<T1, T2> distance(const T1& x1, const T2& x2) {
+inline return_type_t<T1, T2> distance(T1&& x1, T2&& x2) {
   using std::sqrt;
   check_matching_sizes("distance", "x1", x1, "x2", x2);
-  return sqrt(squared_distance(x1, x2));
+  return sqrt(squared_distance(std::forward<T1>(x1), std::forward<T2>(x2)));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/divide.hpp b/stan/math/prim/fun/divide.hpp
index c15ed453953..9c62ba64461 100644
--- a/stan/math/prim/fun/divide.hpp
+++ b/stan/math/prim/fun/divide.hpp
@@ -43,8 +43,10 @@ inline int divide(int x, int y) {
  */
 template <typename T1, typename T2, require_any_eigen_t<T1, T2>* = nullptr,
           require_all_not_st_var<T1, T2>* = nullptr>
-inline auto divide(const T1& m, const T2& c) {
-  return (as_array_or_scalar(m) / as_array_or_scalar(c)).matrix();
+inline auto divide(T1&& m, T2&& c) {
+  return make_holder([](auto&& m_, auto&& c_) {
+    return (as_array_or_scalar(std::forward<decltype(m_)>(m_)) / as_array_or_scalar(std::forward<decltype(c_)>(c_))).matrix();
+  }, std::forward<T1>(m), std::forward<T2>(c));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/dot_product.hpp b/stan/math/prim/fun/dot_product.hpp
index 1a45c854791..2a6aba9bc80 100644
--- a/stan/math/prim/fun/dot_product.hpp
+++ b/stan/math/prim/fun/dot_product.hpp
@@ -21,9 +21,11 @@ namespace math {
 template <typename Vec1, typename Vec2,
           require_all_eigen_vector_t<Vec1, Vec2> * = nullptr,
           require_not_var_t<return_type_t<Vec1, Vec2>> * = nullptr>
-inline auto dot_product(const Vec1 &v1, const Vec2 &v2) {
+inline auto dot_product(Vec1&& v1, Vec2&&v2) {
   check_matching_sizes("dot_product", "v1", v1, "v2", v2);
-  return v1.dot(v2);
+  return make_holder([](auto&& v1_, auto&& v2_) {
+        return v1_.dot(v2_);
+  }, std::forward<Vec1>(v1), std::forward<Vec2>(v2));
 }
 
 /**
diff --git a/stan/math/prim/fun/dot_self.hpp b/stan/math/prim/fun/dot_self.hpp
index 1ac13c8ffda..7ec1c77f227 100644
--- a/stan/math/prim/fun/dot_self.hpp
+++ b/stan/math/prim/fun/dot_self.hpp
@@ -32,7 +32,7 @@ inline double dot_self(const std::vector<double>& x) {
  */
 template <typename T, require_eigen_t<T>* = nullptr,
           require_not_eigen_vt<is_var, T>* = nullptr>
-inline value_type_t<T> dot_self(T&& v) {
+inline auto dot_self(T&& v) {
   return make_holder([](auto&& v_) { return v_.squaredNorm(); },
                      std::forward<T>(v));
 }
diff --git a/stan/math/prim/fun/elt_divide.hpp b/stan/math/prim/fun/elt_divide.hpp
index d0fedb64bdc..72fc4060e8a 100644
--- a/stan/math/prim/fun/elt_divide.hpp
+++ b/stan/math/prim/fun/elt_divide.hpp
@@ -22,9 +22,12 @@ namespace math {
 template <typename Mat1, typename Mat2,
           require_all_eigen_t<Mat1, Mat2>* = nullptr,
           require_all_not_st_var<Mat1, Mat2>* = nullptr>
-auto elt_divide(const Mat1& m1, const Mat2& m2) {
+inline auto elt_divide(Mat1&& m1, Mat2&& m2) {
   check_matching_dims("elt_divide", "m1", m1, "m2", m2);
-  return (m1.array() / m2.array()).matrix();
+  return make_holder([](auto&& m1_, auto&& m2_) {
+    return (std::forward<decltype(m1_)>(m1_).array()
+        / std::forward<decltype(m2_)>(m2_).array()).matrix();
+  }, std::forward<Mat1>(m1), std::forward<Mat2>(m2));
 }
 
 /**
@@ -40,8 +43,8 @@ auto elt_divide(const Mat1& m1, const Mat2& m2) {
  */
 template <typename Mat, typename Scal, require_matrix_t<Mat>* = nullptr,
           require_stan_scalar_t<Scal>* = nullptr>
-auto elt_divide(const Mat& m, Scal s) {
-  return divide(m, s);
+inline auto elt_divide(Mat&& m, Scal s) {
+  return divide(std::forward<Mat>(m), s);
 }
 
 /**
@@ -57,8 +60,10 @@ auto elt_divide(const Mat& m, Scal s) {
  */
 template <typename Scal, typename Mat, require_stan_scalar_t<Scal>* = nullptr,
           require_eigen_t<Mat>* = nullptr>
-auto elt_divide(Scal s, const Mat& m) {
-  return (s / m.array()).matrix();
+auto elt_divide(Scal s, Mat&& m) {
+  return make_holder([s](auto&& m_) {
+    return (s / std::forward<decltype(m_)>(m_).array()).matrix();
+  }, std::forward<Mat>(m));
 }
 
 template <typename Scal1, typename Scal2,
diff --git a/stan/math/prim/fun/elt_multiply.hpp b/stan/math/prim/fun/elt_multiply.hpp
index bad90c7a26d..aac362c42ca 100644
--- a/stan/math/prim/fun/elt_multiply.hpp
+++ b/stan/math/prim/fun/elt_multiply.hpp
@@ -23,9 +23,11 @@ namespace math {
 template <typename Mat1, typename Mat2,
           require_all_eigen_t<Mat1, Mat2>* = nullptr,
           require_all_not_st_var<Mat1, Mat2>* = nullptr>
-auto elt_multiply(const Mat1& m1, const Mat2& m2) {
+auto elt_multiply(Mat1&& m1, Mat2&& m2) {
   check_matching_dims("elt_multiply", "m1", m1, "m2", m2);
-  return m1.cwiseProduct(m2);
+  return make_holder([](auto&& m1_, auto&& m2_) {
+    return std::forward<decltype(m1_)>(m1_).cwiseProduct(std::forward<decltype(m2_)>(m2_));
+  }, std::forward<Mat1>(m1), std::forward<Mat2>(m2));
 }
 
 /**
@@ -59,8 +61,8 @@ auto elt_multiply(const Scalar1& a, const Scalar2& b) {
  */
 template <typename T1, typename T2, require_any_matrix_t<T1, T2>* = nullptr,
           require_any_stan_scalar_t<T1, T2>* = nullptr>
-inline auto elt_multiply(const T1& A, const T2& B) {
-  return multiply(A, B);
+inline auto elt_multiply(T1&& A, T2&& B) {
+  return multiply(std::forward<T1>(A), std::forward<T2>(B));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/eval.hpp b/stan/math/prim/fun/eval.hpp
index cc7f6718daf..1b2bd48f633 100644
--- a/stan/math/prim/fun/eval.hpp
+++ b/stan/math/prim/fun/eval.hpp
@@ -31,8 +31,8 @@ inline T eval(T&& arg) {
  **/
 template <typename T,
           require_not_same_t<std::decay_t<T>, plain_type_t<T>>* = nullptr>
-inline decltype(auto) eval(const T& arg) {
-  return arg.eval();
+inline auto eval(T&& arg) {
+  return plain_type_t<T>(std::forward<T>(arg));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/fft.hpp b/stan/math/prim/fun/fft.hpp
index 6610a3dd858..6ba250b5180 100644
--- a/stan/math/prim/fun/fft.hpp
+++ b/stan/math/prim/fun/fft.hpp
@@ -32,9 +32,9 @@ namespace math {
  */
 template <typename V, require_eigen_vector_vt<is_complex, V>* = nullptr,
           require_not_var_t<base_type_t<value_type_t<V>>>* = nullptr>
-inline Eigen::Matrix<scalar_type_t<V>, -1, 1> fft(const V& x) {
+inline Eigen::Matrix<scalar_type_t<V>, -1, 1> fft(V&& x) {
   // copy because fft() requires Eigen::Matrix type
-  Eigen::Matrix<scalar_type_t<V>, -1, 1> xv = x;
+  Eigen::Matrix<scalar_type_t<V>, -1, 1> xv = std::forward<V>(x);
   if (xv.size() <= 1)
     return xv;
   Eigen::FFT<base_type_t<V>> fft;
@@ -63,9 +63,9 @@ inline Eigen::Matrix<scalar_type_t<V>, -1, 1> fft(const V& x) {
  */
 template <typename V, require_eigen_vector_vt<is_complex, V>* = nullptr,
           require_not_var_t<base_type_t<value_type_t<V>>>* = nullptr>
-inline Eigen::Matrix<scalar_type_t<V>, -1, 1> inv_fft(const V& y) {
+inline Eigen::Matrix<scalar_type_t<V>, -1, 1> inv_fft(V&& y) {
   // copy because fft() requires Eigen::Matrix type
-  Eigen::Matrix<scalar_type_t<V>, -1, 1> yv = y;
+  Eigen::Matrix<scalar_type_t<V>, -1, 1> yv = std::forward<V>(y);
   if (y.size() <= 1)
     return yv;
   Eigen::FFT<base_type_t<V>> fft;
diff --git a/stan/math/prim/fun/multiply.hpp b/stan/math/prim/fun/multiply.hpp
index 59e220dcaf0..14f4b89699d 100644
--- a/stan/math/prim/fun/multiply.hpp
+++ b/stan/math/prim/fun/multiply.hpp
@@ -24,8 +24,10 @@ template <typename Mat, typename Scal, require_stan_scalar_t<Scal>* = nullptr,
           require_eigen_t<Mat>* = nullptr,
           require_all_not_st_var<Scal, Mat>* = nullptr,
           require_all_not_complex_t<Scal, value_type_t<Mat>>* = nullptr>
-inline auto multiply(const Mat& m, Scal c) {
-  return c * m;
+inline auto multiply(Mat&& m, Scal c) {
+  return make_holder([c](auto&& m_) {
+    return c * std::forward<decltype(m_)>(m_);
+  }, std::forward<Mat>(m));
 }
 
 /**
@@ -43,8 +45,10 @@ inline auto multiply(const Mat& m, Scal c) {
 template <typename Mat, typename Scal,
           require_any_complex_t<value_type_t<Mat>, Scal>* = nullptr,
           require_eigen_t<Mat>* = nullptr, require_not_eigen_t<Scal>* = nullptr>
-inline auto multiply(const Mat& m, Scal c) {
-  return m * c;
+inline auto multiply(Mat&& m, Scal c) {
+  return make_holder([c](auto&& m_) {
+    return c * std::forward<decltype(m_)>(m_);
+  }, std::forward<Mat>(m));
 }
 
 /**
@@ -62,8 +66,10 @@ inline auto multiply(const Mat& m, Scal c) {
 template <typename Mat, typename Scal,
           require_any_complex_t<value_type_t<Mat>, Scal>* = nullptr,
           require_eigen_t<Mat>* = nullptr, require_not_eigen_t<Scal>* = nullptr>
-inline auto multiply(const Scal& m, const Mat& c) {
-  return m * c;
+inline auto multiply(const Scal& c, Mat&& m) {
+  return make_holder([c](auto&& m_) {
+    return std::forward<decltype(m_)>(m_) * c;
+  }, std::forward<Mat>(m));
 }
 
 /**
@@ -80,8 +86,10 @@ template <typename Scal, typename Mat, require_stan_scalar_t<Scal>* = nullptr,
           require_eigen_t<Mat>* = nullptr,
           require_all_not_st_var<Scal, Mat>* = nullptr,
           require_all_not_complex_t<Scal, value_type_t<Mat>>* = nullptr>
-inline auto multiply(Scal c, const Mat& m) {
-  return c * m;
+inline auto multiply(Scal c, Mat&& m) {
+  return make_holder([c](auto&& m_) {
+    return  c * std::forward<decltype(m_)>(m_);
+  }, std::forward<Mat>(m));
 }
 
 /**
@@ -101,10 +109,13 @@ inline auto multiply(Scal c, const Mat& m) {
 template <typename Mat1, typename Mat2,
           require_all_eigen_vt<std::is_arithmetic, Mat1, Mat2>* = nullptr,
           require_not_eigen_row_and_col_t<Mat1, Mat2>* = nullptr>
-inline auto multiply(const Mat1& m1, const Mat2& m2) {
+inline auto multiply(Mat1&& m1, Mat2&& m2) {
   check_size_match("multiply", "Columns of m1", m1.cols(), "Rows of m2",
                    m2.rows());
-  return m1 * m2;
+  return make_holder([](auto&& m1_, auto&& m2_) {
+    return std::forward<decltype(m1_)>(m1_) *
+           std::forward<decltype(m2_)>(m2_);
+  }, std::forward<Mat1>(m1), std::forward<Mat2>(m2));
 }
 
 /**
@@ -125,10 +136,12 @@ template <typename Mat1, typename Mat2,
           require_all_eigen_t<Mat1, Mat2>* = nullptr,
           require_t<is_complex<return_type_t<Mat1, Mat2>>>* = nullptr,
           require_not_eigen_row_and_col_t<Mat1, Mat2>* = nullptr>
-inline auto multiply(const Mat1& m1, const Mat2& m2) {
+inline auto multiply(Mat1&& m1, Mat2&& m2) {
   check_size_match("multiply", "Columns of m1", m1.cols(), "Rows of m2",
                    m2.rows());
-  return m1.lazyProduct(m2).eval();
+  return make_holder([](auto&& m1_, auto&& m2_) {
+    return std::forward<decltype(m1)>(m1_).lazyProduct(std::forward<decltype(m2_)>(m2_));
+  }, std::forward<Mat1>(m1), std::forward<Mat2>(m2));
 }
 
 /**
@@ -147,9 +160,9 @@ inline auto multiply(const Mat1& m1, const Mat2& m2) {
 template <typename RowVec, typename ColVec,
           require_not_var_t<return_type_t<RowVec, ColVec>>* = nullptr,
           require_eigen_row_and_col_t<RowVec, ColVec>* = nullptr>
-inline auto multiply(const RowVec& rv, const ColVec& v) {
+inline auto multiply(RowVec&& rv, ColVec&& v) {
   check_multiplicable("multiply", "rv", rv, "v", v);
-  return dot_product(rv, v);
+  return dot_product(std::forward<RowVec>(rv), std::forward<ColVec>(v));
 }
 
 /**
diff --git a/stan/math/prim/fun/norm1.hpp b/stan/math/prim/fun/norm1.hpp
index a6dd7e08507..b56d40692d0 100644
--- a/stan/math/prim/fun/norm1.hpp
+++ b/stan/math/prim/fun/norm1.hpp
@@ -17,9 +17,10 @@ namespace math {
  * @return L1 norm of v.
  */
 template <typename T, require_eigen_vt<std::is_arithmetic, T>* = nullptr>
-inline double norm1(const T& v) {
-  ref_type_t<T> v_ref = v;
-  return v_ref.template lpNorm<1>();
+inline double norm1(T&& v) {
+  return make_holder([](auto&& v_) {
+    return v_.template lpNorm<1>();
+  }, std::forward<T>(v));
 }
 
 /**
diff --git a/stan/math/prim/fun/norm2.hpp b/stan/math/prim/fun/norm2.hpp
index 235782f9ad5..d5f031999c2 100644
--- a/stan/math/prim/fun/norm2.hpp
+++ b/stan/math/prim/fun/norm2.hpp
@@ -17,9 +17,10 @@ namespace math {
  * @return L2 norm of v.
  */
 template <typename T, require_eigen_vt<std::is_arithmetic, T>* = nullptr>
-inline double norm2(const T& v) {
-  ref_type_t<T> v_ref = v;
-  return v_ref.template lpNorm<2>();
+inline double norm2(T&& v) {
+  return make_holder([](auto&& v_) {
+    return v_.template lpNorm<2>();
+  }, std::forward<T>(v));
 }
 
 /**
diff --git a/stan/math/prim/fun/pseudo_eigenvalues.hpp b/stan/math/prim/fun/pseudo_eigenvalues.hpp
index fd51f25f46e..7fe9eae25bc 100644
--- a/stan/math/prim/fun/pseudo_eigenvalues.hpp
+++ b/stan/math/prim/fun/pseudo_eigenvalues.hpp
@@ -8,7 +8,7 @@ namespace stan {
 namespace math {
 
 template <typename T>
-Eigen::Matrix<T, -1, -1> pseudo_eigenvalues(const Eigen::Matrix<T, -1, -1>& m) {
+inline Eigen::Matrix<T, -1, -1> pseudo_eigenvalues(const Eigen::Matrix<T, -1, -1>& m) {
   check_nonzero_size("pseudo_eigenvalues", "m", m);
   check_square("pseudo_eigenvalues", "m", m);
 
diff --git a/stan/math/prim/fun/quad_form_diag.hpp b/stan/math/prim/fun/quad_form_diag.hpp
index d6db9ae58c1..f948dde074e 100644
--- a/stan/math/prim/fun/quad_form_diag.hpp
+++ b/stan/math/prim/fun/quad_form_diag.hpp
@@ -10,15 +10,13 @@ namespace math {
 
 template <typename EigMat, typename EigVec, require_eigen_t<EigMat>* = nullptr,
           require_eigen_vector_t<EigVec>* = nullptr>
-inline auto quad_form_diag(const EigMat& mat, const EigVec& vec) {
+inline auto quad_form_diag(EigMat&& mat, EigVec&& vec) {
   check_square("quad_form_diag", "mat", mat);
   check_size_match("quad_form_diag", "rows of mat", mat.rows(), "size of vec",
                    vec.size());
-  return make_holder(
-      [](const auto& v, const auto& x) {
-        return v.asDiagonal() * x * v.asDiagonal();
-      },
-      to_ref(vec), to_ref(mat));
+  return make_holder([](auto&& mat_, auto&& vec_) {
+        return vec_.asDiagonal() * std::forward<decltype(mat_)>(mat_) * vec_.asDiagonal();
+  }, std::forward<EigMat>(mat), std::forward<EigVec>(vec));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/quad_form_sym.hpp b/stan/math/prim/fun/quad_form_sym.hpp
index b872285ad95..7b9359d82ae 100644
--- a/stan/math/prim/fun/quad_form_sym.hpp
+++ b/stan/math/prim/fun/quad_form_sym.hpp
@@ -27,16 +27,14 @@ template <typename EigMat1, typename EigMat2,
           require_not_eigen_col_vector_t<EigMat2>* = nullptr,
           require_vt_same<EigMat1, EigMat2>* = nullptr,
           require_all_vt_arithmetic<EigMat1, EigMat2>* = nullptr>
-inline plain_type_t<EigMat2> quad_form_sym(EigMat1&& A, EigMat2&& B) {
+inline plain_type_t<EigMat2> quad_form_sym(const EigMat1& A, const EigMat2& B) {
   check_multiplicable("quad_form_sym", "A", A, "B", B);
-  auto&& A_ref = to_ref(std::forward<EigMat1>(A));
+  const auto& A_ref = to_ref(A);
+  const auto& B_ref = to_ref(B);
   check_symmetric("quad_form_sym", "A", A_ref);
   return make_holder(
-      [](auto&& a, auto&& b) {
-        auto ret = (a.transpose() * a * b).eval();
-        return 0.5 * (ret + ret.transpose());
-      },
-      std::forward<decltype(A_ref)>(A_ref), to_ref(std::forward<EigMat2>(B)));
+      [](const auto& ret) { return 0.5 * (ret + ret.transpose()); },
+      (B_ref.transpose() * A_ref * B_ref).eval());
 }
 
 /**
@@ -55,13 +53,12 @@ template <typename EigMat, typename ColVec, require_eigen_t<EigMat>* = nullptr,
           require_eigen_col_vector_t<ColVec>* = nullptr,
           require_vt_same<EigMat, ColVec>* = nullptr,
           require_all_vt_arithmetic<EigMat, ColVec>* = nullptr>
-inline value_type_t<EigMat> quad_form_sym(EigMat&& A, ColVec&& B) {
+inline value_type_t<EigMat> quad_form_sym(const EigMat& A, const ColVec& B) {
   check_multiplicable("quad_form_sym", "A", A, "B", B);
-  auto&& A_ref = to_ref(std::forward<EigMat>(A));
+  const auto& A_ref = to_ref(A);
+  const auto& B_ref = to_ref(B);
   check_symmetric("quad_form_sym", "A", A_ref);
-  return make_holder([](auto&& a, auto&& b) { return b.dot(a * b); },
-                     std::forward<decltype(A_ref)>(A_ref),
-                     to_ref(std::forward<ColVec>(B)));
+  return B_ref.dot(A_ref * B_ref);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/rep_matrix.hpp b/stan/math/prim/fun/rep_matrix.hpp
index 4b4154a71cf..36a68e39500 100644
--- a/stan/math/prim/fun/rep_matrix.hpp
+++ b/stan/math/prim/fun/rep_matrix.hpp
@@ -21,10 +21,12 @@ namespace math {
 template <typename Ret, typename T,
           require_eigen_matrix_dynamic_vt<is_stan_scalar, Ret>* = nullptr,
           require_stan_scalar_t<T>* = nullptr>
-inline auto rep_matrix(const T& x, int m, int n) {
+inline auto rep_matrix(T&& x, int m, int n) {
   check_nonnegative("rep_matrix", "rows", m);
   check_nonnegative("rep_matrix", "cols", n);
-  return Ret::Constant(m, n, x);
+  return make_holder([m, n](auto&& x_) {
+    return Ret::Constant(m, n, std::forward<decltype(x_)>(x_));
+  }, std::forward<T>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/rep_row_vector.hpp b/stan/math/prim/fun/rep_row_vector.hpp
index abc63e4a773..e2460b329aa 100644
--- a/stan/math/prim/fun/rep_row_vector.hpp
+++ b/stan/math/prim/fun/rep_row_vector.hpp
@@ -10,9 +10,11 @@ namespace math {
 template <typename T_ret, typename T,
           require_eigen_row_vector_t<T_ret>* = nullptr,
           require_stan_scalar_t<T>* = nullptr>
-inline auto rep_row_vector(const T& x, int n) {
+inline auto rep_row_vector(T&& x, int n) {
   check_nonnegative("rep_vector", "n", n);
-  return T_ret::Constant(n, x);
+  return make_holder([n](auto&& x_) {
+    return T_ret::Constant(n, std::forward<decltype(x_)>(x_));
+  }, std::forward<T>(x));
 }
 template <typename T, require_stan_scalar_t<T>* = nullptr>
 inline auto rep_row_vector(const T& x, int n) {
diff --git a/stan/math/prim/fun/rows_dot_product.hpp b/stan/math/prim/fun/rows_dot_product.hpp
index 4d8d1e2371a..8984bda7355 100644
--- a/stan/math/prim/fun/rows_dot_product.hpp
+++ b/stan/math/prim/fun/rows_dot_product.hpp
@@ -24,8 +24,8 @@ namespace math {
 template <typename Mat1, typename Mat2,
           require_all_eigen_t<Mat1, Mat2>* = nullptr,
           require_all_not_eigen_vt<is_var, Mat1, Mat2>* = nullptr>
-inline Eigen::Matrix<return_type_t<Mat1, Mat2>, Mat1::RowsAtCompileTime, 1>
-rows_dot_product(const Mat1& v1, const Mat2& v2) {
+inline Eigen::Matrix<return_type_t<Mat1, Mat2>, std::decay_t<Mat1>::RowsAtCompileTime, 1>
+rows_dot_product(Mat1&& v1, Mat2&& v2) {
   check_matching_dims("rows_dot_product", "v1", v1, "v2", v2);
   return make_holder(
       [](auto&& v1, auto&& v2) {
diff --git a/stan/math/prim/fun/rows_dot_self.hpp b/stan/math/prim/fun/rows_dot_self.hpp
index 0f89aa0963e..eb4633d7c12 100644
--- a/stan/math/prim/fun/rows_dot_self.hpp
+++ b/stan/math/prim/fun/rows_dot_self.hpp
@@ -18,11 +18,9 @@ namespace math {
 template <typename T, require_eigen_t<T>* = nullptr,
           require_not_st_var<T>* = nullptr>
 inline auto rows_dot_self(T&& x) {
-  return make_holder(
-      [](const auto& xx) {
-        return std::forward<decltype(xx)>(xx).rowwise().squaredNorm();
-      },
-      std::forward<T>(x));
+  return make_holder([](const auto& xx) {
+    return std::forward<decltype(xx)>(xx).rowwise().squaredNorm();
+  },std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sd.hpp b/stan/math/prim/fun/sd.hpp
index 8eb4292cfa2..96da88c00f9 100644
--- a/stan/math/prim/fun/sd.hpp
+++ b/stan/math/prim/fun/sd.hpp
@@ -28,11 +28,9 @@ inline auto sd(T&& m) {
   return apply_vector_unary<std::decay_t<T>>::reduce(
       std::forward<T>(m), [](auto&& x) {
         check_nonzero_size("sd", "x", x);
-
         if (x.size() == 1) {
           return scalar_type_t<T>(0.0);
         }
-
         return sqrt(variance(std::forward<decltype(x)>(x)));
       });
 }
diff --git a/stan/math/prim/fun/singular_values.hpp b/stan/math/prim/fun/singular_values.hpp
index 7ade631048f..81e2610b726 100644
--- a/stan/math/prim/fun/singular_values.hpp
+++ b/stan/math/prim/fun/singular_values.hpp
@@ -20,13 +20,14 @@ namespace math {
  */
 template <typename EigMat, require_eigen_matrix_dynamic_t<EigMat>* = nullptr,
           require_not_st_var<EigMat>* = nullptr>
-auto singular_values(const EigMat& m) {
+inline auto singular_values(EigMat&& m) {
   if (unlikely(m.size() == 0)) {
     return Eigen::Matrix<base_type_t<EigMat>, Eigen::Dynamic, 1>(0, 1);
   }
-  return Eigen::JacobiSVD<Eigen::Matrix<value_type_t<EigMat>, Eigen::Dynamic,
-                                        Eigen::Dynamic> >(m)
-      .singularValues();
+  return make_holder([](auto&& m_) {
+    return Eigen::JacobiSVD<Eigen::Matrix<value_type_t<EigMat>, Eigen::Dynamic,
+                                          Eigen::Dynamic>>(std::forward<decltype(m_)>(m_)).singularValues();
+  }, std::forward<EigMat>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sub_col.hpp b/stan/math/prim/fun/sub_col.hpp
index 109a73108f0..ec54abd1cff 100644
--- a/stan/math/prim/fun/sub_col.hpp
+++ b/stan/math/prim/fun/sub_col.hpp
@@ -20,13 +20,15 @@ namespace math {
 template <
     typename T, require_matrix_t<T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
-inline auto sub_col(const T& m, size_t i, size_t j, size_t nrows) {
+inline auto sub_col(T&& m, size_t i, size_t j, size_t nrows) {
   check_row_index("sub_col", "i", m, i);
   if (nrows > 0) {
     check_row_index("sub_col", "i+nrows-1", m, i + nrows - 1);
   }
   check_column_index("sub_col", "j", m, j);
-  return m.col(j - 1).segment(i - 1, nrows);
+  return make_holder([i, j, nrows](auto&& m_) {
+    return std::forward<decltype(m_)>(m_).col(j - 1).segment(i - 1, nrows);
+  }, std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sub_row.hpp b/stan/math/prim/fun/sub_row.hpp
index 737cbd16953..4c6e8313553 100644
--- a/stan/math/prim/fun/sub_row.hpp
+++ b/stan/math/prim/fun/sub_row.hpp
@@ -20,13 +20,15 @@ namespace math {
 template <
     typename T, require_matrix_t<T>* = nullptr,
     require_all_not_nonscalar_prim_or_rev_kernel_expression_t<T>* = nullptr>
-inline auto sub_row(const T& m, size_t i, size_t j, size_t ncols) {
+inline auto sub_row(T&& m, size_t i, size_t j, size_t ncols) {
   check_row_index("sub_row", "i", m, i);
   check_column_index("sub_row", "j", m, j);
   if (ncols > 0) {
     check_column_index("sub_col", "j+ncols-1", m, j + ncols - 1);
   }
-  return m.row(i - 1).segment(j - 1, ncols);
+  return make_holder([i, j, ncols](auto&& m_) {
+    return std::forward<decltype(m_)>(m_).row(i - 1).segment(j - 1, ncols);
+  }, std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/subtract.hpp b/stan/math/prim/fun/subtract.hpp
index 4db3099e86e..152f4ad9770 100644
--- a/stan/math/prim/fun/subtract.hpp
+++ b/stan/math/prim/fun/subtract.hpp
@@ -40,9 +40,12 @@ inline return_type_t<ScalarA, ScalarB> subtract(const ScalarA& a,
 template <typename Mat1, typename Mat2,
           require_all_eigen_t<Mat1, Mat2>* = nullptr,
           require_all_not_st_var<Mat1, Mat2>* = nullptr>
-inline auto subtract(const Mat1& m1, const Mat2& m2) {
+inline auto subtract(Mat1&& m1, Mat2&& m2) {
   check_matching_dims("subtract", "m1", m1, "m2", m2);
-  return m1 - m2;
+  return make_holder([](auto&& m1_, auto&& m2_) {
+    return std::forward<decltype(m1_)>(m1_)
+           - std::forward<decltype(m2_)>(m2_);
+  }, std::forward<Mat1>(m1), std::forward<Mat2>(m2));
 }
 
 /**
@@ -58,8 +61,10 @@ inline auto subtract(const Mat1& m1, const Mat2& m2) {
 template <typename Scal, typename Mat, require_stan_scalar_t<Scal>* = nullptr,
           require_eigen_t<Mat>* = nullptr,
           require_all_not_st_var<Mat, Scal>* = nullptr>
-inline auto subtract(const Scal c, const Mat& m) {
-  return (c - m.array()).matrix();
+inline auto subtract(const Scal c, Mat&& m) {
+  return make_holder([c](auto&& m_) {
+    return (c - std::forward<decltype(m_)>(m_).array()).matrix();
+  }, std::forward<Mat>(m));
 }
 
 /**
@@ -75,8 +80,10 @@ inline auto subtract(const Scal c, const Mat& m) {
 template <typename Mat, typename Scal, require_eigen_t<Mat>* = nullptr,
           require_stan_scalar_t<Scal>* = nullptr,
           require_all_not_st_var<Scal, Mat>* = nullptr>
-inline auto subtract(const Mat& m, const Scal c) {
-  return (m.array() - c).matrix();
+inline auto subtract(Mat&& m, const Scal c) {
+  return make_holder([c](auto&& m_) {
+    return (std::forward<decltype(m_)>(m_).array() - c).matrix();
+  }, std::forward<Mat>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/symmetrize_from_lower_tri.hpp b/stan/math/prim/fun/symmetrize_from_lower_tri.hpp
index 8d8a7927812..4e1addb07a0 100644
--- a/stan/math/prim/fun/symmetrize_from_lower_tri.hpp
+++ b/stan/math/prim/fun/symmetrize_from_lower_tri.hpp
@@ -16,10 +16,11 @@ namespace math {
  * @throw std:invalid_argument if the matrix is not square.
  */
 template <typename T, require_eigen_t<T>* = nullptr>
-inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic>
-symmetrize_from_lower_tri(const T& m) {
+inline auto symmetrize_from_lower_tri(T&& m) {
   check_square("symmetrize_from_lower_tri", "m", m);
-  return m.template selfadjointView<Eigen::Lower>();
+  return make_holder([](auto&& m_) {
+   return std::forward<decltype(m_)>(m_).template selfadjointView<Eigen::Lower>();
+  }, std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/symmetrize_from_upper_tri.hpp b/stan/math/prim/fun/symmetrize_from_upper_tri.hpp
index fc10a08d2ef..fef2138fa2d 100644
--- a/stan/math/prim/fun/symmetrize_from_upper_tri.hpp
+++ b/stan/math/prim/fun/symmetrize_from_upper_tri.hpp
@@ -16,10 +16,11 @@ namespace math {
  * @throw std:invalid_argument if the matrix is not square.
  */
 template <typename T, require_eigen_t<T>* = nullptr>
-inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic>
-symmetrize_from_upper_tri(const T& m) {
+inline auto symmetrize_from_upper_tri(T&& m) {
   check_square("symmetrize_from_upper_tri", "m", m);
-  return m.template selfadjointView<Eigen::Upper>();
+  return make_holder([](auto&& m_) {
+   return std::forward<decltype(m_)>(m_).template selfadjointView<Eigen::Upper>();
+  }, std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/tail.hpp b/stan/math/prim/fun/tail.hpp
index 09697a91799..d88f991b0b5 100644
--- a/stan/math/prim/fun/tail.hpp
+++ b/stan/math/prim/fun/tail.hpp
@@ -20,11 +20,13 @@ namespace math {
  * @throw std::out_of_range if n is out of range.
  */
 template <typename T, require_vector_t<T>* = nullptr>
-inline auto tail(const T& v, size_t n) {
+inline auto tail(T&& v, size_t n) {
   if (n != 0) {
     check_vector_index("tail", "n", v, n);
   }
-  return v.tail(n);
+  return make_holder([n](auto&& v_) {
+    return std::forward<decltype(v_)>(v_).tail(n);
+  }, std::forward<T>(v));
 }
 
 /**
diff --git a/stan/math/prim/fun/trace_gen_quad_form.hpp b/stan/math/prim/fun/trace_gen_quad_form.hpp
index 63a0a5a8a10..41183a17e4b 100644
--- a/stan/math/prim/fun/trace_gen_quad_form.hpp
+++ b/stan/math/prim/fun/trace_gen_quad_form.hpp
@@ -33,13 +33,16 @@ template <typename TD, typename TA, typename TB,
           typename = require_all_eigen_t<TD, TA, TB>,
           typename = require_all_not_vt_var<TD, TA, TB>,
           typename = require_any_not_vt_arithmetic<TD, TA, TB>>
-inline auto trace_gen_quad_form(const TD& D, const TA& A, const TB& B) {
+inline auto trace_gen_quad_form(TD&& D, TA&& A, TB&& B) {
   check_square("trace_gen_quad_form", "A", A);
   check_square("trace_gen_quad_form", "D", D);
   check_multiplicable("trace_gen_quad_form", "A", A, "B", B);
   check_multiplicable("trace_gen_quad_form", "B", B, "D", D);
-  const auto& B_ref = to_ref(B);
-  return multiply(B_ref, D.transpose()).cwiseProduct(multiply(A, B_ref)).sum();
+  return make_holder([](auto&& D_, auto&& A_, auto&& B_) {
+    auto&& B_ref = to_ref(std::forward<decltype(B_)>(B_));
+    return multiply(B_ref, std::forward<decltype(D_)>(D_).transpose()).cwiseProduct(multiply(std::forward<decltype(A_)>(A_), B_ref)).sum();
+  }, std::forward<TD>(D), std::forward<TA>(A),
+     std::forward<TB>(B));
 }
 
 /**
diff --git a/stan/math/prim/fun/transpose.hpp b/stan/math/prim/fun/transpose.hpp
index 39cb2dcaf73..b46245a4a63 100644
--- a/stan/math/prim/fun/transpose.hpp
+++ b/stan/math/prim/fun/transpose.hpp
@@ -14,8 +14,10 @@ namespace math {
  * @return transposed matrix
  */
 template <typename T, require_matrix_t<T>* = nullptr>
-auto inline transpose(const T& m) {
-  return m.transpose();
+auto inline transpose(T&& m) {
+  return make_holder([](auto&& m_) {
+    return std::forward<decltype(m_)>(m_).transpose();
+  }, std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/uniform_simplex.hpp b/stan/math/prim/fun/uniform_simplex.hpp
index bc18d34f9ad..483ead24712 100644
--- a/stan/math/prim/fun/uniform_simplex.hpp
+++ b/stan/math/prim/fun/uniform_simplex.hpp
@@ -17,7 +17,9 @@ namespace math {
  */
 inline auto uniform_simplex(int K) {
   check_positive("uniform_simplex", "size", K);
-  return Eigen::VectorXd::Constant(K, 1.0 / K);
+  return make_holder([](int K) {
+    return Eigen::VectorXd::Constant(K, 1.0 / K);
+  }, K);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/variance.hpp b/stan/math/prim/fun/variance.hpp
index 072be627b1c..2691b8beac6 100644
--- a/stan/math/prim/fun/variance.hpp
+++ b/stan/math/prim/fun/variance.hpp
@@ -22,9 +22,9 @@ namespace math {
  */
 template <typename EigMat, require_eigen_t<EigMat>* = nullptr,
           require_not_vt_var<EigMat>* = nullptr>
-inline value_type_t<EigMat> variance(const EigMat& m) {
+inline value_type_t<EigMat> variance(EigMat&& m) {
   using value_t = value_type_t<EigMat>;
-  const auto& mat = to_ref(m);
+  auto&& mat = to_ref(std::forward<EigMat>(m));
   check_nonzero_size("variance", "m", mat);
   if (mat.size() == 1) {
     return value_t{0.0};
diff --git a/stan/math/prim/fun/zeros_vector.hpp b/stan/math/prim/fun/zeros_vector.hpp
index f4cf80e3589..5903a033ba4 100644
--- a/stan/math/prim/fun/zeros_vector.hpp
+++ b/stan/math/prim/fun/zeros_vector.hpp
@@ -16,7 +16,8 @@ namespace math {
  */
 inline auto zeros_vector(int K) {
   check_nonnegative("zeros_vector", "size", K);
-  return Eigen::VectorXd::Zero(K);
+  return make_holder(
+      [](int k) { return Eigen::VectorXd::Zero(k); }, K);
 }
 
 }  // namespace math
diff --git a/test/unit/math/test_ad.hpp b/test/unit/math/test_ad.hpp
index bc6f186c901..12cb15c1517 100644
--- a/test/unit/math/test_ad.hpp
+++ b/test/unit/math/test_ad.hpp
@@ -84,7 +84,7 @@ auto eval(const stan::math::fvar<T>& x) {
  */
 template <typename Derived>
 auto eval(const Eigen::EigenBase<Derived>& x) {
-  return x.derived().eval();
+  return stan::plain_type_t<Derived>(x);
 }
 
 /**

From 92e40765941da441fafbb68b2a1863d4a4943a4b Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Wed, 2 Jul 2025 13:10:43 -0400
Subject: [PATCH 14/31] [Jenkins] auto-formatting by clang-format version
 10.0.0-4ubuntu1

---
 stan/math/prim/fun/columns_dot_product.hpp    | 10 +++--
 stan/math/prim/fun/columns_dot_self.hpp       |  8 ++--
 stan/math/prim/fun/diag_matrix.hpp            |  5 +--
 stan/math/prim/fun/diag_post_multiply.hpp     |  9 ++--
 stan/math/prim/fun/diag_pre_multiply.hpp      |  9 ++--
 stan/math/prim/fun/divide.hpp                 | 10 +++--
 stan/math/prim/fun/dot_product.hpp            |  7 ++-
 stan/math/prim/fun/elt_divide.hpp             | 19 +++++---
 stan/math/prim/fun/elt_multiply.hpp           |  9 ++--
 stan/math/prim/fun/multiply.hpp               | 43 +++++++++++--------
 stan/math/prim/fun/norm1.hpp                  |  5 +--
 stan/math/prim/fun/norm2.hpp                  |  5 +--
 stan/math/prim/fun/pseudo_eigenvalues.hpp     |  3 +-
 stan/math/prim/fun/quad_form_diag.hpp         |  9 ++--
 stan/math/prim/fun/rep_matrix.hpp             |  8 ++--
 stan/math/prim/fun/rep_row_vector.hpp         |  8 ++--
 stan/math/prim/fun/rows_dot_product.hpp       |  3 +-
 stan/math/prim/fun/rows_dot_self.hpp          |  8 ++--
 stan/math/prim/fun/singular_values.hpp        | 12 ++++--
 stan/math/prim/fun/sub_col.hpp                |  8 ++--
 stan/math/prim/fun/sub_row.hpp                |  8 ++--
 stan/math/prim/fun/subtract.hpp               | 26 ++++++-----
 .../prim/fun/symmetrize_from_lower_tri.hpp    |  9 ++--
 .../prim/fun/symmetrize_from_upper_tri.hpp    |  9 ++--
 stan/math/prim/fun/tail.hpp                   |  6 +--
 stan/math/prim/fun/trace_gen_quad_form.hpp    | 13 +++---
 stan/math/prim/fun/transpose.hpp              |  6 +--
 stan/math/prim/fun/uniform_simplex.hpp        |  5 +--
 stan/math/prim/fun/zeros_vector.hpp           |  3 +-
 29 files changed, 170 insertions(+), 113 deletions(-)

diff --git a/stan/math/prim/fun/columns_dot_product.hpp b/stan/math/prim/fun/columns_dot_product.hpp
index 9b92fd8dabd..8449e194598 100644
--- a/stan/math/prim/fun/columns_dot_product.hpp
+++ b/stan/math/prim/fun/columns_dot_product.hpp
@@ -27,9 +27,13 @@ template <typename Mat1, typename Mat2,
 inline auto columns_dot_product(Mat1&& v1, Mat2&& v2) {
   check_matching_dims("columns_dot_product", "v1", v1, "v2", v2);
   return make_holder(
-    [](auto&& v1_, auto&& v2_) {
-      return std::forward<decltype(v1_)>(v1_).cwiseProduct(std::forward<decltype(v2_)>(v2_)).colwise().sum();
-    }, std::forward<Mat1>(v1), std::forward<Mat2>(v2));
+      [](auto&& v1_, auto&& v2_) {
+        return std::forward<decltype(v1_)>(v1_)
+            .cwiseProduct(std::forward<decltype(v2_)>(v2_))
+            .colwise()
+            .sum();
+      },
+      std::forward<Mat1>(v1), std::forward<Mat2>(v2));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/columns_dot_self.hpp b/stan/math/prim/fun/columns_dot_self.hpp
index e444b0c8fe5..941d84a92c5 100644
--- a/stan/math/prim/fun/columns_dot_self.hpp
+++ b/stan/math/prim/fun/columns_dot_self.hpp
@@ -19,9 +19,11 @@ namespace math {
 template <typename T, require_eigen_t<T>* = nullptr,
           require_not_eigen_vt<is_var, T>* = nullptr>
 inline auto columns_dot_self(T&& x) {
-  return make_holder([](auto&& x_) {
-    return std::forward<decltype(x_)>(x_).colwise().squaredNorm();
-  }, std::forward<T>(x));
+  return make_holder(
+      [](auto&& x_) {
+        return std::forward<decltype(x_)>(x_).colwise().squaredNorm();
+      },
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/diag_matrix.hpp b/stan/math/prim/fun/diag_matrix.hpp
index 414061ce915..47902f9e2d8 100644
--- a/stan/math/prim/fun/diag_matrix.hpp
+++ b/stan/math/prim/fun/diag_matrix.hpp
@@ -19,9 +19,8 @@ namespace math {
 template <typename EigVec, require_eigen_vector_t<EigVec>* = nullptr>
 inline Eigen::Matrix<value_type_t<EigVec>, Eigen::Dynamic, Eigen::Dynamic>
 diag_matrix(EigVec&& v) {
-  return make_holder([](auto&& v_) {
-    return v_.asDiagonal();
-  }, std::forward<EigVec>(v));
+  return make_holder([](auto&& v_) { return v_.asDiagonal(); },
+                     std::forward<EigVec>(v));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/diag_post_multiply.hpp b/stan/math/prim/fun/diag_post_multiply.hpp
index e265f7a8bb6..34c879e3920 100644
--- a/stan/math/prim/fun/diag_post_multiply.hpp
+++ b/stan/math/prim/fun/diag_post_multiply.hpp
@@ -25,9 +25,12 @@ template <typename T1, typename T2, require_eigen_t<T1>* = nullptr,
 auto diag_post_multiply(T1&& m1, T2&& m2) {
   check_size_match("diag_post_multiply", "m2.size()", m2.size(), "m1.cols()",
                    m1.cols());
-  return make_holder([](auto&& m1_, auto&& m2_) {
-    return std::forward<decltype(m1_)>(m1_) * std::forward<decltype(m2_)>(m2_).asDiagonal();
-  }, std::forward<T1>(m1), std::forward<T2>(m2));
+  return make_holder(
+      [](auto&& m1_, auto&& m2_) {
+        return std::forward<decltype(m1_)>(m1_)
+               * std::forward<decltype(m2_)>(m2_).asDiagonal();
+      },
+      std::forward<T1>(m1), std::forward<T2>(m2));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/diag_pre_multiply.hpp b/stan/math/prim/fun/diag_pre_multiply.hpp
index bd6ce9a627f..13dec0e71a7 100644
--- a/stan/math/prim/fun/diag_pre_multiply.hpp
+++ b/stan/math/prim/fun/diag_pre_multiply.hpp
@@ -25,9 +25,12 @@ template <typename T1, typename T2, require_eigen_vector_t<T1>* = nullptr,
 auto diag_pre_multiply(T1&& m1, T2&& m2) {
   check_size_match("diag_pre_multiply", "m1.size()", m1.size(), "m2.rows()",
                    m2.rows());
-  return make_holder([](auto&& m1_, auto&& m2_) {
-    return std::forward<decltype(m1_)>(m1_).asDiagonal() * std::forward<decltype(m2_)>(m2_);
-  }, std::forward<T1>(m1), std::forward<T2>(m2));
+  return make_holder(
+      [](auto&& m1_, auto&& m2_) {
+        return std::forward<decltype(m1_)>(m1_).asDiagonal()
+               * std::forward<decltype(m2_)>(m2_);
+      },
+      std::forward<T1>(m1), std::forward<T2>(m2));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/divide.hpp b/stan/math/prim/fun/divide.hpp
index 9c62ba64461..84b5d35a4bb 100644
--- a/stan/math/prim/fun/divide.hpp
+++ b/stan/math/prim/fun/divide.hpp
@@ -44,9 +44,13 @@ inline int divide(int x, int y) {
 template <typename T1, typename T2, require_any_eigen_t<T1, T2>* = nullptr,
           require_all_not_st_var<T1, T2>* = nullptr>
 inline auto divide(T1&& m, T2&& c) {
-  return make_holder([](auto&& m_, auto&& c_) {
-    return (as_array_or_scalar(std::forward<decltype(m_)>(m_)) / as_array_or_scalar(std::forward<decltype(c_)>(c_))).matrix();
-  }, std::forward<T1>(m), std::forward<T2>(c));
+  return make_holder(
+      [](auto&& m_, auto&& c_) {
+        return (as_array_or_scalar(std::forward<decltype(m_)>(m_))
+                / as_array_or_scalar(std::forward<decltype(c_)>(c_)))
+            .matrix();
+      },
+      std::forward<T1>(m), std::forward<T2>(c));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/dot_product.hpp b/stan/math/prim/fun/dot_product.hpp
index 2a6aba9bc80..d5c879a3194 100644
--- a/stan/math/prim/fun/dot_product.hpp
+++ b/stan/math/prim/fun/dot_product.hpp
@@ -21,11 +21,10 @@ namespace math {
 template <typename Vec1, typename Vec2,
           require_all_eigen_vector_t<Vec1, Vec2> * = nullptr,
           require_not_var_t<return_type_t<Vec1, Vec2>> * = nullptr>
-inline auto dot_product(Vec1&& v1, Vec2&&v2) {
+inline auto dot_product(Vec1 &&v1, Vec2 &&v2) {
   check_matching_sizes("dot_product", "v1", v1, "v2", v2);
-  return make_holder([](auto&& v1_, auto&& v2_) {
-        return v1_.dot(v2_);
-  }, std::forward<Vec1>(v1), std::forward<Vec2>(v2));
+  return make_holder([](auto &&v1_, auto &&v2_) { return v1_.dot(v2_); },
+                     std::forward<Vec1>(v1), std::forward<Vec2>(v2));
 }
 
 /**
diff --git a/stan/math/prim/fun/elt_divide.hpp b/stan/math/prim/fun/elt_divide.hpp
index 72fc4060e8a..14d192d8c82 100644
--- a/stan/math/prim/fun/elt_divide.hpp
+++ b/stan/math/prim/fun/elt_divide.hpp
@@ -24,10 +24,13 @@ template <typename Mat1, typename Mat2,
           require_all_not_st_var<Mat1, Mat2>* = nullptr>
 inline auto elt_divide(Mat1&& m1, Mat2&& m2) {
   check_matching_dims("elt_divide", "m1", m1, "m2", m2);
-  return make_holder([](auto&& m1_, auto&& m2_) {
-    return (std::forward<decltype(m1_)>(m1_).array()
-        / std::forward<decltype(m2_)>(m2_).array()).matrix();
-  }, std::forward<Mat1>(m1), std::forward<Mat2>(m2));
+  return make_holder(
+      [](auto&& m1_, auto&& m2_) {
+        return (std::forward<decltype(m1_)>(m1_).array()
+                / std::forward<decltype(m2_)>(m2_).array())
+            .matrix();
+      },
+      std::forward<Mat1>(m1), std::forward<Mat2>(m2));
 }
 
 /**
@@ -61,9 +64,11 @@ inline auto elt_divide(Mat&& m, Scal s) {
 template <typename Scal, typename Mat, require_stan_scalar_t<Scal>* = nullptr,
           require_eigen_t<Mat>* = nullptr>
 auto elt_divide(Scal s, Mat&& m) {
-  return make_holder([s](auto&& m_) {
-    return (s / std::forward<decltype(m_)>(m_).array()).matrix();
-  }, std::forward<Mat>(m));
+  return make_holder(
+      [s](auto&& m_) {
+        return (s / std::forward<decltype(m_)>(m_).array()).matrix();
+      },
+      std::forward<Mat>(m));
 }
 
 template <typename Scal1, typename Scal2,
diff --git a/stan/math/prim/fun/elt_multiply.hpp b/stan/math/prim/fun/elt_multiply.hpp
index aac362c42ca..8bcb81e495e 100644
--- a/stan/math/prim/fun/elt_multiply.hpp
+++ b/stan/math/prim/fun/elt_multiply.hpp
@@ -25,9 +25,12 @@ template <typename Mat1, typename Mat2,
           require_all_not_st_var<Mat1, Mat2>* = nullptr>
 auto elt_multiply(Mat1&& m1, Mat2&& m2) {
   check_matching_dims("elt_multiply", "m1", m1, "m2", m2);
-  return make_holder([](auto&& m1_, auto&& m2_) {
-    return std::forward<decltype(m1_)>(m1_).cwiseProduct(std::forward<decltype(m2_)>(m2_));
-  }, std::forward<Mat1>(m1), std::forward<Mat2>(m2));
+  return make_holder(
+      [](auto&& m1_, auto&& m2_) {
+        return std::forward<decltype(m1_)>(m1_).cwiseProduct(
+            std::forward<decltype(m2_)>(m2_));
+      },
+      std::forward<Mat1>(m1), std::forward<Mat2>(m2));
 }
 
 /**
diff --git a/stan/math/prim/fun/multiply.hpp b/stan/math/prim/fun/multiply.hpp
index 14f4b89699d..3e3668c5cc3 100644
--- a/stan/math/prim/fun/multiply.hpp
+++ b/stan/math/prim/fun/multiply.hpp
@@ -25,9 +25,9 @@ template <typename Mat, typename Scal, require_stan_scalar_t<Scal>* = nullptr,
           require_all_not_st_var<Scal, Mat>* = nullptr,
           require_all_not_complex_t<Scal, value_type_t<Mat>>* = nullptr>
 inline auto multiply(Mat&& m, Scal c) {
-  return make_holder([c](auto&& m_) {
-    return c * std::forward<decltype(m_)>(m_);
-  }, std::forward<Mat>(m));
+  return make_holder(
+      [c](auto&& m_) { return c * std::forward<decltype(m_)>(m_); },
+      std::forward<Mat>(m));
 }
 
 /**
@@ -46,9 +46,9 @@ template <typename Mat, typename Scal,
           require_any_complex_t<value_type_t<Mat>, Scal>* = nullptr,
           require_eigen_t<Mat>* = nullptr, require_not_eigen_t<Scal>* = nullptr>
 inline auto multiply(Mat&& m, Scal c) {
-  return make_holder([c](auto&& m_) {
-    return c * std::forward<decltype(m_)>(m_);
-  }, std::forward<Mat>(m));
+  return make_holder(
+      [c](auto&& m_) { return c * std::forward<decltype(m_)>(m_); },
+      std::forward<Mat>(m));
 }
 
 /**
@@ -67,9 +67,9 @@ template <typename Mat, typename Scal,
           require_any_complex_t<value_type_t<Mat>, Scal>* = nullptr,
           require_eigen_t<Mat>* = nullptr, require_not_eigen_t<Scal>* = nullptr>
 inline auto multiply(const Scal& c, Mat&& m) {
-  return make_holder([c](auto&& m_) {
-    return std::forward<decltype(m_)>(m_) * c;
-  }, std::forward<Mat>(m));
+  return make_holder(
+      [c](auto&& m_) { return std::forward<decltype(m_)>(m_) * c; },
+      std::forward<Mat>(m));
 }
 
 /**
@@ -87,9 +87,9 @@ template <typename Scal, typename Mat, require_stan_scalar_t<Scal>* = nullptr,
           require_all_not_st_var<Scal, Mat>* = nullptr,
           require_all_not_complex_t<Scal, value_type_t<Mat>>* = nullptr>
 inline auto multiply(Scal c, Mat&& m) {
-  return make_holder([c](auto&& m_) {
-    return  c * std::forward<decltype(m_)>(m_);
-  }, std::forward<Mat>(m));
+  return make_holder(
+      [c](auto&& m_) { return c * std::forward<decltype(m_)>(m_); },
+      std::forward<Mat>(m));
 }
 
 /**
@@ -112,10 +112,12 @@ template <typename Mat1, typename Mat2,
 inline auto multiply(Mat1&& m1, Mat2&& m2) {
   check_size_match("multiply", "Columns of m1", m1.cols(), "Rows of m2",
                    m2.rows());
-  return make_holder([](auto&& m1_, auto&& m2_) {
-    return std::forward<decltype(m1_)>(m1_) *
-           std::forward<decltype(m2_)>(m2_);
-  }, std::forward<Mat1>(m1), std::forward<Mat2>(m2));
+  return make_holder(
+      [](auto&& m1_, auto&& m2_) {
+        return std::forward<decltype(m1_)>(m1_)
+               * std::forward<decltype(m2_)>(m2_);
+      },
+      std::forward<Mat1>(m1), std::forward<Mat2>(m2));
 }
 
 /**
@@ -139,9 +141,12 @@ template <typename Mat1, typename Mat2,
 inline auto multiply(Mat1&& m1, Mat2&& m2) {
   check_size_match("multiply", "Columns of m1", m1.cols(), "Rows of m2",
                    m2.rows());
-  return make_holder([](auto&& m1_, auto&& m2_) {
-    return std::forward<decltype(m1)>(m1_).lazyProduct(std::forward<decltype(m2_)>(m2_));
-  }, std::forward<Mat1>(m1), std::forward<Mat2>(m2));
+  return make_holder(
+      [](auto&& m1_, auto&& m2_) {
+        return std::forward<decltype(m1)>(m1_).lazyProduct(
+            std::forward<decltype(m2_)>(m2_));
+      },
+      std::forward<Mat1>(m1), std::forward<Mat2>(m2));
 }
 
 /**
diff --git a/stan/math/prim/fun/norm1.hpp b/stan/math/prim/fun/norm1.hpp
index b56d40692d0..fd29bf4f70b 100644
--- a/stan/math/prim/fun/norm1.hpp
+++ b/stan/math/prim/fun/norm1.hpp
@@ -18,9 +18,8 @@ namespace math {
  */
 template <typename T, require_eigen_vt<std::is_arithmetic, T>* = nullptr>
 inline double norm1(T&& v) {
-  return make_holder([](auto&& v_) {
-    return v_.template lpNorm<1>();
-  }, std::forward<T>(v));
+  return make_holder([](auto&& v_) { return v_.template lpNorm<1>(); },
+                     std::forward<T>(v));
 }
 
 /**
diff --git a/stan/math/prim/fun/norm2.hpp b/stan/math/prim/fun/norm2.hpp
index d5f031999c2..5dbe0ed02b5 100644
--- a/stan/math/prim/fun/norm2.hpp
+++ b/stan/math/prim/fun/norm2.hpp
@@ -18,9 +18,8 @@ namespace math {
  */
 template <typename T, require_eigen_vt<std::is_arithmetic, T>* = nullptr>
 inline double norm2(T&& v) {
-  return make_holder([](auto&& v_) {
-    return v_.template lpNorm<2>();
-  }, std::forward<T>(v));
+  return make_holder([](auto&& v_) { return v_.template lpNorm<2>(); },
+                     std::forward<T>(v));
 }
 
 /**
diff --git a/stan/math/prim/fun/pseudo_eigenvalues.hpp b/stan/math/prim/fun/pseudo_eigenvalues.hpp
index 7fe9eae25bc..7ad4d51cb2b 100644
--- a/stan/math/prim/fun/pseudo_eigenvalues.hpp
+++ b/stan/math/prim/fun/pseudo_eigenvalues.hpp
@@ -8,7 +8,8 @@ namespace stan {
 namespace math {
 
 template <typename T>
-inline Eigen::Matrix<T, -1, -1> pseudo_eigenvalues(const Eigen::Matrix<T, -1, -1>& m) {
+inline Eigen::Matrix<T, -1, -1> pseudo_eigenvalues(
+    const Eigen::Matrix<T, -1, -1>& m) {
   check_nonzero_size("pseudo_eigenvalues", "m", m);
   check_square("pseudo_eigenvalues", "m", m);
 
diff --git a/stan/math/prim/fun/quad_form_diag.hpp b/stan/math/prim/fun/quad_form_diag.hpp
index f948dde074e..ffe00afb651 100644
--- a/stan/math/prim/fun/quad_form_diag.hpp
+++ b/stan/math/prim/fun/quad_form_diag.hpp
@@ -14,9 +14,12 @@ inline auto quad_form_diag(EigMat&& mat, EigVec&& vec) {
   check_square("quad_form_diag", "mat", mat);
   check_size_match("quad_form_diag", "rows of mat", mat.rows(), "size of vec",
                    vec.size());
-  return make_holder([](auto&& mat_, auto&& vec_) {
-        return vec_.asDiagonal() * std::forward<decltype(mat_)>(mat_) * vec_.asDiagonal();
-  }, std::forward<EigMat>(mat), std::forward<EigVec>(vec));
+  return make_holder(
+      [](auto&& mat_, auto&& vec_) {
+        return vec_.asDiagonal() * std::forward<decltype(mat_)>(mat_)
+               * vec_.asDiagonal();
+      },
+      std::forward<EigMat>(mat), std::forward<EigVec>(vec));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/rep_matrix.hpp b/stan/math/prim/fun/rep_matrix.hpp
index 36a68e39500..c6311495471 100644
--- a/stan/math/prim/fun/rep_matrix.hpp
+++ b/stan/math/prim/fun/rep_matrix.hpp
@@ -24,9 +24,11 @@ template <typename Ret, typename T,
 inline auto rep_matrix(T&& x, int m, int n) {
   check_nonnegative("rep_matrix", "rows", m);
   check_nonnegative("rep_matrix", "cols", n);
-  return make_holder([m, n](auto&& x_) {
-    return Ret::Constant(m, n, std::forward<decltype(x_)>(x_));
-  }, std::forward<T>(x));
+  return make_holder(
+      [m, n](auto&& x_) {
+        return Ret::Constant(m, n, std::forward<decltype(x_)>(x_));
+      },
+      std::forward<T>(x));
 }
 
 /**
diff --git a/stan/math/prim/fun/rep_row_vector.hpp b/stan/math/prim/fun/rep_row_vector.hpp
index e2460b329aa..983e64aaabc 100644
--- a/stan/math/prim/fun/rep_row_vector.hpp
+++ b/stan/math/prim/fun/rep_row_vector.hpp
@@ -12,9 +12,11 @@ template <typename T_ret, typename T,
           require_stan_scalar_t<T>* = nullptr>
 inline auto rep_row_vector(T&& x, int n) {
   check_nonnegative("rep_vector", "n", n);
-  return make_holder([n](auto&& x_) {
-    return T_ret::Constant(n, std::forward<decltype(x_)>(x_));
-  }, std::forward<T>(x));
+  return make_holder(
+      [n](auto&& x_) {
+        return T_ret::Constant(n, std::forward<decltype(x_)>(x_));
+      },
+      std::forward<T>(x));
 }
 template <typename T, require_stan_scalar_t<T>* = nullptr>
 inline auto rep_row_vector(const T& x, int n) {
diff --git a/stan/math/prim/fun/rows_dot_product.hpp b/stan/math/prim/fun/rows_dot_product.hpp
index 8984bda7355..8b2b2c28fa3 100644
--- a/stan/math/prim/fun/rows_dot_product.hpp
+++ b/stan/math/prim/fun/rows_dot_product.hpp
@@ -24,7 +24,8 @@ namespace math {
 template <typename Mat1, typename Mat2,
           require_all_eigen_t<Mat1, Mat2>* = nullptr,
           require_all_not_eigen_vt<is_var, Mat1, Mat2>* = nullptr>
-inline Eigen::Matrix<return_type_t<Mat1, Mat2>, std::decay_t<Mat1>::RowsAtCompileTime, 1>
+inline Eigen::Matrix<return_type_t<Mat1, Mat2>,
+                     std::decay_t<Mat1>::RowsAtCompileTime, 1>
 rows_dot_product(Mat1&& v1, Mat2&& v2) {
   check_matching_dims("rows_dot_product", "v1", v1, "v2", v2);
   return make_holder(
diff --git a/stan/math/prim/fun/rows_dot_self.hpp b/stan/math/prim/fun/rows_dot_self.hpp
index eb4633d7c12..0f89aa0963e 100644
--- a/stan/math/prim/fun/rows_dot_self.hpp
+++ b/stan/math/prim/fun/rows_dot_self.hpp
@@ -18,9 +18,11 @@ namespace math {
 template <typename T, require_eigen_t<T>* = nullptr,
           require_not_st_var<T>* = nullptr>
 inline auto rows_dot_self(T&& x) {
-  return make_holder([](const auto& xx) {
-    return std::forward<decltype(xx)>(xx).rowwise().squaredNorm();
-  },std::forward<T>(x));
+  return make_holder(
+      [](const auto& xx) {
+        return std::forward<decltype(xx)>(xx).rowwise().squaredNorm();
+      },
+      std::forward<T>(x));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/singular_values.hpp b/stan/math/prim/fun/singular_values.hpp
index 81e2610b726..bdac47b559d 100644
--- a/stan/math/prim/fun/singular_values.hpp
+++ b/stan/math/prim/fun/singular_values.hpp
@@ -24,10 +24,14 @@ inline auto singular_values(EigMat&& m) {
   if (unlikely(m.size() == 0)) {
     return Eigen::Matrix<base_type_t<EigMat>, Eigen::Dynamic, 1>(0, 1);
   }
-  return make_holder([](auto&& m_) {
-    return Eigen::JacobiSVD<Eigen::Matrix<value_type_t<EigMat>, Eigen::Dynamic,
-                                          Eigen::Dynamic>>(std::forward<decltype(m_)>(m_)).singularValues();
-  }, std::forward<EigMat>(m));
+  return make_holder(
+      [](auto&& m_) {
+        return Eigen::JacobiSVD<Eigen::Matrix<value_type_t<EigMat>,
+                                              Eigen::Dynamic, Eigen::Dynamic>>(
+                   std::forward<decltype(m_)>(m_))
+            .singularValues();
+      },
+      std::forward<EigMat>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sub_col.hpp b/stan/math/prim/fun/sub_col.hpp
index ec54abd1cff..243b3c7ae64 100644
--- a/stan/math/prim/fun/sub_col.hpp
+++ b/stan/math/prim/fun/sub_col.hpp
@@ -26,9 +26,11 @@ inline auto sub_col(T&& m, size_t i, size_t j, size_t nrows) {
     check_row_index("sub_col", "i+nrows-1", m, i + nrows - 1);
   }
   check_column_index("sub_col", "j", m, j);
-  return make_holder([i, j, nrows](auto&& m_) {
-    return std::forward<decltype(m_)>(m_).col(j - 1).segment(i - 1, nrows);
-  }, std::forward<T>(m));
+  return make_holder(
+      [i, j, nrows](auto&& m_) {
+        return std::forward<decltype(m_)>(m_).col(j - 1).segment(i - 1, nrows);
+      },
+      std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/sub_row.hpp b/stan/math/prim/fun/sub_row.hpp
index 4c6e8313553..971972301a9 100644
--- a/stan/math/prim/fun/sub_row.hpp
+++ b/stan/math/prim/fun/sub_row.hpp
@@ -26,9 +26,11 @@ inline auto sub_row(T&& m, size_t i, size_t j, size_t ncols) {
   if (ncols > 0) {
     check_column_index("sub_col", "j+ncols-1", m, j + ncols - 1);
   }
-  return make_holder([i, j, ncols](auto&& m_) {
-    return std::forward<decltype(m_)>(m_).row(i - 1).segment(j - 1, ncols);
-  }, std::forward<T>(m));
+  return make_holder(
+      [i, j, ncols](auto&& m_) {
+        return std::forward<decltype(m_)>(m_).row(i - 1).segment(j - 1, ncols);
+      },
+      std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/subtract.hpp b/stan/math/prim/fun/subtract.hpp
index 152f4ad9770..3b94c5cc3c9 100644
--- a/stan/math/prim/fun/subtract.hpp
+++ b/stan/math/prim/fun/subtract.hpp
@@ -42,10 +42,12 @@ template <typename Mat1, typename Mat2,
           require_all_not_st_var<Mat1, Mat2>* = nullptr>
 inline auto subtract(Mat1&& m1, Mat2&& m2) {
   check_matching_dims("subtract", "m1", m1, "m2", m2);
-  return make_holder([](auto&& m1_, auto&& m2_) {
-    return std::forward<decltype(m1_)>(m1_)
-           - std::forward<decltype(m2_)>(m2_);
-  }, std::forward<Mat1>(m1), std::forward<Mat2>(m2));
+  return make_holder(
+      [](auto&& m1_, auto&& m2_) {
+        return std::forward<decltype(m1_)>(m1_)
+               - std::forward<decltype(m2_)>(m2_);
+      },
+      std::forward<Mat1>(m1), std::forward<Mat2>(m2));
 }
 
 /**
@@ -62,9 +64,11 @@ template <typename Scal, typename Mat, require_stan_scalar_t<Scal>* = nullptr,
           require_eigen_t<Mat>* = nullptr,
           require_all_not_st_var<Mat, Scal>* = nullptr>
 inline auto subtract(const Scal c, Mat&& m) {
-  return make_holder([c](auto&& m_) {
-    return (c - std::forward<decltype(m_)>(m_).array()).matrix();
-  }, std::forward<Mat>(m));
+  return make_holder(
+      [c](auto&& m_) {
+        return (c - std::forward<decltype(m_)>(m_).array()).matrix();
+      },
+      std::forward<Mat>(m));
 }
 
 /**
@@ -81,9 +85,11 @@ template <typename Mat, typename Scal, require_eigen_t<Mat>* = nullptr,
           require_stan_scalar_t<Scal>* = nullptr,
           require_all_not_st_var<Scal, Mat>* = nullptr>
 inline auto subtract(Mat&& m, const Scal c) {
-  return make_holder([c](auto&& m_) {
-    return (std::forward<decltype(m_)>(m_).array() - c).matrix();
-  }, std::forward<Mat>(m));
+  return make_holder(
+      [c](auto&& m_) {
+        return (std::forward<decltype(m_)>(m_).array() - c).matrix();
+      },
+      std::forward<Mat>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/symmetrize_from_lower_tri.hpp b/stan/math/prim/fun/symmetrize_from_lower_tri.hpp
index 4e1addb07a0..ee771ac4fb1 100644
--- a/stan/math/prim/fun/symmetrize_from_lower_tri.hpp
+++ b/stan/math/prim/fun/symmetrize_from_lower_tri.hpp
@@ -18,9 +18,12 @@ namespace math {
 template <typename T, require_eigen_t<T>* = nullptr>
 inline auto symmetrize_from_lower_tri(T&& m) {
   check_square("symmetrize_from_lower_tri", "m", m);
-  return make_holder([](auto&& m_) {
-   return std::forward<decltype(m_)>(m_).template selfadjointView<Eigen::Lower>();
-  }, std::forward<T>(m));
+  return make_holder(
+      [](auto&& m_) {
+        return std::forward<decltype(m_)>(m_)
+            .template selfadjointView<Eigen::Lower>();
+      },
+      std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/symmetrize_from_upper_tri.hpp b/stan/math/prim/fun/symmetrize_from_upper_tri.hpp
index fef2138fa2d..d24a7f91dad 100644
--- a/stan/math/prim/fun/symmetrize_from_upper_tri.hpp
+++ b/stan/math/prim/fun/symmetrize_from_upper_tri.hpp
@@ -18,9 +18,12 @@ namespace math {
 template <typename T, require_eigen_t<T>* = nullptr>
 inline auto symmetrize_from_upper_tri(T&& m) {
   check_square("symmetrize_from_upper_tri", "m", m);
-  return make_holder([](auto&& m_) {
-   return std::forward<decltype(m_)>(m_).template selfadjointView<Eigen::Upper>();
-  }, std::forward<T>(m));
+  return make_holder(
+      [](auto&& m_) {
+        return std::forward<decltype(m_)>(m_)
+            .template selfadjointView<Eigen::Upper>();
+      },
+      std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/tail.hpp b/stan/math/prim/fun/tail.hpp
index d88f991b0b5..a97eb066f15 100644
--- a/stan/math/prim/fun/tail.hpp
+++ b/stan/math/prim/fun/tail.hpp
@@ -24,9 +24,9 @@ inline auto tail(T&& v, size_t n) {
   if (n != 0) {
     check_vector_index("tail", "n", v, n);
   }
-  return make_holder([n](auto&& v_) {
-    return std::forward<decltype(v_)>(v_).tail(n);
-  }, std::forward<T>(v));
+  return make_holder(
+      [n](auto&& v_) { return std::forward<decltype(v_)>(v_).tail(n); },
+      std::forward<T>(v));
 }
 
 /**
diff --git a/stan/math/prim/fun/trace_gen_quad_form.hpp b/stan/math/prim/fun/trace_gen_quad_form.hpp
index 41183a17e4b..ad99f63d23c 100644
--- a/stan/math/prim/fun/trace_gen_quad_form.hpp
+++ b/stan/math/prim/fun/trace_gen_quad_form.hpp
@@ -38,11 +38,14 @@ inline auto trace_gen_quad_form(TD&& D, TA&& A, TB&& B) {
   check_square("trace_gen_quad_form", "D", D);
   check_multiplicable("trace_gen_quad_form", "A", A, "B", B);
   check_multiplicable("trace_gen_quad_form", "B", B, "D", D);
-  return make_holder([](auto&& D_, auto&& A_, auto&& B_) {
-    auto&& B_ref = to_ref(std::forward<decltype(B_)>(B_));
-    return multiply(B_ref, std::forward<decltype(D_)>(D_).transpose()).cwiseProduct(multiply(std::forward<decltype(A_)>(A_), B_ref)).sum();
-  }, std::forward<TD>(D), std::forward<TA>(A),
-     std::forward<TB>(B));
+  return make_holder(
+      [](auto&& D_, auto&& A_, auto&& B_) {
+        auto&& B_ref = to_ref(std::forward<decltype(B_)>(B_));
+        return multiply(B_ref, std::forward<decltype(D_)>(D_).transpose())
+            .cwiseProduct(multiply(std::forward<decltype(A_)>(A_), B_ref))
+            .sum();
+      },
+      std::forward<TD>(D), std::forward<TA>(A), std::forward<TB>(B));
 }
 
 /**
diff --git a/stan/math/prim/fun/transpose.hpp b/stan/math/prim/fun/transpose.hpp
index b46245a4a63..f42868dd970 100644
--- a/stan/math/prim/fun/transpose.hpp
+++ b/stan/math/prim/fun/transpose.hpp
@@ -15,9 +15,9 @@ namespace math {
  */
 template <typename T, require_matrix_t<T>* = nullptr>
 auto inline transpose(T&& m) {
-  return make_holder([](auto&& m_) {
-    return std::forward<decltype(m_)>(m_).transpose();
-  }, std::forward<T>(m));
+  return make_holder(
+      [](auto&& m_) { return std::forward<decltype(m_)>(m_).transpose(); },
+      std::forward<T>(m));
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/uniform_simplex.hpp b/stan/math/prim/fun/uniform_simplex.hpp
index 483ead24712..cd760271630 100644
--- a/stan/math/prim/fun/uniform_simplex.hpp
+++ b/stan/math/prim/fun/uniform_simplex.hpp
@@ -17,9 +17,8 @@ namespace math {
  */
 inline auto uniform_simplex(int K) {
   check_positive("uniform_simplex", "size", K);
-  return make_holder([](int K) {
-    return Eigen::VectorXd::Constant(K, 1.0 / K);
-  }, K);
+  return make_holder(
+      [](int K) { return Eigen::VectorXd::Constant(K, 1.0 / K); }, K);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/zeros_vector.hpp b/stan/math/prim/fun/zeros_vector.hpp
index 5903a033ba4..f23ee3931ae 100644
--- a/stan/math/prim/fun/zeros_vector.hpp
+++ b/stan/math/prim/fun/zeros_vector.hpp
@@ -16,8 +16,7 @@ namespace math {
  */
 inline auto zeros_vector(int K) {
   check_nonnegative("zeros_vector", "size", K);
-  return make_holder(
-      [](int k) { return Eigen::VectorXd::Zero(k); }, K);
+  return make_holder([](int k) { return Eigen::VectorXd::Zero(k); }, K);
 }
 
 }  // namespace math

From 3e921d4e4f7008f540f3c690d7972c6387a0ca48 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Wed, 2 Jul 2025 14:22:19 -0400
Subject: [PATCH 15/31] fix symmetrize

---
 stan/math/prim/err/is_symmetric.hpp              |  4 ++--
 stan/math/prim/fun/symmetrize_from_lower_tri.hpp | 10 +++-------
 stan/math/prim/fun/symmetrize_from_upper_tri.hpp | 10 +++-------
 3 files changed, 8 insertions(+), 16 deletions(-)

diff --git a/stan/math/prim/err/is_symmetric.hpp b/stan/math/prim/err/is_symmetric.hpp
index ccd16b37b06..46a7345ad0b 100644
--- a/stan/math/prim/err/is_symmetric.hpp
+++ b/stan/math/prim/err/is_symmetric.hpp
@@ -21,8 +21,8 @@ namespace math {
  *    element not on the main diagonal is <code>NaN</code>
  */
 template <typename EigMat, require_eigen_matrix_dynamic_t<EigMat>* = nullptr>
-inline bool is_symmetric(const EigMat& y) {
-  const auto& y_ref = to_ref(y);
+inline bool is_symmetric(EigMat&& y) {
+  auto&& y_ref = to_ref(std::forward<EigMat>(y));
   if (!is_square(y_ref)) {
     return false;
   }
diff --git a/stan/math/prim/fun/symmetrize_from_lower_tri.hpp b/stan/math/prim/fun/symmetrize_from_lower_tri.hpp
index ee771ac4fb1..60b3ccab9ae 100644
--- a/stan/math/prim/fun/symmetrize_from_lower_tri.hpp
+++ b/stan/math/prim/fun/symmetrize_from_lower_tri.hpp
@@ -16,14 +16,10 @@ namespace math {
  * @throw std:invalid_argument if the matrix is not square.
  */
 template <typename T, require_eigen_t<T>* = nullptr>
-inline auto symmetrize_from_lower_tri(T&& m) {
+inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic>
+symmetrize_from_lower_tri(T&& m) {
   check_square("symmetrize_from_lower_tri", "m", m);
-  return make_holder(
-      [](auto&& m_) {
-        return std::forward<decltype(m_)>(m_)
-            .template selfadjointView<Eigen::Lower>();
-      },
-      std::forward<T>(m));
+  return std::forward<T>(m).template selfadjointView<Eigen::Lower>();
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/symmetrize_from_upper_tri.hpp b/stan/math/prim/fun/symmetrize_from_upper_tri.hpp
index d24a7f91dad..14d09878460 100644
--- a/stan/math/prim/fun/symmetrize_from_upper_tri.hpp
+++ b/stan/math/prim/fun/symmetrize_from_upper_tri.hpp
@@ -16,14 +16,10 @@ namespace math {
  * @throw std:invalid_argument if the matrix is not square.
  */
 template <typename T, require_eigen_t<T>* = nullptr>
-inline auto symmetrize_from_upper_tri(T&& m) {
+inline Eigen::Matrix<value_type_t<T>, Eigen::Dynamic, Eigen::Dynamic>
+symmetrize_from_upper_tri(T&& m) {
   check_square("symmetrize_from_upper_tri", "m", m);
-  return make_holder(
-      [](auto&& m_) {
-        return std::forward<decltype(m_)>(m_)
-            .template selfadjointView<Eigen::Upper>();
-      },
-      std::forward<T>(m));
+  return std::forward<T>(m).template selfadjointView<Eigen::Upper>();
 }
 
 }  // namespace math

From 43a2e0b89ff5a981eb3b5a05eb53c30b731fcf78 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Wed, 2 Jul 2025 14:48:00 -0400
Subject: [PATCH 16/31] update logic for offset_multiply to direct to correct
 version for std::vector

---
 stan/math/prim/constraint/offset_multiplier_constrain.hpp | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/stan/math/prim/constraint/offset_multiplier_constrain.hpp b/stan/math/prim/constraint/offset_multiplier_constrain.hpp
index d417fd09325..a34d2f44c77 100644
--- a/stan/math/prim/constraint/offset_multiplier_constrain.hpp
+++ b/stan/math/prim/constraint/offset_multiplier_constrain.hpp
@@ -41,7 +41,8 @@ namespace math {
  */
 template <typename T, typename M, typename S,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              T, M, S>* = nullptr>
+              T, M, S>* = nullptr,
+              require_all_not_std_vector_t<T, M, S>* = nullptr>
 inline auto offset_multiplier_constrain(T&& x, M&& mu, S&& sigma) {
   auto&& mu_ref = to_ref(std::forward<M>(mu));
   auto&& sigma_ref = to_ref(std::forward<S>(sigma));
@@ -94,7 +95,8 @@ inline auto offset_multiplier_constrain(T&& x, M&& mu, S&& sigma) {
 template <typename T, typename M, typename S, typename Lp,
           require_convertible_t<return_type_t<T, M, S>, Lp>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
-              T, M, S>* = nullptr>
+              T, M, S>* = nullptr,
+              require_all_not_std_vector_t<T, M, S>* = nullptr>
 inline auto offset_multiplier_constrain(T&& x, M&& mu, S&& sigma, Lp& lp) {
   auto&& mu_ref = to_ref(std::forward<M>(mu));
   auto&& sigma_ref = to_ref(std::forward<S>(sigma));

From 2b9d2611d4aef4cf5ea66e4c897bb2af8d92654f Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Wed, 2 Jul 2025 14:48:59 -0400
Subject: [PATCH 17/31] [Jenkins] auto-formatting by clang-format version
 10.0.0-4ubuntu1

---
 stan/math/prim/constraint/offset_multiplier_constrain.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stan/math/prim/constraint/offset_multiplier_constrain.hpp b/stan/math/prim/constraint/offset_multiplier_constrain.hpp
index a34d2f44c77..333b5d00761 100644
--- a/stan/math/prim/constraint/offset_multiplier_constrain.hpp
+++ b/stan/math/prim/constraint/offset_multiplier_constrain.hpp
@@ -42,7 +42,7 @@ namespace math {
 template <typename T, typename M, typename S,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               T, M, S>* = nullptr,
-              require_all_not_std_vector_t<T, M, S>* = nullptr>
+          require_all_not_std_vector_t<T, M, S>* = nullptr>
 inline auto offset_multiplier_constrain(T&& x, M&& mu, S&& sigma) {
   auto&& mu_ref = to_ref(std::forward<M>(mu));
   auto&& sigma_ref = to_ref(std::forward<S>(sigma));
@@ -96,7 +96,7 @@ template <typename T, typename M, typename S, typename Lp,
           require_convertible_t<return_type_t<T, M, S>, Lp>* = nullptr,
           require_all_not_nonscalar_prim_or_rev_kernel_expression_t<
               T, M, S>* = nullptr,
-              require_all_not_std_vector_t<T, M, S>* = nullptr>
+          require_all_not_std_vector_t<T, M, S>* = nullptr>
 inline auto offset_multiplier_constrain(T&& x, M&& mu, S&& sigma, Lp& lp) {
   auto&& mu_ref = to_ref(std::forward<M>(mu));
   auto&& sigma_ref = to_ref(std::forward<S>(sigma));

From 11442417b908605e1606d6a69be7b9108ba23fcf Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Wed, 2 Jul 2025 16:04:20 -0400
Subject: [PATCH 18/31] fix categorical_logit test to use plain type for
 rep_matrix

---
 stan/math/prim/meta/is_eigen_matrix.hpp           |  5 +++--
 stan/math/prim/meta/is_var_matrix.hpp             |  3 ++-
 stan/math/prim/meta/plain_type.hpp                |  1 -
 stan/math/rev/fun/rep_matrix.hpp                  |  4 ++--
 test/unit/math/rev/fun/rep_matrix_test.cpp        | 15 +++++++++++++--
 .../rev/prob/categorical_logit_glm_lpmf_test.cpp  |  2 +-
 6 files changed, 21 insertions(+), 9 deletions(-)

diff --git a/stan/math/prim/meta/is_eigen_matrix.hpp b/stan/math/prim/meta/is_eigen_matrix.hpp
index 63e021d233e..2fe2089e6ba 100644
--- a/stan/math/prim/meta/is_eigen_matrix.hpp
+++ b/stan/math/prim/meta/is_eigen_matrix.hpp
@@ -6,6 +6,7 @@
 #include <stan/math/prim/meta/conjunction.hpp>
 #include <stan/math/prim/meta/disjunction.hpp>
 #include <stan/math/prim/meta/is_base_pointer_convertible.hpp>
+#include <stan/math/prim/meta/plain_type.hpp>
 #include <stan/math/prim/meta/require_helpers.hpp>
 #include <type_traits>
 
@@ -41,8 +42,8 @@ struct is_eigen_matrix_dynamic_impl<T, true>
 template <typename T>
 struct is_eigen_matrix_dynamic
     : bool_constant<internal::is_eigen_matrix_dynamic_impl<
-          std::decay_t<T>,
-          is_base_pointer_convertible<Eigen::MatrixBase, T>::value>::value> {};
+          plain_type_t<std::decay_t<T>>,
+          is_base_pointer_convertible<Eigen::MatrixBase, plain_type_t<std::decay_t<T>>>::value>::value> {};
 
 /*! \ingroup require_eigens_types */
 /*! \defgroup eigen_matrix_dynamic_types eigen_matrix_dynamic  */
diff --git a/stan/math/prim/meta/is_var_matrix.hpp b/stan/math/prim/meta/is_var_matrix.hpp
index dbdafb67674..9a5f90c3576 100644
--- a/stan/math/prim/meta/is_var_matrix.hpp
+++ b/stan/math/prim/meta/is_var_matrix.hpp
@@ -6,6 +6,7 @@
 #include <stan/math/prim/meta/is_var.hpp>
 #include <stan/math/prim/meta/is_eigen.hpp>
 #include <stan/math/prim/meta/is_vector.hpp>
+#include <stan/math/prim/meta/plain_type.hpp>
 
 namespace stan {
 /**
@@ -17,7 +18,7 @@ namespace stan {
 template <typename T>
 struct is_var_matrix
     : bool_constant<
-          math::conjunction<is_var<T>, is_eigen<value_type_t<T>>>::value> {};
+          math::conjunction<is_var<T>, is_eigen<plain_type_t<value_type_t<T>>>>::value> {};
 
 /*! \ingroup require_eigens_types */
 /*! \defgroup var_matrix_types var_matrix  */
diff --git a/stan/math/prim/meta/plain_type.hpp b/stan/math/prim/meta/plain_type.hpp
index 376a467bb08..44b5ab14c4b 100644
--- a/stan/math/prim/meta/plain_type.hpp
+++ b/stan/math/prim/meta/plain_type.hpp
@@ -4,7 +4,6 @@
 #include <stan/math/prim/meta/is_eigen.hpp>
 #include <stan/math/prim/meta/is_tuple.hpp>
 #include <stan/math/prim/meta/is_detected.hpp>
-#include <stan/math/prim/meta/is_var_matrix.hpp>
 #include <type_traits>
 
 namespace stan {
diff --git a/stan/math/rev/fun/rep_matrix.hpp b/stan/math/rev/fun/rep_matrix.hpp
index 176cfaf8783..07a6dcd727c 100644
--- a/stan/math/rev/fun/rep_matrix.hpp
+++ b/stan/math/rev/fun/rep_matrix.hpp
@@ -42,8 +42,8 @@ inline auto rep_matrix(const T& x, int m, int n) {
  */
 template <typename Ret, typename Vec, require_var_matrix_t<Ret>* = nullptr,
           require_var_matrix_t<Vec>* = nullptr>
-inline auto rep_matrix(const Vec& x, int n) {
-  if (is_row_vector<Vec>::value) {
+inline auto rep_matrix(Vec&& x, int n) {
+  if constexpr (is_row_vector<Vec>::value) {
     check_nonnegative("rep_matrix", "rows", n);
     return make_callback_var(x.val().replicate(n, 1), [x](auto& rep) mutable {
       x.adj() += rep.adj().colwise().sum();
diff --git a/test/unit/math/rev/fun/rep_matrix_test.cpp b/test/unit/math/rev/fun/rep_matrix_test.cpp
index e470616dfe8..334d15670a2 100644
--- a/test/unit/math/rev/fun/rep_matrix_test.cpp
+++ b/test/unit/math/rev/fun/rep_matrix_test.cpp
@@ -6,7 +6,7 @@
 #include <limits>
 #include <string>
 #include <vector>
-
+/*
 TEST(MathMixMatFun, repMatrixVar) {
   using stan::math::rep_matrix;
   using stan::math::sum;
@@ -66,7 +66,17 @@ TEST(MathMixMatFun, repVarMatrixVec) {
   expected_x_var_adjs << 5, 5, 5, 5, 5;
   EXPECT_MATRIX_EQ(x_var.adj(), expected_x_var_adjs);
 }
-
+*/
+TEST(MathMixMatFun, repVarMatrixVec) {
+  using stan::math::rep_matrix;
+  using stan::math::sum;
+  using stan::math::var;
+  using stan::math::var_value;
+  using var_matrix = var_value<Eigen::MatrixXd>;
+  var_value<Eigen::VectorXd> x_var(Eigen::VectorXd::Ones(5));
+  auto x = rep_matrix<var_matrix>(x_var.transpose(), 5);
+}
+/*
 TEST(MathMixMatFun, repVarMatrixRowVec) {
   using stan::math::rep_matrix;
   using stan::math::sum;
@@ -84,3 +94,4 @@ TEST(MathMixMatFun, repVarMatrixRowVec) {
   expected_x_var_adjs << 5, 5, 5, 5, 5;
   EXPECT_MATRIX_EQ(x_var.adj(), expected_x_var_adjs);
 }
+*/
diff --git a/test/unit/math/rev/prob/categorical_logit_glm_lpmf_test.cpp b/test/unit/math/rev/prob/categorical_logit_glm_lpmf_test.cpp
index 4a2cf6c9930..dd3e9b9321b 100644
--- a/test/unit/math/rev/prob/categorical_logit_glm_lpmf_test.cpp
+++ b/test/unit/math/rev/prob/categorical_logit_glm_lpmf_test.cpp
@@ -18,7 +18,7 @@ stan::return_type_t<T_x, T_alpha, T_beta> categorical_logit_glm_simple_lpmf(
 
   auto tmp = stan::math::to_ref(
       stan::math::multiply(x, beta)
-      + stan::math::rep_matrix<std::decay_t<decltype(alpha_row)>>(alpha_row,
+      + stan::math::rep_matrix<stan::plain_type_t<std::decay_t<decltype(alpha_row)>>>(alpha_row,
                                                                   x.rows()));
 
   T_return lpmf = 0;

From 3c42f90b01ad4400d0be7ba04239e663adca32e3 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Wed, 2 Jul 2025 16:05:21 -0400
Subject: [PATCH 19/31] [Jenkins] auto-formatting by clang-format version
 10.0.0-4ubuntu1

---
 stan/math/prim/meta/is_eigen_matrix.hpp                     | 4 +++-
 stan/math/prim/meta/is_var_matrix.hpp                       | 4 ++--
 test/unit/math/rev/prob/categorical_logit_glm_lpmf_test.cpp | 5 +++--
 3 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/stan/math/prim/meta/is_eigen_matrix.hpp b/stan/math/prim/meta/is_eigen_matrix.hpp
index 2fe2089e6ba..df6c0d21ab0 100644
--- a/stan/math/prim/meta/is_eigen_matrix.hpp
+++ b/stan/math/prim/meta/is_eigen_matrix.hpp
@@ -43,7 +43,9 @@ template <typename T>
 struct is_eigen_matrix_dynamic
     : bool_constant<internal::is_eigen_matrix_dynamic_impl<
           plain_type_t<std::decay_t<T>>,
-          is_base_pointer_convertible<Eigen::MatrixBase, plain_type_t<std::decay_t<T>>>::value>::value> {};
+          is_base_pointer_convertible<Eigen::MatrixBase,
+                                      plain_type_t<std::decay_t<T>>>::value>::
+                        value> {};
 
 /*! \ingroup require_eigens_types */
 /*! \defgroup eigen_matrix_dynamic_types eigen_matrix_dynamic  */
diff --git a/stan/math/prim/meta/is_var_matrix.hpp b/stan/math/prim/meta/is_var_matrix.hpp
index 9a5f90c3576..58299b8c331 100644
--- a/stan/math/prim/meta/is_var_matrix.hpp
+++ b/stan/math/prim/meta/is_var_matrix.hpp
@@ -17,8 +17,8 @@ namespace stan {
  */
 template <typename T>
 struct is_var_matrix
-    : bool_constant<
-          math::conjunction<is_var<T>, is_eigen<plain_type_t<value_type_t<T>>>>::value> {};
+    : bool_constant<math::conjunction<
+          is_var<T>, is_eigen<plain_type_t<value_type_t<T>>>>::value> {};
 
 /*! \ingroup require_eigens_types */
 /*! \defgroup var_matrix_types var_matrix  */
diff --git a/test/unit/math/rev/prob/categorical_logit_glm_lpmf_test.cpp b/test/unit/math/rev/prob/categorical_logit_glm_lpmf_test.cpp
index dd3e9b9321b..f26ad7d9618 100644
--- a/test/unit/math/rev/prob/categorical_logit_glm_lpmf_test.cpp
+++ b/test/unit/math/rev/prob/categorical_logit_glm_lpmf_test.cpp
@@ -18,8 +18,9 @@ stan::return_type_t<T_x, T_alpha, T_beta> categorical_logit_glm_simple_lpmf(
 
   auto tmp = stan::math::to_ref(
       stan::math::multiply(x, beta)
-      + stan::math::rep_matrix<stan::plain_type_t<std::decay_t<decltype(alpha_row)>>>(alpha_row,
-                                                                  x.rows()));
+      + stan::math::rep_matrix<
+          stan::plain_type_t<std::decay_t<decltype(alpha_row)>>>(alpha_row,
+                                                                 x.rows()));
 
   T_return lpmf = 0;
   // iterate overt instances

From 0f1658d063530edf9d5d22b0526f0e9e9c62865f Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Wed, 2 Jul 2025 17:09:18 -0400
Subject: [PATCH 20/31] add back tests for rep_matrix

---
 stan/math/prim/meta/is_eigen.hpp           | 29 ++++++++++++++++++++++
 stan/math/prim/meta/is_eigen_matrix.hpp    |  6 ++---
 stan/math/prim/meta/plain_type.hpp         |  1 +
 test/unit/math/rev/fun/rep_matrix_test.cpp | 10 ++++----
 4 files changed, 37 insertions(+), 9 deletions(-)

diff --git a/stan/math/prim/meta/is_eigen.hpp b/stan/math/prim/meta/is_eigen.hpp
index ef776763c64..d3edb1dd9b0 100644
--- a/stan/math/prim/meta/is_eigen.hpp
+++ b/stan/math/prim/meta/is_eigen.hpp
@@ -102,6 +102,35 @@ struct value_type<T,
   using type = typename Eigen::internal::traits<std::decay_t<T>>::Scalar;
 };
 
+/**
+ * Template metaprogram defining the base scalar type of
+ * values stored in an Eigen matrix.
+ *
+ * @tparam T type to check.
+ * @ingroup type_trait
+ */
+template <typename T>
+struct scalar_type<Eigen::EigenBase<T>,
+                   std::enable_if_t<is_eigen<T>::value
+                                    && !internal::has_scalar_trait<T>::value>> {
+  using type = scalar_type_t<
+      typename Eigen::internal::traits<std::decay_t<T>>::Scalar>;
+};
+
+/**
+ * Template metaprogram defining the type of values stored in an
+ * Eigen matrix, vector, or row vector.
+ *
+ * @tparam T type to check
+ * @ingroup type_trait
+ */
+template <typename T>
+struct value_type<Eigen::EigenBase<T>,
+                  std::enable_if_t<is_eigen<T>::value
+                                   && !internal::has_scalar_trait<T>::value>> {
+  using type = typename Eigen::internal::traits<std::decay_t<T>>::Scalar;
+};
+
 /*! \ingroup require_eigens_types */
 /*! \defgroup eigen_types eigen  */
 /*! \addtogroup eigen_types */
diff --git a/stan/math/prim/meta/is_eigen_matrix.hpp b/stan/math/prim/meta/is_eigen_matrix.hpp
index df6c0d21ab0..def330d7acd 100644
--- a/stan/math/prim/meta/is_eigen_matrix.hpp
+++ b/stan/math/prim/meta/is_eigen_matrix.hpp
@@ -42,10 +42,8 @@ struct is_eigen_matrix_dynamic_impl<T, true>
 template <typename T>
 struct is_eigen_matrix_dynamic
     : bool_constant<internal::is_eigen_matrix_dynamic_impl<
-          plain_type_t<std::decay_t<T>>,
-          is_base_pointer_convertible<Eigen::MatrixBase,
-                                      plain_type_t<std::decay_t<T>>>::value>::
-                        value> {};
+          std::decay_t<T>,
+          is_base_pointer_convertible<Eigen::MatrixBase, T>::value>::value> {};
 
 /*! \ingroup require_eigens_types */
 /*! \defgroup eigen_matrix_dynamic_types eigen_matrix_dynamic  */
diff --git a/stan/math/prim/meta/plain_type.hpp b/stan/math/prim/meta/plain_type.hpp
index 44b5ab14c4b..c0cf4613987 100644
--- a/stan/math/prim/meta/plain_type.hpp
+++ b/stan/math/prim/meta/plain_type.hpp
@@ -1,6 +1,7 @@
 #ifndef STAN_MATH_PRIM_META_PLAIN_TYPE_HPP
 #define STAN_MATH_PRIM_META_PLAIN_TYPE_HPP
 
+#include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/meta/is_eigen.hpp>
 #include <stan/math/prim/meta/is_tuple.hpp>
 #include <stan/math/prim/meta/is_detected.hpp>
diff --git a/test/unit/math/rev/fun/rep_matrix_test.cpp b/test/unit/math/rev/fun/rep_matrix_test.cpp
index 334d15670a2..86942d03041 100644
--- a/test/unit/math/rev/fun/rep_matrix_test.cpp
+++ b/test/unit/math/rev/fun/rep_matrix_test.cpp
@@ -6,7 +6,7 @@
 #include <limits>
 #include <string>
 #include <vector>
-/*
+
 TEST(MathMixMatFun, repMatrixVar) {
   using stan::math::rep_matrix;
   using stan::math::sum;
@@ -66,8 +66,8 @@ TEST(MathMixMatFun, repVarMatrixVec) {
   expected_x_var_adjs << 5, 5, 5, 5, 5;
   EXPECT_MATRIX_EQ(x_var.adj(), expected_x_var_adjs);
 }
-*/
-TEST(MathMixMatFun, repVarMatrixVec) {
+
+TEST(MathMixMatFun, repVarMatrixVecTranspose) {
   using stan::math::rep_matrix;
   using stan::math::sum;
   using stan::math::var;
@@ -76,7 +76,7 @@ TEST(MathMixMatFun, repVarMatrixVec) {
   var_value<Eigen::VectorXd> x_var(Eigen::VectorXd::Ones(5));
   auto x = rep_matrix<var_matrix>(x_var.transpose(), 5);
 }
-/*
+
 TEST(MathMixMatFun, repVarMatrixRowVec) {
   using stan::math::rep_matrix;
   using stan::math::sum;
@@ -94,4 +94,4 @@ TEST(MathMixMatFun, repVarMatrixRowVec) {
   expected_x_var_adjs << 5, 5, 5, 5, 5;
   EXPECT_MATRIX_EQ(x_var.adj(), expected_x_var_adjs);
 }
-*/
+

From 7958b815fd59ce6729cb9651abc69ec3f54241cc Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Wed, 2 Jul 2025 17:10:17 -0400
Subject: [PATCH 21/31] [Jenkins] auto-formatting by clang-format version
 10.0.0-4ubuntu1

---
 test/unit/math/rev/fun/rep_matrix_test.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/test/unit/math/rev/fun/rep_matrix_test.cpp b/test/unit/math/rev/fun/rep_matrix_test.cpp
index 86942d03041..9116701e952 100644
--- a/test/unit/math/rev/fun/rep_matrix_test.cpp
+++ b/test/unit/math/rev/fun/rep_matrix_test.cpp
@@ -94,4 +94,3 @@ TEST(MathMixMatFun, repVarMatrixRowVec) {
   expected_x_var_adjs << 5, 5, 5, 5, 5;
   EXPECT_MATRIX_EQ(x_var.adj(), expected_x_var_adjs);
 }
-

From 77646e61d78818fa233eaa7d50c8f032dbb1b459 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Wed, 2 Jul 2025 17:25:09 -0400
Subject: [PATCH 22/31] fix reverse

---
 stan/math/prim/fun/reverse.hpp | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/stan/math/prim/fun/reverse.hpp b/stan/math/prim/fun/reverse.hpp
index ba98bde8407..4bbd31a034a 100644
--- a/stan/math/prim/fun/reverse.hpp
+++ b/stan/math/prim/fun/reverse.hpp
@@ -33,8 +33,14 @@ inline std::vector<T> reverse(const std::vector<T>& x) {
  */
 template <typename T, typename = require_vector_t<T>>
 inline auto reverse(T&& x) {
-  return make_holder([](auto&& xx) { return xx.reverse(); },
-                     std::forward<T>(x));
+  if constexpr (is_eigen_vector<T>::value) {
+    return make_holder([](auto&& xx) { return xx.reverse(); },
+                       std::forward<T>(x));
+  } else {
+    // If std::vector
+    std::decay_t<T> rev(x.size());
+    std::reverse_copy(x.begin(), x.end(), rev.begin());
+  }
 }
 
 }  // namespace math

From 8dc16cae9ca4943b5069aaea4ac31704b4611b61 Mon Sep 17 00:00:00 2001
From: Steve Bronder <Stevo15025@gmail.com>
Date: Wed, 2 Jul 2025 17:49:03 -0400
Subject: [PATCH 23/31] Update reverse.hpp

---
 stan/math/prim/fun/reverse.hpp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/stan/math/prim/fun/reverse.hpp b/stan/math/prim/fun/reverse.hpp
index 4bbd31a034a..f046734d624 100644
--- a/stan/math/prim/fun/reverse.hpp
+++ b/stan/math/prim/fun/reverse.hpp
@@ -40,6 +40,7 @@ inline auto reverse(T&& x) {
     // If std::vector
     std::decay_t<T> rev(x.size());
     std::reverse_copy(x.begin(), x.end(), rev.begin());
+    return rev;
   }
 }
 

From 2b52498119650901cf59e0ad8d0619149e83d8c2 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Thu, 3 Jul 2025 14:14:53 -0400
Subject: [PATCH 24/31] update block like functions for expressions

---
 stan/math/prim/fun/reverse.hpp        |  8 +++---
 stan/math/prim/fun/segment.hpp        | 26 +++++++------------
 stan/math/prim/fun/tail.hpp           | 36 ++++++++++-----------------
 stan/math/prim/meta/is_matrix.hpp     |  2 ++
 test/unit/math/prim/fun/eval_test.cpp |  6 ++---
 5 files changed, 31 insertions(+), 47 deletions(-)

diff --git a/stan/math/prim/fun/reverse.hpp b/stan/math/prim/fun/reverse.hpp
index f046734d624..df0ca4a0531 100644
--- a/stan/math/prim/fun/reverse.hpp
+++ b/stan/math/prim/fun/reverse.hpp
@@ -33,14 +33,14 @@ inline std::vector<T> reverse(const std::vector<T>& x) {
  */
 template <typename T, typename = require_vector_t<T>>
 inline auto reverse(T&& x) {
-  if constexpr (is_eigen_vector<T>::value) {
-    return make_holder([](auto&& xx) { return xx.reverse(); },
-                       std::forward<T>(x));
-  } else {
+  if constexpr (is_std_vector_v<T>) {
     // If std::vector
     std::decay_t<T> rev(x.size());
     std::reverse_copy(x.begin(), x.end(), rev.begin());
     return rev;
+  } else {
+    return make_holder([](auto&& xx) { return xx.reverse(); },
+                       std::forward<T>(x));
   }
 }
 
diff --git a/stan/math/prim/fun/segment.hpp b/stan/math/prim/fun/segment.hpp
index 978788b7e7e..0e8919c5a52 100644
--- a/stan/math/prim/fun/segment.hpp
+++ b/stan/math/prim/fun/segment.hpp
@@ -23,24 +23,16 @@ inline auto segment(Vec&& v, size_t i, size_t n) {
     check_less_or_equal("segment", "n", i + n - 1,
                         static_cast<size_t>(v.size()));
   }
-  return make_holder([i, n](auto&& v_) { return v_.segment(i - 1, n); },
-                     std::forward<Vec>(v));
-}
-
-template <typename T>
-std::vector<T> segment(const std::vector<T>& sv, size_t i, size_t n) {
-  check_greater("segment", "i", i, 0.0);
-  check_less_or_equal("segment", "i", i, sv.size());
-  if (n != 0) {
-    check_greater("segment", "i+n-1", i + n - 1, 0.0);
-    check_less_or_equal("segment", "i+n-1", i + n - 1,
-                        static_cast<size_t>(sv.size()));
-  }
-  std::vector<T> s;
-  for (size_t j = 0; j < n; ++j) {
-    s.push_back(sv[i + j - 1]);
+  if constexpr (is_std_vector_v<Vec>) {
+    std::decay_t<Vec> s;
+    for (size_t j = 0; j < n; ++j) {
+      s.push_back(v[i + j - 1]);
+    }
+    return s;
+  } else {
+    return make_holder([i, n](auto&& v_) { return v_.segment(i - 1, n); },
+                      std::forward<Vec>(v));
   }
-  return s;
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/tail.hpp b/stan/math/prim/fun/tail.hpp
index a97eb066f15..92ae653b8ae 100644
--- a/stan/math/prim/fun/tail.hpp
+++ b/stan/math/prim/fun/tail.hpp
@@ -21,32 +21,22 @@ namespace math {
  */
 template <typename T, require_vector_t<T>* = nullptr>
 inline auto tail(T&& v, size_t n) {
-  if (n != 0) {
-    check_vector_index("tail", "n", v, n);
+  if constexpr (is_std_vector_v<T>) {
+    if (n != 0) {
+      check_std_vector_index("tail", "n", v, n);
+    }
+    std::decay_t<T> s(v.end() - n, v.end());
+    return s;
+  } else {
+    if (n != 0) {
+      check_vector_index("tail", "n", v, n);
+    }
+    return make_holder(
+        [n](auto&& v_) { return std::forward<decltype(v_)>(v_).tail(n); },
+        std::forward<T>(v));
   }
-  return make_holder(
-      [n](auto&& v_) { return std::forward<decltype(v_)>(v_).tail(n); },
-      std::forward<T>(v));
 }
 
-/**
- * Return the specified number of elements as a standard vector
- * from the back of the specified standard vector.
- *
- * @tparam T type of elements in the vector
- * @param sv Standard vector.
- * @param n Size of return.
- * @return The last n elements of sv.
- * @throw std::out_of_range if n is out of range.
- */
-template <typename T>
-std::vector<T> tail(const std::vector<T>& sv, size_t n) {
-  if (n != 0) {
-    check_std_vector_index("tail", "n", sv, n);
-  }
-  std::vector<T> s(sv.end() - n, sv.end());
-  return s;
-}
 
 }  // namespace math
 }  // namespace stan
diff --git a/stan/math/prim/meta/is_matrix.hpp b/stan/math/prim/meta/is_matrix.hpp
index 58cb26712ad..90a96192c34 100644
--- a/stan/math/prim/meta/is_matrix.hpp
+++ b/stan/math/prim/meta/is_matrix.hpp
@@ -17,6 +17,8 @@ template <typename T>
 struct is_matrix
     : bool_constant<math::disjunction<is_rev_matrix<T>, is_eigen<T>>::value> {};
 
+template <typename T>
+constexpr bool is_matrix_v = is_matrix<T>::value;
 /*! \ingroup require_eigens_types */
 /*! \defgroup matrix_types matrix  */
 /*! \addtogroup matrix_types */
diff --git a/test/unit/math/prim/fun/eval_test.cpp b/test/unit/math/prim/fun/eval_test.cpp
index 148cc2f1e12..a807e7093d6 100644
--- a/test/unit/math/prim/fun/eval_test.cpp
+++ b/test/unit/math/prim/fun/eval_test.cpp
@@ -1,5 +1,6 @@
 #include <stan/math/prim.hpp>
 #include <test/unit/util.hpp>
+#include <test/unit/pretty_print_types.hpp>
 #include <gtest/gtest.h>
 #include <cmath>
 #include <limits>
@@ -183,15 +184,14 @@ TEST(MathFunctions, eval_return_type_expression) {
 
   const auto& expr_a = 3 * a;
   auto expr_b = b * b;
-
   EXPECT_TRUE(
       (std::is_same<
           decltype(stan::math::eval(expr_a)),
-          const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>>::value));
+          Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>>::value));
   EXPECT_TRUE(
       (std::is_same<
           decltype(stan::math::eval(expr_b)),
-          const Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>>::value));
+          Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>>::value));
 }
 
 TEST(MathFunctions, eval_return_type_short_circuit_static_sized_matrix) {

From b033319b7f5a964f06ce805a0b37d8099902cf7e Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Thu, 3 Jul 2025 14:15:51 -0400
Subject: [PATCH 25/31] [Jenkins] auto-formatting by clang-format version
 10.0.0-4ubuntu1

---
 stan/math/prim/fun/segment.hpp        |  2 +-
 stan/math/prim/fun/tail.hpp           |  1 -
 test/unit/math/prim/fun/eval_test.cpp | 14 ++++++--------
 3 files changed, 7 insertions(+), 10 deletions(-)

diff --git a/stan/math/prim/fun/segment.hpp b/stan/math/prim/fun/segment.hpp
index 0e8919c5a52..62d552bb121 100644
--- a/stan/math/prim/fun/segment.hpp
+++ b/stan/math/prim/fun/segment.hpp
@@ -31,7 +31,7 @@ inline auto segment(Vec&& v, size_t i, size_t n) {
     return s;
   } else {
     return make_holder([i, n](auto&& v_) { return v_.segment(i - 1, n); },
-                      std::forward<Vec>(v));
+                       std::forward<Vec>(v));
   }
 }
 
diff --git a/stan/math/prim/fun/tail.hpp b/stan/math/prim/fun/tail.hpp
index 92ae653b8ae..f4d50a26320 100644
--- a/stan/math/prim/fun/tail.hpp
+++ b/stan/math/prim/fun/tail.hpp
@@ -37,7 +37,6 @@ inline auto tail(T&& v, size_t n) {
   }
 }
 
-
 }  // namespace math
 }  // namespace stan
 
diff --git a/test/unit/math/prim/fun/eval_test.cpp b/test/unit/math/prim/fun/eval_test.cpp
index a807e7093d6..a3013727be4 100644
--- a/test/unit/math/prim/fun/eval_test.cpp
+++ b/test/unit/math/prim/fun/eval_test.cpp
@@ -184,14 +184,12 @@ TEST(MathFunctions, eval_return_type_expression) {
 
   const auto& expr_a = 3 * a;
   auto expr_b = b * b;
-  EXPECT_TRUE(
-      (std::is_same<
-          decltype(stan::math::eval(expr_a)),
-          Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>>::value));
-  EXPECT_TRUE(
-      (std::is_same<
-          decltype(stan::math::eval(expr_b)),
-          Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>>::value));
+  EXPECT_TRUE((std::is_same<
+               decltype(stan::math::eval(expr_a)),
+               Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>>::value));
+  EXPECT_TRUE((std::is_same<
+               decltype(stan::math::eval(expr_b)),
+               Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>>::value));
 }
 
 TEST(MathFunctions, eval_return_type_short_circuit_static_sized_matrix) {

From 1ebbb3ee554e3310fc99a3ccddb78528ee433a90 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Mon, 7 Jul 2025 13:37:30 -0400
Subject: [PATCH 26/31] remove if in mdivide_left_spd as the expressions return
 the correct size https://godbolt.org/z/cn7dKsMWr

---
 stan/math/prim/fun/mdivide_left_spd.hpp  |  4 ----
 stan/math/prim/fun/mdivide_right_spd.hpp |  4 ----
 stan/math/rev/fun/mdivide_left_spd.hpp   | 25 ++++++++++--------------
 3 files changed, 10 insertions(+), 23 deletions(-)

diff --git a/stan/math/prim/fun/mdivide_left_spd.hpp b/stan/math/prim/fun/mdivide_left_spd.hpp
index d6d27f4274a..1a2e2c4a14c 100644
--- a/stan/math/prim/fun/mdivide_left_spd.hpp
+++ b/stan/math/prim/fun/mdivide_left_spd.hpp
@@ -34,10 +34,6 @@ mdivide_left_spd(EigMat1&& A, EigMat2&& b) {
   auto&& A_ref = to_ref(std::forward<EigMat1>(A));
   check_symmetric(function, "A", A_ref);
   check_not_nan(function, "A", A_ref);
-  if (A.size() == 0) {
-    return {0, b.cols()};
-  }
-
   auto llt = Eigen::Matrix<return_type_t<EigMat1, EigMat2>,
                            std::decay_t<EigMat1>::RowsAtCompileTime,
                            std::decay_t<EigMat1>::ColsAtCompileTime>(
diff --git a/stan/math/prim/fun/mdivide_right_spd.hpp b/stan/math/prim/fun/mdivide_right_spd.hpp
index d86e4f248f2..2898a59304e 100644
--- a/stan/math/prim/fun/mdivide_right_spd.hpp
+++ b/stan/math/prim/fun/mdivide_right_spd.hpp
@@ -34,10 +34,6 @@ mdivide_right_spd(EigMat1&& b, EigMat2&& A) {
   auto&& A_ref = to_ref(std::forward<EigMat2>(A));
   check_symmetric(function, "A", A_ref);
   check_not_nan(function, "A", A_ref);
-  if (A.size() == 0) {
-    return {b.rows(), 0};
-  }
-
   return mdivide_left_spd(std::forward<decltype(A_ref)>(A_ref),
                           std::forward<EigMat1>(b).transpose())
       .transpose();
diff --git a/stan/math/rev/fun/mdivide_left_spd.hpp b/stan/math/rev/fun/mdivide_left_spd.hpp
index 982575a1a6f..b1eede9ec25 100644
--- a/stan/math/rev/fun/mdivide_left_spd.hpp
+++ b/stan/math/rev/fun/mdivide_left_spd.hpp
@@ -259,19 +259,15 @@ mdivide_left_spd(const EigMat1 &A, const EigMat2 &b) {
  */
 template <typename T1, typename T2, require_all_matrix_t<T1, T2> * = nullptr,
           require_any_var_matrix_t<T1, T2> * = nullptr>
-inline auto mdivide_left_spd(const T1 &A, const T2 &B) {
-  using ret_val_type = plain_type_t<decltype(value_of(A) * value_of(B))>;
+inline auto mdivide_left_spd(T1&& A, T2&& B) {
+  auto&& A_ref = to_ref(std::forward<T1>(A));
+  using ret_val_type = plain_type_t<decltype(value_of(A_ref) * value_of(B))>;
   using ret_type = var_value<ret_val_type>;
+  check_multiplicable("mdivide_left_spd", "A", A_ref, "B", B);
 
-  if (A.size() == 0) {
-    return ret_type(ret_val_type(0, B.cols()));
-  }
-
-  check_multiplicable("mdivide_left_spd", "A", A, "B", B);
-
-  if (!is_constant<T1>::value && !is_constant<T2>::value) {
-    arena_t<promote_scalar_t<var, T1>> arena_A = A;
-    arena_t<promote_scalar_t<var, T2>> arena_B = B;
+  if constexpr (!is_constant<T1>::value && !is_constant<T2>::value) {
+    arena_t<promote_scalar_t<var, T1>> arena_A = std::forward<decltype(A_ref)>(A_ref);
+    arena_t<promote_scalar_t<var, T2>> arena_B = std::forward<T2>(B);
 
     check_symmetric("mdivide_left_spd", "A", arena_A.val());
     check_not_nan("mdivide_left_spd", "A", arena_A.val());
@@ -296,8 +292,8 @@ inline auto mdivide_left_spd(const T1 &A, const T2 &B) {
     });
 
     return ret_type(res);
-  } else if (!is_constant<T1>::value) {
-    arena_t<promote_scalar_t<var, T1>> arena_A = A;
+  } else if constexpr (!is_constant<T1>::value) {
+    arena_t<promote_scalar_t<var, T1>> arena_A = std::forward<decltype(A_ref)>(A_ref);;
 
     check_symmetric("mdivide_left_spd", "A", arena_A.val());
     check_not_nan("mdivide_left_spd", "A", arena_A.val());
@@ -322,8 +318,7 @@ inline auto mdivide_left_spd(const T1 &A, const T2 &B) {
 
     return ret_type(res);
   } else {
-    const auto &A_ref = to_ref(value_of(A));
-    arena_t<promote_scalar_t<var, T2>> arena_B = B;
+    arena_t<promote_scalar_t<var, T2>> arena_B = std::forward<T2>(B);
 
     check_symmetric("mdivide_left_spd", "A", A_ref);
     check_not_nan("mdivide_left_spd", "A", A_ref);

From 7862a225f69711b661e689deb3d641b477017e54 Mon Sep 17 00:00:00 2001
From: Stan Jenkins <mc.stanislaw@gmail.com>
Date: Mon, 7 Jul 2025 13:38:36 -0400
Subject: [PATCH 27/31] [Jenkins] auto-formatting by clang-format version
 10.0.0-4ubuntu1

---
 stan/math/rev/fun/mdivide_left_spd.hpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/stan/math/rev/fun/mdivide_left_spd.hpp b/stan/math/rev/fun/mdivide_left_spd.hpp
index b1eede9ec25..8ca5c160f19 100644
--- a/stan/math/rev/fun/mdivide_left_spd.hpp
+++ b/stan/math/rev/fun/mdivide_left_spd.hpp
@@ -259,14 +259,15 @@ mdivide_left_spd(const EigMat1 &A, const EigMat2 &b) {
  */
 template <typename T1, typename T2, require_all_matrix_t<T1, T2> * = nullptr,
           require_any_var_matrix_t<T1, T2> * = nullptr>
-inline auto mdivide_left_spd(T1&& A, T2&& B) {
-  auto&& A_ref = to_ref(std::forward<T1>(A));
+inline auto mdivide_left_spd(T1 &&A, T2 &&B) {
+  auto &&A_ref = to_ref(std::forward<T1>(A));
   using ret_val_type = plain_type_t<decltype(value_of(A_ref) * value_of(B))>;
   using ret_type = var_value<ret_val_type>;
   check_multiplicable("mdivide_left_spd", "A", A_ref, "B", B);
 
   if constexpr (!is_constant<T1>::value && !is_constant<T2>::value) {
-    arena_t<promote_scalar_t<var, T1>> arena_A = std::forward<decltype(A_ref)>(A_ref);
+    arena_t<promote_scalar_t<var, T1>> arena_A
+        = std::forward<decltype(A_ref)>(A_ref);
     arena_t<promote_scalar_t<var, T2>> arena_B = std::forward<T2>(B);
 
     check_symmetric("mdivide_left_spd", "A", arena_A.val());
@@ -293,7 +294,9 @@ inline auto mdivide_left_spd(T1&& A, T2&& B) {
 
     return ret_type(res);
   } else if constexpr (!is_constant<T1>::value) {
-    arena_t<promote_scalar_t<var, T1>> arena_A = std::forward<decltype(A_ref)>(A_ref);;
+    arena_t<promote_scalar_t<var, T1>> arena_A
+        = std::forward<decltype(A_ref)>(A_ref);
+    ;
 
     check_symmetric("mdivide_left_spd", "A", arena_A.val());
     check_not_nan("mdivide_left_spd", "A", arena_A.val());

From ea2f224a4c1a257cd0eeb6a7a6b683b3fa3c3811 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Mon, 7 Jul 2025 13:48:13 -0400
Subject: [PATCH 28/31] update

---
 stan/math/rev/fun/mdivide_left_spd.hpp | 2 --
 1 file changed, 2 deletions(-)

diff --git a/stan/math/rev/fun/mdivide_left_spd.hpp b/stan/math/rev/fun/mdivide_left_spd.hpp
index 8ca5c160f19..9b5891c8809 100644
--- a/stan/math/rev/fun/mdivide_left_spd.hpp
+++ b/stan/math/rev/fun/mdivide_left_spd.hpp
@@ -296,8 +296,6 @@ inline auto mdivide_left_spd(T1 &&A, T2 &&B) {
   } else if constexpr (!is_constant<T1>::value) {
     arena_t<promote_scalar_t<var, T1>> arena_A
         = std::forward<decltype(A_ref)>(A_ref);
-    ;
-
     check_symmetric("mdivide_left_spd", "A", arena_A.val());
     check_not_nan("mdivide_left_spd", "A", arena_A.val());
 

From 49a5273da60b885588b5bb83da1448140d446b45 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Tue, 8 Jul 2025 10:37:39 -0400
Subject: [PATCH 29/31] use to_ref in quad_diag_form

---
 stan/math/prim/fun/quad_form_diag.hpp | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/stan/math/prim/fun/quad_form_diag.hpp b/stan/math/prim/fun/quad_form_diag.hpp
index ffe00afb651..933af4710f8 100644
--- a/stan/math/prim/fun/quad_form_diag.hpp
+++ b/stan/math/prim/fun/quad_form_diag.hpp
@@ -16,8 +16,9 @@ inline auto quad_form_diag(EigMat&& mat, EigVec&& vec) {
                    vec.size());
   return make_holder(
       [](auto&& mat_, auto&& vec_) {
-        return vec_.asDiagonal() * std::forward<decltype(mat_)>(mat_)
-               * vec_.asDiagonal();
+        auto&& vec_ref = to_ref(vec_);
+        return vec_ref.asDiagonal() * std::forward<decltype(mat_)>(mat_)
+               * vec_ref.asDiagonal();
       },
       std::forward<EigMat>(mat), std::forward<EigVec>(vec));
 }

From 60065f1ff69451294841d53b720d14fe9bf25087 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Tue, 8 Jul 2025 14:17:19 -0400
Subject: [PATCH 30/31] use to_ref in quad_diag_form

---
 stan/math/prim/fun/quad_form_diag.hpp | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/stan/math/prim/fun/quad_form_diag.hpp b/stan/math/prim/fun/quad_form_diag.hpp
index 933af4710f8..56e1920ab19 100644
--- a/stan/math/prim/fun/quad_form_diag.hpp
+++ b/stan/math/prim/fun/quad_form_diag.hpp
@@ -16,11 +16,10 @@ inline auto quad_form_diag(EigMat&& mat, EigVec&& vec) {
                    vec.size());
   return make_holder(
       [](auto&& mat_, auto&& vec_) {
-        auto&& vec_ref = to_ref(vec_);
-        return vec_ref.asDiagonal() * std::forward<decltype(mat_)>(mat_)
-               * vec_ref.asDiagonal();
+        return to_ref(vec_).asDiagonal() * std::forward<decltype(mat_)>(mat_)
+               * to_ref(vec_).asDiagonal();
       },
-      std::forward<EigMat>(mat), std::forward<EigVec>(vec));
+      std::forward<EigMat>(mat), to_ref(std::forward<EigVec>(vec)));
 }
 
 }  // namespace math

From 54b12e1f7fbe742e77b0266dc90e43b9bca0e837 Mon Sep 17 00:00:00 2001
From: Steve Bronder <sbronder@flatironinstitute.org>
Date: Tue, 8 Jul 2025 14:18:24 -0400
Subject: [PATCH 31/31] use to_ref in quad_diag_form

---
 stan/math/prim/fun/quad_form_diag.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/stan/math/prim/fun/quad_form_diag.hpp b/stan/math/prim/fun/quad_form_diag.hpp
index 56e1920ab19..e04ed9cd69b 100644
--- a/stan/math/prim/fun/quad_form_diag.hpp
+++ b/stan/math/prim/fun/quad_form_diag.hpp
@@ -16,8 +16,8 @@ inline auto quad_form_diag(EigMat&& mat, EigVec&& vec) {
                    vec.size());
   return make_holder(
       [](auto&& mat_, auto&& vec_) {
-        return to_ref(vec_).asDiagonal() * std::forward<decltype(mat_)>(mat_)
-               * to_ref(vec_).asDiagonal();
+        return vec_.asDiagonal() * std::forward<decltype(mat_)>(mat_)
+               * vec_.asDiagonal();
       },
       std::forward<EigMat>(mat), to_ref(std::forward<EigVec>(vec)));
 }