unsafe fn take_inner(&mut self) -> Option<T> {
        // The mutable reference guarantees there are no other threads that can observe us
        // taking out the wrapped value.
        // Right after this function `self` is supposed to be freed, so it makes little sense
        // to atomically set the state to uninitialized.
        if self.is_initialized() {
            let value = mem::replace(&mut self.value, UnsafeCell::new(MaybeUninit::uninit()));
            Some(value.into_inner().assume_init())
        } else {
            None
        }
    }
/// Takes the wrapped value out of a `SyncOnceCell`.
/// Afterwards the cell is no longer initialized.
///
/// Safety: The cell must now be free'd WITHOUT dropping. No other usages of the cell
/// are valid. Only used by `into_inner` and `drop`.
Takes the wrapped value out of a `SyncOnceCell`.
Afterwards the cell is no longer initialized.

The cell must now be free'd WITHOUT dropping. No other usages of the cell
are valid. Only used by `into_inner` and `drop`.
Takes the wrapped value out of a ` SyncOnceCell ` . Afterwards the cell is no longer initialized . The cell must now be free ' d WITHOUT dropping . No other usages of the cell are valid . Only used by ` into_inner ` and ` drop ` .
unsafe fn take_inner(&mut self) -> Option<T> {
        // The mutable reference guarantees there are no other threads that can observe us
        // taking out the wrapped value.
        // Right after this function `self` is supposed to be freed, so it makes little sense
        // to atomically set the state to uninitialized.
        if self.is_initialized() {
            let value = mem::replace(&mut self.value, UnsafeCell::new(MaybeUninit::uninit()));
            Some(value.into_inner().assume_init())
        } else {
            None
        }
    }
unsafe fn take_inner ( & mut self ) -> Option < T > { // The mutable reference guarantees there are no other threads that can observe us // taking out the wrapped value. // Right after this function `self` is supposed to be freed, so it makes little sense // to atomically set the state to uninitialized. if self . is_initialized ( ) { let value = mem :: replace ( & mut self . value , UnsafeCell :: new ( MaybeUninit :: uninit ( ) ) ) ; Some ( value . into_inner ( ) . assume_init ( ) ) } else { None } }
Takes the wrapped value out of a `SyncOnceCell`.
Takes the wrapped value out of a ` SyncOnceCell ` .
&mut self