From edc26042b570165b659398b7de8d34a563c30ef4 Mon Sep 17 00:00:00 2001
From: divyegala <divyegala@gmail.com>
Date: Tue, 3 May 2022 10:42:38 -0700
Subject: [PATCH 1/3] variadic template types for mdspan/mdarray

---
 cpp/include/raft/core/mdarray.hpp | 125 ++++++++++++++++++++++++------
 cpp/test/mdspan_utils.cu          |   4 +
 2 files changed, 107 insertions(+), 22 deletions(-)

diff --git a/cpp/include/raft/core/mdarray.hpp b/cpp/include/raft/core/mdarray.hpp
index ab6a04587a..f50301c038 100644
--- a/cpp/include/raft/core/mdarray.hpp
+++ b/cpp/include/raft/core/mdarray.hpp
@@ -46,6 +46,7 @@ using layout_c_contiguous = detail::stdex::layout_right;
  */
 using layout_f_contiguous = detail::stdex::layout_left;
 
+namespace detail {
 /**
  * @\brief Template checks and helpers to determine if type T is an std::mdspan
  *         or a derived type
@@ -58,7 +59,6 @@ void __takes_an_mdspan_ptr(
 template <typename T, typename = void>
 struct __is_mdspan : std::false_type {
 };
-
 template <typename T>
 struct __is_mdspan<T, std::void_t<decltype(__takes_an_mdspan_ptr(std::declval<T*>()))>>
   : std::true_type {
@@ -70,6 +70,21 @@ using __is_mdspan_t = __is_mdspan<std::remove_const_t<T>>;
 template <typename T>
 inline constexpr bool __is_mdspan_v = __is_mdspan_t<T>::value;
 
+template <typename...>
+struct is_mdspan : std::true_type {
+};
+template <typename T1>
+struct is_mdspan<T1> : __is_mdspan_t<T1> {
+};
+template <typename T1, typename... Tn>
+struct is_mdspan<T1, Tn...>
+  : std::conditional_t<__is_mdspan_v<T1>, is_mdspan<Tn...>, std::false_type> {
+};
+
+template <typename... Tn>
+inline constexpr bool is_mdspan_v = is_mdspan<Tn...>::value;
+}  // namespace detail
+
 /**
  * @brief stdex::mdspan with device tag to avoid accessing incorrect memory location.
  */
@@ -90,45 +105,88 @@ template <typename ElementType,
 using host_mdspan =
   detail::stdex::mdspan<ElementType, Extents, LayoutPolicy, detail::host_accessor<AccessorPolicy>>;
 
+namespace detail {
 template <typename T, bool B>
-struct __is_device_mdspan : std::false_type {
+struct is_device_mdspan : std::false_type {
 };
-
 template <typename T>
-struct __is_device_mdspan<T, true> : std::bool_constant<not T::accessor_type::is_host_type::value> {
+struct is_device_mdspan<T, true> : std::bool_constant<not T::accessor_type::is_host_type::value> {
 };
 
 /**
  * @\brief Boolean to determine if template type T is either raft::device_mdspan or a derived type
  */
 template <typename T>
-inline constexpr bool is_device_mdspan_v = __is_device_mdspan<T, __is_mdspan_v<T>>::value;
+inline constexpr bool is_device_mdspan_v = is_device_mdspan<T, is_mdspan_v<T>>::value;
 
 template <typename T, bool B>
-struct __is_host_mdspan : std::false_type {
+struct is_host_mdspan : std::false_type {
 };
-
 template <typename T>
-struct __is_host_mdspan<T, true> : T::accessor_type::is_host_type {
+struct is_host_mdspan<T, true> : T::accessor_type::is_host_type {
 };
 
 /**
  * @\brief Boolean to determine if template type T is either raft::host_mdspan or a derived type
  */
 template <typename T>
-inline constexpr bool is_host_mdspan_v = __is_host_mdspan<T, __is_mdspan_v<T>>::value;
+inline constexpr bool is_host_mdspan_v = is_host_mdspan<T, is_mdspan_v<T>>::value;
+}  // namespace detail
+
+template <typename...>
+struct is_device_mdspan : std::true_type {
+};
+template <typename T1>
+struct is_device_mdspan<T1> : detail::is_device_mdspan<T1, detail::is_mdspan_v<T1>> {
+};
+template <typename T1, typename... Tn>
+struct is_device_mdspan<T1, Tn...>
+  : std::conditional_t<detail::is_device_mdspan_v<T1>, is_device_mdspan<Tn...>, std::false_type> {
+};
 
 /**
- * @\brief Boolean to determine if template type T is either raft::host_mdspan/raft::device_mdspan
- *         or their derived types
- *         This is structured such that it will short-circuit if the type is not std::mdspan
- *         or a derived type, and otherwise it will check whether it is a raft::device_mdspan
- *         or raft::host_mdspan assuming the type was found to be std::mdspan or a derived type
+ * @\brief Boolean to determine if variadic template types Tn are either raft::device_mdspan or a
+ * derived type
  */
-template <typename T>
-inline constexpr bool is_mdspan_v =
-  std::conjunction_v<__is_mdspan_t<T>,
-                     std::disjunction<__is_device_mdspan<T, true>, __is_host_mdspan<T, true>>>;
+template <typename... Tn>
+inline constexpr bool is_device_mdspan_v = is_device_mdspan<Tn...>::value;
+
+template <typename...>
+struct is_host_mdspan : std::true_type {
+};
+template <typename T1>
+struct is_host_mdspan<T1> : detail::is_host_mdspan<T1, detail::is_mdspan_v<T1>> {
+};
+template <typename T1, typename... Tn>
+struct is_host_mdspan<T1, Tn...>
+  : std::conditional_t<detail::is_host_mdspan_v<T1>, is_host_mdspan<Tn...>, std::false_type> {
+};
+
+/**
+ * @\brief Boolean to determine if variadic template types Tn are either raft::host_mdspan or a
+ * derived type
+ */
+template <typename... Tn>
+inline constexpr bool is_host_mdspan_v = is_host_mdspan<Tn...>::value;
+
+template <typename...>
+struct is_mdspan : std::true_type {
+};
+template <typename T1>
+struct is_mdspan<T1> : std::disjunction<is_device_mdspan<T1>, is_host_mdspan<T1>> {
+};
+template <typename T1, typename... Tn>
+struct is_mdspan<T1, Tn...>
+  : std::conditional_t<std::disjunction_v<is_device_mdspan<T1>, is_host_mdspan<T1>>,
+                       is_mdspan<Tn...>,
+                       std::false_type> {
+};
+/**
+ * @\brief Boolean to determine if variadic template types Tn are either
+ *          raft::host_mdspan/raft::device_mdspan or their derived types
+ */
+template <typename... Tn>
+inline constexpr bool is_mdspan_v = is_mdspan<Tn...>::value;
 
 /**
  * @brief Interface to implement an owning multi-dimensional array
@@ -152,22 +210,45 @@ class array_interface {
   auto view() const noexcept { return static_cast<Base*>(this)->view(); }
 };
 
+namespace detail {
 template <typename T, typename = void>
-struct __is_array_interface : std::false_type {
+struct is_array_interface : std::false_type {
 };
-
 template <typename T>
-struct __is_array_interface<T, std::void_t<decltype(std::declval<T>().view())>>
+struct is_array_interface<T, std::void_t<decltype(std::declval<T>().view())>>
   : std::bool_constant<is_mdspan_v<decltype(std::declval<T>().view())>> {
 };
 
+template <typename T>
+using is_array_interface_t = is_array_interface<std::remove_const_t<T>>;
+
 /**
  * @\brief Boolean to determine if template type T is raft::array_interface or derived type
  *         or any type that has a member function `view()` that returns either
  *         raft::host_mdspan or raft::device_mdspan
  */
 template <typename T>
-inline constexpr bool is_array_interface_v = __is_array_interface<std::remove_const_t<T>>::value;
+inline constexpr bool is_array_interface_v = is_array_interface<std::remove_const_t<T>>::value;
+}  // namespace detail
+
+template <typename...>
+struct is_array_interface : std::true_type {
+};
+template <typename T1>
+struct is_array_interface<T1> : detail::is_array_interface_t<T1> {
+};
+template <typename T1, typename... Tn>
+struct is_array_interface<T1, Tn...> : std::conditional_t<detail::is_array_interface_v<T1>,
+                                                          is_array_interface<Tn...>,
+                                                          std::false_type> {
+};
+/**
+ * @\brief Boolean to determine if variadic template types Tn are raft::array_interface
+ *         or derived type or any type that has a member function `view()` that returns either
+ *         raft::host_mdspan or raft::device_mdspan
+ */
+template <typename... Tn>
+inline constexpr bool is_array_interface_v = is_array_interface<Tn...>::value;
 
 /**
  * @brief Modified from the c++ mdarray proposal
diff --git a/cpp/test/mdspan_utils.cu b/cpp/test/mdspan_utils.cu
index 15388a5cef..7e7812b7a6 100644
--- a/cpp/test/mdspan_utils.cu
+++ b/cpp/test/mdspan_utils.cu
@@ -64,6 +64,10 @@ void test_template_asserts()
                 "device_matrix_view type not a host_mdspan");
   static_assert(is_host_mdspan_v<host_matrix_view<float>>,
                 "host_matrix_view type is a host_mdspan");
+
+  // checking variadics
+  static_assert(!is_mdspan_v<three_d_mdspan, std::vector<int>>, "variadics mdspans");
+  static_assert(is_mdspan_v<three_d_mdspan, d_mdspan>, "variadics not mdspans");
 }
 
 TEST(MDSpan, TemplateAsserts) { test_template_asserts(); }

From 6d9620a4bed7d394755d0e9777945503d079b0e7 Mon Sep 17 00:00:00 2001
From: divyegala <divyegala@gmail.com>
Date: Thu, 16 Jun 2022 14:39:46 -0700
Subject: [PATCH 2/3] introducting raft::mdspan alias

---
 cpp/include/raft/core/mdarray.hpp | 44 ++++++++++++-------------------
 1 file changed, 17 insertions(+), 27 deletions(-)

diff --git a/cpp/include/raft/core/mdarray.hpp b/cpp/include/raft/core/mdarray.hpp
index f50301c038..6e5a5426a5 100644
--- a/cpp/include/raft/core/mdarray.hpp
+++ b/cpp/include/raft/core/mdarray.hpp
@@ -46,6 +46,13 @@ using layout_c_contiguous = detail::stdex::layout_right;
  */
 using layout_f_contiguous = detail::stdex::layout_left;
 
+template <typename ElementType,
+          typename Extents,
+          typename LayoutPolicy   = layout_c_contiguous,
+          typename AccessorPolicy = accessor_type<ElementType>>
+using mdspan = detail::stdex::
+  mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>
+
 namespace detail {
 /**
  * @\brief Template checks and helpers to determine if type T is an std::mdspan
@@ -54,7 +61,7 @@ namespace detail {
 
 template <typename ElementType, typename Extents, typename LayoutPolicy, typename AccessorPolicy>
 void __takes_an_mdspan_ptr(
-  detail::stdex::mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>*);
+  mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>*);
 
 template <typename T, typename = void>
 struct __is_mdspan : std::false_type {
@@ -69,21 +76,25 @@ using __is_mdspan_t = __is_mdspan<std::remove_const_t<T>>;
 
 template <typename T>
 inline constexpr bool __is_mdspan_v = __is_mdspan_t<T>::value;
+} // namespace detail
 
 template <typename...>
 struct is_mdspan : std::true_type {
 };
 template <typename T1>
-struct is_mdspan<T1> : __is_mdspan_t<T1> {
+struct is_mdspan<T1> : detail::__is_mdspan_t<T1> {
 };
 template <typename T1, typename... Tn>
 struct is_mdspan<T1, Tn...>
-  : std::conditional_t<__is_mdspan_v<T1>, is_mdspan<Tn...>, std::false_type> {
+  : std::conditional_t<detail::__is_mdspan_v<T1>, is_mdspan<Tn...>, std::false_type> {
 };
 
+/**
+ * @\brief Boolean to determine if variadic template types Tn are either
+ *          raft::host_mdspan/raft::device_mdspan or their derived types
+ */
 template <typename... Tn>
 inline constexpr bool is_mdspan_v = is_mdspan<Tn...>::value;
-}  // namespace detail
 
 /**
  * @brief stdex::mdspan with device tag to avoid accessing incorrect memory location.
@@ -92,8 +103,7 @@ template <typename ElementType,
           typename Extents,
           typename LayoutPolicy   = layout_c_contiguous,
           typename AccessorPolicy = detail::stdex::default_accessor<ElementType>>
-using device_mdspan = detail::stdex::
-  mdspan<ElementType, Extents, LayoutPolicy, detail::device_accessor<AccessorPolicy>>;
+using device_mdspan = mdspan<ElementType, Extents, LayoutPolicy, detail::device_accessor<AccessorPolicy>>;
 
 /**
  * @brief stdex::mdspan with host tag to avoid accessing incorrect memory location.
@@ -102,8 +112,7 @@ template <typename ElementType,
           typename Extents,
           typename LayoutPolicy   = layout_c_contiguous,
           typename AccessorPolicy = detail::stdex::default_accessor<ElementType>>
-using host_mdspan =
-  detail::stdex::mdspan<ElementType, Extents, LayoutPolicy, detail::host_accessor<AccessorPolicy>>;
+using host_mdspan = mdspan<ElementType, Extents, LayoutPolicy, detail::host_accessor<AccessorPolicy>>;
 
 namespace detail {
 template <typename T, bool B>
@@ -169,25 +178,6 @@ struct is_host_mdspan<T1, Tn...>
 template <typename... Tn>
 inline constexpr bool is_host_mdspan_v = is_host_mdspan<Tn...>::value;
 
-template <typename...>
-struct is_mdspan : std::true_type {
-};
-template <typename T1>
-struct is_mdspan<T1> : std::disjunction<is_device_mdspan<T1>, is_host_mdspan<T1>> {
-};
-template <typename T1, typename... Tn>
-struct is_mdspan<T1, Tn...>
-  : std::conditional_t<std::disjunction_v<is_device_mdspan<T1>, is_host_mdspan<T1>>,
-                       is_mdspan<Tn...>,
-                       std::false_type> {
-};
-/**
- * @\brief Boolean to determine if variadic template types Tn are either
- *          raft::host_mdspan/raft::device_mdspan or their derived types
- */
-template <typename... Tn>
-inline constexpr bool is_mdspan_v = is_mdspan<Tn...>::value;
-
 /**
  * @brief Interface to implement an owning multi-dimensional array
  *

From fb6e952d9005a6da81855ffebc62dfe98c61dbeb Mon Sep 17 00:00:00 2001
From: divyegala <divyegala@gmail.com>
Date: Thu, 16 Jun 2022 14:51:07 -0700
Subject: [PATCH 3/3] fixing compile failures

---
 cpp/include/raft/core/mdarray.hpp | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/cpp/include/raft/core/mdarray.hpp b/cpp/include/raft/core/mdarray.hpp
index a4b1f46c2c..0ab882e7a0 100644
--- a/cpp/include/raft/core/mdarray.hpp
+++ b/cpp/include/raft/core/mdarray.hpp
@@ -49,9 +49,8 @@ using layout_f_contiguous = detail::stdex::layout_left;
 template <typename ElementType,
           typename Extents,
           typename LayoutPolicy   = layout_c_contiguous,
-          typename AccessorPolicy = accessor_type<ElementType>>
-using mdspan = detail::stdex::
-  mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>
+          typename AccessorPolicy = detail::stdex::default_accessor<ElementType>>
+using mdspan = detail::stdex::mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>;
 
 namespace detail {
 /**
@@ -60,33 +59,32 @@ namespace detail {
  */
 
 template <typename ElementType, typename Extents, typename LayoutPolicy, typename AccessorPolicy>
-void __takes_an_mdspan_ptr(
-  mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>*);
+void __takes_an_mdspan_ptr(mdspan<ElementType, Extents, LayoutPolicy, AccessorPolicy>*);
 
 template <typename T, typename = void>
-struct __is_mdspan : std::false_type {
+struct is_mdspan : std::false_type {
 };
 template <typename T>
-struct __is_mdspan<T, std::void_t<decltype(__takes_an_mdspan_ptr(std::declval<T*>()))>>
+struct is_mdspan<T, std::void_t<decltype(__takes_an_mdspan_ptr(std::declval<T*>()))>>
   : std::true_type {
 };
 
 template <typename T>
-using __is_mdspan_t = __is_mdspan<std::remove_const_t<T>>;
+using is_mdspan_t = is_mdspan<std::remove_const_t<T>>;
 
 template <typename T>
-inline constexpr bool __is_mdspan_v = __is_mdspan_t<T>::value;
-} // namespace detail
+inline constexpr bool is_mdspan_v = is_mdspan_t<T>::value;
+}  // namespace detail
 
 template <typename...>
 struct is_mdspan : std::true_type {
 };
 template <typename T1>
-struct is_mdspan<T1> : detail::__is_mdspan_t<T1> {
+struct is_mdspan<T1> : detail::is_mdspan_t<T1> {
 };
 template <typename T1, typename... Tn>
 struct is_mdspan<T1, Tn...>
-  : std::conditional_t<detail::__is_mdspan_v<T1>, is_mdspan<Tn...>, std::false_type> {
+  : std::conditional_t<detail::is_mdspan_v<T1>, is_mdspan<Tn...>, std::false_type> {
 };
 
 /**
@@ -103,7 +101,8 @@ template <typename ElementType,
           typename Extents,
           typename LayoutPolicy   = layout_c_contiguous,
           typename AccessorPolicy = detail::stdex::default_accessor<ElementType>>
-using device_mdspan = mdspan<ElementType, Extents, LayoutPolicy, detail::device_accessor<AccessorPolicy>>;
+using device_mdspan =
+  mdspan<ElementType, Extents, LayoutPolicy, detail::device_accessor<AccessorPolicy>>;
 
 /**
  * @brief stdex::mdspan with host tag to avoid accessing incorrect memory location.
@@ -112,7 +111,8 @@ template <typename ElementType,
           typename Extents,
           typename LayoutPolicy   = layout_c_contiguous,
           typename AccessorPolicy = detail::stdex::default_accessor<ElementType>>
-using host_mdspan = mdspan<ElementType, Extents, LayoutPolicy, detail::host_accessor<AccessorPolicy>>;
+using host_mdspan =
+  mdspan<ElementType, Extents, LayoutPolicy, detail::host_accessor<AccessorPolicy>>;
 
 namespace detail {
 template <typename T, bool B>