feat: Add lambda_argument and printable_value utilities for enhanced value handling

Co-authored-by: Copilot <copilot@github.com>

Author: Alex-PLACET

include/xtensor/core/xmath.hpp

@@ -1185,6 +1185,19 @@ namespace xt
         {
         };
 
+        template <typename T>
+        inline decltype(auto) lambda_argument(T&& value)
+        {
+            if constexpr (xtl::is_xmasked_value<std::decay_t<T>>::value)
+            {
+                return +value;
+            }
+            else
+            {
+                return std::forward<T>(value);
+            }
+        }
+
         template <class F>
         struct lambda_adapt
         {
@@ -1194,15 +1207,15 @@ namespace xt
             }
 
             template <class... T>
-            auto operator()(T... args) const
+            auto operator()(T&&... args) const
             {
-                return m_lambda(args...);
+                return m_lambda(lambda_argument(std::forward<T>(args))...);
             }
 
             template <class... T, XTL_REQUIRES(detail::supports<F(T...)>)>
-            auto simd_apply(T... args) const
+            auto simd_apply(T&&... args) const
             {
-                return m_lambda(args...);
+                return m_lambda(lambda_argument(std::forward<T>(args))...);
             }
 
             F m_lambda;
@@ -1290,30 +1303,32 @@ namespace xt
         struct pow_impl
         {
             template <class T>
-            auto operator()(T v) const -> decltype(v * v)
+            auto operator()(T&& v) const
             {
-                T temp = pow_impl<N / 2>{}(v);
-                return temp * temp * pow_impl<N & 1>{}(v);
+                auto value = lambda_argument(std::forward<T>(v));
+                auto temp = pow_impl<N / 2>{}(value);
+                return temp * temp * pow_impl<N & 1>{}(value);
             }
         };
 
         template <>
         struct pow_impl<1>
         {
             template <class T>
-            auto operator()(T v) const -> T
+            decltype(auto) operator()(T&& v) const
             {
-                return v;
+                return lambda_argument(std::forward<T>(v));
             }
         };
 
         template <>
         struct pow_impl<0>
         {
             template <class T>
-            auto operator()(T /*v*/) const -> T
+            auto operator()(T&& v) const
             {
-                return T(1);
+                using value_type = std::decay_t<decltype(lambda_argument(std::forward<T>(v)))>;
+                return value_type(1);
             }
         };
     }

include/xtensor/io/xio.hpp

@@ -186,6 +186,18 @@ namespace xt
 
     namespace detail
     {
+        template <typename T, typename B>
+        inline auto printable_value(const xtl::xmasked_value<T, B>& value)
+        {
+            return +value;
+        }
+
+        template <typename T>
+        inline const T& printable_value(const T& value)
+        {
+            return value;
+        }
+
         template <class E, class F>
         std::ostream& xoutput(
             std::ostream& out,
@@ -647,14 +659,7 @@ namespace xt
             void update(const_reference val)
             {
                 std::stringstream buf;
-                if constexpr (xtl::is_xmasked_value<value_type>::value)
-                {
-                    buf << +val;
-                }
-                else
-                {
-                    buf << val;
-                }
+                buf << printable_value(val);
                 std::string s = buf.str();
                 if (int(s.size()) > m_width)
                 {