Composing custom error types in F#

I strongly believe that we should keep code as referential transparent as possible. Unfortunately, F# language does not encourage programmers to use Either monad to deal with errors. The common practice in the community is using common in the rest .NET (imperative) world exception based approach. From my experienced, almost all bugs found in production are caused by unhandled exceptions. 

The problem

In our project we've used the Either monad for error handling with great success for about two years. ExtCore is a great library making dealing with Either, Reader, State and other monads and their combinations really easy. Consider a typical error handling code, which make use Choice computation expression from ExtCore:

	open System
	open ExtCore.Control
	// lower level error type, related to IO operations
	type IOError =
	| FileNotFound of string
	| AccessDenied of int
	// lower level error type, related to text parsing
	type ParseError =
	| WrongEncoding of Text.Encoding
	| Eof
	// higher level error type, combining the two above
	type Error =
	| IO of IOError
	| Parse of ParseError
	// some IO operation
	let readFile file : Choice<string, IOError> = Choice2Of2 <| FileNotFound file
	// parsing function
	let parse text : Choice<string, ParseError> = Choice2Of2 <| Eof
	// a function that returns higher level error (in contract to the two previous ones)
	let higherLevelFunc x: Choice<string, Error> = Choice1Of2 "result1"
	// higher level funtion which operate on `Error` level
	let processFile: Choice<string, Error> = choice {
	let! x = readFile "file" |> Choice.mapError IO // we have to map IOError to Error explicitely
	let! y = parse x |> Choice.mapError Parse // the same for ParseError
	let! z = higherLevelFunc y // this function returns proper `Error`, so no mapping is required
	return x + y
	}

view raw plane_choice.fs hosted with ❤ by GitHub

The code is a bit hairy because of explicit error mapping. We could introduce an operator as a synonym for Choice.mapError, like <!>, after which the code could become a bit cleaner:

	let inline (<!>) x y = Choice.mapError y x
	let processFile: Choice<string, Error> = choice {
	let! x = readFile "file" <!> IO
	let! y = parse x <!> Parse
	let! z = higherLevelFunc y
	return x + y
	}

view raw plane_choice_with_op.fs hosted with ❤ by GitHub

(actually it's the approach we use at in our team).

Rust composable errors

I was completely happy until today, when I read Error Handling in Rust article and found out how elegantly errors are composed using From trait. By implementing it for an error type, you enable auto converting lower level errors to be convertable to it by try! macro, which eliminates error mapping completely. I encourage the reader to read that article because it explains good error handling in general, it's totally applicable to F#.

Porting to F#

Unfortunately, there's no static interface implementation neither in F# nor in .NET, so we cannot just introduce IError with a static member From: 'a -> 'this, like we can in Rust. But in F# we can use statically resolved type parameters to get the result we need. The idea is that each "higher level" error type defines a bunch of static methods, each of which converts some lower level error type to one of the error type cases: 

	type IOError =
	| FileNotFound of string
	| AccessDenied of int
	type ParseError =
	| WrongEncoding of Text.Encoding
	| Eof
	type Error =
	| IO of IOError
	| Parse of ParseError
	static member From (e: IOError) = IO e
	static member From (e: ParseError) = Parse e

view raw errors_with_from.fs hosted with ❤ by GitHub

Now we can write a generic function which can create any higher level error type, which defines From methods:

	let inline convertError (source: Choice<'a, 's>) : Choice<'a, ^t> =
	match source with
	| Choice1Of2 x -> Choice1Of2 x
	| Choice2Of2 e -> Choice2Of2 (^t: (static member From: 's -> ^t) (e))

view raw convertError.fs hosted with ❤ by GitHub

Now we can rewrite our processFile function without explicit mapping to concrete error cases:

	let processFile: Choice<string, Error> = choice {
	let! x = readFile "file" |> convertError
	let! y = parse x |> convertError
	let! z = higherLevelFunc y
	return x + y
	}

view raw with_convert_error.fs hosted with ❤ by GitHub

Great. But it's still not as clean. The remaining bit is to modify Choice computation expression builder so that it can do the same implicit conversion in its Bind method (its ChoiceBuilder from ExtCore as is, but without For and While methods):

	[<Sealed>]
	type ChoiceBuilder () =
	static let zero = Choice1Of2 ()
	member inline __.Return value : Choice<'T, 'Error> = Choice1Of2 value
	[<CustomOperation("error")>]
	member inline __.Error value : Choice<'T, 'Error> = Choice2Of2 value
	member inline __.ReturnFrom (m : Choice<'T, 'Error>) = m
	member __.Zero () : Choice<unit, 'Error> = zero
	member __.Delay (generator : unit -> Choice<'T, 'Error>) : Choice<'T, 'Error> = generator ()
	member inline __.Combine (r1, r2) : Choice<'T, 'Error> =
	match r1 with
	| Choice2Of2 error -> Choice2Of2 error
	| Choice1Of2 () -> r2
	// this is where convertion is happening
	member inline __.Bind (value: Choice<'T, 'InnerE>, binder : 'T -> Choice<'U, ^E>) : Choice<'U, ^E> =
	match value with
	| Choice2Of2 e -> Choice2Of2 (^E: (static member From: 'InnerE -> ^E) (e))
	| Choice1Of2 x -> binder x
	member inline __.TryWith (body : 'T -> Choice<'U, 'Error>, handler) =
	fun value ->
	try body value
	with ex -> handler ex
	member inline __.TryFinally (body : 'T -> Choice<'U, 'Error>, handler) =
	fun value ->
	try body value
	finally handler ()
	member this.Using (resource : ('T :> System.IDisposable), body : _ -> Choice<_,_>): Choice<'U, 'Error> =
	try body resource
	finally if not <| obj.ReferenceEquals(resource, null) then resource.Dispose ()

view raw changed_choice_ce.fs hosted with ❤ by GitHub

The CE now requires all errors to be convertable to its main error type, including the error type itself, so we have to add one more From static method to Error type, and we finally can remove any noise from our processFile function:

	type Error =
	| IO of IOError
	| Parse of ParseError
	static member From (e: Error) = e
	static member From (e: IOError) = IO e
	static member From (e: ParseError) = Parse e
	let x: Choice<_, Error> = choice {
	let! x = readFile "file"
	let! y = parse x
	let! z = higherLevelFunc y
	return! Choice1Of2 <| x + y
	}

view raw final.fs hosted with ❤ by GitHub