This was a question I posted on StackOverflow (Retry Computation expression or other construct in F#), and I wanted to see if there was something different people would come up with here.

I want to be able to write a computation expression in F# that will be able to retry an operation if it throws an exception. Right now my code looks like:

1
2
3
4
5

let x = retry (fun() -> GetResourceX())

let y = retry (fun() -> GetResourceY())

let z = retry (fun() -> DoThis(x, y))

etc. (this is obviously an astract representation of the actual code)

I need to be able to retry each of the functions a set number of times, which I have defined elswhere.

I was thinking a computation expression could help me here, but I don't see how it could help me remove explicitly wrapping each right hand side to a Retryable<'T>

I could see the computation expression looking something like:

1

let! x = Retryable( fun() -> GetResourceX())

etc.

I understand that Monads, in a crude fashion, are wrapper types, but I was hoping a way around this. I know I can overload an operator and have a very succinct syntax for converting an operation into a Retryable<'T>, but to me that's just making the repetition/wrapping more succinct; it's still there. I could wrap each function to be a Retryable<'T>, but once again, I don't see the value over doing what's done at the top of the post (calling retry on each operation. At least it's very explicit).

Maybe computation expressions are the wrong abstraction here, I'm not sure. Any ideas on what could be done here?

Tomas came up with an interesting use of computation expressions which use the Delay and Run functionality, but maybe there's an easier/better way of doing this that doesn't use computation expressions? Thoughts?