package slices

Import Path
	slices (on go.dev)

Dependency Relation
	imports 4 packages, and imported by 21 packages

Involved Source Files

	    iter.go
	  d slices.go
		Package slices defines various functions useful with slices of any type.

	    sort.go
	    zsortanyfunc.go
	    zsortordered.go
Code Examples

	BinarySearch
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			names := []string{"Alice", "Bob", "Vera"}
			n, found := slices.BinarySearch(names, "Vera")
			fmt.Println("Vera:", n, found)
			n, found = slices.BinarySearch(names, "Bill")
			fmt.Println("Bill:", n, found)
		}

	BinarySearchFunc
		package main
		
		import (
			"fmt"
			"slices"
			"strings"
		)
		
		func main() {
			type Person struct {
				Name string
				Age  int
			}
			people := []Person{
				{"Alice", 55},
				{"Bob", 24},
				{"Gopher", 13},
			}
			n, found := slices.BinarySearchFunc(people, Person{"Bob", 0}, func(a, b Person) int {
				return strings.Compare(a.Name, b.Name)
			})
			fmt.Println("Bob:", n, found)
		}

	Chunk
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			type Person struct {
				Name string
				Age  int
			}
		
			type People []Person
		
			people := People{
				{"Gopher", 13},
				{"Alice", 20},
				{"Bob", 5},
				{"Vera", 24},
				{"Zac", 15},
			}
		
			// Chunk people into []Person 2 elements at a time.
			for c := range slices.Chunk(people, 2) {
				fmt.Println(c)
			}
		
		}

	Clip
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			a := [...]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
			s := a[:4:10]
			clip := slices.Clip(s)
			fmt.Println(cap(s))
			fmt.Println(clip)
			fmt.Println(len(clip))
			fmt.Println(cap(clip))
		}

	Clone
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			numbers := []int{0, 42, -10, 8}
			clone := slices.Clone(numbers)
			fmt.Println(clone)
			clone[2] = 10
			fmt.Println(numbers)
		}

	Compact
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			seq := []int{0, 1, 1, 2, 3, 5, 8}
			seq = slices.Compact(seq)
			fmt.Println(seq)
		}

	CompactFunc
		package main
		
		import (
			"fmt"
			"slices"
			"strings"
		)
		
		func main() {
			names := []string{"bob", "Bob", "alice", "Vera", "VERA"}
			names = slices.CompactFunc(names, strings.EqualFold)
			fmt.Println(names)
		}

	Compare
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			names := []string{"Alice", "Bob", "Vera"}
			fmt.Println("Equal:", slices.Compare(names, []string{"Alice", "Bob", "Vera"}))
			fmt.Println("V < X:", slices.Compare(names, []string{"Alice", "Bob", "Xena"}))
			fmt.Println("V > C:", slices.Compare(names, []string{"Alice", "Bob", "Cat"}))
			fmt.Println("3 > 2:", slices.Compare(names, []string{"Alice", "Bob"}))
		}

	CompareFunc
		package main
		
		import (
			"cmp"
			"fmt"
			"slices"
			"strconv"
		)
		
		func main() {
			numbers := []int{0, 43, 8}
			strings := []string{"0", "0", "8"}
			result := slices.CompareFunc(numbers, strings, func(n int, s string) int {
				sn, err := strconv.Atoi(s)
				if err != nil {
					return 1
				}
				return cmp.Compare(n, sn)
			})
			fmt.Println(result)
		}

	Concat
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			s1 := []int{0, 1, 2, 3}
			s2 := []int{4, 5, 6}
			concat := slices.Concat(s1, s2)
			fmt.Println(concat)
		}

	Contains
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			numbers := []int{0, 1, 2, 3}
			fmt.Println(slices.Contains(numbers, 2))
			fmt.Println(slices.Contains(numbers, 4))
		}

	ContainsFunc
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			numbers := []int{0, 42, -10, 8}
			hasNegative := slices.ContainsFunc(numbers, func(n int) bool {
				return n < 0
			})
			fmt.Println("Has a negative:", hasNegative)
			hasOdd := slices.ContainsFunc(numbers, func(n int) bool {
				return n%2 != 0
			})
			fmt.Println("Has an odd number:", hasOdd)
		}

	Delete
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			letters := []string{"a", "b", "c", "d", "e"}
			letters = slices.Delete(letters, 1, 4)
			fmt.Println(letters)
		}

	DeleteFunc
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			seq := []int{0, 1, 1, 2, 3, 5, 8}
			seq = slices.DeleteFunc(seq, func(n int) bool {
				return n%2 != 0 // delete the odd numbers
			})
			fmt.Println(seq)
		}

	Equal
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			numbers := []int{0, 42, 8}
			fmt.Println(slices.Equal(numbers, []int{0, 42, 8}))
			fmt.Println(slices.Equal(numbers, []int{10}))
		}

	EqualFunc
		package main
		
		import (
			"fmt"
			"slices"
			"strconv"
		)
		
		func main() {
			numbers := []int{0, 42, 8}
			strings := []string{"000", "42", "0o10"}
			equal := slices.EqualFunc(numbers, strings, func(n int, s string) bool {
				sn, err := strconv.ParseInt(s, 0, 64)
				if err != nil {
					return false
				}
				return n == int(sn)
			})
			fmt.Println(equal)
		}

	Grow
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			numbers := []int{0, 42, -10, 8}
			grow := slices.Grow(numbers, 2)
			fmt.Println(cap(numbers))
			fmt.Println(grow)
			fmt.Println(len(grow))
			fmt.Println(cap(grow))
		}

	Index
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			numbers := []int{0, 42, 8}
			fmt.Println(slices.Index(numbers, 8))
			fmt.Println(slices.Index(numbers, 7))
		}

	IndexFunc
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			numbers := []int{0, 42, -10, 8}
			i := slices.IndexFunc(numbers, func(n int) bool {
				return n < 0
			})
			fmt.Println("First negative at index", i)
		}

	Insert
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			names := []string{"Alice", "Bob", "Vera"}
			names = slices.Insert(names, 1, "Bill", "Billie")
			names = slices.Insert(names, len(names), "Zac")
			fmt.Println(names)
		}

	IsSorted
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			fmt.Println(slices.IsSorted([]string{"Alice", "Bob", "Vera"}))
			fmt.Println(slices.IsSorted([]int{0, 2, 1}))
		}

	IsSortedFunc
		package main
		
		import (
			"fmt"
			"slices"
			"strings"
		)
		
		func main() {
			names := []string{"alice", "Bob", "VERA"}
			isSortedInsensitive := slices.IsSortedFunc(names, func(a, b string) int {
				return strings.Compare(strings.ToLower(a), strings.ToLower(b))
			})
			fmt.Println(isSortedInsensitive)
			fmt.Println(slices.IsSorted(names))
		}

	Max
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			numbers := []int{0, 42, -10, 8}
			fmt.Println(slices.Max(numbers))
		}

	MaxFunc
		package main
		
		import (
			"cmp"
			"fmt"
			"slices"
		)
		
		func main() {
			type Person struct {
				Name string
				Age  int
			}
			people := []Person{
				{"Gopher", 13},
				{"Alice", 55},
				{"Vera", 24},
				{"Bob", 55},
			}
			firstOldest := slices.MaxFunc(people, func(a, b Person) int {
				return cmp.Compare(a.Age, b.Age)
			})
			fmt.Println(firstOldest.Name)
		}

	Min
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			numbers := []int{0, 42, -10, 8}
			fmt.Println(slices.Min(numbers))
		}

	MinFunc
		package main
		
		import (
			"cmp"
			"fmt"
			"slices"
		)
		
		func main() {
			type Person struct {
				Name string
				Age  int
			}
			people := []Person{
				{"Gopher", 13},
				{"Bob", 5},
				{"Vera", 24},
				{"Bill", 5},
			}
			firstYoungest := slices.MinFunc(people, func(a, b Person) int {
				return cmp.Compare(a.Age, b.Age)
			})
			fmt.Println(firstYoungest.Name)
		}

	Repeat
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			numbers := []int{0, 1, 2, 3}
			repeat := slices.Repeat(numbers, 2)
			fmt.Println(repeat)
		}

	Replace
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			names := []string{"Alice", "Bob", "Vera", "Zac"}
			names = slices.Replace(names, 1, 3, "Bill", "Billie", "Cat")
			fmt.Println(names)
		}

	Reverse
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			names := []string{"alice", "Bob", "VERA"}
			slices.Reverse(names)
			fmt.Println(names)
		}

	Sort
		package main
		
		import (
			"fmt"
			"slices"
		)
		
		func main() {
			smallInts := []int8{0, 42, -10, 8}
			slices.Sort(smallInts)
			fmt.Println(smallInts)
		}

	SortFunc_caseInsensitive
		package main
		
		import (
			"fmt"
			"slices"
			"strings"
		)
		
		func main() {
			names := []string{"Bob", "alice", "VERA"}
			slices.SortFunc(names, func(a, b string) int {
				return strings.Compare(strings.ToLower(a), strings.ToLower(b))
			})
			fmt.Println(names)
		}

	SortFunc_multiField
		package main
		
		import (
			"cmp"
			"fmt"
			"slices"
			"strings"
		)
		
		func main() {
			type Person struct {
				Name string
				Age  int
			}
			people := []Person{
				{"Gopher", 13},
				{"Alice", 55},
				{"Bob", 24},
				{"Alice", 20},
			}
			slices.SortFunc(people, func(a, b Person) int {
				if n := strings.Compare(a.Name, b.Name); n != 0 {
					return n
				}
				// If names are equal, order by age
				return cmp.Compare(a.Age, b.Age)
			})
			fmt.Println(people)
		}

	SortStableFunc
		package main
		
		import (
			"fmt"
			"slices"
			"strings"
		)
		
		func main() {
			type Person struct {
				Name string
				Age  int
			}
			people := []Person{
				{"Gopher", 13},
				{"Alice", 20},
				{"Bob", 24},
				{"Alice", 55},
			}
			// Stable sort by name, keeping age ordering of Alices intact
			slices.SortStableFunc(people, func(a, b Person) int {
				return strings.Compare(a.Name, b.Name)
			})
			fmt.Println(people)
		}


