From b1ea304ec7d421c871061fdfab7f2e097fbd4a0f Mon Sep 17 00:00:00 2001
From: nvdbaranec <56695930+nvdbaranec@users.noreply.github.com>
Date: Fri, 11 Mar 2022 16:54:33 -0600
Subject: [PATCH] Add scan_aggregation and reduce_aggregation derived types.
 (#10357)

This PR adds the `scan_aggregation` and `reduce_aggregation` derived types. With it, all concrete aggregation types are now derived from algorithmic specific subtypes.

Authors:
  - https://github.com/nvdbaranec

Approvers:
  - Robert (Bobby) Evans (https://github.com/revans2)
  - Ram (Ramakrishna Prabhu) (https://github.com/rgsl888prabhu)
  - Bradley Dice (https://github.com/bdice)

URL: https://github.com/rapidsai/cudf/pull/10357
---
 cpp/include/cudf/aggregation.hpp              |  22 +
 .../cudf/detail/aggregation/aggregation.hpp   |  57 +-
 cpp/include/cudf/detail/scan.hpp              |   4 +-
 cpp/include/cudf/reduction.hpp                |   4 +-
 cpp/src/aggregation/aggregation.cpp           |  33 +
 cpp/src/reductions/reductions.cpp             |   6 +-
 cpp/src/reductions/scan/scan.cpp              |   2 +-
 cpp/src/reductions/scan/scan.cuh              |   4 +-
 cpp/src/reductions/scan/scan_exclusive.cu     |   2 +-
 cpp/src/reductions/scan/scan_inclusive.cu     |   2 +-
 cpp/tests/reductions/collect_ops_tests.cpp    | 109 +--
 cpp/tests/reductions/rank_tests.cpp           |   8 +-
 cpp/tests/reductions/reduction_tests.cpp      | 682 +++++++++++-------
 cpp/tests/reductions/scan_tests.cpp           | 303 +++++---
 java/src/main/native/src/ColumnViewJni.cpp    |  12 +-
 python/cudf/cudf/_lib/aggregation.pxd         |  17 +-
 python/cudf/cudf/_lib/aggregation.pyx         | 572 +++++++--------
 python/cudf/cudf/_lib/cpp/aggregation.pxd     |   6 +
 python/cudf/cudf/_lib/cpp/reduce.pxd          |   8 +-
 python/cudf/cudf/_lib/reduce.pyx              |  14 +-
 20 files changed, 1103 insertions(+), 764 deletions(-)

diff --git a/cpp/include/cudf/aggregation.hpp b/cpp/include/cudf/aggregation.hpp
index 2a4b86588cb..539a7c04106 100644
--- a/cpp/include/cudf/aggregation.hpp
+++ b/cpp/include/cudf/aggregation.hpp
@@ -148,6 +148,28 @@ class groupby_scan_aggregation : public virtual aggregation {
   groupby_scan_aggregation() {}
 };
 
+/**
+ * @brief Derived class intended for reduction usage.
+ */
+class reduce_aggregation : public virtual aggregation {
+ public:
+  ~reduce_aggregation() override = default;
+
+ protected:
+  reduce_aggregation() {}
+};
+
+/**
+ * @brief Derived class intended for scan usage.
+ */
+class scan_aggregation : public virtual aggregation {
+ public:
+  ~scan_aggregation() override = default;
+
+ protected:
+  scan_aggregation() {}
+};
+
 /**
  * @brief Derived class intended for segmented reduction usage.
  */
diff --git a/cpp/include/cudf/detail/aggregation/aggregation.hpp b/cpp/include/cudf/detail/aggregation/aggregation.hpp
index cb30a54fe84..eba24dd2d13 100644
--- a/cpp/include/cudf/detail/aggregation/aggregation.hpp
+++ b/cpp/include/cudf/detail/aggregation/aggregation.hpp
@@ -148,6 +148,8 @@ class aggregation_finalizer {  // Declares the interface for the finalizer
 class sum_aggregation final : public rolling_aggregation,
                               public groupby_aggregation,
                               public groupby_scan_aggregation,
+                              public reduce_aggregation,
+                              public scan_aggregation,
                               public segmented_reduce_aggregation {
  public:
   sum_aggregation() : aggregation(SUM) {}
@@ -167,7 +169,10 @@ class sum_aggregation final : public rolling_aggregation,
 /**
  * @brief Derived class for specifying a product aggregation
  */
-class product_aggregation final : public groupby_aggregation, public segmented_reduce_aggregation {
+class product_aggregation final : public groupby_aggregation,
+                                  public reduce_aggregation,
+                                  public scan_aggregation,
+                                  public segmented_reduce_aggregation {
  public:
   product_aggregation() : aggregation(PRODUCT) {}
 
@@ -189,6 +194,8 @@ class product_aggregation final : public groupby_aggregation, public segmented_r
 class min_aggregation final : public rolling_aggregation,
                               public groupby_aggregation,
                               public groupby_scan_aggregation,
+                              public reduce_aggregation,
+                              public scan_aggregation,
                               public segmented_reduce_aggregation {
  public:
   min_aggregation() : aggregation(MIN) {}
@@ -211,6 +218,8 @@ class min_aggregation final : public rolling_aggregation,
 class max_aggregation final : public rolling_aggregation,
                               public groupby_aggregation,
                               public groupby_scan_aggregation,
+                              public reduce_aggregation,
+                              public scan_aggregation,
                               public segmented_reduce_aggregation {
  public:
   max_aggregation() : aggregation(MAX) {}
@@ -251,7 +260,7 @@ class count_aggregation final : public rolling_aggregation,
 /**
  * @brief Derived class for specifying an any aggregation
  */
-class any_aggregation final : public segmented_reduce_aggregation {
+class any_aggregation final : public reduce_aggregation, public segmented_reduce_aggregation {
  public:
   any_aggregation() : aggregation(ANY) {}
 
@@ -270,7 +279,7 @@ class any_aggregation final : public segmented_reduce_aggregation {
 /**
  * @brief Derived class for specifying an all aggregation
  */
-class all_aggregation final : public segmented_reduce_aggregation {
+class all_aggregation final : public reduce_aggregation, public segmented_reduce_aggregation {
  public:
   all_aggregation() : aggregation(ALL) {}
 
@@ -289,7 +298,7 @@ class all_aggregation final : public segmented_reduce_aggregation {
 /**
  * @brief Derived class for specifying a sum_of_squares aggregation
  */
-class sum_of_squares_aggregation final : public groupby_aggregation {
+class sum_of_squares_aggregation final : public groupby_aggregation, public reduce_aggregation {
  public:
   sum_of_squares_aggregation() : aggregation(SUM_OF_SQUARES) {}
 
@@ -308,7 +317,9 @@ class sum_of_squares_aggregation final : public groupby_aggregation {
 /**
  * @brief Derived class for specifying a mean aggregation
  */
-class mean_aggregation final : public rolling_aggregation, public groupby_aggregation {
+class mean_aggregation final : public rolling_aggregation,
+                               public groupby_aggregation,
+                               public reduce_aggregation {
  public:
   mean_aggregation() : aggregation(MEAN) {}
 
@@ -346,7 +357,9 @@ class m2_aggregation : public groupby_aggregation {
 /**
  * @brief Derived class for specifying a standard deviation/variance aggregation
  */
-class std_var_aggregation : public rolling_aggregation, public groupby_aggregation {
+class std_var_aggregation : public rolling_aggregation,
+                            public groupby_aggregation,
+                            public reduce_aggregation {
  public:
   size_type _ddof;  ///< Delta degrees of freedom
 
@@ -418,7 +431,7 @@ class std_aggregation final : public std_var_aggregation {
 /**
  * @brief Derived class for specifying a median aggregation
  */
-class median_aggregation final : public groupby_aggregation {
+class median_aggregation final : public groupby_aggregation, public reduce_aggregation {
  public:
   median_aggregation() : aggregation(MEDIAN) {}
 
@@ -437,7 +450,7 @@ class median_aggregation final : public groupby_aggregation {
 /**
  * @brief Derived class for specifying a quantile aggregation
  */
-class quantile_aggregation final : public groupby_aggregation {
+class quantile_aggregation final : public groupby_aggregation, public reduce_aggregation {
  public:
   quantile_aggregation(std::vector<double> const& q, interpolation i)
     : aggregation{QUANTILE}, _quantiles{q}, _interpolation{i}
@@ -524,7 +537,7 @@ class argmin_aggregation final : public rolling_aggregation, public groupby_aggr
 /**
  * @brief Derived class for specifying a nunique aggregation
  */
-class nunique_aggregation final : public groupby_aggregation {
+class nunique_aggregation final : public groupby_aggregation, public reduce_aggregation {
  public:
   nunique_aggregation(null_policy null_handling)
     : aggregation{NUNIQUE}, _null_handling{null_handling}
@@ -563,7 +576,7 @@ class nunique_aggregation final : public groupby_aggregation {
 /**
  * @brief Derived class for specifying a nth element aggregation
  */
-class nth_element_aggregation final : public groupby_aggregation {
+class nth_element_aggregation final : public groupby_aggregation, public reduce_aggregation {
  public:
   nth_element_aggregation(size_type n, null_policy null_handling)
     : aggregation{NTH_ELEMENT}, _n{n}, _null_handling{null_handling}
@@ -625,7 +638,9 @@ class row_number_aggregation final : public rolling_aggregation {
 /**
  * @brief Derived class for specifying a rank aggregation
  */
-class rank_aggregation final : public rolling_aggregation, public groupby_scan_aggregation {
+class rank_aggregation final : public rolling_aggregation,
+                               public groupby_scan_aggregation,
+                               public scan_aggregation {
  public:
   rank_aggregation() : aggregation{RANK} {}
 
@@ -644,7 +659,9 @@ class rank_aggregation final : public rolling_aggregation, public groupby_scan_a
 /**
  * @brief Derived class for specifying a dense rank aggregation
  */
-class dense_rank_aggregation final : public rolling_aggregation, public groupby_scan_aggregation {
+class dense_rank_aggregation final : public rolling_aggregation,
+                                     public groupby_scan_aggregation,
+                                     public scan_aggregation {
  public:
   dense_rank_aggregation() : aggregation{DENSE_RANK} {}
 
@@ -660,7 +677,9 @@ class dense_rank_aggregation final : public rolling_aggregation, public groupby_
   void finalize(aggregation_finalizer& finalizer) const override { finalizer.visit(*this); }
 };
 
-class percent_rank_aggregation final : public rolling_aggregation, public groupby_scan_aggregation {
+class percent_rank_aggregation final : public rolling_aggregation,
+                                       public groupby_scan_aggregation,
+                                       public scan_aggregation {
  public:
   percent_rank_aggregation() : aggregation{PERCENT_RANK} {}
 
@@ -679,7 +698,9 @@ class percent_rank_aggregation final : public rolling_aggregation, public groupb
 /**
  * @brief Derived aggregation class for specifying COLLECT_LIST aggregation
  */
-class collect_list_aggregation final : public rolling_aggregation, public groupby_aggregation {
+class collect_list_aggregation final : public rolling_aggregation,
+                                       public groupby_aggregation,
+                                       public reduce_aggregation {
  public:
   explicit collect_list_aggregation(null_policy null_handling = null_policy::INCLUDE)
     : aggregation{COLLECT_LIST}, _null_handling{null_handling}
@@ -718,7 +739,9 @@ class collect_list_aggregation final : public rolling_aggregation, public groupb
 /**
  * @brief Derived aggregation class for specifying COLLECT_SET aggregation
  */
-class collect_set_aggregation final : public rolling_aggregation, public groupby_aggregation {
+class collect_set_aggregation final : public rolling_aggregation,
+                                      public groupby_aggregation,
+                                      public reduce_aggregation {
  public:
   explicit collect_set_aggregation(null_policy null_handling = null_policy::INCLUDE,
                                    null_equality nulls_equal = null_equality::EQUAL,
@@ -866,7 +889,7 @@ class udf_aggregation final : public rolling_aggregation {
 /**
  * @brief Derived aggregation class for specifying MERGE_LISTS aggregation
  */
-class merge_lists_aggregation final : public groupby_aggregation {
+class merge_lists_aggregation final : public groupby_aggregation, public reduce_aggregation {
  public:
   explicit merge_lists_aggregation() : aggregation{MERGE_LISTS} {}
 
@@ -885,7 +908,7 @@ class merge_lists_aggregation final : public groupby_aggregation {
 /**
  * @brief Derived aggregation class for specifying MERGE_SETS aggregation
  */
-class merge_sets_aggregation final : public groupby_aggregation {
+class merge_sets_aggregation final : public groupby_aggregation, public reduce_aggregation {
  public:
   explicit merge_sets_aggregation(null_equality nulls_equal, nan_equality nans_equal)
     : aggregation{MERGE_SETS}, _nulls_equal(nulls_equal), _nans_equal(nans_equal)
diff --git a/cpp/include/cudf/detail/scan.hpp b/cpp/include/cudf/detail/scan.hpp
index 36dce6caf0b..fc829617c2d 100644
--- a/cpp/include/cudf/detail/scan.hpp
+++ b/cpp/include/cudf/detail/scan.hpp
@@ -47,7 +47,7 @@ namespace detail {
  * @returns Column with scan results.
  */
 std::unique_ptr<column> scan_exclusive(column_view const& input,
-                                       std::unique_ptr<aggregation> const& agg,
+                                       std::unique_ptr<scan_aggregation> const& agg,
                                        null_policy null_handling,
                                        rmm::cuda_stream_view stream,
                                        rmm::mr::device_memory_resource* mr);
@@ -73,7 +73,7 @@ std::unique_ptr<column> scan_exclusive(column_view const& input,
  * @returns Column with scan results.
  */
 std::unique_ptr<column> scan_inclusive(column_view const& input,
-                                       std::unique_ptr<aggregation> const& agg,
+                                       std::unique_ptr<scan_aggregation> const& agg,
                                        null_policy null_handling,
                                        rmm::cuda_stream_view stream,
                                        rmm::mr::device_memory_resource* mr);
diff --git a/cpp/include/cudf/reduction.hpp b/cpp/include/cudf/reduction.hpp
index 367814cda8e..f140ba7d4a9 100644
--- a/cpp/include/cudf/reduction.hpp
+++ b/cpp/include/cudf/reduction.hpp
@@ -68,7 +68,7 @@ enum class scan_type : bool { INCLUSIVE, EXCLUSIVE };
  */
 std::unique_ptr<scalar> reduce(
   column_view const& col,
-  std::unique_ptr<aggregation> const& agg,
+  std::unique_ptr<reduce_aggregation> const& agg,
   data_type output_dtype,
   rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
 
@@ -142,7 +142,7 @@ std::unique_ptr<column> segmented_reduce(
  */
 std::unique_ptr<column> scan(
   const column_view& input,
-  std::unique_ptr<aggregation> const& agg,
+  std::unique_ptr<scan_aggregation> const& agg,
   scan_type inclusive,
   null_policy null_handling           = null_policy::EXCLUDE,
   rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource());
diff --git a/cpp/src/aggregation/aggregation.cpp b/cpp/src/aggregation/aggregation.cpp
index 68fe6d86103..9405b4c37ac 100644
--- a/cpp/src/aggregation/aggregation.cpp
+++ b/cpp/src/aggregation/aggregation.cpp
@@ -417,6 +417,8 @@ template std::unique_ptr<aggregation> make_sum_aggregation<aggregation>();
 template std::unique_ptr<rolling_aggregation> make_sum_aggregation<rolling_aggregation>();
 template std::unique_ptr<groupby_aggregation> make_sum_aggregation<groupby_aggregation>();
 template std::unique_ptr<groupby_scan_aggregation> make_sum_aggregation<groupby_scan_aggregation>();
+template std::unique_ptr<reduce_aggregation> make_sum_aggregation<reduce_aggregation>();
+template std::unique_ptr<scan_aggregation> make_sum_aggregation<scan_aggregation>();
 template std::unique_ptr<segmented_reduce_aggregation>
 make_sum_aggregation<segmented_reduce_aggregation>();
 
@@ -428,6 +430,8 @@ std::unique_ptr<Base> make_product_aggregation()
 }
 template std::unique_ptr<aggregation> make_product_aggregation<aggregation>();
 template std::unique_ptr<groupby_aggregation> make_product_aggregation<groupby_aggregation>();
+template std::unique_ptr<reduce_aggregation> make_product_aggregation<reduce_aggregation>();
+template std::unique_ptr<scan_aggregation> make_product_aggregation<scan_aggregation>();
 template std::unique_ptr<segmented_reduce_aggregation>
 make_product_aggregation<segmented_reduce_aggregation>();
 
@@ -441,6 +445,8 @@ template std::unique_ptr<aggregation> make_min_aggregation<aggregation>();
 template std::unique_ptr<rolling_aggregation> make_min_aggregation<rolling_aggregation>();
 template std::unique_ptr<groupby_aggregation> make_min_aggregation<groupby_aggregation>();
 template std::unique_ptr<groupby_scan_aggregation> make_min_aggregation<groupby_scan_aggregation>();
+template std::unique_ptr<reduce_aggregation> make_min_aggregation<reduce_aggregation>();
+template std::unique_ptr<scan_aggregation> make_min_aggregation<scan_aggregation>();
 template std::unique_ptr<segmented_reduce_aggregation>
 make_min_aggregation<segmented_reduce_aggregation>();
 
@@ -454,6 +460,8 @@ template std::unique_ptr<aggregation> make_max_aggregation<aggregation>();
 template std::unique_ptr<rolling_aggregation> make_max_aggregation<rolling_aggregation>();
 template std::unique_ptr<groupby_aggregation> make_max_aggregation<groupby_aggregation>();
 template std::unique_ptr<groupby_scan_aggregation> make_max_aggregation<groupby_scan_aggregation>();
+template std::unique_ptr<reduce_aggregation> make_max_aggregation<reduce_aggregation>();
+template std::unique_ptr<scan_aggregation> make_max_aggregation<scan_aggregation>();
 template std::unique_ptr<segmented_reduce_aggregation>
 make_max_aggregation<segmented_reduce_aggregation>();
 
@@ -481,6 +489,7 @@ std::unique_ptr<Base> make_any_aggregation()
   return std::make_unique<detail::any_aggregation>();
 }
 template std::unique_ptr<aggregation> make_any_aggregation<aggregation>();
+template std::unique_ptr<reduce_aggregation> make_any_aggregation<reduce_aggregation>();
 template std::unique_ptr<segmented_reduce_aggregation>
 make_any_aggregation<segmented_reduce_aggregation>();
 
@@ -491,6 +500,7 @@ std::unique_ptr<Base> make_all_aggregation()
   return std::make_unique<detail::all_aggregation>();
 }
 template std::unique_ptr<aggregation> make_all_aggregation<aggregation>();
+template std::unique_ptr<reduce_aggregation> make_all_aggregation<reduce_aggregation>();
 template std::unique_ptr<segmented_reduce_aggregation>
 make_all_aggregation<segmented_reduce_aggregation>();
 
@@ -503,6 +513,7 @@ std::unique_ptr<Base> make_sum_of_squares_aggregation()
 template std::unique_ptr<aggregation> make_sum_of_squares_aggregation<aggregation>();
 template std::unique_ptr<groupby_aggregation>
 make_sum_of_squares_aggregation<groupby_aggregation>();
+template std::unique_ptr<reduce_aggregation> make_sum_of_squares_aggregation<reduce_aggregation>();
 
 /// Factory to create a MEAN aggregation
 template <typename Base>
@@ -513,6 +524,7 @@ std::unique_ptr<Base> make_mean_aggregation()
 template std::unique_ptr<aggregation> make_mean_aggregation<aggregation>();
 template std::unique_ptr<rolling_aggregation> make_mean_aggregation<rolling_aggregation>();
 template std::unique_ptr<groupby_aggregation> make_mean_aggregation<groupby_aggregation>();
+template std::unique_ptr<reduce_aggregation> make_mean_aggregation<reduce_aggregation>();
 
 /// Factory to create a M2 aggregation
 template <typename Base>
@@ -534,6 +546,8 @@ template std::unique_ptr<rolling_aggregation> make_variance_aggregation<rolling_
   size_type ddof);
 template std::unique_ptr<groupby_aggregation> make_variance_aggregation<groupby_aggregation>(
   size_type ddof);
+template std::unique_ptr<reduce_aggregation> make_variance_aggregation<reduce_aggregation>(
+  size_type ddof);
 
 /// Factory to create a STD aggregation
 template <typename Base>
@@ -546,6 +560,8 @@ template std::unique_ptr<rolling_aggregation> make_std_aggregation<rolling_aggre
   size_type ddof);
 template std::unique_ptr<groupby_aggregation> make_std_aggregation<groupby_aggregation>(
   size_type ddof);
+template std::unique_ptr<reduce_aggregation> make_std_aggregation<reduce_aggregation>(
+  size_type ddof);
 
 /// Factory to create a MEDIAN aggregation
 template <typename Base>
@@ -555,6 +571,7 @@ std::unique_ptr<Base> make_median_aggregation()
 }
 template std::unique_ptr<aggregation> make_median_aggregation<aggregation>();
 template std::unique_ptr<groupby_aggregation> make_median_aggregation<groupby_aggregation>();
+template std::unique_ptr<reduce_aggregation> make_median_aggregation<reduce_aggregation>();
 
 /// Factory to create a QUANTILE aggregation
 template <typename Base>
@@ -567,6 +584,8 @@ template std::unique_ptr<aggregation> make_quantile_aggregation<aggregation>(
   std::vector<double> const& quantiles, interpolation interp);
 template std::unique_ptr<groupby_aggregation> make_quantile_aggregation<groupby_aggregation>(
   std::vector<double> const& quantiles, interpolation interp);
+template std::unique_ptr<reduce_aggregation> make_quantile_aggregation<reduce_aggregation>(
+  std::vector<double> const& quantiles, interpolation interp);
 
 /// Factory to create an ARGMAX aggregation
 template <typename Base>
@@ -598,6 +617,8 @@ template std::unique_ptr<aggregation> make_nunique_aggregation<aggregation>(
   null_policy null_handling);
 template std::unique_ptr<groupby_aggregation> make_nunique_aggregation<groupby_aggregation>(
   null_policy null_handling);
+template std::unique_ptr<reduce_aggregation> make_nunique_aggregation<reduce_aggregation>(
+  null_policy null_handling);
 
 /// Factory to create an NTH_ELEMENT aggregation
 template <typename Base>
@@ -609,6 +630,8 @@ template std::unique_ptr<aggregation> make_nth_element_aggregation<aggregation>(
   size_type n, null_policy null_handling);
 template std::unique_ptr<groupby_aggregation> make_nth_element_aggregation<groupby_aggregation>(
   size_type n, null_policy null_handling);
+template std::unique_ptr<reduce_aggregation> make_nth_element_aggregation<reduce_aggregation>(
+  size_type n, null_policy null_handling);
 
 /// Factory to create a ROW_NUMBER aggregation
 template <typename Base>
@@ -628,6 +651,7 @@ std::unique_ptr<Base> make_rank_aggregation()
 template std::unique_ptr<aggregation> make_rank_aggregation<aggregation>();
 template std::unique_ptr<groupby_scan_aggregation>
 make_rank_aggregation<groupby_scan_aggregation>();
+template std::unique_ptr<scan_aggregation> make_rank_aggregation<scan_aggregation>();
 
 /// Factory to create a DENSE_RANK aggregation
 template <typename Base>
@@ -638,6 +662,7 @@ std::unique_ptr<Base> make_dense_rank_aggregation()
 template std::unique_ptr<aggregation> make_dense_rank_aggregation<aggregation>();
 template std::unique_ptr<groupby_scan_aggregation>
 make_dense_rank_aggregation<groupby_scan_aggregation>();
+template std::unique_ptr<scan_aggregation> make_dense_rank_aggregation<scan_aggregation>();
 
 /// Factory to create a PERCENT_RANK aggregation
 template <typename Base>
@@ -648,6 +673,7 @@ std::unique_ptr<Base> make_percent_rank_aggregation()
 template std::unique_ptr<aggregation> make_percent_rank_aggregation<aggregation>();
 template std::unique_ptr<groupby_scan_aggregation>
 make_percent_rank_aggregation<groupby_scan_aggregation>();
+template std::unique_ptr<scan_aggregation> make_percent_rank_aggregation<scan_aggregation>();
 
 /// Factory to create a COLLECT_LIST aggregation
 template <typename Base>
@@ -661,6 +687,8 @@ template std::unique_ptr<rolling_aggregation> make_collect_list_aggregation<roll
   null_policy null_handling);
 template std::unique_ptr<groupby_aggregation> make_collect_list_aggregation<groupby_aggregation>(
   null_policy null_handling);
+template std::unique_ptr<reduce_aggregation> make_collect_list_aggregation<reduce_aggregation>(
+  null_policy null_handling);
 
 /// Factory to create a COLLECT_SET aggregation
 template <typename Base>
@@ -676,6 +704,8 @@ template std::unique_ptr<rolling_aggregation> make_collect_set_aggregation<rolli
   null_policy null_handling, null_equality nulls_equal, nan_equality nans_equal);
 template std::unique_ptr<groupby_aggregation> make_collect_set_aggregation<groupby_aggregation>(
   null_policy null_handling, null_equality nulls_equal, nan_equality nans_equal);
+template std::unique_ptr<reduce_aggregation> make_collect_set_aggregation<reduce_aggregation>(
+  null_policy null_handling, null_equality nulls_equal, nan_equality nans_equal);
 
 /// Factory to create a LAG aggregation
 template <typename Base>
@@ -722,6 +752,7 @@ std::unique_ptr<Base> make_merge_lists_aggregation()
 }
 template std::unique_ptr<aggregation> make_merge_lists_aggregation<aggregation>();
 template std::unique_ptr<groupby_aggregation> make_merge_lists_aggregation<groupby_aggregation>();
+template std::unique_ptr<reduce_aggregation> make_merge_lists_aggregation<reduce_aggregation>();
 
 /// Factory to create a MERGE_SETS aggregation
 template <typename Base>
@@ -734,6 +765,8 @@ template std::unique_ptr<aggregation> make_merge_sets_aggregation<aggregation>(n
                                                                                nan_equality);
 template std::unique_ptr<groupby_aggregation> make_merge_sets_aggregation<groupby_aggregation>(
   null_equality, nan_equality);
+template std::unique_ptr<reduce_aggregation> make_merge_sets_aggregation<reduce_aggregation>(
+  null_equality, nan_equality);
 
 /// Factory to create a MERGE_M2 aggregation
 template <typename Base>
diff --git a/cpp/src/reductions/reductions.cpp b/cpp/src/reductions/reductions.cpp
index 13574f83d4e..bd8c8342708 100644
--- a/cpp/src/reductions/reductions.cpp
+++ b/cpp/src/reductions/reductions.cpp
@@ -45,7 +45,7 @@ struct reduce_dispatch_functor {
   }
 
   template <aggregation::Kind k>
-  std::unique_ptr<scalar> operator()(std::unique_ptr<aggregation> const& agg)
+  std::unique_ptr<scalar> operator()(std::unique_ptr<reduce_aggregation> const& agg)
   {
     switch (k) {
       case aggregation::SUM: return reduction::sum(col, output_dtype, stream, mr); break;
@@ -125,7 +125,7 @@ struct reduce_dispatch_functor {
 
 std::unique_ptr<scalar> reduce(
   column_view const& col,
-  std::unique_ptr<aggregation> const& agg,
+  std::unique_ptr<reduce_aggregation> const& agg,
   data_type output_dtype,
   rmm::cuda_stream_view stream        = rmm::cuda_stream_default,
   rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource())
@@ -145,7 +145,7 @@ std::unique_ptr<scalar> reduce(
 }  // namespace detail
 
 std::unique_ptr<scalar> reduce(column_view const& col,
-                               std::unique_ptr<aggregation> const& agg,
+                               std::unique_ptr<reduce_aggregation> const& agg,
                                data_type output_dtype,
                                rmm::mr::device_memory_resource* mr)
 {
diff --git a/cpp/src/reductions/scan/scan.cpp b/cpp/src/reductions/scan/scan.cpp
index d73fc862380..52aaad5ddcf 100644
--- a/cpp/src/reductions/scan/scan.cpp
+++ b/cpp/src/reductions/scan/scan.cpp
@@ -25,7 +25,7 @@
 namespace cudf {
 
 std::unique_ptr<column> scan(column_view const& input,
-                             std::unique_ptr<aggregation> const& agg,
+                             std::unique_ptr<scan_aggregation> const& agg,
                              scan_type inclusive,
                              null_policy null_handling,
                              rmm::mr::device_memory_resource* mr)
diff --git a/cpp/src/reductions/scan/scan.cuh b/cpp/src/reductions/scan/scan.cuh
index 84387aba914..127f2ae95b4 100644
--- a/cpp/src/reductions/scan/scan.cuh
+++ b/cpp/src/reductions/scan/scan.cuh
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2021, NVIDIA CORPORATION.
+ * Copyright (c) 2021-2022, NVIDIA CORPORATION.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -35,7 +35,7 @@ rmm::device_buffer mask_scan(column_view const& input_view,
 
 template <template <typename> typename DispatchFn>
 std::unique_ptr<column> scan_agg_dispatch(const column_view& input,
-                                          std::unique_ptr<aggregation> const& agg,
+                                          std::unique_ptr<scan_aggregation> const& agg,
                                           null_policy null_handling,
                                           rmm::cuda_stream_view stream,
                                           rmm::mr::device_memory_resource* mr)
diff --git a/cpp/src/reductions/scan/scan_exclusive.cu b/cpp/src/reductions/scan/scan_exclusive.cu
index 9811a986224..3b8cc17c4aa 100644
--- a/cpp/src/reductions/scan/scan_exclusive.cu
+++ b/cpp/src/reductions/scan/scan_exclusive.cu
@@ -81,7 +81,7 @@ struct scan_dispatcher {
 }  // namespace
 
 std::unique_ptr<column> scan_exclusive(const column_view& input,
-                                       std::unique_ptr<aggregation> const& agg,
+                                       std::unique_ptr<scan_aggregation> const& agg,
                                        null_policy null_handling,
                                        rmm::cuda_stream_view stream,
                                        rmm::mr::device_memory_resource* mr)
diff --git a/cpp/src/reductions/scan/scan_inclusive.cu b/cpp/src/reductions/scan/scan_inclusive.cu
index ee865f09f2e..bc2f1d47311 100644
--- a/cpp/src/reductions/scan/scan_inclusive.cu
+++ b/cpp/src/reductions/scan/scan_inclusive.cu
@@ -245,7 +245,7 @@ struct scan_dispatcher {
 
 std::unique_ptr<column> scan_inclusive(
   column_view const& input,
-  std::unique_ptr<aggregation> const& agg,
+  std::unique_ptr<scan_aggregation> const& agg,
   null_policy null_handling,
   rmm::cuda_stream_view stream,
   rmm::mr::device_memory_resource* mr = rmm::mr::get_current_device_resource())
diff --git a/cpp/tests/reductions/collect_ops_tests.cpp b/cpp/tests/reductions/collect_ops_tests.cpp
index d8b1d9c5ca7..688174d31c5 100644
--- a/cpp/tests/reductions/collect_ops_tests.cpp
+++ b/cpp/tests/reductions/collect_ops_tests.cpp
@@ -44,19 +44,22 @@ TYPED_TEST(CollectTestFixedWidth, CollectList)
 
   // null_include without nulls
   fw_wrapper col(values.begin(), values.end());
-  auto const ret = cudf::reduce(col, make_collect_list_aggregation(), data_type{type_id::LIST});
+  auto const ret = cudf::reduce(
+    col, make_collect_list_aggregation<reduce_aggregation>(), data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(col, dynamic_cast<list_scalar*>(ret.get())->view());
 
   // null_include with nulls
   fw_wrapper col_with_null(values.begin(), values.end(), null_mask.begin());
-  auto const ret1 =
-    cudf::reduce(col_with_null, make_collect_list_aggregation(), data_type{type_id::LIST});
+  auto const ret1 = cudf::reduce(
+    col_with_null, make_collect_list_aggregation<reduce_aggregation>(), data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(col_with_null, dynamic_cast<list_scalar*>(ret1.get())->view());
 
   // null_exclude with nulls
   fw_wrapper col_null_filtered{{5, 0, -111, 0, 64, 99, -16}};
-  auto const ret2 = cudf::reduce(
-    col_with_null, make_collect_list_aggregation(null_policy::EXCLUDE), data_type{type_id::LIST});
+  auto const ret2 =
+    cudf::reduce(col_with_null,
+                 make_collect_list_aggregation<reduce_aggregation>(null_policy::EXCLUDE),
+                 data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(col_null_filtered, dynamic_cast<list_scalar*>(ret2.get())->view());
 }
 
@@ -70,11 +73,11 @@ TYPED_TEST(CollectTestFixedWidth, CollectSet)
   fw_wrapper col(values.begin(), values.end());
   fw_wrapper col_with_null(values.begin(), values.end(), null_mask.begin());
 
-  auto null_exclude = make_collect_set_aggregation(
+  auto null_exclude = make_collect_set_aggregation<reduce_aggregation>(
     null_policy::EXCLUDE, null_equality::UNEQUAL, nan_equality::ALL_EQUAL);
-  auto null_eq = make_collect_set_aggregation(
+  auto null_eq = make_collect_set_aggregation<reduce_aggregation>(
     null_policy::INCLUDE, null_equality::EQUAL, nan_equality::ALL_EQUAL);
-  auto null_unequal = make_collect_set_aggregation(
+  auto null_unequal = make_collect_set_aggregation<reduce_aggregation>(
     null_policy::INCLUDE, null_equality::UNEQUAL, nan_equality::ALL_EQUAL);
 
   // test without nulls
@@ -106,7 +109,8 @@ TYPED_TEST(CollectTestFixedWidth, MergeLists)
   // test without nulls
   auto const lists1    = lists_col{{1, 2, 3}, {}, {}, {4}, {5, 6, 7}, {8, 9}, {}};
   auto const expected1 = fw_wrapper{{1, 2, 3, 4, 5, 6, 7, 8, 9}};
-  auto const ret1 = cudf::reduce(lists1, make_merge_lists_aggregation(), data_type{type_id::LIST});
+  auto const ret1      = cudf::reduce(
+    lists1, make_merge_lists_aggregation<reduce_aggregation>(), data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected1, dynamic_cast<list_scalar*>(ret1.get())->view());
 
   // test with nulls
@@ -122,7 +126,8 @@ TYPED_TEST(CollectTestFixedWidth, MergeLists)
                                 null_at(5)};
   auto const expected2 = fw_wrapper{{1, 2, 3, 0, 4, 0, 5, 0, 0, 0, 6, 7, 8, 9},
                                     {1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1}};
-  auto const ret2 = cudf::reduce(lists2, make_merge_lists_aggregation(), data_type{type_id::LIST});
+  auto const ret2      = cudf::reduce(
+    lists2, make_merge_lists_aggregation<reduce_aggregation>(), data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected2, dynamic_cast<list_scalar*>(ret2.get())->view());
 }
 
@@ -134,7 +139,8 @@ TYPED_TEST(CollectTestFixedWidth, MergeSets)
   // test without nulls
   auto const lists1    = lists_col{{1, 2, 3}, {}, {}, {4}, {1, 3, 4}, {0, 3, 10}, {}};
   auto const expected1 = fw_wrapper{{0, 1, 2, 3, 4, 10}};
-  auto const ret1 = cudf::reduce(lists1, make_merge_sets_aggregation(), data_type{type_id::LIST});
+  auto const ret1      = cudf::reduce(
+    lists1, make_merge_sets_aggregation<reduce_aggregation>(), data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected1, dynamic_cast<list_scalar*>(ret1.get())->view());
 
   // test with null_equal
@@ -149,14 +155,17 @@ TYPED_TEST(CollectTestFixedWidth, MergeSets)
                                 },
                                 null_at(5)};
   auto const expected2 = fw_wrapper{{1, 2, 3, 4, 5, 0}, {1, 1, 1, 1, 1, 0}};
-  auto const ret2 = cudf::reduce(lists2, make_merge_sets_aggregation(), data_type{type_id::LIST});
+  auto const ret2      = cudf::reduce(
+    lists2, make_merge_sets_aggregation<reduce_aggregation>(), data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected2, dynamic_cast<list_scalar*>(ret2.get())->view());
 
   // test with null_unequal
   auto const& lists3   = lists2;
   auto const expected3 = fw_wrapper{{1, 2, 3, 4, 5, 0, 0, 0, 0, 0}, {1, 1, 1, 1, 1, 0, 0, 0, 0, 0}};
-  auto const ret3      = cudf::reduce(
-    lists3, make_merge_sets_aggregation(null_equality::UNEQUAL), data_type{type_id::LIST});
+  auto const ret3 =
+    cudf::reduce(lists3,
+                 make_merge_sets_aggregation<reduce_aggregation>(null_equality::UNEQUAL),
+                 data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected3, dynamic_cast<list_scalar*>(ret3.get())->view());
 }
 
@@ -173,23 +182,24 @@ TEST_F(CollectTest, CollectSetWithNaN)
   // nan unequal with null equal
   fp_wrapper expected1{{-2.3e-5f, 1.0f, 2.3e5f, -NAN, -NAN, NAN, NAN, 0.0f},
                        {1, 1, 1, 1, 1, 1, 1, 0}};
-  auto const ret1 = cudf::reduce(col, make_collect_set_aggregation(), data_type{type_id::LIST});
+  auto const ret1 =
+    cudf::reduce(col, make_collect_set_aggregation<reduce_aggregation>(), data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected1, dynamic_cast<list_scalar*>(ret1.get())->view());
 
   // nan unequal with null unequal
   fp_wrapper expected2{{-2.3e-5f, 1.0f, 2.3e5f, -NAN, -NAN, NAN, NAN, 0.0f, 0.0f},
                        {1, 1, 1, 1, 1, 1, 1, 0, 0}};
-  auto const ret2 =
-    cudf::reduce(col,
-                 make_collect_set_aggregation(null_policy::INCLUDE, null_equality::UNEQUAL),
-                 data_type{type_id::LIST});
+  auto const ret2 = cudf::reduce(
+    col,
+    make_collect_set_aggregation<reduce_aggregation>(null_policy::INCLUDE, null_equality::UNEQUAL),
+    data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected2, dynamic_cast<list_scalar*>(ret2.get())->view());
 
   // nan equal with null equal
   fp_wrapper expected3{{-2.3e-5f, 1.0f, 2.3e5f, NAN, 0.0f}, {1, 1, 1, 1, 0}};
   auto const ret3 =
     cudf::reduce(col,
-                 make_collect_set_aggregation(
+                 make_collect_set_aggregation<reduce_aggregation>(
                    null_policy::INCLUDE, null_equality::EQUAL, nan_equality::ALL_EQUAL),
                  data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected3, dynamic_cast<list_scalar*>(ret3.get())->view());
@@ -198,7 +208,7 @@ TEST_F(CollectTest, CollectSetWithNaN)
   fp_wrapper expected4{{-2.3e-5f, 1.0f, 2.3e5f, -NAN, 0.0f, 0.0f}, {1, 1, 1, 1, 0, 0}};
   auto const ret4 =
     cudf::reduce(col,
-                 make_collect_set_aggregation(
+                 make_collect_set_aggregation<reduce_aggregation>(
                    null_policy::INCLUDE, null_equality::UNEQUAL, nan_equality::ALL_EQUAL),
                  data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected4, dynamic_cast<list_scalar*>(ret4.get())->view());
@@ -219,30 +229,33 @@ TEST_F(CollectTest, MergeSetsWithNaN)
 
   // nan unequal with null equal
   fp_wrapper expected1{{-2.3e-5f, 1.0f, 2.3e5f, -NAN, NAN, NAN, 0.0f}, {1, 1, 1, 1, 1, 1, 0}};
-  auto const ret1 = cudf::reduce(col, make_merge_sets_aggregation(), data_type{type_id::LIST});
+  auto const ret1 =
+    cudf::reduce(col, make_merge_sets_aggregation<reduce_aggregation>(), data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected1, dynamic_cast<list_scalar*>(ret1.get())->view());
 
   // nan unequal with null unequal
   fp_wrapper expected2{{-2.3e-5f, 1.0f, 2.3e5f, -NAN, NAN, NAN, 0.0f, 0.0f, 0.0f},
                        {1, 1, 1, 1, 1, 1, 0, 0, 0}};
-  auto const ret2 = cudf::reduce(
-    col, make_merge_sets_aggregation(null_equality::UNEQUAL), data_type{type_id::LIST});
+  auto const ret2 =
+    cudf::reduce(col,
+                 make_merge_sets_aggregation<reduce_aggregation>(null_equality::UNEQUAL),
+                 data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected2, dynamic_cast<list_scalar*>(ret2.get())->view());
 
   // nan equal with null equal
   fp_wrapper expected3{{-2.3e-5f, 1.0f, 2.3e5f, -NAN, 0.0f}, {1, 1, 1, 1, 0}};
-  auto const ret3 =
-    cudf::reduce(col,
-                 make_merge_sets_aggregation(null_equality::EQUAL, nan_equality::ALL_EQUAL),
-                 data_type{type_id::LIST});
+  auto const ret3 = cudf::reduce(
+    col,
+    make_merge_sets_aggregation<reduce_aggregation>(null_equality::EQUAL, nan_equality::ALL_EQUAL),
+    data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected3, dynamic_cast<list_scalar*>(ret3.get())->view());
 
   // nan equal with null unequal
   fp_wrapper expected4{{-2.3e-5f, 1.0f, 2.3e5f, -NAN, 0.0f, 0.0f, 0.0f}, {1, 1, 1, 1, 0, 0, 0}};
-  auto const ret4 =
-    cudf::reduce(col,
-                 make_merge_sets_aggregation(null_equality::UNEQUAL, nan_equality::ALL_EQUAL),
-                 data_type{type_id::LIST});
+  auto const ret4 = cudf::reduce(col,
+                                 make_merge_sets_aggregation<reduce_aggregation>(
+                                   null_equality::UNEQUAL, nan_equality::ALL_EQUAL),
+                                 data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected4, dynamic_cast<list_scalar*>(ret4.get())->view());
 }
 
@@ -255,26 +268,30 @@ TEST_F(CollectTest, CollectStrings)
     str_col{{"a", "a", "b", "b", "b", "c", "c", "d", "e", "e"}, {1, 1, 1, 0, 1, 1, 0, 1, 1, 1}};
 
   // collect_list including nulls
-  auto const ret1 = cudf::reduce(s_col, make_collect_list_aggregation(), data_type{type_id::LIST});
+  auto const ret1 = cudf::reduce(
+    s_col, make_collect_list_aggregation<reduce_aggregation>(), data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(s_col, dynamic_cast<list_scalar*>(ret1.get())->view());
 
   // collect_list excluding nulls
   auto const expected2 = str_col{"a", "a", "b", "b", "c", "d", "e", "e"};
-  auto const ret2      = cudf::reduce(
-    s_col, make_collect_list_aggregation(null_policy::EXCLUDE), data_type{type_id::LIST});
+  auto const ret2 =
+    cudf::reduce(s_col,
+                 make_collect_list_aggregation<reduce_aggregation>(null_policy::EXCLUDE),
+                 data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected2, dynamic_cast<list_scalar*>(ret2.get())->view());
 
   // collect_set with null_equal
   auto const expected3 = str_col{{"a", "b", "c", "d", "e", ""}, null_at(5)};
-  auto const ret3 = cudf::reduce(s_col, make_collect_set_aggregation(), data_type{type_id::LIST});
+  auto const ret3      = cudf::reduce(
+    s_col, make_collect_set_aggregation<reduce_aggregation>(), data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected3, dynamic_cast<list_scalar*>(ret3.get())->view());
 
   // collect_set with null_unequal
   auto const expected4 = str_col{{"a", "b", "c", "d", "e", "", ""}, {1, 1, 1, 1, 1, 0, 0}};
-  auto const ret4 =
-    cudf::reduce(s_col,
-                 make_collect_set_aggregation(null_policy::INCLUDE, null_equality::UNEQUAL),
-                 data_type{type_id::LIST});
+  auto const ret4      = cudf::reduce(
+    s_col,
+    make_collect_set_aggregation<reduce_aggregation>(null_policy::INCLUDE, null_equality::UNEQUAL),
+    data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected4, dynamic_cast<list_scalar*>(ret4.get())->view());
 
   lists_col strings{{"a"},
@@ -288,19 +305,23 @@ TEST_F(CollectTest, CollectStrings)
   // merge_lists
   auto const expected5 = str_col{{"a", "a", "b", "b", "null", "c", "null", "d", "null", "e"},
                                  {1, 1, 1, 1, 0, 1, 0, 1, 0, 1}};
-  auto const ret5 = cudf::reduce(strings, make_merge_lists_aggregation(), data_type{type_id::LIST});
+  auto const ret5      = cudf::reduce(
+    strings, make_merge_lists_aggregation<reduce_aggregation>(), data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected5, dynamic_cast<list_scalar*>(ret5.get())->view());
 
   // merge_sets with null_equal
   auto const expected6 = str_col{{"a", "b", "c", "d", "e", "null"}, {1, 1, 1, 1, 1, 0}};
-  auto const ret6 = cudf::reduce(strings, make_merge_sets_aggregation(), data_type{type_id::LIST});
+  auto const ret6      = cudf::reduce(
+    strings, make_merge_sets_aggregation<reduce_aggregation>(), data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected6, dynamic_cast<list_scalar*>(ret6.get())->view());
 
   // merge_sets with null_unequal
   auto const expected7 =
     str_col{{"a", "b", "c", "d", "e", "null", "null", "null"}, {1, 1, 1, 1, 1, 0, 0, 0}};
-  auto const ret7 = cudf::reduce(
-    strings, make_merge_sets_aggregation(null_equality::UNEQUAL), data_type{type_id::LIST});
+  auto const ret7 =
+    cudf::reduce(strings,
+                 make_merge_sets_aggregation<reduce_aggregation>(null_equality::UNEQUAL),
+                 data_type{type_id::LIST});
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected7, dynamic_cast<list_scalar*>(ret7.get())->view());
 }
 
diff --git a/cpp/tests/reductions/rank_tests.cpp b/cpp/tests/reductions/rank_tests.cpp
index 810d4bef737..52bffa3e4f9 100644
--- a/cpp/tests/reductions/rank_tests.cpp
+++ b/cpp/tests/reductions/rank_tests.cpp
@@ -40,9 +40,9 @@ using percent_result_t =
   cudf::detail::target_type_t<int32_t, cudf::aggregation::Kind::PERCENT_RANK>;
 using percent_result_col = fixed_width_column_wrapper<percent_result_t>;
 
-auto const rank         = cudf::make_rank_aggregation();
-auto const dense_rank   = cudf::make_dense_rank_aggregation();
-auto const percent_rank = cudf::make_percent_rank_aggregation();
+auto const rank         = cudf::make_rank_aggregation<scan_aggregation>();
+auto const dense_rank   = cudf::make_dense_rank_aggregation<scan_aggregation>();
+auto const percent_rank = cudf::make_percent_rank_aggregation<scan_aggregation>();
 
 auto constexpr INCLUSIVE_SCAN = cudf::scan_type::INCLUSIVE;
 auto constexpr INCLUDE_NULLS  = cudf::null_policy::INCLUDE;
@@ -51,7 +51,7 @@ template <typename T>
 struct TypedRankScanTest : BaseScanTest<T> {
   inline void test_ungrouped_rank_scan(cudf::column_view const& input,
                                        cudf::column_view const& expect_vals,
-                                       std::unique_ptr<aggregation> const& agg)
+                                       std::unique_ptr<scan_aggregation> const& agg)
   {
     auto col_out = cudf::scan(input, agg, INCLUSIVE_SCAN, INCLUDE_NULLS);
     CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(expect_vals, col_out->view());
diff --git a/cpp/tests/reductions/reduction_tests.cpp b/cpp/tests/reductions/reduction_tests.cpp
index 276b244dac6..0b90c241f31 100644
--- a/cpp/tests/reductions/reduction_tests.cpp
+++ b/cpp/tests/reductions/reduction_tests.cpp
@@ -35,7 +35,8 @@
 #include <iostream>
 #include <vector>
 
-using aggregation = cudf::aggregation;
+using aggregation        = cudf::aggregation;
+using reduce_aggregation = cudf::reduce_aggregation;
 
 template <typename T>
 std::enable_if_t<!cudf::is_timestamp_t<T>::value, std::vector<T>> convert_values(
@@ -98,7 +99,7 @@ struct ReductionTest : public cudf::test::BaseFixture {
   void reduction_test(const cudf::column_view underlying_column,
                       T_out expected_value,
                       bool succeeded_condition,
-                      std::unique_ptr<aggregation> const& agg,
+                      std::unique_ptr<reduce_aggregation> const& agg,
                       cudf::data_type output_dtype = cudf::data_type{},
                       bool expected_null           = false)
   {
@@ -145,8 +146,10 @@ TYPED_TEST(MinMaxReductionTest, MinMax)
 
   T expected_min_result = *(std::min_element(v.begin(), v.end()));
   T expected_max_result = *(std::max_element(v.begin(), v.end()));
-  this->reduction_test(col, expected_min_result, result_error, cudf::make_min_aggregation());
-  this->reduction_test(col, expected_max_result, result_error, cudf::make_max_aggregation());
+  this->reduction_test(
+    col, expected_min_result, result_error, cudf::make_min_aggregation<reduce_aggregation>());
+  this->reduction_test(
+    col, expected_max_result, result_error, cudf::make_max_aggregation<reduce_aggregation>());
 
   auto res = cudf::minmax(col);
 
@@ -165,10 +168,14 @@ TYPED_TEST(MinMaxReductionTest, MinMax)
   T expected_min_null_result = *(std::min_element(r_min.begin(), r_min.end()));
   T expected_max_null_result = *(std::max_element(r_max.begin(), r_max.end()));
 
-  this->reduction_test(
-    col_nulls, expected_min_null_result, result_error, cudf::make_min_aggregation());
-  this->reduction_test(
-    col_nulls, expected_max_null_result, result_error, cudf::make_max_aggregation());
+  this->reduction_test(col_nulls,
+                       expected_min_null_result,
+                       result_error,
+                       cudf::make_min_aggregation<reduce_aggregation>());
+  this->reduction_test(col_nulls,
+                       expected_max_null_result,
+                       result_error,
+                       cudf::make_max_aggregation<reduce_aggregation>());
 
   auto null_res = cudf::minmax(col_nulls);
 
@@ -192,13 +199,13 @@ TYPED_TEST(MinMaxReductionTest, MinMax)
   this->reduction_test(col_all_nulls,
                        expected_min_all_null_result,
                        result_error,
-                       cudf::make_min_aggregation(),
+                       cudf::make_min_aggregation<reduce_aggregation>(),
                        cudf::data_type{},
                        true);
   this->reduction_test(col_all_nulls,
                        expected_max_all_null_result,
                        result_error,
-                       cudf::make_max_aggregation(),
+                       cudf::make_max_aggregation<reduce_aggregation>(),
                        cudf::data_type{},
                        true);
 
@@ -227,15 +234,20 @@ TYPED_TEST(SumReductionTest, Sum)
   // test without nulls
   cudf::test::fixed_width_column_wrapper<T> col(v.begin(), v.end());
   T expected_value = std::accumulate(v.begin(), v.end(), T{0});
-  this->reduction_test(col, expected_value, this->ret_non_arithmetic, cudf::make_sum_aggregation());
+  this->reduction_test(col,
+                       expected_value,
+                       this->ret_non_arithmetic,
+                       cudf::make_sum_aggregation<reduce_aggregation>());
 
   // test with nulls
   cudf::test::fixed_width_column_wrapper<T> col_nulls = construct_null_column(v, host_bools);
   auto r                                              = replace_nulls(v, host_bools, T{0});
   T expected_null_value                               = std::accumulate(r.begin(), r.end(), T{0});
 
-  this->reduction_test(
-    col_nulls, expected_null_value, this->ret_non_arithmetic, cudf::make_sum_aggregation());
+  this->reduction_test(col_nulls,
+                       expected_null_value,
+                       this->ret_non_arithmetic,
+                       cudf::make_sum_aggregation<reduce_aggregation>());
 }
 
 TYPED_TEST_SUITE(ReductionTest, cudf::test::NumericTypes);
@@ -257,16 +269,20 @@ TYPED_TEST(ReductionTest, Product)
   cudf::test::fixed_width_column_wrapper<T> col(v.begin(), v.end());
   TypeParam expected_value = calc_prod(v);
 
-  this->reduction_test(
-    col, expected_value, this->ret_non_arithmetic, cudf::make_product_aggregation());
+  this->reduction_test(col,
+                       expected_value,
+                       this->ret_non_arithmetic,
+                       cudf::make_product_aggregation<reduce_aggregation>());
 
   // test with nulls
   cudf::test::fixed_width_column_wrapper<T> col_nulls = construct_null_column(v, host_bools);
   auto r                                              = replace_nulls(v, host_bools, T{1});
   TypeParam expected_null_value                       = calc_prod(r);
 
-  this->reduction_test(
-    col_nulls, expected_null_value, this->ret_non_arithmetic, cudf::make_product_aggregation());
+  this->reduction_test(col_nulls,
+                       expected_null_value,
+                       this->ret_non_arithmetic,
+                       cudf::make_product_aggregation<reduce_aggregation>());
 }
 
 TYPED_TEST(ReductionTest, SumOfSquare)
@@ -285,8 +301,10 @@ TYPED_TEST(ReductionTest, SumOfSquare)
   cudf::test::fixed_width_column_wrapper<T> col(v.begin(), v.end());
   T expected_value = calc_reduction(v);
 
-  this->reduction_test(
-    col, expected_value, this->ret_non_arithmetic, cudf::make_sum_of_squares_aggregation());
+  this->reduction_test(col,
+                       expected_value,
+                       this->ret_non_arithmetic,
+                       cudf::make_sum_of_squares_aggregation<reduce_aggregation>());
 
   // test with nulls
   cudf::test::fixed_width_column_wrapper<T> col_nulls = construct_null_column(v, host_bools);
@@ -296,7 +314,7 @@ TYPED_TEST(ReductionTest, SumOfSquare)
   this->reduction_test(col_nulls,
                        expected_null_value,
                        this->ret_non_arithmetic,
-                       cudf::make_sum_of_squares_aggregation());
+                       cudf::make_sum_of_squares_aggregation<reduce_aggregation>());
 }
 
 template <typename T>
@@ -321,16 +339,24 @@ TYPED_TEST(ReductionAnyAllTest, AnyAllTrueTrue)
   // test without nulls
   cudf::test::fixed_width_column_wrapper<T> col(v.begin(), v.end());
 
-  this->reduction_test(col, expected, result_error, cudf::make_any_aggregation(), output_dtype);
-  this->reduction_test(col, expected, result_error, cudf::make_all_aggregation(), output_dtype);
+  this->reduction_test(
+    col, expected, result_error, cudf::make_any_aggregation<reduce_aggregation>(), output_dtype);
+  this->reduction_test(
+    col, expected, result_error, cudf::make_all_aggregation<reduce_aggregation>(), output_dtype);
 
   // test with nulls
   cudf::test::fixed_width_column_wrapper<T> col_nulls = construct_null_column(v, host_bools);
 
-  this->reduction_test(
-    col_nulls, expected, result_error, cudf::make_any_aggregation(), output_dtype);
-  this->reduction_test(
-    col_nulls, expected, result_error, cudf::make_all_aggregation(), output_dtype);
+  this->reduction_test(col_nulls,
+                       expected,
+                       result_error,
+                       cudf::make_any_aggregation<reduce_aggregation>(),
+                       output_dtype);
+  this->reduction_test(col_nulls,
+                       expected,
+                       result_error,
+                       cudf::make_all_aggregation<reduce_aggregation>(),
+                       output_dtype);
 }
 
 TYPED_TEST(ReductionAnyAllTest, AnyAllFalseFalse)
@@ -349,16 +375,24 @@ TYPED_TEST(ReductionAnyAllTest, AnyAllFalseFalse)
   // test without nulls
   cudf::test::fixed_width_column_wrapper<T> col(v.begin(), v.end());
 
-  this->reduction_test(col, expected, result_error, cudf::make_any_aggregation(), output_dtype);
-  this->reduction_test(col, expected, result_error, cudf::make_all_aggregation(), output_dtype);
+  this->reduction_test(
+    col, expected, result_error, cudf::make_any_aggregation<reduce_aggregation>(), output_dtype);
+  this->reduction_test(
+    col, expected, result_error, cudf::make_all_aggregation<reduce_aggregation>(), output_dtype);
 
   // test with nulls
   cudf::test::fixed_width_column_wrapper<T> col_nulls = construct_null_column(v, host_bools);
 
-  this->reduction_test(
-    col_nulls, expected, result_error, cudf::make_any_aggregation(), output_dtype);
-  this->reduction_test(
-    col_nulls, expected, result_error, cudf::make_all_aggregation(), output_dtype);
+  this->reduction_test(col_nulls,
+                       expected,
+                       result_error,
+                       cudf::make_any_aggregation<reduce_aggregation>(),
+                       output_dtype);
+  this->reduction_test(col_nulls,
+                       expected,
+                       result_error,
+                       cudf::make_all_aggregation<reduce_aggregation>(),
+                       output_dtype);
 }
 
 // ----------------------------------------------------------------------------
@@ -388,7 +422,7 @@ TYPED_TEST(MultiStepReductionTest, Mean)
   this->reduction_test(col,
                        expected_value,
                        true,
-                       cudf::make_mean_aggregation(),
+                       cudf::make_mean_aggregation<reduce_aggregation>(),
                        cudf::data_type(cudf::type_id::FLOAT64));
 
   // test with nulls
@@ -401,7 +435,7 @@ TYPED_TEST(MultiStepReductionTest, Mean)
   this->reduction_test(col_nulls,
                        expected_value_nulls,
                        true,
-                       cudf::make_mean_aggregation(),
+                       cudf::make_mean_aggregation<reduce_aggregation>(),
                        cudf::data_type(cudf::type_id::FLOAT64));
 }
 
@@ -417,14 +451,13 @@ TYPED_TEST(MultiStepReductionTest, DISABLED_var_std)
   std::vector<int> int_values({-3, 2, 1, 0, 5, -3, -2, 28});
   std::vector<bool> host_bools({1, 1, 0, 1, 1, 1, 0, 1});
 
-  auto calc_var = [](std::vector<T>& v, cudf::size_type valid_count) {
+  auto calc_var = [](std::vector<T>& v, cudf::size_type valid_count, int ddof) {
     double mean = std::accumulate(v.begin(), v.end(), double{0});
     mean /= valid_count;
 
     double sum_of_sq = std::accumulate(
       v.begin(), v.end(), double{0}, [](double acc, TypeParam i) { return acc + i * i; });
 
-    int ddof            = 1;
     cudf::size_type div = valid_count - ddof;
 
     double var = sum_of_sq / div - ((mean * mean) * valid_count) / div;
@@ -435,10 +468,11 @@ TYPED_TEST(MultiStepReductionTest, DISABLED_var_std)
   std::vector<T> v = convert_values<T>(int_values);
   cudf::test::fixed_width_column_wrapper<T> col(v.begin(), v.end());
 
-  double var   = calc_var(v, v.size());
-  double std   = std::sqrt(var);
-  auto var_agg = cudf::make_variance_aggregation(/*ddof =*/1);
-  auto std_agg = cudf::make_std_aggregation(/*ddof =*/1);
+  auto const ddof = 1;
+  double var      = calc_var(v, v.size(), ddof);
+  double std      = std::sqrt(var);
+  auto var_agg    = cudf::make_variance_aggregation<reduce_aggregation>(ddof);
+  auto std_agg    = cudf::make_std_aggregation<reduce_aggregation>(ddof);
 
   this->reduction_test(col, var, true, var_agg, cudf::data_type(cudf::type_id::FLOAT64));
   this->reduction_test(col, std, true, std_agg, cudf::data_type(cudf::type_id::FLOAT64));
@@ -449,7 +483,7 @@ TYPED_TEST(MultiStepReductionTest, DISABLED_var_std)
     cudf::column_view(col_nulls).size() - cudf::column_view(col_nulls).null_count();
   auto replaced_array = replace_nulls(v, host_bools, T{0});
 
-  double var_nulls = calc_var(replaced_array, valid_count);
+  double var_nulls = calc_var(replaced_array, valid_count, ddof);
   double std_nulls = std::sqrt(var_nulls);
 
   this->reduction_test(
@@ -464,7 +498,7 @@ template <typename T>
 struct ReductionMultiStepErrorCheck : public ReductionTest<T> {
   void reduction_error_check(cudf::test::fixed_width_column_wrapper<T>& col,
                              bool succeeded_condition,
-                             std::unique_ptr<aggregation> const& agg,
+                             std::unique_ptr<reduce_aggregation> const& agg,
                              cudf::data_type output_dtype)
   {
     const cudf::column_view underlying_column = col;
@@ -496,7 +530,7 @@ TYPED_TEST(ReductionMultiStepErrorCheck, DISABLED_ErrorHandling)
   cudf::test::fixed_width_column_wrapper<T> col(v.begin(), v.end());
   cudf::test::fixed_width_column_wrapper<T> col_nulls = construct_null_column(v, host_bools);
 
-  bool is_input_accpetable = this->ret_non_arithmetic;
+  bool is_input_acceptable = this->ret_non_arithmetic;
 
   std::vector<cudf::data_type> dtypes(static_cast<int32_t>(cudf::type_id::NUM_TYPE_IDS) + 1);
   int i = 0;
@@ -511,14 +545,17 @@ TYPED_TEST(ReductionMultiStepErrorCheck, DISABLED_ErrorHandling)
   };
 
   auto evaluate = [&](cudf::data_type dtype) mutable {
-    bool expect_succeed = is_input_accpetable & is_supported_outdtype(dtype);
-    auto var_agg        = cudf::make_variance_aggregation(/*ddof = 1*/);
-    auto std_agg        = cudf::make_std_aggregation(/*ddof = 1*/);
-    this->reduction_error_check(col, expect_succeed, cudf::make_mean_aggregation(), dtype);
+    bool expect_succeed = is_input_acceptable & is_supported_outdtype(dtype);
+    auto const ddof     = 1;
+    auto var_agg        = cudf::make_variance_aggregation<reduce_aggregation>(ddof);
+    auto std_agg        = cudf::make_std_aggregation<reduce_aggregation>(ddof);
+    this->reduction_error_check(
+      col, expect_succeed, cudf::make_mean_aggregation<reduce_aggregation>(), dtype);
     this->reduction_error_check(col, expect_succeed, var_agg, dtype);
     this->reduction_error_check(col, expect_succeed, std_agg, dtype);
 
-    this->reduction_error_check(col_nulls, expect_succeed, cudf::make_mean_aggregation(), dtype);
+    this->reduction_error_check(
+      col_nulls, expect_succeed, cudf::make_mean_aggregation<reduce_aggregation>(), dtype);
     this->reduction_error_check(col_nulls, expect_succeed, var_agg, dtype);
     this->reduction_error_check(col_nulls, expect_succeed, std_agg, dtype);
     return;
@@ -534,7 +571,7 @@ struct ReductionDtypeTest : public cudf::test::BaseFixture {
   void reduction_test(std::vector<int>& int_values,
                       T_out expected_value,
                       bool succeeded_condition,
-                      std::unique_ptr<aggregation> const& agg,
+                      std::unique_ptr<reduce_aggregation> const& agg,
                       cudf::data_type out_dtype,
                       bool expected_overflow = false)
   {
@@ -561,7 +598,7 @@ struct ReductionDtypeTest : public cudf::test::BaseFixture {
 
 TEST_F(ReductionDtypeTest, all_null_output)
 {
-  auto sum_agg = cudf::make_sum_aggregation();
+  auto sum_agg = cudf::make_sum_aggregation<reduce_aggregation>();
 
   auto const col =
     cudf::test::fixed_point_column_wrapper<int32_t>{{0, 0, 0}, {0, 0, 0}, numeric::scale_type{-2}}
@@ -579,7 +616,7 @@ TEST_F(ReductionDtypeTest, different_precision)
   constexpr bool expected_overflow = true;
   std::vector<int> int_values({6, -14, 13, 109, -13, -20, 0, 98, 122, 123});
   int expected_value = std::accumulate(int_values.begin(), int_values.end(), 0);
-  auto sum_agg       = cudf::make_sum_aggregation();
+  auto sum_agg       = cudf::make_sum_aggregation<reduce_aggregation>();
 
   // over flow
   this->reduction_test<int8_t, int8_t>(int_values,
@@ -696,8 +733,8 @@ TEST_F(ReductionErrorTest, empty_column)
 {
   using T        = int32_t;
   auto statement = [](const cudf::column_view col) {
-    std::unique_ptr<cudf::scalar> result =
-      cudf::reduce(col, cudf::make_sum_aggregation(), cudf::data_type(cudf::type_id::INT64));
+    std::unique_ptr<cudf::scalar> result = cudf::reduce(
+      col, cudf::make_sum_aggregation<reduce_aggregation>(), cudf::data_type(cudf::type_id::INT64));
     EXPECT_EQ(result->is_valid(), false);
   };
 
@@ -759,8 +796,8 @@ TEST_P(ReductionParamTest, DISABLED_std_var)
 
   double var   = calc_var(int_values, int_values.size());
   double std   = std::sqrt(var);
-  auto var_agg = cudf::make_variance_aggregation(/*ddof = 1*/ ddof);
-  auto std_agg = cudf::make_std_aggregation(/*ddof = 1*/ ddof);
+  auto var_agg = cudf::make_variance_aggregation<reduce_aggregation>(ddof);
+  auto std_agg = cudf::make_std_aggregation<reduce_aggregation>(ddof);
 
   this->reduction_test(col, var, true, var_agg, cudf::data_type(cudf::type_id::FLOAT64));
   this->reduction_test(col, std, true, std_agg, cudf::data_type(cudf::type_id::FLOAT64));
@@ -789,7 +826,7 @@ struct StringReductionTest : public cudf::test::BaseFixture,
   void reduction_test(const cudf::column_view underlying_column,
                       std::string expected_value,
                       bool succeeded_condition,
-                      std::unique_ptr<aggregation> const& agg,
+                      std::unique_ptr<reduce_aggregation> const& agg,
                       cudf::data_type output_dtype = cudf::data_type{})
   {
     if (cudf::data_type{} == output_dtype) output_dtype = underlying_column.type();
@@ -853,11 +890,15 @@ TEST_P(StringReductionTest, MinMax)
   std::string expected_max_null_result = *(std::max_element(r_strings.begin(), r_strings.end()));
 
   // MIN
-  this->reduction_test(col, expected_min_result, succeed, cudf::make_min_aggregation());
-  this->reduction_test(col_nulls, expected_min_null_result, succeed, cudf::make_min_aggregation());
+  this->reduction_test(
+    col, expected_min_result, succeed, cudf::make_min_aggregation<reduce_aggregation>());
+  this->reduction_test(
+    col_nulls, expected_min_null_result, succeed, cudf::make_min_aggregation<reduce_aggregation>());
   // MAX
-  this->reduction_test(col, expected_max_result, succeed, cudf::make_max_aggregation());
-  this->reduction_test(col_nulls, expected_max_null_result, succeed, cudf::make_max_aggregation());
+  this->reduction_test(
+    col, expected_max_result, succeed, cudf::make_max_aggregation<reduce_aggregation>());
+  this->reduction_test(
+    col_nulls, expected_max_null_result, succeed, cudf::make_max_aggregation<reduce_aggregation>());
 
   // MINMAX
   auto result = cudf::minmax(col);
@@ -931,10 +972,11 @@ TEST_F(StringReductionTest, AllNull)
   cudf::data_type output_dtype = cudf::column_view(col_nulls).type();
 
   // MIN
-  auto result = cudf::reduce(col_nulls, cudf::make_min_aggregation(), output_dtype);
+  auto result =
+    cudf::reduce(col_nulls, cudf::make_min_aggregation<reduce_aggregation>(), output_dtype);
   EXPECT_FALSE(result->is_valid());
   // MAX
-  result = cudf::reduce(col_nulls, cudf::make_max_aggregation(), output_dtype);
+  result = cudf::reduce(col_nulls, cudf::make_max_aggregation<reduce_aggregation>(), output_dtype);
   EXPECT_FALSE(result->is_valid());
   // MINMAX
   auto mm_result = cudf::minmax(col_nulls);
@@ -957,8 +999,10 @@ TYPED_TEST(ReductionTest, Median)
     if (std::is_signed_v<T>) return 3.0;
     return 13.5;
   }();
-  this->reduction_test(
-    col, expected_value, this->ret_non_arithmetic, cudf::make_median_aggregation());
+  this->reduction_test(col,
+                       expected_value,
+                       this->ret_non_arithmetic,
+                       cudf::make_median_aggregation<reduce_aggregation>());
 
   auto col_odd              = cudf::split(col, {1})[1];
   double expected_value_odd = [] {
@@ -966,8 +1010,10 @@ TYPED_TEST(ReductionTest, Median)
     if (std::is_signed_v<T>) return 0.0;
     return 14.0;
   }();
-  this->reduction_test(
-    col_odd, expected_value_odd, this->ret_non_arithmetic, cudf::make_median_aggregation());
+  this->reduction_test(col_odd,
+                       expected_value_odd,
+                       this->ret_non_arithmetic,
+                       cudf::make_median_aggregation<reduce_aggregation>());
   // test with nulls
   cudf::test::fixed_width_column_wrapper<T> col_nulls = construct_null_column(v, host_bools);
   double expected_null_value                          = [] {
@@ -976,8 +1022,10 @@ TYPED_TEST(ReductionTest, Median)
     return 13.0;
   }();
 
-  this->reduction_test(
-    col_nulls, expected_null_value, this->ret_non_arithmetic, cudf::make_median_aggregation());
+  this->reduction_test(col_nulls,
+                       expected_null_value,
+                       this->ret_non_arithmetic,
+                       cudf::make_median_aggregation<reduce_aggregation>());
 
   auto col_nulls_odd             = cudf::split(col_nulls, {1})[1];
   double expected_null_value_odd = [] {
@@ -988,7 +1036,7 @@ TYPED_TEST(ReductionTest, Median)
   this->reduction_test(col_nulls_odd,
                        expected_null_value_odd,
                        this->ret_non_arithmetic,
-                       cudf::make_median_aggregation());
+                       cudf::make_median_aggregation<reduce_aggregation>());
 }
 
 TYPED_TEST(ReductionTest, Quantile)
@@ -1003,11 +1051,15 @@ TYPED_TEST(ReductionTest, Quantile)
   // test without nulls
   cudf::test::fixed_width_column_wrapper<T> col(v.begin(), v.end());
   double expected_value0 = std::is_same_v<T, bool> || std::is_unsigned_v<T> ? v[4] : v[6];
-  this->reduction_test(
-    col, expected_value0, this->ret_non_arithmetic, cudf::make_quantile_aggregation({0.0}, interp));
+  this->reduction_test(col,
+                       expected_value0,
+                       this->ret_non_arithmetic,
+                       cudf::make_quantile_aggregation<reduce_aggregation>({0.0}, interp));
   double expected_value1 = v[3];
-  this->reduction_test(
-    col, expected_value1, this->ret_non_arithmetic, cudf::make_quantile_aggregation({1.0}, interp));
+  this->reduction_test(col,
+                       expected_value1,
+                       this->ret_non_arithmetic,
+                       cudf::make_quantile_aggregation<reduce_aggregation>({1.0}, interp));
 
   // test with nulls
   cudf::test::fixed_width_column_wrapper<T> col_nulls = construct_null_column(v, host_bools);
@@ -1016,11 +1068,11 @@ TYPED_TEST(ReductionTest, Quantile)
   this->reduction_test(col_nulls,
                        expected_value0,
                        this->ret_non_arithmetic,
-                       cudf::make_quantile_aggregation({0}, interp));
+                       cudf::make_quantile_aggregation<reduce_aggregation>({0}, interp));
   this->reduction_test(col_nulls,
                        expected_null_value1,
                        this->ret_non_arithmetic,
-                       cudf::make_quantile_aggregation({1}, interp));
+                       cudf::make_quantile_aggregation<reduce_aggregation>({1}, interp));
 }
 
 TYPED_TEST(ReductionTest, UniqueCount)
@@ -1033,28 +1085,32 @@ TYPED_TEST(ReductionTest, UniqueCount)
   // test without nulls
   cudf::test::fixed_width_column_wrapper<T> col(v.begin(), v.end());
   cudf::size_type expected_value = std::is_same_v<T, bool> ? 2 : 6;
-  this->reduction_test(col,
-                       expected_value,
-                       this->ret_non_arithmetic,
-                       cudf::make_nunique_aggregation(cudf::null_policy::INCLUDE));
-  this->reduction_test(col,
-                       expected_value,
-                       this->ret_non_arithmetic,
-                       cudf::make_nunique_aggregation(cudf::null_policy::EXCLUDE));
+  this->reduction_test(
+    col,
+    expected_value,
+    this->ret_non_arithmetic,
+    cudf::make_nunique_aggregation<reduce_aggregation>(cudf::null_policy::INCLUDE));
+  this->reduction_test(
+    col,
+    expected_value,
+    this->ret_non_arithmetic,
+    cudf::make_nunique_aggregation<reduce_aggregation>(cudf::null_policy::EXCLUDE));
 
   // test with nulls
   cudf::test::fixed_width_column_wrapper<T> col_nulls = construct_null_column(v, host_bools);
   cudf::size_type expected_null_value0                = std::is_same_v<T, bool> ? 3 : 7;
   cudf::size_type expected_null_value1                = std::is_same_v<T, bool> ? 2 : 6;
 
-  this->reduction_test(col_nulls,
-                       expected_null_value0,
-                       this->ret_non_arithmetic,
-                       cudf::make_nunique_aggregation(cudf::null_policy::INCLUDE));
-  this->reduction_test(col_nulls,
-                       expected_null_value1,
-                       this->ret_non_arithmetic,
-                       cudf::make_nunique_aggregation(cudf::null_policy::EXCLUDE));
+  this->reduction_test(
+    col_nulls,
+    expected_null_value0,
+    this->ret_non_arithmetic,
+    cudf::make_nunique_aggregation<reduce_aggregation>(cudf::null_policy::INCLUDE));
+  this->reduction_test(
+    col_nulls,
+    expected_null_value1,
+    this->ret_non_arithmetic,
+    cudf::make_nunique_aggregation<reduce_aggregation>(cudf::null_policy::EXCLUDE));
 }
 
 template <typename T>
@@ -1079,7 +1135,8 @@ TYPED_TEST(FixedPointTestAllReps, FixedPointReductionProductZeroScale)
   auto const expected = std::accumulate(in.cbegin(), in.cend(), ONE, std::multiplies<decimalXX>());
   auto const out_type = static_cast<cudf::column_view>(column).type();
 
-  auto const result        = cudf::reduce(column, cudf::make_product_aggregation(), out_type);
+  auto const result =
+    cudf::reduce(column, cudf::make_product_aggregation<reduce_aggregation>(), out_type);
   auto const result_scalar = static_cast<cudf::scalar_type_t<decimalXX>*>(result.get());
   auto const result_fp     = decimalXX{result_scalar->value()};
 
@@ -1100,7 +1157,8 @@ TYPED_TEST(FixedPointTestAllReps, FixedPointReductionProduct)
     auto const out_type = static_cast<cudf::column_view>(column).type();
     auto const expected = decimalXX{scaled_integer<RepType>{36, scale_type{i * 6}}};
 
-    auto const result        = cudf::reduce(column, cudf::make_product_aggregation(), out_type);
+    auto const result =
+      cudf::reduce(column, cudf::make_product_aggregation<reduce_aggregation>(), out_type);
     auto const result_scalar = static_cast<cudf::scalar_type_t<decimalXX>*>(result.get());
 
     EXPECT_EQ(result_scalar->fixed_point_value(), expected);
@@ -1120,7 +1178,8 @@ TYPED_TEST(FixedPointTestAllReps, FixedPointReductionProductWithNulls)
     auto const out_type = static_cast<cudf::column_view>(column).type();
     auto const expected = decimalXX{scaled_integer<RepType>{6, scale_type{i * 3}}};
 
-    auto const result        = cudf::reduce(column, cudf::make_product_aggregation(), out_type);
+    auto const result =
+      cudf::reduce(column, cudf::make_product_aggregation<reduce_aggregation>(), out_type);
     auto const result_scalar = static_cast<cudf::scalar_type_t<decimalXX>*>(result.get());
 
     EXPECT_EQ(result_scalar->fixed_point_value(), expected);
@@ -1141,7 +1200,8 @@ TYPED_TEST(FixedPointTestAllReps, FixedPointReductionSum)
     auto const expected = decimalXX{scaled_integer<RepType>{10, scale}};
     auto const out_type = static_cast<cudf::column_view>(column).type();
 
-    auto const result        = cudf::reduce(column, cudf::make_sum_aggregation(), out_type);
+    auto const result =
+      cudf::reduce(column, cudf::make_sum_aggregation<reduce_aggregation>(), out_type);
     auto const result_scalar = static_cast<cudf::scalar_type_t<decimalXX>*>(result.get());
 
     EXPECT_EQ(result_scalar->fixed_point_value(), expected);
@@ -1165,7 +1225,8 @@ TYPED_TEST(FixedPointTestAllReps, FixedPointReductionSumAlternate)
   auto const expected = std::accumulate(in.cbegin(), in.cend(), ZERO, std::plus<decimalXX>());
   auto const out_type = static_cast<cudf::column_view>(column).type();
 
-  auto const result        = cudf::reduce(column, cudf::make_sum_aggregation(), out_type);
+  auto const result =
+    cudf::reduce(column, cudf::make_sum_aggregation<reduce_aggregation>(), out_type);
   auto const result_scalar = static_cast<cudf::scalar_type_t<decimalXX>*>(result.get());
 
   EXPECT_EQ(result_scalar->fixed_point_value(), expected);
@@ -1185,7 +1246,8 @@ TYPED_TEST(FixedPointTestAllReps, FixedPointReductionSumFractional)
     auto const out_type = static_cast<cudf::column_view>(column).type();
     auto const expected = decimalXX{scaled_integer<RepType>{666, scale}};
 
-    auto const result        = cudf::reduce(column, cudf::make_sum_aggregation(), out_type);
+    auto const result =
+      cudf::reduce(column, cudf::make_sum_aggregation<reduce_aggregation>(), out_type);
     auto const result_scalar = static_cast<cudf::scalar_type_t<decimalXX>*>(result.get());
 
     EXPECT_EQ(result_scalar->fixed_point_value(), expected);
@@ -1208,7 +1270,8 @@ TYPED_TEST(FixedPointTestAllReps, FixedPointReductionSumLarge)
     auto const expected_value = std::accumulate(values.cbegin(), values.cend(), RepType{0});
     auto const expected       = decimalXX{scaled_integer<RepType>{expected_value, scale}};
 
-    auto const result        = cudf::reduce(column, cudf::make_sum_aggregation(), out_type);
+    auto const result =
+      cudf::reduce(column, cudf::make_sum_aggregation<reduce_aggregation>(), out_type);
     auto const result_scalar = static_cast<cudf::scalar_type_t<decimalXX>*>(result.get());
 
     EXPECT_EQ(result_scalar->fixed_point_value(), expected);
@@ -1228,7 +1291,8 @@ TYPED_TEST(FixedPointTestAllReps, FixedPointReductionMin)
     auto const column   = fp_wrapper{{1, 2, 3, 4}, scale};
     auto const out_type = static_cast<cudf::column_view>(column).type();
 
-    auto const result        = cudf::reduce(column, cudf::make_min_aggregation(), out_type);
+    auto const result =
+      cudf::reduce(column, cudf::make_min_aggregation<reduce_aggregation>(), out_type);
     auto const result_scalar = static_cast<cudf::scalar_type_t<decimalXX>*>(result.get());
 
     EXPECT_EQ(result_scalar->fixed_point_value(), ONE);
@@ -1249,7 +1313,8 @@ TYPED_TEST(FixedPointTestAllReps, FixedPointReductionMinLarge)
     auto const out_type = static_cast<cudf::column_view>(column).type();
     auto const expected = decimalXX{0, scale};
 
-    auto const result        = cudf::reduce(column, cudf::make_min_aggregation(), out_type);
+    auto const result =
+      cudf::reduce(column, cudf::make_min_aggregation<reduce_aggregation>(), out_type);
     auto const result_scalar = static_cast<cudf::scalar_type_t<decimalXX>*>(result.get());
 
     EXPECT_EQ(result_scalar->fixed_point_value(), expected);
@@ -1269,7 +1334,8 @@ TYPED_TEST(FixedPointTestAllReps, FixedPointReductionMax)
     auto const column   = fp_wrapper{{1, 2, 3, 4}, scale};
     auto const out_type = static_cast<cudf::column_view>(column).type();
 
-    auto const result        = cudf::reduce(column, cudf::make_max_aggregation(), out_type);
+    auto const result =
+      cudf::reduce(column, cudf::make_max_aggregation<reduce_aggregation>(), out_type);
     auto const result_scalar = static_cast<cudf::scalar_type_t<decimalXX>*>(result.get());
 
     EXPECT_EQ(result_scalar->fixed_point_value(), FOUR);
@@ -1290,7 +1356,8 @@ TYPED_TEST(FixedPointTestAllReps, FixedPointReductionMaxLarge)
     auto const out_type = static_cast<cudf::column_view>(column).type();
     auto const expected = decimalXX{scaled_integer<RepType>{42, scale}};
 
-    auto const result        = cudf::reduce(column, cudf::make_max_aggregation(), out_type);
+    auto const result =
+      cudf::reduce(column, cudf::make_max_aggregation<reduce_aggregation>(), out_type);
     auto const result_scalar = static_cast<cudf::scalar_type_t<decimalXX>*>(result.get());
 
     EXPECT_EQ(result_scalar->fixed_point_value(), expected);
@@ -1309,7 +1376,8 @@ TYPED_TEST(FixedPointTestAllReps, FixedPointReductionNUnique)
     auto const column   = fp_wrapper{{1, 1, 2, 2, 3, 3, 4, 4}, scale};
     auto const out_type = static_cast<cudf::column_view>(column).type();
 
-    auto const result        = cudf::reduce(column, cudf::make_nunique_aggregation(), out_type);
+    auto const result =
+      cudf::reduce(column, cudf::make_nunique_aggregation<reduce_aggregation>(), out_type);
     auto const result_scalar = static_cast<cudf::scalar_type_t<cudf::size_type>*>(result.get());
 
     EXPECT_EQ(result_scalar->value(), 4);
@@ -1329,7 +1397,8 @@ TYPED_TEST(FixedPointTestAllReps, FixedPointReductionSumOfSquares)
     auto const out_type = static_cast<cudf::column_view>(column).type();
     auto const expected = decimalXX{scaled_integer<RepType>{30, scale_type{i * 2}}};
 
-    auto const result = cudf::reduce(column, cudf::make_sum_of_squares_aggregation(), out_type);
+    auto const result =
+      cudf::reduce(column, cudf::make_sum_of_squares_aggregation<reduce_aggregation>(), out_type);
     auto const result_scalar = static_cast<cudf::scalar_type_t<decimalXX>*>(result.get());
 
     EXPECT_EQ(result_scalar->fixed_point_value(), expected);
@@ -1349,7 +1418,8 @@ TYPED_TEST(FixedPointTestAllReps, FixedPointReductionMedianOddNumberOfElements)
     auto const out_type = static_cast<cudf::column_view>(column).type();
     auto const expected = decimalXX{scaled_integer<RepType>{2, scale}};
 
-    auto const result        = cudf::reduce(column, cudf::make_median_aggregation(), out_type);
+    auto const result =
+      cudf::reduce(column, cudf::make_median_aggregation<reduce_aggregation>(), out_type);
     auto const result_scalar = static_cast<cudf::scalar_type_t<decimalXX>*>(result.get());
 
     EXPECT_EQ(result_scalar->fixed_point_value(), expected);
@@ -1369,7 +1439,8 @@ TYPED_TEST(FixedPointTestAllReps, FixedPointReductionMedianEvenNumberOfElements)
     auto const out_type = static_cast<cudf::column_view>(column).type();
     auto const expected = decimalXX{scaled_integer<RepType>{25, scale}};
 
-    auto const result        = cudf::reduce(column, cudf::make_median_aggregation(), out_type);
+    auto const result =
+      cudf::reduce(column, cudf::make_median_aggregation<reduce_aggregation>(), out_type);
     auto const result_scalar = static_cast<cudf::scalar_type_t<decimalXX>*>(result.get());
 
     EXPECT_EQ(result_scalar->fixed_point_value(), expected);
@@ -1391,7 +1462,9 @@ TYPED_TEST(FixedPointTestAllReps, FixedPointReductionQuantile)
     for (auto const i : {0, 1, 2, 3, 4}) {
       auto const expected = decimalXX{scaled_integer<RepType>{i + 1, scale}};
       auto const result   = cudf::reduce(
-        column, cudf::make_quantile_aggregation({i / 4.0}, cudf::interpolation::LINEAR), out_type);
+        column,
+        cudf::make_quantile_aggregation<reduce_aggregation>({i / 4.0}, cudf::interpolation::LINEAR),
+        out_type);
       auto const result_scalar = static_cast<cudf::scalar_type_t<decimalXX>*>(result.get());
       EXPECT_EQ(result_scalar->fixed_point_value(), expected);
     }
@@ -1414,7 +1487,9 @@ TYPED_TEST(FixedPointTestAllReps, FixedPointReductionNthElement)
     for (auto const i : {0, 1, 2, 3}) {
       auto const expected = decimalXX{scaled_integer<RepType>{values[i], scale}};
       auto const result   = cudf::reduce(
-        column, cudf::make_nth_element_aggregation(i, cudf::null_policy::INCLUDE), out_type);
+        column,
+        cudf::make_nth_element_aggregation<reduce_aggregation>(i, cudf::null_policy::INCLUDE),
+        out_type);
       auto const result_scalar = static_cast<cudf::scalar_type_t<decimalXX>*>(result.get());
       EXPECT_EQ(result_scalar->fixed_point_value(), expected);
     }
@@ -1435,8 +1510,9 @@ TEST_F(Decimal128Only, Decimal128ProductReduction)
     auto const column   = fp_wrapper{{2, 2, 2, 2, 2, 2, 2, 2, 2}, scale};
     auto const expected = decimal128{scaled_integer<RepType>{512, scale_type{i * 9}}};
 
-    auto const out_type      = cudf::data_type{cudf::type_id::DECIMAL128, scale};
-    auto const result        = cudf::reduce(column, cudf::make_product_aggregation(), out_type);
+    auto const out_type = cudf::data_type{cudf::type_id::DECIMAL128, scale};
+    auto const result =
+      cudf::reduce(column, cudf::make_product_aggregation<reduce_aggregation>(), out_type);
     auto const result_scalar = static_cast<cudf::scalar_type_t<decimal128>*>(result.get());
 
     EXPECT_EQ(result_scalar->fixed_point_value(), expected);
@@ -1454,8 +1530,9 @@ TEST_F(Decimal128Only, Decimal128ProductReduction2)
     auto const column   = fp_wrapper{{1, 2, 3, 4, 5, 6}, scale};
     auto const expected = decimal128{scaled_integer<RepType>{720, scale_type{i * 6}}};
 
-    auto const out_type      = cudf::data_type{cudf::type_id::DECIMAL128, scale};
-    auto const result        = cudf::reduce(column, cudf::make_product_aggregation(), out_type);
+    auto const out_type = cudf::data_type{cudf::type_id::DECIMAL128, scale};
+    auto const result =
+      cudf::reduce(column, cudf::make_product_aggregation<reduce_aggregation>(), out_type);
     auto const result_scalar = static_cast<cudf::scalar_type_t<decimal128>*>(result.get());
 
     EXPECT_EQ(result_scalar->fixed_point_value(), expected);
@@ -1474,8 +1551,9 @@ TEST_F(Decimal128Only, Decimal128ProductReduction3)
   auto const lowest   = cuda::std::numeric_limits<RepType>::lowest();
   auto const expected = decimal128{scaled_integer<RepType>{lowest, scale}};
 
-  auto const out_type      = cudf::data_type{cudf::type_id::DECIMAL128, scale};
-  auto const result        = cudf::reduce(column, cudf::make_product_aggregation(), out_type);
+  auto const out_type = cudf::data_type{cudf::type_id::DECIMAL128, scale};
+  auto const result =
+    cudf::reduce(column, cudf::make_product_aggregation<reduce_aggregation>(), out_type);
   auto const result_scalar = static_cast<cudf::scalar_type_t<decimal128>*>(result.get());
 
   EXPECT_EQ(result_scalar->fixed_point_value(), expected);
@@ -1507,40 +1585,56 @@ TYPED_TEST(ReductionTest, NthElement)
     auto const index         = mod(n, v.size());
     T expected_value_nonull  = v[index];
     bool const expected_null = !host_bools[index];
-    this->reduction_test(col,
-                         expected_value_nonull,
-                         true,
-                         cudf::make_nth_element_aggregation(n, cudf::null_policy::INCLUDE));
-    this->reduction_test(col,
-                         expected_value_nonull,
-                         true,
-                         cudf::make_nth_element_aggregation(n, cudf::null_policy::EXCLUDE));
-    this->reduction_test(col_nulls,
-                         expected_value_nonull,
-                         true,
-                         cudf::make_nth_element_aggregation(n, cudf::null_policy::INCLUDE),
-                         cudf::data_type{},
-                         expected_null);
+    this->reduction_test(
+      col,
+      expected_value_nonull,
+      true,
+      cudf::make_nth_element_aggregation<reduce_aggregation>(n, cudf::null_policy::INCLUDE));
+    this->reduction_test(
+      col,
+      expected_value_nonull,
+      true,
+      cudf::make_nth_element_aggregation<reduce_aggregation>(n, cudf::null_policy::EXCLUDE));
+    this->reduction_test(
+      col_nulls,
+      expected_value_nonull,
+      true,
+      cudf::make_nth_element_aggregation<reduce_aggregation>(n, cudf::null_policy::INCLUDE),
+      cudf::data_type{},
+      expected_null);
   }
   // valid only
   for (cudf::size_type n :
        {-valid_count, -valid_count / 2, -2, -1, 0, 1, 2, valid_count / 2, valid_count - 1}) {
     T expected_value_null = v_valid[mod(n, v_valid.size())];
-    this->reduction_test(col_nulls,
-                         expected_value_null,
-                         true,
-                         cudf::make_nth_element_aggregation(n, cudf::null_policy::EXCLUDE));
+    this->reduction_test(
+      col_nulls,
+      expected_value_null,
+      true,
+      cudf::make_nth_element_aggregation<reduce_aggregation>(n, cudf::null_policy::EXCLUDE));
   }
   // error cases
   for (cudf::size_type n : {-input_size - 1, input_size}) {
     this->reduction_test(
-      col, T{}, false, cudf::make_nth_element_aggregation(n, cudf::null_policy::INCLUDE));
+      col,
+      T{},
+      false,
+      cudf::make_nth_element_aggregation<reduce_aggregation>(n, cudf::null_policy::INCLUDE));
     this->reduction_test(
-      col_nulls, T{}, false, cudf::make_nth_element_aggregation(n, cudf::null_policy::INCLUDE));
+      col_nulls,
+      T{},
+      false,
+      cudf::make_nth_element_aggregation<reduce_aggregation>(n, cudf::null_policy::INCLUDE));
     this->reduction_test(
-      col, T{}, false, cudf::make_nth_element_aggregation(n, cudf::null_policy::EXCLUDE));
+      col,
+      T{},
+      false,
+      cudf::make_nth_element_aggregation<reduce_aggregation>(n, cudf::null_policy::EXCLUDE));
     this->reduction_test(
-      col_nulls, T{}, false, cudf::make_nth_element_aggregation(n, cudf::null_policy::EXCLUDE));
+      col_nulls,
+      T{},
+      false,
+      cudf::make_nth_element_aggregation<reduce_aggregation>(n, cudf::null_policy::EXCLUDE));
   }
 }
 
@@ -1564,25 +1658,25 @@ TEST_P(DictionaryStringReductionTest, MinMax)
   this->reduction_test(col,
                        *(std::min_element(host_strings.begin(), host_strings.end())),
                        true,
-                       cudf::make_min_aggregation(),
+                       cudf::make_min_aggregation<reduce_aggregation>(),
                        output_type);
   // sliced
   this->reduction_test(cudf::slice(col, {1, 7}).front(),
                        *(std::min_element(host_strings.begin() + 1, host_strings.begin() + 7)),
                        true,
-                       cudf::make_min_aggregation(),
+                       cudf::make_min_aggregation<reduce_aggregation>(),
                        output_type);
   // MAX
   this->reduction_test(col,
                        *(std::max_element(host_strings.begin(), host_strings.end())),
                        true,
-                       cudf::make_max_aggregation(),
+                       cudf::make_max_aggregation<reduce_aggregation>(),
                        output_type);
   // sliced
   this->reduction_test(cudf::slice(col, {1, 7}).front(),
                        *(std::max_element(host_strings.begin() + 1, host_strings.begin() + 7)),
                        true,
-                       cudf::make_max_aggregation(),
+                       cudf::make_max_aggregation<reduce_aggregation>(),
                        output_type);
 }
 
@@ -1605,48 +1699,60 @@ TYPED_TEST(DictionaryAnyAllTest, AnyAll)
   // without nulls
   {
     cudf::test::dictionary_column_wrapper<T> all_col(v_all.begin(), v_all.end());
-    this->reduction_test(all_col, true, true, cudf::make_any_aggregation(), output_dtype);
-    this->reduction_test(all_col, true, true, cudf::make_all_aggregation(), output_dtype);
+    this->reduction_test(
+      all_col, true, true, cudf::make_any_aggregation<reduce_aggregation>(), output_dtype);
+    this->reduction_test(
+      all_col, true, true, cudf::make_all_aggregation<reduce_aggregation>(), output_dtype);
     cudf::test::dictionary_column_wrapper<T> none_col(v_none.begin(), v_none.end());
-    this->reduction_test(none_col, false, true, cudf::make_any_aggregation(), output_dtype);
-    this->reduction_test(none_col, false, true, cudf::make_all_aggregation(), output_dtype);
+    this->reduction_test(
+      none_col, false, true, cudf::make_any_aggregation<reduce_aggregation>(), output_dtype);
+    this->reduction_test(
+      none_col, false, true, cudf::make_all_aggregation<reduce_aggregation>(), output_dtype);
     cudf::test::dictionary_column_wrapper<T> some_col(v_some.begin(), v_some.end());
-    this->reduction_test(some_col, true, true, cudf::make_any_aggregation(), output_dtype);
-    this->reduction_test(some_col, false, true, cudf::make_all_aggregation(), output_dtype);
+    this->reduction_test(
+      some_col, true, true, cudf::make_any_aggregation<reduce_aggregation>(), output_dtype);
+    this->reduction_test(
+      some_col, false, true, cudf::make_all_aggregation<reduce_aggregation>(), output_dtype);
     // sliced test
     this->reduction_test(cudf::slice(some_col, {1, 3}).front(),
                          true,
                          true,
-                         cudf::make_any_aggregation(),
+                         cudf::make_any_aggregation<reduce_aggregation>(),
                          output_dtype);
     this->reduction_test(cudf::slice(some_col, {1, 2}).front(),
                          true,
                          true,
-                         cudf::make_all_aggregation(),
+                         cudf::make_all_aggregation<reduce_aggregation>(),
                          output_dtype);
   }
   // with nulls
   {
     std::vector<bool> valid({1, 1, 0, 1});
     cudf::test::dictionary_column_wrapper<T> all_col(v_all.begin(), v_all.end(), valid.begin());
-    this->reduction_test(all_col, true, true, cudf::make_any_aggregation(), output_dtype);
-    this->reduction_test(all_col, true, true, cudf::make_all_aggregation(), output_dtype);
+    this->reduction_test(
+      all_col, true, true, cudf::make_any_aggregation<reduce_aggregation>(), output_dtype);
+    this->reduction_test(
+      all_col, true, true, cudf::make_all_aggregation<reduce_aggregation>(), output_dtype);
     cudf::test::dictionary_column_wrapper<T> none_col(v_none.begin(), v_none.end(), valid.begin());
-    this->reduction_test(none_col, false, true, cudf::make_any_aggregation(), output_dtype);
-    this->reduction_test(none_col, false, true, cudf::make_all_aggregation(), output_dtype);
+    this->reduction_test(
+      none_col, false, true, cudf::make_any_aggregation<reduce_aggregation>(), output_dtype);
+    this->reduction_test(
+      none_col, false, true, cudf::make_all_aggregation<reduce_aggregation>(), output_dtype);
     cudf::test::dictionary_column_wrapper<T> some_col(v_some.begin(), v_some.end(), valid.begin());
-    this->reduction_test(some_col, true, true, cudf::make_any_aggregation(), output_dtype);
-    this->reduction_test(some_col, false, true, cudf::make_all_aggregation(), output_dtype);
+    this->reduction_test(
+      some_col, true, true, cudf::make_any_aggregation<reduce_aggregation>(), output_dtype);
+    this->reduction_test(
+      some_col, false, true, cudf::make_all_aggregation<reduce_aggregation>(), output_dtype);
     // sliced test
     this->reduction_test(cudf::slice(some_col, {0, 3}).front(),
                          true,
                          true,
-                         cudf::make_any_aggregation(),
+                         cudf::make_any_aggregation<reduce_aggregation>(),
                          output_dtype);
     this->reduction_test(cudf::slice(some_col, {1, 4}).front(),
                          true,
                          true,
-                         cudf::make_all_aggregation(),
+                         cudf::make_all_aggregation<reduce_aggregation>(),
                          output_dtype);
   }
 }
@@ -1667,8 +1773,11 @@ TYPED_TEST(DictionaryReductionTest, Sum)
   cudf::test::dictionary_column_wrapper<T> col(v.begin(), v.end());
 
   T expected_value = std::accumulate(v.begin(), v.end(), T{0});
-  this->reduction_test(
-    col, expected_value, this->ret_non_arithmetic, cudf::make_sum_aggregation(), output_type);
+  this->reduction_test(col,
+                       expected_value,
+                       this->ret_non_arithmetic,
+                       cudf::make_sum_aggregation<reduce_aggregation>(),
+                       output_type);
 
   // test with nulls
   std::vector<bool> validity({1, 1, 0, 0, 1, 1, 1, 1});
@@ -1677,8 +1786,11 @@ TYPED_TEST(DictionaryReductionTest, Sum)
     auto const r = replace_nulls(v, validity, T{0});
     return std::accumulate(r.begin(), r.end(), T{0});
   }();
-  this->reduction_test(
-    col_nulls, expected_value, this->ret_non_arithmetic, cudf::make_sum_aggregation(), output_type);
+  this->reduction_test(col_nulls,
+                       expected_value,
+                       this->ret_non_arithmetic,
+                       cudf::make_sum_aggregation<reduce_aggregation>(),
+                       output_type);
 }
 
 TYPED_TEST(DictionaryReductionTest, Product)
@@ -1698,7 +1810,7 @@ TYPED_TEST(DictionaryReductionTest, Product)
   this->reduction_test(col,
                        calc_prod(v),  // expected result
                        this->ret_non_arithmetic,
-                       cudf::make_product_aggregation(),
+                       cudf::make_product_aggregation<reduce_aggregation>(),
                        output_type);
 
   // test with nulls
@@ -1708,7 +1820,7 @@ TYPED_TEST(DictionaryReductionTest, Product)
   this->reduction_test(col_nulls,
                        calc_prod(replace_nulls(v, validity, T{1})),  // expected
                        this->ret_non_arithmetic,
-                       cudf::make_product_aggregation(),
+                       cudf::make_product_aggregation<reduce_aggregation>(),
                        output_type);
 }
 
@@ -1729,7 +1841,7 @@ TYPED_TEST(DictionaryReductionTest, SumOfSquare)
   this->reduction_test(col,
                        calc_reduction(v),
                        this->ret_non_arithmetic,
-                       cudf::make_sum_of_squares_aggregation(),
+                       cudf::make_sum_of_squares_aggregation<reduce_aggregation>(),
                        output_type);
 
   // test with nulls
@@ -1739,7 +1851,7 @@ TYPED_TEST(DictionaryReductionTest, SumOfSquare)
   this->reduction_test(col_nulls,
                        calc_reduction(replace_nulls(v, validity, T{0})),  // expected
                        this->ret_non_arithmetic,
-                       cudf::make_sum_of_squares_aggregation(),
+                       cudf::make_sum_of_squares_aggregation<reduce_aggregation>(),
                        output_type);
 }
 
@@ -1761,7 +1873,7 @@ TYPED_TEST(DictionaryReductionTest, Mean)
   this->reduction_test(col,
                        calc_mean(v, v.size()),  // expected_value,
                        true,
-                       cudf::make_mean_aggregation(),
+                       cudf::make_mean_aggregation<reduce_aggregation>(),
                        output_type);
 
   // test with nulls
@@ -1772,7 +1884,7 @@ TYPED_TEST(DictionaryReductionTest, Mean)
   this->reduction_test(col_nulls,
                        calc_mean(replace_nulls(v, validity, T{0}), valid_count),
                        true,
-                       cudf::make_mean_aggregation(),
+                       cudf::make_mean_aggregation<reduce_aggregation>(),
                        output_type);
 }
 
@@ -1787,24 +1899,24 @@ TYPED_TEST(DictionaryReductionTest, DISABLED_VarStd)
   std::vector<T> v = convert_values<T>(int_values);
   cudf::data_type output_type{cudf::type_to_id<double>()};
 
-  auto calc_var = [](std::vector<T> const& v, cudf::size_type valid_count) {
+  auto calc_var = [](std::vector<T> const& v, cudf::size_type valid_count, cudf::size_type ddof) {
     double mean = std::accumulate(v.cbegin(), v.cend(), double{0});
     mean /= valid_count;
     double sum_of_sq = std::accumulate(
       v.cbegin(), v.cend(), double{0}, [](double acc, TypeParam i) { return acc + i * i; });
-    cudf::size_type ddof = 1;
-    auto const div       = valid_count - ddof;
-    double var           = sum_of_sq / div - ((mean * mean) * valid_count) / div;
+    auto const div = valid_count - ddof;
+    double var     = sum_of_sq / div - ((mean * mean) * valid_count) / div;
     return var;
   };
 
   // test without nulls
   cudf::test::dictionary_column_wrapper<T> col(v.begin(), v.end());
 
-  double var   = calc_var(v, v.size());
-  double std   = std::sqrt(var);
-  auto var_agg = cudf::make_variance_aggregation(/*ddof =*/1);
-  auto std_agg = cudf::make_std_aggregation(/*ddof =*/1);
+  cudf::size_type const ddof = 1;
+  double var                 = calc_var(v, v.size(), ddof);
+  double std                 = std::sqrt(var);
+  auto var_agg               = cudf::make_variance_aggregation<reduce_aggregation>(ddof);
+  auto std_agg               = cudf::make_std_aggregation<reduce_aggregation>(ddof);
 
   this->reduction_test(col, var, true, var_agg, output_type);
   this->reduction_test(col, std, true, std_agg, output_type);
@@ -1813,9 +1925,9 @@ TYPED_TEST(DictionaryReductionTest, DISABLED_VarStd)
   std::vector<bool> validity({1, 1, 0, 1, 1, 1, 0, 1});
   cudf::test::dictionary_column_wrapper<T> col_nulls(v.begin(), v.end(), validity.begin());
 
-  cudf::size_type valid_count = std::count(validity.begin(), validity.end(), true);
+  cudf::size_type const valid_count = std::count(validity.begin(), validity.end(), true);
 
-  double var_nulls = calc_var(replace_nulls(v, validity, T{0}), valid_count);
+  double var_nulls = calc_var(replace_nulls(v, validity, T{0}), valid_count, ddof);
   double std_nulls = std::sqrt(var_nulls);
 
   this->reduction_test(col_nulls, var_nulls, true, var_agg, output_type);
@@ -1832,27 +1944,30 @@ TYPED_TEST(DictionaryReductionTest, NthElement)
   // test without nulls
   cudf::test::dictionary_column_wrapper<T> col(v.begin(), v.end());
   cudf::size_type n = 5;
-  this->reduction_test(col,
-                       v[n],  // expected_value,
-                       true,
-                       cudf::make_nth_element_aggregation(n, cudf::null_policy::INCLUDE),
-                       output_type);
+  this->reduction_test(
+    col,
+    v[n],  // expected_value,
+    true,
+    cudf::make_nth_element_aggregation<reduce_aggregation>(n, cudf::null_policy::INCLUDE),
+    output_type);
 
   // test with nulls
   std::vector<bool> validity({1, 1, 0, 1, 1, 1, 0, 1});
   cudf::test::dictionary_column_wrapper<T> col_nulls(v.begin(), v.end(), validity.begin());
 
-  this->reduction_test(col_nulls,
-                       v[n],  // expected_value,
-                       true,
-                       cudf::make_nth_element_aggregation(n, cudf::null_policy::INCLUDE),
-                       output_type);
-  this->reduction_test(col_nulls,
-                       v[2],  // null element
-                       true,
-                       cudf::make_nth_element_aggregation(2, cudf::null_policy::INCLUDE),
-                       output_type,
-                       true);
+  this->reduction_test(
+    col_nulls,
+    v[n],  // expected_value,
+    true,
+    cudf::make_nth_element_aggregation<reduce_aggregation>(n, cudf::null_policy::INCLUDE),
+    output_type);
+  this->reduction_test(
+    col_nulls,
+    v[2],  // null element
+    true,
+    cudf::make_nth_element_aggregation<reduce_aggregation>(2, cudf::null_policy::INCLUDE),
+    output_type,
+    true);
 }
 
 TYPED_TEST(DictionaryReductionTest, UniqueCount)
@@ -1864,26 +1979,29 @@ TYPED_TEST(DictionaryReductionTest, UniqueCount)
 
   // test without nulls
   cudf::test::dictionary_column_wrapper<T> col(v.begin(), v.end());
-  this->reduction_test(col,
-                       6,
-                       this->ret_non_arithmetic,
-                       cudf::make_nunique_aggregation(cudf::null_policy::INCLUDE),
-                       output_type);
+  this->reduction_test(
+    col,
+    6,
+    this->ret_non_arithmetic,
+    cudf::make_nunique_aggregation<reduce_aggregation>(cudf::null_policy::INCLUDE),
+    output_type);
 
   // test with nulls
   std::vector<bool> validity({1, 1, 1, 0, 1, 1, 1, 1});
   cudf::test::dictionary_column_wrapper<T> col_nulls(v.begin(), v.end(), validity.begin());
 
-  this->reduction_test(col_nulls,
-                       7,
-                       this->ret_non_arithmetic,
-                       cudf::make_nunique_aggregation(cudf::null_policy::INCLUDE),
-                       output_type);
-  this->reduction_test(col_nulls,
-                       6,
-                       this->ret_non_arithmetic,
-                       cudf::make_nunique_aggregation(cudf::null_policy::EXCLUDE),
-                       output_type);
+  this->reduction_test(
+    col_nulls,
+    7,
+    this->ret_non_arithmetic,
+    cudf::make_nunique_aggregation<reduce_aggregation>(cudf::null_policy::INCLUDE),
+    output_type);
+  this->reduction_test(
+    col_nulls,
+    6,
+    this->ret_non_arithmetic,
+    cudf::make_nunique_aggregation<reduce_aggregation>(cudf::null_policy::EXCLUDE),
+    output_type);
 }
 
 TYPED_TEST(DictionaryReductionTest, Median)
@@ -1898,7 +2016,7 @@ TYPED_TEST(DictionaryReductionTest, Median)
   this->reduction_test(col,
                        (std::is_signed_v<T>) ? 3.0 : 13.5,
                        this->ret_non_arithmetic,
-                       cudf::make_median_aggregation(),
+                       cudf::make_median_aggregation<reduce_aggregation>(),
                        output_type);
 
   // test with nulls
@@ -1907,7 +2025,7 @@ TYPED_TEST(DictionaryReductionTest, Median)
   this->reduction_test(col_nulls,
                        (std::is_signed_v<T>) ? 0.0 : 13.0,
                        this->ret_non_arithmetic,
-                       cudf::make_median_aggregation(),
+                       cudf::make_median_aggregation<reduce_aggregation>(),
                        output_type);
 }
 
@@ -1925,12 +2043,12 @@ TYPED_TEST(DictionaryReductionTest, Quantile)
   this->reduction_test(col,
                        expected_value,
                        this->ret_non_arithmetic,
-                       cudf::make_quantile_aggregation({0.0}, interp),
+                       cudf::make_quantile_aggregation<reduce_aggregation>({0.0}, interp),
                        output_type);
   this->reduction_test(col,
                        64.0,
                        this->ret_non_arithmetic,
-                       cudf::make_quantile_aggregation({1.0}, interp),
+                       cudf::make_quantile_aggregation<reduce_aggregation>({1.0}, interp),
                        output_type);
 
   // test with nulls
@@ -1940,12 +2058,12 @@ TYPED_TEST(DictionaryReductionTest, Quantile)
   this->reduction_test(col_nulls,
                        expected_value,
                        this->ret_non_arithmetic,
-                       cudf::make_quantile_aggregation({0}, interp),
+                       cudf::make_quantile_aggregation<reduce_aggregation>({0}, interp),
                        output_type);
   this->reduction_test(col_nulls,
                        45.0,
                        this->ret_non_arithmetic,
-                       cudf::make_quantile_aggregation({1}, interp),
+                       cudf::make_quantile_aggregation<reduce_aggregation>({1}, interp),
                        output_type);
 }
 
@@ -1954,7 +2072,7 @@ struct ListReductionTest : public cudf::test::BaseFixture {
                       cudf::column_view const& expected_value,
                       bool succeeded_condition,
                       bool is_valid,
-                      std::unique_ptr<aggregation> const& agg)
+                      std::unique_ptr<reduce_aggregation> const& agg)
   {
     auto statement = [&]() {
       std::unique_ptr<cudf::scalar> result =
@@ -1983,27 +2101,30 @@ TEST_F(ListReductionTest, ListReductionNthElement)
 
   // test without nulls
   LCW col{{-3}, {2, 1}, {0, 5, -3}, {-2}, {}, {28}};
-  this->reduction_test(col,
-                       ElementCol{0, 5, -3},  // expected_value,
-                       true,
-                       true,
-                       cudf::make_nth_element_aggregation(2, cudf::null_policy::INCLUDE));
+  this->reduction_test(
+    col,
+    ElementCol{0, 5, -3},  // expected_value,
+    true,
+    true,
+    cudf::make_nth_element_aggregation<reduce_aggregation>(2, cudf::null_policy::INCLUDE));
 
   // test with null-exclude
   std::vector<bool> validity{1, 0, 0, 1, 1, 0};
   LCW col_nulls({{-3}, {2, 1}, {0, 5, -3}, {-2}, {}, {28}}, validity.begin());
-  this->reduction_test(col_nulls,
-                       ElementCol{-2},  // expected_value,
-                       true,
-                       true,
-                       cudf::make_nth_element_aggregation(1, cudf::null_policy::EXCLUDE));
+  this->reduction_test(
+    col_nulls,
+    ElementCol{-2},  // expected_value,
+    true,
+    true,
+    cudf::make_nth_element_aggregation<reduce_aggregation>(1, cudf::null_policy::EXCLUDE));
 
   // test with null-include
-  this->reduction_test(col_nulls,
-                       ElementCol{},  // expected_value,
-                       true,
-                       false,
-                       cudf::make_nth_element_aggregation(1, cudf::null_policy::INCLUDE));
+  this->reduction_test(
+    col_nulls,
+    ElementCol{},  // expected_value,
+    true,
+    false,
+    cudf::make_nth_element_aggregation<reduce_aggregation>(1, cudf::null_policy::INCLUDE));
 }
 
 TEST_F(ListReductionTest, NestedListReductionNthElement)
@@ -2015,25 +2136,28 @@ TEST_F(ListReductionTest, NestedListReductionNthElement)
   auto nested_list = LCW(
     {{LCW{}, LCW{2, 3, 4}}, {}, {LCW{5}, LCW{6}, LCW{7, 8}}, {LCW{9, 10}}, {LCW{11}, LCW{12, 13}}},
     validity.begin());
-  this->reduction_test(nested_list,
-                       LCW{{}, {2, 3, 4}},  // expected_value,
-                       true,
-                       true,
-                       cudf::make_nth_element_aggregation(0, cudf::null_policy::INCLUDE));
+  this->reduction_test(
+    nested_list,
+    LCW{{}, {2, 3, 4}},  // expected_value,
+    true,
+    true,
+    cudf::make_nth_element_aggregation<reduce_aggregation>(0, cudf::null_policy::INCLUDE));
 
   // test with null-include
-  this->reduction_test(nested_list,
-                       LCW{},  // expected_value,
-                       true,
-                       false,
-                       cudf::make_nth_element_aggregation(2, cudf::null_policy::INCLUDE));
+  this->reduction_test(
+    nested_list,
+    LCW{},  // expected_value,
+    true,
+    false,
+    cudf::make_nth_element_aggregation<reduce_aggregation>(2, cudf::null_policy::INCLUDE));
 
   // test with null-exclude
-  this->reduction_test(nested_list,
-                       LCW{{11}, {12, 13}},  // expected_value,
-                       true,
-                       true,
-                       cudf::make_nth_element_aggregation(2, cudf::null_policy::EXCLUDE));
+  this->reduction_test(
+    nested_list,
+    LCW{{11}, {12, 13}},  // expected_value,
+    true,
+    true,
+    cudf::make_nth_element_aggregation<reduce_aggregation>(2, cudf::null_policy::EXCLUDE));
 }
 
 TEST_F(ListReductionTest, NonValidListReductionNthElement)
@@ -2043,18 +2167,20 @@ TEST_F(ListReductionTest, NonValidListReductionNthElement)
 
   // test against col.size() <= col.null_count()
   std::vector<bool> validity{0};
-  this->reduction_test(LCW{{{1, 2}}, validity.begin()},
-                       ElementCol{},  // expected_value,
-                       true,
-                       false,
-                       cudf::make_nth_element_aggregation(0, cudf::null_policy::INCLUDE));
+  this->reduction_test(
+    LCW{{{1, 2}}, validity.begin()},
+    ElementCol{},  // expected_value,
+    true,
+    false,
+    cudf::make_nth_element_aggregation<reduce_aggregation>(0, cudf::null_policy::INCLUDE));
 
   // test against empty input
-  this->reduction_test(LCW{},
-                       ElementCol{},  // expected_value,
-                       true,
-                       false,
-                       cudf::make_nth_element_aggregation(0, cudf::null_policy::INCLUDE));
+  this->reduction_test(
+    LCW{},
+    ElementCol{},  // expected_value,
+    true,
+    false,
+    cudf::make_nth_element_aggregation<reduce_aggregation>(0, cudf::null_policy::INCLUDE));
 }
 
 struct StructReductionTest : public cudf::test::BaseFixture {
@@ -2064,7 +2190,7 @@ struct StructReductionTest : public cudf::test::BaseFixture {
                       cudf::table_view const& expected_value,
                       bool succeeded_condition,
                       bool is_valid,
-                      std::unique_ptr<aggregation> const& agg)
+                      std::unique_ptr<reduce_aggregation> const& agg)
   {
     auto statement = [&]() {
       std::unique_ptr<cudf::scalar> result =
@@ -2104,7 +2230,7 @@ TEST_F(StructReductionTest, StructReductionNthElement)
     cudf::table_view{{result_col0, result_col1, result_col2}},  // expected_value,
     true,
     true,
-    cudf::make_nth_element_aggregation(2, cudf::null_policy::INCLUDE));
+    cudf::make_nth_element_aggregation<reduce_aggregation>(2, cudf::null_policy::INCLUDE));
 
   // test with null-include
   std::vector<bool> validity{1, 1, 1, 0, 1, 0, 0, 1};
@@ -2121,7 +2247,7 @@ TEST_F(StructReductionTest, StructReductionNthElement)
     cudf::table_view{{result_col0, result_col1, result_col2}},  // expected_value,
     true,
     false,
-    cudf::make_nth_element_aggregation(6, cudf::null_policy::INCLUDE));
+    cudf::make_nth_element_aggregation<reduce_aggregation>(6, cudf::null_policy::INCLUDE));
 
   // test with null-exclude
   result_col0 = ICW{{28}, {1}};
@@ -2132,7 +2258,7 @@ TEST_F(StructReductionTest, StructReductionNthElement)
     cudf::table_view{{result_col0, result_col1, result_col2}},  // expected_value,
     true,
     true,
-    cudf::make_nth_element_aggregation(4, cudf::null_policy::EXCLUDE));
+    cudf::make_nth_element_aggregation<reduce_aggregation>(4, cudf::null_policy::EXCLUDE));
 }
 
 TEST_F(StructReductionTest, NestedStructReductionNthElement)
@@ -2155,7 +2281,7 @@ TEST_F(StructReductionTest, NestedStructReductionNthElement)
     cudf::table_view{{result_col0, result_col1, result_col2}},  // expected_value,
     true,
     true,
-    cudf::make_nth_element_aggregation(1, cudf::null_policy::INCLUDE));
+    cudf::make_nth_element_aggregation<reduce_aggregation>(1, cudf::null_policy::INCLUDE));
 
   // test with null-include
   result_child0 = ICW{0};
@@ -2167,7 +2293,7 @@ TEST_F(StructReductionTest, NestedStructReductionNthElement)
     cudf::table_view{{result_col0, result_col1, result_col2}},  // expected_value,
     true,
     false,
-    cudf::make_nth_element_aggregation(3, cudf::null_policy::INCLUDE));
+    cudf::make_nth_element_aggregation<reduce_aggregation>(3, cudf::null_policy::INCLUDE));
 
   // test with null-exclude
   result_child0 = ICW{0};
@@ -2179,7 +2305,7 @@ TEST_F(StructReductionTest, NestedStructReductionNthElement)
     cudf::table_view{{result_col0, result_col1, result_col2}},  // expected_value,
     true,
     true,
-    cudf::make_nth_element_aggregation(3, cudf::null_policy::EXCLUDE));
+    cudf::make_nth_element_aggregation<reduce_aggregation>(3, cudf::null_policy::EXCLUDE));
 }
 
 TEST_F(StructReductionTest, NonValidStructReductionNthElement)
@@ -2194,11 +2320,12 @@ TEST_F(StructReductionTest, NonValidStructReductionNthElement)
   auto ret_col0   = ICW{{0}, {0}};
   auto ret_col1   = ICW{{0}, {0}};
   auto ret_col2   = ICW{{0}, {0}};
-  this->reduction_test(struct_col,
-                       cudf::table_view{{ret_col0, ret_col1, ret_col2}},  // expected_value,
-                       true,
-                       false,
-                       cudf::make_nth_element_aggregation(0, cudf::null_policy::INCLUDE));
+  this->reduction_test(
+    struct_col,
+    cudf::table_view{{ret_col0, ret_col1, ret_col2}},  // expected_value,
+    true,
+    false,
+    cudf::make_nth_element_aggregation<reduce_aggregation>(0, cudf::null_policy::INCLUDE));
 
   // test against empty input (would fail because we can not create empty struct scalar)
   child0     = ICW{};
@@ -2208,11 +2335,12 @@ TEST_F(StructReductionTest, NonValidStructReductionNthElement)
   ret_col0   = ICW{};
   ret_col1   = ICW{};
   ret_col2   = ICW{};
-  this->reduction_test(struct_col,
-                       cudf::table_view{{ret_col0, ret_col1, ret_col2}},  // expected_value,
-                       false,
-                       false,
-                       cudf::make_nth_element_aggregation(0, cudf::null_policy::INCLUDE));
+  this->reduction_test(
+    struct_col,
+    cudf::table_view{{ret_col0, ret_col1, ret_col2}},  // expected_value,
+    false,
+    false,
+    cudf::make_nth_element_aggregation<reduce_aggregation>(0, cudf::null_policy::INCLUDE));
 }
 
 TEST_F(StructReductionTest, StructReductionMinMaxNoNull)
@@ -2234,7 +2362,7 @@ TEST_F(StructReductionTest, StructReductionMinMaxNoNull)
                          cudf::table_view{{expected_child1, expected_child2}},
                          true,
                          true,
-                         cudf::make_min_aggregation());
+                         cudf::make_min_aggregation<reduce_aggregation>());
   }
 
   {
@@ -2244,7 +2372,7 @@ TEST_F(StructReductionTest, StructReductionMinMaxNoNull)
                          cudf::table_view{{expected_child1, expected_child2}},
                          true,
                          true,
-                         cudf::make_max_aggregation());
+                         cudf::make_max_aggregation<reduce_aggregation>());
   }
 }
 
@@ -2282,7 +2410,7 @@ TEST_F(StructReductionTest, StructReductionMinMaxSlicedInput)
                          cudf::table_view{{expected_child1, expected_child2}},
                          true,
                          true,
-                         cudf::make_min_aggregation());
+                         cudf::make_min_aggregation<reduce_aggregation>());
   }
 
   {
@@ -2292,7 +2420,7 @@ TEST_F(StructReductionTest, StructReductionMinMaxSlicedInput)
                          cudf::table_view{{expected_child1, expected_child2}},
                          true,
                          true,
-                         cudf::make_max_aggregation());
+                         cudf::make_max_aggregation<reduce_aggregation>());
   }
 }
 
@@ -2331,7 +2459,7 @@ TEST_F(StructReductionTest, StructReductionMinMaxWithNulls)
                          cudf::table_view{{expected_child1, expected_child2}},
                          true,
                          true,
-                         cudf::make_min_aggregation());
+                         cudf::make_min_aggregation<reduce_aggregation>());
   }
 
   {
@@ -2341,7 +2469,7 @@ TEST_F(StructReductionTest, StructReductionMinMaxWithNulls)
                          cudf::table_view{{expected_child1, expected_child2}},
                          true,
                          true,
-                         cudf::make_max_aggregation());
+                         cudf::make_max_aggregation<reduce_aggregation>());
   }
 }
 
diff --git a/cpp/tests/reductions/scan_tests.cpp b/cpp/tests/reductions/scan_tests.cpp
index 3cbf5f5deb0..94eb36eee8e 100644
--- a/cpp/tests/reductions/scan_tests.cpp
+++ b/cpp/tests/reductions/scan_tests.cpp
@@ -30,7 +30,8 @@
 #include <algorithm>
 #include <numeric>
 
-using aggregation = cudf::aggregation;
+using aggregation      = cudf::aggregation;
+using scan_aggregation = cudf::scan_aggregation;
 using cudf::null_policy;
 using cudf::scan_type;
 
@@ -41,7 +42,7 @@ struct ScanTest : public BaseScanTest<T> {
 
   void scan_test(cudf::host_span<HostType const> v,
                  cudf::host_span<bool const> b,
-                 std::unique_ptr<aggregation> const& agg,
+                 std::unique_ptr<scan_aggregation> const& agg,
                  scan_type inclusive,
                  null_policy null_handling,
                  numeric::scale_type scale)
@@ -60,7 +61,7 @@ struct ScanTest : public BaseScanTest<T> {
   // Overload to iterate the test over a few different scales for fixed-point tests
   void scan_test(cudf::host_span<HostType const> v,
                  cudf::host_span<bool const> b,
-                 std::unique_ptr<aggregation> const& agg,
+                 std::unique_ptr<scan_aggregation> const& agg,
                  scan_type inclusive,
                  null_policy null_handling = null_policy::EXCLUDE)
   {
@@ -73,7 +74,7 @@ struct ScanTest : public BaseScanTest<T> {
     }
   }
 
-  bool params_supported(std::unique_ptr<aggregation> const& agg, scan_type inclusive)
+  bool params_supported(std::unique_ptr<scan_aggregation> const& agg, scan_type inclusive)
   {
     bool supported = [&] {
       switch (agg->kind) {
@@ -94,7 +95,7 @@ struct ScanTest : public BaseScanTest<T> {
     return supported;
   }
 
-  std::function<HostType(HostType, HostType)> make_agg(std::unique_ptr<aggregation> const& agg)
+  std::function<HostType(HostType, HostType)> make_agg(std::unique_ptr<scan_aggregation> const& agg)
   {
     if constexpr (std::is_same_v<T, cudf::string_view>) {
       switch (agg->kind) {
@@ -119,7 +120,7 @@ struct ScanTest : public BaseScanTest<T> {
     }
   }
 
-  HostType make_identity(std::unique_ptr<aggregation> const& agg)
+  HostType make_identity(std::unique_ptr<scan_aggregation> const& agg)
   {
     if constexpr (std::is_same_v<T, cudf::string_view>) {
       switch (agg->kind) {
@@ -146,7 +147,7 @@ struct ScanTest : public BaseScanTest<T> {
 
   std::unique_ptr<cudf::column> make_expected(cudf::host_span<HostType const> v,
                                               cudf::host_span<bool const> b,
-                                              std::unique_ptr<aggregation> const& agg,
+                                              std::unique_ptr<scan_aggregation> const& agg,
                                               scan_type inclusive,
                                               null_policy null_handling,
                                               numeric::scale_type scale = numeric::scale_type{0})
@@ -212,14 +213,30 @@ TYPED_TEST(ScanTest, Min)
   auto const b = thrust::host_vector<bool>(std::vector<bool>{1, 0, 1, 1, 1, 1, 0, 0, 1});
 
   // no nulls
-  this->scan_test(v, {}, cudf::make_min_aggregation(), scan_type::INCLUSIVE);
-  this->scan_test(v, {}, cudf::make_min_aggregation(), scan_type::EXCLUSIVE);
+  this->scan_test(v, {}, cudf::make_min_aggregation<scan_aggregation>(), scan_type::INCLUSIVE);
+  this->scan_test(v, {}, cudf::make_min_aggregation<scan_aggregation>(), scan_type::EXCLUSIVE);
   // skipna = true (default)
-  this->scan_test(v, b, cudf::make_min_aggregation(), scan_type::INCLUSIVE, null_policy::EXCLUDE);
-  this->scan_test(v, b, cudf::make_min_aggregation(), scan_type::EXCLUSIVE, null_policy::EXCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_min_aggregation<scan_aggregation>(),
+                  scan_type::INCLUSIVE,
+                  null_policy::EXCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_min_aggregation<scan_aggregation>(),
+                  scan_type::EXCLUSIVE,
+                  null_policy::EXCLUDE);
   // skipna = false
-  this->scan_test(v, b, cudf::make_min_aggregation(), scan_type::INCLUSIVE, null_policy::INCLUDE);
-  this->scan_test(v, b, cudf::make_min_aggregation(), scan_type::EXCLUSIVE, null_policy::INCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_min_aggregation<scan_aggregation>(),
+                  scan_type::INCLUSIVE,
+                  null_policy::INCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_min_aggregation<scan_aggregation>(),
+                  scan_type::EXCLUSIVE,
+                  null_policy::INCLUDE);
 }
 
 TYPED_TEST(ScanTest, Max)
@@ -229,14 +246,30 @@ TYPED_TEST(ScanTest, Max)
 
   // inclusive
   // no nulls
-  this->scan_test(v, {}, cudf::make_max_aggregation(), scan_type::INCLUSIVE);
-  this->scan_test(v, {}, cudf::make_max_aggregation(), scan_type::EXCLUSIVE);
+  this->scan_test(v, {}, cudf::make_max_aggregation<scan_aggregation>(), scan_type::INCLUSIVE);
+  this->scan_test(v, {}, cudf::make_max_aggregation<scan_aggregation>(), scan_type::EXCLUSIVE);
   // skipna = true (default)
-  this->scan_test(v, b, cudf::make_max_aggregation(), scan_type::INCLUSIVE, null_policy::EXCLUDE);
-  this->scan_test(v, b, cudf::make_max_aggregation(), scan_type::EXCLUSIVE, null_policy::EXCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_max_aggregation<scan_aggregation>(),
+                  scan_type::INCLUSIVE,
+                  null_policy::EXCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_max_aggregation<scan_aggregation>(),
+                  scan_type::EXCLUSIVE,
+                  null_policy::EXCLUDE);
   // skipna = false
-  this->scan_test(v, b, cudf::make_max_aggregation(), scan_type::INCLUSIVE, null_policy::INCLUDE);
-  this->scan_test(v, b, cudf::make_max_aggregation(), scan_type::EXCLUSIVE, null_policy::INCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_max_aggregation<scan_aggregation>(),
+                  scan_type::INCLUSIVE,
+                  null_policy::INCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_max_aggregation<scan_aggregation>(),
+                  scan_type::EXCLUSIVE,
+                  null_policy::INCLUDE);
 }
 
 TYPED_TEST(ScanTest, Product)
@@ -245,18 +278,30 @@ TYPED_TEST(ScanTest, Product)
   auto const b = thrust::host_vector<bool>(std::vector<bool>{1, 1, 1, 0, 1, 1});
 
   // no nulls
-  this->scan_test(v, {}, cudf::make_product_aggregation(), scan_type::INCLUSIVE);
-  this->scan_test(v, {}, cudf::make_product_aggregation(), scan_type::EXCLUSIVE);
+  this->scan_test(v, {}, cudf::make_product_aggregation<scan_aggregation>(), scan_type::INCLUSIVE);
+  this->scan_test(v, {}, cudf::make_product_aggregation<scan_aggregation>(), scan_type::EXCLUSIVE);
   // skipna = true (default)
-  this->scan_test(
-    v, b, cudf::make_product_aggregation(), scan_type::INCLUSIVE, null_policy::EXCLUDE);
-  this->scan_test(
-    v, b, cudf::make_product_aggregation(), scan_type::EXCLUSIVE, null_policy::EXCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_product_aggregation<scan_aggregation>(),
+                  scan_type::INCLUSIVE,
+                  null_policy::EXCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_product_aggregation<scan_aggregation>(),
+                  scan_type::EXCLUSIVE,
+                  null_policy::EXCLUDE);
   // skipna = false
-  this->scan_test(
-    v, b, cudf::make_product_aggregation(), scan_type::INCLUSIVE, null_policy::INCLUDE);
-  this->scan_test(
-    v, b, cudf::make_product_aggregation(), scan_type::EXCLUSIVE, null_policy::INCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_product_aggregation<scan_aggregation>(),
+                  scan_type::INCLUSIVE,
+                  null_policy::INCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_product_aggregation<scan_aggregation>(),
+                  scan_type::EXCLUSIVE,
+                  null_policy::INCLUDE);
 }
 
 TYPED_TEST(ScanTest, Sum)
@@ -269,14 +314,30 @@ TYPED_TEST(ScanTest, Sum)
   auto const b = thrust::host_vector<bool>(std::vector<bool>{1, 0, 1, 1, 0, 0, 1, 1, 1, 1});
 
   // no nulls
-  this->scan_test(v, {}, cudf::make_sum_aggregation(), scan_type::INCLUSIVE);
-  this->scan_test(v, {}, cudf::make_sum_aggregation(), scan_type::EXCLUSIVE);
+  this->scan_test(v, {}, cudf::make_sum_aggregation<scan_aggregation>(), scan_type::INCLUSIVE);
+  this->scan_test(v, {}, cudf::make_sum_aggregation<scan_aggregation>(), scan_type::EXCLUSIVE);
   // skipna = true (default)
-  this->scan_test(v, b, cudf::make_sum_aggregation(), scan_type::INCLUSIVE, null_policy::EXCLUDE);
-  this->scan_test(v, b, cudf::make_sum_aggregation(), scan_type::EXCLUSIVE, null_policy::EXCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_sum_aggregation<scan_aggregation>(),
+                  scan_type::INCLUSIVE,
+                  null_policy::EXCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_sum_aggregation<scan_aggregation>(),
+                  scan_type::EXCLUSIVE,
+                  null_policy::EXCLUDE);
   // skipna = false
-  this->scan_test(v, b, cudf::make_sum_aggregation(), scan_type::INCLUSIVE, null_policy::INCLUDE);
-  this->scan_test(v, b, cudf::make_sum_aggregation(), scan_type::EXCLUSIVE, null_policy::INCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_sum_aggregation<scan_aggregation>(),
+                  scan_type::INCLUSIVE,
+                  null_policy::INCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_sum_aggregation<scan_aggregation>(),
+                  scan_type::EXCLUSIVE,
+                  null_policy::INCLUDE);
 }
 
 TYPED_TEST(ScanTest, EmptyColumn)
@@ -285,11 +346,27 @@ TYPED_TEST(ScanTest, EmptyColumn)
   auto const b = thrust::host_vector<bool>{};
 
   // skipna = true (default)
-  this->scan_test(v, b, cudf::make_min_aggregation(), scan_type::INCLUSIVE, null_policy::EXCLUDE);
-  this->scan_test(v, b, cudf::make_min_aggregation(), scan_type::EXCLUSIVE, null_policy::EXCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_min_aggregation<scan_aggregation>(),
+                  scan_type::INCLUSIVE,
+                  null_policy::EXCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_min_aggregation<scan_aggregation>(),
+                  scan_type::EXCLUSIVE,
+                  null_policy::EXCLUDE);
   // skipna = false
-  this->scan_test(v, b, cudf::make_min_aggregation(), scan_type::INCLUSIVE, null_policy::INCLUDE);
-  this->scan_test(v, b, cudf::make_min_aggregation(), scan_type::EXCLUSIVE, null_policy::INCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_min_aggregation<scan_aggregation>(),
+                  scan_type::INCLUSIVE,
+                  null_policy::INCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_min_aggregation<scan_aggregation>(),
+                  scan_type::EXCLUSIVE,
+                  null_policy::INCLUDE);
 }
 
 TYPED_TEST(ScanTest, LeadingNulls)
@@ -298,11 +375,27 @@ TYPED_TEST(ScanTest, LeadingNulls)
   auto const b = thrust::host_vector<bool>(std::vector<bool>{0, 1, 1});
 
   // skipna = true (default)
-  this->scan_test(v, b, cudf::make_min_aggregation(), scan_type::INCLUSIVE, null_policy::EXCLUDE);
-  this->scan_test(v, b, cudf::make_min_aggregation(), scan_type::EXCLUSIVE, null_policy::EXCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_min_aggregation<scan_aggregation>(),
+                  scan_type::INCLUSIVE,
+                  null_policy::EXCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_min_aggregation<scan_aggregation>(),
+                  scan_type::EXCLUSIVE,
+                  null_policy::EXCLUDE);
   // skipna = false
-  this->scan_test(v, b, cudf::make_min_aggregation(), scan_type::INCLUSIVE, null_policy::INCLUDE);
-  this->scan_test(v, b, cudf::make_min_aggregation(), scan_type::EXCLUSIVE, null_policy::INCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_min_aggregation<scan_aggregation>(),
+                  scan_type::INCLUSIVE,
+                  null_policy::INCLUDE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_min_aggregation<scan_aggregation>(),
+                  scan_type::EXCLUSIVE,
+                  null_policy::INCLUDE);
 }
 
 class ScanStringsTest : public ScanTest<cudf::string_view> {
@@ -323,21 +416,37 @@ TEST_F(ScanStringsTest, MoreStringsMinMax)
   thrust::host_vector<std::string> v(data_begin, data_begin + row_count);
   thrust::host_vector<bool> b(validity, validity + row_count);
 
-  this->scan_test(v, {}, cudf::make_min_aggregation(), scan_type::INCLUSIVE);
-  this->scan_test(v, b, cudf::make_min_aggregation(), scan_type::INCLUSIVE);
-  this->scan_test(v, b, cudf::make_min_aggregation(), scan_type::INCLUSIVE, null_policy::EXCLUDE);
-
-  this->scan_test(v, {}, cudf::make_min_aggregation(), scan_type::EXCLUSIVE);
-  this->scan_test(v, b, cudf::make_min_aggregation(), scan_type::EXCLUSIVE);
-  this->scan_test(v, b, cudf::make_min_aggregation(), scan_type::EXCLUSIVE, null_policy::EXCLUDE);
-
-  this->scan_test(v, {}, cudf::make_max_aggregation(), scan_type::INCLUSIVE);
-  this->scan_test(v, b, cudf::make_max_aggregation(), scan_type::INCLUSIVE);
-  this->scan_test(v, b, cudf::make_max_aggregation(), scan_type::INCLUSIVE, null_policy::EXCLUDE);
-
-  this->scan_test(v, {}, cudf::make_max_aggregation(), scan_type::EXCLUSIVE);
-  this->scan_test(v, b, cudf::make_max_aggregation(), scan_type::EXCLUSIVE);
-  this->scan_test(v, b, cudf::make_max_aggregation(), scan_type::EXCLUSIVE, null_policy::EXCLUDE);
+  this->scan_test(v, {}, cudf::make_min_aggregation<scan_aggregation>(), scan_type::INCLUSIVE);
+  this->scan_test(v, b, cudf::make_min_aggregation<scan_aggregation>(), scan_type::INCLUSIVE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_min_aggregation<scan_aggregation>(),
+                  scan_type::INCLUSIVE,
+                  null_policy::EXCLUDE);
+
+  this->scan_test(v, {}, cudf::make_min_aggregation<scan_aggregation>(), scan_type::EXCLUSIVE);
+  this->scan_test(v, b, cudf::make_min_aggregation<scan_aggregation>(), scan_type::EXCLUSIVE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_min_aggregation<scan_aggregation>(),
+                  scan_type::EXCLUSIVE,
+                  null_policy::EXCLUDE);
+
+  this->scan_test(v, {}, cudf::make_max_aggregation<scan_aggregation>(), scan_type::INCLUSIVE);
+  this->scan_test(v, b, cudf::make_max_aggregation<scan_aggregation>(), scan_type::INCLUSIVE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_max_aggregation<scan_aggregation>(),
+                  scan_type::INCLUSIVE,
+                  null_policy::EXCLUDE);
+
+  this->scan_test(v, {}, cudf::make_max_aggregation<scan_aggregation>(), scan_type::EXCLUSIVE);
+  this->scan_test(v, b, cudf::make_max_aggregation<scan_aggregation>(), scan_type::EXCLUSIVE);
+  this->scan_test(v,
+                  b,
+                  cudf::make_max_aggregation<scan_aggregation>(),
+                  scan_type::EXCLUSIVE,
+                  null_policy::EXCLUDE);
 }
 
 template <typename T>
@@ -353,26 +462,34 @@ TYPED_TEST(ScanChronoTest, ChronoMinMax)
   cudf::test::fixed_width_column_wrapper<TypeParam, int32_t> expected_min({5, 4, 4, 0, 1, 1, 1, 1},
                                                                           {1, 1, 1, 0, 1, 1, 1, 1});
 
-  auto result = cudf::scan(col, cudf::make_min_aggregation(), cudf::scan_type::INCLUSIVE);
+  auto result =
+    cudf::scan(col, cudf::make_min_aggregation<scan_aggregation>(), cudf::scan_type::INCLUSIVE);
   CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(result->view(), expected_min);
 
-  result = cudf::scan(
-    col, cudf::make_min_aggregation(), cudf::scan_type::INCLUSIVE, cudf::null_policy::EXCLUDE);
+  result = cudf::scan(col,
+                      cudf::make_min_aggregation<scan_aggregation>(),
+                      cudf::scan_type::INCLUSIVE,
+                      cudf::null_policy::EXCLUDE);
   CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(result->view(), expected_min);
 
   cudf::test::fixed_width_column_wrapper<TypeParam, int32_t> expected_max({5, 5, 6, 0, 6, 6, 6, 6},
                                                                           {1, 1, 1, 0, 1, 1, 1, 1});
-  result = cudf::scan(col, cudf::make_max_aggregation(), cudf::scan_type::INCLUSIVE);
+  result =
+    cudf::scan(col, cudf::make_max_aggregation<scan_aggregation>(), cudf::scan_type::INCLUSIVE);
   CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(result->view(), expected_max);
 
-  result = cudf::scan(
-    col, cudf::make_max_aggregation(), cudf::scan_type::INCLUSIVE, cudf::null_policy::EXCLUDE);
+  result = cudf::scan(col,
+                      cudf::make_max_aggregation<scan_aggregation>(),
+                      cudf::scan_type::INCLUSIVE,
+                      cudf::null_policy::EXCLUDE);
   CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(result->view(), expected_max);
 
-  EXPECT_THROW(cudf::scan(col, cudf::make_max_aggregation(), cudf::scan_type::EXCLUSIVE),
-               cudf::logic_error);
-  EXPECT_THROW(cudf::scan(col, cudf::make_min_aggregation(), cudf::scan_type::EXCLUSIVE),
-               cudf::logic_error);
+  EXPECT_THROW(
+    cudf::scan(col, cudf::make_max_aggregation<scan_aggregation>(), cudf::scan_type::EXCLUSIVE),
+    cudf::logic_error);
+  EXPECT_THROW(
+    cudf::scan(col, cudf::make_min_aggregation<scan_aggregation>(), cudf::scan_type::EXCLUSIVE),
+    cudf::logic_error);
 }
 
 template <typename T>
@@ -388,15 +505,19 @@ TYPED_TEST(ScanDurationTest, Sum)
   cudf::test::fixed_width_column_wrapper<TypeParam, int32_t> expected({5, 9, 15, 0, 16, 22, 27, 30},
                                                                       {1, 1, 1, 0, 1, 1, 1, 1});
 
-  auto result = cudf::scan(col, cudf::make_sum_aggregation(), cudf::scan_type::INCLUSIVE);
+  auto result =
+    cudf::scan(col, cudf::make_sum_aggregation<scan_aggregation>(), cudf::scan_type::INCLUSIVE);
   CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(result->view(), expected);
 
-  result = cudf::scan(
-    col, cudf::make_sum_aggregation(), cudf::scan_type::INCLUSIVE, cudf::null_policy::EXCLUDE);
+  result = cudf::scan(col,
+                      cudf::make_sum_aggregation<scan_aggregation>(),
+                      cudf::scan_type::INCLUSIVE,
+                      cudf::null_policy::EXCLUDE);
   CUDF_TEST_EXPECT_COLUMNS_EQUIVALENT(result->view(), expected);
 
-  EXPECT_THROW(cudf::scan(col, cudf::make_sum_aggregation(), cudf::scan_type::EXCLUSIVE),
-               cudf::logic_error);
+  EXPECT_THROW(
+    cudf::scan(col, cudf::make_sum_aggregation<scan_aggregation>(), cudf::scan_type::EXCLUSIVE),
+    cudf::logic_error);
 }
 
 struct StructScanTest : public cudf::test::BaseFixture {
@@ -420,7 +541,8 @@ TEST_F(StructScanTest, StructScanMinMaxNoNull)
       auto child2 = INTS_CW{1, 1, 1, 4, 4, 4, 4, 8, 8, 8};
       return STRUCTS_CW{{child1, child2}};
     }();
-    auto const result = cudf::scan(input, cudf::make_min_aggregation(), cudf::scan_type::INCLUSIVE);
+    auto const result =
+      cudf::scan(input, cudf::make_min_aggregation<scan_aggregation>(), cudf::scan_type::INCLUSIVE);
     CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected, result->view());
   }
 
@@ -430,7 +552,8 @@ TEST_F(StructScanTest, StructScanMinMaxNoNull)
       auto child2 = INTS_CW{1, 2, 3, 3, 3, 3, 3, 3, 3, 3};
       return STRUCTS_CW{{child1, child2}};
     }();
-    auto const result = cudf::scan(input, cudf::make_max_aggregation(), cudf::scan_type::INCLUSIVE);
+    auto const result =
+      cudf::scan(input, cudf::make_max_aggregation<scan_aggregation>(), cudf::scan_type::INCLUSIVE);
     CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected, result->view());
   }
 }
@@ -468,7 +591,8 @@ TEST_F(StructScanTest, StructScanMinMaxSlicedInput)
       auto child2 = INTS_CW{1, 1, 1, 4, 4, 4, 4, 8, 8, 8};
       return STRUCTS_CW{{child1, child2}};
     }();
-    auto const result = cudf::scan(input, cudf::make_min_aggregation(), cudf::scan_type::INCLUSIVE);
+    auto const result =
+      cudf::scan(input, cudf::make_min_aggregation<scan_aggregation>(), cudf::scan_type::INCLUSIVE);
     CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected, result->view());
   }
 
@@ -478,7 +602,8 @@ TEST_F(StructScanTest, StructScanMinMaxSlicedInput)
       auto child2 = INTS_CW{1, 2, 3, 3, 3, 3, 3, 3, 3, 3};
       return STRUCTS_CW{{child1, child2}};
     }();
