Literals

Literals represent constant values and are useful building blocks for computations. F# has a rich set of literals, summarized in Table 3-1.

In F#, string literals can contain newline characters, and regular string literals can contain standard escape codes. Verbatim string literals use a backslash () as a regular character, and two double quotes ("") are the escape for a quote. You can define all integer types using hexadecimal and octal by using the appropriate prefix and postfix indicator.

The following example shows some of these literals in action, along with how to use the F# printf function with a %A pattern to output them to the console. The printf function interprets the %A format pattern using a combination of F#’s reflection (covered in Chapter 7) and the .NET ToString method, which is available for every type, to output values in a human-readable way.

#if INTERACTIVE
#else
module Examples
#endif

// some strings
let message = "Hello
World
	!"
let dir = @"c:projects"

// a byte array
let bytes = "bytesbytesbytes"B

// some numeric types
let xA = 0xFFy
let xB = 0o7777un
let xC = 0b10010UL

// print the results
let main() =
    printfn "%A" message
    printfn "%A" dir
    printfn "%A" bytes
    printfn "%A" xA
    printfn "%A" xB
    printfn "%A" xC

// call the main function
main()                                                                      

This example, when executed, returns the following:

"Hello
World
       !"
"c:projects"
[|98uy; 121uy; 116uy; 101uy; 115uy; 98uy; 121uy; 116uy; 101uy; 115uy; 98uy;
  121uy; 116uy; 101uy; 115uy|]
-1y
4095un
18UL

Anonymous Functions

In F#, anonymous functions are defined using the keyword fun. The function’s arguments are separated by spaces, and the arguments are separated from the function body by a left ASCII arrow (->).

Here is an example of a function that takes two values and adds them together:

fun x y -> x + y

Notice that this function does not have a name; this is a sort of function literal. Functions defined in this way are referred to as anonymous functions, lambda functions, or just lambdas.

The idea that a function does not need a name may seem a little strange. However, if a function is to be passed as an argument to another function, it may not need a name, especially if the task it’s performing is relatively simple.

If you need to give the function a name, you can bind it to an identifier, as described in the next section.

Identifiers and let Bindings

Identifiers are the way you give names to values in F# so you can refer to them later in a program. You define an identifier using the keyword let followed by the name of the identifier, an equal sign, and an expression that specifies the value to which the identifier refers. An expression is any piece of code that represents a computation that will return a value. The following expression shows a value being assigned to an identifier:

let x = 42

To most people coming from an imperative programming background, this will look like a variable assignment. There are a lot of similarities, but a key difference is that in pure functional programming, once a value is assigned to an identifier, it does not change. This is why I will refer to them throughout this book as identifiers, rather than as variables.

An identifier can refer to either a value or a function, and since F# functions are really values in their own right, this is hardly surprising. This means F# has no real concept of a function name or parameter name; these are just identifiers. You can bind an anonymous function to an identifier the same way you can bind a string or integer literal to an identifier:

let myAdd = fun x y -> x + y

However, as it is very common to need to define a function with a name, F# provides a short syntax for this. You write a function definition the same way as a value identifier, except that a function has two or more identifiers between the let keyword and the equal sign, as follows:

let raisePowerTwo x = x ** 2.0

The first identifier is the name of the function, raisePowerTwo, and the identifier that follows it is the name of the function’s parameter, x. If a function has a name, it is strongly recommended that you use this shorter syntax for defining it.

The syntax for declaring values and functionsin F# is indistinguishable because functions are values, and F# syntax treats them both similarly. For example, consider the following code:

let n = 10

let add a b = a + b
let result = add n 4

printfn "result = %i" result

On the first line, the value 10 is assigned to the identifier n; then on the second line, a function named add, which takes two arguments and adds them together, is defined. Notice how similar the syntax is, with the only difference being that a function has parameters that are listed after the function name. Since everything is a value in F#, the literal 10 on the first line is a value, and the result of the expression a + b on the next line is also a value that automatically becomes the result of the add function . Note that there is no need to explicitly return a value from a function as you would in an imperative language.

This example, when executed, returns the following:

result = 14

let x = 42
let x' = 43

let 标识符 = 42

let ``more? `` = true

let ``class`` = "style"

// function to calculate a midpoint
let halfWay a b =
    let dif = b - a
    let mid = dif / 2
    mid + a

// call the function and print the results
printfn "(halfWay 5 11) = %i" (halfWay 5 11)
printfn "(halfWay 11 5) = %i" (halfWay 11 5)                                                                              

(halfWay 5 11) = 8
(halfWay 11 5) = 8

let halfWay a b =
    let dif = b - a in
    let mid = dif / 2 in
    mid + a

let printMessage() =
    let message = "Help me"
    printfn "%s" message

printfn "%s" message                                                

Prog.fs(34,17): error: FS0039: The value or constructor 'message' is not defined.

let SafeUpperCase (s : string) =
    let s = if s = null then "" else s
    s.ToUpperInvariant()

val SafeUpperCase : s:string -> string
> SafeUpperCase "Hello";;
val it : string = "HELLO"
> SafeUpperCase null;;
val it : string = ""
>

let changeType () =
    let x = 1             // bind x to an integer
    let x = "change me"   // rebind x to a string
    let x = x + 1         // attempt to rebind to itself plus an integer
    printfn "%s" x

prog.fs(55,13): error: FS0001: This expression has type
    int
but is here used with type
    string
stopped due to error

let printMessages() =
    // define message and print it
    let message = "Important"
    printfn "%s" message;
    // define an inner function that redefines value of message
    let innerFun () =
        let message = "Very Important"
        printfn "%s" message
    // call the inner function
    innerFun ()
    // finally print the first message again
    printfn "%s" message

printMessages()

Important
Very Important
Important

// function that returns a function to
let calculatePrefixFunction prefix =
    // calculate prefix
    let prefix' = Printf.sprintf "[%s]: " prefix
    // define function to perform prefixing
    let prefixFunction appendee =
        Printf.sprintf "%s%s" prefix' appendee
    // return function
    prefixFunction

// create the prefix function
let prefixer = calculatePrefixFunction "DEBUG"

// use the prefix function
printfn "%s" (prefixer "My message")

[DEBUG]: My message

open System.IO

// function to read first line from a file
let readFirstLine filename =
    // open file using a "use" binding
    use file = File.OpenText filename
    file.ReadLine()

// call function and print the result
printfn "First line was: %s" (readFirstLine "mytext.txt")

Recursion

Recursion means defining a function in terms of itself; in other words, the function calls itself within its definition. Recursion is often used in functional programming where you would use a loop in imperative programming. Many believe that algorithms are much easier to understand when expressed in terms of recursion rather than loops.

To use recursion in F#, use the rec keyword after the let keyword to make the identifier available within the function definition. The following example shows recursion in action. Notice how on the fifth line, the function makes two calls to itself as part of its own definition.

// a function to generate the Fibonacci numbers
let rec fib x =
    match x with
    | 1 -> 1
    | 2 -> 1
    | x -> fib (x - 1) + fib (x - 2)

