Is it possible to get return values selectively on single-value contexts in Go?

go, return-value

Solution

No, you cannot do that apart from one special case described in the Spec:

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.

The best you can do besides the temporary variables (which are the best option) is this:

func first(a interface{}, _ ...interface{}) interface{} {
    return a
}

func main() {
    gimmeOnePlease(first(hereTakeTwo()).(int))
}

Playground: http://play.golang.org/p/VXv-tsYjXt

Variadic version: http://play.golang.org/p/ulpdp3Hppj

Problem

A simple example: ``` package main import "fmt" func hereTakeTwo() (x, y int) { x = 0 y = 1 return } func gimmeOnePlease(x int){ fmt.Println(x) } func main() { gimmeOnePlease(hereTakeTwo()) // fix me } ``` Is it possible to pass only first returned value from `hereTakeTwo()` without using an explicit `_` assignment? Example of what I would like to avoid: ``` func main() { okJustOne, _ := hereTakeTwo() gimmeOnePlease(okJustOne) } ``` What I want is to make `gimmeOnePlease` function able to receive an undefined number of arguments but take only first one OR a way to call `hereTakeTwo` function and get only first returned value without the necessity to use `_` assignments. Or on a last resort (crazy idea) use some kind of adapter function, that takes N args and reurns only first one, and have something like: ``` func main() { gimmeOnePlease(adapter(hereTakeTwo())) } ``` Why? I'm just testing the boundaries of the language and learning how flexible it can be to some purposes.

Original source