-    auto const result = cudf::scan(input, cudf::make_max_aggregation(), cudf::scan_type::INCLUSIVE);
+    auto const result =
+      cudf::scan(input, cudf::make_max_aggregation<scan_aggregation>(), cudf::scan_type::INCLUSIVE);
     CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected, result->view());
   }
 }
@@ -537,8 +662,10 @@ TEST_F(StructScanTest, StructScanMinMaxWithNulls)
       return STRUCTS_CW{{child1, child2}, nulls_at({3, 8})};
     }();
 
-    auto const result = cudf::scan(
-      input, cudf::make_min_aggregation(), cudf::scan_type::INCLUSIVE, null_policy::EXCLUDE);
+    auto const result = cudf::scan(input,
+                                   cudf::make_min_aggregation<scan_aggregation>(),
+                                   cudf::scan_type::INCLUSIVE,
+                                   null_policy::EXCLUDE);
     CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected, result->view());
   }
 
@@ -550,8 +677,10 @@ TEST_F(StructScanTest, StructScanMinMaxWithNulls)
       return STRUCTS_CW{{child1, child2}, nulls_at({3, 8})};
     }();
 
-    auto const result = cudf::scan(
-      input, cudf::make_max_aggregation(), cudf::scan_type::INCLUSIVE, null_policy::EXCLUDE);
+    auto const result = cudf::scan(input,
+                                   cudf::make_max_aggregation<scan_aggregation>(),
+                                   cudf::scan_type::INCLUSIVE,
+                                   null_policy::EXCLUDE);
     CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected, result->view());
   }
 
