Imperative Programming

Imperative Programming
A
s you saw in Chapter 3, you can use F# for pure functional programming. However, some
issues, most notably I/O, are almost impossible to address without some kind of state change.
F# does not require that you program in a stateless fashion. It allows you to use
mutable
identifiers whose values can change over time. F# also has other constructs that support
imperative programming. You’ve already seen some in Chapter 3. Any example that wrote to
the console included a few lines of imperative code alongside functional code. In this chapter,
you’ll explore these constructs, and many others, in much more detail.
First, you’ll look at F#’s
unit type, a special type that means “no value,” which enables
some aspects of imperative programming. Next, you’ll look at some of the ways F# can handle
mutable state, that is, types whose values can change over time. These are the ref type, muta-
ble record types, and arrays. Finally, you’ll look at using .NET libraries. The topics will include
calling static methods, creating objects and working with their members, using special mem-
bers such as indexers and events, and using the F# |> operator, which is handy when dealing
with .NET libraries.
The unit Type
Any function that does not accept or return values is of type unit, which is similar to the type
void in C# and System.Void in the CLR. To a functional programmer, a function that doesn’t
accept or return a value might not seem interesting, since if it doesn’t accept or return a value, it
does nothing. I
n the imperative paradigm, you know that side effects exist, so even if a function
accepts or returns nothing, you know it can still have its uses. The unit type is represented as a
literal value, a pair of parentheses (
()). This means that whenever you want a function that
doesn’t take or return a value, you just put
() in the code:
#light
let main() =

()
I
n this example,
main is a function because y
ou placed parentheses after the identifier,
where its parameters would go. If you didn’t this, it would mean
main is not a function and
instead just a value that is not a function. As you know, all functions are values, but here the
difference between a function and a nonfunction value is important. If
main were a nonfunc-
tion value, the expressions within it would be evaluated only once. Since it is a function, the
expressions will be evaluated each time it is called.
55
CHAPTER 4
■ ■ ■
7575Ch04.qxp 4/27/07 1:00 PM Page 55
■
Caution
Just because a function is named
main
doesn’t mean it is the entry point of the program and is
executed automatically. If you wanted your main function to be executed, then you would need to add a call
to
main()
at the end of the source file. Chapter 6 details exactly how the entry point is determined for an
F# program.
Similarly, by placing () after the equals sign, you tell the compiler you are going to return
nothing. Ordinarily, you need to put something between the equals sign and the empty paren-
theses, or the function is pointless; however, for the sake of keeping things simple, I’ll leave
this function pointless. Now you’ll see the type of main by using the fsc –i switch; the results

of this are as follows. (I explained the notation used by the compiler’s
–i switch in Chapter 3’s
“Types and Type Inference.”) As you can see, the type of
main is a function that accepts unit
and transforms it into a value of type unit:
val main : unit -> unit
Because the compiler now knows the function doesn’t return anything, you can now use it
with some special imperative constructs. To call the function, you can use the
let keyword fol-
lowed by a pair of parentheses and the equals sign. This is a special use of the
let keyword,
which means “call a function that does not return a value.” Alternatively, you can simply call
the function without any extra keywords at all:
#light
let () = main()
// -- or --
main()
Similarly, you can chain functions that return unit together within a function—simply
make sure they all share the same indentation. The next example shows several
print_endline
functions chained together to print text to the console:
#light
let poem() =
print_endline "I wandered lonely as a cloud"
print_endline "That floats on high o'er vales and hills,"
print_endline "When all at once I saw a crowd,"
print_endline "A host, of golden daffodils"
poem()
It’s not quite true that the only functions that return unit type can be used in this manner;
however, using them with a type other than

unit will generate a warning, which is something
most programmers want to av
oid. S
o
, to avoid this, it’s sometimes useful to turn a function
that does return a value into a function of type
unit, typically because it has a side effect. The
need to do this is fairly r
are when just using F# libraries written in F# (although situations
where it is useful do exist), but it is mor
e common when using .NET libr
ar
ies that w
ere not
written in F#.
CHAPTER 4
■
IMPERATIVE PROGRAMMING
56
7575Ch04.qxp 4/27/07 1:00 PM Page 56
The next example shows how to turn a function that returns a value into a function that
r
eturns
u
nit
:
#light
let getShorty() = "shorty"
let _ = getShorty()
// -- or --

