如何在Golang中将功能扩展到导入的类型

I have an imported type

type ExternalType struct {
   quantity int
}


type ExternalArray []*ExternalType

I want to be able to implement the sort interface for ExternalArray for so that I sort it by quantity.

However, I am not sure how I could do that?

A concrete example is this:

https://play.golang.org/p/bEPtJ8NHQK

Define a type in the current package that sorts a slice with the same element type as the imported type:

type byQuantity []*pkg.ExternalType

func (a byQuantity) Len() int           { return len(a) }
func (a byQuantity) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a byQuantity) Less(i, j int) bool { return a[i].Quantity < a[j].Quantity }

Convert the imported slice type value to the type defined above and sort:

a := pkg.ExternalArray{{1}, {3}, {2}}
sort.Sort(byQuantity(a))
// a is now sorted by quantity

Because the original slice and the converted slice share the same backing array, sort on the converted slice also sorts the original slice.

playground example

The sort.Interface defines three methods which must be implemented:

// Len is the number of elements in the collection.
Len() int

// Less reports whether the element with
// index i should sort before the element with index j.
Less(i, j int) bool

// Swap swaps the elements with indexes i and j.
Swap(i, j int)

In this context this would look something like:

type ExternalType struct {
   quantity int
}

type ExternalArray []*ExternalType

func (ea ExternalArray) Len() int {
    return len(ea)
}

func (ea ExternalArray) Less(i, j int) bool {
    return ea[i].quantity < ea[j].quantity
}

func (ea ExternalArray) Swap(i, j int) {
    ea[i], ea[j] = ea[j], ea[i]
}

In order to do the sort you can then use sort.Sort, for example:

arr := ExternalArray{
    &ExternalType{quantity: 33},
    &ExternalType{quantity: 44},
    &ExternalType{quantity: 22},
    &ExternalType{quantity: 11},
}

sort.Sort(arr)
// `arr` is now sorted :-)

Here is a working example in the playground.