Package errors implements various utility functions and types around errors.



    This section is empty.


    View Source
    var ErrPreconditionViolated = errors.New("precondition is violated")

      ErrPreconditionViolated is returned when the precondition is violated


      func FilterOut

      func FilterOut(err error, fns ...Matcher) error

        FilterOut removes all errors that match any of the matchers from the input error. If the input is a singular error, only that error is tested. If the input implements the Aggregate interface, the list of errors will be processed recursively.

        This can be used, for example, to remove known-OK errors (such as io.EOF or os.PathNotFound) from a list of errors.

        func Reduce

        func Reduce(err error) error

          Reduce will return err or, if err is an Aggregate and only has one item, the first item in the aggregate.


          type Aggregate

          type Aggregate interface {
          	Errors() []error
          	Is(error) bool

            Aggregate represents an object that contains multiple errors, but does not necessarily have singular semantic meaning. The aggregate can be used with `errors.Is()` to check for the occurrence of a specific error type. Errors.As() is not supported, because the caller presumably cares about a specific error of potentially multiple that match the given type.

            func AggregateGoroutines

            func AggregateGoroutines(funcs ...func() error) Aggregate

              AggregateGoroutines runs the provided functions in parallel, stuffing all non-nil errors into the returned Aggregate. Returns nil if all the functions complete successfully.

              func CreateAggregateFromMessageCountMap

              func CreateAggregateFromMessageCountMap(m MessageCountMap) Aggregate

                CreateAggregateFromMessageCountMap converts MessageCountMap Aggregate

                func Flatten

                func Flatten(agg Aggregate) Aggregate

                  Flatten takes an Aggregate, which may hold other Aggregates in arbitrary nesting, and flattens them all into a single Aggregate, recursively.

                  func NewAggregate

                  func NewAggregate(errlist []error) Aggregate

                    NewAggregate converts a slice of errors into an Aggregate interface, which is itself an implementation of the error interface. If the slice is empty, this returns nil. It will check if any of the element of input error list is nil, to avoid nil pointer panic when call Error().

                    type Matcher

                    type Matcher func(error) bool

                      Matcher is used to match errors. Returns true if the error matches.

                      type MessageCountMap

                      type MessageCountMap map[string]int

                        MessageCountMap contains occurrence for each error message.

                        Source Files