Refactor scalar_type and value_type

We weren't getting expected behavior from some of these tests (e.g.
return_type<std::vector<matrix_v>> should be var, not matrix_v). I think
I made them simpler and they give me expected behavior for all the
use-cases I'm aware of.

stan/math/prim/arr.hpp

@@ -7,6 +7,7 @@
 #include <stan/math/prim/arr/meta/is_constant_struct.hpp>
 #include <stan/math/prim/arr/meta/is_vector.hpp>
 #include <stan/math/prim/arr/meta/length.hpp>
+#include <stan/math/prim/arr/meta/scalar_type.hpp>
 #include <stan/math/prim/arr/meta/value_type.hpp>
 #include <stan/math/prim/arr/meta/VectorBuilderHelper.hpp>
 #include <stan/math/prim/arr/meta/VectorView.hpp>

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

@@ -0,0 +1,28 @@
+#ifndef STAN_MATH_PRIM_ARR_META_SCALAR_TYPE_HPP
+#define STAN_MATH_PRIM_ARR_META_SCALAR_TYPE_HPP
+
+#include <stan/math/prim/arr/meta/scalar_type.hpp>
+#include <vector>
+
+namespace stan {
+  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;
+  };
+
+  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;
+  };
+}
+#endif

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

@@ -19,7 +19,7 @@ namespace stan {
        * Type of value stored in a standard vector with type
        * <code>T</code> entries.
        */
-      typedef typename std::vector<T>::value_type type;
+      typedef T type;
     };
 
   }

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

@@ -2,16 +2,33 @@
 #define STAN_MATH_PRIM_MAT_META_SCALAR_TYPE_HPP
 
 #include <stan/math/prim/mat/fun/Eigen.hpp>
