diff --git a/docs/sphinx/user_guide/feature/reduction.rst b/docs/sphinx/user_guide/feature/reduction.rst
index 6d4c8695d9..6b24ad98b0 100644
--- a/docs/sphinx/user_guide/feature/reduction.rst
+++ b/docs/sphinx/user_guide/feature/reduction.rst
@@ -190,6 +190,9 @@ RAJA::expt::Reduce
 ..................
 ::
 
+  using VALOP_DOUBLE_SUM = RAJA::expt::ValOp<double, RAJA::operators::plus>;
+  using VALOP_DOUBLE_MIN = RAJA::expt::ValOp<double, RAJA::operators::minimum>;
+
   double* a = ...;
 
   double rs = 0.0;
@@ -198,9 +201,9 @@ RAJA::expt::Reduce
   RAJA::forall<EXEC_POL> ( Res, Seg,
   RAJA::expt::Reduce<RAJA::operators::plus>(&rs),
   RAJA::expt::Reduce<RAJA::operators::minimum>(&rm),
-  [=] (int i, double& _rs, double& _rm) {
+  [=] (int i, VALOP_DOUBLE_SUM& _rs, VALOP_DOUBLE_MIN& _rm) {
     _rs += a[i];
-    _rm = RAJA_MIN(a[i], _rm);
+    _rm.min(a[i]);
   }
   );
 
@@ -213,13 +216,14 @@ RAJA::expt::Reduce
   above. The reduction operation will include the existing value of
   the given target variable.
 * The kernel body lambda expression passed to ``RAJA::forall`` must have a
-  parameter corresponding to each ``RAJA::expt::Reduce`` argument, ``_rs`` and
-  ``_rm`` in the example code. These parameters refer to a local target for each
-  reduction operation. It is important to note that the parameters follow the
-  kernel iteration variable, ``i`` in this case, and appear in the same order
-  as the corresponding ``RAJA::expt::Reduce`` arguments to ``RAJA::forall``. The
-  parameter types must be references to the types used in the
-  ``RAJA::expt::Reduce`` arguments.
+  ``RAJA::expt::ValOp`` parameter corresponding to each ``RAJA::expt::Reduce``
+  argument, ``_rs`` and ``_rm`` in the example code. These parameters refer to a
+  local target for each reduction operation. Each ``ValOp`` needs to be templated
+  on the underlying data type (``double`` for ``_rs`` and ``_rm``), and the operator
+  being used. It is important to note that the parameters follow the kernel iteration
+  variable, ``i`` in this case, and appear in the same order as the corresponding
+  ``RAJA::expt::Reduce`` arguments to ``RAJA::forall``. The ``ValOp`` parameters must
+  be references to the objects instantiated by the ``RAJA::expt::Reduce`` arguments.
 * The local variables referred to by ``_rs`` and ``_rm`` are initialized with
   the *identity* of the reduction operation to be performed.
 * The local variables are updated in the user supplied lambda.
@@ -236,10 +240,19 @@ RAJA::expt::Reduce
           compatible with the ``EXEC_POL``. ``Seg`` is the iteration space
           object for ``RAJA::forall``.
 
-.. important:: The order and types of the local reduction variables in the
-               kernel body lambda expression must match exactly with the
-               corresponding ``RAJA::expt::Reduce`` arguments to the
-               ``RAJA::forall`` to ensure that the correct result is obtained.
+.. important:: * ``RAJA::expt::Reduce`` arguments must be passed to the forall.
+                 These arguments are templated on the reduction operator, and take
+                 a pointer to the target reduction variable that was declared outside
+                 of the forall.
+               * The local reduction arguments to the lambda expression must be
+                 ``RAJA::expt::ValOp`` references. Each ``ValOp`` reference
+                 corresponds to a ``RAJA::expt::Reduce`` argument within the forall.
+               * The ordering of the ``ValOp`` references must correspond to the
+                 ordering of the ``RAJA::expt::Reduce`` arguments to ensure that the
+                 correct result is obtained.
+               * Each ``ValOp`` reduction data type and RAJA operator need to match
+                 the data type referenced, and operator template argument in the
+                 corresponding ``RAJA::expt::Reduce`` argument.
 
 RAJA::expt::ValLoc
 ..................
@@ -247,36 +260,89 @@ RAJA::expt::ValLoc
 As with the current RAJA reduction interface, the new interface supports *loc*
 reductions, which provide the ability to get a kernel/loop index at which the
 final reduction value was found. With this new interface, *loc* reductions
-are performed using ``ValLoc<T>`` types. Since they are strongly typed, they
-provide ``min()`` and ``max()`` operations that are equivalent to using
-``RAJA_MIN()`` or ``RAJA_MAX`` macros as demonstrated in the code example below.
-Users must use the ``getVal()`` and ``getLoc()`` methods to access the reduction
-results::
+are performed using ``ValLoc<T,I>`` types, where ``T`` is the underlying data type,
+and ``I`` is the index type. Users must use the ``getVal()`` and ``getLoc()``
+methods to access the reduction results after the kernel completes.
+
+In the lambda expression, a ``ValLoc<T,I>`` must be wrapped in a
+``ValOp`` type, and passed to the lambda in the same order as the corresponding 
+``RAJA::expt::Reduce`` arguments, e.g. ``ValOp<ValLoc<T,I>, Op>``. In the example
+below, ``VALOPLOC_DOUBLE_MIN`` represents a wrapped ``ValLoc`` usable within the
+lambda.
+
+For convenience, an alias of ``RAJA::expt::ValLocOp<T,I,Op>`` is provided.
+Within the lambda, this ``ValLocOp`` object provides ``minloc``, and ``maxloc``
+functions. In the example below, ``VALOPLOC_DOUBLE_MAX`` represents a wrapped
+``ValLoc`` using the ``ValLocOp`` alias::
 
   double* a = ...;
 
+  using VALOPLOC_DOUBLE_MIN = RAJA::expt::ValOp<ValLoc<double, RAJA::Index_type>,
+                                                       RAJA::operators::minimum>;
+  using VALOPLOC_DOUBLE_MAX = RAJA::expt::ValLocOp<double, RAJA::Index_type,
+                                                   RAJA::operators::minimum>;
+
   using VL_DOUBLE = RAJA::expt::ValLoc<double>;
-  VL_DOUBLE rm_loc;
+  VL_DOUBLE rmin_loc;
+  VL_DOUBLE rmax_loc;
 
   RAJA::forall<EXEC_POL> ( Res, Seg,
-  RAJA::expt::Reduce<RAJA::operators::minimum>(&rm_loc),
-  [=] (int i, VL_DOUBLE& _rm_loc) {
-    _rm_loc = RAJA_MIN(VL_DOUBLE(a[i], i), _rm_loc);
-    //_rm_loc.min(VL_DOUBLE(a[i], i)); // Alternative to RAJA_MIN
+  RAJA::expt::Reduce<RAJA::operators::minimum>(&rmin_loc),
+  RAJA::expt::Reduce<RAJA::operators::maximum>(&rmax_loc),
+  [=] (int i, VALOPLOC_DOUBLE_MIN& _rmin_loc, VALOPLOC_DOUBLE_MAX& _rmax_loc) {
+    _rmin_loc.minloc(a[i], i);
+    _rmax_loc.minloc(a[i], i);
   }
   );
 
-  std::cout << rm_loc.getVal() ...
-  std::cout << rm_loc.getLoc() ...
+  std::cout << rmin_loc.getVal() ...
+  std::cout << rmin_loc.getLoc() ...
+  std::cout << rmax_loc.getVal() ...
+  std::cout << rmax_loc.getLoc() ...
+
+Alternatively, *loc* reductions can be performed on separate reduction data, and
+location variables without a ``ValLoc`` object, seen in the next example below.
+To use this capability, a ``RAJA::expt::ReduceLoc`` argument must be passed to the
+``RAJA::forall``, templated on the reduction operation, and passing in references to
+the data and location. This is illustrated in the example below, with references to
+``rm`` and ``loc`` being passed into the ``ReduceLoc`` argument in the forall. The
+data and location can be accessed outside of the forall directly without
+``getVal()`` or ``getLoc()`` functions.
+:: 
+
+  double* a = ...;
+
+  using VALOPLOC_DOUBLE_MIN = RAJA::expt::ValLocOp<double, RAJA::Index_type,
+                                                   RAJA::operators::minimum>;
+
+  // No ValLoc needed from the user here.
+  double rm;
+  RAJA::Index_type loc;
+
+  RAJA::forall<EXEC_POL> ( Res, Seg,
+  RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&rm, &loc), // --> 1 double & 1 index added
+  [=] (int i, VALOPLOC_DOUBLE_MIN& _rm_loc) {
+    _rm_loc.minloc(a[i], i);
+  }
+  );
+
+  // No getVal() or getLoc() required. Access results in their original form.
+  std::cout << rm ...
+  std::cout << loc ...
+
 
 Lambda Arguments
 ................
 
 This interface takes advantage of C++ parameter packs to allow users to pass
-any number of ``RAJA::expt::Reduce`` objects to the ``RAJA::forall`` method::
+any number of ``RAJA::expt::Reduce`` arguments to the ``RAJA::forall`` method::
 
   double* a = ...;
 
+  using VALOP_DOUBLE_SUM = RAJA::expt::ValOp<double, RAJA::operators::plus>;
+  using VALOP_DOUBLE_MIN = RAJA::expt::ValOp<double, RAJA::operators::minimum>;
+  using VALOPLOC_DOUBLE_MIN = RAJA::expt::ValLocOp<double, RAJA::Index_type, RAJA::operators::minimum>;
+
   using VL_DOUBLE = RAJA::expt::ValLoc<double>;
   VL_DOUBLE rm_loc;
   double rs;
@@ -287,10 +353,13 @@ any number of ``RAJA::expt::Reduce`` objects to the ``RAJA::forall`` method::
     RAJA::expt::Reduce<RAJA::operators::minimum>(&rm),     // --> 1 double added
     RAJA::expt::Reduce<RAJA::operators::minimum>(&rm_loc), // --> 1 VL_DOUBLE added
     RAJA::expt::KernelName("MyFirstRAJAKernel"),           // --> NO args added
-    [=] (int i, double& _rs, double& _rm, VL_DOUBLE& _rm_loc) {
+    [=] (int i,
+         VALOP_DOUBLE_SUM& _rs,
+         VALOP_DOUBLE_MIN& _rm,
+         VALOPLOC_DOUBLE_MIN& _rm_loc) {
       _rs += a[i];
-      _rm = RAJA_MIN(a[i], _rm);
-      _rm_loc.min(VL_DOUBLE(a[i], i));
+      _rm.min(a[i]);
+      _rm_loc.minloc(a[i], i);
     }
   );
 
@@ -300,11 +369,12 @@ any number of ``RAJA::expt::Reduce`` objects to the ``RAJA::forall`` method::
   std::cout << rm_loc.getLoc() ...
 
 Again, the lambda expression parameters are in the same order as
-the ``RAJA::expt::Reduce`` arguments to ``RAJA::forall``. Both the types and
-order of the parameters must match to get correct results and to compile
-successfully. Otherwise, a static assertion will be triggered::
+the ``RAJA::expt::Reduce`` arguments to ``RAJA::forall``. The ``ValOp`` underlying
+data types and operators, and order of the ``ValOp`` parameters must match 
+the corresponding ``RAJA::expt::Reduce`` types to get correct results and to
+compile successfully. Otherwise, a static assertion will be triggered::
 
-  LAMBDA Not invocable w/ EXPECTED_ARGS.
+  LAMBDA Not invocable w/ EXPECTED_ARGS. Ordering and types must match between RAJA::expt::Reduce() and ValOp arguments.
 
 .. note:: This static assert is only enabled when passing an undecorated C++
           lambda. Meaning, this check will not happen when passing
@@ -329,6 +399,9 @@ The usage of the experiemental reductions is similar to the forall example as il
 
   double* a = ...;
 
+  using VALOP_DOUBLE_SUM = RAJA::expt::ValOp<double, RAJA::operators::plus>;
+  using VALOP_DOUBLE_MIN = RAJA::expt::ValOp<double, RAJA::operators::minimum>;
+
   double rs = 0.0;
   double rm = 1e100;
 
@@ -336,12 +409,12 @@ The usage of the experiemental reductions is similar to the forall example as il
     RAJA::expt::Reduce<RAJA::operators::plus>(&rs),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&rm),
     "LaunchReductionKernel",
