Revert "Add tuple support to apply_scalar_unary for autodiff"

This reverts commit 23dafa2.

Author: nsiccha

stan/math/prim/functor/apply_scalar_unary.hpp

@@ -4,13 +4,11 @@
 #include <stan/math/prim/fun/Eigen.hpp>
 #include <stan/math/prim/meta/is_eigen.hpp>
 #include <stan/math/prim/meta/is_complex.hpp>
-#include <stan/math/prim/meta/is_tuple.hpp>
 #include <stan/math/prim/meta/holder.hpp>
 #include <stan/math/prim/meta/require_generics.hpp>
 #include <stan/math/prim/meta/is_vector.hpp>
 #include <stan/math/prim/meta/is_vector_like.hpp>
 #include <stan/math/prim/meta/plain_type.hpp>
-#include <tuple>
 #include <utility>
 #include <vector>
 
@@ -208,36 +206,6 @@ struct apply_scalar_unary<F, T, require_std_vector_t<T>> {
   }
 };
 
-/**
- * Template specialization for vectorized functions applying to
- * tuple arguments.  Each element of the tuple is processed
- * recursively through apply_scalar_unary, allowing heterogeneous
- * element types.
- *
- * @tparam F Type of function defining static apply function.
- * @tparam T Tuple type.
- */
-template <typename F, typename T>
-struct apply_scalar_unary<F, T, require_tuple_t<T>> {
-  template <typename TT, size_t... Is>
-  static inline auto apply_impl(TT&& x, std::index_sequence<Is...>) {
-    return std::make_tuple(
-        apply_scalar_unary<
-            F, std::tuple_element_t<Is, std::decay_t<T>>>::
-            apply(std::get<Is>(std::forward<TT>(x)))...);
-  }
-
-  template <typename TT>
-  static inline auto apply(TT&& x) {
-    return apply_impl(
-        std::forward<TT>(x),
-        std::make_index_sequence<std::tuple_size_v<std::decay_t<T>>>());
-  }
-
-  using return_t = std::decay_t<decltype(
-      apply_scalar_unary<F, T>::apply(std::declval<T>()))>;
-};
-
 }  // namespace math
 }  // namespace stan
 #endif

stan/math/prim/meta/is_autodiff.hpp

@@ -8,12 +8,10 @@
 #include <stan/math/prim/meta/is_fvar.hpp>
 #include <stan/math/prim/meta/is_vector.hpp>
 #include <stan/math/prim/meta/is_var.hpp>
-#include <stan/math/prim/meta/is_tuple.hpp>
 #include <stan/math/prim/meta/require_helpers.hpp>
 #include <stan/math/prim/meta/scalar_type.hpp>
 #include <stan/math/prim/meta/value_type.hpp>
 #include <complex>
-#include <tuple>
 #include <type_traits>
 
 namespace stan {
@@ -48,17 +46,6 @@ template <typename T>
 struct is_autodiff<T, require_eigen_t<T>>
     : bool_constant<is_autodiff<typename std::decay_t<T>::Scalar>::value> {};
 
-template <typename Tuple, typename = void>
-struct is_tuple_autodiff : std::false_type {};
-
-template <typename... Ts>
-struct is_tuple_autodiff<std::tuple<Ts...>, void>
-    : bool_constant<(is_autodiff<Ts>::value || ...)> {};
-
-template <typename T>
-struct is_autodiff<T, math::require_tuple_t<T>>
-    : is_tuple_autodiff<std::decay_t<T>> {};
-
 }  // namespace internal
 
 /**

stan/math/prim/meta/is_container.hpp

@@ -5,7 +5,6 @@
 #include <stan/math/prim/meta/disjunction.hpp>
 #include <stan/math/prim/meta/is_autodiff.hpp>
 #include <stan/math/prim/meta/is_eigen.hpp>
-#include <stan/math/prim/meta/is_tuple.hpp>
 #include <stan/math/prim/meta/is_vector.hpp>
 #include <stan/math/prim/meta/is_var_matrix.hpp>
 #include <stan/math/prim/meta/base_type.hpp>
@@ -100,11 +99,9 @@ using require_not_container_st
 /*! and holds a base type that satisfies @ref is_autodiff_scalar */
 /*! @tparam T the type to check */
 template <typename T>
-using require_ad_container_t = require_t<math::disjunction<
-    math::conjunction<math::disjunction<is_eigen<T>, is_std_vector<T>>,
-                      is_autodiff_scalar<base_type_t<T>>>,
-    math::conjunction<math::is_tuple<T>,
-                      internal::is_autodiff<std::decay_t<T>>>>>;
+using require_ad_container_t
+    = require_all_t<stan::math::disjunction<is_eigen<T>, is_std_vector<T>>,
+                    is_autodiff_scalar<base_type_t<T>>>;
 /*! @} */
 
 }  // namespace stan