@@ -582,8 +711,10 @@ TEST_F(StructScanTest, StructScanMinMaxWithNulls)
       return STRUCTS_CW{{child1, child2}, nulls_at({3, 4, 5, 6, 7, 8, 9})};
     }();
 
-    auto const result = cudf::scan(
-      input, cudf::make_min_aggregation(), cudf::scan_type::INCLUSIVE, null_policy::INCLUDE);
+    auto const result = cudf::scan(input,
+                                   cudf::make_min_aggregation<scan_aggregation>(),
+                                   cudf::scan_type::INCLUSIVE,
+                                   null_policy::INCLUDE);
     CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected, result->view());
   }
 
@@ -612,8 +743,10 @@ TEST_F(StructScanTest, StructScanMinMaxWithNulls)
       return STRUCTS_CW{{child1, child2}, nulls_at({3, 4, 5, 6, 7, 8, 9})};
     }();
 
-    auto const result = cudf::scan(
-      input, cudf::make_max_aggregation(), cudf::scan_type::INCLUSIVE, null_policy::INCLUDE);
+    auto const result = cudf::scan(input,
+                                   cudf::make_max_aggregation<scan_aggregation>(),
+                                   cudf::scan_type::INCLUSIVE,
+                                   null_policy::INCLUDE);
     CUDF_TEST_EXPECT_COLUMNS_EQUAL(expected, result->view());
   }
 }
