Defining Mutable Record Types in Font

Making Data Matrix ECC200 in Font Defining Mutable Record Types

In 3, when you first met record types, I did not discuss how to update their fields. This is because record types are immutable by default. F# provides special syntax to allow the fields in record types to be updated. You do this by using the keyword mutable before the field in a record type. I should emphasize that this operation changes the contents of the record s field rather than changing the record itself. #light type Couple = { her : string ; mutable him : string } let theCouple = { her = "Elizabeth Taylor " ; him = "Nicky Hilton" } let print o = printf "%A\r\n" o let changeCouple() = print theCouple; theCouple.him <- "Michael Wilding"; print theCouple; theCouple.him <- "Michael Todd"; print theCouple; theCouple.him <- "Eddie Fisher"; print theCouple;

theCouple.him <print theCouple; theCouple.him <print theCouple; theCouple.him <print theCouple; theCouple.him <print theCouple changeCouple()

"Richard Burton"; "Richard Burton"; "John Warner"; "Larry Fortensky";

The results are as follows: {her {her {her {her {her {her {her {her = = = = = = = = "Elizabeth "Elizabeth "Elizabeth "Elizabeth "Elizabeth "Elizabeth "Elizabeth "Elizabeth Taylor Taylor Taylor Taylor Taylor Taylor Taylor Taylor "; "; "; "; "; "; "; "; him him him him him him him him = = = = = = = = "Nicky Hilton"} "Michael Wilding"} "Michael Todd"} "Eddie Fisher"} "Richard Burton"} "Richard Burton"} "John Warner"} "Larry Fortensky"}

This example shows a mutable record in action. A type, couple, is defined where the field him is mutable but the field her is not. Next, an instance of couple is initialized, and then you change the value of him many times, each time displaying the results. I should note that the mutable keyword applies per field, so any attempt to update a field that is not mutable will result in a compile error; for example, the next example will fail on the second line: #light theCouple.her <- "Sybil Williams"; print_any theCouple When attempting to compile this program, you ll get the following error message: prog.fs(2,4): error: FS0005: This field is not mutable

The ref type is a simple way for a program to use mutable state, that is, values that change over time. The ref type is just a record type with a single mutable field that is defined in the F# libraries. Some operators are defined to make accessing and updating the field as straightforward as possible. F# s definition of the ref type uses type parameterization, a concept introduced in the previous chapter, so although the value of the ref type can be of any type, you cannot change the type of the value once you have created an instance of the value.

Creating a new instance of the ref type is easy; you use the keyword ref followed by whatever item represents the value of ref. The next example is the compiler s output (using the i option, which shows that the type of phrase is string ref, meaning a reference type that can contain only strings): let phrase = ref "Inconsistency"

val phrase : string ref This syntax is similar to defining a union type s constructors, also shown in the previous chapter. The ref type has two built-in operators to access it; the exclamation point (!) provides access to the value of the reference type, and an operator composed of a colon followed by an equals sign (:=) provides for updating it. The ! operator always returns a value of the type of the contents of the ref type, known to the compiler thanks to type parameterization. The := operator has type unit, because it doesn t return anything. The next example shows how to use a ref type to total the contents of an array. On the third line of totalArray, you see the creation of the ref type. In this case, it is initialized to hold the value 0. On the fifth line, you see the ref type being both accessed and updated. First, ! is used to access the value with the ref type; then, after it has been added to the current value held in the array, the value of the ref type is updated through the use of the := operator. Now the code will correctly print 6 to the console. #light let totalArray () = let a = [| 1; 2; 3 |] let x = ref 0 for n in a do x := !x + n print_int !x print_newline() totalArray() The result is as follows: 6

I Caution If you are used to programming in one of the C family of programming languages, you should be careful here. When reading F# code, it is quite easy to misinterpret the ref type s ! operator as a Boolean not operator. F# uses a function called not for Boolean not operations.