Multi tool use

How to avoid re-implementing sort.Interface for similar golang structs

There is one problem bothering me in Golang.
Say I have 2 structs:

type Dog struct {
Name string
Breed string
Age int
}

type Cat struct {
Name string
FavoriteFood string
Age int
}


And when I try to sort *Dog and *Cat by Age, I have to define 2 different sort struct like:

*Dog

*Cat

Age

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 {//..}


A natural thought is to implement some SortableByAge interface and create a Less function using the interface function. Like:

SortableByAge

Less

type SortableByAge interface {
AgeValue() int
}


And then:

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


However, according to:
http://golang.org/doc/faq#convert_slice_of_interface

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


Above is not possible.

So I wonder what is the best practice for this case and

Is there any other technique that can reduce the need for implementing the sort.Interface for similar structs again and again that I have missed?

sort.Interface

EDIT:
I realized that my examples are terrible :(

In real life case, these 2 structs are very different, the only thing in common between them is that I wish to sort them by a common numeric value.

A better example would be:

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


And the only thing these 2 structs share in common is that I wish to sort a slice(agh... should not have used Pizza in example) of them by price.

Pizza

So, combining them to a common struct is not really working for a lot of cases.
But will look into go generate.

type Animal { Species, Name string; Age int }

3 Answers
3

In this specific case you shouldn't use 2 different types as they are identical, just use a common Animal type:

Animal

type Animal struct {
Name string
Age int
}

func (a Animal) String() string { return fmt.Sprintf("%s(%d)", a.Name, a.Age) }

type SortAnim *Animal

func (c SortAnim) Len() int { return len(c) }
func (c SortAnim) Swap(i, j int) { c[i], c[j] = c[j], c[i] }
func (c SortAnim) Less(i, j int) bool { return c[i].Age < c[j].Age }

func main() {
dogs := *Animal{&Animal{"Max", 4}, &Animal{"Buddy", 3}}
cats := *Animal{&Animal{"Bella", 4}, &Animal{"Kitty", 3}}

fmt.Println(dogs)
sort.Sort(SortAnim(dogs))
fmt.Println(dogs)

fmt.Println(cats)
sort.Sort(SortAnim(cats))
fmt.Println(cats)
}


Output (Go Playground):

[Max(4) Buddy(3)]
[Buddy(3) Max(4)]
[Bella(4) Kitty(3)]
[Kitty(3) Bella(4)]


In general you can only use a common sorting implementation if you're willing to give up concrete types and use interface types instead.

Create the interface type you want your slice to hold:

type Animal interface {
Name() string
Age() int
}


You can have a common implementation of this:

type animal struct {
name string
age int
}

func (a *animal) Name() string { return a.name }
func (a *animal) Age() int { return a.age }
func (a animal) String() string { return fmt.Sprintf("%s(%d)", a.name, a.age) }


Your specific animal types:

type Dog struct {
animal // Embed animal (its methods and fields)
}

type Cat struct {
animal // Embed animal (its methods and fields)
}


You implement sort.Interface on SortAnim:

sort.Interface

SortAnim

type SortAnim Animal

func (c SortAnim) Len() int { return len(c) }
func (c SortAnim) Swap(i, j int) { c[i], c[j] = c[j], c[i] }
func (c SortAnim) Less(i, j int) bool { return c[i].Age() < c[j].Age() }


Using it:

dogs := SortAnim{&Dog{animal{"Max", 4}}, &Dog{animal{"Buddy", 3}}}
cats := SortAnim{&Cat{animal{"Bella", 4}}, &Cat{animal{"Kitty", 3}}}

fmt.Println(dogs)
sort.Sort(SortAnim(dogs))
fmt.Println(dogs)

fmt.Println(cats)
sort.Sort(SortAnim(cats))
fmt.Println(cats)


Output (Go Playground):

[Max(4) Buddy(3)]
[Buddy(3) Max(4)]
[Bella(4) Kitty(3)]
[Kitty(3) Bella(4)]


Note: as illustrated in commit ad26bb5, in Go 1.8 (Q1 2017), you won't have to implement Len() and Swap() and Less() since issue 16721 was resolved. Only Less() is needed, the rest is done by reflection.

Len()

Swap()

Less()

Less()

The problem was:

Len

Swap

See the new sort.go:

sort.go

// Slice sorts the provided slice given the provided less function.
//
// The sort is not guaranteed to be stable. For a stable sort, use
// SliceStable.
//
// The function panics if the provided interface is not a slice.
func Slice(slice interface{}, less func(i, j int) bool) {
rv := reflect.ValueOf(slice)
swap := reflect.Swapper(slice)
length := rv.Len()
quickSort_func(lessSwap{less, swap}, 0, length, maxDepth(length))
}


So as long as you have a Less() function comparing two instances respecting an interface, you can sort any number of struct respecting said common interface.

Less()

sort.Slice(a, func(i, j int) bool { return a[i] < a[j] })

a[i] > a[j]

The best practice for this case would be to define

type Animal struct{
Species,Name string
Age int
}


as suggested by twotwotwo. If cat and dog are similar enough to be sorted in the same way, they are also similar enough to be the same struct. If they are different in some way, then you should reimplement the interface for each type.

An alternative could be to copy all pointers from your *Cat slice into a SortableByAge slice of the same size. If you are going to sort the slice, that will take O(n*log(n)) so an extra O(n) shouldn't be a performance issue.

*Cat

SortableByAge

A third alternative, in the rare event that you have many types that for some reason have to be distinct but still have very simple sorting functions, you can look at autogenerating them with go generate.

By clicking "Post Your Answer", you acknowledge that you have read our updated terms of service, privacy policy and cookie policy, and that your continued use of the website is subject to these policies.