Re: Type invariants and private extensions?

[Jere <jhb.chat@gmail.com>]

On Tuesday, September 12, 2017 at 6:59:17 PM UTC-4, Victor Porton wrote:
> Shark8 wrote:
> 
> > On Tuesday, September 12, 2017 at 2:09:08 PM UTC-6, Victor Porton wrote:
> >> Jeffrey R. Carter wrote:
> >> 
> >> > 
> >> > "I want to" is not the same as "there is no way to solve the problem in
> >> > current Ada". Ada has a feature that provides exactly what you need.
> >> > It's called a variant record.
> >> 
> >> It is a tagged type. AFAIK, a type cannot be both a variant record and
> >> tagged.
> > 
> > You certainly can:
> > 
> >     Type Type_Enumeration is ( TInteger, TReal, TBoolean, Nothing );
> >     
> >     Type Example( Item_Type : Type_Enumeration ) is tagged record
> > case Item_Type is
> > when TInteger => I : Integer;
> > when TReal    => R : Float range Float'Range;
> > when TBoolean => B : Boolean;
> > when Nothing  => Null;
> > end case;
> >     end record;
> >     
> >> Moreover, the object in consideration is a wrapper over a certain C API.
> >> It surely cannot be described in variant record terms.
> > 
> > Sure it can; there's a reason that there's a separation between
> > specification and body, part of which is so you can hide something like an
> > interface to C and present something sensible to your program/clients.
> 
> Thanks.
> 
> But this seems not to solve my problem:
> 
> The base type for Example cannot be defined as a discriminated type for 
> certain Type_Enumeration, because it is possible that when creating the 
> object it may be yet unknown what the value of the discriminant should have 
> (my main problem is to invent somethings if this value is known at object 
> creation, but we must support the unknown case too). AFAIK, it is not 
> possible to change the discriminant later.
> 

I may be misunderstanding what you are looking for, but you can 
make discriminant types unconstrained to let you choose the type 
at run time:

Type Type_Enumeration is ( TInteger, TReal, TBoolean, Nothing );
   
    Type Example( Item_Type : Type_Enumeration := Nothing) is tagged record
        case Item_Type is
            when TInteger => I : Integer;
            when TReal    => R : Float range Float'Range;
            when TBoolean => B : Boolean;
            when Nothing  => Null;
        end case;
    end record; 

Then all you have to do is declare an object with no 
specified discriminant:

 Some_Object : Example;  --notice no discriminant

In Ada, when you do this, you are able to assign new versions 
of the type (with different discriminants:

Some_Integer : Example := (Item_Type => TInteger, I => 100);
Some_Float   : Example := (Item_Type => TFloat,   F => 20.2);

Some_Object := Some_Integer;
Some_Object := Some_Float;

That's just a play example, you can handle building them however 
you want at run time.