, In this segment, I want to introduce mcons cells, which are separate from cons cells, and the difference is an mcons cell supports changing the contents of the car encoder fields. So what if you had a cons cell, like we've been studying, like we've learned is just a pair, and you wanted to change its car, so it didn't have 42, it had 43 or you wanted to change its cdr so it didn't have null, it had some other value. Well, in Racket it turns out there is no way to do that and this is the biggest change between Racket and its predecessors like Scheme and Lisp. And the reason why they made this change is so we could use cons cells to make pairs and lists that were immutable and get all the advantages we had in ML when we saw that lists and tupples were immutable. The biggest advantage we'd like to emphasize is that it made aliasing irrelevant. It did not matter if one part of a list was aliased with another part of another list, because no one would have ever been able to tell the difference, because we couldn't update things. We made a big deal about this back in section one and it's nice that we can program with cons cells in Racket and get the same advantages. As a minor side point, it turns out in a dynamically typed language like Racket, there is another advantage, which is the implementation of the list question mark procedure we saw in the previous segment can be more efficient. Because, when we create a cons cell, we know at that moment whether or not it'll be a list and it will always be a list because no one can ever change any of the contents of any of the cons cells that are relevant to it being a list or not. And so, the implementation is able to record that fact and not have to implement list? by running down the entire list, seeing if the list is actually proper or not. But, suppose that you did want to mutate things, how might you go about it? What would work? What would not? And this is important, because we are going to have some programming idioms come up where mutation is g oing to be useful and its typical limited only because we really want to do it way. So the first thing I want to emphasize is that set bang really does not mutate cons cells. So here is a little list I've defined, I've bounded to x, x holds the list 14. If I say that y is now x, then y also holds the list 14. suppose I said set bang x to be some different list. We saw set bang. What that does is change x to refer to some new and different thing. So if I ask what x is, I get this new list. But if I ask what y is, it's still the list holding 14, because when I defined y, previously, I looked up x, I got the current value for x 14, and null, and so that's what y is. Set bang changed x, but it did not change the cons cell that x referred to. There is still a cons cell out there with 14 in the car and null in the cdr, and so if I ask car of y, I get 14, x now refers to a different cons cell, so car of x returns 42. So if we wanted to change the contents of a cons cell, something, so that if say z and x both referred to the same thing, and then I wanted to update that thing, so that the car the cdr would be different, that is what Racket does not support. So you might think you could do something like oh, let's change the car of x to be 45 and that's just not what set bang does. Set bang only works on identifiers, on variables, and change what, changes what they refer to. Now, Scheme, the predecessor to Racket, had a feature set-car! that would do exactly kind of what we want. It would look up x in the environment, get a cons cell, and mutate the car field of that cons cell to be 45. And it's an advantage of Racket that we cannot do that set-car! simply does not exist, but what if we want it to? Well, Racket understands there are situations where you may want that, and so, it defined a different built-in data type for that thing, and the function that you can use is mcons, which is just like cons except it does not make a cons cell, it makes an mcons cell. So here is a little example wher e I'm actually going to make two mcons cells, where the outer one has a car of 1 and a cdr of true that is itself an mcons cell, and then the nested mcons cell has a car of true and a cdr of hi. Now, you can't ask car of an mpr, you can't ask cdr of an mpr, but you can ask mcar of an mpr and mcdr of an mpr. And of course, since the mcdr in this case is itself a cons cell, we could ask something like mcar of mcdr of mpr and that would get out the Boolean true. Now, the difference between mcons and cons, is that, these things are mutable and there is in fact something mcdr-bang!, right, mcdr!, I could apply to the cons cell in mpr changes to 47, and now sorry mpr holds the cons cell where the car is one and the cdr is 47. Alright? I could change it back. Right? I could change it back to mcons #t hi, alright, and now mpr is back like this. I could even set-mcar! of mcdr of mpr to say 14. And now, if I ask mpr, you'll see that the car of the cdr of mpr is now 14. It's been changed. Okay? So this is how it works. you cannot mix and match things as I pointed out, so length is a wonderful built-in function that works just fine on lists like this, so this is a plain old list that returns true. Length gives an error on improper lists like we saw in the previous section. Length also gives an error on an mcons even if that, you're using mcons in a way that is like proper lists. You cannot use mcons to make proper lists. Length requires a proper list and so you're not allowed to mix and match these things. And of course, something like mcar bang is not going to work on a cons cell that is not an mcons cell. Okay? So that's the idea. Let me just flip back to the slides to emphasize it. All we've really done is introduce a new set of functions and constructs that are separate from cons cells. We make a mutable cons cell with mcons, get its first thing with mcar, second thing with mcdr. We can find out if we have one, this is the one thing I didn't demonstrate for you with mpair?. Set the content, set the car field with set-mcar! and set the cdr field with set-mcdr!. So when we need a mutable data structure Something that has multiple pieces whose content can change we'll use mcon cells, and when we do not want mutability, we'll use regular cons cells.
