Delaying a cleanup block's mutable borrow until it actually runs

With scopeguard::defer!, the closure has to be declared before the equivalent try block, which starts the mutable borrow immediately upon creating that closure,

defer!() isn't suitable here, but the guard function can place your value inside a scopeguard::ScopeGuard insted.

since ScopeGuard supplies Deref and DerefMut, accessing the guard works like accessing the value it holds.

struct Resource {}

// ownership of the resource goes into this destructor
// a closure normally serves this purpose
fn release_resource(resource: Resource) {
    println!("dropping resource");
}

fn main() {
    // obtain the resource, then give it a guard
    let resource: Resource = acquire_resource();
    let mut resource = guard(resource, release_resource);
    // borrowing the resource mutably is another option
    // let mut resource = guard(&mut resource, release_resource_by_mut);

    // access the enclosed resource through its guard
    resource.refresh();
    inspect_resource(&resource);
    change_resource(&mut resource);

    // leaving this scope runs the destructor
    // or disable the guard to recover the resource
    // without invoking its destructor
    // let resource = ScopeGuard::into_inner(resource);
}

Thanks! That looks like it does the job. In the scopeguard documentation, I'd prefer seeing the case "with value" before the example that uses a unit value.