func Skip(err error, skippers ...Skipper) error {
	switch serr := err.(type) {
	case nil:
		return nil
	case errors:
		var n []string
		errs := serr.Errors()
		for _, e := range errs {
			if !skip(e, skippers) {
				n = append(n, e)
			}
		}
		if len(n) == 0 {
			return nil
		}
		return checkers.Error(n...)
	default:
		if skip(serr.Error(), skippers) {
			return nil
		}
		return serr
	}
}
Skip filters errors using skippers.  If err satisfies the below interface

type errors interface {
Errors() []string
}

the filters are applied to each string returned by Errors and then concatenated.
If the error implements the above interface, it is guaranteed that any returned
error will also implement the same.

Skippers are run in the order provided and a single
skipper returning true will result in that error being skipped.
package lint
import (
	"regexp"
	"github.com/surullabs/lint/checkers"
)
type Skipper interface {
	Skip(err string) bool
}
type StringSkipper struct {
	Strings []string
	Matcher func(err, str string) bool
}
func (s StringSkipper) Skip(check string) bool {
	for _, str := range s.Strings {
		if s.Matcher(check, str) {
			return true
		}
	}
	return false
}
func skip(check string, skippers []Skipper) bool {
	for _, s := range skippers {
		if s.Skip(check) {
			return true
		}
	}
	return false
}