Thus far, we've been working with the purely functional fragment of SML. That is, we've been working with the subset of the language that does not include computational effects (also known as side effects) other than printing. In particular, whenever we coded a function, we never changed variables or data. Rather, we always computed new data. For instance, when we wrote code for an abstract data type such as a stack, queue, or dictionary, the operations to insert an item into the data structure didn't effect the old copy of the data structure. Instead, we always built a new data structure with the item appropriately inserted. (Note that the new data structure might refer to the old data structure, so this isn't as inefficient as it first sounds.)
For the most part, coding in a functional style (i.e., without side effects) is a "good thing" because it's easier to reason locally about the behavior of the code. For instance, when we code purely functional queues or stacks, we don't have to worry about a non-local change to a queue or stack. However, in some situations, it is more efficient or clearer to destructively modify a data structure than to build a new version. In these situations, we need some form of mutable data structures.
Like most imperative programming languages, SML provides support for mutable data structures, but unlike languages such as C, C++, or Java, they are not the default. Thus, programmers are encouraged to code purely functionally by default and to only resort to mutable data structures when absolutely necessary. In addition, unlike imperative languages, SML provides no support for mutable variables. In other words, the value of a variable cannot change in SML. Rather, all mutations must occur through data structures.
There are only two built-in mutable data structures in SML: refs and
arrays. SML supports imperative programming through the primitive parameterized ref
type. A value of type "int ref" is a pointer to a location in memory,
where the location in memory contains an integer. It's analogous to "int*"
in C/C++ or "Integer" in Java (but not "int" in Java).
Like lists, refs are polymorphic, so in fact, we can have a ref (i.e., pointer)
to a value of any type.
A partial signature for refs is below:
signature REF = sig type 'a ref (* ref(x) creates a new ref containing x *) val ref : 'a -> 'a ref (* !x is the contents of the ref cell x *) val op ! : 'a ref -> 'a (* Effects: x := y updates the contents of x * so it contains y. *) val op := : 'a ref * 'a -> unit end
A ref is like a box that can store a single value. By using the :=
operator, the value in the box can be changed as a side effect. It is important
to distinguish between the value that is stored in the box, and the box itself.
A ref is the simplest mutable data structure. A mutable data structure is
one that be changed imperatively, or mutated.
The following code shows an example where we use a ref:
let val x : int ref = ref 3 val y : int = !x in x := (!x) + 1; y + (!x) end
The code above evaluates to 7. Let's see why: The first line "val x:int ref = ref 3" creates a new ref cell, initializes the contents to 3, and then returns a reference (i.e., pointer) to the cell and binds it to x. The second line "val y:int = !x" reads the contents of the cell referenced by x, returns 3, and then binds it to y. The third line "x := (!x) + 1;" evaluates "!x" to get 3, adds one to it to get 4, and then sets the contents of the cell referenced by x to this value. The fourth line "y + (!x)" returns the sum of the values y (i.e., 3) and the contents of the cell referenced by x (4). Thus, the whole expression evaluates to 7.
Here's an example of a mutable stack build using refs:
signature MUTABLE_STACK = sig (* An 'a mstack is a mutable stack of 'a elements *) type 'a mstack (* new() is a new empty stack *) val new : unit -> 'a mstack (* Effects: push(m,x) pushes x onto m *) val push : 'a mstack * 'a -> unit (* pop(m) is the head of m. * Effects: pops the head off the stack. *) val pop : 'a mstack -> 'a option end structure Mutable_Stack :> MUTABLE_STACK = struct (* A mutable stack is a reference * to the list of values, with the top * of the stack at the head. *) type 'a mstack = ('a list) ref fun new():'a mstack = ref([]) fun push(s:'a mstack, x:'a):unit = s := x::(!s) fun pop(s:'a stack):'a option = case (!s) of [] => NONE | hd::tl => (s := tl; SOME(hd)) end
A good exercise for you is to implement mutable versions of queues, priority queues, dictionaries, or any other data structure that we've seen in class thus far using refs.
Another important kind of mutable data structure that SML provides is
the array. Arrays generalize refs in that they are a sequence of memory
locations, where each location contains a different value. We can think of
a ref cell as an array of size 1. The type t array is in
fact very similar to the Java array type t[]. Here's a partial
signature for the builtin Array structure for SML. Note that you have to
"open Array" explicitly to use the operations or else
write Array.foo when you want to use the operation foo.
signature ARRAY = sig (* Overview: an 'a array is a mutable fixed-length sequence of * elements of type 'a. *) type 'a array (* array(n,x) is a new array of length n whose elements are * all equal to x. *) val array : int * 'a -> 'a array
(* fromList(lst) is a new array containing the values in lst *) val fromList : 'a list -> 'a array
exception Subscript (* indicates an out-of-bounds array index *)
(* sub(a,i) is the ith element in a. If i is * out of bounds, raise Subscript *) val sub : 'a array * int -> 'a
(* update(a,i,x) * Effects: Set the ith element of a to x * Raise Subscript if i is not a legal index into a *) val update : 'a array * int * 'a -> unit
(* length(a) is the length of a *) val length : 'a array -> int ... end
See the SML documentation for more information on the operations available on arrays.
Notice that we have started using a new kind of clause in the specification, the effects clause. This clause specifies side effects that the operation has beyond the value it returns. When a routine has a side effect, it is useful to have the word "Effects:" explicitly in the specification to warn the user of the side effect.