Ada's Super Powered Enums

One of the problems of dabbling with the Ada programming language is that some features work so much better than in other languages.

Ada enums are one of those features.

If you're looking for Rust style enums (sum types), Ada uses variants which are a different concept than that shown here. Ada enums often get used as the "discriminant" (tag) for variants so a lot of concepts get reused.

There is no enum keyword; instead, an enum is a list of values associated with a type.

type Direction is (Up, Down, Left, Right);

There are a few things Ada does by default here which are hidden.

Specific "attributes" get provided on Direction values. Ada attributes use tick ' syntax instead of the co-existing and normal . syntax to grab composite information and functions in other languages. Just like . syntax, some attributes are values, others are callable functions. This is where the fun begins.

Let's assume a direction and then see what we can do with it:

A_Direction : Direction := Up;

Printing

It's often useful to have printable names associated with enums. This helps print something meaningful when debugging. This gets provided by the 'Image attribute.

--  Prints "UP"
Ada.Text_IO.Put_Line (A_Direction'Image);

Ada follows the Uniform Access Principle and parameter-less attributes and functions don't require parentheses, similar to Ruby or F#.

Parsing

Printable names are nice, but what about parsing a name into an enum? For that you use the 'Value attribute.

Str : String := -- ... some string... from somewhere...

begin
    --  'Value is function-like, so we call it like one.
    A_Direction := Direction'Value (Str);
exception
    when CE : Constraint_Error =>
        Ada.Text_IO.Put_Line ("Unable to parse as direction: " & Str);
end;

Values

You can provide values for enums like in other languages.

type Direction is (Up, Down, Left, Right);

for Direction use (
    Up => 1,
    Down => 2,
    Left => 3,
    Right => 4
);

You can also make the enum a specific bit size using the Size aspect.

type Direction is (Up, Down, Left, Right)
with Size => 8; --  8 bit directions

Array Indexing

The enum values are fixed. What about using them as array indexes, as if the array were a map with default values?

type Direction_Array is array (Direction) of Boolean;
Empty_Locations : Direction_Array := [others => False];

Ada 2022 uses [ ... ] for array literals, but previous versions use ( ... ). You can still use ( ... ) if you want though in Ada 2022. In either case, you still use ( ) for indexing.

We can now directly index, assign and get values from the array using our enum values.

if Empty_Locations (Up) then
    Ada.Text_IO.Put_Line ("Up is empty");
    Empty_Locations (Up) := False;
end if;

Ada array indexing looks like a function call in other languages.

You can also directly assign an array using the enum values:

Empty_Locations := [Up => True, Down => False, Left => True, Right => False];

Or only assign the values you care about:

Empty_Locations := [Up => True, Left => True, others => False];

Array iteration

How would you iterate over the array? With the enum's 'Range!

for X in Direction'Range loop
    if Empty_Locations (X) then
        Ada.Text_IO.Put_Line ("Location " & X'Image & " is empty");
    end if;
end loop;

Not only is there a range, but there's also the ability to directly move between enum values.

A_Direction := Direction'Pred (A_Direction);
A_Direction := Direction'Succ (A_Direction);

How do you know if you're not going to fall off the end of the enum list? Using 'First and 'Last!

if A_Direction = Direction'First then
    Ada.Text_IO.Put_Line ("This is the first direction.");
else
    Ada.Text_IO.Put_Line ("Predecessor is "
        & Direction'Pred (A_Direction)'Image);
end if;

if A_Direction = Direction'Last then
    Ada.Text_IO.Put_Line ("This is the last direction.");
else
    Ada.Text_IO.Put_Line ("Successor is "
        & Direction'Succ (A_Direction)'Image);
end if;

Membership

You can also associate a semantically compatible subtype with an enum. Using Static_Predicate ensures enum conditions at compile-time.

subtype Horizontal is Direction
with Static_Predicate => Horizontal in Left | Right;

Then you can use these to check for appropriate values at runtime.

procedure Only_Horizontals (H : Horizontal) is
begin
    Ada.Text_IO.Put_Line (H'Image & " must be a horizontal");
end Only_Horizontals;

You can also use this subtype as a membership test:

if A_Direction in Horizontal then
    Only_Horizontals (A_Direction);
end if;

Switching

Similar to Rust, we can ensure exhaustive switching off of these values. This also includes testing multiple values at once in a branch. There is no fallthrough between these branches.

case A_Direction is
    when Up =>
        Ada.Text_IO.Put_Line ("Going up");
    when Down =>
        Ada.Text_IO.Put_Line ("Going down");
    when Left | Right =>
        Ada.Text_IO.Put_Line ("Going sideways");
end case;

You can also use subtypes instead in switches:

case A_Direction is
    when Up =>
        Ada.Text_IO.Put_Line ("Going up");
    when Down =>
        Ada.Text_IO.Put_Line ("Going down");
    when Horizontal => --  Use a subtype with a Static_Predicate here.
        Ada.Text_IO.Put_Line ("Going sideways");
end case;

If the cases aren't disjoint you'll get a compile error, even when using subtypes with Static_Predicate.

Caveats

Some of these tricks only work when enums have consecutive ranges. Note that is consecutive, not necessarily starting at 0. This is true in general of arrays in Ada... they can start at indices other than 0 or 1!

Where it gets weird

The enum "Values" are technically functions, and are namespaced to the package, not to the type. This means if you have the same name visible multiple times, such as by use of another package, then function overloading actually ensures the correct version of the type gets picked.

That means this is legal:

type Direction is (Up, Down, Left, Right);
type Elevator_Button is (Up, Down);

D : Direction := Up; --  Picks Direction version of Up.
E : Elevator_Button := Up; -- Picks Elevator_Button version of Up;

Summary

Overall, Ada enums provide a powerful way to represent domain-specific values, but also to use them in interesting ways. Being built-in helps avoid a lot of boilerplate while also helping prevent issues like improper indexing and simplifying conditional tests.