enums - 在 Ada 中扩展枚举

Question

是否可以在 Ada 中扩展 Enum 类型？如果我有例如：

type ABC_Type is (A, B, C);

现在我想要新的类型 ABCDE_Type，它将包括 ABC_Type 拥有的所有内容以及（D，E）。有没有办法做到这一点？

Answer 1

不，您不能在 Ada 中扩展 Enum 类型，您只能创建涵盖原始子集的派生/子类型。

你必须反过来做：

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;

Answer 2

一个人给出的答案是正确的；您不能扩展枚举（或数字）类型。但是，您可以使用 Yony 的 Animal/Fox 示例扩展标记类型，我已将其翻译成 Ada 的 OO 模型：

-- 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;

事实上，扩展（OO 继承）和排除（子类型化）都可以在同一个程序中使用，并且同一个子程序对一个类型进行操作。

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;

子类型本身可以是一个强大的概念。事实上，在对数学建模时，Ada 的子类型可以让函数完全匹配它们的数学定义，或者以某些检查完全不需要的方式实现事物。

-- 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;