Apparently Doxygen has become even pickier...

include/cuco/operator.hpp

@@ -24,37 +24,37 @@ inline namespace op {
  * @brief `insert` operator tag
  */
 struct insert_tag {
-} inline constexpr insert;
+} inline constexpr insert;  ///< `cuco::insert` operator
 
 /**
  * @brief `insert_and_find` operator tag
  */
 struct insert_and_find_tag {
-} inline constexpr insert_and_find;
+} inline constexpr insert_and_find;  ///< `cuco::insert_and_find` operator
 
 /**
  * @brief `insert_or_assign` operator tag
  */
 struct insert_or_assign_tag {
-} inline constexpr insert_or_assign;
+} inline constexpr insert_or_assign;  ///< `cuco::insert_or_assign` operator
 
 /**
  * @brief `erase` operator tag
  */
 struct erase_tag {
-} inline constexpr erase;
+} inline constexpr erase;  ///< `cuco::erase` operator
 
 /**
  * @brief `contains` operator tag
  */
 struct contains_tag {
-} inline constexpr contains;
+} inline constexpr contains;  ///< `cuco::contains` operator
 
 /**
  * @brief `find` operator tag
  */
 struct find_tag {
-} inline constexpr find;
+} inline constexpr find;  ///< `cuco::find` operator
 
 }  // namespace op
 }  // namespace cuco

include/cuco/utility/allocator.hpp

@@ -60,12 +60,31 @@ class cuda_allocator {
   void deallocate(value_type* p, std::size_t) { CUCO_CUDA_TRY(cudaFree(p)); }
 };
 
+/**
+ * @brief Equality comparison operator.
+ *
+ * @tparam T Value type of LHS object
+ * @tparam U Value type of RHS object
+ *
+ * @return `true` iff given arguments are equal
+ */
 template <typename T, typename U>
 bool operator==(cuda_allocator<T> const&, cuda_allocator<U> const&) noexcept
 {
   return true;
 }
 
+/**
+ * @brief Inequality comparison operator.
+ *
+ * @tparam T Value type of LHS object
+ * @tparam U Value type of RHS object
+ *
+ * @param lhs Left-hand side object to compare
+ * @param rhs Right-hand side object to compare
+ *
+ * @return `true` iff given arguments are not equal
+ */
 template <typename T, typename U>
 bool operator!=(cuda_allocator<T> const& lhs, cuda_allocator<U> const& rhs) noexcept
 {

include/cuco/utility/cuda_thread_scope.cuh

@@ -36,9 +36,13 @@ struct cuda_thread_scope {
 };
 
 // alias definitions
-inline constexpr auto thread_scope_system = cuda_thread_scope<cuda::thread_scope_system>{};
-inline constexpr auto thread_scope_device = cuda_thread_scope<cuda::thread_scope_device>{};
-inline constexpr auto thread_scope_block  = cuda_thread_scope<cuda::thread_scope_block>{};
-inline constexpr auto thread_scope_thread = cuda_thread_scope<cuda::thread_scope_thread>{};
+inline constexpr auto thread_scope_system =
+  cuda_thread_scope<cuda::thread_scope_system>{};  ///< `cuco::thread_scope_system`
+inline constexpr auto thread_scope_device =
+  cuda_thread_scope<cuda::thread_scope_device>{};  ///< `cuco::thread_scope_device`
+inline constexpr auto thread_scope_block =
+  cuda_thread_scope<cuda::thread_scope_block>{};  ///< `cuco::thread_scope_block`
+inline constexpr auto thread_scope_thread =
+  cuda_thread_scope<cuda::thread_scope_thread>{};  ///< `cuco::thread_scope_thread`
 
 }  // namespace cuco

include/cuco/utility/traits.hpp

@@ -46,7 +46,8 @@ struct is_bitwise_comparable<T, std::enable_if_t<std::has_unique_object_represen
   : std::true_type {};
 
 template <typename T>
-inline constexpr bool is_bitwise_comparable_v = is_bitwise_comparable<T>::value;
+inline constexpr bool is_bitwise_comparable_v =
+  is_bitwise_comparable<T>::value;  ///< Shortcut definition
 
 /**
  * @brief Declares that a type `Type` is bitwise comparable.
@@ -59,9 +60,11 @@ inline constexpr bool is_bitwise_comparable_v = is_bitwise_comparable<T>::value;
   }
 
 template <bool value, typename... Args>
-inline constexpr bool dependent_bool_value = value;
+inline constexpr bool dependent_bool_value = value;  ///< Unpacked dependent bool value
 
 template <typename... Args>
-inline constexpr bool dependent_false = dependent_bool_value<false, Args...>;
+inline constexpr bool dependent_false =
+  dependent_bool_value<false, Args...>;  ///< Emits a `false` value which is dependent on the given
+                                         ///< argument types
 
 }  // namespace cuco