-    [=] RAJA_HOST_DEVICE (int i, double& _rs, double& _rm) {
+    [=] RAJA_HOST_DEVICE (int i, VALOP_DOUBLE_SUM& _rs, VALOP_DOUBLE_MIN& _rm) {
 
       RAJA::loop<loop_pol>(ctx, Seg, [&] (int i) {
 
         _rs += a[i];
-        _rm = RAJA_MIN(a[i], _rm);
+        _rm.min(a[i], _rm);
 
         }
       );
diff --git a/examples/forall-param-reductions.cpp b/examples/forall-param-reductions.cpp
index fb82582704..2305f74c2b 100644
--- a/examples/forall-param-reductions.cpp
+++ b/examples/forall-param-reductions.cpp
@@ -66,6 +66,11 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   }
 
+//
+// Set a[0] to a different value. Total sum should be 2.
+//
+  a[0] = 3;
+
 //
 // Set min and max loc values
 //
@@ -80,7 +85,7 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 // Note: with this data initialization scheme, the following results will
 //       be observed for all reduction kernels below:
 //
-//  - the sum will be zero
+//  - the sum will be two
 //  - the min will be -100
 //  - the max will be 100
 //  - the min loc will be N/2
@@ -99,7 +104,18 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 // Define ValLoc Type
 //
 
-  using VALLOC_INT = RAJA::expt::ValLoc<int>;
+  using VALLOC_INT = RAJA::expt::ValLoc<int, RAJA::Index_type>;
+
+//
+// Define ValOp Types
+//
+
+  using VALOP_INT_SUM = RAJA::expt::ValOp<int, RAJA::operators::plus>;
+  using VALOP_INT_MIN = RAJA::expt::ValOp<int, RAJA::operators::minimum>;
+  using VALOP_INT_MAX = RAJA::expt::ValOp<int, RAJA::operators::maximum>;
+  using VALOPLOC_INT_MIN = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::minimum>;
+  using VALOPLOC_INT_MAX = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::maximum>;
+
 //----------------------------------------------------------------------------//
 
   std::cout << "\n Running RAJA sequential reductions...\n";
@@ -113,26 +129,38 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT seq_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT seq_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int seq_min2 = std::numeric_limits<int>::max();
+  int seq_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type seq_minloc2(-1);
+  RAJA::Index_type seq_maxloc2(-1);
+
   RAJA::forall<EXEC_POL1>(host_res, arange,
     RAJA::expt::Reduce<RAJA::operators::plus>(&seq_sum),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&seq_min),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&seq_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&seq_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&seq_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&seq_min2, &seq_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&seq_max2, &seq_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce Seq Kernel"),
-    [=](int i, int &_seq_sum, int &_seq_min, int &_seq_max, VALLOC_INT &_seq_minloc, VALLOC_INT &_seq_maxloc) {
+    [=](int i,
+        VALOP_INT_SUM &_seq_sum,
+        VALOP_INT_MIN &_seq_min,
+        VALOP_INT_MAX &_seq_max,
+        VALOPLOC_INT_MIN &_seq_minloc,
+        VALOPLOC_INT_MAX &_seq_maxloc,
+        VALOPLOC_INT_MIN &_seq_minloc2,
+        VALOPLOC_INT_MAX &_seq_maxloc2) {
       _seq_sum += a[i];
 
-      _seq_min = RAJA_MIN(a[i], _seq_min);
-      _seq_max = RAJA_MAX(a[i], _seq_max);
+      _seq_min.min(a[i]);
+      _seq_max.max(a[i]);
+
+      _seq_minloc.minloc(a[i], i);
+      _seq_maxloc.maxloc(a[i], i);
 
-      _seq_minloc = RAJA_MIN(VALLOC_INT(a[i], i), _seq_minloc);
-      _seq_maxloc = RAJA_MAX(VALLOC_INT(a[i], i), _seq_maxloc);
-      //_seq_minloc.min(a[i], i);
-      //_seq_maxloc.max(a[i], i);
-      // Note : RAJA::expt::ValLoc<T> objects provide min() and max() methods
-      //        that are equivalent to the assignments with RAJA_MIN and RAJA_MAX
-      //        above.
+      _seq_minloc2.minloc(a[i], i);
+      _seq_maxloc2.maxloc(a[i], i);
     }
   );
 
@@ -143,6 +171,10 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
                                << seq_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << seq_maxloc.getVal() << " , "
                                << seq_maxloc.getLoc() << std::endl;
+  std::cout << "\tmin2, loc2 = "  << seq_min2 << " , "
+                                  << seq_minloc2 << std::endl;
+  std::cout << "\tmax2, loc2 = "  << seq_max2 << " , "
+                                  << seq_maxloc2 << std::endl;
   // _reductions_raja_seq_end
 
 
@@ -161,23 +193,38 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT omp_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT omp_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int omp_min2 = std::numeric_limits<int>::max();
+  int omp_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type omp_minloc2(-1);
+  RAJA::Index_type omp_maxloc2(-1);
+
   RAJA::forall<EXEC_POL2>(host_res, arange,
     RAJA::expt::Reduce<RAJA::operators::plus>(&omp_sum),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_min),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&omp_min2, &omp_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&omp_max2, &omp_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce OpenMP Kernel"),
-    [=](int i, int &_omp_sum, int &_omp_min, int &_omp_max, VALLOC_INT &_omp_minloc, VALLOC_INT &_omp_maxloc) {
+    [=](int i,
+        VALOP_INT_SUM &_omp_sum,
+        VALOP_INT_MIN &_omp_min,
+        VALOP_INT_MAX &_omp_max,
+        VALOPLOC_INT_MIN &_omp_minloc,
+        VALOPLOC_INT_MAX &_omp_maxloc,
+        VALOPLOC_INT_MIN &_omp_minloc2,
+        VALOPLOC_INT_MAX &_omp_maxloc2) {
       _omp_sum += a[i];
 
-      _omp_min = RAJA_MIN(a[i], _omp_min);
-      _omp_max = RAJA_MAX(a[i], _omp_max);
+      _omp_min.min(a[i]);
+      _omp_max.max(a[i]);
+
+      _omp_minloc.minloc(a[i], i);
+      _omp_maxloc.maxloc(a[i], i);
 
-      _omp_minloc = RAJA_MIN(VALLOC_INT(a[i], i), _omp_minloc);
-      _omp_maxloc = RAJA_MAX(VALLOC_INT(a[i], i), _omp_maxloc);
-      //_omp_minloc.min(a[i], i);
-      //_omp_maxloc.max(a[i], i);
+      _omp_minloc2.minloc(a[i], i);
+      _omp_maxloc2.maxloc(a[i], i);
     }
   );
 
@@ -188,6 +235,10 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
                                << omp_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << omp_maxloc.getVal() << " , "
                                << omp_maxloc.getLoc() << std::endl;
+  std::cout << "\tmin2, loc2 = "  << omp_min2 << " , "
+                                  << omp_minloc2 << std::endl;
+  std::cout << "\tmax2, loc2 = "  << omp_max2 << " , "
+                                  << omp_maxloc2 << std::endl;
 
 #endif
 
@@ -208,23 +259,38 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT omp_t_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT omp_t_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int omp_t_min2 = std::numeric_limits<int>::max();
+  int omp_t_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type omp_t_minloc2(-1);
+  RAJA::Index_type omp_t_maxloc2(-1);
+
   RAJA::forall<EXEC_POL3>(omp_res, arange,
     RAJA::expt::Reduce<RAJA::operators::plus>(&omp_t_sum),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_t_min),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_t_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_t_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_t_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&omp_t_min2, &omp_t_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&omp_t_max2, &omp_t_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce Target OpenMP Kernel"),
-    [=](int i, int &_omp_t_sum, int &_omp_t_min, int &_omp_t_max, VALLOC_INT &_omp_t_minloc, VALLOC_INT &_omp_t_maxloc) {
+    [=](int i,
+        VALOP_INT_SUM &_omp_t_sum,
+        VALOP_INT_MIN &_omp_t_min,
+        VALOP_INT_MAX &_omp_t_max,
+        VALOPLOC_INT_MIN &_omp_t_minloc,
+        VALOPLOC_INT_MAX &_omp_t_maxloc,
+        VALOPLOC_INT_MIN &_omp_t_minloc2,
+        VALOPLOC_INT_MAX &_omp_t_maxloc2) {
       _omp_t_sum += a[i];
 
-      _omp_t_min = RAJA_MIN(a[i], _omp_t_min);
-      _omp_t_max = RAJA_MAX(a[i], _omp_t_max);
+      _omp_t_min.min(a[i]);
+      _omp_t_max.max(a[i]);
 
-      _omp_t_minloc = RAJA_MIN(VALLOC_INT(a[i], i), _omp_t_minloc);
-      _omp_t_maxloc = RAJA_MAX(VALLOC_INT(a[i], i), _omp_t_maxloc);
-      //_omp_t_minloc.min(a[i], i);
-      //_omp_t_maxloc.max(a[i], i);
+      _omp_t_minloc.minloc(a[i], i);
+      _omp_t_maxloc.maxloc(a[i], i);
+
+      _omp_t_minloc2.minloc(a[i], i);
+      _omp_t_maxloc2.maxloc(a[i], i);
     }
   );
 
@@ -235,6 +301,10 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
                                << omp_t_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << omp_t_maxloc.getVal() << " , "
                                << omp_t_maxloc.getLoc() << std::endl;
+  std::cout << "\tmin2, loc2 = "  << omp_t_min2 << " , "
+                                  << omp_t_minloc2 << std::endl;
+  std::cout << "\tmax2, loc2 = "  << omp_t_max2 << " , "
+                                  << omp_t_maxloc2 << std::endl;
 
 #endif
 
@@ -259,23 +329,38 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT cuda_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT cuda_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int cuda_min2 = std::numeric_limits<int>::max();
+  int cuda_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type cuda_minloc2(-1);
+  RAJA::Index_type cuda_maxloc2(-1);
+
   RAJA::forall<EXEC_POL3>(cuda_res, arange,
     RAJA::expt::Reduce<RAJA::operators::plus>(&cuda_sum),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&cuda_min),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&cuda_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&cuda_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&cuda_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&cuda_min2, &cuda_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&cuda_max2, &cuda_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce CUDA Kernel"),
-    [=] RAJA_DEVICE (int i, int &_cuda_sum, int &_cuda_min, int &_cuda_max, VALLOC_INT &_cuda_minloc, VALLOC_INT &_cuda_maxloc) {
+    [=] RAJA_DEVICE ( int i,
+                      VALOP_INT_SUM &_cuda_sum,
+                      VALOP_INT_MIN &_cuda_min,
+                      VALOP_INT_MAX &_cuda_max,
+                      VALOPLOC_INT_MIN &_cuda_minloc,
+                      VALOPLOC_INT_MAX &_cuda_maxloc,
+                      VALOPLOC_INT_MIN &_cuda_minloc2,
+                      VALOPLOC_INT_MAX &_cuda_maxloc2) {
       _cuda_sum += d_a[i];
 
-      _cuda_min = RAJA_MIN(d_a[i], _cuda_min);
-      _cuda_max = RAJA_MAX(d_a[i], _cuda_max);
+      _cuda_min.min(d_a[i]);
+      _cuda_max.max(d_a[i]);
 
-      _cuda_minloc = RAJA_MIN(VALLOC_INT(d_a[i], i), _cuda_minloc);
-      _cuda_maxloc = RAJA_MAX(VALLOC_INT(d_a[i], i), _cuda_maxloc);
-      //_cuda_minloc.min(a[i], i);
-      //_cuda_maxloc.max(a[i], i);
+      _cuda_minloc.minloc(a[i], i);
+      _cuda_maxloc.maxloc(a[i], i);
+
+      _cuda_minloc2.minloc(a[i], i);
+      _cuda_maxloc2.maxloc(a[i], i);
     }
   );
 
@@ -286,6 +371,10 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
                                << cuda_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << cuda_maxloc.getVal() << " , "
                                << cuda_maxloc.getLoc() << std::endl;
+  std::cout << "\tmin2, loc2 = "  << cuda_min2 << " , "
+                                  << cuda_minloc2 << std::endl;
+  std::cout << "\tmax2, loc2 = "  << cuda_max2 << " , "
+                                  << cuda_maxloc2 << std::endl;
   cuda_res.deallocate(d_a);
 #endif
 
@@ -309,23 +398,38 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT hip_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT hip_maxloc(std::numeric_limits<int>::min(), -1);
 
-  RAJA::forall<EXEC_POL3>(arange,
+  int hip_min2 = std::numeric_limits<int>::max();
+  int hip_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type hip_minloc2(-1);
+  RAJA::Index_type hip_maxloc2(-1);
+
+  RAJA::forall<EXEC_POL3>(hip_res, arange,
     RAJA::expt::Reduce<RAJA::operators::plus>(&hip_sum),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&hip_min),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&hip_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&hip_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&hip_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&hip_min2, &hip_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&hip_max2, &hip_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce HIP Kernel"),
-    [=] RAJA_DEVICE (int i, int &_hip_sum, int &_hip_min, int &_hip_max, VALLOC_INT &_hip_minloc, VALLOC_INT &_hip_maxloc) {
+    [=] RAJA_DEVICE ( int i,
+                      VALOP_INT_SUM &_hip_sum,
+                      VALOP_INT_MIN &_hip_min,
+                      VALOP_INT_MAX &_hip_max,
+                      VALOPLOC_INT_MIN &_hip_minloc,
+                      VALOPLOC_INT_MAX &_hip_maxloc,
+                      VALOPLOC_INT_MIN &_hip_minloc2,
+                      VALOPLOC_INT_MAX &_hip_maxloc2) {
       _hip_sum += d_a[i];
 
-      _hip_min = RAJA_MIN(d_a[i], _hip_min);
-      _hip_max = RAJA_MAX(d_a[i], _hip_max);
+      _hip_min.min(d_a[i]);
+      _hip_max.max(d_a[i]);
+
+      _hip_minloc.minloc(d_a[i], i);
+      _hip_maxloc.maxloc(d_a[i], i);
 
-      _hip_minloc = RAJA_MIN(VALLOC_INT(d_a[i], i), _hip_minloc);
-      _hip_maxloc = RAJA_MAX(VALLOC_INT(d_a[i], i), _hip_maxloc);
-      //_hip_minloc.min(d_a[i], i);
-      //_hip_maxloc.max(d_a[i], i);
+      _hip_minloc2.minloc(d_a[i], i);
+      _hip_maxloc2.maxloc(d_a[i], i);
     }
   );
 
@@ -336,6 +440,10 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
                                << hip_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << hip_maxloc.getVal() << " , "
                                << hip_maxloc.getLoc() << std::endl;
+  std::cout << "\tmin2, loc2 = "  << hip_min2 << " , "
+                                  << hip_minloc2 << std::endl;
+  std::cout << "\tmax2, loc2 = "  << hip_max2 << " , "
+                                  << hip_maxloc2 << std::endl;
 
   hip_res.deallocate(d_a);
 #endif
@@ -360,23 +468,38 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT sycl_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT sycl_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int sycl_min2 = std::numeric_limits<int>::max();
+  int sycl_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type sycl_minloc2(-1);
+  RAJA::Index_type sycl_maxloc2(-1);
+
   RAJA::forall<EXEC_POL3>(sycl_res, arange,
     RAJA::expt::Reduce<RAJA::operators::plus>(&sycl_sum),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&sycl_min),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&sycl_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&sycl_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&sycl_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&sycl_min2, &sycl_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&sycl_max2, &sycl_maxloc2),
     RAJA::expt::KernelName("RAJA Reduce SYCL Kernel"),
-    [=] RAJA_DEVICE (int i, int &_sycl_sum, int &_sycl_min, int &_sycl_max, VALLOC_INT &_sycl_minloc, VALLOC_INT &_sycl_maxloc) {
+    [=] RAJA_DEVICE ( int i,
+                      VALOP_INT_SUM &_sycl_sum,
+                      VALOP_INT_MIN &_sycl_min,
+                      VALOP_INT_MAX &_sycl_max,
+                      VALOPLOC_INT_MIN &_sycl_minloc,
+                      VALOPLOC_INT_MAX &_sycl_maxloc,
+                      VALOPLOC_INT_MIN &_sycl_minloc2,
+                      VALOPLOC_INT_MAX &_sycl_maxloc2) {
       _sycl_sum += d_a[i];
 
-      _sycl_min = RAJA_MIN(d_a[i], _sycl_min);
-      _sycl_max = RAJA_MAX(d_a[i], _sycl_max);
+      _sycl_min.min(d_a[i]);
+      _sycl_max.max(d_a[i]);
+
+      _sycl_minloc.minloc(d_a[i], i);
+      _sycl_maxloc.maxloc(d_a[i], i);
 
-      _sycl_minloc = RAJA_MIN(VALLOC_INT(d_a[i], i), _sycl_minloc);
-      _sycl_maxloc = RAJA_MAX(VALLOC_INT(d_a[i], i), _sycl_maxloc);
-      //_sycl_minloc.min(d_a[i], i);
-      //_sycl_maxloc.max(d_a[i], i);
+      _sycl_minloc2.minloc(d_a[i], i);
+      _sycl_maxloc2.maxloc(d_a[i], i);
     }
   );
 
@@ -387,6 +510,10 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
                                << sycl_minloc.getLoc() << std::endl;
   std::cout << "\tmax, loc = " << sycl_maxloc.getVal() << " , "
                                << sycl_maxloc.getLoc() << std::endl;
+  std::cout << "\tmin2, loc2 = "  << sycl_min2 << " , "
+                                  << sycl_minloc2 << std::endl;
+  std::cout << "\tmax2, loc2 = "  << sycl_max2 << " , "
+                                  << sycl_maxloc2 << std::endl;
 
   sycl_res.deallocate(d_a);
 #endif
diff --git a/examples/launch-param-reductions.cpp b/examples/launch-param-reductions.cpp
index b57bedfd6b..5bec907c33 100644
--- a/examples/launch-param-reductions.cpp
+++ b/examples/launch-param-reductions.cpp
@@ -81,6 +81,11 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
     }
   }
 