diff --git a/java/src/main/native/src/ColumnViewJni.cpp b/java/src/main/native/src/ColumnViewJni.cpp
index a69c7c29900..7e5bd9bcade 100644
--- a/java/src/main/native/src/ColumnViewJni.cpp
+++ b/java/src/main/native/src/ColumnViewJni.cpp
@@ -257,7 +257,11 @@ JNIEXPORT jlong JNICALL Java_ai_rapids_cudf_ColumnView_reduce(JNIEnv *env, jclas
     auto col = reinterpret_cast<cudf::column_view *>(j_col_view);
     auto agg = reinterpret_cast<cudf::aggregation *>(j_agg);
     cudf::data_type out_dtype = cudf::jni::make_data_type(j_dtype, scale);
-    return release_as_jlong(cudf::reduce(*col, agg->clone(), out_dtype));
+    return release_as_jlong(
+        cudf::reduce(*col,
+                     std::unique_ptr<cudf::reduce_aggregation>(
+                         dynamic_cast<cudf::reduce_aggregation *>(agg->clone().release())),
+                     out_dtype));
   }
   CATCH_STD(env, 0);
 }
@@ -273,7 +277,11 @@ JNIEXPORT jlong JNICALL Java_ai_rapids_cudf_ColumnView_scan(JNIEnv *env, jclass,
     auto agg = reinterpret_cast<cudf::aggregation *>(j_agg);
     auto scan_type = is_inclusive ? cudf::scan_type::INCLUSIVE : cudf::scan_type::EXCLUSIVE;
     auto null_policy = include_nulls ? cudf::null_policy::INCLUDE : cudf::null_policy::EXCLUDE;
-    return release_as_jlong(cudf::scan(*col, agg->clone(), scan_type, null_policy));
+    return release_as_jlong(
+        cudf::scan(*col,
+                   std::unique_ptr<cudf::scan_aggregation>(
+                       dynamic_cast<cudf::scan_aggregation *>(agg->clone().release())),
+                   scan_type, null_policy));
   }
   CATCH_STD(env, 0);
 }
