Re: Discriminants of tagged types

["Yannick Duchêne (Hibou57)" <yannick_duchene@yahoo.fr>]

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.

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 ?

And for memory management, a pool of tagged type : a pool of  
Integer_Value, a pool of Float_Value, and so on. You will even save memory  
this way. About saving memory, image you have thousands of  
ASCII_Character_Value, each of them allocating all the space which would  
be required to allocate a Float_Value, that is something between 32 and 64  
bits.

But that is easily said, as I do not know about the whole system where  
this excerpt could come from.

Still not convinced.

Le Wed, 27 Oct 2010 22:26:57 +0200, Adam Beneschan <adam@irvine.com> a  
écrit:
> I think that *modifiable* discriminants (which means default
> discriminants in Ada syntax) would be hard to do without, in variant
> record cases.  Suppose, for instance, you were using Ada to write an
> interpreter for Perl or some other language that uses variables whose
> type could change between an integer, a floating-point value, or a
> string.  It seems natural to define a variable's value as a variant
> record:
>
>    type Value (Kind : Value_Kinds := None) is record
>       case Kind is
>          when Integer_Value =>    Int : Long_Integer;  -- or your
> choice of integer type
>          when Float_Value   =>    Flt : Float;         -- ditto
>          when String_Value  =>    Str :
> Ada.Strings.Unbounded.Unbounded_String;
>       end case;
>    end record;
>
> Then, if the program assigns a new value to the variable and the value
> has a different Kind, you'd want to be able to rewrite the value
> that's stored in the symbol table entry for the variable.  In Ada you
> can do this by reassigning the entire record.  Doing this without
> modifiable discriminants would be, I believe, impossible without
> adding some access types and a level of indirection, adding the
> headaches involved with allocation, deallocation, memory leakage,
> dangling references, etc.
>
> Variant records are the main reason I use default discriminants in Ada
> code.  Another typical use is to allow arrays whose size can change
> dynamically:
>
>     MAX_LENGTH : constant := 1000;
>     subtype String_Length is 0 .. MAX_LENGTH;
>     type Variable_String (Len : String_Length) is record
>         Value : String (1 .. Len);
>     end record;
>
>                                -- Adam


-- 
Si les chats miaulent et font autant de vocalises bizarres, c’est pas pour  
les chiens.