// A Formatter formats error messages. type Formatter interface { error // FormatError prints the receiver's first error and returns the next error in // the error chain, if any. FormatError(p Printer) (next error) }


// A Printer formats error messages. // // The most common implementation of Printer is the one provided by package fmt // during Printf (as of Go 1.13). Localization packages such as golang.org/x/text/message // typically provide their own implementations. type Printer interface { // Print appends args to the message output. Print(args ...interface{}) // Printf writes a formatted string. Printf(format string, args ...interface{}) // Detail reports whether error detail is requested. // After the first call to Detail, all text written to the Printer // is formatted as additional detail, or ignored when // detail has not been requested. // If Detail returns false, the caller can avoid printing the detail at all. Detail() bool }


// A Wrapper provides context around another error. type Wrapper interface { // Unwrap returns the next error in the error chain. // If there is no next error, Unwrap returns nil. Unwrap() error }


// As finds the first error in err's chain that matches the type to which target // points, and if so, sets the target to its value and returns true. An error // matches a type if it is assignable to the target type, or if it has a method // As(interface{}) bool such that As(target) returns true. As will panic if target // is not a non-nil pointer to a type which implements error or is of interface type. // // The As method should set the target to its value and return true if err // matches the type to which target points. // // Deprecated: As of Go 1.13, use errors.As instead. func As(err error, target interface{}) bool


// Caller returns a Frame that describes a frame on the caller's stack. // The argument skip is the number of frames to skip over. // Caller(0) returns the frame for the caller of Caller. func Caller(skip int) Frame


// Errorf formats according to a format specifier and returns the string as a // value that satisfies error. // // The returned error includes the file and line number of the caller when // formatted with additional detail enabled. If the last argument is an error // the returned error's Format method will return it if the format string ends // with ": %s", ": %v", or ": %w". If the last argument is an error and the // format string ends with ": %w", the returned error implements an Unwrap // method returning it. // // If the format specifier includes a %w verb with an error operand in a // position other than at the end, the returned error will still implement an // Unwrap method returning the operand, but the error's Format method will not // return the wrapped error. // // It is invalid to include more than one %w verb or to supply it with an // operand that does not implement the error interface. The %w verb is otherwise // a synonym for %v. // // Note that as of Go 1.13, the fmt.Errorf function will do error formatting, // but it will not capture a stack backtrace. func Errorf(format string, a ...interface{}) error


// FormatError calls the FormatError method of f with an errors.Printer // configured according to s and verb, and writes the result to s. func FormatError(f Formatter, s fmt.State, verb rune)


// Is reports whether any error in err's chain matches target. // // An error is considered to match a target if it is equal to that target or if // it implements a method Is(error) bool such that Is(target) returns true. // // Deprecated: As of Go 1.13, use errors.Is instead. func Is(err error, target error) bool


// New returns an error that formats as the given text. // // The returned error contains a Frame set to the caller's location and // implements Formatter to show this information when printed with details. func New(text string) error


// Opaque returns an error with the same error formatting as err // but that does not match err and cannot be unwrapped. func Opaque(err error) error


// Unwrap returns the result of calling the Unwrap method on err, if err implements // Unwrap. Otherwise, Unwrap returns nil. // // Deprecated: As of Go 1.13, use errors.Unwrap instead. func Unwrap(err error) error