[MUSIC] In this segment, we're going to take a brief break from closures. To, for the first time in the course, actually show you something mutable. Show you an assignment statement. So, I have certainly emphasized throughout this course, that you do not need mutable data structures. That they cause lots of problems. There are benefits to avoiding them, that immutability is a great default. But I don't believe that there's always a need to avoid mutation. There are situations where what you are programming. The model of the thing that your computation is about has certain inherent updates to it. There's some state in the world, and that state needs to be updated for everyone who has access to that state to see. That's the natural way to think about your problem. Then using mutation makes sense. The problem with most programming languages is that they make everything mutable. So you have to worry that things should be changed even when, in your model of what the computation should be doing, there's no reason it should ever change. So ML does a nice job of supporting mutation, but not for variables, not for tuples, not for lists. For things you want mutable you have to use a separate language construct called a reference, and only the contents of references can be updated. So I'm showing this to you now because the next closure idiom I want to show you, I'm going to use this in my example. So that's the reason for the ordering. You still did not get to use mutation on your homework. It's an important thing. You need plenty of practice for this mutation free programming. And none of the things we are asking you to program, benefit from mutation, or any easier to do if you are allowed to use references, so you're not, okay? So, here is everything you need to know about these mutable references. There's a new kind of type, t ref, where t is any type, the same way t list is a type for any type t, t ref is. So the type of a reference whose content is a t. So an int ref would have contents that are ints. We have 3 new primatives in the language. Functions we can use, to use references. We make a new reference with the ref function, so this is on the left of an expression. It's a little confusing, we reuse the same thing we used in the type. But the way this works is, you evaluate e to a value. And then you create a new reference and the result is a pointer to that reference, if you will. It's a thing that refers to that reference. So, you now have this thing whose contents are initially whatever e evaluated to. Now those contents can change, cause this is mutation. We change the contents of a reference with the =: operator. This is our assignment statement, =.: What we do is we evaluate 1 to a reference. E2 to some value, and then we update the contents of the reference to that value, so the thing e1 refers to has its contents changed to be the result of e2. In terms of type checking, perhaps not surprisingly, e1 has to be a t ref for sum type t, and e2 has to be a t. We don't allow the contents of a reference is type to change. The type can't change, we have to replace 1 int with another int or 1 string with another string. Finally, if you want to read the contents of a reference, as opposed to writing them or updating them, this is what we use the exclamation point for. So, many languages use exclamation points for negation. ML uses it for retreiveing the contents of a reference. So we evaluate e to a value, it better be some t ref, and then bang of that, the exclamation point of that retrieves the t, retrieves the value in the reference. So let's see an example. it's a silly example, but it emphasizes what is different about these things. So on the first line here you see, val x = ref 42. That is going to go and creat some new location whos contents can change, initialize those contents with 42 and return a reference, an arrow in the picture over on the left to that thing. I din't write the 42 in the box but you should imagine that at this point we've returned X is bound to. This arrow that refers to this box that holds a 42. The next line val y = ref 42, that will make a new box. Initialize it's contents to 42, the result of ref 42 is that arrow pointing to it, and then the variable y now refers to that thing. When we say val z = x, well we evaluate x. We look up x in our dynamic environment, we get the arrow that it points to. And so z and x now refer to the same reference, they are aliases. They both refer to that. So, when you see here, x:=43, which is the next thing this file does. This Bell underscore is just an idiom for, do it. And I don't care about the result. because the result here is not going to be bound to any variable. So we say x =: 43. Now, this left box. Oop, pardon me, holds 43, alright? So on this last line, when we say bang y. We retrieve the contents over here. We get a 42. We retrieve the contents over here, we get 43. 42 + 43 is 85. Notice that x, y, and z all have type int ref. They refer to a mutable location holding an int. You cannot apply addition to an int ref, that doesn't make any sense. The only operation you can do in a ref are assignment with =: and the reference with exclamation point, so you can't write x + 1. You have to write x! + 1. That's keeping separate the notion of a mutable location from the notion of an integer and that's a good thing. In fact as I want to emphasize here x, is immutable. The variable x, the variably y, the variable z, those always refer to the same reference they did when they were created. x holds, is bound to, this arrow, and will always be, this arrow. It's the contents of the thing the arrow is pointing to, that can change. So once you're using mutation, just like in any other programming language, you have to deal with potential aliasing. That is why when we assigned x, the result we get henceforth for exclamation point z changes. Presumably, if you're using mutation, you want to think about stuff like that, and if you don't want to think about stuff like that, don't use mutation. All right. So you should really think of these references as first-class values. You can pass them around, you can do, you can pass a ref to a function, you can return a ref from a function. And for those of you more used to, programming in other languages, Java, C, C++, whatever, you could think of a reference as a little mutable object. It just has one field, so since it only has one field := updates that field, exclamation point reads that field. We don't need to give a name to the field because references only have one. If you wanted multiple fields you could have your reference hold a tuple and then you could update it to point to a different tuple. It's not the tuple that's mutable, it's always just the reference. Contents. And those are minimal references. As I mentioned, we will not use them very much in the course, but we need them a little a bit for the next segment so I thought I would show them to you a bit more generally.