ignore(getShorty())
// -- or --
getShorty() |> ignore
First you define the function getShorty, which returns a string. Now imagine, for what-
ever reason, you want to call this function and ignore its result. The next two lines
demonstrate different ways to do this. First, you can use a
let expression with an underscore
(
_) character in place of the identifier. The underscore tells the compiler this is a value in
which you aren’t interested. Second, this is such a common thing to do that it has been
wrapped into a function,
ignore, which is available in the F# base libraries and is demon-
strated on the third line. The final line shows an alternative way of calling
ignore using the
pass-forward operator to pass the result of
getShorty() to the ignore function. I explain the
pass-forward operator in the “The |> Operator” section.
The mutable Keyword
In Chapter 3 I talked about how you could bind identifiers to values using the keyword let and
noted how under some circumstances you could redefine and rebound, but not modify, these
identifiers. If you want to define an identifier whose value can change over time, you can do
this using the
mutable keyword. A special operator, the left ASCII arrow (or just left arrow), is
composed of a less-than sign and a dash (
<-) and is used to update these identifiers. An update
operation using the left arrow has type
unit, so you can chain these operations together as dis-
cussed in the previous section. The next example demonstrates defining a mutable identifier of
type
string and then changing the changing the value it holds:

#light
let mutable phrase = "How can I be sure, "
print_endline phrase
phrase <- "In a world that's constantly changing"
print_endline phrase
The results ar
e as follo
ws:
How can I be sure,
In a world that's constantly changing
At first glance this doesn’t look too different from redefining an identifier, but it has a couple
of key differ
ences. When you use the left arrow to update a mutable identifier, you can change its
value but not its type—when y
ou r
edefine an identifier
, y
ou can do both. A compile error is pro-
duced if you try to change the type; the next example demonstrates this:
CHAPTER 4
■
IMPERATIVE PROGRAMMING
57
7575Ch04.qxp 4/27/07 1:00 PM Page 57
#light
let mutable number = "one"
phrase <- 1
When attempting to compile this code, you’ll get the following error message:
Prog.fs(9,10): error: FS0001: This expression has type
int

but is here used with type
string
The other major difference is where these changes are visible. When you redefine an iden-
tifier, the change is visible only within the scope of the new identifier. When it passes out of
scope, it reverts to its old value. This is not the case with mutable identifiers. Any changes are
permanent, whatever the scope. The next example demonstrates this:
#light
let redefineX() =
let x = "One"
printfn "Redefining:\r\nx = %s" x
if true then
let x = "Two"
printfn "x = %s" x
else ()
printfn "x = %s" x
let mutableX() =
let mutable x = "One"
printfn "Mutating:\r\nx = %s" x
if true then
x <- "Two"
printfn "x = %s" x
else ()
printfn "x = %s" x
redefineX()
mutableX()
The results are as follows:
Redefining:
x = One
x = Two
x = One

Mutating:
x = One
x = Two
x = Two
CHAPTER 4
■
IMPERATIVE PROGRAMMING
58
7575Ch04.qxp 4/27/07 1:00 PM Page 58
Identifiers defined as mutable are somewhat limited because they can’t be used within a
s
ubfunction. You can see this in the next example:
#light
let mutableY() =
let mutable y = "One"
printfn "Mutating:\r\nx = %s" y
let f() =
y <- "Two"
printfn "x = %s" y
f()
printfn "x = %s" y
The results of this example, when compiled and executed, are as follows:
Prog.fs(35,16): error: The mutable variable 'y' has escaped its scope. Mutable
variables may not be used within an inner subroutine. You may need to use a heap-
allocated mutable reference cell instead, see 'ref' and '!'.
As the error messages says, this is why the ref type, a special type of mutable record, has
been made available—to handle mutable variables that need to be shared among several
functions. I discuss mutable records in the next section and the
ref type in the section after
that.

Defining Mutable Record Types
In Chapter 3, when you first met record types, I did not discuss how to update their fields. This
is because record types are immutable by default. F# provides special syntax to allow the fields
in record types to be updated. You do this by using the keyword
mutable before the field in a
record type. I should emphasize that this operation changes the contents of the record’s field
rather than changing the record itself.
#light
type Couple = { her : string ; mutable him : string }
let theCouple = { her = "Elizabeth Taylor " ; him = "Nicky Hilton" }
let print o = printf "%A\r\n" o
let changeCouple() =
print theCouple;
theCouple.him <- "Michael Wilding";
print theCouple;
theCouple.him <- "Michael Todd";
print theCouple;
theCouple.him <- "Eddie Fisher";
print theCouple;
CHAPTER 4
■
IMPERATIVE PROGRAMMING
59
7575Ch04.qxp 4/27/07 1:00 PM Page 59
theCouple.him <- "Richard Burton";
print theCouple;
theCouple.him <- "Richard Burton";
print theCouple;
theCouple.him <- "John Warner";
print theCouple;

