should work with clang

Author: Alexandre Hoffmann

include/xtensor/containers/xfixed.hpp

@@ -326,8 +326,8 @@ namespace xt
         explicit xfixed_container(const inner_shape_type& shape, value_type v, layout_type l = L);
 
         template <class IX = std::integral_constant<std::size_t, N>>
-            requires(IX::value != 0)
-        xfixed_container(nested_initializer_list_t<value_type, N> t);
+        xfixed_container(nested_initializer_list_t<value_type, N> t)
+            requires(IX::value != 0);
 
         ~xfixed_container() = default;
 
@@ -640,8 +640,8 @@ namespace xt
      */
     template <class ET, class S, layout_type L, bool SH, class Tag>
     template <class IX>
-        requires(IX::value != 0)
     inline xfixed_container<ET, S, L, SH, Tag>::xfixed_container(nested_initializer_list_t<value_type, N> t)
+        requires(IX::value != 0)
     {
         XTENSOR_ASSERT_MSG(
             detail::check_initializer_list_shape<N>::run(t, this->shape()) == true,

include/xtensor/containers/xstorage.hpp

@@ -671,17 +671,17 @@ namespace xt
         svector(IT begin, IT end, const allocator_type& alloc = allocator_type());
 
         template <std::size_t N2, bool I2>
-            requires(N != N2)
-        explicit svector(const svector<T, N2, A, I2>& rhs);
+        explicit svector(const svector<T, N2, A, I2>& rhs)
+            requires(N != N2);
 
         svector& operator=(const svector& rhs);
         svector& operator=(svector&& rhs) noexcept(std::is_nothrow_move_assignable<value_type>::value);
         svector& operator=(const std::vector<T>& rhs);
         svector& operator=(std::initializer_list<T> il);
 
         template <std::size_t N2, bool I2>
-            requires(N != N2)
-        svector& operator=(const svector<T, N2, A, I2>& rhs);
+        svector& operator=(const svector<T, N2, A, I2>& rhs)
+            requires(N != N2);
 
         svector(const svector& other);
         svector(svector&& other) noexcept(std::is_nothrow_move_constructible<value_type>::value);
@@ -812,8 +812,8 @@ namespace xt
 
     template <class T, std::size_t N, class A, bool Init>
     template <std::size_t N2, bool I2>
-        requires(N != N2)
     inline svector<T, N, A, Init>::svector(const svector<T, N2, A, I2>& rhs)
+        requires(N != N2)
         : m_allocator(rhs.get_allocator())
     {
         assign(rhs.begin(), rhs.end());
@@ -872,8 +872,8 @@ namespace xt
 
     template <class T, std::size_t N, class A, bool Init>
     template <std::size_t N2, bool I2>
-        requires(N != N2)
     inline svector<T, N, A, Init>& svector<T, N, A, Init>::operator=(const svector<T, N2, A, I2>& rhs)
+        requires(N != N2)
     {
         m_allocator = std::allocator_traits<allocator_type>::select_on_container_copy_construction(
             rhs.get_allocator()

include/xtensor/generators/xgenerator.hpp

@@ -84,7 +84,7 @@ namespace xt
      *************************************/
 
     template <xgenerator_concept E>
-        requires without_memory_address_concept<E>
+        requires(without_memory_address_concept<E>)
     struct overlapping_memory_checker_traits<E>
     {
         static bool check_overlap(const E&, const memory_range&)
@@ -168,8 +168,8 @@ namespace xt
         const_stepper stepper_end(const O& shape, layout_type) const noexcept;
 
         template <class E, class FE = F>
-            requires has_assign_to_v<E, FE>
-        void assign_to(xexpression<E>& e) const noexcept;
+        void assign_to(xexpression<E>& e) const noexcept
+            requires(has_assign_to_v<E, FE>);
 
         const functor_type& functor() const noexcept;
 
@@ -375,8 +375,8 @@ namespace xt
 
     template <class F, class R, class S>
     template <class E, class FE>
-        requires has_assign_to_v<E, FE>
     inline void xgenerator<F, R, S>::assign_to(xexpression<E>& e) const noexcept
+        requires(has_assign_to_v<E, FE>)
     {
         e.derived_cast().resize(m_shape);
         m_f.assign_to(e);

include/xtensor/misc/xset_operation.hpp

@@ -88,8 +88,8 @@ namespace xt
      * @return a boolean array
      */
     template <class E, class F>
-        requires has_iterator_interface_concept<F>
     inline auto isin(E&& element, F&& test_elements) noexcept
+        requires(has_iterator_interface_concept<F>)
     {
         auto lambda = detail::lambda_isin<std::is_lvalue_reference<F>::value>::make(std::forward<F>(test_elements
         ));
@@ -145,8 +145,8 @@ namespace xt
      * @return a boolean array
      */
     template <class E, class F>
-        requires has_iterator_interface_concept<F>
     inline auto in1d(E&& element, F&& test_elements) noexcept
+        requires(has_iterator_interface_concept<F>)
     {
         XTENSOR_ASSERT(element.dimension() == 1ul);
         XTENSOR_ASSERT(test_elements.dimension() == 1ul);