Merge branch 'master' into master

.github/workflows/go.yml

@@ -17,7 +17,7 @@ jobs:
       - name: Set up Go 1.x
         uses: actions/setup-go@v3
         with:
-          go-version: ^1.16
+          go-version: ^1.18
           check-latest: true
           cache: true
         id: go
@@ -48,8 +48,8 @@ jobs:
       - name: Set up Go 1.x
         uses: actions/setup-go@v3
         with:
-          # use 1.16 to guarantee Go 1.16 compatibility
-          go-version: 1.16
+          # use 1.18 to guarantee Go 1.18 compatibility
+          go-version: 1.18
           check-latest: true
           cache: true
 

core/codec/aesecb.go

@@ -32,9 +32,11 @@ func NewECBEncrypter(b cipher.Block) cipher.BlockMode {
 	return (*ecbEncrypter)(newECB(b))
 }
 
+// BlockSize returns the mode's block size.
 func (x *ecbEncrypter) BlockSize() int { return x.blockSize }
 
-// why we don't return error is because cipher.BlockMode doesn't allow this
+// CryptBlocks encrypts a number of blocks. The length of src must be a multiple of
+// the block size. Dst and src must overlap entirely or not at all.
 func (x *ecbEncrypter) CryptBlocks(dst, src []byte) {
 	if len(src)%x.blockSize != 0 {
 		logx.Error("crypto/cipher: input not full blocks")
@@ -59,11 +61,13 @@ func NewECBDecrypter(b cipher.Block) cipher.BlockMode {
 	return (*ecbDecrypter)(newECB(b))
 }
 
+// BlockSize returns the mode's block size.
 func (x *ecbDecrypter) BlockSize() int {
 	return x.blockSize
 }
 
-// why we don't return error is because cipher.BlockMode doesn't allow this
+// CryptBlocks decrypts a number of blocks. The length of src must be a multiple of
+// the block size. Dst and src must overlap entirely or not at all.
 func (x *ecbDecrypter) CryptBlocks(dst, src []byte) {
 	if len(src)%x.blockSize != 0 {
 		logx.Error("crypto/cipher: input not full blocks")

core/codec/aesecb_test.go

@@ -1,6 +1,7 @@
 package codec
 
 import (
+	"crypto/aes"
 	"encoding/base64"
 	"testing"
 
@@ -10,7 +11,8 @@ import (
 func TestAesEcb(t *testing.T) {
 	var (
 		key     = []byte("q4t7w!z%C*F-JaNdRgUjXn2r5u8x/A?D")
-		val     = []byte("hello")
+		val     = []byte("helloworld")
+		valLong = []byte("helloworldlong..")
 		badKey1 = []byte("aaaaaaaaa")
 		// more than 32 chars
 		badKey2 = []byte("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
@@ -31,6 +33,39 @@ func TestAesEcb(t *testing.T) {
 	src, err := EcbDecrypt(key, dst)
 	assert.Nil(t, err)
 	assert.Equal(t, val, src)
+	block, err := aes.NewCipher(key)
+	assert.NoError(t, err)
+	encrypter := NewECBEncrypter(block)
+	assert.Equal(t, 16, encrypter.BlockSize())
+	decrypter := NewECBDecrypter(block)
+	assert.Equal(t, 16, decrypter.BlockSize())
+
+	dst = make([]byte, 8)
+	encrypter.CryptBlocks(dst, val)
+	for _, b := range dst {
+		assert.Equal(t, byte(0), b)
+	}
+
+	dst = make([]byte, 8)
+	encrypter.CryptBlocks(dst, valLong)
+	for _, b := range dst {
+		assert.Equal(t, byte(0), b)
+	}
+
+	dst = make([]byte, 8)
+	decrypter.CryptBlocks(dst, val)
+	for _, b := range dst {
+		assert.Equal(t, byte(0), b)
+	}
+
+	dst = make([]byte, 8)
+	decrypter.CryptBlocks(dst, valLong)
+	for _, b := range dst {
+		assert.Equal(t, byte(0), b)
+	}
+
+	_, err = EcbEncryptBase64("cTR0N3dDKkYtSmFOZFJnVWpYbjJyNXU4eC9BP0QK", "aGVsbG93b3JsZGxvbmcuLgo=")
+	assert.Error(t, err)
 }
 
 func TestAesEcbBase64(t *testing.T) {

core/codec/dh_test.go

@@ -80,3 +80,17 @@ func TestKeyBytes(t *testing.T) {
 	assert.Nil(t, err)
 	assert.True(t, len(key.Bytes()) > 0)
 }
+
+func TestDHOnErrors(t *testing.T) {
+	key, err := GenerateKey()
+	assert.Nil(t, err)
+	assert.NotEmpty(t, key.Bytes())
+	_, err = ComputeKey(key.PubKey, key.PriKey)
+	assert.NoError(t, err)
+	_, err = ComputeKey(nil, key.PriKey)
+	assert.Error(t, err)
+	_, err = ComputeKey(key.PubKey, nil)
+	assert.Error(t, err)
+
+	assert.NotNil(t, NewPublicKey([]byte("")))
+}

core/collection/cache.go

@@ -30,7 +30,7 @@ type (
 	Cache struct {
 		name           string
 		lock           sync.Mutex
-		data           map[string]interface{}
+		data           map[string]any
 		expire         time.Duration
 		timingWheel    *TimingWheel
 		lruCache       lru
@@ -43,7 +43,7 @@ type (
 // NewCache returns a Cache with given expire.
 func NewCache(expire time.Duration, opts ...CacheOption) (*Cache, error) {
 	cache := &Cache{
-		data:           make(map[string]interface{}),
+		data:           make(map[string]any),
 		expire:         expire,
 		lruCache:       emptyLruCache,
 		barrier:        syncx.NewSingleFlight(),
@@ -59,7 +59,7 @@ func NewCache(expire time.Duration, opts ...CacheOption) (*Cache, error) {
 	}
 	cache.stats = newCacheStat(cache.name, cache.size)
 
-	timingWheel, err := NewTimingWheel(time.Second, slots, func(k, v interface{}) {
+	timingWheel, err := NewTimingWheel(time.Second, slots, func(k, v any) {
 		key, ok := k.(string)
 		if !ok {
 			return
@@ -85,7 +85,7 @@ func (c *Cache) Del(key string) {
 }
 
 // Get returns the item with the given key from c.
-func (c *Cache) Get(key string) (interface{}, bool) {
+func (c *Cache) Get(key string) (any, bool) {
 	value, ok := c.doGet(key)
 	if ok {
 		c.stats.IncrementHit()
@@ -97,12 +97,12 @@ func (c *Cache) Get(key string) (interface{}, bool) {
 }
 
 // Set sets value into c with key.
-func (c *Cache) Set(key string, value interface{}) {
+func (c *Cache) Set(key string, value any) {
 	c.SetWithExpire(key, value, c.expire)
 }
 
 // SetWithExpire sets value into c with key and expire with the given value.
-func (c *Cache) SetWithExpire(key string, value interface{}, expire time.Duration) {
+func (c *Cache) SetWithExpire(key string, value any, expire time.Duration) {
 	c.lock.Lock()
 	_, ok := c.data[key]
 	c.data[key] = value
@@ -120,14 +120,14 @@ func (c *Cache) SetWithExpire(key string, value interface{}, expire time.Duratio
 // Take returns the item with the given key.
 // If the item is in c, return it directly.
 // If not, use fetch method to get the item, set into c and return it.
-func (c *Cache) Take(key string, fetch func() (interface{}, error)) (interface{}, error) {
+func (c *Cache) Take(key string, fetch func() (any, error)) (any, error) {
 	if val, ok := c.doGet(key); ok {
 		c.stats.IncrementHit()
 		return val, nil
 	}
 
 	var fresh bool
-	val, err := c.barrier.Do(key, func() (interface{}, error) {
+	val, err := c.barrier.Do(key, func() (any, error) {
 		// because O(1) on map search in memory, and fetch is an IO query
 		// so we do double check, cache might be taken by another call
 		if val, ok := c.doGet(key); ok {
@@ -157,7 +157,7 @@ func (c *Cache) Take(key string, fetch func() (interface{}, error)) (interface{}
 	return val, nil
 }
 
-func (c *Cache) doGet(key string) (interface{}, bool) {
+func (c *Cache) doGet(key string) (any, bool) {
 	c.lock.Lock()
 	defer c.lock.Unlock()
 

core/collection/cache_test.go

@@ -52,7 +52,7 @@ func TestCacheTake(t *testing.T) {
 	for i := 0; i < 100; i++ {
 		wg.Add(1)
 		go func() {
-			cache.Take("first", func() (interface{}, error) {
+			cache.Take("first", func() (any, error) {
 				atomic.AddInt32(&count, 1)
 				time.Sleep(time.Millisecond * 100)
 				return "first element", nil
@@ -76,7 +76,7 @@ func TestCacheTakeExists(t *testing.T) {
 		wg.Add(1)
 		go func() {
 			cache.Set("first", "first element")
-			cache.Take("first", func() (interface{}, error) {
+			cache.Take("first", func() (any, error) {
 				atomic.AddInt32(&count, 1)
 				time.Sleep(time.Millisecond * 100)
 				return "first element", nil
@@ -99,7 +99,7 @@ func TestCacheTakeError(t *testing.T) {
 	for i := 0; i < 100; i++ {
 		wg.Add(1)
 		go func() {
-			_, err := cache.Take("first", func() (interface{}, error) {
+			_, err := cache.Take("first", func() (any, error) {
 				atomic.AddInt32(&count, 1)
 				time.Sleep(time.Millisecond * 100)
 				return "", errDummy

core/collection/fifo.go

@@ -5,7 +5,7 @@ import "sync"
 // A Queue is a FIFO queue.
 type Queue struct {
 	lock     sync.Mutex
-	elements []interface{}
+	elements []any
 	size     int
 	head     int
 	tail     int
@@ -15,7 +15,7 @@ type Queue struct {
 // NewQueue returns a Queue object.
 func NewQueue(size int) *Queue {
 	return &Queue{
-		elements: make([]interface{}, size),
+		elements: make([]any, size),
 		size:     size,
 	}
 }
@@ -30,12 +30,12 @@ func (q *Queue) Empty() bool {
 }
 
 // Put puts element into q at the last position.
-func (q *Queue) Put(element interface{}) {
+func (q *Queue) Put(element any) {
 	q.lock.Lock()
 	defer q.lock.Unlock()
 
 	if q.head == q.tail && q.count > 0 {
-		nodes := make([]interface{}, len(q.elements)+q.size)
+		nodes := make([]any, len(q.elements)+q.size)
 		copy(nodes, q.elements[q.head:])
 		copy(nodes[len(q.elements)-q.head:], q.elements[:q.head])
 		q.head = 0
@@ -49,7 +49,7 @@ func (q *Queue) Put(element interface{}) {
 }
 
 // Take takes the first element out of q if not empty.
-func (q *Queue) Take() (interface{}, bool) {
+func (q *Queue) Take() (any, bool) {
 	q.lock.Lock()
 	defer q.lock.Unlock()
 

core/collection/ring.go

@@ -4,7 +4,7 @@ import "sync"
 
 // A Ring can be used as fixed size ring.
 type Ring struct {
-	elements []interface{}
+	elements []any
 	index    int
 	lock     sync.RWMutex
 }
@@ -16,12 +16,12 @@ func NewRing(n int) *Ring {
 	}
 
 	return &Ring{
-		elements: make([]interface{}, n),
+		elements: make([]any, n),
 	}
 }
 
 // Add adds v into r.
-func (r *Ring) Add(v interface{}) {
+func (r *Ring) Add(v any) {
 	r.lock.Lock()
 	defer r.lock.Unlock()
 
@@ -30,7 +30,7 @@ func (r *Ring) Add(v interface{}) {
 }
 
 // Take takes all items from r.
-func (r *Ring) Take() []interface{} {
+func (r *Ring) Take() []any {
 	r.lock.RLock()
 	defer r.lock.RUnlock()
 
@@ -43,7 +43,7 @@ func (r *Ring) Take() []interface{} {
 		size = r.index
 	}
 
-	elements := make([]interface{}, size)
+	elements := make([]any, size)
 	for i := 0; i < size; i++ {
 		elements[i] = r.elements[(start+i)%len(r.elements)]
 	}

core/collection/ring_test.go

@@ -19,7 +19,7 @@ func TestRingLess(t *testing.T) {
 		ring.Add(i)
 	}
 	elements := ring.Take()
-	assert.ElementsMatch(t, []interface{}{0, 1, 2}, elements)
+	assert.ElementsMatch(t, []any{0, 1, 2}, elements)
 }
 
 func TestRingMore(t *testing.T) {
@@ -28,7 +28,7 @@ func TestRingMore(t *testing.T) {
 		ring.Add(i)
 	}
 	elements := ring.Take()
-	assert.ElementsMatch(t, []interface{}{6, 7, 8, 9, 10}, elements)
+	assert.ElementsMatch(t, []any{6, 7, 8, 9, 10}, elements)
 }
 
 func TestRingAdd(t *testing.T) {

core/collection/safemap.go

@@ -14,20 +14,20 @@ type SafeMap struct {
 	lock        sync.RWMutex
 	deletionOld int
 	deletionNew int
-	dirtyOld    map[interface{}]interface{}
-	dirtyNew    map[interface{}]interface{}
+	dirtyOld    map[any]any
+	dirtyNew    map[any]any
 }
 
 // NewSafeMap returns a SafeMap.
 func NewSafeMap() *SafeMap {
 	return &SafeMap{
-		dirtyOld: make(map[interface{}]interface{}),
-		dirtyNew: make(map[interface{}]interface{}),
+		dirtyOld: make(map[any]any),
+		dirtyNew: make(map[any]any),
 	}
 }
 
 // Del deletes the value with the given key from m.
-func (m *SafeMap) Del(key interface{}) {
+func (m *SafeMap) Del(key any) {
 	m.lock.Lock()
 	if _, ok := m.dirtyOld[key]; ok {
 		delete(m.dirtyOld, key)
@@ -42,21 +42,21 @@ func (m *SafeMap) Del(key interface{}) {
 		}
 		m.dirtyOld = m.dirtyNew
 		m.deletionOld = m.deletionNew
-		m.dirtyNew = make(map[interface{}]interface{})
+		m.dirtyNew = make(map[any]any)
 		m.deletionNew = 0
 	}
 	if m.deletionNew >= maxDeletion && len(m.dirtyNew) < copyThreshold {
 		for k, v := range m.dirtyNew {
 			m.dirtyOld[k] = v
 		}
-		m.dirtyNew = make(map[interface{}]interface{})
+		m.dirtyNew = make(map[any]any)
 		m.deletionNew = 0
 	}
 	m.lock.Unlock()
 }
 
 // Get gets the value with the given key from m.
-func (m *SafeMap) Get(key interface{}) (interface{}, bool) {
+func (m *SafeMap) Get(key any) (any, bool) {
 	m.lock.RLock()
 	defer m.lock.RUnlock()
 
@@ -70,7 +70,7 @@ func (m *SafeMap) Get(key interface{}) (interface{}, bool) {
 
 // Range calls f sequentially for each key and value present in the map.
 // If f returns false, range stops the iteration.
-func (m *SafeMap) Range(f func(key, val interface{}) bool) {
+func (m *SafeMap) Range(f func(key, val any) bool) {
 	m.lock.RLock()
 	defer m.lock.RUnlock()
 
@@ -87,7 +87,7 @@ func (m *SafeMap) Range(f func(key, val interface{}) bool) {
 }
 
 // Set sets the value into m with the given key.
-func (m *SafeMap) Set(key, value interface{}) {
+func (m *SafeMap) Set(key, value any) {
 	m.lock.Lock()
 	if m.deletionOld <= maxDeletion {
 		if _, ok := m.dirtyNew[key]; ok {

core/collection/safemap_test.go

@@ -138,7 +138,7 @@ func TestSafeMap_Range(t *testing.T) {
 	}
 
 	var count int32
-	m.Range(func(k, v interface{}) bool {
+	m.Range(func(k, v any) bool {
 		atomic.AddInt32(&count, 1)
 		newMap.Set(k, v)
 		return true

core/collection/set.go

@@ -17,14 +17,14 @@ const (
 
 // Set is not thread-safe, for concurrent use, make sure to use it with synchronization.
 type Set struct {
-	data map[interface{}]lang.PlaceholderType
+	data map[any]lang.PlaceholderType
 	tp   int
 }
 
 // NewSet returns a managed Set, can only put the values with the same type.
 func NewSet() *Set {
 	return &Set{
-		data: make(map[interface{}]lang.PlaceholderType),
+		data: make(map[any]lang.PlaceholderType),
 		tp:   untyped,
 	}
 }
@@ -32,13 +32,13 @@ func NewSet() *Set {
 // NewUnmanagedSet returns an unmanaged Set, which can put values with different types.
 func NewUnmanagedSet() *Set {
 	return &Set{
-		data: make(map[interface{}]lang.PlaceholderType),
+		data: make(map[any]lang.PlaceholderType),
 		tp:   unmanaged,
 	}
 }
 
 // Add adds i into s.
-func (s *Set) Add(i ...interface{}) {
+func (s *Set) Add(i ...any) {
 	for _, each := range i {
 		s.add(each)
 	}
@@ -80,7 +80,7 @@ func (s *Set) AddStr(ss ...string) {
 }
 
 // Contains checks if i is in s.
-func (s *Set) Contains(i interface{}) bool {
+func (s *Set) Contains(i any) bool {
 	if len(s.data) == 0 {
 		return false
 	}
@@ -91,8 +91,8 @@ func (s *Set) Contains(i interface{}) bool {
 }
 
 // Keys returns the keys in s.
-func (s *Set) Keys() []interface{} {
-	var keys []interface{}
+func (s *Set) Keys() []any {
+	var keys []any
 
 	for key := range s.data {
 		keys = append(keys, key)
@@ -167,7 +167,7 @@ func (s *Set) KeysStr() []string {
 }
 
 // Remove removes i from s.
-func (s *Set) Remove(i interface{}) {
+func (s *Set) Remove(i any) {
 	s.validate(i)
 	delete(s.data, i)
 }
@@ -177,7 +177,7 @@ func (s *Set) Count() int {
 	return len(s.data)
 }
 
-func (s *Set) add(i interface{}) {
+func (s *Set) add(i any) {
 	switch s.tp {
 	case unmanaged:
 		// do nothing
@@ -189,7 +189,7 @@ func (s *Set) add(i interface{}) {
 	s.data[i] = lang.Placeholder
 }
 
-func (s *Set) setType(i interface{}) {
+func (s *Set) setType(i any) {
 	// s.tp can only be untyped here
 	switch i.(type) {
 	case int:
@@ -205,7 +205,7 @@ func (s *Set) setType(i interface{}) {
 	}
 }
 
-func (s *Set) validate(i interface{}) {
+func (s *Set) validate(i any) {
 	if s.tp == unmanaged {
 		return
 	}

core/collection/set_test.go

@@ -13,7 +13,7 @@ func init() {
 }
 
 func BenchmarkRawSet(b *testing.B) {
-	m := make(map[interface{}]struct{})
+	m := make(map[any]struct{})
 	for i := 0; i < b.N; i++ {
 		m[i] = struct{}{}
 		_ = m[i]
@@ -39,7 +39,7 @@ func BenchmarkSet(b *testing.B) {
 func TestAdd(t *testing.T) {
 	// given
 	set := NewUnmanagedSet()
-	values := []interface{}{1, 2, 3}
+	values := []any{1, 2, 3}
 
 	// when
 	set.Add(values...)
@@ -135,7 +135,7 @@ func TestContainsUnmanagedWithoutElements(t *testing.T) {
 func TestRemove(t *testing.T) {
 	// given
 	set := NewSet()
-	set.Add([]interface{}{1, 2, 3}...)
+	set.Add([]any{1, 2, 3}...)
 
 	// when
 	set.Remove(2)
@@ -147,7 +147,7 @@ func TestRemove(t *testing.T) {
 func TestCount(t *testing.T) {
 	// given
 	set := NewSet()
-	set.Add([]interface{}{1, 2, 3}...)
+	set.Add([]any{1, 2, 3}...)
 
 	// then
 	assert.Equal(t, set.Count(), 3)
@@ -198,5 +198,5 @@ func TestSetType(t *testing.T) {
 	set.add(1)
 	set.add("2")
 	vals := set.Keys()
-	assert.ElementsMatch(t, []interface{}{1, "2"}, vals)
+	assert.ElementsMatch(t, []any{1, "2"}, vals)
 }

core/collection/timingwheel.go

@@ -20,7 +20,7 @@ var (
 
 type (
 	// Execute defines the method to execute the task.
-	Execute func(key, value interface{})
+	Execute func(key, value any)
 
 	// A TimingWheel is a timing wheel object to schedule tasks.
 	TimingWheel struct {
@@ -33,14 +33,14 @@ type (
 		execute       Execute
 		setChannel    chan timingEntry
 		moveChannel   chan baseEntry
-		removeChannel chan interface{}
-		drainChannel  chan func(key, value interface{})
+		removeChannel chan any
+		drainChannel  chan func(key, value any)
 		stopChannel   chan lang.PlaceholderType
 	}
 
 	timingEntry struct {
 		baseEntry
-		value   interface{}
+		value   any
 		circle  int
 		diff    int
 		removed bool
@@ -48,7 +48,7 @@ type (
 
 	baseEntry struct {
 		delay time.Duration
-		key   interface{}
+		key   any
 	}
 
 	positionEntry struct {
@@ -57,8 +57,8 @@ type (
 	}
 
 	timingTask struct {
-		key   interface{}
-		value interface{}
+		key   any
+		value any
 	}
 )
 
@@ -85,8 +85,8 @@ func NewTimingWheelWithTicker(interval time.Duration, numSlots int, execute Exec
 		numSlots:      numSlots,
 		setChannel:    make(chan timingEntry),
 		moveChannel:   make(chan baseEntry),
-		removeChannel: make(chan interface{}),
-		drainChannel:  make(chan func(key, value interface{})),
+		removeChannel: make(chan any),
+		drainChannel:  make(chan func(key, value any)),
 		stopChannel:   make(chan lang.PlaceholderType),
 	}
 
@@ -97,7 +97,7 @@ func NewTimingWheelWithTicker(interval time.Duration, numSlots int, execute Exec
 }
 
 // Drain drains all items and executes them.
-func (tw *TimingWheel) Drain(fn func(key, value interface{})) error {
+func (tw *TimingWheel) Drain(fn func(key, value any)) error {
 	select {
 	case tw.drainChannel <- fn:
 		return nil
@@ -107,7 +107,7 @@ func (tw *TimingWheel) Drain(fn func(key, value interface{})) error {
 }
 
 // MoveTimer moves the task with the given key to the given delay.
-func (tw *TimingWheel) MoveTimer(key interface{}, delay time.Duration) error {
+func (tw *TimingWheel) MoveTimer(key any, delay time.Duration) error {
 	if delay <= 0 || key == nil {
 		return ErrArgument
 	}
@@ -124,7 +124,7 @@ func (tw *TimingWheel) MoveTimer(key interface{}, delay time.Duration) error {
 }
 
 // RemoveTimer removes the task with the given key.
-func (tw *TimingWheel) RemoveTimer(key interface{}) error {
+func (tw *TimingWheel) RemoveTimer(key any) error {
 	if key == nil {
 		return ErrArgument
 	}
@@ -138,7 +138,7 @@ func (tw *TimingWheel) RemoveTimer(key interface{}) error {
 }
 
 // SetTimer sets the task value with the given key to the delay.
-func (tw *TimingWheel) SetTimer(key, value interface{}, delay time.Duration) error {
+func (tw *TimingWheel) SetTimer(key, value any, delay time.Duration) error {
 	if delay <= 0 || key == nil {
 		return ErrArgument
 	}
@@ -162,7 +162,7 @@ func (tw *TimingWheel) Stop() {
 	close(tw.stopChannel)
 }
 
-func (tw *TimingWheel) drainAll(fn func(key, value interface{})) {
+func (tw *TimingWheel) drainAll(fn func(key, value any)) {
 	runner := threading.NewTaskRunner(drainWorkers)
 	for _, slot := range tw.slots {
 		for e := slot.Front(); e != nil; {
@@ -232,7 +232,7 @@ func (tw *TimingWheel) onTick() {
 	tw.scanAndRunTasks(l)
 }
 
-func (tw *TimingWheel) removeTask(key interface{}) {
+func (tw *TimingWheel) removeTask(key any) {
 	val, ok := tw.timers.Get(key)
 	if !ok {
 		return

core/collection/timingwheel_test.go

@@ -20,13 +20,13 @@ const (
 )
 
 func TestNewTimingWheel(t *testing.T) {
-	_, err := NewTimingWheel(0, 10, func(key, value interface{}) {})
+	_, err := NewTimingWheel(0, 10, func(key, value any) {})
 	assert.NotNil(t, err)
 }
 
 func TestTimingWheel_Drain(t *testing.T) {
 	ticker := timex.NewFakeTicker()
-	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v interface{}) {
+	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v any) {
 	}, ticker)
 	tw.SetTimer("first", 3, testStep*4)
 	tw.SetTimer("second", 5, testStep*7)
@@ -36,7 +36,7 @@ func TestTimingWheel_Drain(t *testing.T) {
 	var lock sync.Mutex
 	var wg sync.WaitGroup
 	wg.Add(3)
-	tw.Drain(func(key, value interface{}) {
+	tw.Drain(func(key, value any) {
 		lock.Lock()
 		defer lock.Unlock()
 		keys = append(keys, key.(string))
@@ -50,19 +50,19 @@ func TestTimingWheel_Drain(t *testing.T) {
 	assert.EqualValues(t, []string{"first", "second", "third"}, keys)
 	assert.EqualValues(t, []int{3, 5, 7}, vals)
 	var count int
-	tw.Drain(func(key, value interface{}) {
+	tw.Drain(func(key, value any) {
 		count++
 	})
 	time.Sleep(time.Millisecond * 100)
 	assert.Equal(t, 0, count)
 	tw.Stop()
-	assert.Equal(t, ErrClosed, tw.Drain(func(key, value interface{}) {}))
+	assert.Equal(t, ErrClosed, tw.Drain(func(key, value any) {}))
 }
 
 func TestTimingWheel_SetTimerSoon(t *testing.T) {
 	run := syncx.NewAtomicBool()
 	ticker := timex.NewFakeTicker()
-	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v interface{}) {
+	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v any) {
 		assert.True(t, run.CompareAndSwap(false, true))
 		assert.Equal(t, "any", k)
 		assert.Equal(t, 3, v.(int))
@@ -78,7 +78,7 @@ func TestTimingWheel_SetTimerSoon(t *testing.T) {
 func TestTimingWheel_SetTimerTwice(t *testing.T) {
 	run := syncx.NewAtomicBool()
 	ticker := timex.NewFakeTicker()
-	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v interface{}) {
+	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v any) {
 		assert.True(t, run.CompareAndSwap(false, true))
 		assert.Equal(t, "any", k)
 		assert.Equal(t, 5, v.(int))
@@ -96,7 +96,7 @@ func TestTimingWheel_SetTimerTwice(t *testing.T) {
 
 func TestTimingWheel_SetTimerWrongDelay(t *testing.T) {
 	ticker := timex.NewFakeTicker()
-	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v interface{}) {}, ticker)
+	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v any) {}, ticker)
 	defer tw.Stop()
 	assert.NotPanics(t, func() {
 		tw.SetTimer("any", 3, -testStep)
@@ -105,7 +105,7 @@ func TestTimingWheel_SetTimerWrongDelay(t *testing.T) {
 
 func TestTimingWheel_SetTimerAfterClose(t *testing.T) {
 	ticker := timex.NewFakeTicker()
-	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v interface{}) {}, ticker)
+	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v any) {}, ticker)
 	tw.Stop()
 	assert.Equal(t, ErrClosed, tw.SetTimer("any", 3, testStep))
 }
@@ -113,7 +113,7 @@ func TestTimingWheel_SetTimerAfterClose(t *testing.T) {
 func TestTimingWheel_MoveTimer(t *testing.T) {
 	run := syncx.NewAtomicBool()
 	ticker := timex.NewFakeTicker()
-	tw, _ := NewTimingWheelWithTicker(testStep, 3, func(k, v interface{}) {
+	tw, _ := NewTimingWheelWithTicker(testStep, 3, func(k, v any) {
 		assert.True(t, run.CompareAndSwap(false, true))
 		assert.Equal(t, "any", k)
 		assert.Equal(t, 3, v.(int))
@@ -139,7 +139,7 @@ func TestTimingWheel_MoveTimer(t *testing.T) {
 func TestTimingWheel_MoveTimerSoon(t *testing.T) {
 	run := syncx.NewAtomicBool()
 	ticker := timex.NewFakeTicker()
-	tw, _ := NewTimingWheelWithTicker(testStep, 3, func(k, v interface{}) {
+	tw, _ := NewTimingWheelWithTicker(testStep, 3, func(k, v any) {
 		assert.True(t, run.CompareAndSwap(false, true))
 		assert.Equal(t, "any", k)
 		assert.Equal(t, 3, v.(int))
@@ -155,7 +155,7 @@ func TestTimingWheel_MoveTimerSoon(t *testing.T) {
 func TestTimingWheel_MoveTimerEarlier(t *testing.T) {
 	run := syncx.NewAtomicBool()
 	ticker := timex.NewFakeTicker()
-	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v interface{}) {
+	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v any) {
 		assert.True(t, run.CompareAndSwap(false, true))
 		assert.Equal(t, "any", k)
 		assert.Equal(t, 3, v.(int))
@@ -173,7 +173,7 @@ func TestTimingWheel_MoveTimerEarlier(t *testing.T) {
 
 func TestTimingWheel_RemoveTimer(t *testing.T) {
 	ticker := timex.NewFakeTicker()
-	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v interface{}) {}, ticker)
+	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v any) {}, ticker)
 	tw.SetTimer("any", 3, testStep)
 	assert.NotPanics(t, func() {
 		tw.RemoveTimer("any")
@@ -236,7 +236,7 @@ func TestTimingWheel_SetTimer(t *testing.T) {
 			}
 			var actual int32
 			done := make(chan lang.PlaceholderType)
-			tw, err := NewTimingWheelWithTicker(testStep, test.slots, func(key, value interface{}) {
+			tw, err := NewTimingWheelWithTicker(testStep, test.slots, func(key, value any) {
 				assert.Equal(t, 1, key.(int))
 				assert.Equal(t, 2, value.(int))
 				actual = atomic.LoadInt32(&count)
@@ -317,7 +317,7 @@ func TestTimingWheel_SetAndMoveThenStart(t *testing.T) {
 			}
 			var actual int32
 			done := make(chan lang.PlaceholderType)
-			tw, err := NewTimingWheelWithTicker(testStep, test.slots, func(key, value interface{}) {
+			tw, err := NewTimingWheelWithTicker(testStep, test.slots, func(key, value any) {
 				actual = atomic.LoadInt32(&count)
 				close(done)
 			}, ticker)
@@ -405,7 +405,7 @@ func TestTimingWheel_SetAndMoveTwice(t *testing.T) {
 			}
 			var actual int32
 			done := make(chan lang.PlaceholderType)
-			tw, err := NewTimingWheelWithTicker(testStep, test.slots, func(key, value interface{}) {
+			tw, err := NewTimingWheelWithTicker(testStep, test.slots, func(key, value any) {
 				actual = atomic.LoadInt32(&count)
 				close(done)
 			}, ticker)
@@ -486,7 +486,7 @@ func TestTimingWheel_ElapsedAndSet(t *testing.T) {
 			}
 			var actual int32
 			done := make(chan lang.PlaceholderType)
-			tw, err := NewTimingWheelWithTicker(testStep, test.slots, func(key, value interface{}) {
+			tw, err := NewTimingWheelWithTicker(testStep, test.slots, func(key, value any) {
 				actual = atomic.LoadInt32(&count)
 				close(done)
 			}, ticker)
@@ -577,7 +577,7 @@ func TestTimingWheel_ElapsedAndSetThenMove(t *testing.T) {
 			}
 			var actual int32
 			done := make(chan lang.PlaceholderType)
-			tw, err := NewTimingWheelWithTicker(testStep, test.slots, func(key, value interface{}) {
+			tw, err := NewTimingWheelWithTicker(testStep, test.slots, func(key, value any) {
 				actual = atomic.LoadInt32(&count)
 				close(done)
 			}, ticker)
@@ -612,7 +612,7 @@ func TestMoveAndRemoveTask(t *testing.T) {
 		}
 	}
 	var keys []int
-	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v interface{}) {
+	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v any) {
 		assert.Equal(t, "any", k)
 		assert.Equal(t, 3, v.(int))
 		keys = append(keys, v.(int))
@@ -632,7 +632,7 @@ func TestMoveAndRemoveTask(t *testing.T) {
 func BenchmarkTimingWheel(b *testing.B) {
 	b.ReportAllocs()
 
-	tw, _ := NewTimingWheel(time.Second, 100, func(k, v interface{}) {})
+	tw, _ := NewTimingWheel(time.Second, 100, func(k, v any) {})
 	for i := 0; i < b.N; i++ {
 		tw.SetTimer(i, i, time.Second)
 		tw.SetTimer(b.N+i, b.N+i, time.Second)

core/conf/config.go

@@ -13,7 +13,7 @@ import (
 	"github.com/zeromicro/go-zero/internal/encoding"
 )
 
-var loaders = map[string]func([]byte, interface{}) error{
+var loaders = map[string]func([]byte, any) error{
 	".json": LoadFromJsonBytes,
 	".toml": LoadFromTomlBytes,
 	".yaml": LoadFromYamlBytes,
@@ -22,12 +22,11 @@ var loaders = map[string]func([]byte, interface{}) error{
 
 type fieldInfo struct {
 	name     string
-	kind     reflect.Kind
 	children map[string]fieldInfo
 }
 
 // Load loads config into v from file, .json, .yaml and .yml are acceptable.
-func Load(file string, v interface{}, opts ...Option) error {
+func Load(file string, v any, opts ...Option) error {
 	content, err := os.ReadFile(file)
 	if err != nil {
 		return err
@@ -52,13 +51,13 @@ func Load(file string, v interface{}, opts ...Option) error {
 
 // LoadConfig loads config into v from file, .json, .yaml and .yml are acceptable.
 // Deprecated: use Load instead.
-func LoadConfig(file string, v interface{}, opts ...Option) error {
+func LoadConfig(file string, v any, opts ...Option) error {
 	return Load(file, v, opts...)
 }
 
 // LoadFromJsonBytes loads config into v from content json bytes.
-func LoadFromJsonBytes(content []byte, v interface{}) error {
-	var m map[string]interface{}
+func LoadFromJsonBytes(content []byte, v any) error {
+	var m map[string]any
 	if err := jsonx.Unmarshal(content, &m); err != nil {
 		return err
 	}
@@ -71,12 +70,12 @@ func LoadFromJsonBytes(content []byte, v interface{}) error {
 
 // LoadConfigFromJsonBytes loads config into v from content json bytes.
 // Deprecated: use LoadFromJsonBytes instead.
-func LoadConfigFromJsonBytes(content []byte, v interface{}) error {
+func LoadConfigFromJsonBytes(content []byte, v any) error {
 	return LoadFromJsonBytes(content, v)
 }
 
 // LoadFromTomlBytes loads config into v from content toml bytes.
-func LoadFromTomlBytes(content []byte, v interface{}) error {
+func LoadFromTomlBytes(content []byte, v any) error {
 	b, err := encoding.TomlToJson(content)
 	if err != nil {
 		return err
@@ -86,7 +85,7 @@ func LoadFromTomlBytes(content []byte, v interface{}) error {
 }
 
 // LoadFromYamlBytes loads config into v from content yaml bytes.
-func LoadFromYamlBytes(content []byte, v interface{}) error {
+func LoadFromYamlBytes(content []byte, v any) error {
 	b, err := encoding.YamlToJson(content)
 	if err != nil {
 		return err
@@ -97,12 +96,12 @@ func LoadFromYamlBytes(content []byte, v interface{}) error {
 
 // LoadConfigFromYamlBytes loads config into v from content yaml bytes.
 // Deprecated: use LoadFromYamlBytes instead.
-func LoadConfigFromYamlBytes(content []byte, v interface{}) error {
+func LoadConfigFromYamlBytes(content []byte, v any) error {
 	return LoadFromYamlBytes(content, v)
 }
 
 // MustLoad loads config into v from path, exits on error.
-func MustLoad(path string, v interface{}, opts ...Option) {
+func MustLoad(path string, v any, opts ...Option) {
 	if err := Load(path, v, opts...); err != nil {
 		log.Fatalf("error: config file %s, %s", path, err.Error())
 	}
@@ -140,7 +139,6 @@ func buildStructFieldsInfo(tp reflect.Type) map[string]fieldInfo {
 			} else {
 				info[lowerCaseName] = fieldInfo{
 					name: name,
-					kind: ft.Kind(),
 				}
 			}
 			continue
@@ -156,10 +154,16 @@ func buildStructFieldsInfo(tp reflect.Type) map[string]fieldInfo {
 			fields = buildFieldsInfo(ft.Elem())
 		}
 
-		info[lowerCaseName] = fieldInfo{
-			name:     name,
-			kind:     ft.Kind(),
-			children: fields,
+		if prev, ok := info[lowerCaseName]; ok {
+			// merge fields
+			for k, v := range fields {
+				prev.children[k] = v
+			}
+		} else {
+			info[lowerCaseName] = fieldInfo{
+				name:     name,
+				children: fields,
+			}
 		}
 	}
 
@@ -170,12 +174,12 @@ func toLowerCase(s string) string {
 	return strings.ToLower(s)
 }
 
-func toLowerCaseInterface(v interface{}, info map[string]fieldInfo) interface{} {
+func toLowerCaseInterface(v any, info map[string]fieldInfo) any {
 	switch vv := v.(type) {
-	case map[string]interface{}:
+	case map[string]any:
 		return toLowerCaseKeyMap(vv, info)
-	case []interface{}:
-		var arr []interface{}
+	case []any:
+		var arr []any
 		for _, vvv := range vv {
 			arr = append(arr, toLowerCaseInterface(vvv, info))
 		}
@@ -185,8 +189,8 @@ func toLowerCaseInterface(v interface{}, info map[string]fieldInfo) interface{}
 	}
 }
 
-func toLowerCaseKeyMap(m map[string]interface{}, info map[string]fieldInfo) map[string]interface{} {
-	res := make(map[string]interface{})
+func toLowerCaseKeyMap(m map[string]any, info map[string]fieldInfo) map[string]any {
+	res := make(map[string]any)
 
 	for k, v := range m {
 		ti, ok := info[k]

core/conf/config_test.go

@@ -97,6 +97,30 @@ d = "abcd!@#$112"
 	assert.Equal(t, "abcd!@#$112", val.D)
 }
 
+func TestConfigOptional(t *testing.T) {
+	text := `a = "foo"
+b = 1
+c = "FOO"
+d = "abcd"
+`
+	tmpfile, err := createTempFile(".toml", text)
+	assert.Nil(t, err)
+	defer os.Remove(tmpfile)
+
+	var val struct {
+		A string `json:"a"`
+		B int    `json:"b,optional"`
+		C string `json:"c,optional=B"`
+		D string `json:"d,optional=b"`
+	}
+	if assert.NoError(t, Load(tmpfile, &val)) {
+		assert.Equal(t, "foo", val.A)
+		assert.Equal(t, 1, val.B)
+		assert.Equal(t, "FOO", val.C)
+		assert.Equal(t, "abcd", val.D)
+	}
+}
+
 func TestConfigJsonCanonical(t *testing.T) {
 	text := []byte(`{"a": "foo", "B": "bar"}`)
 
@@ -360,6 +384,78 @@ func TestLoadFromYamlBytesLayers(t *testing.T) {
 	assert.Equal(t, "foo", val.Value)
 }
 
+func TestLoadFromYamlItemOverlay(t *testing.T) {
+	type (
+		Redis struct {
+			Host string
+			Port int
+		}
+
+		RedisKey struct {
+			Redis
+			Key string
+		}
+
+		Server struct {
+			Redis RedisKey
+		}
+
+		TestConfig struct {
+			Server
+			Redis Redis
+		}
+	)
+
+	input := []byte(`Redis:
+  Host: localhost
+  Port: 6379
+  Key: test
+`)
+
+	var c TestConfig
+	if assert.NoError(t, LoadFromYamlBytes(input, &c)) {
+		assert.Equal(t, "localhost", c.Redis.Host)
+		assert.Equal(t, 6379, c.Redis.Port)
+		assert.Equal(t, "test", c.Server.Redis.Key)
+	}
+}
+
+func TestLoadFromYamlItemOverlayWithMap(t *testing.T) {
+	type (
+		Redis struct {
+			Host string
+			Port int
+		}
+
+		RedisKey struct {
+			Redis
+			Key string
+		}
+
+		Server struct {
+			Redis RedisKey
+		}
+
+		TestConfig struct {
+			Server
+			Redis map[string]interface{}
+		}
+	)
+
+	input := []byte(`Redis:
+  Host: localhost
+  Port: 6379
+  Key: test
+`)
+
+	var c TestConfig
+	if assert.NoError(t, LoadFromYamlBytes(input, &c)) {
+		assert.Equal(t, "localhost", c.Server.Redis.Host)
+		assert.Equal(t, 6379, c.Server.Redis.Port)
+		assert.Equal(t, "test", c.Server.Redis.Key)
+	}
+}
+
 func TestUnmarshalJsonBytesMap(t *testing.T) {
 	input := []byte(`{"foo":{"/mtproto.RPCTos": "bff.bff","bar":"baz"}}`)
 

core/conf/readme.md

@@ -4,6 +4,7 @@
 
 ```go
 type RestfulConf struct {
+  ServiceName  string        `json:",env=SERVICE_NAME"`  // read from env automatically
 	Host         string        `json:",default=0.0.0.0"`
 	Port         int
 	LogMode      string        `json:",options=[file,console]"`
@@ -21,20 +22,20 @@ type RestfulConf struct {
 
 ```yaml
 # most fields are optional or have default values
-Port: 8080
-LogMode: console
+port: 8080
+logMode: console
 # you can use env settings
-MaxBytes: ${MAX_BYTES}
+maxBytes: ${MAX_BYTES}
 ```
 
 - toml example
 
 ```toml
 # most fields are optional or have default values
-Port = 8_080
-LogMode = "console"
+port = 8_080
+logMode = "console"
 # you can use env settings
-MaxBytes = "${MAX_BYTES}"
+maxBytes = "${MAX_BYTES}"
 ```
 
 3. Load the config from a file:

core/contextx/unmarshaler.go

@@ -14,13 +14,13 @@ type contextValuer struct {
 	context.Context
 }
 
-func (cv contextValuer) Value(key string) (interface{}, bool) {
+func (cv contextValuer) Value(key string) (any, bool) {
 	v := cv.Context.Value(key)
 	return v, v != nil
 }
 
 // For unmarshals ctx into v.
-func For(ctx context.Context, v interface{}) error {
+func For(ctx context.Context, v any) error {
 	return unmarshaler.UnmarshalValuer(contextValuer{
 		Context: ctx,
 	}, v)

core/discov/internal/etcdclient_mock.go

@@ -81,7 +81,7 @@ func (mr *MockEtcdClientMockRecorder) Ctx() *gomock.Call {
 // Get mocks base method
 func (m *MockEtcdClient) Get(ctx context.Context, key string, opts ...clientv3.OpOption) (*clientv3.GetResponse, error) {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{ctx, key}
+	varargs := []any{ctx, key}
 	for _, a := range opts {
 		varargs = append(varargs, a)
 	}
@@ -92,9 +92,9 @@ func (m *MockEtcdClient) Get(ctx context.Context, key string, opts ...clientv3.O
 }
 
 // Get indicates an expected call of Get
-func (mr *MockEtcdClientMockRecorder) Get(ctx, key interface{}, opts ...interface{}) *gomock.Call {
+func (mr *MockEtcdClientMockRecorder) Get(ctx, key any, opts ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{ctx, key}, opts...)
+	varargs := append([]any{ctx, key}, opts...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockEtcdClient)(nil).Get), varargs...)
 }
 
@@ -108,7 +108,7 @@ func (m *MockEtcdClient) Grant(ctx context.Context, ttl int64) (*clientv3.LeaseG
 }
 
 // Grant indicates an expected call of Grant
-func (mr *MockEtcdClientMockRecorder) Grant(ctx, ttl interface{}) *gomock.Call {
+func (mr *MockEtcdClientMockRecorder) Grant(ctx, ttl any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Grant", reflect.TypeOf((*MockEtcdClient)(nil).Grant), ctx, ttl)
 }
@@ -123,7 +123,7 @@ func (m *MockEtcdClient) KeepAlive(ctx context.Context, id clientv3.LeaseID) (<-
 }
 
 // KeepAlive indicates an expected call of KeepAlive
-func (mr *MockEtcdClientMockRecorder) KeepAlive(ctx, id interface{}) *gomock.Call {
+func (mr *MockEtcdClientMockRecorder) KeepAlive(ctx, id any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "KeepAlive", reflect.TypeOf((*MockEtcdClient)(nil).KeepAlive), ctx, id)
 }
@@ -131,7 +131,7 @@ func (mr *MockEtcdClientMockRecorder) KeepAlive(ctx, id interface{}) *gomock.Cal
 // Put mocks base method
 func (m *MockEtcdClient) Put(ctx context.Context, key, val string, opts ...clientv3.OpOption) (*clientv3.PutResponse, error) {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{ctx, key, val}
+	varargs := []any{ctx, key, val}
 	for _, a := range opts {
 		varargs = append(varargs, a)
 	}
@@ -142,9 +142,9 @@ func (m *MockEtcdClient) Put(ctx context.Context, key, val string, opts ...clien
 }
 
 // Put indicates an expected call of Put
-func (mr *MockEtcdClientMockRecorder) Put(ctx, key, val interface{}, opts ...interface{}) *gomock.Call {
+func (mr *MockEtcdClientMockRecorder) Put(ctx, key, val any, opts ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{ctx, key, val}, opts...)
+	varargs := append([]any{ctx, key, val}, opts...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockEtcdClient)(nil).Put), varargs...)
 }
 
@@ -158,7 +158,7 @@ func (m *MockEtcdClient) Revoke(ctx context.Context, id clientv3.LeaseID) (*clie
 }
 
 // Revoke indicates an expected call of Revoke
-func (mr *MockEtcdClientMockRecorder) Revoke(ctx, id interface{}) *gomock.Call {
+func (mr *MockEtcdClientMockRecorder) Revoke(ctx, id any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Revoke", reflect.TypeOf((*MockEtcdClient)(nil).Revoke), ctx, id)
 }
@@ -166,7 +166,7 @@ func (mr *MockEtcdClientMockRecorder) Revoke(ctx, id interface{}) *gomock.Call {
 // Watch mocks base method
 func (m *MockEtcdClient) Watch(ctx context.Context, key string, opts ...clientv3.OpOption) clientv3.WatchChan {
 	m.ctrl.T.Helper()
-	varargs := []interface{}{ctx, key}
+	varargs := []any{ctx, key}
 	for _, a := range opts {
 		varargs = append(varargs, a)
 	}
@@ -176,8 +176,8 @@ func (m *MockEtcdClient) Watch(ctx context.Context, key string, opts ...clientv3
 }
 
 // Watch indicates an expected call of Watch
-func (mr *MockEtcdClientMockRecorder) Watch(ctx, key interface{}, opts ...interface{}) *gomock.Call {
+func (mr *MockEtcdClientMockRecorder) Watch(ctx, key any, opts ...any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]interface{}{ctx, key}, opts...)
+	varargs := append([]any{ctx, key}, opts...)
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Watch", reflect.TypeOf((*MockEtcdClient)(nil).Watch), varargs...)
 }

core/discov/internal/registry_test.go

@@ -167,7 +167,7 @@ func TestCluster_Watch(t *testing.T) {
 				assert.Equal(t, "world", kv.Val)
 				wg.Done()
 			}).MaxTimes(1)
-			listener.EXPECT().OnDelete(gomock.Any()).Do(func(_ interface{}) {
+			listener.EXPECT().OnDelete(gomock.Any()).Do(func(_ any) {
 				wg.Done()
 			}).MaxTimes(1)
 			go c.watch(cli, "any", 0)

core/discov/internal/statewatcher_mock.go

@@ -58,7 +58,7 @@ func (m *MocketcdConn) WaitForStateChange(ctx context.Context, sourceState conne
 }
 
 // WaitForStateChange indicates an expected call of WaitForStateChange
-func (mr *MocketcdConnMockRecorder) WaitForStateChange(ctx, sourceState interface{}) *gomock.Call {
+func (mr *MocketcdConnMockRecorder) WaitForStateChange(ctx, sourceState any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WaitForStateChange", reflect.TypeOf((*MocketcdConn)(nil).WaitForStateChange), ctx, sourceState)
 }

core/discov/internal/updatelistener_mock.go

@@ -40,7 +40,7 @@ func (m *MockUpdateListener) OnAdd(kv KV) {
 }
 
 // OnAdd indicates an expected call of OnAdd
-func (mr *MockUpdateListenerMockRecorder) OnAdd(kv interface{}) *gomock.Call {
+func (mr *MockUpdateListenerMockRecorder) OnAdd(kv any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnAdd", reflect.TypeOf((*MockUpdateListener)(nil).OnAdd), kv)
 }
@@ -52,7 +52,7 @@ func (m *MockUpdateListener) OnDelete(kv KV) {
 }
 
 // OnDelete indicates an expected call of OnDelete
-func (mr *MockUpdateListenerMockRecorder) OnDelete(kv interface{}) *gomock.Call {
+func (mr *MockUpdateListenerMockRecorder) OnDelete(kv any) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
 	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OnDelete", reflect.TypeOf((*MockUpdateListener)(nil).OnDelete), kv)
 }

core/discov/publisher_test.go

@@ -125,7 +125,7 @@ func TestPublisher_keepAliveAsyncQuit(t *testing.T) {
 	cli.EXPECT().KeepAlive(gomock.Any(), id)
 	var wg sync.WaitGroup
 	wg.Add(1)
-	cli.EXPECT().Revoke(gomock.Any(), id).Do(func(_, _ interface{}) {
+	cli.EXPECT().Revoke(gomock.Any(), id).Do(func(_, _ any) {
 		wg.Done()
 	})
 	pub := NewPublisher(nil, "thekey", "thevalue")
@@ -147,7 +147,7 @@ func TestPublisher_keepAliveAsyncPause(t *testing.T) {
 	pub := NewPublisher(nil, "thekey", "thevalue")
 	var wg sync.WaitGroup
 	wg.Add(1)
-	cli.EXPECT().Revoke(gomock.Any(), id).Do(func(_, _ interface{}) {
+	cli.EXPECT().Revoke(gomock.Any(), id).Do(func(_, _ any) {
 		pub.Stop()
 		wg.Done()
 	})

core/errorx/wrap.go

@@ -12,7 +12,7 @@ func Wrap(err error, message string) error {
 }
 
 // Wrapf returns an error that wraps err with given format and args.
-func Wrapf(err error, format string, args ...interface{}) error {
+func Wrapf(err error, format string, args ...any) error {
 	if err == nil {
 		return nil
 	}

core/executors/bulkexecutor.go

@@ -42,7 +42,7 @@ func NewBulkExecutor(execute Execute, opts ...BulkOption) *BulkExecutor {
 }
 
 // Add adds task into be.
-func (be *BulkExecutor) Add(task interface{}) error {
+func (be *BulkExecutor) Add(task any) error {
 	be.executor.Add(task)
 	return nil
 }
@@ -79,22 +79,22 @@ func newBulkOptions() bulkOptions {
 }
 
 type bulkContainer struct {
-	tasks    []interface{}
+	tasks    []any
 	execute  Execute
 	maxTasks int
 }
 
-func (bc *bulkContainer) AddTask(task interface{}) bool {
+func (bc *bulkContainer) AddTask(task any) bool {
 	bc.tasks = append(bc.tasks, task)
 	return len(bc.tasks) >= bc.maxTasks
 }
 
-func (bc *bulkContainer) Execute(tasks interface{}) {
-	vals := tasks.([]interface{})
+func (bc *bulkContainer) Execute(tasks any) {
+	vals := tasks.([]any)
 	bc.execute(vals)
 }
 
-func (bc *bulkContainer) RemoveAll() interface{} {
+func (bc *bulkContainer) RemoveAll() any {
 	tasks := bc.tasks
 	bc.tasks = nil
 	return tasks

core/executors/bulkexecutor_test.go

@@ -12,7 +12,7 @@ func TestBulkExecutor(t *testing.T) {
 	var values []int
 	var lock sync.Mutex
 
-	executor := NewBulkExecutor(func(items []interface{}) {
+	executor := NewBulkExecutor(func(items []any) {
 		lock.Lock()
 		values = append(values, len(items))
 		lock.Unlock()
@@ -40,7 +40,7 @@ func TestBulkExecutorFlushInterval(t *testing.T) {
 	var wait sync.WaitGroup
 
 	wait.Add(1)
-	executor := NewBulkExecutor(func(items []interface{}) {
+	executor := NewBulkExecutor(func(items []any) {
 		assert.Equal(t, size, len(items))
 		wait.Done()
 	}, WithBulkTasks(caches), WithBulkInterval(time.Millisecond*100))
@@ -53,7 +53,7 @@ func TestBulkExecutorFlushInterval(t *testing.T) {
 }
 
 func TestBulkExecutorEmpty(t *testing.T) {
-	NewBulkExecutor(func(items []interface{}) {
+	NewBulkExecutor(func(items []any) {
 		assert.Fail(t, "should not called")
 	}, WithBulkTasks(10), WithBulkInterval(time.Millisecond))
 	time.Sleep(time.Millisecond * 100)
@@ -67,7 +67,7 @@ func TestBulkExecutorFlush(t *testing.T) {
 
 	var wait sync.WaitGroup
 	wait.Add(1)
-	be := NewBulkExecutor(func(items []interface{}) {
+	be := NewBulkExecutor(func(items []any) {
 		assert.Equal(t, tasks, len(items))
 		wait.Done()
 	}, WithBulkTasks(caches), WithBulkInterval(time.Minute))
@@ -81,8 +81,8 @@ func TestBulkExecutorFlush(t *testing.T) {
 func TestBuldExecutorFlushSlowTasks(t *testing.T) {
 	const total = 1500
 	lock := new(sync.Mutex)
-	result := make([]interface{}, 0, 10000)
-	exec := NewBulkExecutor(func(tasks []interface{}) {
+	result := make([]any, 0, 10000)
+	exec := NewBulkExecutor(func(tasks []any) {
 		time.Sleep(time.Millisecond * 100)
 		lock.Lock()
 		defer lock.Unlock()
@@ -100,7 +100,7 @@ func TestBuldExecutorFlushSlowTasks(t *testing.T) {
 func BenchmarkBulkExecutor(b *testing.B) {
 	b.ReportAllocs()
 
-	be := NewBulkExecutor(func(tasks []interface{}) {
+	be := NewBulkExecutor(func(tasks []any) {
 		time.Sleep(time.Millisecond * time.Duration(len(tasks)))
 	})
 	for i := 0; i < b.N; i++ {

core/executors/chunkexecutor.go

@@ -42,7 +42,7 @@ func NewChunkExecutor(execute Execute, opts ...ChunkOption) *ChunkExecutor {
 }
 
 // Add adds task with given chunk size into ce.
-func (ce *ChunkExecutor) Add(task interface{}, size int) error {
+func (ce *ChunkExecutor) Add(task any, size int) error {
 	ce.executor.Add(chunk{
 		val:  task,
 		size: size,
@@ -82,25 +82,25 @@ func newChunkOptions() chunkOptions {
 }
 
 type chunkContainer struct {
-	tasks        []interface{}
+	tasks        []any
 	execute      Execute
 	size         int
 	maxChunkSize int
 }
 
-func (bc *chunkContainer) AddTask(task interface{}) bool {
+func (bc *chunkContainer) AddTask(task any) bool {
 	ck := task.(chunk)
 	bc.tasks = append(bc.tasks, ck.val)
 	bc.size += ck.size
 	return bc.size >= bc.maxChunkSize
 }
 
-func (bc *chunkContainer) Execute(tasks interface{}) {
-	vals := tasks.([]interface{})
+func (bc *chunkContainer) Execute(tasks any) {
+	vals := tasks.([]any)
 	bc.execute(vals)
 }
 
-func (bc *chunkContainer) RemoveAll() interface{} {
+func (bc *chunkContainer) RemoveAll() any {
 	tasks := bc.tasks
 	bc.tasks = nil
 	bc.size = 0
@@ -108,6 +108,6 @@ func (bc *chunkContainer) RemoveAll() interface{} {
 }
 
 type chunk struct {
-	val  interface{}
+	val  any
 	size int
 }

core/executors/chunkexecutor_test.go

@@ -12,7 +12,7 @@ func TestChunkExecutor(t *testing.T) {
 	var values []int
 	var lock sync.Mutex
 
-	executor := NewChunkExecutor(func(items []interface{}) {
+	executor := NewChunkExecutor(func(items []any) {
 		lock.Lock()
 		values = append(values, len(items))
 		lock.Unlock()
@@ -40,7 +40,7 @@ func TestChunkExecutorFlushInterval(t *testing.T) {
 	var wait sync.WaitGroup
 
 	wait.Add(1)
-	executor := NewChunkExecutor(func(items []interface{}) {
+	executor := NewChunkExecutor(func(items []any) {
 		assert.Equal(t, size, len(items))
 		wait.Done()
 	}, WithChunkBytes(caches), WithFlushInterval(time.Millisecond*100))
@@ -53,10 +53,11 @@ func TestChunkExecutorFlushInterval(t *testing.T) {
 }
 
 func TestChunkExecutorEmpty(t *testing.T) {
-	NewChunkExecutor(func(items []interface{}) {
+	executor := NewChunkExecutor(func(items []any) {
 		assert.Fail(t, "should not called")
 	}, WithChunkBytes(10), WithFlushInterval(time.Millisecond))
 	time.Sleep(time.Millisecond * 100)
+	executor.Wait()
 }
 
 func TestChunkExecutorFlush(t *testing.T) {
@@ -67,7 +68,7 @@ func TestChunkExecutorFlush(t *testing.T) {
 
 	var wait sync.WaitGroup
 	wait.Add(1)
-	be := NewChunkExecutor(func(items []interface{}) {
+	be := NewChunkExecutor(func(items []any) {
 		assert.Equal(t, tasks, len(items))
 		wait.Done()
 	}, WithChunkBytes(caches), WithFlushInterval(time.Minute))
@@ -81,7 +82,7 @@ func TestChunkExecutorFlush(t *testing.T) {
 func BenchmarkChunkExecutor(b *testing.B) {
 	b.ReportAllocs()
 
-	be := NewChunkExecutor(func(tasks []interface{}) {
+	be := NewChunkExecutor(func(tasks []any) {
 		time.Sleep(time.Millisecond * time.Duration(len(tasks)))
 	})
 	for i := 0; i < b.N; i++ {

core/executors/periodicalexecutor.go

@@ -21,16 +21,16 @@ type (
 	TaskContainer interface {
 		// AddTask adds the task into the container.
 		// Returns true if the container needs to be flushed after the addition.
-		AddTask(task interface{}) bool
+		AddTask(task any) bool
 		// Execute handles the collected tasks by the container when flushing.
-		Execute(tasks interface{})
+		Execute(tasks any)
 		// RemoveAll removes the contained tasks, and return them.
-		RemoveAll() interface{}
+		RemoveAll() any
 	}
 
 	// A PeriodicalExecutor is an executor that periodically execute tasks.
 	PeriodicalExecutor struct {
-		commander chan interface{}
+		commander chan any
 		interval  time.Duration
 		container TaskContainer
 		waitGroup sync.WaitGroup
@@ -48,7 +48,7 @@ type (
 func NewPeriodicalExecutor(interval time.Duration, container TaskContainer) *PeriodicalExecutor {
 	executor := &PeriodicalExecutor{
 		// buffer 1 to let the caller go quickly
-		commander:   make(chan interface{}, 1),
+		commander:   make(chan any, 1),
 		interval:    interval,
 		container:   container,
 		confirmChan: make(chan lang.PlaceholderType),
@@ -64,7 +64,7 @@ func NewPeriodicalExecutor(interval time.Duration, container TaskContainer) *Per
 }
 
 // Add adds tasks into pe.
-func (pe *PeriodicalExecutor) Add(task interface{}) {
+func (pe *PeriodicalExecutor) Add(task any) {
 	if vals, ok := pe.addAndCheck(task); ok {
 		pe.commander <- vals
 		<-pe.confirmChan
@@ -74,7 +74,7 @@ func (pe *PeriodicalExecutor) Add(task interface{}) {
 // Flush forces pe to execute tasks.
 func (pe *PeriodicalExecutor) Flush() bool {
 	pe.enterExecution()
-	return pe.executeTasks(func() interface{} {
+	return pe.executeTasks(func() any {
 		pe.lock.Lock()
 		defer pe.lock.Unlock()
 		return pe.container.RemoveAll()
@@ -96,7 +96,7 @@ func (pe *PeriodicalExecutor) Wait() {
 	})
 }
 
-func (pe *PeriodicalExecutor) addAndCheck(task interface{}) (interface{}, bool) {
+func (pe *PeriodicalExecutor) addAndCheck(task any) (any, bool) {
 	pe.lock.Lock()
 	defer func() {
 		if !pe.guarded {
@@ -157,7 +157,7 @@ func (pe *PeriodicalExecutor) enterExecution() {
 	})
 }
 
-func (pe *PeriodicalExecutor) executeTasks(tasks interface{}) bool {
+func (pe *PeriodicalExecutor) executeTasks(tasks any) bool {
 	defer pe.doneExecution()
 
 	ok := pe.hasTasks(tasks)
@@ -168,7 +168,7 @@ func (pe *PeriodicalExecutor) executeTasks(tasks interface{}) bool {
 	return ok
 }
 
-func (pe *PeriodicalExecutor) hasTasks(tasks interface{}) bool {
+func (pe *PeriodicalExecutor) hasTasks(tasks any) bool {
 	if tasks == nil {
 		return false
 	}

core/executors/periodicalexecutor_test.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/zeromicro/go-zero/core/proc"
 	"github.com/zeromicro/go-zero/core/timex"
 )
 
@@ -16,22 +17,22 @@ const threshold = 10
 type container struct {
 	interval time.Duration
 	tasks    []int
-	execute  func(tasks interface{})
+	execute  func(tasks any)
 }
 
-func newContainer(interval time.Duration, execute func(tasks interface{})) *container {
+func newContainer(interval time.Duration, execute func(tasks any)) *container {
 	return &container{
 		interval: interval,
 		execute:  execute,
 	}
 }
 
-func (c *container) AddTask(task interface{}) bool {
+func (c *container) AddTask(task any) bool {
 	c.tasks = append(c.tasks, task.(int))
 	return len(c.tasks) > threshold
 }
 
-func (c *container) Execute(tasks interface{}) {
+func (c *container) Execute(tasks any) {
 	if c.execute != nil {
 		c.execute(tasks)
 	} else {
@@ -39,7 +40,7 @@ func (c *container) Execute(tasks interface{}) {
 	}
 }
 
-func (c *container) RemoveAll() interface{} {
+func (c *container) RemoveAll() any {
 	tasks := c.tasks
 	c.tasks = nil
 	return tasks
@@ -67,6 +68,7 @@ func TestPeriodicalExecutor_QuitGoroutine(t *testing.T) {
 	ticker.Tick()
 	ticker.Wait(time.Millisecond * idleRound)
 	assert.Equal(t, routines, runtime.NumGoroutine())
+	proc.Shutdown()
 }
 
 func TestPeriodicalExecutor_Bulk(t *testing.T) {
@@ -74,7 +76,7 @@ func TestPeriodicalExecutor_Bulk(t *testing.T) {
 	var vals []int
 	// avoid data race
 	var lock sync.Mutex
-	exec := NewPeriodicalExecutor(time.Millisecond, newContainer(time.Millisecond, func(tasks interface{}) {
+	exec := NewPeriodicalExecutor(time.Millisecond, newContainer(time.Millisecond, func(tasks any) {
 		t := tasks.([]int)
 		for _, each := range t {
 			lock.Lock()
@@ -108,7 +110,7 @@ func TestPeriodicalExecutor_Bulk(t *testing.T) {
 
 func TestPeriodicalExecutor_Wait(t *testing.T) {
 	var lock sync.Mutex
-	executer := NewBulkExecutor(func(tasks []interface{}) {
+	executer := NewBulkExecutor(func(tasks []any) {
 		lock.Lock()
 		defer lock.Unlock()
 		time.Sleep(10 * time.Millisecond)
@@ -124,7 +126,7 @@ func TestPeriodicalExecutor_WaitFast(t *testing.T) {
 	const total = 3
 	var cnt int
 	var lock sync.Mutex
-	executer := NewBulkExecutor(func(tasks []interface{}) {
+	executer := NewBulkExecutor(func(tasks []any) {
 		defer func() {
 			cnt++
 		}()
@@ -141,7 +143,7 @@ func TestPeriodicalExecutor_WaitFast(t *testing.T) {
 }
 
 func TestPeriodicalExecutor_Deadlock(t *testing.T) {
-	executor := NewBulkExecutor(func(tasks []interface{}) {
+	executor := NewBulkExecutor(func(tasks []any) {
 	}, WithBulkTasks(1), WithBulkInterval(time.Millisecond))
 	for i := 0; i < 1e5; i++ {
 		executor.Add(1)

core/executors/vars.go

@@ -5,4 +5,4 @@ import "time"
 const defaultFlushInterval = time.Second
 
 // Execute defines the method to execute tasks.
-type Execute func(tasks []interface{})
+type Execute func(tasks []any)

core/fx/stream.go

@@ -21,31 +21,31 @@ type (
 	}
 
 	// FilterFunc defines the method to filter a Stream.
-	FilterFunc func(item interface{}) bool
+	FilterFunc func(item any) bool
 	// ForAllFunc defines the method to handle all elements in a Stream.
-	ForAllFunc func(pipe <-chan interface{})
+	ForAllFunc func(pipe <-chan any)
 	// ForEachFunc defines the method to handle each element in a Stream.
-	ForEachFunc func(item interface{})
+	ForEachFunc func(item any)
 	// GenerateFunc defines the method to send elements into a Stream.
-	GenerateFunc func(source chan<- interface{})
+	GenerateFunc func(source chan<- any)
 	// KeyFunc defines the method to generate keys for the elements in a Stream.
-	KeyFunc func(item interface{}) interface{}
+	KeyFunc func(item any) any
 	// LessFunc defines the method to compare the elements in a Stream.
-	LessFunc func(a, b interface{}) bool
+	LessFunc func(a, b any) bool
 	// MapFunc defines the method to map each element to another object in a Stream.
-	MapFunc func(item interface{}) interface{}
+	MapFunc func(item any) any
 	// Option defines the method to customize a Stream.
 	Option func(opts *rxOptions)
 	// ParallelFunc defines the method to handle elements parallelly.
-	ParallelFunc func(item interface{})
+	ParallelFunc func(item any)
 	// ReduceFunc defines the method to reduce all the elements in a Stream.
-	ReduceFunc func(pipe <-chan interface{}) (interface{}, error)
+	ReduceFunc func(pipe <-chan any) (any, error)
 	// WalkFunc defines the method to walk through all the elements in a Stream.
-	WalkFunc func(item interface{}, pipe chan<- interface{})
+	WalkFunc func(item any, pipe chan<- any)
 
 	// A Stream is a stream that can be used to do stream processing.
 	Stream struct {
-		source <-chan interface{}
+		source <-chan any
 	}
 )
 
@@ -56,7 +56,7 @@ func Concat(s Stream, others ...Stream) Stream {
 
 // From constructs a Stream from the given GenerateFunc.
 func From(generate GenerateFunc) Stream {
-	source := make(chan interface{})
+	source := make(chan any)
 
 	threading.GoSafe(func() {
 		defer close(source)
@@ -67,8 +67,8 @@ func From(generate GenerateFunc) Stream {
 }
 
 // Just converts the given arbitrary items to a Stream.
-func Just(items ...interface{}) Stream {
-	source := make(chan interface{}, len(items))
+func Just(items ...any) Stream {
+	source := make(chan any, len(items))
 	for _, item := range items {
 		source <- item
 	}
@@ -78,7 +78,7 @@ func Just(items ...interface{}) Stream {
 }
 
 // Range converts the given channel to a Stream.
-func Range(source <-chan interface{}) Stream {
+func Range(source <-chan any) Stream {
 	return Stream{
 		source: source,
 	}
@@ -87,7 +87,7 @@ func Range(source <-chan interface{}) Stream {
 // AllMach returns whether all elements of this stream match the provided predicate.
 // May not evaluate the predicate on all elements if not necessary for determining the result.
 // If the stream is empty then true is returned and the predicate is not evaluated.
-func (s Stream) AllMach(predicate func(item interface{}) bool) bool {
+func (s Stream) AllMach(predicate func(item any) bool) bool {
 	for item := range s.source {
 		if !predicate(item) {
 			// make sure the former goroutine not block, and current func returns fast.
@@ -102,7 +102,7 @@ func (s Stream) AllMach(predicate func(item interface{}) bool) bool {
 // AnyMach returns whether any elements of this stream match the provided predicate.
 // May not evaluate the predicate on all elements if not necessary for determining the result.
 // If the stream is empty then false is returned and the predicate is not evaluated.
-func (s Stream) AnyMach(predicate func(item interface{}) bool) bool {
+func (s Stream) AnyMach(predicate func(item any) bool) bool {
 	for item := range s.source {
 		if predicate(item) {
 			// make sure the former goroutine not block, and current func returns fast.
@@ -121,7 +121,7 @@ func (s Stream) Buffer(n int) Stream {
 		n = 0
 	}
 
-	source := make(chan interface{}, n)
+	source := make(chan any, n)
 	go func() {
 		for item := range s.source {
 			source <- item
@@ -134,7 +134,7 @@ func (s Stream) Buffer(n int) Stream {
 
 // Concat returns a Stream that concatenated other streams
 func (s Stream) Concat(others ...Stream) Stream {
-	source := make(chan interface{})
+	source := make(chan any)
 
 	go func() {
 		group := threading.NewRoutineGroup()
@@ -170,12 +170,12 @@ func (s Stream) Count() (count int) {
 
 // Distinct removes the duplicated items base on the given KeyFunc.
 func (s Stream) Distinct(fn KeyFunc) Stream {
-	source := make(chan interface{})
+	source := make(chan any)
 
 	threading.GoSafe(func() {
 		defer close(source)
 
-		keys := make(map[interface{}]lang.PlaceholderType)
+		keys := make(map[any]lang.PlaceholderType)
 		for item := range s.source {
 			key := fn(item)
 			if _, ok := keys[key]; !ok {
@@ -195,7 +195,7 @@ func (s Stream) Done() {
 
 // Filter filters the items by the given FilterFunc.
 func (s Stream) Filter(fn FilterFunc, opts ...Option) Stream {
-	return s.Walk(func(item interface{}, pipe chan<- interface{}) {
+	return s.Walk(func(item any, pipe chan<- any) {
 		if fn(item) {
 			pipe <- item
 		}
@@ -203,7 +203,7 @@ func (s Stream) Filter(fn FilterFunc, opts ...Option) Stream {
 }
 
 // First returns the first item, nil if no items.
-func (s Stream) First() interface{} {
+func (s Stream) First() any {
 	for item := range s.source {
 		// make sure the former goroutine not block, and current func returns fast.
 		go drain(s.source)
@@ -229,13 +229,13 @@ func (s Stream) ForEach(fn ForEachFunc) {
 
 // Group groups the elements into different groups based on their keys.
 func (s Stream) Group(fn KeyFunc) Stream {
-	groups := make(map[interface{}][]interface{})
+	groups := make(map[any][]any)
 	for item := range s.source {
 		key := fn(item)
 		groups[key] = append(groups[key], item)
 	}
 
-	source := make(chan interface{})
+	source := make(chan any)
 	go func() {
 		for _, group := range groups {
 			source <- group
@@ -252,7 +252,7 @@ func (s Stream) Head(n int64) Stream {
 		panic("n must be greater than 0")
 	}
 
-	source := make(chan interface{})
+	source := make(chan any)
 
 	go func() {
 		for item := range s.source {
@@ -279,7 +279,7 @@ func (s Stream) Head(n int64) Stream {
 }
 
 // Last returns the last item, or nil if no items.
-func (s Stream) Last() (item interface{}) {
+func (s Stream) Last() (item any) {
 	for item = range s.source {
 	}
 	return
@@ -287,19 +287,19 @@ func (s Stream) Last() (item interface{}) {
 
 // Map converts each item to another corresponding item, which means it's a 1:1 model.
 func (s Stream) Map(fn MapFunc, opts ...Option) Stream {
-	return s.Walk(func(item interface{}, pipe chan<- interface{}) {
+	return s.Walk(func(item any, pipe chan<- any) {
 		pipe <- fn(item)
 	}, opts...)
 }
 
 // Merge merges all the items into a slice and generates a new stream.
 func (s Stream) Merge() Stream {
-	var items []interface{}
+	var items []any
 	for item := range s.source {
 		items = append(items, item)
 	}
 
-	source := make(chan interface{}, 1)
+	source := make(chan any, 1)
 	source <- items
 	close(source)
 
@@ -309,7 +309,7 @@ func (s Stream) Merge() Stream {
 // NoneMatch returns whether all elements of this stream don't match the provided predicate.
 // May not evaluate the predicate on all elements if not necessary for determining the result.
 // If the stream is empty then true is returned and the predicate is not evaluated.
-func (s Stream) NoneMatch(predicate func(item interface{}) bool) bool {
+func (s Stream) NoneMatch(predicate func(item any) bool) bool {
 	for item := range s.source {
 		if predicate(item) {
 			// make sure the former goroutine not block, and current func returns fast.
@@ -323,19 +323,19 @@ func (s Stream) NoneMatch(predicate func(item interface{}) bool) bool {
 
 // Parallel applies the given ParallelFunc to each item concurrently with given number of workers.
 func (s Stream) Parallel(fn ParallelFunc, opts ...Option) {
-	s.Walk(func(item interface{}, pipe chan<- interface{}) {
+	s.Walk(func(item any, pipe chan<- any) {
 		fn(item)
 	}, opts...).Done()
 }
 
 // Reduce is an utility method to let the caller deal with the underlying channel.
-func (s Stream) Reduce(fn ReduceFunc) (interface{}, error) {
+func (s Stream) Reduce(fn ReduceFunc) (any, error) {
 	return fn(s.source)
 }
 
 // Reverse reverses the elements in the stream.
 func (s Stream) Reverse() Stream {
-	var items []interface{}
+	var items []any
 	for item := range s.source {
 		items = append(items, item)
 	}
@@ -357,7 +357,7 @@ func (s Stream) Skip(n int64) Stream {
 		return s
 	}
 
-	source := make(chan interface{})
+	source := make(chan any)
 
 	go func() {
 		for item := range s.source {
@@ -376,7 +376,7 @@ func (s Stream) Skip(n int64) Stream {
 
 // Sort sorts the items from the underlying source.
 func (s Stream) Sort(less LessFunc) Stream {
-	var items []interface{}
+	var items []any
 	for item := range s.source {
 		items = append(items, item)
 	}
@@ -394,9 +394,9 @@ func (s Stream) Split(n int) Stream {
 		panic("n should be greater than 0")
 	}
 
-	source := make(chan interface{})
+	source := make(chan any)
 	go func() {
-		var chunk []interface{}
+		var chunk []any
 		for item := range s.source {
 			chunk = append(chunk, item)
 			if len(chunk) == n {
@@ -419,7 +419,7 @@ func (s Stream) Tail(n int64) Stream {
 		panic("n should be greater than 0")
 	}
 
-	source := make(chan interface{})
+	source := make(chan any)
 
 	go func() {
 		ring := collection.NewRing(int(n))
@@ -446,7 +446,7 @@ func (s Stream) Walk(fn WalkFunc, opts ...Option) Stream {
 }
 
 func (s Stream) walkLimited(fn WalkFunc, option *rxOptions) Stream {
-	pipe := make(chan interface{}, option.workers)
+	pipe := make(chan any, option.workers)
 
 	go func() {
 		var wg sync.WaitGroup
@@ -477,7 +477,7 @@ func (s Stream) walkLimited(fn WalkFunc, option *rxOptions) Stream {
 }
 
 func (s Stream) walkUnlimited(fn WalkFunc, option *rxOptions) Stream {
-	pipe := make(chan interface{}, option.workers)
+	pipe := make(chan any, option.workers)
 
 	go func() {
 		var wg sync.WaitGroup
@@ -529,7 +529,7 @@ func buildOptions(opts ...Option) *rxOptions {
 }
 
 // drain drains the given channel.
-func drain(channel <-chan interface{}) {
+func drain(channel <-chan any) {
 	for range channel {
 	}
 }

core/fx/stream_test.go

@@ -23,7 +23,7 @@ func TestBuffer(t *testing.T) {
 		var count int32
 		var wait sync.WaitGroup
 		wait.Add(1)
-		From(func(source chan<- interface{}) {
+		From(func(source chan<- any) {
 			ticker := time.NewTicker(10 * time.Millisecond)
 			defer ticker.Stop()
 
@@ -36,7 +36,7 @@ func TestBuffer(t *testing.T) {
 					return
 				}
 			}
-		}).Buffer(N).ForAll(func(pipe <-chan interface{}) {
+		}).Buffer(N).ForAll(func(pipe <-chan any) {
 			wait.Wait()
 			// why N+1, because take one more to wait for sending into the channel
 			assert.Equal(t, int32(N+1), atomic.LoadInt32(&count))
@@ -47,7 +47,7 @@ func TestBuffer(t *testing.T) {
 func TestBufferNegative(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		var result int
-		Just(1, 2, 3, 4).Buffer(-1).Reduce(func(pipe <-chan interface{}) (interface{}, error) {
+		Just(1, 2, 3, 4).Buffer(-1).Reduce(func(pipe <-chan any) (any, error) {
 			for item := range pipe {
 				result += item.(int)
 			}
@@ -61,22 +61,22 @@ func TestCount(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		tests := []struct {
 			name     string
-			elements []interface{}
+			elements []any
 		}{
 			{
 				name: "no elements with nil",
 			},
 			{
 				name:     "no elements",
-				elements: []interface{}{},
+				elements: []any{},
 			},
 			{
 				name:     "1 element",
-				elements: []interface{}{1},
+				elements: []any{1},
 			},
 			{
 				name:     "multiple elements",
-				elements: []interface{}{1, 2, 3},
+				elements: []any{1, 2, 3},
 			},
 		}
 
@@ -92,7 +92,7 @@ func TestCount(t *testing.T) {
 func TestDone(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		var count int32
-		Just(1, 2, 3).Walk(func(item interface{}, pipe chan<- interface{}) {
+		Just(1, 2, 3).Walk(func(item any, pipe chan<- any) {
 			time.Sleep(time.Millisecond * 100)
 			atomic.AddInt32(&count, int32(item.(int)))
 		}).Done()
@@ -103,7 +103,7 @@ func TestDone(t *testing.T) {
 func TestJust(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		var result int
-		Just(1, 2, 3, 4).Reduce(func(pipe <-chan interface{}) (interface{}, error) {
+		Just(1, 2, 3, 4).Reduce(func(pipe <-chan any) (any, error) {
 			for item := range pipe {
 				result += item.(int)
 			}
@@ -116,9 +116,9 @@ func TestJust(t *testing.T) {
 func TestDistinct(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		var result int
-		Just(4, 1, 3, 2, 3, 4).Distinct(func(item interface{}) interface{} {
+		Just(4, 1, 3, 2, 3, 4).Distinct(func(item any) any {
 			return item
-		}).Reduce(func(pipe <-chan interface{}) (interface{}, error) {
+		}).Reduce(func(pipe <-chan any) (any, error) {
 			for item := range pipe {
 				result += item.(int)
 			}
@@ -131,9 +131,9 @@ func TestDistinct(t *testing.T) {
 func TestFilter(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		var result int
-		Just(1, 2, 3, 4).Filter(func(item interface{}) bool {
+		Just(1, 2, 3, 4).Filter(func(item any) bool {
 			return item.(int)%2 == 0
-		}).Reduce(func(pipe <-chan interface{}) (interface{}, error) {
+		}).Reduce(func(pipe <-chan any) (any, error) {
 			for item := range pipe {
 				result += item.(int)
 			}
@@ -154,9 +154,9 @@ func TestFirst(t *testing.T) {
 func TestForAll(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		var result int
-		Just(1, 2, 3, 4).Filter(func(item interface{}) bool {
+		Just(1, 2, 3, 4).Filter(func(item any) bool {
 			return item.(int)%2 == 0
-		}).ForAll(func(pipe <-chan interface{}) {
+		}).ForAll(func(pipe <-chan any) {
 			for item := range pipe {
 				result += item.(int)
 			}
@@ -168,11 +168,11 @@ func TestForAll(t *testing.T) {
 func TestGroup(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		var groups [][]int
-		Just(10, 11, 20, 21).Group(func(item interface{}) interface{} {
+		Just(10, 11, 20, 21).Group(func(item any) any {
 			v := item.(int)
 			return v / 10
-		}).ForEach(func(item interface{}) {
-			v := item.([]interface{})
+		}).ForEach(func(item any) {
+			v := item.([]any)
 			var group []int
 			for _, each := range v {
 				group = append(group, each.(int))
@@ -191,7 +191,7 @@ func TestGroup(t *testing.T) {
 func TestHead(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		var result int
-		Just(1, 2, 3, 4).Head(2).Reduce(func(pipe <-chan interface{}) (interface{}, error) {
+		Just(1, 2, 3, 4).Head(2).Reduce(func(pipe <-chan any) (any, error) {
 			for item := range pipe {
 				result += item.(int)
 			}
@@ -204,7 +204,7 @@ func TestHead(t *testing.T) {
 func TestHeadZero(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		assert.Panics(t, func() {
-			Just(1, 2, 3, 4).Head(0).Reduce(func(pipe <-chan interface{}) (interface{}, error) {
+			Just(1, 2, 3, 4).Head(0).Reduce(func(pipe <-chan any) (any, error) {
 				return nil, nil
 			})
 		})
@@ -214,7 +214,7 @@ func TestHeadZero(t *testing.T) {
 func TestHeadMore(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		var result int
-		Just(1, 2, 3, 4).Head(6).Reduce(func(pipe <-chan interface{}) (interface{}, error) {
+		Just(1, 2, 3, 4).Head(6).Reduce(func(pipe <-chan any) (any, error) {
 			for item := range pipe {
 				result += item.(int)
 			}
@@ -245,14 +245,14 @@ func TestMap(t *testing.T) {
 			expect int
 		}{
 			{
-				mapper: func(item interface{}) interface{} {
+				mapper: func(item any) any {
 					v := item.(int)
 					return v * v
 				},
 				expect: 30,
 			},
 			{
-				mapper: func(item interface{}) interface{} {
+				mapper: func(item any) any {
 					v := item.(int)
 					if v%2 == 0 {
 						return 0
@@ -262,7 +262,7 @@ func TestMap(t *testing.T) {
 				expect: 10,
 			},
 			{
-				mapper: func(item interface{}) interface{} {
+				mapper: func(item any) any {
 					v := item.(int)
 					if v%2 == 0 {
 						panic(v)
@@ -283,12 +283,12 @@ func TestMap(t *testing.T) {
 				} else {
 					workers = runtime.NumCPU()
 				}
-				From(func(source chan<- interface{}) {
+				From(func(source chan<- any) {
 					for i := 1; i < 5; i++ {
 						source <- i
 					}
 				}).Map(test.mapper, WithWorkers(workers)).Reduce(
-					func(pipe <-chan interface{}) (interface{}, error) {
+					func(pipe <-chan any) (any, error) {
 						for item := range pipe {
 							result += item.(int)
 						}
@@ -303,8 +303,8 @@ func TestMap(t *testing.T) {
 
 func TestMerge(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
-		Just(1, 2, 3, 4).Merge().ForEach(func(item interface{}) {
-			assert.ElementsMatch(t, []interface{}{1, 2, 3, 4}, item.([]interface{}))
+		Just(1, 2, 3, 4).Merge().ForEach(func(item any) {
+			assert.ElementsMatch(t, []any{1, 2, 3, 4}, item.([]any))
 		})
 	})
 }
@@ -312,7 +312,7 @@ func TestMerge(t *testing.T) {
 func TestParallelJust(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		var count int32
-		Just(1, 2, 3).Parallel(func(item interface{}) {
+		Just(1, 2, 3).Parallel(func(item any) {
 			time.Sleep(time.Millisecond * 100)
 			atomic.AddInt32(&count, int32(item.(int)))
 		}, UnlimitedWorkers())
@@ -322,8 +322,8 @@ func TestParallelJust(t *testing.T) {
 
 func TestReverse(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
-		Just(1, 2, 3, 4).Reverse().Merge().ForEach(func(item interface{}) {
-			assert.ElementsMatch(t, []interface{}{4, 3, 2, 1}, item.([]interface{}))
+		Just(1, 2, 3, 4).Reverse().Merge().ForEach(func(item any) {
+			assert.ElementsMatch(t, []any{4, 3, 2, 1}, item.([]any))
 		})
 	})
 }
@@ -331,9 +331,9 @@ func TestReverse(t *testing.T) {
 func TestSort(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		var prev int
-		Just(5, 3, 7, 1, 9, 6, 4, 8, 2).Sort(func(a, b interface{}) bool {
+		Just(5, 3, 7, 1, 9, 6, 4, 8, 2).Sort(func(a, b any) bool {
 			return a.(int) < b.(int)
-		}).ForEach(func(item interface{}) {
+		}).ForEach(func(item any) {
 			next := item.(int)
 			assert.True(t, prev < next)
 			prev = next
@@ -346,12 +346,12 @@ func TestSplit(t *testing.T) {
 		assert.Panics(t, func() {
 			Just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).Split(0).Done()
 		})
-		var chunks [][]interface{}
-		Just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).Split(4).ForEach(func(item interface{}) {
-			chunk := item.([]interface{})
+		var chunks [][]any
+		Just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).Split(4).ForEach(func(item any) {
+			chunk := item.([]any)
 			chunks = append(chunks, chunk)
 		})
-		assert.EqualValues(t, [][]interface{}{
+		assert.EqualValues(t, [][]any{
 			{1, 2, 3, 4},
 			{5, 6, 7, 8},
 			{9, 10},
@@ -362,7 +362,7 @@ func TestSplit(t *testing.T) {
 func TestTail(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		var result int
-		Just(1, 2, 3, 4).Tail(2).Reduce(func(pipe <-chan interface{}) (interface{}, error) {
+		Just(1, 2, 3, 4).Tail(2).Reduce(func(pipe <-chan any) (any, error) {
 			for item := range pipe {
 				result += item.(int)
 			}
@@ -375,7 +375,7 @@ func TestTail(t *testing.T) {
 func TestTailZero(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		assert.Panics(t, func() {
-			Just(1, 2, 3, 4).Tail(0).Reduce(func(pipe <-chan interface{}) (interface{}, error) {
+			Just(1, 2, 3, 4).Tail(0).Reduce(func(pipe <-chan any) (any, error) {
 				return nil, nil
 			})
 		})
@@ -385,11 +385,11 @@ func TestTailZero(t *testing.T) {
 func TestWalk(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		var result int
-		Just(1, 2, 3, 4, 5).Walk(func(item interface{}, pipe chan<- interface{}) {
+		Just(1, 2, 3, 4, 5).Walk(func(item any, pipe chan<- any) {
 			if item.(int)%2 != 0 {
 				pipe <- item
 			}
-		}, UnlimitedWorkers()).ForEach(func(item interface{}) {
+		}, UnlimitedWorkers()).ForEach(func(item any) {
 			result += item.(int)
 		})
 		assert.Equal(t, 9, result)
@@ -398,16 +398,16 @@ func TestWalk(t *testing.T) {
 
 func TestStream_AnyMach(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
-		assetEqual(t, false, Just(1, 2, 3).AnyMach(func(item interface{}) bool {
+		assetEqual(t, false, Just(1, 2, 3).AnyMach(func(item any) bool {
 			return item.(int) == 4
 		}))
-		assetEqual(t, false, Just(1, 2, 3).AnyMach(func(item interface{}) bool {
+		assetEqual(t, false, Just(1, 2, 3).AnyMach(func(item any) bool {
 			return item.(int) == 0
 		}))
-		assetEqual(t, true, Just(1, 2, 3).AnyMach(func(item interface{}) bool {
+		assetEqual(t, true, Just(1, 2, 3).AnyMach(func(item any) bool {
 			return item.(int) == 2
 		}))
-		assetEqual(t, true, Just(1, 2, 3).AnyMach(func(item interface{}) bool {
+		assetEqual(t, true, Just(1, 2, 3).AnyMach(func(item any) bool {
 			return item.(int) == 2
 		}))
 	})
@@ -416,17 +416,17 @@ func TestStream_AnyMach(t *testing.T) {
 func TestStream_AllMach(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		assetEqual(
-			t, true, Just(1, 2, 3).AllMach(func(item interface{}) bool {
+			t, true, Just(1, 2, 3).AllMach(func(item any) bool {
 				return true
 			}),
 		)
 		assetEqual(
-			t, false, Just(1, 2, 3).AllMach(func(item interface{}) bool {
+			t, false, Just(1, 2, 3).AllMach(func(item any) bool {
 				return false
 			}),
 		)
 		assetEqual(
-			t, false, Just(1, 2, 3).AllMach(func(item interface{}) bool {
+			t, false, Just(1, 2, 3).AllMach(func(item any) bool {
 				return item.(int) == 1
 			}),
 		)
@@ -436,17 +436,17 @@ func TestStream_AllMach(t *testing.T) {
 func TestStream_NoneMatch(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		assetEqual(
-			t, true, Just(1, 2, 3).NoneMatch(func(item interface{}) bool {
+			t, true, Just(1, 2, 3).NoneMatch(func(item any) bool {
 				return false
 			}),
 		)
 		assetEqual(
-			t, false, Just(1, 2, 3).NoneMatch(func(item interface{}) bool {
+			t, false, Just(1, 2, 3).NoneMatch(func(item any) bool {
 				return true
 			}),
 		)
 		assetEqual(
-			t, true, Just(1, 2, 3).NoneMatch(func(item interface{}) bool {
+			t, true, Just(1, 2, 3).NoneMatch(func(item any) bool {
 				return item.(int) == 4
 			}),
 		)
@@ -455,19 +455,19 @@ func TestStream_NoneMatch(t *testing.T) {
 
 func TestConcat(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
-		a1 := []interface{}{1, 2, 3}
-		a2 := []interface{}{4, 5, 6}
+		a1 := []any{1, 2, 3}
+		a2 := []any{4, 5, 6}
 		s1 := Just(a1...)
 		s2 := Just(a2...)
 		stream := Concat(s1, s2)
-		var items []interface{}
+		var items []any
 		for item := range stream.source {
 			items = append(items, item)
 		}
 		sort.Slice(items, func(i, j int) bool {
 			return items[i].(int) < items[j].(int)
 		})
-		ints := make([]interface{}, 0)
+		ints := make([]any, 0)
 		ints = append(ints, a1...)
 		ints = append(ints, a2...)
 		assetEqual(t, ints, items)
@@ -479,7 +479,7 @@ func TestStream_Skip(t *testing.T) {
 		assetEqual(t, 3, Just(1, 2, 3, 4).Skip(1).Count())
 		assetEqual(t, 1, Just(1, 2, 3, 4).Skip(3).Count())
 		assetEqual(t, 4, Just(1, 2, 3, 4).Skip(0).Count())
-		equal(t, Just(1, 2, 3, 4).Skip(3), []interface{}{4})
+		equal(t, Just(1, 2, 3, 4).Skip(3), []any{4})
 		assert.Panics(t, func() {
 			Just(1, 2, 3, 4).Skip(-1)
 		})
@@ -489,27 +489,27 @@ func TestStream_Skip(t *testing.T) {
 func TestStream_Concat(t *testing.T) {
 	runCheckedTest(t, func(t *testing.T) {
 		stream := Just(1).Concat(Just(2), Just(3))
-		var items []interface{}
+		var items []any
 		for item := range stream.source {
 			items = append(items, item)
 		}
 		sort.Slice(items, func(i, j int) bool {
 			return items[i].(int) < items[j].(int)
 		})
-		assetEqual(t, []interface{}{1, 2, 3}, items)
+		assetEqual(t, []any{1, 2, 3}, items)
 
 		just := Just(1)
-		equal(t, just.Concat(just), []interface{}{1})
+		equal(t, just.Concat(just), []any{1})
 	})
 }
 
 func BenchmarkParallelMapReduce(b *testing.B) {
 	b.ReportAllocs()
 
-	mapper := func(v interface{}) interface{} {
+	mapper := func(v any) any {
 		return v.(int64) * v.(int64)
 	}
-	reducer := func(input <-chan interface{}) (interface{}, error) {
+	reducer := func(input <-chan any) (any, error) {
 		var result int64
 		for v := range input {
 			result += v.(int64)
@@ -517,7 +517,7 @@ func BenchmarkParallelMapReduce(b *testing.B) {
 		return result, nil
 	}
 	b.ResetTimer()
-	From(func(input chan<- interface{}) {
+	From(func(input chan<- any) {
 		b.RunParallel(func(pb *testing.PB) {
 			for pb.Next() {
 				input <- int64(rand.Int())
@@ -529,10 +529,10 @@ func BenchmarkParallelMapReduce(b *testing.B) {
 func BenchmarkMapReduce(b *testing.B) {
 	b.ReportAllocs()
 
-	mapper := func(v interface{}) interface{} {
+	mapper := func(v any) any {
 		return v.(int64) * v.(int64)
 	}
-	reducer := func(input <-chan interface{}) (interface{}, error) {
+	reducer := func(input <-chan any) (any, error) {
 		var result int64
 		for v := range input {
 			result += v.(int64)
@@ -540,21 +540,21 @@ func BenchmarkMapReduce(b *testing.B) {
 		return result, nil
 	}
 	b.ResetTimer()
-	From(func(input chan<- interface{}) {
+	From(func(input chan<- any) {
 		for i := 0; i < b.N; i++ {
 			input <- int64(rand.Int())
 		}
 	}).Map(mapper).Reduce(reducer)
 }
 
-func assetEqual(t *testing.T, except, data interface{}) {
+func assetEqual(t *testing.T, except, data any) {
 	if !reflect.DeepEqual(except, data) {
 		t.Errorf(" %v, want %v", data, except)
 	}
 }
 
-func equal(t *testing.T, stream Stream, data []interface{}) {
-	items := make([]interface{}, 0)
+func equal(t *testing.T, stream Stream, data []any) {
+	items := make([]any, 0)
 	for item := range stream.source {
 		items = append(items, item)
 	}

core/fx/timeout.go

@@ -29,7 +29,7 @@ func DoWithTimeout(fn func() error, timeout time.Duration, opts ...DoOption) err
 
 	// create channel with buffer size 1 to avoid goroutine leak
 	done := make(chan error, 1)
-	panicChan := make(chan interface{}, 1)
+	panicChan := make(chan any, 1)
 	go func() {
 		defer func() {
 			if p := recover(); p != nil {

core/hash/consistenthash.go

@@ -26,7 +26,7 @@ type (
 		hashFunc Func
 		replicas int
 		keys     []uint64
-		ring     map[uint64][]interface{}
+		ring     map[uint64][]any
 		nodes    map[string]lang.PlaceholderType
 		lock     sync.RWMutex
 	}
@@ -50,21 +50,21 @@ func NewCustomConsistentHash(replicas int, fn Func) *ConsistentHash {
 	return &ConsistentHash{
 		hashFunc: fn,
 		replicas: replicas,
-		ring:     make(map[uint64][]interface{}),
+		ring:     make(map[uint64][]any),
 		nodes:    make(map[string]lang.PlaceholderType),
 	}
 }
 
 // Add adds the node with the number of h.replicas,
 // the later call will overwrite the replicas of the former calls.
-func (h *ConsistentHash) Add(node interface{}) {
+func (h *ConsistentHash) Add(node any) {
 	h.AddWithReplicas(node, h.replicas)
 }
 
 // AddWithReplicas adds the node with the number of replicas,
 // replicas will be truncated to h.replicas if it's larger than h.replicas,
 // the later call will overwrite the replicas of the former calls.
-func (h *ConsistentHash) AddWithReplicas(node interface{}, replicas int) {
+func (h *ConsistentHash) AddWithReplicas(node any, replicas int) {
 	h.Remove(node)
 
 	if replicas > h.replicas {
@@ -89,7 +89,7 @@ func (h *ConsistentHash) AddWithReplicas(node interface{}, replicas int) {
 
 // AddWithWeight adds the node with weight, the weight can be 1 to 100, indicates the percent,
 // the later call will overwrite the replicas of the former calls.
-func (h *ConsistentHash) AddWithWeight(node interface{}, weight int) {
+func (h *ConsistentHash) AddWithWeight(node any, weight int) {
 	// don't need to make sure weight not larger than TopWeight,
 	// because AddWithReplicas makes sure replicas cannot be larger than h.replicas
 	replicas := h.replicas * weight / TopWeight
@@ -97,7 +97,7 @@ func (h *ConsistentHash) AddWithWeight(node interface{}, weight int) {
 }
 
 // Get returns the corresponding node from h base on the given v.
-func (h *ConsistentHash) Get(v interface{}) (interface{}, bool) {
+func (h *ConsistentHash) Get(v any) (any, bool) {
 	h.lock.RLock()
 	defer h.lock.RUnlock()
 
@@ -124,7 +124,7 @@ func (h *ConsistentHash) Get(v interface{}) (interface{}, bool) {
 }
 
 // Remove removes the given node from h.
-func (h *ConsistentHash) Remove(node interface{}) {
+func (h *ConsistentHash) Remove(node any) {
 	nodeRepr := repr(node)
 
 	h.lock.Lock()
@@ -177,10 +177,10 @@ func (h *ConsistentHash) removeNode(nodeRepr string) {
 	delete(h.nodes, nodeRepr)
 }
 
-func innerRepr(node interface{}) string {
+func innerRepr(node any) string {
 	return fmt.Sprintf("%d:%v", prime, node)
 }
 
-func repr(node interface{}) string {
+func repr(node any) string {
 	return lang.Repr(node)
 }

core/hash/consistenthash_test.go

@@ -42,7 +42,7 @@ func TestConsistentHash(t *testing.T) {
 		keys[key.(string)]++
 	}
 
-	mi := make(map[interface{}]int, len(keys))
+	mi := make(map[any]int, len(keys))
 	for k, v := range keys {
 		mi[k] = v
 	}

core/iox/bufferpool.go

@@ -16,7 +16,7 @@ func NewBufferPool(capability int) *BufferPool {
 	return &BufferPool{
 		capability: capability,
 		pool: &sync.Pool{
-			New: func() interface{} {
+			New: func() any {
 				return new(bytes.Buffer)
 			},
 		},

core/jsonx/json.go

@@ -9,12 +9,12 @@ import (
 )
 
 // Marshal marshals v into json bytes.
-func Marshal(v interface{}) ([]byte, error) {
+func Marshal(v any) ([]byte, error) {
 	return json.Marshal(v)
 }
 
 // MarshalToString marshals v into a string.
-func MarshalToString(v interface{}) (string, error) {
+func MarshalToString(v any) (string, error) {
 	data, err := Marshal(v)
 	if err != nil {
 		return "", err
@@ -24,7 +24,7 @@ func MarshalToString(v interface{}) (string, error) {
 }
 
 // Unmarshal unmarshals data bytes into v.
-func Unmarshal(data []byte, v interface{}) error {
+func Unmarshal(data []byte, v any) error {
 	decoder := json.NewDecoder(bytes.NewReader(data))
 	if err := unmarshalUseNumber(decoder, v); err != nil {
 		return formatError(string(data), err)
@@ -34,7 +34,7 @@ func Unmarshal(data []byte, v interface{}) error {
 }
 
 // UnmarshalFromString unmarshals v from str.
-func UnmarshalFromString(str string, v interface{}) error {
+func UnmarshalFromString(str string, v any) error {
 	decoder := json.NewDecoder(strings.NewReader(str))
 	if err := unmarshalUseNumber(decoder, v); err != nil {
 		return formatError(str, err)
@@ -44,7 +44,7 @@ func UnmarshalFromString(str string, v interface{}) error {
 }
 
 // UnmarshalFromReader unmarshals v from reader.
-func UnmarshalFromReader(reader io.Reader, v interface{}) error {
+func UnmarshalFromReader(reader io.Reader, v any) error {
 	var buf strings.Builder
 	teeReader := io.TeeReader(reader, &buf)
 	decoder := json.NewDecoder(teeReader)
@@ -55,7 +55,7 @@ func UnmarshalFromReader(reader io.Reader, v interface{}) error {
 	return nil
 }
 
-func unmarshalUseNumber(decoder *json.Decoder, v interface{}) error {
+func unmarshalUseNumber(decoder *json.Decoder, v any) error {
 	decoder.UseNumber()
 	return decoder.Decode(v)
 }

core/lang/lang.go

@@ -11,13 +11,13 @@ var Placeholder PlaceholderType
 
 type (
 	// AnyType can be used to hold any type.
-	AnyType = interface{}
+	AnyType = any
 	// PlaceholderType represents a placeholder type.
 	PlaceholderType = struct{}
 )
 
 // Repr returns the string representation of v.
-func Repr(v interface{}) string {
+func Repr(v any) string {
 	if v == nil {
 		return ""
 	}

core/lang/lang_test.go

@@ -23,7 +23,7 @@ func TestRepr(t *testing.T) {
 		u64 uint64  = 8
 	)
 	tests := []struct {
-		v      interface{}
+		v      any
 		expect string
 	}{
 		{

core/logc/logs.go

@@ -28,18 +28,18 @@ func Close() error {
 }
 
 // Error writes v into error log.
-func Error(ctx context.Context, v ...interface{}) {
+func Error(ctx context.Context, v ...any) {
 	getLogger(ctx).Error(v...)
 }
 
 // Errorf writes v with format into error log.
-func Errorf(ctx context.Context, format string, v ...interface{}) {
+func Errorf(ctx context.Context, format string, v ...any) {
 	getLogger(ctx).Errorf(fmt.Errorf(format, v...).Error())
 }
 
 // Errorv writes v into error log with json content.
 // No call stack attached, because not elegant to pack the messages.
-func Errorv(ctx context.Context, v interface{}) {
+func Errorv(ctx context.Context, v any) {
 	getLogger(ctx).Errorv(v)
 }
 
@@ -49,22 +49,22 @@ func Errorw(ctx context.Context, msg string, fields ...LogField) {
 }
 
 // Field returns a LogField for the given key and value.
-func Field(key string, value interface{}) LogField {
+func Field(key string, value any) LogField {
 	return logx.Field(key, value)
 }
 
 // Info writes v into access log.
-func Info(ctx context.Context, v ...interface{}) {
+func Info(ctx context.Context, v ...any) {
 	getLogger(ctx).Info(v...)
 }
 
 // Infof writes v with format into access log.
-func Infof(ctx context.Context, format string, v ...interface{}) {
+func Infof(ctx context.Context, format string, v ...any) {
 	getLogger(ctx).Infof(format, v...)
 }
 
 // Infov writes v into access log with json content.
-func Infov(ctx context.Context, v interface{}) {
+func Infov(ctx context.Context, v any) {
 	getLogger(ctx).Infov(v)
 }
 
@@ -97,17 +97,17 @@ func SetUp(c LogConf) error {
 }
 
 // Slow writes v into slow log.
-func Slow(ctx context.Context, v ...interface{}) {
+func Slow(ctx context.Context, v ...any) {
 	getLogger(ctx).Slow(v...)
 }
 
 // Slowf writes v with format into slow log.
-func Slowf(ctx context.Context, format string, v ...interface{}) {
+func Slowf(ctx context.Context, format string, v ...any) {
 	getLogger(ctx).Slowf(format, v...)
 }
 
 // Slowv writes v into slow log with json content.
-func Slowv(ctx context.Context, v interface{}) {
+func Slowv(ctx context.Context, v any) {
 	getLogger(ctx).Slowv(v)
 }
 

core/logc/logs_test.go

@@ -26,7 +26,7 @@ func TestAddGlobalFields(t *testing.T) {
 	AddGlobalFields(Field("a", "1"), Field("b", "2"))
 	AddGlobalFields(Field("c", "3"))
 	Info(context.Background(), "world")
-	var m map[string]interface{}
+	var m map[string]any
 	assert.NoError(t, json.Unmarshal(buf.Bytes(), &m))
 	assert.Equal(t, "1", m["a"])
 	assert.Equal(t, "2", m["b"])

core/logx/fields_test.go

@@ -25,7 +25,7 @@ func TestAddGlobalFields(t *testing.T) {
 	AddGlobalFields(Field("a", "1"), Field("b", "2"))
 	AddGlobalFields(Field("c", "3"))
 	Info("world")
-	var m map[string]interface{}
+	var m map[string]any
 	assert.NoError(t, json.Unmarshal(buf.Bytes(), &m))
 	assert.Equal(t, "1", m["a"])
 	assert.Equal(t, "2", m["b"])

core/logx/lesslogger.go

@@ -13,14 +13,14 @@ func NewLessLogger(milliseconds int) *LessLogger {
 }
 
 // Error logs v into error log or discard it if more than once in the given duration.
-func (logger *LessLogger) Error(v ...interface{}) {
+func (logger *LessLogger) Error(v ...any) {
 	logger.logOrDiscard(func() {
 		Error(v...)
 	})
 }
 
 // Errorf logs v with format into error log or discard it if more than once in the given duration.
-func (logger *LessLogger) Errorf(format string, v ...interface{}) {
+func (logger *LessLogger) Errorf(format string, v ...any) {
 	logger.logOrDiscard(func() {
 		Errorf(format, v...)
 	})

core/logx/logger.go

@@ -8,35 +8,35 @@ import (
 // A Logger represents a logger.
 type Logger interface {
 	// Debug logs a message at info level.
-	Debug(...interface{})
+	Debug(...any)
 	// Debugf logs a message at info level.
-	Debugf(string, ...interface{})
+	Debugf(string, ...any)
 	// Debugv logs a message at info level.
-	Debugv(interface{})
+	Debugv(any)
 	// Debugw logs a message at info level.
 	Debugw(string, ...LogField)
 	// Error logs a message at error level.
-	Error(...interface{})
+	Error(...any)
 	// Errorf logs a message at error level.
-	Errorf(string, ...interface{})
+	Errorf(string, ...any)
 	// Errorv logs a message at error level.
-	Errorv(interface{})
+	Errorv(any)
 	// Errorw logs a message at error level.
 	Errorw(string, ...LogField)
 	// Info logs a message at info level.
-	Info(...interface{})
+	Info(...any)
 	// Infof logs a message at info level.
-	Infof(string, ...interface{})
+	Infof(string, ...any)
 	// Infov logs a message at info level.
-	Infov(interface{})
+	Infov(any)
 	// Infow logs a message at info level.
 	Infow(string, ...LogField)
 	// Slow logs a message at slow level.
-	Slow(...interface{})
+	Slow(...any)
 	// Slowf logs a message at slow level.
-	Slowf(string, ...interface{})
+	Slowf(string, ...any)
 	// Slowv logs a message at slow level.
-	Slowv(interface{})
+	Slowv(any)
 	// Sloww logs a message at slow level.
 	Sloww(string, ...LogField)
 	// WithCallerSkip returns a new logger with the given caller skip.

core/logx/logs.go

@@ -34,13 +34,13 @@ type (
 	// LogField is a key-value pair that will be added to the log entry.
 	LogField struct {
 		Key   string
-		Value interface{}
+		Value any
 	}
 
 	// LogOption defines the method to customize the logging.
 	LogOption func(options *logOptions)
 
-	logEntry map[string]interface{}
+	logEntry map[string]any
 
 	logOptions struct {
 		gzipEnabled           bool
@@ -67,17 +67,17 @@ func Close() error {
 }
 
 // Debug writes v into access log.
-func Debug(v ...interface{}) {
+func Debug(v ...any) {
 	writeDebug(fmt.Sprint(v...))
 }
 
 // Debugf writes v with format into access log.
-func Debugf(format string, v ...interface{}) {
+func Debugf(format string, v ...any) {
 	writeDebug(fmt.Sprintf(format, v...))
 }
 
 // Debugv writes v into access log with json content.
-func Debugv(v interface{}) {
+func Debugv(v any) {
 	writeDebug(v)
 }
 
@@ -98,30 +98,30 @@ func DisableStat() {
 }
 
 // Error writes v into error log.
-func Error(v ...interface{}) {
+func Error(v ...any) {
 	writeError(fmt.Sprint(v...))
 }
 
 // Errorf writes v with format into error log.
-func Errorf(format string, v ...interface{}) {
+func Errorf(format string, v ...any) {
 	writeError(fmt.Errorf(format, v...).Error())
 }
 
 // ErrorStack writes v along with call stack into error log.
-func ErrorStack(v ...interface{}) {
+func ErrorStack(v ...any) {
 	// there is newline in stack string
 	writeStack(fmt.Sprint(v...))
 }
 
 // ErrorStackf writes v along with call stack in format into error log.
-func ErrorStackf(format string, v ...interface{}) {
+func ErrorStackf(format string, v ...any) {
 	// there is newline in stack string
 	writeStack(fmt.Sprintf(format, v...))
 }
 
 // Errorv writes v into error log with json content.
 // No call stack attached, because not elegant to pack the messages.
-func Errorv(v interface{}) {
+func Errorv(v any) {
 	writeError(v)
 }
 
@@ -131,7 +131,7 @@ func Errorw(msg string, fields ...LogField) {
 }
 
 // Field returns a LogField for the given key and value.
-func Field(key string, value interface{}) LogField {
+func Field(key string, value any) LogField {
 	switch val := value.(type) {
 	case error:
 		return LogField{Key: key, Value: val.Error()}
@@ -169,17 +169,17 @@ func Field(key string, value interface{}) LogField {
 }
 
 // Info writes v into access log.
-func Info(v ...interface{}) {
+func Info(v ...any) {
 	writeInfo(fmt.Sprint(v...))
 }
 
 // Infof writes v with format into access log.
-func Infof(format string, v ...interface{}) {
+func Infof(format string, v ...any) {
 	writeInfo(fmt.Sprintf(format, v...))
 }
 
 // Infov writes v into access log with json content.
-func Infov(v interface{}) {
+func Infov(v any) {
 	writeInfo(v)
 }
 
@@ -263,27 +263,27 @@ func SetUp(c LogConf) (err error) {
 }
 
 // Severe writes v into severe log.
-func Severe(v ...interface{}) {
+func Severe(v ...any) {
 	writeSevere(fmt.Sprint(v...))
 }
 
 // Severef writes v with format into severe log.
-func Severef(format string, v ...interface{}) {
+func Severef(format string, v ...any) {
 	writeSevere(fmt.Sprintf(format, v...))
 }
 
 // Slow writes v into slow log.
-func Slow(v ...interface{}) {
+func Slow(v ...any) {
 	writeSlow(fmt.Sprint(v...))
 }
 
 // Slowf writes v with format into slow log.
-func Slowf(format string, v ...interface{}) {
+func Slowf(format string, v ...any) {
 	writeSlow(fmt.Sprintf(format, v...))
 }
 
 // Slowv writes v into slow log with json content.
-func Slowv(v interface{}) {
+func Slowv(v any) {
 	writeSlow(v)
 }
 
@@ -293,12 +293,12 @@ func Sloww(msg string, fields ...LogField) {
 }
 
 // Stat writes v into stat log.
-func Stat(v ...interface{}) {
+func Stat(v ...any) {
 	writeStat(fmt.Sprint(v...))
 }
 
 // Statf writes v with format into stat log.
-func Statf(format string, v ...interface{}) {
+func Statf(format string, v ...any) {
 	writeStat(fmt.Sprintf(format, v...))
 }
 
@@ -422,19 +422,19 @@ func shallLogStat() bool {
 	return atomic.LoadUint32(&disableStat) == 0
 }
 
-func writeDebug(val interface{}, fields ...LogField) {
+func writeDebug(val any, fields ...LogField) {
 	if shallLog(DebugLevel) {
 		getWriter().Debug(val, addCaller(fields...)...)
 	}
 }
 
-func writeError(val interface{}, fields ...LogField) {
+func writeError(val any, fields ...LogField) {
 	if shallLog(ErrorLevel) {
 		getWriter().Error(val, addCaller(fields...)...)
 	}
 }
 
-func writeInfo(val interface{}, fields ...LogField) {
+func writeInfo(val any, fields ...LogField) {
 	if shallLog(InfoLevel) {
 		getWriter().Info(val, addCaller(fields...)...)
 	}
@@ -446,7 +446,7 @@ func writeSevere(msg string) {
 	}
 }
 
-func writeSlow(val interface{}, fields ...LogField) {
+func writeSlow(val any, fields ...LogField) {
 	if shallLog(ErrorLevel) {
 		getWriter().Slow(val, addCaller(fields...)...)
 	}

core/logx/logs_test.go

@@ -29,49 +29,49 @@ type mockWriter struct {
 	builder strings.Builder
 }
 
-func (mw *mockWriter) Alert(v interface{}) {
+func (mw *mockWriter) Alert(v any) {
 	mw.lock.Lock()
 	defer mw.lock.Unlock()
 	output(&mw.builder, levelAlert, v)
 }
 
-func (mw *mockWriter) Debug(v interface{}, fields ...LogField) {
+func (mw *mockWriter) Debug(v any, fields ...LogField) {
 	mw.lock.Lock()
 	defer mw.lock.Unlock()
 	output(&mw.builder, levelDebug, v, fields...)
 }
 
-func (mw *mockWriter) Error(v interface{}, fields ...LogField) {
+func (mw *mockWriter) Error(v any, fields ...LogField) {
 	mw.lock.Lock()
 	defer mw.lock.Unlock()
 	output(&mw.builder, levelError, v, fields...)
 }
 
-func (mw *mockWriter) Info(v interface{}, fields ...LogField) {
+func (mw *mockWriter) Info(v any, fields ...LogField) {
 	mw.lock.Lock()
 	defer mw.lock.Unlock()
 	output(&mw.builder, levelInfo, v, fields...)
 }
 
-func (mw *mockWriter) Severe(v interface{}) {
+func (mw *mockWriter) Severe(v any) {
 	mw.lock.Lock()
 	defer mw.lock.Unlock()
 	output(&mw.builder, levelSevere, v)
 }
 
-func (mw *mockWriter) Slow(v interface{}, fields ...LogField) {
+func (mw *mockWriter) Slow(v any, fields ...LogField) {
 	mw.lock.Lock()
 	defer mw.lock.Unlock()
 	output(&mw.builder, levelSlow, v, fields...)
 }
 
-func (mw *mockWriter) Stack(v interface{}) {
+func (mw *mockWriter) Stack(v any) {
 	mw.lock.Lock()
 	defer mw.lock.Unlock()
 	output(&mw.builder, levelError, v)
 }
 
-func (mw *mockWriter) Stat(v interface{}, fields ...LogField) {
+func (mw *mockWriter) Stat(v any, fields ...LogField) {
 	mw.lock.Lock()
 	defer mw.lock.Unlock()
 	output(&mw.builder, levelStat, v, fields...)
@@ -103,41 +103,41 @@ func TestField(t *testing.T) {
 	tests := []struct {
 		name string
 		f    LogField
-		want map[string]interface{}
+		want map[string]any
 	}{
 		{
 			name: "error",
 			f:    Field("foo", errors.New("bar")),
-			want: map[string]interface{}{
+			want: map[string]any{
 				"foo": "bar",
 			},
 		},
 		{
 			name: "errors",
 			f:    Field("foo", []error{errors.New("bar"), errors.New("baz")}),
-			want: map[string]interface{}{
-				"foo": []interface{}{"bar", "baz"},
+			want: map[string]any{
+				"foo": []any{"bar", "baz"},
 			},
 		},
 		{
 			name: "strings",
 			f:    Field("foo", []string{"bar", "baz"}),
-			want: map[string]interface{}{
-				"foo": []interface{}{"bar", "baz"},
+			want: map[string]any{
+				"foo": []any{"bar", "baz"},
 			},
 		},
 		{
 			name: "duration",
 			f:    Field("foo", time.Second),
-			want: map[string]interface{}{
+			want: map[string]any{
 				"foo": "1s",
 			},
 		},
 		{
 			name: "durations",
 			f:    Field("foo", []time.Duration{time.Second, 2 * time.Second}),
-			want: map[string]interface{}{
-				"foo": []interface{}{"1s", "2s"},
+			want: map[string]any{
+				"foo": []any{"1s", "2s"},
 			},
 		},
 		{
@@ -146,22 +146,22 @@ func TestField(t *testing.T) {
 				time.Date(2020, time.January, 1, 0, 0, 0, 0, time.UTC),
 				time.Date(2020, time.January, 2, 0, 0, 0, 0, time.UTC),
 			}),
-			want: map[string]interface{}{
-				"foo": []interface{}{"2020-01-01 00:00:00 +0000 UTC", "2020-01-02 00:00:00 +0000 UTC"},
+			want: map[string]any{
+				"foo": []any{"2020-01-01 00:00:00 +0000 UTC", "2020-01-02 00:00:00 +0000 UTC"},
 			},
 		},
 		{
 			name: "stringer",
 			f:    Field("foo", ValStringer{val: "bar"}),
-			want: map[string]interface{}{
+			want: map[string]any{
 				"foo": "bar",
 			},
 		},
 		{
 			name: "stringers",
 			f:    Field("foo", []fmt.Stringer{ValStringer{val: "bar"}, ValStringer{val: "baz"}}),
-			want: map[string]interface{}{
-				"foo": []interface{}{"bar", "baz"},
+			want: map[string]any{
+				"foo": []any{"bar", "baz"},
 			},
 		},
 	}
@@ -213,7 +213,7 @@ func TestStructedLogAlert(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelAlert, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelAlert, w, func(v ...any) {
 		Alert(fmt.Sprint(v...))
 	})
 }
@@ -223,7 +223,7 @@ func TestStructedLogDebug(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelDebug, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelDebug, w, func(v ...any) {
 		Debug(v...)
 	})
 }
@@ -233,7 +233,7 @@ func TestStructedLogDebugf(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelDebug, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelDebug, w, func(v ...any) {
 		Debugf(fmt.Sprint(v...))
 	})
 }
@@ -243,7 +243,7 @@ func TestStructedLogDebugv(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelDebug, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelDebug, w, func(v ...any) {
 		Debugv(fmt.Sprint(v...))
 	})
 }
@@ -253,7 +253,7 @@ func TestStructedLogDebugw(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelDebug, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelDebug, w, func(v ...any) {
 		Debugw(fmt.Sprint(v...), Field("foo", time.Second))
 	})
 }
@@ -263,7 +263,7 @@ func TestStructedLogError(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelError, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelError, w, func(v ...any) {
 		Error(v...)
 	})
 }
@@ -273,7 +273,7 @@ func TestStructedLogErrorf(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelError, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelError, w, func(v ...any) {
 		Errorf("%s", fmt.Sprint(v...))
 	})
 }
@@ -283,7 +283,7 @@ func TestStructedLogErrorv(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelError, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelError, w, func(v ...any) {
 		Errorv(fmt.Sprint(v...))
 	})
 }
@@ -293,7 +293,7 @@ func TestStructedLogErrorw(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelError, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelError, w, func(v ...any) {
 		Errorw(fmt.Sprint(v...), Field("foo", "bar"))
 	})
 }
@@ -303,7 +303,7 @@ func TestStructedLogInfo(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelInfo, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelInfo, w, func(v ...any) {
 		Info(v...)
 	})
 }
@@ -313,7 +313,7 @@ func TestStructedLogInfof(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelInfo, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelInfo, w, func(v ...any) {
 		Infof("%s", fmt.Sprint(v...))
 	})
 }
@@ -323,7 +323,7 @@ func TestStructedLogInfov(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelInfo, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelInfo, w, func(v ...any) {
 		Infov(fmt.Sprint(v...))
 	})
 }
@@ -333,7 +333,7 @@ func TestStructedLogInfow(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelInfo, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelInfo, w, func(v ...any) {
 		Infow(fmt.Sprint(v...), Field("foo", "bar"))
 	})
 }
@@ -343,7 +343,7 @@ func TestStructedLogInfoConsoleAny(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLogConsole(t, w, func(v ...interface{}) {
+	doTestStructedLogConsole(t, w, func(v ...any) {
 		old := atomic.LoadUint32(&encoding)
 		atomic.StoreUint32(&encoding, plainEncodingType)
 		defer func() {
@@ -359,7 +359,7 @@ func TestStructedLogInfoConsoleAnyString(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLogConsole(t, w, func(v ...interface{}) {
+	doTestStructedLogConsole(t, w, func(v ...any) {
 		old := atomic.LoadUint32(&encoding)
 		atomic.StoreUint32(&encoding, plainEncodingType)
 		defer func() {
@@ -375,7 +375,7 @@ func TestStructedLogInfoConsoleAnyError(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLogConsole(t, w, func(v ...interface{}) {
+	doTestStructedLogConsole(t, w, func(v ...any) {
 		old := atomic.LoadUint32(&encoding)
 		atomic.StoreUint32(&encoding, plainEncodingType)
 		defer func() {
@@ -391,7 +391,7 @@ func TestStructedLogInfoConsoleAnyStringer(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLogConsole(t, w, func(v ...interface{}) {
+	doTestStructedLogConsole(t, w, func(v ...any) {
 		old := atomic.LoadUint32(&encoding)
 		atomic.StoreUint32(&encoding, plainEncodingType)
 		defer func() {
@@ -409,7 +409,7 @@ func TestStructedLogInfoConsoleText(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLogConsole(t, w, func(v ...interface{}) {
+	doTestStructedLogConsole(t, w, func(v ...any) {
 		old := atomic.LoadUint32(&encoding)
 		atomic.StoreUint32(&encoding, plainEncodingType)
 		defer func() {
@@ -425,7 +425,7 @@ func TestStructedLogSlow(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelSlow, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelSlow, w, func(v ...any) {
 		Slow(v...)
 	})
 }
@@ -435,7 +435,7 @@ func TestStructedLogSlowf(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelSlow, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelSlow, w, func(v ...any) {
 		Slowf(fmt.Sprint(v...))
 	})
 }
@@ -445,7 +445,7 @@ func TestStructedLogSlowv(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelSlow, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelSlow, w, func(v ...any) {
 		Slowv(fmt.Sprint(v...))
 	})
 }
@@ -455,7 +455,7 @@ func TestStructedLogSloww(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelSlow, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelSlow, w, func(v ...any) {
 		Sloww(fmt.Sprint(v...), Field("foo", time.Second))
 	})
 }
@@ -465,7 +465,7 @@ func TestStructedLogStat(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelStat, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelStat, w, func(v ...any) {
 		Stat(v...)
 	})
 }
@@ -475,7 +475,7 @@ func TestStructedLogStatf(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelStat, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelStat, w, func(v ...any) {
 		Statf(fmt.Sprint(v...))
 	})
 }
@@ -485,7 +485,7 @@ func TestStructedLogSevere(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelSevere, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelSevere, w, func(v ...any) {
 		Severe(v...)
 	})
 }
@@ -495,7 +495,7 @@ func TestStructedLogSeveref(t *testing.T) {
 	old := writer.Swap(w)
 	defer writer.Store(old)
 
-	doTestStructedLog(t, levelSevere, w, func(v ...interface{}) {
+	doTestStructedLog(t, levelSevere, w, func(v ...any) {
 		Severef(fmt.Sprint(v...))
 	})
 }
@@ -507,7 +507,7 @@ func TestStructedLogWithDuration(t *testing.T) {
 	defer writer.Store(old)
 
 	WithDuration(time.Second).Info(message)
-	var entry map[string]interface{}
+	var entry map[string]any
 	if err := json.Unmarshal([]byte(w.String()), &entry); err != nil {
 		t.Error(err)
 	}
@@ -767,11 +767,11 @@ func put(b []byte) {
 	}
 }
 
-func doTestStructedLog(t *testing.T, level string, w *mockWriter, write func(...interface{})) {
+func doTestStructedLog(t *testing.T, level string, w *mockWriter, write func(...any)) {
 	const message = "hello there"
 	write(message)
 
-	var entry map[string]interface{}
+	var entry map[string]any
 	if err := json.Unmarshal([]byte(w.String()), &entry); err != nil {
 		t.Error(err)
 	}
@@ -782,7 +782,7 @@ func doTestStructedLog(t *testing.T, level string, w *mockWriter, write func(...
 	assert.True(t, strings.Contains(val.(string), message))
 }
 
-func doTestStructedLogConsole(t *testing.T, w *mockWriter, write func(...interface{})) {
+func doTestStructedLogConsole(t *testing.T, w *mockWriter, write func(...any)) {
 	const message = "hello there"
 	write(message)
 	assert.True(t, strings.Contains(w.String(), message))
@@ -822,8 +822,8 @@ func (v ValStringer) String() string {
 	return v.val
 }
 
-func validateFields(t *testing.T, content string, fields map[string]interface{}) {
-	var m map[string]interface{}
+func validateFields(t *testing.T, content string, fields map[string]any) {
+	var m map[string]any
 	if err := json.Unmarshal([]byte(content), &m); err != nil {
 		t.Error(err)
 	}

core/logx/readme-cn.md

@@ -52,27 +52,27 @@ type LogConf struct {
 ```go
 type Logger interface {
 	// Error logs a message at error level.
-	Error(...interface{})
+	Error(...any)
 	// Errorf logs a message at error level.
-	Errorf(string, ...interface{})
+	Errorf(string, ...any)
 	// Errorv logs a message at error level.
-	Errorv(interface{})
+	Errorv(any)
 	// Errorw logs a message at error level.
 	Errorw(string, ...LogField)
 	// Info logs a message at info level.
-	Info(...interface{})
+	Info(...any)
 	// Infof logs a message at info level.
-	Infof(string, ...interface{})
+	Infof(string, ...any)
 	// Infov logs a message at info level.
-	Infov(interface{})
+	Infov(any)
 	// Infow logs a message at info level.
 	Infow(string, ...LogField)
 	// Slow logs a message at slow level.
-	Slow(...interface{})
+	Slow(...any)
 	// Slowf logs a message at slow level.
-	Slowf(string, ...interface{})
+	Slowf(string, ...any)
 	// Slowv logs a message at slow level.
-	Slowv(interface{})
+	Slowv(any)
 	// Sloww logs a message at slow level.
 	Sloww(string, ...LogField)
 	// WithContext returns a new logger with the given context.
@@ -165,7 +165,7 @@ func NewSensitiveLogger(writer logx.Writer) *SensitiveLogger {
 	}
 }
 
-func (l *SensitiveLogger) Info(msg interface{}, fields ...logx.LogField) {
+func (l *SensitiveLogger) Info(msg any, fields ...logx.LogField) {
 	if m, ok := msg.(Message); ok {
 		l.Writer.Info(Message{
 			Name:     m.Name,

core/logx/readme.md

@@ -51,27 +51,27 @@ type LogConf struct {
 ```go
 type Logger interface {
 	// Error logs a message at error level.
-	Error(...interface{})
+	Error(...any)
 	// Errorf logs a message at error level.
-	Errorf(string, ...interface{})
+	Errorf(string, ...any)
 	// Errorv logs a message at error level.
-	Errorv(interface{})
+	Errorv(any)
 	// Errorw logs a message at error level.
 	Errorw(string, ...LogField)
 	// Info logs a message at info level.
-	Info(...interface{})
+	Info(...any)
 	// Infof logs a message at info level.
-	Infof(string, ...interface{})
+	Infof(string, ...any)
 	// Infov logs a message at info level.
-	Infov(interface{})
+	Infov(any)
 	// Infow logs a message at info level.
 	Infow(string, ...LogField)
 	// Slow logs a message at slow level.
-	Slow(...interface{})
+	Slow(...any)
 	// Slowf logs a message at slow level.
-	Slowf(string, ...interface{})
+	Slowf(string, ...any)
 	// Slowv logs a message at slow level.
-	Slowv(interface{})
+	Slowv(any)
 	// Sloww logs a message at slow level.
 	Sloww(string, ...LogField)
 	// WithContext returns a new logger with the given context.
@@ -164,7 +164,7 @@ func NewSensitiveLogger(writer logx.Writer) *SensitiveLogger {
 	}
 }
 
-func (l *SensitiveLogger) Info(msg interface{}, fields ...logx.LogField) {
+func (l *SensitiveLogger) Info(msg any, fields ...logx.LogField) {
 	if m, ok := msg.(Message); ok {
 		l.Writer.Info(Message{
 			Name:     m.Name,

core/logx/richlogger.go

@@ -40,15 +40,15 @@ type richLogger struct {
 	fields     []LogField
 }
 
-func (l *richLogger) Debug(v ...interface{}) {
+func (l *richLogger) Debug(v ...any) {
 	l.debug(fmt.Sprint(v...))
 }
 
-func (l *richLogger) Debugf(format string, v ...interface{}) {
+func (l *richLogger) Debugf(format string, v ...any) {
 	l.debug(fmt.Sprintf(format, v...))
 }
 
-func (l *richLogger) Debugv(v interface{}) {
+func (l *richLogger) Debugv(v any) {
 	l.debug(v)
 }
 
@@ -56,15 +56,15 @@ func (l *richLogger) Debugw(msg string, fields ...LogField) {
 	l.debug(msg, fields...)
 }
 
-func (l *richLogger) Error(v ...interface{}) {
+func (l *richLogger) Error(v ...any) {
 	l.err(fmt.Sprint(v...))
 }
 
-func (l *richLogger) Errorf(format string, v ...interface{}) {
+func (l *richLogger) Errorf(format string, v ...any) {
 	l.err(fmt.Sprintf(format, v...))
 }
 
-func (l *richLogger) Errorv(v interface{}) {
+func (l *richLogger) Errorv(v any) {
 	l.err(fmt.Sprint(v))
 }
 
@@ -72,15 +72,15 @@ func (l *richLogger) Errorw(msg string, fields ...LogField) {
 	l.err(msg, fields...)
 }
 
-func (l *richLogger) Info(v ...interface{}) {
+func (l *richLogger) Info(v ...any) {
 	l.info(fmt.Sprint(v...))
 }
 
-func (l *richLogger) Infof(format string, v ...interface{}) {
+func (l *richLogger) Infof(format string, v ...any) {
 	l.info(fmt.Sprintf(format, v...))
 }
 
-func (l *richLogger) Infov(v interface{}) {
+func (l *richLogger) Infov(v any) {
 	l.info(v)
 }
 
@@ -88,15 +88,15 @@ func (l *richLogger) Infow(msg string, fields ...LogField) {
 	l.info(msg, fields...)
 }
 
-func (l *richLogger) Slow(v ...interface{}) {
+func (l *richLogger) Slow(v ...any) {
 	l.slow(fmt.Sprint(v...))
 }
 
-func (l *richLogger) Slowf(format string, v ...interface{}) {
+func (l *richLogger) Slowf(format string, v ...any) {
 	l.slow(fmt.Sprintf(format, v...))
 }
 
-func (l *richLogger) Slowv(v interface{}) {
+func (l *richLogger) Slowv(v any) {
 	l.slow(v)
 }
 
@@ -156,25 +156,25 @@ func (l *richLogger) buildFields(fields ...LogField) []LogField {
 	return fields
 }
 
-func (l *richLogger) debug(v interface{}, fields ...LogField) {
+func (l *richLogger) debug(v any, fields ...LogField) {
 	if shallLog(DebugLevel) {
 		getWriter().Debug(v, l.buildFields(fields...)...)
 	}
 }
 
-func (l *richLogger) err(v interface{}, fields ...LogField) {
+func (l *richLogger) err(v any, fields ...LogField) {
 	if shallLog(ErrorLevel) {
 		getWriter().Error(v, l.buildFields(fields...)...)
 	}
 }
 
-func (l *richLogger) info(v interface{}, fields ...LogField) {
+func (l *richLogger) info(v any, fields ...LogField) {
 	if shallLog(InfoLevel) {
 		getWriter().Info(v, l.buildFields(fields...)...)
 	}
 }
 
-func (l *richLogger) slow(v interface{}, fields ...LogField) {
+func (l *richLogger) slow(v any, fields ...LogField) {
 	if shallLog(ErrorLevel) {
 		getWriter().Slow(v, l.buildFields(fields...)...)
 	}

core/logx/syslog_test.go

@@ -42,7 +42,7 @@ func captureOutput(f func()) string {
 }
 
 func getContent(jsonStr string) string {
-	var entry map[string]interface{}
+	var entry map[string]any
 	json.Unmarshal([]byte(jsonStr), &entry)
 
 	val, ok := entry[contentKey]

core/logx/writer.go

@@ -16,15 +16,15 @@ import (
 
 type (
 	Writer interface {
-		Alert(v interface{})
+		Alert(v any)
 		Close() error
-		Debug(v interface{}, fields ...LogField)
-		Error(v interface{}, fields ...LogField)
-		Info(v interface{}, fields ...LogField)
-		Severe(v interface{})
-		Slow(v interface{}, fields ...LogField)
-		Stack(v interface{})
-		Stat(v interface{}, fields ...LogField)
+		Debug(v any, fields ...LogField)
+		Error(v any, fields ...LogField)
+		Info(v any, fields ...LogField)
+		Severe(v any)
+		Slow(v any, fields ...LogField)
+		Stack(v any)
+		Stat(v any, fields ...LogField)
 	}
 
 	atomicWriter struct {
@@ -171,7 +171,7 @@ func newFileWriter(c LogConf) (Writer, error) {
 	}, nil
 }
 
-func (w *concreteWriter) Alert(v interface{}) {
+func (w *concreteWriter) Alert(v any) {
 	output(w.errorLog, levelAlert, v)
 }
 
@@ -195,69 +195,69 @@ func (w *concreteWriter) Close() error {
 	return w.statLog.Close()
 }
 
-func (w *concreteWriter) Debug(v interface{}, fields ...LogField) {
+func (w *concreteWriter) Debug(v any, fields ...LogField) {
 	output(w.infoLog, levelDebug, v, fields...)
 }
 
-func (w *concreteWriter) Error(v interface{}, fields ...LogField) {
+func (w *concreteWriter) Error(v any, fields ...LogField) {
 	output(w.errorLog, levelError, v, fields...)
 }
 
-func (w *concreteWriter) Info(v interface{}, fields ...LogField) {
+func (w *concreteWriter) Info(v any, fields ...LogField) {
 	output(w.infoLog, levelInfo, v, fields...)
 }
 
-func (w *concreteWriter) Severe(v interface{}) {
+func (w *concreteWriter) Severe(v any) {
 	output(w.severeLog, levelFatal, v)
 }
 
-func (w *concreteWriter) Slow(v interface{}, fields ...LogField) {
+func (w *concreteWriter) Slow(v any, fields ...LogField) {
 	output(w.slowLog, levelSlow, v, fields...)
 }
 
-func (w *concreteWriter) Stack(v interface{}) {
+func (w *concreteWriter) Stack(v any) {
 	output(w.stackLog, levelError, v)
 }
 
-func (w *concreteWriter) Stat(v interface{}, fields ...LogField) {
+func (w *concreteWriter) Stat(v any, fields ...LogField) {
 	output(w.statLog, levelStat, v, fields...)
 }
 
 type nopWriter struct{}
 
-func (n nopWriter) Alert(_ interface{}) {
+func (n nopWriter) Alert(_ any) {
 }
 
 func (n nopWriter) Close() error {
 	return nil
 }
 
-func (n nopWriter) Debug(_ interface{}, _ ...LogField) {
+func (n nopWriter) Debug(_ any, _ ...LogField) {
 }
 
-func (n nopWriter) Error(_ interface{}, _ ...LogField) {
+func (n nopWriter) Error(_ any, _ ...LogField) {
 }
 
-func (n nopWriter) Info(_ interface{}, _ ...LogField) {
+func (n nopWriter) Info(_ any, _ ...LogField) {
 }
 
-func (n nopWriter) Severe(_ interface{}) {
+func (n nopWriter) Severe(_ any) {
 }
 
-func (n nopWriter) Slow(_ interface{}, _ ...LogField) {
+func (n nopWriter) Slow(_ any, _ ...LogField) {
 }
 
-func (n nopWriter) Stack(_ interface{}) {
+func (n nopWriter) Stack(_ any) {
 }
 
-func (n nopWriter) Stat(_ interface{}, _ ...LogField) {
+func (n nopWriter) Stat(_ any, _ ...LogField) {
 }
 
-func buildFields(fields ...LogField) []string {
+func buildPlainFields(fields ...LogField) []string {
 	var items []string
 
 	for _, field := range fields {
-		items = append(items, fmt.Sprintf("%s=%v", field.Key, field.Value))
+		items = append(items, fmt.Sprintf("%s=%+v", field.Key, field.Value))
 	}
 
 	return items
@@ -277,7 +277,7 @@ func combineGlobalFields(fields []LogField) []LogField {
 	return ret
 }
 
-func output(writer io.Writer, level string, val interface{}, fields ...LogField) {
+func output(writer io.Writer, level string, val any, fields ...LogField) {
 	// only truncate string content, don't know how to truncate the values of other types.
 	if v, ok := val.(string); ok {
 		maxLen := atomic.LoadUint32(&maxContentLength)
@@ -291,7 +291,7 @@ func output(writer io.Writer, level string, val interface{}, fields ...LogField)
 
 	switch atomic.LoadUint32(&encoding) {
 	case plainEncodingType:
-		writePlainAny(writer, level, val, buildFields(fields...)...)
+		writePlainAny(writer, level, val, buildPlainFields(fields...)...)
 	default:
 		entry := make(logEntry)
 		for _, field := range fields {
@@ -330,7 +330,7 @@ func wrapLevelWithColor(level string) string {
 	return color.WithColorPadding(level, colour)
 }
 
-func writeJson(writer io.Writer, info interface{}) {
+func writeJson(writer io.Writer, info any) {
 	if content, err := json.Marshal(info); err != nil {
 		log.Println(err.Error())
 	} else if writer == nil {
@@ -340,7 +340,7 @@ func writeJson(writer io.Writer, info interface{}) {
 	}
 }
 
-func writePlainAny(writer io.Writer, level string, val interface{}, fields ...string) {
+func writePlainAny(writer io.Writer, level string, val any, fields ...string) {
 	level = wrapLevelWithColor(level)
 
 	switch v := val.(type) {
@@ -377,7 +377,7 @@ func writePlainText(writer io.Writer, level, msg string, fields ...string) {
 	}
 }
 
-func writePlainValue(writer io.Writer, level string, val interface{}, fields ...string) {
+func writePlainValue(writer io.Writer, level string, val any, fields ...string) {
 	var buf bytes.Buffer
 	buf.WriteString(getTimestamp())
 	buf.WriteByte(plainEncodingSep)

core/mapping/jsonunmarshaler.go

@@ -11,17 +11,17 @@ const jsonTagKey = "json"
 var jsonUnmarshaler = NewUnmarshaler(jsonTagKey)
 
 // UnmarshalJsonBytes unmarshals content into v.
-func UnmarshalJsonBytes(content []byte, v interface{}, opts ...UnmarshalOption) error {
+func UnmarshalJsonBytes(content []byte, v any, opts ...UnmarshalOption) error {
 	return unmarshalJsonBytes(content, v, getJsonUnmarshaler(opts...))
 }
 
 // UnmarshalJsonMap unmarshals content from m into v.
-func UnmarshalJsonMap(m map[string]interface{}, v interface{}, opts ...UnmarshalOption) error {
+func UnmarshalJsonMap(m map[string]any, v any, opts ...UnmarshalOption) error {
 	return getJsonUnmarshaler(opts...).Unmarshal(m, v)
 }
 
 // UnmarshalJsonReader unmarshals content from reader into v.
-func UnmarshalJsonReader(reader io.Reader, v interface{}, opts ...UnmarshalOption) error {
+func UnmarshalJsonReader(reader io.Reader, v any, opts ...UnmarshalOption) error {
 	return unmarshalJsonReader(reader, v, getJsonUnmarshaler(opts...))
 }
 
@@ -33,8 +33,8 @@ func getJsonUnmarshaler(opts ...UnmarshalOption) *Unmarshaler {
 	return jsonUnmarshaler
 }
 
-func unmarshalJsonBytes(content []byte, v interface{}, unmarshaler *Unmarshaler) error {
-	var m interface{}
+func unmarshalJsonBytes(content []byte, v any, unmarshaler *Unmarshaler) error {
+	var m any
 	if err := jsonx.Unmarshal(content, &m); err != nil {
 		return err
 	}
@@ -42,8 +42,8 @@ func unmarshalJsonBytes(content []byte, v interface{}, unmarshaler *Unmarshaler)
 	return unmarshaler.Unmarshal(m, v)
 }
 
-func unmarshalJsonReader(reader io.Reader, v interface{}, unmarshaler *Unmarshaler) error {
-	var m interface{}
+func unmarshalJsonReader(reader io.Reader, v any, unmarshaler *Unmarshaler) error {
+	var m any
 	if err := jsonx.UnmarshalFromReader(reader, &m); err != nil {
 		return err
 	}

core/mapping/jsonunmarshaler_test.go

@@ -871,7 +871,7 @@ func TestUnmarshalReaderError(t *testing.T) {
 
 func TestUnmarshalMap(t *testing.T) {
 	t.Run("nil map and valid", func(t *testing.T) {
-		var m map[string]interface{}
+		var m map[string]any
 		var v struct {
 			Any string `json:",optional"`
 		}
@@ -882,7 +882,7 @@ func TestUnmarshalMap(t *testing.T) {
 	})
 
 	t.Run("empty map but not valid", func(t *testing.T) {
-		m := map[string]interface{}{}
+		m := map[string]any{}
 		var v struct {
 			Any string
 		}
@@ -892,7 +892,7 @@ func TestUnmarshalMap(t *testing.T) {
 	})
 
 	t.Run("empty map and valid", func(t *testing.T) {
-		m := map[string]interface{}{}
+		m := map[string]any{}
 		var v struct {
 			Any string `json:",optional"`
 		}
@@ -905,7 +905,7 @@ func TestUnmarshalMap(t *testing.T) {
 	})
 
 	t.Run("valid map", func(t *testing.T) {
-		m := map[string]interface{}{
+		m := map[string]any{
 			"Any": "foo",
 		}
 		var v struct {
@@ -930,3 +930,13 @@ func TestUnmarshalJsonArray(t *testing.T) {
 	assert.Equal(t, "kevin", v[0].Name)
 	assert.Equal(t, 18, v[0].Age)
 }
+
+func TestUnmarshalJsonBytesError(t *testing.T) {
+	var v []struct {
+		Name string `json:"name"`
+		Age  int    `json:"age"`
+	}
+
+	assert.Error(t, UnmarshalJsonBytes([]byte((``)), &v))
+	assert.Error(t, UnmarshalJsonReader(strings.NewReader(``), &v))
+}

core/mapping/marshaler.go

@@ -13,8 +13,8 @@ const (
 
 // Marshal marshals the given val and returns the map that contains the fields.
 // optional=another is not implemented, and it's hard to implement and not common used.
-func Marshal(val interface{}) (map[string]map[string]interface{}, error) {
-	ret := make(map[string]map[string]interface{})
+func Marshal(val any) (map[string]map[string]any, error) {
+	ret := make(map[string]map[string]any)
 	tp := reflect.TypeOf(val)
 	if tp.Kind() == reflect.Ptr {
 		tp = tp.Elem()
@@ -45,7 +45,7 @@ func getTag(field reflect.StructField) (string, bool) {
 }
 
 func processMember(field reflect.StructField, value reflect.Value,
-	collector map[string]map[string]interface{}) error {
+	collector map[string]map[string]any) error {
 	var key string
 	var opt *fieldOptions
 	var err error
@@ -73,7 +73,7 @@ func processMember(field reflect.StructField, value reflect.Value,
 	if ok {
 		m[key] = val
 	} else {
-		m = map[string]interface{}{
+		m = map[string]any{
 			key: val,
 		}
 	}

core/mapping/marshaler_test.go

@@ -227,7 +227,7 @@ func TestMarshal_Range(t *testing.T) {
 }
 
 func TestMarshal_RangeOut(t *testing.T) {
-	tests := []interface{}{
+	tests := []any{
 		struct {
 			Int int `json:"int,range=[1:3]"`
 		}{
@@ -262,7 +262,7 @@ func TestMarshal_RangeOut(t *testing.T) {
 }
 
 func TestMarshal_RangeIllegal(t *testing.T) {
-	tests := []interface{}{
+	tests := []any{
 		struct {
 			Int int `json:"int,range=[3:1]"`
 		}{
@@ -284,7 +284,7 @@ func TestMarshal_RangeIllegal(t *testing.T) {
 func TestMarshal_RangeLeftEqualsToRight(t *testing.T) {
 	tests := []struct {
 		name  string
-		value interface{}
+		value any
 		err   error
 	}{
 		{

core/mapping/tomlunmarshaler.go

@@ -7,7 +7,7 @@ import (
 )
 
 // UnmarshalTomlBytes unmarshals TOML bytes into the given v.
-func UnmarshalTomlBytes(content []byte, v interface{}, opts ...UnmarshalOption) error {
+func UnmarshalTomlBytes(content []byte, v any, opts ...UnmarshalOption) error {
 	b, err := encoding.TomlToJson(content)
 	if err != nil {
 		return err
@@ -17,7 +17,7 @@ func UnmarshalTomlBytes(content []byte, v interface{}, opts ...UnmarshalOption)
 }
 
 // UnmarshalTomlReader unmarshals TOML from the given io.Reader into the given v.
-func UnmarshalTomlReader(r io.Reader, v interface{}, opts ...UnmarshalOption) error {
+func UnmarshalTomlReader(r io.Reader, v any, opts ...UnmarshalOption) error {
 	b, err := io.ReadAll(r)
 	if err != nil {
 		return err

core/mapping/unmarshaler.go

@@ -30,9 +30,9 @@ var (
 	durationType        = reflect.TypeOf(time.Duration(0))
 	cacheKeys           = make(map[string][]string)
 	cacheKeysLock       sync.Mutex
-	defaultCache        = make(map[string]interface{})
+	defaultCache        = make(map[string]any)
 	defaultCacheLock    sync.Mutex
-	emptyMap            = map[string]interface{}{}
+	emptyMap            = map[string]any{}
 	emptyValue          = reflect.ValueOf(lang.Placeholder)
 )
 
@@ -66,12 +66,12 @@ func NewUnmarshaler(key string, opts ...UnmarshalOption) *Unmarshaler {
 }
 
 // UnmarshalKey unmarshals m into v with tag key.
-func UnmarshalKey(m map[string]interface{}, v interface{}) error {
+func UnmarshalKey(m map[string]any, v any) error {
 	return keyUnmarshaler.Unmarshal(m, v)
 }
 
 // Unmarshal unmarshals m into v.
-func (u *Unmarshaler) Unmarshal(i interface{}, v interface{}) error {
+func (u *Unmarshaler) Unmarshal(i any, v any) error {
 	valueType := reflect.TypeOf(v)
 	if valueType.Kind() != reflect.Ptr {
 		return errValueNotSettable
@@ -79,13 +79,13 @@ func (u *Unmarshaler) Unmarshal(i interface{}, v interface{}) error {
 
 	elemType := Deref(valueType)
 	switch iv := i.(type) {
-	case map[string]interface{}:
+	case map[string]any:
 		if elemType.Kind() != reflect.Struct {
 			return errTypeMismatch
 		}
 
 		return u.UnmarshalValuer(mapValuer(iv), v)
-	case []interface{}:
+	case []any:
 		if elemType.Kind() != reflect.Slice {
 			return errTypeMismatch
 		}
@@ -97,11 +97,11 @@ func (u *Unmarshaler) Unmarshal(i interface{}, v interface{}) error {
 }
 
 // UnmarshalValuer unmarshals m into v.
-func (u *Unmarshaler) UnmarshalValuer(m Valuer, v interface{}) error {
+func (u *Unmarshaler) UnmarshalValuer(m Valuer, v any) error {
 	return u.unmarshalWithFullName(simpleValuer{current: m}, v, "")
 }
 
-func (u *Unmarshaler) fillMap(fieldType reflect.Type, value reflect.Value, mapValue interface{}) error {
+func (u *Unmarshaler) fillMap(fieldType reflect.Type, value reflect.Value, mapValue any) error {
 	if !value.CanSet() {
 		return errValueNotSettable
 	}
@@ -121,7 +121,7 @@ func (u *Unmarshaler) fillMap(fieldType reflect.Type, value reflect.Value, mapVa
 	return nil
 }
 
-func (u *Unmarshaler) fillMapFromString(value reflect.Value, mapValue interface{}) error {
+func (u *Unmarshaler) fillMapFromString(value reflect.Value, mapValue any) error {
 	if !value.CanSet() {
 		return errValueNotSettable
 	}
@@ -142,7 +142,7 @@ func (u *Unmarshaler) fillMapFromString(value reflect.Value, mapValue interface{
 	return nil
 }
 
-func (u *Unmarshaler) fillSlice(fieldType reflect.Type, value reflect.Value, mapValue interface{}) error {
+func (u *Unmarshaler) fillSlice(fieldType reflect.Type, value reflect.Value, mapValue any) error {
 	if !value.CanSet() {
 		return errValueNotSettable
 	}
@@ -172,7 +172,7 @@ func (u *Unmarshaler) fillSlice(fieldType reflect.Type, value reflect.Value, map
 		switch dereffedBaseKind {
 		case reflect.Struct:
 			target := reflect.New(dereffedBaseType)
-			if err := u.Unmarshal(ithValue.(map[string]interface{}), target.Interface()); err != nil {
+			if err := u.Unmarshal(ithValue.(map[string]any), target.Interface()); err != nil {
 				return err
 			}
 
@@ -196,8 +196,8 @@ func (u *Unmarshaler) fillSlice(fieldType reflect.Type, value reflect.Value, map
 }
 
 func (u *Unmarshaler) fillSliceFromString(fieldType reflect.Type, value reflect.Value,
-	mapValue interface{}) error {
-	var slice []interface{}
+	mapValue any) error {
+	var slice []any
 	switch v := mapValue.(type) {
 	case fmt.Stringer:
 		if err := jsonx.UnmarshalFromString(v.String(), &slice); err != nil {
@@ -226,14 +226,14 @@ func (u *Unmarshaler) fillSliceFromString(fieldType reflect.Type, value reflect.
 }
 
 func (u *Unmarshaler) fillSliceValue(slice reflect.Value, index int,
-	baseKind reflect.Kind, value interface{}) error {
+	baseKind reflect.Kind, value any) error {
 	ithVal := slice.Index(index)
 	switch v := value.(type) {
 	case fmt.Stringer:
 		return setValueFromString(baseKind, ithVal, v.String())
 	case string:
 		return setValueFromString(baseKind, ithVal, v)
-	case map[string]interface{}:
+	case map[string]any:
 		return u.fillMap(ithVal.Type(), ithVal, value)
 	default:
 		// don't need to consider the difference between int, int8, int16, int32, int64,
@@ -281,7 +281,7 @@ func (u *Unmarshaler) fillSliceWithDefault(derefedType reflect.Type, value refle
 	return u.fillSlice(derefedType, value, slice)
 }
 
-func (u *Unmarshaler) generateMap(keyType, elemType reflect.Type, mapValue interface{}) (reflect.Value, error) {
+func (u *Unmarshaler) generateMap(keyType, elemType reflect.Type, mapValue any) (reflect.Value, error) {
 	mapType := reflect.MapOf(keyType, elemType)
 	valueType := reflect.TypeOf(mapValue)
 	if mapType == valueType {
@@ -306,7 +306,7 @@ func (u *Unmarshaler) generateMap(keyType, elemType reflect.Type, mapValue inter
 
 			targetValue.SetMapIndex(key, target.Elem())
 		case reflect.Struct:
-			keythMap, ok := keythData.(map[string]interface{})
+			keythMap, ok := keythData.(map[string]any)
 			if !ok {
 				return emptyValue, errTypeMismatch
 			}
@@ -318,7 +318,7 @@ func (u *Unmarshaler) generateMap(keyType, elemType reflect.Type, mapValue inter
 
 			SetMapIndexValue(elemType, targetValue, key, target.Elem())
 		case reflect.Map:
-			keythMap, ok := keythData.(map[string]interface{})
+			keythMap, ok := keythData.(map[string]any)
 			if !ok {
 				return emptyValue, errTypeMismatch
 			}
@@ -372,6 +372,26 @@ func (u *Unmarshaler) parseOptionsWithContext(field reflect.StructField, m Value
 		return key, nil, nil
 	}
 
+	if u.opts.canonicalKey != nil {
+		key = u.opts.canonicalKey(key)
+
+		if len(options.OptionalDep) > 0 {
+			// need to create a new fieldOption, because the original one is shared through cache.
+			options = &fieldOptions{
+				fieldOptionsWithContext: fieldOptionsWithContext{
+					Inherit:    options.Inherit,
+					FromString: options.FromString,
+					Optional:   options.Optional,
+					Options:    options.Options,
+					Default:    options.Default,
+					EnvVar:     options.EnvVar,
+					Range:      options.Range,
+				},
+				OptionalDep: u.opts.canonicalKey(options.OptionalDep),
+			}
+		}
+	}
+
 	optsWithContext, err := options.toOptionsWithContext(key, m, fullName)
 	if err != nil {
 		return "", nil, err
@@ -493,7 +513,7 @@ func (u *Unmarshaler) processFieldNotFromString(fieldType reflect.Type, value re
 
 	switch {
 	case valueKind == reflect.Map && typeKind == reflect.Struct:
-		mv, ok := mapValue.(map[string]interface{})
+		mv, ok := mapValue.(map[string]any)
 		if !ok {
 			return errTypeMismatch
 		}
@@ -516,7 +536,7 @@ func (u *Unmarshaler) processFieldNotFromString(fieldType reflect.Type, value re
 }
 
 func (u *Unmarshaler) processFieldPrimitive(fieldType reflect.Type, value reflect.Value,
-	mapValue interface{}, opts *fieldOptionsWithContext, fullName string) error {
+	mapValue any, opts *fieldOptionsWithContext, fullName string) error {
 	typeKind := Deref(fieldType).Kind()
 	valueKind := reflect.TypeOf(mapValue).Kind()
 
@@ -611,7 +631,7 @@ func (u *Unmarshaler) processFieldStruct(fieldType reflect.Type, value reflect.V
 }
 
 func (u *Unmarshaler) processFieldTextUnmarshaler(fieldType reflect.Type, value reflect.Value,
-	mapValue interface{}) (bool, error) {
+	mapValue any) (bool, error) {
 	var tval encoding.TextUnmarshaler
 	var ok bool
 
@@ -736,7 +756,7 @@ func (u *Unmarshaler) processNamedFieldWithValue(fieldType reflect.Type, value r
 }
 
 func (u *Unmarshaler) processNamedFieldWithValueFromString(fieldType reflect.Type, value reflect.Value,
-	mapValue interface{}, key string, opts *fieldOptionsWithContext, fullName string) error {
+	mapValue any, key string, opts *fieldOptionsWithContext, fullName string) error {
 	valueKind := reflect.TypeOf(mapValue).Kind()
 	if valueKind != reflect.String {
 		return fmt.Errorf("the value in map is not string, but %s", valueKind)
@@ -812,7 +832,7 @@ func (u *Unmarshaler) processNamedFieldWithoutValue(fieldType reflect.Type, valu
 	return nil
 }
 
-func (u *Unmarshaler) unmarshalWithFullName(m valuerWithParent, v interface{}, fullName string) error {
+func (u *Unmarshaler) unmarshalWithFullName(m valuerWithParent, v any, fullName string) error {
 	rv := reflect.ValueOf(v)
 	if err := ValidatePtr(&rv); err != nil {
 		return err
@@ -880,7 +900,7 @@ func fillDurationValue(fieldType reflect.Type, value reflect.Value, dur string)
 	return nil
 }
 
-func fillPrimitive(fieldType reflect.Type, value reflect.Value, mapValue interface{},
+func fillPrimitive(fieldType reflect.Type, value reflect.Value, mapValue any,
 	opts *fieldOptionsWithContext, fullName string) error {
 	if !value.CanSet() {
 		return errValueNotSettable
@@ -909,7 +929,7 @@ func fillPrimitive(fieldType reflect.Type, value reflect.Value, mapValue interfa
 	}
 }
 
-func fillWithSameType(fieldType reflect.Type, value reflect.Value, mapValue interface{},
+func fillWithSameType(fieldType reflect.Type, value reflect.Value, mapValue any,
 	opts *fieldOptionsWithContext) error {
 	if !value.CanSet() {
 		return errValueNotSettable
@@ -932,12 +952,12 @@ func fillWithSameType(fieldType reflect.Type, value reflect.Value, mapValue inte
 }
 
 // getValue gets the value for the specific key, the key can be in the format of parentKey.childKey
-func getValue(m valuerWithParent, key string) (interface{}, bool) {
+func getValue(m valuerWithParent, key string) (any, bool) {
 	keys := readKeys(key)
 	return getValueWithChainedKeys(m, keys)
 }
 
-func getValueWithChainedKeys(m valuerWithParent, keys []string) (interface{}, bool) {
+func getValueWithChainedKeys(m valuerWithParent, keys []string) (any, bool) {
 	switch len(keys) {
 	case 0:
 		return nil, false
@@ -946,7 +966,7 @@ func getValueWithChainedKeys(m valuerWithParent, keys []string) (interface{}, bo
 		return v, ok
 	default:
 		if v, ok := m.Value(keys[0]); ok {
-			if nextm, ok := v.(map[string]interface{}); ok {
+			if nextm, ok := v.(map[string]any); ok {
 				return getValueWithChainedKeys(recursiveValuer{
 					current: mapValuer(nextm),
 					parent:  m,
@@ -1005,7 +1025,7 @@ func readKeys(key string) []string {
 	return keys
 }
 
-func setSameKindValue(targetType reflect.Type, target reflect.Value, value interface{}) {
+func setSameKindValue(targetType reflect.Type, target reflect.Value, value any) {
 	if reflect.ValueOf(value).Type().AssignableTo(targetType) {
 		target.Set(reflect.ValueOf(value))
 	} else {

core/mapping/utils.go

@@ -64,7 +64,7 @@ func Deref(t reflect.Type) reflect.Type {
 }
 
 // Repr returns the string representation of v.
-func Repr(v interface{}) string {
+func Repr(v any) string {
 	return lang.Repr(v)
 }
 
@@ -89,7 +89,7 @@ func ValidatePtr(v *reflect.Value) error {
 	return nil
 }
 
-func convertTypeFromString(kind reflect.Kind, str string) (interface{}, error) {
+func convertTypeFromString(kind reflect.Kind, str string) (any, error) {
 	switch kind {
 	case reflect.Bool:
 		switch strings.ToLower(str) {
@@ -484,7 +484,7 @@ func parseSegments(val string) []string {
 	return segments
 }
 
-func setMatchedPrimitiveValue(kind reflect.Kind, value reflect.Value, v interface{}) error {
+func setMatchedPrimitiveValue(kind reflect.Kind, value reflect.Value, v any) error {
 	switch kind {
 	case reflect.Bool:
 		value.SetBool(v.(bool))
@@ -536,7 +536,7 @@ func structValueRequired(tag string, tp reflect.Type) (bool, error) {
 	return required, err
 }
 
-func toFloat64(v interface{}) (float64, bool) {
+func toFloat64(v any) (float64, bool) {
 	switch val := v.(type) {
 	case int:
 		return float64(val), true
@@ -623,7 +623,7 @@ func validateNumberRange(fv float64, nr *numberRange) error {
 	return nil
 }
 
-func validateValueInOptions(val interface{}, options []string) error {
+func validateValueInOptions(val any, options []string) error {
 	if len(options) > 0 {
 		switch v := val.(type) {
 		case string:
@@ -640,7 +640,7 @@ func validateValueInOptions(val interface{}, options []string) error {
 	return nil
 }
 
-func validateValueRange(mapValue interface{}, opts *fieldOptionsWithContext) error {
+func validateValueRange(mapValue any, opts *fieldOptionsWithContext) error {
 	if opts == nil || opts.Range == nil {
 		return nil
 	}

core/mapping/utils_test.go

@@ -258,7 +258,7 @@ func TestSetValueFormatErrors(t *testing.T) {
 		IntValue   int
 		UintValue  uint
 		FloatValue float32
-		MapValue   map[string]interface{}
+		MapValue   map[string]any
 	}
 
 	var bar Bar

core/mapping/valuer.go

@@ -4,7 +4,7 @@ type (
 	// A Valuer interface defines the way to get values from the underlying object with keys.
 	Valuer interface {
 		// Value gets the value associated with the given key.
-		Value(key string) (interface{}, bool)
+		Value(key string) (any, bool)
 	}
 
 	// A valuerWithParent defines a node that has a parent node.
@@ -22,12 +22,12 @@ type (
 
 	// A valueWithParent is used to wrap the value with its parent.
 	valueWithParent struct {
-		value  interface{}
+		value  any
 		parent valuerWithParent
 	}
 
 	// mapValuer is a type for map to meet the Valuer interface.
-	mapValuer map[string]interface{}
+	mapValuer map[string]any
 	// simpleValuer is a type to get value from current node.
 	simpleValuer node
 	// recursiveValuer is a type to get the value recursively from current and parent nodes.
@@ -35,13 +35,13 @@ type (
 )
 
 // Value gets the value assciated with the given key from mv.
-func (mv mapValuer) Value(key string) (interface{}, bool) {
+func (mv mapValuer) Value(key string) (any, bool) {
 	v, ok := mv[key]
 	return v, ok
 }
 
 // Value gets the value associated with the given key from sv.
-func (sv simpleValuer) Value(key string) (interface{}, bool) {
+func (sv simpleValuer) Value(key string) (any, bool) {
 	v, ok := sv.current.Value(key)
 	return v, ok
 }
@@ -60,7 +60,7 @@ func (sv simpleValuer) Parent() valuerWithParent {
 
 // Value gets the value associated with the given key from rv,
 // and it will inherit the value from parent nodes.
-func (rv recursiveValuer) Value(key string) (interface{}, bool) {
+func (rv recursiveValuer) Value(key string) (any, bool) {
 	val, ok := rv.current.Value(key)
 	if !ok {
 		if parent := rv.Parent(); parent != nil {
@@ -70,7 +70,7 @@ func (rv recursiveValuer) Value(key string) (interface{}, bool) {
 		return nil, false
 	}
 
-	vm, ok := val.(map[string]interface{})
+	vm, ok := val.(map[string]any)
 	if !ok {
 		return val, true
 	}
@@ -85,7 +85,7 @@ func (rv recursiveValuer) Value(key string) (interface{}, bool) {
 		return val, true
 	}
 
-	pm, ok := pv.(map[string]interface{})
+	pm, ok := pv.(map[string]any)
 	if !ok {
 		return val, true
 	}

core/mapping/valuer_test.go

@@ -7,17 +7,17 @@ import (
 )
 
 func TestMapValuerWithInherit_Value(t *testing.T) {
-	input := map[string]interface{}{
-		"discovery": map[string]interface{}{
+	input := map[string]any{
+		"discovery": map[string]any{
 			"host": "localhost",
 			"port": 8080,
 		},
-		"component": map[string]interface{}{
+		"component": map[string]any{
 			"name": "test",
 		},
 	}
 	valuer := recursiveValuer{
-		current: mapValuer(input["component"].(map[string]interface{})),
+		current: mapValuer(input["component"].(map[string]any)),
 		parent: simpleValuer{
 			current: mapValuer(input),
 		},
@@ -26,24 +26,24 @@ func TestMapValuerWithInherit_Value(t *testing.T) {
 	val, ok := valuer.Value("discovery")
 	assert.True(t, ok)
 
-	m, ok := val.(map[string]interface{})
+	m, ok := val.(map[string]any)
 	assert.True(t, ok)
 	assert.Equal(t, "localhost", m["host"])
 	assert.Equal(t, 8080, m["port"])
 }
 
 func TestRecursiveValuer_Value(t *testing.T) {
-	input := map[string]interface{}{
-		"component": map[string]interface{}{
+	input := map[string]any{
+		"component": map[string]any{
 			"name": "test",
-			"foo": map[string]interface{}{
+			"foo": map[string]any{
 				"bar": "baz",
 			},
 		},
 		"foo": "value",
 	}
 	valuer := recursiveValuer{
-		current: mapValuer(input["component"].(map[string]interface{})),
+		current: mapValuer(input["component"].(map[string]any)),
 		parent: simpleValuer{
 			current: mapValuer(input),
 		},
@@ -51,7 +51,7 @@ func TestRecursiveValuer_Value(t *testing.T) {
 
 	val, ok := valuer.Value("foo")
 	assert.True(t, ok)
-	assert.EqualValues(t, map[string]interface{}{
+	assert.EqualValues(t, map[string]any{
 		"bar": "baz",
 	}, val)
 }

core/mapping/yamlunmarshaler.go

@@ -7,7 +7,7 @@ import (
 )
 
 // UnmarshalYamlBytes unmarshals content into v.
-func UnmarshalYamlBytes(content []byte, v interface{}, opts ...UnmarshalOption) error {
+func UnmarshalYamlBytes(content []byte, v any, opts ...UnmarshalOption) error {
 	b, err := encoding.YamlToJson(content)
 	if err != nil {
 		return err
@@ -17,7 +17,7 @@ func UnmarshalYamlBytes(content []byte, v interface{}, opts ...UnmarshalOption)
 }
 
 // UnmarshalYamlReader unmarshals content from reader into v.
-func UnmarshalYamlReader(reader io.Reader, v interface{}, opts ...UnmarshalOption) error {
+func UnmarshalYamlReader(reader io.Reader, v any, opts ...UnmarshalOption) error {
 	b, err := io.ReadAll(reader)
 	if err != nil {
 		return err

core/mathx/entropy.go

@@ -5,7 +5,7 @@ import "math"
 const epsilon = 1e-6
 
 // CalcEntropy calculates the entropy of m.
-func CalcEntropy(m map[interface{}]int) float64 {
+func CalcEntropy(m map[any]int) float64 {
 	if len(m) == 0 || len(m) == 1 {
 		return 1
 	}

core/mathx/entropy_test.go

@@ -9,7 +9,7 @@ import (
 func TestCalcEntropy(t *testing.T) {
 	const total = 1000
 	const count = 100
-	m := make(map[interface{}]int, total)
+	m := make(map[any]int, total)
 	for i := 0; i < total; i++ {
 		m[i] = count
 	}

core/mathx/unstable_test.go

@@ -61,7 +61,7 @@ func TestUnstable_Distribution(t *testing.T) {
 	_, ok := m[0]
 	assert.False(t, ok)
 
-	mi := make(map[interface{}]int, len(m))
+	mi := make(map[any]int, len(m))
 	for k, v := range m {
 		mi[k] = v
 	}

core/metric/counter_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/prometheus/client_golang/prometheus/testutil"
 	"github.com/stretchr/testify/assert"
+	"github.com/zeromicro/go-zero/core/proc"
 	"github.com/zeromicro/go-zero/core/prometheus"
 )
 
@@ -17,6 +18,9 @@ func TestNewCounterVec(t *testing.T) {
 	})
 	defer counterVec.close()
 	counterVecNil := NewCounterVec(nil)
+	counterVec.Inc("path", "code")
+	counterVec.Add(1, "path", "code")
+	proc.Shutdown()
 	assert.NotNil(t, counterVec)
 	assert.Nil(t, counterVecNil)
 }

core/metric/gauge_test.go

@@ -5,6 +5,7 @@ import (
 
 	"github.com/prometheus/client_golang/prometheus/testutil"
 	"github.com/stretchr/testify/assert"
+	"github.com/zeromicro/go-zero/core/proc"
 )
 
 func TestNewGaugeVec(t *testing.T) {
@@ -18,6 +19,8 @@ func TestNewGaugeVec(t *testing.T) {
 	gaugeVecNil := NewGaugeVec(nil)
 	assert.NotNil(t, gaugeVec)
 	assert.Nil(t, gaugeVecNil)
+
+	proc.Shutdown()
 }
 
 func TestGaugeInc(t *testing.T) {

core/metric/histogram_test.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/prometheus/client_golang/prometheus/testutil"
 	"github.com/stretchr/testify/assert"
+	"github.com/zeromicro/go-zero/core/proc"
 )
 
 func TestNewHistogramVec(t *testing.T) {
@@ -47,4 +48,6 @@ func TestHistogramObserve(t *testing.T) {
 
 	err := testutil.CollectAndCompare(hv.histogram, strings.NewReader(metadata+val))
 	assert.Nil(t, err)
+
+	proc.Shutdown()
 }

core/mr/mapreduce.go

@@ -24,29 +24,29 @@ var (
 
 type (
 	// ForEachFunc is used to do element processing, but no output.
-	ForEachFunc func(item interface{})
+	ForEachFunc func(item any)
 	// GenerateFunc is used to let callers send elements into source.
-	GenerateFunc func(source chan<- interface{})
+	GenerateFunc func(source chan<- any)
 	// MapFunc is used to do element processing and write the output to writer.
-	MapFunc func(item interface{}, writer Writer)
+	MapFunc func(item any, writer Writer)
 	// MapperFunc is used to do element processing and write the output to writer,
 	// use cancel func to cancel the processing.
-	MapperFunc func(item interface{}, writer Writer, cancel func(error))
+	MapperFunc func(item any, writer Writer, cancel func(error))
 	// ReducerFunc is used to reduce all the mapping output and write to writer,
 	// use cancel func to cancel the processing.
-	ReducerFunc func(pipe <-chan interface{}, writer Writer, cancel func(error))
+	ReducerFunc func(pipe <-chan any, writer Writer, cancel func(error))
 	// VoidReducerFunc is used to reduce all the mapping output, but no output.
 	// Use cancel func to cancel the processing.
-	VoidReducerFunc func(pipe <-chan interface{}, cancel func(error))
+	VoidReducerFunc func(pipe <-chan any, cancel func(error))
 	// Option defines the method to customize the mapreduce.
 	Option func(opts *mapReduceOptions)
 
 	mapperContext struct {
 		ctx       context.Context
 		mapper    MapFunc
-		source    <-chan interface{}
+		source    <-chan any
 		panicChan *onceChan
-		collector chan<- interface{}
+		collector chan<- any
 		doneChan  <-chan lang.PlaceholderType
 		workers   int
 	}
@@ -58,7 +58,7 @@ type (
 
 	// Writer interface wraps Write method.
 	Writer interface {
-		Write(v interface{})
+		Write(v any)
 	}
 )
 
@@ -68,16 +68,16 @@ func Finish(fns ...func() error) error {
 		return nil
 	}
 
-	return MapReduceVoid(func(source chan<- interface{}) {
+	return MapReduceVoid(func(source chan<- any) {
 		for _, fn := range fns {
 			source <- fn
 		}
-	}, func(item interface{}, writer Writer, cancel func(error)) {
+	}, func(item any, writer Writer, cancel func(error)) {
 		fn := item.(func() error)
 		if err := fn(); err != nil {
 			cancel(err)
 		}
-	}, func(pipe <-chan interface{}, cancel func(error)) {
+	}, func(pipe <-chan any, cancel func(error)) {
 	}, WithWorkers(len(fns)))
 }
 
@@ -87,11 +87,11 @@ func FinishVoid(fns ...func()) {
 		return
 	}
 
-	ForEach(func(source chan<- interface{}) {
+	ForEach(func(source chan<- any) {
 		for _, fn := range fns {
 			source <- fn
 		}
-	}, func(item interface{}) {
+	}, func(item any) {
 		fn := item.(func())
 		fn()
 	}, WithWorkers(len(fns)))
@@ -100,14 +100,14 @@ func FinishVoid(fns ...func()) {
 // ForEach maps all elements from given generate but no output.
 func ForEach(generate GenerateFunc, mapper ForEachFunc, opts ...Option) {
 	options := buildOptions(opts...)
-	panicChan := &onceChan{channel: make(chan interface{})}
+	panicChan := &onceChan{channel: make(chan any)}
 	source := buildSource(generate, panicChan)
-	collector := make(chan interface{})
+	collector := make(chan any)
 	done := make(chan lang.PlaceholderType)
 
 	go executeMappers(mapperContext{
 		ctx: options.ctx,
-		mapper: func(item interface{}, _ Writer) {
+		mapper: func(item any, _ Writer) {
 			mapper(item)
 		},
 		source:    source,
@@ -132,25 +132,25 @@ func ForEach(generate GenerateFunc, mapper ForEachFunc, opts ...Option) {
 // MapReduce maps all elements generated from given generate func,
 // and reduces the output elements with given reducer.
 func MapReduce(generate GenerateFunc, mapper MapperFunc, reducer ReducerFunc,
-	opts ...Option) (interface{}, error) {
-	panicChan := &onceChan{channel: make(chan interface{})}
+	opts ...Option) (any, error) {
+	panicChan := &onceChan{channel: make(chan any)}
 	source := buildSource(generate, panicChan)
 	return mapReduceWithPanicChan(source, panicChan, mapper, reducer, opts...)
 }
 
 // MapReduceChan maps all elements from source, and reduce the output elements with given reducer.
-func MapReduceChan(source <-chan interface{}, mapper MapperFunc, reducer ReducerFunc,
-	opts ...Option) (interface{}, error) {
-	panicChan := &onceChan{channel: make(chan interface{})}
+func MapReduceChan(source <-chan any, mapper MapperFunc, reducer ReducerFunc,
+	opts ...Option) (any, error) {
+	panicChan := &onceChan{channel: make(chan any)}
 	return mapReduceWithPanicChan(source, panicChan, mapper, reducer, opts...)
 }
 
 // mapReduceWithPanicChan maps all elements from source, and reduce the output elements with given reducer.
-func mapReduceWithPanicChan(source <-chan interface{}, panicChan *onceChan, mapper MapperFunc,
-	reducer ReducerFunc, opts ...Option) (interface{}, error) {
+func mapReduceWithPanicChan(source <-chan any, panicChan *onceChan, mapper MapperFunc,
+	reducer ReducerFunc, opts ...Option) (any, error) {
 	options := buildOptions(opts...)
 	// output is used to write the final result
-	output := make(chan interface{})
+	output := make(chan any)
 	defer func() {
 		// reducer can only write once, if more, panic
 		for range output {
@@ -159,7 +159,7 @@ func mapReduceWithPanicChan(source <-chan interface{}, panicChan *onceChan, mapp
 	}()
 
 	// collector is used to collect data from mapper, and consume in reducer
-	collector := make(chan interface{}, options.workers)
+	collector := make(chan any, options.workers)
 	// if done is closed, all mappers and reducer should stop processing
 	done := make(chan lang.PlaceholderType)
 	writer := newGuardedWriter(options.ctx, output, done)
@@ -197,7 +197,7 @@ func mapReduceWithPanicChan(source <-chan interface{}, panicChan *onceChan, mapp
 
 	go executeMappers(mapperContext{
 		ctx: options.ctx,
-		mapper: func(item interface{}, w Writer) {
+		mapper: func(item any, w Writer) {
 			mapper(item, w, cancel)
 		},
 		source:    source,
@@ -229,7 +229,7 @@ func mapReduceWithPanicChan(source <-chan interface{}, panicChan *onceChan, mapp
 // MapReduceVoid maps all elements generated from given generate,
 // and reduce the output elements with given reducer.
 func MapReduceVoid(generate GenerateFunc, mapper MapperFunc, reducer VoidReducerFunc, opts ...Option) error {
-	_, err := MapReduce(generate, mapper, func(input <-chan interface{}, writer Writer, cancel func(error)) {
+	_, err := MapReduce(generate, mapper, func(input <-chan any, writer Writer, cancel func(error)) {
 		reducer(input, cancel)
 	}, opts...)
 	if errors.Is(err, ErrReduceNoOutput) {
@@ -266,8 +266,8 @@ func buildOptions(opts ...Option) *mapReduceOptions {
 	return options
 }
 
-func buildSource(generate GenerateFunc, panicChan *onceChan) chan interface{} {
-	source := make(chan interface{})
+func buildSource(generate GenerateFunc, panicChan *onceChan) chan any {
+	source := make(chan any)
 	go func() {
 		defer func() {
 			if r := recover(); r != nil {
@@ -283,7 +283,7 @@ func buildSource(generate GenerateFunc, panicChan *onceChan) chan interface{} {
 }
 
 // drain drains the channel.
-func drain(channel <-chan interface{}) {
+func drain(channel <-chan any) {
 	// drain the channel
 	for range channel {
 	}
@@ -348,11 +348,11 @@ func once(fn func(error)) func(error) {
 
 type guardedWriter struct {
 	ctx     context.Context
-	channel chan<- interface{}
+	channel chan<- any
 	done    <-chan lang.PlaceholderType
 }
 
-func newGuardedWriter(ctx context.Context, channel chan<- interface{},
+func newGuardedWriter(ctx context.Context, channel chan<- any,
 	done <-chan lang.PlaceholderType) guardedWriter {
 	return guardedWriter{
 		ctx:     ctx,
@@ -361,7 +361,7 @@ func newGuardedWriter(ctx context.Context, channel chan<- interface{},
 	}
 }
 
-func (gw guardedWriter) Write(v interface{}) {
+func (gw guardedWriter) Write(v any) {
 	select {
 	case <-gw.ctx.Done():
 		return
@@ -373,11 +373,11 @@ func (gw guardedWriter) Write(v interface{}) {
 }
 
 type onceChan struct {
-	channel chan interface{}
+	channel chan any
 	wrote   int32
 }
 
-func (oc *onceChan) write(val interface{}) {
+func (oc *onceChan) write(val any) {
 	if atomic.CompareAndSwapInt32(&oc.wrote, 0, 1) {
 		oc.channel <- val
 	}

core/mr/mapreduce_fuzz_test.go

@@ -29,23 +29,23 @@ func FuzzMapReduce(f *testing.F) {
 		reducerIdx := rand.Int63n(n)
 		squareSum := (n - 1) * n * (2*n - 1) / 6
 
-		fn := func() (interface{}, error) {
+		fn := func() (any, error) {
 			defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
 
-			return MapReduce(func(source chan<- interface{}) {
+			return MapReduce(func(source chan<- any) {
 				for i := int64(0); i < n; i++ {
 					source <- i
 					if genPanic && i == genIdx {
 						panic("foo")
 					}
 				}
-			}, func(item interface{}, writer Writer, cancel func(error)) {
+			}, func(item any, writer Writer, cancel func(error)) {
 				v := item.(int64)
 				if mapperPanic && v == mapperIdx {
 					panic("bar")
 				}
 				writer.Write(v * v)
-			}, func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
+			}, func(pipe <-chan any, writer Writer, cancel func(error)) {
 				var idx int64
 				var total int64
 				for v := range pipe {

core/mr/mapreduce_fuzzcase_test.go

@@ -54,21 +54,21 @@ func TestMapReduceRandom(t *testing.T) {
 				reducerIdx := rand.Int63n(n)
 				squareSum := (n - 1) * n * (2*n - 1) / 6
 
-				fn := func() (interface{}, error) {
-					return MapReduce(func(source chan<- interface{}) {
+				fn := func() (any, error) {
+					return MapReduce(func(source chan<- any) {
 						for i := int64(0); i < n; i++ {
 							source <- i
 							if genPanic && i == genIdx {
 								panic("foo")
 							}
 						}
-					}, func(item interface{}, writer Writer, cancel func(error)) {
+					}, func(item any, writer Writer, cancel func(error)) {
 						v := item.(int64)
 						if mapperPanic && v == mapperIdx {
 							panic("bar")
 						}
 						writer.Write(v * v)
-					}, func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
+					}, func(pipe <-chan any, writer Writer, cancel func(error)) {
 						var idx int64
 						var total int64
 						for v := range pipe {

core/mr/mapreduce_test.go

@@ -91,11 +91,11 @@ func TestForEach(t *testing.T) {
 		defer goleak.VerifyNone(t)
 
 		var count uint32
-		ForEach(func(source chan<- interface{}) {
+		ForEach(func(source chan<- any) {
 			for i := 0; i < tasks; i++ {
 				source <- i
 			}
-		}, func(item interface{}) {
+		}, func(item any) {
 			atomic.AddUint32(&count, 1)
 		}, WithWorkers(-1))
 
@@ -106,11 +106,11 @@ func TestForEach(t *testing.T) {
 		defer goleak.VerifyNone(t)
 
 		var count uint32
-		ForEach(func(source chan<- interface{}) {
+		ForEach(func(source chan<- any) {
 			for i := 0; i < tasks; i++ {
 				source <- i
 			}
-		}, func(item interface{}) {
+		}, func(item any) {
 			if item.(int)%2 == 0 {
 				atomic.AddUint32(&count, 1)
 			}
@@ -123,11 +123,11 @@ func TestForEach(t *testing.T) {
 		defer goleak.VerifyNone(t)
 
 		assert.PanicsWithValue(t, "foo", func() {
-			ForEach(func(source chan<- interface{}) {
+			ForEach(func(source chan<- any) {
 				for i := 0; i < tasks; i++ {
 					source <- i
 				}
-			}, func(item interface{}) {
+			}, func(item any) {
 				panic("foo")
 			})
 		})
@@ -139,9 +139,9 @@ func TestGeneratePanic(t *testing.T) {
 
 	t.Run("all", func(t *testing.T) {
 		assert.PanicsWithValue(t, "foo", func() {
-			ForEach(func(source chan<- interface{}) {
+			ForEach(func(source chan<- any) {
 				panic("foo")
-			}, func(item interface{}) {
+			}, func(item any) {
 			})
 		})
 	})
@@ -154,14 +154,14 @@ func TestMapperPanic(t *testing.T) {
 	var run int32
 	t.Run("all", func(t *testing.T) {
 		assert.PanicsWithValue(t, "foo", func() {
-			_, _ = MapReduce(func(source chan<- interface{}) {
+			_, _ = MapReduce(func(source chan<- any) {
 				for i := 0; i < tasks; i++ {
 					source <- i
 				}
-			}, func(item interface{}, writer Writer, cancel func(error)) {
+			}, func(item any, writer Writer, cancel func(error)) {
 				atomic.AddInt32(&run, 1)
 				panic("foo")
-			}, func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
+			}, func(pipe <-chan any, writer Writer, cancel func(error)) {
 			})
 		})
 		assert.True(t, atomic.LoadInt32(&run) < tasks/2)
@@ -176,7 +176,7 @@ func TestMapReduce(t *testing.T) {
 		mapper      MapperFunc
 		reducer     ReducerFunc
 		expectErr   error
-		expectValue interface{}
+		expectValue any
 	}{
 		{
 			name:        "simple",
@@ -185,7 +185,7 @@ func TestMapReduce(t *testing.T) {
 		},
 		{
 			name: "cancel with error",
-			mapper: func(item interface{}, writer Writer, cancel func(error)) {
+			mapper: func(item any, writer Writer, cancel func(error)) {
 				v := item.(int)
 				if v%3 == 0 {
 					cancel(errDummy)
@@ -196,7 +196,7 @@ func TestMapReduce(t *testing.T) {
 		},
 		{
 			name: "cancel with nil",
-			mapper: func(item interface{}, writer Writer, cancel func(error)) {
+			mapper: func(item any, writer Writer, cancel func(error)) {
 				v := item.(int)
 				if v%3 == 0 {
 					cancel(nil)
@@ -208,7 +208,7 @@ func TestMapReduce(t *testing.T) {
 		},
 		{
 			name: "cancel with more",
-			reducer: func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
+			reducer: func(pipe <-chan any, writer Writer, cancel func(error)) {
 				var result int
 				for item := range pipe {
 					result += item.(int)
@@ -226,13 +226,13 @@ func TestMapReduce(t *testing.T) {
 		for _, test := range tests {
 			t.Run(test.name, func(t *testing.T) {
 				if test.mapper == nil {
-					test.mapper = func(item interface{}, writer Writer, cancel func(error)) {
+					test.mapper = func(item any, writer Writer, cancel func(error)) {
 						v := item.(int)
 						writer.Write(v * v)
 					}
 				}
 				if test.reducer == nil {
-					test.reducer = func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
+					test.reducer = func(pipe <-chan any, writer Writer, cancel func(error)) {
 						var result int
 						for item := range pipe {
 							result += item.(int)
@@ -240,7 +240,7 @@ func TestMapReduce(t *testing.T) {
 						writer.Write(result)
 					}
 				}
-				value, err := MapReduce(func(source chan<- interface{}) {
+				value, err := MapReduce(func(source chan<- any) {
 					for i := 1; i < 5; i++ {
 						source <- i
 					}
@@ -256,13 +256,13 @@ func TestMapReduce(t *testing.T) {
 		for _, test := range tests {
 			t.Run(test.name, func(t *testing.T) {
 				if test.mapper == nil {
-					test.mapper = func(item interface{}, writer Writer, cancel func(error)) {
+					test.mapper = func(item any, writer Writer, cancel func(error)) {
 						v := item.(int)
 						writer.Write(v * v)
 					}
 				}
 				if test.reducer == nil {
-					test.reducer = func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
+					test.reducer = func(pipe <-chan any, writer Writer, cancel func(error)) {
 						var result int
 						for item := range pipe {
 							result += item.(int)
@@ -271,7 +271,7 @@ func TestMapReduce(t *testing.T) {
 					}
 				}
 
-				source := make(chan interface{})
+				source := make(chan any)
 				go func() {
 					for i := 1; i < 5; i++ {
 						source <- i
@@ -291,13 +291,13 @@ func TestMapReduceWithReduerWriteMoreThanOnce(t *testing.T) {
 	defer goleak.VerifyNone(t)
 
 	assert.Panics(t, func() {
-		MapReduce(func(source chan<- interface{}) {
+		MapReduce(func(source chan<- any) {
 			for i := 0; i < 10; i++ {
 				source <- i
 			}
-		}, func(item interface{}, writer Writer, cancel func(error)) {
+		}, func(item any, writer Writer, cancel func(error)) {
 			writer.Write(item)
-		}, func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
+		}, func(pipe <-chan any, writer Writer, cancel func(error)) {
 			drain(pipe)
 			writer.Write("one")
 			writer.Write("two")
@@ -323,7 +323,7 @@ func TestMapReduceVoid(t *testing.T) {
 		},
 		{
 			name: "cancel with error",
-			mapper: func(item interface{}, writer Writer, cancel func(error)) {
+			mapper: func(item any, writer Writer, cancel func(error)) {
 				v := item.(int)
 				if v%3 == 0 {
 					cancel(errDummy)
@@ -334,7 +334,7 @@ func TestMapReduceVoid(t *testing.T) {
 		},
 		{
 			name: "cancel with nil",
-			mapper: func(item interface{}, writer Writer, cancel func(error)) {
+			mapper: func(item any, writer Writer, cancel func(error)) {
 				v := item.(int)
 				if v%3 == 0 {
 					cancel(nil)
@@ -345,7 +345,7 @@ func TestMapReduceVoid(t *testing.T) {
 		},
 		{
 			name: "cancel with more",
-			reducer: func(pipe <-chan interface{}, cancel func(error)) {
+			reducer: func(pipe <-chan any, cancel func(error)) {
 				for item := range pipe {
 					result := atomic.AddUint32(&value, uint32(item.(int)))
 					if result > 10 {
@@ -362,19 +362,19 @@ func TestMapReduceVoid(t *testing.T) {
 			atomic.StoreUint32(&value, 0)
 
 			if test.mapper == nil {
-				test.mapper = func(item interface{}, writer Writer, cancel func(error)) {
+				test.mapper = func(item any, writer Writer, cancel func(error)) {
 					v := item.(int)
 					writer.Write(v * v)
 				}
 			}
 			if test.reducer == nil {
-				test.reducer = func(pipe <-chan interface{}, cancel func(error)) {
+				test.reducer = func(pipe <-chan any, cancel func(error)) {
 					for item := range pipe {
 						atomic.AddUint32(&value, uint32(item.(int)))
 					}
 				}
 			}
-			err := MapReduceVoid(func(source chan<- interface{}) {
+			err := MapReduceVoid(func(source chan<- any) {
 				for i := 1; i < 5; i++ {
 					source <- i
 				}
@@ -392,16 +392,16 @@ func TestMapReduceVoidWithDelay(t *testing.T) {
 	defer goleak.VerifyNone(t)
 
 	var result []int
-	err := MapReduceVoid(func(source chan<- interface{}) {
+	err := MapReduceVoid(func(source chan<- any) {
 		source <- 0
 		source <- 1
-	}, func(item interface{}, writer Writer, cancel func(error)) {
+	}, func(item any, writer Writer, cancel func(error)) {
 		i := item.(int)
 		if i == 0 {
 			time.Sleep(time.Millisecond * 50)
 		}
 		writer.Write(i)
-	}, func(pipe <-chan interface{}, cancel func(error)) {
+	}, func(pipe <-chan any, cancel func(error)) {
 		for item := range pipe {
 			i := item.(int)
 			result = append(result, i)
@@ -417,13 +417,13 @@ func TestMapReducePanic(t *testing.T) {
 	defer goleak.VerifyNone(t)
 
 	assert.Panics(t, func() {
-		_, _ = MapReduce(func(source chan<- interface{}) {
+		_, _ = MapReduce(func(source chan<- any) {
 			source <- 0
 			source <- 1
-		}, func(item interface{}, writer Writer, cancel func(error)) {
+		}, func(item any, writer Writer, cancel func(error)) {
 			i := item.(int)
 			writer.Write(i)
-		}, func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
+		}, func(pipe <-chan any, writer Writer, cancel func(error)) {
 			for range pipe {
 				panic("panic")
 			}
@@ -435,17 +435,17 @@ func TestMapReducePanicOnce(t *testing.T) {
 	defer goleak.VerifyNone(t)
 
 	assert.Panics(t, func() {
-		_, _ = MapReduce(func(source chan<- interface{}) {
+		_, _ = MapReduce(func(source chan<- any) {
 			for i := 0; i < 100; i++ {
 				source <- i
 			}
-		}, func(item interface{}, writer Writer, cancel func(error)) {
+		}, func(item any, writer Writer, cancel func(error)) {
 			i := item.(int)
 			if i == 0 {
 				panic("foo")
 			}
 			writer.Write(i)
-		}, func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
+		}, func(pipe <-chan any, writer Writer, cancel func(error)) {
 			for range pipe {
 				panic("bar")
 			}
@@ -457,12 +457,12 @@ func TestMapReducePanicBothMapperAndReducer(t *testing.T) {
 	defer goleak.VerifyNone(t)
 
 	assert.Panics(t, func() {
-		_, _ = MapReduce(func(source chan<- interface{}) {
+		_, _ = MapReduce(func(source chan<- any) {
 			source <- 0
 			source <- 1
-		}, func(item interface{}, writer Writer, cancel func(error)) {
+		}, func(item any, writer Writer, cancel func(error)) {
 			panic("foo")
-		}, func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
+		}, func(pipe <-chan any, writer Writer, cancel func(error)) {
 			panic("bar")
 		})
 	})
@@ -472,16 +472,16 @@ func TestMapReduceVoidCancel(t *testing.T) {
 	defer goleak.VerifyNone(t)
 
 	var result []int
-	err := MapReduceVoid(func(source chan<- interface{}) {
+	err := MapReduceVoid(func(source chan<- any) {
 		source <- 0
 		source <- 1
-	}, func(item interface{}, writer Writer, cancel func(error)) {
+	}, func(item any, writer Writer, cancel func(error)) {
 		i := item.(int)
 		if i == 1 {
 			cancel(errors.New("anything"))
 		}
 		writer.Write(i)
-	}, func(pipe <-chan interface{}, cancel func(error)) {
+	}, func(pipe <-chan any, cancel func(error)) {
 		for item := range pipe {
 			i := item.(int)
 			result = append(result, i)
@@ -496,18 +496,18 @@ func TestMapReduceVoidCancelWithRemains(t *testing.T) {
 
 	var done int32
 	var result []int
-	err := MapReduceVoid(func(source chan<- interface{}) {
+	err := MapReduceVoid(func(source chan<- any) {
 		for i := 0; i < defaultWorkers*2; i++ {
 			source <- i
 		}
 		atomic.AddInt32(&done, 1)
-	}, func(item interface{}, writer Writer, cancel func(error)) {
+	}, func(item any, writer Writer, cancel func(error)) {
 		i := item.(int)
 		if i == defaultWorkers/2 {
 			cancel(errors.New("anything"))
 		}
 		writer.Write(i)
-	}, func(pipe <-chan interface{}, cancel func(error)) {
+	}, func(pipe <-chan any, cancel func(error)) {
 		for item := range pipe {
 			i := item.(int)
 			result = append(result, i)
@@ -522,13 +522,13 @@ func TestMapReduceWithoutReducerWrite(t *testing.T) {
 	defer goleak.VerifyNone(t)
 
 	uids := []int{1, 2, 3}
-	res, err := MapReduce(func(source chan<- interface{}) {
+	res, err := MapReduce(func(source chan<- any) {
 		for _, uid := range uids {
 			source <- uid
 		}
-	}, func(item interface{}, writer Writer, cancel func(error)) {
+	}, func(item any, writer Writer, cancel func(error)) {
 		writer.Write(item)
-	}, func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
+	}, func(pipe <-chan any, writer Writer, cancel func(error)) {
 		drain(pipe)
 		// not calling writer.Write(...), should not panic
 	})
@@ -542,15 +542,15 @@ func TestMapReduceVoidPanicInReducer(t *testing.T) {
 	const message = "foo"
 	assert.Panics(t, func() {
 		var done int32
-		_ = MapReduceVoid(func(source chan<- interface{}) {
+		_ = MapReduceVoid(func(source chan<- any) {
 			for i := 0; i < defaultWorkers*2; i++ {
 				source <- i
 			}
 			atomic.AddInt32(&done, 1)
-		}, func(item interface{}, writer Writer, cancel func(error)) {
+		}, func(item any, writer Writer, cancel func(error)) {
 			i := item.(int)
 			writer.Write(i)
-		}, func(pipe <-chan interface{}, cancel func(error)) {
+		}, func(pipe <-chan any, cancel func(error)) {
 			panic(message)
 		}, WithWorkers(1))
 	})
@@ -561,12 +561,12 @@ func TestForEachWithContext(t *testing.T) {
 
 	var done int32
 	ctx, cancel := context.WithCancel(context.Background())
-	ForEach(func(source chan<- interface{}) {
+	ForEach(func(source chan<- any) {
 		for i := 0; i < defaultWorkers*2; i++ {
 			source <- i
 		}
 		atomic.AddInt32(&done, 1)
-	}, func(item interface{}) {
+	}, func(item any) {
 		i := item.(int)
 		if i == defaultWorkers/2 {
 			cancel()
@@ -580,18 +580,18 @@ func TestMapReduceWithContext(t *testing.T) {
 	var done int32
 	var result []int
 	ctx, cancel := context.WithCancel(context.Background())
-	err := MapReduceVoid(func(source chan<- interface{}) {
+	err := MapReduceVoid(func(source chan<- any) {
 		for i := 0; i < defaultWorkers*2; i++ {
 			source <- i
 		}
 		atomic.AddInt32(&done, 1)
-	}, func(item interface{}, writer Writer, c func(error)) {
+	}, func(item any, writer Writer, c func(error)) {
 		i := item.(int)
 		if i == defaultWorkers/2 {
 			cancel()
 		}
 		writer.Write(i)
-	}, func(pipe <-chan interface{}, cancel func(error)) {
+	}, func(pipe <-chan any, cancel func(error)) {
 		for item := range pipe {
 			i := item.(int)
 			result = append(result, i)
@@ -604,10 +604,10 @@ func TestMapReduceWithContext(t *testing.T) {
 func BenchmarkMapReduce(b *testing.B) {
 	b.ReportAllocs()
 
-	mapper := func(v interface{}, writer Writer, cancel func(error)) {
+	mapper := func(v any, writer Writer, cancel func(error)) {
 		writer.Write(v.(int64) * v.(int64))
 	}
-	reducer := func(input <-chan interface{}, writer Writer, cancel func(error)) {
+	reducer := func(input <-chan any, writer Writer, cancel func(error)) {
 		var result int64
 		for v := range input {
 			result += v.(int64)
@@ -616,7 +616,7 @@ func BenchmarkMapReduce(b *testing.B) {
 	}
 
 	for i := 0; i < b.N; i++ {
-		MapReduce(func(input chan<- interface{}) {
+		MapReduce(func(input chan<- any) {
 			for j := 0; j < 2; j++ {
 				input <- int64(j)
 			}

core/mr/readme-cn.md

@@ -58,16 +58,16 @@ import (
 )
 
 func main() {
-    val, err := mr.MapReduce(func(source chan<- interface{}) {
+    val, err := mr.MapReduce(func(source chan<- any) {
         // generator
         for i := 0; i < 10; i++ {
             source <- i
         }
-    }, func(item interface{}, writer mr.Writer, cancel func(error)) {
+    }, func(item any, writer mr.Writer, cancel func(error)) {
         // mapper
         i := item.(int)
         writer.Write(i * i)
-    }, func(pipe <-chan interface{}, writer mr.Writer, cancel func(error)) {
+    }, func(pipe <-chan any, writer mr.Writer, cancel func(error)) {
         // reducer
         var sum int
         for i := range pipe {

core/mr/readme.md

@@ -59,16 +59,16 @@ import (
 )
 
 func main() {
-    val, err := mr.MapReduce(func(source chan<- interface{}) {
+    val, err := mr.MapReduce(func(source chan<- any) {
         // generator
         for i := 0; i < 10; i++ {
             source <- i
         }
-    }, func(item interface{}, writer mr.Writer, cancel func(error)) {
+    }, func(item any, writer mr.Writer, cancel func(error)) {
         // mapper
         i := item.(int)
         writer.Write(i * i)
-    }, func(pipe <-chan interface{}, writer mr.Writer, cancel func(error)) {
+    }, func(pipe <-chan any, writer mr.Writer, cancel func(error)) {
         // reducer
         var sum int
         for i := range pipe {

core/proc/shutdown.go

@@ -43,6 +43,16 @@ func SetTimeToForceQuit(duration time.Duration) {
 	delayTimeBeforeForceQuit = duration
 }
 
+// Shutdown calls the registered shutdown listeners, only for test purpose.
+func Shutdown() {
+	shutdownListeners.notifyListeners()
+}
+
+// WrapUp wraps up the process, only for test purpose.
+func WrapUp() {
+	wrapUpListeners.notifyListeners()
+}
+
 func gracefulStop(signals chan os.Signal) {
 	signal.Stop(signals)
 

core/proc/shutdown_test.go

@@ -18,14 +18,14 @@ func TestShutdown(t *testing.T) {
 	called := AddWrapUpListener(func() {
 		val++
 	})
-	wrapUpListeners.notifyListeners()
+	WrapUp()
 	called()
 	assert.Equal(t, 1, val)
 
 	called = AddShutdownListener(func() {
 		val += 2
 	})
-	shutdownListeners.notifyListeners()
+	Shutdown()
 	called()
 	assert.Equal(t, 3, val)
 }

core/queue/consumer.go

@@ -4,7 +4,7 @@ type (
 	// A Consumer interface represents a consumer that can consume string messages.
 	Consumer interface {
 		Consume(string) error
-		OnEvent(event interface{})
+		OnEvent(event any)
 	}
 
 	// ConsumerFactory defines the factory to generate consumers.

core/queue/queue.go

@@ -31,7 +31,7 @@ type (
 		quit                 chan struct{}
 		listeners            []Listener
 		eventLock            sync.Mutex
-		eventChannels        []chan interface{}
+		eventChannels        []chan any
 	}
 
 	// A Listener interface represents a listener that can be notified with queue events.
@@ -77,7 +77,7 @@ func (q *Queue) AddListener(listener Listener) {
 }
 
 // Broadcast broadcasts message to all event channels.
-func (q *Queue) Broadcast(message interface{}) {
+func (q *Queue) Broadcast(message any) {
 	go func() {
 		q.eventLock.Lock()
 		defer q.eventLock.Unlock()
@@ -119,7 +119,7 @@ func (q *Queue) Stop() {
 	close(q.quit)
 }
 
-func (q *Queue) consume(eventChan chan interface{}) {
+func (q *Queue) consume(eventChan chan any) {
 	var consumer Consumer
 
 	for {
@@ -216,7 +216,7 @@ func (q *Queue) resume() {
 
 func (q *Queue) startConsumers(number int) {
 	for i := 0; i < number; i++ {
-		eventChan := make(chan interface{})
+		eventChan := make(chan any)
 		q.eventLock.Lock()
 		q.eventChannels = append(q.eventChannels, eventChan)
 		q.eventLock.Unlock()

core/queue/queue_test.go

@@ -52,7 +52,7 @@ func (c *mockedConsumer) Consume(string) error {
 	return nil
 }
 
-func (c *mockedConsumer) OnEvent(interface{}) {
+func (c *mockedConsumer) OnEvent(any) {
 	if atomic.AddInt32(&c.events, 1) <= consumers {
 		c.wait.Done()
 	}

core/search/tree.go

@@ -35,7 +35,7 @@ type (
 	}
 
 	node struct {
-		item     interface{}
+		item     any
 		children [2]map[string]*node
 	}
 
@@ -46,7 +46,7 @@ type (
 
 	// A Result is a search result from tree.
 	Result struct {
-		Item   interface{}
+		Item   any
 		Params map[string]string
 	}
 )
@@ -59,7 +59,7 @@ func NewTree() *Tree {
 }
 
 // Add adds item to associate with route.
-func (t *Tree) Add(route string, item interface{}) error {
+func (t *Tree) Add(route string, item any) error {
 	if len(route) == 0 || route[0] != slash {
 		return errNotFromRoot
 	}
@@ -149,7 +149,7 @@ func (nd *node) getChildren(route string) map[string]*node {
 	return nd.children[0]
 }
 
-func add(nd *node, route string, item interface{}) error {
+func add(nd *node, route string, item any) error {
 	if len(route) == 0 {
 		if nd.item != nil {
 			return errDupItem
@@ -228,7 +228,7 @@ func match(pat, token string) innerResult {
 	}
 }
 
-func newNode(item interface{}) *node {
+func newNode(item any) *node {
 	return &node{
 		item: item,
 		children: [2]map[string]*node{

core/service/serviceconf_test.go

@@ -3,6 +3,7 @@ package service
 import (
 	"testing"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/zeromicro/go-zero/core/logx"
 )
 
@@ -16,3 +17,15 @@ func TestServiceConf(t *testing.T) {
 	}
 	c.MustSetUp()
 }
+
+func TestServiceConfWithMetricsUrl(t *testing.T) {
+	c := ServiceConf{
+		Name: "foo",
+		Log: logx.LogConf{
+			Mode: "volume",
+		},
+		Mode:       "dev",
+		MetricsUrl: "http://localhost:8080",
+	}
+	assert.NoError(t, c.SetUp())
+}

core/service/servicegroup_test.go

@@ -5,6 +5,7 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/zeromicro/go-zero/core/proc"
 )
 
 var (
@@ -55,6 +56,7 @@ func TestServiceGroup(t *testing.T) {
 	}
 
 	group.Stop()
+	proc.Shutdown()
 
 	mutex.Lock()
 	defer mutex.Unlock()

core/stat/metrics.go

@@ -104,7 +104,7 @@ type (
 	}
 )
 
-func (c *metricsContainer) AddTask(v interface{}) bool {
+func (c *metricsContainer) AddTask(v any) bool {
 	if task, ok := v.(Task); ok {
 		if task.Drop {
 			c.drops++
@@ -117,7 +117,7 @@ func (c *metricsContainer) AddTask(v interface{}) bool {
 	return false
 }
 
-func (c *metricsContainer) Execute(v interface{}) {
+func (c *metricsContainer) Execute(v any) {
 	pair := v.(tasksDurationPair)
 	tasks := pair.tasks
 	duration := pair.duration
@@ -180,7 +180,7 @@ func (c *metricsContainer) Execute(v interface{}) {
 	log(report)
 }
 
-func (c *metricsContainer) RemoveAll() interface{} {
+func (c *metricsContainer) RemoveAll() any {
 	tasks := c.tasks
 	duration := c.duration
 	drops := c.drops

core/stat/topk.go

@@ -16,11 +16,11 @@ func (h *taskHeap) Swap(i, j int) {
 	(*h)[i], (*h)[j] = (*h)[j], (*h)[i]
 }
 
-func (h *taskHeap) Push(x interface{}) {
+func (h *taskHeap) Push(x any) {
 	*h = append(*h, x.(Task))
 }
 
-func (h *taskHeap) Pop() interface{} {
+func (h *taskHeap) Pop() any {
 	old := *h
 	n := len(old)
 	x := old[n-1]

core/stores/builder/builder.go

@@ -9,7 +9,7 @@ import (
 const dbTag = "db"
 
 // RawFieldNames converts golang struct field into slice string.
-func RawFieldNames(in interface{}, postgresSql ...bool) []string {
+func RawFieldNames(in any, postgresSql ...bool) []string {
 	out := make([]string, 0)
 	v := reflect.ValueOf(in)
 	if v.Kind() == reflect.Ptr {

core/stores/cache/cache.go

@@ -20,32 +20,32 @@ type (
 		// DelCtx deletes cached values with keys.
 		DelCtx(ctx context.Context, keys ...string) error
 		// Get gets the cache with key and fills into v.
-		Get(key string, val interface{}) error
+		Get(key string, val any) error
 		// GetCtx gets the cache with key and fills into v.
-		GetCtx(ctx context.Context, key string, val interface{}) error
+		GetCtx(ctx context.Context, key string, val any) error
 		// IsNotFound checks if the given error is the defined errNotFound.
 		IsNotFound(err error) bool
 		// Set sets the cache with key and v, using c.expiry.
-		Set(key string, val interface{}) error
+		Set(key string, val any) error
 		// SetCtx sets the cache with key and v, using c.expiry.
-		SetCtx(ctx context.Context, key string, val interface{}) error
+		SetCtx(ctx context.Context, key string, val any) error
 		// SetWithExpire sets the cache with key and v, using given expire.
-		SetWithExpire(key string, val interface{}, expire time.Duration) error
+		SetWithExpire(key string, val any, expire time.Duration) error
 		// SetWithExpireCtx sets the cache with key and v, using given expire.
-		SetWithExpireCtx(ctx context.Context, key string, val interface{}, expire time.Duration) error
+		SetWithExpireCtx(ctx context.Context, key string, val any, expire time.Duration) error
 		// Take takes the result from cache first, if not found,
 		// query from DB and set cache using c.expiry, then return the result.
-		Take(val interface{}, key string, query func(val interface{}) error) error
+		Take(val any, key string, query func(val any) error) error
 		// TakeCtx takes the result from cache first, if not found,
 		// query from DB and set cache using c.expiry, then return the result.
-		TakeCtx(ctx context.Context, val interface{}, key string, query func(val interface{}) error) error
+		TakeCtx(ctx context.Context, val any, key string, query func(val any) error) error
 		// TakeWithExpire takes the result from cache first, if not found,
 		// query from DB and set cache using given expire, then return the result.
-		TakeWithExpire(val interface{}, key string, query func(val interface{}, expire time.Duration) error) error
+		TakeWithExpire(val any, key string, query func(val any, expire time.Duration) error) error
 		// TakeWithExpireCtx takes the result from cache first, if not found,
 		// query from DB and set cache using given expire, then return the result.
-		TakeWithExpireCtx(ctx context.Context, val interface{}, key string,
-			query func(val interface{}, expire time.Duration) error) error
+		TakeWithExpireCtx(ctx context.Context, val any, key string,
+			query func(val any, expire time.Duration) error) error
 	}
 
 	cacheCluster struct {
@@ -97,7 +97,7 @@ func (cc cacheCluster) DelCtx(ctx context.Context, keys ...string) error {
 		return c.(Cache).DelCtx(ctx, key)
 	default:
 		var be errorx.BatchError
-		nodes := make(map[interface{}][]string)
+		nodes := make(map[any][]string)
 		for _, key := range keys {
 			c, ok := cc.dispatcher.Get(key)
 			if !ok {
@@ -118,12 +118,12 @@ func (cc cacheCluster) DelCtx(ctx context.Context, keys ...string) error {
 }
 
 // Get gets the cache with key and fills into v.
-func (cc cacheCluster) Get(key string, val interface{}) error {
+func (cc cacheCluster) Get(key string, val any) error {
 	return cc.GetCtx(context.Background(), key, val)
 }
 
 // GetCtx gets the cache with key and fills into v.
-func (cc cacheCluster) GetCtx(ctx context.Context, key string, val interface{}) error {
+func (cc cacheCluster) GetCtx(ctx context.Context, key string, val any) error {
 	c, ok := cc.dispatcher.Get(key)
 	if !ok {
 		return cc.errNotFound
@@ -138,12 +138,12 @@ func (cc cacheCluster) IsNotFound(err error) bool {
 }
 
 // Set sets the cache with key and v, using c.expiry.
-func (cc cacheCluster) Set(key string, val interface{}) error {
+func (cc cacheCluster) Set(key string, val any) error {
 	return cc.SetCtx(context.Background(), key, val)
 }
 
 // SetCtx sets the cache with key and v, using c.expiry.
-func (cc cacheCluster) SetCtx(ctx context.Context, key string, val interface{}) error {
+func (cc cacheCluster) SetCtx(ctx context.Context, key string, val any) error {
 	c, ok := cc.dispatcher.Get(key)
 	if !ok {
 		return cc.errNotFound
@@ -153,12 +153,12 @@ func (cc cacheCluster) SetCtx(ctx context.Context, key string, val interface{})
 }
 
 // SetWithExpire sets the cache with key and v, using given expire.
-func (cc cacheCluster) SetWithExpire(key string, val interface{}, expire time.Duration) error {
+func (cc cacheCluster) SetWithExpire(key string, val any, expire time.Duration) error {
 	return cc.SetWithExpireCtx(context.Background(), key, val, expire)
 }
 
 // SetWithExpireCtx sets the cache with key and v, using given expire.
-func (cc cacheCluster) SetWithExpireCtx(ctx context.Context, key string, val interface{}, expire time.Duration) error {
+func (cc cacheCluster) SetWithExpireCtx(ctx context.Context, key string, val any, expire time.Duration) error {
 	c, ok := cc.dispatcher.Get(key)
 	if !ok {
 		return cc.errNotFound
@@ -169,13 +169,13 @@ func (cc cacheCluster) SetWithExpireCtx(ctx context.Context, key string, val int
 
 // Take takes the result from cache first, if not found,
 // query from DB and set cache using c.expiry, then return the result.
-func (cc cacheCluster) Take(val interface{}, key string, query func(val interface{}) error) error {
+func (cc cacheCluster) Take(val any, key string, query func(val any) error) error {
 	return cc.TakeCtx(context.Background(), val, key, query)
 }
 
 // TakeCtx takes the result from cache first, if not found,
 // query from DB and set cache using c.expiry, then return the result.
-func (cc cacheCluster) TakeCtx(ctx context.Context, val interface{}, key string, query func(val interface{}) error) error {
+func (cc cacheCluster) TakeCtx(ctx context.Context, val any, key string, query func(val any) error) error {
 	c, ok := cc.dispatcher.Get(key)
 	if !ok {
 		return cc.errNotFound
@@ -186,13 +186,13 @@ func (cc cacheCluster) TakeCtx(ctx context.Context, val interface{}, key string,
 
 // TakeWithExpire takes the result from cache first, if not found,
 // query from DB and set cache using given expire, then return the result.
-func (cc cacheCluster) TakeWithExpire(val interface{}, key string, query func(val interface{}, expire time.Duration) error) error {
+func (cc cacheCluster) TakeWithExpire(val any, key string, query func(val any, expire time.Duration) error) error {
 	return cc.TakeWithExpireCtx(context.Background(), val, key, query)
 }
 
 // TakeWithExpireCtx takes the result from cache first, if not found,
 // query from DB and set cache using given expire, then return the result.
-func (cc cacheCluster) TakeWithExpireCtx(ctx context.Context, val interface{}, key string, query func(val interface{}, expire time.Duration) error) error {
+func (cc cacheCluster) TakeWithExpireCtx(ctx context.Context, val any, key string, query func(val any, expire time.Duration) error) error {
 	c, ok := cc.dispatcher.Get(key)
 	if !ok {
 		return cc.errNotFound

core/stores/cache/cache_test.go

@@ -44,11 +44,11 @@ func (mc *mockedNode) DelCtx(_ context.Context, keys ...string) error {
 	return be.Err()
 }
 
-func (mc *mockedNode) Get(key string, val interface{}) error {
+func (mc *mockedNode) Get(key string, val any) error {
 	return mc.GetCtx(context.Background(), key, val)
 }
 
-func (mc *mockedNode) GetCtx(ctx context.Context, key string, val interface{}) error {
+func (mc *mockedNode) GetCtx(ctx context.Context, key string, val any) error {
 	bs, ok := mc.vals[key]
 	if ok {
 		return json.Unmarshal(bs, val)
@@ -61,11 +61,11 @@ func (mc *mockedNode) IsNotFound(err error) bool {
 	return errors.Is(err, mc.errNotFound)
 }
 
-func (mc *mockedNode) Set(key string, val interface{}) error {
+func (mc *mockedNode) Set(key string, val any) error {
 	return mc.SetCtx(context.Background(), key, val)
 }
 
-func (mc *mockedNode) SetCtx(ctx context.Context, key string, val interface{}) error {
+func (mc *mockedNode) SetCtx(ctx context.Context, key string, val any) error {
 	data, err := json.Marshal(val)
 	if err != nil {
 		return err
@@ -75,19 +75,19 @@ func (mc *mockedNode) SetCtx(ctx context.Context, key string, val interface{}) e
 	return nil
 }
 
-func (mc *mockedNode) SetWithExpire(key string, val interface{}, expire time.Duration) error {
+func (mc *mockedNode) SetWithExpire(key string, val any, expire time.Duration) error {
 	return mc.SetWithExpireCtx(context.Background(), key, val, expire)
 }
 
-func (mc *mockedNode) SetWithExpireCtx(ctx context.Context, key string, val interface{}, expire time.Duration) error {
+func (mc *mockedNode) SetWithExpireCtx(ctx context.Context, key string, val any, expire time.Duration) error {
 	return mc.Set(key, val)
 }
 
-func (mc *mockedNode) Take(val interface{}, key string, query func(val interface{}) error) error {
+func (mc *mockedNode) Take(val any, key string, query func(val any) error) error {
 	return mc.TakeCtx(context.Background(), val, key, query)
 }
 
-func (mc *mockedNode) TakeCtx(ctx context.Context, val interface{}, key string, query func(val interface{}) error) error {
+func (mc *mockedNode) TakeCtx(ctx context.Context, val any, key string, query func(val any) error) error {
 	if _, ok := mc.vals[key]; ok {
 		return mc.GetCtx(ctx, key, val)
 	}
@@ -99,12 +99,12 @@ func (mc *mockedNode) TakeCtx(ctx context.Context, val interface{}, key string,
 	return mc.SetCtx(ctx, key, val)
 }
 
-func (mc *mockedNode) TakeWithExpire(val interface{}, key string, query func(val interface{}, expire time.Duration) error) error {
+func (mc *mockedNode) TakeWithExpire(val any, key string, query func(val any, expire time.Duration) error) error {
 	return mc.TakeWithExpireCtx(context.Background(), val, key, query)
 }
 
-func (mc *mockedNode) TakeWithExpireCtx(ctx context.Context, val interface{}, key string, query func(val interface{}, expire time.Duration) error) error {
-	return mc.Take(val, key, func(val interface{}) error {
+func (mc *mockedNode) TakeWithExpireCtx(ctx context.Context, val any, key string, query func(val any, expire time.Duration) error) error {
+	return mc.Take(val, key, func(val any) error {
 		return query(val, 0)
 	})
 }
@@ -279,13 +279,13 @@ func TestCache_Balance(t *testing.T) {
 	for i := 0; i < total/10; i++ {
 		var val int
 		if i%2 == 0 {
-			assert.Nil(t, c.Take(&val, strconv.Itoa(i*10), func(val interface{}) error {
+			assert.Nil(t, c.Take(&val, strconv.Itoa(i*10), func(val any) error {
 				*val.(*int) = i
 				count++
 				return nil
 			}))
 		} else {
-			assert.Nil(t, c.TakeWithExpire(&val, strconv.Itoa(i*10), func(val interface{}, expire time.Duration) error {
+			assert.Nil(t, c.TakeWithExpire(&val, strconv.Itoa(i*10), func(val any, expire time.Duration) error {
 				*val.(*int) = i
 				count++
 				return nil
@@ -307,10 +307,10 @@ func TestCacheNoNode(t *testing.T) {
 	assert.NotNil(t, c.Get("foo", nil))
 	assert.NotNil(t, c.Set("foo", nil))
 	assert.NotNil(t, c.SetWithExpire("foo", nil, time.Second))
-	assert.NotNil(t, c.Take(nil, "foo", func(val interface{}) error {
+	assert.NotNil(t, c.Take(nil, "foo", func(val any) error {
 		return nil
 	}))
-	assert.NotNil(t, c.TakeWithExpire(nil, "foo", func(val interface{}, duration time.Duration) error {
+	assert.NotNil(t, c.TakeWithExpire(nil, "foo", func(val any, duration time.Duration) error {
 		return nil
 	}))
 }

core/stores/cache/cachenode.go

@@ -89,12 +89,12 @@ func (c cacheNode) DelCtx(ctx context.Context, keys ...string) error {
 }
 
 // Get gets the cache with key and fills into v.
-func (c cacheNode) Get(key string, val interface{}) error {
+func (c cacheNode) Get(key string, val any) error {
 	return c.GetCtx(context.Background(), key, val)
 }
 
 // GetCtx gets the cache with key and fills into v.
-func (c cacheNode) GetCtx(ctx context.Context, key string, val interface{}) error {
+func (c cacheNode) GetCtx(ctx context.Context, key string, val any) error {
 	err := c.doGetCache(ctx, key, val)
 	if err == errPlaceholder {
 		return c.errNotFound
@@ -109,22 +109,22 @@ func (c cacheNode) IsNotFound(err error) bool {
 }
 
 // Set sets the cache with key and v, using c.expiry.
-func (c cacheNode) Set(key string, val interface{}) error {
+func (c cacheNode) Set(key string, val any) error {
 	return c.SetCtx(context.Background(), key, val)
 }
 
 // SetCtx sets the cache with key and v, using c.expiry.
-func (c cacheNode) SetCtx(ctx context.Context, key string, val interface{}) error {
+func (c cacheNode) SetCtx(ctx context.Context, key string, val any) error {
 	return c.SetWithExpireCtx(ctx, key, val, c.aroundDuration(c.expiry))
 }
 
 // SetWithExpire sets the cache with key and v, using given expire.
-func (c cacheNode) SetWithExpire(key string, val interface{}, expire time.Duration) error {
+func (c cacheNode) SetWithExpire(key string, val any, expire time.Duration) error {
 	return c.SetWithExpireCtx(context.Background(), key, val, expire)
 }
 
 // SetWithExpireCtx sets the cache with key and v, using given expire.
-func (c cacheNode) SetWithExpireCtx(ctx context.Context, key string, val interface{},
+func (c cacheNode) SetWithExpireCtx(ctx context.Context, key string, val any,
 	expire time.Duration) error {
 	data, err := jsonx.Marshal(val)
 	if err != nil {
@@ -141,34 +141,34 @@ func (c cacheNode) String() string {
 
 // Take takes the result from cache first, if not found,
 // query from DB and set cache using c.expiry, then return the result.
-func (c cacheNode) Take(val interface{}, key string, query func(val interface{}) error) error {
+func (c cacheNode) Take(val any, key string, query func(val any) error) error {
 	return c.TakeCtx(context.Background(), val, key, query)
 }
 
 // TakeCtx takes the result from cache first, if not found,
 // query from DB and set cache using c.expiry, then return the result.
-func (c cacheNode) TakeCtx(ctx context.Context, val interface{}, key string,
-	query func(val interface{}) error) error {
-	return c.doTake(ctx, val, key, query, func(v interface{}) error {
+func (c cacheNode) TakeCtx(ctx context.Context, val any, key string,
+	query func(val any) error) error {
+	return c.doTake(ctx, val, key, query, func(v any) error {
 		return c.SetCtx(ctx, key, v)
 	})
 }
 
 // TakeWithExpire takes the result from cache first, if not found,
 // query from DB and set cache using given expire, then return the result.
-func (c cacheNode) TakeWithExpire(val interface{}, key string, query func(val interface{},
+func (c cacheNode) TakeWithExpire(val any, key string, query func(val any,
 	expire time.Duration) error) error {
 	return c.TakeWithExpireCtx(context.Background(), val, key, query)
 }
 
 // TakeWithExpireCtx takes the result from cache first, if not found,
 // query from DB and set cache using given expire, then return the result.
-func (c cacheNode) TakeWithExpireCtx(ctx context.Context, val interface{}, key string,
-	query func(val interface{}, expire time.Duration) error) error {
+func (c cacheNode) TakeWithExpireCtx(ctx context.Context, val any, key string,
+	query func(val any, expire time.Duration) error) error {
 	expire := c.aroundDuration(c.expiry)
-	return c.doTake(ctx, val, key, func(v interface{}) error {
+	return c.doTake(ctx, val, key, func(v any) error {
 		return query(v, expire)
-	}, func(v interface{}) error {
+	}, func(v any) error {
 		return c.SetWithExpireCtx(ctx, key, v, expire)
 	})
 }
@@ -184,7 +184,7 @@ func (c cacheNode) asyncRetryDelCache(keys ...string) {
 	}, keys...)
 }
 
-func (c cacheNode) doGetCache(ctx context.Context, key string, v interface{}) error {
+func (c cacheNode) doGetCache(ctx context.Context, key string, v any) error {
 	c.stat.IncrementTotal()
 	data, err := c.rds.GetCtx(ctx, key)
 	if err != nil {
@@ -205,10 +205,10 @@ func (c cacheNode) doGetCache(ctx context.Context, key string, v interface{}) er
 	return c.processCache(ctx, key, data, v)
 }
 
-func (c cacheNode) doTake(ctx context.Context, v interface{}, key string,
-	query func(v interface{}) error, cacheVal func(v interface{}) error) error {
+func (c cacheNode) doTake(ctx context.Context, v any, key string,
+	query func(v any) error, cacheVal func(v any) error) error {
 	logger := logx.WithContext(ctx)
-	val, fresh, err := c.barrier.DoEx(key, func() (interface{}, error) {
+	val, fresh, err := c.barrier.DoEx(key, func() (any, error) {
 		if err := c.doGetCache(ctx, key, v); err != nil {
 			if err == errPlaceholder {
 				return nil, c.errNotFound
@@ -255,7 +255,7 @@ func (c cacheNode) doTake(ctx context.Context, v interface{}, key string,
 	return jsonx.Unmarshal(val.([]byte), v)
 }
 
-func (c cacheNode) processCache(ctx context.Context, key, data string, v interface{}) error {
+func (c cacheNode) processCache(ctx context.Context, key, data string, v any) error {
 	err := jsonx.Unmarshal([]byte(data), v)
 	if err == nil {
 		return nil

core/stores/cache/cachenode_test.go

@@ -1,3 +1,6 @@
+//go:build !race
+
+// Disable data race detection is because of the timingWheel in cacheNode.
 package cache
 
 import (
@@ -59,7 +62,7 @@ func TestCacheNode_DelCache(t *testing.T) {
 		ticker := timex.NewFakeTicker()
 		var err error
 		timingWheel, err = collection.NewTimingWheelWithTicker(
-			time.Millisecond, timingWheelSlots, func(key, value interface{}) {
+			time.Millisecond, timingWheelSlots, func(key, value any) {
 				clean(key, value)
 			}, ticker)
 		assert.NoError(t, err)
@@ -143,7 +146,7 @@ func TestCacheNode_Take(t *testing.T) {
 	cn := NewNode(store, syncx.NewSingleFlight(), NewStat("any"), errTestNotFound,
 		WithExpiry(time.Second), WithNotFoundExpiry(time.Second))
 	var str string
-	err = cn.Take(&str, "any", func(v interface{}) error {
+	err = cn.Take(&str, "any", func(v any) error {
 		*v.(*string) = "value"
 		return nil
 	})
@@ -164,7 +167,7 @@ func TestCacheNode_TakeBadRedis(t *testing.T) {
 	cn := NewNode(redis.New(r.Addr()), syncx.NewSingleFlight(), NewStat("any"),
 		errTestNotFound, WithExpiry(time.Second), WithNotFoundExpiry(time.Second))
 	var str string
-	assert.Error(t, cn.Take(&str, "any", func(v interface{}) error {
+	assert.Error(t, cn.Take(&str, "any", func(v any) error {
 		*v.(*string) = "value"
 		return nil
 	}))
@@ -185,7 +188,7 @@ func TestCacheNode_TakeNotFound(t *testing.T) {
 		errNotFound:    errTestNotFound,
 	}
 	var str string
-	err = cn.Take(&str, "any", func(v interface{}) error {
+	err = cn.Take(&str, "any", func(v any) error {
 		return errTestNotFound
 	})
 	assert.True(t, cn.IsNotFound(err))
@@ -195,7 +198,7 @@ func TestCacheNode_TakeNotFound(t *testing.T) {
 	assert.Equal(t, `*`, val)
 
 	store.Set("any", "*")
-	err = cn.Take(&str, "any", func(v interface{}) error {
+	err = cn.Take(&str, "any", func(v any) error {
 		return nil
 	})
 	assert.True(t, cn.IsNotFound(err))
@@ -203,7 +206,7 @@ func TestCacheNode_TakeNotFound(t *testing.T) {
 
 	store.Del("any")
 	errDummy := errors.New("dummy")
-	err = cn.Take(&str, "any", func(v interface{}) error {
+	err = cn.Take(&str, "any", func(v any) error {
 		return errDummy
 	})
 	assert.Equal(t, errDummy, err)
@@ -224,7 +227,7 @@ func TestCacheNode_TakeWithExpire(t *testing.T) {
 		errNotFound:    errors.New("any"),
 	}
 	var str string
-	err = cn.TakeWithExpire(&str, "any", func(v interface{}, expire time.Duration) error {
+	err = cn.TakeWithExpire(&str, "any", func(v any, expire time.Duration) error {
 		*v.(*string) = "value"
 		return nil
 	})
@@ -274,7 +277,7 @@ func TestCacheValueWithBigInt(t *testing.T) {
 	)
 
 	assert.Nil(t, cn.Set(key, value))
-	var val interface{}
+	var val any
 	assert.Nil(t, cn.Get(key, &val))
 	assert.Equal(t, strconv.FormatInt(value, 10), fmt.Sprintf("%v", val))
 }

core/stores/cache/cleaner.go

@@ -48,7 +48,7 @@ func AddCleanTask(task func() error, keys ...string) {
 	}, time.Second)
 }
 
-func clean(key, value interface{}) {
+func clean(key, value any) {
 	taskRunner.Schedule(func() {
 		dt := value.(delayTask)
 		err := dt.task()

core/stores/cache/cleaner_test.go

@@ -5,6 +5,7 @@ import (
 	"time"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/zeromicro/go-zero/core/proc"
 )
 
 func TestNextDelay(t *testing.T) {
@@ -51,6 +52,7 @@ func TestNextDelay(t *testing.T) {
 			next, ok := nextDelay(test.input)
 			assert.Equal(t, test.ok, ok)
 			assert.Equal(t, test.output, next)
+			proc.Shutdown()
 		})
 	}
 }

core/stores/kv/store.go

@@ -23,8 +23,8 @@ type (
 		DecrbyCtx(ctx context.Context, key string, decrement int64) (int64, error)
 		Del(keys ...string) (int, error)
 		DelCtx(ctx context.Context, keys ...string) (int, error)
-		Eval(script, key string, args ...interface{}) (interface{}, error)
-		EvalCtx(ctx context.Context, script, key string, args ...interface{}) (interface{}, error)
+		Eval(script, key string, args ...any) (any, error)
+		EvalCtx(ctx context.Context, script, key string, args ...any) (any, error)
 		Exists(key string) (bool, error)
 		ExistsCtx(ctx context.Context, key string) (bool, error)
 		Expire(key string, seconds int) error
@@ -69,22 +69,22 @@ type (
 		LlenCtx(ctx context.Context, key string) (int, error)
 		Lpop(key string) (string, error)
 		LpopCtx(ctx context.Context, key string) (string, error)
-		Lpush(key string, values ...interface{}) (int, error)
-		LpushCtx(ctx context.Context, key string, values ...interface{}) (int, error)
+		Lpush(key string, values ...any) (int, error)
+		LpushCtx(ctx context.Context, key string, values ...any) (int, error)
 		Lrange(key string, start, stop int) ([]string, error)
 		LrangeCtx(ctx context.Context, key string, start, stop int) ([]string, error)
 		Lrem(key string, count int, value string) (int, error)
 		LremCtx(ctx context.Context, key string, count int, value string) (int, error)
 		Persist(key string) (bool, error)
 		PersistCtx(ctx context.Context, key string) (bool, error)
-		Pfadd(key string, values ...interface{}) (bool, error)
-		PfaddCtx(ctx context.Context, key string, values ...interface{}) (bool, error)
+		Pfadd(key string, values ...any) (bool, error)
+		PfaddCtx(ctx context.Context, key string, values ...any) (bool, error)
 		Pfcount(key string) (int64, error)
 		PfcountCtx(ctx context.Context, key string) (int64, error)
-		Rpush(key string, values ...interface{}) (int, error)
-		RpushCtx(ctx context.Context, key string, values ...interface{}) (int, error)
-		Sadd(key string, values ...interface{}) (int, error)
-		SaddCtx(ctx context.Context, key string, values ...interface{}) (int, error)
+		Rpush(key string, values ...any) (int, error)
+		RpushCtx(ctx context.Context, key string, values ...any) (int, error)
+		Sadd(key string, values ...any) (int, error)
+		SaddCtx(ctx context.Context, key string, values ...any) (int, error)
 		Scard(key string) (int64, error)
 		ScardCtx(ctx context.Context, key string) (int64, error)
 		Set(key, value string) error
@@ -95,16 +95,16 @@ type (
 		SetnxCtx(ctx context.Context, key, value string) (bool, error)
 		SetnxEx(key, value string, seconds int) (bool, error)
 		SetnxExCtx(ctx context.Context, key, value string, seconds int) (bool, error)
-		Sismember(key string, value interface{}) (bool, error)
-		SismemberCtx(ctx context.Context, key string, value interface{}) (bool, error)
+		Sismember(key string, value any) (bool, error)
+		SismemberCtx(ctx context.Context, key string, value any) (bool, error)
 		Smembers(key string) ([]string, error)
 		SmembersCtx(ctx context.Context, key string) ([]string, error)
 		Spop(key string) (string, error)
 		SpopCtx(ctx context.Context, key string) (string, error)
 		Srandmember(key string, count int) ([]string, error)
 		SrandmemberCtx(ctx context.Context, key string, count int) ([]string, error)
-		Srem(key string, values ...interface{}) (int, error)
-		SremCtx(ctx context.Context, key string, values ...interface{}) (int, error)
+		Srem(key string, values ...any) (int, error)
+		SremCtx(ctx context.Context, key string, values ...any) (int, error)
 		Sscan(key string, cursor uint64, match string, count int64) (keys []string, cur uint64, err error)
 		SscanCtx(ctx context.Context, key string, cursor uint64, match string, count int64) (keys []string, cur uint64, err error)
 		Ttl(key string) (int, error)
@@ -131,8 +131,8 @@ type (
 		ZrangebyscoreWithScoresAndLimitCtx(ctx context.Context, key string, start, stop int64, page, size int) ([]redis.Pair, error)
 		Zrank(key, field string) (int64, error)
 		ZrankCtx(ctx context.Context, key, field string) (int64, error)
-		Zrem(key string, values ...interface{}) (int, error)
-		ZremCtx(ctx context.Context, key string, values ...interface{}) (int, error)
+		Zrem(key string, values ...any) (int, error)
+		ZremCtx(ctx context.Context, key string, values ...any) (int, error)
 		Zremrangebyrank(key string, start, stop int64) (int, error)
 		ZremrangebyrankCtx(ctx context.Context, key string, start, stop int64) (int, error)
 		Zremrangebyscore(key string, start, stop int64) (int, error)
@@ -224,11 +224,11 @@ func (cs clusterStore) DelCtx(ctx context.Context, keys ...string) (int, error)
 	return val, be.Err()
 }
 
-func (cs clusterStore) Eval(script, key string, args ...interface{}) (interface{}, error) {
+func (cs clusterStore) Eval(script, key string, args ...any) (any, error) {
 	return cs.EvalCtx(context.Background(), script, key, args...)
 }
 
-func (cs clusterStore) EvalCtx(ctx context.Context, script, key string, args ...interface{}) (interface{}, error) {
+func (cs clusterStore) EvalCtx(ctx context.Context, script, key string, args ...any) (any, error) {
 	node, err := cs.getRedis(key)
 	if err != nil {
 		return nil, err
@@ -510,11 +510,11 @@ func (cs clusterStore) LpopCtx(ctx context.Context, key string) (string, error)
 	return node.LpopCtx(ctx, key)
 }
 
-func (cs clusterStore) Lpush(key string, values ...interface{}) (int, error) {
+func (cs clusterStore) Lpush(key string, values ...any) (int, error) {
 	return cs.LpushCtx(context.Background(), key, values...)
 }
 
-func (cs clusterStore) LpushCtx(ctx context.Context, key string, values ...interface{}) (int, error) {
+func (cs clusterStore) LpushCtx(ctx context.Context, key string, values ...any) (int, error) {
 	node, err := cs.getRedis(key)
 	if err != nil {
 		return 0, err
@@ -562,11 +562,11 @@ func (cs clusterStore) PersistCtx(ctx context.Context, key string) (bool, error)
 	return node.PersistCtx(ctx, key)
 }
 
-func (cs clusterStore) Pfadd(key string, values ...interface{}) (bool, error) {
+func (cs clusterStore) Pfadd(key string, values ...any) (bool, error) {
 	return cs.PfaddCtx(context.Background(), key, values...)
 }
 
-func (cs clusterStore) PfaddCtx(ctx context.Context, key string, values ...interface{}) (bool, error) {
+func (cs clusterStore) PfaddCtx(ctx context.Context, key string, values ...any) (bool, error) {
 	node, err := cs.getRedis(key)
 	if err != nil {
 		return false, err
@@ -588,11 +588,11 @@ func (cs clusterStore) PfcountCtx(ctx context.Context, key string) (int64, error
 	return node.PfcountCtx(ctx, key)
 }
 
-func (cs clusterStore) Rpush(key string, values ...interface{}) (int, error) {
+func (cs clusterStore) Rpush(key string, values ...any) (int, error) {
 	return cs.RpushCtx(context.Background(), key, values...)
 }
 
-func (cs clusterStore) RpushCtx(ctx context.Context, key string, values ...interface{}) (int, error) {
+func (cs clusterStore) RpushCtx(ctx context.Context, key string, values ...any) (int, error) {
 	node, err := cs.getRedis(key)
 	if err != nil {
 		return 0, err
@@ -601,11 +601,11 @@ func (cs clusterStore) RpushCtx(ctx context.Context, key string, values ...inter
 	return node.RpushCtx(ctx, key, values...)
 }
 
-func (cs clusterStore) Sadd(key string, values ...interface{}) (int, error) {
+func (cs clusterStore) Sadd(key string, values ...any) (int, error) {
 	return cs.SaddCtx(context.Background(), key, values...)
 }
 
-func (cs clusterStore) SaddCtx(ctx context.Context, key string, values ...interface{}) (int, error) {
+func (cs clusterStore) SaddCtx(ctx context.Context, key string, values ...any) (int, error) {
 	node, err := cs.getRedis(key)
 	if err != nil {
 		return 0, err
@@ -692,11 +692,11 @@ func (cs clusterStore) GetSetCtx(ctx context.Context, key, value string) (string
 	return node.GetSetCtx(ctx, key, value)
 }
 
-func (cs clusterStore) Sismember(key string, value interface{}) (bool, error) {
+func (cs clusterStore) Sismember(key string, value any) (bool, error) {
 	return cs.SismemberCtx(context.Background(), key, value)
 }
 
-func (cs clusterStore) SismemberCtx(ctx context.Context, key string, value interface{}) (bool, error) {
+func (cs clusterStore) SismemberCtx(ctx context.Context, key string, value any) (bool, error) {
 	node, err := cs.getRedis(key)
 	if err != nil {
 		return false, err
@@ -744,11 +744,11 @@ func (cs clusterStore) SrandmemberCtx(ctx context.Context, key string, count int
 	return node.SrandmemberCtx(ctx, key, count)
 }
 
-func (cs clusterStore) Srem(key string, values ...interface{}) (int, error) {
+func (cs clusterStore) Srem(key string, values ...any) (int, error) {
 	return cs.SremCtx(context.Background(), key, values...)
 }
 
-func (cs clusterStore) SremCtx(ctx context.Context, key string, values ...interface{}) (int, error) {
+func (cs clusterStore) SremCtx(ctx context.Context, key string, values ...any) (int, error) {
 	node, err := cs.getRedis(key)
 	if err != nil {
 		return 0, err
@@ -925,11 +925,11 @@ func (cs clusterStore) ZrangebyscoreWithScoresAndLimitCtx(ctx context.Context, k
 	return node.ZrangebyscoreWithScoresAndLimitCtx(ctx, key, start, stop, page, size)
 }
 
-func (cs clusterStore) Zrem(key string, values ...interface{}) (int, error) {
+func (cs clusterStore) Zrem(key string, values ...any) (int, error) {
 	return cs.ZremCtx(context.Background(), key, values...)
 }
 
-func (cs clusterStore) ZremCtx(ctx context.Context, key string, values ...interface{}) (int, error) {
+func (cs clusterStore) ZremCtx(ctx context.Context, key string, values ...any) (int, error) {
 	node, err := cs.getRedis(key)
 	if err != nil {
 		return 0, err

core/stores/mon/bulkinserter.go

@@ -53,7 +53,7 @@ func (bi *BulkInserter) Flush() {
 }
 
 // Insert inserts doc.
-func (bi *BulkInserter) Insert(doc interface{}) {
+func (bi *BulkInserter) Insert(doc any) {
 	bi.executor.Add(doc)
 }
 
@@ -66,17 +66,17 @@ func (bi *BulkInserter) SetResultHandler(handler ResultHandler) {
 
 type dbInserter struct {
 	collection    *mongo.Collection
-	documents     []interface{}
+	documents     []any
 	resultHandler ResultHandler
 }
 
-func (in *dbInserter) AddTask(doc interface{}) bool {
+func (in *dbInserter) AddTask(doc any) bool {
 	in.documents = append(in.documents, doc)
 	return len(in.documents) >= maxBulkRows
 }
 
-func (in *dbInserter) Execute(objs interface{}) {
-	docs := objs.([]interface{})
+func (in *dbInserter) Execute(objs any) {
+	docs := objs.([]any)
 	if len(docs) == 0 {
 		return
 	}
@@ -89,7 +89,7 @@ func (in *dbInserter) Execute(objs interface{}) {
 	}
 }
 
-func (in *dbInserter) RemoveAll() interface{} {
+func (in *dbInserter) RemoveAll() any {
 	documents := in.documents
 	in.documents = nil
 	return documents

core/stores/mon/collection.go

@@ -46,7 +46,7 @@ type (
 	// Collection defines a MongoDB collection.
 	Collection interface {
 		// Aggregate executes an aggregation pipeline.
-		Aggregate(ctx context.Context, pipeline interface{}, opts ...*mopt.AggregateOptions) (
+		Aggregate(ctx context.Context, pipeline any, opts ...*mopt.AggregateOptions) (
 			*mongo.Cursor, error)
 		// BulkWrite performs a bulk write operation.
 		BulkWrite(ctx context.Context, models []mongo.WriteModel, opts ...*mopt.BulkWriteOptions) (
@@ -54,64 +54,64 @@ type (
 		// Clone creates a copy of this collection with the same settings.
 		Clone(opts ...*mopt.CollectionOptions) (*mongo.Collection, error)
 		// CountDocuments returns the number of documents in the collection that match the filter.
-		CountDocuments(ctx context.Context, filter interface{}, opts ...*mopt.CountOptions) (int64, error)
+		CountDocuments(ctx context.Context, filter any, opts ...*mopt.CountOptions) (int64, error)
 		// Database returns the database that this collection is a part of.
 		Database() *mongo.Database
 		// DeleteMany deletes documents from the collection that match the filter.
-		DeleteMany(ctx context.Context, filter interface{}, opts ...*mopt.DeleteOptions) (
+		DeleteMany(ctx context.Context, filter any, opts ...*mopt.DeleteOptions) (
 			*mongo.DeleteResult, error)
 		// DeleteOne deletes at most one document from the collection that matches the filter.
-		DeleteOne(ctx context.Context, filter interface{}, opts ...*mopt.DeleteOptions) (
+		DeleteOne(ctx context.Context, filter any, opts ...*mopt.DeleteOptions) (
 			*mongo.DeleteResult, error)
 		// Distinct returns a list of distinct values for the given key across the collection.
-		Distinct(ctx context.Context, fieldName string, filter interface{},
-			opts ...*mopt.DistinctOptions) ([]interface{}, error)
+		Distinct(ctx context.Context, fieldName string, filter any,
+			opts ...*mopt.DistinctOptions) ([]any, error)
 		// Drop drops this collection from database.
 		Drop(ctx context.Context) error
 		// EstimatedDocumentCount returns an estimate of the count of documents in a collection
 		// using collection metadata.
 		EstimatedDocumentCount(ctx context.Context, opts ...*mopt.EstimatedDocumentCountOptions) (int64, error)
 		// Find finds the documents matching the provided filter.
-		Find(ctx context.Context, filter interface{}, opts ...*mopt.FindOptions) (*mongo.Cursor, error)
+		Find(ctx context.Context, filter any, opts ...*mopt.FindOptions) (*mongo.Cursor, error)
 		// FindOne returns up to one document that matches the provided filter.
-		FindOne(ctx context.Context, filter interface{}, opts ...*mopt.FindOneOptions) (
+		FindOne(ctx context.Context, filter any, opts ...*mopt.FindOneOptions) (
 			*mongo.SingleResult, error)
 		// FindOneAndDelete returns at most one document that matches the filter. If the filter
 		// matches multiple documents, only the first document is deleted.
-		FindOneAndDelete(ctx context.Context, filter interface{}, opts ...*mopt.FindOneAndDeleteOptions) (
+		FindOneAndDelete(ctx context.Context, filter any, opts ...*mopt.FindOneAndDeleteOptions) (
 			*mongo.SingleResult, error)
 		// FindOneAndReplace returns at most one document that matches the filter. If the filter
 		// matches multiple documents, FindOneAndReplace returns the first document in the
 		// collection that matches the filter.
-		FindOneAndReplace(ctx context.Context, filter, replacement interface{},
+		FindOneAndReplace(ctx context.Context, filter, replacement any,
 			opts ...*mopt.FindOneAndReplaceOptions) (*mongo.SingleResult, error)
 		// FindOneAndUpdate returns at most one document that matches the filter. If the filter
 		// matches multiple documents, FindOneAndUpdate returns the first document in the
 		// collection that matches the filter.
-		FindOneAndUpdate(ctx context.Context, filter, update interface{},
+		FindOneAndUpdate(ctx context.Context, filter, update any,
 			opts ...*mopt.FindOneAndUpdateOptions) (*mongo.SingleResult, error)
 		// Indexes returns the index view for this collection.
 		Indexes() mongo.IndexView
 		// InsertMany inserts the provided documents.
-		InsertMany(ctx context.Context, documents []interface{}, opts ...*mopt.InsertManyOptions) (
+		InsertMany(ctx context.Context, documents []any, opts ...*mopt.InsertManyOptions) (
 			*mongo.InsertManyResult, error)
 		// InsertOne inserts the provided document.
-		InsertOne(ctx context.Context, document interface{}, opts ...*mopt.InsertOneOptions) (
+		InsertOne(ctx context.Context, document any, opts ...*mopt.InsertOneOptions) (
 			*mongo.InsertOneResult, error)
 		// ReplaceOne replaces at most one document that matches the filter.
-		ReplaceOne(ctx context.Context, filter, replacement interface{},
+		ReplaceOne(ctx context.Context, filter, replacement any,
 			opts ...*mopt.ReplaceOptions) (*mongo.UpdateResult, error)
 		// UpdateByID updates a single document matching the provided filter.
-		UpdateByID(ctx context.Context, id, update interface{},
+		UpdateByID(ctx context.Context, id, update any,
 			opts ...*mopt.UpdateOptions) (*mongo.UpdateResult, error)
 		// UpdateMany updates the provided documents.
-		UpdateMany(ctx context.Context, filter, update interface{},
+		UpdateMany(ctx context.Context, filter, update any,
 			opts ...*mopt.UpdateOptions) (*mongo.UpdateResult, error)
 		// UpdateOne updates a single document matching the provided filter.
-		UpdateOne(ctx context.Context, filter, update interface{},
+		UpdateOne(ctx context.Context, filter, update any,
 			opts ...*mopt.UpdateOptions) (*mongo.UpdateResult, error)
 		// Watch returns a change stream cursor used to receive notifications of changes to the collection.
-		Watch(ctx context.Context, pipeline interface{}, opts ...*mopt.ChangeStreamOptions) (
+		Watch(ctx context.Context, pipeline any, opts ...*mopt.ChangeStreamOptions) (
 			*mongo.ChangeStream, error)
 	}
 
@@ -135,7 +135,7 @@ func newCollection(collection *mongo.Collection, brk breaker.Breaker) Collection
 	}
 }
 
-func (c *decoratedCollection) Aggregate(ctx context.Context, pipeline interface{},
+func (c *decoratedCollection) Aggregate(ctx context.Context, pipeline any,
 	opts ...*mopt.AggregateOptions) (cur *mongo.Cursor, err error) {
 	ctx, span := startSpan(ctx, aggregate)
 	defer func() {
@@ -175,7 +175,7 @@ func (c *decoratedCollection) BulkWrite(ctx context.Context, models []mongo.Writ
 	return
 }
 
-func (c *decoratedCollection) CountDocuments(ctx context.Context, filter interface{},
+func (c *decoratedCollection) CountDocuments(ctx context.Context, filter any,
 	opts ...*mopt.CountOptions) (count int64, err error) {
 	ctx, span := startSpan(ctx, countDocuments)
 	defer func() {
@@ -195,7 +195,7 @@ func (c *decoratedCollection) CountDocuments(ctx context.Context, filter interfa
 	return
 }
 
-func (c *decoratedCollection) DeleteMany(ctx context.Context, filter interface{},
+func (c *decoratedCollection) DeleteMany(ctx context.Context, filter any,
 	opts ...*mopt.DeleteOptions) (res *mongo.DeleteResult, err error) {
 	ctx, span := startSpan(ctx, deleteMany)
 	defer func() {
@@ -215,7 +215,7 @@ func (c *decoratedCollection) DeleteMany(ctx context.Context, filter interface{}
 	return
 }
 
-func (c *decoratedCollection) DeleteOne(ctx context.Context, filter interface{},
+func (c *decoratedCollection) DeleteOne(ctx context.Context, filter any,
 	opts ...*mopt.DeleteOptions) (res *mongo.DeleteResult, err error) {
 	ctx, span := startSpan(ctx, deleteOne)
 	defer func() {
@@ -235,8 +235,8 @@ func (c *decoratedCollection) DeleteOne(ctx context.Context, filter interface{},
 	return
 }
 
-func (c *decoratedCollection) Distinct(ctx context.Context, fieldName string, filter interface{},
-	opts ...*mopt.DistinctOptions) (val []interface{}, err error) {
+func (c *decoratedCollection) Distinct(ctx context.Context, fieldName string, filter any,
+	opts ...*mopt.DistinctOptions) (val []any, err error) {
 	ctx, span := startSpan(ctx, distinct)
 	defer func() {
 		endSpan(span, err)
@@ -275,7 +275,7 @@ func (c *decoratedCollection) EstimatedDocumentCount(ctx context.Context,
 	return
 }
 
-func (c *decoratedCollection) Find(ctx context.Context, filter interface{},
+func (c *decoratedCollection) Find(ctx context.Context, filter any,
 	opts ...*mopt.FindOptions) (cur *mongo.Cursor, err error) {
 	ctx, span := startSpan(ctx, find)
 	defer func() {
@@ -295,7 +295,7 @@ func (c *decoratedCollection) Find(ctx context.Context, filter interface{},
 	return
 }
 
-func (c *decoratedCollection) FindOne(ctx context.Context, filter interface{},
+func (c *decoratedCollection) FindOne(ctx context.Context, filter any,
 	opts ...*mopt.FindOneOptions) (res *mongo.SingleResult, err error) {
 	ctx, span := startSpan(ctx, findOne)
 	defer func() {
@@ -316,7 +316,7 @@ func (c *decoratedCollection) FindOne(ctx context.Context, filter interface{},
 	return
 }
 
-func (c *decoratedCollection) FindOneAndDelete(ctx context.Context, filter interface{},
+func (c *decoratedCollection) FindOneAndDelete(ctx context.Context, filter any,
 	opts ...*mopt.FindOneAndDeleteOptions) (res *mongo.SingleResult, err error) {
 	ctx, span := startSpan(ctx, findOneAndDelete)
 	defer func() {
@@ -337,8 +337,8 @@ func (c *decoratedCollection) FindOneAndDelete(ctx context.Context, filter inter
 	return
 }
 
-func (c *decoratedCollection) FindOneAndReplace(ctx context.Context, filter interface{},
-	replacement interface{}, opts ...*mopt.FindOneAndReplaceOptions) (
+func (c *decoratedCollection) FindOneAndReplace(ctx context.Context, filter any,
+	replacement any, opts ...*mopt.FindOneAndReplaceOptions) (
 	res *mongo.SingleResult, err error) {
 	ctx, span := startSpan(ctx, findOneAndReplace)
 	defer func() {
@@ -359,7 +359,7 @@ func (c *decoratedCollection) FindOneAndReplace(ctx context.Context, filter inte
 	return
 }
 
-func (c *decoratedCollection) FindOneAndUpdate(ctx context.Context, filter, update interface{},
+func (c *decoratedCollection) FindOneAndUpdate(ctx context.Context, filter, update any,
 	opts ...*mopt.FindOneAndUpdateOptions) (res *mongo.SingleResult, err error) {
 	ctx, span := startSpan(ctx, findOneAndUpdate)
 	defer func() {
@@ -380,7 +380,7 @@ func (c *decoratedCollection) FindOneAndUpdate(ctx context.Context, filter, upda
 	return
 }
 
-func (c *decoratedCollection) InsertMany(ctx context.Context, documents []interface{},
+func (c *decoratedCollection) InsertMany(ctx context.Context, documents []any,
 	opts ...*mopt.InsertManyOptions) (res *mongo.InsertManyResult, err error) {
 	ctx, span := startSpan(ctx, insertMany)
 	defer func() {
@@ -400,7 +400,7 @@ func (c *decoratedCollection) InsertMany(ctx context.Context, documents []interf
 	return
 }
 
-func (c *decoratedCollection) InsertOne(ctx context.Context, document interface{},
+func (c *decoratedCollection) InsertOne(ctx context.Context, document any,
 	opts ...*mopt.InsertOneOptions) (res *mongo.InsertOneResult, err error) {
 	ctx, span := startSpan(ctx, insertOne)
 	defer func() {
@@ -420,7 +420,7 @@ func (c *decoratedCollection) InsertOne(ctx context.Context, document interface{
 	return
 }
 
-func (c *decoratedCollection) ReplaceOne(ctx context.Context, filter, replacement interface{},
+func (c *decoratedCollection) ReplaceOne(ctx context.Context, filter, replacement any,
 	opts ...*mopt.ReplaceOptions) (res *mongo.UpdateResult, err error) {
 	ctx, span := startSpan(ctx, replaceOne)
 	defer func() {
@@ -440,7 +440,7 @@ func (c *decoratedCollection) ReplaceOne(ctx context.Context, filter, replacemen
 	return
 }
 
-func (c *decoratedCollection) UpdateByID(ctx context.Context, id, update interface{},
+func (c *decoratedCollection) UpdateByID(ctx context.Context, id, update any,
 	opts ...*mopt.UpdateOptions) (res *mongo.UpdateResult, err error) {
 	ctx, span := startSpan(ctx, updateByID)
 	defer func() {
@@ -460,7 +460,7 @@ func (c *decoratedCollection) UpdateByID(ctx context.Context, id, update interfa
 	return
 }
 
-func (c *decoratedCollection) UpdateMany(ctx context.Context, filter, update interface{},
+func (c *decoratedCollection) UpdateMany(ctx context.Context, filter, update any,
 	opts ...*mopt.UpdateOptions) (res *mongo.UpdateResult, err error) {
 	ctx, span := startSpan(ctx, updateMany)
 	defer func() {
@@ -480,7 +480,7 @@ func (c *decoratedCollection) UpdateMany(ctx context.Context, filter, update int
 	return
 }
 
-func (c *decoratedCollection) UpdateOne(ctx context.Context, filter, update interface{},
+func (c *decoratedCollection) UpdateOne(ctx context.Context, filter, update any,
 	opts ...*mopt.UpdateOptions) (res *mongo.UpdateResult, err error) {
 	ctx, span := startSpan(ctx, updateOne)
 	defer func() {
@@ -501,7 +501,7 @@ func (c *decoratedCollection) UpdateOne(ctx context.Context, filter, update inte
 }
 
 func (c *decoratedCollection) logDuration(ctx context.Context, method string,
-	startTime time.Duration, err error, docs ...interface{}) {
+	startTime time.Duration, err error, docs ...any) {
 	duration := timex.Since(startTime)
 	logger := logx.WithContext(ctx).WithDuration(duration)
 

core/stores/mon/collection_test.go

@@ -422,7 +422,7 @@ func TestCollection_InsertMany(t *testing.T) {
 			brk:        breaker.NewBreaker(),
 		}
 		mt.AddMockResponses(mtest.CreateSuccessResponse(bson.D{{Key: "ok", Value: 1}}...))
-		res, err := c.InsertMany(context.Background(), []interface{}{
+		res, err := c.InsertMany(context.Background(), []any{
 			bson.D{{Key: "foo", Value: "bar"}},
 			bson.D{{Key: "foo", Value: "baz"}},
 		})
@@ -431,7 +431,7 @@ func TestCollection_InsertMany(t *testing.T) {
 		assert.Equal(t, 2, len(res.InsertedIDs))
 
 		c.brk = new(dropBreaker)
-		_, err = c.InsertMany(context.Background(), []interface{}{bson.D{{Key: "foo", Value: "bar"}}})
+		_, err = c.InsertMany(context.Background(), []any{bson.D{{Key: "foo", Value: "bar"}}})
 		assert.Equal(t, errDummy, err)
 	})
 }

core/stores/mon/model.go

@@ -96,7 +96,7 @@ func (m *Model) StartSession(opts ...*mopt.SessionOptions) (sess mongo.Session,
 }
 
 // Aggregate executes an aggregation pipeline.
-func (m *Model) Aggregate(ctx context.Context, v, pipeline interface{}, opts ...*mopt.AggregateOptions) error {
+func (m *Model) Aggregate(ctx context.Context, v, pipeline any, opts ...*mopt.AggregateOptions) error {
 	cur, err := m.Collection.Aggregate(ctx, pipeline, opts...)
 	if err != nil {
 		return err
@@ -107,7 +107,7 @@ func (m *Model) Aggregate(ctx context.Context, v, pipeline interface{}, opts ...
 }
 
 // DeleteMany deletes documents that match the filter.
-func (m *Model) DeleteMany(ctx context.Context, filter interface{}, opts ...*mopt.DeleteOptions) (int64, error) {
+func (m *Model) DeleteMany(ctx context.Context, filter any, opts ...*mopt.DeleteOptions) (int64, error) {
 	res, err := m.Collection.DeleteMany(ctx, filter, opts...)
 	if err != nil {
 		return 0, err
@@ -117,7 +117,7 @@ func (m *Model) DeleteMany(ctx context.Context, filter interface{}, opts ...*mop
 }
 
 // DeleteOne deletes the first document that matches the filter.
-func (m *Model) DeleteOne(ctx context.Context, filter interface{}, opts ...*mopt.DeleteOptions) (int64, error) {
+func (m *Model) DeleteOne(ctx context.Context, filter any, opts ...*mopt.DeleteOptions) (int64, error) {
 	res, err := m.Collection.DeleteOne(ctx, filter, opts...)
 	if err != nil {
 		return 0, err
@@ -127,7 +127,7 @@ func (m *Model) DeleteOne(ctx context.Context, filter interface{}, opts ...*mopt
 }
 
 // Find finds documents that match the filter.
-func (m *Model) Find(ctx context.Context, v, filter interface{}, opts ...*mopt.FindOptions) error {
+func (m *Model) Find(ctx context.Context, v, filter any, opts ...*mopt.FindOptions) error {
 	cur, err := m.Collection.Find(ctx, filter, opts...)
 	if err != nil {
 		return err
@@ -138,7 +138,7 @@ func (m *Model) Find(ctx context.Context, v, filter interface{}, opts ...*mopt.F
 }
 
 // FindOne finds the first document that matches the filter.
-func (m *Model) FindOne(ctx context.Context, v, filter interface{}, opts ...*mopt.FindOneOptions) error {
+func (m *Model) FindOne(ctx context.Context, v, filter any, opts ...*mopt.FindOneOptions) error {
 	res, err := m.Collection.FindOne(ctx, filter, opts...)
 	if err != nil {
 		return err
@@ -148,7 +148,7 @@ func (m *Model) FindOne(ctx context.Context, v, filter interface{}, opts ...*mop
 }
 
 // FindOneAndDelete finds a single document and deletes it.
-func (m *Model) FindOneAndDelete(ctx context.Context, v, filter interface{},
+func (m *Model) FindOneAndDelete(ctx context.Context, v, filter any,
 	opts ...*mopt.FindOneAndDeleteOptions) error {
 	res, err := m.Collection.FindOneAndDelete(ctx, filter, opts...)
 	if err != nil {
@@ -159,7 +159,7 @@ func (m *Model) FindOneAndDelete(ctx context.Context, v, filter interface{},
 }
 
 // FindOneAndReplace finds a single document and replaces it.
-func (m *Model) FindOneAndReplace(ctx context.Context, v, filter, replacement interface{},
+func (m *Model) FindOneAndReplace(ctx context.Context, v, filter, replacement any,
 	opts ...*mopt.FindOneAndReplaceOptions) error {
 	res, err := m.Collection.FindOneAndReplace(ctx, filter, replacement, opts...)
 	if err != nil {
@@ -170,7 +170,7 @@ func (m *Model) FindOneAndReplace(ctx context.Context, v, filter, replacement in
 }
 
 // FindOneAndUpdate finds a single document and updates it.
-func (m *Model) FindOneAndUpdate(ctx context.Context, v, filter, update interface{},
+func (m *Model) FindOneAndUpdate(ctx context.Context, v, filter, update any,
 	opts ...*mopt.FindOneAndUpdateOptions) error {
 	res, err := m.Collection.FindOneAndUpdate(ctx, filter, update, opts...)
 	if err != nil {
@@ -217,9 +217,9 @@ func (w *wrappedSession) CommitTransaction(ctx context.Context) (err error) {
 // WithTransaction implements the mongo.Session interface.
 func (w *wrappedSession) WithTransaction(
 	ctx context.Context,
-	fn func(sessCtx mongo.SessionContext) (interface{}, error),
+	fn func(sessCtx mongo.SessionContext) (any, error),
 	opts ...*mopt.TransactionOptions,
-) (res interface{}, err error) {
+) (res any, err error) {
 	ctx, span := startSpan(ctx, withTransaction)
 	defer func() {
 		endSpan(span, err)

core/stores/mon/model_test.go

@@ -20,7 +20,7 @@ func TestModel_StartSession(t *testing.T) {
 		assert.Nil(t, err)
 		defer sess.EndSession(context.Background())
 
-		_, err = sess.WithTransaction(context.Background(), func(sessCtx mongo.SessionContext) (interface{}, error) {
+		_, err = sess.WithTransaction(context.Background(), func(sessCtx mongo.SessionContext) (any, error) {
 			_ = sessCtx.StartTransaction()
 			sessCtx.Client().Database("1")
 			sessCtx.EndSession(context.Background())
@@ -57,7 +57,7 @@ func TestModel_Aggregate(t *testing.T) {
 			"DBName.CollectionName",
 			mtest.NextBatch)
 		mt.AddMockResponses(find, getMore, killCursors)
-		var result []interface{}
+		var result []any
 		err := m.Aggregate(context.Background(), &result, mongo.Pipeline{})
 		assert.Nil(t, err)
 		assert.Equal(t, 2, len(result))
@@ -128,7 +128,7 @@ func TestModel_Find(t *testing.T) {
 			"DBName.CollectionName",
 			mtest.NextBatch)
 		mt.AddMockResponses(find, getMore, killCursors)
-		var result []interface{}
+		var result []any
 		err := m.Find(context.Background(), &result, bson.D{})
 		assert.Nil(t, err)
 		assert.Equal(t, 2, len(result))