Simple for loops are the most efficient way to iterate over integer ranges. This is illustrated here by a replacement implementation of the repeatFetch function from Chapter 2:

let repeatFetch url n =
    for i = 1 to n do
        let html = http url
        printf "fetched <<< %s >>>
" html
    printf "Done!
"

This loop is executed for successive values of i over the given range, including both start and end indexes.

The second looping construct is a while loop, which repeats until a given guard is false. For example, here is a way to keep your computer busy until the weekend:

open System

let loopUntilSaturday() =
    while (DateTime.Now.DayOfWeek <> DayOfWeek.Saturday) do
        printf "Still working!
"

    printf "Saturday at last!
"

When executing this code in F# Interactive, you can interrupt its execution by using Ctrl+C.

As discussed in Chapter 3, any values compatible with the type seq<type> can be iterated using the for pattern in seq do ... construct. The input seq may be an F# list value, any seq<type>, or a value of any type supporting a GetEnumerator method. Here are some simple examples:

> for (b,pj) in [ ("Banana 1",true); ("Banana 2",false) ] do
      if pj then printfn "%s is in pyjamas today!" b;;
Banana 1 is in pyjamas today!

The following example iterates the results of a regular expression match. The type returned by the .NET method System.Text.RegularExpressions.Regex.Matches is a MatchCollection, which for reasons known best to the .NET designers doesn't directly support the seq<Match> interface. It does, however, support a GetEnumerator method that permits iteration over the individual results of the operation, each of which is of type Match; the F# compiler inserts the conversions necessary to view the collection as a seq<Match> and perform the iteration. You learn more about using the .NET Regular Expression library in Chapter 10:

> open System.Text.RegularExpressions;;
> for m in (Regex.Matches("All the Pretty Horses","[a-zA-Z]+")) do
      printf "res = %s
" m.Value;;
res = All
res = the
res = Pretty
res = Horses

One particularly useful mutable record is the general-purpose type of mutable reference cells, or ref cells for short. These often play much the same role as pointers in other imperative programming languages. You can see how to use mutable reference cells in the following example:

> let cell1 = ref 1;;
val cell1 : int ref = {contents = 1;}

> !cell1;;
val it : int = 1

> cell1 := 3;;
val it : unit = ()

> cell1;;
val it : int ref = {contents = 3;}

> !cell1;;
val it : int = 3

The key type is 'T ref, and its main operators are ref, !, and :=. The types of these operators are as follows:

val ref  : 'T -> 'T ref
val (:=) : 'T ref -> 'T -> unit
val (!)  : 'T ref -> 'T

These allocate a reference cell, mutate the cell, and read the cell, respectively. The operation cell1 := 3 is the key one; after this operation, the value returned by evaluating the expression !cell1 is changed. You can also use either the contents field or the Value property to access the value of a reference cell.

Both the 'T ref type and its operations are defined in the F# library as simple record data structures with a single mutable field:

type 'T ref = { mutable contents: 'T }
let (!) r = r.contents
let (:=) r v = r.contents <- v
let ref v = { contents = v }

The type 'T ref is a synonym for a type Microsoft.FSharp.Core.Ref<'T> defined in this way.

val add : Table<'Key,'Value> -> 'Key -> 'Value -> unit

member Add : 'Key * 'Value -> unit

val add : 'Key -> 'Value -> Table<'Key,'Value> -> Table<'Key,'Value>

member Add : 'Key * 'Value -> Table<'Key,'Value>

Like all mutable data structures, two mutable record values or two values of type 'T ref may refer to the same reference cell—this is called aliasing. Aliasing of immutable data structures isn't a problem; no client consuming or inspecting the data values can detect that the values have been aliased. However, aliasing of mutable data can lead to problems in understanding code. In general, it's good practice to ensure that no two values currently in scope directly alias the same mutable data structures. The following example continues from earlier and shows how an update to cell1 can affect the value returned by !cell2:

> let cell2 = cell1;;
val cell2 : int ref = {contents = 3;}

> !cell2;;
val it : int = 3

> cell1 := 7;;
val it : unit = ()

> !cell2;;
val it : int 7

Mutable data is often hidden behind an encapsulation boundary. Chapter 7 looks at encapsulation in more detail, but one easy way to do this is to make data private to a function. For example, the following shows how to hide a mutable reference within the inner closure of values referenced by a function value:

let generateStamp =
    let count = ref 0
    (fun () -> count := !count + 1; !count)

val generateStamp: unit -> int

