Refactor for the meta functions

.gitignore

@@ -77,3 +77,9 @@ lib/boost_*/user-config.jam
 
 # clang-tidy output
 .clang-fixes.log
+
+# Clang compilation database
+compile_commands.json
+
+# Visual Studio Project Setup
+.vscode/*

stan/math/fwd/core/fvar.hpp

@@ -3,7 +3,6 @@
 
 #include <stan/math/prim/meta.hpp>
 #include <stan/math/prim/scal/fun/is_nan.hpp>
-#include <stan/math/fwd/meta.hpp>
 #include <ostream>
 
 namespace stan {
@@ -49,6 +48,10 @@ struct fvar {
    */
   T d_;
 
+  /**
+   * The Type inside of the fvar.
+   */
+  using Scalar = T;
   /**
    * Return the value of this variable.
    *

stan/math/fwd/meta.hpp

@@ -1,7 +1,6 @@
 #ifndef STAN_MATH_FWD_META_HPP
 #define STAN_MATH_FWD_META_HPP
 
-#include <stan/math/fwd/scal/meta/ad_promotable.hpp>
 #include <stan/math/fwd/scal/meta/is_fvar.hpp>
 #include <stan/math/fwd/scal/meta/partials_type.hpp>
 #include <stan/math/fwd/scal/meta/operands_and_partials.hpp>

stan/math/fwd/scal/meta/is_fvar.hpp

@@ -3,16 +3,23 @@
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/prim/scal/meta/is_fvar.hpp>
+#include <type_traits>
 
 namespace stan {
-/**
- * Defines a public enum named value and sets it to true(1)
- * when instantiated with the stan::math::fvar type.
- */
+
+namespace internal {
+template <typename T>
+struct is_fvar_impl : std::false_type {};
+
+template <typename T>
+struct is_fvar_impl<math::fvar<T>> : std::true_type {};
+
+}  // namespace internal
+
 template <typename T>
-struct is_fvar<stan::math::fvar<T> > {
-  enum { value = true };
-};
+struct is_fvar<T,
+               std::enable_if_t<internal::is_fvar_impl<std::decay_t<T>>::value>>
+    : std::true_type {};
 
 }  // namespace stan
 #endif

stan/math/fwd/scal/meta/partials_type.hpp

@@ -2,13 +2,15 @@
 #define STAN_MATH_FWD_SCAL_META_PARTIALS_TYPE_HPP
 
 #include <stan/math/fwd/core.hpp>
+#include <stan/math/fwd/scal/meta/is_fvar.hpp>
 #include <stan/math/prim/scal/meta/partials_type.hpp>