// call the function and print the results
printfn "(fib 2) = %i" (fib 2)
printfn "(fib 6) = %i" (fib 6)
printfn "(fib 11) = %i" (fib 11)

This example, when executed, returns the following:

(fib 2) = 1
(fib 6) = 8
(fib 11) = 89

This function calculates the nth term in the Fibonacci sequence . The Fibonacci sequence is generated by adding the previous two numbers in the sequence, and it progresses as follows: 1, 1, 2, 3, 5, 8, 13, .... Recursion is most appropriate for calculating the Fibonacci sequence because the definition of any number in the sequence, other than the first two, depends on being able to calculate the previous two numbers, so the Fibonacci sequence is defined in terms of itself.

Although recursion is a powerful tool, you should be careful when using it. It is easy to inadvertently write a recursive function that never terminates. Although intentionally writing a program that does not terminate is sometimes useful, it is rarely the goal when trying to perform calculations. To ensure that recursive functions terminate, it is often useful to think of recursion in terms of a base case and a recursive case:

• The recursive caseis the value for which the function is defined in terms of itself. For the function fib, this is any value other than 1 and 2.

• The base caseis the nonrecursive case; that is, there must be some value where the function is not defined in terms of itself. In the fib function, 1 and 2 are the base cases.

Having a base case is not enough in itself to ensure termination. The recursive case must tend toward the base case. In the fib example, if x is greater than or equal to 3, then the recursive case will tend toward the base case, because x will always become smaller and will at some point reach 2. However, if x is less than 1, then x will grow continually more negative, and the function will recurse until the limits of the machine are reached, resulting in a stack overflow error (System.StackOverflowException).

The previous code also uses F# pattern matching, which is discussed in the “Pattern Matching” section later in this chapter.

Operators

In F#, you can think of operators as a more aesthetically pleasing way to call functions. F# has two different kinds of operators:

• A prefix operator is an operator where the operands come after the operator.

• An infix operator comes in between the first and second operands.

F# provides a rich and diverse set of operators that you can use with numeric, Boolean, string, and collection types. The operators defined in F# and its libraries are too numerous to be covered in this section, so rather than looking at individual operators, we’ll look at how to use and define operators in F#.

As in C#, F# operators are overloaded, meaning you can use more than one type with an operator; however, unlike in C#, both operands must be the same type, or the compiler will generate an error. F# also allows users to define and redefine operators.

Operators follow a set of rules similar to C#’s for operator overloading resolution; therefore, any class in the .NET Framework Base Class Library (BCL), or any .NET library , that was written to support operator overloading in C# will support it in F#. For example, you can use the + operator to concatenate strings, as well as to add a System.TimeSpan to a System.DateTime, because these types support an overload of the + operator. The following example illustrates this:

let rhyme = "Jack " + "and " + "Jill"

open System
let oneYearLater =
    DateTime.Now + new TimeSpan(365, 0, 0, 0, 0)

Unlike functions, operators are not values, so they cannot be passed to other functions as parameters. However, if you need to use an operator as a value, you can do this by surrounding it with parentheses. The operator will then behave exactly like a function. Practically, this has two consequences :

• The operator is now a function, and its parameters will appear after the operator:

  let result = (+) 1 1

• As it is a value, it could be returned as the result of a function, passed to another function, or bound to an identifier. This provides a very concise way to define the add function:

  let add = (+)

You’ll see how using an operator as a value can be useful later in this chapter when we look at working with lists.

Users can define their own operators or redefine any of the existing ones if they want (although this is not always advisable because the operators then no longer support overloading). Consider the following perverse example that redefines + to perform subtraction:

let (+) a b = a - b
printfn "%i" (1 + 1)

User-defined (custom) operators must be nonalphanumeric and can be a single character or a group of characters. You can use the following characters in custom operators:

!%&*+-./<=>@^|∼

You can also use a ? character as long as it’s not the first in the name.

The syntax for defining an operator is the same as using the let keyword to define a function, except the operator replaces the function name and is surrounded by parentheses so the compiler knows that the symbols are used as a name of an operator, rather than as the operator itself. The following example shows defining a custom operator, +*, which adds its operands and then multiplies them:

let (+*) a b = (a + b) * a * b
printfn "(1 +* 2) = %i" (1 +* 2)

This example, when executed, returns the following:

(1 +* 2) = 6

The rules for distinguishing between prefix and infix operators by name are somewhat complex. To quote MSDN,

Only certain operators can be used as prefix operators. Some operators are always prefix operators, others can be infix or prefix, and the rest are always infix operators. Operators that begin with !, except !=, and the operator ∼, or repeated sequences of ∼, are always prefix operators. The operators +, -, +., -., &, &&, %, and %% can be prefix operators or infix operators. You distinguish the prefix version of these operators from the infix version by adding a ∼ at the beginning of a prefix operator when it is defined. The ∼ is not used when you use the operator, only when it is defined.

—Microsoft Developer Network

Function Application

Function application simply means calling a function with some arguments . The following example shows the function add being defined and then applied to two arguments. Notice that the arguments are not separated with parentheses or commas; only whitespace is needed to separate them.

let add x y = x + y

let result = add 4 5

printfn "(add 4 5) = %i" result

This example, when executed, returns the following:

(add 4 5) = 9

In F#, a function has a fixed number of arguments and is applied to the value that appears next in the source file. You do not necessarily need to use parentheses when calling functions, but F# programmers often use them to define which function should be applied to which arguments. Consider the simple case where you want to add four numbers using the add function. You could bind the result of each function call to a new identifier, but for such a simple calculation, this would be very cumbersome:

let add x y = x + y

let result1 = add 4 5
let result2 = add 6 7

let finalResult = add result1 result2

Instead, it often better to pass the result of one function directly to the next function. To do this, you use parentheses to show which parameters are associated with which functions:

let add x y = x + y

let result =
    add (add 4 5) (add 6 7)

Here, the second and third occurrences of the add function are grouped with the parameters 4, 5 and 6, 7, respectively, and the first occurrence of the add function will act on the results of the other two functions.

F# also offers another way to apply functions, using the pipe-forward operator (|>) . This operator has the following definition:

let (|>) x f = f x

This simply means it takes a parameter, x, and applies that to the given function, f, so that the parameter is now given before the function. The following example shows a parameter, 0.5, being applied to the function System.Math.Cosusing the pipe-forward operator:

let result = 0.5 |> System.Math.Cos

This reversal can be useful in some circumstances, especially when you want to chain many functions together. Here is the previous add function example rewritten using the pipe-forward operator:

let add x y = x + y

let result = add 6 7 |> add 4 |> add 5

Some programmers think this style is more readable because it has the effect of making the code read in a more left-to-right manner. The code should now be read as “add 6 to 7, then forward this result to the next function, which will add 4, and then forward this result to a function that will add 5.” A more detailed explanation of where it’s appropriate to use this style of function application can be found in Chapter 4.

This example also takes advantage of the capability to partially apply functions in F#, as discussed in the next section.

Partial Application of Functions

F# supports the partial application of functions. This means you don’t need to pass all the arguments to a function at once. Notice that the final example in the previous section passes a single argument to the add function, which takes two arguments. This is very much related to the idea that functions are values.

