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 nils and nilness 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.