Documentation

Overview

    Package errors implements functions to manipulate errors.

    This package implements the Go 2 draft designs for error inspection and printing:

    https://go.googlesource.com/proposal/+/master/design/go2draft.md
    

    This is an EXPERIMENTAL package, and may change in arbitrary ways without notice.

    Example
    Output:
    
    1989-03-15 22:30:00 +0000 UTC: the file system has gone away
    

    Index

    Examples

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func As

    func As(err error, target interface{}) bool

      As finds the first error in err's chain that matches a type to which target points, and if so, sets the target to its value and reports success. An error matches a type if it is of the same type, or if it has an As method such that As(target) returns true. As will panic if target is nil or not a pointer.

      The As method should set the target to its value and report success if err matches the type to which target points and report success.

      Example
      Output:
      
      Failed at path: non-existing
      

      func Is

      func Is(err, target error) bool

        Is returns true if 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 an Is method such that Is(target) returns true.

        func New

        func New(text string) error

          New returns an error that formats as the given text.

          The returned error embeds a Frame set to the caller's location and implements Formatter to show this information when printed with details.

          Example
          Output:
          
          emit macho dwarf: elf header corrupted
          
          Example (Errorf)

            The fmt package's Errorf function lets us use the package's formatting features to create descriptive error messages.

            Output:
            
            user "bimmler" (id 17) not found
            

            func Opaque

            func Opaque(err error) error

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

              func Unwrap

              func Unwrap(err error) error

                Unwrap returns the next error in err's chain. If there is no next error, Unwrap returns nil.

                Types

                type Formatter

                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 Formatter formats error messages.

                  type Frame

                  type Frame struct {
                  	// contains filtered or unexported fields
                  }

                    A Frame contains part of a call stack.

                    func Caller

                    func Caller(skip int) Frame

                      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 (Frame) Format

                      func (f Frame) Format(p Printer)

                        Format prints the stack as error detail. It should be called from an error's Format implementation, before printing any other error detail.

                        type Printer

                        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 Printer formats error messages.

                          The most common implementation of Printer is the one provided by package fmt during Printf. Localization packages such as golang.org/x/text/message typically provide their own implementations.

                          type Wrapper

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

                            An Wrapper provides context around another error.

                            Directories

                            Path Synopsis
                            Package fmt implements formatted I/O with functions analogous to C's printf and scanf.
                            Package fmt implements formatted I/O with functions analogous to C's printf and scanf.