Re: Intervention needed?

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

On Monday, March 25, 2019 at 3:14:38 PM UTC-4, Randy Brukardt wrote:
> "Jere" wrote in message
> > On Saturday, March 23, 2019 at 3:53:34 AM UTC-4, Randy Brukardt wrote:
> ...
> > 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.
> 
> I was specifically asking about the common need to have connections between
> containers. It's not likely that a single container is all one needs to
> solve a problem, so one needs ways to refer to elements of one container
> from another.
> 
> For instance, one might need a index for another container. (For instance,
> to allow lookups by some internal characteristic.) If the main container is
> structured (as in an internal representation of HTML or XML, or a compiler
> symbol table), the index has to be a separate container. Ada provides
> cursors to represent those sorts of interconnections. How does Rust do it??
> (If it does it at all.)
> 
> This sort of thing comes up any time that one has two separate data
> structures that are inter-related. Sometimes you can use composition for
> combining structures (and that's preferable when possible), but if there are
> potentially multiple references to a single item or if the element is just
> part of a larger data structure, composition doesn't work and some sort of
> reference is needed.
> 
>                        Randy.
> 
> P.S. Sorry about breaking the thread; the message wouldn't post because of 
> header limits (too many replies).

I generally don't come across situations that require this, so I don't know
how useful my answer will be.  Plus I've only programmed in Rust off and on
for fun on some side projects.  I mostly do either C or Ada as the platform
allows.

Generally, Rust looks at potential memory erroneous access as a 100% no
no, so the same method used in Ada with Cursors wouldn't be allowed.  They
have really really low chance, but there still is a chance.  From what
I could find on the topic, the general first suggestion is to rethink
your approach and pick a better solution that doesn't involve potentially
dangling references (similar to the mentality we often suggest to new
comers trying to port ideas from C/C++ into Ada directly without 
considering the Ada way).  

Aside from that, if you can't approach it very differently, there are
different options available.  For more temporary type situations (say
wanting to delete a subset of elements from a container), they provide
various map(), filter(), and collect() operations that interact with
the iterators to get the configuration you want.

For more long term containers (This sounds more like what you are asking
for), the methods I came across were to take a step back and determine
which of the 2 (or more) containers really needs to be the owner of the
data (it isn't always the one that common sense initially indicates), 
have it own the data using an owning reference, and have the other
containers use non-owning references (which you can promote to owning
references temporarily as needed).  That would be more along the lines
of the idiomatic "safe" approach.  This allows Rust to keep track
of who can use the reference when (using temporal rules) and doesn't 
involve any unsafe code.

That isn't a silver bullet for all situations though.  In some cases, 
you might have to use one standard container and another that you 
make from scratch and have the standard container integrate into the 
other one under the hood. 

I'm not a very seasoned Rust programmer, so I am probably missing some
other solutions.  I'm more comfortable in Ada and like to use it more
anyways.  I'm also sure you could come up with some situation where
the above suggestions wouldn't work.   I don't generally have a better
answer due to lack of experience.  And the answer may at some point
indeed involve unsafe programming. You are still required to maintain
the 100% memory safety, even in the case of using the "unsafe" keyword,
so something too similar to the Ada cursors method in its current form
would not be allowed.

Sorry for the long wait on the reply.  I wanted to do some test programming
to make sure the stuff I mentioned above would actually work and also
do some research on it since, in my problem domains, I don't ever run
into situations where container shadowing/interacting is required.