diff --git a/python/cudf/cudf/_lib/aggregation.pxd b/python/cudf/cudf/_lib/aggregation.pxd
index 84bcaed1b36..ad2c978801f 100644
--- a/python/cudf/cudf/_lib/aggregation.pxd
+++ b/python/cudf/cudf/_lib/aggregation.pxd
@@ -1,18 +1,16 @@
-# Copyright (c) 2020, NVIDIA CORPORATION.
+# Copyright (c) 2020-2022, NVIDIA CORPORATION.
 
 from libcpp.memory cimport unique_ptr
 
 from cudf._lib.cpp.aggregation cimport (
-    aggregation,
     groupby_aggregation,
     groupby_scan_aggregation,
+    reduce_aggregation,
     rolling_aggregation,
+    scan_aggregation,
 )
 
 
-cdef class Aggregation:
-    cdef unique_ptr[aggregation] c_obj
-
 cdef class RollingAggregation:
     cdef unique_ptr[rolling_aggregation] c_obj
 
@@ -22,7 +20,14 @@ cdef class GroupbyAggregation:
 cdef class GroupbyScanAggregation:
     cdef unique_ptr[groupby_scan_aggregation] c_obj
 
-cdef Aggregation make_aggregation(op, kwargs=*)
+cdef class ReduceAggregation:
+    cdef unique_ptr[reduce_aggregation] c_obj
+
+cdef class ScanAggregation:
+    cdef unique_ptr[scan_aggregation] c_obj
+
 cdef RollingAggregation make_rolling_aggregation(op, kwargs=*)
 cdef GroupbyAggregation make_groupby_aggregation(op, kwargs=*)
 cdef GroupbyScanAggregation make_groupby_scan_aggregation(op, kwargs=*)
