apiVersion: release-notes/v2
kind: feature
area: istioctl
releaseNotes:
- |

John Howard <******@****.***> 1706030446 -0800

	// the executable.
	cmd = testenv.Command(t, gotool, "tool", "nm", dest)
	if output, err = cmd.CombinedOutput(); err != nil {
		t.Fatalf("Failed: %v:\nOut: %s\n", err, output)
	}
	// Look for shape-based instantiation of Sort, but ignore any extra wrapper
	// ending in "-tramp" (which are created on riscv).
	re := regexp.MustCompile(`\bSort\[.*shape.*\][^-]`)
	r := re.FindAllIndex(output, -1)

      echo "${dep} ${repo}" >> "${TMP_DIR}/tidy_deps.txt"
      # switch the required version to an explicit v0.0.0 (rather than an unknown v0.0.0-00010101000000-000000000000)
      go mod edit -require "${dep}@v0.0.0"
    done
  )
done < "${tidy_unordered}"

kube::log::status "go.mod: tidying" >&11
for repo in $(tsort "${TMP_DIR}/tidy_deps.txt"); do
  (

	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))

	// Output: true
	// false
	// false
}

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

}

// 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.

	for i := 0; i < b.N; i++ {
		Sort(StringSlice(ss))
	}
}

func BenchmarkSlicesSortStrings_Sorted(b *testing.B) {
	ss := makeSortedStrings(N)
	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		slices.Sort(ss)
	}
}

// These benchmarks compare sorting a slice of structs with sort.Sort vs.
// slices.SortFunc.
type myStruct struct {
	a, b, c, d string
	n          int
}

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)
}

				data-toggle="control-options"> <c:if test="${empty sort}">
						<la:message key="labels.searchoptions_score" />
					</c:if> <c:if test="${sort=='score.desc'}">
						<la:message key="labels.searchoptions_score" />
					</c:if> <c:if test="${sort=='filename.asc'}">
						<la:message key="labels.search_result_sort_filename_asc" />
					</c:if> <c:if test="${sort=='filename.desc'}">

				data-toggle="control-options"> <c:if test="${empty sort}">
						<la:message key="labels.searchoptions_score" />
					</c:if> <c:if test="${sort=='score.desc'}">
						<la:message key="labels.searchoptions_score" />
					</c:if> <c:if test="${sort=='filename.asc'}">
						<la:message key="labels.search_result_sort_filename_asc" />
					</c:if> <c:if test="${sort=='filename.desc'}">