How does the io.Closer interface work with defer for resource management?

// io.Closer definition
type Closer interface { Close() error }

// Pattern 1: defer immediately after acquiring the resource
func readConfig(path string) ([]byte, error) {
    f, err := os.Open(path)
    if err != nil { return nil, fmt.Errorf("open: %w", err) }
    defer f.Close()   // guaranteed to run when function returns
    return io.ReadAll(f)
}

// Pattern 2: handle Close() error (important for writable files)
func writeConfig(path string, data []byte) (retErr error) {
    f, err := os.Create(path)
    if err != nil { return fmt.Errorf("create: %w", err) }
    defer func() {
        if err := f.Close(); err != nil && retErr == nil {
            retErr = fmt.Errorf("close: %w", err) // capture Close error
        }
    }()
    _, err = f.Write(data)
    return err
}

// Pattern 3: implementing Closer on your own type
type DBPool struct {
    pool *sql.DB
}
func (p *DBPool) Close() error { return p.pool.Close() }

// Closer in a function signature for maximum flexibility
func mustClose(c io.Closer) {
    if err := c.Close(); err != nil {
        log.Printf("close error: %v", err)
    }
}
// Works for files, DB connections, HTTP response bodies, etc.