how to parse multiple returns in golang

No, this is not possible. You must assign all values from a multi-value expression to separate variables to use them, e.g.:

a, b := temp()
fmt.Println("first = %d and second = %d", a, b)
// first = 1 and second = 1

[Edit]

Interestingly, it appears that in some cases you can use multi-value expressions as function call arguments if the argument types and arity match, or for purely variadic functions (Go Playground):

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

func incr2(x, y int) (int, int) {
  return x + 1, y + 1
}

func main() {
  incr2(oneTwo()) // OK: multi-value return and arguments match.

  fmt.Println(oneTwo()) // OK: pure variadic function.

  fmt.Printf("%d %d", oneTwo()) // ERR: mixed formal and variadic args.
}

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