Re: Ada.Bounded_Strings

[Adam Beneschan <adam@irvine.com>]

On Apr 4, 9:10 am, Pascal Obry <pas...@obry.net> wrote:

> > Sorting out string handling out would be nice, too.
>
> Probably something to do in this area I agree.

OK, this is *really* beating a dead horse, but...

When I read this and was thinking randomly about Ada's string
handling, I got to wondering why Bounded_Strings was defined as a
generic, rather than declaring a discriminated type with the maximum
length as the discriminant.  I don't know why I hadn't thought of this
before, in the last 13 years, but I figured someone else had probably
asked that, so sure enough after a bit of searching I ended up finding
the answer in the Ada 95 Rationale.  The problem is, the answer
doesn't make a whit of sense to me.

The idea was to declare a non-generic package and a Bounded_String
type that looked like:

    type Bounded_String (Max_Length : Positive) is record
        Length : Natural;
        Data   : String(1..Max_Length);
    end record;

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?  If you have two different maximum
lengths, then you have to instantiate Bounded_Strings twice to get
types with different maximum lengths; and then the Bounded_String
types are separate types and you can't do an assignment anyway.  So I
don't see why this was considered a disadvantage of the discriminant
approach.  (Plus, with a discriminant definition you could at least
write an assignment *procedure* with one OUT parameter, but you can't
do that with generics, except by defining a second generic package
that takes two instances of Bounded_Strings as formal parameters,
which would then have to be instantiated for every combination of two
lengths for which you'd want to do assignment.)

I realize I'm at least a decade too late in asking this, but in case
someone has a good memory, I was wondering if someone could explain
this to me?

And would it be useful to add a package like this now?  (I'm thinking
of this because Graham alluded to Ada's not being adopted in business
settings, and I'm wondering whether this kind of type would seem more
comfortable and familiar to COBOL-type programmers than an
Unbounded_String type.  But I'm just guessing---I really wouldn't
know.)

                                 -- thanks, Adam