code: func Is(e error, originals ...error) bool {
  	is := func(e, original error) bool {
  		for {
  			if e == original {
  				return true
  			}
  			if e == nil || original == nil {
  				return false
  			}
  			w, ok := e.(*merryErr)
  			if !ok {
  				return false
  			}
  			e = w.err
  		}
  	}
  	for _, o := range originals {
  		if is(e, o) {
  			return true
  		}
  	}
  	// check cause
  	if c := Cause(e); c != nil {
  		return Is(c, originals...)
  	}
  
  	return false
  }
docs: // Is checks whether e is equal to or wraps the original, at any depth.
  // If e == nil, return false.
  // This is useful if your package uses the common golang pattern of
  // exported error constants.  If your package exports an ErrEOF constant,
  // which is initialized like this:
  //
  //     var ErrEOF = errors.New("End of file error")
  //
  // ...and your user wants to compare an error returned by your package
  // with ErrEOF:
  //
  //     err := urpack.Read()
  //     if err == urpack.ErrEOF {
  //
  // ...the comparison will fail if the error has been wrapped by merry
  // at some point.  Replace the comparison with:
  //
  //     if merry.Is(err, urpack.ErrEOF) {
  //
  // Causes
  //
  // Is will also return true if any of the originals is in the cause chain
  // of e.  For example:
  //
  //     e1 := merry.New("base error")
  //     e2 := merry.New("library error")
  //     // e2 was caused by e1
  //     e3 := merry.WithCause(e1, e2)
  //     merry.Is(e3, e2)  // yes it is, because e3 is based on e2
  //     merry.Is(e3, e1)  // yes it is, because e1 was a cause of e3
  //