feat: add Debounce function

function/function.go

@@ -7,6 +7,7 @@ package function
 import (
 	"fmt"
 	"reflect"
+	"sync"
 	"time"
 )
 
@@ -84,22 +85,44 @@ func Delay(delay time.Duration, fn any, args ...any) {
 }
 
 // Debounced creates a debounced function that delays invoking fn until after wait duration have elapsed since the last time the debounced function was invoked.
+// Deprecated: Use Debounce function instead.
 // Play: https://go.dev/play/p/absuEGB_GN7
-func Debounced(fn func(), duration time.Duration) func() {
-	// Catch programming error while constructing the closure
-	mustBeFunction(fn)
+func Debounced(fn func(), delay time.Duration) func() {
+	debouncedFn, _ := Debounce(fn, delay)
+	return debouncedFn
+}
 
-	timer := time.NewTimer(duration)
-	timer.Stop()
+// Debounce creates a debounced version of the provided function.
+// Play: todo
+func Debounce(fn func(), delay time.Duration) (debouncedFn func(), cancelFn func()) {
+	var (
+		timer *time.Timer
+		mu    sync.Mutex
+	)
 
-	go func() {
-		for {
-			<-timer.C
-			go fn()
+	debouncedFn = func() {
+		mu.Lock()
+		defer mu.Unlock()
+
+		if timer != nil {
+			timer.Stop()
 		}
-	}()
 
-	return func() { timer.Reset(duration) }
+		timer = time.AfterFunc(delay, func() {
+			fn()
+		})
+	}
+
+	cancelFn = func() {
+		mu.Lock()
+		defer mu.Unlock()
+
+		if timer != nil {
+			timer.Stop()
+		}
+	}
+
+	return debouncedFn, cancelFn
 }
 
 // Schedule invoke function every duration time, util close the returned bool channel.

function/function_example_test.go

@@ -79,6 +79,32 @@ func ExampleDelay() {
 	// hello
 }
 
+func ExampleDebounce() {
+	callCount := 0
+	fn := func() {
+		callCount++
+	}
+
+	debouncedFn, _ := Debounce(fn, 500*time.Millisecond)
+
+	for i := 0; i < 10; i++ {
+		debouncedFn()
+		time.Sleep(50 * time.Millisecond)
+	}
+
+	time.Sleep(1 * time.Second)
+	fmt.Println(callCount)
+
+	debouncedFn()
+
+	time.Sleep(1 * time.Second)
+	fmt.Println(callCount)
+
+	// Output:
+	// 1
+	// 2
+}
+
 func ExampleDebounced() {
 	count := 0
 	add := func() {

function/function_test.go

@@ -125,6 +125,80 @@ func TestDebounced(t *testing.T) {
 	assert.Equal(2, count)
 }
 
+func TestDebounce(t *testing.T) {
+	assert := internal.NewAssert(t, "TestDebounce")
+
+	t.Run("Single call", func(t *testing.T) {
+		callCount := 0
+		fn := func() {
+			callCount++
+		}
+
+		debouncedFn, _ := Debounce(fn, 500*time.Millisecond)
+		debouncedFn()
+
+		time.Sleep(1 * time.Second)
+
+		assert.Equal(1, callCount)
+	})
+
+	t.Run("Multiple calls within debounce interval", func(t *testing.T) {
+		callCount := 0
+		fn := func() {
+			callCount++
+		}
+
+		debouncedFn, _ := Debounce(fn, 1*time.Second)
+
+		for i := 0; i < 5; i++ {
+			go func(index int) {
+				time.Sleep(time.Duration(index) * 200 * time.Millisecond)
+				debouncedFn()
+			}(i)
+		}
+
+		time.Sleep(2 * time.Second)
+
+		assert.Equal(1, callCount)
+	})
+
+	t.Run("Immediate consecutive calls", func(t *testing.T) {
+		callCount := 0
+		fn := func() {
+			callCount++
+		}
+
+		debouncedFn, _ := Debounce(fn, 500*time.Millisecond)
+
+		for i := 0; i < 10; i++ {
+			debouncedFn()
+			time.Sleep(50 * time.Millisecond)
+		}
+
+		time.Sleep(1 * time.Second)
+
+		assert.Equal(1, callCount)
+	})
+
+	t.Run("Cancel calls", func(t *testing.T) {
+		callCount := 0
+		fn := func() {
+			callCount++
+		}
+
+		debouncedFn, cancelFn := Debounce(fn, 500*time.Millisecond)
+
+		debouncedFn()
+
+		cancelFn()
+
+		time.Sleep(1 * time.Second)
+
+		assert.Equal(0, callCount)
+	})
+
+}
+
 func TestSchedule(t *testing.T) {
 	// assert := internal.NewAssert(t, "TestSchedule")