Six years of Go(blog.golang.org)

  if value, err := bar(); err != nil {
    return err
  }

  if value, err := bar(); err != nil {
    return err
  } else {
    log.Print(value)  // this compiles
  }
  log.Print(value)  // does not compile

  var value MyType
  var err error
  if value, err = bar(); err != nil {
    return err
  }

  var value MyType
  if value, err := bar(); err != nil {
    return err
  }

  package main
  import "fmt"

  func foo(a ...interface{})interface{}{
    if len(a) == 0 {
      return nil
    } else if len(a) == 1 {
      return a[0]
    } else {
      return a
    }
  }

  func barbar() (a, b int) { return 1, 2 }
  func bar() (a int) { return 1 }
  func baz() { return }

  func main() {
    fmt.Println( foo(barbar()) ) // prints: [1, 2]
    fmt.Println( foo(bar()) )    // prints: 1
    fmt.Println( foo(baz()) )    // compile error: baz() used as value
  }

  reply, err := redis.Givemethevalue(key)
  if err != nil {
    return err
  }

  thing, err := postgres.getById(reply)
  if err != nil {
    return err
  }

    struct fooer {
      x int
      blah string
      // ... more state
      err error
    }

    func Foo(x int) (string, error) {
      f := &fooer{x: x};
      defer f.cleanup()
      f.stepOne()
      f.stepTwo()
      f.stepThree()
      return f.blah, f.err
    }

    func (f *fooer) stepOne() {
      // ... do stuff and maybe set f.err
    }

    func (f *fooer) stepTwo() {
      if f.err != nil {
        return
      }
      // ... do stuff and maybe set f.err
    }

    func (f *fooer) stepThree() {
      if f.err != nil {
        return
      }
      // ... do stuff and maybe set f.err; set f.blah
    }

    func (f *fooer) cleanup() {
      // ...
    }

    func (f *fooer) fail(err error) {
        if f.err == nil {
            f.err = err
        }
    }

  var err error