Check out the formatting tips on the right for help formatting and making links.
Use the template below:
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;;
