proposal: fmt: add deferred/lazy formatting support to Errorf

[vsaljooghi]

Proposal Details

Hello,

I have a custom error type defined as follows:

type ErrorInfo struct {
	ErrCode int
	Err     error
}

func NewErrInfo(errCode int, err error) *ErrorInfo {
	return &ErrorInfo{
		ErrCode: errCode,
		Err:     err,
	}
}

func (ei *ErrorInfo) Error() string {
	if ei.Err == nil {
		return fmt.Sprintf("error code (%d)", ei.ErrCode)
	}

	return fmt.Sprintf("%s (%d)", ei.Err.Error(), ei.ErrCode)
}

This *ErrorInfo object is typically created in a low-level function with only the ErrCode set. The actual human-readable error corresponding to ErrCode is assigned later in a high-level function.

The workflow is:

1. A low-level function creates a *ErrorInfo with just the error code.
2. This object is wrapped in an error using %w and propagated up through intermediate functions, which may enrich the error.
3. In the high-level function, I use errors.As() to locate the original *ErrorInfo inside the wrapped error chain.
4. Once found, I modify the object (for example, mapping ErrCode to a human-readable error and setting ErrInfo.Err).
5. I then want to print the top-level error message so it reflects the updated *ErrorInfo.

The problem with using fmt.Errorf() directly is that it constructs the error string immediately. If the *ErrorInfo is modified later, these changes are not reflected in the printed message.

Workaround: lazy error formatting
To solve this, I created a lazyError wrapper that defers formatting until Error() is called:

type lazyError struct {
	format string
	args   []interface{}
}

func (le *lazyError) Error() string {
	return fmt.Errorf(le.format, le.args...).Error()
}

func (le *lazyError) Unwrap() []error {
	err := fmt.Errorf(le.format, le.args...)

	switch x := err.(type) {
	case interface{ Unwrap() error }:
		return []error{x.Unwrap()}
	case interface{ Unwrap() []error }:
		return x.Unwrap()
	default:
		return nil
	}
}

func Errorf(format string, args ...interface{}) error {
	return &lazyError{
		format: format,
		args: args,
	}
}

it would be great if fmt.Errorf() do lazy formatting out of box

Best Regards,
Vahid

[gabyhelp]

Related Issues

• proposal: allow `errors.New()` to take a formatting string, or add `errors.Errorf()` #49348 (closed)
• proposal: fmt: feature request: add Error, which corresponds to Errorf as Print corresponds to Printf #22848 (closed)
• proposal: fmt: add an additional %j verb to wrap errors #58107 (closed)

_{(Emoji vote if this was helpful or unhelpful; more detailed feedback welcome in this discussion.)}

[adonovan]

it would be great if fmt.Errorf() do lazy formatting out of box

How would that work? There's not a lot of room between specified behaviors for an extra caching wrapping layer. (Clearly fmt.Errorf cannot behave exactly like your lazy Errorf since it would change the moment at which the error string is formatted, which is an observable and incompatible behavior change.) Perhaps you could sketch the alternative implementation you have in mind.

(BTW, operations that lazily populate the error object should be protected by sync.Mutex or a sync.Once to avoid data races.)

[vsaljooghi]

A usage example describing above workflow:

func getTemp() error {
	switch rand.Intn(3) {
	case 1:
		return NewErrInfo(1, nil)
	case 2:
		return NewErrInfo(2, nil)
	default:
		return nil
	}
}

func retryGetTemp() error {
	var err error
	var retryCounter int

	for retryCounter = 1; retryCounter < 3; retryCounter++ {
		if err = getTemp(); err == nil {
			return nil
		}
	}

	return Errorf("(retries: %d): %w", retryCounter, err)
}

func canISwim(name string) error {
	if err := retryGetTemp(); err != nil {
		return Errorf("I am sorry %s. Water temperature is not appropriate for swimming: %w", name, err)
	} else {
		return Errorf("You are lucky %s. Water temperature is appropriate for swimming", name)
	}
}

func main() {
	if err := canISwim("vahid"); err != nil {
		var errInfo *ErrorInfo

		if errors.As(err, &errInfo){
			mapError(errInfo)
		}

		log.Printf("%s", err)
	}
}

func mapError(errInfo *ErrorInfo) {
	if errInfo.Err == nil {
		switch errInfo.ErrCode {
		case 1:
			errInfo.Err = errors.New("water is too cold")
		case 2:
			errInfo.Err = errors.New("water is too warm")
		default:
			errInfo.Err = errors.New("unknown error code")
		}
	}
}

[seankhliao]

I think this is just one of those things that you can do in your own package when you need it, not something to be done by default as the mutability is surprising. https://go.dev/doc/faq#x_in_std

[vsaljooghi]

it would be great if fmt.Errorf() do lazy formatting out of box

How would that work? There's not a lot of room between specified behaviors for an extra caching wrapping layer. (Clearly fmt.Errorf cannot behave exactly like your lazy Errorf since it would change the moment at which the error string is formatted, which is an observable and incompatible behavior change.) Perhaps you could sketch the alternative implementation you have in mind.

(BTW, operations that lazily populate the error object should be protected by sync.Mutex or a sync.Once to avoid data races.)

My idea is to modify the behavior of Go’s internal wrapErrors type so that it works like my custom lazyError: instead of returning an already formatted string in Error(), the struct would defer formatting (whenever Error() of wrapErrors is called, a fmt.Sprintf() will do the formatting on args and returns the string. Args are kept in a field of wrapErrors).

From errors.go

type wrapErrors struct {
	msg  string
	errs []error
}

func (e *wrapErrors) Error() string {
	return e.msg
}

func (e *wrapErrors) Unwrap() []error {
	return e.errs
}

Regarding synchronization:
The mutation occurs on the wrapped error object itself (via its pointer), not on the top-level error. Therefore, it is the responsibility of the custom error type definer to handle its own concurrency requirements. If the wrapped error type be modified from multiple goroutines, the type’s definer must ensure proper synchronization.
In my case, the ErrorInfo object is never modified concurrently from multiple goroutines, so I did not add a mutex to the struct.