Cómo evitar volver a implementar el ordenamiento. Interfaz para estructuras de golang similares

Hay un problema que me molesta en Golang. Digamos que tengo 2 estructuras:

type Dog struct {
   Name string
   Breed string
   Age int
}

type Cat struct {
    Name string
    FavoriteFood string
    Age int
}

Y cuando trato de ordenar[]*Dog y[]*Cat porAge, Tengo que definir 2 estructuras de clasificación diferentes como:

type SortCat []*Cat
func (c SortCat) Len() int {//..}
func (c SortCat) Swap(i, j int) {//..}
func (c SortCat) Less(i, j int) bool {//..}

type SortDog []*Dog
func (c SortDog) Len() int {//..}
func (c SortDog) Swap(i, j int) {//..}
func (c SortDog) Less(i, j int) bool {//..}

Un pensamiento natural es implementar algunosSortableByAge interfaz y crear unLess función utilizando la función de interfaz. Me gusta:

type SortableByAge interface {
    AgeValue() int
}

Y entonces:

type SortAnimal []SortableByAge
func (c SortDog) Less(i, j int) bool {
    return c[i].AgeValue() < c[j].AgeValue() 
}

Sin embargo, de acuerdo con:http://golang.org/doc/faq#convert_slice_of_interface

dogs := make([]*Dogs, 0 , 1)
//add dogs here
sort.Sort(SortAnimal(dogs))

Arriba no es posible.

Así que me pregunto cuál es la mejor práctica para este caso y

¿Existe alguna otra técnica que pueda reducir la necesidad de implementar elsort.Interface para estructuras similares una y otra vez que me he perdido?

EDITAR: me di cuenta de que mis ejemplos son terribles :(

En el caso de la vida real, estas 2 estructuras son muy diferentes, lo único en común entre ellas es que deseo ordenarlas por un valor numérico común.

Un mejor ejemplo sería:

type Laptop {//...}
type Pizza {//...}

Y lo único que estas 2 estructuras comparten en común es que deseo ordenar una porción (agh ... no debería haber usadoPizza en ejemplo) de ellos por precio.

Por lo tanto, combinarlos con una estructura común no funciona realmente en muchos casos. Pero se verá en ir a generar.