Error Handling

type error interface {
	Error() string
}

package main

import (
	"errors"
	"fmt"
	"strings"
)

type ISBN string

// ParseISBN returns the error last, as the convention requires.
func ParseISBN(s string) (ISBN, error) {
	d := strings.ReplaceAll(s, "-", "")
	if len(d) != 13 {
		return "", fmt.Errorf("isbn %q has %d digits, want 13", s, len(d))
	}
	return ISBN(d), nil
}

func main() {
	isbn, err := ParseISBN("978-0-13-419044-0")
	if err != nil {
		fmt.Println("failed:", err)
		return
	}
	fmt.Println("parsed:", isbn)

	_, err = ParseISBN("12-34")
	if err != nil {
		fmt.Println("failed:", err)
	}

	e1 := errors.New("not found")
	e2 := errors.New("not found")
	fmt.Println(e1 == e2, e1 == e1)
	fmt.Printf("%T %v\n", e1, e1)
}

parsed: 9780134190440
failed: isbn "12-34" has 4 digits, want 13
false true
*errors.errorString not found

package main

import (
	"errors"
	"fmt"
)

// A sentinel error: a package-level variable callers compare against.
var ErrNotFound = errors.New("catalog: book not found")

// constError makes an error that cannot be reassigned.
type constError string

func (e constError) Error() string { return string(e) }

const ErrEmptyTitle = constError("catalog: empty title")

// LoanError is a custom error type carrying structured data.
type LoanError struct {
	ISBN   string
	Member string
	Reason string
}

func (e *LoanError) Error() string {
	return fmt.Sprintf("loan %s to %s: %s", e.ISBN, e.Member, e.Reason)
}

func find(isbn string) error {
	if isbn == "" {
		return ErrNotFound
	}
	return nil
}

func lend(isbn, member string) error {
	return &LoanError{ISBN: isbn, Member: member, Reason: "already on loan"}
}

func main() {
	if err := find(""); err == ErrNotFound {
		fmt.Println("direct comparison:", err)
	}
	var err error = ErrEmptyTitle
	fmt.Println(err == ErrEmptyTitle, err == constError("catalog: empty title"))

	err = lend("9780134190440", "ana")
	if le, ok := err.(*LoanError); ok {
		fmt.Println("member:", le.Member, "| reason:", le.Reason)
	}
	fmt.Println(err)
}

direct comparison: catalog: book not found
true true
member: ana | reason: already on loan
loan 9780134190440 to ana: already on loan

package main

import (
	"errors"
	"fmt"
)

var ErrNotFound = errors.New("book not found")

func lookup(isbn string) error {
	return fmt.Errorf("lookup %s: %w", isbn, ErrNotFound)
}

func borrow(isbn string) error {
	if err := lookup(isbn); err != nil {
		return fmt.Errorf("borrow: %w", err)
	}
	return nil
}

func main() {
	err := borrow("9780134190440")
	fmt.Println(err)
	fmt.Println("==:", err == ErrNotFound)
	fmt.Println("Is:", errors.Is(err, ErrNotFound))

	// errors.Unwrap peels exactly one layer.
	inner := errors.Unwrap(err)
	fmt.Println("one layer:", inner)
	fmt.Println("two layers:", errors.Unwrap(inner))
	fmt.Println("three layers:", errors.Unwrap(errors.Unwrap(inner)))

	// %v flattens the chain into text: the link is lost.
	flat := fmt.Errorf("borrow: %v", lookup("9780134190440"))
	fmt.Println("flat Is:", errors.Is(flat, ErrNotFound))
	fmt.Printf("%T %T\n", err, flat)

	// Errorf with a nil %w operand.
	var none error
	n := fmt.Errorf("wrapped nil: %w", none)
	fmt.Println(n, errors.Unwrap(n) == nil)
}

borrow: lookup 9780134190440: book not found
==: false
Is: true
one layer: lookup 9780134190440: book not found
two layers: book not found
three layers: <nil>
flat Is: false
*fmt.wrapError *errors.errorString
wrapped nil: %!w(<nil>) true

package main

import (
	"errors"
	"fmt"
	"io/fs"
	"os"
)

type LoanError struct {
	ISBN   string
	Reason string
}

func (e *LoanError) Error() string { return "loan " + e.ISBN + ": " + e.Reason }

func lend() error {
	return fmt.Errorf("checkout: %w", &LoanError{ISBN: "9780134190440", Reason: "already on loan"})
}

