Removed constexpr workarounds

JohanMabille · JohanMabille · commit 5b9fc760d97f · 2026-04-28T16:15:39.000+02:00
diff --git a/include/xtensor/containers/xcontainer.hpp b/include/xtensor/containers/xcontainer.hpp
@@ -114,11 +114,11 @@ namespace xt
 
         size_type size() const noexcept;
 
-        XTENSOR_CONSTEXPR_RETURN size_type dimension() const noexcept;
+        constexpr size_type dimension() const noexcept;
 
-        XTENSOR_CONSTEXPR_RETURN const inner_shape_type& shape() const noexcept;
-        XTENSOR_CONSTEXPR_RETURN const inner_strides_type& strides() const noexcept;
-        XTENSOR_CONSTEXPR_RETURN const inner_backstrides_type& backstrides() const noexcept;
+        constexpr const inner_shape_type& shape() const noexcept;
+        constexpr const inner_strides_type& strides() const noexcept;
+        constexpr const inner_backstrides_type& backstrides() const noexcept;
 
         template <class T>
         void fill(const T& value);
@@ -373,7 +373,7 @@ namespace xt
      * Returns the number of dimensions of the container.
      */
     template <class D>
-    XTENSOR_CONSTEXPR_RETURN auto xcontainer<D>::dimension() const noexcept -> size_type
+    constexpr auto xcontainer<D>::dimension() const noexcept -> size_type
     {
         return shape().size();
     }
@@ -382,7 +382,7 @@ namespace xt
      * Returns the shape of the container.
      */
     template <class D>
-    XTENSOR_CONSTEXPR_RETURN auto xcontainer<D>::shape() const noexcept -> const inner_shape_type&
+    constexpr auto xcontainer<D>::shape() const noexcept -> const inner_shape_type&
     {
         return derived_cast().shape_impl();
     }
@@ -391,7 +391,7 @@ namespace xt
      * Returns the strides of the container.
      */
     template <class D>
-    XTENSOR_CONSTEXPR_RETURN auto xcontainer<D>::strides() const noexcept -> const inner_strides_type&
+    constexpr auto xcontainer<D>::strides() const noexcept -> const inner_strides_type&
     {
         return derived_cast().strides_impl();
     }
@@ -400,7 +400,7 @@ namespace xt
      * Returns the backstrides of the container.
      */
     template <class D>
-    XTENSOR_CONSTEXPR_RETURN auto xcontainer<D>::backstrides() const noexcept -> const inner_backstrides_type&
+    constexpr auto xcontainer<D>::backstrides() const noexcept -> const inner_backstrides_type&
     {
         return derived_cast().backstrides_impl();
     }
diff --git a/include/xtensor/containers/xfixed.hpp b/include/xtensor/containers/xfixed.hpp
@@ -373,9 +373,9 @@ namespace xt
         storage_type& storage_impl() noexcept;
         const storage_type& storage_impl() const noexcept;
 
-        XTENSOR_CONSTEXPR_RETURN const inner_shape_type& shape_impl() const noexcept;
-        XTENSOR_CONSTEXPR_RETURN const inner_strides_type& strides_impl() const noexcept;
-        XTENSOR_CONSTEXPR_RETURN const inner_backstrides_type& backstrides_impl() const noexcept;
+        constexpr const inner_shape_type& shape_impl() const noexcept;
+        constexpr const inner_strides_type& strides_impl() const noexcept;
+        constexpr const inner_backstrides_type& backstrides_impl() const noexcept;
 
         friend class xcontainer<xfixed_container<ET, S, L, SH, Tag>>;
     };
@@ -495,9 +495,9 @@ namespace xt
         storage_type& storage_impl() noexcept;
         const storage_type& storage_impl() const noexcept;
 
