Re: Variant record limitation - what's a better solution?

[Georg Bauhaus <rm.dash-bauhaus@futureapps.de>]

On 09.07.13 08:38, Peter Brooks wrote:

> function load(x : lorry_size := small) return small_lorry_load;
> function load(x : lorry_size := medium) return  medium_lorry_load;
> function load(x : lorry_size := large) return large_lorry_load;
>
>
> type
> lorry_type(lorry : lorry_size) is
>          record
>                  number_plate : lorry_number_plate;
>                  location : depot_name_type;
>                  destination : depot_name_type;
>                  case lorry is
>                          when small => lorry_load : load(lorry);
>                          when medium => lorry_load : load(lorry);
>                          when large => lorry_load : load(lorry);
>                  end case;
>          end record;
> "
>
> I know that the syntax is wrong - I've been trying all sorts of alternatives. What have I not understood?

Adam's and Simon's solutions should work better, I think. This one
will make a discriminant check fail if a caller mistakenly loads
a large size from a small lorry, say.

   type
      lorry_type(lorry : lorry_size) is private;

    function load(L : Lorry_type) return small_lorry_load;
    function load(L : Lorry_type) return  medium_lorry_load;
    function load(L : Lorry_type) return large_lorry_load;

private

    type
      lorry_type(lorry : lorry_size) is
         record
                 number_plate : lorry_number_plate;
                 location : depot_name_type;
                 destination : depot_name_type;
                 case lorry is
                         when small => small_load : small_lorry_load;
                         when medium => medium_load : medium_lorry_load;
                         when large => large_load : large_lorry_Load;
                 end case;
         end record;

The bodies of the load functions will be

    function load(L : Lorry_type) return  Medium_Lorry_Load is
    begin
       return L.Medium_Load;
    end Load;

and similarly for the other two functions. (They are operation of
type lorry_type, hence the parameter L). A caller will then
declare
   x : large_lorry_load;
begin
   x := load(my_lorry);
end
after which X will have a copy of the large component of L, provided
the discriminant matches, i.e. my_lorry.lorry = large.
If not, the program raises constraint_error.