diff --git a/common/cond.go b/common/cond.go
index e95cf12..bf59929 100644
--- a/common/cond.go
+++ b/common/cond.go
@@ -4,7 +4,10 @@ import (
 	"context"
 	"io"
 	"runtime"
+	"sort"
 	"unsafe"
+
+	"github.com/sagernet/sing/common/x/constraints"
 )
 
 func Any[T any](array []T, block func(it T) bool) bool {
@@ -161,6 +164,48 @@ func UniqBy[T any, C comparable](arr []T, block func(it T) C) []T {
 	return result
 }
 
+func SortBy[T any, C constraints.Ordered](arr []T, block func(it T) C) {
+	sort.Slice(arr, func(i, j int) bool {
+		return block(arr[i]) < block(arr[j])
+	})
+}
+
+func MinBy[T any, C constraints.Ordered](arr []T, block func(it T) C) T {
+	var min T
+	var minValue C
+	if len(arr) == 0 {
+		return min
+	}
+	min = arr[0]
+	for i := 1; i < len(arr); i++ {
+		item := arr[i]
+		value := block(item)
+		if value < minValue {
+			min = item
+			minValue = value
+		}
+	}
+	return min
+}
+
+func MaxBy[T any, C constraints.Ordered](arr []T, block func(it T) C) T {
+	var max T
+	var maxValue C
+	if len(arr) == 0 {
+		return max
+	}
+	max = arr[0]
+	for i := 1; i < len(arr); i++ {
+		item := arr[i]
+		value := block(item)
+		if value > maxValue {
+			max = item
+			maxValue = value
+		}
+	}
+	return max
+}
+
 func FilterIsInstance[T any, N any](arr []T, block func(it T) (N, bool)) []N {
 	var retArr []N
 	for _, it := range arr {
diff --git a/common/x/constraints/constraints.go b/common/x/constraints/constraints.go
new file mode 100644
index 0000000..2c033df
--- /dev/null
+++ b/common/x/constraints/constraints.go
@@ -0,0 +1,50 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package constraints defines a set of useful constraints to be used
+// with type parameters.
+package constraints
+
+// Signed is a constraint that permits any signed integer type.
+// If future releases of Go add new predeclared signed integer types,
+// this constraint will be modified to include them.
+type Signed interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64
+}
+
+// Unsigned is a constraint that permits any unsigned integer type.
+// If future releases of Go add new predeclared unsigned integer types,
+// this constraint will be modified to include them.
+type Unsigned interface {
+	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
+}
+
+// Integer is a constraint that permits any integer type.
+// If future releases of Go add new predeclared integer types,
+// this constraint will be modified to include them.
+type Integer interface {
+	Signed | Unsigned
+}
+
+// Float is a constraint that permits any floating-point type.
+// If future releases of Go add new predeclared floating-point types,
+// this constraint will be modified to include them.
+type Float interface {
+	~float32 | ~float64
+}
+
+// Complex is a constraint that permits any complex numeric type.
+// If future releases of Go add new predeclared complex numeric types,
+// this constraint will be modified to include them.
+type Complex interface {
+	~complex64 | ~complex128
+}
+
+// Ordered is a constraint that permits any ordered type: any type
+// that supports the operators < <= >= >.
+// If future releases of Go add new ordered types,
+// this constraint will be modified to include them.
+type Ordered interface {
+	Integer | Float | ~string
+}