Module Pa_lwt

module Pa_lwt : sig..end

Syntactic sugars for Lwt (deprecated)

This extension add the following sugars:

• anonymous bind:

write stdout "Hello, " >> write stdout "world!"

If you are mixing `>>` and `;`, you need to use parentheses or `begin`/`end` to get the result you expect:

write stdout "Hello, " >> (ignore (); write stdout "world!")

• lwt-binding:

lwt ch = get_char stdin in
         code

is the same as bind (get_char stdin) (fun ch -> code)

Moreover it supports parallel binding:

lwt x = do_something1 ()
         and y = do_something2 in
         code

will let do_something1 () and do_something2 () runs then bind their result to x and y. It is the same as:

let t1 = do_something1
         and t2 = do_something2 in
         bind t1 (fun x -> bind t2 (fun y -> code))

• exception catching:

try_lwt
           <expr>

,

try_lwt
           <expr>
         with
           <branches>

,

try_lwt
           <expr>
         finally
           <expr>

and:

try_lwt
           <expr>
         with
           <branches>
         finally
           <expr>

For example:

try_lwt
           f x
         with
           | Failure msg ->
               prerr_endline msg;
               return ()

is expanded to:

catch (fun _ -> f x)
           (function
              | Failure msg ->
                  prerr_endline msg;
                  return ()
              | exn ->
                  Lwt.fail exn)

Note that the exn -> Lwt.fail exn branch is automatically addedd when needed.

Note also that finally is evaluated before with if an exception is raised. This is not the case with the newer PPX extension: there, finally is always evaluated last.

The construction try_lwt <expr> just catch regular exception into lwt exception. i.e. it is the same as catch (fun _ -> <expr>) fail.

• exception raising:

raise_lwt <expr>

This allow exception to be traced when the -lwt-debug switch is passed to the syntax extension.

• assertion:

assert_lwt <expr>

• for loop:

for_lwt i = <expr> to <expr> do
          <expr>
        done

and:

for_lwt i = <expr> downto <expr> do
          <expr>
        done

• iteration over streams:

for_lwt <patt> in <expr> do
          <expr>
        done

• while loop:

while_lwt <expr> do
          <expr>
        done

• pattern matching:

match_lwt <expr> with
          | <patt_1> -> <expr_1>
          ...
          | <patt_n> -> <expr_n>