That is not what I'm talking about. e.g. (in Rust) let map: TreeMap<uint, SomeHugeThing> = make_map(); let value: Option<&SomeHugeThing> = map.find(&123);

That is not what I'm talking about. e.g. (in Rust) let map: TreeMap<uint, SomeHugeThing> = make_map(); let value: Option<&SomeHugeThing> = map.find(&123); `map` is a (recursive) tree that associates a `uint` key with a value of type `SomeHugeThing`, imagine that is, e.g. 1KB, or otherwise expensive to copy. The `value` is a direct pointer to the memory of the value associated with the key 123 (if it exists), that is, it is extremely cheap to manipulate `value` because it is basically a machine pointer directly into the memory of the TreeMap. Rust gives you the power for that to be perfectly safe without a GC: there's no risk that changes to the `map` structure will cause the `value` pointer to be invalidated. As far as I know, Ada etc. do not allow for this without a GC. That is, there's no way to have a safe pointer directly into the memory controlled by some dynamic data structure. Instead, one would have to search the `map` each time the value is wanted, or turn on GC. > its "unsafe" mechanism needs to be used in order to implement performant data structures for this reason. Implement some performant data structures. There's a lot of data structures that can be implemented performantly without begin intrusive (sure, one might want to use `unsafe` occasionally to optimise them fully, but the `unsafe` is almost always not being used to make it intrusive). Also, I don't understand the relevance of that link, the top comment (which is mine, btw) clearly demonstrates that `unsafe` is not necessary.