+cdef ReduceAggregation make_reduce_aggregation(op, kwargs=*)
+cdef ScanAggregation make_scan_aggregation(op, kwargs=*)
diff --git a/python/cudf/cudf/_lib/aggregation.pyx b/python/cudf/cudf/_lib/aggregation.pyx
index 35b806909ec..4dc91268d57 100644
--- a/python/cudf/cudf/_lib/aggregation.pyx
+++ b/python/cudf/cudf/_lib/aggregation.pyx
@@ -77,285 +77,6 @@ class CorrelationType(IntEnum):
     )
 
 
-cdef class Aggregation:
-    """A Cython wrapper for aggregations.
-
-    **This class should never be instantiated using a standard constructor,
-    only using one of its many factories.** These factories handle mapping
-    different cudf operations to their libcudf analogs, e.g.
-    `cudf.DataFrame.idxmin` -> `libcudf.argmin`. Additionally, they perform
-    any additional configuration needed to translate Python arguments into
-    their corresponding C++ types (for instance, C++ enumerations used for
-    flag arguments). The factory approach is necessary to support operations
-    like `df.agg(lambda x: x.sum())`; such functions are called with this
-    class as an argument to generation the desired aggregation.
-    """
-    @property
-    def kind(self):
-        return AggregationKind(self.c_obj.get()[0].kind).name
-
-    @classmethod
-    def sum(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_sum_aggregation[aggregation]())
-        return agg
-
-    @classmethod
-    def min(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_min_aggregation[aggregation]())
-        return agg
-
-    @classmethod
-    def max(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_max_aggregation[aggregation]())
-        return agg
-
-    @classmethod
-    def idxmin(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_argmin_aggregation[aggregation]())
-        return agg
-
-    @classmethod
-    def idxmax(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_argmax_aggregation[aggregation]())
-        return agg
-
-    @classmethod
-    def mean(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_mean_aggregation[aggregation]())
-        return agg
-
-    @classmethod
-    def count(cls, dropna=True):
-        cdef libcudf_types.null_policy c_null_handling
-        if dropna:
-            c_null_handling = libcudf_types.null_policy.EXCLUDE
-        else:
-            c_null_handling = libcudf_types.null_policy.INCLUDE
-
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_count_aggregation[aggregation](
-                c_null_handling
-            ))
-        return agg
-
-    @classmethod
-    def size(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_count_aggregation[aggregation](
-                <libcudf_types.null_policy><underlying_type_t_null_policy>(
-                    NullHandling.INCLUDE
-                )
-            ))
-        return agg
-
-    @classmethod
-    def nunique(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_nunique_aggregation[aggregation]())
-        return agg
-
-    @classmethod
-    def nth(cls, libcudf_types.size_type size):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_nth_element_aggregation[aggregation](
-                size))
-        return agg
-
-    @classmethod
-    def first(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_nth_element_aggregation[aggregation](
-                0,
-                <libcudf_types.null_policy><underlying_type_t_null_policy>(
-                    NullHandling.EXCLUDE
-                )
-            )
-        )
-        return agg
-
-    @classmethod
-    def last(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_nth_element_aggregation[aggregation](
-                -1,
-                <libcudf_types.null_policy><underlying_type_t_null_policy>(
-                    NullHandling.EXCLUDE
-                )
-            )
-        )
-        return agg
-
-    @classmethod
-    def any(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_any_aggregation[aggregation]())
-        return agg
-
-    @classmethod
-    def all(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_all_aggregation[aggregation]())
-        return agg
-
-    @classmethod
-    def product(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_product_aggregation[aggregation]())
-        return agg
-    prod = product
-
-    @classmethod
-    def sum_of_squares(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_sum_of_squares_aggregation[aggregation]()
-        )
-        return agg
-
-    @classmethod
-    def var(cls, ddof=1):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_variance_aggregation[aggregation](ddof))
-        return agg
-
-    @classmethod
-    def std(cls, ddof=1):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_std_aggregation[aggregation](ddof))
-        return agg
-
-    @classmethod
-    def median(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_median_aggregation[aggregation]())
-        return agg
-
-    @classmethod
-    def quantile(cls, q=0.5, interpolation="linear"):
-        cdef Aggregation agg = cls()
-
-        if not pd.api.types.is_list_like(q):
-            q = [q]
-
-        cdef vector[double] c_q = q
-        cdef libcudf_types.interpolation c_interp = (
-            <libcudf_types.interpolation> (
-                <underlying_type_t_interpolation> (
-                    Interpolation[interpolation.upper()]
-                )
-            )
-        )
-        agg.c_obj = move(
-            libcudf_aggregation.make_quantile_aggregation[aggregation](
-                c_q, c_interp)
-        )
-        return agg
-
-    @classmethod
-    def collect(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_collect_list_aggregation[aggregation]())
-        return agg
-
-    @classmethod
-    def unique(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_collect_set_aggregation[aggregation]())
-        return agg
-
-    @classmethod
-    def from_udf(cls, op, *args, **kwargs):
-        cdef Aggregation agg = cls()
-
-        cdef libcudf_types.type_id tid
-        cdef libcudf_types.data_type out_dtype
-        cdef string cpp_str
-
-        # Handling UDF type
-        nb_type = numpy_support.from_dtype(kwargs['dtype'])
-        type_signature = (nb_type[:],)
-        compiled_op = cudautils.compile_udf(op, type_signature)
-        output_np_dtype = cudf.dtype(compiled_op[1])
-        cpp_str = compiled_op[0].encode('UTF-8')
-        if output_np_dtype not in SUPPORTED_NUMPY_TO_LIBCUDF_TYPES:
-            raise TypeError(
-                "Result of window function has unsupported dtype {}"
-                .format(op[1])
-            )
-        tid = (
-            <libcudf_types.type_id> (
-                <underlying_type_t_type_id> (
-                    SUPPORTED_NUMPY_TO_LIBCUDF_TYPES[output_np_dtype]
-                )
-            )
-        )
-        out_dtype = libcudf_types.data_type(tid)
-
-        agg.c_obj = move(
-            libcudf_aggregation.make_udf_aggregation[aggregation](
-                libcudf_aggregation.udf_type.PTX, cpp_str, out_dtype
-            ))
-        return agg
-
-    # scan aggregations
-    # TODO: update this after adding per algorithm aggregation derived types
-    # https://github.com/rapidsai/cudf/issues/7106
-    cumsum = sum
-    cummin = min
-    cummax = max
-
-    @classmethod
-    def cumcount(cls):
-        cdef Aggregation agg = cls()
-        agg.c_obj = move(
-            libcudf_aggregation.make_count_aggregation[aggregation](
-                libcudf_types.null_policy.INCLUDE
-            ))
-        return agg
-
-    @classmethod
-    def corr(cls, method, libcudf_types.size_type min_periods):
-        cdef Aggregation agg = cls()
-        cdef libcudf_aggregation.correlation_type c_method = (
-            <libcudf_aggregation.correlation_type> (
-                <underlying_type_t_correlation_type> (
-                    CorrelationType[method.upper()]
-                )
-            )
-        )
-        agg.c_obj = move(
-            libcudf_aggregation.make_correlation_aggregation[aggregation](
-                c_method, min_periods
-            ))
-        return agg
-
-
 cdef class RollingAggregation:
     """A Cython wrapper for rolling window aggregations.
 
@@ -844,7 +565,202 @@ cdef class GroupbyScanAggregation:
     cummax = max
 
 
-cdef Aggregation make_aggregation(op, kwargs=None):
+cdef class ReduceAggregation:
+    """A Cython wrapper for reduce aggregations.
+
+    **This class should never be instantiated using a standard constructor,
+    only using one of its many factories.** These factories handle mapping
+    different cudf operations to their libcudf analogs, e.g.
+    `cudf.DataFrame.idxmin` -> `libcudf.argmin`. Additionally, they perform
+    any additional configuration needed to translate Python arguments into
+    their corresponding C++ types (for instance, C++ enumerations used for
+    flag arguments). The factory approach is necessary to support operations
+    like `df.agg(lambda x: x.sum())`; such functions are called with this
+    class as an argument to generation the desired aggregation.
+    """
+    @property
+    def kind(self):
+        return AggregationKind(self.c_obj.get()[0].kind).name
+
+    @classmethod
+    def sum(cls):
+        cdef ReduceAggregation agg = cls()
+        agg.c_obj = move(
+            libcudf_aggregation.
+            make_sum_aggregation[reduce_aggregation]())
+        return agg
+
+    @classmethod
+    def product(cls):
+        cdef ReduceAggregation agg = cls()
+        agg.c_obj = move(
+            libcudf_aggregation.make_product_aggregation[
+                reduce_aggregation]())
+        return agg
+    prod = product
+
+    @classmethod
+    def min(cls):
+        cdef ReduceAggregation agg = cls()
+        agg.c_obj = move(
+            libcudf_aggregation.
+            make_min_aggregation[reduce_aggregation]())
+        return agg
+
+    @classmethod
+    def max(cls):
+        cdef ReduceAggregation agg = cls()
+        agg.c_obj = move(
+            libcudf_aggregation.
+            make_max_aggregation[reduce_aggregation]())
+        return agg
+
+    @classmethod
+    def any(cls):
+        cdef ReduceAggregation agg = cls()
+        agg.c_obj = move(
+            libcudf_aggregation.make_any_aggregation[reduce_aggregation]())
+        return agg
+
+    @classmethod
+    def all(cls):
+        cdef ReduceAggregation agg = cls()
+        agg.c_obj = move(
+            libcudf_aggregation.make_all_aggregation[reduce_aggregation]())
+        return agg
+
+    @classmethod
+    def sum_of_squares(cls):
+        cdef ReduceAggregation agg = cls()
+        agg.c_obj = move(
+            libcudf_aggregation.make_sum_of_squares_aggregation[
+                reduce_aggregation]()
+        )
+        return agg
+
+    @classmethod
+    def mean(cls):
+        cdef ReduceAggregation agg = cls()
+        agg.c_obj = move(
+            libcudf_aggregation.make_mean_aggregation[reduce_aggregation]())
+        return agg
+
+    @classmethod
+    def var(cls, ddof=1):
+        cdef ReduceAggregation agg = cls()
+        agg.c_obj = move(
+            libcudf_aggregation.make_variance_aggregation[
+                reduce_aggregation](ddof))
+        return agg
+
+    @classmethod
+    def std(cls, ddof=1):
+        cdef ReduceAggregation agg = cls()
+        agg.c_obj = move(
+            libcudf_aggregation.make_std_aggregation[reduce_aggregation](ddof))
+        return agg
+
+    @classmethod
+    def median(cls):
+        cdef ReduceAggregation agg = cls()
+        agg.c_obj = move(
+            libcudf_aggregation.make_median_aggregation[reduce_aggregation]())
+        return agg
+
+    @classmethod
+    def quantile(cls, q=0.5, interpolation="linear"):
+        cdef ReduceAggregation agg = cls()
+
+        if not pd.api.types.is_list_like(q):
+            q = [q]
+
+        cdef vector[double] c_q = q
+        cdef libcudf_types.interpolation c_interp = (
+            <libcudf_types.interpolation> (
+                <underlying_type_t_interpolation> (
+                    Interpolation[interpolation.upper()]
+                )
+            )
+        )
+        agg.c_obj = move(
+            libcudf_aggregation.make_quantile_aggregation[reduce_aggregation](
+                c_q, c_interp)
+        )
+        return agg
+
+    @classmethod
+    def nunique(cls):
+        cdef ReduceAggregation agg = cls()
+        agg.c_obj = move(
+            libcudf_aggregation.make_nunique_aggregation[reduce_aggregation]())
+        return agg
+
+    @classmethod
+    def nth(cls, libcudf_types.size_type size):
+        cdef ReduceAggregation agg = cls()
+        agg.c_obj = move(
+            libcudf_aggregation.make_nth_element_aggregation[
+                reduce_aggregation](size))
+        return agg
+
+cdef class ScanAggregation:
+    """A Cython wrapper for scan aggregations.
+
+    **This class should never be instantiated using a standard constructor,
+    only using one of its many factories.** These factories handle mapping
+    different cudf operations to their libcudf analogs, e.g.
+    `cudf.DataFrame.idxmin` -> `libcudf.argmin`. Additionally, they perform
+    any additional configuration needed to translate Python arguments into
+    their corresponding C++ types (for instance, C++ enumerations used for
+    flag arguments). The factory approach is necessary to support operations
+    like `df.agg(lambda x: x.sum())`; such functions are called with this
+    class as an argument to generation the desired aggregation.
+    """
+    @property
+    def kind(self):
+        return AggregationKind(self.c_obj.get()[0].kind).name
+
+    @classmethod
+    def sum(cls):
+        cdef ScanAggregation agg = cls()
+        agg.c_obj = move(
+            libcudf_aggregation.
+            make_sum_aggregation[scan_aggregation]())
+        return agg
+
+    @classmethod
+    def product(cls):
+        cdef ScanAggregation agg = cls()
+        agg.c_obj = move(
+            libcudf_aggregation.make_product_aggregation[scan_aggregation]())
+        return agg
+    prod = product
+
+    @classmethod
+    def min(cls):
+        cdef ScanAggregation agg = cls()
+        agg.c_obj = move(
+            libcudf_aggregation.
+            make_min_aggregation[scan_aggregation]())
+        return agg
+
+    @classmethod
+    def max(cls):
+        cdef ScanAggregation agg = cls()
+        agg.c_obj = move(
+            libcudf_aggregation.
+            make_max_aggregation[scan_aggregation]())
+        return agg
+
+    # scan aggregations
+    # TODO: update this after adding per algorithm aggregation derived types
+    # https://github.com/rapidsai/cudf/issues/7106
+    cumsum = sum
+    cummin = min
+    cummax = max
+
+
+cdef RollingAggregation make_rolling_aggregation(op, kwargs=None):
     r"""
     Parameters
     ----------
