Merge branch 'main'

Author: loichyan

CHANGELOG.md

@@ -40,6 +40,10 @@ follows <https://www.conventionalcommits.org/en/v1.0.0/> to track changes.
 ### Added
 
 - Add a helper macro `#[dynify]` for trait transformations ({{PRNUM}}).
+- Support downcasting a `Buffered` pointer (#10).
+
+[#10]: https://github.com/loichyan/dynify/pull/10
+[{{PRNUM}}]: https://github.com/loichyan/dynify/pull/{{PRNUM}}
 
 ## [0.1.0] - 2025-07-06
 

src/constructor.rs

@@ -209,7 +209,7 @@ impl<T: ?Sized> Opaque<T> {
 pub trait Dynify: Construct {
     /// Constructs the object in the supplied container.
     ///
-    /// For non-panicking variant, use [`try_init`](Self::try_init).
+    /// For a non-panicking alternative see [`try_init`](Self::try_init).
     ///
     /// # Panic
     ///
@@ -245,7 +245,7 @@ pub trait Dynify: Construct {
 
     /// Constructs the object in two containers in turn.
     ///
-    /// For non-panicking variant, use [`try_init2`](Self::try_init2).
+    /// For a non-panicking alternative see [`try_init2`](Self::try_init2).
     ///
     /// # Examples
     ///
@@ -302,7 +302,7 @@ impl<T: Construct> Dynify for T {}
 pub trait PinDynify: PinConstruct {
     /// Constructs the object in the supplied container.
     ///
-    /// For non-panicking variant, use [`try_pin_init`](Self::try_pin_init).
+    /// For a non-panicking alternative see [`try_pin_init`](Self::try_pin_init).
     ///
     /// # Panic
     ///
@@ -338,7 +338,7 @@ pub trait PinDynify: PinConstruct {
 
     /// Constructs the object in two containers in turn.
     ///
-    /// For non-panicking variant, use [`try_pin_init2`](Self::try_pin_init2).
+    /// For a non-panicking alternative see [`try_pin_init2`](Self::try_pin_init2).
     ///
     /// # Panic
     ///

src/container.rs

@@ -1,4 +1,5 @@
 use core::alloc::Layout;
+use core::any::Any;
 use core::fmt;
 use core::marker::PhantomData;
 use core::mem::MaybeUninit;
@@ -143,6 +144,69 @@ impl<'a, T: ?Sized> Buffered<'a, T> {
         }
     }
 }
+impl<'a> Buffered<'a, dyn Any> {
+    /// Attempts to downcast the pointer to a concrete type.
+    pub fn downcast<T: Any>(self) -> Result<Buffered<'a, T>, Self> {
+        if self.is::<T>() {
+            unsafe { Ok(self.downcast_unchecked()) }
+        } else {
+            Err(self)
+        }
+    }
+
+    /// Downcasts the box to a concrete type.
+    ///
+    /// For a safe alternative see [`downcast`](Self::downcast).
+    ///
+    /// # Safety
+    ///
+    /// The contained value must be of type `T`.
+    pub unsafe fn downcast_unchecked<T: Any>(self) -> Buffered<'a, T> {
+        Buffered::from_raw(self.into_raw().cast())
+    }
+}
+impl<'a> Buffered<'a, dyn Any + Send> {
+    /// Attempts to downcast the pointer to a concrete type.
+    pub fn downcast<T: Any>(self) -> Result<Buffered<'a, T>, Self> {
+        if self.is::<T>() {
+            unsafe { Ok(self.downcast_unchecked()) }
+        } else {
+            Err(self)
+        }
+    }
+
+    /// Downcasts the box to a concrete type.
+    ///
+    /// For a safe alternative see [`downcast`](Self::downcast).
+    ///
+    /// # Safety
+    ///
+    /// The contained value must be of type `T`.
+    pub unsafe fn downcast_unchecked<T: Any>(self) -> Buffered<'a, T> {
+        Buffered::from_raw(self.into_raw().cast())
+    }
+}
+impl<'a> Buffered<'a, dyn Any + Send + Sync> {
+    /// Attempts to downcast the pointer to a concrete type.
+    pub fn downcast<T: Any>(self) -> Result<Buffered<'a, T>, Self> {
+        if self.is::<T>() {
+            unsafe { Ok(self.downcast_unchecked()) }
+        } else {
+            Err(self)
+        }
+    }
+
+    /// Downcasts the box to a concrete type.
+    ///
+    /// For a safe alternative see [`downcast`](Self::downcast).
+    ///
+    /// # Safety
+    ///
+    /// The contained value must be of type `T`.
+    pub unsafe fn downcast_unchecked<T: Any>(self) -> Buffered<'a, T> {
+        Buffered::from_raw(self.into_raw().cast())
+    }
+}
 
 // Pretend `Buffered` owns the value of `T` rather than just a pointer to it.
 // This, along with the `Buffered::project*` APIs, makes it easy to obtain a

src/container_tests.rs

@@ -8,7 +8,7 @@ use smallvec::SmallVec;
 
 use super::*;
 use crate::utils::*;
-use crate::{from_closure, Dynify};
+use crate::{from_closure, Dynify, Opaque};
 
 trait DebugEmplace: Emplace<dyn Any, Err = Self::__Err> {
     type __Err: std::fmt::Debug;
@@ -177,3 +177,29 @@ fn clean_up_boxed_zst_on_panic() {
 fn clean_up_boxed_on_panic() {
     let _ = from_closure::<usize, usize, _>(|_| panic!("just panic")).boxed();
 }
+
+#[rstest]
+#[case(fastrand::i32(..))]
+#[case(randstr(16..32))]
+fn downcast_buffered<T>(#[case] data: T)
+where
+    T: Any + Clone + core::fmt::Debug + Eq + Send + Sync,
+{
+    struct Impossbile;
+    let mut stack = newstk::<32>();
+
+    let init = from_closure(|slot| slot.write(data.clone()) as &mut Opaque<dyn Any>);
+    let val = stack.emplace(init).unwrap();
+    let val = val.downcast::<Impossbile>().err().unwrap();
+    assert_eq!(val.downcast().ok().as_deref(), Some(&data));
+
+    let init = from_closure(|slot| slot.write(data.clone()) as &mut Opaque<dyn Any + Send>);
+    let val = stack.emplace(init).unwrap();
+    let val = val.downcast::<Impossbile>().err().unwrap();
+    assert_eq!(val.downcast().ok().as_deref(), Some(&data));
+
+    let init = from_closure(|slot| slot.write(data.clone()) as &mut Opaque<dyn Any + Send + Sync>);
+    let val = stack.emplace(init).unwrap();
+    let val = val.downcast::<Impossbile>().err().unwrap();
+    assert_eq!(val.downcast().ok().as_deref(), Some(&data));
+}

src/lib.md

@@ -137,3 +137,5 @@ have these concerns, it's better to go with the battle tested async-trait.
 - **smallvec**: Enable container implementations for `SmallVec`, a drop-in
   replacement for `[u8; N] + Vec<u8>`.
 - **macros**: Enable helpful procedural macros.
+
+[`SmallVec`]: smallvec::SmallVec