Why Can't I Return Multiple Values Without Destructuring in Go?

Returning Multiple Values in Go: Understanding the Nuanced Restrictions

In Go, returning multiple values allows you to return multiple results from a single function. However, not all multiple-return scenarios are considered valid. Let's explore the constraints and a notable exception to this rule.

Why the Two Return Values Example is Valid

The example you provided:

func FindUserInfo(id string) (Info, bool) {
    it, present := all[id]
    return it, present
}

is valid because it follows the "comma ok" pattern. This idiom is specifically used when accessing a map key:

mapValue, ok := map[key]

In order to retrieve both the map value and the "ok" status, we must assign them to variables. The compiler understands that the "it" and "present" variables are used to destructure the result of the map indexing operation.

Why the One Return Value Example is Invalid

In contrast, the following example:

func FindUserInfo(id string) (Info, bool) {
    return all[id]
}

is invalid because it does not destructure the map indexing operation. This would lead to a single return value, which is not compatible with the specified return type of the function.

Avoidance of Temporary Variables Not Possible

It is currently not possible to avoid the temporary variables in this specific scenario. The "comma ok" idiom requires explicit assignment of the destructured values to variables.

Conclusion

Understanding the nuances of multiple return values in Go is crucial. While the "comma ok" pattern allows for multiple return values, it is restricted to map indexing, channel retrieval, and type assertions. Consequently, in your case, temporary variables are necessary when returning both a value and an "ok" status from a map indexing operation.

The above is the detailed content of Why Can't I Return Multiple Values Without Destructuring in Go?. For more information, please follow other related articles on the PHP Chinese website!