A better debounce function for Golang that prevents duplicate calls and ensures consistent timing. This example is for a any type of input (not type safe), but it can/should be adapted to specific function signatures.

debounce.go

package main

import (
	"fmt"
	"time"
)

func main() {

	f := func(args ...interface{}) {
		fmt.Println(args)
	}

	d := Debounce(f, time.Second)

	for i := 0; i < 10; i++ {
		d(fmt.Sprintf("%d calling", i), i, struct{}{})
		time.Sleep(time.Millisecond * 10)
	}

	// wait for f() to run
	time.Sleep(time.Minute)

}

// Debounce will group calls to the returned function into one call to f, but
// only once the returned function has stopped being called for d nanoseconds.
func Debounce(f func(args ...interface{}), d time.Duration) func(args ...interface{}) {
	incoming := make(chan []interface{})

	go func() {
		var e []interface{}

		t := time.NewTimer(d)
		t.Stop()

		for {
			select {
			case e = <-incoming:
				t.Reset(d)
			case <-t.C:
				go f(e)
			}
		}
	}()

	return func(args ...interface{}) {
		go func() { incoming <- args }()
	}
}