diff --git a/blas/impl/KokkosBlas1_scal_impl.hpp b/blas/impl/KokkosBlas1_scal_impl.hpp
index de216a156e..72606b6bb2 100644
--- a/blas/impl/KokkosBlas1_scal_impl.hpp
+++ b/blas/impl/KokkosBlas1_scal_impl.hpp
@@ -57,7 +57,7 @@ struct V_Scal_Functor {
   XV m_x;
   AV m_a;
 
-  V_Scal_Functor(const RV& r, const XV& x, const AV& a, const SizeType startingColumn)
+  V_Scal_Functor(const RV& r, const XV& x, const AV& a)
       : m_r(r), m_x(x), m_a(a) {
     static_assert(Kokkos::is_view<RV>::value,
                   "V_Scal_Functor: RV is not a Kokkos::View.");
@@ -68,15 +68,6 @@ struct V_Scal_Functor {
                   "V_Scal_Functor: XV is not a Kokkos::View.");
     static_assert(RV::rank == 1, "V_Scal_Functor: RV is not rank 1.");
     static_assert(XV::rank == 1, "V_Scal_Functor: XV is not rank 1.");
-
-
-    if constexpr (Kokkos::is_view_v<AV>) {
-      if (startingColumn != 0) {
-      m_a = Kokkos::subview(
-          a,
-          std::make_pair(startingColumn, static_cast<SizeType>(a.extent(0))));
-      }
-    }
   }
 
   KOKKOS_INLINE_FUNCTION
@@ -105,54 +96,31 @@ struct V_Scal_Functor {
   }
 };
 
