Golang embed an interface with additional hidden methods?

I want to embed a http.ResponseWriter in a struct. That's fine, it makes sure my struct also implements http.ResponseWriter:

type MyWriter struct {
    BytesWritten int
    http.ResponseWriter
}

However, it no longer implements http.Hijacker, http.CloseNotifier or http.Flusher even though the embedded http.ResponseWriter usually does.

Is there some way to do this?

If you know that the response writer satisfies all of the interfaces listed in the question, then you can do this:

type allResponseWriterInterfaces {
    http.ResponseWriter
    http.Hijacker
    http.CloseNotifier
    http.Flusher
}

type MyWriter struct {
    BytesWritten int
    allResponseWriterInterfaces
}

...

aw, ok := w.(allResponseWriterInterfaces)
if !ok {
    // oops, response writer does not implement the interfaces
    // handle the error
}
mw := MyWriter{0, aw}

It get's messy if the response writer does not satisfy all of the interfaces. See the Gorilla logger for an example of handling the case where the response writer satisfies (http.ResponseWriter, http.CloseNotifier) or (http.ResponseWriter, http.CloseNotifier, http.Hijacker).

One solution is the brute-force solution. Actually implement all permutations. I tried this and found out how painful it is. There are 18 permutations!

So here is a general-purpose wrapper. The advantage is that you can re-use this wrapper as many times as you want.

The key is to define an interface like so:

// ResponseWriterTo can proxy requests to an underlying http.ResponseWriter.
// It is used with CustomResponseWriter to wrap an http.ResponseWriter with
// custom behavior.
type ResponseWriterTo interface {
    HeaderTo(w http.ResponseWriter) http.Header
    WriteHeaderTo(w http.ResponseWriter, s int)
    WriteTo(w http.ResponseWriter, b []byte) (n int, err error)

    // Additional methods that http.ResponseWriter sometimes implements.
    CloseNotifyTo(w http.CloseNotifier) <-chan bool
    FlushTo(w http.Flusher)
    HijackTo(w http.Hijacker) (net.Conn, *bufio.ReadWriter, error)

    // ReaderFrom is used by the http package to optimize reads from TCP
    // connections or from files.
    ReadFromTo(w io.ReaderFrom, r io.Reader) (n int64, err error)
}

so that we can define a custom wrapper function (this is the verbose part):

// CustomResponseWriter creates a http.ResponseWriter that implements as many
// hidden interfaces from the base http.ResponseWriter as are available.
func CustomResponseWriter(base http.ResponseWriter, custom ResponseWriterTo) http.ResponseWriter {
    rw := &customResponseWriter{base: base, custom: custom}

    // the base http.ResponseWriter can implement many hidden interfaces,
    // so check all permutations

    type HCFR interface {
        http.ResponseWriter
        http.Hijacker
        http.CloseNotifier
        http.Flusher
        io.ReaderFrom
    }
    if _, ok := base.(HCFR); ok {
        return struct {
            HCFR
        }{rw}
    }

    type HCF interface {
        http.ResponseWriter
        http.Hijacker
        http.CloseNotifier
        http.Flusher
    }
    if _, ok := base.(HCF); ok {
        return struct {
            HCF
        }{rw}
    }

    type HCR interface {
        http.ResponseWriter
        http.Hijacker
        http.CloseNotifier
        io.ReaderFrom
    }
    if _, ok := base.(HCR); ok {
        return struct {
            HCR
        }{rw}
    }

    type HFR interface {
        http.ResponseWriter
        http.Hijacker
        http.Flusher
        io.ReaderFrom
    }
    if _, ok := base.(HFR); ok {
        return struct {
            HFR
        }{rw}
    }

    type CFR interface {
        http.ResponseWriter
        http.CloseNotifier
        http.Flusher
        io.ReaderFrom
    }
    if _, ok := base.(CFR); ok {
        return struct {
            CFR
        }{rw}
    }

    type HC interface {
        http.ResponseWriter
        http.Hijacker
        http.CloseNotifier
    }
    if _, ok := base.(HC); ok {
        return struct {
            HC
        }{rw}
    }

    type HF interface {
        http.ResponseWriter
        http.Hijacker
        http.Flusher
    }
    if _, ok := base.(HF); ok {
        return struct {
            HF
        }{rw}
    }

    type CF interface {
        http.ResponseWriter
        http.CloseNotifier
        http.Flusher
    }
    if _, ok := base.(CF); ok {
        return struct {
            CF
        }{rw}
    }

    type HR interface {
        http.ResponseWriter
        http.Hijacker
        io.ReaderFrom
    }
    if _, ok := base.(HR); ok {
        return struct {
            HR
        }{rw}
    }

    type CR interface {
        http.ResponseWriter
        http.CloseNotifier
        io.ReaderFrom
    }
    if _, ok := base.(CR); ok {
        return struct {
            CR
        }{rw}
    }

    type FR interface {
        http.ResponseWriter
        http.Flusher
        io.ReaderFrom
    }
    if _, ok := base.(FR); ok {
        return struct {
            FR
        }{rw}
    }

    type H interface {
        http.ResponseWriter
        http.Hijacker
    }
    if _, ok := base.(H); ok {
        return struct {
            H
        }{rw}
    }

    type C interface {
        http.ResponseWriter
        http.CloseNotifier
    }
    if _, ok := base.(C); ok {
        return struct {
            C
        }{rw}
    }

    type F interface {
        http.ResponseWriter
        http.Flusher
    }
    if _, ok := base.(F); ok {
        return struct {
            F
        }{rw}
    }

    type R interface {
        http.ResponseWriter
        io.ReaderFrom
    }
    if _, ok := base.(R); ok {
        return struct {
            R
        }{rw}
    }

    return struct {
        http.ResponseWriter
    }{rw}
}

// customResponseWriter allows us to adapt a ResponseWriterTo to a ResponseWriter.
type customResponseWriter struct {
    base   http.ResponseWriter
    custom ResponseWriterTo
}

func (w *customResponseWriter) Header() http.Header         { return w.custom.HeaderTo(w.base) }
func (w *customResponseWriter) Write(b []byte) (int, error) { return w.custom.WriteTo(w.base, b) }
func (w *customResponseWriter) WriteHeader(s int)           { w.custom.WriteHeaderTo(w.base, s) }
func (w *customResponseWriter) CloseNotify() <-chan bool {
    return w.custom.CloseNotifyTo(w.base.(http.CloseNotifier))
}
func (w *customResponseWriter) Flush() { w.custom.FlushTo(w.base.(http.Flusher)) }
func (w *customResponseWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
    return w.custom.HijackTo(w.base.(http.Hijacker))
}
func (w *customResponseWriter) ReadFrom(r io.Reader) (n int64, err error) {
    return w.custom.ReadFromTo(w.base.(io.ReaderFrom), r)
}

The idea is to embed the correct interface into a struct. Then only the "right" methods are exposed.