Re: Intervention needed?

[Optikos <optikos@verizon.net>]

On Saturday, March 23, 2019 at 9:59:38 AM UTC-4, Jere wrote:
> On Saturday, March 23, 2019 at 3:53:34 AM UTC-4, Randy Brukardt wrote:
> > "Jere" wrote in message 
> > ...
> > > Not really.  In Rust they don't even use cursors.  They go straight to
> > > iterators.  On top of that, the combination of being able to specify the
> > > lifetime of all of your variables (if you need to) and the ownership rules
> > > gives them 100% safety from dangling references when they create and use
> > > those iterators.
> > 
> > If you don't store any cursors and just use iterators in Ada, you have the 
> > same level of safety: the tampering checks prevent any problems with 
> > iterators. (Well, unless you turn them off, of course, but if you remove the 
> > seatbelts, you can't much complain that they didn't protect you.)
> > 
> > I'd be interested to find out how Rust deals with the need to designate 
> > individual elements of a container (which is the primary reason that Ada 
> > exposes cursors).
> > 
> >                        Randy.
> 
> Keep in mind the rust paradigm is very different than Ada's.  When you
> obtain an iterator of a container, you borrow ownership of the container.
> At that point it is impossible to tamper with the container because it
> is a compile time error to modify the container when something else has 
> ownership of it. It's a compile time version of Ada's tampering checks
> using an ownership model.  If you need to remove items as you iterate, 
> there is a consuming version of the iterator that allows for that. It
> handles all the logic of keeping the iterator correct as you remove
> items.  If you need to remove only specific items, it provides 
> functions for that as well (but you would not iterate while using 
> them do to the ownership/borrowing rules).
> 
> Additionally, Rust allows you to specify the lifetime of the iterator, 
> the lifetime of the reference to the item, and how they relate to the
> lifetime of the container so that the compiler can guarantee that
> nothing dangles (it's a relative specification..container has lifetime 
> A and everything else has either A or a lifetime relative to A).

This overt specification of lifetime (vis a vis Ada's multiple fixed assumptions of lifetime) seems to be Rust's key innovative contribution that Ada lacks.  An analogous key contribution to humankind is that ATS2 and ATS3 base their guaranteed no-dangling-pointer correctness on “type* views” (and their type@address primitives in “viewtypes”) which are quite different syntactically than Rust's overt specification of lifetime but in the end provide to ATS a direct measure of extent of lifetime implied by (and directly derived from) what depending on what for how long.

* What ATS calls type is a branch of type-theory from higher mathematics.  What we call type in programming is generally called “sort” in ATS, where ATS's usage of sort has the meaning of “kind” or “category” as in ‘what sort of programmer are you?’, but ATS's usage of sort does not have the meaning of “order arrangement” as in the SQL-statement clause SORT.