Errors as values: wrap, Is and As

Why errors as values?

Many languages throw exceptions that jump out of functions and are caught somewhere far away. It is easy to forget which calls can fail. Go makes failure visible: a function that can fail returns an error as its last result, and the caller decides what to do, right there. The code is longer, but the flow of control is always clear.

The error type

type error interface {
	Error() string
}

f, err := os.Open("marks.csv")
if err != nil {
	return fmt.Errorf("open marks file: %w", err)
}
defer f.Close()

Creating errors

import "errors"

var ErrNotFound = errors.New("not found")          // a sentinel error

func findUser(id int) (string, error) {
	if id != 1 {
		return "", ErrNotFound
	}
	return "Asha", nil
}

err := fmt.Errorf("invalid amount %d", -5)          // formatted, no wrapping

Wrapping with %w: adding context

A bare "not found" deep inside a big program is hard to debug. Each layer should add what it was doing. fmt.Errorf with the %w verb creates a new error whose message includes the old one AND keeps the old error inside, so it can still be found later. This is called wrapping.

func loadProfile(id int) error {
	_, err := findUser(id)
	if err != nil {
		return fmt.Errorf("load profile %d: %w", id, err)
	}
	return nil
}

err := loadProfile(7)
fmt.Println(err)                         // load profile 7: not found
fmt.Println(errors.Is(err, ErrNotFound)) // true

Custom error types and errors.As

Sometimes a caller needs details: which field failed validation, which HTTP status the bank returned. Make a struct type with an Error method, return it (wrapped or not), and the caller extracts it with errors.As, which also looks through the chain.

type ValidationError struct {
	Field string
	Msg   string
}

func (e *ValidationError) Error() string {
	return e.Field + ": " + e.Msg
}

func validate(age int) error {
	if age < 18 {
		return &ValidationError{Field: "age", Msg: "must be 18 or older"}
	}
	return nil
}

err := fmt.Errorf("signup: %w", validate(15))
var ve *ValidationError
if errors.As(err, &ve) {
	fmt.Println("bad field:", ve.Field) // bad field: age
}

Several errors at once

Go 1.20 added errors.Join(err1, err2, ...), which combines several errors into one (nil ones are dropped). errors.Is and errors.As check each of them. It is useful when validating a form with several bad fields.

Handle an error once

• Either handle it (retry, use a default, show a message) or return it with context. Do not log it AND return it at every layer, or one failure prints ten log lines.
• Never ignore errors silently with _ unless you have written down why it is safe.
• Do not check err.Error() text with strings.Contains; messages change. Use errors.Is or errors.As.
• Return early on errors so the "happy path" stays at the left edge of the code, not deeply nested.

// Hard to read: nested
if err == nil {
	if data, err := parse(raw); err == nil {
		save(data)
	}
}

// Go style: return early
data, err := parse(raw)
if err != nil {
	return fmt.Errorf("parse: %w", err)
}
return save(data)