Back to Questions
919
views1
comment
Computation expressions: Why is "return" implictly added after the last do! ?
f#

Hi,

I'm trying to understand computation expressions. I have had problem implementing an imperative builder that implements the semantics of "return" as seen in C-like languages.

My problem is that it seems return statements are implicitly added. In other words:

1
2
3
4
5
6

imperative {
  ...
  while true do
    do! ...
  ...
}

becomes:

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

imperative {


  ...


  while true do


    do! ...
    return ()


  ...


}

The problem is that the extra return would cause the entire imperative block to be exited.

To confirm the addition of the extra "return", you can use this code:

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

type M =
    | Delay of (unit -> M)
    | Bind of M * (unit -> M)
    | Return of obj
    | ReturnFrom of M
    | Combine of M * M
    | Zero
    | TryWith of M * (System.Exception -> M)
    | TryFinally of M * (unit -> unit)
    | While of (unit -> bool) * M
    | For of (obj seq) * (obj -> M)

type DummyBuilder() =                
    member x.Bind(e, f) =
        Bind(e, f)

    member x.Return(r) =
        Return r

    member x.ReturnFrom(r) =
        ReturnFrom r

    member x.Combine(e1, e2) =
        Combine(e1, e2)

    member x.Delay(f) =
        Delay f

    member x.Zero() =
        Zero
    
    member x.TryWith(e, h) =
        TryWith(e, h)

    member x.TryFinally(e, c) =
        TryFinally(e, c)

    member x.While(cond, body) =
        While(cond, body)

    member x.For(objs, body) =
        For(objs, body)

let debug = DummyBuilder()

let rec trace indent m : string list =
    let wrap (kw : string) (sub : string list) : string list =
        (sprintf "%sBEGIN %s" indent kw) :: sub @ [sprintf "%sEND %s" indent kw]

    match m with
    | Delay f ->
        let f' = f() |> trace (indent + " ")
        wrap "Delay" f'

    | Bind(e, f) ->
        let f' = f() |> trace (indent + " ")
        let e' = e |> trace (indent + " ")
        wrap "Bind" (("e:" :: e') @ ("fun() ->" :: f'))

    | Combine(e1, e2) ->
        let e1' = e1 |> trace (indent + " ")
        let e2' = e2 |> trace (indent + " ")
        wrap "Combine" (e1' @ e2')

    | Return(v) ->
        wrap "Return" [sprintf "%s %A" indent v]

    | ReturnFrom(e) ->
        let e' = e |> trace (indent + " ")
        wrap "ReturnFrom" e'

    | For(objs, f) ->
        let objs' = sprintf "%A" objs
        let f' = f() |> trace (indent + " ")
        wrap "For" (objs' :: f')

    | TryFinally(e, f) ->
        e
        |> trace (indent + " ")
        |> wrap "TryFinally"

    | TryWith(e, h) ->
        e
        |> trace (indent + " ")
        |> wrap "TryWith"

    | While(cond, body) ->
        body
        |> trace (indent + " ")
        |> wrap "While"

    | Zero -> wrap "Zero" []


let f() =
    let d = debug {
        while true do
            do! debug {
                return 123
            }
    }

    let s = trace "" d

    for d in s do printfn "%s" d;;

f() prints:

BEGIN Delay
BEGIN While
BEGIN Delay
BEGIN Bind
e:
BEGIN Delay
BEGIN Return
123
END Return
END Delay
fun() ->
BEGIN Return
<null>
END Return
END Bind
END Delay
END While
END Delay

Edit: code also available there:

[link:bitbucket.org]

At the top of the file.

.

As far as I can tell, this is because 

1
2

  do! e
  ...

is just shorthand for

1
2

  let! (_:unit) = e
  ...

Therefore, you should never end a block with just a do! - this would be equivalent to a let! binding without a body. However, the F# compiler seems to give you added flexibility by implicitly inserting a return () in the do! case to make the syntax work (although the spec doesn't seem to call out this behavior).

You might get better results by trying

1
2

  do! e
  ()

which will use your Zero method instead of Return.

By on 1/8/2011 10:13 AM ()

    Topic tags

    IntelliFactory Offices Copyright (c) 2011-2012 IntelliFactory. All rights reserved.
    Home | Products | Consulting | Trainings | Blogs | Jobs | Contact Us | Terms of Use | Privacy Policy | Cookie Policy     		Built with WebSharper