+#include <type_traits>
 
 namespace stan {
 
 template <typename T>
-struct partials_type<stan::math::fvar<T> > {
-  typedef T type;
+struct partials_type<T, std::enable_if_t<is_fvar<std::decay_t<T>>::value>> {
+  using type = typename std::decay_t<T>::Scalar;
 };
 
 }  // namespace stan

stan/math/mix/meta.hpp

@@ -2,8 +2,6 @@
 #define STAN_MATH_MIX_META_HPP
 
 #include <stan/math/prim/scal/meta/ad_promotable.hpp>
-#include <stan/math/rev/scal/meta/ad_promotable.hpp>
-#include <stan/math/fwd/scal/meta/ad_promotable.hpp>
 
 #include <stan/math/fwd/core.hpp>
 #include <stan/math/fwd/scal/meta/is_fvar.hpp>

stan/math/prim/arr/meta/index_type.hpp

@@ -1,7 +1,9 @@
 #ifndef STAN_MATH_PRIM_ARR_META_INDEX_TYPE_HPP
 #define STAN_MATH_PRIM_ARR_META_INDEX_TYPE_HPP
 
+#include <stan/math/prim/arr/meta/is_vector.hpp>
 #include <stan/math/prim/scal/meta/index_type.hpp>
+#include <type_traits>
 #include <vector>
 
 namespace stan {
@@ -14,11 +16,8 @@ namespace math {
  * @tparam T type of elements in standard vector.
  */
 template <typename T>
-struct index_type<std::vector<T> > {
-  /**
-   * Typedef for index of standard vectors.
-   */
-  typedef typename std::vector<T>::size_type type;
+struct index_type<T, std::enable_if_t<is_std_vector<T>::value>> {
+  using type = typename std::decay_t<T>::size_type;
 };
 
 }  // namespace math

stan/math/prim/arr/meta/is_constant.hpp

@@ -1,20 +1,23 @@
 #ifndef STAN_MATH_PRIM_ARR_META_IS_CONSTANT_HPP
 #define STAN_MATH_PRIM_ARR_META_IS_CONSTANT_HPP
 
+#include <stan/math/prim/arr/meta/is_vector.hpp>
+#include <stan/math/prim/scal/meta/bool_constant.hpp>
 #include <stan/math/prim/scal/meta/is_constant.hpp>
+#include <type_traits>
 #include <vector>
 
 namespace stan {
 /**
- * Defines a public enum named value and sets it to true
+ * Defines a static member named value and sets it to true
  * if the type of the elements in the provided std::vector
  * is constant, false otherwise. This is used in
  * the is_constant_all metaprogram.
  * @tparam type of the elements in the std::vector
  */
 template <typename T>
-struct is_constant<std::vector<T> > {
-  enum { value = is_constant<T>::value };
+struct is_constant<T, std::enable_if_t<is_std_vector<T>::value>>
+    : bool_constant<is_constant<typename std::decay_t<T>::value_type>::value> {
 };
 
 }  // namespace stan

stan/math/prim/arr/meta/is_vector.hpp

@@ -2,22 +2,35 @@
 #define STAN_MATH_PRIM_ARR_META_IS_VECTOR_HPP
 
 #include <stan/math/prim/scal/meta/is_vector.hpp>
+#include <type_traits>
 #include <vector>
 
 namespace stan {
 
-// FIXME: use boost::type_traits::remove_all_extents to
-//   extend to array/ptr types
+namespace internal {
 
+/**
+ * This underlying implimentation is used when the type is not an std vector.
+ */
 template <typename T>
-struct is_vector<const T> {
-  enum { value = is_vector<T>::value };
-  typedef T type;
-};
+struct is_std_vector_impl : std::false_type {};
+
+/**
+ * This specialization implimentation has a static member named value when the
+ * template type is an std vector.
+ */
+template <typename... Args>
+struct is_std_vector_impl<std::vector<Args...>> : std::true_type {};
+
+}  // namespace internal
+
+/**
+ * Checks if the decayed type of T is a standard vector.
+ */
 template <typename T>
-struct is_vector<std::vector<T> > {
-  enum { value = 1 };
-  typedef T type;
-};
+struct is_std_vector<
+    T, std::enable_if_t<internal::is_std_vector_impl<std::decay_t<T>>::value>>
+    : std::true_type {};
+
 }  // namespace stan
 #endif

stan/math/prim/arr/meta/scalar_type.hpp

@@ -1,28 +1,20 @@
 #ifndef STAN_MATH_PRIM_ARR_META_SCALAR_TYPE_HPP
 #define STAN_MATH_PRIM_ARR_META_SCALAR_TYPE_HPP
 
+#include <stan/math/prim/arr/meta/is_vector.hpp>
 #include <stan/math/prim/scal/meta/scalar_type.hpp>
+#include <type_traits>
 #include <vector>
 
 namespace stan {
+/**
+ * Specialization of scalar_type for vector to recursivly return the inner
+ * scalar type.
+ */
 template <typename T>
-struct scalar_type<std::vector<T> > {
-  typedef typename scalar_type<T>::type type;
+struct scalar_type<T, std::enable_if_t<is_std_vector<T>::value>> {
+  using type = scalar_type_t<typename std::decay_t<T>::value_type>;
 };
 
-template <typename T>
-struct scalar_type<const std::vector<T> > {
-  typedef typename scalar_type<T>::type type;
-};
-
-template <typename T>
-struct scalar_type<std::vector<T>&> {
-  typedef typename scalar_type<T>::type type;
-};
-
-template <typename T>
-struct scalar_type<const std::vector<T>&> {
-  typedef typename scalar_type<T>::type type;
-};
 }  // namespace stan
 #endif

stan/math/prim/arr/meta/value_type.hpp

@@ -1,6 +1,7 @@
 #ifndef STAN_MATH_PRIM_ARR_META_VALUE_TYPE_HPP
 #define STAN_MATH_PRIM_ARR_META_VALUE_TYPE_HPP
 
+#include <stan/math/prim/arr/meta/is_vector.hpp>
 #include <stan/math/prim/scal/meta/value_type.hpp>
 #include <vector>
 
@@ -14,12 +15,8 @@ namespace math {
  * @tparam T type of elements in standard vector.
  */
 template <typename T>
-struct value_type<std::vector<T> > {
-  /**
-   * Type of value stored in a standard vector with type
-   * <code>T</code> entries.
-   */
-  typedef T type;
+struct value_type<T, std::enable_if_t<is_std_vector<T>::value>> {
+  using type = typename std::decay_t<T>::value_type;
 };
 
 }  // namespace math

stan/math/prim/mat/meta/index_type.hpp

@@ -1,8 +1,10 @@
 #ifndef STAN_MATH_PRIM_MAT_META_INDEX_TYPE_HPP
 #define STAN_MATH_PRIM_MAT_META_INDEX_TYPE_HPP
 
+#include <stan/math/prim/mat/fun/Eigen.hpp>
+#include <stan/math/prim/mat/meta/is_eigen.hpp>
 #include <stan/math/prim/scal/meta/index_type.hpp>
-#include <Eigen/Core>
+#include <type_traits>
 
 namespace stan {
 namespace math {
@@ -12,12 +14,10 @@ namespace math {
  * an Eigen matrix, vector, or row vector.
  *
  * @tparam T type of matrix.
- * @tparam R number of rows for matrix.
- * @tparam C number of columns for matrix.
  */
-template <typename T, int R, int C>
-struct index_type<Eigen::Matrix<T, R, C> > {
-  typedef typename Eigen::Matrix<T, R, C>::Index type;
+template <typename T>
+struct index_type<T, std::enable_if_t<is_eigen<T>::value>> {
+  using type = typename std::decay_t<T>::Index;
 };
 
 }  // namespace math

stan/math/prim/mat/meta/is_constant.hpp

@@ -2,7 +2,10 @@
 #define STAN_MATH_PRIM_MAT_META_IS_CONSTANT_HPP
 
 #include <stan/math/prim/mat/fun/Eigen.hpp>
+#include <stan/math/prim/mat/meta/is_eigen.hpp>
+#include <stan/math/prim/scal/meta/bool_constant.hpp>
 #include <stan/math/prim/scal/meta/is_constant.hpp>
+#include <type_traits>
 
 namespace stan {
 /**
@@ -11,26 +14,11 @@ namespace stan {
  * is constant, false otherwise. This is used in
  * the is_constant_all metaprogram.
  *
- * @tparam T type of the elements in the Eigen Matrix
- * @tparam R number of rows in the Eigen Matrix
- * @tparam C number of cols in the eigen Matrix
- */
-template <typename T, int R, int C>
-struct is_constant<Eigen::Matrix<T, R, C> > {
-  enum { value = is_constant<T>::value };
-};
-
-/**
- * Defines a public enum named value and sets it to true
- * if the type of the elements in the provided Eigen Block
- * is constant, false otherwise. This is used in
- * the is_constant_all metaprogram.
- * @tparam type of the elements in the Eigen Block
+ * @tparam T type of the Eigen Matrix
  */
 template <typename T>
-struct is_constant<Eigen::Block<T> > {
-  enum { value = is_constant<T>::value };
-};
+struct is_constant<T, std::enable_if_t<is_eigen<T>::value>>
+    : bool_constant<is_constant<typename std::decay_t<T>::Scalar>::value> {};
 
 }  // namespace stan
 #endif