theCouple.him <- "Larry Fortensky";
print theCouple
changeCouple()
The results are as follows:
{her = "Elizabeth Taylor "; him = "Nicky Hilton"}
{her = "Elizabeth Taylor "; him = "Michael Wilding"}
{her = "Elizabeth Taylor "; him = "Michael Todd"}
{her = "Elizabeth Taylor "; him = "Eddie Fisher"}
{her = "Elizabeth Taylor "; him = "Richard Burton"}
{her = "Elizabeth Taylor "; him = "Richard Burton"}
{her = "Elizabeth Taylor "; him = "John Warner"}
{her = "Elizabeth Taylor "; him = "Larry Fortensky"}
This example shows a mutable record in action. A type, couple, is defined where the field
him is mutable but the field her is not. Next, an instance of couple is initialized, and then you
change the value of
him many times, each time displaying the results. I should note that the
mutable keyword applies per field, so any attempt to update a field that is not mutable will
result in a compile error; for example, the next example will fail on the second line:
#light
theCouple.her <- "Sybil Williams";
print_any theCouple
When attempting to compile this program, you’ll get the following error message:
prog.fs(2,4): error: FS0005: This field is not mutable
The ref Type
The ref type
is a simple way for a program to use mutable state, that is, values that change
over time. The
ref type is just a record type with a single mutable field that is defined in the F#
libraries. Some operators are defined to make accessing and updating the field as straightfor-
ward as possible. F#’s definition of the

ref type uses type parameterization, a concept
introduced in the previous chapter, so although the value of the
ref type can be of any type,
you cannot change the type of the value once you have created an instance of the value.
CHAPTER 4
■
IMPERATIVE PROGRAMMING
60
7575Ch04.qxp 4/27/07 1:00 PM Page 60
Creating a new instance of the ref type is easy; you use the keyword ref followed by what-
ever item represents the value of
ref. The next example is the compiler’s output (using the –i
option, which shows that the type of phrase is string ref, meaning a reference type that can
contain only strings):
l
et phrase = ref "Inconsistency"
val phrase : string ref
This syntax is similar to defining a union type’s constructors, also shown in the previous
chapter. The
ref type has two built-in operators to access it; the exclamation point (!) pro-
vides access to the value of the reference type, and an operator composed of a colon followed
by an equals sign (
:=) provides for updating it. The ! operator always returns a value of the
type of the contents of the
ref type, known to the compiler thanks to type parameterization.
The
:= operator has type unit, because it doesn’t return anything.
The next example shows how to use a
ref type to total the contents of an array. On the
third line of

totalArray, you see the creation of the ref type. In this case, it is initialized to
hold the value
0. On the fifth line, you see the ref type being both accessed and updated. First,
! is used to access the value with the ref type; then, after it has been added to the current
value held in the array, the value of the
ref type is updated through the use of the := operator.
Now the code will correctly print
6 to the console.
#light
let totalArray () =
let a = [| 1; 2; 3 |]
let x = ref 0
for n in a do
x := !x + n
print_int !x
print_newline()
totalArray()
The result is as follows:
6
■
Caution
If you are used to programming in one of the C family of programming languages, you should
be careful here. When reading F# code, it is quite easy to misinterpret the
ref
type’s
!
operator as a Boolean
“not” operator. F# uses a function called
not
for Boolean “not” operations.

CHAPTER 4
■
IMPERATIVE PROGRAMMING
61
7575Ch04.qxp 4/27/07 1:00 PM Page 61
The ref type is a useful way to share mutable values between several functions. An identi-
fier can be bound to a
ref type defined in scope that is common to all functions that want to
use the value; then the functions can use the value of the identifier as they like, changing it or
merely reading it. Because in F# functions can be passed around as if they were values, every-
where the function goes, the value follows it. This process is known as
capturing a local or
creating a closure. The next example demonstrates this by defining three functions, inc, dec,
and
show, which all share a common ref type holding an integer. The functions inc, dec, and
show are all defined in their own private scopes and then returned to the top level as a tuple so
they are visible everywhere. Note how
n is not returned; it remains private, but inc, dec, and
show are all still able to access n. This is a useful technique for controlling what operations can
take place on mutable data.
#light
let inc, dec, show =
let n = ref 0
let inc () =
n := !n + 1
let dec () =
n := !n - 1
let show () =
print_int !n
inc, dec, show

inc()
inc()
dec()
show()
The result is as follows:
1
Arrays
Arrays are a concept that most programmers are familiar with, since almost all programming
languages have some sor
t of arr
ay type
. The F# array type is based on the BCL
System.Array
type, so anyone who has used in arrays in C# or Visual Basic will find that the underlying con-
cepts are the same.
Arrays ar
e a mutable collection type in F#. Arr
ays are the opposite of lists, discussed in
Chapter 3. The values within arrays are updatable, whereas lists are not, and lists can grow
dynamically, whereas arrays cannot. One-dimensional arrays are sometimes referred to as
v
ectors
, and multidimensional arr
ays are sometimes called
matrices. Arr
ays are defined by a
sequence of items separated by semicolons (
;) and delimited by an opening square bracket
and a vertical bar (
[|) and a closing bar and square bracket (|]). The syntax for referencing an

