proposal: cmp: add `CompareBy` function

[coady]

Proposal Details

An addition to the cmp package to support a common use case in ordered comparison.

func CompareBy[K cmp.Ordered, V any](key func(V) K) func(V, V) int {
	return func(a, b V) int { return cmp.Compare(key(a), key(b)) }
}

The majority of custom comparison functions apply the same transformation to each element. Analogous to Python's key functions, and would integrate well with Reverse proposed in #65632.

[gabyhelp]

Related Issues

• proposal: cmp: add Reverse function #65632
• proposal: cmp: add CompareBool #61643 (closed)
• proposal: cmp: Equal #70161 (closed)
• cmp: new package with Ordered, Compare, Less; min, max as builtins #59488 (closed)

_{(Emoji vote if this was helpful or unhelpful; more detailed feedback welcome in this discussion.)}

[ianlancetaylor]

It would help to show a couple of examples from the standard library or elsewhere where existing code could be changed to use the proposed function. Would the result look better? Thanks.

[krishpranav]

Message to Maintainer:

Hello 👋,

I would like to submit a proposal for integrating the new CompareBy function into the cmp package. This feature aims to provide a flexible and efficient way to compare ordered values by applying a custom key function, similar to Python’s key function. It simplifies sorting, comparisons, and data handling by allowing developers to define how values should be compared. 🔄

Key Details:

• The CompareBy function enhances Go's cmp package by allowing custom key functions for comparisons. 🔑
• It integrates seamlessly with existing features like Reverse for even more advanced use cases. 🔁
• This change solves a common problem where developers need to apply a transformation to each element before comparison, which is currently not possible with the standard cmp.Compare function. 🧩

Relevant PR:

• This PR is related to 🚀 cmp: Unleash the Power of Custom Comparisons with the CompareBy Function! 🔥💥 #71241, which discusses the need for a flexible comparison function in the Go standard library. 📝

I’ve included test cases to ensure the new function works as expected, and the results are passing successfully.
✅ I’m confident this feature will significantly improve the flexibility of Go’s cmp package for ordered comparisons. 🚀

Looking forward to your feedback! 🙏💬

Thanks :)

• Krisna Pranav aka krishpranav

[gopherbot]

Change https://go.dev/cl/642395 mentions this issue: 🚀 cmp: Unleash the Power of Custom Comparisons with the CompareBy Function! 🔥💥

[earthboundkid]

From the proposed doc string:

sort.Slice(people, cmp.CompareBy(func(p Person) int { return p.Age }))

Presumably that was supposed to be slices.SortFunc. I don't think it looks better than slices.SortFunc(people, func(a, b Person) int { return cmp.Compare(a.Age, b.Age) }). It also lets you do a reversal by doing cmp.Compare(b.Age, a.Age) or chain comparisons with cmp.Or.

[dils2k]

I don't quite understand the use cases. In #71241 a use case that you mentioned is sorting an array of structs. But is the code below not what you are trying to do?

type Person struct {
	age int
}

ppl := []Person{{age: 2}, {age: 1}}
slices.SortFunc(ppl, func(a, b Person) int {
	return cmp.Compare(a.age, b.age)
})

fmt.Println(ppl)

[jimmyfrasche]

It would be nice if there were a slices.SortBy that took a key func directly so you could do

slices.SortBy(ppl, func(p Person) int { return p.age })

That would be very handy. I'm not sure of other places where a key func would be useful like that, though.

[coady]

Example from SortFunc.

names := []string{"Bob", "alice", "VERA"}
slices.SortFunc(names, func(a, b string) int { return cmp.Compare(strings.ToLower(a), strings.ToLower(b)) })
slices.SortFunc(names, CompareBy(func(n string) string { return strings.ToLower(n) }))
slices.SortFunc(names, CompareBy(strings.ToLower))

The readability improvement will be proportional to how much logic is duplicated, so simple attribute access is the least compelling. Relatedly, the more logic there is the more likely the function or method will already exist - or should - and can be in-lined.

type Person struct {
	children map[string]int // name: age
}

func (p Person) NumChildren() int {
	return len(p.children)
}

func (p Person) ChildAge(name string) int {
	return p.children[name]
}

slices.SortFunc(names, func(a, b string) int { return cmp.Compare(p.ChildAge(a), p.ChildAge(b)) })
slices.SortFunc(names, CompareBy(func(n string) int { return p.ChildAge(n) }))
slices.SortFunc(names, CompareBy(p.ChildAge))

slices.SortFunc(ppl, func(a, b Person) int { return cmp.Compare(a.NumChildren(), b.NumChildren()) })
slices.SortFunc(ppl, CompareBy(func(p Person) int { return p.NumChildren() }))
slices.SortFunc(ppl, CompareBy(Person.NumChildren))

I'm not opposed to SortBy either; just proposed the most general version. The use cases in slices are: CompareFunc, IsSortedFunc, MaxFunc, MinFunc, Sort{Stable}Func, Sorted{Stable}Func. I think the new SortedFunc is the most useful now.

[adonovan]

Applying the key function to every pair of V elements on demand at comparison time (O(n log n) calls, each computing two elements) may be significantly less efficient than using the "decorate, sort, undecorate" approach, which calls the key function exactly once for each V element---especially if the key function allocates memory.