+//
+// Set a[0] to a different value. Total sum should be 2.
+//
+  a[0] = 3;
+
 //
 // Set min and max loc values
 //
@@ -95,7 +100,7 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 // Note: with this data initialization scheme, the following results will
 //       be observed for all reduction kernels below:
 //
-//  - the sum will be zero
+//  - the sum will be two
 //  - the min will be -100
 //  - the max will be 100
 //  - the min loc will be N/2
@@ -115,6 +120,17 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
 //
 
   using VALLOC_INT = RAJA::expt::ValLoc<int>;
+
+//
+// Define ValOp Types
+//
+
+  using VALOP_INT_SUM = RAJA::expt::ValOp<int, RAJA::operators::plus>;
+  using VALOP_INT_MIN = RAJA::expt::ValOp<int, RAJA::operators::minimum>;
+  using VALOP_INT_MAX = RAJA::expt::ValOp<int, RAJA::operators::maximum>;
+  using VALOPLOC_INT_MIN = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::minimum>;
+  using VALOPLOC_INT_MAX = RAJA::expt::ValLocOp<int, RAJA::Index_type, RAJA::operators::maximum>;
+
 //----------------------------------------------------------------------------//
 
   std::cout << "\n Running RAJA sequential reductions...\n";
@@ -129,32 +145,41 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT seq_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT seq_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int seq_min2 = std::numeric_limits<int>::max();
+  int seq_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type seq_minloc2(-1);
+  RAJA::Index_type seq_maxloc2(-1);
+
   RAJA::launch<LAUNCH_POL1>
     (host_res, RAJA::LaunchParams(), "SeqReductionKernel",
-    RAJA::expt::Reduce<RAJA::operators::plus>(&seq_sum),
+    RAJA::expt::Reduce<RAJA::operators::plus   >(&seq_sum),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&seq_min),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&seq_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&seq_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&seq_maxloc),
-     [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
-                           int &_seq_sum, int &_seq_min,
-                           int &_seq_max, VALLOC_INT &_seq_minloc,
-                           VALLOC_INT &_seq_maxloc) {
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&seq_min2, &seq_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&seq_max2, &seq_maxloc2),
+     [=] RAJA_HOST_DEVICE ( RAJA::LaunchContext ctx,
+                            VALOP_INT_SUM &_seq_sum,
+                            VALOP_INT_MIN &_seq_min,
+                            VALOP_INT_MAX &_seq_max,
+                            VALOPLOC_INT_MIN &_seq_minloc,
+                            VALOPLOC_INT_MAX &_seq_maxloc,
+                            VALOPLOC_INT_MIN &_seq_minloc2,
+                            VALOPLOC_INT_MAX &_seq_maxloc2) {
 
       RAJA::loop<LOOP_POL1>(ctx, arange, [&] (int i) {
 
           _seq_sum += a[i];
 
-          _seq_min = RAJA_MIN(a[i], _seq_min);
-          _seq_max = RAJA_MAX(a[i], _seq_max);
+          _seq_min.min(a[i]);
+          _seq_max.max(a[i]);
+
+          _seq_minloc.minloc(a[i], i);
+          _seq_maxloc.maxloc(a[i], i);
 
-          _seq_minloc = RAJA_MIN(VALLOC_INT(a[i], i), _seq_minloc);
-          _seq_maxloc = RAJA_MAX(VALLOC_INT(a[i], i), _seq_maxloc);
-          //_seq_minloc.min(a[i], i);
-          //_seq_maxloc.max(a[i], i);
-          // Note : RAJA::expt::ValLoc<T> objects provide min() and max() methods
-          //        that are equivalent to the assignments with RAJA_MIN and RAJA_MAX
-          //        above.
+          _seq_minloc2.minloc(a[i], i);
+          _seq_maxloc2.maxloc(a[i], i);
         }
       );
 
@@ -187,29 +212,41 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT omp_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT omp_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int omp_min2 = std::numeric_limits<int>::max();
+  int omp_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type omp_minloc2(-1);
+  RAJA::Index_type omp_maxloc2(-1);
+
   RAJA::launch<LAUNCH_POL2>
     (host_res, RAJA::LaunchParams(), "OmpReductionKernel",
-    RAJA::expt::Reduce<RAJA::operators::plus>(&omp_sum),
+    RAJA::expt::Reduce<RAJA::operators::plus   >(&omp_sum),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_min),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&omp_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&omp_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&omp_min2, &omp_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&omp_max2, &omp_maxloc2),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
-                           int &_omp_sum, int &_omp_min,
-                           int &_omp_max, VALLOC_INT &_omp_minloc,
-                           VALLOC_INT &_omp_maxloc) {
+                           VALOP_INT_SUM &_omp_sum,
+                           VALOP_INT_MIN &_omp_min,
+                           VALOP_INT_MAX &_omp_max,
+                           VALOPLOC_INT_MIN &_omp_minloc,
+                           VALOPLOC_INT_MAX &_omp_maxloc,
+                           VALOPLOC_INT_MIN &_omp_minloc2,
+                           VALOPLOC_INT_MAX &_omp_maxloc2) {
 
       RAJA::loop<LOOP_POL2>(ctx, arange, [&] (int i) {
 
           _omp_sum += a[i];
 
-          _omp_min = RAJA_MIN(a[i], _omp_min);
-          _omp_max = RAJA_MAX(a[i], _omp_max);
+          _omp_min.min(a[i]);
+          _omp_max.max(a[i]);
+
+          _omp_minloc.minloc(a[i], i);
+          _omp_maxloc.maxloc(a[i], i);
 
-          _omp_minloc = RAJA_MIN(VALLOC_INT(a[i], i), _omp_minloc);
-          _omp_maxloc = RAJA_MAX(VALLOC_INT(a[i], i), _omp_maxloc);
-          //_omp_minloc.min(a[i], i);
-          //_omp_maxloc.max(a[i], i);
+          _omp_minloc2.minloc(a[i], i);
+          _omp_maxloc2.maxloc(a[i], i);
         }
       );
 
@@ -247,30 +284,43 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT cuda_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT cuda_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int cuda_min2 = std::numeric_limits<int>::max();
+  int cuda_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type cuda_minloc2(-1);
+  RAJA::Index_type cuda_maxloc2(-1);
+
   RAJA::launch<LAUNCH_POL3>
     (device_res, RAJA::LaunchParams(RAJA::Teams(NUMBER_OF_TEAMS), RAJA::Threads(CUDA_BLOCK_SIZE)),
      "CUDAReductionKernel",
-    RAJA::expt::Reduce<RAJA::operators::plus>(&cuda_sum),
+    RAJA::expt::Reduce<RAJA::operators::plus   >(&cuda_sum),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&cuda_min),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&cuda_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&cuda_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&cuda_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&cuda_min2, &cuda_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&cuda_max2, &cuda_maxloc2),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
-                           int &_cuda_sum, int &_cuda_min, int &_cuda_max,
-                           VALLOC_INT &_cuda_minloc, VALLOC_INT &_cuda_maxloc) {
+                           VALOP_INT_SUM &_cuda_sum,
+                           VALOP_INT_MIN &_cuda_min,
+                           VALOP_INT_MAX &_cuda_max,
+                           VALOPLOC_INT_MIN &_cuda_minloc,
+                           VALOPLOC_INT_MAX &_cuda_maxloc,
+                           VALOPLOC_INT_MIN &_cuda_minloc2,
+                           VALOPLOC_INT_MAX &_cuda_maxloc2) {
 
 
       RAJA::loop<LOOP_POL3>(ctx, arange, [&] (int i) {
 
           _cuda_sum += d_a[i];
 
-          _cuda_min = RAJA_MIN(d_a[i], _cuda_min);
-          _cuda_max = RAJA_MAX(d_a[i], _cuda_max);
+          _cuda_min.min(d_a[i]);
+          _cuda_max.max(d_a[i]);
+
+          _cuda_minloc.minloc(a[i], i);
+          _cuda_maxloc.maxloc(a[i], i);
 
-          _cuda_minloc = RAJA_MIN(VALLOC_INT(d_a[i], i), _cuda_minloc);
-          _cuda_maxloc = RAJA_MAX(VALLOC_INT(d_a[i], i), _cuda_maxloc);
-          //_cuda_minloc.min(a[i], i);
-          //_cuda_maxloc.max(a[i], i);
+          _cuda_minloc2.minloc(a[i], i);
+          _cuda_maxloc2.maxloc(a[i], i);
 
         }
       );
@@ -311,31 +361,42 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT hip_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT hip_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int hip_min2 = std::numeric_limits<int>::max();
+  int hip_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type hip_minloc2(-1);
+  RAJA::Index_type hip_maxloc2(-1);
+
   RAJA::launch<LAUNCH_POL3>
     (device_res, RAJA::LaunchParams(RAJA::Teams(NUMBER_OF_TEAMS), RAJA::Threads(HIP_BLOCK_SIZE)),
      "HipReductionKernel",
-    RAJA::expt::Reduce<RAJA::operators::plus>(&hip_sum),
+    RAJA::expt::Reduce<RAJA::operators::plus   >(&hip_sum),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&hip_min),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&hip_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&hip_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&hip_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&hip_min2, &hip_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&hip_max2, &hip_maxloc2),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
-                           int &_hip_sum, int &_hip_min,
-                           int &_hip_max, VALLOC_INT &_hip_minloc,
-                           VALLOC_INT &_hip_maxloc) {
+                           VALOP_INT_SUM &_hip_sum,
+                           VALOP_INT_MIN &_hip_min,
+                           VALOP_INT_MAX &_hip_max,
+                           VALOPLOC_INT_MIN &_hip_minloc,
+                           VALOPLOC_INT_MAX &_hip_maxloc,
+                           VALOPLOC_INT_MIN &_hip_minloc2,
+                           VALOPLOC_INT_MAX &_hip_maxloc2) {
 
       RAJA::loop<LOOP_POL3>(ctx, arange, [&] (int i) {
 
           _hip_sum += d_a[i];
 
-          _hip_min = RAJA_MIN(d_a[i], _hip_min);
-          _hip_max = RAJA_MAX(d_a[i], _hip_max);
+          _hip_min.min(d_a[i]);
+          _hip_max.max(d_a[i]);
 
-          _hip_minloc = RAJA_MIN(VALLOC_INT(d_a[i], i), _hip_minloc);
-          _hip_maxloc = RAJA_MAX(VALLOC_INT(d_a[i], i), _hip_maxloc);
-          //_hip_minloc.min(d_a[i], i);
-          //_hip_maxloc.max(d_a[i], i);
+          _hip_minloc.minloc(d_a[i], i);
+          _hip_maxloc.maxloc(d_a[i], i);
 
+          _hip_minloc2.minloc(d_a[i], i);
+          _hip_maxloc2.maxloc(d_a[i], i);
         }
       );
 
@@ -374,31 +435,42 @@ int main(int RAJA_UNUSED_ARG(argc), char** RAJA_UNUSED_ARG(argv[]))
   VALLOC_INT sycl_minloc(std::numeric_limits<int>::max(), -1);
   VALLOC_INT sycl_maxloc(std::numeric_limits<int>::min(), -1);
 
+  int sycl_min2 = std::numeric_limits<int>::max();
+  int sycl_max2 = std::numeric_limits<int>::min();
+  RAJA::Index_type sycl_minloc2(-1);
+  RAJA::Index_type sycl_maxloc2(-1);
+
   RAJA::launch<LAUNCH_POL4>
     (device_res, RAJA::LaunchParams(RAJA::Teams(NUMBER_OF_TEAMS), RAJA::Threads(SYCL_BLOCK_SIZE)),
      "SyclReductionKernel",
-    RAJA::expt::Reduce<RAJA::operators::plus>(&sycl_sum),
+    RAJA::expt::Reduce<RAJA::operators::plus   >(&sycl_sum),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&sycl_min),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&sycl_max),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&sycl_minloc),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&sycl_maxloc),
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&sycl_min2, &sycl_minloc2),
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&sycl_max2, &sycl_maxloc2),
      [=] RAJA_HOST_DEVICE (RAJA::LaunchContext ctx,
-                           int &_sycl_sum, int &_sycl_min,
-                           int &_sycl_max, VALLOC_INT &_sycl_minloc,
-                           VALLOC_INT &_sycl_maxloc) {
+                           VALOP_INT_SUM &_sycl_sum,
+                           VALOP_INT_MIN &_sycl_min,
+                           VALOP_INT_MAX &_sycl_max,
+                           VALOPLOC_INT_MIN &_sycl_minloc,
+                           VALOPLOC_INT_MAX &_sycl_maxloc,
+                           VALOPLOC_INT_MIN &_sycl_minloc2,
+                           VALOPLOC_INT_MAX &_sycl_maxloc2) {
 
       RAJA::loop<LOOP_POL4>(ctx, arange, [&] (int i) {
 
           _sycl_sum += d_a[i];
 
-          _sycl_min = RAJA_MIN(d_a[i], _sycl_min);
-          _sycl_max = RAJA_MAX(d_a[i], _sycl_max);
+          _sycl_min.min(d_a[i]);
+          _sycl_max.max(d_a[i]);
 
-          _sycl_minloc = RAJA_MIN(VALLOC_INT(d_a[i], i), _sycl_minloc);
-          _sycl_maxloc = RAJA_MAX(VALLOC_INT(d_a[i], i), _sycl_maxloc);
-          //_sycl_minloc.min(d_a[i], i);
-          //_sycl_maxloc.max(d_a[i], i);
+          _sycl_minloc.minloc(d_a[i], i);
+          _sycl_maxloc.maxloc(d_a[i], i);
 
+          _sycl_minloc2.minloc(d_a[i], i);
+          _sycl_maxloc2.maxloc(d_a[i], i);
         }
       );
 
diff --git a/include/RAJA/pattern/params/forall.hpp b/include/RAJA/pattern/params/forall.hpp
index fb854c8706..5a656206f5 100644
--- a/include/RAJA/pattern/params/forall.hpp
+++ b/include/RAJA/pattern/params/forall.hpp
@@ -276,7 +276,7 @@ namespace expt
     template<typename LAMBDA, typename... EXPECTED_ARGS>
     constexpr concepts::enable_if<has_empty_op<LAMBDA>> check_invocable(LAMBDA&&, const camp::list<EXPECTED_ARGS...>&) {
 #if !defined(RAJA_ENABLE_HIP)
-      static_assert(is_invocable<LAMBDA, typename get_lambda_index_type<LAMBDA>::type, EXPECTED_ARGS...>::value, "LAMBDA Not invocable w/ EXPECTED_ARGS."); 
+      static_assert(is_invocable<LAMBDA, typename get_lambda_index_type<LAMBDA>::type, EXPECTED_ARGS...>::value, "LAMBDA Not invocable w/ EXPECTED_ARGS. Ordering and types must match between RAJA::expt::Reduce() and ValOp arguments."); 
 #endif
     }
 
diff --git a/include/RAJA/pattern/params/params_base.hpp b/include/RAJA/pattern/params/params_base.hpp
index 51e96260f8..98380f6ffc 100644
--- a/include/RAJA/pattern/params/params_base.hpp
+++ b/include/RAJA/pattern/params/params_base.hpp
@@ -6,6 +6,112 @@ namespace RAJA
 {
 namespace expt
 {
+
+  template<typename T, typename IndexType = RAJA::Index_type>
+  struct ValLoc {
+    using index_type = IndexType;
+    using value_type = T;
+
+    ValLoc() = default;
+    RAJA_HOST_DEVICE constexpr explicit ValLoc(value_type v) : val(v) {}
+    RAJA_HOST_DEVICE constexpr ValLoc(value_type v, index_type l) : val(v), loc(l) {}
+
+    ValLoc(ValLoc const &) = default;
+    ValLoc(ValLoc &&) = default;
+    ValLoc& operator=(ValLoc const &) = default;
+    ValLoc& operator=(ValLoc &&) = default;
+
+    RAJA_HOST_DEVICE constexpr bool operator<(const ValLoc& rhs) const { return val < rhs.val; }
+    RAJA_HOST_DEVICE constexpr bool operator>(const ValLoc& rhs) const { return val > rhs.val; }
+
+    RAJA_HOST_DEVICE constexpr const value_type& getVal() const {return val;}
+    RAJA_HOST_DEVICE constexpr const index_type& getLoc() const {return loc;}
+
+    RAJA_HOST_DEVICE void set(T inval, IndexType inindex) {val = inval; loc = inindex;}
+    RAJA_HOST_DEVICE void setVal(T inval) {val = inval;}
+    RAJA_HOST_DEVICE void setLoc(IndexType inindex) {loc = inindex;}
+
+    value_type val;
+    index_type loc = -1;
+  };
+
+  template<typename T, template <typename, typename, typename> class Op>
+  struct ValOp {
+    using value_type = T;
+    using op_type = Op<T,T,T>;
+
+    ValOp() = default;
+    RAJA_HOST_DEVICE constexpr explicit ValOp(value_type v) : val(v) {}
+
+    ValOp(ValOp const &) = default;
+    ValOp(ValOp &&) = default;
+    ValOp& operator=(ValOp const &) = default;
+    ValOp& operator=(ValOp &&) = default;
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::minimum<T,T,T>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & min(value_type v) { if (v < val) { val = v; } return *this; }
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::maximum<T,T,T>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & max(value_type v) { if (v > val) { val = v; } return *this; }
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::plus<T,T,T>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & operator+=(const value_type& rhs) { val += rhs; return *this; }
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::bit_and<T,T,T>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & operator&=(const value_type& rhs) { val &= rhs; return *this; }
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::bit_or<T,T,T>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & operator|=(const value_type& rhs) { val |= rhs; return *this; }
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::bit_and<T,T,T>>::value> * = nullptr>
+    RAJA_HOST_DEVICE ValOp & operator&=(value_type& rhs) { val &= rhs; return *this; }
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::bit_or<T,T,T>>::value> * = nullptr>
+    RAJA_HOST_DEVICE ValOp & operator|=(value_type& rhs) { val |= rhs; return *this; }
+
+    RAJA_HOST_DEVICE constexpr bool operator<(const ValOp& rhs) const { val < rhs.val; return *this; }
+    RAJA_HOST_DEVICE constexpr bool operator>(const ValOp& rhs) const { val > rhs.val; return *this; }
+
+    value_type val = op_type::identity();
+  };
+
+  template<typename T, typename IndexType, template <typename, typename, typename> class Op>
+  struct ValOp <ValLoc<T,IndexType>, Op> {
+    using index_type = IndexType;
+    using value_type = ValLoc<T,index_type>;
+    using op_type = Op<value_type,value_type,value_type>;
+    using valloc_value_type = typename value_type::value_type;
+    using valloc_index_type = typename value_type::index_type;
+
+    ValOp() = default;
+    RAJA_HOST_DEVICE constexpr explicit ValOp(value_type v) : val(v) {}
+    RAJA_HOST_DEVICE constexpr ValOp(valloc_value_type v, valloc_index_type l) : val(v, l) {}
+
+    ValOp(ValOp const &) = default;
+    ValOp(ValOp &&) = default;
+    ValOp& operator=(ValOp const &) = default;
+    ValOp& operator=(ValOp &&) = default;
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::minimum<value_type,value_type,value_type>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & min(value_type v) { if (v < val) { val = v; } return *this; }
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::maximum<value_type,value_type,value_type>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & max(value_type v) { if (v > val) { val = v; } return *this; }
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::minimum<value_type,value_type,value_type>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & minloc(valloc_value_type v, valloc_index_type l) { return min(value_type(v,l)); }
+
+    template <typename U = op_type, std::enable_if_t<std::is_same<U, RAJA::operators::maximum<value_type,value_type,value_type>>::value> * = nullptr>
+    RAJA_HOST_DEVICE constexpr ValOp & maxloc(valloc_value_type v, valloc_index_type l) { return max(value_type(v,l)); }
+
+    RAJA_HOST_DEVICE constexpr bool operator<(const ValOp& rhs) const { return val < rhs.val; }
+    RAJA_HOST_DEVICE constexpr bool operator>(const ValOp& rhs) const { return val > rhs.val; }
+
+    value_type val = op_type::identity();
+  };
+
+  template<typename T, typename IndexType, template <typename, typename, typename> class Op>
+  using ValLocOp = ValOp<ValLoc<T, IndexType>, Op>;
+
 namespace detail
 {
 
diff --git a/include/RAJA/pattern/params/reducer.hpp b/include/RAJA/pattern/params/reducer.hpp
index 05103c7ad4..78b6d7714d 100644
--- a/include/RAJA/pattern/params/reducer.hpp
+++ b/include/RAJA/pattern/params/reducer.hpp
@@ -15,46 +15,18 @@
 namespace RAJA
 {
 
-namespace expt
-{
-
-template<typename T>
-struct ValLoc {
-  using index_type = RAJA::Index_type;
-  using value_type = T;
-
-  RAJA_HOST_DEVICE ValLoc() {}
-  RAJA_HOST_DEVICE ValLoc(value_type v) : val(v) {}
-  RAJA_HOST_DEVICE ValLoc(value_type v, RAJA::Index_type l) : val(v), loc(l) {}
-
-  RAJA_HOST_DEVICE void min(value_type v, index_type l) { if (v < val) { val = v; loc = l; } }
-  RAJA_HOST_DEVICE void max(value_type v, index_type l) { if (v > val) { val = v; loc = l; } }
-
-  bool constexpr operator<(const ValLoc& rhs) const { return val < rhs.val; }
-  bool constexpr operator>(const ValLoc& rhs) const { return val > rhs.val; }
-
-  value_type getVal() {return val;}
-  RAJA::Index_type getLoc() {return loc;}
-
-private:
-  value_type val;
-  index_type loc = -1;
-};
-
-} //  namespace expt
-
 namespace operators
 {
 
-template <typename T>
-struct limits<RAJA::expt::ValLoc<T>> {
-  RAJA_INLINE RAJA_HOST_DEVICE static constexpr RAJA::expt::ValLoc<T> min()
+template <typename T, typename IndexType>
+struct limits<RAJA::expt::ValLoc<T, IndexType>> {
+  RAJA_INLINE RAJA_HOST_DEVICE static constexpr RAJA::expt::ValLoc<T, IndexType> min()
   {
-    return RAJA::expt::ValLoc<T>(RAJA::operators::limits<T>::min());
+    return RAJA::expt::ValLoc<T, IndexType>(RAJA::operators::limits<T>::min());
   }
-  RAJA_INLINE RAJA_HOST_DEVICE static constexpr RAJA::expt::ValLoc<T> max()
+  RAJA_INLINE RAJA_HOST_DEVICE static constexpr RAJA::expt::ValLoc<T, IndexType> max()
   {
-    return RAJA::expt::ValLoc<T>(RAJA::operators::limits<T>::max());
+    return RAJA::expt::ValLoc<T, IndexType>(RAJA::operators::limits<T>::max());
   }
 };
 
@@ -83,16 +55,41 @@ namespace detail
   // Basic Reducer
   //
   //
-  template <typename Op, typename T>
+
+  // Basic data type Reducer
+  // T must be a basic data type
+  // VOp must be ValOp<T, Op>
+  template <typename Op, typename T, typename VOp>
   struct Reducer : public ForallParamBase {
     using op = Op;
-    using value_type = T;
+    using value_type = T; // This is a basic data type
 
-    RAJA_HOST_DEVICE Reducer() {}
-    Reducer(value_type *target_in) : target(target_in), val(op::identity()) {}
+    Reducer() = default;
 
+    // Basic data type constructor
+    RAJA_HOST_DEVICE Reducer(value_type *target_in) : m_valop(VOp{}), target(target_in){}
+
+    Reducer(Reducer const &) = default;
+    Reducer(Reducer &&) = default;
+    Reducer& operator=(Reducer const &) = default;
+    Reducer& operator=(Reducer &&) = default;
+
+    // Internal ValOp object that is used within RAJA::forall/launch
+    VOp m_valop = VOp{};
+
+    // Points to the user specified result variable
     value_type *target = nullptr;
-    value_type val = op::identity();
+
+    // combineTarget() performs the final op on the target data and location in resolve()
+    RAJA_HOST_DEVICE void combineTarget(value_type in)
+    {
+      value_type temp = op{}(*target, in);
+      *target = temp;
+    }
+
+    RAJA_HOST_DEVICE
+    value_type &
+    getVal() { return m_valop.val; }
 
 #if defined(RAJA_CUDA_ACTIVE) || defined(RAJA_HIP_ACTIVE) || defined(RAJA_SYCL_ACTIVE)
     // Device related attributes.
@@ -101,48 +98,101 @@ namespace detail
     unsigned int * device_count = nullptr;
 #endif
 
-    using ARG_TUP_T = camp::tuple<value_type*>;
-    RAJA_HOST_DEVICE ARG_TUP_T get_lambda_arg_tup() { return camp::make_tuple(&val); }
+    // These are types and parameters extracted from this struct, and given to the forall.
+    using ARG_TUP_T = camp::tuple<VOp*>;
+    RAJA_HOST_DEVICE ARG_TUP_T get_lambda_arg_tup() { return camp::make_tuple(&m_valop); }
 
     using ARG_LIST_T = typename ARG_TUP_T::TList;
     static constexpr size_t num_lambda_args = camp::tuple_size<ARG_TUP_T>::value ;
   };
 
-} // namespace detail
-
-template <template <typename, typename, typename> class Op, typename T>
-auto constexpr Reduce(T *target)
-{
-  return detail::Reducer<Op<T, T, T>, T>(target);
-}
+  // Partial specialization of Reducer for ValLoc
+  // T is a deduced basic data type
+  // I is a deduced index type
+  template <typename T, typename I, template <typename, typename, typename> class Op>
+  struct Reducer<Op<ValLoc<T,I>, ValLoc<T,I>, ValLoc<T,I>>, ValLoc<T,I>, ValOp<ValLoc<T,I>, Op>> : public ForallParamBase {
+    using target_value_type = T;
+    using target_index_type = I;
+    using value_type = ValLoc<T,I>;
+    using op = Op<value_type,value_type,value_type>;
+    using VOp = ValOp<ValLoc<target_value_type,target_index_type>, Op>;
+
+    Reducer() = default;
+
+    // ValLoc constructor
+    // Note that the target_ variables point to the val and loc within the user defined target ValLoc
+    RAJA_HOST_DEVICE Reducer(value_type *target_in) : m_valop(VOp{}), target_value(&target_in->val), target_index(&target_in->loc) {}
+
+    // Dual input constructor for ReduceLoc<>(data, index) case
+    // The target_ variables point to vars defined by the user
+    RAJA_HOST_DEVICE Reducer(target_value_type *data_in, target_index_type *index_in) : m_valop(VOp{}), target_value(data_in), target_index(index_in) {}
+
+    Reducer(Reducer const &) = default;
+    Reducer(Reducer &&) = default;
+    Reducer& operator=(Reducer const &) = default;
+    Reducer& operator=(Reducer &&) = default;
+
+    // The ValLoc within m_valop is initialized with data and location values from either a ValLoc, or dual data and location values, passed into the constructor
+    VOp m_valop = VOp{};
+
+    // Points to either dual value and index defined by the user, or value and index within a ValLoc defined by the user
+    target_value_type *target_value = nullptr;
+    target_index_type *target_index = nullptr;
+
+    // combineTarget() performs the final op on the target data and location in resolve()
+    RAJA_HOST_DEVICE void combineTarget(value_type in)
+    {
+      // Create a different temp ValLoc solely for combining
+      value_type temp(*target_value, *target_index);
+      temp = op{}(temp, in);
+      *target_value = temp.val;
+      *target_index = temp.loc;
+    }
 
+    RAJA_HOST_DEVICE
+    value_type &
+    getVal() { return m_valop.val; }
 
+#if defined(RAJA_CUDA_ACTIVE) || defined(RAJA_HIP_ACTIVE) || defined(RAJA_SYCL_ACTIVE)
+    // Device related attributes.
+    value_type * devicetarget = nullptr;
+    RAJA::detail::SoAPtr<value_type, device_mem_pool_t> device_mem;
+    unsigned int * device_count = nullptr;
+#endif
 
-namespace detail
-{
+    // These are types and parameters extracted from this struct, and given to the forall.
+    using ARG_TUP_T = camp::tuple<VOp*>;
+    RAJA_HOST_DEVICE ARG_TUP_T get_lambda_arg_tup() { return camp::make_tuple(&m_valop); }
 
-  //
-  //
-  // Basic ReducerLoc
-  //
-  //
-  template <typename Op, typename T>
-  struct ReducerLoc : public Reducer<Op, T> {
-    using Base = Reducer<Op, T>;
-    using value_type = typename Base::value_type;
-    ReducerLoc(value_type *target_in) {
-      Base::target = target_in;
-      Base::val = value_type(Op::identity());
-    }
+    using ARG_LIST_T = typename ARG_TUP_T::TList;
+    static constexpr size_t num_lambda_args = camp::tuple_size<ARG_TUP_T>::value ;
   };
 
 } // namespace detail
 
+// Standard use case.
 template <template <typename, typename, typename> class Op, typename T>
-auto constexpr ReduceLoc(T *target)
+auto constexpr Reduce(T *target)
+{
+  return detail::Reducer<Op<T,T,T>, T, ValOp<T, Op>>(target);
+}
+
+// User-defined ValLoc case.
+template <template <typename, typename, typename> class Op, typename T, typename IndexType>
+auto constexpr Reduce(ValLoc<T, IndexType> *target)
+{
+  using VL = ValLoc<T,IndexType>;
+  return detail::Reducer<Op<VL,VL,VL>, VL, ValOp<ValLoc<T, IndexType>, Op>>(target);
+}
+
+// Dual input use case where reduction value and location are separate, non-ValLoc types supplied by the user.
+template <template <typename, typename, typename> class Op, typename T, typename IndexType>
+auto constexpr ReduceLoc(T *target, IndexType *index)
 {
-  return detail::ReducerLoc<Op<T, T, T>, T>(target);
+  using VL = ValLoc<T,IndexType>;
+  return detail::Reducer<Op<VL,VL,VL>, VL, ValOp<ValLoc<T, IndexType>, Op>>(target, index);
 }
+
 } // namespace expt
 
 
diff --git a/include/RAJA/policy/cuda/params/reduce.hpp b/include/RAJA/policy/cuda/params/reduce.hpp
index a2e734b1eb..6ab3372aaa 100644
--- a/include/RAJA/policy/cuda/params/reduce.hpp
+++ b/include/RAJA/policy/cuda/params/reduce.hpp
@@ -8,14 +8,16 @@
 #include "RAJA/policy/cuda/reduce.hpp"
 #include "RAJA/pattern/params/reducer.hpp"
 
+#include "RAJA/policy/cuda/policy.hpp"
+
 namespace RAJA {
 namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  init(Reducer<OP, T>& red, RAJA::cuda::detail::cudaInfo& ci)
+  init(Reducer<OP, T, VOp>& red, RAJA::cuda::detail::cudaInfo& ci)
   {
     red.devicetarget = RAJA::cuda::pinned_mempool_type::getInstance().template malloc<T>(1);
     red.device_mem.allocate(ci.gridDim.x * ci.gridDim.y * ci.gridDim.z);
@@ -23,22 +25,26 @@ namespace detail {
   }
 
   // Combine
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   RAJA_HOST_DEVICE
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  combine(Reducer<OP, T>& red)
+  combine(Reducer<OP, T, VOp>& red)
   {
-    RAJA::cuda::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter>(red);
+    RAJA::cuda::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter, OP>(red.devicetarget,
+                                                                            red.getVal(),
+                                                                            red.device_mem,
+                                                                            red.device_count);
   }
 
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_cuda_policy<EXEC_POL> >
-  resolve(Reducer<OP, T>& red, RAJA::cuda::detail::cudaInfo& ci)
+  resolve(Reducer<OP, T, VOp>& red, RAJA::cuda::detail::cudaInfo& ci)
   {
     // complete reduction
     ci.res.wait();
-    *red.target = OP{}(*red.target, *red.devicetarget);
+
+    red.combineTarget(*red.devicetarget);
 
     // free memory
     RAJA::cuda::device_zeroed_mempool_type::getInstance().free(red.device_count);
diff --git a/include/RAJA/policy/cuda/reduce.hpp b/include/RAJA/policy/cuda/reduce.hpp
index 8d55698af8..2b13417531 100644
--- a/include/RAJA/policy/cuda/reduce.hpp
+++ b/include/RAJA/policy/cuda/reduce.hpp
@@ -275,7 +275,10 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
 
 
 template <typename GlobalIterationGetter, typename OP, typename T>
-RAJA_DEVICE RAJA_INLINE void grid_reduce(RAJA::expt::detail::Reducer<OP, T>& red)
+RAJA_DEVICE RAJA_INLINE void grid_reduce( T * device_target,
+                                          T val,
+                                          RAJA::detail::SoAPtr<T,RAJA::cuda::device_mempool_type> device_mem,
+                                          unsigned int* device_count)
 {
   using BlockIterationGetter = typename get_index_block<GlobalIterationGetter>::type;
   using ThreadIterationGetter = typename get_index_thread<GlobalIterationGetter>::type;
@@ -287,16 +290,16 @@ RAJA_DEVICE RAJA_INLINE void grid_reduce(RAJA::expt::detail::Reducer<OP, T>& red
   const int blockId = BlockIterationGetter::index();
   const int threadId = ThreadIterationGetter::index();
 
-  T temp = block_reduce<ThreadIterationGetter, OP>(red.val, OP::identity());
+  T temp = block_reduce<ThreadIterationGetter, OP>(val, OP::identity());
 
   // one thread per block writes to device_mem
   bool lastBlock = false;
   if (threadId == 0) {
-    red.device_mem.set(blockId, temp);
+    device_mem.set(blockId, temp);
     // ensure write visible to all threadblocks
     __threadfence();
     // increment counter, (wraps back to zero if old count == wrap_around)
-    unsigned int old_count = ::atomicInc(red.device_count, wrap_around);
+    unsigned int old_count = ::atomicInc(device_count, wrap_around);
     lastBlock = (old_count == wrap_around);
   }
 
@@ -309,14 +312,14 @@ RAJA_DEVICE RAJA_INLINE void grid_reduce(RAJA::expt::detail::Reducer<OP, T>& red
     __threadfence();
 
     for (int i = threadId; i < numBlocks; i += numThreads) {
-      temp = OP{}(temp, red.device_mem.get(i));
+      temp = OP{}(temp, device_mem.get(i));
     }
 
     temp = block_reduce<ThreadIterationGetter, OP>(temp, OP::identity());
 
     // one thread returns value
     if (threadId == 0) {
-      *(red.devicetarget) = temp;
+      *device_target = temp;
     }
   }
 }
diff --git a/include/RAJA/policy/hip/params/reduce.hpp b/include/RAJA/policy/hip/params/reduce.hpp
index 584d049c5b..a3da07ee2c 100644
--- a/include/RAJA/policy/hip/params/reduce.hpp
+++ b/include/RAJA/policy/hip/params/reduce.hpp
@@ -13,9 +13,9 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  init(Reducer<OP, T>& red, RAJA::hip::detail::hipInfo& hi)
+  init(Reducer<OP, T, VOp>& red, RAJA::hip::detail::hipInfo& hi)
   {
     red.devicetarget = RAJA::hip::pinned_mempool_type::getInstance().template malloc<T>(1);
     red.device_mem.allocate(hi.gridDim.x * hi.gridDim.y * hi.gridDim.z);
@@ -23,22 +23,26 @@ namespace detail {
   }
 
   // Combine
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   RAJA_HOST_DEVICE
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  combine(Reducer<OP, T>& red)
+  combine(Reducer<OP, T, VOp>& red)
   {
-    RAJA::hip::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter>(red);
+    RAJA::hip::impl::expt::grid_reduce<typename EXEC_POL::IterationGetter,OP>( red.devicetarget,
+                                                                            red.getVal(),
+                                                                            red.device_mem,
+                                                                            red.device_count);
   }
 
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_hip_policy<EXEC_POL> >
-  resolve(Reducer<OP, T>& red, RAJA::hip::detail::hipInfo& hi)
+  resolve(Reducer<OP, T, VOp>& red, RAJA::hip::detail::hipInfo& hi)
   {
     // complete reduction
     hi.res.wait();
-    *red.target = OP{}(*red.target, *red.devicetarget);
+
+    red.combineTarget(*red.devicetarget);
 
     // free memory
     RAJA::hip::device_zeroed_mempool_type::getInstance().free(red.device_count);
diff --git a/include/RAJA/policy/hip/reduce.hpp b/include/RAJA/policy/hip/reduce.hpp
index e8e67029ef..c81adf8e24 100644
--- a/include/RAJA/policy/hip/reduce.hpp
+++ b/include/RAJA/policy/hip/reduce.hpp
@@ -269,7 +269,10 @@ RAJA_DEVICE RAJA_INLINE T block_reduce(T val, T identity)
 
 
 template <typename GlobalIterationGetter, typename OP, typename T>
-RAJA_DEVICE RAJA_INLINE void grid_reduce(RAJA::expt::detail::Reducer<OP, T>& red)
+RAJA_DEVICE RAJA_INLINE void grid_reduce( T * device_target,
+                                          T val,
+                                          RAJA::detail::SoAPtr<T,RAJA::hip::device_mempool_type> device_mem,
+                                          unsigned int * device_count)
 {
   using BlockIterationGetter = typename get_index_block<GlobalIterationGetter>::type;
   using ThreadIterationGetter = typename get_index_thread<GlobalIterationGetter>::type;
@@ -281,16 +284,16 @@ RAJA_DEVICE RAJA_INLINE void grid_reduce(RAJA::expt::detail::Reducer<OP, T>& red
   const int blockId = BlockIterationGetter::index();
   const int threadId = ThreadIterationGetter::index();
 
-  T temp = block_reduce<ThreadIterationGetter, OP>(red.val, OP::identity());
+  T temp = block_reduce<ThreadIterationGetter, OP>(val, OP::identity());
 
   // one thread per block writes to device_mem
   bool lastBlock = false;
   if (threadId == 0) {
-    red.device_mem.set(blockId, temp);
+    device_mem.set(blockId, temp);
     // ensure write visible to all threadblocks
     __threadfence();
     // increment counter, (wraps back to zero if old count == wrap_around)
-    unsigned int old_count = ::atomicInc(red.device_count, wrap_around);
+    unsigned int old_count = ::atomicInc(device_count, wrap_around);
     lastBlock = (old_count == wrap_around);
   }
 
@@ -303,14 +306,14 @@ RAJA_DEVICE RAJA_INLINE void grid_reduce(RAJA::expt::detail::Reducer<OP, T>& red
     __threadfence();
 
     for (int i = threadId; i < numBlocks; i += numThreads) {
-      temp = OP{}(temp, red.device_mem.get(i));
+      temp = OP{}(temp, device_mem.get(i));
     }
 
     temp = block_reduce<ThreadIterationGetter, OP>(temp, OP::identity());
 
     // one thread returns value
     if (threadId == 0) {
-      *(red.devicetarget) = temp;
+      *device_target = temp;
     }
   }
 }
diff --git a/include/RAJA/policy/openmp/params/reduce.hpp b/include/RAJA/policy/openmp/params/reduce.hpp
index ffa270b0f3..f71efc255a 100644
--- a/include/RAJA/policy/openmp/params/reduce.hpp
+++ b/include/RAJA/policy/openmp/params/reduce.hpp
@@ -10,24 +10,24 @@ namespace detail {
 #if defined(RAJA_ENABLE_OPENMP)
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  init(Reducer<OP, T>& red) {
-    red.val = OP::identity();
+  init(Reducer<OP, T, VOp>& red) {
+    red.m_valop.val = OP::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
-    out.val = OP{}(out.val, in.val);
+  combine(Reducer<OP, T, VOp>& out, const Reducer<OP, T, VOp>& in) {
+    out.m_valop.val = OP{}(out.m_valop.val, in.m_valop.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_openmp_policy<EXEC_POL> >
-  resolve(Reducer<OP, T>& red) {
-    *red.target = OP{}(*red.target, red.val);
+  resolve(Reducer<OP, T, VOp>& red) {
+    red.combineTarget(red.m_valop.val);
   }
 
 #endif
diff --git a/include/RAJA/policy/openmp_target/params/reduce.hpp b/include/RAJA/policy/openmp_target/params/reduce.hpp
index df5c6af235..6127eef226 100644
--- a/include/RAJA/policy/openmp_target/params/reduce.hpp
+++ b/include/RAJA/policy/openmp_target/params/reduce.hpp
@@ -10,24 +10,24 @@ namespace detail {
 #if defined(RAJA_ENABLE_TARGET_OPENMP)
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  init(Reducer<OP, T>& red) {
-    red.val = OP::identity();
+  init(Reducer<OP, T, VOp>& red) {
+    red.m_valop.val = OP::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
-    out.val = OP{}(out.val, in.val);
+  combine(Reducer<OP, T, VOp>& out, const Reducer<OP, T, VOp>& in) {
+    out.m_valop.val = OP{}(out.m_valop.val, in.m_valop.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_target_openmp_policy<EXEC_POL> >
-  resolve(Reducer<OP, T>& red) {
-    *red.target = OP{}(*red.target, red.val);
+  resolve(Reducer<OP, T, I, VOp>& red) {
+    red.combineTarget(red.m_valop.val);
   }
 
 #endif
diff --git a/include/RAJA/policy/sequential/params/reduce.hpp b/include/RAJA/policy/sequential/params/reduce.hpp
index 60f83c4079..b77028ca5f 100644
--- a/include/RAJA/policy/sequential/params/reduce.hpp
+++ b/include/RAJA/policy/sequential/params/reduce.hpp
@@ -8,22 +8,24 @@ namespace expt {
 namespace detail {
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  init(Reducer<OP, T>& red) {
-    red.val = OP::identity();
+  init(Reducer<OP, T, VOp>& red) {
+    red.m_valop.val = OP::identity();
   }
+
   // Combine
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
-    out.val = OP{}(out.val, in.val);
+  combine(Reducer<OP, T, VOp>& out, const Reducer<OP, T, VOp>& in) {
+    out.m_valop.val = OP{}(out.m_valop.val, in.m_valop.val);
   }
+
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< std::is_same< EXEC_POL, RAJA::seq_exec> >
-  resolve(Reducer<OP, T>& red) {
-    *red.target = OP{}(*red.target, red.val);
+  resolve(Reducer<OP, T, VOp>& red) {
+    red.combineTarget(red.m_valop.val);
   }
 
 } //  namespace detail
diff --git a/include/RAJA/policy/sycl/params/reduce.hpp b/include/RAJA/policy/sycl/params/reduce.hpp
index a1afbe5835..e2fb7e1a5a 100644
--- a/include/RAJA/policy/sycl/params/reduce.hpp
+++ b/include/RAJA/policy/sycl/params/reduce.hpp
@@ -10,25 +10,24 @@ namespace detail {
 #if defined(RAJA_ENABLE_SYCL)
 
   // Init
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  init(Reducer<OP, T>& red) {
-    red.val = OP::identity();
+  init(Reducer<OP, T, VOp>& red) {
+    red.m_valop.val = OP::identity();
   }
 
   // Combine
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  SYCL_EXTERNAL
-  combine(Reducer<OP, T>& out, const Reducer<OP, T>& in) {
-    out.val = OP{}(out.val, in.val);
+  combine(Reducer<OP, T, VOp>& out, const Reducer<OP, T, VOp>& in) {
+    out.m_valop.val = OP{}(out.m_valop.val, in.m_valop.val);
   }
 
   // Resolve
-  template<typename EXEC_POL, typename OP, typename T>
+  template<typename EXEC_POL, typename OP, typename T, typename VOp>
   camp::concepts::enable_if< type_traits::is_sycl_policy<EXEC_POL> >
-  resolve(Reducer<OP, T>& red) {
-    *red.target = OP{}(*red.target, red.val);
+  resolve(Reducer<OP, T, VOp>& red) {
+    red.combineTarget(red.m_valop.val);
   }
 
 #endif
diff --git a/include/RAJA/util/SoAPtr.hpp b/include/RAJA/util/SoAPtr.hpp
index 47802d8f0a..6adea65b80 100644
--- a/include/RAJA/util/SoAPtr.hpp
+++ b/include/RAJA/util/SoAPtr.hpp
@@ -26,6 +26,9 @@
 #include "RAJA/pattern/detail/reduce.hpp"
 #include "RAJA/util/types.hpp"
 
+// for RAJA::expt::ValLoc
+#include "RAJA/pattern/params/params_base.hpp"
+
 namespace RAJA
 {
 
@@ -165,6 +168,77 @@ class SoAPtr<RAJA::reduce::detail::ValueLoc<T, IndexType, doing_min>, mempool, a
   second_type* mem_idx = nullptr;
 };
 
+/*!
+ * @brief Specialization for RAJA::expt::ValLoc.
+ */
+template <typename T, typename IndexType, typename mempool, typename accessor>
+class SoAPtr<RAJA::expt::ValLoc<T, IndexType>, mempool, accessor>
+{
+  using first_type = T;
+  using second_type = IndexType;
+
+  template < typename, typename, typename >
+  friend class SoAPtr; // friend other instantiations of this class
+
+public:
+  using value_type = RAJA::expt::ValLoc<T, IndexType>;
+
+  template < typename rhs_accessor >
+  using rebind_accessor = SoAPtr<value_type, mempool, rhs_accessor>;
+
+  SoAPtr() = default;
+  SoAPtr(SoAPtr const&) = default;
+  SoAPtr(SoAPtr &&) = default;
+  SoAPtr& operator=(SoAPtr const&) = default;
+  SoAPtr& operator=(SoAPtr &&) = default;
+
+  explicit SoAPtr(size_t size)
+      : mem(mempool::getInstance().template malloc<first_type>(size)),
+        mem_idx(mempool::getInstance().template malloc<second_type>(size))
+  {
+  }
+
+  template < typename rhs_accessor,
+             std::enable_if_t<!std::is_same<accessor, rhs_accessor>::value>* = nullptr >
+  RAJA_HOST_DEVICE
+  explicit SoAPtr(SoAPtr<value_type, mempool, rhs_accessor> const& rhs)
+    : mem(rhs.mem)
+    , mem_idx(rhs.mem_idx)
+  { }
+
+  SoAPtr& allocate(size_t size)
+  {
+    mem = mempool::getInstance().template malloc<first_type>(size);
+    mem_idx = mempool::getInstance().template malloc<second_type>(size);
+    return *this;
+  }
+
+  SoAPtr& deallocate()
+  {
+    mempool::getInstance().free(mem);
+    mem = nullptr;
+    mempool::getInstance().free(mem_idx);
+    mem_idx = nullptr;
+    return *this;
+  }
+
+  RAJA_HOST_DEVICE bool allocated() const { return mem != nullptr; }
+
+  RAJA_HOST_DEVICE value_type get(size_t i) const
+  {
+    return value_type(accessor::get(mem, i), accessor::get(mem_idx, i));
+  }
+  RAJA_HOST_DEVICE void set(size_t i, value_type val)
+  {
+    accessor::set(mem, i, val.getVal());
+    accessor::set(mem_idx, i, val.getLoc());
+  }
+
+private:
+  first_type* mem = nullptr;
+  second_type* mem_idx = nullptr;
+};
+
 }  // namespace detail
 
 }  // namespace RAJA
diff --git a/scripts/lc-builds/corona_sycl.sh b/scripts/lc-builds/corona_sycl.sh
index 4828d7dce4..815928e434 100755
--- a/scripts/lc-builds/corona_sycl.sh
+++ b/scripts/lc-builds/corona_sycl.sh
@@ -69,9 +69,6 @@ echo "   1) Load the ROCm module version matching the version in the compiler pa
 echo "      you passed to this script."
 echo
 echo "   2) Prefix the LD_LIBRARY_PATH environment variable with "
-echo "        SYCL_PATH/lib:SYCL_PATH/lib64"
-echo
-echo "      where SYCL_PATH is set to the compiler installation path you passed"
-echo "      to this script (using the proper command for your shell)."
+echo "        ${SYCL_PATH}/lib:${SYCL_PATH}/lib64"
 echo
 echo "***********************************************************************"
diff --git a/test/functional/forall/reduce-basic/CMakeLists.txt b/test/functional/forall/reduce-basic/CMakeLists.txt
index 42f03f04c8..de6ce12264 100644
--- a/test/functional/forall/reduce-basic/CMakeLists.txt
+++ b/test/functional/forall/reduce-basic/CMakeLists.txt
@@ -8,7 +8,7 @@
 #
 # List of experimental reduction types for generating test files.
 #
-set(REDUCETYPES ReduceSum ReduceMin ReduceMax ReduceMaxLoc ReduceMinLoc)
+set(REDUCETYPES ReduceSum ReduceMin ReduceMax ReduceMaxLoc ReduceMinLoc ReduceMaxLocAlt ReduceMinLocAlt)
 
 set(DATATYPES CoreReductionDataTypeList)
 
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitAnd.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitAnd.hpp
index b1524827e0..c64106fc59 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitAnd.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitAnd.hpp
@@ -20,6 +20,8 @@ void ForallReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
                                      const std::vector<IDX_TYPE>& seg_idx,
                                      camp::resources::Resource working_res)
 {
+  using REF_BITAND = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::bit_and>;
+
   IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
   IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
 
@@ -41,13 +43,15 @@ void ForallReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
   }
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  RAJA::ReduceBitAnd<REDUCE_POLICY, DATA_TYPE> simpand(21);
+  DATA_TYPE simpand(21);
 
-  RAJA::forall<EXEC_POLICY>(seg, [=] RAJA_HOST_DEVICE(IDX_TYPE idx) {
-    simpand &= working_array[idx];
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::Reduce<RAJA::operators::bit_and>(&simpand),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITAND & _simpand) {
+      _simpand &= working_array[idx];
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(simpand.get()), 5);
+  ASSERT_EQ(static_cast<DATA_TYPE>(simpand), 5);
 
 
   //
@@ -73,7 +77,7 @@ void ForallReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
     RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand),
     RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand2),
     RAJA::expt::KernelName("RAJA Reduce BitAnd"),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &r1, DATA_TYPE &r2) {
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITAND &r1, REF_BITAND &r2) {
       r1 &= working_array[idx];
       r2 &= working_array[idx];
   });
@@ -87,7 +91,7 @@ void ForallReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
   for (int j = 0; j < nloops; ++j) {
     RAJA::forall<EXEC_POLICY>(seg,
       RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand),
-      [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &r1) {
+      [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITAND &r1) {
         r1 &= working_array[idx];
     });
   }
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitOr.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitOr.hpp
index 6e83c14e95..8c3ea14c4d 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitOr.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceBitOr.hpp
@@ -20,6 +20,8 @@ void ForallReduceBitOrBasicTestImpl(const SEG_TYPE& seg,
                                      const std::vector<IDX_TYPE>& seg_idx,
                                      camp::resources::Resource working_res)
 {
+  using REF_BITOR = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::bit_or>;
+
   IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
   IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
 
@@ -41,13 +43,15 @@ void ForallReduceBitOrBasicTestImpl(const SEG_TYPE& seg,
   }
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  RAJA::ReduceBitOr<REDUCE_POLICY, DATA_TYPE> simpor(5);
+  DATA_TYPE simpor(5);
 
-  RAJA::forall<EXEC_POLICY>(seg, [=] RAJA_HOST_DEVICE(IDX_TYPE idx) {
-    simpor |= working_array[idx];
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::Reduce<RAJA::operators::bit_or>(&simpor),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITOR & _simpor) {
+      _simpor |= working_array[idx];
   });
 
-  ASSERT_EQ(static_cast<DATA_TYPE>(simpor.get()), 13);
+  ASSERT_EQ(static_cast<DATA_TYPE>(simpor), 13);
 
  
   //
@@ -73,7 +77,7 @@ void ForallReduceBitOrBasicTestImpl(const SEG_TYPE& seg,
     RAJA::expt::Reduce<RAJA::operators::bit_or>(&redor),
     RAJA::expt::Reduce<RAJA::operators::bit_or>(&redor2),
     RAJA::expt::KernelName("RAJA Reduce BitOr"),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &r1, DATA_TYPE &r2) {
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITOR &r1, REF_BITOR &r2) {
       r1 |= working_array[idx];
       r2 |= working_array[idx];
   });
@@ -87,7 +91,7 @@ void ForallReduceBitOrBasicTestImpl(const SEG_TYPE& seg,
   for (int j = 0; j < nloops; ++j) {
     RAJA::forall<EXEC_POLICY>(seg,
       RAJA::expt::Reduce<RAJA::operators::bit_or>(&redor),
-      [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &r1) {
+      [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_BITOR &r1) {
         r1 |= working_array[idx];
     });
   }
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMax.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMax.hpp
index 75b9fce4e3..773c737a85 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMax.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMax.hpp
@@ -20,6 +20,8 @@ void ForallReduceMaxBasicTestImpl(const SEG_TYPE& seg,
                                   const std::vector<IDX_TYPE>& seg_idx,
                                   camp::resources::Resource working_res)
 {
+  using REF_MAX = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::maximum>;
+
   IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
   IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
  
@@ -48,16 +50,16 @@ void ForallReduceMaxBasicTestImpl(const SEG_TYPE& seg,
 
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  DATA_TYPE maxinit = big_max;
+  DATA_TYPE maxinit(big_max);
   DATA_TYPE max(max_init);
 
   RAJA::forall<EXEC_POLICY>(seg, 
     RAJA::expt::Reduce<RAJA::operators::maximum>(&maxinit),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
     RAJA::expt::KernelName("RAJA Reduce Max"),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &mi, DATA_TYPE &m) {
-      mi = RAJA_MAX(working_array[idx], mi);
-      m  = RAJA_MAX(working_array[idx], m);
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MAX &mi, REF_MAX &m) {
+      mi.max(working_array[idx]);
+      m.max(working_array[idx]);
   });
 
   ASSERT_EQ(static_cast<DATA_TYPE>(maxinit), big_max);
@@ -69,16 +71,16 @@ void ForallReduceMaxBasicTestImpl(const SEG_TYPE& seg,
   DATA_TYPE factor = 2;
   RAJA::forall<EXEC_POLICY>(seg, 
     RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &m) {
-      m = RAJA_MAX(working_array[idx] * factor, m);
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MAX &m) {
+      m.max(working_array[idx] * factor);
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(max), ref_max * factor);
    
   factor = 3;
   RAJA::forall<EXEC_POLICY>(seg, 
     RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &m) {
-      m = RAJA_MAX(working_array[idx] * factor, m);
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MAX &m) {
+      m.max(working_array[idx] * factor);
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(max), ref_max * factor);
    
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
index fbea0e034c..225018eac8 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLoc.hpp
@@ -57,7 +57,8 @@ void ForallReduceMaxLocBasicTestImpl(const SEG_TYPE& seg,
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
 
-  using VL_TYPE = RAJA::expt::ValLoc<DATA_TYPE>;
+  using VL_TYPE = RAJA::expt::ValLoc<DATA_TYPE, IDX_TYPE>;
+  using VL_LAMBDA_TYPE = RAJA::expt::ValLocOp<DATA_TYPE, IDX_TYPE, RAJA::operators::maximum>;
   VL_TYPE maxinit(big_max, maxloc_init);
   VL_TYPE max(max_init, maxloc_init);
 
@@ -65,9 +66,9 @@ void ForallReduceMaxLocBasicTestImpl(const SEG_TYPE& seg,
     RAJA::expt::Reduce<RAJA::operators::maximum>(&maxinit),
     RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
     RAJA::expt::KernelName("RAJA Reduce MaxLoc"),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &mi, VL_TYPE &m) {
-      mi.max( working_array[idx], idx );
-      m.max( working_array[idx], idx );
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &mi, VL_LAMBDA_TYPE &m) {
+      mi.maxloc( working_array[idx], idx );
+      m.maxloc( working_array[idx], idx );
   });
 
   ASSERT_EQ(static_cast<DATA_TYPE>(maxinit.getVal()), big_max);
@@ -75,28 +76,18 @@ void ForallReduceMaxLocBasicTestImpl(const SEG_TYPE& seg,
   ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), ref_max);
   ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), ref_maxloc);
 
-  max = VL_TYPE(max_init, maxloc_init);
+  max.set(max_init, maxloc_init);
   ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), max_init);
   ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), maxloc_init);
 
   DATA_TYPE factor = 2;
   RAJA::forall<EXEC_POLICY>(seg,
     RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &m) {
-      m.max( working_array[idx] * factor, idx);
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
+      m.maxloc( working_array[idx] * factor, idx);
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), ref_max * factor);
   ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), ref_maxloc);
-  
-  factor = 3;
-  RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &m) {
-      m.max( working_array[idx] * factor, idx);
-  });
-  ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), ref_max * factor);
-  ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), ref_maxloc);
- 
 
   deallocateForallTestData<DATA_TYPE>(working_res,
                                       working_array,
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLocAlt.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLocAlt.hpp
new file mode 100644
index 0000000000..68810ac893
--- /dev/null
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMaxLocAlt.hpp
@@ -0,0 +1,199 @@
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
+// Copyright (c) 2016-24, Lawrence Livermore National Security, LLC
+// and RAJA project contributors. See the RAJA/LICENSE file for details.
+//
+// SPDX-License-Identifier: (BSD-3-Clause)
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
+
+#ifndef __TEST_FORALL_BASIC_REDUCEMAXLOCALT_HPP__
+#define __TEST_FORALL_BASIC_REDUCEMAXLOCALT_HPP__
+
+#include <cstdlib>
+#include <ctime>
+#include <numeric>
+#include <vector>
+
+template <typename IDX_TYPE, typename DATA_TYPE,
+          typename SEG_TYPE,
+          typename EXEC_POLICY, typename REDUCE_POLICY>
+void ForallReduceMaxLocAltBasicTestImpl(const SEG_TYPE& seg,
+                                     const std::vector<IDX_TYPE>& seg_idx,
+                                     camp::resources::Resource working_res)
+{
+  IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
+  IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
+
+  DATA_TYPE* working_array;
+  DATA_TYPE* check_array;
+  DATA_TYPE* test_array;
+
+  allocateForallTestData<DATA_TYPE>(data_len,
+                                    working_res,
+                                    &working_array,
+                                    &check_array,
+                                    &test_array);
+
+  const int modval = 100;
+  const DATA_TYPE max_init = -modval;
+  const IDX_TYPE maxloc_init = -1;
+  const IDX_TYPE maxloc_idx = seg_idx[ idx_len * 2/3 ];
+  const DATA_TYPE big_max = modval*10;
+  const IDX_TYPE big_maxloc = maxloc_init;
+
+  for (IDX_TYPE i = 0; i < data_len; ++i) {
+    test_array[i] = static_cast<DATA_TYPE>( 1000 % modval );
+  }
+  test_array[maxloc_idx] = static_cast<DATA_TYPE>(big_max);
+
+  DATA_TYPE ref_max = max_init;
+  IDX_TYPE ref_maxloc = maxloc_init;
+  for (IDX_TYPE i = 0; i < idx_len; ++i) {
+    if ( test_array[ seg_idx[i] ] > ref_max ) {
+       ref_max = test_array[ seg_idx[i] ];
+       ref_maxloc = seg_idx[i];
+    } 
+  }
+
+  working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
+
+
+  using VL_TYPE = RAJA::expt::ValLoc<DATA_TYPE, IDX_TYPE>;
+  using VL_LAMBDA_TYPE = RAJA::expt::ValLocOp<DATA_TYPE, IDX_TYPE, RAJA::operators::maximum>;
+  VL_TYPE maxinit(big_max, maxloc_init);
+  VL_TYPE max(max_init, maxloc_init);
+
+  RAJA::forall<EXEC_POLICY>(seg, 
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&maxinit),
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&max),
+    RAJA::expt::KernelName("RAJA Reduce MaxLoc"),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &mi, VL_LAMBDA_TYPE &m) {
+      mi.maxloc( working_array[idx], idx );
+      m.maxloc( working_array[idx], idx );
+  });
+
+  ASSERT_EQ(static_cast<DATA_TYPE>(maxinit.getVal()), big_max);
+  ASSERT_EQ(static_cast<IDX_TYPE>(maxinit.getLoc()), big_maxloc);
+  ASSERT_EQ(static_cast<DATA_TYPE>(max.getVal()), ref_max);
+  ASSERT_EQ(static_cast<IDX_TYPE>(max.getLoc()), ref_maxloc);
+
+  VL_TYPE max2(max_init, maxloc_init);
+
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::Reduce<RAJA::operators::maximum>(&max2),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE &m2) {
+      m2.max( max );
+  });
+  ASSERT_EQ(static_cast<DATA_TYPE>(max2.getVal()), static_cast<DATA_TYPE>(max.getVal()));
+  ASSERT_EQ(static_cast<IDX_TYPE>(max2.getLoc()), static_cast<IDX_TYPE>(max.getLoc()));
+
+  DATA_TYPE s_max = max_init;
+  IDX_TYPE s_maxloc = maxloc_init;
+
+  const int factor = 4;
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&s_max, &s_maxloc),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
+      m.maxloc( working_array[idx] * factor, idx);
+  });
+  ASSERT_EQ(static_cast<DATA_TYPE>(s_max), ref_max * factor);
+  ASSERT_EQ(static_cast<IDX_TYPE>(s_maxloc), ref_maxloc);
+
+  DATA_TYPE s_max2 = max_init;
+  IDX_TYPE s_maxloc2 = maxloc_init;
+
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::ReduceLoc<RAJA::operators::maximum>(&s_max2, &s_maxloc2),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE &m2) {
+      m2.max(max2);
+  });
+  ASSERT_EQ(static_cast<DATA_TYPE>(s_max2), static_cast<DATA_TYPE>(max2.getVal()));
+  ASSERT_EQ(static_cast<IDX_TYPE>(s_maxloc2), static_cast<IDX_TYPE>(max2.getLoc()));
+
+
+  deallocateForallTestData<DATA_TYPE>(working_res,
+                                      working_array,
+                                      check_array,
+                                      test_array);
+}
+
+TYPED_TEST_SUITE_P(ForallReduceMaxLocAltBasicTest);
+template <typename T>
+class ForallReduceMaxLocAltBasicTest : public ::testing::Test
+{
+};
+
+TYPED_TEST_P(ForallReduceMaxLocAltBasicTest, ReduceMaxLocAltBasicForall)
+{
+  using IDX_TYPE      = typename camp::at<TypeParam, camp::num<0>>::type;
+  using DATA_TYPE     = typename camp::at<TypeParam, camp::num<1>>::type;
+  using WORKING_RES   = typename camp::at<TypeParam, camp::num<2>>::type;
+  using EXEC_POLICY   = typename camp::at<TypeParam, camp::num<3>>::type;
+  using REDUCE_POLICY = typename camp::at<TypeParam, camp::num<4>>::type;
+
+  camp::resources::Resource working_res{WORKING_RES::get_default()};
+
+  std::vector<IDX_TYPE> seg_idx;
+
+// Range segment tests
+  RAJA::TypedRangeSegment<IDX_TYPE> r1( 0, 28 );
+  RAJA::getIndices(seg_idx, r1);
+  ForallReduceMaxLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r1, seg_idx, working_res);
+
+  seg_idx.clear();
+  RAJA::TypedRangeSegment<IDX_TYPE> r2( 3, 642 );
+  RAJA::getIndices(seg_idx, r2);
+  ForallReduceMaxLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r2, seg_idx, working_res);
+
+  seg_idx.clear();
+  RAJA::TypedRangeSegment<IDX_TYPE> r3( 0, 2057 );
+  RAJA::getIndices(seg_idx, r3);
+  ForallReduceMaxLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r3, seg_idx, working_res);
+
+// Range-stride segment tests
+  seg_idx.clear();
+  RAJA::TypedRangeStrideSegment<IDX_TYPE> r4( 0, 188, 2 );
+  RAJA::getIndices(seg_idx, r4);
+  ForallReduceMaxLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeStrideSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r4, seg_idx, working_res);
+
+  seg_idx.clear();
+  RAJA::TypedRangeStrideSegment<IDX_TYPE> r5( 3, 1029, 3 );
+  RAJA::getIndices(seg_idx, r5);
+  ForallReduceMaxLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeStrideSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r5, seg_idx, working_res);
+
+// List segment tests
+  seg_idx.clear();
+  IDX_TYPE last = 10567;
+  srand( time(NULL) );
+  for (IDX_TYPE i = 0; i < last; ++i) {
+    IDX_TYPE randval = IDX_TYPE( rand() % RAJA::stripIndexType(last) );
+    if ( i < randval ) {
+      seg_idx.push_back(i);
+    }
+  }
+  RAJA::TypedListSegment<IDX_TYPE> l1( &seg_idx[0], seg_idx.size(),
+                                       working_res );
+  ForallReduceMaxLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedListSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    l1, seg_idx, working_res);
+}
+
+REGISTER_TYPED_TEST_SUITE_P(ForallReduceMaxLocAltBasicTest,
+                            ReduceMaxLocAltBasicForall);
+
+#endif  // __TEST_FORALL_BASIC_REDUCEMAXLOCALT_HPP__
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMin.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMin.hpp
index 78d9e0368c..9aab696301 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMin.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMin.hpp
@@ -20,6 +20,8 @@ void ForallReduceMinBasicTestImpl(const SEG_TYPE& seg,
                                   const std::vector<IDX_TYPE>& seg_idx,
                                   camp::resources::Resource working_res)
 {
+  using REF_MIN = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::minimum>;
+
   IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
   IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
 
@@ -48,16 +50,16 @@ void ForallReduceMinBasicTestImpl(const SEG_TYPE& seg,
 
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  DATA_TYPE mininit = small_min;
+  DATA_TYPE mininit(small_min);
   DATA_TYPE min(min_init);
 
   RAJA::forall<EXEC_POLICY>(seg, 
     RAJA::expt::Reduce<RAJA::operators::minimum>(&mininit),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
     RAJA::expt::KernelName("RAJA Reduce Min"),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &mi, DATA_TYPE &m) {
-      mi = RAJA_MIN(working_array[idx], mi);
-      m  = RAJA_MIN(working_array[idx], m);
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MIN &mi, REF_MIN &m) {
+      mi.min(working_array[idx]);
+      m.min(working_array[idx]);
   });
 
   ASSERT_EQ(static_cast<DATA_TYPE>(mininit), small_min);
@@ -69,16 +71,16 @@ void ForallReduceMinBasicTestImpl(const SEG_TYPE& seg,
   DATA_TYPE factor = 3; 
   RAJA::forall<EXEC_POLICY>(seg, 
     RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &m) {
-      m = RAJA_MIN(working_array[idx] * factor, m);
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MIN &m) {
+      m.min(working_array[idx] * factor);
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(min), ref_min * factor);
 
   factor = 2;
   RAJA::forall<EXEC_POLICY>(seg, 
     RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &m) {
-      m = RAJA_MIN(working_array[idx] * factor, m);
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_MIN &m) {
+      m.min(working_array[idx] * factor);
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(min), ref_min * factor);
 
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
index c0996f24c1..dc48b403ea 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLoc.hpp
@@ -56,8 +56,8 @@ void ForallReduceMinLocBasicTestImpl(const SEG_TYPE& seg,
 
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-
-  using VL_TYPE = RAJA::expt::ValLoc<DATA_TYPE>;
+  using VL_TYPE = RAJA::expt::ValLoc<DATA_TYPE, IDX_TYPE>;
+  using VL_LAMBDA_TYPE = RAJA::expt::ValLocOp<DATA_TYPE, IDX_TYPE, RAJA::operators::minimum>;
   VL_TYPE mininit(small_min, minloc_init);
   VL_TYPE min(min_init, minloc_init);
 
@@ -65,9 +65,9 @@ void ForallReduceMinLocBasicTestImpl(const SEG_TYPE& seg,
     RAJA::expt::Reduce<RAJA::operators::minimum>(&mininit),
     RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
     RAJA::expt::KernelName("RAJA Reduce MinLoc"),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &mi, VL_TYPE &m) {
-      mi.min( working_array[idx], idx );
-      m.min( working_array[idx], idx );
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &mi, VL_LAMBDA_TYPE &m) {
+      mi.minloc( working_array[idx], idx );
+      m.minloc( working_array[idx], idx );
   });
 
   ASSERT_EQ(static_cast<DATA_TYPE>(mininit.getVal()), small_min);
@@ -75,28 +75,18 @@ void ForallReduceMinLocBasicTestImpl(const SEG_TYPE& seg,
   ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), ref_min);
   ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), ref_minloc);
 
