I think we could simplify the https://github.com/pkg/errors API a little further and add two new functions only:

func Cause(err error) error
func Wrap(err error, message string) error
- func Errorf(format string, args ...interface{}) error
- func WithMessage(err error, message string) error
- func WithStack(err error) error
- func Wrapf(err error, format string, args ...interface{}) error

1. assuming the stack traces were configurable globally, ie. via a flag:

func main() {
	if debug {
		errors.CaptureStackTraces = true // false by default
	}
}

2. and if we kept using fmt package for formatted error messages (fmt.Errorf(), fmt.Wrapf()).

cc @bradfitz @davecheney

As another point in the design space, a package like https://github.com/pkg/errors but with the simpler API is https://godoc.org/github.com/samsarahq/go/oops.

It's a good package, but what's the argument for bringing it into the standard library? Bear in mind https://golang.org/doc/faq#x_in_std .

One motivation for standardizing is uniform handling of well-known errors. For example, wrapping io.EOF confuses io.Copy, which ignores io.EOF but not when wrapped since it checks for equality. I don't have a great answer on what to do though, because sometimes you might want a wrapped error to have a different semantic meaning and other times you might want to preserve the original error but just have some added debug information.

@ianlancetaylor argument for bringing it into the standard library is just standardization of error context across the Go ecosystem. Not everyone uses github.com/pkg/errors as of now obviously.

Example:
I'd like to be able to inspect a stack trace of any incoming error from 3rd party pkgs. Currently, I struggle with some generic errors returned by vendored packages (ie. a variable instantiated during the boot time, returned by many functions/methods). I always end up debugging the underlying package itself (debugger or with injecting errors.Wrap()) instead of having a quick hint about the cause (file:line) in the first place.

Thanks. Standardization of error context is a big concept, and I don't think that the errors package addresses all aspects of it. For example, see https://commandcenter.blogspot.com/2017/12/error-handling-in-upspin.html for some additional ideas in this space.

\cc @neild @mpvl

I would also like to see standardization around some common optional interfaces, like IsTemporary() bool. Having it in the stdlib would encourage people to use the same interfaces when applicable.

I like the approach in this blog post, Failure Is Your Domain. The author emphasizes the importance of "owning" your failure modes, but I think that some of the functions mentioned in the article would be good candidates for standard library inclusion.

I'd be glad to see standard errors package simply replaced by github.com/pkg/errors (or something with the same purpose), like it was mentioned here: #16968
Standard one doesn't give you anything which fmt.Errorf() doesn't do already.
Never understood why we have both fmt.Errorf() and errors.New() tbh, instead of doing errors.Newf() or fmt.Error().

Is there a reason why this is a Go 2 issue, rather than just including the new functions into the errors package? After all, it should be backwards compatible

@deanveloper, because Go isn't a language where we just keep adding stuff all the time. We prefer to think about the end goal and the minimal set of things that would interact well. Once we add stuff, we can't remove it soon or easily, and it might not be what we want in the end. So we prefer to go slowly, even if that's boring and frustrating at times.

Closing in favor of the discussion at https://github.com/golang/go/wiki/Go2ErrorValuesFeedback . I have added this issue to that page.