diff --git a/benchmarks/hash_table/static_set/insert_bench.cu b/benchmarks/hash_table/static_set/insert_bench.cu
index 48bc37fa4..c2443c107 100644
--- a/benchmarks/hash_table/static_set/insert_bench.cu
+++ b/benchmarks/hash_table/static_set/insert_bench.cu
@@ -47,8 +47,10 @@ void static_set_insert(nvbench::state& state, nvbench::type_list<Key, Dist>)
 
   state.exec(nvbench::exec_tag::sync | nvbench::exec_tag::timer,
              [&](nvbench::launch& launch, auto& timer) {
-               cuco::experimental::static_set<Key> set{
-                 size, cuco::empty_key<Key>{-1}, {}, {}, {}, {launch.get_stream()}};
+               auto set = cuco::experimental::make_static_set<Key>(
+                 cuco::experimental::extent<std::size_t>{size},
+                 cuco::empty_key<Key>{-1},
+                 cuco::experimental::cuda_stream_ref{launch.get_stream()});
 
                timer.start();
                set.insert(keys.begin(), keys.end(), {launch.get_stream()});
diff --git a/include/cuco/detail/extent_base.cuh b/include/cuco/detail/extent_base.cuh
new file mode 100644
index 000000000..063fcc741
--- /dev/null
+++ b/include/cuco/detail/extent_base.cuh
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2023, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <type_traits>
+
+namespace cuco::experimental::detail {
+
+/**
+ * @brief Base class of public extent class.
+ *
+ * This class should not be used directly.
+ *
+ * @tparam SizeType Size type
+ */
+template <typename SizeType>
+class extent_base {
+  static_assert(std::is_integral_v<SizeType>, "SizeType bust be integral.");
+
+ public:
+  using value_type = SizeType;  ///< Extent value type
+};
+}  // namespace cuco::experimental::detail
\ No newline at end of file
diff --git a/include/cuco/detail/static_set/static_set.inl b/include/cuco/detail/static_set/static_set.inl
index 1800c8910..c296dd46d 100644
--- a/include/cuco/detail/static_set/static_set.inl
+++ b/include/cuco/detail/static_set/static_set.inl
@@ -20,6 +20,7 @@
 #include <cuco/detail/static_set/functors.cuh>
 #include <cuco/detail/static_set/kernels.cuh>
 #include <cuco/detail/storage/counter_storage.cuh>
+#include <cuco/detail/traits.hpp>
 #include <cuco/detail/tuning.cuh>
 #include <cuco/detail/utils.hpp>
 #include <cuco/operator.hpp>
@@ -39,18 +40,19 @@ namespace cuco {
 namespace experimental {
 
 template <class Key,
-          class Extent,
           cuda::thread_scope Scope,
+          class Extent,
           class KeyEqual,
           class ProbingScheme,
           class Allocator,
           class Storage>
-constexpr static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::static_set(
+constexpr static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::static_set(
   Extent capacity,
   empty_key<Key> empty_key_sentinel,
   KeyEqual pred,
   ProbingScheme const& probing_scheme,
   Allocator const& alloc,
+  [[maybe_unused]] Storage const& storage,
   cuda_stream_ref stream)
   : empty_key_sentinel_{empty_key_sentinel},
     predicate_{pred},
@@ -62,15 +64,15 @@ constexpr static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Sto
 }
 
 template <class Key,
-          class Extent,
           cuda::thread_scope Scope,
+          class Extent,
           class KeyEqual,
           class ProbingScheme,
           class Allocator,
           class Storage>
 template <typename InputIt>
-static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::size_type
-static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::insert(
+static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::size_type
+static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::insert(
   InputIt first, InputIt last, cuda_stream_ref stream)
 {
   auto const num_keys = cuco::detail::distance(first, last);
@@ -92,14 +94,14 @@ static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::ins
 }
 
 template <class Key,
-          class Extent,
           cuda::thread_scope Scope,
+          class Extent,
           class KeyEqual,
           class ProbingScheme,
           class Allocator,
           class Storage>
 template <typename InputIt>
-void static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::insert_async(
+void static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::insert_async(
   InputIt first, InputIt last, cuda_stream_ref stream)
 {
   auto const num_keys = cuco::detail::distance(first, last);
@@ -116,15 +118,15 @@ void static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>
 }
 
 template <class Key,
-          class Extent,
           cuda::thread_scope Scope,
+          class Extent,
           class KeyEqual,
           class ProbingScheme,
           class Allocator,
           class Storage>
 template <typename InputIt, typename StencilIt, typename Predicate>
-static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::size_type
-static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::insert_if(
+static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::size_type
+static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::insert_if(
   InputIt first, InputIt last, StencilIt stencil, Predicate pred, cuda_stream_ref stream)
 {
   auto const num_keys = cuco::detail::distance(first, last);
@@ -145,14 +147,14 @@ static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::ins
 }
 
 template <class Key,
-          class Extent,
           cuda::thread_scope Scope,
+          class Extent,
           class KeyEqual,
           class ProbingScheme,
           class Allocator,
           class Storage>
 template <typename InputIt, typename StencilIt, typename Predicate>
-void static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::insert_if_async(
+void static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::insert_if_async(
   InputIt first, InputIt last, StencilIt stencil, Predicate pred, cuda_stream_ref stream)
 {
   auto const num_keys = cuco::detail::distance(first, last);
@@ -168,14 +170,14 @@ void static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>
 }
 
 template <class Key,
-          class Extent,
           cuda::thread_scope Scope,
+          class Extent,
           class KeyEqual,
           class ProbingScheme,
           class Allocator,
           class Storage>
 template <typename InputIt, typename OutputIt>
-void static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::contains(
+void static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::contains(
   InputIt first, InputIt last, OutputIt output_begin, cuda_stream_ref stream) const
 {
   contains_async(first, last, output_begin, stream);
@@ -183,14 +185,14 @@ void static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>
 }
 
 template <class Key,
-          class Extent,
           cuda::thread_scope Scope,
+          class Extent,
           class KeyEqual,
           class ProbingScheme,
           class Allocator,
           class Storage>
 template <typename InputIt, typename OutputIt>
-void static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::contains_async(
+void static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::contains_async(
   InputIt first, InputIt last, OutputIt output_begin, cuda_stream_ref stream) const
 {
   auto const num_keys = cuco::detail::distance(first, last);
@@ -212,14 +214,14 @@ void static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>
 }
 
 template <class Key,
-          class Extent,
           cuda::thread_scope Scope,
+          class Extent,
           class KeyEqual,
           class ProbingScheme,
           class Allocator,
           class Storage>
 template <typename InputIt, typename OutputIt>
-void static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::find(
+void static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::find(
   InputIt first, InputIt last, OutputIt output_begin, cuda_stream_ref stream) const
 {
   find_async(first, last, output_begin, stream);
@@ -227,14 +229,14 @@ void static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>
 }
 
 template <class Key,
-          class Extent,
           cuda::thread_scope Scope,
+          class Extent,
           class KeyEqual,
           class ProbingScheme,
           class Allocator,
           class Storage>
 template <typename InputIt, typename OutputIt>
-void static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::find_async(
+void static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::find_async(
   InputIt first, InputIt last, OutputIt output_begin, cuda_stream_ref stream) const
 {
   auto const num_keys = cuco::detail::distance(first, last);
@@ -250,14 +252,14 @@ void static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>
 }
 
 template <class Key,
-          class Extent,
           cuda::thread_scope Scope,
+          class Extent,
           class KeyEqual,
           class ProbingScheme,
           class Allocator,
           class Storage>
 template <typename OutputIt>
-OutputIt static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::retrieve_all(
+OutputIt static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::retrieve_all(
   OutputIt output_begin, cuda_stream_ref stream) const
 {
   auto begin  = thrust::make_transform_iterator(thrust::counting_iterator<size_type>(0),
@@ -296,14 +298,14 @@ OutputIt static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Stor
 }
 
 template <class Key,
-          class Extent,
           cuda::thread_scope Scope,
+          class Extent,
           class KeyEqual,
           class ProbingScheme,
           class Allocator,
           class Storage>
-static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::size_type
-static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::size(
+static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::size_type
+static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::size(
   cuda_stream_ref stream) const
 {
   auto counter = detail::counter_storage<size_type, thread_scope, allocator_type>{allocator_};
@@ -323,47 +325,68 @@ static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::siz
 }
 
 template <class Key,
-          class Extent,
           cuda::thread_scope Scope,
+          class Extent,
           class KeyEqual,
           class ProbingScheme,
           class Allocator,
           class Storage>
 constexpr auto
-static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::capacity()
+static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::capacity()
   const noexcept
 {
   return storage_.capacity();
 }
 
 template <class Key,
-          class Extent,
           cuda::thread_scope Scope,
+          class Extent,
           class KeyEqual,
           class ProbingScheme,
           class Allocator,
           class Storage>
-constexpr static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::key_type
-static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::empty_key_sentinel()
+constexpr static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::key_type
+static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::empty_key_sentinel()
   const noexcept
 {
   return empty_key_sentinel_;
 }
 
 template <class Key,
-          class Extent,
           cuda::thread_scope Scope,
+          class Extent,
           class KeyEqual,
           class ProbingScheme,
           class Allocator,
           class Storage>
 template <typename... Operators>
-auto static_set<Key, Extent, Scope, KeyEqual, ProbingScheme, Allocator, Storage>::ref(
+auto static_set<Key, Scope, Extent, KeyEqual, ProbingScheme, Allocator, Storage>::ref(
   Operators...) const noexcept
 {
   static_assert(sizeof...(Operators), "No operators specified");
   return ref_type<Operators...>{
     cuco::empty_key<key_type>(empty_key_sentinel_), predicate_, probing_scheme_, storage_.ref()};
 }
+
+template <class Key, cuda::thread_scope Scope, class... Args>
+constexpr auto make_static_set(Args&&... args)
+{
+  // TODO don't repeat defaults
+  return static_set<Key, Scope>{
+    detail::find_arg<detail::is_extent>(std::forward<Args>(args)...),  // required parameter
+    detail::find_arg<empty_key<Key>>(std::forward<Args>(args)...),     // required parameter
+    detail::find_arg<detail::key_equal_traits<Key>::template is_equal_functor_t>(
+      std::forward<Args>(args)..., thrust::equal_to<Key>{}),
+    detail::find_arg<detail::is_probing_scheme>(std::forward<Args>(args)...,
+                                                double_hashing<4,  // CG size
+                                                               cuco::murmurhash3_32<Key>,
+                                                               cuco::murmurhash3_32<Key>>{}),
+    detail::find_arg<detail::is_allocator>(std::forward<Args>(args)...,
+                                           cuco::cuda_allocator<std::byte>{}),
+    detail::find_arg<detail::is_storage>(std::forward<Args>(args)...,
+                                         cuco::experimental::aow_storage<1>{}),
+    detail::find_arg<cuda_stream_ref>(std::forward<Args>(args)..., cuda_stream_ref{})};
+}
+
 }  // namespace experimental
 }  // namespace cuco
diff --git a/include/cuco/detail/traits.hpp b/include/cuco/detail/traits.hpp
new file mode 100644
index 000000000..722b0f9c3
--- /dev/null
+++ b/include/cuco/detail/traits.hpp
@@ -0,0 +1,118 @@
+/*
+ * Copyright (c) 2023, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cuco/detail/extent_base.cuh>
+#include <cuco/detail/probing_scheme_base.cuh>
+// #include <cuco/detail/storage/storage_base.cuh> // FIXME check inheritance
+#include <cuco/storage.cuh>
+
+#include <memory>
+#include <type_traits>
+
+namespace cuco::experimental::detail {
+
+// Trait to check if T is a valid probing scheme type
+template <typename T, typename Enable = void>
+struct is_probing_scheme : std::false_type {
+};
+
+template <typename T>
+struct is_probing_scheme<
+  T,
+  std::enable_if_t<
+    std::is_base_of_v<cuco::experimental::detail::probing_scheme_base<T::cg_size>, T>>>
+  : std::true_type {
+};
+
+template <typename T>
+inline constexpr bool is_probing_scheme_v = is_probing_scheme<T>::value;
+
+template <typename T, typename Enable = void>
+struct is_storage : std::false_type {
+};
+
+template <typename T>
+struct is_storage<
+  T,
+  std::enable_if_t<std::is_same_v<cuco::experimental::aow_storage<T::window_size>, T>>>
+  : std::true_type {
+};
+
+/* FIXME
+std::enable_if_t<std::is_base_of_v<
+  typename cuco::experimental::detail::storage_base<typename T::extent_type>,
+  T>>> : std::true_type {};
+*/
+
+template <typename T>
+inline constexpr bool is_storage_v = is_storage<T>::value;
+
+// Trait to check if T is a `cuco::extent`
+template <typename T, typename Enable = void>
+struct is_extent : std::false_type {
+};
+
+template <typename T>
+struct is_extent<
+  T,
+  std::enable_if_t<
+    std::is_base_of_v<typename cuco::experimental::detail::extent_base<typename T::value_type>, T>>>
+  : std::true_type {
+};
+
+template <typename T>
+inline constexpr bool is_extent_v = is_extent<T>::value;
+
+// Trait to check if T is allocator-like
+template <typename T, typename Enable = std::void_t<>>
+struct is_allocator : std::false_type {
+};
+
+template <typename T>
+struct is_allocator<T,
+                    std::void_t<typename T::value_type,
+                                decltype(std::declval<T&>().allocate(std::size_t{})),
+                                decltype(std::declval<T&>().deallocate(
+                                  std::declval<typename T::value_type*>(), std::size_t{}))>>
+  : std::true_type {
+};
+
+template <typename T>
+inline constexpr bool is_allocator_v = is_allocator<T>::value;
+
+template <typename Key>
+struct key_equal_traits {
+  template <typename T, typename = std::void_t<>>
+  struct is_equal_functor : std::false_type {
+  };
+
+  template <typename T>
+  struct is_equal_functor<
+    T,
+    std::void_t<std::enable_if_t<std::is_invocable_r_v<bool, T, Key const&, Key const&>>>>
+    : std::true_type {
+  };
+
+  template <typename T>
+  using is_equal_functor_t = typename is_equal_functor<T>::type;
+
+  template <typename T>
+  static constexpr bool is_equal_functor_v = is_equal_functor<T>::value;
+};
+
+}  // namespace cuco::experimental::detail
\ No newline at end of file
diff --git a/include/cuco/detail/utils.hpp b/include/cuco/detail/utils.hpp
index 513ccd559..50b9034cd 100644
--- a/include/cuco/detail/utils.hpp
+++ b/include/cuco/detail/utils.hpp
@@ -105,4 +105,44 @@ constexpr ForwardIt lower_bound(ForwardIt first, ForwardIt last, const T& value)
 }
 
 }  // namespace detail
+
+namespace experimental::detail {
+
+// TODO docs
+template <template <typename> typename Predicate, typename...>
+constexpr void find_arg(...)
+{  // end of parameter pack
+  static_assert(Predicate<void>(), "Missing required parameter");
+}
+
+template <template <typename> typename Predicate, typename T, typename... Args>
+constexpr decltype(auto) find_arg(T&& t, Args&&... args)
+{
+  // if the current head of the parameter pack matches the predicate
+  if constexpr (Predicate<std::remove_reference_t<T>>()) { return std::forward<T>(t); }
+  // else go to the next element in the pack
+  if constexpr (not Predicate<std::remove_reference_t<T>>()) {
+    return find_arg<Predicate>(std::forward<Args&&>(args)...);
+  }
+}
+
+// TODO docs
+template <typename Compare, typename...>
+constexpr void find_arg(...)
+{  // end of parameter pack
+  static_assert(std::is_same_v<Compare, void>, "Missing required parameter");
+}
+
+template <typename Compare, typename T, typename... Args>
+constexpr decltype(auto) find_arg(T&& t, Args&&... args)
+{
+  // if the current head of the parameter pack matches the Compare type
+  if constexpr (std::is_same_v<Compare, T>) { return std::forward<T>(t); }
+  // else go to the next element in the pack
+  if constexpr (not std::is_same_v<Compare, T>) {
+    return find_arg<Compare>(std::forward<Args&&>(args)...);
+  }
+}
+
+}  // namespace experimental::detail
 }  // namespace cuco
diff --git a/include/cuco/extent.cuh b/include/cuco/extent.cuh
index b825188ed..131cb778d 100644
--- a/include/cuco/extent.cuh
+++ b/include/cuco/extent.cuh
@@ -16,6 +16,7 @@
 
 #pragma once
 
+#include <cuco/detail/extent_base.cuh>
 #include <cuco/detail/prime.hpp>
 
 #include <cstddef>
@@ -32,8 +33,8 @@ static constexpr std::size_t dynamic_extent = static_cast<std::size_t>(-1);
  * @tparam N Extent
  */
 template <typename SizeType, std::size_t N = dynamic_extent>
-struct extent {
-  using value_type = SizeType;  ///< Extent value type
+struct extent : private detail::extent_base<SizeType> {
+  using value_type = typename detail::extent_base<SizeType>::value_type;  ///< Extent value type
 
   constexpr extent() = default;
 
@@ -67,8 +68,8 @@ struct extent {
  * @tparam SizeType Size type
  */
 template <typename SizeType>
-struct extent<SizeType, dynamic_extent> {
-  using value_type = SizeType;  ///< Extent value type
+struct extent<SizeType, dynamic_extent> : private detail::extent_base<SizeType> {
+  using value_type = typename detail::extent_base<SizeType>::value_type;  ///< Extent value type
 
   /**
    * @brief Constructs extent from a given `size`.
diff --git a/include/cuco/static_set.cuh b/include/cuco/static_set.cuh
index 90d59a2e1..15dd393bc 100644
--- a/include/cuco/static_set.cuh
+++ b/include/cuco/static_set.cuh
@@ -73,8 +73,8 @@ namespace experimental {
  * @throw If the probing scheme type is not inherited from `cuco::detail::probing_scheme_base`
  *
  * @tparam Key Type used for keys. Requires `cuco::is_bitwise_comparable_v<Key>`
- * @tparam Extent Data structure size type
  * @tparam Scope The scope in which operations will be performed by individual threads.
+ * @tparam Extent Data structure size type
  * @tparam KeyEqual Binary callable type used to compare two keys for equality
  * @tparam ProbingScheme Probing scheme (see `include/cuco/probing_scheme.cuh` for choices)
  * @tparam Allocator Type of allocator used for device storage
@@ -82,8 +82,8 @@ namespace experimental {
  */
 
 template <class Key,
-          class Extent             = cuco::experimental::extent<std::size_t>,
           cuda::thread_scope Scope = cuda::thread_scope_device,
+          class Extent             = cuco::experimental::extent<std::size_t>,
           class KeyEqual           = thrust::equal_to<Key>,
           class ProbingScheme      = experimental::double_hashing<4,  // CG size
                                                              cuco::murmurhash3_32<Key>,
@@ -159,6 +159,7 @@ class static_set {
    * @param pred Key equality binary predicate
    * @param probing_scheme Probing scheme
    * @param alloc Allocator used for allocating device storage
+   * @param storage Instance of slot window storage type
    * @param stream CUDA stream used to initialize the map
    */
   constexpr static_set(Extent capacity,
@@ -166,6 +167,7 @@ class static_set {
                        KeyEqual pred                       = {},
                        ProbingScheme const& probing_scheme = {},
                        Allocator const& alloc              = {},
+                       Storage const& storage              = {},
                        cuda_stream_ref stream              = {});
 
   /**
@@ -396,6 +398,10 @@ class static_set {
   storage_type storage_;                ///< Slot window storage
 };
 
+// TODO docs
+template <class Key, cuda::thread_scope Scope = cuda::thread_scope_device, class... Args>
+[[nodiscard]] constexpr auto make_static_set(Args&&... args);
+
 }  // namespace experimental
 }  // namespace cuco