-#include <stan/math/prim/mat/meta/is_vector.hpp>
-#include <stan/math/prim/mat/meta/value_type.hpp>
-#include <stan/math/prim/scal/meta/scalar_type.hpp>
+#include <stan/math/prim/arr/meta/scalar_type.hpp>
 
 namespace stan {
 
-  template <typename T>
-  struct scalar_type<Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic> > {
+  template <typename T, int R, int C>
+  struct scalar_type<Eigen::Matrix<T, R, C> > {
+    typedef typename scalar_type<T>::type type;
+  };
+
+  template <typename T, int R, int C>
+  struct scalar_type<const Eigen::Matrix<T, R, C> > {
+    typedef typename scalar_type<T>::type type;
+  };
+
+  template <typename T, int R, int C>
+  struct scalar_type<Eigen::Matrix<T, R, C>& > {
     typedef typename scalar_type<T>::type type;
   };
 
+  template <typename T, int R, int C>
+  struct scalar_type<const Eigen::Matrix<T, R, C>& > {
+    typedef typename scalar_type<T>::type type;
+  };
+
+  template <typename T>
+  struct scalar_type<Eigen::Block<T> > {
+    typedef typename scalar_type<T>::type type;
+  };
 }
 #endif

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

@@ -1,7 +1,7 @@
 #ifndef STAN_MATH_PRIM_MAT_META_VALUE_TYPE_HPP
 #define STAN_MATH_PRIM_MAT_META_VALUE_TYPE_HPP
 
-#include <stan/math/prim/scal/meta/value_type.hpp>
+#include <stan/math/prim/arr/meta/value_type.hpp>
 #include <Eigen/Core>
 
 namespace stan {
@@ -17,7 +17,7 @@ namespace stan {
      */
     template <typename T, int R, int C>
     struct value_type<Eigen::Matrix<T, R, C> > {
-      typedef typename Eigen::Matrix<T, R, C>::Scalar type;
+      typedef T type;
     };
 
   }

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

@@ -5,22 +5,6 @@
 #include <stan/math/prim/scal/meta/value_type.hpp>
 
 namespace stan {
-  namespace {
-    template <bool is_vec, typename T>
-    struct scalar_type_helper {
-      typedef T type;
-    };
-
-    template <typename T>
-    struct scalar_type_helper<true, T> {
-      typedef typename
-      scalar_type_helper<is_vector<typename
-                                   stan::math::value_type<T>::type>::value,
-                         typename stan::math::value_type<T>::type>::type
-      type;
-    };
-  }
-
   /**
    * Metaprogram structure to determine the base scalar type
    * of a template argument.
@@ -31,7 +15,7 @@ namespace stan {
    */
   template <typename T>
   struct scalar_type {
-    typedef typename scalar_type_helper<is_vector<T>::value, T>::type type;
+    typedef T type;
   };
 
   template <typename T>

test/unit/math/prim/arr/meta/scalar_type_test.cpp

@@ -10,3 +10,21 @@ TEST(MetaTraits, ScalarTypeArray) {
   test::expect_same_type<int, scalar_type<vector<int> >::type>();
   test::expect_same_type<double, scalar_type<vector<vector<double> > >::type>();
 }
+
+TEST(MetaTraits, ScalarTypeArrayConst) {
+  using stan::scalar_type;
+  using std::vector;
+
+  test::expect_same_type<double, scalar_type<const vector<double> >::type>();
+  test::expect_same_type<int, scalar_type<const vector<int> >::type>();
+  test::expect_same_type<double, scalar_type<const vector<vector<double> > >::type>();
+}
+
+TEST(MetaTraits, ScalarTypeArrayConstConst) {
+  using stan::scalar_type;
+  using std::vector;
+
+  test::expect_same_type<const double, scalar_type<const vector<const double> >::type>();
+  test::expect_same_type<const int, scalar_type<const vector<const int> >::type>();
+  test::expect_same_type<const double, scalar_type<const vector<const vector<const double> > >::type>();
+}

test/unit/math/prim/mat/meta/scalar_type_test.cpp

@@ -14,8 +14,6 @@ TEST(MetaTraits, ScalarTypeMat) {
   expect_same_type<double, scalar_type<MatrixXd>::type>();
   expect_same_type<double, scalar_type<VectorXd>::type>();
   expect_same_type<double, scalar_type<RowVectorXd>::type>();
-
-  // TODO(Sean): This behavior doesn't seem to make sense prima facie
-  // Likely change this so that we would expect `double` here instead.
-  expect_same_type<MatrixXd, scalar_type<vector<MatrixXd> >::type>();
+  expect_same_type<double, scalar_type<vector<double> >::type>();
+  expect_same_type<double, scalar_type<vector<MatrixXd> >::type>();
 }

test/unit/math/prim/mat/meta/value_type_test.cpp

@@ -15,4 +15,7 @@ TEST(MathMeta, index_type) {
 
   expect_same_type<Matrix<double,1,Dynamic>::Scalar,
                    value_type<Matrix<double,1,Dynamic> >::type>();
+
+  expect_same_type<Matrix<double,1,Dynamic>,
+                   value_type<std::vector<Matrix<double,1,Dynamic> > >::type>();
 }

test/unit/math/rev/arr/meta/return_type_test.cpp

@@ -0,0 +1,19 @@
+#include <stan/math/rev/arr.hpp>
+#include <gtest/gtest.h>
+#include <test/unit/util.hpp>
+
+using stan::return_type;
+using stan::math::var;
+using std::vector;
+
+TEST(MetaTraits, ReturnTypeVarArray) {
+  test::expect_same_type<var, return_type<vector<var> >::type>();
+  test::expect_same_type<var, return_type<vector<var>, double>::type>();
+  test::expect_same_type<var, return_type<vector<var>, double>::type>();
+}
+
+TEST(MetaTraits, ReturnTypeDoubleArray) {
+  test::expect_same_type<double, return_type<vector<double> >::type>();
+  test::expect_same_type<double, return_type<vector<double>, double>::type>();
+  test::expect_same_type<double, return_type<vector<double>, double>::type>();
+}

test/unit/math/rev/mat/meta/return_type_test.cpp

@@ -0,0 +1,34 @@
+#include <stan/math/rev/mat.hpp>
+#include <stan/math/rev/mat/fun/typedefs.hpp>
+#include <gtest/gtest.h>
+#include <test/unit/util.hpp>
+
+using stan::return_type;
+using stan::math::var;
+using stan::math::matrix_d;
+using stan::math::matrix_v;
+using stan::math::vector_d;
+using stan::math::vector_v;
+using std::vector;
+
+TEST(MetaTraits, ReturnTypeVarMat) {
+  test::expect_same_type<var, return_type<vector_v >::type>();
+  test::expect_same_type<var, return_type<matrix_v >::type>();
+  test::expect_same_type<var, return_type<matrix_v, double>::type>();
+  test::expect_same_type<var, return_type<matrix_v, var>::type>();
+  test::expect_same_type<var, return_type<matrix_d, matrix_v>::type>();
+}
+
+TEST(MetaTraits, ReturnTypeMatMultivar) {
+  //test::expect_same_type<var, return_type<vector<vector_v> >::type>();
+  test::expect_same_type<var, return_type<vector<matrix_v> >::type>();
+  test::expect_same_type<var, return_type<vector<matrix_v>, double>::type>();
+  test::expect_same_type<var, return_type<vector<matrix_v>, var>::type>();
+  test::expect_same_type<var, return_type<vector<matrix_d>, matrix_v>::type>();
+}
+
+TEST(MetaTraits, ReturnTypeDoubleMat) {
+  test::expect_same_type<double, return_type<vector_d >::type>();
+  test::expect_same_type<double, return_type<matrix_d, double>::type>();
+  test::expect_same_type<var, return_type<matrix_d, var>::type>();
+}