The errors proposal introduces a new paradigm for inspecting wrapped errors.

var target *Type
if errors.As(err, &target) {
   ...
}

I love this new paradigm and I think it should be extended to any interface. The one that immediately comes to my mind that would benefit is http.ResponseWrapper.
http.ResponseWriter interface has 3 methods, but there are 5 other methods that the underlying type can implement:
http.CloseNotifier, http.Flusher, http.Hijacker, io.ReaderFrom, http.Pusher

There are 2 "easy" ways to address this: a wrapping type can either expose them directly, and if the underlying type doesn't implement them, the method becomes a no-op; or the wrapping type can expose the original ResponseWriter, but this may leak functionality.

func (wrapped http.ResponseWriter, r *http.Request) {
  if w, ok := wrapped.(interface{ ResponseWriter() http.ResponseWriter }); ok {
    if f, ok := w.ResponseWriter().(http.Flusher); ok {
      f.Flush()
    }
    // w.ResponseWriter().Write() can now also be called, which might break the purpose of the wrapper in the first place.
  }
}

This nested wrapping looks very similar to the errors problem. But what if the wrapper was written like this?

type MyLoggingWriter struct {
  http.ResponseWriter
  length int
}

func (w *MyLoggingWriter) As(type interface{}) bool {
  return As(w.ResponseWriter, type)
}

// also would override Write() method to record num bytes written
...

func (wrapped http.RepsonseWriter, r *http.Request) {
  if h := new(http.Hijacker); As(wrapped, &h) {
    // now you can hijack the session
  }
}

Some unknowns about this proposal:

• the new As method needs a package. I originally thought of reflect but that would mean pulling in reflect pkg a lot more.
• This introduces another way of doing type assertions, which in general, the go community frowns upon.

I think the real power in the As method in how it allows the input type to define it's own As(interface{}) method. We could do without a generalized method and just have the paradigm that wrapping interfaces implement an As unwrapper. An implementation would look something like this:

func (w *MyLoggingWriter) As(v interface{}) bool {
  switch x := v.(type) {
  case **http.Hijacker:
    if h, ok := w.ResponseWriter.(http.Hijacker); ok {
      *x = &h
      return true
    }
    // ... repeat for all the others you want to implement
}

This is tedious and not future proof. However, a generalized method depends on reflection.
Maybe a hybrid approach could be take where libraries that don't want to pull in reflection can implement it manually like above. I would note that the current errors proposal depends on reflection and that it would probably be used just as often. I think that this also allows for optimizations in the future where reflection could potentially be removed and the interface be unchanged.

Some corollaries:

• I think the Is and Unwrap functions are superfluous, but I haven't totally thought through that.

Isn't errors.Is(err, syscall.EADDRNOTAVAIL) the same as: As(err, syscall.EADDRNOTAVAIL) if err sufficiently implements As(type interface)?