defer in Rust

After a Hacker News discussion about implementing Go's defer keyword in C++, I stumbled upon this comment and more specifically this response to it by "Occivink":

There's plenty of one-time cases where you don't want to declare an entire class but still enjoy scope-based functions.

Specificall the "don't want to declare an entire class" suggests that languages like C++ have high friction for explaining your desired invariant (cleanup is run when $thing is destroyed) to the compiler.

It seems like most languages either hand-wave this away (cough Java cough) or use what seems like a workaround (defer).

Rust has the so-called Drop trait, which is a typeclass that contains a single method with no return value that is run when a variable is dropped (i.e. goes out of scope).

This works fine for most general cases - i.e. closing file handlers - but can get complicated if other use-cases of defer are considered:

• returning an error-value by mutating a reference in the enclosing scope (oh boy)
• deferring a decision about when/whether to run cleanup to the caller

While thinking about how to do this with the Drop trait I realised that defer can actually be trivially implemented in Rust, using Drop.

A simple implementation of defer can be seen in defer.rs, an implementation using shared mutable state for error returns is in the file defer-with-error.rs and an implementation that allows cleanup to be cancelled (don't actually do this, it leaks a pointer) is in undefer.rs.

Whether any of this is actually useful is not up to me to decide. I haven't actually had a real-life need for this.

You can run the examples with cargo run --example defer, etc.

Notes

• Drop is not guaranteed to run in case of panics or program aborts, if you need support for that check out scopeguard

Further reading:

• The Pain Of Real Linear Types in Rust
• Go's defer
• Rust's Drop