Some Thoughts About Error Handling

Guidelines

If you want to support error handling, then the semantics should be enforced by the static type system. That usually means returning some kind of tagged union that the static type system understands. This should make it impossible to use the returned value without specifying what to do if there's an error.

If you don't want to support error handling, then you shouldn't allow it at all. That usually means throwing an undocumented exception that isn't part of the method's contract. This should make it possible to refactor the code or fix bugs without a breaking change.

Error handling should probably be supported for IO and parsing, because that kind of logic tends to fail even if the code is correct. But error handling probably shouldn't be supported for bugs. Bugs tend to put the process into an undefined state that can only be addressed by killing the process.

Comments

Methods can accept a pair of continuation parameters (one for the happy path, and one for the unhappy path) instead of returning a tagged union. The two approaches are basically equivalent. Often the unhappy path is short, because the caller chooses to throw the relevant error instead of handling it.

If you're tempted to throw an exception because a pure precondition was violated, then you probably failed to properly express that precondition as a parameter type. To offer a contrived example: The static type system can prevent division-by-zero errors if you use a NonZeroInt type as the second parameter of a division method. If you're implementing a type like NonZeroInt, though, then you probably want to support error handling for the relevant precondition in a factory method.

If you're tempted to express an impure precondition as a parameter type, then you're probably better off with support for error handling instead. To offer another contrived example: You can create a type called PathToFileThatExists, and use it as the first parameter of a file reading method, but the name is misleading. The file won't necessarily exist by the time you invoke the file reading method, so you still need to account for the unhappy possibility of a missing file.

Appendix

// This is one way to support error handling for a pure precondition in a factory method.                                                                 
public class NonZeroInt {                                                                                                                                 
    public int Value { get; }                                                                                                                             
    public static TResult From<TResult>(int arg, Func<NonZeroInt, TResult> happy, Func<ArgumentOutOfRangeException, TResult> unhappy) { 
        return (arg == 0) ? unhappy(new ArgumentOutOfRangeException(nameof(arg))) : happy(new NonZeroInt(arg));                                           
    }                                                                                                                                                     
    private NonZeroInt(int value) { Value = value; }                                                                                                      
}                                                                                                                                                         
                                                                                                                                                          
// Error handling isn't needed here because this method can't fail.                                                                                       
public static class MathUtils {                                                                                                                           
    public static int Divide(int lhs, NonZeroInt rhs) { return lhs / rhs.Value; }                                                                         
}                                                                                                                                                         
                                                                                                                                                          
// You generally want to support error handling for impure preconditions.                                                                                 
public interface IFileSystem {                                                                                                                            
    Task<TaggedUnion<IReadOnlyList<byte>, FileNotFoundException>> ReadFile(string path);                                                
}