chore: remove any keywords

Signed-off-by: cui fliter <imcusg@gmail.com>

.github/dependabot.yml

@@ -9,7 +9,3 @@ updates:
     directory: "/" # Location of package manifests
     schedule:
       interval: "daily"
-  - package-ecosystem: "gomod" # See documentation for possible values
-    directory: "/tools/goctl" # Location of package manifests
-    schedule:
-      interval: "daily"

.github/workflows/go.yml

@@ -17,7 +17,7 @@ jobs:
       - name: Set up Go 1.x
         uses: actions/setup-go@v3
         with:
-          go-version: ^1.18
+          go-version: ^1.16
           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.18 to guarantee Go 1.18 compatibility
-          go-version: 1.18
+          # use 1.16 to guarantee Go 1.16 compatibility
+          go-version: 1.16
           check-latest: true
           cache: true
 

.gitignore

@@ -11,7 +11,7 @@
 !api
 
 # ignore
-**/.idea
+.idea
 **/.DS_Store
 **/logs
 

core/collection/cache.go

@@ -30,7 +30,7 @@ type (
 	Cache struct {
 		name           string
 		lock           sync.Mutex
-		data           map[string]any
+		data           map[string]interface{}
 		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]any),
+		data:           make(map[string]interface{}),
 		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 any) {
+	timingWheel, err := NewTimingWheel(time.Second, slots, func(k, v interface{}) {
 		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) (any, bool) {
+func (c *Cache) Get(key string) (interface{}, bool) {
 	value, ok := c.doGet(key)
 	if ok {
 		c.stats.IncrementHit()
@@ -97,12 +97,12 @@ func (c *Cache) Get(key string) (any, bool) {
 }
 
 // Set sets value into c with key.
-func (c *Cache) Set(key string, value any) {
+func (c *Cache) Set(key string, value interface{}) {
 	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 any, expire time.Duration) {
+func (c *Cache) SetWithExpire(key string, value interface{}, 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 any, expire time.Duration) {
 // 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() (any, error)) (any, error) {
+func (c *Cache) Take(key string, fetch func() (interface{}, error)) (interface{}, error) {
 	if val, ok := c.doGet(key); ok {
 		c.stats.IncrementHit()
 		return val, nil
 	}
 
 	var fresh bool
-	val, err := c.barrier.Do(key, func() (any, error) {
+	val, err := c.barrier.Do(key, func() (interface{}, 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() (any, error)) (any, error) {
 	return val, nil
 }
 
-func (c *Cache) doGet(key string) (any, bool) {
+func (c *Cache) doGet(key string) (interface{}, 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() (any, error) {
+			cache.Take("first", func() (interface{}, 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() (any, error) {
+			cache.Take("first", func() (interface{}, 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() (any, error) {
+			_, err := cache.Take("first", func() (interface{}, 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 []any
+	elements []interface{}
 	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([]any, size),
+		elements: make([]interface{}, 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 any) {
+func (q *Queue) Put(element interface{}) {
 	q.lock.Lock()
 	defer q.lock.Unlock()
 
 	if q.head == q.tail && q.count > 0 {
-		nodes := make([]any, len(q.elements)+q.size)
+		nodes := make([]interface{}, 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 any) {
 }
 
 // Take takes the first element out of q if not empty.
-func (q *Queue) Take() (any, bool) {
+func (q *Queue) Take() (interface{}, 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 []any
+	elements []interface{}
 	index    int
 	lock     sync.RWMutex
 }
@@ -16,12 +16,12 @@ func NewRing(n int) *Ring {
 	}
 
 	return &Ring{
-		elements: make([]any, n),
+		elements: make([]interface{}, n),
 	}
 }
 
 // Add adds v into r.
-func (r *Ring) Add(v any) {
+func (r *Ring) Add(v interface{}) {
 	r.lock.Lock()
 	defer r.lock.Unlock()
 
@@ -30,7 +30,7 @@ func (r *Ring) Add(v any) {
 }
 
 // Take takes all items from r.
-func (r *Ring) Take() []any {
+func (r *Ring) Take() []interface{} {
 	r.lock.RLock()
 	defer r.lock.RUnlock()
 
@@ -43,7 +43,7 @@ func (r *Ring) Take() []any {
 		size = r.index
 	}
 
-	elements := make([]any, size)
+	elements := make([]interface{}, 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, []any{0, 1, 2}, elements)
+	assert.ElementsMatch(t, []interface{}{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, []any{6, 7, 8, 9, 10}, elements)
+	assert.ElementsMatch(t, []interface{}{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[any]any
-	dirtyNew    map[any]any
+	dirtyOld    map[interface{}]interface{}
+	dirtyNew    map[interface{}]interface{}
 }
 
 // NewSafeMap returns a SafeMap.
 func NewSafeMap() *SafeMap {
 	return &SafeMap{
-		dirtyOld: make(map[any]any),
-		dirtyNew: make(map[any]any),
+		dirtyOld: make(map[interface{}]interface{}),
+		dirtyNew: make(map[interface{}]interface{}),
 	}
 }
 
 // Del deletes the value with the given key from m.
-func (m *SafeMap) Del(key any) {
+func (m *SafeMap) Del(key interface{}) {
 	m.lock.Lock()
 	if _, ok := m.dirtyOld[key]; ok {
 		delete(m.dirtyOld, key)
@@ -42,21 +42,21 @@ func (m *SafeMap) Del(key any) {
 		}
 		m.dirtyOld = m.dirtyNew
 		m.deletionOld = m.deletionNew
-		m.dirtyNew = make(map[any]any)
+		m.dirtyNew = make(map[interface{}]interface{})
 		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[any]any)
+		m.dirtyNew = make(map[interface{}]interface{})
 		m.deletionNew = 0
 	}
 	m.lock.Unlock()
 }
 
 // Get gets the value with the given key from m.
-func (m *SafeMap) Get(key any) (any, bool) {
+func (m *SafeMap) Get(key interface{}) (interface{}, bool) {
 	m.lock.RLock()
 	defer m.lock.RUnlock()
 
@@ -70,7 +70,7 @@ func (m *SafeMap) Get(key any) (any, 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 any) bool) {
+func (m *SafeMap) Range(f func(key, val interface{}) bool) {
 	m.lock.RLock()
 	defer m.lock.RUnlock()
 
@@ -87,7 +87,7 @@ func (m *SafeMap) Range(f func(key, val any) bool) {
 }
 
 // Set sets the value into m with the given key.
-func (m *SafeMap) Set(key, value any) {
+func (m *SafeMap) Set(key, value interface{}) {
 	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 any) bool {
+	m.Range(func(k, v interface{}) 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[any]lang.PlaceholderType
+	data map[interface{}]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[any]lang.PlaceholderType),
+		data: make(map[interface{}]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[any]lang.PlaceholderType),
+		data: make(map[interface{}]lang.PlaceholderType),
 		tp:   unmanaged,
 	}
 }
 
 // Add adds i into s.
-func (s *Set) Add(i ...any) {
+func (s *Set) Add(i ...interface{}) {
 	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 any) bool {
+func (s *Set) Contains(i interface{}) bool {
 	if len(s.data) == 0 {
 		return false
 	}
@@ -91,8 +91,8 @@ func (s *Set) Contains(i any) bool {
 }
 
 // Keys returns the keys in s.
-func (s *Set) Keys() []any {
-	var keys []any
+func (s *Set) Keys() []interface{} {
+	var keys []interface{}
 
 	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 any) {
+func (s *Set) Remove(i interface{}) {
 	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 any) {
+func (s *Set) add(i interface{}) {
 	switch s.tp {
 	case unmanaged:
 		// do nothing
@@ -189,7 +189,7 @@ func (s *Set) add(i any) {
 	s.data[i] = lang.Placeholder
 }
 
-func (s *Set) setType(i any) {
+func (s *Set) setType(i interface{}) {
 	// s.tp can only be untyped here
 	switch i.(type) {
 	case int:
@@ -205,7 +205,7 @@ func (s *Set) setType(i any) {
 	}
 }
 
-func (s *Set) validate(i any) {
+func (s *Set) validate(i interface{}) {
 	if s.tp == unmanaged {
 		return
 	}

core/collection/set_test.go

@@ -13,7 +13,7 @@ func init() {
 }
 
 func BenchmarkRawSet(b *testing.B) {
-	m := make(map[any]struct{})
+	m := make(map[interface{}]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 := []any{1, 2, 3}
+	values := []interface{}{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([]any{1, 2, 3}...)
+	set.Add([]interface{}{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([]any{1, 2, 3}...)
+	set.Add([]interface{}{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, []any{1, "2"}, vals)
+	assert.ElementsMatch(t, []interface{}{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 any)
+	Execute func(key, value interface{})
 
 	// 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 any
-		drainChannel  chan func(key, value any)
+		removeChannel chan interface{}
+		drainChannel  chan func(key, value interface{})
 		stopChannel   chan lang.PlaceholderType
 	}
 
 	timingEntry struct {
 		baseEntry
-		value   any
+		value   interface{}
 		circle  int
 		diff    int
 		removed bool
@@ -48,7 +48,7 @@ type (
 
 	baseEntry struct {
 		delay time.Duration
-		key   any
+		key   interface{}
 	}
 
 	positionEntry struct {
@@ -57,8 +57,8 @@ type (
 	}
 
 	timingTask struct {
-		key   any
-		value any
+		key   interface{}
+		value interface{}
 	}
 )
 
@@ -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 any),
-		drainChannel:  make(chan func(key, value any)),
+		removeChannel: make(chan interface{}),
+		drainChannel:  make(chan func(key, value interface{})),
 		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 any)) error {
+func (tw *TimingWheel) Drain(fn func(key, value interface{})) error {
 	select {
 	case tw.drainChannel <- fn:
 		return nil
@@ -107,7 +107,7 @@ func (tw *TimingWheel) Drain(fn func(key, value any)) error {
 }
 
 // MoveTimer moves the task with the given key to the given delay.
-func (tw *TimingWheel) MoveTimer(key any, delay time.Duration) error {
+func (tw *TimingWheel) MoveTimer(key interface{}, delay time.Duration) error {
 	if delay <= 0 || key == nil {
 		return ErrArgument
 	}
@@ -124,7 +124,7 @@ func (tw *TimingWheel) MoveTimer(key any, delay time.Duration) error {
 }
 
 // RemoveTimer removes the task with the given key.
-func (tw *TimingWheel) RemoveTimer(key any) error {
+func (tw *TimingWheel) RemoveTimer(key interface{}) error {
 	if key == nil {
 		return ErrArgument
 	}
@@ -138,7 +138,7 @@ func (tw *TimingWheel) RemoveTimer(key any) error {
 }
 
 // SetTimer sets the task value with the given key to the delay.
-func (tw *TimingWheel) SetTimer(key, value any, delay time.Duration) error {
+func (tw *TimingWheel) SetTimer(key, value interface{}, 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 any)) {
+func (tw *TimingWheel) drainAll(fn func(key, value interface{})) {
 	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 any) {
+func (tw *TimingWheel) removeTask(key interface{}) {
 	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 any) {})
+	_, err := NewTimingWheel(0, 10, func(key, value interface{}) {})
 	assert.NotNil(t, err)
 }
 
 func TestTimingWheel_Drain(t *testing.T) {
 	ticker := timex.NewFakeTicker()
-	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v any) {
+	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v interface{}) {
 	}, 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 any) {
+	tw.Drain(func(key, value interface{}) {
 		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 any) {
+	tw.Drain(func(key, value interface{}) {
 		count++
 	})
 	time.Sleep(time.Millisecond * 100)
 	assert.Equal(t, 0, count)
 	tw.Stop()
-	assert.Equal(t, ErrClosed, tw.Drain(func(key, value any) {}))
+	assert.Equal(t, ErrClosed, tw.Drain(func(key, value interface{}) {}))
 }
 
 func TestTimingWheel_SetTimerSoon(t *testing.T) {
 	run := syncx.NewAtomicBool()
 	ticker := timex.NewFakeTicker()
-	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v any) {
+	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v interface{}) {
 		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 any) {
+	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v interface{}) {
 		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 any) {}, ticker)
+	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v interface{}) {}, 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 any) {}, ticker)
+	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v interface{}) {}, 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 any) {
+	tw, _ := NewTimingWheelWithTicker(testStep, 3, func(k, v interface{}) {
 		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 any) {
+	tw, _ := NewTimingWheelWithTicker(testStep, 3, func(k, v interface{}) {
 		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 any) {
+	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v interface{}) {
 		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 any) {}, ticker)
+	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v interface{}) {}, 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 any) {
+			tw, err := NewTimingWheelWithTicker(testStep, test.slots, func(key, value interface{}) {
 				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 any) {
+			tw, err := NewTimingWheelWithTicker(testStep, test.slots, func(key, value interface{}) {
 				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 any) {
+			tw, err := NewTimingWheelWithTicker(testStep, test.slots, func(key, value interface{}) {
 				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 any) {
+			tw, err := NewTimingWheelWithTicker(testStep, test.slots, func(key, value interface{}) {
 				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 any) {
+			tw, err := NewTimingWheelWithTicker(testStep, test.slots, func(key, value interface{}) {
 				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 any) {
+	tw, _ := NewTimingWheelWithTicker(testStep, 10, func(k, v interface{}) {
 		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 any) {})
+	tw, _ := NewTimingWheel(time.Second, 100, func(k, v interface{}) {})
 	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

@@ -17,7 +17,7 @@ const jsonTagKey = "json"
 
 var (
 	fillDefaultUnmarshaler = mapping.NewUnmarshaler(jsonTagKey, mapping.WithDefault())
-	loaders                = map[string]func([]byte, any) error{
+	loaders                = map[string]func([]byte, interface{}) error{
 		".json": LoadFromJsonBytes,
 		".toml": LoadFromTomlBytes,
 		".yaml": LoadFromYamlBytes,
@@ -34,12 +34,12 @@ type fieldInfo struct {
 
 // FillDefault fills the default values for the given v,
 // and the premise is that the value of v must be guaranteed to be empty.
-func FillDefault(v any) error {
-	return fillDefaultUnmarshaler.Unmarshal(map[string]any{}, v)
+func FillDefault(v interface{}) error {
+	return fillDefaultUnmarshaler.Unmarshal(map[string]interface{}{}, v)
 }
 
 // Load loads config into v from file, .json, .yaml and .yml are acceptable.
-func Load(file string, v any, opts ...Option) error {
+func Load(file string, v interface{}, opts ...Option) error {
 	content, err := os.ReadFile(file)
 	if err != nil {
 		return err
@@ -64,18 +64,18 @@ func Load(file string, v any, 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 any, opts ...Option) error {
+func LoadConfig(file string, v interface{}, opts ...Option) error {
 	return Load(file, v, opts...)
 }
 
 // LoadFromJsonBytes loads config into v from content json bytes.
-func LoadFromJsonBytes(content []byte, v any) error {
+func LoadFromJsonBytes(content []byte, v interface{}) error {
 	info, err := buildFieldsInfo(reflect.TypeOf(v))
 	if err != nil {
 		return err
 	}
 
-	var m map[string]any
+	var m map[string]interface{}
 	if err := jsonx.Unmarshal(content, &m); err != nil {
 		return err
 	}
@@ -87,12 +87,12 @@ func LoadFromJsonBytes(content []byte, v any) error {
 
 // LoadConfigFromJsonBytes loads config into v from content json bytes.
 // Deprecated: use LoadFromJsonBytes instead.
-func LoadConfigFromJsonBytes(content []byte, v any) error {
+func LoadConfigFromJsonBytes(content []byte, v interface{}) error {
 	return LoadFromJsonBytes(content, v)
 }
 
 // LoadFromTomlBytes loads config into v from content toml bytes.
-func LoadFromTomlBytes(content []byte, v any) error {
+func LoadFromTomlBytes(content []byte, v interface{}) error {
 	b, err := encoding.TomlToJson(content)
 	if err != nil {
 		return err
@@ -102,7 +102,7 @@ func LoadFromTomlBytes(content []byte, v any) error {
 }
 
 // LoadFromYamlBytes loads config into v from content yaml bytes.
-func LoadFromYamlBytes(content []byte, v any) error {
+func LoadFromYamlBytes(content []byte, v interface{}) error {
 	b, err := encoding.YamlToJson(content)
 	if err != nil {
 		return err
@@ -113,12 +113,12 @@ func LoadFromYamlBytes(content []byte, v any) error {
 
 // LoadConfigFromYamlBytes loads config into v from content yaml bytes.
 // Deprecated: use LoadFromYamlBytes instead.
-func LoadConfigFromYamlBytes(content []byte, v any) error {
+func LoadConfigFromYamlBytes(content []byte, v interface{}) error {
 	return LoadFromYamlBytes(content, v)
 }
 
 // MustLoad loads config into v from path, exits on error.
-func MustLoad(path string, v any, opts ...Option) {
+func MustLoad(path string, v interface{}, opts ...Option) {
 	if err := Load(path, v, opts...); err != nil {
 		log.Fatalf("error: config file %s, %s", path, err.Error())
 	}
@@ -276,12 +276,12 @@ func toLowerCase(s string) string {
 	return strings.ToLower(s)
 }
 
-func toLowerCaseInterface(v any, info *fieldInfo) any {
+func toLowerCaseInterface(v interface{}, info *fieldInfo) interface{} {
 	switch vv := v.(type) {
-	case map[string]any:
+	case map[string]interface{}:
 		return toLowerCaseKeyMap(vv, info)
-	case []any:
-		var arr []any
+	case []interface{}:
+		var arr []interface{}
 		for _, vvv := range vv {
 			arr = append(arr, toLowerCaseInterface(vvv, info))
 		}
@@ -291,8 +291,8 @@ func toLowerCaseInterface(v any, info *fieldInfo) any {
 	}
 }
 
-func toLowerCaseKeyMap(m map[string]any, info *fieldInfo) map[string]any {
-	res := make(map[string]any)
+func toLowerCaseKeyMap(m map[string]interface{}, info *fieldInfo) map[string]interface{} {
+	res := make(map[string]interface{})
 
 	for k, v := range m {
 		ti, ok := info.children[k]

core/conf/config_test.go

@@ -632,7 +632,7 @@ func Test_FieldOverwrite(t *testing.T) {
 			Name2 *string
 		}
 
-		validate := func(val any) {
+		validate := func(val interface{}) {
 			input := []byte(`{"Name": "hello", "Name2": "world"}`)
 			assert.NoError(t, LoadFromJsonBytes(input, val))
 		}
@@ -668,7 +668,7 @@ func Test_FieldOverwrite(t *testing.T) {
 			Name *string
 		}
 
-		validate := func(val any) {
+		validate := func(val interface{}) {
 			input := []byte(`{"Name": "hello"}`)
 			err := LoadFromJsonBytes(input, val)
 			assert.ErrorAs(t, err, &dupErr)
@@ -711,7 +711,7 @@ func Test_FieldOverwrite(t *testing.T) {
 			Name *int
 		}
 
-		validate := func(val any) {
+		validate := func(val interface{}) {
 			input := []byte(`{"Name": "hello"}`)
 			err := LoadFromJsonBytes(input, val)
 			assert.ErrorAs(t, err, &dupErr)

core/contextx/unmarshaler.go

@@ -14,13 +14,13 @@ type contextValuer struct {
 	context.Context
 }
 
-func (cv contextValuer) Value(key string) (any, bool) {
+func (cv contextValuer) Value(key string) (interface{}, bool) {
 	v := cv.Context.Value(key)
 	return v, v != nil
 }
 
 // For unmarshals ctx into v.
-func For(ctx context.Context, v any) error {
+func For(ctx context.Context, v interface{}) 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 := []any{ctx, key}
+	varargs := []interface{}{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 any, opts ...any) *gomock.Call {
+func (mr *MockEtcdClientMockRecorder) Get(ctx, key interface{}, opts ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{ctx, key}, opts...)
+	varargs := append([]interface{}{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 any) *gomock.Call {
+func (mr *MockEtcdClientMockRecorder) Grant(ctx, ttl interface{}) *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 any) *gomock.Call {
+func (mr *MockEtcdClientMockRecorder) KeepAlive(ctx, id interface{}) *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 any) *gomock.Call {
 // 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 := []any{ctx, key, val}
+	varargs := []interface{}{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 any, opts ...any) *gomock.Call {
+func (mr *MockEtcdClientMockRecorder) Put(ctx, key, val interface{}, opts ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{ctx, key, val}, opts...)
+	varargs := append([]interface{}{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 any) *gomock.Call {
+func (mr *MockEtcdClientMockRecorder) Revoke(ctx, id interface{}) *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 any) *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 := []any{ctx, key}
+	varargs := []interface{}{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 any, opts ...any) *gomock.Call {
+func (mr *MockEtcdClientMockRecorder) Watch(ctx, key interface{}, opts ...interface{}) *gomock.Call {
 	mr.mock.ctrl.T.Helper()
-	varargs := append([]any{ctx, key}, opts...)
+	varargs := append([]interface{}{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(_ any) {
+			listener.EXPECT().OnDelete(gomock.Any()).Do(func(_ interface{}) {
 				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 any) *gomock.Call {
+func (mr *MocketcdConnMockRecorder) WaitForStateChange(ctx, sourceState interface{}) *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 any) *gomock.Call {
+func (mr *MockUpdateListenerMockRecorder) OnAdd(kv interface{}) *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 any) *gomock.Call {
+func (mr *MockUpdateListenerMockRecorder) OnDelete(kv interface{}) *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(_, _ any) {
+	cli.EXPECT().Revoke(gomock.Any(), id).Do(func(_, _ interface{}) {
 		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(_, _ any) {
+	cli.EXPECT().Revoke(gomock.Any(), id).Do(func(_, _ interface{}) {
 		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 ...any) error {
+func Wrapf(err error, format string, args ...interface{}) 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 any) error {
+func (be *BulkExecutor) Add(task interface{}) error {
 	be.executor.Add(task)
 	return nil
 }
@@ -79,22 +79,22 @@ func newBulkOptions() bulkOptions {
 }
 
 type bulkContainer struct {
-	tasks    []any
+	tasks    []interface{}
 	execute  Execute
 	maxTasks int
 }
 
-func (bc *bulkContainer) AddTask(task any) bool {
+func (bc *bulkContainer) AddTask(task interface{}) bool {
 	bc.tasks = append(bc.tasks, task)
 	return len(bc.tasks) >= bc.maxTasks
 }
 
-func (bc *bulkContainer) Execute(tasks any) {
-	vals := tasks.([]any)
+func (bc *bulkContainer) Execute(tasks interface{}) {
+	vals := tasks.([]interface{})
 	bc.execute(vals)
 }
 
-func (bc *bulkContainer) RemoveAll() any {
+func (bc *bulkContainer) RemoveAll() interface{} {
 	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 []any) {
+	executor := NewBulkExecutor(func(items []interface{}) {
 		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 []any) {
+	executor := NewBulkExecutor(func(items []interface{}) {
 		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 []any) {
+	NewBulkExecutor(func(items []interface{}) {
 		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 []any) {
+	be := NewBulkExecutor(func(items []interface{}) {
 		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([]any, 0, 10000)
-	exec := NewBulkExecutor(func(tasks []any) {
+	result := make([]interface{}, 0, 10000)
+	exec := NewBulkExecutor(func(tasks []interface{}) {
 		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 []any) {
+	be := NewBulkExecutor(func(tasks []interface{}) {
 		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 any, size int) error {
+func (ce *ChunkExecutor) Add(task interface{}, size int) error {
 	ce.executor.Add(chunk{
 		val:  task,
 		size: size,
@@ -82,25 +82,25 @@ func newChunkOptions() chunkOptions {
 }
 
 type chunkContainer struct {
-	tasks        []any
+	tasks        []interface{}
 	execute      Execute
 	size         int
 	maxChunkSize int
 }
 
-func (bc *chunkContainer) AddTask(task any) bool {
+func (bc *chunkContainer) AddTask(task interface{}) 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 any) {
-	vals := tasks.([]any)
+func (bc *chunkContainer) Execute(tasks interface{}) {
+	vals := tasks.([]interface{})
 	bc.execute(vals)
 }
 
-func (bc *chunkContainer) RemoveAll() any {
+func (bc *chunkContainer) RemoveAll() interface{} {
 	tasks := bc.tasks
 	bc.tasks = nil
 	bc.size = 0
@@ -108,6 +108,6 @@ func (bc *chunkContainer) RemoveAll() any {
 }
 
 type chunk struct {
-	val  any
+	val  interface{}
 	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 []any) {
+	executor := NewChunkExecutor(func(items []interface{}) {
 		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 []any) {
+	executor := NewChunkExecutor(func(items []interface{}) {
 		assert.Equal(t, size, len(items))
 		wait.Done()
 	}, WithChunkBytes(caches), WithFlushInterval(time.Millisecond*100))
@@ -53,7 +53,7 @@ func TestChunkExecutorFlushInterval(t *testing.T) {
 }
 
 func TestChunkExecutorEmpty(t *testing.T) {
-	executor := NewChunkExecutor(func(items []any) {
+	executor := NewChunkExecutor(func(items []interface{}) {
 		assert.Fail(t, "should not called")
 	}, WithChunkBytes(10), WithFlushInterval(time.Millisecond))
 	time.Sleep(time.Millisecond * 100)
@@ -68,7 +68,7 @@ func TestChunkExecutorFlush(t *testing.T) {
 
 	var wait sync.WaitGroup
 	wait.Add(1)
-	be := NewChunkExecutor(func(items []any) {
+	be := NewChunkExecutor(func(items []interface{}) {
 		assert.Equal(t, tasks, len(items))
 		wait.Done()
 	}, WithChunkBytes(caches), WithFlushInterval(time.Minute))
@@ -82,7 +82,7 @@ func TestChunkExecutorFlush(t *testing.T) {
 func BenchmarkChunkExecutor(b *testing.B) {
 	b.ReportAllocs()
 
-	be := NewChunkExecutor(func(tasks []any) {
+	be := NewChunkExecutor(func(tasks []interface{}) {
 		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 any) bool
+		AddTask(task interface{}) bool
 		// Execute handles the collected tasks by the container when flushing.
-		Execute(tasks any)
+		Execute(tasks interface{})
 		// RemoveAll removes the contained tasks, and return them.
-		RemoveAll() any
+		RemoveAll() interface{}
 	}
 
 	// A PeriodicalExecutor is an executor that periodically execute tasks.
 	PeriodicalExecutor struct {
-		commander chan any
+		commander chan interface{}
 		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 any, 1),
+		commander:   make(chan interface{}, 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 any) {
+func (pe *PeriodicalExecutor) Add(task interface{}) {
 	if vals, ok := pe.addAndCheck(task); ok {
 		pe.commander <- vals
 		<-pe.confirmChan
@@ -74,7 +74,7 @@ func (pe *PeriodicalExecutor) Add(task any) {
 // Flush forces pe to execute tasks.
 func (pe *PeriodicalExecutor) Flush() bool {
 	pe.enterExecution()
-	return pe.executeTasks(func() any {
+	return pe.executeTasks(func() interface{} {
 		pe.lock.Lock()
 		defer pe.lock.Unlock()
 		return pe.container.RemoveAll()
@@ -96,7 +96,7 @@ func (pe *PeriodicalExecutor) Wait() {
 	})
 }
 
-func (pe *PeriodicalExecutor) addAndCheck(task any) (any, bool) {
+func (pe *PeriodicalExecutor) addAndCheck(task interface{}) (interface{}, bool) {
 	pe.lock.Lock()
 	defer func() {
 		if !pe.guarded {
@@ -157,7 +157,7 @@ func (pe *PeriodicalExecutor) enterExecution() {
 	})
 }
 
-func (pe *PeriodicalExecutor) executeTasks(tasks any) bool {
+func (pe *PeriodicalExecutor) executeTasks(tasks interface{}) bool {
 	defer pe.doneExecution()
 
 	ok := pe.hasTasks(tasks)
@@ -168,7 +168,7 @@ func (pe *PeriodicalExecutor) executeTasks(tasks any) bool {
 	return ok
 }
 
-func (pe *PeriodicalExecutor) hasTasks(tasks any) bool {
+func (pe *PeriodicalExecutor) hasTasks(tasks interface{}) bool {
 	if tasks == nil {
 		return false
 	}

core/executors/periodicalexecutor_test.go

@@ -17,22 +17,22 @@ const threshold = 10
 type container struct {
 	interval time.Duration
 	tasks    []int
-	execute  func(tasks any)
+	execute  func(tasks interface{})
 }
 
-func newContainer(interval time.Duration, execute func(tasks any)) *container {
+func newContainer(interval time.Duration, execute func(tasks interface{})) *container {
 	return &container{
 		interval: interval,
 		execute:  execute,
 	}
 }
 
-func (c *container) AddTask(task any) bool {
+func (c *container) AddTask(task interface{}) bool {
 	c.tasks = append(c.tasks, task.(int))
 	return len(c.tasks) > threshold
 }
 
-func (c *container) Execute(tasks any) {
+func (c *container) Execute(tasks interface{}) {
 	if c.execute != nil {
 		c.execute(tasks)
 	} else {
@@ -40,7 +40,7 @@ func (c *container) Execute(tasks any) {
 	}
 }
 
-func (c *container) RemoveAll() any {
+func (c *container) RemoveAll() interface{} {
 	tasks := c.tasks
 	c.tasks = nil
 	return tasks
@@ -76,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 any) {
+	exec := NewPeriodicalExecutor(time.Millisecond, newContainer(time.Millisecond, func(tasks interface{}) {
 		t := tasks.([]int)
 		for _, each := range t {
 			lock.Lock()
@@ -110,7 +110,7 @@ func TestPeriodicalExecutor_Bulk(t *testing.T) {
 
 func TestPeriodicalExecutor_Wait(t *testing.T) {
 	var lock sync.Mutex
-	executer := NewBulkExecutor(func(tasks []any) {
+	executer := NewBulkExecutor(func(tasks []interface{}) {
 		lock.Lock()
 		defer lock.Unlock()
 		time.Sleep(10 * time.Millisecond)
@@ -126,7 +126,7 @@ func TestPeriodicalExecutor_WaitFast(t *testing.T) {
 	const total = 3
 	var cnt int
 	var lock sync.Mutex
-	executer := NewBulkExecutor(func(tasks []any) {
+	executer := NewBulkExecutor(func(tasks []interface{}) {
 		defer func() {
 			cnt++
 		}()
@@ -143,7 +143,7 @@ func TestPeriodicalExecutor_WaitFast(t *testing.T) {
 }
 
 func TestPeriodicalExecutor_Deadlock(t *testing.T) {
-	executor := NewBulkExecutor(func(tasks []any) {
+	executor := NewBulkExecutor(func(tasks []interface{}) {
 	}, 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 []any)
+type Execute func(tasks []interface{})

core/fx/stream.go

@@ -21,31 +21,31 @@ type (
 	}
 
 	// FilterFunc defines the method to filter a Stream.
-	FilterFunc func(item any) bool
+	FilterFunc func(item interface{}) bool
 	// ForAllFunc defines the method to handle all elements in a Stream.
-	ForAllFunc func(pipe <-chan any)
+	ForAllFunc func(pipe <-chan interface{})
 	// ForEachFunc defines the method to handle each element in a Stream.
-	ForEachFunc func(item any)
+	ForEachFunc func(item interface{})
 	// GenerateFunc defines the method to send elements into a Stream.
-	GenerateFunc func(source chan<- any)
+	GenerateFunc func(source chan<- interface{})
 	// KeyFunc defines the method to generate keys for the elements in a Stream.
-	KeyFunc func(item any) any
+	KeyFunc func(item interface{}) interface{}
 	// LessFunc defines the method to compare the elements in a Stream.
-	LessFunc func(a, b any) bool
+	LessFunc func(a, b interface{}) bool
 	// MapFunc defines the method to map each element to another object in a Stream.
-	MapFunc func(item any) any
+	MapFunc func(item interface{}) interface{}
 	// Option defines the method to customize a Stream.
 	Option func(opts *rxOptions)
 	// ParallelFunc defines the method to handle elements parallelly.
-	ParallelFunc func(item any)
+	ParallelFunc func(item interface{})
 	// ReduceFunc defines the method to reduce all the elements in a Stream.
-	ReduceFunc func(pipe <-chan any) (any, error)
+	ReduceFunc func(pipe <-chan interface{}) (interface{}, error)
 	// WalkFunc defines the method to walk through all the elements in a Stream.
-	WalkFunc func(item any, pipe chan<- any)
+	WalkFunc func(item interface{}, pipe chan<- interface{})
 
 	// A Stream is a stream that can be used to do stream processing.
 	Stream struct {
-		source <-chan any
+		source <-chan interface{}
 	}
 )
 
@@ -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 any)
+	source := make(chan interface{})
 
 	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 ...any) Stream {
-	source := make(chan any, len(items))
+func Just(items ...interface{}) Stream {
+	source := make(chan interface{}, len(items))
 	for _, item := range items {
 		source <- item
 	}
@@ -78,7 +78,7 @@ func Just(items ...any) Stream {
 }
 
 // Range converts the given channel to a Stream.
-func Range(source <-chan any) Stream {
+func Range(source <-chan interface{}) Stream {
 	return Stream{
 		source: source,
 	}
@@ -87,7 +87,7 @@ func Range(source <-chan any) 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 any) bool) bool {
+func (s Stream) AllMach(predicate func(item interface{}) 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 any) 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 any) bool) bool {
+func (s Stream) AnyMach(predicate func(item interface{}) 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 any, n)
+	source := make(chan interface{}, 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 any)
+	source := make(chan interface{})
 
 	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 any)
+	source := make(chan interface{})
 
 	threading.GoSafe(func() {
 		defer close(source)
 
-		keys := make(map[any]lang.PlaceholderType)
+		keys := make(map[interface{}]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 any, pipe chan<- any) {
+	return s.Walk(func(item interface{}, pipe chan<- interface{}) {
 		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() any {
+func (s Stream) First() interface{} {
 	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[any][]any)
+	groups := make(map[interface{}][]interface{})
 	for item := range s.source {
 		key := fn(item)
 		groups[key] = append(groups[key], item)
 	}
 
-	source := make(chan any)
+	source := make(chan interface{})
 	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 any)
+	source := make(chan interface{})
 
 	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 any) {
+func (s Stream) Last() (item interface{}) {
 	for item = range s.source {
 	}
 	return
@@ -287,19 +287,19 @@ func (s Stream) Last() (item any) {
 
 // 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 any, pipe chan<- any) {
+	return s.Walk(func(item interface{}, pipe chan<- interface{}) {
 		pipe <- fn(item)
 	}, opts...)
 }
 
 // Merge merges all the items into a slice and generates a new stream.
 func (s Stream) Merge() Stream {
-	var items []any
+	var items []interface{}
 	for item := range s.source {
 		items = append(items, item)
 	}
 
-	source := make(chan any, 1)
+	source := make(chan interface{}, 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 any) bool) bool {
+func (s Stream) NoneMatch(predicate func(item interface{}) 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 any) 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 any, pipe chan<- any) {
+	s.Walk(func(item interface{}, pipe chan<- interface{}) {
 		fn(item)
 	}, opts...).Done()
 }
 
 // Reduce is an utility method to let the caller deal with the underlying channel.
-func (s Stream) Reduce(fn ReduceFunc) (any, error) {
+func (s Stream) Reduce(fn ReduceFunc) (interface{}, error) {
 	return fn(s.source)
 }
 
 // Reverse reverses the elements in the stream.
 func (s Stream) Reverse() Stream {
-	var items []any
+	var items []interface{}
 	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 any)
+	source := make(chan interface{})
 
 	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 []any
+	var items []interface{}
 	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 any)
+	source := make(chan interface{})
 	go func() {
-		var chunk []any
+		var chunk []interface{}
 		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 any)
+	source := make(chan interface{})
 
 	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 any, option.workers)
+	pipe := make(chan interface{}, 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 any, option.workers)
+	pipe := make(chan interface{}, 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 any) {
+func drain(channel <-chan interface{}) {
 	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<- any) {
+		From(func(source chan<- interface{}) {
 			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 any) {
+		}).Buffer(N).ForAll(func(pipe <-chan interface{}) {
 			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 any) (any, error) {
+		Just(1, 2, 3, 4).Buffer(-1).Reduce(func(pipe <-chan interface{}) (interface{}, 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 []any
+			elements []interface{}
 		}{
 			{
 				name: "no elements with nil",
 			},
 			{
 				name:     "no elements",
-				elements: []any{},
+				elements: []interface{}{},
 			},
 			{
 				name:     "1 element",
-				elements: []any{1},
+				elements: []interface{}{1},
 			},
 			{
 				name:     "multiple elements",
-				elements: []any{1, 2, 3},
+				elements: []interface{}{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 any, pipe chan<- any) {
+		Just(1, 2, 3).Walk(func(item interface{}, pipe chan<- interface{}) {
 			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 any) (any, error) {
+		Just(1, 2, 3, 4).Reduce(func(pipe <-chan interface{}) (interface{}, 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 any) any {
+		Just(4, 1, 3, 2, 3, 4).Distinct(func(item interface{}) interface{} {
 			return item
-		}).Reduce(func(pipe <-chan any) (any, error) {
+		}).Reduce(func(pipe <-chan interface{}) (interface{}, 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 any) bool {
+		Just(1, 2, 3, 4).Filter(func(item interface{}) bool {
 			return item.(int)%2 == 0
-		}).Reduce(func(pipe <-chan any) (any, error) {
+		}).Reduce(func(pipe <-chan interface{}) (interface{}, 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 any) bool {
+		Just(1, 2, 3, 4).Filter(func(item interface{}) bool {
 			return item.(int)%2 == 0
-		}).ForAll(func(pipe <-chan any) {
+		}).ForAll(func(pipe <-chan interface{}) {
 			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 any) any {
+		Just(10, 11, 20, 21).Group(func(item interface{}) interface{} {
 			v := item.(int)
 			return v / 10
-		}).ForEach(func(item any) {
-			v := item.([]any)
+		}).ForEach(func(item interface{}) {
+			v := item.([]interface{})
 			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 any) (any, error) {
+		Just(1, 2, 3, 4).Head(2).Reduce(func(pipe <-chan interface{}) (interface{}, 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 any) (any, error) {
+			Just(1, 2, 3, 4).Head(0).Reduce(func(pipe <-chan interface{}) (interface{}, 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 any) (any, error) {
+		Just(1, 2, 3, 4).Head(6).Reduce(func(pipe <-chan interface{}) (interface{}, error) {
 			for item := range pipe {
 				result += item.(int)
 			}
@@ -245,14 +245,14 @@ func TestMap(t *testing.T) {
 			expect int
 		}{
 			{
-				mapper: func(item any) any {
+				mapper: func(item interface{}) interface{} {
 					v := item.(int)
 					return v * v
 				},
 				expect: 30,
 			},
 			{
-				mapper: func(item any) any {
+				mapper: func(item interface{}) interface{} {
 					v := item.(int)
 					if v%2 == 0 {
 						return 0
@@ -262,7 +262,7 @@ func TestMap(t *testing.T) {
 				expect: 10,
 			},
 			{
-				mapper: func(item any) any {
+				mapper: func(item interface{}) interface{} {
 					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<- any) {
+				From(func(source chan<- interface{}) {
 					for i := 1; i < 5; i++ {
 						source <- i
 					}
 				}).Map(test.mapper, WithWorkers(workers)).Reduce(
-					func(pipe <-chan any) (any, error) {
+					func(pipe <-chan interface{}) (interface{}, 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 any) {
-			assert.ElementsMatch(t, []any{1, 2, 3, 4}, item.([]any))
+		Just(1, 2, 3, 4).Merge().ForEach(func(item interface{}) {
+			assert.ElementsMatch(t, []interface{}{1, 2, 3, 4}, item.([]interface{}))
 		})
 	})
 }
@@ -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 any) {
+		Just(1, 2, 3).Parallel(func(item interface{}) {
 			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 any) {
-			assert.ElementsMatch(t, []any{4, 3, 2, 1}, item.([]any))
+		Just(1, 2, 3, 4).Reverse().Merge().ForEach(func(item interface{}) {
+			assert.ElementsMatch(t, []interface{}{4, 3, 2, 1}, item.([]interface{}))
 		})
 	})
 }
@@ -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 any) bool {
+		Just(5, 3, 7, 1, 9, 6, 4, 8, 2).Sort(func(a, b interface{}) bool {
 			return a.(int) < b.(int)
-		}).ForEach(func(item any) {
+		}).ForEach(func(item interface{}) {
 			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 [][]any
-		Just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).Split(4).ForEach(func(item any) {
-			chunk := item.([]any)
+		var chunks [][]interface{}
+		Just(1, 2, 3, 4, 5, 6, 7, 8, 9, 10).Split(4).ForEach(func(item interface{}) {
+			chunk := item.([]interface{})
 			chunks = append(chunks, chunk)
 		})
-		assert.EqualValues(t, [][]any{
+		assert.EqualValues(t, [][]interface{}{
 			{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 any) (any, error) {
+		Just(1, 2, 3, 4).Tail(2).Reduce(func(pipe <-chan interface{}) (interface{}, 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 any) (any, error) {
+			Just(1, 2, 3, 4).Tail(0).Reduce(func(pipe <-chan interface{}) (interface{}, 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 any, pipe chan<- any) {
+		Just(1, 2, 3, 4, 5).Walk(func(item interface{}, pipe chan<- interface{}) {
 			if item.(int)%2 != 0 {
 				pipe <- item
 			}
-		}, UnlimitedWorkers()).ForEach(func(item any) {
+		}, UnlimitedWorkers()).ForEach(func(item interface{}) {
 			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 any) bool {
+		assetEqual(t, false, Just(1, 2, 3).AnyMach(func(item interface{}) bool {
 			return item.(int) == 4
 		}))
-		assetEqual(t, false, Just(1, 2, 3).AnyMach(func(item any) bool {
+		assetEqual(t, false, Just(1, 2, 3).AnyMach(func(item interface{}) bool {
 			return item.(int) == 0
 		}))
-		assetEqual(t, true, Just(1, 2, 3).AnyMach(func(item any) bool {
+		assetEqual(t, true, Just(1, 2, 3).AnyMach(func(item interface{}) bool {
 			return item.(int) == 2
 		}))
-		assetEqual(t, true, Just(1, 2, 3).AnyMach(func(item any) bool {
+		assetEqual(t, true, Just(1, 2, 3).AnyMach(func(item interface{}) 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 any) bool {
+			t, true, Just(1, 2, 3).AllMach(func(item interface{}) bool {
 				return true
 			}),
 		)
 		assetEqual(
-			t, false, Just(1, 2, 3).AllMach(func(item any) bool {
+			t, false, Just(1, 2, 3).AllMach(func(item interface{}) bool {
 				return false
 			}),
 		)
 		assetEqual(
-			t, false, Just(1, 2, 3).AllMach(func(item any) bool {
+			t, false, Just(1, 2, 3).AllMach(func(item interface{}) 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 any) bool {
+			t, true, Just(1, 2, 3).NoneMatch(func(item interface{}) bool {
 				return false
 			}),
 		)
 		assetEqual(
-			t, false, Just(1, 2, 3).NoneMatch(func(item any) bool {
+			t, false, Just(1, 2, 3).NoneMatch(func(item interface{}) bool {
 				return true
 			}),
 		)
 		assetEqual(
-			t, true, Just(1, 2, 3).NoneMatch(func(item any) bool {
+			t, true, Just(1, 2, 3).NoneMatch(func(item interface{}) 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 := []any{1, 2, 3}
-		a2 := []any{4, 5, 6}
+		a1 := []interface{}{1, 2, 3}
+		a2 := []interface{}{4, 5, 6}
 		s1 := Just(a1...)
 		s2 := Just(a2...)
 		stream := Concat(s1, s2)
-		var items []any
+		var items []interface{}
 		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([]any, 0)
+		ints := make([]interface{}, 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), []any{4})
+		equal(t, Just(1, 2, 3, 4).Skip(3), []interface{}{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 []any
+		var items []interface{}
 		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, []any{1, 2, 3}, items)
+		assetEqual(t, []interface{}{1, 2, 3}, items)
 
 		just := Just(1)
-		equal(t, just.Concat(just), []any{1})
+		equal(t, just.Concat(just), []interface{}{1})
 	})
 }
 
 func BenchmarkParallelMapReduce(b *testing.B) {
 	b.ReportAllocs()
 
-	mapper := func(v any) any {
+	mapper := func(v interface{}) interface{} {
 		return v.(int64) * v.(int64)
 	}
-	reducer := func(input <-chan any) (any, error) {
+	reducer := func(input <-chan interface{}) (interface{}, 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<- any) {
+	From(func(input chan<- interface{}) {
 		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 any) any {
+	mapper := func(v interface{}) interface{} {
 		return v.(int64) * v.(int64)
 	}
-	reducer := func(input <-chan any) (any, error) {
+	reducer := func(input <-chan interface{}) (interface{}, 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<- any) {
+	From(func(input chan<- interface{}) {
 		for i := 0; i < b.N; i++ {
 			input <- int64(rand.Int())
 		}
 	}).Map(mapper).Reduce(reducer)
 }
 
-func assetEqual(t *testing.T, except, data any) {
+func assetEqual(t *testing.T, except, data interface{}) {
 	if !reflect.DeepEqual(except, data) {
 		t.Errorf(" %v, want %v", data, except)
 	}
 }
 
-func equal(t *testing.T, stream Stream, data []any) {
-	items := make([]any, 0)
+func equal(t *testing.T, stream Stream, data []interface{}) {
+	items := make([]interface{}, 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 any, 1)
+	panicChan := make(chan interface{}, 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][]any
+		ring     map[uint64][]interface{}
 		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][]any),
+		ring:     make(map[uint64][]interface{}),
 		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 any) {
+func (h *ConsistentHash) Add(node interface{}) {
 	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 any, replicas int) {
+func (h *ConsistentHash) AddWithReplicas(node interface{}, replicas int) {
 	h.Remove(node)
 
 	if replicas > h.replicas {
@@ -89,7 +89,7 @@ func (h *ConsistentHash) AddWithReplicas(node any, 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 any, weight int) {
+func (h *ConsistentHash) AddWithWeight(node interface{}, 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 any, weight int) {
 }
 
 // Get returns the corresponding node from h base on the given v.
-func (h *ConsistentHash) Get(v any) (any, bool) {
+func (h *ConsistentHash) Get(v interface{}) (interface{}, bool) {
 	h.lock.RLock()
 	defer h.lock.RUnlock()
 
@@ -124,7 +124,7 @@ func (h *ConsistentHash) Get(v any) (any, bool) {
 }
 
 // Remove removes the given node from h.
-func (h *ConsistentHash) Remove(node any) {
+func (h *ConsistentHash) Remove(node interface{}) {
 	nodeRepr := repr(node)
 
 	h.lock.Lock()
@@ -177,10 +177,10 @@ func (h *ConsistentHash) removeNode(nodeRepr string) {
 	delete(h.nodes, nodeRepr)
 }
 
-func innerRepr(node any) string {
+func innerRepr(node interface{}) string {
 	return fmt.Sprintf("%d:%v", prime, node)
 }
 
-func repr(node any) string {
+func repr(node interface{}) 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[any]int, len(keys))
+	mi := make(map[interface{}]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() any {
+			New: func() interface{} {
 				return new(bytes.Buffer)
 			},
 		},

core/jsonx/json.go

@@ -9,12 +9,12 @@ import (
 )
 
 // Marshal marshals v into json bytes.
-func Marshal(v any) ([]byte, error) {
+func Marshal(v interface{}) ([]byte, error) {
 	return json.Marshal(v)
 }
 
 // MarshalToString marshals v into a string.
-func MarshalToString(v any) (string, error) {
+func MarshalToString(v interface{}) (string, error) {
 	data, err := Marshal(v)
 	if err != nil {
 		return "", err
@@ -24,7 +24,7 @@ func MarshalToString(v any) (string, error) {
 }
 
 // Unmarshal unmarshals data bytes into v.
-func Unmarshal(data []byte, v any) error {
+func Unmarshal(data []byte, v interface{}) 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 any) error {
 }
 
 // UnmarshalFromString unmarshals v from str.
-func UnmarshalFromString(str string, v any) error {
+func UnmarshalFromString(str string, v interface{}) 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 any) error {
 }
 
 // UnmarshalFromReader unmarshals v from reader.
-func UnmarshalFromReader(reader io.Reader, v any) error {
+func UnmarshalFromReader(reader io.Reader, v interface{}) error {
 	var buf strings.Builder
 	teeReader := io.TeeReader(reader, &buf)
 	decoder := json.NewDecoder(teeReader)
@@ -55,7 +55,7 @@ func UnmarshalFromReader(reader io.Reader, v any) error {
 	return nil
 }
 
-func unmarshalUseNumber(decoder *json.Decoder, v any) error {
+func unmarshalUseNumber(decoder *json.Decoder, v interface{}) 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 = any
+	AnyType = interface{}
 	// PlaceholderType represents a placeholder type.
 	PlaceholderType = struct{}
 )
 
 // Repr returns the string representation of v.
-func Repr(v any) string {
+func Repr(v interface{}) 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      any
+		v      interface{}
 		expect string
 	}{
 		{

core/logc/logs.go

@@ -48,18 +48,18 @@ func Debugw(ctx context.Context, msg string, fields ...LogField) {
 }
 
 // Error writes v into error log.
-func Error(ctx context.Context, v ...any) {
+func Error(ctx context.Context, v ...interface{}) {
 	getLogger(ctx).Error(v...)
 }
 
 // Errorf writes v with format into error log.
-func Errorf(ctx context.Context, format string, v ...any) {
+func Errorf(ctx context.Context, format string, v ...interface{}) {
 	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 any) {
+func Errorv(ctx context.Context, v interface{}) {
 	getLogger(ctx).Errorv(v)
 }
 
@@ -69,22 +69,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 any) LogField {
+func Field(key string, value interface{}) LogField {
 	return logx.Field(key, value)
 }
 
 // Info writes v into access log.
-func Info(ctx context.Context, v ...any) {
+func Info(ctx context.Context, v ...interface{}) {
 	getLogger(ctx).Info(v...)
 }
 
 // Infof writes v with format into access log.
-func Infof(ctx context.Context, format string, v ...any) {
+func Infof(ctx context.Context, format string, v ...interface{}) {
 	getLogger(ctx).Infof(format, v...)
 }
 
 // Infov writes v into access log with json content.
-func Infov(ctx context.Context, v any) {
+func Infov(ctx context.Context, v interface{}) {
 	getLogger(ctx).Infov(v)
 }
 
@@ -117,17 +117,17 @@ func SetUp(c LogConf) error {
 }
 
 // Slow writes v into slow log.
-func Slow(ctx context.Context, v ...any) {
+func Slow(ctx context.Context, v ...interface{}) {
 	getLogger(ctx).Slow(v...)
 }
 
 // Slowf writes v with format into slow log.
-func Slowf(ctx context.Context, format string, v ...any) {
+func Slowf(ctx context.Context, format string, v ...interface{}) {
 	getLogger(ctx).Slowf(format, v...)
 }
 
 // Slowv writes v into slow log with json content.
-func Slowv(ctx context.Context, v any) {
+func Slowv(ctx context.Context, v interface{}) {
 	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]any
+	var m map[string]interface{}
 	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]any
+	var m map[string]interface{}
 	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 ...any) {
+func (logger *LessLogger) Error(v ...interface{}) {
 	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 ...any) {
+func (logger *LessLogger) Errorf(format string, v ...interface{}) {
 	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(...any)
+	Debug(...interface{})
 	// Debugf logs a message at info level.
-	Debugf(string, ...any)
+	Debugf(string, ...interface{})
 	// Debugv logs a message at info level.
-	Debugv(any)
+	Debugv(interface{})
 	// Debugw logs a message at info level.
 	Debugw(string, ...LogField)
 	// Error logs a message at error level.
-	Error(...any)
+	Error(...interface{})
 	// Errorf logs a message at error level.
-	Errorf(string, ...any)
+	Errorf(string, ...interface{})
 	// Errorv logs a message at error level.
-	Errorv(any)
+	Errorv(interface{})
 	// Errorw logs a message at error level.
 	Errorw(string, ...LogField)
 	// Info logs a message at info level.
-	Info(...any)
+	Info(...interface{})
 	// Infof logs a message at info level.
-	Infof(string, ...any)
+	Infof(string, ...interface{})
 	// Infov logs a message at info level.
-	Infov(any)
+	Infov(interface{})
 	// Infow logs a message at info level.
 	Infow(string, ...LogField)
 	// Slow logs a message at slow level.
-	Slow(...any)
+	Slow(...interface{})
 	// Slowf logs a message at slow level.
-	Slowf(string, ...any)
+	Slowf(string, ...interface{})
 	// Slowv logs a message at slow level.
-	Slowv(any)
+	Slowv(interface{})
 	// 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 any
+		Value interface{}
 	}
 
 	// LogOption defines the method to customize the logging.
 	LogOption func(options *logOptions)
 
-	logEntry map[string]any
+	logEntry map[string]interface{}
 
 	logOptions struct {
 		gzipEnabled           bool
@@ -67,17 +67,17 @@ func Close() error {
 }
 
 // Debug writes v into access log.
-func Debug(v ...any) {
+func Debug(v ...interface{}) {
 	writeDebug(fmt.Sprint(v...))
 }
 
 // Debugf writes v with format into access log.
-func Debugf(format string, v ...any) {
+func Debugf(format string, v ...interface{}) {
 	writeDebug(fmt.Sprintf(format, v...))
 }
 
 // Debugv writes v into access log with json content.
-func Debugv(v any) {
+func Debugv(v interface{}) {
 	writeDebug(v)
 }
 
@@ -98,30 +98,30 @@ func DisableStat() {
 }
 
 // Error writes v into error log.
-func Error(v ...any) {
+func Error(v ...interface{}) {
 	writeError(fmt.Sprint(v...))
 }
 
 // Errorf writes v with format into error log.
-func Errorf(format string, v ...any) {
+func Errorf(format string, v ...interface{}) {
 	writeError(fmt.Errorf(format, v...).Error())
 }
 
 // ErrorStack writes v along with call stack into error log.
-func ErrorStack(v ...any) {
+func ErrorStack(v ...interface{}) {
 	// 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 ...any) {
+func ErrorStackf(format string, v ...interface{}) {
 	// 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 any) {
+func Errorv(v interface{}) {
 	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 any) LogField {
+func Field(key string, value interface{}) LogField {
 	switch val := value.(type) {
 	case error:
 		return LogField{Key: key, Value: val.Error()}
@@ -169,17 +169,17 @@ func Field(key string, value any) LogField {
 }
 
 // Info writes v into access log.
-func Info(v ...any) {
+func Info(v ...interface{}) {
 	writeInfo(fmt.Sprint(v...))
 }
 
 // Infof writes v with format into access log.
-func Infof(format string, v ...any) {
+func Infof(format string, v ...interface{}) {
 	writeInfo(fmt.Sprintf(format, v...))
 }
 
 // Infov writes v into access log with json content.
-func Infov(v any) {
+func Infov(v interface{}) {
 	writeInfo(v)
 }
 
@@ -263,27 +263,27 @@ func SetUp(c LogConf) (err error) {
 }
 
 // Severe writes v into severe log.
-func Severe(v ...any) {
+func Severe(v ...interface{}) {
 	writeSevere(fmt.Sprint(v...))
 }
 
 // Severef writes v with format into severe log.
-func Severef(format string, v ...any) {
+func Severef(format string, v ...interface{}) {
 	writeSevere(fmt.Sprintf(format, v...))
 }
 
 // Slow writes v into slow log.
-func Slow(v ...any) {
+func Slow(v ...interface{}) {
 	writeSlow(fmt.Sprint(v...))
 }
 
 // Slowf writes v with format into slow log.
-func Slowf(format string, v ...any) {
+func Slowf(format string, v ...interface{}) {
 	writeSlow(fmt.Sprintf(format, v...))
 }
 
 // Slowv writes v into slow log with json content.
-func Slowv(v any) {
+func Slowv(v interface{}) {
 	writeSlow(v)
 }
 
@@ -293,12 +293,12 @@ func Sloww(msg string, fields ...LogField) {
 }
 
 // Stat writes v into stat log.
-func Stat(v ...any) {
+func Stat(v ...interface{}) {
 	writeStat(fmt.Sprint(v...))
 }
 
 // Statf writes v with format into stat log.
-func Statf(format string, v ...any) {
+func Statf(format string, v ...interface{}) {
 	writeStat(fmt.Sprintf(format, v...))
 }
 
@@ -422,19 +422,19 @@ func shallLogStat() bool {
 	return atomic.LoadUint32(&disableStat) == 0
 }
 
-func writeDebug(val any, fields ...LogField) {
+func writeDebug(val interface{}, fields ...LogField) {
 	if shallLog(DebugLevel) {
 		getWriter().Debug(val, addCaller(fields...)...)
 	}
 }
 
-func writeError(val any, fields ...LogField) {
+func writeError(val interface{}, fields ...LogField) {
 	if shallLog(ErrorLevel) {
 		getWriter().Error(val, addCaller(fields...)...)
 	}
 }
 
-func writeInfo(val any, fields ...LogField) {
+func writeInfo(val interface{}, fields ...LogField) {
 	if shallLog(InfoLevel) {
 		getWriter().Info(val, addCaller(fields...)...)
 	}
@@ -446,7 +446,7 @@ func writeSevere(msg string) {
 	}
 }
 
-func writeSlow(val any, fields ...LogField) {
+func writeSlow(val interface{}, 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 any) {
+func (mw *mockWriter) Alert(v interface{}) {
 	mw.lock.Lock()
 	defer mw.lock.Unlock()
 	output(&mw.builder, levelAlert, v)
 }
 
-func (mw *mockWriter) Debug(v any, fields ...LogField) {
+func (mw *mockWriter) Debug(v interface{}, fields ...LogField) {
 	mw.lock.Lock()
 	defer mw.lock.Unlock()
 	output(&mw.builder, levelDebug, v, fields...)
 }
 
-func (mw *mockWriter) Error(v any, fields ...LogField) {
+func (mw *mockWriter) Error(v interface{}, fields ...LogField) {
 	mw.lock.Lock()
 	defer mw.lock.Unlock()
 	output(&mw.builder, levelError, v, fields...)
 }
 
-func (mw *mockWriter) Info(v any, fields ...LogField) {
+func (mw *mockWriter) Info(v interface{}, fields ...LogField) {
 	mw.lock.Lock()
 	defer mw.lock.Unlock()
 	output(&mw.builder, levelInfo, v, fields...)
 }
 
-func (mw *mockWriter) Severe(v any) {
+func (mw *mockWriter) Severe(v interface{}) {
 	mw.lock.Lock()
 	defer mw.lock.Unlock()
 	output(&mw.builder, levelSevere, v)
 }
 
-func (mw *mockWriter) Slow(v any, fields ...LogField) {
+func (mw *mockWriter) Slow(v interface{}, fields ...LogField) {
 	mw.lock.Lock()
 	defer mw.lock.Unlock()
 	output(&mw.builder, levelSlow, v, fields...)
 }
 
-func (mw *mockWriter) Stack(v any) {
+func (mw *mockWriter) Stack(v interface{}) {
 	mw.lock.Lock()
 	defer mw.lock.Unlock()
 	output(&mw.builder, levelError, v)
 }
 
-func (mw *mockWriter) Stat(v any, fields ...LogField) {
+func (mw *mockWriter) Stat(v interface{}, 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]any
+		want map[string]interface{}
 	}{
 		{
 			name: "error",
 			f:    Field("foo", errors.New("bar")),
-			want: map[string]any{
+			want: map[string]interface{}{
 				"foo": "bar",
 			},
 		},
 		{
 			name: "errors",
 			f:    Field("foo", []error{errors.New("bar"), errors.New("baz")}),
-			want: map[string]any{
-				"foo": []any{"bar", "baz"},
+			want: map[string]interface{}{
+				"foo": []interface{}{"bar", "baz"},
 			},
 		},
 		{
 			name: "strings",
 			f:    Field("foo", []string{"bar", "baz"}),
-			want: map[string]any{
-				"foo": []any{"bar", "baz"},
+			want: map[string]interface{}{
+				"foo": []interface{}{"bar", "baz"},
 			},
 		},
 		{
 			name: "duration",
 			f:    Field("foo", time.Second),
-			want: map[string]any{
+			want: map[string]interface{}{
 				"foo": "1s",
 			},
 		},
 		{
 			name: "durations",
 			f:    Field("foo", []time.Duration{time.Second, 2 * time.Second}),
-			want: map[string]any{
-				"foo": []any{"1s", "2s"},
+			want: map[string]interface{}{
+				"foo": []interface{}{"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]any{
-				"foo": []any{"2020-01-01 00:00:00 +0000 UTC", "2020-01-02 00:00:00 +0000 UTC"},
+			want: map[string]interface{}{
+				"foo": []interface{}{"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]any{
+			want: map[string]interface{}{
 				"foo": "bar",
 			},
 		},
 		{
 			name: "stringers",
 			f:    Field("foo", []fmt.Stringer{ValStringer{val: "bar"}, ValStringer{val: "baz"}}),
-			want: map[string]any{
-				"foo": []any{"bar", "baz"},
+			want: map[string]interface{}{
+				"foo": []interface{}{"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 ...any) {
+	doTestStructedLog(t, levelAlert, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelDebug, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelDebug, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelDebug, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelDebug, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelError, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelError, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelError, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelError, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelInfo, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelInfo, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelInfo, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelInfo, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLogConsole(t, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLogConsole(t, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLogConsole(t, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLogConsole(t, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLogConsole(t, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelSlow, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelSlow, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelSlow, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelSlow, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelStat, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelStat, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelSevere, w, func(v ...interface{}) {
 		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 ...any) {
+	doTestStructedLog(t, levelSevere, w, func(v ...interface{}) {
 		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]any
+	var entry map[string]interface{}
 	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(...any)) {
+func doTestStructedLog(t *testing.T, level string, w *mockWriter, write func(...interface{})) {
 	const message = "hello there"
 	write(message)
 
-	var entry map[string]any
+	var entry map[string]interface{}
 	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(...any)) {
+func doTestStructedLogConsole(t *testing.T, w *mockWriter, write func(...interface{})) {
 	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]any) {
-	var m map[string]any
+func validateFields(t *testing.T, content string, fields map[string]interface{}) {
+	var m map[string]interface{}
 	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(...any)
+	Error(...interface{})
 	// Errorf logs a message at error level.
-	Errorf(string, ...any)
+	Errorf(string, ...interface{})
 	// Errorv logs a message at error level.
-	Errorv(any)
+	Errorv(interface{})
 	// Errorw logs a message at error level.
 	Errorw(string, ...LogField)
 	// Info logs a message at info level.
-	Info(...any)
+	Info(...interface{})
 	// Infof logs a message at info level.
-	Infof(string, ...any)
+	Infof(string, ...interface{})
 	// Infov logs a message at info level.
-	Infov(any)
+	Infov(interface{})
 	// Infow logs a message at info level.
 	Infow(string, ...LogField)
 	// Slow logs a message at slow level.
-	Slow(...any)
+	Slow(...interface{})
 	// Slowf logs a message at slow level.
-	Slowf(string, ...any)
+	Slowf(string, ...interface{})
 	// Slowv logs a message at slow level.
-	Slowv(any)
+	Slowv(interface{})
 	// 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 any, fields ...logx.LogField) {
+func (l *SensitiveLogger) Info(msg interface{}, 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(...any)
+	Error(...interface{})
 	// Errorf logs a message at error level.
-	Errorf(string, ...any)
+	Errorf(string, ...interface{})
 	// Errorv logs a message at error level.
-	Errorv(any)
+	Errorv(interface{})
 	// Errorw logs a message at error level.
 	Errorw(string, ...LogField)
 	// Info logs a message at info level.
-	Info(...any)
+	Info(...interface{})
 	// Infof logs a message at info level.
-	Infof(string, ...any)
+	Infof(string, ...interface{})
 	// Infov logs a message at info level.
-	Infov(any)
+	Infov(interface{})
 	// Infow logs a message at info level.
 	Infow(string, ...LogField)
 	// Slow logs a message at slow level.
-	Slow(...any)
+	Slow(...interface{})
 	// Slowf logs a message at slow level.
-	Slowf(string, ...any)
+	Slowf(string, ...interface{})
 	// Slowv logs a message at slow level.
-	Slowv(any)
+	Slowv(interface{})
 	// 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 any, fields ...logx.LogField) {
+func (l *SensitiveLogger) Info(msg interface{}, 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 ...any) {
+func (l *richLogger) Debug(v ...interface{}) {
 	l.debug(fmt.Sprint(v...))
 }
 
-func (l *richLogger) Debugf(format string, v ...any) {
+func (l *richLogger) Debugf(format string, v ...interface{}) {
 	l.debug(fmt.Sprintf(format, v...))
 }
 
-func (l *richLogger) Debugv(v any) {
+func (l *richLogger) Debugv(v interface{}) {
 	l.debug(v)
 }
 
@@ -56,15 +56,15 @@ func (l *richLogger) Debugw(msg string, fields ...LogField) {
 	l.debug(msg, fields...)
 }
 
-func (l *richLogger) Error(v ...any) {
+func (l *richLogger) Error(v ...interface{}) {
 	l.err(fmt.Sprint(v...))
 }
 
-func (l *richLogger) Errorf(format string, v ...any) {
+func (l *richLogger) Errorf(format string, v ...interface{}) {
 	l.err(fmt.Sprintf(format, v...))
 }
 
-func (l *richLogger) Errorv(v any) {
+func (l *richLogger) Errorv(v interface{}) {
 	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 ...any) {
+func (l *richLogger) Info(v ...interface{}) {
 	l.info(fmt.Sprint(v...))
 }
 
-func (l *richLogger) Infof(format string, v ...any) {
+func (l *richLogger) Infof(format string, v ...interface{}) {
 	l.info(fmt.Sprintf(format, v...))
 }
 
-func (l *richLogger) Infov(v any) {
+func (l *richLogger) Infov(v interface{}) {
 	l.info(v)
 }
 
@@ -88,15 +88,15 @@ func (l *richLogger) Infow(msg string, fields ...LogField) {
 	l.info(msg, fields...)
 }
 
-func (l *richLogger) Slow(v ...any) {
+func (l *richLogger) Slow(v ...interface{}) {
 	l.slow(fmt.Sprint(v...))
 }
 
-func (l *richLogger) Slowf(format string, v ...any) {
+func (l *richLogger) Slowf(format string, v ...interface{}) {
 	l.slow(fmt.Sprintf(format, v...))
 }
 
-func (l *richLogger) Slowv(v any) {
+func (l *richLogger) Slowv(v interface{}) {
 	l.slow(v)
 }
 
@@ -156,25 +156,25 @@ func (l *richLogger) buildFields(fields ...LogField) []LogField {
 	return fields
 }
 
-func (l *richLogger) debug(v any, fields ...LogField) {
+func (l *richLogger) debug(v interface{}, fields ...LogField) {
 	if shallLog(DebugLevel) {
 		getWriter().Debug(v, l.buildFields(fields...)...)
 	}
 }
 
-func (l *richLogger) err(v any, fields ...LogField) {
+func (l *richLogger) err(v interface{}, fields ...LogField) {
 	if shallLog(ErrorLevel) {
 		getWriter().Error(v, l.buildFields(fields...)...)
 	}
 }
 
-func (l *richLogger) info(v any, fields ...LogField) {
+func (l *richLogger) info(v interface{}, fields ...LogField) {
 	if shallLog(InfoLevel) {
 		getWriter().Info(v, l.buildFields(fields...)...)
 	}
 }
 
-func (l *richLogger) slow(v any, fields ...LogField) {
+func (l *richLogger) slow(v interface{}, fields ...LogField) {
 	if shallLog(ErrorLevel) {
 		getWriter().Slow(v, l.buildFields(fields...)...)
 	}

core/logx/rotatelogger_test.go

@@ -9,7 +9,6 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/zeromicro/go-zero/core/fs"
-	"github.com/zeromicro/go-zero/core/stringx"
 )
 
 func TestDailyRotateRuleMarkRotated(t *testing.T) {
@@ -233,23 +232,6 @@ func TestRotateLoggerWithSizeLimitRotateRuleMayCompressFileTrue(t *testing.T) {
 	assert.NotNil(t, err)
 }
 
-func TestRotateLoggerWithSizeLimitRotateRuleMayCompressFileFailed(t *testing.T) {
-	old := os.Stdout
-	os.Stdout = os.NewFile(0, os.DevNull)
-	defer func() {
-		os.Stdout = old
-	}()
-
-	filename := stringx.RandId()
-	logger, err := NewLogger(filename, new(SizeLimitRotateRule), true)
-	defer os.Remove(filename)
-	if assert.NoError(t, err) {
-		assert.NotPanics(t, func() {
-			logger.maybeCompressFile(stringx.RandId())
-		})
-	}
-}
-
 func TestRotateLoggerWithSizeLimitRotateRuleRotate(t *testing.T) {
 	filename, err := fs.TempFilenameWithText("foo")
 	assert.Nil(t, err)

core/logx/syslog_test.go

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

core/logx/writer.go

@@ -16,15 +16,15 @@ import (
 
 type (
 	Writer interface {
-		Alert(v any)
+		Alert(v interface{})
 		Close() error
-		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)
+		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)
 	}
 
 	atomicWriter struct {
@@ -171,7 +171,7 @@ func newFileWriter(c LogConf) (Writer, error) {
 	}, nil
 }
 
-func (w *concreteWriter) Alert(v any) {
+func (w *concreteWriter) Alert(v interface{}) {
 	output(w.errorLog, levelAlert, v)
 }
 
@@ -195,62 +195,62 @@ func (w *concreteWriter) Close() error {
 	return w.statLog.Close()
 }
 
-func (w *concreteWriter) Debug(v any, fields ...LogField) {
+func (w *concreteWriter) Debug(v interface{}, fields ...LogField) {
 	output(w.infoLog, levelDebug, v, fields...)
 }
 
-func (w *concreteWriter) Error(v any, fields ...LogField) {
+func (w *concreteWriter) Error(v interface{}, fields ...LogField) {
 	output(w.errorLog, levelError, v, fields...)
 }
 
-func (w *concreteWriter) Info(v any, fields ...LogField) {
+func (w *concreteWriter) Info(v interface{}, fields ...LogField) {
 	output(w.infoLog, levelInfo, v, fields...)
 }
 
-func (w *concreteWriter) Severe(v any) {
+func (w *concreteWriter) Severe(v interface{}) {
 	output(w.severeLog, levelFatal, v)
 }
 
-func (w *concreteWriter) Slow(v any, fields ...LogField) {
+func (w *concreteWriter) Slow(v interface{}, fields ...LogField) {
 	output(w.slowLog, levelSlow, v, fields...)
 }
 
-func (w *concreteWriter) Stack(v any) {
+func (w *concreteWriter) Stack(v interface{}) {
 	output(w.stackLog, levelError, v)
 }
 
-func (w *concreteWriter) Stat(v any, fields ...LogField) {
+func (w *concreteWriter) Stat(v interface{}, fields ...LogField) {
 	output(w.statLog, levelStat, v, fields...)
 }
 
 type nopWriter struct{}
 
-func (n nopWriter) Alert(_ any) {
+func (n nopWriter) Alert(_ interface{}) {
 }
 
 func (n nopWriter) Close() error {
 	return nil
 }
 
-func (n nopWriter) Debug(_ any, _ ...LogField) {
+func (n nopWriter) Debug(_ interface{}, _ ...LogField) {
 }
 
-func (n nopWriter) Error(_ any, _ ...LogField) {
+func (n nopWriter) Error(_ interface{}, _ ...LogField) {
 }
 
-func (n nopWriter) Info(_ any, _ ...LogField) {
+func (n nopWriter) Info(_ interface{}, _ ...LogField) {
 }
 
-func (n nopWriter) Severe(_ any) {
+func (n nopWriter) Severe(_ interface{}) {
 }
 
-func (n nopWriter) Slow(_ any, _ ...LogField) {
+func (n nopWriter) Slow(_ interface{}, _ ...LogField) {
 }
 
-func (n nopWriter) Stack(_ any) {
+func (n nopWriter) Stack(_ interface{}) {
 }
 
-func (n nopWriter) Stat(_ any, _ ...LogField) {
+func (n nopWriter) Stat(_ interface{}, _ ...LogField) {
 }
 
 func buildPlainFields(fields ...LogField) []string {
@@ -277,7 +277,7 @@ func combineGlobalFields(fields []LogField) []LogField {
 	return ret
 }
 
-func output(writer io.Writer, level string, val any, fields ...LogField) {
+func output(writer io.Writer, level string, val interface{}, 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)
@@ -330,7 +330,7 @@ func wrapLevelWithColor(level string) string {
 	return color.WithColorPadding(level, colour)
 }
 
-func writeJson(writer io.Writer, info any) {
+func writeJson(writer io.Writer, info interface{}) {
 	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 any) {
 	}
 }
 
-func writePlainAny(writer io.Writer, level string, val any, fields ...string) {
+func writePlainAny(writer io.Writer, level string, val interface{}, 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 any, fields ...string) {
+func writePlainValue(writer io.Writer, level string, val interface{}, 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 any, opts ...UnmarshalOption) error {
+func UnmarshalJsonBytes(content []byte, v interface{}, opts ...UnmarshalOption) error {
 	return unmarshalJsonBytes(content, v, getJsonUnmarshaler(opts...))
 }
 
 // UnmarshalJsonMap unmarshals content from m into v.
-func UnmarshalJsonMap(m map[string]any, v any, opts ...UnmarshalOption) error {
+func UnmarshalJsonMap(m map[string]interface{}, v interface{}, opts ...UnmarshalOption) error {
 	return getJsonUnmarshaler(opts...).Unmarshal(m, v)
 }
 
 // UnmarshalJsonReader unmarshals content from reader into v.
-func UnmarshalJsonReader(reader io.Reader, v any, opts ...UnmarshalOption) error {
+func UnmarshalJsonReader(reader io.Reader, v interface{}, 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 any, unmarshaler *Unmarshaler) error {
-	var m any
+func unmarshalJsonBytes(content []byte, v interface{}, unmarshaler *Unmarshaler) error {
+	var m interface{}
 	if err := jsonx.Unmarshal(content, &m); err != nil {
 		return err
 	}
@@ -42,8 +42,8 @@ func unmarshalJsonBytes(content []byte, v any, unmarshaler *Unmarshaler) error {
 	return unmarshaler.Unmarshal(m, v)
 }
 
-func unmarshalJsonReader(reader io.Reader, v any, unmarshaler *Unmarshaler) error {
-	var m any
+func unmarshalJsonReader(reader io.Reader, v interface{}, unmarshaler *Unmarshaler) error {
+	var m interface{}
 	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]any
+		var m map[string]interface{}
 		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]any{}
+		m := map[string]interface{}{}
 		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]any{}
+		m := map[string]interface{}{}
 		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]any{
+		m := map[string]interface{}{
 			"Any": "foo",
 		}
 		var v struct {

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 any) (map[string]map[string]any, error) {
-	ret := make(map[string]map[string]any)
+func Marshal(val interface{}) (map[string]map[string]interface{}, error) {
+	ret := make(map[string]map[string]interface{})
 	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]any) error {
+	collector map[string]map[string]interface{}) 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]any{
+		m = map[string]interface{}{
 			key: val,
 		}
 	}

core/mapping/marshaler_test.go

@@ -227,7 +227,7 @@ func TestMarshal_Range(t *testing.T) {
 }
 
 func TestMarshal_RangeOut(t *testing.T) {
-	tests := []any{
+	tests := []interface{}{
 		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 := []any{
+	tests := []interface{}{
 		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 any
+		value interface{}
 		err   error
 	}{
 		{

core/mapping/tomlunmarshaler.go

@@ -7,7 +7,7 @@ import (
 )
 
 // UnmarshalTomlBytes unmarshals TOML bytes into the given v.
-func UnmarshalTomlBytes(content []byte, v any, opts ...UnmarshalOption) error {
+func UnmarshalTomlBytes(content []byte, v interface{}, opts ...UnmarshalOption) error {
 	b, err := encoding.TomlToJson(content)
 	if err != nil {
 		return err
@@ -17,7 +17,7 @@ func UnmarshalTomlBytes(content []byte, v any, opts ...UnmarshalOption) error {
 }
 
 // UnmarshalTomlReader unmarshals TOML from the given io.Reader into the given v.
-func UnmarshalTomlReader(r io.Reader, v any, opts ...UnmarshalOption) error {
+func UnmarshalTomlReader(r io.Reader, v interface{}, 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]any)
+	defaultCache        = make(map[string]interface{})
 	defaultCacheLock    sync.Mutex
-	emptyMap            = map[string]any{}
+	emptyMap            = map[string]interface{}{}
 	emptyValue          = reflect.ValueOf(lang.Placeholder)
 )
 
@@ -67,12 +67,12 @@ func NewUnmarshaler(key string, opts ...UnmarshalOption) *Unmarshaler {
 }
 
 // UnmarshalKey unmarshals m into v with tag key.
-func UnmarshalKey(m map[string]any, v any) error {
+func UnmarshalKey(m map[string]interface{}, v interface{}) error {
 	return keyUnmarshaler.Unmarshal(m, v)
 }
 
 // Unmarshal unmarshals m into v.
-func (u *Unmarshaler) Unmarshal(i any, v any) error {
+func (u *Unmarshaler) Unmarshal(i interface{}, v interface{}) error {
 	valueType := reflect.TypeOf(v)
 	if valueType.Kind() != reflect.Ptr {
 		return errValueNotSettable
@@ -80,13 +80,13 @@ func (u *Unmarshaler) Unmarshal(i any, v any) error {
 
 	elemType := Deref(valueType)
 	switch iv := i.(type) {
-	case map[string]any:
+	case map[string]interface{}:
 		if elemType.Kind() != reflect.Struct {
 			return errTypeMismatch
 		}
 
 		return u.UnmarshalValuer(mapValuer(iv), v)
-	case []any:
+	case []interface{}:
 		if elemType.Kind() != reflect.Slice {
 			return errTypeMismatch
 		}
@@ -98,11 +98,11 @@ func (u *Unmarshaler) Unmarshal(i any, v any) error {
 }
 
 // UnmarshalValuer unmarshals m into v.
-func (u *Unmarshaler) UnmarshalValuer(m Valuer, v any) error {
+func (u *Unmarshaler) UnmarshalValuer(m Valuer, v interface{}) error {
 	return u.unmarshalWithFullName(simpleValuer{current: m}, v, "")
 }
 
-func (u *Unmarshaler) fillMap(fieldType reflect.Type, value reflect.Value, mapValue any) error {
+func (u *Unmarshaler) fillMap(fieldType reflect.Type, value reflect.Value, mapValue interface{}) error {
 	if !value.CanSet() {
 		return errValueNotSettable
 	}
@@ -122,7 +122,7 @@ func (u *Unmarshaler) fillMap(fieldType reflect.Type, value reflect.Value, mapVa
 	return nil
 }
 
-func (u *Unmarshaler) fillMapFromString(value reflect.Value, mapValue any) error {
+func (u *Unmarshaler) fillMapFromString(value reflect.Value, mapValue interface{}) error {
 	if !value.CanSet() {
 		return errValueNotSettable
 	}
@@ -143,7 +143,7 @@ func (u *Unmarshaler) fillMapFromString(value reflect.Value, mapValue any) error
 	return nil
 }
 
-func (u *Unmarshaler) fillSlice(fieldType reflect.Type, value reflect.Value, mapValue any) error {
+func (u *Unmarshaler) fillSlice(fieldType reflect.Type, value reflect.Value, mapValue interface{}) error {
 	if !value.CanSet() {
 		return errValueNotSettable
 	}
@@ -173,7 +173,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]any), target.Interface()); err != nil {
+			if err := u.Unmarshal(ithValue.(map[string]interface{}), target.Interface()); err != nil {
 				return err
 			}
 
@@ -197,8 +197,8 @@ func (u *Unmarshaler) fillSlice(fieldType reflect.Type, value reflect.Value, map
 }
 
 func (u *Unmarshaler) fillSliceFromString(fieldType reflect.Type, value reflect.Value,
-	mapValue any) error {
-	var slice []any
+	mapValue interface{}) error {
+	var slice []interface{}
 	switch v := mapValue.(type) {
 	case fmt.Stringer:
 		if err := jsonx.UnmarshalFromString(v.String(), &slice); err != nil {
@@ -227,14 +227,14 @@ func (u *Unmarshaler) fillSliceFromString(fieldType reflect.Type, value reflect.
 }
 
 func (u *Unmarshaler) fillSliceValue(slice reflect.Value, index int,
-	baseKind reflect.Kind, value any) error {
+	baseKind reflect.Kind, value interface{}) 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]any:
+	case map[string]interface{}:
 		return u.fillMap(ithVal.Type(), ithVal, value)
 	default:
 		// don't need to consider the difference between int, int8, int16, int32, int64,
@@ -282,7 +282,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 any) (reflect.Value, error) {
+func (u *Unmarshaler) generateMap(keyType, elemType reflect.Type, mapValue interface{}) (reflect.Value, error) {
 	mapType := reflect.MapOf(keyType, elemType)
 	valueType := reflect.TypeOf(mapValue)
 	if mapType == valueType {
@@ -307,7 +307,7 @@ func (u *Unmarshaler) generateMap(keyType, elemType reflect.Type, mapValue any)
 
 			targetValue.SetMapIndex(key, target.Elem())
 		case reflect.Struct:
-			keythMap, ok := keythData.(map[string]any)
+			keythMap, ok := keythData.(map[string]interface{})
 			if !ok {
 				return emptyValue, errTypeMismatch
 			}
@@ -319,7 +319,7 @@ func (u *Unmarshaler) generateMap(keyType, elemType reflect.Type, mapValue any)
 
 			SetMapIndexValue(elemType, targetValue, key, target.Elem())
 		case reflect.Map:
-			keythMap, ok := keythData.(map[string]any)
+			keythMap, ok := keythData.(map[string]interface{})
 			if !ok {
 				return emptyValue, errTypeMismatch
 			}
@@ -514,7 +514,7 @@ func (u *Unmarshaler) processFieldNotFromString(fieldType reflect.Type, value re
 
 	switch {
 	case valueKind == reflect.Map && typeKind == reflect.Struct:
-		mv, ok := mapValue.(map[string]any)
+		mv, ok := mapValue.(map[string]interface{})
 		if !ok {
 			return errTypeMismatch
 		}
@@ -537,7 +537,7 @@ func (u *Unmarshaler) processFieldNotFromString(fieldType reflect.Type, value re
 }
 
 func (u *Unmarshaler) processFieldPrimitive(fieldType reflect.Type, value reflect.Value,
-	mapValue any, opts *fieldOptionsWithContext, fullName string) error {
+	mapValue interface{}, opts *fieldOptionsWithContext, fullName string) error {
 	typeKind := Deref(fieldType).Kind()
 	valueKind := reflect.TypeOf(mapValue).Kind()
 
@@ -632,7 +632,7 @@ func (u *Unmarshaler) processFieldStruct(fieldType reflect.Type, value reflect.V
 }
 
 func (u *Unmarshaler) processFieldTextUnmarshaler(fieldType reflect.Type, value reflect.Value,
-	mapValue any) (bool, error) {
+	mapValue interface{}) (bool, error) {
 	var tval encoding.TextUnmarshaler
 	var ok bool
 
@@ -712,7 +712,7 @@ func (u *Unmarshaler) processNamedField(field reflect.StructField, value reflect
 	valuer := createValuer(m, opts)
 	mapValue, hasValue := getValue(valuer, canonicalKey)
 
-	// When fillDefault is used, m is a null value, hasValue must be false, all priority judgments fillDefault.
+	// When fillDefault is used, m is a null value, hasValue must be false, all priority judgments fillDefault,
 	if u.opts.fillDefault {
 		if !value.IsZero() {
 			return fmt.Errorf("set the default value, %s must be zero", fullName)
@@ -764,7 +764,7 @@ func (u *Unmarshaler) processNamedFieldWithValue(fieldType reflect.Type, value r
 }
 
 func (u *Unmarshaler) processNamedFieldWithValueFromString(fieldType reflect.Type, value reflect.Value,
-	mapValue any, key string, opts *fieldOptionsWithContext, fullName string) error {
+	mapValue interface{}, 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)
@@ -844,7 +844,7 @@ func (u *Unmarshaler) processNamedFieldWithoutValue(fieldType reflect.Type, valu
 	return nil
 }
 
-func (u *Unmarshaler) unmarshalWithFullName(m valuerWithParent, v any, fullName string) error {
+func (u *Unmarshaler) unmarshalWithFullName(m valuerWithParent, v interface{}, fullName string) error {
 	rv := reflect.ValueOf(v)
 	if err := ValidatePtr(&rv); err != nil {
 		return err
@@ -924,7 +924,7 @@ func fillDurationValue(fieldType reflect.Type, value reflect.Value, dur string)
 	return nil
 }
 
-func fillPrimitive(fieldType reflect.Type, value reflect.Value, mapValue any,
+func fillPrimitive(fieldType reflect.Type, value reflect.Value, mapValue interface{},
 	opts *fieldOptionsWithContext, fullName string) error {
 	if !value.CanSet() {
 		return errValueNotSettable
@@ -953,7 +953,7 @@ func fillPrimitive(fieldType reflect.Type, value reflect.Value, mapValue any,
 	}
 }
 
-func fillWithSameType(fieldType reflect.Type, value reflect.Value, mapValue any,
+func fillWithSameType(fieldType reflect.Type, value reflect.Value, mapValue interface{},
 	opts *fieldOptionsWithContext) error {
 	if !value.CanSet() {
 		return errValueNotSettable
@@ -976,12 +976,12 @@ func fillWithSameType(fieldType reflect.Type, value reflect.Value, mapValue any,
 }
 
 // getValue gets the value for the specific key, the key can be in the format of parentKey.childKey
-func getValue(m valuerWithParent, key string) (any, bool) {
+func getValue(m valuerWithParent, key string) (interface{}, bool) {
 	keys := readKeys(key)
 	return getValueWithChainedKeys(m, keys)
 }
 
-func getValueWithChainedKeys(m valuerWithParent, keys []string) (any, bool) {
+func getValueWithChainedKeys(m valuerWithParent, keys []string) (interface{}, bool) {
 	switch len(keys) {
 	case 0:
 		return nil, false
@@ -990,7 +990,7 @@ func getValueWithChainedKeys(m valuerWithParent, keys []string) (any, bool) {
 		return v, ok
 	default:
 		if v, ok := m.Value(keys[0]); ok {
-			if nextm, ok := v.(map[string]any); ok {
+			if nextm, ok := v.(map[string]interface{}); ok {
 				return getValueWithChainedKeys(recursiveValuer{
 					current: mapValuer(nextm),
 					parent:  m,
@@ -1049,7 +1049,7 @@ func readKeys(key string) []string {
 	return keys
 }
 
-func setSameKindValue(targetType reflect.Type, target reflect.Value, value any) {
+func setSameKindValue(targetType reflect.Type, target reflect.Value, value interface{}) {
 	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 any) string {
+func Repr(v interface{}) string {
 	return lang.Repr(v)
 }
 
@@ -89,7 +89,7 @@ func ValidatePtr(v *reflect.Value) error {
 	return nil
 }
 
-func convertTypeFromString(kind reflect.Kind, str string) (any, error) {
+func convertTypeFromString(kind reflect.Kind, str string) (interface{}, 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 any) error {
+func setMatchedPrimitiveValue(kind reflect.Kind, value reflect.Value, v interface{}) 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 any) (float64, bool) {
+func toFloat64(v interface{}) (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 any, options []string) error {
+func validateValueInOptions(val interface{}, options []string) error {
 	if len(options) > 0 {
 		switch v := val.(type) {
 		case string:
@@ -640,7 +640,7 @@ func validateValueInOptions(val any, options []string) error {
 	return nil
 }
 
-func validateValueRange(mapValue any, opts *fieldOptionsWithContext) error {
+func validateValueRange(mapValue interface{}, 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]any
+		MapValue   map[string]interface{}
 	}
 
 	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) (any, bool)
+		Value(key string) (interface{}, 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  any
+		value  interface{}
 		parent valuerWithParent
 	}
 
 	// mapValuer is a type for map to meet the Valuer interface.
-	mapValuer map[string]any
+	mapValuer map[string]interface{}
 	// 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) (any, bool) {
+func (mv mapValuer) Value(key string) (interface{}, 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) (any, bool) {
+func (sv simpleValuer) Value(key string) (interface{}, 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) (any, bool) {
+func (rv recursiveValuer) Value(key string) (interface{}, 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) (any, bool) {
 		return nil, false
 	}
 
-	vm, ok := val.(map[string]any)
+	vm, ok := val.(map[string]interface{})
 	if !ok {
 		return val, true
 	}
@@ -85,7 +85,7 @@ func (rv recursiveValuer) Value(key string) (any, bool) {
 		return val, true
 	}
 
-	pm, ok := pv.(map[string]any)
+	pm, ok := pv.(map[string]interface{})
 	if !ok {
 		return val, true
 	}

core/mapping/valuer_test.go

@@ -7,17 +7,17 @@ import (
 )
 
 func TestMapValuerWithInherit_Value(t *testing.T) {
-	input := map[string]any{
-		"discovery": map[string]any{
+	input := map[string]interface{}{
+		"discovery": map[string]interface{}{
 			"host": "localhost",
 			"port": 8080,
 		},
-		"component": map[string]any{
+		"component": map[string]interface{}{
 			"name": "test",
 		},
 	}
 	valuer := recursiveValuer{
-		current: mapValuer(input["component"].(map[string]any)),
+		current: mapValuer(input["component"].(map[string]interface{})),
 		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]any)
+	m, ok := val.(map[string]interface{})
 	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]any{
-		"component": map[string]any{
+	input := map[string]interface{}{
+		"component": map[string]interface{}{
 			"name": "test",
-			"foo": map[string]any{
+			"foo": map[string]interface{}{
 				"bar": "baz",
 			},
 		},
 		"foo": "value",
 	}
 	valuer := recursiveValuer{
-		current: mapValuer(input["component"].(map[string]any)),
+		current: mapValuer(input["component"].(map[string]interface{})),
 		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]any{
+	assert.EqualValues(t, map[string]interface{}{
 		"bar": "baz",
 	}, val)
 }

core/mapping/yamlunmarshaler.go

@@ -7,7 +7,7 @@ import (
 )
 
 // UnmarshalYamlBytes unmarshals content into v.
-func UnmarshalYamlBytes(content []byte, v any, opts ...UnmarshalOption) error {
+func UnmarshalYamlBytes(content []byte, v interface{}, opts ...UnmarshalOption) error {
 	b, err := encoding.YamlToJson(content)
 	if err != nil {
 		return err
@@ -17,7 +17,7 @@ func UnmarshalYamlBytes(content []byte, v any, opts ...UnmarshalOption) error {
 }
 
 // UnmarshalYamlReader unmarshals content from reader into v.
-func UnmarshalYamlReader(reader io.Reader, v any, opts ...UnmarshalOption) error {
+func UnmarshalYamlReader(reader io.Reader, v interface{}, 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[any]int) float64 {
+func CalcEntropy(m map[interface{}]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[any]int, total)
+	m := make(map[interface{}]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[any]int, len(m))
+	mi := make(map[interface{}]int, len(m))
 	for k, v := range m {
 		mi[k] = v
 	}

core/mr/mapreduce.go

@@ -7,6 +7,7 @@ import (
 	"sync/atomic"
 
 	"github.com/zeromicro/go-zero/core/errorx"
+	"github.com/zeromicro/go-zero/core/lang"
 )
 
 const (
@@ -23,30 +24,30 @@ var (
 
 type (
 	// ForEachFunc is used to do element processing, but no output.
-	ForEachFunc[T any] func(item T)
+	ForEachFunc func(item interface{})
 	// GenerateFunc is used to let callers send elements into source.
-	GenerateFunc[T any] func(source chan<- T)
+	GenerateFunc func(source chan<- interface{})
 	// MapFunc is used to do element processing and write the output to writer.
-	MapFunc[T, U any] func(item T, writer Writer[U])
+	MapFunc func(item interface{}, writer Writer)
 	// MapperFunc is used to do element processing and write the output to writer,
 	// use cancel func to cancel the processing.
-	MapperFunc[T, U any] func(item T, writer Writer[U], cancel func(error))
+	MapperFunc func(item interface{}, 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[U, V any] func(pipe <-chan U, writer Writer[V], cancel func(error))
+	ReducerFunc func(pipe <-chan interface{}, 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[U any] func(pipe <-chan U, cancel func(error))
+	VoidReducerFunc func(pipe <-chan interface{}, cancel func(error))
 	// Option defines the method to customize the mapreduce.
 	Option func(opts *mapReduceOptions)
 
-	mapperContext[T, U any] struct {
+	mapperContext struct {
 		ctx       context.Context
-		mapper    MapFunc[T, U]
-		source    <-chan T
+		mapper    MapFunc
+		source    <-chan interface{}
 		panicChan *onceChan
-		collector chan<- U
-		doneChan  <-chan struct{}
+		collector chan<- interface{}
+		doneChan  <-chan lang.PlaceholderType
 		workers   int
 	}
 
@@ -56,8 +57,8 @@ type (
 	}
 
 	// Writer interface wraps Write method.
-	Writer[T any] interface {
-		Write(v T)
+	Writer interface {
+		Write(v interface{})
 	}
 )
 
@@ -67,15 +68,16 @@ func Finish(fns ...func() error) error {
 		return nil
 	}
 
-	return MapReduceVoid(func(source chan<- func() error) {
+	return MapReduceVoid(func(source chan<- interface{}) {
 		for _, fn := range fns {
 			source <- fn
 		}
-	}, func(fn func() error, writer Writer[any], cancel func(error)) {
+	}, func(item interface{}, writer Writer, cancel func(error)) {
+		fn := item.(func() error)
 		if err := fn(); err != nil {
 			cancel(err)
 		}
-	}, func(pipe <-chan any, cancel func(error)) {
+	}, func(pipe <-chan interface{}, cancel func(error)) {
 	}, WithWorkers(len(fns)))
 }
 
@@ -85,26 +87,27 @@ func FinishVoid(fns ...func()) {
 		return
 	}
 
-	ForEach(func(source chan<- func()) {
+	ForEach(func(source chan<- interface{}) {
 		for _, fn := range fns {
 			source <- fn
 		}
-	}, func(fn func()) {
+	}, func(item interface{}) {
+		fn := item.(func())
 		fn()
 	}, WithWorkers(len(fns)))
 }
 
 // ForEach maps all elements from given generate but no output.
-func ForEach[T any](generate GenerateFunc[T], mapper ForEachFunc[T], opts ...Option) {
+func ForEach(generate GenerateFunc, mapper ForEachFunc, opts ...Option) {
 	options := buildOptions(opts...)
-	panicChan := &onceChan{channel: make(chan any)}
+	panicChan := &onceChan{channel: make(chan interface{})}
 	source := buildSource(generate, panicChan)
-	collector := make(chan any)
-	done := make(chan struct{})
+	collector := make(chan interface{})
+	done := make(chan lang.PlaceholderType)
 
-	go executeMappers(mapperContext[T, any]{
+	go executeMappers(mapperContext{
 		ctx: options.ctx,
-		mapper: func(item T, _ Writer[any]) {
+		mapper: func(item interface{}, _ Writer) {
 			mapper(item)
 		},
 		source:    source,
@@ -128,26 +131,26 @@ func ForEach[T any](generate GenerateFunc[T], mapper ForEachFunc[T], opts ...Opt
 
 // MapReduce maps all elements generated from given generate func,
 // and reduces the output elements with given reducer.
-func MapReduce[T, U, V any](generate GenerateFunc[T], mapper MapperFunc[T, U], reducer ReducerFunc[U, V],
-	opts ...Option) (V, error) {
-	panicChan := &onceChan{channel: make(chan any)}
+func MapReduce(generate GenerateFunc, mapper MapperFunc, reducer ReducerFunc,
+	opts ...Option) (interface{}, error) {
+	panicChan := &onceChan{channel: make(chan interface{})}
 	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[T, U, V any](source <-chan T, mapper MapperFunc[T, U], reducer ReducerFunc[U, V],
-	opts ...Option) (V, error) {
-	panicChan := &onceChan{channel: make(chan any)}
+func MapReduceChan(source <-chan interface{}, mapper MapperFunc, reducer ReducerFunc,
+	opts ...Option) (interface{}, error) {
+	panicChan := &onceChan{channel: make(chan interface{})}
 	return mapReduceWithPanicChan(source, panicChan, mapper, reducer, opts...)
 }
 
 // mapReduceWithPanicChan maps all elements from source, and reduce the output elements with given reducer.
-func mapReduceWithPanicChan[T, U, V any](source <-chan T, panicChan *onceChan, mapper MapperFunc[T, U],
-	reducer ReducerFunc[U, V], opts ...Option) (val V, err error) {
+func mapReduceWithPanicChan(source <-chan interface{}, panicChan *onceChan, mapper MapperFunc,
+	reducer ReducerFunc, opts ...Option) (interface{}, error) {
 	options := buildOptions(opts...)
 	// output is used to write the final result
-	output := make(chan V)
+	output := make(chan interface{})
 	defer func() {
 		// reducer can only write once, if more, panic
 		for range output {
@@ -156,12 +159,12 @@ func mapReduceWithPanicChan[T, U, V any](source <-chan T, panicChan *onceChan, m
 	}()
 
 	// collector is used to collect data from mapper, and consume in reducer
-	collector := make(chan U, options.workers)
+	collector := make(chan interface{}, options.workers)
 	// if done is closed, all mappers and reducer should stop processing
-	done := make(chan struct{})
+	done := make(chan lang.PlaceholderType)
 	writer := newGuardedWriter(options.ctx, output, done)
 	var closeOnce sync.Once
-	// use atomic type to avoid data race
+	// use atomic.Value to avoid data race
 	var retErr errorx.AtomicError
 	finish := func() {
 		closeOnce.Do(func() {
@@ -192,9 +195,9 @@ func mapReduceWithPanicChan[T, U, V any](source <-chan T, panicChan *onceChan, m
 		reducer(collector, writer, cancel)
 	}()
 
-	go executeMappers(mapperContext[T, U]{
+	go executeMappers(mapperContext{
 		ctx: options.ctx,
-		mapper: func(item T, w Writer[U]) {
+		mapper: func(item interface{}, w Writer) {
 			mapper(item, w, cancel)
 		},
 		source:    source,
@@ -207,29 +210,26 @@ func mapReduceWithPanicChan[T, U, V any](source <-chan T, panicChan *onceChan, m
 	select {
 	case <-options.ctx.Done():
 		cancel(context.DeadlineExceeded)
-		err = context.DeadlineExceeded
+		return nil, context.DeadlineExceeded
 	case v := <-panicChan.channel:
 		// drain output here, otherwise for loop panic in defer
 		drain(output)
 		panic(v)
 	case v, ok := <-output:
-		if e := retErr.Load(); e != nil {
-			err = e
+		if err := retErr.Load(); err != nil {
+			return nil, err
 		} else if ok {
-			val = v
+			return v, nil
 		} else {
-			err = ErrReduceNoOutput
+			return nil, ErrReduceNoOutput
 		}
 	}
-
-	return
 }
 
 // MapReduceVoid maps all elements generated from given generate,
 // and reduce the output elements with given reducer.
-func MapReduceVoid[T, U any](generate GenerateFunc[T], mapper MapperFunc[T, U],
-	reducer VoidReducerFunc[U], opts ...Option) error {
-	_, err := MapReduce(generate, mapper, func(input <-chan U, writer Writer[any], cancel func(error)) {
+func MapReduceVoid(generate GenerateFunc, mapper MapperFunc, reducer VoidReducerFunc, opts ...Option) error {
+	_, err := MapReduce(generate, mapper, func(input <-chan interface{}, 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[T any](generate GenerateFunc[T], panicChan *onceChan) chan T {
-	source := make(chan T)
+func buildSource(generate GenerateFunc, panicChan *onceChan) chan interface{} {
+	source := make(chan interface{})
 	go func() {
 		defer func() {
 			if r := recover(); r != nil {
@@ -283,13 +283,13 @@ func buildSource[T any](generate GenerateFunc[T], panicChan *onceChan) chan T {
 }
 
 // drain drains the channel.
-func drain[T any](channel <-chan T) {
+func drain(channel <-chan interface{}) {
 	// drain the channel
 	for range channel {
 	}
 }
 
-func executeMappers[T, U any](mCtx mapperContext[T, U]) {
+func executeMappers(mCtx mapperContext) {
 	var wg sync.WaitGroup
 	defer func() {
 		wg.Wait()
@@ -298,7 +298,7 @@ func executeMappers[T, U any](mCtx mapperContext[T, U]) {
 	}()
 
 	var failed int32
-	pool := make(chan struct{}, mCtx.workers)
+	pool := make(chan lang.PlaceholderType, mCtx.workers)
 	writer := newGuardedWriter(mCtx.ctx, mCtx.collector, mCtx.doneChan)
 	for atomic.LoadInt32(&failed) == 0 {
 		select {
@@ -306,7 +306,7 @@ func executeMappers[T, U any](mCtx mapperContext[T, U]) {
 			return
 		case <-mCtx.doneChan:
 			return
-		case pool <- struct{}{}:
+		case pool <- lang.Placeholder:
 			item, ok := <-mCtx.source
 			if !ok {
 				<-pool
@@ -346,21 +346,22 @@ func once(fn func(error)) func(error) {
 	}
 }
 
-type guardedWriter[T any] struct {
+type guardedWriter struct {
 	ctx     context.Context
-	channel chan<- T
-	done    <-chan struct{}
+	channel chan<- interface{}
+	done    <-chan lang.PlaceholderType
 }
 
-func newGuardedWriter[T any](ctx context.Context, channel chan<- T, done <-chan struct{}) guardedWriter[T] {
-	return guardedWriter[T]{
+func newGuardedWriter(ctx context.Context, channel chan<- interface{},
+	done <-chan lang.PlaceholderType) guardedWriter {
+	return guardedWriter{
 		ctx:     ctx,
 		channel: channel,
 		done:    done,
 	}
 }
 
-func (gw guardedWriter[T]) Write(v T) {
+func (gw guardedWriter) Write(v interface{}) {
 	select {
 	case <-gw.ctx.Done():
 		return
@@ -372,11 +373,11 @@ func (gw guardedWriter[T]) Write(v T) {
 }
 
 type onceChan struct {
-	channel chan any
+	channel chan interface{}
 	wrote   int32
 }
 
-func (oc *onceChan) write(val any) {
+func (oc *onceChan) write(val interface{}) {
 	if atomic.CompareAndSwapInt32(&oc.wrote, 0, 1) {
 		oc.channel <- val
 	}

core/mr/mapreduce_fuzz_test.go

@@ -1,3 +1,6 @@
+//go:build go1.18
+// +build go1.18
+
 package mr
 
 import (
@@ -15,9 +18,9 @@ import (
 func FuzzMapReduce(f *testing.F) {
 	rand.Seed(time.Now().UnixNano())
 
-	f.Add(int64(10), runtime.NumCPU())
-	f.Fuzz(func(t *testing.T, n int64, workers int) {
-		n = n%5000 + 5000
+	f.Add(uint(10), uint(runtime.NumCPU()))
+	f.Fuzz(func(t *testing.T, num, workers uint) {
+		n := int64(num)%5000 + 5000
 		genPanic := rand.Intn(100) == 0
 		mapperPanic := rand.Intn(100) == 0
 		reducerPanic := rand.Intn(100) == 0
@@ -26,33 +29,34 @@ func FuzzMapReduce(f *testing.F) {
 		reducerIdx := rand.Int63n(n)
 		squareSum := (n - 1) * n * (2*n - 1) / 6
 
-		fn := func() (int64, error) {
+		fn := func() (interface{}, error) {
 			defer goleak.VerifyNone(t, goleak.IgnoreCurrent())
 
-			return MapReduce(func(source chan<- int64) {
+			return MapReduce(func(source chan<- interface{}) {
 				for i := int64(0); i < n; i++ {
 					source <- i
 					if genPanic && i == genIdx {
 						panic("foo")
 					}
 				}
-			}, func(v int64, writer Writer[int64], cancel func(error)) {
+			}, func(item interface{}, writer Writer, cancel func(error)) {
+				v := item.(int64)
 				if mapperPanic && v == mapperIdx {
 					panic("bar")
 				}
 				writer.Write(v * v)
-			}, func(pipe <-chan int64, writer Writer[int64], cancel func(error)) {
+			}, func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
 				var idx int64
 				var total int64
 				for v := range pipe {
 					if reducerPanic && idx == reducerIdx {
 						panic("baz")
 					}
-					total += v
+					total += v.(int64)
 					idx++
 				}
 				writer.Write(total)
-			}, WithWorkers(workers%50+runtime.NumCPU()))
+			}, WithWorkers(int(workers)%50+runtime.NumCPU()/2))
 		}
 
 		if genPanic || mapperPanic || reducerPanic {
@@ -68,7 +72,7 @@ func FuzzMapReduce(f *testing.F) {
 		} else {
 			val, err := fn()
 			assert.Nil(t, err)
-			assert.Equal(t, squareSum, val)
+			assert.Equal(t, squareSum, val.(int64))
 		}
 	})
 }

core/mr/mapreduce_fuzzcase_test.go

@@ -54,27 +54,28 @@ func TestMapReduceRandom(t *testing.T) {
 				reducerIdx := rand.Int63n(n)
 				squareSum := (n - 1) * n * (2*n - 1) / 6
 
-				fn := func() (int64, error) {
-					return MapReduce(func(source chan<- int64) {
+				fn := func() (interface{}, error) {
+					return MapReduce(func(source chan<- interface{}) {
 						for i := int64(0); i < n; i++ {
 							source <- i
 							if genPanic && i == genIdx {
 								panic("foo")
 							}
 						}
-					}, func(v int64, writer Writer[int64], cancel func(error)) {
+					}, func(item interface{}, writer Writer, cancel func(error)) {
+						v := item.(int64)
 						if mapperPanic && v == mapperIdx {
 							panic("bar")
 						}
 						writer.Write(v * v)
-					}, func(pipe <-chan int64, writer Writer[int64], cancel func(error)) {
+					}, func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
 						var idx int64
 						var total int64
 						for v := range pipe {
 							if reducerPanic && idx == reducerIdx {
 								panic("baz")
 							}
-							total += v
+							total += v.(int64)
 							idx++
 						}
 						writer.Write(total)
@@ -94,7 +95,7 @@ func TestMapReduceRandom(t *testing.T) {
 				} else {
 					val, err := fn()
 					assert.Nil(t, err)
-					assert.Equal(t, squareSum, val)
+					assert.Equal(t, squareSum, val.(int64))
 				}
 				bar.Increment()
 			})

core/mr/mapreduce_test.go

@@ -3,7 +3,7 @@ package mr
 import (
 	"context"
 	"errors"
-	"io/ioutil"
+	"io"
 	"log"
 	"runtime"
 	"sync/atomic"
@@ -17,7 +17,7 @@ import (
 var errDummy = errors.New("dummy")
 
 func init() {
-	log.SetOutput(ioutil.Discard)
+	log.SetOutput(io.Discard)
 }
 
 func TestFinish(t *testing.T) {
@@ -91,11 +91,11 @@ func TestForEach(t *testing.T) {
 		defer goleak.VerifyNone(t)
 
 		var count uint32
-		ForEach(func(source chan<- int) {
+		ForEach(func(source chan<- interface{}) {
 			for i := 0; i < tasks; i++ {
 				source <- i
 			}
-		}, func(item int) {
+		}, func(item interface{}) {
 			atomic.AddUint32(&count, 1)
 		}, WithWorkers(-1))
 
@@ -106,12 +106,12 @@ func TestForEach(t *testing.T) {
 		defer goleak.VerifyNone(t)
 
 		var count uint32
-		ForEach(func(source chan<- int) {
+		ForEach(func(source chan<- interface{}) {
 			for i := 0; i < tasks; i++ {
 				source <- i
 			}
-		}, func(item int) {
-			if item%2 == 0 {
+		}, func(item interface{}) {
+			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<- int) {
+			ForEach(func(source chan<- interface{}) {
 				for i := 0; i < tasks; i++ {
 					source <- i
 				}
-			}, func(item int) {
+			}, func(item interface{}) {
 				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<- int) {
+			ForEach(func(source chan<- interface{}) {
 				panic("foo")
-			}, func(item int) {
+			}, func(item interface{}) {
 			})
 		})
 	})
@@ -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<- int) {
+			_, _ = MapReduce(func(source chan<- interface{}) {
 				for i := 0; i < tasks; i++ {
 					source <- i
 				}
-			}, func(item int, writer Writer[int], cancel func(error)) {
+			}, func(item interface{}, writer Writer, cancel func(error)) {
 				atomic.AddInt32(&run, 1)
 				panic("foo")
-			}, func(pipe <-chan int, writer Writer[int], cancel func(error)) {
+			}, func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
 			})
 		})
 		assert.True(t, atomic.LoadInt32(&run) < tasks/2)
@@ -173,10 +173,10 @@ func TestMapReduce(t *testing.T) {
 
 	tests := []struct {
 		name        string
-		mapper      MapperFunc[int, int]
-		reducer     ReducerFunc[int, int]
+		mapper      MapperFunc
+		reducer     ReducerFunc
 		expectErr   error
-		expectValue int
+		expectValue interface{}
 	}{
 		{
 			name:        "simple",
@@ -185,7 +185,8 @@ func TestMapReduce(t *testing.T) {
 		},
 		{
 			name: "cancel with error",
-			mapper: func(v int, writer Writer[int], cancel func(error)) {
+			mapper: func(item interface{}, writer Writer, cancel func(error)) {
+				v := item.(int)
 				if v%3 == 0 {
 					cancel(errDummy)
 				}
@@ -195,20 +196,22 @@ func TestMapReduce(t *testing.T) {
 		},
 		{
 			name: "cancel with nil",
-			mapper: func(v int, writer Writer[int], cancel func(error)) {
+			mapper: func(item interface{}, writer Writer, cancel func(error)) {
+				v := item.(int)
 				if v%3 == 0 {
 					cancel(nil)
 				}
 				writer.Write(v * v)
 			},
-			expectErr: ErrCancelWithNil,
+			expectErr:   ErrCancelWithNil,
+			expectValue: nil,
 		},
 		{
 			name: "cancel with more",
-			reducer: func(pipe <-chan int, writer Writer[int], cancel func(error)) {
+			reducer: func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
 				var result int
 				for item := range pipe {
-					result += item
+					result += item.(int)
 					if result > 10 {
 						cancel(errDummy)
 					}
@@ -223,20 +226,21 @@ func TestMapReduce(t *testing.T) {
 		for _, test := range tests {
 			t.Run(test.name, func(t *testing.T) {
 				if test.mapper == nil {
-					test.mapper = func(v int, writer Writer[int], cancel func(error)) {
+					test.mapper = func(item interface{}, writer Writer, cancel func(error)) {
+						v := item.(int)
 						writer.Write(v * v)
 					}
 				}
 				if test.reducer == nil {
-					test.reducer = func(pipe <-chan int, writer Writer[int], cancel func(error)) {
+					test.reducer = func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
 						var result int
 						for item := range pipe {
-							result += item
+							result += item.(int)
 						}
 						writer.Write(result)
 					}
 				}
-				value, err := MapReduce(func(source chan<- int) {
+				value, err := MapReduce(func(source chan<- interface{}) {
 					for i := 1; i < 5; i++ {
 						source <- i
 					}
@@ -252,21 +256,22 @@ func TestMapReduce(t *testing.T) {
 		for _, test := range tests {
 			t.Run(test.name, func(t *testing.T) {
 				if test.mapper == nil {
-					test.mapper = func(v int, writer Writer[int], cancel func(error)) {
+					test.mapper = func(item interface{}, writer Writer, cancel func(error)) {
+						v := item.(int)
 						writer.Write(v * v)
 					}
 				}
 				if test.reducer == nil {
-					test.reducer = func(pipe <-chan int, writer Writer[int], cancel func(error)) {
+					test.reducer = func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
 						var result int
 						for item := range pipe {
-							result += item
+							result += item.(int)
 						}
 						writer.Write(result)
 					}
 				}
 
-				source := make(chan int)
+				source := make(chan interface{})
 				go func() {
 					for i := 1; i < 5; i++ {
 						source <- i
@@ -286,13 +291,13 @@ func TestMapReduceWithReduerWriteMoreThanOnce(t *testing.T) {
 	defer goleak.VerifyNone(t)
 
 	assert.Panics(t, func() {
-		MapReduce(func(source chan<- int) {
+		MapReduce(func(source chan<- interface{}) {
 			for i := 0; i < 10; i++ {
 				source <- i
 			}
-		}, func(item int, writer Writer[int], cancel func(error)) {
+		}, func(item interface{}, writer Writer, cancel func(error)) {
 			writer.Write(item)
-		}, func(pipe <-chan int, writer Writer[string], cancel func(error)) {
+		}, func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
 			drain(pipe)
 			writer.Write("one")
 			writer.Write("two")
@@ -306,8 +311,8 @@ func TestMapReduceVoid(t *testing.T) {
 	var value uint32
 	tests := []struct {
 		name        string
-		mapper      MapperFunc[int, int]
-		reducer     VoidReducerFunc[int]
+		mapper      MapperFunc
+		reducer     VoidReducerFunc
 		expectValue uint32
 		expectErr   error
 	}{
@@ -318,7 +323,8 @@ func TestMapReduceVoid(t *testing.T) {
 		},
 		{
 			name: "cancel with error",
-			mapper: func(v int, writer Writer[int], cancel func(error)) {
+			mapper: func(item interface{}, writer Writer, cancel func(error)) {
+				v := item.(int)
 				if v%3 == 0 {
 					cancel(errDummy)
 				}
@@ -328,7 +334,8 @@ func TestMapReduceVoid(t *testing.T) {
 		},
 		{
 			name: "cancel with nil",
-			mapper: func(v int, writer Writer[int], cancel func(error)) {
+			mapper: func(item interface{}, writer Writer, cancel func(error)) {
+				v := item.(int)
 				if v%3 == 0 {
 					cancel(nil)
 				}
@@ -338,9 +345,9 @@ func TestMapReduceVoid(t *testing.T) {
 		},
 		{
 			name: "cancel with more",
-			reducer: func(pipe <-chan int, cancel func(error)) {
+			reducer: func(pipe <-chan interface{}, cancel func(error)) {
 				for item := range pipe {
-					result := atomic.AddUint32(&value, uint32(item))
+					result := atomic.AddUint32(&value, uint32(item.(int)))
 					if result > 10 {
 						cancel(errDummy)
 					}
@@ -355,18 +362,19 @@ func TestMapReduceVoid(t *testing.T) {
 			atomic.StoreUint32(&value, 0)
 
 			if test.mapper == nil {
-				test.mapper = func(v int, writer Writer[int], cancel func(error)) {
+				test.mapper = func(item interface{}, writer Writer, cancel func(error)) {
+					v := item.(int)
 					writer.Write(v * v)
 				}
 			}
 			if test.reducer == nil {
-				test.reducer = func(pipe <-chan int, cancel func(error)) {
+				test.reducer = func(pipe <-chan interface{}, cancel func(error)) {
 					for item := range pipe {
-						atomic.AddUint32(&value, uint32(item))
+						atomic.AddUint32(&value, uint32(item.(int)))
 					}
 				}
 			}
-			err := MapReduceVoid(func(source chan<- int) {
+			err := MapReduceVoid(func(source chan<- interface{}) {
 				for i := 1; i < 5; i++ {
 					source <- i
 				}
@@ -384,17 +392,18 @@ func TestMapReduceVoidWithDelay(t *testing.T) {
 	defer goleak.VerifyNone(t)
 
 	var result []int
-	err := MapReduceVoid(func(source chan<- int) {
+	err := MapReduceVoid(func(source chan<- interface{}) {
 		source <- 0
 		source <- 1
-	}, func(i int, writer Writer[int], cancel func(error)) {
+	}, func(item interface{}, writer Writer, cancel func(error)) {
+		i := item.(int)
 		if i == 0 {
 			time.Sleep(time.Millisecond * 50)
 		}
 		writer.Write(i)
-	}, func(pipe <-chan int, cancel func(error)) {
+	}, func(pipe <-chan interface{}, cancel func(error)) {
 		for item := range pipe {
-			i := item
+			i := item.(int)
 			result = append(result, i)
 		}
 	})
@@ -408,12 +417,13 @@ func TestMapReducePanic(t *testing.T) {
 	defer goleak.VerifyNone(t)
 
 	assert.Panics(t, func() {
-		_, _ = MapReduce(func(source chan<- int) {
+		_, _ = MapReduce(func(source chan<- interface{}) {
 			source <- 0
 			source <- 1
-		}, func(i int, writer Writer[int], cancel func(error)) {
+		}, func(item interface{}, writer Writer, cancel func(error)) {
+			i := item.(int)
 			writer.Write(i)
-		}, func(pipe <-chan int, writer Writer[int], cancel func(error)) {
+		}, func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
 			for range pipe {
 				panic("panic")
 			}
@@ -425,16 +435,17 @@ func TestMapReducePanicOnce(t *testing.T) {
 	defer goleak.VerifyNone(t)
 
 	assert.Panics(t, func() {
-		_, _ = MapReduce(func(source chan<- int) {
+		_, _ = MapReduce(func(source chan<- interface{}) {
 			for i := 0; i < 100; i++ {
 				source <- i
 			}
-		}, func(i int, writer Writer[int], cancel func(error)) {
+		}, func(item interface{}, writer Writer, cancel func(error)) {
+			i := item.(int)
 			if i == 0 {
 				panic("foo")
 			}
 			writer.Write(i)
-		}, func(pipe <-chan int, writer Writer[int], cancel func(error)) {
+		}, func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
 			for range pipe {
 				panic("bar")
 			}
@@ -446,12 +457,12 @@ func TestMapReducePanicBothMapperAndReducer(t *testing.T) {
 	defer goleak.VerifyNone(t)
 
 	assert.Panics(t, func() {
-		_, _ = MapReduce(func(source chan<- int) {
+		_, _ = MapReduce(func(source chan<- interface{}) {
 			source <- 0
 			source <- 1
-		}, func(item int, writer Writer[int], cancel func(error)) {
+		}, func(item interface{}, writer Writer, cancel func(error)) {
 			panic("foo")
-		}, func(pipe <-chan int, writer Writer[int], cancel func(error)) {
+		}, func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
 			panic("bar")
 		})
 	})
@@ -461,17 +472,18 @@ func TestMapReduceVoidCancel(t *testing.T) {
 	defer goleak.VerifyNone(t)
 
 	var result []int
-	err := MapReduceVoid(func(source chan<- int) {
+	err := MapReduceVoid(func(source chan<- interface{}) {
 		source <- 0
 		source <- 1
-	}, func(i int, writer Writer[int], cancel func(error)) {
+	}, func(item interface{}, writer Writer, cancel func(error)) {
+		i := item.(int)
 		if i == 1 {
 			cancel(errors.New("anything"))
 		}
 		writer.Write(i)
-	}, func(pipe <-chan int, cancel func(error)) {
+	}, func(pipe <-chan interface{}, cancel func(error)) {
 		for item := range pipe {
-			i := item
+			i := item.(int)
 			result = append(result, i)
 		}
 	})
@@ -484,19 +496,21 @@ func TestMapReduceVoidCancelWithRemains(t *testing.T) {
 
 	var done int32
 	var result []int
-	err := MapReduceVoid(func(source chan<- int) {
+	err := MapReduceVoid(func(source chan<- interface{}) {
 		for i := 0; i < defaultWorkers*2; i++ {
 			source <- i
 		}
 		atomic.AddInt32(&done, 1)
-	}, func(i int, writer Writer[int], cancel func(error)) {
+	}, func(item interface{}, writer Writer, cancel func(error)) {
+		i := item.(int)
 		if i == defaultWorkers/2 {
 			cancel(errors.New("anything"))
 		}
 		writer.Write(i)
-	}, func(pipe <-chan int, cancel func(error)) {
+	}, func(pipe <-chan interface{}, cancel func(error)) {
 		for item := range pipe {
-			result = append(result, item)
+			i := item.(int)
+			result = append(result, i)
 		}
 	})
 	assert.NotNil(t, err)
@@ -508,18 +522,18 @@ func TestMapReduceWithoutReducerWrite(t *testing.T) {
 	defer goleak.VerifyNone(t)
 
 	uids := []int{1, 2, 3}
-	res, err := MapReduce(func(source chan<- int) {
+	res, err := MapReduce(func(source chan<- interface{}) {
 		for _, uid := range uids {
 			source <- uid
 		}
-	}, func(item int, writer Writer[int], cancel func(error)) {
+	}, func(item interface{}, writer Writer, cancel func(error)) {
 		writer.Write(item)
-	}, func(pipe <-chan int, writer Writer[int], cancel func(error)) {
+	}, func(pipe <-chan interface{}, writer Writer, cancel func(error)) {
 		drain(pipe)
 		// not calling writer.Write(...), should not panic
 	})
 	assert.Equal(t, ErrReduceNoOutput, err)
-	assert.Equal(t, 0, res)
+	assert.Nil(t, res)
 }
 
 func TestMapReduceVoidPanicInReducer(t *testing.T) {
@@ -528,14 +542,15 @@ func TestMapReduceVoidPanicInReducer(t *testing.T) {
 	const message = "foo"
 	assert.Panics(t, func() {
 		var done int32
-		_ = MapReduceVoid(func(source chan<- int) {
+		_ = MapReduceVoid(func(source chan<- interface{}) {
 			for i := 0; i < defaultWorkers*2; i++ {
 				source <- i
 			}
 			atomic.AddInt32(&done, 1)
-		}, func(i int, writer Writer[int], cancel func(error)) {
+		}, func(item interface{}, writer Writer, cancel func(error)) {
+			i := item.(int)
 			writer.Write(i)
-		}, func(pipe <-chan int, cancel func(error)) {
+		}, func(pipe <-chan interface{}, cancel func(error)) {
 			panic(message)
 		}, WithWorkers(1))
 	})
@@ -546,12 +561,13 @@ func TestForEachWithContext(t *testing.T) {
 
 	var done int32
 	ctx, cancel := context.WithCancel(context.Background())
-	ForEach(func(source chan<- int) {
+	ForEach(func(source chan<- interface{}) {
 		for i := 0; i < defaultWorkers*2; i++ {
 			source <- i
 		}
 		atomic.AddInt32(&done, 1)
-	}, func(i int) {
+	}, func(item interface{}) {
+		i := item.(int)
 		if i == defaultWorkers/2 {
 			cancel()
 		}
@@ -564,19 +580,20 @@ func TestMapReduceWithContext(t *testing.T) {
 	var done int32
 	var result []int
 	ctx, cancel := context.WithCancel(context.Background())
-	err := MapReduceVoid(func(source chan<- int) {
+	err := MapReduceVoid(func(source chan<- interface{}) {
 		for i := 0; i < defaultWorkers*2; i++ {
 			source <- i
 		}
 		atomic.AddInt32(&done, 1)
-	}, func(i int, writer Writer[int], c func(error)) {
+	}, func(item interface{}, writer Writer, c func(error)) {
+		i := item.(int)
 		if i == defaultWorkers/2 {
 			cancel()
 		}
 		writer.Write(i)
-	}, func(pipe <-chan int, cancel func(error)) {
+	}, func(pipe <-chan interface{}, cancel func(error)) {
 		for item := range pipe {
-			i := item
+			i := item.(int)
 			result = append(result, i)
 		}
 	}, WithContext(ctx))
@@ -587,19 +604,19 @@ func TestMapReduceWithContext(t *testing.T) {
 func BenchmarkMapReduce(b *testing.B) {
 	b.ReportAllocs()
 
-	mapper := func(v int64, writer Writer[int64], cancel func(error)) {
-		writer.Write(v * v)
+	mapper := func(v interface{}, writer Writer, cancel func(error)) {
+		writer.Write(v.(int64) * v.(int64))
 	}
-	reducer := func(input <-chan int64, writer Writer[int64], cancel func(error)) {
+	reducer := func(input <-chan interface{}, writer Writer, cancel func(error)) {
 		var result int64
 		for v := range input {
-			result += v
+			result += v.(int64)
 		}
 		writer.Write(result)
 	}
 
 	for i := 0; i < b.N; i++ {
-		MapReduce(func(input chan<- int64) {
+		MapReduce(func(input chan<- interface{}) {
 			for j := 0; j < 2; j++ {
 				input <- int64(j)
 			}

core/mr/readme-cn.md

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

core/mr/readme.md

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

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 any)
+		OnEvent(event interface{})
 	}
 
 	// 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 any
+		eventChannels        []chan interface{}
 	}
 
 	// 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 any) {
+func (q *Queue) Broadcast(message interface{}) {
 	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 any) {
+func (q *Queue) consume(eventChan chan interface{}) {
 	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 any)
+		eventChan := make(chan interface{})
 		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(any) {
+func (c *mockedConsumer) OnEvent(interface{}) {
 	if atomic.AddInt32(&c.events, 1) <= consumers {
 		c.wait.Done()
 	}

core/search/tree.go

@@ -35,7 +35,7 @@ type (
 	}
 
 	node struct {
-		item     any
+		item     interface{}
 		children [2]map[string]*node
 	}
 
@@ -46,7 +46,7 @@ type (
 
 	// A Result is a search result from tree.
 	Result struct {
-		Item   any
+		Item   interface{}
 		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 any) error {
+func (t *Tree) Add(route string, item interface{}) 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 any) error {
+func add(nd *node, route string, item interface{}) error {
 	if len(route) == 0 {
 		if nd.item != nil {
 			return errDupItem
@@ -228,7 +228,7 @@ func match(pat, token string) innerResult {
 	}
 }
 
-func newNode(item any) *node {
+func newNode(item interface{}) *node {
 	return &node{
 		item: item,
 		children: [2]map[string]*node{

core/stat/metrics.go

@@ -104,7 +104,7 @@ type (
 	}
 )
 
-func (c *metricsContainer) AddTask(v any) bool {
+func (c *metricsContainer) AddTask(v interface{}) bool {
 	if task, ok := v.(Task); ok {
 		if task.Drop {
 			c.drops++
@@ -117,7 +117,7 @@ func (c *metricsContainer) AddTask(v any) bool {
 	return false
 }
 
-func (c *metricsContainer) Execute(v any) {
+func (c *metricsContainer) Execute(v interface{}) {
 	pair := v.(tasksDurationPair)
 	tasks := pair.tasks
 	duration := pair.duration
@@ -180,7 +180,7 @@ func (c *metricsContainer) Execute(v any) {
 	log(report)
 }
 
-func (c *metricsContainer) RemoveAll() any {
+func (c *metricsContainer) RemoveAll() interface{} {
 	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 any) {
+func (h *taskHeap) Push(x interface{}) {
 	*h = append(*h, x.(Task))
 }
 
-func (h *taskHeap) Pop() any {
+func (h *taskHeap) Pop() interface{} {
 	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 any, postgresSql ...bool) []string {
+func RawFieldNames(in interface{}, postgresSql ...bool) []string {
 	out := make([]string, 0)
 	v := reflect.ValueOf(in)
 	if v.Kind() == reflect.Ptr {

core/stores/cache/cache.go

@@ -21,32 +21,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 any) error
+		Get(key string, val interface{}) error
 		// GetCtx gets the cache with key and fills into v.
-		GetCtx(ctx context.Context, key string, val any) error
+		GetCtx(ctx context.Context, key string, val interface{}) 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 any) error
+		Set(key string, val interface{}) error
 		// SetCtx sets the cache with key and v, using c.expiry.
-		SetCtx(ctx context.Context, key string, val any) error
+		SetCtx(ctx context.Context, key string, val interface{}) error
 		// SetWithExpire sets the cache with key and v, using given expire.
-		SetWithExpire(key string, val any, expire time.Duration) error
+		SetWithExpire(key string, val interface{}, expire time.Duration) error
 		// SetWithExpireCtx sets the cache with key and v, using given expire.
-		SetWithExpireCtx(ctx context.Context, key string, val any, expire time.Duration) error
+		SetWithExpireCtx(ctx context.Context, key string, val interface{}, 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 any, key string, query func(val any) error) error
+		Take(val interface{}, key string, query func(val interface{}) 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 any, key string, query func(val any) error) error
+		TakeCtx(ctx context.Context, val interface{}, key string, query func(val interface{}) 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 any, key string, query func(val any, expire time.Duration) error) error
+		TakeWithExpire(val interface{}, key string, query func(val interface{}, 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 any, key string,
-			query func(val any, expire time.Duration) error) error
+		TakeWithExpireCtx(ctx context.Context, val interface{}, key string,
+			query func(val interface{}, expire time.Duration) error) error
 	}
 
 	cacheCluster struct {
@@ -98,7 +98,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[any][]string)
+		nodes := make(map[interface{}][]string)
 		for _, key := range keys {
 			c, ok := cc.dispatcher.Get(key)
 			if !ok {
@@ -119,12 +119,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 any) error {
+func (cc cacheCluster) Get(key string, val interface{}) 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 any) error {
+func (cc cacheCluster) GetCtx(ctx context.Context, key string, val interface{}) error {
 	c, ok := cc.dispatcher.Get(key)
 	if !ok {
 		return cc.errNotFound
@@ -139,12 +139,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 any) error {
+func (cc cacheCluster) Set(key string, val interface{}) 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 any) error {
+func (cc cacheCluster) SetCtx(ctx context.Context, key string, val interface{}) error {
 	c, ok := cc.dispatcher.Get(key)
 	if !ok {
 		return cc.errNotFound
@@ -154,12 +154,12 @@ func (cc cacheCluster) SetCtx(ctx context.Context, key string, val any) error {
 }
 
 // SetWithExpire sets the cache with key and v, using given expire.
-func (cc cacheCluster) SetWithExpire(key string, val any, expire time.Duration) error {
+func (cc cacheCluster) SetWithExpire(key string, val interface{}, 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 any, expire time.Duration) error {
+func (cc cacheCluster) SetWithExpireCtx(ctx context.Context, key string, val interface{}, expire time.Duration) error {
 	c, ok := cc.dispatcher.Get(key)
 	if !ok {
 		return cc.errNotFound
@@ -170,13 +170,13 @@ func (cc cacheCluster) SetWithExpireCtx(ctx context.Context, key string, val any
 
 // 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 any, key string, query func(val any) error) error {
+func (cc cacheCluster) Take(val interface{}, key string, query func(val interface{}) 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 any, key string, query func(val any) error) error {
+func (cc cacheCluster) TakeCtx(ctx context.Context, val interface{}, key string, query func(val interface{}) error) error {
 	c, ok := cc.dispatcher.Get(key)
 	if !ok {
 		return cc.errNotFound
@@ -187,13 +187,13 @@ func (cc cacheCluster) TakeCtx(ctx context.Context, val any, key string, query f
 
 // 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 any, key string, query func(val any, expire time.Duration) error) error {
+func (cc cacheCluster) TakeWithExpire(val interface{}, key string, query func(val interface{}, 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 any, key string, query func(val any, expire time.Duration) error) error {
+func (cc cacheCluster) TakeWithExpireCtx(ctx context.Context, val interface{}, key string, query func(val interface{}, 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 any) error {
+func (mc *mockedNode) Get(key string, val interface{}) error {
 	return mc.GetCtx(context.Background(), key, val)
 }
 
-func (mc *mockedNode) GetCtx(ctx context.Context, key string, val any) error {
+func (mc *mockedNode) GetCtx(ctx context.Context, key string, val interface{}) 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 any) error {
+func (mc *mockedNode) Set(key string, val interface{}) error {
 	return mc.SetCtx(context.Background(), key, val)
 }
 
-func (mc *mockedNode) SetCtx(ctx context.Context, key string, val any) error {
+func (mc *mockedNode) SetCtx(ctx context.Context, key string, val interface{}) 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 any) error {
 	return nil
 }
 
-func (mc *mockedNode) SetWithExpire(key string, val any, expire time.Duration) error {
+func (mc *mockedNode) SetWithExpire(key string, val interface{}, expire time.Duration) error {
 	return mc.SetWithExpireCtx(context.Background(), key, val, expire)
 }
 
-func (mc *mockedNode) SetWithExpireCtx(ctx context.Context, key string, val any, expire time.Duration) error {
+func (mc *mockedNode) SetWithExpireCtx(ctx context.Context, key string, val interface{}, expire time.Duration) error {
 	return mc.Set(key, val)
 }
 
-func (mc *mockedNode) Take(val any, key string, query func(val any) error) error {
+func (mc *mockedNode) Take(val interface{}, key string, query func(val interface{}) error) error {
 	return mc.TakeCtx(context.Background(), val, key, query)
 }
 
-func (mc *mockedNode) TakeCtx(ctx context.Context, val any, key string, query func(val any) error) error {
+func (mc *mockedNode) TakeCtx(ctx context.Context, val interface{}, key string, query func(val interface{}) 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 any, key string, query fu
 	return mc.SetCtx(ctx, key, val)
 }
 
-func (mc *mockedNode) TakeWithExpire(val any, key string, query func(val any, expire time.Duration) error) error {
+func (mc *mockedNode) TakeWithExpire(val interface{}, key string, query func(val interface{}, expire time.Duration) error) error {
 	return mc.TakeWithExpireCtx(context.Background(), val, key, query)
 }
 
-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 {
+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 {
 		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 any) error {
+			assert.Nil(t, c.Take(&val, strconv.Itoa(i*10), func(val interface{}) error {
 				*val.(*int) = i
 				count++
 				return nil
 			}))
 		} else {
-			assert.Nil(t, c.TakeWithExpire(&val, strconv.Itoa(i*10), func(val any, expire time.Duration) error {
+			assert.Nil(t, c.TakeWithExpire(&val, strconv.Itoa(i*10), func(val interface{}, 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 any) error {
+	assert.NotNil(t, c.Take(nil, "foo", func(val interface{}) error {
 		return nil
 	}))
-	assert.NotNil(t, c.TakeWithExpire(nil, "foo", func(val any, duration time.Duration) error {
+	assert.NotNil(t, c.TakeWithExpire(nil, "foo", func(val interface{}, 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 any) error {
+func (c cacheNode) Get(key string, val interface{}) 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 any) error {
+func (c cacheNode) GetCtx(ctx context.Context, key string, val interface{}) 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 any) error {
+func (c cacheNode) Set(key string, val interface{}) 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 any) error {
+func (c cacheNode) SetCtx(ctx context.Context, key string, val interface{}) 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 any, expire time.Duration) error {
+func (c cacheNode) SetWithExpire(key string, val interface{}, 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 any,
+func (c cacheNode) SetWithExpireCtx(ctx context.Context, key string, val interface{},
 	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 any, key string, query func(val any) error) error {
+func (c cacheNode) Take(val interface{}, key string, query func(val interface{}) 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 any, key string,
-	query func(val any) error) error {
-	return c.doTake(ctx, val, key, query, func(v any) error {
+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 {
 		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 any, key string, query func(val any,
+func (c cacheNode) TakeWithExpire(val interface{}, key string, query func(val interface{},
 	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 any, key string,
-	query func(val any, expire time.Duration) error) error {
+func (c cacheNode) TakeWithExpireCtx(ctx context.Context, val interface{}, key string,
+	query func(val interface{}, expire time.Duration) error) error {
 	expire := c.aroundDuration(c.expiry)
-	return c.doTake(ctx, val, key, func(v any) error {
+	return c.doTake(ctx, val, key, func(v interface{}) error {
 		return query(v, expire)
-	}, func(v any) error {
+	}, func(v interface{}) 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 any) error {
+func (c cacheNode) doGetCache(ctx context.Context, key string, v interface{}) 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 any) error {
 	return c.processCache(ctx, key, data, v)
 }
 
-func (c cacheNode) doTake(ctx context.Context, v any, key string,
-	query func(v any) error, cacheVal func(v any) error) error {
+func (c cacheNode) doTake(ctx context.Context, v interface{}, key string,
+	query func(v interface{}) error, cacheVal func(v interface{}) error) error {
 	logger := logx.WithContext(ctx)
-	val, fresh, err := c.barrier.DoEx(key, func() (any, error) {
+	val, fresh, err := c.barrier.DoEx(key, func() (interface{}, 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 any, key string,
 	return jsonx.Unmarshal(val.([]byte), v)
 }
 
-func (c cacheNode) processCache(ctx context.Context, key, data string, v any) error {
+func (c cacheNode) processCache(ctx context.Context, key, data string, v interface{}) error {
 	err := jsonx.Unmarshal([]byte(data), v)
 	if err == nil {
 		return nil

core/stores/cache/cachenode_test.go

@@ -1,6 +1,3 @@
-//go:build !race
-
-// Disable data race detection is because of the timingWheel in cacheNode.
 package cache
 
 import (
@@ -62,7 +59,7 @@ func TestCacheNode_DelCache(t *testing.T) {
 		ticker := timex.NewFakeTicker()
 		var err error
 		timingWheel, err = collection.NewTimingWheelWithTicker(
-			time.Millisecond, timingWheelSlots, func(key, value any) {
+			time.Millisecond, timingWheelSlots, func(key, value interface{}) {
 				clean(key, value)
 			}, ticker)
 		assert.NoError(t, err)
@@ -146,7 +143,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 any) error {
+	err = cn.Take(&str, "any", func(v interface{}) error {
 		*v.(*string) = "value"
 		return nil
 	})
@@ -167,7 +164,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 any) error {
+	assert.Error(t, cn.Take(&str, "any", func(v interface{}) error {
 		*v.(*string) = "value"
 		return nil
 	}))
@@ -188,7 +185,7 @@ func TestCacheNode_TakeNotFound(t *testing.T) {
 		errNotFound:    errTestNotFound,
 	}
 	var str string
-	err = cn.Take(&str, "any", func(v any) error {
+	err = cn.Take(&str, "any", func(v interface{}) error {
 		return errTestNotFound
 	})
 	assert.True(t, cn.IsNotFound(err))
@@ -198,7 +195,7 @@ func TestCacheNode_TakeNotFound(t *testing.T) {
 	assert.Equal(t, `*`, val)
 
 	store.Set("any", "*")
-	err = cn.Take(&str, "any", func(v any) error {
+	err = cn.Take(&str, "any", func(v interface{}) error {
 		return nil
 	})
 	assert.True(t, cn.IsNotFound(err))
@@ -206,7 +203,7 @@ func TestCacheNode_TakeNotFound(t *testing.T) {
 
 	store.Del("any")
 	errDummy := errors.New("dummy")
-	err = cn.Take(&str, "any", func(v any) error {
+	err = cn.Take(&str, "any", func(v interface{}) error {
 		return errDummy
 	})
 	assert.Equal(t, errDummy, err)
@@ -228,7 +225,7 @@ func TestCacheNode_TakeNotFoundButChangedByOthers(t *testing.T) {
 	}
 
 	var str string
-	err = cn.Take(&str, "any", func(v any) error {
+	err = cn.Take(&str, "any", func(v interface{}) error {
 		store.Set("any", "foo")
 		return errTestNotFound
 	})
@@ -256,7 +253,7 @@ func TestCacheNode_TakeWithExpire(t *testing.T) {
 		errNotFound:    errors.New("any"),
 	}
 	var str string
-	err = cn.TakeWithExpire(&str, "any", func(v any, expire time.Duration) error {
+	err = cn.TakeWithExpire(&str, "any", func(v interface{}, expire time.Duration) error {
 		*v.(*string) = "value"
 		return nil
 	})
@@ -306,7 +303,7 @@ func TestCacheValueWithBigInt(t *testing.T) {
 	)
 
 	assert.Nil(t, cn.Set(key, value))
-	var val any
+	var val interface{}
 	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 any) {
+func clean(key, value interface{}) {
 	taskRunner.Schedule(func() {
 		dt := value.(delayTask)
 		err := dt.task()

core/stores/clickhouse/clickhouse.go

@@ -0,0 +1,14 @@
+package clickhouse
+
+import (
+	// imports the driver, don't remove this comment, golint requires.
+	_ "github.com/ClickHouse/clickhouse-go/v2"
+	"github.com/zeromicro/go-zero/core/stores/sqlx"
+)
+
+const clickHouseDriverName = "clickhouse"
+
+// New returns a clickhouse connection.
+func New(datasource string, opts ...sqlx.SqlOption) sqlx.SqlConn {
+	return sqlx.NewSqlConn(clickHouseDriverName, datasource, opts...)
+}

core/stores/clickhouse/clickhouse_test.go

@@ -0,0 +1,11 @@
+package clickhouse
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestClickHouse(t *testing.T) {
+	assert.NotNil(t, New("clickhouse"))
+}

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 ...any) (any, error)
-		EvalCtx(ctx context.Context, script, key string, args ...any) (any, error)
+		Eval(script, key string, args ...interface{}) (interface{}, error)
+		EvalCtx(ctx context.Context, script, key string, args ...interface{}) (interface{}, 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 ...any) (int, error)
-		LpushCtx(ctx context.Context, key string, values ...any) (int, error)
+		Lpush(key string, values ...interface{}) (int, error)
+		LpushCtx(ctx context.Context, key string, values ...interface{}) (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 ...any) (bool, error)
-		PfaddCtx(ctx context.Context, key string, values ...any) (bool, error)
+		Pfadd(key string, values ...interface{}) (bool, error)
+		PfaddCtx(ctx context.Context, key string, values ...interface{}) (bool, error)
 		Pfcount(key string) (int64, error)
 		PfcountCtx(ctx context.Context, key string) (int64, 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)
+		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)
 		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 any) (bool, error)
-		SismemberCtx(ctx context.Context, key string, value any) (bool, error)
+		Sismember(key string, value interface{}) (bool, error)
+		SismemberCtx(ctx context.Context, key string, value interface{}) (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 ...any) (int, error)
-		SremCtx(ctx context.Context, key string, values ...any) (int, error)
+		Srem(key string, values ...interface{}) (int, error)
+		SremCtx(ctx context.Context, key string, values ...interface{}) (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 ...any) (int, error)
-		ZremCtx(ctx context.Context, key string, values ...any) (int, error)
+		Zrem(key string, values ...interface{}) (int, error)
+		ZremCtx(ctx context.Context, key string, values ...interface{}) (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 ...any) (any, error) {
+func (cs clusterStore) Eval(script, key string, args ...interface{}) (interface{}, error) {
 	return cs.EvalCtx(context.Background(), script, key, args...)
 }
 
-func (cs clusterStore) EvalCtx(ctx context.Context, script, key string, args ...any) (any, error) {
+func (cs clusterStore) EvalCtx(ctx context.Context, script, key string, args ...interface{}) (interface{}, 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 ...any) (int, error) {
+func (cs clusterStore) Lpush(key string, values ...interface{}) (int, error) {
 	return cs.LpushCtx(context.Background(), key, values...)
 }
 
-func (cs clusterStore) LpushCtx(ctx context.Context, key string, values ...any) (int, error) {
+func (cs clusterStore) LpushCtx(ctx context.Context, key string, values ...interface{}) (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 ...any) (bool, error) {
+func (cs clusterStore) Pfadd(key string, values ...interface{}) (bool, error) {
 	return cs.PfaddCtx(context.Background(), key, values...)
 }
 
-func (cs clusterStore) PfaddCtx(ctx context.Context, key string, values ...any) (bool, error) {
+func (cs clusterStore) PfaddCtx(ctx context.Context, key string, values ...interface{}) (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 ...any) (int, error) {
+func (cs clusterStore) Rpush(key string, values ...interface{}) (int, error) {
 	return cs.RpushCtx(context.Background(), key, values...)
 }
 
-func (cs clusterStore) RpushCtx(ctx context.Context, key string, values ...any) (int, error) {
+func (cs clusterStore) RpushCtx(ctx context.Context, key string, values ...interface{}) (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 ...any)
 	return node.RpushCtx(ctx, key, values...)
 }
 
-func (cs clusterStore) Sadd(key string, values ...any) (int, error) {
+func (cs clusterStore) Sadd(key string, values ...interface{}) (int, error) {
 	return cs.SaddCtx(context.Background(), key, values...)
 }
 
-func (cs clusterStore) SaddCtx(ctx context.Context, key string, values ...any) (int, error) {
+func (cs clusterStore) SaddCtx(ctx context.Context, key string, values ...interface{}) (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 any) (bool, error) {
+func (cs clusterStore) Sismember(key string, value interface{}) (bool, error) {
 	return cs.SismemberCtx(context.Background(), key, value)
 }
 
-func (cs clusterStore) SismemberCtx(ctx context.Context, key string, value any) (bool, error) {
+func (cs clusterStore) SismemberCtx(ctx context.Context, key string, value interface{}) (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 ...any) (int, error) {
+func (cs clusterStore) Srem(key string, values ...interface{}) (int, error) {
 	return cs.SremCtx(context.Background(), key, values...)
 }
 
-func (cs clusterStore) SremCtx(ctx context.Context, key string, values ...any) (int, error) {
+func (cs clusterStore) SremCtx(ctx context.Context, key string, values ...interface{}) (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 ...any) (int, error) {
+func (cs clusterStore) Zrem(key string, values ...interface{}) (int, error) {
 	return cs.ZremCtx(context.Background(), key, values...)
 }
 
-func (cs clusterStore) ZremCtx(ctx context.Context, key string, values ...any) (int, error) {
+func (cs clusterStore) ZremCtx(ctx context.Context, key string, values ...interface{}) (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 any) {
+func (bi *BulkInserter) Insert(doc interface{}) {
 	bi.executor.Add(doc)
 }
 
@@ -66,17 +66,17 @@ func (bi *BulkInserter) SetResultHandler(handler ResultHandler) {
 
 type dbInserter struct {
 	collection    *mongo.Collection
-	documents     []any
+	documents     []interface{}
 	resultHandler ResultHandler
 }
 
-func (in *dbInserter) AddTask(doc any) bool {
+func (in *dbInserter) AddTask(doc interface{}) bool {
 	in.documents = append(in.documents, doc)
 	return len(in.documents) >= maxBulkRows
 }
 
-func (in *dbInserter) Execute(objs any) {
-	docs := objs.([]any)
+func (in *dbInserter) Execute(objs interface{}) {
+	docs := objs.([]interface{})
 	if len(docs) == 0 {
 		return
 	}
@@ -89,7 +89,7 @@ func (in *dbInserter) Execute(objs any) {
 	}
 }
 
-func (in *dbInserter) RemoveAll() any {
+func (in *dbInserter) RemoveAll() interface{} {
 	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 any, opts ...*mopt.AggregateOptions) (
+		Aggregate(ctx context.Context, pipeline interface{}, 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 any, opts ...*mopt.CountOptions) (int64, error)
+		CountDocuments(ctx context.Context, filter interface{}, 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 any, opts ...*mopt.DeleteOptions) (
+		DeleteMany(ctx context.Context, filter interface{}, opts ...*mopt.DeleteOptions) (
 			*mongo.DeleteResult, error)
 		// DeleteOne deletes at most one document from the collection that matches the filter.
-		DeleteOne(ctx context.Context, filter any, opts ...*mopt.DeleteOptions) (
+		DeleteOne(ctx context.Context, filter interface{}, 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 any,
-			opts ...*mopt.DistinctOptions) ([]any, error)
+		Distinct(ctx context.Context, fieldName string, filter interface{},
+			opts ...*mopt.DistinctOptions) ([]interface{}, 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 any, opts ...*mopt.FindOptions) (*mongo.Cursor, error)
+		Find(ctx context.Context, filter interface{}, opts ...*mopt.FindOptions) (*mongo.Cursor, error)
 		// FindOne returns up to one document that matches the provided filter.
-		FindOne(ctx context.Context, filter any, opts ...*mopt.FindOneOptions) (
+		FindOne(ctx context.Context, filter interface{}, 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 any, opts ...*mopt.FindOneAndDeleteOptions) (
+		FindOneAndDelete(ctx context.Context, filter interface{}, 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 any,
+		FindOneAndReplace(ctx context.Context, filter, replacement interface{},
 			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 any,
+		FindOneAndUpdate(ctx context.Context, filter, update interface{},
 			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 []any, opts ...*mopt.InsertManyOptions) (
+		InsertMany(ctx context.Context, documents []interface{}, opts ...*mopt.InsertManyOptions) (
 			*mongo.InsertManyResult, error)
 		// InsertOne inserts the provided document.
-		InsertOne(ctx context.Context, document any, opts ...*mopt.InsertOneOptions) (
+		InsertOne(ctx context.Context, document interface{}, opts ...*mopt.InsertOneOptions) (
 			*mongo.InsertOneResult, error)
 		// ReplaceOne replaces at most one document that matches the filter.
-		ReplaceOne(ctx context.Context, filter, replacement any,
+		ReplaceOne(ctx context.Context, filter, replacement interface{},
 			opts ...*mopt.ReplaceOptions) (*mongo.UpdateResult, error)
 		// UpdateByID updates a single document matching the provided filter.
-		UpdateByID(ctx context.Context, id, update any,
+		UpdateByID(ctx context.Context, id, update interface{},
 			opts ...*mopt.UpdateOptions) (*mongo.UpdateResult, error)
 		// UpdateMany updates the provided documents.
-		UpdateMany(ctx context.Context, filter, update any,
+		UpdateMany(ctx context.Context, filter, update interface{},
 			opts ...*mopt.UpdateOptions) (*mongo.UpdateResult, error)
 		// UpdateOne updates a single document matching the provided filter.
-		UpdateOne(ctx context.Context, filter, update any,
+		UpdateOne(ctx context.Context, filter, update interface{},
 			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 any, opts ...*mopt.ChangeStreamOptions) (
+		Watch(ctx context.Context, pipeline interface{}, 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 any,
+func (c *decoratedCollection) Aggregate(ctx context.Context, pipeline interface{},
 	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 any,
+func (c *decoratedCollection) CountDocuments(ctx context.Context, filter interface{},
 	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 any,
 	return
 }
 
-func (c *decoratedCollection) DeleteMany(ctx context.Context, filter any,
+func (c *decoratedCollection) DeleteMany(ctx context.Context, filter interface{},
 	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 any,
 	return
 }
 
-func (c *decoratedCollection) DeleteOne(ctx context.Context, filter any,
+func (c *decoratedCollection) DeleteOne(ctx context.Context, filter interface{},
 	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 any,
 	return
 }
 
-func (c *decoratedCollection) Distinct(ctx context.Context, fieldName string, filter any,
-	opts ...*mopt.DistinctOptions) (val []any, err error) {
+func (c *decoratedCollection) Distinct(ctx context.Context, fieldName string, filter interface{},
+	opts ...*mopt.DistinctOptions) (val []interface{}, 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 any,
+func (c *decoratedCollection) Find(ctx context.Context, filter interface{},
 	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 any,
 	return
 }
 
-func (c *decoratedCollection) FindOne(ctx context.Context, filter any,
+func (c *decoratedCollection) FindOne(ctx context.Context, filter interface{},
 	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 any,
 	return
 }
 
-func (c *decoratedCollection) FindOneAndDelete(ctx context.Context, filter any,
+func (c *decoratedCollection) FindOneAndDelete(ctx context.Context, filter interface{},
 	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 any,
 	return
 }
 
-func (c *decoratedCollection) FindOneAndReplace(ctx context.Context, filter any,
-	replacement any, opts ...*mopt.FindOneAndReplaceOptions) (
+func (c *decoratedCollection) FindOneAndReplace(ctx context.Context, filter interface{},
+	replacement interface{}, 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 any,
 	return
 }
 
-func (c *decoratedCollection) FindOneAndUpdate(ctx context.Context, filter, update any,
+func (c *decoratedCollection) FindOneAndUpdate(ctx context.Context, filter, update interface{},
 	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 []any,
+func (c *decoratedCollection) InsertMany(ctx context.Context, documents []interface{},
 	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 []any,
 	return
 }
 
-func (c *decoratedCollection) InsertOne(ctx context.Context, document any,
+func (c *decoratedCollection) InsertOne(ctx context.Context, document interface{},
 	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 any,
 	return
 }
 
-func (c *decoratedCollection) ReplaceOne(ctx context.Context, filter, replacement any,
+func (c *decoratedCollection) ReplaceOne(ctx context.Context, filter, replacement interface{},
 	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 any,
+func (c *decoratedCollection) UpdateByID(ctx context.Context, id, update interface{},
 	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 any,
 	return
 }
 
-func (c *decoratedCollection) UpdateMany(ctx context.Context, filter, update any,
+func (c *decoratedCollection) UpdateMany(ctx context.Context, filter, update interface{},
 	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 any
 	return
 }
 
-func (c *decoratedCollection) UpdateOne(ctx context.Context, filter, update any,
+func (c *decoratedCollection) UpdateOne(ctx context.Context, filter, update interface{},
 	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 any,
 }
 
 func (c *decoratedCollection) logDuration(ctx context.Context, method string,
-	startTime time.Duration, err error, docs ...any) {
+	startTime time.Duration, err error, docs ...interface{}) {
 	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(), []any{
+		res, err := c.InsertMany(context.Background(), []interface{}{
 			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(), []any{bson.D{{Key: "foo", Value: "bar"}}})
+		_, err = c.InsertMany(context.Background(), []interface{}{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 any, opts ...*mopt.AggregateOptions) error {
+func (m *Model) Aggregate(ctx context.Context, v, pipeline interface{}, 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 any, opts ...*mopt.Ag
 }
 
 // DeleteMany deletes documents that match the filter.
-func (m *Model) DeleteMany(ctx context.Context, filter any, opts ...*mopt.DeleteOptions) (int64, error) {
+func (m *Model) DeleteMany(ctx context.Context, filter interface{}, 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 any, opts ...*mopt.Delete
 }
 
 // DeleteOne deletes the first document that matches the filter.
-func (m *Model) DeleteOne(ctx context.Context, filter any, opts ...*mopt.DeleteOptions) (int64, error) {
+func (m *Model) DeleteOne(ctx context.Context, filter interface{}, 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 any, opts ...*mopt.DeleteO
 }
 
 // Find finds documents that match the filter.
-func (m *Model) Find(ctx context.Context, v, filter any, opts ...*mopt.FindOptions) error {
+func (m *Model) Find(ctx context.Context, v, filter interface{}, 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 any, opts ...*mopt.FindOptio
 }
 
 // FindOne finds the first document that matches the filter.
-func (m *Model) FindOne(ctx context.Context, v, filter any, opts ...*mopt.FindOneOptions) error {
+func (m *Model) FindOne(ctx context.Context, v, filter interface{}, 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 any, opts ...*mopt.FindOn
 }
 
 // FindOneAndDelete finds a single document and deletes it.
-func (m *Model) FindOneAndDelete(ctx context.Context, v, filter any,
+func (m *Model) FindOneAndDelete(ctx context.Context, v, filter interface{},
 	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 any,
 }
 
 // FindOneAndReplace finds a single document and replaces it.
-func (m *Model) FindOneAndReplace(ctx context.Context, v, filter, replacement any,
+func (m *Model) FindOneAndReplace(ctx context.Context, v, filter, replacement interface{},
 	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 an
 }
 
 // FindOneAndUpdate finds a single document and updates it.
-func (m *Model) FindOneAndUpdate(ctx context.Context, v, filter, update any,
+func (m *Model) FindOneAndUpdate(ctx context.Context, v, filter, update interface{},
 	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) (any, error),
+	fn func(sessCtx mongo.SessionContext) (interface{}, error),
 	opts ...*mopt.TransactionOptions,
-) (res any, err error) {
+) (res interface{}, 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) (any, error) {
+		_, err = sess.WithTransaction(context.Background(), func(sessCtx mongo.SessionContext) (interface{}, 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 []any
+		var result []interface{}
 		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 []any
+		var result []interface{}
 		err := m.Find(context.Background(), &result, bson.D{})
 		assert.Nil(t, err)
 		assert.Equal(t, 2, len(result))

core/stores/monc/cachedmodel.go

@@ -83,7 +83,7 @@ func (mm *Model) DelCache(ctx context.Context, keys ...string) error {
 }
 
 // DeleteOne deletes the document with given filter, and remove it from cache.
-func (mm *Model) DeleteOne(ctx context.Context, key string, filter any,
+func (mm *Model) DeleteOne(ctx context.Context, key string, filter interface{},
 	opts ...*mopt.DeleteOptions) (int64, error) {
 	val, err := mm.Model.DeleteOne(ctx, filter, opts...)
 	if err != nil {
@@ -98,27 +98,27 @@ func (mm *Model) DeleteOne(ctx context.Context, key string, filter any,
 }
 
 // DeleteOneNoCache deletes the document with given filter.
-func (mm *Model) DeleteOneNoCache(ctx context.Context, filter any,
+func (mm *Model) DeleteOneNoCache(ctx context.Context, filter interface{},
 	opts ...*mopt.DeleteOptions) (int64, error) {
 	return mm.Model.DeleteOne(ctx, filter, opts...)
 }
 
 // FindOne unmarshals a record into v with given key and query.
-func (mm *Model) FindOne(ctx context.Context, key string, v, filter any,
+func (mm *Model) FindOne(ctx context.Context, key string, v, filter interface{},
 	opts ...*mopt.FindOneOptions) error {
-	return mm.cache.TakeCtx(ctx, v, key, func(v any) error {
+	return mm.cache.TakeCtx(ctx, v, key, func(v interface{}) error {
 		return mm.Model.FindOne(ctx, v, filter, opts...)
 	})
 }
 
 // FindOneNoCache unmarshals a record into v with query, without cache.
-func (mm *Model) FindOneNoCache(ctx context.Context, v, filter any,
+func (mm *Model) FindOneNoCache(ctx context.Context, v, filter interface{},
 	opts ...*mopt.FindOneOptions) error {
 	return mm.Model.FindOne(ctx, v, filter, opts...)
 }
 
 // FindOneAndDelete deletes the document with given filter, and unmarshals it into v.
-func (mm *Model) FindOneAndDelete(ctx context.Context, key string, v, filter any,
+func (mm *Model) FindOneAndDelete(ctx context.Context, key string, v, filter interface{},
 	opts ...*mopt.FindOneAndDeleteOptions) error {
 	if err := mm.Model.FindOneAndDelete(ctx, v, filter, opts...); err != nil {
 		return err
@@ -128,14 +128,14 @@ func (mm *Model) FindOneAndDelete(ctx context.Context, key string, v, filter any
 }
 
 // FindOneAndDeleteNoCache deletes the document with given filter, and unmarshals it into v.
-func (mm *Model) FindOneAndDeleteNoCache(ctx context.Context, v, filter any,
+func (mm *Model) FindOneAndDeleteNoCache(ctx context.Context, v, filter interface{},
 	opts ...*mopt.FindOneAndDeleteOptions) error {
 	return mm.Model.FindOneAndDelete(ctx, v, filter, opts...)
 }
 
 // FindOneAndReplace replaces the document with given filter with replacement, and unmarshals it into v.
-func (mm *Model) FindOneAndReplace(ctx context.Context, key string, v, filter any,
-	replacement any, opts ...*mopt.FindOneAndReplaceOptions) error {
+func (mm *Model) FindOneAndReplace(ctx context.Context, key string, v, filter interface{},
+	replacement interface{}, opts ...*mopt.FindOneAndReplaceOptions) error {
 	if err := mm.Model.FindOneAndReplace(ctx, v, filter, replacement, opts...); err != nil {
 		return err
 	}
@@ -144,14 +144,14 @@ func (mm *Model) FindOneAndReplace(ctx context.Context, key string, v, filter an
 }
 
 // FindOneAndReplaceNoCache replaces the document with given filter with replacement, and unmarshals it into v.
-func (mm *Model) FindOneAndReplaceNoCache(ctx context.Context, v, filter any,
-	replacement any, opts ...*mopt.FindOneAndReplaceOptions) error {
+func (mm *Model) FindOneAndReplaceNoCache(ctx context.Context, v, filter interface{},
+	replacement interface{}, opts ...*mopt.FindOneAndReplaceOptions) error {
 	return mm.Model.FindOneAndReplace(ctx, v, filter, replacement, opts...)
 }
 
 // FindOneAndUpdate updates the document with given filter with update, and unmarshals it into v.
-func (mm *Model) FindOneAndUpdate(ctx context.Context, key string, v, filter any,
-	update any, opts ...*mopt.FindOneAndUpdateOptions) error {
+func (mm *Model) FindOneAndUpdate(ctx context.Context, key string, v, filter interface{},
+	update interface{}, opts ...*mopt.FindOneAndUpdateOptions) error {
 	if err := mm.Model.FindOneAndUpdate(ctx, v, filter, update, opts...); err != nil {
 		return err
 	}
@@ -160,18 +160,18 @@ func (mm *Model) FindOneAndUpdate(ctx context.Context, key string, v, filter any
 }
 
 // FindOneAndUpdateNoCache updates the document with given filter with update, and unmarshals it into v.
-func (mm *Model) FindOneAndUpdateNoCache(ctx context.Context, v, filter any,
-	update any, opts ...*mopt.FindOneAndUpdateOptions) error {
+func (mm *Model) FindOneAndUpdateNoCache(ctx context.Context, v, filter interface{},
+	update interface{}, opts ...*mopt.FindOneAndUpdateOptions) error {
 	return mm.Model.FindOneAndUpdate(ctx, v, filter, update, opts...)
 }
 
 // GetCache unmarshal the cache into v with given key.
-func (mm *Model) GetCache(key string, v any) error {
+func (mm *Model) GetCache(key string, v interface{}) error {
 	return mm.cache.Get(key, v)
 }
 
 // InsertOne inserts a single document into the collection, and remove the cache placeholder.
-func (mm *Model) InsertOne(ctx context.Context, key string, document any,
+func (mm *Model) InsertOne(ctx context.Context, key string, document interface{},
 	opts ...*mopt.InsertOneOptions) (*mongo.InsertOneResult, error) {
 	res, err := mm.Model.InsertOne(ctx, document, opts...)
 	if err != nil {
@@ -186,13 +186,13 @@ func (mm *Model) InsertOne(ctx context.Context, key string, document any,
 }
 
 // InsertOneNoCache inserts a single document into the collection.
-func (mm *Model) InsertOneNoCache(ctx context.Context, document any,
+func (mm *Model) InsertOneNoCache(ctx context.Context, document interface{},
 	opts ...*mopt.InsertOneOptions) (*mongo.InsertOneResult, error) {
 	return mm.Model.InsertOne(ctx, document, opts...)
 }
 
 // ReplaceOne replaces a single document in the collection, and remove the cache.
-func (mm *Model) ReplaceOne(ctx context.Context, key string, filter, replacement any,
+func (mm *Model) ReplaceOne(ctx context.Context, key string, filter, replacement interface{},
 	opts ...*mopt.ReplaceOptions) (*mongo.UpdateResult, error) {
 	res, err := mm.Model.ReplaceOne(ctx, filter, replacement, opts...)
 	if err != nil {
@@ -207,18 +207,18 @@ func (mm *Model) ReplaceOne(ctx context.Context, key string, filter, replacement
 }
 
 // ReplaceOneNoCache replaces a single document in the collection.
-func (mm *Model) ReplaceOneNoCache(ctx context.Context, filter, replacement any,
+func (mm *Model) ReplaceOneNoCache(ctx context.Context, filter, replacement interface{},
 	opts ...*mopt.ReplaceOptions) (*mongo.UpdateResult, error) {
 	return mm.Model.ReplaceOne(ctx, filter, replacement, opts...)
 }
 
 // SetCache sets the cache with given key and value.
-func (mm *Model) SetCache(key string, v any) error {
+func (mm *Model) SetCache(key string, v interface{}) error {
 	return mm.cache.Set(key, v)
 }
 
 // UpdateByID updates the document with given id with update, and remove the cache.
-func (mm *Model) UpdateByID(ctx context.Context, key string, id, update any,
+func (mm *Model) UpdateByID(ctx context.Context, key string, id, update interface{},
 	opts ...*mopt.UpdateOptions) (*mongo.UpdateResult, error) {
 	res, err := mm.Model.UpdateByID(ctx, id, update, opts...)
 	if err != nil {
@@ -233,13 +233,13 @@ func (mm *Model) UpdateByID(ctx context.Context, key string, id, update any,
 }
 
 // UpdateByIDNoCache updates the document with given id with update.
-func (mm *Model) UpdateByIDNoCache(ctx context.Context, id, update any,
+func (mm *Model) UpdateByIDNoCache(ctx context.Context, id, update interface{},
 	opts ...*mopt.UpdateOptions) (*mongo.UpdateResult, error) {
 	return mm.Model.UpdateByID(ctx, id, update, opts...)
 }
 
 // UpdateMany updates the documents that match filter with update, and remove the cache.
-func (mm *Model) UpdateMany(ctx context.Context, keys []string, filter, update any,
+func (mm *Model) UpdateMany(ctx context.Context, keys []string, filter, update interface{},
 	opts ...*mopt.UpdateOptions) (*mongo.UpdateResult, error) {
 	res, err := mm.Model.UpdateMany(ctx, filter, update, opts...)
 	if err != nil {
@@ -254,13 +254,13 @@ func (mm *Model) UpdateMany(ctx context.Context, keys []string, filter, update a
 }
 
 // UpdateManyNoCache updates the documents that match filter with update.
-func (mm *Model) UpdateManyNoCache(ctx context.Context, filter, update any,
+func (mm *Model) UpdateManyNoCache(ctx context.Context, filter, update interface{},
 	opts ...*mopt.UpdateOptions) (*mongo.UpdateResult, error) {
 	return mm.Model.UpdateMany(ctx, filter, update, opts...)
 }
 
 // UpdateOne updates the first document that matches filter with update, and remove the cache.
-func (mm *Model) UpdateOne(ctx context.Context, key string, filter, update any,
+func (mm *Model) UpdateOne(ctx context.Context, key string, filter, update interface{},
 	opts ...*mopt.UpdateOptions) (*mongo.UpdateResult, error) {
 	res, err := mm.Model.UpdateOne(ctx, filter, update, opts...)
 	if err != nil {
@@ -275,7 +275,7 @@ func (mm *Model) UpdateOne(ctx context.Context, key string, filter, update any,
 }
 
 // UpdateOneNoCache updates the first document that matches filter with update.
-func (mm *Model) UpdateOneNoCache(ctx context.Context, filter, update any,
+func (mm *Model) UpdateOneNoCache(ctx context.Context, filter, update interface{},
 	opts ...*mopt.UpdateOptions) (*mongo.UpdateResult, error) {
 	return mm.Model.UpdateOne(ctx, filter, update, opts...)
 }

core/stores/postgres/postgresql.go

@@ -2,11 +2,11 @@ package postgres
 
 import (
 	// imports the driver, don't remove this comment, golint requires.
-	_ "github.com/jackc/pgx/v5"
+	_ "github.com/lib/pq"
 	"github.com/zeromicro/go-zero/core/stores/sqlx"
 )
 
-const postgresDriverName = "pgx"
+const postgresDriverName = "postgres"
 
 // New returns a postgres connection.
 func New(datasource string, opts ...sqlx.SqlOption) sqlx.SqlConn {

core/stores/redis/redis.go

@@ -392,13 +392,13 @@ func (s *Redis) DelCtx(ctx context.Context, keys ...string) (val int, err error)
 }
 
 // Eval is the implementation of redis eval command.
-func (s *Redis) Eval(script string, keys []string, args ...any) (any, error) {
+func (s *Redis) Eval(script string, keys []string, args ...interface{}) (interface{}, error) {
 	return s.EvalCtx(context.Background(), script, keys, args...)
 }
 
 // EvalCtx is the implementation of redis eval command.
 func (s *Redis) EvalCtx(ctx context.Context, script string, keys []string,
-	args ...any) (val any, err error) {
+	args ...interface{}) (val interface{}, err error) {
 	err = s.brk.DoWithAcceptable(func() error {
 		conn, err := getRedis(s)
 		if err != nil {
@@ -413,13 +413,13 @@ func (s *Redis) EvalCtx(ctx context.Context, script string, keys []string,
 }
 
 // EvalSha is the implementation of redis evalsha command.
-func (s *Redis) EvalSha(sha string, keys []string, args ...any) (any, error) {
+func (s *Redis) EvalSha(sha string, keys []string, args ...interface{}) (interface{}, error) {
 	return s.EvalShaCtx(context.Background(), sha, keys, args...)
 }
 
 // EvalShaCtx is the implementation of redis evalsha command.
 func (s *Redis) EvalShaCtx(ctx context.Context, sha string, keys []string,
-	args ...any) (val any, err error) {
+	args ...interface{}) (val interface{}, err error) {
 	err = s.brk.DoWithAcceptable(func() error {
 		conn, err := getRedis(s)
 		if err != nil {
@@ -974,7 +974,7 @@ func (s *Redis) HmsetCtx(ctx context.Context, key string, fieldsAndValues map[st
 			return err
 		}
 
-		vals := make(map[string]any, len(fieldsAndValues))
+		vals := make(map[string]interface{}, len(fieldsAndValues))
 		for k, v := range fieldsAndValues {
 			vals[k] = v
 		}
@@ -1171,12 +1171,12 @@ func (s *Redis) LpopCtx(ctx context.Context, key string) (val string, err error)
 }
 
 // Lpush is the implementation of redis lpush command.
-func (s *Redis) Lpush(key string, values ...any) (int, error) {
+func (s *Redis) Lpush(key string, values ...interface{}) (int, error) {
 	return s.LpushCtx(context.Background(), key, values...)
 }
 
 // LpushCtx is the implementation of redis lpush command.
-func (s *Redis) LpushCtx(ctx context.Context, key string, values ...any) (val int, err error) {
+func (s *Redis) LpushCtx(ctx context.Context, key string, values ...interface{}) (val int, err error) {
 	err = s.brk.DoWithAcceptable(func() error {
 		conn, err := getRedis(s)
 		if err != nil {
@@ -1303,12 +1303,12 @@ func (s *Redis) PersistCtx(ctx context.Context, key string) (val bool, err error
 }
 
 // Pfadd is the implementation of redis pfadd command.
-func (s *Redis) Pfadd(key string, values ...any) (bool, error) {
+func (s *Redis) Pfadd(key string, values ...interface{}) (bool, error) {
 	return s.PfaddCtx(context.Background(), key, values...)
 }
 
 // PfaddCtx is the implementation of redis pfadd command.
-func (s *Redis) PfaddCtx(ctx context.Context, key string, values ...any) (val bool, err error) {
+func (s *Redis) PfaddCtx(ctx context.Context, key string, values ...interface{}) (val bool, err error) {
 	err = s.brk.DoWithAcceptable(func() error {
 		conn, err := getRedis(s)
 		if err != nil {
@@ -1433,12 +1433,12 @@ func (s *Redis) RpopCtx(ctx context.Context, key string) (val string, err error)
 }
 
 // Rpush is the implementation of redis rpush command.
-func (s *Redis) Rpush(key string, values ...any) (int, error) {
+func (s *Redis) Rpush(key string, values ...interface{}) (int, error) {
 	return s.RpushCtx(context.Background(), key, values...)
 }
 
 // RpushCtx is the implementation of redis rpush command.
-func (s *Redis) RpushCtx(ctx context.Context, key string, values ...any) (val int, err error) {
+func (s *Redis) RpushCtx(ctx context.Context, key string, values ...interface{}) (val int, err error) {
 	err = s.brk.DoWithAcceptable(func() error {
 		conn, err := getRedis(s)
 		if err != nil {
@@ -1458,12 +1458,12 @@ func (s *Redis) RpushCtx(ctx context.Context, key string, values ...any) (val in
 }
 
 // Sadd is the implementation of redis sadd command.
-func (s *Redis) Sadd(key string, values ...any) (int, error) {
+func (s *Redis) Sadd(key string, values ...interface{}) (int, error) {
 	return s.SaddCtx(context.Background(), key, values...)
 }
 
 // SaddCtx is the implementation of redis sadd command.
-func (s *Redis) SaddCtx(ctx context.Context, key string, values ...any) (val int, err error) {
+func (s *Redis) SaddCtx(ctx context.Context, key string, values ...interface{}) (val int, err error) {
 	err = s.brk.DoWithAcceptable(func() error {
 		conn, err := getRedis(s)
 		if err != nil {
@@ -1660,12 +1660,12 @@ func (s *Redis) SetnxExCtx(ctx context.Context, key, value string, seconds int)
 }
 
 // Sismember is the implementation of redis sismember command.
-func (s *Redis) Sismember(key string, value any) (bool, error) {
+func (s *Redis) Sismember(key string, value interface{}) (bool, error) {
 	return s.SismemberCtx(context.Background(), key, value)
 }
 
 // SismemberCtx is the implementation of redis sismember command.
-func (s *Redis) SismemberCtx(ctx context.Context, key string, value any) (val bool, err error) {
+func (s *Redis) SismemberCtx(ctx context.Context, key string, value interface{}) (val bool, err error) {
 	err = s.brk.DoWithAcceptable(func() error {
 		conn, err := getRedis(s)
 		if err != nil {
@@ -1740,12 +1740,12 @@ func (s *Redis) SrandmemberCtx(ctx context.Context, key string, count int) (val
 }
 
 // Srem is the implementation of redis srem command.
-func (s *Redis) Srem(key string, values ...any) (int, error) {
+func (s *Redis) Srem(key string, values ...interface{}) (int, error) {
 	return s.SremCtx(context.Background(), key, values...)
 }
 
 // SremCtx is the implementation of redis srem command.
-func (s *Redis) SremCtx(ctx context.Context, key string, values ...any) (val int, err error) {
+func (s *Redis) SremCtx(ctx context.Context, key string, values ...interface{}) (val int, err error) {
 	err = s.brk.DoWithAcceptable(func() error {
 		conn, err := getRedis(s)
 		if err != nil {
@@ -2167,12 +2167,12 @@ func (s *Redis) ZrankCtx(ctx context.Context, key, field string) (val int64, err
 }
 
 // Zrem is the implementation of redis zrem command.
-func (s *Redis) Zrem(key string, values ...any) (int, error) {
+func (s *Redis) Zrem(key string, values ...interface{}) (int, error) {
 	return s.ZremCtx(context.Background(), key, values...)
 }
 
 // ZremCtx is the implementation of redis zrem command.
-func (s *Redis) ZremCtx(ctx context.Context, key string, values ...any) (val int, err error) {
+func (s *Redis) ZremCtx(ctx context.Context, key string, values ...interface{}) (val int, err error) {
 	err = s.brk.DoWithAcceptable(func() error {
 		conn, err := getRedis(s)
 		if err != nil {
@@ -2810,7 +2810,7 @@ func toFloatPairs(vals []red.Z) []FloatPair {
 	return pairs
 }
 
-func toStrings(vals []any) []string {
+func toStrings(vals []interface{}) []string {
 	ret := make([]string, len(vals))
 
 	for i, val := range vals {

core/stores/redis/redis_test.go

@@ -1628,7 +1628,7 @@ func TestRedis_Zscan(t *testing.T) {
 }
 
 func TestRedisToStrings(t *testing.T) {
-	vals := toStrings([]any{1, 2})
+	vals := toStrings([]interface{}{1, 2})
 	assert.EqualValues(t, []string{"1", "2"}, vals)
 }
 

core/stores/sqlc/cachedsql.go

@@ -29,17 +29,17 @@ type (
 	// ExecCtxFn defines the sql exec method.
 	ExecCtxFn func(ctx context.Context, conn sqlx.SqlConn) (sql.Result, error)
 	// IndexQueryFn defines the query method that based on unique indexes.
-	IndexQueryFn func(conn sqlx.SqlConn, v any) (any, error)
+	IndexQueryFn func(conn sqlx.SqlConn, v interface{}) (interface{}, error)
 	// IndexQueryCtxFn defines the query method that based on unique indexes.
-	IndexQueryCtxFn func(ctx context.Context, conn sqlx.SqlConn, v any) (any, error)
+	IndexQueryCtxFn func(ctx context.Context, conn sqlx.SqlConn, v interface{}) (interface{}, error)
 	// PrimaryQueryFn defines the query method that based on primary keys.
-	PrimaryQueryFn func(conn sqlx.SqlConn, v, primary any) error
+	PrimaryQueryFn func(conn sqlx.SqlConn, v, primary interface{}) error
 	// PrimaryQueryCtxFn defines the query method that based on primary keys.
-	PrimaryQueryCtxFn func(ctx context.Context, conn sqlx.SqlConn, v, primary any) error
+	PrimaryQueryCtxFn func(ctx context.Context, conn sqlx.SqlConn, v, primary interface{}) error
 	// QueryFn defines the query method.
-	QueryFn func(conn sqlx.SqlConn, v any) error
+	QueryFn func(conn sqlx.SqlConn, v interface{}) error
 	// QueryCtxFn defines the query method.
-	QueryCtxFn func(ctx context.Context, conn sqlx.SqlConn, v any) error
+	QueryCtxFn func(ctx context.Context, conn sqlx.SqlConn, v interface{}) error
 
 	// A CachedConn is a DB connection with cache capability.
 	CachedConn struct {
@@ -79,12 +79,12 @@ func (cc CachedConn) DelCacheCtx(ctx context.Context, keys ...string) error {
 }
 
 // GetCache unmarshals cache with given key into v.
-func (cc CachedConn) GetCache(key string, v any) error {
+func (cc CachedConn) GetCache(key string, v interface{}) error {
 	return cc.GetCacheCtx(context.Background(), key, v)
 }
 
 // GetCacheCtx unmarshals cache with given key into v.
-func (cc CachedConn) GetCacheCtx(ctx context.Context, key string, v any) error {
+func (cc CachedConn) GetCacheCtx(ctx context.Context, key string, v interface{}) error {
 	return cc.cache.GetCtx(ctx, key, v)
 }
 
@@ -112,38 +112,38 @@ func (cc CachedConn) ExecCtx(ctx context.Context, exec ExecCtxFn, keys ...string
 }
 
 // ExecNoCache runs exec with given sql statement, without affecting cache.
-func (cc CachedConn) ExecNoCache(q string, args ...any) (sql.Result, error) {
+func (cc CachedConn) ExecNoCache(q string, args ...interface{}) (sql.Result, error) {
 	return cc.ExecNoCacheCtx(context.Background(), q, args...)
 }
 
 // ExecNoCacheCtx runs exec with given sql statement, without affecting cache.
-func (cc CachedConn) ExecNoCacheCtx(ctx context.Context, q string, args ...any) (
+func (cc CachedConn) ExecNoCacheCtx(ctx context.Context, q string, args ...interface{}) (
 	sql.Result, error) {
 	return cc.db.ExecCtx(ctx, q, args...)
 }
 
 // QueryRow unmarshals into v with given key and query func.
-func (cc CachedConn) QueryRow(v any, key string, query QueryFn) error {
-	queryCtx := func(_ context.Context, conn sqlx.SqlConn, v any) error {
+func (cc CachedConn) QueryRow(v interface{}, key string, query QueryFn) error {
+	queryCtx := func(_ context.Context, conn sqlx.SqlConn, v interface{}) error {
 		return query(conn, v)
 	}
 	return cc.QueryRowCtx(context.Background(), v, key, queryCtx)
 }
 
 // QueryRowCtx unmarshals into v with given key and query func.
-func (cc CachedConn) QueryRowCtx(ctx context.Context, v any, key string, query QueryCtxFn) error {
-	return cc.cache.TakeCtx(ctx, v, key, func(v any) error {
+func (cc CachedConn) QueryRowCtx(ctx context.Context, v interface{}, key string, query QueryCtxFn) error {
+	return cc.cache.TakeCtx(ctx, v, key, func(v interface{}) error {
 		return query(ctx, cc.db, v)
 	})
 }
 
 // QueryRowIndex unmarshals into v with given key.
-func (cc CachedConn) QueryRowIndex(v any, key string, keyer func(primary any) string,
+func (cc CachedConn) QueryRowIndex(v interface{}, key string, keyer func(primary interface{}) string,
 	indexQuery IndexQueryFn, primaryQuery PrimaryQueryFn) error {
-	indexQueryCtx := func(_ context.Context, conn sqlx.SqlConn, v any) (any, error) {
+	indexQueryCtx := func(_ context.Context, conn sqlx.SqlConn, v interface{}) (interface{}, error) {
 		return indexQuery(conn, v)
 	}
-	primaryQueryCtx := func(_ context.Context, conn sqlx.SqlConn, v, primary any) error {
+	primaryQueryCtx := func(_ context.Context, conn sqlx.SqlConn, v, primary interface{}) error {
 		return primaryQuery(conn, v, primary)
 	}
 
@@ -151,14 +151,14 @@ func (cc CachedConn) QueryRowIndex(v any, key string, keyer func(primary any) st
 }
 
 // QueryRowIndexCtx unmarshals into v with given key.
-func (cc CachedConn) QueryRowIndexCtx(ctx context.Context, v any, key string,
-	keyer func(primary any) string, indexQuery IndexQueryCtxFn,
+func (cc CachedConn) QueryRowIndexCtx(ctx context.Context, v interface{}, key string,
+	keyer func(primary interface{}) string, indexQuery IndexQueryCtxFn,
 	primaryQuery PrimaryQueryCtxFn) error {
-	var primaryKey any
+	var primaryKey interface{}
 	var found bool
 
 	if err := cc.cache.TakeWithExpireCtx(ctx, &primaryKey, key,
-		func(val any, expire time.Duration) (err error) {
+		func(val interface{}, expire time.Duration) (err error) {
 			primaryKey, err = indexQuery(ctx, cc.db, v)
 			if err != nil {
 				return
@@ -175,42 +175,42 @@ func (cc CachedConn) QueryRowIndexCtx(ctx context.Context, v any, key string,
 		return nil
 	}
 
-	return cc.cache.TakeCtx(ctx, v, keyer(primaryKey), func(v any) error {
+	return cc.cache.TakeCtx(ctx, v, keyer(primaryKey), func(v interface{}) error {
 		return primaryQuery(ctx, cc.db, v, primaryKey)
 	})
 }
 
 // QueryRowNoCache unmarshals into v with given statement.
-func (cc CachedConn) QueryRowNoCache(v any, q string, args ...any) error {
+func (cc CachedConn) QueryRowNoCache(v interface{}, q string, args ...interface{}) error {
 	return cc.QueryRowNoCacheCtx(context.Background(), v, q, args...)
 }
 
 // QueryRowNoCacheCtx unmarshals into v with given statement.
-func (cc CachedConn) QueryRowNoCacheCtx(ctx context.Context, v any, q string,
-	args ...any) error {
+func (cc CachedConn) QueryRowNoCacheCtx(ctx context.Context, v interface{}, q string,
+	args ...interface{}) error {
 	return cc.db.QueryRowCtx(ctx, v, q, args...)
 }
 
 // QueryRowsNoCache unmarshals into v with given statement.
 // It doesn't use cache, because it might cause consistency problem.
-func (cc CachedConn) QueryRowsNoCache(v any, q string, args ...any) error {
+func (cc CachedConn) QueryRowsNoCache(v interface{}, q string, args ...interface{}) error {
 	return cc.QueryRowsNoCacheCtx(context.Background(), v, q, args...)
 }
 
 // QueryRowsNoCacheCtx unmarshals into v with given statement.
 // It doesn't use cache, because it might cause consistency problem.
-func (cc CachedConn) QueryRowsNoCacheCtx(ctx context.Context, v any, q string,
-	args ...any) error {
+func (cc CachedConn) QueryRowsNoCacheCtx(ctx context.Context, v interface{}, q string,
+	args ...interface{}) error {
 	return cc.db.QueryRowsCtx(ctx, v, q, args...)
 }
 
 // SetCache sets v into cache with given key.
-func (cc CachedConn) SetCache(key string, val any) error {
+func (cc CachedConn) SetCache(key string, val interface{}) error {
 	return cc.SetCacheCtx(context.Background(), key, val)
 }
 
 // SetCacheCtx sets v into cache with given key.
-func (cc CachedConn) SetCacheCtx(ctx context.Context, key string, val any) error {
+func (cc CachedConn) SetCacheCtx(ctx context.Context, key string, val interface{}) error {
 	return cc.cache.SetCtx(ctx, key, val)
 }
 

core/stores/sqlc/cachedsql_test.go

@@ -57,7 +57,7 @@ func TestStat(t *testing.T) {
 
 	for i := 0; i < 10; i++ {
 		var str string
-		err = c.QueryRow(&str, "name", func(conn sqlx.SqlConn, v any) error {
+		err = c.QueryRow(&str, "name", func(conn sqlx.SqlConn, v interface{}) error {
 			*v.(*string) = "zero"
 			return nil
 		})
@@ -87,24 +87,24 @@ func TestCachedConn_QueryRowIndex_NoCache(t *testing.T) {
 	}, cache.WithExpiry(time.Second*10))
 
 	var str string
-	err = c.QueryRowIndex(&str, "index", func(s any) string {
+	err = c.QueryRowIndex(&str, "index", func(s interface{}) string {
 		return fmt.Sprintf("%s/1234", s)
-	}, func(conn sqlx.SqlConn, v any) (any, error) {
+	}, func(conn sqlx.SqlConn, v interface{}) (interface{}, error) {
 		*v.(*string) = "zero"
 		return "primary", errors.New("foo")
-	}, func(conn sqlx.SqlConn, v, pri any) error {
+	}, func(conn sqlx.SqlConn, v, pri interface{}) error {
 		assert.Equal(t, "primary", pri)
 		*v.(*string) = "xin"
 		return nil
 	})
 	assert.NotNil(t, err)
 
-	err = c.QueryRowIndex(&str, "index", func(s any) string {
+	err = c.QueryRowIndex(&str, "index", func(s interface{}) string {
 		return fmt.Sprintf("%s/1234", s)
-	}, func(conn sqlx.SqlConn, v any) (any, error) {
+	}, func(conn sqlx.SqlConn, v interface{}) (interface{}, error) {
 		*v.(*string) = "zero"
 		return "primary", nil
-	}, func(conn sqlx.SqlConn, v, pri any) error {
+	}, func(conn sqlx.SqlConn, v, pri interface{}) error {
 		assert.Equal(t, "primary", pri)
 		*v.(*string) = "xin"
 		return nil
@@ -130,12 +130,12 @@ func TestCachedConn_QueryRowIndex_HasCache(t *testing.T) {
 
 	var str string
 	r.Set("index", `"primary"`)
-	err = c.QueryRowIndex(&str, "index", func(s any) string {
+	err = c.QueryRowIndex(&str, "index", func(s interface{}) string {
 		return fmt.Sprintf("%s/1234", s)
-	}, func(conn sqlx.SqlConn, v any) (any, error) {
+	}, func(conn sqlx.SqlConn, v interface{}) (interface{}, error) {
 		assert.Fail(t, "should not go here")
 		return "primary", nil
-	}, func(conn sqlx.SqlConn, v, primary any) error {
+	}, func(conn sqlx.SqlConn, v, primary interface{}) error {
 		*v.(*string) = "xin"
 		assert.Equal(t, "primary", primary)
 		return nil
@@ -163,7 +163,7 @@ func TestCachedConn_QueryRowIndex_HasCache_IntPrimary(t *testing.T) {
 	)
 	tests := []struct {
 		name         string
-		primary      any
+		primary      interface{}
 		primaryCache string
 	}{
 		{
@@ -220,12 +220,12 @@ func TestCachedConn_QueryRowIndex_HasCache_IntPrimary(t *testing.T) {
 
 			var str string
 			r.Set("index", test.primaryCache)
-			err = c.QueryRowIndex(&str, "index", func(s any) string {
+			err = c.QueryRowIndex(&str, "index", func(s interface{}) string {
 				return fmt.Sprintf("%v/1234", s)
-			}, func(conn sqlx.SqlConn, v any) (any, error) {
+			}, func(conn sqlx.SqlConn, v interface{}) (interface{}, error) {
 				assert.Fail(t, "should not go here")
 				return test.primary, nil
-			}, func(conn sqlx.SqlConn, v, primary any) error {
+			}, func(conn sqlx.SqlConn, v, primary interface{}) error {
 				*v.(*string) = "xin"
 				assert.Equal(t, primary, primary)
 				return nil
@@ -260,12 +260,12 @@ func TestCachedConn_QueryRowIndex_HasWrongCache(t *testing.T) {
 
 			var str string
 			r.Set(k, v)
-			err = c.QueryRowIndex(&str, "index", func(s any) string {
+			err = c.QueryRowIndex(&str, "index", func(s interface{}) string {
 				return fmt.Sprintf("%s/1234", s)
-			}, func(conn sqlx.SqlConn, v any) (any, error) {
+			}, func(conn sqlx.SqlConn, v interface{}) (interface{}, error) {
 				*v.(*string) = "xin"
 				return "primary", nil
-			}, func(conn sqlx.SqlConn, v, primary any) error {
+			}, func(conn sqlx.SqlConn, v, primary interface{}) error {
 				*v.(*string) = "xin"
 				assert.Equal(t, "primary", primary)
 				return nil
@@ -292,7 +292,7 @@ func TestStatCacheFails(t *testing.T) {
 
 	for i := 0; i < 20; i++ {
 		var str string
-		err := c.QueryRow(&str, "name", func(conn sqlx.SqlConn, v any) error {
+		err := c.QueryRow(&str, "name", func(conn sqlx.SqlConn, v interface{}) error {
 			return errors.New("db failed")
 		})
 		assert.NotNil(t, err)
@@ -314,7 +314,7 @@ func TestStatDbFails(t *testing.T) {
 
 	for i := 0; i < 20; i++ {
 		var str string
-		err = c.QueryRow(&str, "name", func(conn sqlx.SqlConn, v any) error {
+		err = c.QueryRow(&str, "name", func(conn sqlx.SqlConn, v interface{}) error {
 			return errors.New("db failed")
 		})
 		assert.NotNil(t, err)
@@ -339,7 +339,7 @@ func TestStatFromMemory(t *testing.T) {
 	wait.Add(4)
 	go func() {
 		var str string
-		err := c.QueryRow(&str, "name", func(conn sqlx.SqlConn, v any) error {
+		err := c.QueryRow(&str, "name", func(conn sqlx.SqlConn, v interface{}) error {
 			*v.(*string) = "zero"
 			return nil
 		})
@@ -355,7 +355,7 @@ func TestStatFromMemory(t *testing.T) {
 		go func() {
 			var str string
 			wait.Done()
-			err := c.QueryRow(&str, "name", func(conn sqlx.SqlConn, v any) error {
+			err := c.QueryRow(&str, "name", func(conn sqlx.SqlConn, v interface{}) error {
 				*v.(*string) = "zero"
 				return nil
 			})
@@ -368,7 +368,7 @@ func TestStatFromMemory(t *testing.T) {
 	for i := 0; i < 5; i++ {
 		go func() {
 			var str string
-			err := c.QueryRow(&str, "name", func(conn sqlx.SqlConn, v any) error {
+			err := c.QueryRow(&str, "name", func(conn sqlx.SqlConn, v interface{}) error {
 				*v.(*string) = "zero"
 				return nil
 			})
@@ -397,7 +397,7 @@ func TestCachedConnQueryRow(t *testing.T) {
 	var user string
 	var ran bool
 	c := NewNodeConn(&conn, r, cache.WithExpiry(time.Second*30))
-	err = c.QueryRow(&user, key, func(conn sqlx.SqlConn, v any) error {
+	err = c.QueryRow(&user, key, func(conn sqlx.SqlConn, v interface{}) error {
 		ran = true
 		user = value
 		return nil
@@ -426,7 +426,7 @@ func TestCachedConnQueryRowFromCache(t *testing.T) {
 	var ran bool
 	c := NewNodeConn(&conn, r, cache.WithExpiry(time.Second*30))
 	assert.Nil(t, c.SetCache(key, value))
-	err = c.QueryRow(&user, key, func(conn sqlx.SqlConn, v any) error {
+	err = c.QueryRow(&user, key, func(conn sqlx.SqlConn, v interface{}) error {
 		ran = true
 		user = value
 		return nil
@@ -452,7 +452,7 @@ func TestQueryRowNotFound(t *testing.T) {
 	var ran int
 	c := NewNodeConn(&conn, r, cache.WithExpiry(time.Second*30))
 	for i := 0; i < 20; i++ {
-		err = c.QueryRow(&user, key, func(conn sqlx.SqlConn, v any) error {
+		err = c.QueryRow(&user, key, func(conn sqlx.SqlConn, v interface{}) error {
 			ran++
 			return sql.ErrNoRows
 		})
@@ -551,7 +551,7 @@ func TestQueryRowNoCache(t *testing.T) {
 	)
 	var user string
 	var ran bool
-	conn := dummySqlConn{queryRow: func(v any, q string, args ...any) error {
+	conn := dummySqlConn{queryRow: func(v interface{}, q string, args ...interface{}) error {
 		user = value
 		ran = true
 		return nil
@@ -583,10 +583,10 @@ func resetStats() {
 }
 
 type dummySqlConn struct {
-	queryRow func(any, string, ...any) error
+	queryRow func(interface{}, string, ...interface{}) error
 }
 
-func (d dummySqlConn) ExecCtx(ctx context.Context, query string, args ...any) (sql.Result, error) {
+func (d dummySqlConn) ExecCtx(ctx context.Context, query string, args ...interface{}) (sql.Result, error) {
 	return nil, nil
 }
 
@@ -594,15 +594,15 @@ func (d dummySqlConn) PrepareCtx(ctx context.Context, query string) (sqlx.StmtSe
 	return nil, nil
 }
 
-func (d dummySqlConn) QueryRowPartialCtx(ctx context.Context, v any, query string, args ...any) error {
+func (d dummySqlConn) QueryRowPartialCtx(ctx context.Context, v interface{}, query string, args ...interface{}) error {
 	return nil
 }
 
-func (d dummySqlConn) QueryRowsCtx(ctx context.Context, v any, query string, args ...any) error {
+func (d dummySqlConn) QueryRowsCtx(ctx context.Context, v interface{}, query string, args ...interface{}) error {
 	return nil
 }
 
-func (d dummySqlConn) QueryRowsPartialCtx(ctx context.Context, v any, query string, args ...any) error {
+func (d dummySqlConn) QueryRowsPartialCtx(ctx context.Context, v interface{}, query string, args ...interface{}) error {
 	return nil
 }
 
@@ -610,7 +610,7 @@ func (d dummySqlConn) TransactCtx(ctx context.Context, fn func(context.Context,
 	return nil
 }
 
-func (d dummySqlConn) Exec(query string, args ...any) (sql.Result, error) {
+func (d dummySqlConn) Exec(query string, args ...interface{}) (sql.Result, error) {
 	return nil, nil
 }
 
@@ -618,26 +618,26 @@ func (d dummySqlConn) Prepare(query string) (sqlx.StmtSession, error) {
 	return nil, nil
 }
 
-func (d dummySqlConn) QueryRow(v any, query string, args ...any) error {
+func (d dummySqlConn) QueryRow(v interface{}, query string, args ...interface{}) error {
 	return d.QueryRowCtx(context.Background(), v, query, args...)
 }
 
-func (d dummySqlConn) QueryRowCtx(_ context.Context, v any, query string, args ...any) error {
+func (d dummySqlConn) QueryRowCtx(_ context.Context, v interface{}, query string, args ...interface{}) error {
 	if d.queryRow != nil {
 		return d.queryRow(v, query, args...)
 	}
 	return nil
 }
 
-func (d dummySqlConn) QueryRowPartial(v any, query string, args ...any) error {
+func (d dummySqlConn) QueryRowPartial(v interface{}, query string, args ...interface{}) error {
 	return nil
 }
 
-func (d dummySqlConn) QueryRows(v any, query string, args ...any) error {
+func (d dummySqlConn) QueryRows(v interface{}, query string, args ...interface{}) error {
 	return nil
 }
 
-func (d dummySqlConn) QueryRowsPartial(v any, query string, args ...any) error {
+func (d dummySqlConn) QueryRowsPartial(v interface{}, query string, args ...interface{}) error {
 	return nil
 }
 
@@ -656,20 +656,20 @@ type trackedConn struct {
 	transactValue  bool
 }
 
-func (c *trackedConn) Exec(query string, args ...any) (sql.Result, error) {
+func (c *trackedConn) Exec(query string, args ...interface{}) (sql.Result, error) {
 	return c.ExecCtx(context.Background(), query, args...)
 }
 
-func (c *trackedConn) ExecCtx(ctx context.Context, query string, args ...any) (sql.Result, error) {
+func (c *trackedConn) ExecCtx(ctx context.Context, query string, args ...interface{}) (sql.Result, error) {
 	c.execValue = true
 	return c.dummySqlConn.ExecCtx(ctx, query, args...)
 }
 
-func (c *trackedConn) QueryRows(v any, query string, args ...any) error {
+func (c *trackedConn) QueryRows(v interface{}, query string, args ...interface{}) error {
 	return c.QueryRowsCtx(context.Background(), v, query, args...)
 }
 
-func (c *trackedConn) QueryRowsCtx(ctx context.Context, v any, query string, args ...any) error {
+func (c *trackedConn) QueryRowsCtx(ctx context.Context, v interface{}, query string, args ...interface{}) error {
 	c.queryRowsValue = true
 	return c.dummySqlConn.QueryRowsCtx(ctx, v, query, args...)
 }

core/stores/sqlx/bulkinserter.go

@@ -64,7 +64,7 @@ func (bi *BulkInserter) Flush() {
 }
 
 // Insert inserts given args.
-func (bi *BulkInserter) Insert(args ...any) error {
+func (bi *BulkInserter) Insert(args ...interface{}) error {
 	value, err := format(bi.stmt.valueFormat, args...)
 	if err != nil {
 		return err
@@ -110,12 +110,12 @@ type dbInserter struct {
 	resultHandler ResultHandler
 }
 
-func (in *dbInserter) AddTask(task any) bool {
+func (in *dbInserter) AddTask(task interface{}) bool {
 	in.values = append(in.values, task.(string))
 	return len(in.values) >= maxBulkRows
 }
 
-func (in *dbInserter) Execute(bulk any) {
+func (in *dbInserter) Execute(bulk interface{}) {
 	values := bulk.([]string)
 	if len(values) == 0 {
 		return
@@ -135,7 +135,7 @@ func (in *dbInserter) Execute(bulk any) {
 	}
 }
 
-func (in *dbInserter) RemoveAll() any {
+func (in *dbInserter) RemoveAll() interface{} {
 	values := in.values
 	in.values = nil
 	return values