Re: Discriminants of tagged types

[Adam Beneschan <adam@irvine.com>]

On Oct 27, 3:07 pm, Yannick Duchêne (Hibou57)
<yannick_duch...@yahoo.fr> wrote:
> I see your good point.
>
> I have something similar for Windows API interfacing (ex. for event  
> handlers whose parameters may be made of two short integer, a reference, a  
> long integer, and so, in the same parameter, depending on a message ID).  
> This is a particular case, because I use Unchecked_Union, and  
> Unchecked_Union requires a default value for the discriminant.
>
> Otherwise, in your example, I would say what you named Value, is not a  
> Value, and rather an Expression, unless you meant an abstract view of what  
> a Value is.

Well, this was just intended to be an example, and it's best not to
get hung up on one example.  The idea was something like: suppose
you're writing an Ada interpreter for the Perl language, which does
not have strong typing.  A Perl program can have a variable named $x,
and the program could, at one point, assign $x=3; to give it an
integer value, and later $x="This is a string"; to give it a string
value, say.  The Ada interpreter would likely have some lookup table
in which it would look up the name "$x" and this would give it some
information about the current state of $x, with one of those pieces of
information being the current value of $x.  The idea here is that for
a Perl assignment statement, the interpreter could look up the record
containing $x and then reassign the value in that record to a new
value, which would involve changing the discriminant.  (Of course,
this is a huge oversimplification of the Perl language.  But it's the
sort of thing that could work in simpler interpreters---and, in fact,
I have used Ada for tools with command-line interfaces that would be
considered simple interpreters.  Also, of course, there are many other
possible uses for variant records that have nothing to do with
interpreters.)


> As there are Integer_Value, Float_Value, String_Value, I suppose each of  
> these three is associated to specific operations. So why not three types ?  
> Tagged types derived from a root abstract tagged type ?

Because the Ada record that contains information about $x cannot have
a component of type Root_Value_Type'Class.  The component would have
to be of an *access* type to Root_Value_Type'Class, and that's where
you start having to worry about allocation and memory leakage and the
like.  It's certainly one way to solve the problem, but it's not
without cost, and for a *simple* case (Perl would not be a simple
case, so it's a bad example), a variant record could be better.
Memory management is never as simple as it seems.

                                -- Adam