Blog Post: Lifetime Parameters in Rust

[shelby3]

@steveklabnik

@shelby3

I am thinking borrowed immutable references are shared ownership, and mutable borrows are exclusive ownership. I don't understand the mention of Box.

References do not have ownership, at all. Ownership implies that when the owner goes out of scope, the resource is freed, but this is very much not the case with references.

I was thinking of Box as just another reference that can have shared or exclusive ownership. My concept was that 'borrowed' means all the references are sharing. I realize my conceptualization was incorrect, because the stack based borrowing always has to unwind to only the instance that created the Box reacquiring exclusive ownership, unless of course it had moved that ownership.

@troplin

Box is the prototype of unique ownership. It's the equivalent of the C++ std::unique_ptr.

But I still don't understand the distinction between a Box and a reference & in the context of ownership. Seems I can move ownership from a Box to a &? I was thinking of a Box as only the way to construct object on the heap. Is my function required to input the type of Box when it demands the ownership be moved to the function?

@krdln

@troplin

@shelby3

Am I correct to understand that you want to use Rc / Arc where you need shared mutable references where the invariants of safe mutable coordination can't be modeled by the low-level lifetimes checker? So in order words, your Rc / Arc is unsafe (i.e. not checked by the compiler) from the standpoint of mutability invariants.

No, Rc / Arc is only for immutable references AFAIK. (I don't have much experience using them). If you need mutable shared ownership you have to use Cell / RefCell (I have even less experience using those).

To explain more, Rc and Arc provide shared ownership while Cell, RefCell and atomics provide shared mutability. Sometimes you just need shared mutability, sometimes just shared ownership, and when you need both, then you use something like Rc<Cell<T>>.

Rust checks two dimensions of resource lifetimes safety: allocation and mutability.

So we forsake Rust's compile-time safety when the allocation and/or mutability sharing can't be modelled by Rust's stack based borrows.

Afaics, the stack is the key word that we needed to introduce to distil to the generative essence.

Edit: or more accurately stack based and block scope based within a function. And there there is also the issue of closures and Box inside objects that out live stack frames.