-        XTENSOR_CONSTEXPR_RETURN const inner_shape_type& shape_impl() const noexcept;
-        XTENSOR_CONSTEXPR_RETURN const inner_strides_type& strides_impl() const noexcept;
-        XTENSOR_CONSTEXPR_RETURN const inner_backstrides_type& backstrides_impl() const noexcept;
+        constexpr const inner_shape_type& shape_impl() const noexcept;
+        constexpr const inner_strides_type& strides_impl() const noexcept;
+        constexpr const inner_backstrides_type& backstrides_impl() const noexcept;
 
         friend class xcontainer<xfixed_adaptor<EC, S, L, SH, Tag>>;
     };
@@ -740,21 +740,19 @@ namespace xt
     }
 
     template <class ET, class S, layout_type L, bool SH, class Tag>
-    XTENSOR_CONSTEXPR_RETURN auto xfixed_container<ET, S, L, SH, Tag>::shape_impl() const noexcept
-        -> const inner_shape_type&
+    constexpr auto xfixed_container<ET, S, L, SH, Tag>::shape_impl() const noexcept -> const inner_shape_type&
     {
         return m_shape;
     }
 
     template <class ET, class S, layout_type L, bool SH, class Tag>
-    XTENSOR_CONSTEXPR_RETURN auto xfixed_container<ET, S, L, SH, Tag>::strides_impl() const noexcept
-        -> const inner_strides_type&
+    constexpr auto xfixed_container<ET, S, L, SH, Tag>::strides_impl() const noexcept -> const inner_strides_type&
     {
         return m_strides;
     }
 
     template <class ET, class S, layout_type L, bool SH, class Tag>
-    XTENSOR_CONSTEXPR_RETURN auto xfixed_container<ET, S, L, SH, Tag>::backstrides_impl() const noexcept
+    constexpr auto xfixed_container<ET, S, L, SH, Tag>::backstrides_impl() const noexcept
         -> const inner_backstrides_type&
     {
         return m_backstrides;
@@ -937,21 +935,21 @@ namespace xt
     }
 
     template <class EC, class S, layout_type L, bool SH, class Tag>
-    XTENSOR_CONSTEXPR_RETURN auto xfixed_adaptor<EC, S, L, SH, Tag>::shape_impl() const noexcept
+    constexpr auto xfixed_adaptor<EC, S, L, SH, Tag>::shape_impl() const noexcept
         -> const inner_shape_type&
     {
         return m_shape;
     }
 
     template <class EC, class S, layout_type L, bool SH, class Tag>
-    XTENSOR_CONSTEXPR_RETURN auto xfixed_adaptor<EC, S, L, SH, Tag>::strides_impl() const noexcept
+    constexpr auto xfixed_adaptor<EC, S, L, SH, Tag>::strides_impl() const noexcept
         -> const inner_strides_type&
     {
         return m_strides;
     }
 
     template <class EC, class S, layout_type L, bool SH, class Tag>
-    XTENSOR_CONSTEXPR_RETURN auto xfixed_adaptor<EC, S, L, SH, Tag>::backstrides_impl() const noexcept
+    constexpr auto xfixed_adaptor<EC, S, L, SH, Tag>::backstrides_impl() const noexcept
         -> const inner_backstrides_type&
     {
         return m_backstrides;
diff --git a/include/xtensor/containers/xscalar.hpp b/include/xtensor/containers/xscalar.hpp
@@ -466,25 +466,25 @@ namespace xt
      *****************************/
 
     template <class CT>
-    XTENSOR_CONSTEXPR_RETURN auto linear_begin(xscalar<CT>& c) noexcept -> decltype(c.dummy_begin())
+    constexpr auto linear_begin(xscalar<CT>& c) noexcept -> decltype(c.dummy_begin())
     {
         return c.dummy_begin();
     }
 
     template <class CT>
-    XTENSOR_CONSTEXPR_RETURN auto linear_end(xscalar<CT>& c) noexcept -> decltype(c.dummy_end())
+    constexpr auto linear_end(xscalar<CT>& c) noexcept -> decltype(c.dummy_end())
     {
         return c.dummy_end();
     }
 
     template <class CT>
-    XTENSOR_CONSTEXPR_RETURN auto linear_begin(const xscalar<CT>& c) noexcept -> decltype(c.dummy_begin())
+    constexpr auto linear_begin(const xscalar<CT>& c) noexcept -> decltype(c.dummy_begin())
     {
         return c.dummy_begin();
     }
 
     template <class CT>
-    XTENSOR_CONSTEXPR_RETURN auto linear_end(const xscalar<CT>& c) noexcept -> decltype(c.dummy_end())
+    constexpr auto linear_end(const xscalar<CT>& c) noexcept -> decltype(c.dummy_end())
     {
         return c.dummy_end();
     }
diff --git a/include/xtensor/core/xiterator.hpp b/include/xtensor/core/xiterator.hpp
@@ -417,7 +417,7 @@ namespace xt
     }
 
     template <class C>
