Add 'with()' and 'with_mut()' as associated functions to ErasedPtr

This allows one to use ErasedPtr where rust won't allow a typed reference. For example in
recursive types.

Author: cehteh

crates/erasable/src/lib.rs

@@ -185,6 +185,54 @@ pub unsafe trait ErasablePtr {
     ///
     /// The erased pointer must have been created by `erase`.
     unsafe fn unerase(this: ErasedPtr) -> Self;
+
+    /// Run a closure on a borrow of the real pointer.  Unlike the `Thin<T>` wrapper this does
+    /// not carry the original type around. Thus it is required to specify the original impl
+    /// type when calling this function.
+    ///
+    /// ```
+    /// # use {erasable::*, std::rc::Rc};
+    /// let rc: Rc<i32> = Rc::new(123);
+    ///
+    /// let erased: ErasedPtr = ErasablePtr::erase(rc);
+    ///
+    /// let cloned = unsafe {
+    ///     <Rc<i32> as ErasablePtr>::with(&erased, |rc| rc.clone())
+    /// };
+    ///
+    /// assert_eq!(*cloned, 123);
+    /// ```
+    ///
+    /// The main purpose of this function is to be able implement recursive types that would
+    /// be otherwise not representable in rust.
+    ///
+    /// # Safety
+    ///
+    ///  * The erased pointer must have been created by `erase`.
+    ///  * The specified impl type must be the original type.
+    unsafe fn with<F, T>(this: &ErasedPtr, f: F) -> T
+    where
+        Self: Sized,
+        F: FnOnce(&Self) -> T,
+    {
+        f(&ManuallyDrop::new(&Self::unerase(*this)))
+    }
+
+    /// Run a closure on a mutable borrow of the real pointer.  Unlike the `Thin<T>` wrapper
+    /// this does not carry the original type around. Thus it is required to specify the
+    /// original impl type when calling this function.
+    ///
+    /// # Safety
+    ///
+    ///  * The erased pointer must have been created by `erase`.
+    ///  * The specified impl type must be the original type.
+    unsafe fn with_mut<F, T>(this: &mut ErasedPtr, f: F) -> T
+    where
+        Self: Sized,
+        F: FnOnce(&mut Self) -> T,
+    {
+        f(&mut ManuallyDrop::new(&mut Self::unerase(*this)))
+    }
 }
 
 /// A pointee type that supports type-erased pointers (thin pointers).

crates/erasable/tests/smoke.rs

@@ -32,3 +32,30 @@ fn thinning() {
     Thin::with_mut(&mut thin, |thin| *thin = Default::default());
     let boxed = Thin::into_inner(thin);
 }
+
+#[test]
+fn withfn() {
+    let boxed: Box<Big> = Default::default();
+
+    let erased: ErasedPtr = ErasablePtr::erase(boxed);
+
+    unsafe {
+        <Box<Big> as ErasablePtr>::with(&erased, |bigbox| {
+            assert_eq!(*bigbox, Default::default());
+        })
+    }
+}
+
+#[test]
+fn with_mut_fn() {
+    let boxed: Box<Big> = Default::default();
+
+    let mut erased: ErasedPtr = ErasablePtr::erase(boxed);
+
+    unsafe {
+        <Box<Big> as ErasablePtr>::with_mut(&mut erased, |bigbox| {
+            bigbox.0[0] = 123456;
+            assert_ne!(*bigbox, Default::default());
+        })
+    }
+}