Re: List container strawman 1.2

[John English <je@brighton.ac.uk>]

Ted Dennison wrote:
> 
> In article <3BF27410.C899A16B@brighton.ac.uk>, John English says...
> >My vote also goes to First and Last. Apart from anything else, the
> >names are then consistent with the corresponding array attributes,
> >and consistency is a Good Thing IMHO.
> 
> Are you saying First and List just for the "Position", or for that and for the
> Push and Pop routines too?

Hmm, Push_First and Push_Last? How about Insert_First, Insert_Last
(which would be effectively a renaming of
Insert(List,First(List),Item)).

Gah. Which is more confusing: having Front(L) = Item(First(L))
or First(L) = Item(First(L))? Perhaps Front and Back are "a
convenience too far", and should be dropped since they are
easily constructed from simpler building blocks? I would have
thought that bloating the API with extra functionality would be
a bad idea unless there's a good reason to, such as the operations
would be difficult for the user to implement (for some value of
"difficult")... I don't think writing Item(First(I)) counts as
"difficult", though.

I'd personally prefer to stick to:
  &, Singleton (or To_List?), Size, First, Last, Next, Previous,
  Item, Insert, Remove, Modify, Sort, Stream_Read, Stream_Write.

Iterator is nice too but instantiating the generic (and wrapping the
operation in an approapriately-shaped procedure first) is probably
more hassle than a while I <> Last(L) loop, IMHO...

OTOH, Sort counts as "difficult" so should probably be kept. However,
another one I might one would be Shuffle, which is about the same
level of difficulty... maybe a generalisation such as Swap(Index,Index)
might be a useful building block for algorithms of this sort.

Also operations on sublists, specified by a range of Indexes to allow
you to remove a sublist, insert a sublist, replace a sublist by another,
and so on. You'd need Copy(List,From,To) and Cut(List,From,To) for
this.

e.g. Insert(List_1, Index_1, Copy(List_2,A,B));
or   Insert(List_1, Index_1, Cut(List_2,A,B));

I also think that an Index needs to know which list it refers to,
to avoid:
  I := First(L2); Insert(L1,I,X); -- L1 /= L2
The package in my book models an iterator as a pair of pointers (one
to the list header, one to the element or null). (L,null) refers to
the end of L (the position after the last element); (null,null) is a
null iterator. Since it's a private type, the two pointers are always
kept in synch by the iterator primitives.

So Insert would need two parameters (List and Value) and Remove would
need one: Insert(First(L),Item) instead of Insert(L,First(L),Item) or
(worse) Insert(L,First(L2),Item).

Phew. Sorry for the stream-of-consciousness ramble... hope it helps ;-)

-----------------------------------------------------------------
 John English              | mailto:je@brighton.ac.uk
 Senior Lecturer           | http://www.comp.it.bton.ac.uk/je
 Dept. of Computing        | ** NON-PROFIT CD FOR CS STUDENTS **
 University of Brighton    |    -- see http://burks.bton.ac.uk
-----------------------------------------------------------------