Add freeze operator

[eholk]

It'd be nice to be able to treat things as const. Since this involves changing the type, it will probably require language support, although it might be possible to do it with reflection.

[eholk]

@graydon suggests calling it const as an expression.

[nikomatsakis]

My current thoughts on this are that freezing and thawing are kind of unnecessary, but we need to make a few changes to mutability and unique ptrs to make this all work. Right now, mutability for default fields (those without an explicit mut qualifier) is inherited from the container. So if you write:

let mut v = {x: 3, y: 4};

You can indeed mutate v.x and v.y even though the fields are not declared mutable. This seems surprising at first but is a logical consequence of the variable v being mutable; after all, if I wanted to do v.x = x1 I could always write v = {x: x1 with v}. However, if you write:

let mut v = ~{x: 3, y: 4};

then, currently, x and y are truly immutable. This is true despite the fact that v is a unique box, and hence I can write something like v = ~{x: x1 with *v} which is basically the same as what we saw before in effect. At some point,
@pcwalton and I both independently came to the conclusion that we ought to "inherit" mutability through unique pointers in the same way.

We also already have the rule that borrowck allows you to borrow the contents of a mutable unique ptr as immutable. That is, we can do something like this:

let x: ~mut int = ~mut 5;
let y: &int = &*x;       // *Immutable* int

This works because borrowck will detect and prevent any attempt to modify *x while y is live.

Anyway, if we did this, then properly designed data structures can be "frozen" and "thawed" in a rather automatic way, just by borrowing and moving them. At least I think they can. I'll write up an example in a gist and post it.

[nikomatsakis]

Here is a gist explaining the idea in a bit more detail: https://gist.github.com/3130874

[nikomatsakis]

The send_map module shows how this can work now. Fixed.