Re: discriminant questions

["Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de>]

On Thu, 22 Sep 2011 13:57:51 -0700 (PDT), Maciej Sobczak wrote:

> On Sep 22, 10:07�am, "Dmitry A. Kazakov" <mail...@dmitry-kazakov.de>
> wrote:
> 
>> Consider a generic
>> implementation of removing all elements of the container using iterators:
>>
>> � �This := Container.First;
>> � �while This /= Null_Iterator loop
>> � � � �Next := This.Next;
>> � � � �This.Delete;
>> � � � �This := Next;
>> � �end loop;
>>
>> This may work or not depending on the semantics of Delete. E.g. for a
>> circular list, it will loop forever.
> 
> Not convincing, for several reasons:
> 
> 1. Null_Iterator as a sentinel value is not necessary, you might use
> Container.Is_Empty instead.

Is_Empty is a container-wide operation. X = Null_Iterator is an iterator
operation, same is X.Is_In. Aren't you a proponent of iterator approach?

> 2. Even with the above structure, This := This.Delete_And_Move_To_Next
> would do the trick. It would also work for vectors.

What about This.Delete? Should it be removed from the interface?

The problem here is the semantics of existing iterators upon container
manipulation, not computability of the algorithm. Iterators as pointers
have issues that operations on other pointers influence pointers apparently
not involved in the operation, while the implied contract of an iterator is
that it points its element no matter what.

Can I declare an iterator object constant? What is the meaning of its
"constantness" when the container gets manipulated? See a huge language
problem here? An iterator can be immutable only if the container is. How do
I express such stuff in the language?

> 3. You don't have to include circular lists in the same set of types
> as other linear containers in the first place, so there would be no
> temptation to use the generic algorithm with inappropriate container.
> That is, a circular list probably deserves a different interface
> anyway.

Circular lists are the most important ones among doubly-linked lists, and
are especially interesting for iterator-based approaches, because insertion
and removal in such lists can be done without knowing the list's head.

> 4. Are you sure that the circularity is a property of the container?

And being doubly linked is? That is the whole point, list of whatever
structure is not yet a container.

> Or rather of the traversal? Do you know that I can write a circular
> iterator as a wrapper for a "normal" one, for any linear container?
> Will you insist on having a completely separate container type for
> backwards/randomized/etc. iteration as well?

Now you are closer to understanding my point that list is not a container
and the interface of container is not necessarily its implementation.

> So you are blaming iterators for having badly designed generic
> container interface in the first place. Not convincing.

There are more comfortable and safe interfaces than iterators, I want them
available first. I want the language supporting implementation of such
interfaces rather than mounting kludges on kludges like accessors, limited
returns etc.

-- 
Regards,
Dmitry A. Kazakov
http://www.dmitry-kazakov.de