Re: "out" or "access"

[Robert A Duff <bobduff@world.std.com>]

Matthew Heaney <matthew_heaney@acm.org> writes:

> You are correct.  However, the library I'm building has one iterator
> type, that can be used to both query and modify objects in the
> collection.  The representation of the iterator must therefore include
> an access-to-variable access type.

Perhaps you should have two different sorts of iterators, one that can
modify, and one that can't.

> So perhaps I'm going beyond what even access constant params buy you.
> Maybe my real problem is how to "cast away const."

Sounds dangerous.

>...  It would be hip if
> the language provided a way to do that explicitly, analogous to
> something like Unchecked_Conversion.
> 
> BTW: does the language define --or give implementation advice-- on what
> the effect of unchecked conversion from access-to-constant to
> access-to-variable is?  Or is it the intention of the designers that you
> never try to do that?

I think you should not do that.  What should it mean?  I mean, if you
modify a constant?  An Ada compiler is within it's rights to put
constant stuff in read-only memory -- and if you modify it, you get a
core dump or some such nasty thing.  Or share memory for the same
constant data -- you better not change it.

Perhaps you should give an example.  It seems like cast-away-const is
even worse than any type-cheating one might want to do.

> Oh yes, but this doesn't meet my needs, because you need to call a
> dispatching operation ("factory method") that returns an iterator of a
> class-wide type.  Class-wide types are indefinate, and therefore require
> initialization during object declaration, which isn't possible if the
> type is limited.

I wish we could initialize limited things, but still not copy them
around.  Sigh.

- Bob
-- 
Change robert to bob to get my real email address.  Sorry.