package sort

Import Path
	sort (on go.dev)

Dependency Relation
	imports 2 packages, and imported by 27 packages

Involved Source Files

	    search.go
	    slice.go
	  d sort.go
		Package sort provides primitives for sorting slices and user-defined collections.

	    zsortfunc.go
	    zsortinterface.go
Code Examples

	
		package main
		
		import (
			"fmt"
			"sort"
		)
		
		type Person struct {
			Name string
			Age  int
		}
		
		func (p Person) String() string {
			return fmt.Sprintf("%s: %d", p.Name, p.Age)
		}
		
		// ByAge implements sort.Interface for []Person based on
		// the Age field.
		type ByAge []Person
		
		func (a ByAge) Len() int           { return len(a) }
		func (a ByAge) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
		func (a ByAge) Less(i, j int) bool { return a[i].Age < a[j].Age }
		
		func main() {
			people := []Person{
				{"Bob", 31},
				{"John", 42},
				{"Michael", 17},
				{"Jenny", 26},
			}
		
			fmt.Println(people)
			// There are two ways to sort a slice. First, one can define
			// a set of methods for the slice type, as with ByAge, and
			// call sort.Sort. In this first example we use that technique.
			sort.Sort(ByAge(people))
			fmt.Println(people)
		
			// The other way is to use sort.Slice with a custom Less
			// function, which can be provided as a closure. In this
			// case no methods are needed. (And if they exist, they
			// are ignored.) Here we re-sort in reverse order: compare
			// the closure with ByAge.Less.
			sort.Slice(people, func(i, j int) bool {
				return people[i].Age > people[j].Age
			})
			fmt.Println(people)
		
		}

	Float64s
		package main
		
		import (
			"fmt"
			"math"
			"sort"
		)
		
		func main() {
			s := []float64{5.2, -1.3, 0.7, -3.8, 2.6} // unsorted
			sort.Float64s(s)
			fmt.Println(s)
		
			s = []float64{math.Inf(1), math.NaN(), math.Inf(-1), 0.0} // unsorted
			sort.Float64s(s)
			fmt.Println(s)
		
		}

	Float64sAreSorted
		package main
		
		import (
			"fmt"
			"sort"
		)
		
		func main() {
			s := []float64{0.7, 1.3, 2.6, 3.8, 5.2} // sorted ascending
			fmt.Println(sort.Float64sAreSorted(s))
		
			s = []float64{5.2, 3.8, 2.6, 1.3, 0.7} // sorted descending
			fmt.Println(sort.Float64sAreSorted(s))
		
			s = []float64{5.2, 1.3, 0.7, 3.8, 2.6} // unsorted
			fmt.Println(sort.Float64sAreSorted(s))
		
		}

	Ints
		package main
		
		import (
			"fmt"
			"sort"
		)
		
		func main() {
			s := []int{5, 2, 6, 3, 1, 4} // unsorted
			sort.Ints(s)
			fmt.Println(s)
		}

	IntsAreSorted
		package main
		
		import (
			"fmt"
			"sort"
		)
		
		func main() {
			s := []int{1, 2, 3, 4, 5, 6} // sorted ascending
			fmt.Println(sort.IntsAreSorted(s))
		
			s = []int{6, 5, 4, 3, 2, 1} // sorted descending
			fmt.Println(sort.IntsAreSorted(s))
		
			s = []int{3, 2, 4, 1, 5} // unsorted
			fmt.Println(sort.IntsAreSorted(s))
		
		}

	Reverse
		package main
		
		import (
			"fmt"
			"sort"
		)
		
		func main() {
			s := []int{5, 2, 6, 3, 1, 4} // unsorted
			sort.Sort(sort.Reverse(sort.IntSlice(s)))
			fmt.Println(s)
		}

	Search
		package main
		
		import (
			"fmt"
			"sort"
		)
		
		func main() {
			a := []int{1, 3, 6, 10, 15, 21, 28, 36, 45, 55}
			x := 6
		
			i := sort.Search(len(a), func(i int) bool { return a[i] >= x })
			if i < len(a) && a[i] == x {
				fmt.Printf("found %d at index %d in %v\n", x, i, a)
			} else {
				fmt.Printf("%d not found in %v\n", x, a)
			}
		}

	SearchFloat64s
		package main
		
		import (
			"fmt"
			"sort"
		)
		
		func main() {
			a := []float64{1.0, 2.0, 3.3, 4.6, 6.1, 7.2, 8.0}
		
			x := 2.0
			i := sort.SearchFloat64s(a, x)
			fmt.Printf("found %g at index %d in %v\n", x, i, a)
		
			x = 0.5
			i = sort.SearchFloat64s(a, x)
			fmt.Printf("%g not found, can be inserted at index %d in %v\n", x, i, a)
		}

	SearchInts
		package main
		
		import (
			"fmt"
			"sort"
		)
		
		func main() {
			a := []int{1, 2, 3, 4, 6, 7, 8}
		
			x := 2
			i := sort.SearchInts(a, x)
			fmt.Printf("found %d at index %d in %v\n", x, i, a)
		
			x = 5
			i = sort.SearchInts(a, x)
			fmt.Printf("%d not found, can be inserted at index %d in %v\n", x, i, a)
		}

	Search_descendingOrder
		package main
		
		import (
			"fmt"
			"sort"
		)
		
		func main() {
			a := []int{55, 45, 36, 28, 21, 15, 10, 6, 3, 1}
			x := 6
		
			i := sort.Search(len(a), func(i int) bool { return a[i] <= x })
			if i < len(a) && a[i] == x {
				fmt.Printf("found %d at index %d in %v\n", x, i, a)
			} else {
				fmt.Printf("%d not found in %v\n", x, a)
			}
		}

	Slice
		package main
		
		import (
			"fmt"
			"sort"
		)
		
		func main() {
			people := []struct {
				Name string
				Age  int
			}{
				{"Gopher", 7},
				{"Alice", 55},
				{"Vera", 24},
				{"Bob", 75},
			}
			sort.Slice(people, func(i, j int) bool { return people[i].Name < people[j].Name })
			fmt.Println("By name:", people)
		
			sort.Slice(people, func(i, j int) bool { return people[i].Age < people[j].Age })
			fmt.Println("By age:", people)
		}

	SliceStable
		package main
		
		import (
			"fmt"
			"sort"
		)
		
		func main() {
		
			people := []struct {
				Name string
				Age  int
			}{
				{"Alice", 25},
				{"Elizabeth", 75},
				{"Alice", 75},
				{"Bob", 75},
				{"Alice", 75},
				{"Bob", 25},
				{"Colin", 25},
				{"Elizabeth", 25},
			}
		
			// Sort by name, preserving original order
			sort.SliceStable(people, func(i, j int) bool { return people[i].Name < people[j].Name })
			fmt.Println("By name:", people)
		
			// Sort by age preserving name order
			sort.SliceStable(people, func(i, j int) bool { return people[i].Age < people[j].Age })
			fmt.Println("By age,name:", people)
		
		}

	Strings
		package main
		
		import (
			"fmt"
			"sort"
		)
		
		func main() {
			s := []string{"Go", "Bravo", "Gopher", "Alpha", "Grin", "Delta"}
			sort.Strings(s)
			fmt.Println(s)
		}

	_sortKeys
		package main
		
		import (
			"fmt"
			"sort"
		)
		
		// A couple of type definitions to make the units clear.
		type earthMass float64
		type au float64
		
		// A Planet defines the properties of a solar system object.
		type Planet struct {
			name     string
			mass     earthMass
			distance au
		}
		
		// By is the type of a "less" function that defines the ordering of its Planet arguments.
		type By func(p1, p2 *Planet) bool
		
		// Sort is a method on the function type, By, that sorts the argument slice according to the function.
		func (by By) Sort(planets []Planet) {
			ps := &planetSorter{
				planets: planets,
				by:      by, // The Sort method's receiver is the function (closure) that defines the sort order.
			}
			sort.Sort(ps)
		}
		
		// planetSorter joins a By function and a slice of Planets to be sorted.
		type planetSorter struct {
			planets []Planet
			by      func(p1, p2 *Planet) bool // Closure used in the Less method.
		}
		
		// Len is part of sort.Interface.
		func (s *planetSorter) Len() int {
			return len(s.planets)
		}
		
		// Swap is part of sort.Interface.
		func (s *planetSorter) Swap(i, j int) {
			s.planets[i], s.planets[j] = s.planets[j], s.planets[i]
		}
		
		// Less is part of sort.Interface. It is implemented by calling the "by" closure in the sorter.
		func (s *planetSorter) Less(i, j int) bool {
			return s.by(&s.planets[i], &s.planets[j])
		}
		
		var planets = []Planet{
			{"Mercury", 0.055, 0.4},
			{"Venus", 0.815, 0.7},
			{"Earth", 1.0, 1.0},
			{"Mars", 0.107, 1.5},
		}
		
		// ExampleSortKeys demonstrates a technique for sorting a struct type using programmable sort criteria.
		func main() {
			// Closures that order the Planet structure.
			name := func(p1, p2 *Planet) bool {
				return p1.name < p2.name
			}
			mass := func(p1, p2 *Planet) bool {
				return p1.mass < p2.mass
			}
			distance := func(p1, p2 *Planet) bool {
				return p1.distance < p2.distance
			}
			decreasingDistance := func(p1, p2 *Planet) bool {
				return distance(p2, p1)
			}
		
			// Sort the planets by the various criteria.
			By(name).Sort(planets)
			fmt.Println("By name:", planets)
		
			By(mass).Sort(planets)
			fmt.Println("By mass:", planets)
		
			By(distance).Sort(planets)
			fmt.Println("By distance:", planets)
		
			By(decreasingDistance).Sort(planets)
			fmt.Println("By decreasing distance:", planets)
		
		}

	_sortMultiKeys
		package main
		
		import (
			"fmt"
			"sort"
		)
		
		// A Change is a record of source code changes, recording user, language, and delta size.
		type Change struct {
			user     string
			language string
			lines    int
		}
		
		type lessFunc func(p1, p2 *Change) bool
		
		// multiSorter implements the Sort interface, sorting the changes within.
		type multiSorter struct {
			changes []Change
			less    []lessFunc
		}
		
		// Sort sorts the argument slice according to the less functions passed to OrderedBy.
		func (ms *multiSorter) Sort(changes []Change) {
			ms.changes = changes
			sort.Sort(ms)
		}
		
		// OrderedBy returns a Sorter that sorts using the less functions, in order.
		// Call its Sort method to sort the data.
		func OrderedBy(less ...lessFunc) *multiSorter {
			return &multiSorter{
				less: less,
			}
		}
		
		// Len is part of sort.Interface.
		func (ms *multiSorter) Len() int {
			return len(ms.changes)
		}
		
		// Swap is part of sort.Interface.
		func (ms *multiSorter) Swap(i, j int) {
			ms.changes[i], ms.changes[j] = ms.changes[j], ms.changes[i]
		}
		
		// Less is part of sort.Interface. It is implemented by looping along the
		// less functions until it finds a comparison that discriminates between
		// the two items (one is less than the other). Note that it can call the
		// less functions twice per call. We could change the functions to return
		// -1, 0, 1 and reduce the number of calls for greater efficiency: an
		// exercise for the reader.
		func (ms *multiSorter) Less(i, j int) bool {
			p, q := &ms.changes[i], &ms.changes[j]
			// Try all but the last comparison.
			var k int
			for k = 0; k < len(ms.less)-1; k++ {
				less := ms.less[k]
				switch {
				case less(p, q):
					// p < q, so we have a decision.
					return true
				case less(q, p):
					// p > q, so we have a decision.
					return false
				}
				// p == q; try the next comparison.
			}
			// All comparisons to here said "equal", so just return whatever
			// the final comparison reports.
			return ms.less[k](p, q)
		}
		
		var changes = []Change{
			{"gri", "Go", 100},
			{"ken", "C", 150},
			{"glenda", "Go", 200},
			{"rsc", "Go", 200},
			{"r", "Go", 100},
			{"ken", "Go", 200},
			{"dmr", "C", 100},
			{"r", "C", 150},
			{"gri", "Smalltalk", 80},
		}
		
		// ExampleMultiKeys demonstrates a technique for sorting a struct type using different
		// sets of multiple fields in the comparison. We chain together "Less" functions, each of
		// which compares a single field.
		func main() {
			// Closures that order the Change structure.
			user := func(c1, c2 *Change) bool {
				return c1.user < c2.user
			}
			language := func(c1, c2 *Change) bool {
				return c1.language < c2.language
			}
			increasingLines := func(c1, c2 *Change) bool {
				return c1.lines < c2.lines
			}
			decreasingLines := func(c1, c2 *Change) bool {
				return c1.lines > c2.lines // Note: > orders downwards.
			}
		
			// Simple use: Sort by user.
			OrderedBy(user).Sort(changes)
			fmt.Println("By user:", changes)
		
			// More examples.
			OrderedBy(user, increasingLines).Sort(changes)
			fmt.Println("By user,<lines:", changes)
		
			OrderedBy(user, decreasingLines).Sort(changes)
			fmt.Println("By user,>lines:", changes)
		
			OrderedBy(language, increasingLines).Sort(changes)
			fmt.Println("By language,<lines:", changes)
		
			OrderedBy(language, increasingLines, user).Sort(changes)
			fmt.Println("By language,<lines,user:", changes)
		
		}

	_sortWrapper
		package main
		
		import (
			"fmt"
			"sort"
		)
		
		type Grams int
		
		func (g Grams) String() string { return fmt.Sprintf("%dg", int(g)) }
		
		type Organ struct {
			Name   string
			Weight Grams
		}
		
		type Organs []*Organ
		
		func (s Organs) Len() int      { return len(s) }
		func (s Organs) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
		
		// ByName implements sort.Interface by providing Less and using the Len and
		// Swap methods of the embedded Organs value.
		type ByName struct{ Organs }
		
		func (s ByName) Less(i, j int) bool { return s.Organs[i].Name < s.Organs[j].Name }
		
		// ByWeight implements sort.Interface by providing Less and using the Len and
		// Swap methods of the embedded Organs value.
		type ByWeight struct{ Organs }
		
		func (s ByWeight) Less(i, j int) bool { return s.Organs[i].Weight < s.Organs[j].Weight }
		
		func main() {
			s := []*Organ{
				{"brain", 1340},
				{"heart", 290},
				{"liver", 1494},
				{"pancreas", 131},
				{"prostate", 62},
				{"spleen", 162},
			}
		
			sort.Sort(ByWeight{s})
			fmt.Println("Organs by weight:")
			printOrgans(s)
		
			sort.Sort(ByName{s})
			fmt.Println("Organs by name:")
			printOrgans(s)
		
		}
		
		func printOrgans(s []*Organ) {
			for _, o := range s {
				fmt.Printf("%-8s (%v)\n", o.Name, o.Weight)
			}
		}


