Re: Ada.Bounded_Strings

[Adam Beneschan <adam@irvine.com>]

On Apr 4, 4:35 pm, Robert A Duff <bobd...@shell01.TheWorld.com> wrote:
> Adam Beneschan <a...@irvine.com> writes:
> > The disadvantage of this approach was given as this: "[P]redefined
> > assignment and equality for discriminated Bounded_String do not have
> > the desired behavior.  Assignment makes sense when the maximum lengths
> > of source and target are different, as long as the source's current
> > length is no greater than the target's maximum length, yet predefined
> > ":=" would raise Constraint_Error on the discriminant mismatch".
>
> > The reason this doesn't make sense to me is, how does the generic
> > definition solve the problem?
>
> It doesn't, but it does cause the problem to be prevented statically,
> rather than via an exception at run time.

Right.  But even in the discriminant case, the compiler would usually
know statically that the assignment would necessarily raise an
exception.  (I'm assuming the discriminant would be constant in the
vast majority of cases.)  The compilers I'm familiar with would
display that fact at compile time.  Our compiler also has an option to
reject programs that will necessarily fail a predefined check such as
this.


> As far as I know, there is no way to actually solve the problem in Ada
> -- that is, allow all the assignments that make sense, and no others.

Not in a way that allows you to put the two characters := in the
statement.  But  in the discriminant case, you can still define your
own assignment *procedure*, which is almost as good.  I know, it
doesn't help with initializers.


> I must admit, that generic seems awfully heavy.  Part of the rationale
> (rationalization?) was that you can just pick some reasonable max
> length, and instantiate the thing once, and use it all over your
> program.

Again, this doesn't sound reasonable in the context of the sort of
"business applications" that I used to work on in COBOL.  For other
types of applications, it's probably OK, or Ada.Strings.Unbounded may
be best.  The reason I'm even thinking about all this is that I had
been hoping for a number of years now that Ada would be able to make
inroads into "business" applications and maybe be seen as an
alternative to COBOL, and I'm a bit disappointed that, AFAIK, nothing
or very little has happened in that arena.  Not that I think
Ada.Strings.Bounded is a major reason for this, or that providing a
better string-handling facility would help at all.  (shrug)

                                -- Adam