pub fn from_rc(rc: Rc<T>) -> Self {
        let p = Rc::as_ptr(&rc) as *mut T;
        // SAFETY: The pointer was returned by `Rc::as_ptr` and so is not null
        unsafe {
            Self {
                data: NonNull::new_unchecked(p),
                alloc: rc,
            }
        }
    }
/// Creates a new `Mrc` from an [`Rc`] that shares ownership of the `Rc`'s data.
///
/// Like [`Mrc::new`], this method requires `T: Sized + 'static`. If you have an
/// `Rc<T>` where `T: ?Sized`, then you can create an `Mrc<T>` via [`Mrc::from_borrow`].
///
/// As long as the returned `Mrc` is alive, the strong count of the `Rc` will be at least one.
/// This is also the case if any `Mrc`'s derived from the return value via [`Clone`] and
/// [`Mrc::map`] are alive. The strong count of the input `Rc` could be observed by another `Rc`
/// also sharing ownership of the data. It is not specified whether clones of the return value
/// will be reflected in that strong count.
///
/// This function is essentially free to call. After inlining, it will consist of one to two
/// pointer copies.


As long as the returned `Mrc` is alive, the strong count of the `Rc` will be at least one.

This function is essentially free to call. After inlining, it will consist of one to two
pointer copies.
As long as the returned ` Mrc ` is alive the strong count of the ` Rc ` will be at least one . This function is essentially free to call . After inlining it will consist of one to two pointer copies .
pub fn from_rc(rc: Rc<T>) -> Self {
        let p = Rc::as_ptr(&rc) as *mut T;
        // SAFETY: The pointer was returned by `Rc::as_ptr` and so is not null
        unsafe {
            Self {
                data: NonNull::new_unchecked(p),
                alloc: rc,
            }
        }
    }
pub fn from_rc ( rc : Rc < T > ) -> Self { let p = Rc :: as_ptr ( & rc ) as * mut T ; // SAFETY: The pointer was returned by `Rc::as_ptr` and so is not null unsafe { Self { data : NonNull :: new_unchecked ( p ) , alloc : rc , } } }
Creates a new `Mrc` from an [`Rc`] that shares ownership of the `Rc`'s data.
Creates a new ` Mrc ` from an [ ` Rc ` ] that shares ownership of the ` Rc ` ' s data .
rc
Rc<T>
rc
Rc<T>