Package-Level Type Names (total 2, neither is exported)

	/* sort exporteds by: alphabet | popularity */
	/* 2 unexporteds ... *//* 2 unexporteds: */
	 type sortedHint int (basic type)

		As Outputs Of (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			func choosePivotCmpFunc[E](data []E, a, b int, cmp func(a, b E) int) (pivot int, hint sortedHint)
			func choosePivotOrdered[E](data []E, 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 80, in which 40 are exported)

	 func All[Slice, E](s Slice) iter.Seq2[int, E]

		Type Parameters:
			Slice: ~[]E
			E: any

		All returns an iterator over index-value pairs in the slice
		in the usual order.

	 func AppendSeq[Slice, E](s Slice, seq iter.Seq[E]) Slice

		Type Parameters:
			Slice: ~[]E
			E: any

		AppendSeq appends the values from seq to the slice and
		returns the extended slice.

	 func Backward[Slice, E](s Slice) iter.Seq2[int, E]

		Type Parameters:
			Slice: ~[]E
			E: any

		Backward returns an iterator over index-value pairs in the slice,
		traversing it backward with descending indices.

	 func BinarySearch[S, E](x S, target E) (int, bool)

		Type Parameters:
			S: ~[]E
			E: cmp.Ordered

		BinarySearch searches for target in a sorted slice and returns the earliest
		position where target is found, or the position where target would appear
		in the sort order; it also returns a bool saying whether the target is
		really found in the slice. The slice must be sorted in increasing order.

	 func BinarySearchFunc[S, E, T](x S, target T, cmp func(E, T) int) (int, bool)

		Type Parameters:
			S: ~[]E
			E: any
			T: any

		BinarySearchFunc works like [BinarySearch], but uses a custom comparison
		function. The slice must be sorted in increasing order, where "increasing"
		is defined by cmp. cmp should return 0 if the slice element matches
		the target, a negative number if the slice element precedes the target,
		or a positive number if the slice element follows the target.
		cmp must implement the same ordering as the slice, such that if
		cmp(a, t) < 0 and cmp(b, t) >= 0, then a must precede b in the slice.

	 func Chunk[Slice, E](s Slice, n int) iter.Seq[Slice]

		Type Parameters:
			Slice: ~[]E
			E: any

		Chunk returns an iterator over consecutive sub-slices of up to n elements of s.
		All but the last sub-slice will have size n.
		All sub-slices are clipped to have no capacity beyond the length.
		If s is empty, the sequence is empty: there is no empty slice in the sequence.
		Chunk panics if n is less than 1.

	 func Clip[S, E](s S) S

		Type Parameters:
			S: ~[]E
			E: any

		Clip removes unused capacity from the slice, returning s[:len(s):len(s)].

	 func Clone[S, E](s S) S

		Type Parameters:
			S: ~[]E
			E: any

		Clone returns a copy of the slice.
		The elements are copied using assignment, so this is a shallow clone.
		The result may have additional unused capacity.

	 func Collect[E](seq iter.Seq[E]) []E

		Type Parameters:
			E: any

		Collect collects values from seq into a new slice and returns it.

	 func Compact[S, E](s S) S

		Type Parameters:
			S: ~[]E
			E: comparable

		Compact replaces consecutive runs of equal elements with a single copy.
		This is like the uniq command found on Unix.
		Compact modifies the contents of the slice s and returns the modified slice,
		which may have a smaller length.
		Compact zeroes the elements between the new length and the original length.

	 func CompactFunc[S, E](s S, eq func(E, E) bool) S

		Type Parameters:
			S: ~[]E
			E: any

		CompactFunc is like [Compact] but uses an equality function to compare elements.
		For runs of elements that compare equal, CompactFunc keeps the first one.
		CompactFunc zeroes the elements between the new length and the original length.

	 func Compare[S, E](s1, s2 S) int

		Type Parameters:
			S: ~[]E
			E: cmp.Ordered

		Compare compares the elements of s1 and s2, using [cmp.Compare] on each pair
		of elements. The elements are compared sequentially, starting at index 0,
		until one element is not equal to the other.
		The result of comparing the first non-matching elements is returned.
		If both slices are equal until one of them ends, the shorter slice is
		considered less than the longer one.
		The result is 0 if s1 == s2, -1 if s1 < s2, and +1 if s1 > s2.

	 func CompareFunc[S1, S2, E1, E2](s1 S1, s2 S2, cmp func(E1, E2) int) int

		Type Parameters:
			S1: ~[]E1
			S2: ~[]E2
			E1: any
			E2: any

		CompareFunc is like [Compare] but uses a custom comparison function on each
		pair of elements.
		The result is the first non-zero result of cmp; if cmp always
		returns 0 the result is 0 if len(s1) == len(s2), -1 if len(s1) < len(s2),
		and +1 if len(s1) > len(s2).

	 func Concat[S, E](slices ...S) S

		Type Parameters:
			S: ~[]E
			E: any

		Concat returns a new slice concatenating the passed in slices.

	 func Contains[S, E](s S, v E) bool

		Type Parameters:
			S: ~[]E
			E: comparable

		Contains reports whether v is present in s.

	 func ContainsFunc[S, E](s S, f func(E) bool) bool

		Type Parameters:
			S: ~[]E
			E: any

		ContainsFunc reports whether at least one
		element e of s satisfies f(e).

	 func Delete[S, E](s S, i, j int) S

		Type Parameters:
			S: ~[]E
			E: any

		Delete removes the elements s[i:j] from s, returning the modified slice.
		Delete panics if j > len(s) or s[i:j] is not a valid slice of s.
		Delete is O(len(s)-i), so if many items must be deleted, it is better to
		make a single call deleting them all together than to delete one at a time.
		Delete zeroes the elements s[len(s)-(j-i):len(s)].

	 func DeleteFunc[S, E](s S, del func(E) bool) S

		Type Parameters:
			S: ~[]E
			E: any

		DeleteFunc removes any elements from s for which del returns true,
		returning the modified slice.
		DeleteFunc zeroes the elements between the new length and the original length.

	 func Equal[S, E](s1, s2 S) bool

		Type Parameters:
			S: ~[]E
			E: comparable

		Equal reports whether two slices are equal: the same length and all
		elements equal. If the lengths are different, Equal returns false.
		Otherwise, the elements are compared in increasing index order, and the
		comparison stops at the first unequal pair.
		Empty and nil slices are considered equal.
		Floating point NaNs are not considered equal.

	 func EqualFunc[S1, S2, E1, E2](s1 S1, s2 S2, eq func(E1, E2) bool) bool

		Type Parameters:
			S1: ~[]E1
			S2: ~[]E2
			E1: any
			E2: any

		EqualFunc reports whether two slices are equal using an equality
		function on each pair of elements. If the lengths are different,
		EqualFunc returns false. Otherwise, the elements are compared in
		increasing index order, and the comparison stops at the first index
		for which eq returns false.

	 func Grow[S, E](s S, n int) S

		Type Parameters:
			S: ~[]E
			E: any

		Grow increases the slice's capacity, if necessary, to guarantee space for
		another n elements. After Grow(n), at least n elements can be appended
		to the slice without another allocation. If n is negative or too large to
		allocate the memory, Grow panics.

	 func Index[S, E](s S, v E) int

		Type Parameters:
			S: ~[]E
			E: comparable

		Index returns the index of the first occurrence of v in s,
		or -1 if not present.

	 func IndexFunc[S, E](s S, f func(E) bool) int

		Type Parameters:
			S: ~[]E
			E: any

		IndexFunc returns the first index i satisfying f(s[i]),
		or -1 if none do.

	 func Insert[S, E](s S, i int, v ...E) S

		Type Parameters:
			S: ~[]E
			E: any

		Insert inserts the values v... into s at index i,
		returning the modified slice.
		The elements at s[i:] are shifted up to make room.
		In the returned slice r, r[i] == v[0],
		and r[i+len(v)] == value originally at r[i].
		Insert panics if i is out of range.
		This function is O(len(s) + len(v)).

	 func IsSorted[S, E](x S) bool

		Type Parameters:
			S: ~[]E
			E: cmp.Ordered

		IsSorted reports whether x is sorted in ascending order.

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

		Type Parameters:
			S: ~[]E
			E: any

		IsSortedFunc reports whether x is sorted in ascending order, with cmp as the
		comparison function as defined by [SortFunc].

	 func Max[S, E](x S) E

		Type Parameters:
			S: ~[]E
			E: cmp.Ordered

		Max returns the maximal value in x. It panics if x is empty.
		For floating-point E, Max propagates NaNs (any NaN value in x
		forces the output to be NaN).

	 func MaxFunc[S, E](x S, cmp func(a, b E) int) E

		Type Parameters:
			S: ~[]E
			E: any

		MaxFunc returns the maximal value in x, using cmp to compare elements.
		It panics if x is empty. If there is more than one maximal element
		according to the cmp function, MaxFunc returns the first one.

	 func Min[S, E](x S) E

		Type Parameters:
			S: ~[]E
			E: cmp.Ordered

		Min returns the minimal value in x. It panics if x is empty.
		For floating-point numbers, Min propagates NaNs (any NaN value in x
		forces the output to be NaN).

	 func MinFunc[S, E](x S, cmp func(a, b E) int) E

		Type Parameters:
			S: ~[]E
			E: any

		MinFunc returns the minimal value in x, using cmp to compare elements.
		It panics if x is empty. If there is more than one minimal element
		according to the cmp function, MinFunc returns the first one.

	 func Repeat[S, E](x S, count int) S

		Type Parameters:
			S: ~[]E
			E: any

		Repeat returns a new slice that repeats the provided slice the given number of times.
		The result has length and capacity (len(x) * count).
		The result is never nil.
		Repeat panics if count is negative or if the result of (len(x) * count)
		overflows.

	 func Replace[S, E](s S, i, j int, v ...E) S

		Type Parameters:
			S: ~[]E
			E: any

		Replace replaces the elements s[i:j] by the given v, and returns the
		modified slice.
		Replace panics if j > len(s) or s[i:j] is not a valid slice of s.
		When len(v) < (j-i), Replace zeroes the elements between the new length and the original length.

	 func Reverse[S, E](s S)

		Type Parameters:
			S: ~[]E
			E: any

		Reverse reverses the elements of the slice in place.

	 func Sort[S, E](x S)

		Type Parameters:
			S: ~[]E
			E: cmp.Ordered

		Sort sorts a slice of any ordered type in ascending order.
		When sorting floating-point numbers, NaNs are ordered before other values.

	 func Sorted[E](seq iter.Seq[E]) []E

		Type Parameters:
			E: cmp.Ordered

		Sorted collects values from seq into a new slice, sorts the slice,
		and returns it.

	 func SortedFunc[E](seq iter.Seq[E], cmp func(E, E) int) []E

		Type Parameters:
			E: any

		SortedFunc collects values from seq into a new slice, sorts the slice
		using the comparison function, and returns it.

	 func SortedStableFunc[E](seq iter.Seq[E], cmp func(E, E) int) []E

		Type Parameters:
			E: any

		SortedStableFunc collects values from seq into a new slice.
		It then sorts the slice while keeping the original order of equal elements,
		using the comparison function to compare elements.
		It returns the new slice.

	 func SortFunc[S, E](x S, cmp func(a, b E) int)

		Type Parameters:
			S: ~[]E
			E: any

		SortFunc sorts the slice x in ascending order as determined by the cmp
		function. This sort is not guaranteed to be stable.
		cmp(a, b) should return a negative number when a < b, a positive number when
		a > b and zero when a == b or a and b are incomparable in the sense of
		a strict weak ordering.
		
		SortFunc requires that cmp is a strict weak ordering.
		See https://en.wikipedia.org/wiki/Weak_ordering#Strict_weak_orderings.
		The function should return 0 for incomparable items.

	 func SortStableFunc[S, E](x S, cmp func(a, b E) int)

		Type Parameters:
			S: ~[]E
			E: any

		SortStableFunc sorts the slice x while keeping the original order of equal
		elements, using cmp to compare elements in the same way as [SortFunc].

	 func Values[Slice, E](s Slice) iter.Seq[E]

		Type Parameters:
			Slice: ~[]E
			E: any

		Values returns an iterator that yields the slice elements in order.

	/* 40 unexporteds ... *//* 40 unexporteds: */
	 func breakPatternsCmpFunc[E](data []E, a, b int, cmp func(a, b E) int)

		Type Parameters:
			E: any

		breakPatternsCmpFunc scatters some elements around in an attempt to break some patterns
		that might cause imbalanced partitions in quicksort.

	 func breakPatternsOrdered[E](data []E, a, b int)

		Type Parameters:
			E: cmp.Ordered

		breakPatternsOrdered scatters some elements around in an attempt to break some patterns
		that might cause imbalanced partitions in quicksort.

	 func choosePivotCmpFunc[E](data []E, a, b int, cmp func(a, b E) int) (pivot int, hint sortedHint)

		Type Parameters:
			E: any

		choosePivotCmpFunc 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 choosePivotOrdered[E](data []E, a, b int) (pivot int, hint sortedHint)

		Type Parameters:
			E: cmp.Ordered

		choosePivotOrdered 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 heapSortCmpFunc[E](data []E, a, b int, cmp func(a, b E) int)

		Type Parameters:
			E: any

	 func heapSortOrdered[E](data []E, a, b int)

		Type Parameters:
			E: cmp.Ordered

	 func insertionSortCmpFunc[E](data []E, a, b int, cmp func(a, b E) int)

		Type Parameters:
			E: any

		insertionSortCmpFunc sorts data[a:b] using insertion sort.

	 func insertionSortOrdered[E](data []E, a, b int)

		Type Parameters:
			E: cmp.Ordered

		insertionSortOrdered sorts data[a:b] using insertion sort.

	 func isNaN[T](x T) bool

		Type Parameters:
			T: cmp.Ordered

		isNaN reports whether x is a NaN without requiring the math package.
		This will always return false if T is not floating-point.

	 func medianAdjacentCmpFunc[E](data []E, a int, swaps *int, cmp func(a, b E) int) int

		Type Parameters:
			E: any

		medianAdjacentCmpFunc finds the median of data[a - 1], data[a], data[a + 1] and stores the index into a.

	 func medianAdjacentOrdered[E](data []E, a int, swaps *int) int

		Type Parameters:
			E: cmp.Ordered

		medianAdjacentOrdered finds the median of data[a - 1], data[a], data[a + 1] and stores the index into a.

	 func medianCmpFunc[E](data []E, a, b, c int, swaps *int, cmp func(a, b E) int) int

		Type Parameters:
			E: any

		medianCmpFunc returns x where data[x] is the median of data[a],data[b],data[c], where x is a, b, or c.

	 func medianOrdered[E](data []E, a, b, c int, swaps *int) int

		Type Parameters:
			E: cmp.Ordered

		medianOrdered returns x where data[x] is the median of data[a],data[b],data[c], where x is a, b, or c.

	 func nextPowerOfTwo(length int) uint
	 func order2CmpFunc[E](data []E, a, b int, swaps *int, cmp func(a, b E) int) (int, int)

		Type Parameters:
			E: any

		order2CmpFunc returns x,y where data[x] <= data[y], where x,y=a,b or x,y=b,a.

	 func order2Ordered[E](data []E, a, b int, swaps *int) (int, int)

		Type Parameters:
			E: cmp.Ordered

		order2Ordered returns x,y where data[x] <= data[y], where x,y=a,b or x,y=b,a.

	 func overlaps[E](a, b []E) bool

		Type Parameters:
			E: any

		overlaps reports whether the memory ranges a[0:len(a)] and b[0:len(b)] overlap.

	 func partialInsertionSortCmpFunc[E](data []E, a, b int, cmp func(a, b E) int) bool

		Type Parameters:
			E: any

		partialInsertionSortCmpFunc partially sorts a slice, returns true if the slice is sorted at the end.

	 func partialInsertionSortOrdered[E](data []E, a, b int) bool

		Type Parameters:
			E: cmp.Ordered

		partialInsertionSortOrdered partially sorts a slice, returns true if the slice is sorted at the end.

	 func partitionCmpFunc[E](data []E, a, b, pivot int, cmp func(a, b E) int) (newpivot int, alreadyPartitioned bool)

		Type Parameters:
			E: any

		partitionCmpFunc 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 partitionEqualCmpFunc[E](data []E, a, b, pivot int, cmp func(a, b E) int) (newpivot int)

		Type Parameters:
			E: any

		partitionEqualCmpFunc 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 partitionEqualOrdered[E](data []E, a, b, pivot int) (newpivot int)

		Type Parameters:
			E: cmp.Ordered

		partitionEqualOrdered 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 partitionOrdered[E](data []E, a, b, pivot int) (newpivot int, alreadyPartitioned bool)

		Type Parameters:
			E: cmp.Ordered

		partitionOrdered 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 pdqsortCmpFunc[E](data []E, a, b, limit int, cmp func(a, b E) int)

		Type Parameters:
			E: any

		pdqsortCmpFunc 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 pdqsortOrdered[E](data []E, a, b, limit int)

		Type Parameters:
			E: cmp.Ordered

		pdqsortOrdered 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 reverseRangeCmpFunc[E](data []E, a, b int, cmp func(a, b E) int)

		Type Parameters:
			E: any

	 func reverseRangeOrdered[E](data []E, a, b int)

		Type Parameters:
			E: cmp.Ordered

	 func rotateCmpFunc[E](data []E, a, m, b int, cmp func(a, b E) int)

		Type Parameters:
			E: any

		rotateCmpFunc 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 rotateLeft[E](s []E, r int)

		Type Parameters:
			E: any

		rotateLeft rotates s left by r spaces.
		s_final[i] = s_orig[i+r], wrapping around.

	 func rotateOrdered[E](data []E, a, m, b int)

		Type Parameters:
			E: cmp.Ordered

		rotateOrdered 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 rotateRight[E](s []E, r int)

		Type Parameters:
			E: any

	 func siftDownCmpFunc[E](data []E, lo, hi, first int, cmp func(a, b E) int)

		Type Parameters:
			E: any

		siftDownCmpFunc implements the heap property on data[lo:hi].
		first is an offset into the array where the root of the heap lies.

	 func siftDownOrdered[E](data []E, lo, hi, first int)

		Type Parameters:
			E: cmp.Ordered

		siftDownOrdered implements the heap property on data[lo:hi].
		first is an offset into the array where the root of the heap lies.

	 func stableCmpFunc[E](data []E, n int, cmp func(a, b E) int)

		Type Parameters:
			E: any

	 func stableOrdered[E](data []E, n int)

		Type Parameters:
			E: cmp.Ordered

	 func startIdx[E](haystack, needle []E) int

		Type Parameters:
			E: any

		startIdx returns the index in haystack where the needle starts.
		prerequisite: the needle must be aliased entirely inside the haystack.

	 func swapRangeCmpFunc[E](data []E, a, b, n int, cmp func(a, b E) int)

		Type Parameters:
			E: any

	 func swapRangeOrdered[E](data []E, a, b, n int)

		Type Parameters:
			E: cmp.Ordered

	 func symMergeCmpFunc[E](data []E, a, m, b int, cmp func(a, b E) int)

		Type Parameters:
			E: any

		symMergeCmpFunc 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 symMergeOrdered[E](data []E, a, m, b int)

		Type Parameters:
			E: cmp.Ordered

		symMergeOrdered 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.7.6. (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 @zigo_101 (reachable from the left QR code) to get the latest news of Golds.