Há um problema me incomodando em Golang. Digamos que eu tenha 2 estruturas:

type Dog struct {
   Name string
   Breed string
   Age int
}

type Cat struct {
    Name string
    FavoriteFood string
    Age int
}

E quando eu tento classificar[]*Dog e[]*Cat porAge, Eu tenho que definir duas estruturas de classificação 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 {//..}

Um pensamento natural é implementar algumasSortableByAge interface e crie umLess função usando a função de interface. Gostar:

type SortableByAge interface {
    AgeValue() int
}

E depois:

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

No entanto, de acordo com:http://golang.org/doc/faq#convert_slice_of_interface

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

Acima não é possível.

Então, eu me pergunto qual é a melhor prática para este caso e

Existe alguma outra técnica que possa reduzir a necessidade de implementar osort.Interface por estruturas semelhantes repetidamente que eu perdi?

EDIT: percebi que meus exemplos são terríveis :(

No caso da vida real, essas duas estruturas são muito diferentes, a única coisa em comum entre elas é que desejo classificá-las por um valor numérico comum.

Um exemplo melhor seria:

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

E a única coisa que essas duas estruturas compartilham em comum é que eu gostaria de classificar uma fatia (agh ... não deveria ter usadoPizza no exemplo) deles por preço.

Portanto, combiná-los com uma estrutura comum não está funcionando para muitos casos. Mas vai olhar para ir gerar.