Question

I’ working on a basic 2D CAD engine and the pipeline operator significantly improved my code. Basically several functions start with a point (x,y) in space and compute a final position after a number of move operations:

let finalPosition =
    startingPosition
    |> moveByLengthAndAngle x1 a1 
    |> moveByXandY x2 y2
    |> moveByXandAngle x3 a3
    |> moveByLengthAndAngle x4 a4
    // etc...

This is incredibly easy to read and I’d like to keep it that way. The various x1, a1, etc. obviously have a meaning name in the real code.

Now the new requirement is to introduce exception handling. A big try/with around the whole operation chain is not enough because I’d like to know which line caused the exception. I need to know which argument is invalid, so that the user knows what parameter must be changed.

For example if the first line (moveByLengthAndAngle x1 a1) raises an exception, I’d like to tell something like “Hey, -90 is an invalid value for a1! a1 must be between 45 and 90!”. Given that many operations of the same type can be used in the sequence it’s not enough to define a different exception type for each operation (in this example I wouldn’t be able to tell if the error was the first or the last move).

The obvious solution would be to split the chain in single let statements, each within its respective try/with. This however would make my beautiful and readable code a bit messy, not so readable anymore.

Is there a way to satisfy this requirement without sacrificing the readability and elegance of the current code?

(note. right now every moveBy function raises an exception in case of errors, but I’m free to change for ex. to return an option, a bigger tuple, or just anything else if needed).

Answer 1

How about folding over Choices? Let’s say that instead of pipelining the actions, you represent them like this:

let startingPosition = 0. ,0.

let moveByLengthAndAngle l a (x,y) = x,y // too lazy to do the math
let moveByXandY dx dy (x,y) = 
    //failwith "oops"
    x+dx, y+dy
let moveByXandAngle dx a (x,y) = x+dx, y

let actions = 
    [
        moveByLengthAndAngle 0. 0., "failed first moveByLengthAndAngle"
        moveByXandY 1. 2., "failed moveByXandY"
        moveByXandY 3. 4., "failed moveByXandY"
        moveByXandAngle 3. 4., "failed moveByXandAngle"
        moveByLengthAndAngle 4. 5., "failed second moveByLengthAndAngle"
    ]

i.e. actions is of type ((float * float -> float * float) * string) list.

Now, using FSharpx we lift the actions to Choice and fold/bind (not sure how to call it this is similar to foldM in Haskell) over the actions:

let folder position (f,message) =
    Choice.bind (Choice.protect f >> Choice.mapSecond (konst message)) position

let finalPosition = List.fold folder (Choice1Of2 startingPosition) actions

finalPosition is of type Choice<float * float, string> , i.e. it’s either the final result of all those functions, or an error (as defined in the table above).

Explanation for this last snippet:

• Choice.protect is similar to Tomas’ protect, except that when it finds an exception, it returns the exception wrapped in a Choice2Of2. When there’s no exception, it returns the result wrapped in a Choice1Of2.
• Choice.mapSecond changes this potential exception in Choice2Of2 with the error message defined in the table of actions. Instead of (konst message) this could also be a function that builds the error message using the exception.
• Choice.bind runs this “protected” action against the current position. It will not run the actual action if the current position is in error (i.e. a Choice2Of2).
• Finally, the fold applies all actions threading along / accumulating the resulting Choice (either the current position or an error).

So now we just have to pattern match to handle each case (correct result or error):

match finalPosition with
| Choice1Of2 (x,y) -> 
    printfn "final position: %f,%f" x y
| Choice2Of2 error -> 
    printfn "error: %s" error

If you uncomment failwith "oops" above, finalPosition will be a Choice2Of2 "failed moveByXandY"