use errors.AsType for error assertions

Author: marten-seemann

content/docs/connect-udp/proxy.md

@@ -35,8 +35,7 @@ http.Handle("/masque", func(w http.ResponseWriter, r *http.Request) {
   // parse the UDP proxying request
   mreq, err := masque.ParseRequest(r, t)
   if err != nil {
-    var perr *masque.RequestParseError
-    if errors.As(err, &perr) {
+    if perr, ok := errors.AsType[*masque.RequestParseError](err); ok {
       w.WriteHeader(perr.HTTPStatus)
       return
     }

content/docs/quic/connection.md

@@ -117,32 +117,23 @@ The most common way to handle an error is by interface-asserting it to `net.Erro
 The following example shows how to inspect an error in detail:
 
 ```go
-var (
-  statelessResetErr   *quic.StatelessResetError
-  handshakeTimeoutErr *quic.HandshakeTimeoutError
-  idleTimeoutErr      *quic.IdleTimeoutError
-  appErr              *quic.ApplicationError
-  transportErr        *quic.TransportError
-  vnErr               *quic.VersionNegotiationError
-)
-switch {
-case errors.As(err, &statelessResetErr):
+if _, ok := errors.AsType[*quic.StatelessResetError](err); ok {
   // stateless reset
-case errors.As(err, &handshakeTimeoutErr):
+} else if _, ok := errors.AsType[*quic.HandshakeTimeoutError](err); ok {
   // connection timed out before completion of the handshake
-case errors.As(err, &idleTimeoutErr):
+} else if _, ok := errors.AsType[*quic.IdleTimeoutError](err); ok {
   // idle timeout
-case errors.As(err, &appErr):
+} else if appErr, ok := errors.AsType[*quic.ApplicationError](err); ok {
   // application error
   remote := appErr.Remote             // was the error triggered by the peer?
   errorCode := appErr.ErrorCode       // application-defined error code
   errorMessage := appErr.ErrorMessage // application-defined error message
-case errors.As(err, &transportErr):
+} else if transportErr, ok := errors.AsType[*quic.TransportError](err); ok {
   // transport error
   remote := transportErr.Remote             // was the error triggered by the peer?
   errorCode := transportErr.ErrorCode       // error code (RFC 9000, section 20.1)
   errorMessage := transportErr.ErrorMessage // error message
-case errors.As(err, &vnErr):
+} else if vnErr, ok := errors.AsType[*quic.VersionNegotiationError](err); ok {
   // version negotation error
   ourVersions := vnErr.Ours     // locally supported QUIC versions
   theirVersions := vnErr.Theirs // QUIC versions support by the remote

content/docs/quic/streams.md

@@ -115,8 +115,7 @@ When a stream is reset (i.e. when `CancelRead` or `CancelWrite` are used), appli
 QUIC itself does not interpret this value; instead, it is the responsibility of the application layer to assign specific meanings to different error codes. 
 
 ```go
-var streamErr *quic.StreamError
-if errors.As(err, &streamErr) {
+if streamErr, ok := errors.AsType[*quic.StreamError](err); ok {
   errorCode := streamErr.ErrorCode
 }
 ```

content/docs/webtransport/session.md

@@ -23,8 +23,7 @@ Similar to closing a `quic.Conn`, this action causes all calls to `AcceptStream`
 
 On the receiver side, this error will be surfaced as a `webtransport.SessionError`:
 ```go
-var sessErr *webtransport.SessionError
-if errors.As(err, &sessErr) {
+if sessErr, ok := errors.AsType[*webtransport.SessionError](err); ok {
   errorCode := sessErr.ErrorCode
   errorMessage := sessErr.Message
 }

content/docs/webtransport/streams.md

@@ -18,8 +18,7 @@ WebTransport itself does not interpret this value; instead, it is the responsibi
 Below is an example of how to type-assert an error as a `webtransport.StreamError`:
 
 ```go
-var streamErr *webtransport.StreamError
-if errors.As(err, &streamErr) {
+if streamErr, ok := errors.AsType[*webtransport.StreamError](err); ok {
   errorCode := streamErr.ErrorCode
 }
 ```