The line let count = ref 0 is executed once, when the generateStamp function is defined. Here is an example of the use of this function:

> generateStamp();;
val it : int = 1

> generateStamp();;
val it : int = 2

This is a powerful technique for hiding and encapsulating mutable state without resorting to writing new type and class definitions. It's good programming practice in polished code to ensure that all related items of mutable state are collected under some named data structure or other entity such as a function.

In Chapter 3, you saw in passing that you can use sequence expressions as a way to generate interesting array values. For example:

> let arr = [| for i in 0 .. 5 -> (i,i*i) |];;
val arr : (int * int) [] =
  [|(0, 0); (1, 1); (2, 4); (3, 9); (4, 16); (5, 25)|]

You can also use a convenient syntax for extracting subarrays from existing arrays; this is called slice notation. A slice expression for a single-dimensional array has the form arr.[start..finish], where one of start and finish may optionally be omitted, and index zero or the index of the last element of the array is assumed instead. For example:

> let arr = [| for i in 0 .. 5 -> (i,i*i) |];;
val arr : (int * int) [] =
  [|(0, 0); (1, 1); (2, 4); (3, 9); (4, 16); (5, 25)|]

> arr.[1..3];;
val it : (int * int) [] = [| (1, 1); (2, 4); (3, 9); |]

> arr.[..2];;
val it : (int * int) [] = [| (0, 0); (1, 1); (2, 4); |]

> arr.[3..];;
val it : (int * int) [] = [| (3, 9); (4, 16); (5, 25) |]

Slicing syntax is used extensively in the example "Verifying Circuits with Propositional Logic" in Chapter 12. You can also use slicing syntax with strings and several other F# types such as vectors and matrices, and the operator can be overloaded to work with your own type definitions. The F# library definitions of vectors and matrices can be used as a guide.

Like other .NET languages, F# directly supports two-dimensional array values that are stored flat: that is, where an array of dimensions (N, M) is stored using a contiguous array of N * M elements. The types for these values are written using [,], such as in int[,] and double[,], and these types also support slicing syntax. Values of these types are created and manipulated using the values in the Array2D module. Likewise, there is a module for manipulating three-dimensional array values whose types are written int[,,]. You can also use the code in those modules as a template for defining code to manipulate arrays of higher dimension.

As mentioned in Chapter 3, the .NET Framework comes with a type System.Collections.Generic.List<'T>, which, although named List, is better described as a resizeable array. The F# library includes the following type abbreviation for this purpose:

type ResizeArray<'T> = System.Collections.Generic.List<'T>

Here is a simple example of using this data structure:

> let names = new ResizeArray<string>();;
val names : ResizeArray<string>

> for name in ["Claire"; "Sophie"; "Jane"] do
      names.Add(name);;
val it : unit = ()

> names.Count;;
val it : int = 3

> names.[0];;
val it : string = "Claire"

> names.[1];;
val it : string = "Sophie"

> names.[2];;
val it : string = "Jane"

Resizable arrays use an underlying array for storage and support constant-time random-access lookup. In many situations, this makes a resizable array more efficient than an F# list, which supports efficient access only from the head (left) of the list. You can find the full set of members supported by this type in the .NET documentation. Commonly used properties and members include Add, Count, ConvertAll, Insert, BinarySearch, and ToArray. A module ResizeArray is included in the F# library; it provides operations over this type in the style of the other F# collections.

Like other .NET collections, values of type ResizeArray<'T> support the seq<'T> interface. There is also an overload of the new constructor for this collection type that lets you specify initial values via a seq<'T>. This means you can create and consume instances of this collection type using sequence expressions:

> let squares = new ResizeArray<int>(seq { for i in 0 .. 100 -> i*i });;
val squares : ResizeArray<int>

> for x in squares do
      printfn "square: %d" x;;
square: 0
square: 1
square: 4
square: 9
...

The type System.Collections.Generic.Dictionary<'Key,'Value> is an efficient hash-table structure that is excellent for storing associations between values. The use of this collection from F# code requires a little care, because it must be able to correctly hash the key type. For simple key types such as integers, strings, and tuples, the default hashing behavior is adequate. Here is a simple example:

> open System.Collections.Generic;;

> let capitals = new Dictionary<string, string>(HashIdentity.Structural);;
val capitals : Dictionary<string,string> = dict []

> capitals.["USA"] <- "Washington";;
val it : unit = ()

> capitals.["Bangladesh"] <- "Dhaka";;
val it : unit = ()

