Replace is_like with IsKnownOp

Signed-off-by: John Pennycook <[email protected]>

Author: Pennycook

sycl/include/sycl/known_identity.hpp

@@ -28,64 +28,45 @@ namespace detail {
 // Forward declaration for deterministic reductions.
 template <typename BinaryOperation> struct DeterministicOperatorWrapper;
 
-template <typename T, typename U> struct is_like : public std::is_same<T, U> {};
-
-template <typename T, typename U>
-constexpr bool is_like_v = is_like<T, U>::value;
-
-template <typename T, typename U>
-struct is_like<DeterministicOperatorWrapper<T>, U> : std::is_same<T, U> {};
-
-template <typename T, typename U>
-struct is_like<T, DeterministicOperatorWrapper<U>> : std::is_same<T, U> {};
+template <typename T, class BinaryOperation,
+          template <typename> class... KnownOperation>
+using IsKnownOp = std::bool_constant<(
+    (std::is_same_v<BinaryOperation, KnownOperation<T>> ||
+     std::is_same_v<BinaryOperation, KnownOperation<void>> ||
+     std::is_same_v<BinaryOperation,
+                    DeterministicOperatorWrapper<KnownOperation<T>>> ||
+     std::is_same_v<BinaryOperation,
+                    DeterministicOperatorWrapper<KnownOperation<void>>>) ||
+    ...)>;
 
 template <typename T, class BinaryOperation>
-using IsPlus = std::bool_constant<is_like_v<BinaryOperation, sycl::plus<T>> ||
-                                  is_like_v<BinaryOperation, sycl::plus<void>>>;
+using IsPlus = IsKnownOp<T, BinaryOperation, sycl::plus>;
 
 template <typename T, class BinaryOperation>
-using IsMultiplies =
-    std::bool_constant<is_like_v<BinaryOperation, sycl::multiplies<T>> ||
-                       is_like_v<BinaryOperation, sycl::multiplies<void>>>;
+using IsMultiplies = IsKnownOp<T, BinaryOperation, sycl::multiplies>;
 
 template <typename T, class BinaryOperation>
-using IsMinimum =
-    std::bool_constant<is_like_v<BinaryOperation, sycl::minimum<T>> ||
-                       is_like_v<BinaryOperation, sycl::minimum<void>>>;
+using IsMinimum = IsKnownOp<T, BinaryOperation, sycl::minimum>;
 
 template <typename T, class BinaryOperation>
-using IsMaximum =
-    std::bool_constant<is_like_v<BinaryOperation, sycl::maximum<T>> ||
-                       is_like_v<BinaryOperation, sycl::maximum<void>>>;
+using IsMaximum = IsKnownOp<T, BinaryOperation, sycl::maximum>;
 
 template <typename T, class BinaryOperation>
-using IsBitAND =
-    std::bool_constant<is_like_v<BinaryOperation, sycl::bit_and<T>> ||
-                       is_like_v<BinaryOperation, sycl::bit_and<void>>>;
+using IsBitAND = IsKnownOp<T, BinaryOperation, sycl::bit_and>;
 
 template <typename T, class BinaryOperation>
-using IsBitOR =
-    std::bool_constant<is_like_v<BinaryOperation, sycl::bit_or<T>> ||
-                       is_like_v<BinaryOperation, sycl::bit_or<void>>>;
+using IsBitOR = IsKnownOp<T, BinaryOperation, sycl::bit_or>;
 
 template <typename T, class BinaryOperation>
-using IsBitXOR =
-    std::bool_constant<is_like_v<BinaryOperation, sycl::bit_xor<T>> ||
-                       is_like_v<BinaryOperation, sycl::bit_xor<void>>>;
+using IsBitXOR = IsKnownOp<T, BinaryOperation, sycl::bit_xor>;
 
 template <typename T, class BinaryOperation>
 using IsLogicalAND =
-    std::bool_constant<is_like_v<BinaryOperation, std::logical_and<T>> ||
-                       is_like_v<BinaryOperation, std::logical_and<void>> ||
-                       is_like_v<BinaryOperation, sycl::logical_and<T>> ||
-                       is_like_v<BinaryOperation, sycl::logical_and<void>>>;
+    IsKnownOp<T, BinaryOperation, std::logical_and, sycl::logical_and>;
 
 template <typename T, class BinaryOperation>
 using IsLogicalOR =
-    std::bool_constant<is_like_v<BinaryOperation, std::logical_or<T>> ||
-                       is_like_v<BinaryOperation, std::logical_or<void>> ||
-                       is_like_v<BinaryOperation, sycl::logical_or<T>> ||
-                       is_like_v<BinaryOperation, sycl::logical_or<void>>>;
+    IsKnownOp<T, BinaryOperation, std::logical_or, sycl::logical_or>;
 
 // Use SFINAE so that the "true" branch could be implemented in
 // include/sycl/stl_wrappers/complex that would only be available if STL's