.

Check out the formatting tips on the right for help formatting and making links.

Use the template below:

Summary

How to mix imperative code and bindings, and related topics

People frequently want to write code that contains embedded actions (also called statements, i.e. the code is imperative - in F# these are just expressions that return the type "unit", which is here essentially equivalent to the type "void"). Here are some guidelines for which constructs to use to write that code.

• Most the time you will be writing an expression, e.g. part of the body of a function. Then just use

   <statement>;
   <statement>;
   <statement>

("<statement>" is an expression with type "unit" - i.e. "void").

• You can mix this with binding variables, e.g.

   let f x = 
     <statement>;
     let y = <expression> in 
     let z = <expression> in 
     <statement>;
     <expr>

In terms of cost each "let" binding is just like declaring a local in C# with some initialization code. That is, multiple "let/in" pairs are not expensive, and nor is nesting them.

• If necessary use a begin/end or parentheses to disambiguate. This is especially needed for if/then/else

   if x then (
     <statement>;
     <statement>
   ) else (
     <statement>;
     <statement>
   )


   if x then begin 
     <statement>;
     <statement>
   end else begin
     <statement>;
     <statement>
   end

• You may also need this at "match" and "try" calls, i.e. any construct that has a dangling expression, e.g.

  begin match x with 
  | A -> 
     <statement>;
  | B -> 
     <statement>;
  end;
  <statement>

• Within expressions some people use

   let _ = <statement> in 
   let _ = <statement> in

• If you need to do imperative actions after an object constructor use "then":

   type C = 
     class
       val id: string
       new(id) = 
            { id = id }
          then 
            printf "the object has been initialized\n"

• At the top level of a module (where you're writing a declaration, not an expression) you can prefix each action by "do" or "let _ = ". You can also write plain, naked expressions but ONLY if the previous declaration was terminated by a ";;" - this is typically only used for scripts.

   do <statement> 
   let _ = <statement>
   let x = 1;;
   x+x;;

• If you want to perform actions as part of the specification of a set of recursive bindings then use "do" bindings (they are resolved according to the rules at http://research.microsoft.com/projects/ilx/fsharp-manual/advanced.aspx#ReactiveRecursion). This is rarely used, though very useful when needed.