> capitals.ContainsKey("USA");;
val it : bool = true

> capitals.ContainsKey("Australia");;
val it : bool = false

> capitals.Keys;;
val it : KeyCollection<string,string> = seq["USA"; "Bangladesh"]

> capitals.["USA"];;
val it : string = "Washington"

Dictionaries are compatible with the type seq<KeyValuePair<'key,'value>>, where KeyValuePair is a type from the System.Collections.Generic namespace and simply supports the properties Key and Value. Armed with this knowledge, you can use iteration to perform an operation for each element of the collection:

> for kvp in capitals do
      printf "%s has capital %s
" kvp.Key kvp.Value;;
USA has capital Washington
Bangladesh has capital Dhaka
val it : unit = ()

The Dictionary method TryGetValue is of special interest because its use from F# is a little nonstandard. This method takes an input value of type 'Key and looks it up in the table. It returns a bool indicating whether the lookup succeeded: true if the given key is in the dictionary and false otherwise. The value itself is returned via a .NET idiom called an out parameter. From F# code, three ways of using .NET methods rely on out parameters:

Here's how you do it using a mutable local:

open System.Collections.Generic

let lookupName nm (dict : Dictionary<string,string>) =
    let mutable res = ""
    let foundIt = dict.TryGetValue(nm, &res)
    if foundIt then res
    else failwithf "Didn't find %s" nm

The use of a reference cell can be cleaner. For example:

> let res = ref "";;
val res: string ref = {contents = "";}

> capitals.TryGetValue("Australia", res);;
val it: bool = false

> capitals.TryGetValue("USA", res);;
val it: bool = true

> res;;
val it: string ref = {contents = "Washington"}

Finally, here is the technique where you don't pass the final parameter, and instead the result is returned as part of a tuple:

> capitals.TryGetValue("Australia");;
val it: bool * string = (false, null)

> capitals.TryGetValue("USA");;
val it: bool * string = (true, "Washington")

Note that the value returned in the second element of the tuple may be null if the lookup fails when this technique is used. null values are discussed in the section "Working with null Values" at the end of this chapter.

You can use dictionaries with compound keys such as tuple keys of type (int * int). If necessary, you can specify the hash function used for these values when creating the instance of the dictionary. The default is to use generic hashing, also called structural hashing, a topic covered in more detail in Chapter 8. If you want to indicate this explicitly, you do so by specifying Microsoft.FSharp.Collections. HashIdentity.Structural when creating the collection instance. In some cases, this can also lead to performance improvements, because the F# compiler often generates a hashing function appropriate for the compound type.

Here is an example that uses a dictionary with a compound key type to represent sparse maps:

> open System.Collections.Generic;;
> open Microsoft.FSharp.Collections;;

> let sparseMap = new Dictionary<(int * int), float>();;
val sparseMap : Dictionary <(int * int),float> = dict []

> sparseMap.[(0,2)] <- 4.0;;
val it : unit = ()

> sparseMap.[(1021,1847)] <- 9.0;;
val it : unit = ()

> sparseMap.Keys;;
val it : Dictionary.KeyCollection<(int * int),float> = seq [(0,2); (1021; 1847)]

Some of the other important mutable data structures in the F# and .NET libraries are as follows:

You can catch exceptions using the try ... with ... language construct and :? type-test patterns, which filter any exception value caught by the with clause. For example:

> try
     raise (System.InvalidOperationException ("it's just not my day"))
  with
     | :? System.InvalidOperationException -> printfn "caught!";;
caught!

Chapter 5 covers these patterns more closely. The following code sample shows how to use try ... with ... to catch two kinds of exceptions that may arise from the operations that make up the http method, in both cases returning the empty string "" as the incomplete result. Note that try ... with ... is just an expression, and it may return a result in both branches:

open System.IO

let http(url: string) =
    try
        let req = System.Net.WebRequest.Create(url)
        let resp = req.GetResponse()
        let stream = resp.GetResponseStream()
        let reader = new StreamReader(stream)
        let html = reader.ReadToEnd()
        html
    with
        | :? System.UriFormatException -> ""
        | :? System.Net.WebException -> ""

When an exception is thrown, a value is created that records information about the exception. This value is matched against the earlier type-test patterns. It may also be bound directly and manipulated in the with clause of the try ... with constructs. For example, all exception values support the Message property:

> try
      raise (new System.InvalidOperationException ("invalid operation"))
  with
      | err -> printfn "oops, msg = '%s'" err.Message;;
oops, msg = 'invalid operation'

