Come aggiungere nuovi metodi a un tipo esistente in Go?

Voglio aggiungere un metodo util convenienza su gorilla/muxtipi di route e router:

package util

import(
    "net/http"
    "github.com/0xor1/gorillaseed/src/server/lib/mux"
)

func (r *mux.Route) Subroute(tpl string, h http.Handler) *mux.Route{
    return r.PathPrefix("/" + tpl).Subrouter().PathPrefix("/").Handler(h)
}

func (r *mux.Router) Subroute(tpl string, h http.Handler) *mux.Route{
    return r.PathPrefix("/" + tpl).Subrouter().PathPrefix("/").Handler(h)
}

ma il compilatore mi informa

Impossibile definire nuovi metodi su tipo non locale mux.Router

Quindi come potrei raggiungere questo obiettivo? Posso creare un nuovo tipo di struttura con campi anonimi mux.Route e mux.Router? O qualcos'altro?

Come menzionato dal compilatore, non è possibile estendere i tipi esistenti in un altro pacchetto. È possibile definire il proprio alias o pacchetto secondario come segue:

type MyRouter mux.Router

func (m *MyRouter) F() { ... }

o incorporando il router originale:

type MyRouter struct {
    *mux.Router
}

func (m *MyRouter) F() { ... }

...
r := &MyRouter{router}
r.F()

Volevo ampliare la risposta data da @jimt qui . Questa risposta è corretta e mi ha aiutato moltissimo a risolvere questo problema. Tuttavia, ci sono alcuni avvertimenti su entrambi i metodi (alias, embed) con i quali ho avuto problemi.

nota : uso i termini genitore e figlio, anche se non sono sicuro che sia il migliore per composizione. Fondamentalmente, parent è il tipo che si desidera modificare localmente. Child è il nuovo tipo che tenta di implementare quella modifica.

Metodo 1 - Digitare la definizione

type child parent
// or
type MyThing imported.Thing

• Fornisce accesso ai campi.
• Non fornisce accesso ai metodi.

Metodo 2 - Incorporamento ( documentazione ufficiale )

type child struct {
    parent
}
// or with import and pointer
type MyThing struct {
    *imported.Thing
}

• Fornisce accesso ai campi.
• Fornisce accesso ai metodi.
• Richiede considerazione per l'inizializzazione.

Sommario

• Utilizzando il metodo di composizione, il genitore incorporato non verrà inizializzato se si tratta di un puntatore. Il genitore deve essere inizializzato separatamente.
• Se il genitore incorporato è un puntatore e non è inizializzato quando il figlio è inizializzato, si verificherà un errore di dereference del puntatore zero.
• Sia la definizione del tipo che i casi di incorporamento forniscono accesso ai campi del genitore.
• La definizione del tipo non consente l'accesso ai metodi del genitore, ma lo incorpora il genitore.

Puoi vederlo nel seguente codice.

esempio funzionante nel parco giochi

package main

import (
    "fmt"
)

type parent struct {
    attr string
}

type childAlias parent

type childObjParent struct {
    parent
}

type childPointerParent struct {
    *parent
}

func (p *parent) parentDo(s string) { fmt.Println(s) }
func (c *childAlias) childAliasDo(s string) { fmt.Println(s) }
func (c *childObjParent) childObjParentDo(s string) { fmt.Println(s) }
func (c *childPointerParent) childPointerParentDo(s string) { fmt.Println(s) }

func main() {
    p := &parent{"pAttr"}
    c1 := &childAlias{"cAliasAttr"}
    c2 := &childObjParent{}
    // When the parent is a pointer it must be initialized.
    // Otherwise, we get a nil pointer error when trying to set the attr.
    c3 := &childPointerParent{}
    c4 := &childPointerParent{&parent{}}

    c2.attr = "cObjParentAttr"
    // c3.attr = "cPointerParentAttr" // NOGO nil pointer dereference
    c4.attr = "cPointerParentAttr"

    // CAN do because we inherit parent's fields
    fmt.Println(p.attr)
    fmt.Println(c1.attr)
    fmt.Println(c2.attr)
    fmt.Println(c4.attr)

    p.parentDo("called parentDo on parent")
    c1.childAliasDo("called childAliasDo on ChildAlias")
    c2.childObjParentDo("called childObjParentDo on ChildObjParent")
    c3.childPointerParentDo("called childPointerParentDo on ChildPointerParent")
    c4.childPointerParentDo("called childPointerParentDo on ChildPointerParent")

    // CANNOT do because we don't inherit parent's methods
    // c1.parentDo("called parentDo on childAlias") // NOGO c1.parentDo undefined

    // CAN do because we inherit the parent's methods
    c2.parentDo("called parentDo on childObjParent")
    c3.parentDo("called parentDo on childPointerParent")
    c4.parentDo("called parentDo on childPointerParent")
}