Because a function is just a value, if it doesn’t receive all its arguments at once, it returns a value that is a new function waiting for the rest of the arguments. So, in the example, passing just the value 4 to the add function results in a new function, which I named addFour because it takes one parameter and adds the value 4 to it. At first glance, this idea can look uninteresting and unhelpful, but it is a powerful part of functional programming that you’ll see used throughout the book.

This behavior may not always be appropriate. For example, if the function takes two floating-point parameters that represent a point, it may not be desirable to have these numbers passed to the function separately because they both make up the point they represent. To address this, you may surround a function’s parameters with parentheses and separate them with commas, turning them into a tuple. You can see this in the following code:

let sub (a, b) = a - b

let subFour = sub 4

When attempting to compile this example, you will receive the following error message:

prog.fs(15,19): error: FS0001: This expression has type
    int
but is here used with type
    'a * 'b

This example will not compile because the sub function requires both parameters to be given at once. sub now has only one parameter, the tuple (a, b), instead of two, and although the call to sub in the second line provides only one argument, it’s not a tuple. So, the program does not type check, as the code is trying to pass an integer to a function that takes a tuple. Tuples are discussed in more detail in the “Defining Types” section later in this chapter.

In general, functions that can be partially applied–known as curried functions–are preferred over functions that use tuples. This is because functions that can be partially applied are more flexible than tuples, giving users of the function more choices about how to use them. This is especially true when creating a library to be used by other programmers. You may not be able to anticipate all the ways your users will want to use your functions, so it is best to give them the flexibility of functions that can be partially applied. Note that when you call your curried F# functions from C#, the curried nature of the arguments is hidden by “compiler magic.” You can call the F# function with all its arguments (in brackets, as usual in C#), but since partial application isn’t supported by C# you can’t call it with just some of its arguments .

Pattern Matching

Pattern matching allows you to look at the value of an identifier and then make different computations depending on its value. It might be compared to the switch statement in C++ and C#, but it is much more powerful and flexible. Programs that are written in the functional style tend to be written as series of transformations applied to the input data. Pattern matching allows you to analyze the input data and decided which transformation should be applied to it, so pattern matching fits in well with programming in the functional style.

The pattern-matching construct in F# allows you to pattern match over a variety of types and values . It also has several different forms and crops up in several places in the language, including its exception-handling syntax, which is discussed in the “Exceptions and Exception Handling” section later in this chapter.

The simplest form of pattern matching is matching over a value. You saw this earlier in this chapter, in the “Recursion” section, where it was used to implement a function that generated numbers in the Fibonacci sequence. To illustrate the syntax, the following code shows an implementation of a function that will produce the Lucas numbers, a sequence of numbers as follows: 1, 3, 4, 7, 11, 18, 29, 47, 76, .... The Lucas sequence has the same definition as the Fibonacci sequence; only the starting points are different.

// definition of Lucas numbers using pattern matching
let rec luc x =
    match x with
    | x when x <= 0 -> failwith "value must be greater than 0"
    | 1 -> 1
    | 2 -> 3
    | x -> luc (x - 1) + luc (x - 2)

// call the function and print the results
printfn "(luc 2) = %i" (luc 2)
printfn "(luc 6) = %i" (luc 6)
printfn "(luc 11) = %i" (luc 11)
printfn "(luc 12) = %i" (luc 12)

This example, when executed, returns the following:

(luc 2) = 3
(luc 6) = 18
(luc 11) = 199
(luc 12) = 322

The syntax for pattern matching uses the keyword match, followed by the identifier that will be matched, then the keyword with, and then all the possible matching rules separated by vertical bars (|). In the simplest case, a rule consists of either a constant or an identifier, followed by an arrow (->), and then by the expression to be used when the value matches the rule. In this definition of the function luc, the second two cases are literals—the values 1 and 2—and these will be replaced with the values 1 and 3, respectively. The fourth case will match any value of x greater than 2, and this will cause two further calls to the luc function.

The rules are matched in the order in which they are defined, and the compiler will issue a warning if pattern matching is incomplete; that is, if there is some possible input value that will not match any rule. This would be the case in the luc function if you had omitted the final rule, because any values of x greater than 2 would not match any rule. The compiler will also issue a warning if there are any rules that will never be matched, typically because there is another rule in front of them that is more general. This would be the case in the luc function if the fourth rule were moved ahead of the first rule. In this case, none of the other rules would ever be matched because the first rule would match any value of x.

You can add a when guard (as in the first rule in the example) to give precise control about when a rule fires. A when guard is composed of the keyword when followed by a Boolean expression . Once the rule is matched, the when clause is evaluated, and the rule will fire only if the expression evaluates to true. If the expression evaluates to false, the remaining rules will be searched for another match. The first rule is designed to be the function’s error handler. The first part of the rule is an identifier that will match any integer, but the when guard means the rule will match only those integers that are less than or equal to zero.

If you want, you can omit the first |. This can be useful when the pattern match is small and you want to fit it on one line. You can see this in the following example, which also demonstrates the use of the underscore (_) as a wildcard:

let booleanToString x =
    match x with false -> "False" | _ -> "True"

The _ will match any value and is a way of telling the compiler that you’re not interested in using this value. For example, in this booleanToString function, you do not need to use the constant true in the second rule because if the first rule is matched, you know that the value of x will be true. Moreover, you do not need to use x to derive the string "True", so you can ignore the value and just use _ as a wildcard.

Another useful feature of pattern matching is that you can combine two patterns into one rule through the use of the vertical bar (|). The following code, stringToBoolean, demonstrates this:

// function for converting a Boolean to a string
let booleanToString x =
    match x with false -> "False" | _ -> "True"

// function for converting a string to a Boolean
let stringToBoolean x =
    match x with
    | "True" | "true" -> true
    | "False" | "false" -> false
    | _ -> failwith "unexpected input"

// call the functions and print the results
printfn "(booleanToString true) = %s"
    (booleanToString true)
printfn "(booleanToString false) = %s"
    (booleanToString false)
printfn "(stringToBoolean "True") = %b"
    (stringToBoolean "True")
printfn "(stringToBoolean "false") = %b"
    (stringToBoolean "false")
printfn "(stringToBoolean "Hello") = %b"
    (stringToBoolean "Hello")

The first two rules have two strings that should evaluate to the same value, so rather than having two separate rules, you can just use | between the two patterns. The results of this example, when executed, are as follows:

(booleanToString true) = True
(booleanToString false) = False
(stringToBoolean "True") = true
(stringToBoolean "false") = false
Microsoft.FSharp.Core.FailureException: unexpected input
   at FSI_0005.stringToBoolean(String x)
   at <StartupCode$FSI_0005>.$FSI_0005.main@()

It is also possible to pattern match over most of the types defined by F#. The next two examples demonstrate pattern matching over tuples , with two functions that implement a Boolean And and Or using pattern matching. Each takes a slightly different approach.

let myOr b1 b2 =
    match b1, b2 with
    | true, _ -> true
    | _, true -> true
    | _ -> false

let myAnd p =
    match p with
    | true, true -> true
    | _ -> false