Exceptions may also be processed using the try ... finally ... construct. This guarantees to run the finally clause both when an exception is thrown and when the expression evaluates normally. This allows you to ensure that resources are disposed after the completion of an operation. For example, you can ensure that the web response from the previous example is closed as follows:

let httpViaTryFinally(url: string) =
    let req = System.Net.WebRequest.Create(url)
    let resp = req.GetResponse()
    try
        let stream = resp.GetResponseStream()
        let reader = new StreamReader(stream)
        let html = reader.ReadToEnd()
        html
    finally
        resp.Close()

In practice, you can use a shorter form to close and dispose of resources, simply by using a use binding instead of a let binding. This closes the response at the end of the scope of the resp variable, a technique that is discussed in full in Chapter 8. Here is how the previous function looks using this form:

let httpViaUseBinding(url: string) =
    let req = System.Net.WebRequest.Create(url)
    use resp = req.GetResponse()
    let stream = resp.GetResponseStream()
    let reader = new StreamReader(stream)
    let html = reader.ReadToEnd()
    html

F# lets you define new kinds of exception objects that carry data in a conveniently accessible form. For example, here is a declaration of a new class of exceptions and a function that wraps http with a filter that catches particular cases:

exception BlockedURL of string

let http2 url =
    if url = "http://www.kaos.org"
    then raise(BlockedURL(url))
    else http url

You can extract the information from F# exception values, again using pattern matching:

> try
     raise(BlockedURL("http://www.kaos.org"))
  with
     | BlockedURL(url) -> printf "blocked! url = '%s'
" url;;
blocked! url = 'http://www.kaos.org'

Exception values are always subtypes of the F# type exn, an abbreviation for the .NET type System.Exception. The declaration exception BlockedURL of string is shorthand for defining a new F# class type BlockedURLException, which is a subtype of System.Exception. Exception types can also be defined explicitly by defining new object types. Chapters 5 and 6 look more closely at object types and subtyping.

Table 4-3 summarizes the exception-related language and library constructs.

The .NET types System.IO.File and System.IO.Directory contain a number of simple functions to make working with files easy. For example, here's a way to output lines of text to a file:

> open System.IO;;

> File.WriteAllLines("test.txt", [| "This is a test file.";
                                    "It is easy to read." |]);;
val it : unit = ()

Many simple file-processing tasks require reading all the lines of a file. You can do this by reading all the lines in one action as an array using System.IO.File.ReadAllLines:

> open System.IO;;

> File.ReadAllLines("test.txt");;
val it : string [] = [| "This is a test file.";  "It is easy to read." |]

If necessary, the entire file can be read as a single string using System.IO.File.ReadAllText:

> File.ReadAllText("test.txt");;
val it : string = "This is a test file.
It is easy to read
"

You can also use the results of System.IO.File.ReadAllLines as part of a list or sequence defined using a sequence expression:

> [ for line in File.ReadAllLines("test.txt") do
       let words = line.Split [| ' ' |]
       if words.Length > 3 && words.[2] = "easy" then
           yield line ];;
val it : string list = [| "It is easy to read." |]

The .NET namespace System.IO contains the primary .NET types for reading/writing bytes and text to/from data sources. The primary output constructs in this namespace are as follows:

Here is a simple example of using System.IO.File.CreateText to create a StreamWriter and write two strings:

> let outp = File.CreateText("playlist.txt");;
val outp : StreamWriter

> outp.WriteLine("Enchanted");;
val it : unit = ()

> outp.WriteLine("Put your records on");;
val it : unit = ()

> outp.Close();

These are the primary input constructs in the System.IO namespace:

Here is a simple example of using System.IO.File.OpenText to create a StreamReader and read two strings:

> let inp = File.OpenText("playlist.txt");;
val inp : StreamReader

> inp.ReadLine();;
val it : string = "Enchanted"

> inp.ReadLine();;
val it : string = "Put your records on"

> inp.Close();;
val it : unit = ()

The System.IO namespace contains a number of other types, all of which are useful for corner cases of advanced I/O but that you won't need to use from day to day. For example, the following abstractions appear in the .NET documentation:

Some functions that are generic over different kinds of output streams make use of these; for example, the formatting function twprintf discussed in the section "Using printf and Friends" writes to any System.IO.TextWriter.

Some simple input/output routines are provided in the System.Console class. For example:

> System.Console.WriteLine("Hello World");;
Hello World

> System.Console.ReadLine();;
<enter "I'm still here" here>
val it : string = "I'm still here"