-#if 0
-// Partial specialization of V_Scal_Functor that lets a be a scalar
-// (rather than a 1-D View, as in the most general version above).
-// This functor computes any of the following:
-//
-// 1. Y(i) = alpha*X(i) for alpha in -1,0,1
-// 2. Y(i) = a*X(i)
-template <class RV, class XV, int scalar_x, class SizeType>
-struct V_Scal_Functor<RV, typename XV::non_const_value_type, XV, scalar_x,
-                      SizeType> {
-  typedef SizeType size_type;
-  typedef Kokkos::ArithTraits<typename RV::non_const_value_type> ATS;
+/*! \brief 
 
-  RV m_r;
-  XV m_x;
-  const typename XV::non_const_value_type m_a;
+ r(i) = av * x(i)
+ r(i) = av() * x(i)
 
-  V_Scal_Functor(const RV& r, const XV& x,
-                 const typename XV::non_const_value_type& a,
-                 const SizeType /* startingColumn */)
-      : m_r(r), m_x(x), m_a(a) {}
+ \param space
+ \param r
+ \param av
+ \param x
+ \param alphaHint A KokkosKernels::Impl::ScalarHint corresponding to the value of av. If not KokkosKernels::Impl:ß:ScalarHint::none, may be used to optimize the implementation
+
+ \tparam SizeType
+ \tparam ExecutionSpace
+ \tparam RV
+ \tparam AV
+ \tparam XV
+
+*/
+template <typename SizeType, typename ExecutionSpace, typename RV, typename AV, typename XV>
+void V_Scal_Generic(const ExecutionSpace& space, const RV& r, const AV& av,
+                    const XV& x,
+                    const KokkosKernels::Impl::ScalarHint &alphaHint = KokkosKernels::Impl::ScalarHint::none) {
+
+  // TODO: assert some things about AV
 
-  KOKKOS_INLINE_FUNCTION
-  void operator()(const size_type& i) const {
-    if (scalar_x == 0) {
-      m_r(i) = ATS::zero();
-    }
-    if (scalar_x == -1) {
-      m_r(i) = -m_x(i);
-    }
-    if (scalar_x == 1) {
-      m_r(i) = m_x(i);
-    }
-    if (scalar_x == 2) {
-      m_r(i) = m_a * m_x(i);
-    }
-  }
-};
-#endif
-
-// Variant of MV_Scal_Generic for single vectors (1-D Views) r and x.
-// As above, av is either a 1-D View (and only its first entry will be
-// read), or a scalar.
-template <class execution_space, class RV, class AV, class XV, class SizeType>
-void V_Scal_Generic(const execution_space& space, const RV& r, const AV& av,
-                    const XV& x, 
-                    const SizeType startingColumn,
-                    const KokkosKernels::Impl::ScalarHint &alphaHint) {
   static_assert(Kokkos::is_view<RV>::value,
                 "V_Scal_Generic: RV is not a Kokkos::View.");
   static_assert(Kokkos::is_view<XV>::value,
@@ -161,26 +129,26 @@ void V_Scal_Generic(const execution_space& space, const RV& r, const AV& av,
   static_assert(XV::rank == 1, "V_Scal_Generic: XV is not rank 1.");
 
   const SizeType numRows = x.extent(0);
-  Kokkos::RangePolicy<execution_space, SizeType> policy(space, 0, numRows);
+  Kokkos::RangePolicy<ExecutionSpace, SizeType> policy(space, 0, numRows);
 
   if (alphaHint == KokkosKernels::Impl::ScalarHint::zero) {
-    V_Scal_Functor<RV, AV, XV, KokkosKernels::Impl::ScalarHint::zero, SizeType> op(r, x, av, startingColumn);
-    Kokkos::parallel_for("KokkosBlas::Scal::S0", policy, op);
+    V_Scal_Functor<RV, AV, XV, KokkosKernels::Impl::ScalarHint::zero, SizeType> op(r, x, av);
+    Kokkos::parallel_for("KokkosBlas::Scal::0", policy, op);
     return;
   }
   else if (alphaHint == KokkosKernels::Impl::ScalarHint::neg_one) {
-    V_Scal_Functor<RV, AV, XV, KokkosKernels::Impl::ScalarHint::neg_one, SizeType> op(r, x, av, startingColumn);
-    Kokkos::parallel_for("KokkosBlas::Scal::S1", policy, op);
+    V_Scal_Functor<RV, AV, XV, KokkosKernels::Impl::ScalarHint::neg_one, SizeType> op(r, x, av);
+    Kokkos::parallel_for("KokkosBlas::Scal::-1", policy, op);
     return;
   }
   else if (alphaHint == KokkosKernels::Impl::ScalarHint::pos_one) {
-    V_Scal_Functor<RV, AV, XV, KokkosKernels::Impl::ScalarHint::pos_one, SizeType> op(r, x, av, startingColumn);
-    Kokkos::parallel_for("KokkosBlas::Scal::S2", policy, op);
+    V_Scal_Functor<RV, AV, XV, KokkosKernels::Impl::ScalarHint::pos_one, SizeType> op(r, x, av);
+    Kokkos::parallel_for("KokkosBlas::Scal::1", policy, op);
     return;
   }
 
-  V_Scal_Functor<RV, AV, XV, KokkosKernels::Impl::ScalarHint::none, SizeType> op(r, x, av, startingColumn);
-  Kokkos::parallel_for("KokkosBlas::Scal::S3", policy, op);
+  V_Scal_Functor<RV, AV, XV, KokkosKernels::Impl::ScalarHint::none, SizeType> op(r, x, av);
+  Kokkos::parallel_for("KokkosBlas::Scal::none", policy, op);
 }
 
 }  // namespace Impl
diff --git a/blas/impl/KokkosBlas1_scal_mv_impl.hpp b/blas/impl/KokkosBlas1_scal_mv_impl.hpp
index 045f3e194b..242c077cc9 100644
--- a/blas/impl/KokkosBlas1_scal_mv_impl.hpp
+++ b/blas/impl/KokkosBlas1_scal_mv_impl.hpp
@@ -422,7 +422,7 @@ void MV_Scal_Generic(const execution_space& space, const RVector& r,
 template <class execution_space, class RMV, class AV, class XMV, class SizeType>
 void MV_Scal_Invoke_Left(const execution_space& space, const RMV& r,
                          const AV& av, const XMV& x,
-                         const KokkosKernels::Impl::ScalarHint &a = KokkosKernels::Impl::ScalarHint::none) {
+                         const KokkosKernels::Impl::ScalarHint &aHint = KokkosKernels::Impl::ScalarHint::none) {
   const SizeType numCols = x.extent(1);
 
 #if KOKKOSBLAS_OPTIMIZATION_LEVEL_SCAL <= 2
@@ -440,7 +440,7 @@ void MV_Scal_Invoke_Left(const execution_space& space, const RMV& r,
     typedef decltype(R_cur) RMV2D;
 
     MV_Scal_Unrolled<execution_space, RMV2D, AV, XMV2D, 8, SizeType>(
-        space, R_cur, av, X_cur, j, a);
+        space, R_cur, av, X_cur, j, aHint);
   }
   for (; j + 4 <= numCols; j += 4) {
     const std::pair<SizeType, SizeType> rng(j, j + 4);
@@ -450,7 +450,7 @@ void MV_Scal_Invoke_Left(const execution_space& space, const RMV& r,
     typedef decltype(R_cur) RMV2D;
 
     MV_Scal_Unrolled<execution_space, RMV2D, AV, XMV2D, 4, SizeType>(
-        space, R_cur, av, X_cur, j, a);
+        space, R_cur, av, X_cur, j, aHint);
   }
   for (; j < numCols; ++j) {
     // RMV and XMV need to turn 1-D.
@@ -459,8 +459,21 @@ void MV_Scal_Invoke_Left(const execution_space& space, const RMV& r,
     typedef decltype(r_cur) RV;
     typedef decltype(x_cur) XV;
 
-    V_Scal_Generic<execution_space, RV, AV, XV, SizeType>(space, r_cur, av,
-                                                          x_cur, j, a);
+    // If AV is a rank-one vector, get a rank-0 subview
+    // Otherwise, just pass along AV as-is
+    // can't short-circuit if constexpr :(
+    if constexpr (Kokkos::is_view_v<AV>) {
+      if constexpr (AV::rank == 1) {
+        auto a_cur = Kokkos::subview(av, j);
+        V_Scal_Generic<SizeType>(space, r_cur, a_cur, x_cur, aHint);
+      } else {
+        V_Scal_Generic<SizeType>(space, r_cur, av, x_cur, aHint);        
+      }
+    } else {
+      V_Scal_Generic<SizeType>(space, r_cur, av, x_cur, aHint);
+    }
+
+
   }
 
 #else  // KOKKOSBLAS_OPTIMIZATION_LEVEL_SCAL > 2
@@ -472,7 +485,7 @@ void MV_Scal_Invoke_Left(const execution_space& space, const RMV& r,
       typedef decltype(r_0) RV;
       typedef decltype(x_0) XV;
 
-      V_Scal_Generic<execution_space, RV, AV, XV, SizeType>(space, r_0, av, x_0,
+      V_Scal_Generic<SizeType>(space, r_0, av, x_0,
                                                             0, a);
       break;
     }
@@ -537,7 +550,7 @@ void MV_Scal_Invoke_Left(const execution_space& space, const RMV& r,
           space, r, av, x, 0, a);
       break;
     default:
-      MV_Scal_Generic<execution_space, RMV, AV, XMV, SizeType>(space, r, av, x,
+      MV_Scal_Generic<SizeType>(space, r, av, x,
                                                                0, a);
   }
 
@@ -574,11 +587,9 @@ void MV_Scal_Invoke_Right(const execution_space& space, const RMV& r,
 
     RV r_0 = Kokkos::subview(r, Kokkos::ALL(), 0);
     XV x_0 = Kokkos::subview(x, Kokkos::ALL(), 0);
-    V_Scal_Generic<execution_space, RMV, aVector, XMV, 1, SizeType>(space, r_0,
-                                                                    av, x_0, a);
+    V_Scal_Generic<SizeType>(space, r_0, av, x_0, a);
   } else {
-    MV_Scal_Generic<execution_space, RMV, aVector, XMV, SizeType>(space, r, av,
-                                                                  x, a);
+    MV_Scal_Generic<SizeType>(space, r, av, x, a);
   }
 }
 
diff --git a/blas/impl/KokkosBlas1_scal_spec.hpp b/blas/impl/KokkosBlas1_scal_spec.hpp
index c117a8f8c4..57f120941c 100644
--- a/blas/impl/KokkosBlas1_scal_spec.hpp
+++ b/blas/impl/KokkosBlas1_scal_spec.hpp
@@ -39,11 +39,12 @@ struct scal_eti_spec_avail {
 
 //
 // Macro for declaration of full specialization availability
-// KokkosBlas::Impl::Scal for rank == 1.  This is NOT for users!!!  All
+// KokkosBlas::Impl::Scal for rank == 1 R and X.  This is NOT for users!!!  All
 // the declarations of full specializations go in this header file.
 // We may spread out definitions (see _INST macro below) across one or
 // more .cpp files.
 //
+// Alpha can either be scalar or rank 0
 #define KOKKOSBLAS1_SCAL_ETI_SPEC_AVAIL(SCALAR, LAYOUT, EXEC_SPACE, MEM_SPACE) \
   template <>                                                                  \
   struct scal_eti_spec_avail<                                                  \
@@ -56,15 +57,28 @@ struct scal_eti_spec_avail {
                    Kokkos::MemoryTraits<Kokkos::Unmanaged> >,                  \
       1> {                                                                     \
     enum : bool { value = true };                                              \
+  };                                                                           \
+  template <>                                                                  \
+  struct scal_eti_spec_avail<                                                  \
+      EXEC_SPACE,                                                              \
+      Kokkos::View<SCALAR*, LAYOUT, Kokkos::Device<EXEC_SPACE, MEM_SPACE>,     \
+                   Kokkos::MemoryTraits<Kokkos::Unmanaged> >,                  \
+      Kokkos::View<SCALAR, LAYOUT, Kokkos::Device<EXEC_SPACE, MEM_SPACE>,      \
+                  Kokkos::MemoryTraits<Kokkos::Unmanaged> >,                   \
+      Kokkos::View<const SCALAR*, LAYOUT,                                      \
+                   Kokkos::Device<EXEC_SPACE, MEM_SPACE>,                      \
+                   Kokkos::MemoryTraits<Kokkos::Unmanaged> >,                  \
+      1> {                                                                     \
+    enum : bool { value = true };                                              \
   };
-
 //
 // Macro for declaration of full specialization availability
-// KokkosBlas::Impl::Scal for rank == 2.  This is NOT for users!!!  All
+// KokkosBlas::Impl::Scal for rank == 2 R and X. This is NOT for users!!!  All
 // the declarations of full specializations go in this header file.
 // We may spread out definitions (see _DEF macro below) across one or
 // more .cpp files.
 //
+// Alpha can either be rank 1, rank 0, or scalar
 #define KOKKOSBLAS1_SCAL_MV_ETI_SPEC_AVAIL(SCALAR, LAYOUT, EXEC_SPACE,      \
                                            MEM_SPACE)                       \
   template <>                                                               \
@@ -82,6 +96,20 @@ struct scal_eti_spec_avail {
     enum : bool { value = true };                                           \
   };                                                                        \
   template <>                                                               \
+  struct scal_eti_spec_avail<                                               \
+      EXEC_SPACE,                                                           \
+      Kokkos::View<SCALAR**, LAYOUT, Kokkos::Device<EXEC_SPACE, MEM_SPACE>, \
+                   Kokkos::MemoryTraits<Kokkos::Unmanaged> >,               \
+      Kokkos::View<const SCALAR, LAYOUT,                                    \
+                   Kokkos::Device<EXEC_SPACE, MEM_SPACE>,                   \
+                   Kokkos::MemoryTraits<Kokkos::Unmanaged> >,               \
+      Kokkos::View<const SCALAR**, LAYOUT,                                  \
+                   Kokkos::Device<EXEC_SPACE, MEM_SPACE>,                   \
+                   Kokkos::MemoryTraits<Kokkos::Unmanaged> >,               \
+      2> {                                                                  \
+    enum : bool { value = true };                                           \
+  };                                                                        \
+  template <>                                                               \
   struct scal_eti_spec_avail<                                               \
       EXEC_SPACE,                                                           \
       Kokkos::View<SCALAR**, LAYOUT, Kokkos::Device<EXEC_SPACE, MEM_SPACE>, \
@@ -151,7 +179,7 @@ struct Scal<execution_space, RV, typename XV::non_const_value_type, XV, 1,
           typeid(RV).name(), typeid(AV).name(), typeid(XV).name());
 #endif
 
-    const size_type numRows = X.extent(0);
+    
     KokkosKernels::Impl::ScalarHint alphaHint = KokkosKernels::Impl::ScalarHint::none;
     if (alpha == ATA::zero()) {
       alphaHint = KokkosKernels::Impl::ScalarHint::zero;
@@ -161,25 +189,22 @@ struct Scal<execution_space, RV, typename XV::non_const_value_type, XV, 1,
       alphaHint = KokkosKernels::Impl::ScalarHint::pos_one;
     }
 
+    const size_type numRows = X.extent(0);
     if (numRows < static_cast<size_type>(INT_MAX)) {
-      typedef int index_type;
-      V_Scal_Generic<execution_space, RV, AV, XV, index_type>(space, R, alpha,
-                                                              X, 0, alphaHint);
+      V_Scal_Generic<int>(space, R, alpha, X, alphaHint);
     } else {
-      typedef typename XV::size_type index_type;
-      V_Scal_Generic<execution_space, RV, AV, XV, index_type>(space, R, alpha,
-                                                              X, 0, alphaHint);
+      V_Scal_Generic<typename XV::size_type>(space, R, alpha, X, alphaHint);
     }
     Kokkos::Profiling::popRegion();
   }
 };
 
-/// \brief Partial specialization of Scal for 2-D Views and 1-D View AV.
+/// \brief Partial specialization of Scal for 2-D Views and 1-D, 0-D, or scalar AV.
 ///
 /// Compute any of the following:
-///
-/// 1. R(i,j) = a*X(i,j) for a in -1,0,1
-/// 2. R(i,j) = alpha(j)*X(i,j)
+/// 1. R(i,j) = av    * X(i,j)
+/// 2. R(i,j) = av()  * X(i,j)
+/// 3. R(i,j) = av(j) * X(i,j)
 template <class execution_space, class RMV, class AV, class XMV>
 struct Scal<execution_space, RMV, AV, XMV, 2, false,
             KOKKOSKERNELS_IMPL_COMPILE_LIBRARY> {
@@ -189,6 +214,9 @@ struct Scal<execution_space, RMV, AV, XMV, 2, false,
 
   static void scal(const execution_space& space, const RMV& R, const AV& av,
                    const XMV& X) {
+
+    // TODO: assert some things about AV
+
     static_assert(Kokkos::is_view<RMV>::value,
                   "KokkosBlas::Impl::"
                   "Scal<2-D>: RMV is not a Kokkos::View.");
@@ -201,9 +229,6 @@ struct Scal<execution_space, RMV, AV, XMV, 2, false,
     static_assert(RMV::rank == 2,
                   "KokkosBlas::Impl::Scal<2-D>: "
                   "RMV is not rank 2.");
-    static_assert(AV::rank == 1,
-                  "KokkosBlas::Impl::Scal<2-D>: "
-                  "AV is not rank 1.");
     static_assert(XMV::rank == 2,
                   "KokkosBlas::Impl::Scal<2-D>: "
                   "XMV is not rank 2.");
@@ -312,17 +337,29 @@ struct Scal<execution_space, RMV, typename XMV::non_const_value_type, XMV, 2,
 
 //
 // Macro for declaration of full specialization of
-// KokkosBlas::Impl::Scal for rank == 2.  This is NOT for users!!!  All
+// KokkosBlas::Impl::Scal for rank == 1.  This is NOT for users!!!  All
 // the declarations of full specializations go in this header file.
 // We may spread out definitions (see _DEF macro below) across one or
 // more .cpp files.
 //
+// alpha can be either scalar or rank 0
 #define KOKKOSBLAS1_SCAL_ETI_SPEC_DECL(SCALAR, LAYOUT, EXEC_SPACE, MEM_SPACE) \
   extern template struct Scal<                                                \
       EXEC_SPACE,                                                             \
       Kokkos::View<SCALAR*, LAYOUT, Kokkos::Device<EXEC_SPACE, MEM_SPACE>,    \
                    Kokkos::MemoryTraits<Kokkos::Unmanaged> >,                 \
       SCALAR,                                                                 \
+      Kokkos::View<const SCALAR*, LAYOUT,                                     \
+                   Kokkos::Device<EXEC_SPACE, MEM_SPACE>,                     \
+                   Kokkos::MemoryTraits<Kokkos::Unmanaged> >,                 \
+      1, false, true>; \
+  extern template struct Scal<                                                \
+      EXEC_SPACE,                                                             \
+      Kokkos::View<SCALAR*, LAYOUT, Kokkos::Device<EXEC_SPACE, MEM_SPACE>,    \
+                   Kokkos::MemoryTraits<Kokkos::Unmanaged> >,                 \
+      Kokkos::View<const SCALAR, LAYOUT,                                     \
+                   Kokkos::Device<EXEC_SPACE, MEM_SPACE>,                     \
+                   Kokkos::MemoryTraits<Kokkos::Unmanaged> >,                 \
       Kokkos::View<const SCALAR*, LAYOUT,                                     \
                    Kokkos::Device<EXEC_SPACE, MEM_SPACE>,                     \
                    Kokkos::MemoryTraits<Kokkos::Unmanaged> >,                 \
@@ -334,6 +371,17 @@ struct Scal<execution_space, RMV, typename XMV::non_const_value_type, XMV, 2,
       Kokkos::View<SCALAR*, LAYOUT, Kokkos::Device<EXEC_SPACE, MEM_SPACE>,    \
                    Kokkos::MemoryTraits<Kokkos::Unmanaged> >,                 \
       SCALAR,                                                                 \
+      Kokkos::View<const SCALAR*, LAYOUT,                                     \
+                   Kokkos::Device<EXEC_SPACE, MEM_SPACE>,                     \
+                   Kokkos::MemoryTraits<Kokkos::Unmanaged> >,                 \
+      1, false, true>; \
+  template struct Scal<                                                       \
+      EXEC_SPACE,                                                             \
+      Kokkos::View<SCALAR*, LAYOUT, Kokkos::Device<EXEC_SPACE, MEM_SPACE>,    \
+                   Kokkos::MemoryTraits<Kokkos::Unmanaged> >,                 \
+      Kokkos::View<const SCALAR, LAYOUT,                                     \
+                   Kokkos::Device<EXEC_SPACE, MEM_SPACE>,                     \
+                   Kokkos::MemoryTraits<Kokkos::Unmanaged> >,                 \
       Kokkos::View<const SCALAR*, LAYOUT,                                     \
                    Kokkos::Device<EXEC_SPACE, MEM_SPACE>,                     \
                    Kokkos::MemoryTraits<Kokkos::Unmanaged> >,                 \
diff --git a/blas/impl/KokkosBlas1_scal_unified_scalar_view_impl.hpp b/blas/impl/KokkosBlas1_scal_unified_scalar_view_impl.hpp
index 0e7959408c..24faba32d9 100644
--- a/blas/impl/KokkosBlas1_scal_unified_scalar_view_impl.hpp
+++ b/blas/impl/KokkosBlas1_scal_unified_scalar_view_impl.hpp
@@ -19,31 +19,38 @@
 #include <KokkosKernels_config.h>
 #include <Kokkos_Core.hpp>
 
+#include <KokkosKernels_ViewUtils.hpp>
+
 /*! \brief
 
-Canonicalizes a variety of different "scalar" values of AVa
-into one of four alpha_types depending on whether AV comes
-from host-accesible memory or not
-
-Implements the following table:
-
-"host" meaning Kokkos::Impl::MemorySpaceAccess<HostSpace>::accessible from AV
-
-Row | RMV    | AV               | XMV    | alpha_type
- 1  | Rank-1 | S                | Rank-1 | const S
- 2  | Rank-2 | S                | Rank-2 | const S
- 3  | Rank-1 | View<S, host>    | Rank-1 | const S
- 4  | Rank-2 | View<S, host>    | Rank-2 | const S
- 5  | Rank-1 | View<S, dev>     | Rank-1 | View<const S, dev>
- 6  | Rank-2 | View<S, dev>     | Rank-2 | View<const S, dev>
- 7  | Rank-1 | View<S[1], host> | Rank-1 | const S
- 8  | Rank-2 | View<S[1], host> | Rank-2 | const S
- 9  | Rank-1 | View<S*, host>   | Rank-1 | const S
-10  | Rank-2 | View<S*, host>   | Rank-2 | View<const S*, host>
-11  | Rank-1 | View<S[1], dev>  | Rank-1 | View<const S, dev>
-12  | Rank-1 | View<S*, dev>    | Rank-1 | View<const S, dev>
-13  | Rank-2 | View<S[1], dev>  | Rank-2 | View<const S, dev>
-14  | Rank-2 | View<S*, dev>    | Rank-2 | View<const S*, dev>
+Canonicalizes a variety of different "scalar" values of AV to the most
+restrictive version still consistent with the interface.
+
+This may reduce the number of instantiations.
+
+Transformations made:
+* rank-1 AV, RMV, and XMV means AV is actually a scalar. On the host, we can go
+further and convert to a true scalar since we can access the value. On device,
+take a subview to convert to rank-0 scalar.
+* S[1] -> S
+* apply const to view data types
+* TODO: simplify this by just applying these in turn when possible
+
+Row | RMV / XMV | AV               | alpha_type
+ 1  | Rank-1    | S                | S
+ 2  | Rank-2    | S                | S
+ 3  | Rank-1    | View<S, host>    | S
+ 4  | Rank-2    | View<S, host>    | S
+ 5  | Rank-1    | View<S, dev>     | View<const S, dev, unmanaged>
+ 6  | Rank-2    | View<S, dev>     | View<const S, dev, unmanaged>
+ 7  | Rank-1    | View<S[1], host> | S
+ 8  | Rank-2    | View<S[1], host> | S
+ 9  | Rank-1    | View<S*, host>   | S
+10  | Rank-2    | View<S*, host>   | View<const S*, host, unmanaged>
+11  | Rank-1    | View<S[1], dev>  | View<const S, dev, unmanaged>
+12  | Rank-1    | View<S*, dev>    | View<const S, dev, unmanaged>
+13  | Rank-2    | View<S[1], dev>  | View<const S, dev, unmanaged>
+14  | Rank-2    | View<S*, dev>    | View<const S*, dev, unmanaged>
 
 See comments on the implementation below for each rows
 
@@ -57,33 +64,29 @@ namespace KokkosBlas::Impl {
 template <typename T, typename Enable = void>
 struct is_host : std::false_type {};
 template <typename T>
-struct is_host<
-    T,
-    std::enable_if_t<Kokkos::is_view_v<T> &&
-                     !Kokkos::Impl::MemorySpaceAccess<
-                         Kokkos::HostSpace, typename T::memory_space>::accessible>>
+struct is_host<T, std::enable_if_t<Kokkos::is_view_v<T> &&
+                                   Kokkos::Impl::MemorySpaceAccess<
+                                       Kokkos::HostSpace,
+                                       typename T::memory_space>::accessible>>
     : std::true_type {};
 template <typename T>
 constexpr inline bool is_host_v = is_host<T>::value;
-template <typename T>
-constexpr inline bool is_dev_v = !is_host_v<T>;
-
 
 template <typename T, typename Enable = void>
-struct is_rank_0 : std::false_type {};
+struct is_dev : std::false_type {};
 template <typename T>
-struct is_rank_0<T,
-                 std::enable_if_t<Kokkos::is_view_v<T> && T::rank == 0>>
+struct is_dev<T, std::enable_if_t<Kokkos::is_view_v<T> &&
+                                  !Kokkos::Impl::MemorySpaceAccess<
+                                       Kokkos::HostSpace,
+                                       typename T::memory_space>::accessible>>
     : std::true_type {};
 template <typename T>
-constexpr inline bool is_rank_0_v = is_rank_0<T>::value;
-
+constexpr inline bool is_dev_v = is_dev<T>::value;
 
 template <typename T, typename Enable = void>
 struct is_rank_0_host : std::false_type {};
 template <typename T>
-struct is_rank_0_host<T,
-                      std::enable_if_t<is_host_v<T> && T::rank == 0>>
+struct is_rank_0_host<T, std::enable_if_t<is_host_v<T> && T::rank == 0>>
     : std::true_type {};
 template <typename T>
 constexpr inline bool is_rank_0_host_v = is_rank_0_host<T>::value;
@@ -91,8 +94,7 @@ constexpr inline bool is_rank_0_host_v = is_rank_0_host<T>::value;
 template <typename T, typename Enable = void>
 struct is_rank_1_host : std::false_type {};
 template <typename T>
-struct is_rank_1_host<T,
-                      std::enable_if_t<is_host_v<T> && T::rank == 1>>
+struct is_rank_1_host<T, std::enable_if_t<is_host_v<T> && T::rank == 1>>
     : std::true_type {};
 template <typename T>
 constexpr inline bool is_rank_1_host_v = is_rank_1_host<T>::value;
@@ -100,19 +102,25 @@ constexpr inline bool is_rank_1_host_v = is_rank_1_host<T>::value;
 template <typename T, typename Enable = void>
 struct is_rank_1_host_static : std::false_type {};
 template <typename T>
-struct is_rank_1_host_static<T,
-                             std::enable_if_t<is_rank_1_host_v<T> &&
-                                              T::static_extent(0) == 1>>
+struct is_rank_1_host_static<
+    T, std::enable_if_t<is_rank_1_host_v<T> && T::static_extent(0) == 1>>
+    : std::true_type {};
+template <typename T>
+constexpr inline bool is_rank_1_host_static_v = is_rank_1_host_static<T>::value;
+
+template <typename T, typename Enable = void>
+struct is_rank_1_host_dynamic : std::false_type {};
+template <typename T>
+struct is_rank_1_host_dynamic<
+    T, std::enable_if_t<is_rank_1_host_v<T> && T::rank_dynamic == 1>>
     : std::true_type {};
 template <typename T>
-constexpr inline bool is_rank_1_host_static_v =
-    is_rank_1_host_static<T>::value;
+constexpr inline bool is_rank_1_host_dynamic_v = is_rank_1_host_dynamic<T>::value;
 
 template <typename T, typename Enable = void>
 struct is_rank_0_dev : std::false_type {};
 template <typename T>
-struct is_rank_0_dev<T,
-                     std::enable_if_t<is_dev_v<T> && T::rank == 0>>
+struct is_rank_0_dev<T, std::enable_if_t<is_dev_v<T> && T::rank == 0>>
     : std::true_type {};
 template <typename T>
 constexpr inline bool is_rank_0_dev_v = is_rank_0_dev<T>::value;
@@ -120,8 +128,7 @@ constexpr inline bool is_rank_0_dev_v = is_rank_0_dev<T>::value;
 template <typename T, typename Enable = void>
 struct is_rank_1_dev : std::false_type {};
 template <typename T>
-struct is_rank_1_dev<T,
-                     std::enable_if_t<is_dev_v<T> && T::rank == 1>>
+struct is_rank_1_dev<T, std::enable_if_t<is_dev_v<T> && T::rank == 1>>
     : std::true_type {};
 template <typename T>
 constexpr inline bool is_rank_1_dev_v = is_rank_1_dev<T>::value;
@@ -130,54 +137,57 @@ template <typename T, typename Enable = void>
 struct is_rank_1_dev_static : std::false_type {};
 template <typename T>
 struct is_rank_1_dev_static<
-    T,
-    std::enable_if_t<is_rank_1_dev_v<T> && T::static_extent(0) == 1>>
+    T, std::enable_if_t<is_rank_1_dev_v<T> && T::static_extent(0) == 1>>
+    : std::true_type {};
+template <typename T>
+constexpr inline bool is_rank_1_dev_static_v = is_rank_1_dev_static<T>::value;
+
+template <typename T, typename Enable = void>
+struct is_rank_1_dev_dynamic : std::false_type {};
+template <typename T>
+struct is_rank_1_dev_dynamic<
+    T, std::enable_if_t<is_rank_1_dev_v<T> && T::rank_dynamic == 1>>
     : std::true_type {};
 template <typename T>
-constexpr inline bool is_rank_1_dev_static_v =
-    is_rank_1_dev_static<T>::value;
+constexpr inline bool is_rank_1_dev_dynamic_v = is_rank_1_dev_dynamic<T>::value;
 
-template <typename RMV, typename AV, typename XMV,
-          typename Enable = void>
+template <typename RMV, typename AV, typename XMV, typename Enable = void>
 struct scal_unified_scalar_view;
 
-// Rows 1,2: scalar -> const S
+// Rows 1,2: S -> S
 template <typename RMV, typename AV, typename XMV>
 struct scal_unified_scalar_view<RMV, AV, XMV,
                                 std::enable_if_t<!Kokkos::is_view_v<AV>>> {
-  using alpha_type = const AV;
+  using alpha_type = AV;
 
-  static alpha_type from(const AV &av) { 
-    return av; }
+  static alpha_type from(const AV &av) { return av; }
 };
 
 // Rows 3,4: AV is a rank 0 host view
 template <typename RMV, typename AV, typename XMV>
-struct scal_unified_scalar_view<
-    RMV, AV, XMV,
-    std::enable_if_t<is_rank_0_host_v<AV>>> {
-  using alpha_type = const typename AV::data_type;
+struct scal_unified_scalar_view<RMV, AV, XMV,
+                                std::enable_if_t<is_rank_0_host_v<AV>>> {
+  using alpha_type = typename AV::non_const_data_type;
 
   static alpha_type from(const AV &av) { return av(); }
 };
 
 // Rows 5,6: AV is a rank 0 device view
 template <typename RMV, typename AV, typename XMV>
-struct scal_unified_scalar_view<
-    RMV, AV, XMV, std::enable_if_t<is_rank_0_dev_v<AV>>> {
-  using alpha_type = Kokkos::View<const typename AV::data_type, 
-  typename AV::memory_space, Kokkos::MemoryUnmanaged>;
+struct scal_unified_scalar_view<RMV, AV, XMV,
+                                std::enable_if_t<is_rank_0_dev_v<AV>>> {
+  using alpha_type =
+      Kokkos::View<const typename AV::data_type, typename AV::memory_space,
+                   Kokkos::MemoryUnmanaged>;
 
   static alpha_type from(const AV &av) { return alpha_type(av); }
 };
 
 // Rows 7,8: AV is a rank 1 host view with known extent
 template <typename RMV, typename AV, typename XMV>
-struct scal_unified_scalar_view<
-    RMV, AV, XMV,
-    std::enable_if_t<is_rank_1_host_static_v<AV>>> {
-
-  using alpha_type = const typename AV::value_type;
+struct scal_unified_scalar_view<RMV, AV, XMV,
+                                std::enable_if_t<is_rank_1_host_static_v<AV>>> {
+  using alpha_type = typename AV::non_const_value_type;
 
   static alpha_type from(const AV &av) { return av(0); }
 };
@@ -187,14 +197,13 @@ struct scal_unified_scalar_view<
 template <typename RMV, typename AV, typename XMV>
 struct scal_unified_scalar_view<
     RMV, AV, XMV,
-    std::enable_if_t<is_rank_1_host_v<AV> && XMV::rank == 1 &&
-                     RMV::rank == 1>> {
-
-  using alpha_type = const typename AV::value_type;
+    std::enable_if_t<is_rank_1_host_dynamic_v<AV> && RMV::rank == 1 && XMV::rank == 1>> {
+  using alpha_type = typename AV::non_const_value_type;
 
   static alpha_type from(const AV &av) { return av(0); }
 };
 
+
 // Row 10: AV is a rank 1 host view of unknown size, and we assume
 // each element is to scale a vector in RMV and XMV
 template <typename RMV, typename AV, typename XMV>
@@ -202,9 +211,9 @@ struct scal_unified_scalar_view<
     RMV, AV, XMV,
     std::enable_if_t<is_rank_1_host_v<AV> && XMV::rank == 2 &&
                      RMV::rank == 2>> {
-
-  using alpha_type = Kokkos::View<const typename AV::data_type,
-  typename AV::array_layout, typename AV::memory_space, Kokkos::MemoryUnmanaged>;
+  using alpha_type =
+      Kokkos::View<typename AV::data_type, typename AV::array_layout,
+                   typename AV::memory_space, Kokkos::MemoryUnmanaged>;
 
   static alpha_type from(const AV &av) { return av; }
 };
@@ -212,11 +221,8 @@ struct scal_unified_scalar_view<
 // Row 11, 12: AV is a rank 1 dev view, but we assume its
 // a single scalar since XMV and YMV are rank 1
 template <typename RMV, typename AV, typename XMV>
-struct scal_unified_scalar_view<
-    RMV, AV, XMV,
-    std::enable_if_t<is_rank_1_dev_v<AV> && XMV::rank == 1 &&
-                     RMV::rank == 1>> {
-  
+struct scal_unified_scalar_view<RMV, AV, XMV,
+                                std::enable_if_t<is_rank_1_dev_dynamic_v<AV>>> {
   using alpha_type =
       Kokkos::View<const typename AV::value_type, typename AV::memory_space,
                    Kokkos::MemoryUnmanaged>;
@@ -227,10 +233,8 @@ struct scal_unified_scalar_view<
 // Row 13: AV is a rank 1 dev view of static size,
 // so its a single scalar
 template <typename RMV, typename AV, typename XMV>
-struct scal_unified_scalar_view<
-    RMV, AV, XMV,
-    std::enable_if_t<is_rank_1_dev_static_v<AV>>> {
-
+struct scal_unified_scalar_view<RMV, AV, XMV,
+                                std::enable_if_t<is_rank_1_dev_static_v<AV>>> {
   using alpha_type =
       Kokkos::View<const typename AV::value_type, typename AV::memory_space,
                    Kokkos::MemoryUnmanaged>;
@@ -244,37 +248,57 @@ struct scal_unified_scalar_view<
 template <typename RMV, typename AV, typename XMV>
 struct scal_unified_scalar_view<
     RMV, AV, XMV,
-    std::enable_if_t<is_rank_1_dev_v<AV> && XMV::rank == 2 &&
-                     RMV::rank == 2>> {
-
-  using alpha_type = Kokkos::View<const typename AV::data_type,
-  typename AV::array_layout, typename AV::memory_space, Kokkos::MemoryUnmanaged>;
+    std::enable_if_t<is_rank_1_dev_v<AV> && XMV::rank == 2 && RMV::rank == 2>> {
+  using alpha_type =
+      Kokkos::View<typename AV::data_type, typename AV::array_layout,
+                   typename AV::memory_space, Kokkos::MemoryUnmanaged>;
 
   static alpha_type from(const AV &av) { return av; }
 };
 
 
-/*!
+/*! \brief return av
+
 Get a POD, Kokkos::complex, or 0D view as a scalar
 */
-template <typename AV,
-        std::enable_if_t<!Kokkos::is_view_v<AV>, bool> = true>
-KOKKOS_INLINE_FUNCTION
-auto as_scalar(const AV &av) {
-    return av;
+template <typename AV, std::enable_if_t<!Kokkos::is_view_v<AV>, bool> = true>
+KOKKOS_INLINE_FUNCTION auto as_scalar(const AV &av) {
+  return av;
 }
 
-/*!
+/*! \brief return av()
+
 Get a POD, Kokkos::complex, or 0D view as a scalar
 */
 template <typename AV,
-        std::enable_if_t<is_rank_0_v<AV>, bool> = true>
-KOKKOS_INLINE_FUNCTION
-auto as_scalar(const AV &av) {
-    return av();
+          std::enable_if_t<KokkosKernels::Impl::is_rank_0_v<AV>, bool> = true>
+KOKKOS_INLINE_FUNCTION auto as_scalar(const AV &av) {
+  return av();
 }
 
+/*! \brief return av
+ */
+template <typename AV, typename IndexType,
+          std::enable_if_t<!Kokkos::is_view_v<AV>, bool> = true>
+KOKKOS_INLINE_FUNCTION auto as_scalar(const AV &av, const IndexType & /*i*/) {
+  return av;
+}
 
+/*! \brief return av()
+ */
+template <typename AV, typename IndexType,
+          std::enable_if_t<KokkosKernels::Impl::is_rank_0_v<AV>, bool> = true>
+KOKKOS_INLINE_FUNCTION auto as_scalar(const AV &av, const IndexType &i) {
+  return av();
+}
+
+/*! \brief return av(i)
+ */
+template <typename AV, typename IndexType,
+          std::enable_if_t<KokkosKernels::Impl::is_rank_1_v<AV>, bool> = true>
+KOKKOS_INLINE_FUNCTION auto as_scalar(const AV &av, const IndexType &i) {
+  return av(i);
+}
 
 }  // namespace KokkosBlas::Impl
 
diff --git a/blas/unit_test/Test_Blas1_scal.hpp b/blas/unit_test/Test_Blas1_scal.hpp
index 6c4f7b7f2a..1eb4df004e 100644
--- a/blas/unit_test/Test_Blas1_scal.hpp
+++ b/blas/unit_test/Test_Blas1_scal.hpp
@@ -21,6 +21,84 @@
 #include <KokkosKernels_TestUtils.hpp>
 
 namespace Test {
+
+/*! \brief Test scal will AV being a view or a scalar
+
+*/
+template <typename XView, typename YView, typename Device, typename AV>
+void impl_test_scal_a_is_3(int N, const AV &a) {
+
+  typedef typename XView::value_type ScalarX;
+  typedef typename YView::value_type ScalarY;
+  typedef Kokkos::ArithTraits<ScalarX> AT;
+
+  typename AT::mag_type eps = AT::epsilon() * 1000;
+
+  view_stride_adapter<XView> x("X", N);
+  view_stride_adapter<YView> y("Y", N);
+
+  Kokkos::Random_XorShift64_Pool<typename Device::execution_space> rand_pool(
+      13718);
+
+  {
+    ScalarX randStart, randEnd;
+    Test::getRandomBounds(1.0, randStart, randEnd);
+    Kokkos::fill_random(x.d_view, rand_pool, randStart, randEnd);
+  }
+
+  Kokkos::deep_copy(x.h_base, x.d_base);
+
+  KokkosBlas::scal(y.d_view, a, x.d_view);
+  Kokkos::deep_copy(y.h_base, y.d_base);
+  for (int i = 0; i < N; i++) {
+    // scaling factor is 3
+    EXPECT_NEAR_KK(static_cast<ScalarY>(3 * x.h_view(i)), y.h_view(i), eps);
+  }
+
+  // Zero out y again and run with const input
+  Kokkos::deep_copy(y.d_view, Kokkos::ArithTraits<ScalarY>::zero());
+  KokkosBlas::scal(y.d_view, a, x.d_view_const);
+  Kokkos::deep_copy(y.h_base, y.d_base);
+  for (int i = 0; i < N; i++) {
+    // scaling factor is three
+    EXPECT_NEAR_KK(static_cast<ScalarY>(3 * x.h_view(i)), y.h_view(i), eps);
+  }
+
+}
+
+/*! \brief test scal with alpha is a rank-1 scalar
+
+    \tparam VIEW is alpha a view?
+    \tparam RANK if VIEW what rank is alpha?
+    \tparam STATIC if VIEW and RANK=1, is the extent static?
+*/
+template <typename ScalarX, typename ScalarY, typename ScalarA,  typename Layout, typename Device, bool VIEW, int RANK, bool STATIC>
+void impl_test_scal_alphas(int N) {
+
+  using XView = Kokkos::View<ScalarX*, Layout, Device>;
+  using YView = Kokkos::View<ScalarY*, Layout, Device>;
+
+  if constexpr(VIEW) {
+    if constexpr (1 == RANK && STATIC) {
+      Kokkos::View<ScalarA[1], Layout, Device> a("View<A[1]>");
+      Kokkos::deep_copy(a, 3);
+      impl_test_scal_a_is_3<XView, YView, Device>(N, a);
+    } else if constexpr(1 == RANK) {
+      Kokkos::View<ScalarA*, Layout, Device> a("View<A*>", 1);
+      Kokkos::deep_copy(a, 3);
+      impl_test_scal_a_is_3<XView, YView, Device>(N, a);
+    } else if constexpr(0 == RANK) {
+      Kokkos::View<ScalarA, Layout, Device> a("View<A>");
+      Kokkos::deep_copy(a, 3);
+      impl_test_scal_a_is_3<XView, YView, Device>(N, a);
+    }
+  } else {
+    ScalarA a{3};
+    impl_test_scal_a_is_3<XView, YView, Device>(N, a);
+  }
+
+}
+
 template <class ViewTypeA, class ViewTypeB, class Device>
 void impl_test_scal(int N) {
   typedef typename ViewTypeA::value_type ScalarA;
@@ -145,10 +223,26 @@ int test_scal() {
      !defined(KOKKOSKERNELS_IMPL_CHECK_ETI_CALLS))
   typedef Kokkos::View<ScalarA*, Kokkos::LayoutLeft, Device> view_type_a_ll;
   typedef Kokkos::View<ScalarB*, Kokkos::LayoutLeft, Device> view_type_b_ll;
+#if 0
   Test::impl_test_scal<view_type_a_ll, view_type_b_ll, Device>(0);
   Test::impl_test_scal<view_type_a_ll, view_type_b_ll, Device>(13);
   Test::impl_test_scal<view_type_a_ll, view_type_b_ll, Device>(1024);
-  // Test::impl_test_scal<view_type_a_ll, view_type_b_ll, Device>(132231);
+#else
+  Test::impl_test_scal_alphas<ScalarA, ScalarB, ScalarA, Kokkos::LayoutLeft, Device, false, 0, false>(0);
+  Test::impl_test_scal_alphas<ScalarA, ScalarB, ScalarA, Kokkos::LayoutLeft, Device, true, 0, false>(0);
+  Test::impl_test_scal_alphas<ScalarA, ScalarB, ScalarA, Kokkos::LayoutLeft, Device, true, 1, false>(0);
+  Test::impl_test_scal_alphas<ScalarA, ScalarB, ScalarA, Kokkos::LayoutLeft, Device, true, 1, true>(0);
+
+  Test::impl_test_scal_alphas<ScalarA, ScalarB, ScalarA, Kokkos::LayoutLeft, Device, false, 0, false>(13);
+  Test::impl_test_scal_alphas<ScalarA, ScalarB, ScalarA, Kokkos::LayoutLeft, Device, true, 0, false>(13);
+  Test::impl_test_scal_alphas<ScalarA, ScalarB, ScalarA, Kokkos::LayoutLeft, Device, true, 1, false>(13);
+  Test::impl_test_scal_alphas<ScalarA, ScalarB, ScalarA, Kokkos::LayoutLeft, Device, true, 1, true>(13);
+
+  Test::impl_test_scal_alphas<ScalarA, ScalarB, ScalarA, Kokkos::LayoutLeft, Device, false, 0, false>(1024);
+  Test::impl_test_scal_alphas<ScalarA, ScalarB, ScalarA, Kokkos::LayoutLeft, Device, true, 0, false>(1024);
+  Test::impl_test_scal_alphas<ScalarA, ScalarB, ScalarA, Kokkos::LayoutLeft, Device, true, 1, false>(1024);
+  Test::impl_test_scal_alphas<ScalarA, ScalarB, ScalarA, Kokkos::LayoutLeft, Device, true, 1, true>(1024);
+#endif
 #endif
 
 #if defined(KOKKOSKERNELS_INST_LAYOUTRIGHT) || \
@@ -159,7 +253,6 @@ int test_scal() {
   Test::impl_test_scal<view_type_a_lr, view_type_b_lr, Device>(0);
   Test::impl_test_scal<view_type_a_lr, view_type_b_lr, Device>(13);
   Test::impl_test_scal<view_type_a_lr, view_type_b_lr, Device>(1024);
-  // Test::impl_test_scal<view_type_a_lr, view_type_b_lr, Device>(132231);
 #endif
 
 #if (!defined(KOKKOSKERNELS_ETI_ONLY) && \
@@ -169,7 +262,6 @@ int test_scal() {
   Test::impl_test_scal<view_type_a_ls, view_type_b_ls, Device>(0);
   Test::impl_test_scal<view_type_a_ls, view_type_b_ls, Device>(13);
   Test::impl_test_scal<view_type_a_ls, view_type_b_ls, Device>(1024);
-  // Test::impl_test_scal<view_type_a_ls, view_type_b_ls, Device>(132231);
 #endif
 
 #if !defined(KOKKOSKERNELS_ETI_ONLY) && \
diff --git a/common/src/KokkosKernels_UnifiedScalarView.hpp b/common/src/KokkosKernels_UnifiedScalarView.hpp
index 9e50bd0851..bb27a83abd 100644
--- a/common/src/KokkosKernels_UnifiedScalarView.hpp
+++ b/common/src/KokkosKernels_UnifiedScalarView.hpp
@@ -17,6 +17,8 @@
 #ifndef KOKKOSKERNELS_UNIFIEDSCALARVIEW_HPP
 #define KOKKOSKERNELS_UNIFIEDSCALARVIEW_HPP
 
+#if 0
+
 #include <type_traits>
 
 #include <Kokkos_Core.hpp>
@@ -102,4 +104,6 @@ constexpr unified_scalar_t<Value> get_scalar(const Value &v) {
 } // namespace Impl
 } // namespace KokkosKernels
 
+#endif
+
 #endif // KOKKOSKERNELS_UNIFIEDSCALARVIEW_HPP
\ No newline at end of file
diff --git a/common/src/KokkosKernels_ViewUtils.hpp b/common/src/KokkosKernels_ViewUtils.hpp
new file mode 100644
index 0000000000..bae4b6fc1d
--- /dev/null
+++ b/common/src/KokkosKernels_ViewUtils.hpp
@@ -0,0 +1,47 @@
+//@HEADER
+// ************************************************************************
+//
+//                        Kokkos v. 4.0
+//       Copyright (2022) National Technology & Engineering
+//               Solutions of Sandia, LLC (NTESS).
+//
+// Under the terms of Contract DE-NA0003525 with NTESS,
+// the U.S. Government retains certain rights in this software.
+//
+// Part of Kokkos, under the Apache License v2.0 with LLVM Exceptions.
+// See https://kokkos.org/LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//@HEADER
+#include <type_traits>
+
+#include "Kokkos_Core.hpp"
+
+#ifndef KOKKOSKERNELS_VIEWUTILS_HPP
+#define KOKKOSKERNELS_VIEWUTILS_HPP
+
+namespace KokkosKernels::Impl {
+
+template <typename T, typename Enable = void>
+struct is_rank_0 : std::false_type {};
+template <typename T>
+struct is_rank_0<T,
+                 std::enable_if_t<Kokkos::is_view_v<T> && T::rank == 0>>
+    : std::true_type {};
+template <typename T>
+constexpr inline bool is_rank_0_v = is_rank_0<T>::value;
+
+template <typename T, typename Enable = void>
+struct is_rank_1 : std::false_type {};
+template <typename T>
+struct is_rank_1<T,
+                 std::enable_if_t<Kokkos::is_view_v<T> && T::rank == 1>>
+    : std::true_type {};
+template <typename T>
+constexpr inline bool is_rank_1_v = is_rank_1<T>::value;
+
+
+} // namespace KokkosKernels::Impl
+
+#endif // KOKKOSKERNELS_VIEWUTILS_HPP
+
diff --git a/common/src/KokkosKernels_helpers.hpp b/common/src/KokkosKernels_helpers.hpp
index b36360b991..2e8c29ce20 100644
--- a/common/src/KokkosKernels_helpers.hpp
+++ b/common/src/KokkosKernels_helpers.hpp
@@ -43,15 +43,19 @@ struct GetUnifiedLayout {
                                           default_layout>::array_layout;
 };
 
+/* If T is not a view, type is TX::non_const_value_type
+*/
 template <class T, class TX, bool do_const,
           bool isView = Kokkos::is_view<T>::value>
 struct GetUnifiedScalarViewType {
   typedef typename TX::non_const_value_type type;
 };
 
+/* If T is a view, type is T with unified layout & unmanaged
+*/
 template <class T, class TX>
 struct GetUnifiedScalarViewType<T, TX, false, true> {
-  typedef Kokkos::View<typename T::non_const_value_type*,
+  typedef Kokkos::View<typename T::non_const_data_type,
                        typename KokkosKernels::Impl::GetUnifiedLayoutPreferring<
                            T, typename TX::array_layout>::array_layout,
                        typename T::device_type,
@@ -61,7 +65,7 @@ struct GetUnifiedScalarViewType<T, TX, false, true> {
 
 template <class T, class TX>
 struct GetUnifiedScalarViewType<T, TX, true, true> {
-  typedef Kokkos::View<typename T::const_value_type*,
+  typedef Kokkos::View<typename T::const_data_type,
                        typename KokkosKernels::Impl::GetUnifiedLayoutPreferring<
                            T, typename TX::array_layout>::array_layout,
                        typename T::device_type,
@@ -69,6 +73,7 @@ struct GetUnifiedScalarViewType<T, TX, true, true> {
       type;
 };
 
+
 template <class... Ts>
 struct are_integral : std::bool_constant<((std::is_integral_v<Ts> ||
                                            std::is_enum_v<Ts>)&&...)> {};
diff --git a/common/unit_test/Test_Common.hpp b/common/unit_test/Test_Common.hpp
index b734522c47..38d4d9c2c8 100644
--- a/common/unit_test/Test_Common.hpp
+++ b/common/unit_test/Test_Common.hpp
@@ -26,7 +26,7 @@
 #include <Test_Common_PrintConfiguration.hpp>
 #include <Test_Common_Iota.hpp>
 #include <Test_Common_LowerBound.hpp>
-#include <Test_Common_UnifiedScalarView.hpp>
+// #include <Test_Common_UnifiedScalarView.hpp>
 #include <Test_Common_UpperBound.hpp>
 
 #endif  // TEST_COMMON_HPP