Re: Intervention needed?

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

"Paul Rubin" <no.email@nospam.invalid> wrote in message 
news:874l7y4i7x.fsf@nightsong.com...
> "Randy Brukardt" <randy@rrsoftware.com> writes:
>> A lot of what the ownership scheme does well isn't really necessary in
>> Ada in the first place, as one can use a discriminant-dependent
>> component to get the same effect without any pointers at all.
>
> Does that mean just some kind of tagged record?  Of course that would
> work the same way in other languages, maybe with different surface
> syntax.

No, I just mean a discriminanted record:

    subtype Short_Natural range 0 .. 100;
    type Short_List is (Len : Short_Natural := 0) is record
          Data : array (1 .. Len) of Element_Type;
    end record;

Depending on the implementation, there might be no pointers at all in the 
implementation, or there might be some hidden ones that are handled 
automatically. Either way, there is no exposed pointers and thus no danger 
associated with them.

One has to assign this as a whole, but that's usually easy. Janus/Ada has a 
lot of tiny linked lists that could probably have been done this way (and 
would be safer, but a bit less control over memory management).

>> and singly-linked lists (which are just sequences of elements, can be
>> modeled as an array just as well as with a list).
>
> I think that's not so easy: a common practice with linked lists is to
> have multiple lists with different heads sharing the same tail.  So
> there has to be some indirection.

True, but you (probably) can't do that in Rust anyway.

Some background here: The basic idea behind pointer ownership is to prevent 
various issues by enforcing an invariant -- that each allocated object is 
stored in exactly one pointer object. This is enforced with a variety of 
runtime and compile-time rules.

Now, it's clear that one can't even walk a data structure that way, so the 
idea of "borrowing" a pointer for a limited time was invented. Such 
borrowing has to be done in carefully controlled ways in order to keep it 
being safe -- for instance, no one can read or write the original pointer 
while it is borrowed.

Multiple long-lived pointers that point at a single object are simply not 
allowed. In part, that's done by making assignment either illegal or a move 
(where the source is nulled when the pointer is assigned).

For something like a cursor, that means that Rust-pointers couldn't be used 
to create the object. The entire point of a cursor is that it is a 
long-lived handle to a specific element in a larger data structure. One 
can't null out part of the data structure to create the handle, and if the 
assignment is banned completely, you could never create a valid cursor 
object in the first place.

There are similar issues with back pointers in a data structure, as you 
might guess.

                                 Randy.


                    Randy.