-  min = VL_TYPE(min_init, minloc_init);
+  min.set(min_init, minloc_init);
   ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), min_init);
   ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), minloc_init);
 
   DATA_TYPE factor = 2;
   RAJA::forall<EXEC_POLICY>(seg,
     RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &m) {
-      m.min( working_array[idx] * factor, idx);
-  });
-  ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), ref_min * factor);
-  ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), ref_minloc);
-
-  factor = 3;
-  RAJA::forall<EXEC_POLICY>(seg,
-    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_TYPE &m) {
-      m.min( working_array[idx] * factor, idx);
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
+      m.minloc( working_array[idx] * factor, idx);
   });
   ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), ref_min * factor);
   ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), ref_minloc);
-   
 
   deallocateForallTestData<DATA_TYPE>(working_res,
                                       working_array,
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLocAlt.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLocAlt.hpp
new file mode 100644
index 0000000000..07a6058234
--- /dev/null
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceMinLocAlt.hpp
@@ -0,0 +1,198 @@
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
+// Copyright (c) 2016-24, Lawrence Livermore National Security, LLC
+// and RAJA project contributors. See the RAJA/LICENSE file for details.
+//
+// SPDX-License-Identifier: (BSD-3-Clause)
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
+
+#ifndef __TEST_FORALL_BASIC_REDUCEMINLOCALT_HPP__
+#define __TEST_FORALL_BASIC_REDUCEMINLOCALT_HPP__
+
+#include <cstdlib>
+#include <ctime>
+#include <numeric>
+#include <vector>
+
+template <typename IDX_TYPE, typename DATA_TYPE,
+          typename SEG_TYPE,
+          typename EXEC_POLICY, typename REDUCE_POLICY>
+void ForallReduceMinLocAltBasicTestImpl(const SEG_TYPE& seg,
+                                     const std::vector<IDX_TYPE>& seg_idx,
+                                     camp::resources::Resource working_res)
+{
+  IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
+  IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
+
+  DATA_TYPE* working_array;
+  DATA_TYPE* check_array;
+  DATA_TYPE* test_array;
+
+  allocateForallTestData<DATA_TYPE>(data_len,
+                                    working_res,
+                                    &working_array,
+                                    &check_array,
+                                    &test_array);
+
+  const int modval = 100;
+  const DATA_TYPE min_init = modval+1;
+  const IDX_TYPE minloc_init = -1;
+  const IDX_TYPE minloc_idx = seg_idx[ idx_len * 2/3 ];
+  const DATA_TYPE small_min = -modval;
+  const IDX_TYPE small_minloc = minloc_init;
+
+  for (IDX_TYPE i = 0; i < data_len; ++i) {
+    test_array[i] = static_cast<DATA_TYPE>( rand() % modval );
+  }
+  test_array[minloc_idx] = static_cast<DATA_TYPE>(small_min);
+
+  DATA_TYPE ref_min = min_init;
+  IDX_TYPE ref_minloc = minloc_init;
+  for (IDX_TYPE i = 0; i < idx_len; ++i) {
+    if ( test_array[ seg_idx[i] ] < ref_min ) {
+       ref_min = test_array[ seg_idx[i] ];
+       ref_minloc = seg_idx[i];
+    } 
+  }
+
+  working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
+
+  using VL_TYPE = RAJA::expt::ValLoc<DATA_TYPE, IDX_TYPE>;
+  using VL_LAMBDA_TYPE = RAJA::expt::ValLocOp<DATA_TYPE, IDX_TYPE, RAJA::operators::minimum>;
+  VL_TYPE mininit(small_min, minloc_init);
+  VL_TYPE min(min_init, minloc_init);
+
+  RAJA::forall<EXEC_POLICY>(seg, 
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&mininit),
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
+    RAJA::expt::KernelName("RAJA Reduce MinLoc"),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &mi, VL_LAMBDA_TYPE &m) {
+      mi.minloc( working_array[idx], idx );
+      m.minloc( working_array[idx], idx );
+  });
+
+  ASSERT_EQ(static_cast<DATA_TYPE>(mininit.getVal()), small_min);
+  ASSERT_EQ(static_cast<IDX_TYPE>(mininit.getLoc()), small_minloc);
+  ASSERT_EQ(static_cast<DATA_TYPE>(min.getVal()), ref_min);
+  ASSERT_EQ(static_cast<IDX_TYPE>(min.getLoc()), ref_minloc);
+
+  VL_TYPE min2(min_init, minloc_init);
+
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::Reduce<RAJA::operators::minimum>(&min2),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE &m2) {
+      m2.min( min );
+  });
+  ASSERT_EQ(static_cast<DATA_TYPE>(min2.getVal()), static_cast<DATA_TYPE>(min.getVal()));
+  ASSERT_EQ(static_cast<IDX_TYPE>(min2.getLoc()), static_cast<IDX_TYPE>(min.getLoc()));
+
+  DATA_TYPE s_min = min_init;
+  IDX_TYPE s_minloc = minloc_init;
+
+  const int factor = 4;
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&s_min, &s_minloc),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, VL_LAMBDA_TYPE &m) {
+      m.minloc( working_array[idx] * factor, idx);
+  });
+  ASSERT_EQ(static_cast<DATA_TYPE>(s_min), ref_min * factor);
+  ASSERT_EQ(static_cast<IDX_TYPE>(s_minloc), ref_minloc);
+
+  DATA_TYPE s_min2 = min_init;
+  IDX_TYPE s_minloc2 = minloc_init;
+
+  RAJA::forall<EXEC_POLICY>(seg,
+    RAJA::expt::ReduceLoc<RAJA::operators::minimum>(&s_min2, &s_minloc2),
+    [=] RAJA_HOST_DEVICE(IDX_TYPE RAJA_UNUSED_ARG(idx), VL_LAMBDA_TYPE &m2) {
+      m2.min(min2);
+  });
+  ASSERT_EQ(static_cast<DATA_TYPE>(s_min2), static_cast<DATA_TYPE>(min2.getVal()));
+  ASSERT_EQ(static_cast<IDX_TYPE>(s_minloc2), static_cast<IDX_TYPE>(min2.getLoc()));
+   
+
+  deallocateForallTestData<DATA_TYPE>(working_res,
+                                      working_array,
+                                      check_array,
+                                      test_array);
+}
+
+TYPED_TEST_SUITE_P(ForallReduceMinLocAltBasicTest);
+template <typename T>
+class ForallReduceMinLocAltBasicTest : public ::testing::Test
+{
+};
+
+TYPED_TEST_P(ForallReduceMinLocAltBasicTest, ReduceMinLocAltBasicForall)
+{
+  using IDX_TYPE      = typename camp::at<TypeParam, camp::num<0>>::type;
+  using DATA_TYPE     = typename camp::at<TypeParam, camp::num<1>>::type;
+  using WORKING_RES   = typename camp::at<TypeParam, camp::num<2>>::type;
+  using EXEC_POLICY   = typename camp::at<TypeParam, camp::num<3>>::type;
+  using REDUCE_POLICY = typename camp::at<TypeParam, camp::num<4>>::type;
+
+  camp::resources::Resource working_res{WORKING_RES::get_default()};
+
+  std::vector<IDX_TYPE> seg_idx;
+
+// Range segment tests
+  RAJA::TypedRangeSegment<IDX_TYPE> r1( 0, 28 );
+  RAJA::getIndices(seg_idx, r1);
+  ForallReduceMinLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r1, seg_idx, working_res);
+
+  seg_idx.clear();
+  RAJA::TypedRangeSegment<IDX_TYPE> r2( 3, 642 );
+  RAJA::getIndices(seg_idx, r2);
+  ForallReduceMinLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r2, seg_idx, working_res);
+
+  seg_idx.clear();
+  RAJA::TypedRangeSegment<IDX_TYPE> r3( 0, 2057 );
+  RAJA::getIndices(seg_idx, r3);
+  ForallReduceMinLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r3, seg_idx, working_res);
+
+// Range-stride segment tests
+  seg_idx.clear();
+  RAJA::TypedRangeStrideSegment<IDX_TYPE> r4( 0, 188, 2 );
+  RAJA::getIndices(seg_idx, r4);
+  ForallReduceMinLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeStrideSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r4, seg_idx, working_res);
+
+  seg_idx.clear();
+  RAJA::TypedRangeStrideSegment<IDX_TYPE> r5( 3, 1029, 3 );
+  RAJA::getIndices(seg_idx, r5);
+  ForallReduceMinLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedRangeStrideSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    r5, seg_idx, working_res);
+
+// List segment tests
+  seg_idx.clear();
+  IDX_TYPE last = 10567;
+  srand( time(NULL) );
+  for (IDX_TYPE i = 0; i < last; ++i) {
+    IDX_TYPE randval = IDX_TYPE( rand() % RAJA::stripIndexType(last) );
+    if ( i < randval ) {
+      seg_idx.push_back(i);
+    }
+  }
+  RAJA::TypedListSegment<IDX_TYPE> l1( &seg_idx[0], seg_idx.size(),
+                                       working_res );
+  ForallReduceMinLocAltBasicTestImpl<IDX_TYPE, DATA_TYPE,
+                                  RAJA::TypedListSegment<IDX_TYPE>,
+                                  EXEC_POLICY, REDUCE_POLICY>(
+                                    l1, seg_idx, working_res);
+}
+
+REGISTER_TYPED_TEST_SUITE_P(ForallReduceMinLocAltBasicTest,
+                            ReduceMinLocAltBasicForall);
+
+#endif  // __TEST_FORALL_BASIC_REDUCEMINLOCALT_HPP__
diff --git a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceSum.hpp b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceSum.hpp
index a5a11acf09..4105700f7c 100644
--- a/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceSum.hpp
+++ b/test/functional/forall/reduce-basic/tests/test-forall-basic-expt-ReduceSum.hpp
@@ -20,6 +20,8 @@ void ForallReduceSumBasicTestImpl(const SEG_TYPE& seg,
                                   const std::vector<IDX_TYPE>& seg_idx,
                                   camp::resources::Resource working_res)
 {
+  using REF_SUM = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::plus>;
+
   IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
   IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
 
@@ -46,14 +48,14 @@ void ForallReduceSumBasicTestImpl(const SEG_TYPE& seg,
 
   working_res.memcpy(working_array, test_array, sizeof(DATA_TYPE) * data_len);
 
-  DATA_TYPE sum = 0;
-  DATA_TYPE sum2 = 2;
+  DATA_TYPE sum(0);
+  DATA_TYPE sum2(2);
 
   RAJA::forall<EXEC_POLICY>(seg, 
     RAJA::expt::Reduce<RAJA::operators::plus>(&sum),
     RAJA::expt::Reduce<RAJA::operators::plus>(&sum2),
     RAJA::expt::KernelName("RAJA Reduce Sum"),
-    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &s1, DATA_TYPE &s2) {
+    [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_SUM &s1, REF_SUM &s2) {
       s1 += working_array[idx];
       s2 += working_array[idx];
   });
@@ -68,7 +70,7 @@ void ForallReduceSumBasicTestImpl(const SEG_TYPE& seg,
   for (int j = 0; j < nloops; ++j) {
     RAJA::forall<EXEC_POLICY>(seg, 
       RAJA::expt::Reduce<RAJA::operators::plus>(&sum),
-      [=] RAJA_HOST_DEVICE(IDX_TYPE idx, DATA_TYPE &s) {
+      [=] RAJA_HOST_DEVICE(IDX_TYPE idx, REF_SUM &s) {
         s += working_array[idx];
     });
   }
diff --git a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceBitAnd.hpp b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceBitAnd.hpp
index 776b63f6b0..0a91d5f9b8 100644
--- a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceBitAnd.hpp
+++ b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceBitAnd.hpp
@@ -22,6 +22,8 @@ void LaunchParamExptReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
                                      const std::vector<IDX_TYPE>& seg_idx,
                                      camp::resources::Resource working_res)
 {
+  using REF_BITAND = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::bit_and>;
+
   IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
   IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
 
@@ -51,7 +53,7 @@ void LaunchParamExptReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
   RAJA::launch<LAUNCH_POLICY>
     (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
      RAJA::expt::Reduce<RAJA::operators::bit_and>(&simpand),
-     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, DATA_TYPE &_simpand) {
+     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_BITAND &_simpand) {
 
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
 
@@ -86,7 +88,7 @@ void LaunchParamExptReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
     (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
      RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand),
      RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand2),
-     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, DATA_TYPE &_redand, DATA_TYPE &_redand2) {
+     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_BITAND &_redand, REF_BITAND &_redand2) {
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
         _redand  &= working_array[idx];
         _redand2 &= working_array[idx];
@@ -103,7 +105,7 @@ void LaunchParamExptReduceBitAndBasicTestImpl(const SEG_TYPE& seg,
     RAJA::launch<LAUNCH_POLICY>
       (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
        RAJA::expt::Reduce<RAJA::operators::bit_and>(&redand),
-       [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, DATA_TYPE _redand) {
+       [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_BITAND _redand) {
         RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
           _redand &= working_array[idx];
       });
diff --git a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceMin.hpp b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceMin.hpp
index 2936f2de09..91ab75dbab 100644
--- a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceMin.hpp
+++ b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceMin.hpp
@@ -21,6 +21,8 @@ void LaunchParamExptReduceMinBasicTestImpl(const SEG_TYPE& seg,
                                            const std::vector<IDX_TYPE>& seg_idx,
                                            camp::resources::Resource working_res)
 {
+  using REF_MIN = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::minimum>;
+
   IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
   IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
 
@@ -60,12 +62,12 @@ void LaunchParamExptReduceMinBasicTestImpl(const SEG_TYPE& seg,
      "LaunchMinBasicTest",
      RAJA::expt::Reduce<RAJA::operators::minimum>(&mininit),
      RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
-     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, DATA_TYPE &_mininit, DATA_TYPE &_min) {
+     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_MIN &_mininit, REF_MIN &_min) {
 
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
 
-          _mininit = RAJA_MIN(working_array[idx], _mininit);
-          _min     = RAJA_MIN(working_array[idx], _min);
+          _mininit.min(working_array[idx]);
+          _min.min(working_array[idx]);
 
     });
 
@@ -82,11 +84,11 @@ void LaunchParamExptReduceMinBasicTestImpl(const SEG_TYPE& seg,
   RAJA::launch<LAUNCH_POLICY>
     (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
      RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
-     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, DATA_TYPE &_min) {
+     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_MIN &_min) {
 
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
 
-          _min = RAJA_MIN(working_array[idx] * factor, _min);
+          _min.min(working_array[idx] * factor);
     });
 
   });
@@ -98,10 +100,10 @@ void LaunchParamExptReduceMinBasicTestImpl(const SEG_TYPE& seg,
   RAJA::launch<LAUNCH_POLICY>
     (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
      RAJA::expt::Reduce<RAJA::operators::minimum>(&min),
-     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, DATA_TYPE &_min) {
+     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_MIN &_min) {
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
 
-          _min = RAJA_MIN(working_array[idx] * factor, _min);
+          _min.min(working_array[idx] * factor);
       });
   });
 
diff --git a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceSum.hpp b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceSum.hpp
index bf4b29ec28..f6200628cf 100644
--- a/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceSum.hpp
+++ b/test/functional/launch/reduce-params/tests/test-launch-basic-param-expt-ReduceSum.hpp
@@ -21,6 +21,7 @@ void LaunchParamExptReduceSumBasicTestImpl(const SEG_TYPE& seg,
                                            const std::vector<IDX_TYPE>& seg_idx,
                                            camp::resources::Resource working_res)
 {
+  using REF_SUM = RAJA::expt::ValOp<DATA_TYPE, RAJA::operators::plus>;
 
   IDX_TYPE data_len = seg_idx[seg_idx.size() - 1] + 1;
   IDX_TYPE idx_len = static_cast<IDX_TYPE>( seg_idx.size() );
@@ -59,7 +60,7 @@ void LaunchParamExptReduceSumBasicTestImpl(const SEG_TYPE& seg,
      "LaunchSumBasicTest",
      RAJA::expt::Reduce<RAJA::operators::plus>(&sum),
      RAJA::expt::Reduce<RAJA::operators::plus>(&sum2),
-     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, DATA_TYPE &_sum, DATA_TYPE &_sum2) {
+     [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_SUM &_sum, REF_SUM &_sum2) {
 
       RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
           _sum  += working_array[idx];
@@ -79,7 +80,7 @@ void LaunchParamExptReduceSumBasicTestImpl(const SEG_TYPE& seg,
     RAJA::launch<LAUNCH_POLICY>
       (RAJA::LaunchParams(RAJA::Teams(blocks), RAJA::Threads(threads)),
        RAJA::expt::Reduce<RAJA::operators::plus>(&sum),
-       [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, DATA_TYPE &_sum) {
+       [=] RAJA_HOST_DEVICE(RAJA::LaunchContext ctx, REF_SUM &_sum) {
 
         RAJA::loop<GLOBAL_THREAD_POLICY>(ctx, seg, [&](IDX_TYPE idx) {
             _sum += working_array[idx];