Re: Array Help?

[stefan-lucks@see-the.signature]

On Thu, 8 Mar 2012, Randy Brukardt wrote:
[...]
> <stefan-lucks@see-the.signature> wrote: 

> > 1. Testing
> >
> > When you declare
> >
> >  procedure Sort(Items: in out array(Positive range <>) of T)
> 
> Let's hope you never do that, because anonymous types are the bane of Ada. 
> And you surely can't do it today!

OK, the real thing would look about like that: 

  generic
     type Element_Type is (<>);
     type Index_Type is (Positive range <>);
     type Collection_Type is array(Index_Type range <>) of Element_Type;
     with function "<"(Left, Right : Element_Type) return Boolean is <>;

  function Sort(Items : Collection_Type) return Collection_Type;

> > in a package specification, and you try to write a proper black-box test,
> > you need *more* test cases then when you do the same with another popular
> > language.
> 
> Right. Bob's suggestion for some semi-constrained array subtype would fix 
> that. But note that it was killed in Ada 95 in part because the 
> implementation needed was essentially a record type with some sort of magic 
> indexing. Which was a mess.

Would it ease the implementation if you constrain the start index to some 
fixed value, such as Index_Type'First?

[...]

> >  procedure Sort(Items: in out array(generic Positive range <>) of T);

> Again, anonymous types are a disaster in Ada, and there is no way that we 
> should have more of them. I would strongly hope that this never appears even 
> in Ada 2525. ;-)

Sorry for using anonymous arrays. I hardly ever do this in real 
code. Please change the above code to 

  generic
     type Element_Type is (<>);
     type Collection_Type is array(generic Positive range <>) of Element_Type;
     with function "<"(Left, Right : Element_Type) return Boolean is <>;
  function Sort(Items : Collection_Type) return Collection_Type;

The issue is the same:

> > Sort(X) should be callable if the index type of X is any discrete type,
> > except when the index type is too large (i.e., X has more than
> > Positive'Last elements).
> 
> If you want that, you need to declare that. Positive is a numeric type, and 
> thus has "+" and "-" available; it is never going to be allowed to match 
> "any discrete type" which includes enumeration types.
> 
> It's plenty easy to write a generic like this (see the predefined ones for 
> examples), so I fail to see what possible need you are addressing here.

It is a readability issue. I frequently use arrays with different index 
types, that I need to sort, or to search for the same item being stored 
more than once ... Having to instantiate, say, the same Sort procedure 
several times makes the program less readable. 

But I agree with you that that is a minor issue, and that Bob's suggestion 
seems to solve the testing thing quite well.



-- 
---- Stefan.Lucks (at) uni-weimar.de, University of Weimar, Germany  ----
    <http://www.uni-weimar.de/cms/medien/mediensicherheit/home.html>
------  I  love  the  taste  of  Cryptanalysis  in  the  morning!  ------