func main() {
	err := lend()

	// errors.As: declare a target variable and pass its address.
	var le *LoanError
	if errors.As(err, &le) {
		fmt.Println("As:", le.ISBN, le.Reason)
	}

	// errors.AsType (Go 1.26): generic, no target variable, no vet trap.
	if le, ok := errors.AsType[*LoanError](err); ok {
		fmt.Println("AsType:", le.ISBN, le.Reason)
	}

	// The target may also be an interface type.
	if t, ok := errors.AsType[interface {
		error
		Timeout() bool
	}](err); !ok {
		fmt.Println("no Timeout method:", t == nil)
	}

	// A standard-library example: *fs.PathError.
	_, err = os.Open("/no/such/dir/catalog.json")
	if pe, ok := errors.AsType[*fs.PathError](err); ok {
		fmt.Println("op:", pe.Op, "| path:", pe.Path, "| err:", pe.Err)
	}
	fmt.Println(errors.Is(err, fs.ErrNotExist), errors.Is(err, os.ErrNotExist))
}

As: 9780134190440 already on loan
AsType: 9780134190440 already on loan
no Timeout method: true
op: open | path: /no/such/dir/catalog.json | err: no such file or directory
true true

package main

import (
	"errors"
	"fmt"
	"io"
	"io/fs"
)

var (
	ErrNoTitle  = errors.New("title is empty")
	ErrNoAuthor = errors.New("no author")
	ErrBadISBN  = errors.New("bad isbn")
)

func validate(title, author, isbn string) error {
	var errs []error
	if title == "" {
		errs = append(errs, ErrNoTitle)
	}
	if author == "" {
		errs = append(errs, ErrNoAuthor)
	}
	if len(isbn) != 13 {
		errs = append(errs, fmt.Errorf("isbn %q: %w", isbn, ErrBadISBN))
	}
	return errors.Join(errs...)
}

func main() {
	err := validate("", "", "123")
	fmt.Println(err)
	fmt.Println("---")
	fmt.Println(errors.Is(err, ErrNoAuthor), errors.Is(err, ErrBadISBN), errors.Is(err, io.EOF))

	// A nil slice (or all-nil arguments) joins to nil: `err != nil` stays idiomatic.
	fmt.Println(validate("Go", "Pike", "9780134190440") == nil, errors.Join(nil, nil) == nil)

	// Multiple %w verbs in one Errorf (Go 1.20) build the same tree shape.
	both := fmt.Errorf("sync: %w; %w", io.ErrUnexpectedEOF, fs.ErrPermission)
	fmt.Println(both)
	fmt.Printf("%T\n", both)
	fmt.Println(errors.Is(both, io.ErrUnexpectedEOF), errors.Is(both, fs.ErrPermission))
	// errors.Unwrap returns nil for a multi-error: it only follows Unwrap() error.
	fmt.Println(errors.Unwrap(both) == nil)

	// Join(...) is the type produced by errors.Join.
	j := errors.Join(ErrNoTitle, ErrNoAuthor)
	if u, ok := j.(interface{ Unwrap() []error }); ok {
		fmt.Println(len(u.Unwrap()), u.Unwrap()[1])
	}
}

title is empty
no author
isbn "123": bad isbn
---
true true false
true true
sync: unexpected EOF; permission denied
*fmt.wrapErrors
true true
true
2 no author

package main

import "fmt"

type LoanError struct{ Reason string }

func (e *LoanError) Error() string { return "loan: " + e.Reason }

// broken returns a typed nil pointer wrapped in a non-nil error interface.
func broken(fail bool) error {
	var le *LoanError
	if fail {
		le = &LoanError{Reason: "on loan"}
	}
	return le // BUG: always a non-nil interface
}

// fixed returns an untyped nil on success.
func fixed(fail bool) error {
	if fail {
		return &LoanError{Reason: "on loan"}
	}
	return nil
}

func main() {
	err := broken(false)
	fmt.Println(err == nil, err != nil)
	fmt.Printf("%T %v\n", err, err == (*LoanError)(nil))
	fmt.Println(fixed(false) == nil)
	fmt.Println("calling Error on the typed nil:")
	defer func() { fmt.Println("recovered:", recover()) }()
	fmt.Println(err.Error())
}

false true
*main.LoanError true
true
calling Error on the typed nil:
recovered: runtime error: invalid memory address or nil pointer dereference

package main

import (
	"errors"
	"fmt"
	"os"
	"path/filepath"
)

// import wraps every failure with one deferred statement.
func importCatalog(path string) (err error) {
	defer func() {
		if err != nil {
			err = fmt.Errorf("import %s: %w", filepath.Base(path), err)
		}
	}()

	f, err := os.Open(path)
	if err != nil {
		return err
	}
	defer f.Close()

	var buf [4]byte
	if _, err := f.Read(buf[:]); err != nil {
		return fmt.Errorf("read header: %w", err)
	}
	return nil
}

