pub fn guard<T, F>(value: T, dropfn: F) -> ScopeGuard<T, F>

where

    F: FnMut(&mut T),

{

    ScopeGuard { dropfn, value }

}

    pub fn into_inner(guard: Self) -> T {

        // Cannot move out of Drop-implementing types, so

        // ptr::read the value and forget the guard.

        unsafe {

            let value = ptr::read(&guard.value);

            // read the closure so that it is dropped, and assign it to a local

            // variable to ensure that it is only dropped after the guard has

            // been forgotten. (In case the Drop impl of the closure, or that

            // of any consumed captured variable, panics).

            let _dropfn = ptr::read(&guard.dropfn);

            mem::forget(guard);

            value

        }

    }

    fn deref(&self) -> &T {

        &self.value

    }

    fn deref_mut(&mut self) -> &mut T {

        &mut self.value

    }

    fn drop(&mut self) {

        (self.dropfn)(&mut self.value);

    }