Computation expressions provide the syntax, but not the abstraction power, of monads. Would be nice to have full monads, but still, CE are *extremely* useful to communicate clearly in code. For example, I am now doing some asynchronous socket processing including parsing input messages and sending output messages. After musing about it for a while, I figured that what I need is the Async monad enhanced to carry a state (I want this to propagate unparsed leftover input).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

module StateAsync =
    type StateAsync<'S,'T> =
        private { Run: 'S -> Async<'T * 'S> }

    let LiftAsync a =
        let g s =
            async {
                let! x = a
                return (x, s)
            }
        { Run = g }

    let GetState =
        let g s = async.Return(s, s)
        { Run = g }

    let SetState s =
        let g _ = async.Return((), s)
        { Run = g }

    let Run { Run = f } s = f s

    let Return x =
        let g s = async.Return(x, s)
        { Run = g }

    let Bind f x =
        let g s = async.Bind(x.Run s, fun (v, s) -> (f v).Run s)
        { Run = g }

    type StateAsyncBuilder = Do with
        member this.Return x = Return x
        member this.ReturnFrom(x: StateAsync<_,_>) = x
        member this.Bind(x, f) = Bind f x
        member this.Bind(x, f) = Bind f (LiftAsync x)

With this in place, I can define for example a parser that collects all input until a delimiter (for example, to read the HTTP request head before CR LF CR LF):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

let readUntil (delimiter: string) (read: Async<string>) =
    let rec loop acc (input: string) =
        StateAsync.Do {
            match input.IndexOf(delimiter) with
            | -1 ->
                let! x = read
                return! loop (input :: acc) x
            | k ->
                let result =
                    input.Substring(k) :: acc
                    |> List.rev
                    |> String.concat ""
                let leftover = input.Substring(k + delimiter.Length)
                do! StateAsync.SetState leftover
                return result
        }
    StateAsync.Do {
        let! state = StateAsync.GetState
        do! StateAsync.SetState ""
        return! loop [] state
    }

Naturally, there are different ways to write this but the CE syntax helps making the purpose clear, and also helps reasoning about the code.

Typically you don't need to create your own as the built-in ones or those that are part of a framework (such as WebSharper) are all that you would need.
Occasionally, you do have a need. I created one to manage COM object references from F#:

[link:fwaris.wordpress.com] .

I believe it important to *understand* how to create computational expressions because that will give you deeper insights into functional programming (consider it a rite of passage for F#).

When starting with computational expression look at the boilerplate implementation in the F# spec (section 6.3.10 ):

[link:research.microsoft.com]

I've been using F# for at least 2 years and haven't yet come across a need for creating my own computation expression. That could be due to a) the domain in which I work and b) the fact that you can invariably express the same concept other ways (in that sense, CEs are merely a syntactic convenience). I think they're less important in an impure functional language--obviously a language like Haskell couldn't do much without monads.