Re: advice on package design

[Jared <nowhere@nowhere.nowhere>]

Robert A Duff <bobduff@shell01.TheWorld.com> wrote in
news:wccsm2u6k1t.fsf@shell01.TheWorld.com: 

> But that seems less readable (to me) than just writing
> "Initialize_Database;" where I want it to happen.
> So a rule (requiring "declare") that is intended to increase
> readability actually decreases it.
> 
> And if you want a statement in a package *spec* (say, to initialize
> something), it's far worse.  There's no direct workaround; you have to
> totally rearrange the structure of your design in order to get around
> a silly syntax rule.

Is this terribly common, though?  I'm just a hobbyist, so when I run
across something like that, I just assume I have a bad design.

> It seems to me that:
> 
>     Mumble: T := Blah(...);
> 
> should be precisely equivalent to:
> 
>     Mumble: T;
>     Mumble := Blah(...);
> 
> which should be precisely equivalent to:
> 
>     Mumble: T;
>     Blah(Mumble);
> 
> (where in the last example we replace function Blah with a procedure
> with an 'out' parameter).  The programmer should be able to switch
> from one of these forms to another, without changing the semantics of
> the program.  But the syntax rules require stirring the code around
> when you make these changes.
> 
> (Another reason Ada does not have the above desirable property is that
> function results of subtype String behave differently from 'out'
> parameters of subtype String.  I don't like that.)

This is the case for all unconstrained array types.  In order to use
unconstrained variables, we three distasteful choices.  Invoke the
entire object mechanism for a single controlled type, fiddle with
access types and hope not to drop any references, or create code that
looks like:

>     function F(...) return String is
>         A: String := ...;
>     begin
>         Do_Something(A);
>         declare
>             B: constant String := G(A);    
>         begin
>             ... and so on ..................................
>                                                             declare
>                                                                 Z:
>                               String ... 
>                                                             begin
>                                                                 return
>                               Z; 
> 
> Yuck.

There's always Ada.Strings.Unbounded.Unbounded_String, but that's
only good for character arrays.


Incidentally, I'm just a hobbyist, so I don't know about this; how
common is it in production code to declare a controlled type just
to guarantee uniqueness of reference?  Of those, how many are used
for arrays?