Package errwrap implements methods to formalize error wrapping in Go. All of the top-level functions that take an `error` are built to be able to take any error, not just wrapped errors. This allows you to use errwrap without having to type-check and type-cast everywhere.
package errwrap

import (
	
	
	
)
WalkFunc is the callback called for Walk.
type WalkFunc func(error)
Wrapper is an interface that can be implemented by custom types to have all the Contains, Get, etc. functions in errwrap work. When Walk reaches a Wrapper, it will call the callback for every wrapped error in addition to the wrapper itself. Since all the top-level functions in errwrap use Walk, this means that all those functions work with your custom type.
type Wrapper interface {
	WrappedErrors() []error
}
Wrap defines that outer wraps inner, returning an error type that can be cleanly used with the other methods in this package, such as Contains, GetAll, etc. This function won't modify the error message at all (the outer message will be used).
func (,  error) error {
	return &wrappedError{
		Outer: ,
		Inner: ,
	}
}
Wrapf wraps an error with a formatting message. This is similar to using `fmt.Errorf` to wrap an error. If you're using `fmt.Errorf` to wrap errors, you should replace it with this. format is the format of the error message. The string '{{err}}' will be replaced with the original error message.
func ( string,  error) error {
	 := "<nil>"
	if  != nil {
		 = .Error()
	}

	 := errors.New(strings.Replace(
		, "{{err}}", , -1))

	return Wrap(, )
}
Contains checks if the given error contains an error with the message msg. If err is not a wrapped error, this will always return false unless the error itself happens to match this msg.
func ( error,  string) bool {
	return len(GetAll(, )) > 0
}
ContainsType checks if the given error contains an error with the same concrete type as v. If err is not a wrapped error, this will check the err itself.
func ( error,  interface{}) bool {
	return len(GetAllType(, )) > 0
}
Get is the same as GetAll but returns the deepest matching error.
func ( error,  string) error {
	 := GetAll(, )
	if len() > 0 {
		return [len()-1]
	}

	return nil
}
GetType is the same as GetAllType but returns the deepest matching error.
func ( error,  interface{}) error {
	 := GetAllType(, )
	if len() > 0 {
		return [len()-1]
	}

	return nil
}
GetAll gets all the errors that might be wrapped in err with the given message. The order of the errors is such that the outermost matching error (the most recent wrap) is index zero, and so on.
func ( error,  string) []error {
	var  []error

	Walk(, func( error) {
		if .Error() ==  {
			 = append(, )
		}
	})

	return 
}
GetAllType gets all the errors that are the same type as v. The order of the return value is the same as described in GetAll.
func ( error,  interface{}) []error {
	var  []error

	var  string
	if  != nil {
		 = reflect.TypeOf().String()
	}
	Walk(, func( error) {
		var  string
		if  != nil {
			 = reflect.TypeOf().String()
		}

		if  ==  {
			 = append(, )
		}
	})

	return 
}
Walk walks all the wrapped errors in err and calls the callback. If err isn't a wrapped error, this will be called once for err. If err is a wrapped error, the callback will be called for both the wrapper that implements error as well as the wrapped error itself.
func ( error,  WalkFunc) {
	if  == nil {
		return
	}

	switch e := .(type) {
	case *wrappedError:
		(.Outer)
		(.Inner, )
	case Wrapper:
		()

		for ,  := range .WrappedErrors() {
			(, )
		}
	default:
		()
	}
}
wrappedError is an implementation of error that has both the outer and inner errors.
type wrappedError struct {
	Outer error
	Inner error
}

func ( *wrappedError) () string {
	return .Outer.Error()
}

func ( *wrappedError) () []error {
	return []error{.Outer, .Inner}