Don't defer Close() on writable files (2017)(joeshaw.org)

    package errs

    // Capture runs errFunc and assigns the error, if any, to *errPtr. Preserves the
    // original error by wrapping with errors.Join if the errFunc err is non-nil.
    func Capture(errPtr *error, errFunc func() error, msg string) {
        err := errFunc()
        if err == nil {
            return
        }
        *errPtr = errors.Join(*errPtr, fmt.Errorf("%s: %w", msg, err))
    }

    func doThing() (_ string, mErr error) {
        f, err := os.Open("foo")
        if err != nil {
            return "", fmt.Errorf("open file: %w", err)
        }
        // Use the file...
        defer errs.Capture(&mErr, f.Close, "close file")

        return "", nil
    }

      f, err := os.Open(blah)
      // ...
      defer CheckClose(f, &err)

    f, err = with(os.Open(thing)) {
        // do stuff
    }
    // at this point err has the same semantics as your CheckClose

    struct Foo {
      bool dirty,
    }

    impl Foo {
      fn clean_up(&mut self) {
        // ...
        self.dirty = false;
      }
    }

    impl Drop for Foo {
      fn drop(&mut self) {
        if self.dirty {
          panic!("Foo was not cleaned up before its lifetime ended");
        }
      }
    }

    fn bar(foo: &mut foo) {
      foo.clean_up();
    }

   switch {
   case strings.Contains(err.Error(), "close thing foo"):
       // deal with foo close error
   case strings.Contains(err.Error(), "close thing bar"):
       // deal with bar close error
   }

  defer f.Close()

  defer func(){ _ = f.Close() }()

    func doSomething() (err error) {
        var f *os.File
        f, err = os.Create("foo")
        if err != nil {
           return
        }
        defer func(){
           if nil != f {
              f.Close()
           }
        }()

        _, err = f.Write([]byte("bar")
        if err != nil {
            return
        }

        err = f.Close()
        f = nil
        return
    }

  Retrying the close() after a failure return is the wrong thing to
  do, since this may cause a reused file descriptor from another
  thread to be closed.  This can occur because the Linux kernel
  always releases the file descriptor early in the close operation,
  freeing it for reuse; the steps that may return an error, such as
  flushing data to the filesystem or device, occur only later in
  the close operation.

  Many other implementations similarly always close the file
  descriptor (except in the case of EBADF, meaning that the file
  descriptor was invalid) even if they subsequently report an error
  on return from close().  POSIX.1 is currently silent on this
  point, but there are plans to mandate this behavior in the next
  major release of the standard.

  func f(filename string) error {
    fp, err := os.Create(filename)
    if err != nil {
      return err
    }
    defer fp.Close()
    if _, err := fmt.Fprintln(fp, "Hello, world!"); err != nil {
      return err
    }
    return fp.Close() // safe to call multiple times
  }