Re: FAQ and string functions

[Ted Dennison <dennison@telepath.com>]

Darren New wrote:
> Tell me how you declare a variable for an array whose bounds you don't know
> until after you're past the declaration? 

That's not what you said before. Its also a nearly irrelevant point, 
since you can almost always place declaration at the point where you 
*do* know the length.

> Tell me how you add more elements to the end of an array?

In Ada the idiom isn't to add elements to the end of an existing array; 
its to build a new one with the two old arrays catenated. If this needs 
to be done progressively, one uses recursion.

Of course that can be real slow. But if you care that much about speed, 
typically you'd want to be using your own bounded-style algorithms 
anyway. It might be nice to have some middle-speed-ground in there using 
dynamic allocation too. Hopefully the new list support in Ada0X will 
help out there.

> You can't do something like 
>   X := X & Y

No, but you can easily do:

declare
    New_X : constant String := X & Y;

> 
> Yes, actually, it can be a huge hardship, if that's how you think about
> things. If you've got a variable of global lifetime (or whatever Ada calls

We're back to my earlier point: Perhaps you should change how you think 
about things, rather than demand we "move the mountain to Mohhamed". You 
can't expect every language to support every idiom every other language 
supports. If you go into Lisp trying to program it like Perl, you won't 
have much fun either.


> Well, X idiom is kind of what we're talking about here. Of course Ada

It shouldn't be. If you can do the same tasks Idiom X is used for in Ada 
with idiom Y, and idiom Y isn't a royal pain comparativly, then I don't 
see a problem (except perhaps with training).

> But this works poorly in many places where, for example, you want to
> accumulate a bunch of results into an array. Like, I want to read lines from
> the terminal into an array of strings until I get a blank line.

Only if you refuse to use recursion. Note that the original list 
processing language (LISP) has variable length arrays (lists) as its 
basic data type, and it still encouraged using recursion for these kinds 
of tasks.

But as we said, that is something that will (hopefully) be corrected in 
the next Ada revision.