Extending Enum in Ada

Question

Is it possible to extend an Enum type in Ada? if I have for example:

type ABC_Type is (A, B, C);

Now I want new type ABCDE_Type that will include everything that ABC_Type has and Also (D, E). Is there a way to do that?

Answer 1

The answer given by oneone is correct; you cannot extend enumeration (or numeric) types. You can however extend tagged types, using Yony's Animal/Fox example I've translated it into Ada's OO-model:

-- Percent defines an integer-value between zero and one-hundred, inclusive.
Subtype Percent is Natural Range 0..100;

-- Attribute defines an integer between one and ten, inclusive.
Subtype Attribute is Positive Range 1..10;

-- Animal, the base object-class.
Type Animal is Abstract Tagged Record
-- All Animals have a survivability attribute.
Survivability : Percent:= Percent'Last; -- Default "survivability" to Max.
End Record;

-----------------------------------------------------
-- Declaration of Primitive Operations for Animal. --
-----------------------------------------------------

-- Name; returns the name of the type of the animal.
Function Name( Object : In Animal'Class ) Return String;


-------------------------------------------------------
-- Implementation of Primitive Operations for Animal --
-------------------------------------------------------

Function Name( Object : In Animal'Class ) Return String is
Use Ada.Tags;
begin
    -- This is implementation dependent; with the compiler I'm using the Uppercased 
    -- type-name of the actual object will be returned.
Return External_Tag(Object'Tag);
end Name;

---------------------------
-- The Fox object-class. --
---------------------------
Type Fox is New Animal with record
Cunning : Attribute:= Attribute'First;
end record;

In fact, both extension (OO-inheritance) and exclusion (subtyping) can be used in the same program, and the same subprograms operating on a type.

package Windowing is
Type Window is tagged private;

-- Pointers for windows.
Type Window_Pointer is Access Window'Class; -- Normal pointer
Subtype Handle is Not Null Window_Pointer;  -- Pointer with Null excluded.

-- A light 'vector' of handles.
Type Window_List is Array (Positive Range <>) of Handle;

-- Primitive operations
Function Get_Child_Windows( Object : In Handle ) Return Window_List;
Procedure Set_Window_Height( Object : In Handle; Height : In Positive );
Function  Get_Window_Height( Object : In Handle ) Return Positive;

-- more primitive operations... including subprograms to create windows 
    -- and perhaps assign them as children.

Private
Package Win_Vectors is new
  Ada.Containers.Vectors(Index_Type => Positive, Element_Type => Handle);

Type Window is Tagged Record
    -- X & Y may be negative, or zero.
    X, Y        : Integer:= Positive'First;
    -- Height & Width must be positive.
    Height, Width   : Positive:=    Positive'First;
    -- Child-list
    Children        : Win_Vectors.Vector:= Win_Vectors.Empty_Vector;
End Record;


End Windowing;

package body Windowing is
Procedure Set_Window_Height( Object : In Handle; Height : In Positive ) is
begin
    Object.Height:= Set_Window_Height.Height;
end Set_Window_Height;

Function  Get_Window_Height( Object : In Handle ) Return Positive is
begin
    Return Object.Height;
end Get_Window_Height;

Function Get_Child_Windows ( Object : In Handle ) Return Window_List is
begin
    -- Return a null-array if there are no child windows.
    if Object.Children.Is_Empty then
      Return (2..1 => Object);
    end if;

    -- Create an array of the proper size, then initialize to self-referential
    -- handle to avoid null-exclusion error.
    Return Result : Window_List( 1..Positive(Object.Children.Length) ):= 
         (others => Object) do
    Declare
         Procedure Assign_Handle(Position : Win_Vectors.Cursor) is
          Use Win_Vectors;
          Index : Positive:= To_Index( Position );
         begin
          Result(Index):= Element(Position);
         end Assign_Handle;
    Begin
         -- Replace the self-referential handles with the correct ones.
         Object.Children.Iterate( Process => Assign_Handle'Access );
    End;
    End Return;
end Get_Child_Windows;


end Windowing;

Subtyping itself can be be a powerful concept on its own. Indeed when modeling mathematics, Ada's subtypings can allow functions to exactly match their mathematical definitions, or implement things in such a way that certain checks are completely unnessacary.

-- Remove non-normal representations.
Subtype Real is Float Range Float'Range;

-- Constrain to non-negative numbers.
Subtype Natural_Real is Real Range 0.0 .. Real'Last; 

-- Because of the parameter-type, we do not need to implement any checks
-- for negative numbers in the subprogram body.
Function Square_Root( X : In Natural_Real ) Return Natural_Real;

-- Because Divisor is positive, we need not worry about ddivide-by-zero.
Function Good_Divide( Quotient: Integer; Divisor: Positive ) Return Natural;

Answer 2

No, you cannot extend an Enum type in Ada, you can only create derivations/subtypes that cover a subset of the original one.

You have to do it the other way round:

type ABCDE_Type is (A, B, C, D, E);
type ABC_Type is new ABCDE_Type range A .. C;
-- or
subtype ABC_Type is ABCDE_Type range A .. C;