add Box::(try_)map

Author: Qelxiros

library/alloc/src/boxed.rs

@@ -192,11 +192,15 @@ use core::fmt;
 use core::future::Future;
 use core::hash::{Hash, Hasher};
 use core::marker::{Tuple, Unsize};
+#[cfg(not(no_global_oom_handling))]
+use core::mem::MaybeUninit;
 use core::mem::{self, SizedTypeProperties};
 use core::ops::{
     AsyncFn, AsyncFnMut, AsyncFnOnce, CoerceUnsized, Coroutine, CoroutineState, Deref, DerefMut,
     DerefPure, DispatchFromDyn, LegacyReceiver,
 };
+#[cfg(not(no_global_oom_handling))]
+use core::ops::{Residual, Try};
 use core::pin::{Pin, PinCoerceUnsized};
 use core::ptr::{self, NonNull, Unique};
 use core::task::{Context, Poll};
@@ -389,6 +393,84 @@ impl<T> Box<T> {
     pub fn try_new_zeroed() -> Result<Box<mem::MaybeUninit<T>>, AllocError> {
         Box::try_new_zeroed_in(Global)
     }
+
+    /// Maps the value in a box, reusing the allocation if possible.
+    ///
+    /// `f` is called on the value in the box, and the result is returned, also boxed.
+    ///
+    /// Note: this is an associated function, which means that you have
+    /// to call it as `Box::map(b, f)` instead of `b.map(f)`. This
+    /// is so that there is no conflict with a method on the inner type.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(smart_pointer_try_map)]
+    ///
+    /// let b = Box::new(7);
+    /// let new = Box::map(b, |i| i + 7);
+    /// assert_eq!(*new, 14);
+    /// ```
+    #[cfg(not(no_global_oom_handling))]
+    #[unstable(feature = "smart_pointer_try_map", issue = "144419")]
+    pub fn map<U>(this: Self, f: impl FnOnce(T) -> U) -> Box<U> {
+        if size_of::<T>() == size_of::<U>() && align_of::<T>() == align_of::<U>() {
+            let (allocation, value) = unsafe {
+                let ptr = Box::into_raw(this);
+                let value = ptr.read();
+                let allocation = Box::from_raw(ptr.cast::<MaybeUninit<U>>());
+                (allocation, value)
+            };
+
+            Box::write(allocation, f(value))
+        } else {
+            Box::new(f(*this))
+        }
+    }
+
+    /// Attempts to map the value in a box, reusing the allocation if possible.
+    ///
+    /// `f` is called on the value in the box, and if the operation succeeds, the result is
+    /// returned, also boxed.
+    ///
+    /// Note: this is an associated function, which means that you have
+    /// to call it as `Box::try_map(b, f)` instead of `b.try_map(f)`. This
+    /// is so that there is no conflict with a method on the inner type.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(smart_pointer_try_map)]
+    ///
+    /// let b = Box::new(7);
+    /// let new = Box::try_map(b, u32::try_from).unwrap();
+    /// assert_eq!(*new, 7);
+    /// ```
+    #[cfg(not(no_global_oom_handling))]
+    #[unstable(feature = "smart_pointer_try_map", issue = "144419")]
+    pub fn try_map<R>(
+        this: Self,
+        f: impl FnOnce(T) -> R,
+    ) -> <R::Residual as Residual<Box<R::Output>>>::TryType
+    where
+        R: Try,
+        R::Residual: Residual<Box<R::Output>>,
+    {
+        if size_of::<T>() == size_of::<R::Output>() && align_of::<T>() == align_of::<R::Output>() {
+            let (allocation, value) = unsafe {
+                let ptr = Box::into_raw(this);
+                let value = ptr.read();
+                let allocation = Box::from_raw(ptr.cast::<MaybeUninit<R::Output>>());
+                (allocation, value)
+            };
+            <R::Residual as Residual<Box<R::Output>>>::TryType::from_output(Box::write(
+                allocation,
+                f(value)?,
+            ))
+        } else {
+            <R::Residual as Residual<Box<R::Output>>>::TryType::from_output(Box::new(f(*this)?))
+        }
+    }
 }
 
 impl<T, A: Allocator> Box<T, A> {

library/alloc/src/lib.rs

@@ -153,6 +153,7 @@
 #![feature(trusted_len)]
 #![feature(trusted_random_access)]
 #![feature(try_trait_v2)]
+#![feature(try_trait_v2_residual)]
 #![feature(try_with_capacity)]
 #![feature(tuple_trait)]
 #![feature(ub_checks)]

tests/ui/parallel-rustc/ty-variance-issue-124423.stderr

@@ -278,10 +278,9 @@ note: if you're trying to build a new `Box<_, _>` consider using one of the foll
       Box::<T>::new_uninit
       Box::<T>::new_zeroed
       Box::<T>::try_new
-      and 22 others
   --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
 
 error: aborting due to 30 previous errors
 
 Some errors have detailed explanations: E0121, E0224, E0261, E0412, E0599.
-For more information about an error, try `rustc --explain E0121`.
+For more information about an error, try `rustc --explain E0121`.

tests/ui/parallel-rustc/ty-variance-issue-127971.stderr

@@ -104,10 +104,9 @@ note: if you're trying to build a new `Box<_, _>` consider using one of the foll
       Box::<T>::new_uninit
       Box::<T>::new_zeroed
       Box::<T>::try_new
-      and 22 others
   --> $SRC_DIR/alloc/src/boxed.rs:LL:COL
 
 error: aborting due to 11 previous errors
 
 Some errors have detailed explanations: E0121, E0224, E0261, E0599.
-For more information about an error, try `rustc --explain E0121`.
+For more information about an error, try `rustc --explain E0121`.

tests/ui/privacy/suggest-box-new.stderr

@@ -63,7 +63,7 @@ LL -             x: (),
 LL -         })),
 LL +         wtf: Some(Box::new_in(_, _)),
    |
