Re: Intervention needed?

[Jere <jhb.chat@gmail.com>]

On Tuesday, March 19, 2019 at 6:13:20 PM UTC-4, Randy Brukardt wrote:
> 
> The whole point of the Rust scheme as I understand it is to avoid such 
> things. In particular, you can never have a pointer with multiple owners. 
> The "borrow" scheme as I understand it allows the owner to be temporarily 
> transfered (so you can walk lists, for instance), but long-term storage of 
> such pointers is simply not allowed. You can't build a cursor that way (nor 
> a doubly-linked list). Perhaps the Rust people have gone beyond simple 
> borrow semantics -- I don't know.
> 
Rust has a couple levels of ownership and borrowing.  It employs both
spacial and temporal ownership rules.  The 90% solution uses spacial
rules (the ones you are most likely familiar with).  For managing
data across threads or doing complex data types, Rust also provides
temporal ownership/borrowing.  Think of the same distinction Ada has
for named access types vs anonymous access types. You can catch a lot
more at compile time with named access types, but anonymous access types
can potentially have more runtime checking.  In Rust, the standard reference
scheme you are probably familiar with employ spacial ownership.  If you
need temporal ownership, then for single threaded you use things like
the RC<> generic (reference counted), and for multi-threaded you use things
like the ARC<> generic (atomic reference counted).  There are other things
of similar nature.  These employ temporal rules, which can potentially 
require runtime checks, though the presence of the spacial ownership rules
can help optimize out a lot of the run time checks.  I kind of mentioned 
this above, but the spacial and temporal rules aren't mutually exclusive.
They can work together when needed.

I don't know if you saw my earlier question to you (from a while back in
this email chain), but do you know if Tucker was looking at the recent
upgrades to the ownership scheme?  Some of them may (or may not) be useful
for Ada (if that gets implemented).  In particular, in the old ownership
scheme, if you needed to use a throwaway variable to capture a return result
in Rust, you couldn't reborrow again until that throwaway variable went
out of scope.  In the updated system, they are able to tell it is throwaway
and allow for the ownership transfer.  I was thinking about this for
Ada particularly since we are required to capture function returns into
some sort of variable.