More Gotchas of Defer in Go, Part II

Post by int_19h » Thu, Dec 21, 2017, 8:56 PM UTC

mratzloff wrote: post #30

brian-armstrong wrote: post #28

Defers just feel like a watered down version of what you get with good scoping and RAII. They're a half measure for something programming languages solved decades ago.

Go has a garbage collector. RAII is only viable in languages where destruction is predictable, like C++ or PHP.

Post by barsonme » Thu, Dec 21, 2017, 9:31 PM UTC

pcwalton wrote: post #19

barsonme wrote: post #18

Earlier quoted context omitted.

It's not terribly uncommon for larger functions to do something like func someSQLStuff() { tx, err := createTx() defer func() { if err != nil { tx.Rollback() log(err) } else { tx.Commit() } }() rows, err = tx.QueryContext( ... ) // more SQL } Basically, function-scoped cleanup. Like closing opened files.

But that defer is already lexically at the function scope, so block-scoped defer would do the same thing.

Post by bsaul » Thu, Dec 21, 2017, 9:41 PM UTC

brabel wrote: post #2

Every point mentioned was not a gotcha to anyone who read the official introductory tour of the language. The behaviour may be unexpected to newbies, but if you spent an hour or so learning the language, you shouldn't be falling for these.

Post by Groxx » Thu, Dec 21, 2017, 9:44 PM UTC

infogulch wrote: post #34

Groxx wrote: post #27

Earlier quoted context omitted.

Both seem like fair options to me. With function scope, you can func f() { x := ... if x.something() { x.doSomethingEarlier() defer x.cleanup() } // use x however you like } where scope-based forces you to do stuff like func f() { x := ... if x.something() { x.doSomethingEarlier() defer x.cleanup() // use x however you like } else { // use x however you like } } In a scope-based defer, you'd have to keep all related…

I think function scope is a good default, and wrapping in an anonymous function and calling it (like your last example) is a simple workaround to get the scope_defer behavior. If it was scope based there's nothing you could do to get func_defer behavior.

    func f(){
      deferred := []
      defer func() { for d in deferred.reverse(): d() }() // plus error handling
      if x.something() {
        deferred.push(func(){ cleanup() });
      }
      // same as func scope
    }

Post by Groxx » Thu, Dec 21, 2017, 10:09 PM UTC

pcwalton wrote: post #13

willvarfar wrote: post #11

Earlier quoted context omitted.

Well I think the function scope the most useful, but wish there was block scope available too. So what I really wish was that languages used dot notation to go up scope eg ..name is that name two blocks out. This was one of the good parts of VB syntax which I miss in other languages. Think how much nicer it is than python's nonlocal and global, for example!

What's the use case for function scoped defer? I have never once needed function scoped RAII in C++ or any other language.

    func f(i interface{}) {
      if closable, ok := i.(closable); ok {
        defer closable.close()
      }
      // do stuff with i, maybe other casts, etc
    }

    deferrable := func(){}
    if closable {
      deferrable = closable.close
    }
    defer deferrable()