I don't know Rust but, can this `defer` evaluate after the `return` statement is evaluated like in Swift? Because in Swift you can do this:

    func atomic_get_and_inc() -> Int {
        sem.wait()
        defer {
            value += 1
            sem.signal()
        }
        return value
    }

▲ kibwen 3 hours ago | parent | next [-]

It's easy to demonstrate that destructors run after evaluating `return` in Rust:

    struct PrintOnDrop;
    
    impl Drop for PrintOnDrop {
        fn drop(&mut self) {
            println!("dropped");
        }
    }
    
    fn main() {
        let p = PrintOnDrop;
        return println!("returning");
    }

But the idea of altering the return value of a function from within a `defer` block after a `return` is evaluated is zany. Please never do that, in any language.

▲ ninkendo 3 hours ago | parent | prev [-]

EDIT: I don’t think you can actually put a return in a defer, I may have misremembered, it’s been several years. Disregard this comment chain.

It gets even better in swift, because you can put the return statement in the defer, creating a sort of named return value:

    func getInt() -> Int {
        let i: Int // declared but not
                   // defined yet!

        defer { return i }

        // all code paths must define i
        // exactly once, or it’s a compiler
        // error
        if foo() {
            i = 0
        } else {
            i = 1
        }

        doOtherStuff()
    }

▲ kibwen 2 hours ago | parent | next [-]

This control flow is wacky. Please never do this.

▲ 2 hours ago | parent | prev | next [-]

[deleted]

▲ mojuba 3 hours ago | parent | prev [-]

Huh, I didn't know about `return` in `defer`, but is it really useful?

	▲	ninkendo an hour ago \| parent \| next [-]
		No, I actually misremembered… you can’t return in a defer. The magical thing I was misremembering is that you can reference a not-yet-defined value in a defer, so long as all code paths define it once: `fn callFoo() -> FooResult { let fooParam: Int // declared, not defined yet defer { // fooParam must get defined by the end of the function foo(fooParam) otherStuffAfterFoo() // … } // all code paths must assign fooParam if cond { fooParam = 0 } else { fooParam = 1 return // early return! } doOtherStuff() }` Blame it on it being years since I’ve coded in swift, my memory is fuzzy.
	▲	2 hours ago \| parent \| prev [-]
		[deleted]