How do errors.Is and errors.As walk the chain that fmt.Errorf's %w builds?

## The chain is an ordinary linked list There is no registry and no runtime magic behind error wrapping. When `fmt.Errorf` sees `%w`, the value it returns carries a reference to the operand and exposes it through one method: ``` Unwrap() error ``` Any type of yours can do the same by declaring that method. So a wrapped error is just a node pointing at the next node, and the last node, typically a sentinel built with `errors.New`, has no `Unwrap` method at all. That is the end of the list. ## `errors.Unwrap`: one step `errors.Unwrap(err)` returns the result of `err`'s `Unwrap` method, or `nil` if `err` has no such method. It is a single step, not a traversal. Written as a loop it is the whole data structure: ``` for err != nil { fmt.Printf("%T: %v\n", err, err) err = errors.Unwrap(err) } ``` That loop is also the best debugging tool for wrapping problems, because it prints where the chain actually stops. ## `errors.Is`: equality along the chain `errors.Is(err, target)` answers "is this specific error value somewhere in the chain?". It walks from `err` downward and at each level compares the current error to `target` for equality, then unwraps and repeats. It returns true at the first match and false when the walk runs out. The classic use is a package-level sentinel: ``` var ErrNotFound = errors.New("record not found") ``` Each `errors.New` call produces a distinct value even for identical text, which is exactly what makes sentinel comparison meaningful: matching is by identity, never by message. `errors.Is` also gives a level a chance to answer for itself if that level's type defines its own `Is` method, but the default behaviour, and the one you rely on for sentinels, is plain equality. ## `errors.As`: type matching along the chain `errors.As(err, target)` answers "is there an error of this concrete type in the chain, and if so give it to me?". The walk is identical; the test is different. At each level it checks whether the error's dynamic type is assignable to the type `target` points at. On the first fit it assigns through the pointer and returns true, which is why the argument must be a pointer at all: `As` has to have somewhere to put the value. ``` var pathErr *fs.PathError if errors.As(err, &pathErr) { // pathErr.Op, pathErr.Path and pathErr.Err are now usable } ``` `target` must be a non-nil pointer to a type implementing `error` or to an interface type. Anything else, including passing the value rather than its address, makes `errors.As` panic. `go vet`'s `errorsas` check catches the common form of that mistake before it ships. Use `errors.As` rather than a type assertion. `err.(*fs.PathError)` only inspects the outermost error, so it starts failing the moment any layer wraps the error with `%w`, which is precisely the change you want to be free to make. ## Where the walk stops The walk ends at the first error without an `Unwrap` method. Two very different things produce that ending: 1. You reached the bottom, a sentinel or a leaf error. This is normal. 2. Some layer in the middle formatted its cause with `%v` instead of `%w`. The chain was cut there, and everything below it is unreachable even though its text is still in the message. From the caller's side those two look identical: `errors.Is` returns false either way. That asymmetry is why wrapping discipline matters through every layer of a return path, not just at the top and the bottom. ## Cost and practical notes - The walk is O(depth) with depth typically under five, so cost is not a consideration on an error path. - `errors.Is` is the right way to compare against a sentinel; `==` is only correct when you know nothing wrapped the error, which is a fragile assumption in any package with callers. - Both functions accept a nil error and simply report no match, so you do not need a nil guard before calling them. - Recent Go adds `errors.AsType`, a generic form of `errors.As` that takes the wanted type as a type parameter and returns the matched error together with a bool, instead of requiring you to declare a variable and pass its address. It performs the same walk.