Named Results and Comma-ok

## Multiple results are a language feature, not a trick Most languages let a function hand back exactly one thing, so returning two forces you into an out-parameter, a wrapper struct, or a tuple type. Go declares extra results directly in the signature: ```go func parsePort(s string) (int, bool) func Atoi(s string) (int, error) // strconv func LookupEnv(key string) (string, bool) // os ``` The result list is parenthesised whenever there is more than one result. Crucially, those two values are **not** bundled into a single object. Go has no tuple type, so there is nothing you can store the pair in, no `.0` and `.1`, and no way to pass "the results" around as one value. They exist only in the moment of the call. ## The caller must account for every result Because the values are separate, the assignment must have one target per result: ```go port, ok := parsePort(raw) ``` If you supply the wrong number of targets, the program does not compile. `port := parsePort(raw)` produces an assignment-mismatch error (one variable, two values), and so does `a, b, c := parsePort(raw)`. This is deliberate: the compiler will not let you quietly forget that the function told you something else as well. The same rule applies to `=` on existing variables. With `:=`, at least one of the names on the left must be new; if both `port` and `ok` already exist, use `=`. ## The blank identifier discards a result When a result genuinely does not matter, name it `_`: ```go port, _ := parsePort(raw) // keep the number, drop the flag _, ok := parsePort(raw) // keep the flag, drop the number ``` `_` is the blank identifier. It is not a variable: no storage is allocated, you cannot read it back, and it may appear many times in the same statement or function. It matters in Go specifically because an ordinary declared local that is never used is a **compile error** — so `_` is how you say "I know there is a value here and I am deliberately dropping it". That deliberateness is the point of review scrutiny. Discarding a `bool` that means "this value is real" or an `error` that means "this failed" turns a reported failure into a silent one, and the zero value you keep looks like a legitimate answer. In a config validator that runs as a CI step, `port, _ := parsePort(raw)` yields `0` for garbage input and the step passes; the same call written `port, ok := parsePort(raw)` forces the next line to decide what to do. If you write `_`, you should be able to say out loud why the dropped value carries no information you need. ## Forwarding a multi-valued call A call with several results can be used in two other places, both of which consume all of the values at once: ```go func port(raw string) (int, bool) { return parsePort(raw) // result types line up exactly } fmt.Println(parsePort(raw)) // both values become the arguments ``` What you cannot do is mix a multi-valued call with anything else. `fmt.Println("port:", parsePort(raw))` is rejected — a multi-valued call in a single-value context. The workaround is always the same: assign the results to variables first, then use them individually. ## Where you meet this every day The two-result shape shows up in three familiar guises. `(T, error)` is the failure convention: a value plus a reason it might be missing. `(T, bool)` is the comma-ok convention: a value plus whether it exists at all, as in `os.LookupEnv`, which distinguishes an unset environment variable from one set to the empty string. And several standard-library functions simply return two useful things — `context.WithTimeout` hands back a derived context and the cancel function you must call. In all three cases the mechanics are identical: two targets, or one target and a `_`, and never a single variable. ## What interviewers listen for They want to hear that the count is checked by the compiler, that `_` is the escape hatch rather than a variable, and that discarding a result is a decision with consequences rather than syntax noise. Saying "Go returns a tuple" is the common slip; it is close enough to be useful shorthand and wrong enough to mislead you the moment you try to store one.