printfn "(myOr true false) = %b" (myOr true false)
printfn "(myOr false false) = %b" (myOr false false)
printfn "(myAnd (true, false)) = %b" (myAnd (true, false))
printfn "(myAnd (true, true)) = %b" (myAnd (true, true))

This example, when executed, returns the following:

(myOr true false) = true
(myOr false false) = false
(myAnd (true, false)) = false
(myAnd (true, true)) = true

The myOr function has two Boolean parameters, which are placed between the match and with keywords and are separated by commas to form a tuple. The myAnd function has one parameter, which is itself a tuple. Either way, the syntax for creating pattern matches for tuples is the same and is similar to the syntax for creating tuples.

If it’s necessary to match values within the tuple, the constants or identifiers are separated by commas, and the position of the identifier or constant defines what it matches within the tuple. This is shown in the first and second rules of the myOr function and in the first rule of the myAnd function. These rules match parts of the tuples with constants, but you could use identifiers if you want to work with the separate parts of the tuple later in the rule definition. Just because you’re working with tuples doesn’t mean you always need to look at the various parts that make up the tuple.

The third rule of myOrand the second rule of myAnd show the whole tuple matched with a single _ wildcard character. This, too, could be replaced with an identifier if you want to work with the value in the second half of the rule definition.

Because pattern matching is such a common task in F#, the language provides an alternative shorthand syntax. If the sole purpose of a function is to pattern match over something, then it may be worth using this syntax. In this version of the pattern-matching syntax, you use the keyword function, place the pattern where the function’s parameters would usually go, and then separate all the alternative rules with |. The following example shows this syntax in action in a simple function that recursively processes a list of strings and concatenates them into a single string:

// concatenate a list of strings into single string
let rec concatStringList =
    function head :: tail -> head + concatStringList tail
           | [] -> ""

// test data
let jabber = ["'Twas "; "brillig, "; "and "; "the "; "slithy "; "toves "; "..."]
// call the function
let completJabber = concatStringList jabber
// print the result
printfn "%s" completJabber

This example, when executed, returns the following:

'Twas brillig, and the slithy toves ...

Pattern matching is one of the fundamental building blocks of F#, and we’ll return to it several times in this chapter. We’ll look at pattern matching over lists, with record types and union types, and with exception handling. The most advanced use of pattern matching is discussed in the “Active Patterns” section toward the end of the chapter. You can find details of how to pattern match over types from non-F# libraries in Chapter 4.

Control Flow

F# has a strong notion of control flow. In this way, it differs from many pure functional languages, where the notion of control flow is very loose, because expressions can be evaluated in essentially any order. The strong notion of control flow is apparent in the if ... then ... else ... expression .

In F#, the if ... then ... else ... construct is an expression, meaning it returns a value. One of two different values will be returned, depending on the value of the Boolean expression between the if and then keywords. The next example illustrates this. The if ... then ... else ... expression is evaluated to return either "heads" or "tails", depending on whether the program is run on an even second or an odd second.

let result =
    if System.DateTime.Now.Second % 2 = 0 then
        "heads"
    else
        "tails"

printfn "%A" result

It’s interesting to note that the if ... then ... else ... expression is just a convenient shorthand for pattern matching over a Boolean value. So the previous example could be rewritten as follows:

let result =
    match System.DateTime.Now.Second % 2 = 0 with
    | true -> "heads"
    | false ->  "tails"

The if ... then ... else ... expression has some implications that you might not expect if you are more familiar with imperative-style programming. F#’s type system requires that the values being returned by the if ... then ... else ... expression must be the same type, or the compiler will generate an error. So, if in the previous example, you replaced the string "tails" with an integer or Boolean value, you would get a compile error. If (very rarely) you really require the values to be of different types, you can create an if ... then ... else ... expression of type obj (F#’s version of System.Object), as shown in the following example, which prints either "heads" or false to the console:

let result =
    if System.DateTime.Now.Second % 2 = 0 then
        box "heads"
    else
        box false

printfn "%A" result

Imperative programmers may be surprised that an if ... then ... else ... expression must have an else if the expression returns a value. This is pretty logical when you think about it and considering the examples you’ve just seen. If the else were removed from the code, the identifier result could not be assigned a value when the if evaluated to false, and having uninitialized identifiers is something that F# (and functional programming in general) aims to avoid. There is a way for a program to contain an if ... then expression without the else, but this is very much in the style of imperative programming, so I discuss it in Chapter 4.

Lists

F# lists are simple collection types that are built into F#. An F# list can be an empty list, represented by square brackets ([]), or it can be another list with a value concatenated to it. You concatenate values to the front of an F# list using a built-in operator that consists of two colons (::), pronounced “cons.” The following example shows some lists being defined, starting with an empty list on the first line, followed by two lists where strings are placed at the front by concatenation:

let emptyList = []
let oneItem = "one " :: []
let twoItem = "one " :: "two " :: []

The syntax to add items to a list by concatenation is a little verbose, so if you just want to define a list, you can use shorthand. In this shorthand notation, you place the list items between square brackets and separate them with a semicolon (;), as follows:

let shortHand = ["apples "; "pears"]

Another F# operator that works on lists is the at symbol (@), which you can use to concatenate two lists together, as follows:

let twoLists = ["one, "; "two, "] @ ["buckle "; "my "; "shoe "]

All items in an F# list must be of the same type. If you try to place items of different types in a list—for example, you try to concatenate a string to a list of integers—you will get a compile error. If you need a list of mixed types, you can create a list of type obj (the F# equivalent of System.Object), as in the following code:

// the empty list
let emptyList = []

// list of one item
let oneItem = "one " :: []

// list of two items
let twoItem = "one " :: "two " :: []

// list of two items
let shortHand = ["apples "; "pairs "]

// concatenation of two lists
let twoLists = ["one, "; "two, "] @ ["buckle "; "my "; "shoe "]
// list of objects
let objList = [box 1; box 2.0; box "three"]
// print the lists
let main() =
    printfn "%A" emptyList
    printfn "%A" oneItem
    printfn "%A" twoItem
    printfn "%A" shortHand
    printfn "%A" twoLists
    printfn "%A" objList

// call the main function
main()

This example, when executed, returns the following:

[]
["one "]
["one "; "two "]
["apples "; "pairs "]
["one, "; "two, "; "buckle "; "my "; "shoe "]
[1; 2.0; "three"]

I discuss types in F# in more detail in the “Types and Type Inference” section later in this chapter.

F# lists are immutable; in other words, once a list is created, it cannot be altered. The functions and operators that act on lists do not alter them, but they create a new, modified version of the list, leaving the old list available for later use if needed. The next example shows this.

// create a list of one item
let one = ["one "]
// create a list of two items
let two = "two " :: one
// create a list of three items
let three = "three " :: two

// reverse the list of three items
let rightWayRound = List.rev three

// function to print the results
let main() =
    printfn "%A" one
    printfn "%A" two
    printfn "%A" three
    printfn "%A" rightWayRound
// call the main function
main()

An F# list containing a single string is created, and then two more lists are created, each using the previous one as a base. Finally, the List.rev function is applied to the last list to create a new reversed list. When you print these lists, it is easy to see that all the original lists remain unaltered:

["one "]
["two "; "one "]
["three "; "two "; "one "]
["one "; "two "; "three "]

// list to be concatenated
let listOfList = [[2; 3; 5]; [7; 11; 13]; [17; 19; 23; 29]]

// definition of a concatenation function
let rec concatList l =
    match l with
    | head :: tail -> head @ (concatList tail)
    | [] -> []

// call the function
let primes = concatList listOfList

// print the results
printfn "%A" primes

[2; 3; 5; 7; 11; 13; 17; 19; 23; 29]

// function that attempts to find various sequences
let rec findSequence l =
    match l with
    // match a list containing exactly 3 numbers
    | [x; y; z] ->
        printfn "Last 3 numbers in the list were %i %i %i"
            x y z
    // match a list of 1, 2, 3 in a row
    | 1 :: 2 :: 3 :: tail ->
        printfn "Found sequence 1, 2, 3 within the list"
        findSequence tail
    // if neither case matches and items remain
    // recursively call the function
    | head :: tail -> findSequence tail
    // if no items remain terminate                                                
    | [] -> ()

// some test data
let testSequence = [1; 2; 3; 4; 5; 6; 7; 8; 9; 8; 7; 6; 5; 4; 3; 2; 1]

// call the function
findSequence testSequence

Found sequence 1, 2, 3 within the list
Last 3 numbers in the list were 3 2 1

let rec addOneAll list =
    match list with
    | head :: rest ->
        head + 1 :: addOneAll rest
    | [] -> []

printfn "(addOneAll [1; 2; 3]) = %A" (addOneAll [1; 2; 3])

(addOneAll [1; 2; 3]) = [2; 3; 4]

let rec map func list =
    match list with
    | head :: rest ->
        func head :: map func rest
    | [] -> []

let result = List.map ((+) 1) [1; 2; 3]

printfn "List.map ((+) 1) [1; 2; 3] = %A" result

(List.map ((+) 1) [1; 2; 3]) = [2; 3; 4]

// create some list comprehensions
let numericList = [ 0 .. 9 ]
let alpherSeq = seq { 'A' .. 'Z' }

// print them
printfn "%A" numericList
printfn "%A" alpherSeq

[0; 1; 2; 3; 4; 5; 6; 7; 8; 9]
seq ['A'; 'B'; 'C'; 'D'; ...]

// create some list comprehensions
let multiplesOfThree = [ 0 .. 3 .. 30 ]
let revNumericSeq = [ 9 .. -1 .. 0 ]

// print them
printfn "%A" multiplesOfThree
printfn "%A" revNumericSeq

[0; 3; 6; 9; 12; 15; 18; 21; 24; 27; 30]
[9; 8; 7; 6; 5; 4; 3; 2; 1; 0]

// a sequence of squares
let squares =
    seq { for x in 1 .. 10 -> x * x }
// print the sequence
printfn "%A" squares

seq [1; 4; 9; 16; ...]

// a sequence of even numbers
let evens n =
    seq { for x in 1 .. n do
            if x % 2 = 0 then yield x }

// print the sequence
printfn "%A" (evens 10)

seq [2; 4; 6; 8; ...]

// sequence of tuples representing points
let squarePoints n =
    seq { for x in 1 .. n do
            for y in 1 .. n do
                yield x, y }

// print the sequence
printfn "%A" (squarePoints 3)

seq [(1, 1); (1, 2); (1, 3); (2, 1); ...]

Types and Type Inference

F# is a strongly typed language, which means you cannot use a function with a value that is inappropriate. You cannot call a function that has a string as a parameter with an integer argument; you must explicitly convert between the two. The way the language treats the type of its values is referred to as its type system. F# has a type system that does not get in the way of routine programming. In F#, all values have a type, and this includes values that are functions.

Ordinarily, you don’t need to explicitly declare types; the compiler will work out the type of a value from the types of the literals in the function and the resulting types of other functions it calls. If everything is OK, the compiler will keep the types to itself; only if there is a type mismatch will the compiler inform you by reporting a compile error. This process is generally referred to as type inference. If you want to know more about the types in a program, you can make the compiler display all inferred types with the –i switch. Visual Studio users (and users of other IDEs such as Xamarin Studio and MonoDevelop) get tool tips that show types when they hover the mouse pointer over an identifier.

The way type inference works in F# is fairly easy to understand. The compiler works through the program, assigning types to identifiers as they are defined, starting with the top leftmost identifier and working its way down to the bottom rightmost. It assigns types based on the types it already knows—that is, the types of literals and (more commonly) the types of functions defined in other source files or assemblies.

The following example defines two F# identifiers and then shows their inferred types displayed on the console with the F# compiler’s –i switch:

let aString = "Spring time in Paris"
let anInt = 42
val aString : string
val anInt : int

The types of these two identifiers are unsurprising—string and int, respectively. The syntax used by the compiler to describe them is fairly straightforward: the keyword val (meaning “value”) and then the identifier, a colon, and finally the type.

The definition of the function makeMessagein the next example is a little more interesting:

let makeMessage x = (Printf.sprintf "%i" x) + " days to spring time"
let half x = x / 2
val makeMessage : int -> string
val half : int -> int

Note that the makeMessage function’s definition is prefixed with the keyword val, just like the two values you saw before; even though it is a function, the F# compiler still considers it to be a value. Also, the type itself uses the notation int -> string, meaning a function that takes an integer and returns a string. The -> between the type names (an ASCII arrow, or just arrow) represents the transformation of the function being applied. The arrow represents a transformation of the value, but not necessarily the type, because it can represent a function that transforms a value into a value of the same type, as shown in the half function on the second line.

The types of functions that can be partially applied and functions that take tuples differ. The following functions, div1 and div2, illustrate this:

let div1 x y = x / y
let div2 (x, y) = x / y

let divRemainder x y = x / y, x % y
val div1 : int -> int -> int
val div2 : int * int -> int
val divRemainder : int -> int -> int * int

The function div1 can be partially applied, and its type is int -> int -> int, representing that the arguments can be passed in separately. Compare this with the function div2, which has the type int * int -> int, meaning a function that takes a pair of integers—a tuple of integers—and turns them into a single integer. You can see this in the function div_remainder, which performs integer division and also returns the remainder at the same time. Its type is int -> int -> int * int, meaning a curried function that returns an integer tuple.

The next function, doNothing, looks inconspicuous enough, but it is quite interesting from a typing point of view.

let doNothing x = x
val doNothing : 'a -> 'a