-    XTENSOR_CONSTEXPR_RETURN auto linear_begin(C& c) noexcept
+    constexpr auto linear_begin(C& c) noexcept
     {
         if constexpr (detail::has_linear_iterator<C>::value)
         {
@@ -430,7 +430,7 @@ namespace xt
     }
 
     template <class C>
-    XTENSOR_CONSTEXPR_RETURN auto linear_end(C& c) noexcept
+    constexpr auto linear_end(C& c) noexcept
     {
         if constexpr (detail::has_linear_iterator<C>::value)
         {
@@ -443,7 +443,7 @@ namespace xt
     }
 
     template <class C>
-    XTENSOR_CONSTEXPR_RETURN auto linear_begin(const C& c) noexcept
+    constexpr auto linear_begin(const C& c) noexcept
     {
         if constexpr (detail::has_linear_iterator<C>::value)
         {
@@ -456,7 +456,7 @@ namespace xt
     }
 
     template <class C>
-    XTENSOR_CONSTEXPR_RETURN auto linear_end(const C& c) noexcept
+    constexpr auto linear_end(const C& c) noexcept
     {
         if constexpr (detail::has_linear_iterator<C>::value)
         {
diff --git a/include/xtensor/core/xtensor_config.hpp b/include/xtensor/core/xtensor_config.hpp
@@ -35,17 +35,12 @@
 
 // Workaround for some missing constexpr functionality in MSVC 2015 and MSVC 2017 x86
 #if defined(_MSC_VER)
-#define XTENSOR_CONSTEXPR_ENHANCED const
 // The following must not be defined to const, otherwise
 // it prevents generation of copy operators of classes
 // containing XTENSOR_CONSTEXPR_ENHANCED_STATIC members
 #define XTENSOR_CONSTEXPR_ENHANCED_STATIC
-#define XTENSOR_CONSTEXPR_RETURN inline
 #else
-#define XTENSOR_CONSTEXPR_ENHANCED constexpr
-#define XTENSOR_CONSTEXPR_RETURN constexpr
 #define XTENSOR_CONSTEXPR_ENHANCED_STATIC constexpr static
-#define XTENSOR_HAS_CONSTEXPR_ENHANCED
 #endif
 
 #ifndef XTENSOR_DEFAULT_DATA_CONTAINER
diff --git a/include/xtensor/views/xbroadcast.hpp b/include/xtensor/views/xbroadcast.hpp
@@ -96,25 +96,25 @@ namespace xt
      *****************************/
 
     template <class CT, class X>
-    XTENSOR_CONSTEXPR_RETURN auto linear_begin(xbroadcast<CT, X>& c) noexcept
+    constexpr auto linear_begin(xbroadcast<CT, X>& c) noexcept
     {
         return linear_begin(c.expression());
     }
 
     template <class CT, class X>
-    XTENSOR_CONSTEXPR_RETURN auto linear_end(xbroadcast<CT, X>& c) noexcept
+    constexpr auto linear_end(xbroadcast<CT, X>& c) noexcept
     {
         return linear_end(c.expression());
     }
 
     template <class CT, class X>
-    XTENSOR_CONSTEXPR_RETURN auto linear_begin(const xbroadcast<CT, X>& c) noexcept
+    constexpr auto linear_begin(const xbroadcast<CT, X>& c) noexcept
     {
         return linear_begin(c.expression());
     }
 
     template <class CT, class X>
-    XTENSOR_CONSTEXPR_RETURN auto linear_end(const xbroadcast<CT, X>& c) noexcept
+    constexpr auto linear_end(const xbroadcast<CT, X>& c) noexcept
     {
         return linear_end(c.expression());
     }
diff --git a/include/xtensor/views/xslice.hpp b/include/xtensor/views/xslice.hpp
@@ -21,16 +21,6 @@
 #include "../core/xtensor_config.hpp"
 #include "../utils/xutils.hpp"
 
-#ifndef XTENSOR_CONSTEXPR
-#if (defined(_MSC_VER) || __GNUC__ < 8)
-#define XTENSOR_CONSTEXPR inline
-#define XTENSOR_GLOBAL_CONSTEXPR static const
-#else
-#define XTENSOR_CONSTEXPR constexpr
-#define XTENSOR_GLOBAL_CONSTEXPR constexpr
-#endif
-#endif
-
 namespace xt
 {
 
@@ -70,11 +60,11 @@ namespace xt
      * slice tags *
      **************/
 
-#define DEFINE_TAG_CONVERSION(NAME)                 \
-    template <class T>                              \
-    XTENSOR_CONSTEXPR NAME convert() const noexcept \
-    {                                               \
-        return NAME();                              \
+#define DEFINE_TAG_CONVERSION(NAME)         \
+    template <class T>                      \
+    constexpr NAME convert() const noexcept \
+    {                                       \
+        return NAME();                      \
     }
 
     struct xall_tag
@@ -642,20 +632,20 @@ namespace xt
             std::ptrdiff_t rng[3];  // = { 0, 0, 0 };
         };
 
-        XTENSOR_CONSTEXPR xtuph get_tuph_or_val(std::ptrdiff_t /*val*/, std::true_type)
+        constexpr xtuph get_tuph_or_val(std::ptrdiff_t /*val*/, std::true_type)
         {
             return xtuph();
         }
 
-        XTENSOR_CONSTEXPR std::ptrdiff_t get_tuph_or_val(std::ptrdiff_t val, std::false_type)
+        constexpr std::ptrdiff_t get_tuph_or_val(std::ptrdiff_t val, std::false_type)
         {
             return val;
         }
 
         template <class A, class B, class C>
         struct rangemaker<A, B, C>
         {
-            XTENSOR_CONSTEXPR operator xrange_adaptor<A, B, C>()
+            constexpr operator xrange_adaptor<A, B, C>()
             {
                 return xrange_adaptor<A, B, C>(
                     {get_tuph_or_val(rng[0], std::is_same<A, xtuph>()),
@@ -670,7 +660,7 @@ namespace xt
         template <class A, class B>
         struct rangemaker<A, B>
         {
-            XTENSOR_CONSTEXPR operator xrange_adaptor<A, B, xt::placeholders::xtuph>()
+            constexpr operator xrange_adaptor<A, B, xt::placeholders::xtuph>()
             {
                 return xrange_adaptor<A, B, xt::placeholders::xtuph>(
                     {get_tuph_or_val(rng[0], std::is_same<A, xtuph>()),
@@ -683,25 +673,25 @@ namespace xt
         };
 
         template <class... OA>
-        XTENSOR_CONSTEXPR auto operator|(const rangemaker<OA...>& rng, const std::ptrdiff_t& t)
+        constexpr auto operator|(const rangemaker<OA...>& rng, const std::ptrdiff_t& t)
         {
             auto nrng = rangemaker<OA..., std::ptrdiff_t>({rng.rng[0], rng.rng[1], rng.rng[2]});
             nrng.rng[sizeof...(OA)] = t;
             return nrng;
         }
 
         template <class... OA>
-        XTENSOR_CONSTEXPR auto operator|(const rangemaker<OA...>& rng, const xt::placeholders::xtuph& /*t*/)
+        constexpr auto operator|(const rangemaker<OA...>& rng, const xt::placeholders::xtuph& /*t*/)
         {
             auto nrng = rangemaker<OA..., xt::placeholders::xtuph>({rng.rng[0], rng.rng[1], rng.rng[2]});
             return nrng;
         }
 
-        XTENSOR_GLOBAL_CONSTEXPR xtuph _{};
-        XTENSOR_GLOBAL_CONSTEXPR rangemaker<> _r = rangemaker<>({{0, 0, 0}});
-        XTENSOR_GLOBAL_CONSTEXPR xall_tag _a{};
-        XTENSOR_GLOBAL_CONSTEXPR xnewaxis_tag _n{};
-        XTENSOR_GLOBAL_CONSTEXPR xellipsis_tag _e{};
+        constexpr xtuph _{};
+        constexpr rangemaker<> _r = rangemaker<>({{0, 0, 0}});
+        constexpr xall_tag _a{};
+        constexpr xnewaxis_tag _n{};
+        constexpr xellipsis_tag _e{};
     }
 
     inline auto xnone()
@@ -1598,6 +1588,4 @@ namespace xt
     }
 }
 
-#undef XTENSOR_CONSTEXPR
-
 #endif

Original file line number	Diff line number	Diff line change
`@@ -114,11 +114,11 @@ namespace xt`
`114`	`114`
`115`	`115`	`size_type size() const noexcept;`
`116`	`116`
`117`		`- XTENSOR_CONSTEXPR_RETURN size_type dimension() const noexcept;`
	`117`	`+ constexpr size_type dimension() const noexcept;`
`118`	`118`
`119`		`- XTENSOR_CONSTEXPR_RETURN const inner_shape_type& shape() const noexcept;`
`120`		`- XTENSOR_CONSTEXPR_RETURN const inner_strides_type& strides() const noexcept;`
`121`		`- XTENSOR_CONSTEXPR_RETURN const inner_backstrides_type& backstrides() const noexcept;`
	`119`	`+ constexpr const inner_shape_type& shape() const noexcept;`
	`120`	`+ constexpr const inner_strides_type& strides() const noexcept;`
	`121`	`+ constexpr const inner_backstrides_type& backstrides() const noexcept;`
`122`	`122`
`123`	`123`	`template <class T>`
`124`	`124`	`void fill(const T& value);`
`@@ -373,7 +373,7 @@ namespace xt`
`373`	`373`	`* Returns the number of dimensions of the container.`
`374`	`374`	`*/`
`375`	`375`	`template <class D>`
`376`		`- XTENSOR_CONSTEXPR_RETURN auto xcontainer<D>::dimension() const noexcept -> size_type`
	`376`	`+ constexpr auto xcontainer<D>::dimension() const noexcept -> size_type`
`377`	`377`	`{`
`378`	`378`	`return shape().size();`
`379`	`379`	`}`
`@@ -382,7 +382,7 @@ namespace xt`
`382`	`382`	`* Returns the shape of the container.`
`383`	`383`	`*/`
`384`	`384`	`template <class D>`
`385`		`- XTENSOR_CONSTEXPR_RETURN auto xcontainer<D>::shape() const noexcept -> const inner_shape_type&`
	`385`	`+ constexpr auto xcontainer<D>::shape() const noexcept -> const inner_shape_type&`
`386`	`386`	`{`
`387`	`387`	`return derived_cast().shape_impl();`
`388`	`388`	`}`
`@@ -391,7 +391,7 @@ namespace xt`
`391`	`391`	`* Returns the strides of the container.`
`392`	`392`	`*/`
`393`	`393`	`template <class D>`
`394`		`- XTENSOR_CONSTEXPR_RETURN auto xcontainer<D>::strides() const noexcept -> const inner_strides_type&`
	`394`	`+ constexpr auto xcontainer<D>::strides() const noexcept -> const inner_strides_type&`
`395`	`395`	`{`
`396`	`396`	`return derived_cast().strides_impl();`
`397`	`397`	`}`
`@@ -400,7 +400,7 @@ namespace xt`
`400`	`400`	`* Returns the backstrides of the container.`
`401`	`401`	`*/`
`402`	`402`	`template <class D>`
`403`		`- XTENSOR_CONSTEXPR_RETURN auto xcontainer<D>::backstrides() const noexcept -> const inner_backstrides_type&`
	`403`	`+ constexpr auto xcontainer<D>::backstrides() const noexcept -> const inner_backstrides_type&`
`404`	`404`	`{`
`405`	`405`	`return derived_cast().backstrides_impl();`
`406`	`406`	`}`
Original file line number	Diff line number	Diff line change
`@@ -373,9 +373,9 @@ namespace xt`
`373`	`373`	`storage_type& storage_impl() noexcept;`
`374`	`374`	`const storage_type& storage_impl() const noexcept;`
`375`	`375`
`376`		`- XTENSOR_CONSTEXPR_RETURN const inner_shape_type& shape_impl() const noexcept;`
`377`		`- XTENSOR_CONSTEXPR_RETURN const inner_strides_type& strides_impl() const noexcept;`
`378`		`- XTENSOR_CONSTEXPR_RETURN const inner_backstrides_type& backstrides_impl() const noexcept;`
	`376`	`+ constexpr const inner_shape_type& shape_impl() const noexcept;`
	`377`	`+ constexpr const inner_strides_type& strides_impl() const noexcept;`
	`378`	`+ constexpr const inner_backstrides_type& backstrides_impl() const noexcept;`
`379`	`379`
`380`	`380`	`friend class xcontainer<xfixed_container<ET, S, L, SH, Tag>>;`
`381`	`381`	`};`
`@@ -495,9 +495,9 @@ namespace xt`
`495`	`495`	`storage_type& storage_impl() noexcept;`
`496`	`496`	`const storage_type& storage_impl() const noexcept;`
`497`	`497`
`498`		`- XTENSOR_CONSTEXPR_RETURN const inner_shape_type& shape_impl() const noexcept;`
`499`		`- XTENSOR_CONSTEXPR_RETURN const inner_strides_type& strides_impl() const noexcept;`
`500`		`- XTENSOR_CONSTEXPR_RETURN const inner_backstrides_type& backstrides_impl() const noexcept;`
	`498`	`+ constexpr const inner_shape_type& shape_impl() const noexcept;`
	`499`	`+ constexpr const inner_strides_type& strides_impl() const noexcept;`
	`500`	`+ constexpr const inner_backstrides_type& backstrides_impl() const noexcept;`
`501`	`501`
`502`	`502`	`friend class xcontainer<xfixed_adaptor<EC, S, L, SH, Tag>>;`
`503`	`503`	`};`
`@@ -740,21 +740,19 @@ namespace xt`
`740`	`740`	`}`
`741`	`741`
`742`	`742`	`template <class ET, class S, layout_type L, bool SH, class Tag>`
`743`		`- XTENSOR_CONSTEXPR_RETURN auto xfixed_container<ET, S, L, SH, Tag>::shape_impl() const noexcept`
`744`		`- -> const inner_shape_type&`
	`743`	`+ constexpr auto xfixed_container<ET, S, L, SH, Tag>::shape_impl() const noexcept -> const inner_shape_type&`
`745`	`744`	`{`
`746`	`745`	`return m_shape;`
`747`	`746`	`}`
`748`	`747`
`749`	`748`	`template <class ET, class S, layout_type L, bool SH, class Tag>`
`750`		`- XTENSOR_CONSTEXPR_RETURN auto xfixed_container<ET, S, L, SH, Tag>::strides_impl() const noexcept`
`751`		`- -> const inner_strides_type&`
	`749`	`+ constexpr auto xfixed_container<ET, S, L, SH, Tag>::strides_impl() const noexcept -> const inner_strides_type&`
`752`	`750`	`{`
`753`	`751`	`return m_strides;`
`754`	`752`	`}`
`755`	`753`
`756`	`754`	`template <class ET, class S, layout_type L, bool SH, class Tag>`
`757`		`- XTENSOR_CONSTEXPR_RETURN auto xfixed_container<ET, S, L, SH, Tag>::backstrides_impl() const noexcept`
	`755`	`+ constexpr auto xfixed_container<ET, S, L, SH, Tag>::backstrides_impl() const noexcept`
`758`	`756`	`-> const inner_backstrides_type&`
`759`	`757`	`{`
`760`	`758`	`return m_backstrides;`
`@@ -937,21 +935,21 @@ namespace xt`
`937`	`935`	`}`
`938`	`936`
`939`	`937`	`template <class EC, class S, layout_type L, bool SH, class Tag>`
`940`		`- XTENSOR_CONSTEXPR_RETURN auto xfixed_adaptor<EC, S, L, SH, Tag>::shape_impl() const noexcept`
	`938`	`+ constexpr auto xfixed_adaptor<EC, S, L, SH, Tag>::shape_impl() const noexcept`
`941`	`939`	`-> const inner_shape_type&`
`942`	`940`	`{`
`943`	`941`	`return m_shape;`
`944`	`942`	`}`
`945`	`943`
`946`	`944`	`template <class EC, class S, layout_type L, bool SH, class Tag>`
`947`		`- XTENSOR_CONSTEXPR_RETURN auto xfixed_adaptor<EC, S, L, SH, Tag>::strides_impl() const noexcept`
	`945`	`+ constexpr auto xfixed_adaptor<EC, S, L, SH, Tag>::strides_impl() const noexcept`
`948`	`946`	`-> const inner_strides_type&`
`949`	`947`	`{`
`950`	`948`	`return m_strides;`
`951`	`949`	`}`
`952`	`950`
`953`	`951`	`template <class EC, class S, layout_type L, bool SH, class Tag>`
`954`		`- XTENSOR_CONSTEXPR_RETURN auto xfixed_adaptor<EC, S, L, SH, Tag>::backstrides_impl() const noexcept`
	`952`	`+ constexpr auto xfixed_adaptor<EC, S, L, SH, Tag>::backstrides_impl() const noexcept`
`955`	`953`	`-> const inner_backstrides_type&`
`956`	`954`	`{`
`957`	`955`	`return m_backstrides;`
Original file line number	Diff line number	Diff line change
`@@ -466,25 +466,25 @@ namespace xt`
`466`	`466`	`*****************************/`
`467`	`467`
`468`	`468`	`template <class CT>`
`469`		`- XTENSOR_CONSTEXPR_RETURN auto linear_begin(xscalar<CT>& c) noexcept -> decltype(c.dummy_begin())`
	`469`	`+ constexpr auto linear_begin(xscalar<CT>& c) noexcept -> decltype(c.dummy_begin())`
`470`	`470`	`{`
`471`	`471`	`return c.dummy_begin();`
`472`	`472`	`}`
`473`	`473`
`474`	`474`	`template <class CT>`
`475`		`- XTENSOR_CONSTEXPR_RETURN auto linear_end(xscalar<CT>& c) noexcept -> decltype(c.dummy_end())`
	`475`	`+ constexpr auto linear_end(xscalar<CT>& c) noexcept -> decltype(c.dummy_end())`
`476`	`476`	`{`
`477`	`477`	`return c.dummy_end();`
`478`	`478`	`}`
`479`	`479`
`480`	`480`	`template <class CT>`
`481`		`- XTENSOR_CONSTEXPR_RETURN auto linear_begin(const xscalar<CT>& c) noexcept -> decltype(c.dummy_begin())`
	`481`	`+ constexpr auto linear_begin(const xscalar<CT>& c) noexcept -> decltype(c.dummy_begin())`
`482`	`482`	`{`
`483`	`483`	`return c.dummy_begin();`
`484`	`484`	`}`
`485`	`485`
`486`	`486`	`template <class CT>`
`487`		`- XTENSOR_CONSTEXPR_RETURN auto linear_end(const xscalar<CT>& c) noexcept -> decltype(c.dummy_end())`
	`487`	`+ constexpr auto linear_end(const xscalar<CT>& c) noexcept -> decltype(c.dummy_end())`
`488`	`488`	`{`
`489`	`489`	`return c.dummy_end();`
`490`	`490`	`}`
Original file line number	Diff line number	Diff line change
`@@ -417,7 +417,7 @@ namespace xt`
`417`	`417`	`}`
`418`	`418`
`419`	`419`	`template <class C>`
`420`		`- XTENSOR_CONSTEXPR_RETURN auto linear_begin(C& c) noexcept`
	`420`	`+ constexpr auto linear_begin(C& c) noexcept`
`421`	`421`	`{`
`422`	`422`	`if constexpr (detail::has_linear_iterator<C>::value)`
`423`	`423`	`{`
`@@ -430,7 +430,7 @@ namespace xt`
`430`	`430`	`}`
`431`	`431`
`432`	`432`	`template <class C>`
`433`		`- XTENSOR_CONSTEXPR_RETURN auto linear_end(C& c) noexcept`
	`433`	`+ constexpr auto linear_end(C& c) noexcept`
`434`	`434`	`{`
`435`	`435`	`if constexpr (detail::has_linear_iterator<C>::value)`
`436`	`436`	`{`
`@@ -443,7 +443,7 @@ namespace xt`
`443`	`443`	`}`
`444`	`444`
`445`	`445`	`template <class C>`
`446`		`- XTENSOR_CONSTEXPR_RETURN auto linear_begin(const C& c) noexcept`
	`446`	`+ constexpr auto linear_begin(const C& c) noexcept`
`447`	`447`	`{`
`448`	`448`	`if constexpr (detail::has_linear_iterator<C>::value)`
`449`	`449`	`{`
`@@ -456,7 +456,7 @@ namespace xt`
`456`	`456`	`}`
`457`	`457`
`458`	`458`	`template <class C>`
`459`		`- XTENSOR_CONSTEXPR_RETURN auto linear_end(const C& c) noexcept`
	`459`	`+ constexpr auto linear_end(const C& c) noexcept`
`460`	`460`	`{`
`461`	`461`	`if constexpr (detail::has_linear_iterator<C>::value)`
`462`	`462`	`{`
Original file line number	Diff line number	Diff line change
`@@ -96,25 +96,25 @@ namespace xt`
`96`	`96`	`*****************************/`
`97`	`97`
`98`	`98`	`template <class CT, class X>`
`99`		`- XTENSOR_CONSTEXPR_RETURN auto linear_begin(xbroadcast<CT, X>& c) noexcept`
	`99`	`+ constexpr auto linear_begin(xbroadcast<CT, X>& c) noexcept`
`100`	`100`	`{`
`101`	`101`	`return linear_begin(c.expression());`
`102`	`102`	`}`
`103`	`103`
`104`	`104`	`template <class CT, class X>`
`105`		`- XTENSOR_CONSTEXPR_RETURN auto linear_end(xbroadcast<CT, X>& c) noexcept`
	`105`	`+ constexpr auto linear_end(xbroadcast<CT, X>& c) noexcept`
`106`	`106`	`{`
`107`	`107`	`return linear_end(c.expression());`
`108`	`108`	`}`
`109`	`109`
`110`	`110`	`template <class CT, class X>`
`111`		`- XTENSOR_CONSTEXPR_RETURN auto linear_begin(const xbroadcast<CT, X>& c) noexcept`
	`111`	`+ constexpr auto linear_begin(const xbroadcast<CT, X>& c) noexcept`
`112`	`112`	`{`
`113`	`113`	`return linear_begin(c.expression());`
`114`	`114`	`}`
`115`	`115`
`116`	`116`	`template <class CT, class X>`
`117`		`- XTENSOR_CONSTEXPR_RETURN auto linear_end(const xbroadcast<CT, X>& c) noexcept`
	`117`	`+ constexpr auto linear_end(const xbroadcast<CT, X>& c) noexcept`
`118`	`118`	`{`
`119`	`119`	`return linear_end(c.expression());`
`120`	`120`	`}`