Re: Intervention needed?

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

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).

If you were instead referring to indexing the container, for things
like vector, Rust looks to see if the container implements the Index
trait, and, if so, allows for the user to use the index operation
on the container.  It's very similar to making a cursor and setting the
variable_indexing aspect and constant_indexing aspect, except rust doesn't
expose the underlying equivalent cursor type.  So you either work
with Indexes or Iterators depending on your need.