@@ -863,26 +779,26 @@ cdef Aggregation make_aggregation(op, kwargs=None):
 
     Returns
     -------
-    Aggregation
+    RollingAggregation
     """
     if kwargs is None:
         kwargs = {}
 
-    cdef Aggregation agg
+    cdef RollingAggregation agg
     if isinstance(op, str):
-        agg = getattr(Aggregation, op)(**kwargs)
+        agg = getattr(RollingAggregation, op)(**kwargs)
     elif callable(op):
         if op is list:
-            agg = Aggregation.collect()
+            agg = RollingAggregation.collect()
         elif "dtype" in kwargs:
-            agg = Aggregation.from_udf(op, **kwargs)
+            agg = RollingAggregation.from_udf(op, **kwargs)
         else:
-            agg = op(Aggregation)
+            agg = op(RollingAggregation)
     else:
         raise TypeError(f"Unknown aggregation {op}")
     return agg
 
-cdef RollingAggregation make_rolling_aggregation(op, kwargs=None):
+cdef GroupbyAggregation make_groupby_aggregation(op, kwargs=None):
     r"""
     Parameters
     ----------
@@ -901,26 +817,26 @@ cdef RollingAggregation make_rolling_aggregation(op, kwargs=None):
 
     Returns
     -------
-    RollingAggregation
+    GroupbyAggregation
     """
     if kwargs is None:
         kwargs = {}
 
-    cdef RollingAggregation agg
+    cdef GroupbyAggregation agg
     if isinstance(op, str):
-        agg = getattr(RollingAggregation, op)(**kwargs)
+        agg = getattr(GroupbyAggregation, op)(**kwargs)
     elif callable(op):
         if op is list:
-            agg = RollingAggregation.collect()
+            agg = GroupbyAggregation.collect()
         elif "dtype" in kwargs:
-            agg = RollingAggregation.from_udf(op, **kwargs)
+            agg = GroupbyAggregation.from_udf(op, **kwargs)
         else:
-            agg = op(RollingAggregation)
+            agg = op(GroupbyAggregation)
     else:
         raise TypeError(f"Unknown aggregation {op}")
     return agg
 
-cdef GroupbyAggregation make_groupby_aggregation(op, kwargs=None):
+cdef GroupbyScanAggregation make_groupby_scan_aggregation(op, kwargs=None):
     r"""
     Parameters
     ----------
