Re: Intervention needed?

["Randy Brukardt" <randy@rrsoftware.com>]

"Optikos" <optikos@verizon.net> wrote in message 
news:de2f5462-fa10-4fdf-97a6-99989e40c697@googlegroups.com...
On Tuesday, March 19, 2019 at 6:13:20 PM UTC-4, Randy Brukardt wrote:
>> Baloney. The cursor object still exists, and someone can still try to use
>> it. Yes, you'll get an ...exception... rather than erroneous execution
>
>No, you have it all wrong ...there....  Not raise an exception, but rather
>gracefully take the end-of-walk branch of code, just as in normal 
>operations.

Walking is only a small portion of the usage of cursors, and IMHO it is the 
least important one (since everyone other than container developers ought to 
be using iterators to walk their containers).

A cursor is a handle accessing an element of a larger container, nothing 
more or less than that. The primary usage is to connect data structures made 
up of multiple containers. For instance, consider a compiler symboltable. 
There is a tree structure that represents each of the declarations and their 
scopes, and a map structure that represents a mapping of names to nodes of 
the treee. The contents of that map is going to be tree cursors, each 
representing a declaration with a particular name.

In such a structure, it would be common to assume that the cursors are valid 
(just like you would assume that pointers are non-null in such a case --  
that's precisely what Janus/Ada code does, for instance). And dereferencing 
a cursor that points at a deleted node has to raise some exception (just as 
it would when using a pointer).

The value of cursors is that they can be implemented by a range of 
abstractions with a range of checking, from array indicies (as in the 
bounded containers and the vector) to pointers with a variety of schemes 
from no dangling checking to the bulletproof controlled cursor scheme.

In any case, the implementation of a cursor is irrelevant, since the Rust 
scheme doesn't allow making copies of pointers in the first place. Since you 
can't create a cursor with a pointer implementation, it becomes irrelevant 
as to how it is treated at end-of-life.

Sadly, what I see here is someone who's so bought into Rust hype that they 
fail to consider the real trade-offs implicit in such a technology. There's 
no reason to bring the basic Rust scheme into Ada, since there is almost no 
reason in Ada to create such pointers in the first place (see my reply to 
Paul). Where everyone needs help is for complex data structures, and Rust 
(as I understand it, anyway) provides little help there. Tucker at least is 
trying to help with the issues associated with those sorts of structures, 
but it remains to be seen whether the proposal can get baked enough to get 
it into Ada 2020.

                            Randy.