How to pass multiple return values to a variadic function?

Question

I have a Go function which returns two integer values. Below is the function

func temp() (int, int){
 return 1,1
}

Is it possible to put temp function directly into a Println and print both the outputs using string formatting as below:

fmt.Println("first= %d and second = %d", temp() ) // This doesn't work

In Python, I am able to do the following:

def func():
    return 1,1
print("{0}={1}".format(*func())
>> '1=2'

Can I do Something similar in Go too?

Answer 1

Foreword: I released this utility in github.com/icza/gox, see gox.Wrap().

---

First, for what you attempt to do you should use fmt.Printf() instead of fmt.Println() as only the former expects and uses a format string.

Going forward, this isn't supported by default, because quoting from Spec: Calls:

As a special case, if the return values of a function or method g are equal in number and individually assignable to the parameters of another function or method f, then the call f(g(parameters_of_g)) will invoke f after binding the return values of g to the parameters of f in order. The call of f must contain no parameters other than the call of g, and g must have at least one return value. If f has a final ... parameter, it is assigned the return values of g that remain after assignment of regular parameters.

And fmt.Printf() has a signature of:

func Printf(format string, a ...interface{}) (n int, err error)

You cannot pass other parameters to fmt.Printf() besides a function call (the return values of the call).

Note that the signature of fmt.Println() is:

func Println(a ...interface{}) (n int, err error)

Which means that fmt.Println(temp()) works, and so does with any other functions that have at least one return value, because the last sentence of the quoted part allows this ("If f has a final ... parameter, it is assigned the return values of g that remain after assignment of regular parameters.")

But with a little trick we can achieve what you want with fmt.Printf() too.

Note that if temp() would return a value of type []interface{}, we could use ... to pass it as the value of some variadic parameter.

Meaning this works:

func main() {
    fmt.Printf("1: %v, 2: %v\n", temp()...)
}

func temp() []interface{} { return []interface{}{1, 2} }

And it properly prints (try it on the Go Playground):

1: 1, 2: 2

So we just need a utility function that wraps the return values of any function into a []interface{}, and so we can use this to pass to fmt.Printf().

And it's dead-simple:

func wrap(vs ...interface{}) []interface{} {
    return vs
}

As detailed above (with fmt.Println()), we can pass the return values of any function that has at least 1 return value to wrap() as the values of its input parameters.

Now using this wrap() function, see the following example:

func main() {
    fmt.Printf("1: %v\n", wrap(oneInt())...)
    fmt.Printf("1: %v, 2: %v\n", wrap(twoInts())...)
    fmt.Printf("1: %v, 2: %v, 3: %v\n", wrap(threeStrings())...)
}

func oneInt() int { return 1 }

func twoInts() (int, int) { return 1, 2 }

func threeStrings() (string, string, string) { return "1", "2", "3" }

This works, and it outputs (try it on the Go Playground):

1: 1
1: 1, 2: 2
1: 1, 2: 2, 3: 3

For more on the topic, see related question:

Multiple values in single-value context

Return map like 'ok' in Golang on normal functions