Project Verona FAQ

> Verona uses regions, groups of objects, as its fundamental concept of ownership. Rather than specifying object ownership as a reference owns an object, we generalise this a little to a reference can own a region, where a region is a group of objects. Within a region, any object can refer to any other object in that region. There is no restriction on the topology. When the owning reference to a region goes away then the entire region is collected.

In Rust, objects referenced by owning pointers form a tree--there is a unique pointer to each object. In Verona, an owning pointer references a sub-graph of the heap that is disjoint except for the path through the owning pointer. The sub-graph can be reclaimed when the owning pointer goes out of scope. Within the sub-graph, there are no restrictions, so you can have cyclic structures like doubly-linked lists. In Rust, by contrast, having a doubly-linked list requires either raw pointers and unsafe, or some sort of reference-counted pointer.

You can use regions to statically enforce the property that other pointers into a region, for example from the stack, cannot outlive the owning pointer for the region (and thus the region itself). Allowing such temporary aliasing of objects potentially eliminates or at least reduces the need for a borrowing mechanism. In Rust, for example, you run into borrowing as soon as you try to iterate over a linked list. If you allow temporary aliasing (and ensure that the iterator pointer cannot outlive the region by restricting its scope to a context where the region is live) you don't need a borrowing concept.

Using regions this way addresses one of the vague dissatisfaction I have with Rust, which is you need to introduce borrowing just to iterate over a singly linked list, and you need raw pointers and unsafe, or a special mechanism that uses unsafe under the hood, to have doubly linked lists. On the other hand, this creates problems as well. For example, within a region, you can't delete an object when the pointer to it goes out of scope, because it may be referenced from another object. So while you can always safely reclaim a region when the owning pointer goes out of scope, you can produce unbounded memory use by creating objects within regions. (As far as I can tell, Verona doesn't attempt to address that issue, yet.)

https://news.ycombinator.com/item?id=22074707

https://news.ycombinator.com/item?id=21682867