Golang slices.IsSortedFunc Function

The slices.IsSortedFunc function in Golang is part of the slices package, introduced in Go 1.21 as part of the standard library. This function allows you to determine whether a slice is sorted based on a custom comparison function. It is particularly useful when you need to check the order of elements in a slice according to specific criteria that go beyond the default ordering.

Table of Contents

1. Introduction
2. slices.IsSortedFunc Function Syntax
3. Examples
   • Basic Usage
   • Checking Custom Order for Structs
   • Handling Edge Cases with Custom Comparisons
4. Real-World Use Case Example
5. Conclusion

Introduction

The slices.IsSortedFunc function provides a flexible way to check if a slice is sorted according to a custom comparison function. This function allows you to define the criteria for sorting, making it ideal for scenarios where the default comparison operators do not suffice, such as sorting complex types or applying non-standard ordering rules.

slices.IsSortedFunc Function Syntax

The syntax for the slices.IsSortedFunc function is as follows:

func IsSortedFunc[S ~[]E, E any](x S, cmp func(a, b E) int) bool

Parameters:

• x S: The slice to check for sorted order.
• cmp func(a, b E) int: A custom comparison function that defines the sorting order. It should return:
  • A negative number if a should come before b.
  • Zero if a and b are considered equal.
  • A positive number if a should come after b.

Returns:

• bool: true if the slice is sorted according to the custom comparison function, false otherwise.

Behavior:

• Custom sorted order check: The function iterates through the slice, using the custom comparison function to determine if each element is in the correct order relative to the next. If any element is out of order, the function returns false.

Examples

Basic Usage

This example demonstrates how to use slices.IsSortedFunc to check if a slice of integers is sorted in descending order.

Example

package main

import (
	"fmt"
	"slices"
)

func main() {
	// Define a slice of integers
	numbers := []int{5, 4, 3, 2, 1}

	// Define a custom comparison function for descending order
	descending := func(a, b int) int {
		return b - a
	}

	// Check if the slice is sorted in descending order
	isSorted := slices.IsSortedFunc(numbers, descending)

	// Print the result
	fmt.Println("Is the slice sorted in descending order?", isSorted)
}

Output:

Is the slice sorted in descending order? true

Explanation:

• The slices.IsSortedFunc function uses the descending comparison function to check if the numbers slice is sorted in descending order. Since the slice is sorted as required, the function returns true.

Checking Custom Order for Structs

This example shows how to use slices.IsSortedFunc to check if a slice of structs is sorted based on a specific field.

Example

package main

import (
	"fmt"
	"slices"
)

type Person struct {
	Name string
	Age  int
}

func main() {
	// Define a slice of Person structs
	people := []Person{
		{"Alice", 30},
		{"Bob", 25},
		{"Charlie", 35},
	}

	// Define a custom comparison function to sort by Age in ascending order
	byAge := func(a, b Person) int {
		return a.Age - b.Age
	}

	// Check if the slice is sorted by Age
	isSorted := slices.IsSortedFunc(people, byAge)

	// Print the result
	fmt.Println("Is the slice sorted by Age?", isSorted)
}

Output:

Is the slice sorted by Age? false

Explanation:

• The slices.IsSortedFunc function checks if the people slice is sorted by the Age field using the byAge comparison function. Since the slice is not sorted by age, the function returns false.

Handling Edge Cases with Custom Comparisons

This example demonstrates how slices.IsSortedFunc behaves with slices that are empty or have a single element, using a custom comparison function.

Example

package main

import (
	"fmt"
	"slices"
)

func main() {
	// Define an empty slice and a single-element slice
	emptySlice := []int{}
	singleElementSlice := []int{42}

	// Define a simple comparison function for ascending order
	ascending := func(a, b int) int {
		return a - b
	}

	// Check if the slices are sorted
	isEmptySorted := slices.IsSortedFunc(emptySlice, ascending)
	isSingleElementSorted := slices.IsSortedFunc(singleElementSlice, ascending)

	// Print the results
	fmt.Println("Is the empty slice sorted?", isEmptySorted)
	fmt.Println("Is the single-element slice sorted?", isSingleElementSorted)
}

Output:

Is the empty slice sorted? true
Is the single-element slice sorted? true

Explanation:

• The slices.IsSortedFunc function correctly returns true for both the empty slice and the single-element slice, as these are trivially sorted regardless of the comparison function.

Real-World Use Case Example: Verifying Sorted Data with Custom Rules

A practical use case for slices.IsSortedFunc is verifying that data is sorted according to custom rules, such as checking if a list of events is sorted by timestamp in reverse chronological order.

Example: Checking Event List Order by Timestamp

package main

import (
	"fmt"
	"time"
	"slices"
)

type Event struct {
	Name      string
	Timestamp time.Time
}

func main() {
	// Define a slice of Event structs
	events := []Event{
		{"Event1", time.Date(2024, 7, 1, 0, 0, 0, 0, time.UTC)},
		{"Event2", time.Date(2024, 6, 1, 0, 0, 0, 0, time.UTC)},
		{"Event3", time.Date(2024, 5, 1, 0, 0, 0, 0, time.UTC)},
	}

	// Define a custom comparison function for reverse chronological order
	byTimestampDesc := func(a, b Event) int {
		return int(b.Timestamp.Sub(a.Timestamp))
	}

	// Check if the events are sorted in reverse chronological order
	isSorted := slices.IsSortedFunc(events, byTimestampDesc)

	// Print the result
	fmt.Println("Are the events sorted in reverse chronological order?", isSorted)
}

Output:

Are the events sorted in reverse chronological order? true

Explanation:

• The slices.IsSortedFunc function uses the byTimestampDesc comparison function to verify that the events slice is sorted in reverse chronological order. Since the events are ordered as required, the function returns true.

Conclusion

The slices.IsSortedFunc function in Go is used for checking the sorted order of slices based on custom criteria. It is particularly useful when dealing with complex types or when standard sorting rules do not apply. By using slices.IsSortedFunc, you can ensure that your data is correctly ordered according to the specific requirements of your Go applications.