pub fn uninitialized_array(&self) -> *mut [MaybeUninit<T>] {
        let mut chunks = self.chunks.borrow_mut();
        let len = chunks.current.capacity() - chunks.current.len();
        let next_item_index = chunks.current.len();

        unsafe {
        // Go through pointers, to make sure we never create a reference to uninitialized T.
            let start = chunks.current.as_mut_ptr().offset(next_item_index as isize);
            let start_uninit = start as *mut MaybeUninit<T>;
            slice::from_raw_parts_mut(start_uninit, len) as *mut _
        }
    }
/// Returns unused space.
///
/// *This unused space is still not considered "allocated".* Therefore, it
/// won't be dropped unless there are further calls to `alloc`,
/// [`alloc_uninitialized`][Arena::alloc_uninitialized], or
/// [`alloc_extend`][Arena::alloc_extend] which is why the method is safe.
///
/// It returns a raw pointer to avoid creating multiple mutable references to the same place.
/// It is up to the caller not to dereference it after any of the `alloc_` methods are called.
Returns unused space.

It returns a raw pointer to avoid creating multiple mutable references to the same place.
It is up to the caller not to dereference it after any of the `alloc_` methods are called.
Returns unused space . It returns a raw pointer to avoid creating multiple mutable references to the same place . It is up to the caller not to dereference it after any of the ` alloc_ ` methods are called .
pub fn uninitialized_array(&self) -> *mut [MaybeUninit<T>] {
        let mut chunks = self.chunks.borrow_mut();
        let len = chunks.current.capacity() - chunks.current.len();
        let next_item_index = chunks.current.len();
        unsafe {
        // Go through pointers, to make sure we never create a reference to uninitialized T.
            let start = chunks.current.as_mut_ptr().offset(next_item_index as isize);
            let start_uninit = start as *mut MaybeUninit<T>;
            slice::from_raw_parts_mut(start_uninit, len) as *mut _
        }
    }
pub fn uninitialized_array ( & self ) -> * mut [ MaybeUninit < T > ] { let mut chunks = self . chunks . borrow_mut ( ) ; let len = chunks . current . capacity ( ) - chunks . current . len ( ) ; let next_item_index = chunks . current . len ( ) ; unsafe { // Go through pointers, to make sure we never create a reference to uninitialized T. let start = chunks . current . as_mut_ptr ( ) . offset ( next_item_index as isize ) ; let start_uninit = start as * mut MaybeUninit < T > ; slice :: from_raw_parts_mut ( start_uninit , len ) as * mut _ } }
Returns unused space.
Returns unused space .
&self
&self