Recover a nil interface through type assertion

Question

Consider the following (demo https://go.dev/play/p/VrJx-eEij14)

type myError struct {
    err error
}

func (e myError) Error() string { return e.err.Error() }

func main() {
    var (
        err       error = fmt.Errorf("%w", myError{errors.New("I am an error")})
        nilErr    error = nil
        errAny    any   = err
        nilErrAny any   = nilErr
    )

    {
        recErr, ok := errAny.(error)
        fmt.Println(recErr, ok)
    }

    {
        recErr, ok := nilErrAny.(error)
        fmt.Println(recErr, ok)
    }
}

It prints

I am an error true
<nil> false

while I expected it to print

I am an error true
<nil> true

Trying the same exercice replacing the interface type error with *int (demo https://go.dev/play/p/NtHVyYO9Hfj)

func main() {
    var (
        p       *A  = &A{}
        nilp    *A  = nil
        pAny    any = p
        nilpAny any = nilp
    )

    {
        rec, ok := pAny.(*A)
        fmt.Println(rec, ok)
    }

    {
        rec, ok := nilpAny.(*A)
        fmt.Println(rec, ok)
    }
}

does yield to the output I expect

&{} true
<nil> true

Why can one recover a nil int pointer from an empty interface but not a nil error from an empty interface?

---

FYI, the specific situation I am trying to solve is one, where I am caching errors. The values cached are of type any. Some errors cached are nil. I care about the difference between a nil error and an object that I could unexpectedly not type assert into an error because I would have messed my cache up.

Answer 1

Internally, a variable of interface type is an intermediate object that contains a pointer to the actual object and information about the type of that object, and it is possible for the interface value to be "empty", which is represented by the keyword nil (though this situation is distinct from a nil pointer). Thus, there are two ways in which a variable of interface type can "be nil": the variable itself can be nil (the intermediate object is empty), or the intermediate object contains a pointer to the actual object is nil. Assigning the literal nil to a variable of interface type produces the first situation. You can produce the second situation with e.g. nilErr error = nil.(*myError), or by assigning a nil pointer that is already held in a variable of type *myError.