// Package mark provides a mechanism for tagging errors with a well-known error value.
package mark
import "errors"
// This list of errors is not exhaustive, but is a good starting point for most
// applications. Feel free to add more as needed, but don't go overboard.
// Remember, the specific types of errors are only important so far as someone
// calling your code might want to write logic to handle each type of error
// differently.
//
// Do not add application-specific errors to this list. Instead, just define
// your own package with your own application-specific errors, and use this
// package to mark errors with them. The errors in this package are not special,
// they're just plain old errors.
//
// Not all errors need to be marked. An error that is not marked should be
// treated as an unexpected error that cannot be handled by calling code. This
// is often the case for network errors or logic errors.
var (
ErrNotFound = errors.New("not found")
ErrAlreadyExists = errors.New("already exists")
ErrBadRequest = errors.New("bad request")
ErrUnauthorized = errors.New("unauthorized")
ErrCancelled = errors.New("request cancelled")
ErrUnavailable = errors.New("unavailable")
ErrTimedout = errors.New("request timed out")
ErrTooLarge = errors.New("request is too large")
ErrTooManyRequests = errors.New("too many requests")
ErrForbidden = errors.New("forbidden")
)
// With wraps err with another error that will return true from errors.Is and
// errors.As for both err and markErr, and anything either may wrap.
func With(err, markErr error) error {
if err == nil {
return nil
}
return marked{wrapped: err, mark: markErr}
}
type marked struct {
wrapped error
mark error
}
func (f marked) Is(target error) bool {
// if this is false, errors.Is will call unwrap and retry on the wrapped
// error.
return errors.Is(f.mark, target)
}
func (f marked) As(target any) bool {
// if this is false, errors.As will call unwrap and retry on the wrapped
// error.
return errors.As(f.mark, target)
}
func (f marked) Unwrap() error {
return f.wrapped
}
func (f marked) Error() string {
return f.mark.Error() + ": " + f.wrapped.Error()
}
