Return values of function as input arguments to another

If I have

func returnIntAndString() (i int, s string) {...}

And I have:

func doSomething(i int, s string) {...}

Then I can do the following successfully:

doSomething(returnIntAndString())

However, let's say I want to add another argument to doSomething like:

func doSomething(msg string, i int, s string) {...}

Go complains when compiling if I call it like:

doSomething("message", returnIntAndString())

With:

main.go:45: multiple-value returnIntAndString() in single-value context
main.go:45: not enough arguments in call to doSomething()

Is there a way to do this or should I just give up and assign the return values from returnIntAndString to some references and pass msg and these values like doSomething(msg, code, str) ?

It's described here in the spec. It requires the inner function to return the correct types for all arguments. There is no allowance for extra parameters along with a function that returns multiple values.

> 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.
>
> func Split(s string, pos int) (string, string) {
> return s[0:pos], s[pos:]
> }
>
> func Join(s, t string) string {
> return s + t
> }
>
> if Join(Split(value, len(value)/2)) != value {
> log.Panic("test fails")
> }

If those specific conditions are not met, then you need to assign the return values and call the function separately.

I had the same question. The best solution I could come up with is creating types or structs for my desired extra parameters and writing methods for them like this:

package main

import (
	"fmt"
)

type Message string

type MessageNumber struct {
	Message string
	Number int
}

func testfunc() (foo int, bar int) {
	foo = 4
	bar = 2
	return
}

func (baz Message) testfunc2(foo int, bar int) {
	fmt.Println(foo, bar, baz)
}

func (baz MessageNumber) testfunc3(foo int, bar int) {
	fmt.Println(foo, bar, baz.Number, baz.Message)
}

func main() {
	Message("the answer").testfunc2(testfunc())
	MessageNumber{"what were we talking about again?", 0}.testfunc3(testfunc())
	fmt.Println("Done.  Have a day.")
}

The output looks like this:

user@Frodos-Atari-MEGA-STE:~/go/test$ go run main.go
4 2 the answer
4 2 0 what were we talking about again?
Done.  Have a day.