array element is the name of the identifier of the arr
ay follo
wed by period (
.) and then the
index of the element in square brackets (
[]). The syntax for retrieving the value of an element
CHAPTER 4
■
IMPERATIVE PROGRAMMING
62
7575Ch04.qxp 4/27/07 1:00 PM Page 62
stops there. The syntax for setting the value of an element is the left arrow (<-) followed by the
value to be assigned to the element.
The next example shows an array being read from and written to. First an array,
rhymeAr-
ray
, is defined, and then you read all the members from it. Then you insert new values into the
array, and finally you print out all the values you have.
#light
let rhymeArray =
[| "Went to market" ;
"Stayed home" ;
"Had roast beef" ;
"Had none" |]
let firstPiggy = rhymeArray.[0]
let secondPiggy = rhymeArray.[1]
let thirdPiggy = rhymeArray.[2]
let fourthPiggy = rhymeArray.[3]
rhymeArray.[0] <- "Wee,"
rhymeArray.[1] <- "wee,"

rhymeArray.[2] <- "wee,"
rhymeArray.[3] <- "all the way home"
print_endline firstPiggy
print_endline secondPiggy
print_endline thirdPiggy
print_endline fourthPiggy
print_any rhymeArray
The results of this example, when compiled and executed, are as follows:
Went to market
Stayed home
Had roast beef
Had none
[|"Wee,"; "wee,"; "wee,"; "all the way home"|]
Arr
ays, like lists, use type parameterization, so the type of the array is the type of its con-
tents followed by the array’s type, so
rhymeArray has type string array, which may also be
written
string[].
M
ultidimensional arr
ays in F# come in two slightly different flavors, jagged and rectangu-
lar.
J
agged
arrays
, as the name suggests, are arrays where the second dimension is not a
r
egular shape
.

They ar
e simply arrays whose contents happen to other arr
ays, and the length
of the inner arrays is not forced to be the same. In
rectangular arrays, all inner arrays are of the
same length; in fact, ther
e is really no concept of an inner array since the whole array is just
the same object.
The method of getting and setting items in the two differ
ent types of arr
ays
differs slightly
.
CHAPTER 4
■
IMPERATIVE PROGRAMMING
63
7575Ch04.qxp 4/27/07 1:00 PM Page 63
For jagged arrays, you use the period followed by the index in parentheses, but you have
t
o use this twice (one time for each dimension), because the first time you get back the inner
array and the second time you get the element within it.
The next example demonstrates a simple jagged array, called jagged. The array members
are accessed in two different ways. The first inner array (at index
0) is assigned to the identifier
singleDim, and then its first element is assigned to itemOne. On the fourth line, the first ele-
ment of the second inner array is assigned to
itemTwo, using one line of code.
#light
let jagged = [| [| "one" |] ; [| "two" ; "three" |] |]

let singleDim = jagged.[0]
let itemOne = singleDim.[0]
let itemTwo = jagged.[1].[0]
printfn "%s %s" itemOne itemTwo
The results of this example, when compiled and executed, are as follows:
one two
To reference elements in rectangular arrays, use a period (.) followed by all the indexes in
square brackets, separated by commas. Unlike jagged arrays, which are multidimensional but
can be defined using the same (
[||]) syntax as single-dimensional arrays, you must create
rectangular arrays with the
create function of the Array2 and Array3 modules, which support
two- and three-dimensional arrays, respectively. This doesn’t mean rectangular arrays are lim-
ited to three dimensions, because it’s possible to use the
System.Array class to create
rectangular arrays with more than three dimensions; however, creating such arrays should be
considered carefully, because adding extra dimensions can quickly lead to very large objects.
The next example creates a rectangular array,
square. Then its elements are populated
with the integers 1, 2, 3, and 4.
#light
let square = Array2.create 2 2 0
square.[0,0] <- 1
square.[0,1] <- 2
square.[1,0] <- 3
square.[1,1] <- 4
printf "%A\r\n" square
Now let’s look at the differences between jagged and rectangular arrays. First create a
jagged arr
ay to represent Pascal’s Triangle:

#light
let pascalsTriangle = [|
[|1|];
[|1; 1|];
[|1; 2; 1|];
[|1; 3; 3; 1|];
CHAPTER 4
■
IMPERATIVE PROGRAMMING
64
7575Ch04.qxp 4/27/07 1:00 PM Page 64