How to pass WaitGroup to a sequential function call?

I have a function which can be called sequentially or concurrently in separate goroutine.

I want to ensure that function is executed completely before main goroutine finishes, so I am passing *sync.WaitGroup argument to the function. Now, at some places the function is to be called sequentially.

I can pass nil waitGroup to the function like this:

func my_func(wg *sync.WaitGroup){
   if wg != nil{
   defer wg.Done()
   }
   // do the task
}
func main(){
my_func(nil) // sequential call
wg := sync.WaitGroup{}
wg.Add(1)
go my_func(&wg)  // concurrent call
wg.Wait()
}

Is there any better way to achieve this ?

Your my_func() should not know / should not care how it is executed (whether in a new goroutine or not). So just for this you should not pass wg. Do not enforce concurrent or non-concurrent use of your API, let users of your package decide how they wish to call it.

If someone wishes to run it concurrently, in a new goroutine, wg can be handled outside of my_func() like this:

wg.Add(1)
go func() {
	defer wg.Done()
	my_func()
}()

This also gives possibility to put further code before / after the function call that will be executed before the wg.Done() call:

wg.Add(1)
go func() {
	defer wg.Done()
	// other code before
	my_func()
	// other code after
}()

Also note that if you have this in many places, you can create a helper function that takes care of the goroutine launching and waitgroup handling:

func launchMyFunc(wg *sync.WaitGroup) {
	go func() {
		defer wg.Done()
		my_func()
	}()
}

You can also create a helper that accepts an arbitrary no-arg no-return function:

func launchFunc(wg *sync.WaitGroup, f func()) {
	go func() {
		defer wg.Done()
		f()
	}()
}

Using the above helpers this is how you could do the same:

wg.Add(1)
launchMyFunc(wg)
// or
wg.Add(1)
launchFunc(wg, my_func)