Struct DropGuard

pub struct DropGuard<T, F>
where
    F: FnOnce(T),
{ /* private fields */ }

🔬This is a nightly-only experimental API. (drop_guard)

Wrap a value and run a closure when dropped.

This is useful for quickly creating destructors inline.

Examples

#![feature(drop_guard)]

use std::mem::DropGuard;

{
    // Create a new guard around a string that will
    // print its value when dropped.
    let s = String::from("Chashu likes tuna");
    let mut s = DropGuard::new(s, |s| println!("{s}"));

    // Modify the string contained in the guard.
    s.push_str("!!!");

    // The guard will be dropped here, printing:
    // "Chashu likes tuna!!!"
}

Implementations

impl<T, F> DropGuard<T, F>

where F: FnOnce(T),

pub const fn new(inner: T, f: F) -> DropGuard<T, F>

🔬This is a nightly-only experimental API. (drop_guard)

Create a new instance of DropGuard.

Example

#![feature(drop_guard)]

use std::mem::DropGuard;

let value = String::from("Chashu likes tuna");
let guard = DropGuard::new(value, |s| println!("{s}"));

pub fn into_inner(guard: DropGuard<T, F>) -> T

🔬This is a nightly-only experimental API. (drop_guard)

Consumes the DropGuard, returning the wrapped value.

This will not execute the closure. This is implemented as an associated function to prevent any potential conflicts with any other methods called into_inner from the Deref and DerefMut impls.

It is typically preferred to call this function instead of mem::forget because it will return the stored value and drop variables captured by the closure instead of leaking their owned resources.

Example

#![feature(drop_guard)]

use std::mem::DropGuard;

let value = String::from("Nori likes chicken");
let guard = DropGuard::new(value, |s| println!("{s}"));
assert_eq!(DropGuard::into_inner(guard), "Nori likes chicken");

Trait Implementations

impl<T, F> Debug for DropGuard<T, F>

where T: Debug, F: FnOnce(T),

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T, F> Deref for DropGuard<T, F>

where F: FnOnce(T),

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T, F> DerefMut for DropGuard<T, F>

where F: FnOnce(T),

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

Mutably dereferences the value.

impl<T, F> Drop for DropGuard<T, F>

where F: FnOnce(T),

fn drop(&mut self)

Executes the destructor for this type.