test: collection 包完善测试用例

game/activity/events.go

@@ -3,7 +3,7 @@ package activity
 import (
 	"fmt"
 	"github.com/kercylan98/minotaur/utils/collection"
-	listings2 "github.com/kercylan98/minotaur/utils/collection/listings"
+	"github.com/kercylan98/minotaur/utils/collection/listings"
 	"github.com/kercylan98/minotaur/utils/generic"
 	"github.com/kercylan98/minotaur/utils/log"
 	"github.com/kercylan98/minotaur/utils/timer"
@@ -22,28 +22,28 @@ type (
 )
 
 var (
-	upcomingEventHandlers       map[any]*listings2.PrioritySlice[func(activityId any)] // 即将开始的活动事件处理器
+	upcomingEventHandlers       map[any]*listings.PrioritySlice[func(activityId any)] // 即将开始的活动事件处理器
-	startedEventHandlers        map[any]*listings2.PrioritySlice[func(activityId any)] // 活动开始事件处理器
+	startedEventHandlers        map[any]*listings.PrioritySlice[func(activityId any)] // 活动开始事件处理器
-	endedEventHandlers          map[any]*listings2.PrioritySlice[func(activityId any)] // 活动结束事件处理器
+	endedEventHandlers          map[any]*listings.PrioritySlice[func(activityId any)] // 活动结束事件处理器
-	extShowStartedEventHandlers map[any]*listings2.PrioritySlice[func(activityId any)] // 活动结束后延长展示开始事件处理器
+	extShowStartedEventHandlers map[any]*listings.PrioritySlice[func(activityId any)] // 活动结束后延长展示开始事件处理器
-	extShowEndedEventHandlers   map[any]*listings2.PrioritySlice[func(activityId any)] // 活动结束后延长展示结束事件处理器
+	extShowEndedEventHandlers   map[any]*listings.PrioritySlice[func(activityId any)] // 活动结束后延长展示结束事件处理器
-	newDayEventHandlers         map[any]*listings2.PrioritySlice[func(activityId any)] // 新的一天事件处理器
+	newDayEventHandlers         map[any]*listings.PrioritySlice[func(activityId any)] // 新的一天事件处理器
 )
 
 func init() {
-	upcomingEventHandlers = make(map[any]*listings2.PrioritySlice[func(activityId any)])
+	upcomingEventHandlers = make(map[any]*listings.PrioritySlice[func(activityId any)])
-	startedEventHandlers = make(map[any]*listings2.PrioritySlice[func(activityId any)])
+	startedEventHandlers = make(map[any]*listings.PrioritySlice[func(activityId any)])
-	endedEventHandlers = make(map[any]*listings2.PrioritySlice[func(activityId any)])
+	endedEventHandlers = make(map[any]*listings.PrioritySlice[func(activityId any)])
-	extShowStartedEventHandlers = make(map[any]*listings2.PrioritySlice[func(activityId any)])
+	extShowStartedEventHandlers = make(map[any]*listings.PrioritySlice[func(activityId any)])
-	extShowEndedEventHandlers = make(map[any]*listings2.PrioritySlice[func(activityId any)])
+	extShowEndedEventHandlers = make(map[any]*listings.PrioritySlice[func(activityId any)])
-	newDayEventHandlers = make(map[any]*listings2.PrioritySlice[func(activityId any)])
+	newDayEventHandlers = make(map[any]*listings.PrioritySlice[func(activityId any)])
 }
 
 // RegUpcomingEvent 注册即将开始的活动事件处理器
 func RegUpcomingEvent[Type, ID generic.Basic](activityType Type, handler UpcomingEventHandler[ID], priority ...int) {
 	handlers, exist := upcomingEventHandlers[activityType]
 	if !exist {
-		handlers = listings2.NewPrioritySlice[func(activityId any)]()
+		handlers = listings.NewPrioritySlice[func(activityId any)]()
 		upcomingEventHandlers[activityType] = handlers
 	}
 	handlers.Append(func(activityId any) {
@@ -76,7 +76,7 @@ func OnUpcomingEvent[Type, ID generic.Basic](activity *Activity[Type, ID]) {
 func RegStartedEvent[Type, ID generic.Basic](activityType Type, handler StartedEventHandler[ID], priority ...int) {
 	handlers, exist := startedEventHandlers[activityType]
 	if !exist {
-		handlers = listings2.NewPrioritySlice[func(activityId any)]()
+		handlers = listings.NewPrioritySlice[func(activityId any)]()
 		startedEventHandlers[activityType] = handlers
 	}
 	handlers.Append(func(activityId any) {
@@ -117,7 +117,7 @@ func OnStartedEvent[Type, ID generic.Basic](activity *Activity[Type, ID]) {
 func RegEndedEvent[Type, ID generic.Basic](activityType Type, handler EndedEventHandler[ID], priority ...int) {
 	handlers, exist := endedEventHandlers[activityType]
 	if !exist {
-		handlers = listings2.NewPrioritySlice[func(activityId any)]()
+		handlers = listings.NewPrioritySlice[func(activityId any)]()
 		endedEventHandlers[activityType] = handlers
 	}
 	handlers.Append(func(activityId any) {
@@ -150,7 +150,7 @@ func OnEndedEvent[Type, ID generic.Basic](activity *Activity[Type, ID]) {
 func RegExtendedShowStartedEvent[Type, ID generic.Basic](activityType Type, handler ExtendedShowStartedEventHandler[ID], priority ...int) {
 	handlers, exist := extShowStartedEventHandlers[activityType]
 	if !exist {
-		handlers = listings2.NewPrioritySlice[func(activityId any)]()
+		handlers = listings.NewPrioritySlice[func(activityId any)]()
 		extShowStartedEventHandlers[activityType] = handlers
 	}
 	handlers.Append(func(activityId any) {
@@ -183,7 +183,7 @@ func OnExtendedShowStartedEvent[Type, ID generic.Basic](activity *Activity[Type,
 func RegExtendedShowEndedEvent[Type, ID generic.Basic](activityType Type, handler ExtendedShowEndedEventHandler[ID], priority ...int) {
 	handlers, exist := extShowEndedEventHandlers[activityType]
 	if !exist {
-		handlers = listings2.NewPrioritySlice[func(activityId any)]()
+		handlers = listings.NewPrioritySlice[func(activityId any)]()
 		extShowEndedEventHandlers[activityType] = handlers
 	}
 	handlers.Append(func(activityId any) {
@@ -216,7 +216,7 @@ func OnExtendedShowEndedEvent[Type, ID generic.Basic](activity *Activity[Type, I
 func RegNewDayEvent[Type, ID generic.Basic](activityType Type, handler NewDayEventHandler[ID], priority ...int) {
 	handlers, exist := newDayEventHandlers[activityType]
 	if !exist {
-		handlers = listings2.NewPrioritySlice[func(activityId any)]()
+		handlers = listings.NewPrioritySlice[func(activityId any)]()
 		newDayEventHandlers[activityType] = handlers
 	}
 	handlers.Append(func(activityId any) {

planner/pce/tmpl_field.go

@@ -96,7 +96,7 @@ func (slf *TmplField) handleSlice(fieldName, fieldType string, fields map[string
 	}
 	slf.slice = true
 	t := strings.TrimPrefix(fieldType, "[]")
-	if collection.FindInMapKey(fields, t) {
+	if collection.KeyInMap(fields, t) {
 		slf.Struct = nil
 		slf.Type = t
 	} else {

planner/pce/tmpl_struct.go

@@ -19,7 +19,7 @@ func (slf *TmplStruct) addField(parent, name, desc, fieldType string, fields map
 		Desc: desc,
 		Type: fieldType,
 	}
-	if !collection.FindInMapKey(fields, fieldType) {
+	if !collection.KeyInMap(fields, fieldType) {
 		field.setStruct(parent, name, desc, fieldType, fields)
 	} else {
 		field.Type = GetFieldGolangType(fields[fieldType])

server/event.go

@@ -3,7 +3,7 @@ package server
 import (
 	"fmt"
 	"github.com/kercylan98/minotaur/utils/collection"
-	listings2 "github.com/kercylan98/minotaur/utils/collection/listings"
+	"github.com/kercylan98/minotaur/utils/collection/listings"
 	"github.com/kercylan98/minotaur/utils/log"
 	"github.com/kercylan98/minotaur/utils/runtimes"
 	"golang.org/x/crypto/ssh/terminal"
@@ -43,45 +43,45 @@ type (
 func newEvent(srv *Server) *event {
 	return &event{
 		Server:                                  srv,
-		startBeforeEventHandlers:                listings2.NewPrioritySlice[StartBeforeEventHandler](),
+		startBeforeEventHandlers:                listings.NewPrioritySlice[StartBeforeEventHandler](),
-		startFinishEventHandlers:                listings2.NewPrioritySlice[StartFinishEventHandler](),
+		startFinishEventHandlers:                listings.NewPrioritySlice[StartFinishEventHandler](),
-		stopEventHandlers:                       listings2.NewPrioritySlice[StopEventHandler](),
+		stopEventHandlers:                       listings.NewPrioritySlice[StopEventHandler](),
-		connectionReceivePacketEventHandlers:    listings2.NewPrioritySlice[ConnectionReceivePacketEventHandler](),
+		connectionReceivePacketEventHandlers:    listings.NewPrioritySlice[ConnectionReceivePacketEventHandler](),
-		connectionOpenedEventHandlers:           listings2.NewPrioritySlice[ConnectionOpenedEventHandler](),
+		connectionOpenedEventHandlers:           listings.NewPrioritySlice[ConnectionOpenedEventHandler](),
-		connectionClosedEventHandlers:           listings2.NewPrioritySlice[ConnectionClosedEventHandler](),
+		connectionClosedEventHandlers:           listings.NewPrioritySlice[ConnectionClosedEventHandler](),
-		messageErrorEventHandlers:               listings2.NewPrioritySlice[MessageErrorEventHandler](),
+		messageErrorEventHandlers:               listings.NewPrioritySlice[MessageErrorEventHandler](),
-		messageLowExecEventHandlers:             listings2.NewPrioritySlice[MessageLowExecEventHandler](),
+		messageLowExecEventHandlers:             listings.NewPrioritySlice[MessageLowExecEventHandler](),
-		connectionOpenedAfterEventHandlers:      listings2.NewPrioritySlice[ConnectionOpenedAfterEventHandler](),
+		connectionOpenedAfterEventHandlers:      listings.NewPrioritySlice[ConnectionOpenedAfterEventHandler](),
-		connectionWritePacketBeforeHandlers:     listings2.NewPrioritySlice[ConnectionWritePacketBeforeEventHandler](),
+		connectionWritePacketBeforeHandlers:     listings.NewPrioritySlice[ConnectionWritePacketBeforeEventHandler](),
-		shuntChannelCreatedEventHandlers:        listings2.NewPrioritySlice[ShuntChannelCreatedEventHandler](),
+		shuntChannelCreatedEventHandlers:        listings.NewPrioritySlice[ShuntChannelCreatedEventHandler](),
-		shuntChannelClosedEventHandlers:         listings2.NewPrioritySlice[ShuntChannelClosedEventHandler](),
+		shuntChannelClosedEventHandlers:         listings.NewPrioritySlice[ShuntChannelClosedEventHandler](),
-		connectionPacketPreprocessEventHandlers: listings2.NewPrioritySlice[ConnectionPacketPreprocessEventHandler](),
+		connectionPacketPreprocessEventHandlers: listings.NewPrioritySlice[ConnectionPacketPreprocessEventHandler](),
-		messageExecBeforeEventHandlers:          listings2.NewPrioritySlice[MessageExecBeforeEventHandler](),
+		messageExecBeforeEventHandlers:          listings.NewPrioritySlice[MessageExecBeforeEventHandler](),
-		messageReadyEventHandlers:               listings2.NewPrioritySlice[MessageReadyEventHandler](),
+		messageReadyEventHandlers:               listings.NewPrioritySlice[MessageReadyEventHandler](),
-		deadlockDetectEventHandlers:             listings2.NewPrioritySlice[OnDeadlockDetectEventHandler](),
+		deadlockDetectEventHandlers:             listings.NewPrioritySlice[OnDeadlockDetectEventHandler](),
 	}
 }
 
 type event struct {
 	*Server
-	startBeforeEventHandlers                *listings2.PrioritySlice[StartBeforeEventHandler]
+	startBeforeEventHandlers                *listings.PrioritySlice[StartBeforeEventHandler]
-	startFinishEventHandlers                *listings2.PrioritySlice[StartFinishEventHandler]
+	startFinishEventHandlers                *listings.PrioritySlice[StartFinishEventHandler]
-	stopEventHandlers                       *listings2.PrioritySlice[StopEventHandler]
+	stopEventHandlers                       *listings.PrioritySlice[StopEventHandler]
-	connectionReceivePacketEventHandlers    *listings2.PrioritySlice[ConnectionReceivePacketEventHandler]
+	connectionReceivePacketEventHandlers    *listings.PrioritySlice[ConnectionReceivePacketEventHandler]
-	connectionOpenedEventHandlers           *listings2.PrioritySlice[ConnectionOpenedEventHandler]
+	connectionOpenedEventHandlers           *listings.PrioritySlice[ConnectionOpenedEventHandler]
-	connectionClosedEventHandlers           *listings2.PrioritySlice[ConnectionClosedEventHandler]
+	connectionClosedEventHandlers           *listings.PrioritySlice[ConnectionClosedEventHandler]
-	messageErrorEventHandlers               *listings2.PrioritySlice[MessageErrorEventHandler]
+	messageErrorEventHandlers               *listings.PrioritySlice[MessageErrorEventHandler]
-	messageLowExecEventHandlers             *listings2.PrioritySlice[MessageLowExecEventHandler]
+	messageLowExecEventHandlers             *listings.PrioritySlice[MessageLowExecEventHandler]
-	connectionOpenedAfterEventHandlers      *listings2.PrioritySlice[ConnectionOpenedAfterEventHandler]
+	connectionOpenedAfterEventHandlers      *listings.PrioritySlice[ConnectionOpenedAfterEventHandler]
-	connectionWritePacketBeforeHandlers     *listings2.PrioritySlice[ConnectionWritePacketBeforeEventHandler]
+	connectionWritePacketBeforeHandlers     *listings.PrioritySlice[ConnectionWritePacketBeforeEventHandler]
-	shuntChannelCreatedEventHandlers        *listings2.PrioritySlice[ShuntChannelCreatedEventHandler]
+	shuntChannelCreatedEventHandlers        *listings.PrioritySlice[ShuntChannelCreatedEventHandler]
-	shuntChannelClosedEventHandlers         *listings2.PrioritySlice[ShuntChannelClosedEventHandler]
+	shuntChannelClosedEventHandlers         *listings.PrioritySlice[ShuntChannelClosedEventHandler]
-	connectionPacketPreprocessEventHandlers *listings2.PrioritySlice[ConnectionPacketPreprocessEventHandler]
+	connectionPacketPreprocessEventHandlers *listings.PrioritySlice[ConnectionPacketPreprocessEventHandler]
-	messageExecBeforeEventHandlers          *listings2.PrioritySlice[MessageExecBeforeEventHandler]
+	messageExecBeforeEventHandlers          *listings.PrioritySlice[MessageExecBeforeEventHandler]
-	messageReadyEventHandlers               *listings2.PrioritySlice[MessageReadyEventHandler]
+	messageReadyEventHandlers               *listings.PrioritySlice[MessageReadyEventHandler]
-	deadlockDetectEventHandlers             *listings2.PrioritySlice[OnDeadlockDetectEventHandler]
+	deadlockDetectEventHandlers             *listings.PrioritySlice[OnDeadlockDetectEventHandler]
 
-	consoleCommandEventHandlers        map[string]*listings2.PrioritySlice[ConsoleCommandEventHandler]
+	consoleCommandEventHandlers        map[string]*listings.PrioritySlice[ConsoleCommandEventHandler]
 	consoleCommandEventHandlerInitOnce sync.Once
 }
 
@@ -109,7 +109,7 @@ func (slf *event) RegConsoleCommandEvent(command string, handler ConsoleCommandE
 	}
 
 	slf.consoleCommandEventHandlerInitOnce.Do(func() {
-		slf.consoleCommandEventHandlers = map[string]*listings2.PrioritySlice[ConsoleCommandEventHandler]{}
+		slf.consoleCommandEventHandlers = map[string]*listings.PrioritySlice[ConsoleCommandEventHandler]{}
 		go func() {
 			for {
 				var input string
@@ -124,7 +124,7 @@ func (slf *event) RegConsoleCommandEvent(command string, handler ConsoleCommandE
 	})
 	list, exist := slf.consoleCommandEventHandlers[command]
 	if !exist {
-		list = listings2.NewPrioritySlice[ConsoleCommandEventHandler]()
+		list = listings.NewPrioritySlice[ConsoleCommandEventHandler]()
 		slf.consoleCommandEventHandlers[command] = list
 	}
 	list.Append(handler, collection.FindFirstOrDefaultInSlice(priority, 0))

server/gateway/events.go

@@ -3,7 +3,7 @@ package gateway
 import (
 	"github.com/kercylan98/minotaur/server"
 	"github.com/kercylan98/minotaur/utils/collection"
-	listings2 "github.com/kercylan98/minotaur/utils/collection/listings"
+	"github.com/kercylan98/minotaur/utils/collection/listings"
 )
 
 type (
@@ -17,22 +17,22 @@ type (
 
 func newEvents() *events {
 	return &events{
-		connectionOpenedEventHandles:             listings2.NewPrioritySlice[ConnectionOpenedEventHandle](),
+		connectionOpenedEventHandles:             listings.NewPrioritySlice[ConnectionOpenedEventHandle](),
-		connectionClosedEventHandles:             listings2.NewPrioritySlice[ConnectionClosedEventHandle](),
+		connectionClosedEventHandles:             listings.NewPrioritySlice[ConnectionClosedEventHandle](),
-		connectionReceivePacketEventHandles:      listings2.NewPrioritySlice[ConnectionReceivePacketEventHandle](),
+		connectionReceivePacketEventHandles:      listings.NewPrioritySlice[ConnectionReceivePacketEventHandle](),
-		endpointConnectOpenedEventHandles:        listings2.NewPrioritySlice[EndpointConnectOpenedEventHandle](),
+		endpointConnectOpenedEventHandles:        listings.NewPrioritySlice[EndpointConnectOpenedEventHandle](),
-		endpointConnectClosedEventHandles:        listings2.NewPrioritySlice[EndpointConnectClosedEventHandle](),
+		endpointConnectClosedEventHandles:        listings.NewPrioritySlice[EndpointConnectClosedEventHandle](),
-		endpointConnectReceivePacketEventHandles: listings2.NewPrioritySlice[EndpointConnectReceivePacketEventHandle](),
+		endpointConnectReceivePacketEventHandles: listings.NewPrioritySlice[EndpointConnectReceivePacketEventHandle](),
 	}
 }
 
 type events struct {
-	connectionOpenedEventHandles             *listings2.PrioritySlice[ConnectionOpenedEventHandle]
+	connectionOpenedEventHandles             *listings.PrioritySlice[ConnectionOpenedEventHandle]
-	connectionClosedEventHandles             *listings2.PrioritySlice[ConnectionClosedEventHandle]
+	connectionClosedEventHandles             *listings.PrioritySlice[ConnectionClosedEventHandle]
-	connectionReceivePacketEventHandles      *listings2.PrioritySlice[ConnectionReceivePacketEventHandle]
+	connectionReceivePacketEventHandles      *listings.PrioritySlice[ConnectionReceivePacketEventHandle]
-	endpointConnectOpenedEventHandles        *listings2.PrioritySlice[EndpointConnectOpenedEventHandle]
+	endpointConnectOpenedEventHandles        *listings.PrioritySlice[EndpointConnectOpenedEventHandle]
-	endpointConnectClosedEventHandles        *listings2.PrioritySlice[EndpointConnectClosedEventHandle]
+	endpointConnectClosedEventHandles        *listings.PrioritySlice[EndpointConnectClosedEventHandle]
-	endpointConnectReceivePacketEventHandles *listings2.PrioritySlice[EndpointConnectReceivePacketEventHandle]
+	endpointConnectReceivePacketEventHandles *listings.PrioritySlice[EndpointConnectReceivePacketEventHandle]
 }
 
 // RegConnectionOpenedEventHandle 注册客户端连接打开事件处理函数

server/message.go

@@ -70,7 +70,7 @@ type (
 
 // HasMessageType 检查是否存在指定的消息类型
 func HasMessageType(mt MessageType) bool {
-	return collection.FindInMapKey(messageNames, mt)
+	return collection.KeyInMap(messageNames, mt)
 }
 
 // Message 服务器消息

server/network.go

@@ -57,7 +57,7 @@ func GetNetworks() []Network {
 
 // check 检查网络模式是否支持
 func (n Network) check() {
-	if !collection.FindInMapKey(networkNameMap, string(n)) {
+	if !collection.KeyInMap(networkNameMap, string(n)) {
 		panic(fmt.Errorf("unsupported network mode: %s", n))
 	}
 }

utils/arrangement/area.go

@@ -45,7 +45,7 @@ func (slf *Area[ID, AreaInfo]) IsAllow(item Item[ID]) (constraintErr error, conf
 
 // IsConflict 检测一个成员是否会造成冲突
 func (slf *Area[ID, AreaInfo]) IsConflict(item Item[ID]) bool {
-	if collection.FindInMapKey(slf.items, item.GetID()) {
+	if collection.KeyInMap(slf.items, item.GetID()) {
 		return false
 	}
 	for _, conflict := range slf.conflicts {
@@ -58,7 +58,7 @@ func (slf *Area[ID, AreaInfo]) IsConflict(item Item[ID]) bool {
 
 // GetConflictItems 获取与一个成员产生冲突的所有其他成员
 func (slf *Area[ID, AreaInfo]) GetConflictItems(item Item[ID]) map[ID]Item[ID] {
-	if collection.FindInMapKey(slf.items, item.GetID()) {
+	if collection.KeyInMap(slf.items, item.GetID()) {
 		return nil
 	}
 	var conflictItems map[ID]Item[ID]

utils/arrangement/editor.go

@@ -32,7 +32,7 @@ func (slf *Editor[ID, AreaInfo]) RemoveAreaItem(area *Area[ID, AreaInfo], item I
 
 // AddAreaItem 将一个成员添加到编排区域中，如果该成员已经存在于编排区域中，则不进行任何操作
 func (slf *Editor[ID, AreaInfo]) AddAreaItem(area *Area[ID, AreaInfo], item Item[ID]) {
-	if collection.FindInMapKey(slf.falls, item.GetID()) {
+	if collection.KeyInMap(slf.falls, item.GetID()) {
 		return
 	}
 	area.items[item.GetID()] = item

utils/collection/collection.go

@@ -0,0 +1,6 @@
+package collection
+
+import "github.com/kercylan98/minotaur/utils/generic"
+
+type ComparisonHandler[V any] func(source, target V) bool
+type OrderedValueGetter[V any, N generic.Ordered] func(v V) N

utils/collection/contains.go

@@ -1,7 +1,5 @@
 package collection
 
-type ComparisonHandler[V any] func(source, target V) bool
-
 // InSlice 检查 v 是否被包含在 slice 中，当 handler 返回 true 时，表示 v 和 slice 中的某个元素相匹配
 func InSlice[S ~[]V, V any](slice S, v V, handler ComparisonHandler[V]) bool {
 	if len(slice) == 0 {

utils/collection/find.go

@@ -1,6 +1,8 @@
 package collection
 
-import "github.com/kercylan98/minotaur/utils/generic"
+import (
+	"github.com/kercylan98/minotaur/utils/generic"
+)
 
 // FindLoopedNextInSlice 返回 i 的下一个数组成员，当 i 达到数组长度时从 0 开始
 //   - 当 i 为负数时将返回第一个元素
@@ -143,32 +145,42 @@ func FindIndexInComparableSlice[S ~[]V, V comparable](slice S, v V) int {
 	return -1
 }
 
-// FindInSliceByBinary 判断切片中是否存在某个元素，返回第一个匹配的索引和元素，不存在则索引返回 -1
+// FindMinimumInComparableSlice 获取切片中的最小值
-func FindInSliceByBinary[S ~[]V, V any](slice S, handler func(v V) bool) (i int, t V) {
+func FindMinimumInComparableSlice[S ~[]V, V generic.Ordered](slice S) (result V) {
-	low := 0
-	high := len(slice) - 1
-
-	for low <= high {
-		mid := low + (high-low)/2
-		if handler(slice[mid]) {
-			return mid, slice[mid]
-		} else if handler(slice[mid]) {
-			high = mid - 1
-		} else {
-			low = mid + 1
-		}
-	}
-	return -1, t
-}
-
-// FindMinimumInSlice 获取切片中的最小值
-func FindMinimumInSlice[S ~[]V, V generic.Number](slice S, handler ComparisonHandler[V]) (result V) {
 	if len(slice) == 0 {
 		return
 	}
 	result = slice[0]
 	for i := 1; i < len(slice); i++ {
-		if handler(slice[i], result) {
+		if result > slice[i] {
+			result = slice[i]
+		}
+	}
+	return
+}
+
+// FindMinimumInSlice 获取切片中的最小值
+func FindMinimumInSlice[S ~[]V, V any, N generic.Ordered](slice S, handler OrderedValueGetter[V, N]) (result V) {
+	if len(slice) == 0 {
+		return
+	}
+	result = slice[0]
+	for i := 1; i < len(slice); i++ {
+		if handler(result) > handler(slice[i]) {
+			result = slice[i]
+		}
+	}
+	return
+}
+
+// FindMaximumInComparableSlice 获取切片中的最大值
+func FindMaximumInComparableSlice[S ~[]V, V generic.Ordered](slice S) (result V) {
+	if len(slice) == 0 {
+		return
+	}
+	result = slice[0]
+	for i := 1; i < len(slice); i++ {
+		if result < slice[i] {
 			result = slice[i]
 		}
 	}
@@ -176,44 +188,100 @@ func FindMinimumInSlice[S ~[]V, V generic.Number](slice S, handler ComparisonHan
 }
 
 // FindMaximumInSlice 获取切片中的最大值
-func FindMaximumInSlice[S ~[]V, V generic.Number](slice S, handler ComparisonHandler[V]) (result V) {
+func FindMaximumInSlice[S ~[]V, V any, N generic.Ordered](slice S, handler OrderedValueGetter[V, N]) (result V) {
 	if len(slice) == 0 {
 		return
 	}
 	result = slice[0]
 	for i := 1; i < len(slice); i++ {
-		if handler(result, slice[i]) {
+		if handler(result) < handler(slice[i]) {
 			result = slice[i]
 		}
 	}
 	return
 }
 
-// FindMin2MaxInSlice 获取切片中的最小值和最大值
+// FindMin2MaxInComparableSlice 获取切片中的最小值和最大值
-func FindMin2MaxInSlice[S ~[]V, V generic.Number](slice S, handler ComparisonHandler[V]) (min, max V) {
+func FindMin2MaxInComparableSlice[S ~[]V, V generic.Ordered](slice S) (min, max V) {
 	if len(slice) == 0 {
 		return
 	}
 	min = slice[0]
 	max = slice[0]
 	for i := 1; i < len(slice); i++ {
-		if handler(slice[i], min) {
+		if min > slice[i] {
 			min = slice[i]
 		}
-		if handler(max, slice[i]) {
+		if max < slice[i] {
 			max = slice[i]
 		}
 	}
 	return
 }
 
+// FindMin2MaxInSlice 获取切片中的最小值和最大值
+func FindMin2MaxInSlice[S ~[]V, V any, N generic.Ordered](slice S, handler OrderedValueGetter[V, N]) (min, max V) {
+	if len(slice) == 0 {
+		return
+	}
+	min = slice[0]
+	max = slice[0]
+	for i := 1; i < len(slice); i++ {
+		if handler(min) > handler(slice[i]) {
+			min = slice[i]
+		}
+		if handler(max) < handler(slice[i]) {
+			max = slice[i]
+		}
+	}
+	return
+}
+
+// FindMinFromComparableMap 获取 map 中的最小值
+func FindMinFromComparableMap[M ~map[K]V, K comparable, V generic.Ordered](m M) (result V) {
+	if m == nil {
+		return
+	}
+	var first bool
+	for _, v := range m {
+		if !first {
+			result = v
+			first = true
+			continue
+		}
+		if result > v {
+			result = v
+		}
+	}
+	return
+}
+
 // FindMinFromMap 获取 map 中的最小值
-func FindMinFromMap[M ~map[K]V, K comparable, V generic.Number](m M, handler ComparisonHandler[V]) (result V) {
+func FindMinFromMap[M ~map[K]V, K comparable, V any, N generic.Ordered](m M, handler OrderedValueGetter[V, N]) (result V) {
+	if m == nil {
+		return
+	}
+	var first bool
+	for _, v := range m {
+		if !first {
+			result = v
+			first = true
+			continue
+		}
+		if handler(result) > handler(v) {
+			result = v
+		}
+	}
+	return
+}
+
+// FindMaxFromComparableMap 获取 map 中的最大值
+func FindMaxFromComparableMap[M ~map[K]V, K comparable, V generic.Ordered](m M) (result V) {
 	if m == nil {
 		return
 	}
 	for _, v := range m {
-		if handler(v, result) {
+		if result < v {
 			result = v
 		}
 	}
@@ -221,36 +289,60 @@ func FindMinFromMap[M ~map[K]V, K comparable, V generic.Number](m M, handler Com
 }
 
 // FindMaxFromMap 获取 map 中的最大值
-func FindMaxFromMap[M ~map[K]V, K comparable, V generic.Number](m M, handler ComparisonHandler[V]) (result V) {
+func FindMaxFromMap[M ~map[K]V, K comparable, V any, N generic.Ordered](m M, handler OrderedValueGetter[V, N]) (result V) {
 	if m == nil {
 		return
 	}
 	for _, v := range m {
-		if handler(result, v) {
+		if handler(result) < handler(v) {
 			result = v
 		}
 	}
 	return
 }
 
-// FindMin2MaxFromMap 获取 map 中的最小值和最大值
+// FindMin2MaxFromComparableMap 获取 map 中的最小值和最大值
-func FindMin2MaxFromMap[M ~map[K]V, K comparable, V generic.Number](m M, handler ComparisonHandler[V]) (min, max V) {
+func FindMin2MaxFromComparableMap[M ~map[K]V, K comparable, V generic.Ordered](m M) (min, max V) {
 	if m == nil {
 		return
 	}
+	var first bool
 	for _, v := range m {
-		if handler(v, min) {
+		if !first {
+			min = v
+			max = v
+			first = true
+			continue
+		}
+		if min > v {
 			min = v
 		}
-		if handler(max, v) {
+		if max < v {
 			max = v
 		}
 	}
 	return
 }
 
-// FindInMapKey 判断 map 中是否存在某个 key
+// FindMin2MaxFromMap 获取 map 中的最小值和最大值
-func FindInMapKey[M ~map[K]V, K comparable, V any](m M, k K) bool {
+func FindMin2MaxFromMap[M ~map[K]V, K comparable, V generic.Ordered](m M) (min, max V) {
-	_, exist := m[k]
+	if m == nil {
-	return exist
+		return
+	}
+	var first bool
+	for _, v := range m {
+		if !first {
+			min = v
+			max = v
+			first = true
+			continue
+		}
+		if min > v {
+			min = v
+		}
+		if max < v {
+			max = v
+		}
+	}
+	return
 }

utils/collection/find_example_test.go

@@ -48,3 +48,129 @@ func ExampleFindOrDefaultInComparableSlice() {
 	// Output:
 	// 2
 }
+
+func ExampleFindInSlice() {
+	_, result := collection.FindInSlice([]int{1, 2, 3}, func(v int) bool {
+		return v == 2
+	})
+	fmt.Println(result)
+	// Output:
+	// 2
+}
+
+func ExampleFindIndexInSlice() {
+	result := collection.FindIndexInSlice([]int{1, 2, 3}, func(v int) bool {
+		return v == 2
+	})
+	fmt.Println(result)
+	// Output:
+	// 1
+}
+
+func ExampleFindInComparableSlice() {
+	index, result := collection.FindInComparableSlice([]int{1, 2, 3}, 2)
+	fmt.Println(index, result)
+	// Output:
+	// 1 2
+}
+
+func ExampleFindIndexInComparableSlice() {
+	result := collection.FindIndexInComparableSlice([]int{1, 2, 3}, 2)
+	fmt.Println(result)
+	// Output:
+	// 1
+}
+
+func ExampleFindMinimumInComparableSlice() {
+	result := collection.FindMinimumInComparableSlice([]int{1, 2, 3})
+	fmt.Println(result)
+	// Output:
+	// 1
+}
+
+func ExampleFindMinimumInSlice() {
+	result := collection.FindMinimumInSlice([]int{1, 2, 3}, func(v int) int {
+		return v
+	})
+	fmt.Println(result)
+	// Output:
+	// 1
+}
+
+func ExampleFindMaximumInComparableSlice() {
+	result := collection.FindMaximumInComparableSlice([]int{1, 2, 3})
+	fmt.Println(result)
+	// Output:
+	// 3
+}
+
+func ExampleFindMaximumInSlice() {
+	result := collection.FindMaximumInSlice([]int{1, 2, 3}, func(v int) int {
+		return v
+	})
+	fmt.Println(result)
+	// Output:
+	// 3
+}
+
+func ExampleFindMin2MaxInComparableSlice() {
+	minimum, maximum := collection.FindMin2MaxInComparableSlice([]int{1, 2, 3})
+	fmt.Println(minimum, maximum)
+	// Output:
+	// 1 3
+}
+
+func ExampleFindMin2MaxInSlice() {
+	minimum, maximum := collection.FindMin2MaxInSlice([]int{1, 2, 3}, func(v int) int {
+		return v
+	})
+	fmt.Println(minimum, maximum)
+	// Output:
+	// 1 3
+}
+
+func ExampleFindMinFromComparableMap() {
+	result := collection.FindMinFromComparableMap(map[int]int{1: 1, 2: 2, 3: 3})
+	fmt.Println(result)
+	// Output:
+	// 1
+}
+
+func ExampleFindMinFromMap() {
+	result := collection.FindMinFromMap(map[int]int{1: 1, 2: 2, 3: 3}, func(v int) int {
+		return v
+	})
+	fmt.Println(result)
+	// Output:
+	// 1
+}
+
+func ExampleFindMaxFromComparableMap() {
+	result := collection.FindMaxFromComparableMap(map[int]int{1: 1, 2: 2, 3: 3})
+	fmt.Println(result)
+	// Output:
+	// 3
+}
+
+func ExampleFindMaxFromMap() {
+	result := collection.FindMaxFromMap(map[int]int{1: 1, 2: 2, 3: 3}, func(v int) int {
+		return v
+	})
+	fmt.Println(result)
+	// Output:
+	// 3
+}
+
+func ExampleFindMin2MaxFromComparableMap() {
+	minimum, maximum := collection.FindMin2MaxFromComparableMap(map[int]int{1: 1, 2: 2, 3: 3})
+	fmt.Println(minimum, maximum)
+	// Output:
+	// 1 3
+}
+
+func ExampleFindMin2MaxFromMap() {
+	minimum, maximum := collection.FindMin2MaxFromMap(map[int]int{1: 1, 2: 2, 3: 3})
+	fmt.Println(minimum, maximum)
+	// Output:
+	// 1 3
+}

utils/collection/find_test.go

@@ -127,3 +127,341 @@ func TestFindOrDefaultInComparableSlice(t *testing.T) {
 		})
 	}
 }
+
+func TestFindInSlice(t *testing.T) {
+	var cases = []struct {
+		name     string
+		input    []int
+		expected int
+	}{
+		{"TestFindInSlice_NonEmptySlice", []int{1, 2, 3}, 2},
+		{"TestFindInSlice_EmptySlice", []int{}, 0},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			_, actual := collection.FindInSlice(c.input, func(v int) bool {
+				return v == 2
+			})
+			if actual != c.expected {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expected, actual, "the element of input is not equal")
+			}
+		})
+	}
+}
+
+func TestFindIndexInSlice(t *testing.T) {
+	var cases = []struct {
+		name     string
+		input    []int
+		expected int
+	}{
+		{"TestFindIndexInSlice_NonEmptySlice", []int{1, 2, 3}, 1},
+		{"TestFindIndexInSlice_EmptySlice", []int{}, -1},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			actual := collection.FindIndexInSlice(c.input, func(v int) bool {
+				return v == 2
+			})
+			if actual != c.expected {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expected, actual, "the index of input is not equal")
+			}
+		})
+	}
+}
+
+func TestFindInComparableSlice(t *testing.T) {
+	var cases = []struct {
+		name     string
+		input    []int
+		expected int
+	}{
+		{"TestFindInComparableSlice_NonEmptySlice", []int{1, 2, 3}, 2},
+		{"TestFindInComparableSlice_EmptySlice", []int{}, 0},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			_, actual := collection.FindInComparableSlice(c.input, 2)
+			if actual != c.expected {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expected, actual, "the element of input is not equal")
+			}
+		})
+	}
+}
+
+func TestFindIndexInComparableSlice(t *testing.T) {
+	var cases = []struct {
+		name     string
+		input    []int
+		expected int
+	}{
+		{"TestFindIndexInComparableSlice_NonEmptySlice", []int{1, 2, 3}, 1},
+		{"TestFindIndexInComparableSlice_EmptySlice", []int{}, -1},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			actual := collection.FindIndexInComparableSlice(c.input, 2)
+			if actual != c.expected {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expected, actual, "the index of input is not equal")
+			}
+		})
+	}
+}
+
+func TestFindMinimumInComparableSlice(t *testing.T) {
+	var cases = []struct {
+		name     string
+		input    []int
+		expected int
+	}{
+		{"TestFindMinimumInComparableSlice_NonEmptySlice", []int{1, 2, 3}, 1},
+		{"TestFindMinimumInComparableSlice_EmptySlice", []int{}, 0},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			actual := collection.FindMinimumInComparableSlice(c.input)
+			if actual != c.expected {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expected, actual, "the minimum of input is not equal")
+			}
+		})
+	}
+}
+
+func TestFindMinimumInSlice(t *testing.T) {
+	var cases = []struct {
+		name     string
+		input    []int
+		expected int
+	}{
+		{"TestFindMinimumInSlice_NonEmptySlice", []int{1, 2, 3}, 1},
+		{"TestFindMinimumInSlice_EmptySlice", []int{}, 0},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			actual := collection.FindMinimumInSlice(c.input, func(v int) int {
+				return v
+			})
+			if actual != c.expected {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expected, actual, "the minimum of input is not equal")
+			}
+		})
+	}
+}
+
+func TestFindMaximumInComparableSlice(t *testing.T) {
+	var cases = []struct {
+		name     string
+		input    []int
+		expected int
+	}{
+		{"TestFindMaximumInComparableSlice_NonEmptySlice", []int{1, 2, 3}, 3},
+		{"TestFindMaximumInComparableSlice_EmptySlice", []int{}, 0},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			actual := collection.FindMaximumInComparableSlice(c.input)
+			if actual != c.expected {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expected, actual, "the maximum of input is not equal")
+			}
+		})
+	}
+}
+
+func TestFindMaximumInSlice(t *testing.T) {
+	var cases = []struct {
+		name     string
+		input    []int
+		expected int
+	}{
+		{"TestFindMaximumInSlice_NonEmptySlice", []int{1, 2, 3}, 3},
+		{"TestFindMaximumInSlice_EmptySlice", []int{}, 0},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			actual := collection.FindMaximumInSlice(c.input, func(v int) int {
+				return v
+			})
+			if actual != c.expected {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expected, actual, "the maximum of input is not equal")
+			}
+		})
+	}
+}
+
+func TestFindMin2MaxInComparableSlice(t *testing.T) {
+	var cases = []struct {
+		name        string
+		input       []int
+		expectedMin int
+		expectedMax int
+	}{
+		{"TestFindMin2MaxInComparableSlice_NonEmptySlice", []int{1, 2, 3}, 1, 3},
+		{"TestFindMin2MaxInComparableSlice_EmptySlice", []int{}, 0, 0},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			minimum, maximum := collection.FindMin2MaxInComparableSlice(c.input)
+			if minimum != c.expectedMin || maximum != c.expectedMax {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expectedMin, minimum, "the minimum of input is not equal")
+			}
+		})
+	}
+}
+
+func TestFindMin2MaxInSlice(t *testing.T) {
+	var cases = []struct {
+		name        string
+		input       []int
+		expectedMin int
+		expectedMax int
+	}{
+		{"TestFindMin2MaxInSlice_NonEmptySlice", []int{1, 2, 3}, 1, 3},
+		{"TestFindMin2MaxInSlice_EmptySlice", []int{}, 0, 0},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			minimum, maximum := collection.FindMin2MaxInSlice(c.input, func(v int) int {
+				return v
+			})
+			if minimum != c.expectedMin || maximum != c.expectedMax {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expectedMin, minimum, "the minimum of input is not equal")
+			}
+		})
+	}
+}
+
+func TestFindMinFromComparableMap(t *testing.T) {
+	var cases = []struct {
+		name     string
+		input    map[int]int
+		expected int
+	}{
+		{"TestFindMinFromComparableMap_NonEmptyMap", map[int]int{1: 1, 2: 2, 3: 3}, 1},
+		{"TestFindMinFromComparableMap_EmptyMap", map[int]int{}, 0},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			actual := collection.FindMinFromComparableMap(c.input)
+			if actual != c.expected {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expected, actual, "the minimum of input is not equal")
+			}
+		})
+	}
+}
+
+func TestFindMinFromMap(t *testing.T) {
+	var cases = []struct {
+		name     string
+		input    map[int]int
+		expected int
+	}{
+		{"TestFindMinFromMap_NonEmptyMap", map[int]int{1: 1, 2: 2, 3: 3}, 1},
+		{"TestFindMinFromMap_EmptyMap", map[int]int{}, 0},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			actual := collection.FindMinFromMap(c.input, func(v int) int {
+				return v
+			})
+			if actual != c.expected {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expected, actual, "the minimum of input is not equal")
+			}
+		})
+	}
+}
+
+func TestFindMaxFromComparableMap(t *testing.T) {
+	var cases = []struct {
+		name     string
+		input    map[int]int
+		expected int
+	}{
+		{"TestFindMaxFromComparableMap_NonEmptyMap", map[int]int{1: 1, 2: 2, 3: 3}, 3},
+		{"TestFindMaxFromComparableMap_EmptyMap", map[int]int{}, 0},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			actual := collection.FindMaxFromComparableMap(c.input)
+			if actual != c.expected {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expected, actual, "the maximum of input is not equal")
+			}
+		})
+	}
+}
+
+func TestFindMaxFromMap(t *testing.T) {
+	var cases = []struct {
+		name     string
+		input    map[int]int
+		expected int
+	}{
+		{"TestFindMaxFromMap_NonEmptyMap", map[int]int{1: 1, 2: 2, 3: 3}, 3},
+		{"TestFindMaxFromMap_EmptyMap", map[int]int{}, 0},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			actual := collection.FindMaxFromMap(c.input, func(v int) int {
+				return v
+			})
+			if actual != c.expected {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expected, actual, "the maximum of input is not equal")
+			}
+		})
+	}
+}
+
+func TestFindMin2MaxFromComparableMap(t *testing.T) {
+	var cases = []struct {
+		name        string
+		input       map[int]int
+		expectedMin int
+		expectedMax int
+	}{
+		{"TestFindMin2MaxFromComparableMap_NonEmptyMap", map[int]int{1: 1, 2: 2, 3: 3}, 1, 3},
+		{"TestFindMin2MaxFromComparableMap_EmptyMap", map[int]int{}, 0, 0},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			minimum, maximum := collection.FindMin2MaxFromComparableMap(c.input)
+			if minimum != c.expectedMin || maximum != c.expectedMax {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expectedMin, minimum, "the minimum of input is not equal")
+			}
+		})
+	}
+}
+
+func TestFindMin2MaxFromMap(t *testing.T) {
+	var cases = []struct {
+		name        string
+		input       map[int]int
+		expectedMin int
+		expectedMax int
+	}{
+		{"TestFindMin2MaxFromMap_NonEmptyMap", map[int]int{1: 1, 2: 2, 3: 3}, 1, 3},
+		{"TestFindMin2MaxFromMap_EmptyMap", map[int]int{}, 0, 0},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			minimum, maximum := collection.FindMin2MaxFromMap(c.input)
+			if minimum != c.expectedMin || maximum != c.expectedMax {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expectedMin, minimum, "the minimum of input is not equal")
+			}
+		})
+	}
+}

utils/collection/item.go

@@ -2,5 +2,8 @@ package collection
 
 // SwapSlice 将切片中的两个元素进行交换
 func SwapSlice[S ~[]V, V any](slice *S, i, j int) {
+	if i < 0 || j < 0 || i >= len(*slice) || j >= len(*slice) {
+		return
+	}
 	(*slice)[i], (*slice)[j] = (*slice)[j], (*slice)[i]
 }

utils/collection/item_example_test.go

@@ -0,0 +1,14 @@
+package collection_test
+
+import (
+	"fmt"
+	"github.com/kercylan98/minotaur/utils/collection"
+)
+
+func ExampleSwapSlice() {
+	var s = []int{1, 2, 3}
+	collection.SwapSlice(&s, 0, 1)
+	fmt.Println(s)
+	// Output:
+	// [2 1 3]
+}

utils/collection/item_test.go

@@ -0,0 +1,32 @@
+package collection_test
+
+import (
+	"github.com/kercylan98/minotaur/utils/collection"
+	"testing"
+)
+
+func TestSwapSlice(t *testing.T) {
+	var cases = []struct {
+		name   string
+		slice  []int
+		i      int
+		j      int
+		expect []int
+	}{
+		{"TestSwapSliceNonEmpty", []int{1, 2, 3}, 0, 1, []int{2, 1, 3}},
+		{"TestSwapSliceEmpty", []int{}, 0, 0, []int{}},
+		{"TestSwapSliceIndexOutOfBound", []int{1, 2, 3}, 0, 3, []int{1, 2, 3}},
+		{"TestSwapSliceNil", nil, 0, 0, nil},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			collection.SwapSlice(&c.slice, c.i, c.j)
+			for i, v := range c.slice {
+				if v != c.expect[i] {
+					t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expect, c.slice, "the slice is not equal")
+				}
+			}
+		})
+	}
+}

utils/collection/map_example_test.go

@@ -0,0 +1,21 @@
+package collection
+
+import "fmt"
+
+func ExampleMappingFromSlice() {
+	result := MappingFromSlice[[]int, []int]([]int{1, 2, 3}, func(value int) int {
+		return value + 1
+	})
+	fmt.Println(result)
+	// Output:
+	// [2 3 4]
+}
+
+func ExampleMappingFromMap() {
+	result := MappingFromMap[map[int]int, map[int]int](map[int]int{1: 1, 2: 2, 3: 3}, func(value int) int {
+		return value + 1
+	})
+	fmt.Println(result)
+	// Output:
+	// map[1:2 2:3 3:4]
+}

utils/collection/map_test.go

@@ -0,0 +1,60 @@
+package collection_test
+
+import (
+	"github.com/kercylan98/minotaur/utils/collection"
+	"testing"
+)
+
+func TestMappingFromSlice(t *testing.T) {
+	var cases = []struct {
+		name     string
+		input    []int
+		expected []int
+	}{
+		{"TestMappingFromSlice_NonEmptySlice", []int{1, 2, 3}, []int{2, 3, 4}},
+		{"TestMappingFromSlice_EmptySlice", []int{}, []int{}},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			result := collection.MappingFromSlice[[]int, []int](c.input, func(value int) int {
+				return value + 1
+			})
+			if len(result) != len(c.expected) {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expected, result, "the length of input is not equal")
+			}
+			for i := 0; i < len(result); i++ {
+				if result[i] != c.expected[i] {
+					t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expected, result, "the value of input is not equal")
+				}
+			}
+		})
+	}
+}
+
+func TestMappingFromMap(t *testing.T) {
+	var cases = []struct {
+		name     string
+		input    map[int]int
+		expected map[int]int
+	}{
+		{"TestMappingFromMap_NonEmptyMap", map[int]int{1: 1, 2: 2, 3: 3}, map[int]int{1: 2, 2: 3, 3: 4}},
+		{"TestMappingFromMap_EmptyMap", map[int]int{}, map[int]int{}},
+	}
+
+	for _, c := range cases {
+		t.Run(c.name, func(t *testing.T) {
+			result := collection.MappingFromMap[map[int]int, map[int]int](c.input, func(value int) int {
+				return value + 1
+			})
+			if len(result) != len(c.expected) {
+				t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expected, result, "the length of input is not equal")
+			}
+			for k, v := range result {
+				if v != c.expected[k] {
+					t.Fatalf("%s failed, expected: %v, actual: %v, error: %s", c.name, c.expected, result, "the value of input is not equal")
+				}
+			}
+		})
+	}
+}

utils/deck/deck.go

@@ -20,7 +20,7 @@ type Deck[I Item] struct {
 
 // AddGroup 将一个组添加到甲板中
 func (slf *Deck[I]) AddGroup(group *Group[I]) {
-	if !collection.FindInMapKey(slf.groups, group.GetGuid()) {
+	if !collection.KeyInMap(slf.groups, group.GetGuid()) {
 		slf.groups[group.GetGuid()] = group
 		slf.sort = append(slf.sort, group.GetGuid())
 	}

utils/fsm/fsm.go

@@ -60,7 +60,7 @@ func (slf *FSM[State, Data]) Unregister(state State) {
 
 // HasState 检查状态机是否存在特定状态
 func (slf *FSM[State, Data]) HasState(state State) bool {
-	return collection.FindInMapKey(slf.states, state)
+	return collection.KeyInMap(slf.states, state)
 }
 
 // Change 改变状态机状态到新的状态