@@ -932,33 +848,33 @@ cdef GroupbyAggregation make_groupby_aggregation(op, kwargs=None):
           to specify aggregations that take arguments, e.g.,
           `lambda x: x.quantile(0.5)`.
         * Is a user defined aggregation function that operates on
-          group values. In this case, the output dtype must be
+          grouped, scannable values. In this case, the output dtype must be
           specified in the `kwargs` dictionary.
     \*\*kwargs : dict, optional
         Any keyword arguments to be passed to the op.
 
     Returns
     -------
-    GroupbyAggregation
+    GroupbyScanAggregation
     """
     if kwargs is None:
         kwargs = {}
 
-    cdef GroupbyAggregation agg
+    cdef GroupbyScanAggregation agg
     if isinstance(op, str):
-        agg = getattr(GroupbyAggregation, op)(**kwargs)
+        agg = getattr(GroupbyScanAggregation, op)(**kwargs)
     elif callable(op):
         if op is list:
-            agg = GroupbyAggregation.collect()
+            agg = GroupbyScanAggregation.collect()
         elif "dtype" in kwargs:
-            agg = GroupbyAggregation.from_udf(op, **kwargs)
+            agg = GroupbyScanAggregation.from_udf(op, **kwargs)
         else:
-            agg = op(GroupbyAggregation)
+            agg = op(GroupbyScanAggregation)
     else:
         raise TypeError(f"Unknown aggregation {op}")
     return agg
 
-cdef GroupbyScanAggregation make_groupby_scan_aggregation(op, kwargs=None):
+cdef ReduceAggregation make_reduce_aggregation(op, kwargs=None):
     r"""
     Parameters
     ----------
@@ -970,28 +886,66 @@ cdef GroupbyScanAggregation make_groupby_scan_aggregation(op, kwargs=None):
           to specify aggregations that take arguments, e.g.,
           `lambda x: x.quantile(0.5)`.
         * Is a user defined aggregation function that operates on
-          group values. In this case, the output dtype must be
+          reducible values. In this case, the output dtype must be
           specified in the `kwargs` dictionary.
     \*\*kwargs : dict, optional
         Any keyword arguments to be passed to the op.
 
     Returns
     -------
-    GroupbyScanAggregation
+    ReduceAggregation
     """
     if kwargs is None:
         kwargs = {}
 
-    cdef GroupbyScanAggregation agg
+    cdef ReduceAggregation agg
     if isinstance(op, str):
-        agg = getattr(GroupbyScanAggregation, op)(**kwargs)
+        agg = getattr(ReduceAggregation, op)(**kwargs)
     elif callable(op):
         if op is list:
-            agg = GroupbyScanAggregation.collect()
+            agg = ReduceAggregation.collect()
         elif "dtype" in kwargs:
-            agg = GroupbyScanAggregation.from_udf(op, **kwargs)
+            agg = ReduceAggregation.from_udf(op, **kwargs)
         else:
-            agg = op(GroupbyScanAggregation)
+            agg = op(ReduceAggregation)
+    else:
+        raise TypeError(f"Unknown aggregation {op}")
+    return agg
+
+cdef ScanAggregation make_scan_aggregation(op, kwargs=None):
+    r"""
+    Parameters
+    ----------
+    op : str or callable
+        If callable, must meet one of the following requirements:
+
+        * Is of the form lambda x: x.agg(*args, **kwargs), where
+          `agg` is the name of a supported aggregation. Used to
+          to specify aggregations that take arguments, e.g.,
+          `lambda x: x.quantile(0.5)`.
+        * Is a user defined aggregation function that operates on
+          scannable values. In this case, the output dtype must be
+          specified in the `kwargs` dictionary.
+    \*\*kwargs : dict, optional
+        Any keyword arguments to be passed to the op.
+
+    Returns
+    -------
+    ScanAggregation
+    """
+    if kwargs is None:
+        kwargs = {}
+
+    cdef ScanAggregation agg
+    if isinstance(op, str):
+        agg = getattr(ScanAggregation, op)(**kwargs)
+    elif callable(op):
+        if op is list:
+            agg = ScanAggregation.collect()
+        elif "dtype" in kwargs:
+            agg = ScanAggregation.from_udf(op, **kwargs)
+        else:
+            agg = op(ScanAggregation)
     else:
         raise TypeError(f"Unknown aggregation {op}")
     return agg
diff --git a/python/cudf/cudf/_lib/cpp/aggregation.pxd b/python/cudf/cudf/_lib/cpp/aggregation.pxd
index 04eead4ee1b..399deb74c9c 100644
--- a/python/cudf/cudf/_lib/cpp/aggregation.pxd
+++ b/python/cudf/cudf/_lib/cpp/aggregation.pxd
@@ -53,6 +53,12 @@ cdef extern from "cudf/aggregation.hpp" namespace "cudf" nogil:
     cdef cppclass groupby_scan_aggregation:
         aggregation.Kind kind
 
+    cdef cppclass reduce_aggregation:
+        aggregation.Kind kind
+
+    cdef cppclass scan_aggregation:
+        aggregation.Kind kind
+
     ctypedef enum udf_type:
         CUDA 'cudf::udf_type::CUDA'
         PTX 'cudf::udf_type::PTX'
diff --git a/python/cudf/cudf/_lib/cpp/reduce.pxd b/python/cudf/cudf/_lib/cpp/reduce.pxd
index 53c8cd59468..22ae09346ed 100644
--- a/python/cudf/cudf/_lib/cpp/reduce.pxd
+++ b/python/cudf/cudf/_lib/cpp/reduce.pxd
@@ -1,9 +1,9 @@
-# Copyright (c) 2020, NVIDIA CORPORATION.
+# Copyright (c) 2020-2022, NVIDIA CORPORATION.
 
 from libcpp.memory cimport unique_ptr
 from libcpp.utility cimport pair
 
-from cudf._lib.aggregation cimport aggregation
+from cudf._lib.aggregation cimport reduce_aggregation, scan_aggregation
 from cudf._lib.cpp.column.column cimport column
 from cudf._lib.cpp.column.column_view cimport column_view
 from cudf._lib.cpp.scalar.scalar cimport scalar
@@ -14,7 +14,7 @@ from cudf._lib.scalar cimport DeviceScalar
 cdef extern from "cudf/reduction.hpp" namespace "cudf" nogil:
     cdef unique_ptr[scalar] cpp_reduce "cudf::reduce" (
         column_view col,
-        const unique_ptr[aggregation] agg,
+        const unique_ptr[reduce_aggregation] agg,
         data_type type
     ) except +
 
@@ -24,7 +24,7 @@ cdef extern from "cudf/reduction.hpp" namespace "cudf" nogil:
 
     cdef unique_ptr[column] cpp_scan "cudf::scan" (
         column_view col,
-        const unique_ptr[aggregation] agg,
+        const unique_ptr[scan_aggregation] agg,
         scan_type inclusive
     ) except +
 
diff --git a/python/cudf/cudf/_lib/reduce.pyx b/python/cudf/cudf/_lib/reduce.pyx
index ecb787703d2..1d7c5690b79 100644
--- a/python/cudf/cudf/_lib/reduce.pyx
+++ b/python/cudf/cudf/_lib/reduce.pyx
@@ -1,4 +1,4 @@
-# Copyright (c) 2020-2021, NVIDIA CORPORATION.
+# Copyright (c) 2020-2022, NVIDIA CORPORATION.
 
 import cudf
 from cudf.api.types import is_decimal_dtype
@@ -16,7 +16,12 @@ from cudf._lib.types import SUPPORTED_NUMPY_TO_LIBCUDF_TYPES
 from libcpp.memory cimport unique_ptr
 from libcpp.utility cimport move, pair
 
-from cudf._lib.aggregation cimport Aggregation, make_aggregation
+from cudf._lib.aggregation cimport (
+    ReduceAggregation,
+    ScanAggregation,
+    make_reduce_aggregation,
+    make_scan_aggregation,
+)
 from cudf._lib.types cimport (
     dtype_to_data_type,
     is_decimal_type_id,
@@ -50,7 +55,8 @@ def reduce(reduction_op, Column incol, dtype=None, **kwargs):
 
     cdef column_view c_incol_view = incol.view()
     cdef unique_ptr[scalar] c_result
-    cdef Aggregation cython_agg = make_aggregation(reduction_op, kwargs)
+    cdef ReduceAggregation cython_agg = make_reduce_aggregation(
+        reduction_op, kwargs)
 
     cdef data_type c_out_dtype = dtype_to_data_type(col_dtype)
 
@@ -98,7 +104,7 @@ def scan(scan_op, Column incol, inclusive, **kwargs):
     """
     cdef column_view c_incol_view = incol.view()
     cdef unique_ptr[column] c_result
-    cdef Aggregation cython_agg = make_aggregation(scan_op, kwargs)
+    cdef ScanAggregation cython_agg = make_scan_aggregation(scan_op, kwargs)
 
     cdef scan_type c_inclusive = \
         scan_type.INCLUSIVE if inclusive else scan_type.EXCLUSIVE