The System.Console.Out object can also be used as a TextWriter.

Throughout this book, you've used the printfn function, which is one way to print strings from F# values. This is a powerful, extensible technique for type-safe formatting. A related function called sprintf builds strings:

> sprintf "Name: %s, Age: %d" "Anna" 3;;
val it : string = "Name: Anna, Age: 3"

The format strings accepted by printf and sprintf are recognized and parsed by the F# compiler, and their use is statically type checked to ensure the arguments given for the formatting holes are consistent with the formatting directives. For example, if you use an integer where a string is expected, you see a type error:

> sprintf "Name: %s, Age: %d" 3 10;;
------------------------------^
error: FS0001: This expression was expected to have type string but here
has type int

Several printf-style formatting functions are provided in the Microsoft.FSharp.Text.Printf module. Table 4-4 shows the most important of these.

Table 4-5 shows the basic formatting codes for printf-style formatting.

Any value can be formatted using a %O or %A pattern; these patterns are extremely useful when you're prototyping or examining data. %O converts the object to a string using the Object.ToString() function supported by all values. For example:

> System.DateTime.Now.ToString();;
val it : string = "28/06/20.. 17:14:07 PM"

> sprintf "It is now %O" System.DateTime.Now;;
val it : string = "It is now 28/06/20... 17:14:09"

Object.ToString() is a somewhat undirected way of formatting data. Structural types such as tuples, lists, records, discriminated unions, collections, arrays, and matrices are often poorly formatted by this technique. The %A pattern uses .NET reflection to format any F# value as a string based on the structure of the value. For example:

> printf "The result is %A
" [1;2;3];;
"The result is [1; 2; 3]"

Generic structural formatting can be extended to work with any user-defined data types, a topic covered on the F# web site. This is covered in detail in the F# library documentation for the printf function.

Many constructs in the System.IO namespace need to be closed after use, partly because they hold on to operating system resources such as file handles. You can ignore this issue when prototyping code in F# Interactive. However, as we touched on earlier in this chapter, in more polished code, you should use language constructs such as use var = expr to ensure that the resource is closed at the end of the lexical scope where a stream object is active. For example:

let myWriteStringToFile () =
    use outp = File.CreateText(@"playlist.txt")
    outp.WriteLine("Enchanted")
    outp.WriteLine("Put your records on")

This is equivalent to the following:

let myWriteStringToFile () =
    using (File.CreateText(@"playlist.txt")) (fun outp ->
        outp.WriteLine("Enchanted")
        outp.WriteLine("Put your records on"))

where the function using has the following definition in the F# library:

