In my previous post, I doubled down on my claim that Go’s error handling strategy is, on balance, the best.

In this post, I wanted to take this a bit further, and *prove* that multiple returns and error values are the best,

When I say best, I obviously mean, of the set of choices available to programmers that write real world programs — because real world programs have to handle things going wrong.

# The language we have

I am only going to use the Go language that we have today, not any version of the language which might be available in the future — it simply isn’t practical to hold my breath for that long. As I will show, additions to the language like dare I say, exceptions, would not change the outcome.

# A simple problem

For this discussion, I’m going to start with a made up, but very simple function, which demonstrates the requirement for error handling.

package main import "fmt" // Positive returns true if the number is positive, false if it is negative. func Positive(n int) bool { return n > -1 } func Check(n int) { if Positive(n) { fmt.Println(n, "is positive") } else { fmt.Println(n, "is negative") } } func main() { Check(1) Check(0) Check(-1) }

If you run this code, you get the following output

1 is positive 0 is positive -1 is negative

which is *wrong*.

How can this single line function be wrong ? It is wrong because zero is neither positive or negative, and that cannot be accurately captured by the boolean return value from `Positive`

.

This is a contrived example, but hopefully one that can be adapted to discuss the costs and benefits of the various methods of error handling.

# Preconditions

No matter what solution is determined to be the best, a check will have to be added to `Positive`

to test the non zero precondition. Here is an example with the precondition added

// Positive returns true if the number is positive, false if it is negative. // The second return value indicates if the result is valid, which in the case // of n == 0, is not valid. func Positive(n int) (bool, bool) { if n == 0 { return false, false } return n > -1, true } func Check(n int) { pos, ok := Positive(n) if !ok { fmt.Println(n, "is neither") return } if pos { fmt.Println(n, "is positive") } else { fmt.Println(n, "is negative") } }

Running this program we see that the bug is fixed,

1 is positive 0 is neither -1 is negative

albeit in an ungainly way. For those interested, I also tried a version using a `switch`

which was harder to read for the saving of one line of code.

This then is the baseline to compare other solutions.

# Error

Returning a boolean is uncommon, it’s far more common to return an error value, even if the set of errors is fixed. For completeness, and because this simple example is supposed to hold up in more complex circumstances, here is an example using a value that conforms to the `error`

interface.

// Positive returns true if the number is positive, false if it is negative. func Positive(n int) (bool, error) { if n == 0 { return false, errors.New("undefined") } return n > -1, nil } func Check(n int) { pos, err := Positive(n) if err != nil { fmt.Println(n, err) return } if pos { fmt.Println(n, "is positive") } else { fmt.Println(n, "is negative") } }

The result is a function which performs the same, and the caller must check the result in an near identical way.

If anything, this underlines the flexibility of Go’s errors are values

methodology. When an error occurs, indicating only success or failure (think of the two result form of map lookup), a boolean can be substituted instead of an interface value, which removes the any confusion arising from typed `nil`

s and `nil`

ness of interface values.

# More boolean

Here is an example which allows `Positive`

to return three states, `true`

, `false`

, and `nil`

(Anyone with a background in set theory or SQL will be twitching at this point).

// If the result not nil, the result is true if the number is // positive, false if it is negative. func Positive(n int) *bool { if n == 0 { return nil } r := n > -1 return &r } func Check(n int) { pos := Positive(n) if pos == nil { fmt.Println(n, "is neither") return } if *pos { fmt.Println(n, "is positive") } else { fmt.Println(n, "is negative") } }

`Positive`

has grown another line, because of the requirement to capture the address of the result of the comparison.

Worse, now before the return value can be used anywhere, it must be checked to make sure that it points to a valid address. This is the situation that Java developers face constantly and leads to deep seated hatred of `nil`

(with good reason). This clearly isn’t a viable solution.

# Let’s try panicking

For completeness, let’s look at a version of this code that tries to simulate exceptions using `panic`

.

// Positive returns true if the number is positive, false if it is negative. // In the case that n is 0, Positive will panic. func Positive(n int) bool { if n == 0 { panic("undefined") } return n > -1 } func Check(n int) { defer func() { if recover() != nil { fmt.Println("is neither") } }() if Positive(n) { fmt.Println(n, "is positive") } else { fmt.Println(n, "is negative") } }

… this is just getting worse.

# Not exceptional

For the truly exceptional cases, the ones that represent either unrecoverable programming mistakes, like index out of bounds, or unrecoverable environmental problem, like running out of stack, we have `panic`

.

For all of the remaining cases, *any* error conditions that you will encounter in a Go program, are *by definition* not exceptional — you expect them because regardless of returning a boolean, an error, or pancing, it is the result of a test in *your* code.

# Forgetting to check

I consider the argument that Developers forget to check error codes

is cancelled out by the counter argument Developers forget to handle exceptions

. Either may be true, depending on the language you are basing your argument on, but neither commands a winning position.

With that said, you only need to check the error value *if you care about the result*.

Knowing the difference between which errors to ignore and which to check is why we’re paid as professionals.

# Conclusion

I have shown in the article that multiple returns and error values the simplest, and most reliable to use. Easier to use than any other form of error handling, including ones that *do not even exist* in Go as it stands today.

# A challenge

So this is the best demonstration I can come up with, but I expect others can do better, particularly where the monadic style is used. I look forward to your feedback.