BTW, is this actually safe? it seems a lot like it's a data-race.

E.g. `&'static [int]` is certainly `Share`, so something
```rust
static mut THING: &'static [int] = &[];
static A: &'static [int] = &[1,2,3,4];
static B: &'static [int] = &[5];
fn main() {
    spawn(proc() THING = A);
    spawn(proc() THING = B);

    sleep(100);
    println!("{}", THING);
}
```

The writes to `THING`, are, in general, writing two words, the pointer (`.ptr`) and the length (`.len`) of the slice. Imagine if the writes occur in the order

- `THING.ptr = A.ptr`
- `THING.ptr = B.ptr`
- `THING.len = B.len`
- `THING.len = A.len`

(that is, the `B` writes occur completely between the `A` ones.)

You're left with `THING = (B.ptr, A.len)` i.e. it thinks the vector is of length 4... but `B` is only pointing to data of length 1.

Am I missing something?