Golang RedirectHandler() returns interface, ends up with *http.redirectHandler

Please do not be aggressive with my post, I am trying to learn Go, but facing some challenges in my understanding.

This is my sample code:

package main

import (
        "log"
        "net/http"
        "reflect"
        "fmt"
)

func main() {
        mux := http.NewServeMux()

        rh := http.RedirectHandler("http://example.org", 307)
        fmt.Println("The type of the object, returned by the RedirectHandler is")
        fmt.Println(reflect.TypeOf(rh))
        fmt.Println("End with type observation")
        mux.Handle("/foo", rh)

        log.Println("Listening ...")
        http.ListenAndServe(":3000", mux)
}

My questions are:

1. RedirectHandler returns a Handler interface, is this a common pattern and what is the benefit ?
2. Does that mean that the inside the function you schould have a struct that implements that interface and then return the struct ? If not, how in the world do we return an interface, as essentially it's just a set of non-implemented methods ?
3. If you run my code, you would see that the type of the variable 'rh' is *http.redirectHandler. For such a pointer I am not able to find anything in the http package, so we started from 'returns an interface' to end up with 'here's your pointer, that does not exists in the doc'.
4. Those are just my confusing thoughts, I would appreciate comments who want to help me with my confusion.

> 1. RedirectHandler returns a Handler interface, is this a common pattern and what is the benefit?

While there is a rule of thumb to return concrete types instead of interfaces (often stated as "Accept interfaces return structs"), it is sometimes desirable to hide the implementation, for any number of reasons. One of them is to be free to change the implementation in any way in future versions of a package. Another is to prevent misuse of the return value; accessing struct fields concurrently, for instance.

Making all these functions (RedirectHandler, NotFoundHandler, TimeoutHandler, etc.) return http.Handler also makes them easily discoverable in the docs: they all appear together as constructors for http.Handler instead of scattered around in the list of functions. I'm assuming (!) that may have played a role when deciding to do it this way, but you'd have to ask the authors (you can do this on the mailing list).

> 2. Does that mean that [RedirectHandler returns] a struct that implements that interface?

Maybe. It can also return any other type that implements the interface, although it is indeed a struct type in Go 1.15. But that can change, precisely because the function returns an interface instead of a concrete type.

> 3. If you run my code, you would see that the type of the variable 'rh' is *http.redirectHandler. For such a pointer I am not able to find anything in the http package.

The docs for unexported identifiers are not rendered by default (because you can't use them anyway). Add m=all to the query string to show them: https://golang.org/pkg/net/http/?m=all#redirectHandler