-   = and 12 other candidates
+   = and 13 other candidates
 help: consider using the `Default` trait
    |
 LL -         wtf: Some(Box(U {
@@ -118,7 +118,7 @@ LL +     let _ = Box::new_zeroed();
 LL -     let _ = Box {};
 LL +     let _ = Box::new_in(_, _);
    |
-   = and 13 other candidates
+   = and 14 other candidates
 help: consider using the `Default` trait
    |
 LL -     let _ = Box {};
@@ -141,12 +141,12 @@ LL -     let _ = Box::<i32> {};
 LL +     let _ = Box::<i32>::new_in(_, _);
    |
 LL -     let _ = Box::<i32> {};
-LL +     let _ = Box::<i32>::into_inner(_);
+LL +     let _ = Box::<i32>::map(_, _);
    |
 LL -     let _ = Box::<i32> {};
-LL +     let _ = Box::<i32>::write(_, _);
+LL +     let _ = Box::<i32>::into_inner(_);
    |
-   = and 4 other candidates
+   = and 5 other candidates
 help: consider using the `Default` trait
    |
 LL -     let _ = Box::<i32> {};

tests/ui/suggestions/multi-suggestion.ascii.stderr

@@ -63,7 +63,7 @@ LL -             x: (),
 LL -         })),
 LL +         wtf: Some(Box::new_in(_, _)),
    |
-   = and 12 other candidates
+   = and 13 other candidates
 help: consider using the `Default` trait
    |
 LL -         wtf: Some(Box(U {
@@ -118,7 +118,7 @@ LL +     let _ = Box::new_zeroed();
 LL -     let _ = Box {};
 LL +     let _ = Box::new_in(_, _);
    |
-   = and 13 other candidates
+   = and 14 other candidates
 help: consider using the `Default` trait
    |
 LL -     let _ = Box {};

tests/ui/suggestions/multi-suggestion.unicode.stderr

@@ -63,7 +63,7 @@ LL -             x: (),
 LL -         })),
 LL +         wtf: Some(Box::new_in(_, _)),
    │
-   ╰ and 12 other candidates
+   ╰ and 13 other candidates
 help: consider using the `Default` trait
    ╭╴
 LL -         wtf: Some(Box(U {
@@ -118,7 +118,7 @@ LL +     let _ = Box::new_zeroed();
 LL -     let _ = Box {};
 LL +     let _ = Box::new_in(_, _);
    │
-   ╰ and 13 other candidates
+   ╰ and 14 other candidates
 help: consider using the `Default` trait
    ╭╴
 LL -     let _ = Box {};