Mastering Type-Safe Comparisons with Go's cmp Package

Introduction

In the Go ecosystem, comparing values safely and efficiently is a common need. The cmp package, introduced with Go 1.18 generics, provides a type‑safe way to compare ordered data types, making comparison logic more flexible and performant.

Core Components of the cmp Package

Ordered Constraint

The Ordered interface defines a constraint for types that support the standard ordering operators (<, <=, >=, >). It includes all built‑in integer, unsigned integer, floating‑point, and string types. The definition uses the tilde ( ~) syntax to allow any type whose underlying type satisfies the listed primitives:

type Ordered interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64 |
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr |
    ~float32 | ~float64 |
    ~string
}

This generic constraint enables functions to operate on any ordered type without sacrificing type safety.

Less Function

The Less function provides a basic comparison that returns true if the first argument is less than the second. It includes special handling for NaN values, treating them as less than any non‑NaN value:

func Less[T Ordered](x, y T) bool {
    return (isNaN(x) && !isNaN(y)) || x < y
}

The helper isNaN checks for NaN because, in Go, NaN is not equal to any value, including itself.

Compare Function

The Compare function returns an int indicating the ordering relationship between two values: -1 if x < y, 0 if they are equal, and 1 if x > y. It also correctly handles NaN cases:

func Compare[T Ordered](x, y T) int {
    xNaN := isNaN(x)
    yNaN := isNaN(y)
    if xNaN && yNaN {
        return 0
    }
    if xNaN || x < y {
        return -1
    }
    if yNaN || x > y {
        return 1
    }
    return 0
}

Practical Applications

The cmp package is ideal for scenarios requiring type‑safe, high‑performance comparisons, such as implementing custom data structures (priority queues, sorting algorithms) or performing ordered operations in database code. By leveraging the Ordered constraint and the provided functions, developers can write concise, safe, and efficient comparison logic.

Conclusion

The Go cmp package offers a powerful, generic‑based toolkit for type‑safe comparisons. Its clear interfaces and functions enable developers to build robust applications with accurate and performant comparison behavior.