diff --git a/include/xtensor/containers/xscalar.hpp b/include/xtensor/containers/xscalar.hpp
index 106a65923..2c5896c1b 100644
--- a/include/xtensor/containers/xscalar.hpp
+++ b/include/xtensor/containers/xscalar.hpp
@@ -159,12 +159,12 @@ namespace xt
         using accessible_base::shape;
 
         template <class... Args>
-        reference operator()(Args...) noexcept;
+        reference operator()(Args...);
         template <class... Args>
         reference unchecked(Args...) noexcept;
 
         template <class... Args>
-        const_reference operator()(Args...) const noexcept;
+        const_reference operator()(Args...) const;
         template <class... Args>
         const_reference unchecked(Args...) const noexcept;
 
@@ -551,7 +551,7 @@ namespace xt
 
     template <class CT>
     template <class... Args>
-    inline auto xscalar<CT>::operator()(Args...) noexcept -> reference
+    inline auto xscalar<CT>::operator()(Args...) -> reference
     {
         XTENSOR_CHECK_DIMENSION((std::array<int, 0>()), Args()...);
         return m_value;
@@ -566,7 +566,7 @@ namespace xt
 
     template <class CT>
     template <class... Args>
-    inline auto xscalar<CT>::operator()(Args...) const noexcept -> const_reference
+    inline auto xscalar<CT>::operator()(Args...) const -> const_reference
     {
         XTENSOR_CHECK_DIMENSION((std::array<int, 0>()), Args()...);
         return m_value;
diff --git a/include/xtensor/core/xaccessible.hpp b/include/xtensor/core/xaccessible.hpp
index 8ca55f8a4..6b94bebf7 100644
--- a/include/xtensor/core/xaccessible.hpp
+++ b/include/xtensor/core/xaccessible.hpp
@@ -37,7 +37,7 @@ namespace xt
         using size_type = typename inner_types::size_type;
 
         size_type size() const noexcept(noexcept(derived_cast().shape()));
-        size_type dimension() const noexcept;
+        size_type dimension() const noexcept(noexcept(derived_cast().shape()));
         size_type shape(size_type index) const;
 
         template <class... Args>
@@ -147,7 +147,7 @@ namespace xt
      * Returns the number of dimensions of the expression.
      */
     template <class D>
-    inline auto xconst_accessible<D>::dimension() const noexcept -> size_type
+    inline auto xconst_accessible<D>::dimension() const noexcept(noexcept(derived_cast().shape())) -> size_type
     {
         return derived_cast().shape().size();
     }
diff --git a/include/xtensor/core/xexpression.hpp b/include/xtensor/core/xexpression.hpp
index 49a662f17..d9ffd5a09 100644
--- a/include/xtensor/core/xexpression.hpp
+++ b/include/xtensor/core/xexpression.hpp
@@ -424,29 +424,33 @@ namespace xt
         return m_ptr->name();                         \
     }
 
-#define XTENSOR_FORWARD_CONST_ITERATOR_METHOD(name)                                               \
-    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>                                          \
-    auto name() const noexcept -> decltype(std::declval<xtl::constify_t<E>>().template name<L>()) \
-    {                                                                                             \
-        return m_ptr->template name<L>();                                                         \
-    }                                                                                             \
-    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>                                 \
-    auto name(const S& shape) const noexcept                                                      \
-        -> decltype(std::declval<xtl::constify_t<E>>().template name<L>(shape))                   \
-    {                                                                                             \
-        return m_ptr->template name<L>();                                                         \
+#define XTENSOR_FORWARD_CONST_ITERATOR_METHOD(name)                                             \
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>                                        \
+    auto name() const noexcept(noexcept(std::declval<xtl::constify_t<E>>().template name<L>())) \
+        -> decltype(std::declval<xtl::constify_t<E>>().template name<L>())                      \
+    {                                                                                           \
+        return m_ptr->template name<L>();                                                       \
+    }                                                                                           \
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>                               \
+    auto name(const S& shape)                                                                   \
+        const noexcept(noexcept(std::declval<xtl::constify_t<E>>().template name<L>(shape)))    \
+            -> decltype(std::declval<xtl::constify_t<E>>().template name<L>(shape))             \
+    {                                                                                           \
+        return m_ptr->template name<L>();                                                       \
     }
 
-#define XTENSOR_FORWARD_ITERATOR_METHOD(name)                                                 \
-    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>                             \
-    auto name(const S& shape) noexcept -> decltype(std::declval<E>().template name<L>(shape)) \
-    {                                                                                         \
-        return m_ptr->template name<L>();                                                     \
-    }                                                                                         \
-    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>                                      \
-    auto name() noexcept -> decltype(std::declval<E>().template name<L>())                    \
-    {                                                                                         \
-        return m_ptr->template name<L>();                                                     \
+#define XTENSOR_FORWARD_ITERATOR_METHOD(name)                                               \
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>                           \
+    auto name(const S& shape) noexcept(noexcept(std::declval<E>().template name<L>(shape))) \
+        -> decltype(std::declval<E>().template name<L>(shape))                              \
+    {                                                                                       \
+        return m_ptr->template name<L>();                                                   \
+    }                                                                                       \
+    template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>                                    \
+    auto name() noexcept(noexcept(std::declval<E>().template name<L>()))                    \
+        -> decltype(std::declval<E>().template name<L>())                                   \
+    {                                                                                       \
+        return m_ptr->template name<L>();                                                   \
     }
 
     namespace detail
diff --git a/include/xtensor/core/xfunction.hpp b/include/xtensor/core/xfunction.hpp
index 99144b377..30b6c458b 100644
--- a/include/xtensor/core/xfunction.hpp
+++ b/include/xtensor/core/xfunction.hpp
@@ -50,8 +50,8 @@ namespace xt
             bool is_trivial;
             bool is_initialized;
 
-            xfunction_cache_impl()
-                : shape(xtl::make_sequence<S>(0, std::size_t(0)))
+            xfunction_cache_impl() noexcept
+                : shape()
                 , is_trivial(false)
                 , is_initialized(false)
             {
@@ -272,10 +272,13 @@ namespace xt
         using const_reverse_iterator = typename iterable_base::const_reverse_iterator;
 
         template <class Func, class... CTA, class U = std::enable_if_t<!std::is_base_of<std::decay_t<Func>, self_type>::value>>
-        xfunction(Func&& f, CTA&&... e) noexcept;
+        xfunction(Func&& f, CTA&&... e) noexcept(
+            std::is_nothrow_constructible<tuple_type, CTA&&...>::value
+            && std::is_nothrow_constructible<functor_type, Func&&>::value
+        );
 
         template <class FA, class... CTA>
-        xfunction(xfunction<FA, CTA...> xf) noexcept;
+        xfunction(xfunction<FA, CTA...> xf);
 
         ~xfunction() = default;
 
@@ -498,7 +501,10 @@ namespace xt
      */
     template <class F, class... CT>
     template <class Func, class... CTA, class U>
-    inline xfunction<F, CT...>::xfunction(Func&& f, CTA&&... e) noexcept
+    inline xfunction<F, CT...>::xfunction(Func&& f, CTA&&... e) noexcept(
+        std::is_nothrow_constructible<tuple_type, CTA&&...>::value
+        && std::is_nothrow_constructible<functor_type, Func&&>::value
+    )
         : m_e(std::forward<CTA>(e)...)
         , m_f(std::forward<Func>(f))
     {
@@ -511,7 +517,7 @@ namespace xt
      */
     template <class F, class... CT>
     template <class FA, class... CTA>
-    inline xfunction<F, CT...>::xfunction(xfunction<FA, CTA...> xf) noexcept
+    inline xfunction<F, CT...>::xfunction(xfunction<FA, CTA...> xf)
         : m_e(xf.arguments())
         , m_f(xf.functor())
     {
diff --git a/include/xtensor/core/xiterable.hpp b/include/xtensor/core/xiterable.hpp
index 62f48173a..d10f3718e 100644
--- a/include/xtensor/core/xiterable.hpp
+++ b/include/xtensor/core/xiterable.hpp
@@ -74,40 +74,40 @@ namespace xt
         using const_reverse_iterator = const_reverse_layout_iterator<XTENSOR_DEFAULT_TRAVERSAL>;
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        const_layout_iterator<L> begin() const noexcept;
+        const_layout_iterator<L> begin() const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        const_layout_iterator<L> end() const noexcept;
+        const_layout_iterator<L> end() const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        const_layout_iterator<L> cbegin() const noexcept;
+        const_layout_iterator<L> cbegin() const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        const_layout_iterator<L> cend() const noexcept;
+        const_layout_iterator<L> cend() const;
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        const_reverse_layout_iterator<L> rbegin() const noexcept;
+        const_reverse_layout_iterator<L> rbegin() const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        const_reverse_layout_iterator<L> rend() const noexcept;
+        const_reverse_layout_iterator<L> rend() const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        const_reverse_layout_iterator<L> crbegin() const noexcept;
+        const_reverse_layout_iterator<L> crbegin() const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        const_reverse_layout_iterator<L> crend() const noexcept;
+        const_reverse_layout_iterator<L> crend() const;
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        const_broadcast_iterator<S, L> begin(const S& shape) const noexcept;
+        const_broadcast_iterator<S, L> begin(const S& shape) const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        const_broadcast_iterator<S, L> end(const S& shape) const noexcept;
+        const_broadcast_iterator<S, L> end(const S& shape) const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        const_broadcast_iterator<S, L> cbegin(const S& shape) const noexcept;
+        const_broadcast_iterator<S, L> cbegin(const S& shape) const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        const_broadcast_iterator<S, L> cend(const S& shape) const noexcept;
+        const_broadcast_iterator<S, L> cend(const S& shape) const;
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        const_reverse_broadcast_iterator<S, L> rbegin(const S& shape) const noexcept;
+        const_reverse_broadcast_iterator<S, L> rbegin(const S& shape) const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        const_reverse_broadcast_iterator<S, L> rend(const S& shape) const noexcept;
+        const_reverse_broadcast_iterator<S, L> rend(const S& shape) const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        const_reverse_broadcast_iterator<S, L> crbegin(const S& shape) const noexcept;
+        const_reverse_broadcast_iterator<S, L> crbegin(const S& shape) const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        const_reverse_broadcast_iterator<S, L> crend(const S& shape) const noexcept;
+        const_reverse_broadcast_iterator<S, L> crend(const S& shape) const;
 
     protected:
 
@@ -116,19 +116,19 @@ namespace xt
     private:
 
         template <layout_type L>
-        const_layout_iterator<L> get_cbegin(bool end_index) const noexcept;
+        const_layout_iterator<L> get_cbegin(bool end_index) const;
         template <layout_type L>
-        const_layout_iterator<L> get_cend(bool end_index) const noexcept;
+        const_layout_iterator<L> get_cend(bool end_index) const;
 
         template <layout_type L, class S>
-        const_broadcast_iterator<S, L> get_cbegin(const S& shape, bool end_index) const noexcept;
+        const_broadcast_iterator<S, L> get_cbegin(const S& shape, bool end_index) const;
         template <layout_type L, class S>
-        const_broadcast_iterator<S, L> get_cend(const S& shape, bool end_index) const noexcept;
+        const_broadcast_iterator<S, L> get_cend(const S& shape, bool end_index) const;
 
         template <class S>
-        const_stepper get_stepper_begin(const S& shape) const noexcept;
+        const_stepper get_stepper_begin(const S& shape) const;
         template <class S>
-        const_stepper get_stepper_end(const S& shape, layout_type l) const noexcept;
+        const_stepper get_stepper_end(const S& shape, layout_type l) const;
 
         const derived_type& derived_cast() const;
     };
@@ -192,46 +192,46 @@ namespace xt
         using base_type::rend;
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        layout_iterator<L> begin() noexcept;
+        layout_iterator<L> begin();
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        layout_iterator<L> end() noexcept;
+        layout_iterator<L> end();
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        reverse_layout_iterator<L> rbegin() noexcept;
+        reverse_layout_iterator<L> rbegin();
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        reverse_layout_iterator<L> rend() noexcept;
+        reverse_layout_iterator<L> rend();
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        broadcast_iterator<S, L> begin(const S& shape) noexcept;
+        broadcast_iterator<S, L> begin(const S& shape);
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        broadcast_iterator<S, L> end(const S& shape) noexcept;
+        broadcast_iterator<S, L> end(const S& shape);
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        reverse_broadcast_iterator<S, L> rbegin(const S& shape) noexcept;
+        reverse_broadcast_iterator<S, L> rbegin(const S& shape);
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        reverse_broadcast_iterator<S, L> rend(const S& shape) noexcept;
+        reverse_broadcast_iterator<S, L> rend(const S& shape);
 
     private:
 
         template <layout_type L>
-        layout_iterator<L> get_begin(bool end_index) noexcept;
+        layout_iterator<L> get_begin(bool end_index);
         template <layout_type L>
-        layout_iterator<L> get_end(bool end_index) noexcept;
+        layout_iterator<L> get_end(bool end_index);
 
         template <layout_type L, class S>
-        broadcast_iterator<S, L> get_begin(const S& shape, bool end_index) noexcept;
+        broadcast_iterator<S, L> get_begin(const S& shape, bool end_index);
         template <layout_type L, class S>
-        broadcast_iterator<S, L> get_end(const S& shape, bool end_index) noexcept;
+        broadcast_iterator<S, L> get_end(const S& shape, bool end_index);
 
         template <class S>
-        stepper get_stepper_begin(const S& shape) noexcept;
+        stepper get_stepper_begin(const S& shape);
         template <class S>
-        stepper get_stepper_end(const S& shape, layout_type l) noexcept;
+        stepper get_stepper_end(const S& shape, layout_type l);
 
         template <class S>
-        const_stepper get_stepper_begin(const S& shape) const noexcept;
+        const_stepper get_stepper_begin(const S& shape) const;
         template <class S>
-        const_stepper get_stepper_end(const S& shape, layout_type l) const noexcept;
+        const_stepper get_stepper_end(const S& shape, layout_type l) const;
 
         derived_type& derived_cast();
     };
@@ -367,60 +367,60 @@ namespace xt
         using const_reverse_iterator = select_const_reverse_iterator<XTENSOR_DEFAULT_TRAVERSAL>;
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        select_iterator<L> begin() noexcept;
+        select_iterator<L> begin() noexcept(L == static_layout);
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        select_iterator<L> end() noexcept;
+        select_iterator<L> end() noexcept(L == static_layout);
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        select_const_iterator<L> begin() const noexcept;
+        select_const_iterator<L> begin() const noexcept(L == static_layout);
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        select_const_iterator<L> end() const noexcept;
+        select_const_iterator<L> end() const noexcept(L == static_layout);
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        select_const_iterator<L> cbegin() const noexcept;
+        select_const_iterator<L> cbegin() const noexcept(L == static_layout);
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        select_const_iterator<L> cend() const noexcept;
+        select_const_iterator<L> cend() const noexcept(L == static_layout);
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        select_reverse_iterator<L> rbegin() noexcept;
+        select_reverse_iterator<L> rbegin() noexcept(L == static_layout);
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        select_reverse_iterator<L> rend() noexcept;
+        select_reverse_iterator<L> rend() noexcept(L == static_layout);
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        select_const_reverse_iterator<L> rbegin() const noexcept;
+        select_const_reverse_iterator<L> rbegin() const noexcept(L == static_layout);
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        select_const_reverse_iterator<L> rend() const noexcept;
+        select_const_reverse_iterator<L> rend() const noexcept(L == static_layout);
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        select_const_reverse_iterator<L> crbegin() const noexcept;
+        select_const_reverse_iterator<L> crbegin() const noexcept(L == static_layout);
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        select_const_reverse_iterator<L> crend() const noexcept;
+        select_const_reverse_iterator<L> crend() const noexcept(L == static_layout);
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        broadcast_iterator<S, L> begin(const S& shape) noexcept;
+        broadcast_iterator<S, L> begin(const S& shape);
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        broadcast_iterator<S, L> end(const S& shape) noexcept;
+        broadcast_iterator<S, L> end(const S& shape);
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        const_broadcast_iterator<S, L> begin(const S& shape) const noexcept;
+        const_broadcast_iterator<S, L> begin(const S& shape) const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        const_broadcast_iterator<S, L> end(const S& shape) const noexcept;
+        const_broadcast_iterator<S, L> end(const S& shape) const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        const_broadcast_iterator<S, L> cbegin(const S& shape) const noexcept;
+        const_broadcast_iterator<S, L> cbegin(const S& shape) const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        const_broadcast_iterator<S, L> cend(const S& shape) const noexcept;
+        const_broadcast_iterator<S, L> cend(const S& shape) const;
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        reverse_broadcast_iterator<S, L> rbegin(const S& shape) noexcept;
+        reverse_broadcast_iterator<S, L> rbegin(const S& shape);
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        reverse_broadcast_iterator<S, L> rend(const S& shape) noexcept;
+        reverse_broadcast_iterator<S, L> rend(const S& shape);
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        const_reverse_broadcast_iterator<S, L> rbegin(const S& shape) const noexcept;
+        const_reverse_broadcast_iterator<S, L> rbegin(const S& shape) const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        const_reverse_broadcast_iterator<S, L> rend(const S& shape) const noexcept;
+        const_reverse_broadcast_iterator<S, L> rend(const S& shape) const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        const_reverse_broadcast_iterator<S, L> crbegin(const S& shape) const noexcept;
+        const_reverse_broadcast_iterator<S, L> crbegin(const S& shape) const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class S>
-        const_reverse_broadcast_iterator<S, L> crend(const S& shape) const noexcept;
+        const_reverse_broadcast_iterator<S, L> crend(const S& shape) const;
 
     private:
 
@@ -445,7 +445,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xconst_iterable<D>::begin() const noexcept -> const_layout_iterator<L>
+    inline auto xconst_iterable<D>::begin() const -> const_layout_iterator<L>
     {
         return this->template cbegin<L>();
     }
@@ -457,7 +457,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xconst_iterable<D>::end() const noexcept -> const_layout_iterator<L>
+    inline auto xconst_iterable<D>::end() const -> const_layout_iterator<L>
     {
         return this->template cend<L>();
     }
@@ -468,7 +468,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xconst_iterable<D>::cbegin() const noexcept -> const_layout_iterator<L>
+    inline auto xconst_iterable<D>::cbegin() const -> const_layout_iterator<L>
     {
         return this->template get_cbegin<L>(false);
     }
@@ -480,7 +480,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xconst_iterable<D>::cend() const noexcept -> const_layout_iterator<L>
+    inline auto xconst_iterable<D>::cend() const -> const_layout_iterator<L>
     {
         return this->template get_cend<L>(true);
     }
@@ -497,7 +497,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xconst_iterable<D>::rbegin() const noexcept -> const_reverse_layout_iterator<L>
+    inline auto xconst_iterable<D>::rbegin() const -> const_reverse_layout_iterator<L>
     {
         return this->template crbegin<L>();
     }
@@ -509,7 +509,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xconst_iterable<D>::rend() const noexcept -> const_reverse_layout_iterator<L>
+    inline auto xconst_iterable<D>::rend() const -> const_reverse_layout_iterator<L>
     {
         return this->template crend<L>();
     }
@@ -520,7 +520,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xconst_iterable<D>::crbegin() const noexcept -> const_reverse_layout_iterator<L>
+    inline auto xconst_iterable<D>::crbegin() const -> const_reverse_layout_iterator<L>
     {
         return const_reverse_layout_iterator<L>(get_cend<L>(true));
     }
@@ -532,7 +532,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xconst_iterable<D>::crend() const noexcept -> const_reverse_layout_iterator<L>
+    inline auto xconst_iterable<D>::crend() const -> const_reverse_layout_iterator<L>
     {
         return const_reverse_layout_iterator<L>(get_cbegin<L>(false));
     }
@@ -552,7 +552,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xconst_iterable<D>::begin(const S& shape) const noexcept -> const_broadcast_iterator<S, L>
+    inline auto xconst_iterable<D>::begin(const S& shape) const -> const_broadcast_iterator<S, L>
     {
         return cbegin<L>(shape);
     }
@@ -566,7 +566,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xconst_iterable<D>::end(const S& shape) const noexcept -> const_broadcast_iterator<S, L>
+    inline auto xconst_iterable<D>::end(const S& shape) const -> const_broadcast_iterator<S, L>
     {
         return cend<L>(shape);
     }
@@ -580,7 +580,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xconst_iterable<D>::cbegin(const S& shape) const noexcept -> const_broadcast_iterator<S, L>
+    inline auto xconst_iterable<D>::cbegin(const S& shape) const -> const_broadcast_iterator<S, L>
     {
         return get_cbegin<L, S>(shape, false);
     }
@@ -594,7 +594,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xconst_iterable<D>::cend(const S& shape) const noexcept -> const_broadcast_iterator<S, L>
+    inline auto xconst_iterable<D>::cend(const S& shape) const -> const_broadcast_iterator<S, L>
     {
         return get_cend<L, S>(shape, true);
     }
@@ -614,8 +614,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xconst_iterable<D>::rbegin(const S& shape) const noexcept
-        -> const_reverse_broadcast_iterator<S, L>
+    inline auto xconst_iterable<D>::rbegin(const S& shape) const -> const_reverse_broadcast_iterator<S, L>
     {
         return crbegin<L, S>(shape);
     }
@@ -629,8 +628,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xconst_iterable<D>::rend(const S& shape) const noexcept
-        -> const_reverse_broadcast_iterator<S, L>
+    inline auto xconst_iterable<D>::rend(const S& shape) const -> const_reverse_broadcast_iterator<S, L>
     {
         return crend<L, S>(shape);
     }
@@ -644,8 +642,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xconst_iterable<D>::crbegin(const S& shape) const noexcept
-        -> const_reverse_broadcast_iterator<S, L>
+    inline auto xconst_iterable<D>::crbegin(const S& shape) const -> const_reverse_broadcast_iterator<S, L>
     {
         return const_reverse_broadcast_iterator<S, L>(get_cend<L, S>(shape, true));
     }
@@ -659,8 +656,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xconst_iterable<D>::crend(const S& shape) const noexcept
-        -> const_reverse_broadcast_iterator<S, L>
+    inline auto xconst_iterable<D>::crend(const S& shape) const -> const_reverse_broadcast_iterator<S, L>
     {
         return const_reverse_broadcast_iterator<S, L>(get_cbegin<L, S>(shape, false));
     }
@@ -669,21 +665,21 @@ namespace xt
 
     template <class D>
     template <layout_type L>
-    inline auto xconst_iterable<D>::get_cbegin(bool end_index) const noexcept -> const_layout_iterator<L>
+    inline auto xconst_iterable<D>::get_cbegin(bool end_index) const -> const_layout_iterator<L>
     {
         return const_layout_iterator<L>(get_stepper_begin(get_shape()), &get_shape(), end_index);
     }
 
     template <class D>
     template <layout_type L>
-    inline auto xconst_iterable<D>::get_cend(bool end_index) const noexcept -> const_layout_iterator<L>
+    inline auto xconst_iterable<D>::get_cend(bool end_index) const -> const_layout_iterator<L>
     {
         return const_layout_iterator<L>(get_stepper_end(get_shape(), L), &get_shape(), end_index);
     }
 
     template <class D>
     template <layout_type L, class S>
-    inline auto xconst_iterable<D>::get_cbegin(const S& shape, bool end_index) const noexcept
+    inline auto xconst_iterable<D>::get_cbegin(const S& shape, bool end_index) const
         -> const_broadcast_iterator<S, L>
     {
         return const_broadcast_iterator<S, L>(get_stepper_begin(shape), shape, end_index);
@@ -691,7 +687,7 @@ namespace xt
 
     template <class D>
     template <layout_type L, class S>
-    inline auto xconst_iterable<D>::get_cend(const S& shape, bool end_index) const noexcept
+    inline auto xconst_iterable<D>::get_cend(const S& shape, bool end_index) const
         -> const_broadcast_iterator<S, L>
     {
         return const_broadcast_iterator<S, L>(get_stepper_end(shape, L), shape, end_index);
@@ -699,15 +695,14 @@ namespace xt
 
     template <class D>
     template <class S>
-    inline auto xconst_iterable<D>::get_stepper_begin(const S& shape) const noexcept -> const_stepper
+    inline auto xconst_iterable<D>::get_stepper_begin(const S& shape) const -> const_stepper
     {
         return derived_cast().stepper_begin(shape);
     }
 
     template <class D>
     template <class S>
-    inline auto xconst_iterable<D>::get_stepper_end(const S& shape, layout_type l) const noexcept
-        -> const_stepper
+    inline auto xconst_iterable<D>::get_stepper_end(const S& shape, layout_type l) const -> const_stepper
     {
         return derived_cast().stepper_end(shape, l);
     }
@@ -738,7 +733,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xiterable<D>::begin() noexcept -> layout_iterator<L>
+    inline auto xiterable<D>::begin() -> layout_iterator<L>
     {
         return get_begin<L>(false);
     }
@@ -750,7 +745,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xiterable<D>::end() noexcept -> layout_iterator<L>
+    inline auto xiterable<D>::end() -> layout_iterator<L>
     {
         return get_end<L>(true);
     }
@@ -767,7 +762,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xiterable<D>::rbegin() noexcept -> reverse_layout_iterator<L>
+    inline auto xiterable<D>::rbegin() -> reverse_layout_iterator<L>
     {
         return reverse_layout_iterator<L>(get_end<L>(true));
     }
@@ -779,7 +774,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xiterable<D>::rend() noexcept -> reverse_layout_iterator<L>
+    inline auto xiterable<D>::rend() -> reverse_layout_iterator<L>
     {
         return reverse_layout_iterator<L>(get_begin<L>(false));
     }
@@ -799,7 +794,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xiterable<D>::begin(const S& shape) noexcept -> broadcast_iterator<S, L>
+    inline auto xiterable<D>::begin(const S& shape) -> broadcast_iterator<S, L>
     {
         return get_begin<L, S>(shape, false);
     }
@@ -813,7 +808,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xiterable<D>::end(const S& shape) noexcept -> broadcast_iterator<S, L>
+    inline auto xiterable<D>::end(const S& shape) -> broadcast_iterator<S, L>
     {
         return get_end<L, S>(shape, true);
     }
@@ -833,7 +828,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xiterable<D>::rbegin(const S& shape) noexcept -> reverse_broadcast_iterator<S, L>
+    inline auto xiterable<D>::rbegin(const S& shape) -> reverse_broadcast_iterator<S, L>
     {
         return reverse_broadcast_iterator<S, L>(get_end<L, S>(shape, true));
     }
@@ -847,7 +842,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xiterable<D>::rend(const S& shape) noexcept -> reverse_broadcast_iterator<S, L>
+    inline auto xiterable<D>::rend(const S& shape) -> reverse_broadcast_iterator<S, L>
     {
         return reverse_broadcast_iterator<S, L>(get_begin<L, S>(shape, false));
     }
@@ -856,56 +851,56 @@ namespace xt
 
     template <class D>
     template <layout_type L>
-    inline auto xiterable<D>::get_begin(bool end_index) noexcept -> layout_iterator<L>
+    inline auto xiterable<D>::get_begin(bool end_index) -> layout_iterator<L>
     {
         return layout_iterator<L>(get_stepper_begin(this->get_shape()), &(this->get_shape()), end_index);
     }
 
     template <class D>
     template <layout_type L>
-    inline auto xiterable<D>::get_end(bool end_index) noexcept -> layout_iterator<L>
+    inline auto xiterable<D>::get_end(bool end_index) -> layout_iterator<L>
     {
         return layout_iterator<L>(get_stepper_end(this->get_shape(), L), &(this->get_shape()), end_index);
     }
 
     template <class D>
     template <layout_type L, class S>
-    inline auto xiterable<D>::get_begin(const S& shape, bool end_index) noexcept -> broadcast_iterator<S, L>
+    inline auto xiterable<D>::get_begin(const S& shape, bool end_index) -> broadcast_iterator<S, L>
     {
         return broadcast_iterator<S, L>(get_stepper_begin(shape), shape, end_index);
     }
 
     template <class D>
     template <layout_type L, class S>
-    inline auto xiterable<D>::get_end(const S& shape, bool end_index) noexcept -> broadcast_iterator<S, L>
+    inline auto xiterable<D>::get_end(const S& shape, bool end_index) -> broadcast_iterator<S, L>
     {
         return broadcast_iterator<S, L>(get_stepper_end(shape, L), shape, end_index);
     }
 
     template <class D>
     template <class S>
-    inline auto xiterable<D>::get_stepper_begin(const S& shape) noexcept -> stepper
+    inline auto xiterable<D>::get_stepper_begin(const S& shape) -> stepper
     {
         return derived_cast().stepper_begin(shape);
     }
 
     template <class D>
     template <class S>
-    inline auto xiterable<D>::get_stepper_end(const S& shape, layout_type l) noexcept -> stepper
+    inline auto xiterable<D>::get_stepper_end(const S& shape, layout_type l) -> stepper
     {
         return derived_cast().stepper_end(shape, l);
     }
 
     template <class D>
     template <class S>
-    inline auto xiterable<D>::get_stepper_begin(const S& shape) const noexcept -> const_stepper
+    inline auto xiterable<D>::get_stepper_begin(const S& shape) const -> const_stepper
     {
         return derived_cast().stepper_begin(shape);
     }
 
     template <class D>
     template <class S>
-    inline auto xiterable<D>::get_stepper_end(const S& shape, layout_type l) const noexcept -> const_stepper
+    inline auto xiterable<D>::get_stepper_end(const S& shape, layout_type l) const -> const_stepper
     {
         return derived_cast().stepper_end(shape, l);
     }
@@ -930,7 +925,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xcontiguous_iterable<D>::begin() noexcept -> select_iterator<L>
+    inline auto xcontiguous_iterable<D>::begin() noexcept(L == static_layout) -> select_iterator<L>
     {
         if constexpr (L == static_layout)
         {
@@ -949,7 +944,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xcontiguous_iterable<D>::end() noexcept -> select_iterator<L>
+    inline auto xcontiguous_iterable<D>::end() noexcept(L == static_layout) -> select_iterator<L>
     {
         if constexpr (L == static_layout)
         {
@@ -967,7 +962,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xcontiguous_iterable<D>::begin() const noexcept -> select_const_iterator<L>
+    inline auto xcontiguous_iterable<D>::begin() const noexcept(L == static_layout) -> select_const_iterator<L>
     {
         return this->template cbegin<L>();
     }
@@ -979,7 +974,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xcontiguous_iterable<D>::end() const noexcept -> select_const_iterator<L>
+    inline auto xcontiguous_iterable<D>::end() const noexcept(L == static_layout) -> select_const_iterator<L>
     {
         return this->template cend<L>();
     }
@@ -990,7 +985,8 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xcontiguous_iterable<D>::cbegin() const noexcept -> select_const_iterator<L>
+    inline auto xcontiguous_iterable<D>::cbegin() const noexcept(L == static_layout)
+        -> select_const_iterator<L>
     {
         if constexpr (L == static_layout)
         {
@@ -1009,7 +1005,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xcontiguous_iterable<D>::cend() const noexcept -> select_const_iterator<L>
+    inline auto xcontiguous_iterable<D>::cend() const noexcept(L == static_layout) -> select_const_iterator<L>
     {
         if constexpr (L == static_layout)
         {
@@ -1033,7 +1029,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xcontiguous_iterable<D>::rbegin() noexcept -> select_reverse_iterator<L>
+    inline auto xcontiguous_iterable<D>::rbegin() noexcept(L == static_layout) -> select_reverse_iterator<L>
     {
         if constexpr (L == static_layout)
         {
@@ -1052,7 +1048,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xcontiguous_iterable<D>::rend() noexcept -> select_reverse_iterator<L>
+    inline auto xcontiguous_iterable<D>::rend() noexcept(L == static_layout) -> select_reverse_iterator<L>
     {
         if constexpr (L == static_layout)
         {
@@ -1070,7 +1066,8 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xcontiguous_iterable<D>::rbegin() const noexcept -> select_const_reverse_iterator<L>
+    inline auto xcontiguous_iterable<D>::rbegin() const noexcept(L == static_layout)
+        -> select_const_reverse_iterator<L>
     {
         return this->template crbegin<L>();
     }
@@ -1082,7 +1079,8 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xcontiguous_iterable<D>::rend() const noexcept -> select_const_reverse_iterator<L>
+    inline auto xcontiguous_iterable<D>::rend() const noexcept(L == static_layout)
+        -> select_const_reverse_iterator<L>
     {
         return this->template crend<L>();
     }
@@ -1093,7 +1091,8 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xcontiguous_iterable<D>::crbegin() const noexcept -> select_const_reverse_iterator<L>
+    inline auto xcontiguous_iterable<D>::crbegin() const noexcept(L == static_layout)
+        -> select_const_reverse_iterator<L>
     {
         if constexpr (L == static_layout)
         {
@@ -1112,7 +1111,8 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xcontiguous_iterable<D>::crend() const noexcept -> select_const_reverse_iterator<L>
+    inline auto xcontiguous_iterable<D>::crend() const noexcept(L == static_layout)
+        -> select_const_reverse_iterator<L>
     {
         if constexpr (L == static_layout)
         {
@@ -1140,7 +1140,7 @@ namespace xt
     //@{
     template <class D>
     template <layout_type L, class S>
-    inline auto xcontiguous_iterable<D>::begin(const S& shape) noexcept -> broadcast_iterator<S, L>
+    inline auto xcontiguous_iterable<D>::begin(const S& shape) -> broadcast_iterator<S, L>
     {
         return iterable_base::template begin<L, S>(shape);
     }
@@ -1154,7 +1154,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xcontiguous_iterable<D>::end(const S& shape) noexcept -> broadcast_iterator<S, L>
+    inline auto xcontiguous_iterable<D>::end(const S& shape) -> broadcast_iterator<S, L>
     {
         return iterable_base::template end<L, S>(shape);
     }
@@ -1168,7 +1168,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xcontiguous_iterable<D>::begin(const S& shape) const noexcept -> const_broadcast_iterator<S, L>
+    inline auto xcontiguous_iterable<D>::begin(const S& shape) const -> const_broadcast_iterator<S, L>
     {
         return iterable_base::template begin<L, S>(shape);
     }
@@ -1182,7 +1182,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xcontiguous_iterable<D>::end(const S& shape) const noexcept -> const_broadcast_iterator<S, L>
+    inline auto xcontiguous_iterable<D>::end(const S& shape) const -> const_broadcast_iterator<S, L>
     {
         return iterable_base::template end<L, S>(shape);
     }
@@ -1196,8 +1196,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xcontiguous_iterable<D>::cbegin(const S& shape) const noexcept
-        -> const_broadcast_iterator<S, L>
+    inline auto xcontiguous_iterable<D>::cbegin(const S& shape) const -> const_broadcast_iterator<S, L>
     {
         return iterable_base::template cbegin<L, S>(shape);
     }
@@ -1211,7 +1210,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xcontiguous_iterable<D>::cend(const S& shape) const noexcept -> const_broadcast_iterator<S, L>
+    inline auto xcontiguous_iterable<D>::cend(const S& shape) const -> const_broadcast_iterator<S, L>
     {
         return iterable_base::template cend<L, S>(shape);
     }
@@ -1231,7 +1230,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xcontiguous_iterable<D>::rbegin(const S& shape) noexcept -> reverse_broadcast_iterator<S, L>
+    inline auto xcontiguous_iterable<D>::rbegin(const S& shape) -> reverse_broadcast_iterator<S, L>
     {
         return iterable_base::template rbegin<L, S>(shape);
     }
@@ -1245,7 +1244,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xcontiguous_iterable<D>::rend(const S& shape) noexcept -> reverse_broadcast_iterator<S, L>
+    inline auto xcontiguous_iterable<D>::rend(const S& shape) -> reverse_broadcast_iterator<S, L>
     {
         return iterable_base::template rend<L, S>(shape);
     }
@@ -1259,8 +1258,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xcontiguous_iterable<D>::rbegin(const S& shape) const noexcept
-        -> const_reverse_broadcast_iterator<S, L>
+    inline auto xcontiguous_iterable<D>::rbegin(const S& shape) const -> const_reverse_broadcast_iterator<S, L>
     {
         return iterable_base::template rbegin<L, S>(shape);
     }
@@ -1274,8 +1272,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xcontiguous_iterable<D>::rend(const S& shape) const noexcept
-        -> const_reverse_broadcast_iterator<S, L>
+    inline auto xcontiguous_iterable<D>::rend(const S& shape) const -> const_reverse_broadcast_iterator<S, L>
     {
         return iterable_base::template rend<L, S>(shape);
     }
@@ -1289,7 +1286,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xcontiguous_iterable<D>::crbegin(const S& shape) const noexcept
+    inline auto xcontiguous_iterable<D>::crbegin(const S& shape) const
         -> const_reverse_broadcast_iterator<S, L>
     {
         return iterable_base::template crbegin<L, S>(shape);
@@ -1304,8 +1301,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L, class S>
-    inline auto xcontiguous_iterable<D>::crend(const S& shape) const noexcept
-        -> const_reverse_broadcast_iterator<S, L>
+    inline auto xcontiguous_iterable<D>::crend(const S& shape) const -> const_reverse_broadcast_iterator<S, L>
     {
         return iterable_base::template crend<L, S>(shape);
     }
diff --git a/include/xtensor/core/xmath.hpp b/include/xtensor/core/xmath.hpp
index 6b86c4b74..36734d8ea 100644
--- a/include/xtensor/core/xmath.hpp
+++ b/include/xtensor/core/xmath.hpp
@@ -1772,7 +1772,7 @@ namespace xt
      * @return a boolean
      */
     template <class E1, class E2>
-    inline auto allclose(E1&& e1, E2&& e2, double rtol = 1e-05, double atol = 1e-08) noexcept
+    inline auto allclose(E1&& e1, E2&& e2, double rtol = 1e-05, double atol = 1e-08)
     {
         return xt::all(isclose(std::forward<E1>(e1), std::forward<E2>(e2), rtol, atol));
     }
diff --git a/include/xtensor/core/xshape.hpp b/include/xtensor/core/xshape.hpp
index 1380f4e07..8668c72fd 100644
--- a/include/xtensor/core/xshape.hpp
+++ b/include/xtensor/core/xshape.hpp
@@ -124,7 +124,7 @@ namespace xt
      * @return bool
      */
     template <class E, class S>
-    inline bool has_shape(const E& e, std::initializer_list<S> shape) noexcept
+    inline bool has_shape(const E& e, std::initializer_list<S> shape)
     {
         return e.shape().size() == shape.size()
                && std::equal(e.shape().cbegin(), e.shape().cend(), shape.begin());
diff --git a/include/xtensor/generators/xbuilder.hpp b/include/xtensor/generators/xbuilder.hpp
index 1026b21c7..e4041df23 100644
--- a/include/xtensor/generators/xbuilder.hpp
+++ b/include/xtensor/generators/xbuilder.hpp
@@ -993,7 +993,7 @@ namespace xt
     {
 
         template <std::size_t... I, class... E>
-        inline auto meshgrid_impl(std::index_sequence<I...>, E&&... e) noexcept
+        inline auto meshgrid_impl(std::index_sequence<I...>, E&&... e)
         {
             return std::make_tuple(detail::make_xgenerator(
                 detail::repeat_impl<xclosure_t<E>>(std::forward<E>(e), I),
@@ -1011,7 +1011,7 @@ namespace xt
      * @returns tuple of xgenerator expressions.
      */
     template <class... E>
-    inline auto meshgrid(E&&... e) noexcept
+    inline auto meshgrid(E&&... e)
     {
         return detail::meshgrid_impl(std::make_index_sequence<sizeof...(E)>(), std::forward<E>(e)...);
     }
diff --git a/include/xtensor/generators/xgenerator.hpp b/include/xtensor/generators/xgenerator.hpp
index 57d7d5d6c..878a25d57 100644
--- a/include/xtensor/generators/xgenerator.hpp
+++ b/include/xtensor/generators/xgenerator.hpp
@@ -166,7 +166,7 @@ namespace xt
         const_stepper stepper_end(const O& shape, layout_type) const noexcept;
 
         template <class E, class FE = F>
-        void assign_to(xexpression<E>& e) const noexcept
+        void assign_to(xexpression<E>& e) const
             requires(assignable_to_expression<E, FE>);
 
         const functor_type& functor() const noexcept;
@@ -373,7 +373,7 @@ namespace xt
 
     template <class F, class R, class S>
     template <class E, class FE>
-    inline void xgenerator<F, R, S>::assign_to(xexpression<E>& e) const noexcept
+    inline void xgenerator<F, R, S>::assign_to(xexpression<E>& e) const
         requires(assignable_to_expression<E, FE>)
     {
         e.derived_cast().resize(m_shape);
diff --git a/include/xtensor/misc/xcomplex.hpp b/include/xtensor/misc/xcomplex.hpp
index c803bb77c..fbed8928c 100644
--- a/include/xtensor/misc/xcomplex.hpp
+++ b/include/xtensor/misc/xcomplex.hpp
@@ -36,7 +36,7 @@ namespace xt
     decltype(auto) real(E&& e) noexcept;
 
     template <class E>
-    decltype(auto) imag(E&& e) noexcept;
+    decltype(auto) imag(E&& e);
 
     /********************************
      * real and imag implementation *
@@ -72,7 +72,7 @@ namespace xt
             }
 
             template <class E>
-            inline static auto imag(E&& e) noexcept
+            inline static auto imag(E&& e)
             {
                 return zeros<typename std::decay_t<E>::value_type>(e.shape());
             }
@@ -90,7 +90,7 @@ namespace xt
             }
 
             template <class E>
-            inline static decltype(auto) imag(E&& e) noexcept
+            inline static decltype(auto) imag(E&& e)
             {
                 return detail::complex_helper<xtl::is_complex<typename std::decay_t<E>::value_type>::value>::imag(
                     std::forward<E>(e)
@@ -141,7 +141,7 @@ namespace xt
      * @tparam e The xt::xexpression
      */
     template <class E>
-    inline decltype(auto) imag(E&& e) noexcept
+    inline decltype(auto) imag(E&& e)
     {
         return detail::complex_expression_helper<is_xexpression<std::decay_t<E>>::value>::imag(std::forward<E>(e
         ));
diff --git a/include/xtensor/misc/xmanipulation.hpp b/include/xtensor/misc/xmanipulation.hpp
index db4125e01..614854160 100644
--- a/include/xtensor/misc/xmanipulation.hpp
+++ b/include/xtensor/misc/xmanipulation.hpp
@@ -42,7 +42,7 @@ namespace xt
     }
 
     template <class E>
-    auto transpose(E&& e) noexcept;
+    auto transpose(E&& e);
 
     template <class E, class S, class Tag = check_policy::none>
     auto transpose(E&& e, S&& permutation, Tag check_policy = Tag());
@@ -236,7 +236,7 @@ namespace xt
      * @param e the input expression
      */
     template <class E>
-    inline auto transpose(E&& e) noexcept
+    inline auto transpose(E&& e)
     {
         using shape_type = xindex_type_t<typename std::decay_t<E>::shape_type>;
         shape_type shape;
diff --git a/include/xtensor/misc/xset_operation.hpp b/include/xtensor/misc/xset_operation.hpp
index 94c64cd62..3e4777f34 100644
--- a/include/xtensor/misc/xset_operation.hpp
+++ b/include/xtensor/misc/xset_operation.hpp
@@ -53,7 +53,7 @@ namespace xt
             template <class E>
             static auto make(E&& e)
             {
-                return [e](const auto& t)
+                return [e = std::forward<E>(e)](const auto& t)
                 {
                     return std::find(e.begin(), e.end(), t) != e.end();
                 };
@@ -133,7 +133,7 @@ namespace xt
      * @return a boolean array
      */
     template <class E, class T>
-    inline auto in1d(E&& element, std::initializer_list<T> test_elements) noexcept
+    inline auto in1d(E&& element, std::initializer_list<T> test_elements)
     {
         XTENSOR_ASSERT(element.dimension() == 1ul);
         return isin(std::forward<E>(element), std::forward<std::initializer_list<T>>(test_elements));
@@ -150,7 +150,7 @@ namespace xt
      * @return a boolean array
      */
     template <class E, class F>
-    inline auto in1d(E&& element, F&& test_elements) noexcept
+    inline auto in1d(E&& element, F&& test_elements)
         requires(iterable_expression<F>)
     {
         XTENSOR_ASSERT(element.dimension() == 1ul);
@@ -170,7 +170,7 @@ namespace xt
      * @return a boolean array
      */
     template <class E, std::forward_iterator I>
-    inline auto in1d(E&& element, I&& test_elements_begin, I&& test_elements_end) noexcept
+    inline auto in1d(E&& element, I&& test_elements_begin, I&& test_elements_end)
     {
         XTENSOR_ASSERT(element.dimension() == 1ul);
         return isin(
diff --git a/include/xtensor/reducers/xnorm.hpp b/include/xtensor/reducers/xnorm.hpp
index b883573f6..c5ccb303b 100644
--- a/include/xtensor/reducers/xnorm.hpp
+++ b/include/xtensor/reducers/xnorm.hpp
@@ -368,7 +368,7 @@ namespace xt
 
 #define XTENSOR_NORM_FUNCTION_AXES(NAME)                                                             \
     template <class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>                \
-    inline auto NAME(E&& e, const I(&axes)[N], EVS es = EVS()) noexcept                              \
+    inline auto NAME(E&& e, const I(&axes)[N], EVS es = EVS())                                       \
     {                                                                                                \
         using axes_type = std::array<typename std::decay_t<E>::size_type, N>;                        \
         return NAME(std::forward<E>(e), xtl::forward_sequence<axes_type, decltype(axes)>(axes), es); \
@@ -396,7 +396,7 @@ namespace xt
 #define XTENSOR_COMMA ,
 #define XTENSOR_NORM_FUNCTION(NAME, RESULT_TYPE, REDUCE_EXPR, REDUCE_OP, MERGE_FUNC)                                       \
     template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(std::negation<is_reducer_options<X>>)> \
-    inline auto NAME(E&& e, X&& axes, EVS es = EVS()) noexcept                                                             \
+    inline auto NAME(E&& e, X&& axes, EVS es = EVS())                                                                      \
     {                                                                                                                      \
         using value_type = typename std::decay_t<E>::value_type;                                                           \
         using result_type = detail::norm_value_type_t<RESULT_TYPE>;                                                        \
@@ -415,7 +415,7 @@ namespace xt
     }                                                                                                                      \
                                                                                                                            \
     template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_xexpression<E>)>                             \
-    inline auto NAME(E&& e, EVS es = EVS()) noexcept                                                                       \
+    inline auto NAME(E&& e, EVS es = EVS())                                                                                \
     {                                                                                                                      \
         return NAME(std::forward<E>(e), arange(e.dimension()), es);                                                        \
     }                                                                                                                      \
@@ -450,7 +450,7 @@ namespace xt
      * the reducer represents a scalar result, otherwise an array of appropriate dimension.
      */
     template <class E, class X, class EVS, class>
-    auto norm_l0(E&& e, X&& axes, EVS es) noexcept;
+    auto norm_l0(E&& e, X&& axes, EVS es);
 
     /**
      * @ingroup red_functions
@@ -465,7 +465,7 @@ namespace xt
      * the reducer represents a scalar result, otherwise an array of appropriate dimension.
      */
     template <class E, class X, class EVS, class>
-    auto norm_l1(E&& e, X&& axes, EVS es) noexcept;
+    auto norm_l1(E&& e, X&& axes, EVS es);
 
     /**
      * @ingroup red_functions
@@ -480,7 +480,7 @@ namespace xt
      * the reducer represents a scalar result, otherwise an array of appropriate dimension.
      */
     template <class E, class X, class EVS, class>
-    auto norm_sq(E&& e, X&& axes, EVS es) noexcept;
+    auto norm_sq(E&& e, X&& axes, EVS es);
 
     /**
      * @ingroup red_functions
@@ -491,7 +491,7 @@ namespace xt
      *  otherwise: implemented as <tt>sqrt(norm_sq(t))</tt>.
      */
     template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_xexpression<E>)>
-    inline auto norm_l2(E&& e, EVS es = EVS()) noexcept
+    inline auto norm_l2(E&& e, EVS es = EVS())
     {
         using std::sqrt;
         return sqrt(norm_sq(std::forward<E>(e), es));
@@ -513,13 +513,13 @@ namespace xt
         class X,
         class EVS = DEFAULT_STRATEGY_REDUCERS,
         XTL_REQUIRES(is_xexpression<E>, std::negation<is_reducer_options<X>>)>
-    inline auto norm_l2(E&& e, X&& axes, EVS es = EVS()) noexcept
+    inline auto norm_l2(E&& e, X&& axes, EVS es = EVS())
     {
         return sqrt(norm_sq(std::forward<E>(e), std::forward<X>(axes), es));
     }
 
     template <class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto norm_l2(E&& e, const I (&axes)[N], EVS es = EVS()) noexcept
+    inline auto norm_l2(E&& e, const I (&axes)[N], EVS es = EVS())
     {
         using axes_type = std::array<typename std::decay_t<E>::size_type, N>;
         return sqrt(norm_sq(std::forward<E>(e), xtl::forward_sequence<axes_type, decltype(axes)>(axes), es));
@@ -538,7 +538,7 @@ namespace xt
      * the reducer represents a scalar result, otherwise an array of appropriate dimension.
      */
     template <class E, class X, class EVS, class>
-    auto norm_linf(E&& e, X&& axes, EVS es) noexcept;
+    auto norm_linf(E&& e, X&& axes, EVS es);
 
     /**
      * @ingroup red_functions
@@ -554,7 +554,7 @@ namespace xt
      * the reducer represents a scalar result, otherwise an array of appropriate dimension.
      */
     template <class E, class X, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(std::negation<is_reducer_options<X>>)>
-    inline auto norm_lp_to_p(E&& e, double p, X&& axes, EVS es = EVS()) noexcept
+    inline auto norm_lp_to_p(E&& e, double p, X&& axes, EVS es = EVS())
     {
         using value_type = typename std::decay_t<E>::value_type;
         using result_type = norm_type_t<std::decay_t<E>>;
@@ -572,13 +572,13 @@ namespace xt
     }
 
     template <class E, class EVS = DEFAULT_STRATEGY_REDUCERS, XTL_REQUIRES(is_xexpression<E>)>
-    inline auto norm_lp_to_p(E&& e, double p, EVS es = EVS()) noexcept
+    inline auto norm_lp_to_p(E&& e, double p, EVS es = EVS())
     {
         return norm_lp_to_p(std::forward<E>(e), p, arange(e.dimension()), es);
     }
 
     template <class E, class I, std::size_t N, class EVS = DEFAULT_STRATEGY_REDUCERS>
-    inline auto norm_lp_to_p(E&& e, double p, const I (&axes)[N], EVS es = EVS()) noexcept
+    inline auto norm_lp_to_p(E&& e, double p, const I (&axes)[N], EVS es = EVS())
     {
         using axes_type = std::array<typename std::decay_t<E>::size_type, N>;
         return norm_lp_to_p(std::forward<E>(e), p, xtl::forward_sequence<axes_type, decltype(axes)>(axes), es);
diff --git a/include/xtensor/views/xfunctor_view.hpp b/include/xtensor/views/xfunctor_view.hpp
index bedbbe828..73d674af2 100644
--- a/include/xtensor/views/xfunctor_view.hpp
+++ b/include/xtensor/views/xfunctor_view.hpp
@@ -169,8 +169,9 @@ namespace xt
         template <class Func, class E>
         xfunctor_applier_base(Func&&, E&&) noexcept;
 
-        size_type size() const noexcept;
-        const inner_shape_type& shape() const noexcept;
+        size_type size() const noexcept(noexcept(std::declval<const xexpression_type&>().size()));
+        const inner_shape_type& shape() const
+            noexcept(noexcept(std::declval<const xexpression_type&>().shape()));
         const inner_strides_type& strides() const noexcept;
         const inner_backstrides_type& backstrides() const noexcept;
         using accessible_base::dimension;
@@ -266,60 +267,60 @@ namespace xt
         }
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        auto begin() noexcept;
+        auto begin();
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        auto end() noexcept;
+        auto end();
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        auto begin() const noexcept;
+        auto begin() const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        auto end() const noexcept;
+        auto end() const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        auto cbegin() const noexcept;
+        auto cbegin() const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        auto cend() const noexcept;
+        auto cend() const;
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        auto rbegin() noexcept;
+        auto rbegin();
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        auto rend() noexcept;
+        auto rend();
 
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        auto rbegin() const noexcept;
+        auto rbegin() const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        auto rend() const noexcept;
+        auto rend() const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        auto crbegin() const noexcept;
+        auto crbegin() const;
         template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        auto crend() const noexcept;
+        auto crend() const;
 
         template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        broadcast_iterator<S, L> begin(const S& shape) noexcept;
+        broadcast_iterator<S, L> begin(const S& shape);
         template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        broadcast_iterator<S, L> end(const S& shape) noexcept;
+        broadcast_iterator<S, L> end(const S& shape);
 
         template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        const_broadcast_iterator<S, L> begin(const S& shape) const noexcept;
+        const_broadcast_iterator<S, L> begin(const S& shape) const;
         template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        const_broadcast_iterator<S, L> end(const S& shape) const noexcept;
+        const_broadcast_iterator<S, L> end(const S& shape) const;
         template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        const_broadcast_iterator<S, L> cbegin(const S& shape) const noexcept;
+        const_broadcast_iterator<S, L> cbegin(const S& shape) const;
         template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        const_broadcast_iterator<S, L> cend(const S& shape) const noexcept;
+        const_broadcast_iterator<S, L> cend(const S& shape) const;
 
         template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        reverse_broadcast_iterator<S, L> rbegin(const S& shape) noexcept;
+        reverse_broadcast_iterator<S, L> rbegin(const S& shape);
         template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        reverse_broadcast_iterator<S, L> rend(const S& shape) noexcept;
+        reverse_broadcast_iterator<S, L> rend(const S& shape);
 
         template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        const_reverse_broadcast_iterator<S, L> rbegin(const S& shape) const noexcept;
+        const_reverse_broadcast_iterator<S, L> rbegin(const S& shape) const;
         template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        const_reverse_broadcast_iterator<S, L> rend(const S& shape) const noexcept;
+        const_reverse_broadcast_iterator<S, L> rend(const S& shape) const;
         template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        const_reverse_broadcast_iterator<S, L> crbegin(const S& shape) const noexcept;
+        const_reverse_broadcast_iterator<S, L> crbegin(const S& shape) const;
         template <class S, layout_type L = XTENSOR_DEFAULT_TRAVERSAL>
-        const_reverse_broadcast_iterator<S, L> crend(const S& shape) const noexcept;
+        const_reverse_broadcast_iterator<S, L> crend(const S& shape) const;
 
         linear_iterator linear_begin() noexcept;
         linear_iterator linear_end() noexcept;
@@ -706,7 +707,8 @@ namespace xt
      * Returns the size of the expression.
      */
     template <class D>
-    inline auto xfunctor_applier_base<D>::size() const noexcept -> size_type
+    inline auto xfunctor_applier_base<D>::size() const
+        noexcept(noexcept(std::declval<const xexpression_type&>().size())) -> size_type
     {
         return m_e.size();
     }
@@ -715,7 +717,8 @@ namespace xt
      * Returns the shape of the expression.
      */
     template <class D>
-    inline auto xfunctor_applier_base<D>::shape() const noexcept -> const inner_shape_type&
+    inline auto xfunctor_applier_base<D>::shape() const
+        noexcept(noexcept(std::declval<const xexpression_type&>().shape())) -> const inner_shape_type&
     {
         return m_e.shape();
     }
@@ -933,7 +936,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xfunctor_applier_base<D>::begin() noexcept
+    inline auto xfunctor_applier_base<D>::begin()
     {
         return xfunctor_iterator<functor_type, decltype(m_e.template begin<L>())>(
             m_e.template begin<L>(),
@@ -948,7 +951,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xfunctor_applier_base<D>::end() noexcept
+    inline auto xfunctor_applier_base<D>::end()
     {
         return xfunctor_iterator<functor_type, decltype(m_e.template end<L>())>(m_e.template end<L>(), &m_functor);
     }
@@ -959,7 +962,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xfunctor_applier_base<D>::begin() const noexcept
+    inline auto xfunctor_applier_base<D>::begin() const
     {
         return this->template cbegin<L>();
     }
@@ -971,7 +974,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xfunctor_applier_base<D>::end() const noexcept
+    inline auto xfunctor_applier_base<D>::end() const
     {
         return this->template cend<L>();
     }
@@ -982,7 +985,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xfunctor_applier_base<D>::cbegin() const noexcept
+    inline auto xfunctor_applier_base<D>::cbegin() const
     {
         return xfunctor_iterator<const functor_type, decltype(m_e.template cbegin<L>())>(
             m_e.template cbegin<L>(),
@@ -997,7 +1000,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xfunctor_applier_base<D>::cend() const noexcept
+    inline auto xfunctor_applier_base<D>::cend() const
     {
         return xfunctor_iterator<const functor_type, decltype(m_e.template cend<L>())>(
             m_e.template cend<L>(),
@@ -1020,7 +1023,7 @@ namespace xt
      */
     template <class D>
     template <class S, layout_type L>
-    inline auto xfunctor_applier_base<D>::begin(const S& shape) noexcept -> broadcast_iterator<S, L>
+    inline auto xfunctor_applier_base<D>::begin(const S& shape) -> broadcast_iterator<S, L>
     {
         return broadcast_iterator<S, L>(m_e.template begin<S, L>(shape), &m_functor);
     }
@@ -1034,7 +1037,7 @@ namespace xt
      */
     template <class D>
     template <class S, layout_type L>
-    inline auto xfunctor_applier_base<D>::end(const S& shape) noexcept -> broadcast_iterator<S, L>
+    inline auto xfunctor_applier_base<D>::end(const S& shape) -> broadcast_iterator<S, L>
     {
         return broadcast_iterator<S, L>(m_e.template end<S, L>(shape), &m_functor);
     }
@@ -1048,8 +1051,7 @@ namespace xt
      */
     template <class D>
     template <class S, layout_type L>
-    inline auto xfunctor_applier_base<D>::begin(const S& shape) const noexcept
-        -> const_broadcast_iterator<S, L>
+    inline auto xfunctor_applier_base<D>::begin(const S& shape) const -> const_broadcast_iterator<S, L>
     {
         return cbegin<S, L>(shape);
     }
@@ -1063,7 +1065,7 @@ namespace xt
      */
     template <class D>
     template <class S, layout_type L>
-    inline auto xfunctor_applier_base<D>::end(const S& shape) const noexcept -> const_broadcast_iterator<S, L>
+    inline auto xfunctor_applier_base<D>::end(const S& shape) const -> const_broadcast_iterator<S, L>
     {
         return cend<S, L>(shape);
     }
@@ -1077,8 +1079,7 @@ namespace xt
      */
     template <class D>
     template <class S, layout_type L>
-    inline auto xfunctor_applier_base<D>::cbegin(const S& shape) const noexcept
-        -> const_broadcast_iterator<S, L>
+    inline auto xfunctor_applier_base<D>::cbegin(const S& shape) const -> const_broadcast_iterator<S, L>
     {
         return const_broadcast_iterator<S, L>(m_e.template cbegin<S, L>(shape), &m_functor);
     }
@@ -1092,7 +1093,7 @@ namespace xt
      */
     template <class D>
     template <class S, layout_type L>
-    inline auto xfunctor_applier_base<D>::cend(const S& shape) const noexcept -> const_broadcast_iterator<S, L>
+    inline auto xfunctor_applier_base<D>::cend(const S& shape) const -> const_broadcast_iterator<S, L>
     {
         return const_broadcast_iterator<S, L>(m_e.template cend<S, L>(shape), &m_functor);
     }
@@ -1109,7 +1110,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xfunctor_applier_base<D>::rbegin() noexcept
+    inline auto xfunctor_applier_base<D>::rbegin()
     {
         return xfunctor_iterator<functor_type, decltype(m_e.template rbegin<L>())>(
             m_e.template rbegin<L>(),
@@ -1124,7 +1125,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xfunctor_applier_base<D>::rend() noexcept
+    inline auto xfunctor_applier_base<D>::rend()
     {
         return xfunctor_iterator<functor_type, decltype(m_e.template rend<L>())>(
             m_e.template rend<L>(),
@@ -1138,7 +1139,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xfunctor_applier_base<D>::rbegin() const noexcept
+    inline auto xfunctor_applier_base<D>::rbegin() const
     {
         return this->template crbegin<L>();
     }
@@ -1150,7 +1151,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xfunctor_applier_base<D>::rend() const noexcept
+    inline auto xfunctor_applier_base<D>::rend() const
     {
         return this->template crend<L>();
     }
@@ -1161,7 +1162,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xfunctor_applier_base<D>::crbegin() const noexcept
+    inline auto xfunctor_applier_base<D>::crbegin() const
     {
         return xfunctor_iterator<const functor_type, decltype(m_e.template crbegin<L>())>(
             m_e.template crbegin<L>(),
@@ -1176,7 +1177,7 @@ namespace xt
      */
     template <class D>
     template <layout_type L>
-    inline auto xfunctor_applier_base<D>::crend() const noexcept
+    inline auto xfunctor_applier_base<D>::crend() const
     {
         return xfunctor_iterator<const functor_type, decltype(m_e.template crend<L>())>(
             m_e.template crend<L>(),
@@ -1199,7 +1200,7 @@ namespace xt
      */
     template <class D>
     template <class S, layout_type L>
-    inline auto xfunctor_applier_base<D>::rbegin(const S& shape) noexcept -> reverse_broadcast_iterator<S, L>
+    inline auto xfunctor_applier_base<D>::rbegin(const S& shape) -> reverse_broadcast_iterator<S, L>
     {
         return reverse_broadcast_iterator<S, L>(m_e.template rbegin<S, L>(shape), &m_functor);
     }
@@ -1213,7 +1214,7 @@ namespace xt
      */
     template <class D>
     template <class S, layout_type L>
-    inline auto xfunctor_applier_base<D>::rend(const S& shape) noexcept -> reverse_broadcast_iterator<S, L>
+    inline auto xfunctor_applier_base<D>::rend(const S& shape) -> reverse_broadcast_iterator<S, L>
     {
         return reverse_broadcast_iterator<S, L>(m_e.template rend<S, L>(shape), &m_functor);
     }
@@ -1227,7 +1228,7 @@ namespace xt
      */
     template <class D>
     template <class S, layout_type L>
-    inline auto xfunctor_applier_base<D>::rbegin(const S& shape) const noexcept
+    inline auto xfunctor_applier_base<D>::rbegin(const S& shape) const
         -> const_reverse_broadcast_iterator<S, L>
     {
         return crbegin<S, L>(shape);
@@ -1242,7 +1243,7 @@ namespace xt
      */
     template <class D>
     template <class S, layout_type L>
-    inline auto xfunctor_applier_base<D>::rend(const S& /*shape*/) const noexcept
+    inline auto xfunctor_applier_base<D>::rend(const S& /*shape*/) const
         -> const_reverse_broadcast_iterator<S, L>
     {
         return crend<S, L>();
@@ -1257,7 +1258,7 @@ namespace xt
      */
     template <class D>
     template <class S, layout_type L>
-    inline auto xfunctor_applier_base<D>::crbegin(const S& /*shape*/) const noexcept
+    inline auto xfunctor_applier_base<D>::crbegin(const S& /*shape*/) const
         -> const_reverse_broadcast_iterator<S, L>
     {
         return const_reverse_broadcast_iterator<S, L>(m_e.template crbegin<S, L>(), &m_functor);
@@ -1272,8 +1273,7 @@ namespace xt
      */
     template <class D>
     template <class S, layout_type L>
-    inline auto xfunctor_applier_base<D>::crend(const S& shape) const noexcept
-        -> const_reverse_broadcast_iterator<S, L>
+    inline auto xfunctor_applier_base<D>::crend(const S& shape) const -> const_reverse_broadcast_iterator<S, L>
     {
         return const_reverse_broadcast_iterator<S, L>(m_e.template crend<S, L>(shape), &m_functor);
     }
diff --git a/include/xtensor/views/xindex_view.hpp b/include/xtensor/views/xindex_view.hpp
index 6701d3bf3..c806c4908 100644
--- a/include/xtensor/views/xindex_view.hpp
+++ b/include/xtensor/views/xindex_view.hpp
@@ -818,7 +818,7 @@ namespace xt
      * \sa filtration
      */
     template <layout_type L = XTENSOR_DEFAULT_TRAVERSAL, class E, class O>
-    inline auto filter(E&& e, O&& condition) noexcept
+    inline auto filter(E&& e, O&& condition)
     {
         auto indices = argwhere<L>(std::forward<O>(condition));
         using view_type = xindex_view<xclosure_t<E>, decltype(indices)>;
diff --git a/include/xtensor/views/xslice.hpp b/include/xtensor/views/xslice.hpp
index 6cd2865a4..4e6fa611f 100644
--- a/include/xtensor/views/xslice.hpp
+++ b/include/xtensor/views/xslice.hpp
@@ -327,12 +327,12 @@ namespace xt
         xkeep_slice(std::initializer_list<S> t);
 
         template <std::convertible_to<T> S>
-        operator xkeep_slice<S>() const noexcept;
+        operator xkeep_slice<S>() const;
 
         // Same as implicit conversion operator but more convenient to call
         // from a variant visitor
         template <std::convertible_to<T> S>
-        xkeep_slice<S> convert() const noexcept;
+        xkeep_slice<S> convert() const;
 
         size_type operator()(size_type i) const noexcept;
         size_type size() const noexcept;
@@ -435,12 +435,12 @@ namespace xt
         xdrop_slice(std::initializer_list<S> t);
 
         template <std::convertible_to<T> S>
-        operator xdrop_slice<S>() const noexcept;
+        operator xdrop_slice<S>() const;
 
         // Same as implicit conversion operator but more convenient to call
         // from a variant visitor
         template <std::convertible_to<T> S>
-        xdrop_slice<S> convert() const noexcept;
+        xdrop_slice<S> convert() const;
 
         size_type operator()(size_type i) const noexcept;
         size_type size() const noexcept;
@@ -1310,7 +1310,7 @@ namespace xt
 
     template <class T>
     template <std::convertible_to<T> S>
-    inline xkeep_slice<T>::operator xkeep_slice<S>() const noexcept
+    inline xkeep_slice<T>::operator xkeep_slice<S>() const
     {
         xkeep_slice<S> ret;
         using us_type = typename container_type::size_type;
@@ -1340,7 +1340,7 @@ namespace xt
 
     template <class T>
     template <std::convertible_to<T> S>
-    inline xkeep_slice<S> xkeep_slice<T>::convert() const noexcept
+    inline xkeep_slice<S> xkeep_slice<T>::convert() const
     {
         return xkeep_slice<S>(*this);
     }
@@ -1454,7 +1454,7 @@ namespace xt
 
     template <class T>
     template <std::convertible_to<T> S>
-    inline xdrop_slice<T>::operator xdrop_slice<S>() const noexcept
+    inline xdrop_slice<T>::operator xdrop_slice<S>() const
     {
         xdrop_slice<S> ret;
         ret.m_raw_indices.resize(m_raw_indices.size());
@@ -1492,7 +1492,7 @@ namespace xt
 
     template <class T>
     template <std::convertible_to<T> S>
-    inline xdrop_slice<S> xdrop_slice<T>::convert() const noexcept
+    inline xdrop_slice<S> xdrop_slice<T>::convert() const
     {
         return xdrop_slice<S>(*this);
     }
diff --git a/test/test_xbuilder.cpp b/test/test_xbuilder.cpp
index d35847a8e..9fb5c5e4e 100644
--- a/test/test_xbuilder.cpp
+++ b/test/test_xbuilder.cpp
@@ -12,6 +12,7 @@
 #endif
 
 #include <sstream>
+#include <stdexcept>
 
 #include "xtensor/containers/xarray.hpp"
 #include "xtensor/containers/xfixed.hpp"
@@ -706,4 +707,20 @@ namespace xt
         b = std::is_same<decltype(ed3), xarray<double>>::value;
         EXPECT_TRUE(b);
     }
+
+    TEST(xbuilder, meshgrid_broadcast_error)
+    {
+        xarray<int> a = {1, 2, 3};
+        xarray<int> b = {1, 2};
+        XT_EXPECT_THROW(meshgrid(a + b, a), broadcast_error);
+    }
+
+#ifdef XTENSOR_ENABLE_ASSERT
+    TEST(xbuilder, arange_fixed_shape_mismatch)
+    {
+        xtensor_fixed<int, xshape<3>> a;
+        XT_EXPECT_THROW(a = arange(5), std::runtime_error);
+    }
+#endif
+
 }
diff --git a/test/test_xcomplex.cpp b/test/test_xcomplex.cpp
index 920d21b8e..0a2547dd6 100644
--- a/test/test_xcomplex.cpp
+++ b/test/test_xcomplex.cpp
@@ -356,4 +356,16 @@ namespace xt
         xtensor<double, 1> exp_im = {double(1), double(1), double(-2)};
         EXPECT_EQ(im, exp_im);
     }
+
+    TEST(xcomplex, broadcast_error)
+    {
+        using cpx = std::complex<double>;
+        xarray<cpx> a = {cpx(1., 1.), cpx(2., 2.), cpx(3., 3.)};
+        xarray<cpx> b = {cpx(1., 1.), cpx(2., 2.)};
+        XT_EXPECT_THROW(real(a + b).shape(), broadcast_error);
+        xarray<double> c = {1., 2., 3.};
+        xarray<double> d = {1., 2.};
+        XT_EXPECT_THROW(imag(c + d), broadcast_error);
+    }
+
 }
diff --git a/test/test_xfunction.cpp b/test/test_xfunction.cpp
index ddf08758c..1fd27c304 100644
--- a/test/test_xfunction.cpp
+++ b/test/test_xfunction.cpp
@@ -515,4 +515,15 @@ namespace xt
         xtensor<Point3, 1> res{r1, r2, r3};
         EXPECT_EQ(c, res);
     }
+
+    TEST(xfunction, iterator_broadcast_error)
+    {
+        xarray<int> a = {1, 2, 3};
+        xarray<int> b = {1, 2};
+        auto f = a + b;
+        XT_EXPECT_THROW(f.begin(), broadcast_error);
+        XT_EXPECT_THROW(f.cend(), broadcast_error);
+        XT_EXPECT_THROW(f.rbegin(), broadcast_error);
+    }
+
 }
diff --git a/test/test_xindex_view.cpp b/test/test_xindex_view.cpp
index cdf22c1f6..0e959cc54 100644
--- a/test/test_xindex_view.cpp
+++ b/test/test_xindex_view.cpp
@@ -187,4 +187,12 @@ namespace xt
         xarray<double> expected = {{1, 2, 3}, {5, 7, 9}};
         EXPECT_EQ(expected, b);
     }
+
+    TEST(xindex_view, filter_broadcast_error)
+    {
+        xarray<double> a = {1., 2., 3.};
+        xarray<double> b = {1., 2.};
+        XT_EXPECT_THROW(filter(a, a > b), broadcast_error);
+    }
+
 }
diff --git a/test/test_xmanipulation.cpp b/test/test_xmanipulation.cpp
index 32f5d4370..f93293758 100644
--- a/test/test_xmanipulation.cpp
+++ b/test/test_xmanipulation.cpp
@@ -637,4 +637,12 @@ namespace xt
     TEST(xmanipulation, zzzzzz)
     {
     }
+
+    TEST(xmanipulation, transpose_broadcast_error)
+    {
+        xarray<int> a = {1, 2, 3};
+        xarray<int> b = {1, 2};
+        XT_EXPECT_THROW(transpose(a + b), broadcast_error);
+    }
+
 }
diff --git a/test/test_xmath.cpp b/test/test_xmath.cpp
index 57771859b..520ffa8ed 100644
--- a/test/test_xmath.cpp
+++ b/test/test_xmath.cpp
@@ -1025,4 +1025,12 @@ namespace xt
         xt::xtensor<double, 1> expected_sums = {1.0, 1.0};
         EXPECT_TRUE(xt::allclose(row_sums, expected_sums));
     }
+
+    TEST(xmath, allclose_broadcast_error)
+    {
+        xarray<double> a = {1., 2., 3.};
+        xarray<double> b = {1., 2.};
+        XT_EXPECT_THROW(allclose(a, b), broadcast_error);
+    }
+
 }
diff --git a/test/test_xnorm.cpp b/test/test_xnorm.cpp
index 632114530..f32b15462 100644
--- a/test/test_xnorm.cpp
+++ b/test/test_xnorm.cpp
@@ -185,4 +185,13 @@ namespace xt
         EXPECT_EQ(norm_induced_l1(a, evaluation_strategy::immediate)(), 6.0);
         EXPECT_EQ(norm_induced_linf(a, evaluation_strategy::immediate)(), 7.0);
     }
+
+    TEST(xnorm, invalid_axis)
+    {
+        xarray<double> a = {1., 2., 3.};
+        XT_EXPECT_ANY_THROW(norm_l1(a, {1}));
+        XT_EXPECT_ANY_THROW(norm_l2(a, {1}));
+        XT_EXPECT_ANY_THROW(norm_lp_to_p(a, 3., {1}));
+    }
+
 }  // namespace xt
diff --git a/test/test_xset_operation.cpp b/test/test_xset_operation.cpp
index 07cbde18d..8d3c6da3d 100644
--- a/test/test_xset_operation.cpp
+++ b/test/test_xset_operation.cpp
@@ -8,6 +8,7 @@
  ****************************************************************************/
 
 #include <cstddef>
+#include <stdexcept>
 
 #include "xtensor/containers/xarray.hpp"
 #include "xtensor/containers/xtensor.hpp"
@@ -25,6 +26,7 @@ namespace xt
         EXPECT_EQ(xt::isin(a, b), res);
         EXPECT_EQ(xt::isin(a, b.begin(), b.end()), res);
         EXPECT_EQ(xt::isin(a, {1, 2}), res);
+        EXPECT_EQ(xt::isin(a, xt::xtensor<int, 1>({1, 2})), res);
     }
 
     TEST(xset_operation, in1d)
@@ -37,6 +39,17 @@ namespace xt
         EXPECT_EQ(xt::in1d(a, {1, 2}), res);
     }
 
+#ifdef XTENSOR_ENABLE_ASSERT
+    TEST(xset_operation, in1d_not_1d)
+    {
+        xt::xtensor<int, 2> a = {{1, 2}, {3, 4}};
+        xt::xtensor<int, 1> b = {1, 2};
+        XT_EXPECT_THROW(xt::in1d(a, b), std::runtime_error);
+        XT_EXPECT_THROW(xt::in1d(a, b.begin(), b.end()), std::runtime_error);
+        XT_EXPECT_THROW(xt::in1d(a, {1, 2}), std::runtime_error);
+    }
+#endif
+
     TEST(xset_operation, searchsorted)
     {
         xt::xtensor<size_t, 1> a = {1, 2, 7, 8, 20};
diff --git a/test/test_xshape.cpp b/test/test_xshape.cpp
index a00db785e..5af4c6d3e 100644
--- a/test/test_xshape.cpp
+++ b/test/test_xshape.cpp
@@ -66,4 +66,12 @@ namespace xt
         ASSERT_TRUE(xt::has_shape(A, shape));
         ASSERT_TRUE(xt::has_shape(A, {2, 3}));
     }
+
+    TEST(xshape, has_shape_broadcast_error)
+    {
+        xarray<int> a = {1, 2, 3};
+        xarray<int> b = {1, 2};
+        XT_EXPECT_THROW(has_shape(a + b, {3}), broadcast_error);
+    }
+
 }