Can non-nil interface fields be considered `nonzero`?

[ydnar]

Hi there, thanks for making this package.

I observed this issue printing a complex data structure with several structs containing interface fields which could be one of many conforming types. A number of those types might be empty structs, where the type is the only relevant information (the zero value is the only value).

If the outer struct with an interface field is printed, the nonzero function returns false because the concrete value of the interface field is zero. An example playground showing this can be found here: https://go.dev/play/p/HjxnCorTQtj

For interface fields, would it be possible to mark the field as nonzero if the field is non-nil, rather than the value of what the field is pointing at?

Thanks!

package main

import (
	"fmt"

	"github.com/kr/pretty"
)

func main() {
	// This should print the zero value for A
	v := &A{Err: nil}
	pretty.Println(v)

	// This will print &main.FormatError{...}
	v.Err = &FormatError{"foo.go", 12}
	pretty.Println(v)

	// This SHOULD print &main.A{Err: main.LogicError{}}, but prints the zero value for A instead.
	v.Err = LogicError{}
	pretty.Println(v)
}

type A struct {
	Err error
}

type FormatError struct {
	File string
	Line int
}

func (err *FormatError) Error() string {
	return fmt.Sprintf("format error: %s:%d", err.File, err.Line)
}

type LogicError struct{}

func (LogicError) Error() string {
	return "logic error"
}

Output

&main.A{}
&main.A{
    Err: &main.FormatError{File:"foo.go", Line:12},
}
&main.A{}

Desired Output

&main.A{}
&main.A{
    Err: &main.FormatError{File:"foo.go", Line:12},
}
&main.A{
    Err: &main.LogicError{},
}