// write keeps the Close error of a file opened for writing.
func write(path string, data []byte) (err error) {
	f, err := os.Create(path)
	if err != nil {
		return err
	}
	defer func() {
		err = errors.Join(err, f.Close())
	}()
	_, err = f.Write(data)
	return err
}

func main() {
	dir, err := os.MkdirTemp("", "shelf")
	if err != nil {
		fmt.Println(err)
		return
	}
	defer os.RemoveAll(dir)
	if err := os.Chdir(dir); err != nil {
		fmt.Println(err)
		return
	}

	fmt.Println(importCatalog("missing.json"))

	if err := os.WriteFile("empty.json", nil, 0o600); err != nil {
		fmt.Println(err)
		return
	}
	fmt.Println(importCatalog("empty.json"))

	fmt.Println(write("ok.json", []byte("[]")))
}

import missing.json: open missing.json: no such file or directory
import empty.json: read header: EOF
<nil>

package main

import (
	"fmt"
	"io"
	"strings"
)

// errWriter remembers the first write error, so a sequence of writes can be
// checked once at the end.
type errWriter struct {
	w   io.Writer
	err error
}

func (ew *errWriter) printf(format string, args ...any) {
	if ew.err != nil {
		return
	}
	_, ew.err = fmt.Fprintf(ew.w, format, args...)
}

// failAfter fails the n-th write.
type failAfter struct {
	n  int
	sb strings.Builder
}

func (f *failAfter) Write(p []byte) (int, error) {
	if f.n == 0 {
		return 0, fmt.Errorf("disk full")
	}
	f.n--
	return f.sb.Write(p)
}

func main() {
	dst := &failAfter{n: 2}
	ew := &errWriter{w: dst}
	ew.printf("title: %s\n", "The Go Programming Language")
	ew.printf("authors: %s\n", "Donovan, Kernighan")
	ew.printf("isbn: %s\n", "9780134190440") // fails
	ew.printf("pages: %d\n", 380)            // skipped
	fmt.Print(dst.sb.String())
	fmt.Println("error:", ew.err)
}

title: The Go Programming Language
authors: Donovan, Kernighan
error: disk full

package main

import "fmt"

func main() {
	var m map[string]int
	fmt.Println("before")
	m["isbn"] = 1
	fmt.Println("after")
}

before
panic: assignment to entry in nil map

package main

import (
	"fmt"
	"strconv"
)

type NotFound struct{ ISBN string }

func (n *NotFound) Error() string { return "not found: " + n.ISBN }

func find() error {
	return NotFound{"1"}
}

func name() error {
	return "oops"
}

func main() {
	n, err := strconv.Atoi("12")
	m, err := strconv.Atoi("34")
	fmt.Println(n, m)
	x, err := strconv.Atoi("56")
	fmt.Println(x)
	e := error.New("x")
}

./main.go:13:9: cannot use NotFound{…} (value of struct type NotFound) as error value in return statement: NotFound does not implement error (method Error has pointer receiver)
./main.go:17:9: cannot use "oops" (constant of type string) as error value in return statement: string does not implement error (missing method Error)
./main.go:21:5: declared and not used: err
./main.go:26:2: declared and not used: e
./main.go:26:13: error.New undefined (type error has no field or method New)

package main

import (
	"errors"
	"fmt"
	"os"
)

func main() {
	_, err := os.Open("missing.json")
	var pe os.PathError // not a pointer to a pointer
	if errors.As(err, pe) {
		fmt.Println(pe.Path)
	}
}

main.go:12:5: second argument to errors.As must be a non-nil pointer to either a type that implements error, or to any interface type

package main

import (
	"errors"
	"fmt"
)

var ErrNotFound = errors.New("not found")

func main() {
	fmt.Printf("lookup failed: %w\n", ErrNotFound)
	_ = fmt.Errorf("lookup failed: %w", "not found")
	msg := "100% sure"
	_ = fmt.Errorf(msg)
}

main.go:11:29: fmt.Printf does not support error-wrapping directive %w
main.go:12:33: fmt.Errorf format %w has arg "not found" of wrong type string
main.go:14:17: non-constant format string in call to fmt.Errorf

package main

import (
	"errors"
	"fmt"
)

func main() {
	var e error
	_, ok := errors.AsType[string](e)
	fmt.Println(ok)
}

./main.go:10:25: string does not satisfy error (missing method Error)

package main

import (
	"fmt"
	"os"
)

func load() (int, error) {
	f, err := os.Open("catalog.json")
	if err != nil {
		return 0, err
	}
	defer f.Close()
	return 1, nil
}

func main() {
	n, err := load()
	if err != nil {
		if n, err := load(); err != nil {
			fmt.Println("retry failed", n)
		}
	}
	fmt.Println(n)
}

retry failed 0
0