This function has the type 'a -> 'a, meaning it takes a value of one type and returns a value of the same type. Any type that begins with a single quotation mark (') means a variable type. F# has a type, obj, that maps to System.Object and represents a value of any type, a concept that you will probably be familiar with from other common language runtime (CLR)–based programming languages (and indeed, many languages that do not target the CLR). However, a variable type is not the same. Notice how the type has an 'a on both sides of the arrow. This means that, even though the compiler does not yet know the type, it knows that the type of the return value will be the same as the type of the argument. This feature of the type system, sometimes referred to as type parameterization, allows the compiler to find more type errors at compile time and can help avoid casting.

The function doNothingToAnInt, shown next, is an example of a value being constrained—a type constraint. In this case, the function parameter x is constrained to be an int. It is possible to constrain any identifier, not just function parameters, to be of a certain type, although it is more typical to need to constrain parameters. The list stringListhere shows how to constrain an identifier that is not a function parameter:

let doNothingToAnInt (x: int) = x
let intList = [1; 2; 3]

let (stringList: list<string>) = ["one"; "two"; "three"]
val doNothingToAnInt _int : int -> int
val intList : int list
val stringList : string list

The syntax for constraining a value to be of a certain type is straightforward. Within parentheses, the identifier name is followed by a colon (:), followed by the type name. This is also sometimes called a type annotation.

The intList value is a list of integers, and the identifier’s type is int list. This indicates that the compiler has recognized that the list contains only integers, and in this case, the type of its items is not undetermined but is int. Any attempt to add anything other than values of type int to the list will result in a compile error.

The identifier stringList has a type annotation. Although this is unnecessary, since the compiler can resolve the type from the value, it is used to show an alternative syntax for working with undetermined types. You can place the type between angle brackets after the type that it is associated with instead of just writing it before the type name. Note that even though the type of stringList is constrained to be list<string> (a list of strings), the compiler still reports its type as string list when displaying the type, and they mean exactly the same thing. This syntax is supported to make F# types with a type parameter look like generic types from other .NET libraries.

Constraining values is not usually necessary when writing pure F#, though it can occasionally be useful. It’s most useful when using .NET libraries written in languages other than F# and for interoperation with unmanaged libraries. In both these cases, the compiler has less type information, so it is often necessary to give it enough information to disambiguate things.

Defining Types

The type system in F# provides a number of features for defining custom types. F#’s type definitions fall broadly into three categories:

• Tuples or records: A set of types composed to form a composite type (similar to structs in C or classes in C#)

• Sum types (sometimes referred to as union types)

• Class types (which we tackle in Chapter 5)

let pair = true, false
let b1, b2 = pair
let b3, _ = pair
let _, b4 = pair

type Name = string
type Fullname = string * string

let fullNameToSting (x: Fullname) =
    let first, second = x in
    first + " " + second

// define an organization with unique fields
type Organization1 = { boss: string; lackeys: string list }
// create an instance of this organization
let rainbow =
    { boss = "Jeffrey";
      lackeys = ["Zippy"; "George"; "Bungle"] }                                                                              

// define two organizations with overlapping fields
type Organization2 = { chief: string; underlings: string list }
type Organization3 = { chief: string; indians: string list }

// create an instance of Organization2
let (thePlayers: Organization2) =
    { chief = "Peter Quince";
      underlings = ["Francis Flute"; "Robin Starveling";
                    "Tom Snout"; "Snug"; "Nick Bottom"] }
// create an instance of Organization3
let (wayneManor: Organization3) =
    { chief = "Batman";
      indians = ["Robin"; "Alfred"] }

// define an organization type
type Organization = { chief: string; indians: string list }

// create an instance of this type
let wayneManor =
    { chief = "Batman";
      indians = ["Robin"; "Alfred"] }

// access a field from this type
printfn "wayneManor.chief = %s" wayneManor.chief

// define an organization type
type Organization = { chief: string; indians: string list }

// create an instance of this type
let wayneManor =
    { chief = "Batman";
      indians = ["Robin"; "Alfred"] }
// create a modified instance of this type
let wayneManor' =
    { wayneManor with indians = [ "Alfred" ] }

// print out the two organizations
printfn "wayneManor = %A" wayneManor
printfn "wayneManor' = %A" wayneManor'

wayneManor = {chief = "Batman";
 indians = ["Robin"; "Alfred"];}
wayneManor' = {chief = "Batman";
 indians = ["Alfred"];}

// type representing a couple
type Couple = { him : string ; her : string }

// list of couples
let couples =
    [ { him = "Brad" ; her = "Angelina" };
      { him = "Becks" ; her = "Posh" };
      { him = "Chris" ; her = "Gwyneth" };
      { him = "Michael" ; her = "Catherine" } ]

// function to find "David" from a list of couples
let rec findDavid l =
    match l with
    | { him = x ; her = "Posh" } :: tail -> x
    | _ :: tail -> findDavid tail
    | [] -> failwith "Couldn't find David"

// print the results    
printfn "%A" (findDavid couples)

Becks

let rec findPartner soughtHer l =
    match l with
    | { him = x ; her = her } :: tail when her = soughtHer -> x
    | _ :: tail -> findPartner soughtHer tail
    | [] -> failwith "Couldn't find him"

type Volume =
    | Liter of float
    | UsPint of float
    | ImperialPint of float

let vol1 = Liter 2.5
let vol2 = UsPint 2.5
let vol3 = ImperialPint (2.5)

// union type using field labels
type Shape =
| Square of side:float
| Rectangle of width:float * height:float
| Circle of radius:float

// create an instance of a union type without using the field label
let sq = Square 1.2
// create an instance of a union type using the field label
let sq2 = Square(side=1.2)
// create an instance of a union type using multiple field labels
// and assigning the field out-of-order
let rect3 = Rectangle(height=3.4, width=1.2)

// type representing volumes                                                
type Volume =
    | Liter of float
    | UsPint of float
    | ImperialPint of float

// various kinds of volumes
let vol1 = Liter 2.5
let vol2 = UsPint 2.5
let vol3 = ImperialPint 2.5

// some functions to convert between volumes
let convertVolumeToLiter x =
    match x with
    | Liter x -> x
    | UsPint x -> x * 0.473
    | ImperialPint x -> x * 0.568
let convertVolumeUsPint x =
    match x with
    | Liter x -> x * 2.113
    | UsPint x -> x
    | ImperialPint x -> x * 1.201
let convertVolumeImperialPint x =
    match x with
    | Liter x -> x * 1.760
    | UsPint x -> x * 0.833
    | ImperialPint x -> x

// a function to print a volume
let printVolumes x =
    printfn "Volume in liters = %f,
in us pints = %f,
in imperial pints = %f"
        (convertVolumeToLiter x)
        (convertVolumeUsPint x)
        (convertVolumeImperialPint x)

// print the results
printVolumes vol1
printVolumes vol2
printVolumes vol3

Volume in liters = 2.500000,
in us pints = 5.282500,
in imperial pints = 4.400000
Volume in liters = 1.182500,
in us pints = 2.500000,
in imperial pints = 2.082500
Volume in liters = 1.420000,
in us pints = 3.002500,
in imperial pints = 2.500000

type 'a BinaryTree =
| BinaryNode of 'a BinaryTree * 'a BinaryTree
| BinaryValue of 'a

let tree1 =
    BinaryNode(
        BinaryNode ( BinaryValue 1, BinaryValue 2),
        BinaryNode ( BinaryValue 3, BinaryValue 4) )

type Tree<'a> =
| Node of Tree<'a> list
| Value of 'a

let tree2 =
    Node( [ Node( [Value "one"; Value "two"] ) ;
         Node( [Value "three"; Value "four"] ) ]  )

// definition of a binary tree
type 'a BinaryTree =
    | BinaryNode of 'a BinaryTree * 'a BinaryTree
    | BinaryValue of 'a

// create an instance of a binary tree
let tree1 =
    BinaryNode(
        BinaryNode ( BinaryValue 1, BinaryValue 2),
        BinaryNode ( BinaryValue 3, BinaryValue 4) )

// definition of a tree
type Tree<'a> =
    | Node of Tree<'a> list
    | Value of 'a

// create an instance of a tree
let tree2 =
    Node( [ Node( [Value "one"; Value "two"] ) ;
        Node( [Value "three"; Value "four"] ) ] )

// function to print the binary tree
let rec printBinaryTreeValues x =
    match x with
    | BinaryNode (node1, node2) ->
        printBinaryTreeValues node1
        printBinaryTreeValues node2
    | BinaryValue x ->
        printf "%A, " x

// function to print the tree
let rec printTreeValues x =
    match x with
    | Node l -> List.iter printTreeValues l
    | Value x ->
        printf "%A, " x

// print the results
printBinaryTreeValues tree1
printfn ""
printTreeValues tree2

1, 2, 3, 4,
"one", "two", "three", "four",

// represents an XML attribute
type XmlAttribute =
    { AttribName: string;
      AttribValue: string; }

// represents an XML element
type XmlElement =
    { ElementName: string;
      Attributes: list<XmlAttribute>;
      InnerXml: XmlTree }

// represents an XML tree
and XmlTree =
  | Element of XmlElement
  | ElementList of list<XmlTree>
  | Text of string
  | Comment of string
  | Empty                                                

Active Patterns

Active patterns provide a flexible way to use F#’s pattern-matching constructs. They allow you to execute a function to see whether a match has occurred or not, which is why they are called active. Their design goal is to permit you to make better reuse of pattern-matching logic in your application.

All active patterns take an input and then perform some computation with that input to determine whether a match has occurred. There are two sorts of active patterns:

• Complete activepatterns allow you to break a match down into a finite number of cases.

• Partial active patternscan either match or fail.

First, we’ll look at complete active patterns.

open System

// definition of the active pattern
let (|Bool|Int|Float|String|) input =
    // attempt to parse a bool
    let success, res = Boolean.TryParse input
    if success then Bool(res)
    else
        // attempt to parse an int
        let success, res = Int32.TryParse input
        if success then Int(res)
        else
            // attempt to parse a float (Double)
            let success, res = Double.TryParse input
            if success then Float(res)
            else String(input)

// function to print the results by pattern
// matching over the active pattern
let printInputWithType input =
    match input with
    | Bool b -> printfn "Boolean: %b" b
    | Int i -> printfn "Integer: %i" i
    | Float f -> printfn "Floating point: %f" f
    | String s -> printfn "String: %s" s

// print the results    
printInputWithType "true"
printInputWithType "12"
printInputWithType "-12.1"

Boolean: true
String: 12
Floating point: -12.100000

type option<'a> =
    | Some of 'a
    | None

open System.Text.RegularExpressions

// the definition of the active pattern
let (|Regex|_|) regexPattern input =
    // create and attempt to match a regular expression
    let regex = new Regex(regexPattern)
    let regexMatch = regex.Match(input)
    // return either Some or None
    if regexMatch.Success then
        Some regexMatch.Value
    else
        None

// function to print the results by pattern
// matching over different instances of the
// active pattern
let printInputWithType input =
    match input with
    | Regex "$true|false^" s -> printfn "Boolean: %s" s
    | Regex @"$-?d+^" s -> printfn "Integer: %s" s
    | Regex "$-?d+.d*^" s -> printfn "Floating point: %s" s
    | _ -> printfn "String: %s" input

// print the results
printInputWithType "true"
printInputWithType "12"
printInputWithType "-12.1"                                                                              

Boolean: true
String: 12
Floating point: -12.1

Units of Measure

Units of measure are an interesting addition to the F# type system . They allow you to classify numeric values into different units. The idea of this is to prevent you from accidentally using a numeric value incorrectly—for example, adding together a value that represents inches with a value that represents centimeters without first performing the proper conversion.

To define a unit of measure, you declare a type name and prefix it with the attribute Measure. Here is an example of creating a unit of type meters (abbreviated to m):

[<Measure>]type m

To create a value with a unit, you simply postfix the value with the name of the unit in angled brackets. So, to create a value of the meter type, use the following syntax :

let meters = 1.0<m>

Now we are going to revisit the example from the “Defining Types” section, which used union types to prevent various units of volume from being mixed up. This example implements something similar using units of measure. It starts by defining a unit of measure for liters and another for pints. Then it defines two identifiers that represent different volumes: one with a pint unit and one with a liter. Finally, it tries to add these two values, an operation that should result in an error, since you can’t add pints and liters without first converting them.

[<Measure>]type liter
[<Measure>]type pint

let vol1 = 2.5<liter>
let vol2 = 2.5<pint>

let newVol = vol1 + vol2

This program will not compile, resulting in the following error:

Program.fs(7,21): error FS0001: The unit of measure 'pint' does not match the unit of measure 'liter'

The addition or subtraction of different units of measure is not allowed, but the multiplication or division of different units of measure is allowed and will create a new unit of measure. For example, you know that to convert a pint to a liter, you need to multiply it by the ratio of liters to pints. One liter is made up of approximately 1.76 pints, so you can now calculate the correct conversion ratio in the program.

let ratio =  1.0<liter> / 1.76056338<pint>

The identifier ratio will have the type float<liter/pint>, which makes it clear that it is the ratio of liters to pints. Furthermore, when a value of type float<pint> is multiplied by a value of type float<liter/pint>, the resulting type will automatically be of type float<liter>, as you would expect. This means you can now write the following program, which ensures that pints are safely converted to liters before adding them:

// define some units of measure
[<Measure>]type liter
[<Measure>]type pint

// define some volumes
let vol1 = 2.5<liter>
let vol2 = 2.5<pint>

// define the ratio of pints to liters
let ratio =  1.0<liter> / 1.76056338<pint>

// a function to convert pints to liters
let convertPintToLiter pints =
    pints * ratio

// perform the conversion and add the values
let newVol = vol1 + (convertPintToLiter vol2)

Note that in versions of F# up to and including 3.1, you have to strip off the unit of measure by casting, before printing or formatting the value using sprintf, printf, or printtfn. For example,

// stripping off unit of measure (<= F# 3.1)
printfn "The volume is %f" (float vol1)

From F# 4.0 onwards, this requirement has been removed. You can apply format placeholders like %f and %i directly to values having units of measure.

// using a format placeholder with a unit-of-measure value (>= F# 4.0)
printfn "The volume is %f" vol1

Exceptions and Exception Handling

Defining exceptions in F# is similar to defining a constructor of a union type, and the syntax for handling exceptions is similar to pattern matching.

You define exceptions using the exception keyword, followed by the name of the exception, and then optionally the keyword of and the types of any values the exception should contain, with multiple types separated by asterisks. The following example shows the definition of an exception, WrongSecond, which contains one integer value:

exception WrongSecond of int

You can raise exceptions with the raise keyword , as shown in the else clause in the following testSecond function. F# also has an alternative to the raise keyword, the failwith function, as shown in the following if clause. If, as is commonly the case, you just want to raise an exception with a text description of what went wrong, you can use failwith to raise a generic exception that contains the text passed to the function, like so:

// define an exception type
exception WrongSecond of int

// list of prime numbers
let primes =
    [ 2; 3; 5; 7; 11; 13; 17; 19; 23; 29; 31; 37; 41; 43; 47; 53; 59 ]

// function to test if current second is prime
let testSecond() =
    try
        let currentSecond = System.DateTime.Now.Second in
        // test if current second is in the list of primes
        if List.exists (fun x -> x = currentSecond) primes then
            // use the failwith function to raise an exception
            failwith "A prime second"
        else
            // raise the WrongSecond exception
            raise (WrongSecond currentSecond)
    with
    // catch the wrong second exception
    WrongSecond x ->
        printf "The current was %i, which is not prime" x

// call the function
testSecond()

As shown in testSecond, the try and with keywords handle exceptions. The expressions that are subject to error handling go between the try and with keywords, and one or more pattern-matching rules must follow the with keyword. When trying to match an F# exception, the syntax follows that of trying to match an F# constructor from a union type. The first half of the rule consists of the exception name, followed by identifiers or wildcards to match values that the exception contains. The second half of the rule is an expression that states how the exception should be handled. One major difference between this and the regular pattern-matching constructs is that no warning or error is issued if pattern matching is incomplete. This is because any exceptions that are unhandled will propagate until they reach the top level and stop execution. The example handles exception wrongSecond, while leaving the exception raised by failwith to propagate.

F# also supports a finally keyword , which is used with the try keyword. You can’t use the finally keyword in conjunction with the with keyword. The finally expression will be executed whether or not an exception is thrown. The following example shows a finally block being used to ensure a file is closed and disposed of after it is written to:

// function to write to a file
let writeToFile() =
    // open a file
    let file = System.IO.File.CreateText("test.txt")
    try
        // write to it
        file.WriteLine("Hello F# users")
    finally
        // close the file, this will happen even if
        // an exception occurs writing to the file
        file.Dispose()

// call the function
writeToFile()

Lazy Evaluation

Lazy evaluation goes hand in hand with functional programming . The theory is that if there are no side effects in the language, the compiler or runtime is free to choose the evaluation order of expressions.

As you know, F# allows functions to have side effects, so it’s not possible for the compiler or runtime to have a free hand in function evaluation; therefore, F# is said to have a strict evaluation order, or to be a strict language. You can still take advantage of lazy evaluation, but you must be explicit about which computations can be delayed—that is, evaluated in a lazy manner.

You use the keyword lazy to delay a computation (invoke lazy evaluation). The computation within the lazy expression remains unevaluated until evaluation is explicitly forced with the force function from the Lazy module. When the force function is applied to a particular lazy expression, the value is computed, and the result is cached. Subsequent calls to the force function return the cached value–whatever it is—even if this means raising an exception.

The following code shows a simple use of lazy evaluation:

let lazyValue = lazy ( 2 + 2 )
let actualValue = Lazy.force lazyValue

printfn "%i" actualValue

The first line delays a simple expression for evaluation later. The next line forces evaluation. Finally, the value is printed.

The value has been cached, so any side effects that take place when the value is computed will occur only the first time the lazy value is forced. This is fairly easy to demonstrate, as shown by this example:

let lazySideEffect =
    lazy
        ( let temp = 2 + 2
          printfn "%i" temp
          temp )

printfn "Force value the first time: "
let actualValue1 = Lazy.force lazySideEffect
printfn "Force value the second time: "
let actualValue2 = Lazy.force lazySideEffect

In this example, a lazy value has a side effect when it is calculated: it writes to the console. To show that this side effect takes place only once, it forces the value twice. As you can see from the result, writing to the console takes place only once:

Force value the first time:
4
Force value the second time:

Laziness can also be useful when working with collections. The idea of a lazy collection is that elements in the collection are calculated on demand. Some collection types also cache the results of these calculations, so there is no need to recalculate elements. The collection most commonly used for lazy programming in F# is the seq type, a shorthand for the BCL’s IEnumerable type. seq values are created and manipulated using functions in the Seq module. Many other values are also compatible with the type seq; for example, all F# lists and arrays are compatible with this type, as are most other collection types in the F# libraries and the BCL.

Possibly the most important function for creating lazy collections, and probably the most difficult to understand, is unfold. This function allows you to create a lazy list. What makes it complicated is that you must provide a function that will be repeatedly evaluated to provide the elements of the list. The function passed to Seq.unfold can take any type of parameter and must return an option type. An option type, recall, is a union type that can be either None or Some(x), where x is a value of any type. In the context of Seq.unfold, None is used to represent the end of a list. The Some constructor must contain a tuple. The first item in the tuple represents the value that will become the first value in the list. The second value in the tuple is the value that will be passed into the function the next time it is called. You can think of this value as an accumulator.

The next example shows how this works. The identifier lazyListcontains three values. If the value passed into the function is less than 13, it appends the list using this value to form the list element, and then adds 1 to the value passed to the list. This will be the value passed to the function the next time it is called. If the value is greater than or equal to 13, the example terminates the list by returning None.

// the lazy list definition
let lazyList =
    Seq.unfold
        (fun x ->
            if x < 13 then
                // if smaller than the limit return
                // the current and next value
                Some(x, x + 1)
            else
                // if great than the limit
                // terminate the sequence
                None)
        10

// print the results
printfn "%A" lazyList

This example, when executed, returns the following:

10
11
12

Sequences are useful to represent lists that don’t terminate. A nonterminating list can’t be represented by a classic list, which is constrained by the amount of memory available. The next example demonstrates this by creating fibs, an infinite list of all the Fibonacci numbers . To display the results conveniently, the example uses the function Seq.take to turn the first 20 items into an F# list, but carries on calculating many more Fibonacci numbers, as it uses F# bigint integers, so it is not limited by the size of a 32-bit integer.

// create an infinite list of Fibonacci numbers
let fibs =
    Seq.unfold
        (fun (n0, n1) ->
            Some(n0, (n1, n0 + n1)))
        (1I,1I)

// take the first twenty items from the list
let first20 = Seq.take 20 fibs

// print the finite list
printfn "%A" first20

This example, when executed, returns the following:

[1I; 1I; 2I; 3I; 5I; 8I; 13I; 21I; 34I; 55I; 89I; 144I; 233I; 377I; 610I; 987I;
1597I; 2584I; 4181I; 6765I]

Note that both of these sequences could also be created using the list comprehension discussed earlier in this chapter. If list comprehensions are based on sequences, they are automatically lazy.

Summary

In this chapter, you looked at the major functional programming constructs in F#. This is the core of the language, and I hope you’ve developed a good feel for how to approach writing algorithms and handling data in F#. The next chapter covers imperative programming, and you’ll see how to mix functional and imperative programming techniques to handle tasks such as input and output.