Using function to process synchronously and asynchronously both and get results in golang

I wanted a function exec to process synchronously and asynchronously both.

I might execute multiple go routines of exec from Compute function.

Wanted to check whether it is fine to code like this.

package main

import "fmt"

type Test struct {
	a int
	b int
}

func (t *Test) exec(responseChannel *chan bool, errChannel *chan error) (bool, error) {
	response := false
	if responseChannel != nil && errChannel != nil {
		*responseChannel <- response
		*errChannel <- nil
	}
	return response, nil
}

func (t *Test) Compute(sync bool) {
	if !sync {
		responseChannel := make(chan bool)
		errChannel := make(chan error)

		go t.exec(&responseChannel, &errChannel)

		fmt.Println(<-responseChannel)
		fmt.Println(<-errChannel)
	} else {
		res, err := t.exec(nil, nil)
		fmt.Println(res)
		fmt.Println(err)
	}
}

func main() {

	t := Test{
		10,
		12,
	}

	t.Compute(true)
	t.Compute(false)

}

In my usecase I will be making network calls (most only db calls) in exec function.

The idiomatic approach is to write synchronous functions with the caller using Go routines as needed. Here's the code rewritten to that idiom:

func (t *Test) exec() (bool, error) {
	response := false
	return response, nil
}

func (t *Test) Compute(sync bool) {
	if !sync {
		type result struct {
			value bool
			err   error
		}
		c := make(chan result)
		go func() {
			var r result
			r.value, r.err = t.exec()
			c <- r
		}()
		fmt.Println(<-c)
	} else {
		res, err := t.exec()
		fmt.Println(res)
		fmt.Println(err)
	}
}

Both calls to exec are executed synchronously in the question and this answer. I assume that the question presents a stripped down example and that the real code has actual asynchrony. If not, then the code can be reduced to:

func (t *Test) Compute(sync bool) {
	res, err := t.exec()
	fmt.Println(res)
	fmt.Println(err)
}

Short answer: Yes, this is fine.

However, you may want to consider some alternatives. When you start dealing with more complex code, you'll need to continuously update exec to handle more complex concurrency structures, like sync.WaitGroup, while those updates will be redundant for the synchronous portion. Usually people will write two functions (one for async work and one for sync work) and then work with those. Here's a very rough example:

func (t *Test) doAsync(out chan any, ...) {
...
out <- val
}

func (t *Test) doSync(...) any {
...
return val
}

func (t *Test) Compute(sync bool) {
    var res any
    if sync {
        res = doSync(...)
    } else {
        resChan := make(chan any)
        doAsync(resChan, ...)
        res = <-resChan
    }
}

This way, if you need to update the async handler with more complex stuff, the sync handler doesn't need to worry about it.