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 const fn dismiss(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. 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::dismiss(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> 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.

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.