Package-Level Type Names (total 8, in which 4 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type Float64Slice ([])
		Float64Slice implements Interface for a []float64, sorting in increasing order,
		with not-a-number (NaN) values ordered before other values.

		Methods (total 5, all are exported)
			( Float64Slice) Len() int
			( Float64Slice) Less(i, j int) bool
				Less reports whether x[i] should be ordered before x[j], as required by the sort Interface.
				Note that floating-point comparison by itself is not a transitive relation: it does not
				report a consistent ordering for not-a-number (NaN) values.
				This implementation of Less places NaN values before any others, by using:
				
					x[i] < x[j] || (math.IsNaN(x[i]) && !math.IsNaN(x[j]))

			( Float64Slice) Search(x float64) int
				Search returns the result of applying SearchFloat64s to the receiver and x.

			( Float64Slice) Sort()
				Sort is a convenience method: x.Sort() calls Sort(x).

			( Float64Slice) Swap(i, j int)
		Implements (at least one exported)
			 Float64Slice : Interface

	 type Interface (interface)
		An implementation of Interface can be sorted by the routines in this package.
		The methods refer to elements of the underlying collection by integer index.

		Methods (total 3, all are exported)
			( Interface) Len() int
				Len is the number of elements in the collection.

			( Interface) Less(i, j int) bool
				Less reports whether the element with index i
				must sort before the element with index j.
				
				If both Less(i, j) and Less(j, i) are false,
				then the elements at index i and j are considered equal.
				Sort may place equal elements in any order in the final result,
				while Stable preserves the original input order of equal elements.
				
				Less must describe a transitive ordering:
				 - if both Less(i, j) and Less(j, k) are true, then Less(i, k) must be true as well.
				 - if both Less(i, j) and Less(j, k) are false, then Less(i, k) must be false as well.
				
				Note that floating-point comparison (the < operator on float32 or float64 values)
				is not a transitive ordering when not-a-number (NaN) values are involved.
				See Float64Slice.Less for a correct implementation for floating-point values.

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

		Implemented By (at least 21, in which 5 are exported)
			 Float64Slice
			 IntSlice
			 StringSlice
			*go.opentelemetry.io/otel/attribute.Sortable
			*internal/fmtsort.SortedMap
			/* 16+ unexporteds ... *//* 16+ unexporteds: */
			 reverse
			 compress/flate.byFreq
			 compress/flate.byLiteral
			 encoding/json.byIndex
			 github.com/gotd/neo.moments
			 github.com/gotd/td/internal/mtproto/salts.saltSlice
			 github.com/gotd/td/telegram/dcs.sortByLen
			 net.byPref
			 net.byPriorityWeight
			*net.byRFC6724
			*net/http.headerSorter
			*net/http.http2sorter
			 net/http.http2sortPriorityNodeSiblings
			 regexp.runeSlice
			 regexp/syntax.ranges
			 vendor/golang.org/x/text/unicode/bidi.bracketPairs
		As Outputs Of (at least one exported)
			func Reverse(data Interface) Interface
		As Inputs Of (at least 21, in which 4 are exported)
			func IsSorted(data Interface) bool
			func Reverse(data Interface) Interface
			func Sort(data Interface)
			func Stable(data Interface)
			/* 17+ unexporteds ... *//* 17+ unexporteds: */
			func breakPatterns(data Interface, a, b int)
			func choosePivot(data Interface, a, b int) (pivot int, hint sortedHint)
			func heapSort(data Interface, a, b int)
			func insertionSort(data Interface, a, b int)
			func median(data Interface, a, b, c int, swaps *int) int
			func medianAdjacent(data Interface, a int, swaps *int) int
			func order2(data Interface, a, b int, swaps *int) (int, int)
			func partialInsertionSort(data Interface, a, b int) bool
			func partition(data Interface, a, b, pivot int) (newpivot int, alreadyPartitioned bool)
			func partitionEqual(data Interface, a, b, pivot int) (newpivot int)
			func pdqsort(data Interface, a, b, limit int)
			func reverseRange(data Interface, a, b int)
			func rotate(data Interface, a, m, b int)
			func siftDown(data Interface, lo, hi, first int)
			func stable(data Interface, n int)
			func swapRange(data Interface, a, b, n int)
			func symMerge(data Interface, a, m, b int)

	 type IntSlice ([])
		IntSlice attaches the methods of Interface to []int, sorting in increasing order.

		Methods (total 5, all are exported)
			( IntSlice) Len() int
			( IntSlice) Less(i, j int) bool
			( IntSlice) Search(x int) int
				Search returns the result of applying SearchInts to the receiver and x.

			( IntSlice) Sort()
				Sort is a convenience method: x.Sort() calls Sort(x).

			( IntSlice) Swap(i, j int)
		Implements (at least one exported)
			 IntSlice : Interface

	 type StringSlice ([])
		StringSlice attaches the methods of Interface to []string, sorting in increasing order.

		Methods (total 5, all are exported)
			( StringSlice) Len() int
			( StringSlice) Less(i, j int) bool
			( StringSlice) Search(x string) int
				Search returns the result of applying SearchStrings to the receiver and x.

			( StringSlice) Sort()
				Sort is a convenience method: x.Sort() calls Sort(x).

			( StringSlice) Swap(i, j int)
		Implements (at least one exported)
			 StringSlice : Interface

	/* 4 unexporteds ... *//* 4 unexporteds: */
	 type lessSwap (struct)
		lessSwap is a pair of Less and Swap function for use with the
		auto-generated func-optimized variant of sort.go in
		zfuncversion.go.

		Fields (total 2, both are exported)
			Less func(i, j int) bool
			Swap func(i, j int)
		As Inputs Of (at least 17, none are exported)
			/* 17+ unexporteds ... *//* 17+ unexporteds: */
			func breakPatterns_func(data lessSwap, a, b int)
			func choosePivot_func(data lessSwap, a, b int) (pivot int, hint sortedHint)
			func heapSort_func(data lessSwap, a, b int)
			func insertionSort_func(data lessSwap, a, b int)
			func median_func(data lessSwap, a, b, c int, swaps *int) int
			func medianAdjacent_func(data lessSwap, a int, swaps *int) int
			func order2_func(data lessSwap, a, b int, swaps *int) (int, int)
			func partialInsertionSort_func(data lessSwap, a, b int) bool
			func partition_func(data lessSwap, a, b, pivot int) (newpivot int, alreadyPartitioned bool)
			func partitionEqual_func(data lessSwap, a, b, pivot int) (newpivot int)
			func pdqsort_func(data lessSwap, a, b, limit int)
			func reverseRange_func(data lessSwap, a, b int)
			func rotate_func(data lessSwap, a, m, b int)
			func siftDown_func(data lessSwap, lo, hi, first int)
			func stable_func(data lessSwap, n int)
			func swapRange_func(data lessSwap, a, b, n int)
			func symMerge_func(data lessSwap, a, m, b int)

	 type reverse (struct)

		Fields (only one, which is exported)
			Interface Interface
				This embedded Interface permits Reverse to use the methods of
				another Interface implementation.

		Methods (total 3, all are exported)
			( reverse) Len() int
				Len is the number of elements in the collection.

			( reverse) Less(i, j int) bool
				Less returns the opposite of the embedded implementation's Less method.

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

		Implements (at least one exported)
			 reverse : Interface

	 type sortedHint int (basic type)

		As Outputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func choosePivot(data Interface, a, b int) (pivot int, hint sortedHint)
			func choosePivot_func(data lessSwap, a, b int) (pivot int, hint sortedHint)
		As Types Of (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			const decreasingHint
			const increasingHint
			const unknownHint

	 type xorshift uint64 (basic type)
		xorshift paper: https://www.jstatsoft.org/article/view/v008i14/xorshift.pdf

		Methods (only one, which is exported)
			(*xorshift) Next() uint64


Package-Level Functions (total 54, in which 18 are exported)

	 func Find(n int, cmp func(int) int) (i int, found bool)
		Find uses binary search to find and return the smallest index i in [0, n)
		at which cmp(i) <= 0. If there is no such index i, Find returns i = n.
		The found result is true if i < n and cmp(i) == 0.
		Find calls cmp(i) only for i in the range [0, n).
		
		To permit binary search, Find requires that cmp(i) > 0 for a leading
		prefix of the range, cmp(i) == 0 in the middle, and cmp(i) < 0 for
		the final suffix of the range. (Each subrange could be empty.)
		The usual way to establish this condition is to interpret cmp(i)
		as a comparison of a desired target value t against entry i in an
		underlying indexed data structure x, returning <0, 0, and >0
		when t < x[i], t == x[i], and t > x[i], respectively.
		
		For example, to look for a particular string in a sorted, random-access
		list of strings:
		
			i, found := sort.Find(x.Len(), func(i int) int {
			    return strings.Compare(target, x.At(i))
			})
			if found {
			    fmt.Printf("found %s at entry %d\n", target, i)
			} else {
			    fmt.Printf("%s not found, would insert at %d", target, i)
			}

	 func Float64s(x []float64)
		Float64s sorts a slice of float64s in increasing order.
		Not-a-number (NaN) values are ordered before other values.
		
		Note: consider using the newer slices.Sort function, which runs faster.

	 func Float64sAreSorted(x []float64) bool
		Float64sAreSorted reports whether the slice x is sorted in increasing order,
		with not-a-number (NaN) values before any other values.
		
		Note: consider using the newer slices.IsSorted function, which runs faster.

	 func Ints(x []int)
		Ints sorts a slice of ints in increasing order.
		
		Note: consider using the newer slices.Sort function, which runs faster.

	 func IntsAreSorted(x []int) bool
		IntsAreSorted reports whether the slice x is sorted in increasing order.
		
		Note: consider using the newer slices.IsSorted function, which runs faster.

	 func IsSorted(data Interface) bool
		IsSorted reports whether data is sorted.
		
		Note: in many situations, the newer slices.IsSortedFunc function is more
		ergonomic and runs faster.

	 func Reverse(data Interface) Interface
		Reverse returns the reverse order for data.

	 func Search(n int, f func(int) bool) int
		Search uses binary search to find and return the smallest index i
		in [0, n) at which f(i) is true, assuming that on the range [0, n),
		f(i) == true implies f(i+1) == true. That is, Search requires that
		f is false for some (possibly empty) prefix of the input range [0, n)
		and then true for the (possibly empty) remainder; Search returns
		the first true index. If there is no such index, Search returns n.
		(Note that the "not found" return value is not -1 as in, for instance,
		strings.Index.)
		Search calls f(i) only for i in the range [0, n).
		
		A common use of Search is to find the index i for a value x in
		a sorted, indexable data structure such as an array or slice.
		In this case, the argument f, typically a closure, captures the value
		to be searched for, and how the data structure is indexed and
		ordered.
		
		For instance, given a slice data sorted in ascending order,
		the call Search(len(data), func(i int) bool { return data[i] >= 23 })
		returns the smallest index i such that data[i] >= 23. If the caller
		wants to find whether 23 is in the slice, it must test data[i] == 23
		separately.
		
		Searching data sorted in descending order would use the <=
		operator instead of the >= operator.
		
		To complete the example above, the following code tries to find the value
		x in an integer slice data sorted in ascending order:
		
			x := 23
			i := sort.Search(len(data), func(i int) bool { return data[i] >= x })
			if i < len(data) && data[i] == x {
				// x is present at data[i]
			} else {
				// x is not present in data,
				// but i is the index where it would be inserted.
			}
		
		As a more whimsical example, this program guesses your number:
		
			func GuessingGame() {
				var s string
				fmt.Printf("Pick an integer from 0 to 100.\n")
				answer := sort.Search(100, func(i int) bool {
					fmt.Printf("Is your number <= %d? ", i)
					fmt.Scanf("%s", &s)
					return s != "" && s[0] == 'y'
				})
				fmt.Printf("Your number is %d.\n", answer)
			}

	 func SearchFloat64s(a []float64, x float64) int
		SearchFloat64s searches for x in a sorted slice of float64s and returns the index
		as specified by Search. The return value is the index to insert x if x is not
		present (it could be len(a)).
		The slice must be sorted in ascending order.

	 func SearchInts(a []int, x int) int
		SearchInts searches for x in a sorted slice of ints and returns the index
		as specified by Search. The return value is the index to insert x if x is
		not present (it could be len(a)).
		The slice must be sorted in ascending order.

	 func SearchStrings(a []string, x string) int
		SearchStrings searches for x in a sorted slice of strings and returns the index
		as specified by Search. The return value is the index to insert x if x is not
		present (it could be len(a)).
		The slice must be sorted in ascending order.

	 func Slice(x any, less func(i, j int) bool)
		Slice sorts the slice x given the provided less function.
		It panics if x is not a slice.
		
		The sort is not guaranteed to be stable: equal elements
		may be reversed from their original order.
		For a stable sort, use SliceStable.
		
		The less function must satisfy the same requirements as
		the Interface type's Less method.

	 func SliceIsSorted(x any, less func(i, j int) bool) bool
		SliceIsSorted reports whether the slice x is sorted according to the provided less function.
		It panics if x is not a slice.

	 func SliceStable(x any, less func(i, j int) bool)
		SliceStable sorts the slice x using the provided less
		function, keeping equal elements in their original order.
		It panics if x is not a slice.
		
		The less function must satisfy the same requirements as
		the Interface type's Less method.

	 func Sort(data Interface)
		Sort sorts data in ascending order as determined by the Less method.
		It makes one call to data.Len to determine n and O(n*log(n)) calls to
		data.Less and data.Swap. The sort is not guaranteed to be stable.
		
		Note: in many situations, the newer slices.SortFunc function is more
		ergonomic and runs faster.

	 func Stable(data Interface)
		Stable sorts data in ascending order as determined by the Less method,
		while keeping the original order of equal elements.
		
		It makes one call to data.Len to determine n, O(n*log(n)) calls to
		data.Less and O(n*log(n)*log(n)) calls to data.Swap.
		
		Note: in many situations, the newer slices.SortStableFunc function is more
		ergonomic and runs faster.

	 func Strings(x []string)
		Strings sorts a slice of strings in increasing order.
		
		Note: consider using the newer slices.Sort function, which runs faster.

	 func StringsAreSorted(x []string) bool
		StringsAreSorted reports whether the slice x is sorted in increasing order.
		
		Note: consider using the newer slices.IsSorted function, which runs faster.

	/* 36 unexporteds ... *//* 36 unexporteds: */
	 func breakPatterns(data Interface, a, b int)
		breakPatterns scatters some elements around in an attempt to break some patterns
		that might cause imbalanced partitions in quicksort.

	 func breakPatterns_func(data lessSwap, a, b int)
		breakPatterns_func scatters some elements around in an attempt to break some patterns
		that might cause imbalanced partitions in quicksort.

	 func choosePivot(data Interface, a, b int) (pivot int, hint sortedHint)
		choosePivot chooses a pivot in data[a:b].
		
		[0,8): chooses a static pivot.
		[8,shortestNinther): uses the simple median-of-three method.
		[shortestNinther,∞): uses the Tukey ninther method.

	 func choosePivot_func(data lessSwap, a, b int) (pivot int, hint sortedHint)
		choosePivot_func chooses a pivot in data[a:b].
		
		[0,8): chooses a static pivot.
		[8,shortestNinther): uses the simple median-of-three method.
		[shortestNinther,∞): uses the Tukey ninther method.

	 func heapSort(data Interface, a, b int)
	 func heapSort_func(data lessSwap, a, b int)
	 func insertionSort(data Interface, a, b int)
		insertionSort sorts data[a:b] using insertion sort.

	 func insertionSort_func(data lessSwap, a, b int)
		insertionSort_func sorts data[a:b] using insertion sort.

	 func isNaN(f float64) bool
		isNaN is a copy of math.IsNaN to avoid a dependency on the math package.

	 func median(data Interface, a, b, c int, swaps *int) int
		median returns x where data[x] is the median of data[a],data[b],data[c], where x is a, b, or c.

	 func median_func(data lessSwap, a, b, c int, swaps *int) int
		median_func returns x where data[x] is the median of data[a],data[b],data[c], where x is a, b, or c.

	 func medianAdjacent(data Interface, a int, swaps *int) int
		medianAdjacent finds the median of data[a - 1], data[a], data[a + 1] and stores the index into a.

	 func medianAdjacent_func(data lessSwap, a int, swaps *int) int
		medianAdjacent_func finds the median of data[a - 1], data[a], data[a + 1] and stores the index into a.

	 func nextPowerOfTwo(length int) uint
	 func order2(data Interface, a, b int, swaps *int) (int, int)
		order2 returns x,y where data[x] <= data[y], where x,y=a,b or x,y=b,a.

	 func order2_func(data lessSwap, a, b int, swaps *int) (int, int)
		order2_func returns x,y where data[x] <= data[y], where x,y=a,b or x,y=b,a.

	 func partialInsertionSort(data Interface, a, b int) bool
		partialInsertionSort partially sorts a slice, returns true if the slice is sorted at the end.

	 func partialInsertionSort_func(data lessSwap, a, b int) bool
		partialInsertionSort_func partially sorts a slice, returns true if the slice is sorted at the end.

	 func partition(data Interface, a, b, pivot int) (newpivot int, alreadyPartitioned bool)
		partition does one quicksort partition.
		Let p = data[pivot]
		Moves elements in data[a:b] around, so that data[i]<p and data[j]>=p for i<newpivot and j>newpivot.
		On return, data[newpivot] = p

	 func partition_func(data lessSwap, a, b, pivot int) (newpivot int, alreadyPartitioned bool)
		partition_func does one quicksort partition.
		Let p = data[pivot]
		Moves elements in data[a:b] around, so that data[i]<p and data[j]>=p for i<newpivot and j>newpivot.
		On return, data[newpivot] = p

	 func partitionEqual(data Interface, a, b, pivot int) (newpivot int)
		partitionEqual partitions data[a:b] into elements equal to data[pivot] followed by elements greater than data[pivot].
		It assumed that data[a:b] does not contain elements smaller than the data[pivot].

	 func partitionEqual_func(data lessSwap, a, b, pivot int) (newpivot int)
		partitionEqual_func partitions data[a:b] into elements equal to data[pivot] followed by elements greater than data[pivot].
		It assumed that data[a:b] does not contain elements smaller than the data[pivot].

	 func pdqsort(data Interface, a, b, limit int)
		pdqsort sorts data[a:b].
		The algorithm based on pattern-defeating quicksort(pdqsort), but without the optimizations from BlockQuicksort.
		pdqsort paper: https://arxiv.org/pdf/2106.05123.pdf
		C++ implementation: https://github.com/orlp/pdqsort
		Rust implementation: https://docs.rs/pdqsort/latest/pdqsort/
		limit is the number of allowed bad (very unbalanced) pivots before falling back to heapsort.

	 func pdqsort_func(data lessSwap, a, b, limit int)
		pdqsort_func sorts data[a:b].
		The algorithm based on pattern-defeating quicksort(pdqsort), but without the optimizations from BlockQuicksort.
		pdqsort paper: https://arxiv.org/pdf/2106.05123.pdf
		C++ implementation: https://github.com/orlp/pdqsort
		Rust implementation: https://docs.rs/pdqsort/latest/pdqsort/
		limit is the number of allowed bad (very unbalanced) pivots before falling back to heapsort.

	 func reverseRange(data Interface, a, b int)
	 func reverseRange_func(data lessSwap, a, b int)
	 func rotate(data Interface, a, m, b int)
		rotate rotates two consecutive blocks u = data[a:m] and v = data[m:b] in data:
		Data of the form 'x u v y' is changed to 'x v u y'.
		rotate performs at most b-a many calls to data.Swap,
		and it assumes non-degenerate arguments: a < m && m < b.

	 func rotate_func(data lessSwap, a, m, b int)
		rotate_func rotates two consecutive blocks u = data[a:m] and v = data[m:b] in data:
		Data of the form 'x u v y' is changed to 'x v u y'.
		rotate performs at most b-a many calls to data.Swap,
		and it assumes non-degenerate arguments: a < m && m < b.

	 func siftDown(data Interface, lo, hi, first int)
		siftDown implements the heap property on data[lo:hi].
		first is an offset into the array where the root of the heap lies.

	 func siftDown_func(data lessSwap, lo, hi, first int)
		siftDown_func implements the heap property on data[lo:hi].
		first is an offset into the array where the root of the heap lies.

	 func stable(data Interface, n int)
	 func stable_func(data lessSwap, n int)
	 func swapRange(data Interface, a, b, n int)
	 func swapRange_func(data lessSwap, a, b, n int)
	 func symMerge(data Interface, a, m, b int)
		symMerge merges the two sorted subsequences data[a:m] and data[m:b] using
		the SymMerge algorithm from Pok-Son Kim and Arne Kutzner, "Stable Minimum
		Storage Merging by Symmetric Comparisons", in Susanne Albers and Tomasz
		Radzik, editors, Algorithms - ESA 2004, volume 3221 of Lecture Notes in
		Computer Science, pages 714-723. Springer, 2004.
		
		Let M = m-a and N = b-n. Wolog M < N.
		The recursion depth is bound by ceil(log(N+M)).
		The algorithm needs O(M*log(N/M + 1)) calls to data.Less.
		The algorithm needs O((M+N)*log(M)) calls to data.Swap.
		
		The paper gives O((M+N)*log(M)) as the number of assignments assuming a
		rotation algorithm which uses O(M+N+gcd(M+N)) assignments. The argumentation
		in the paper carries through for Swap operations, especially as the block
		swapping rotate uses only O(M+N) Swaps.
		
		symMerge assumes non-degenerate arguments: a < m && m < b.
		Having the caller check this condition eliminates many leaf recursion calls,
		which improves performance.

	 func symMerge_func(data lessSwap, a, m, b int)
		symMerge_func merges the two sorted subsequences data[a:m] and data[m:b] using
		the SymMerge algorithm from Pok-Son Kim and Arne Kutzner, "Stable Minimum
		Storage Merging by Symmetric Comparisons", in Susanne Albers and Tomasz
		Radzik, editors, Algorithms - ESA 2004, volume 3221 of Lecture Notes in
		Computer Science, pages 714-723. Springer, 2004.
		
		Let M = m-a and N = b-n. Wolog M < N.
		The recursion depth is bound by ceil(log(N+M)).
		The algorithm needs O(M*log(N/M + 1)) calls to data.Less.
		The algorithm needs O((M+N)*log(M)) calls to data.Swap.
		
		The paper gives O((M+N)*log(M)) as the number of assignments assuming a
		rotation algorithm which uses O(M+N+gcd(M+N)) assignments. The argumentation
		in the paper carries through for Swap operations, especially as the block
		swapping rotate uses only O(M+N) Swaps.
		
		symMerge assumes non-degenerate arguments: a < m && m < b.
		Having the caller check this condition eliminates many leaf recursion calls,
		which improves performance.


Package-Level Constants (total 3, none are exported)

	/* 3 unexporteds ... *//* 3 unexporteds: */
	const decreasingHint sortedHint = 2
	const increasingHint sortedHint = 1
	const unknownHint sortedHint = 0

The pages are generated with Golds v0.6.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.