let using (ie : #System.IDisposable) f =
    try f(ie)
    finally ie.Dispose()

use and using ensure that the underlying stream is closed deterministically and the operating system resources are reclaimed when the lexical scope is exited. This happens regardless of whether the scope is exited because of normal termination or because of an exception. Chapter 8 covers the language construct use, the operator using, and related issues in more detail.

When imperative programmers begin to use F#, they frequently use mutable local variables or reference cells heavily as they translate code fragments from their favorite imperative language into F#. The resulting code often looks very bad. Over time, they learn to avoid many uses of mutable locals. For example, consider the following (naive) implementation of factorization, transliterated from C code:

let factorizeImperative n =
    let mutable primefactor1 = 1
    let mutable primefactor2 = n
    let mutable i = 2
    let mutable fin = false
    while (i < n && not fin) do
        if (n % i = 0) then
            primefactor1 <- i
            primefactor2 <- n / i
            fin <- true
        i <- i + 1
    if (primefactor1 = 1) then None
    else Some (primefactor1, primefactor2)

This code can be replaced by the following use of an inner recursive function:

let factorizeRecursive n =
    let rec find i =
        if i >= n then None
        elif (n % i = 0) then Some(i,n / i)
        else find (i+1)
    find 2

The second code is not only shorter but also uses no mutation, which makes it easier to reuse and maintain. You can also see that the loop terminates (i is increasing toward n) and see the two exit conditions for the function (i >= n and n % i = 0). Note that the state i has become an explicit parameter.

Where possible, separate out as much of your computation as possible using side-effect-free functional programming. For example, sprinkling printf expressions throughout your code may make for a good debugging technique but, if not used wisely, can lead to code that is difficult to understand and inherently imperative.

A common technique of object-oriented programming is to ensure that mutable data structures are private, nonescaping, and, where possible, fully separated, which means there is no chance that distinct pieces of code can access each other's internal state in undesirable ways. Fully separated state can even be used inside the implementation of what, to the outside world, appears to be a purely functional piece of code.

For example, where necessary, you can use side effects on private data structures allocated at the start of an algorithm and then discard these data structures before returning a result; the overall result is then effectively a side-effect-free function. One example of separation from the F# library is the library's implementation of List.map, which uses mutation internally; the writes occur on an internal, separated data structure that no other code can access. Thus, as far as callers are concerned, List.map is pure and functional. The following is a second example that divides a sequence of inputs into equivalence classes (the F# library function Seq.groupBy does a similar thing):

open System.Collections.Generic

let divideIntoEquivalenceClasses keyf seq =

    // The dictionary to hold the equivalence classes
    let dict = new Dictionary<'key,ResizeArray<'T>>()

    // Build the groupings
    seq |> Seq.iter (fun v ->
        let key = keyf v
        let ok,prev = dict.TryGetValue(key)
        if ok then prev.Add(v)
        else let prev = new ResizeArray<'T>()
             dict.[key] <- prev
             prev.Add(v))

    // Return the sequence-of-sequences. Don't reveal the
    // internal collections: just reveal them as sequences
    dict |> Seq.map (fun group -> group.Key, Seq.readonly group.Value)

This uses the Dictionary and ResizeArray mutable data structures internally, but these mutable data structures aren't revealed externally. The inferred type of the overall function is as follows:

val divideIntoEquivalenceClasses : ('T -> 'key) -> seq<'T> -> seq<'key * seq<'T>>

Here is an example use:

> divideIntoEquivalenceClasses (fun n -> n % 3) [ 0 .. 10 ];;

val it : seq<int * seq<int>>
= seq [(0, seq [0; 3; 6; 9]); (1, seq [1; 4; 7; 10]); (2, seq [2; 5; 8])]

It's often helpful to use the weakest set of side effects necessary to achieve your programming task and at least be aware when you're using strong side effects:

Whether a particular side effect is stronger or weaker depends very much on your application and whether the consequences of the side effect are sufficiently isolated and separated from other entities. Strong side effects can and should be used freely in the outer shell of an application or when you're scripting with F# Interactive; otherwise, not much can be achieved.

When you're writing larger pieces of code, you should write your application and libraries in such a way that most of your code either doesn't use strong side effects or at least makes it obvious when these side effects are being used. Threads and concurrency are commonly used to mediate problems associated with strong side effects; Chapter 14 covers these issues in more depth.

It's generally thought to be bad style to combine delayed computations (that is, laziness) and side effects. This isn't entirely true; for example, it's reasonable to set up a read from a file system as a lazy computation using sequences. However, it's relatively easy to make mistakes in this sort of programming. For example, consider the following code:

open System.IO
let reader1, reader2 =
    let reader = new StreamReader(File.OpenRead("test.txt"))
    let firstReader() = reader.ReadLine()
    let secondReader() = reader.ReadLine()

    // Note: we close the stream reader here!
    // But we are returning function values which use the reader
    // This is very bad!
    reader.Close()
    firstReader, secondReader

// Note: stream reader is now closed! The next line will fail!
let firstLine = reader1()
let secondLine = reader2()
firstLine, secondLine

This code is wrong because the StreamReader object reader is used after the point indicated by the comment. The returned function values are then called, and they try to read from the captured variable reader. Function values are just one example of delayed computations: other examples are lazy values, sequences, and any objects that perform computations on demand. Be careful not to build delayed objects such as reader that represent handles to transient, disposable resources, unless those objects are used in a way that respects the lifetime of that resource.

The previous code can be corrected to avoid using laziness in combination with a transient resource:

open System.IO

let line1, line2 =
    let reader = new StreamReader(File.OpenRead("test.txt"))
    let firstLine = reader.ReadLine()
    let secondLine = reader.ReadLine()
    reader.Close()
    firstLine, secondLine

Another technique uses language and/or library constructs that tie the lifetime of an object to some larger object. For example, you can use a use binding within a sequence expression, which augments the sequence object with the code needed to clean up the resource when iteration is finished or terminates. This technique is discussed further in Chapter 8 and shown by example here:

let reader =
    seq { use reader = new StreamReader(File.OpenRead("test.txt"))
          while not reader.EndOfStream do
              yield reader.ReadLine() }

The general lesson is to try to keep your core application pure. Use both delayed computations (laziness) and imperative programming (side effects) where appropriate, but be careful about using them together.