Delphi – for … in on enumerated data types

I like [Wayback/Archive] enumerated type a lot.
The allow you to perfectly describe what the members of such a type actually mean, much more readable than a bunch of integer constants!

Given an enumerated type like TTraphicLightColors

type
  TTraphicLightColors = (Red, Orange, Green);

I always wondered why  – since the for ... in statement was added to the [Wayback/Archive] structured statements part of the Delphi language – it is not possible to use a for … in statement like the this:

</span>
<pre>var
  TraphicLightColor: TTraphicLightColors;
begin
  try
    for TraphicLightColor in TraphicLightColor do
      ShowValueAsTraphicLightColor(Ord(Value));
    // [DCC Error] EnumerationEnumeratorDemoProcedures.dpr(63): E2430 for-in statement cannot operate on collection type 'TTraphicLightColors'
end;

Somehow, for ... in [Wayback/Archive]  expects a collection type.
A request for [WayBack/Archive] the for … in do on enumerated types compiler feature is in QC, but it is closed with reason “Won’t do”.

Back in Delphi 2007, I tried working around this by writing a type implementing the GetEnumerator pattern myself, but got [WayBack/Archive] Internal Errors when compiling anything but the most basic sample.

Until today, where I found how I could get that most basic sample to work!
It is an example on how you could implement this: it is research, so you decide if you find the result practical enough to use yourself.

Lets start with the REnumerationEnumerator record and the TEnumerationEnumerator enumerator class that it generates:

unit EnumerationEnumerator;

interface

uses
  TypInfo;

type
  TEnumerationEnumerator = class
  private
    FMinValue: Integer;
    FMaxValue: Integer;
    FValue: Integer;
  public
    constructor Create(aEnumeratorTypeInfo: PTypeInfo);
    function GetCurrent: Integer;
    function MoveNext: Boolean;
    property Current: Integer read GetCurrent;
  end;

  REnumerationEnumerator = record
  private
    EnumeratorTypeInfo: PTypeInfo;
  public
    constructor Create(aEnumeratorTypeInfo: PTypeInfo);
    class function From(aEnumeratorTypeInfo: PTypeInfo): REnumerationEnumerator; static;
    function GetEnumerator: TEnumerationEnumerator;
  end;

implementation

{ REnumerationEnumerator }

constructor REnumerationEnumerator.Create(aEnumeratorTypeInfo: PTypeInfo);
begin
  Assert(aEnumeratorTypeInfo^.Kind = tkEnumeration);
  EnumeratorTypeInfo := aEnumeratorTypeInfo;
end;

{ REnumerationEnumerator }

class function REnumerationEnumerator.From(aEnumeratorTypeInfo: PTypeInfo): REnumerationEnumerator;
begin
  Result := REnumerationEnumerator.Create(aEnumeratorTypeInfo);
end;

function REnumerationEnumerator.GetEnumerator: TEnumerationEnumerator;
begin
  Result := TEnumerationEnumerator.Create(EnumeratorTypeInfo);
end;

{ TEnumerationEnumerator }

constructor TEnumerationEnumerator.Create(aEnumeratorTypeInfo: PTypeInfo);
var
  EnumeratorTypeInfo: PTypeInfo;
  EnumerationTypeData: PTypeData;
begin
  Assert(aEnumeratorTypeInfo^.Kind = tkEnumeration);
  EnumeratorTypeInfo := aEnumeratorTypeInfo;
  EnumerationTypeData := GetTypeData(EnumeratorTypeInfo);
  FMinValue := EnumerationTypeData.MinValue;
  FMaxValue := EnumerationTypeData.MaxValue;
  FValue := FMinValue-1;
end;

function TEnumerationEnumerator.GetCurrent: Integer;
begin
  Result := FValue;
end;

function TEnumerationEnumerator.MoveNext: Boolean;
begin
  Result := FValue < FMaxValue;
  if Result then
    Inc(FValue);
end;

end.

Note it contains both a Create constructor and From static class function.
This is by intent, I will explain this shortly.

The above unit gets great result when you call it in the main body of a simple console application like this:

program EnumerationEnumeratorDemo;

{$APPTYPE CONSOLE}

uses
  SysUtils,
  TypInfo,
  EnumerationEnumerator in 'EnumerationEnumerator.pas',
  TraphicLightColorsUnit in 'TraphicLightColorsUnit.pas';

procedure ShowValueAsTraphicLightColor(Value: Integer);
var
  TraphicLightColorsTypeInfo: PTypeInfo;
begin
  TraphicLightColorsTypeInfo := TypeInfo(TTraphicLightColors);
  Writeln(Value, ' ', GetEnumName(TraphicLightColorsTypeInfo, Value));
end;

var
  Value: Integer;
  TraphicLightColor: TTraphicLightColors;
  TraphicLightColorsTypeInfo: PTypeInfo;
begin
  try
    Writeln('For in - create constructor - only works in your main program:');
    TraphicLightColorsTypeInfo := TypeInfo(TTraphicLightColors);
    for Value in REnumerationEnumerator.Create(TraphicLightColorsTypeInfo) do
    begin
      // TraphicLightColor := TTraphicLightColors(Value);
      ShowValueAsTraphicLightColor(Value);
    end;

    Writeln('For to:');
    for TraphicLightColor := Low(TTraphicLightColors) to High(TTraphicLightColors) do
    begin
      Value := Ord(TraphicLightColor);
      ShowValueAsTraphicLightColor(Value);
    end;

    Write('Press <Enter>');
    Readln;
  except
    on E:Exception do
      Writeln(E.Classname, ': ', E.Message);
  end;
end.

You get output like this:

For in - create constructor - only works in your main program:
0 Red
1 Orange
2 Green
For to:
0 Red
1 Orange
2 Green
Press <Enter>

Until you start using that code in a procedure or function, then you consistently get Internal Error messages from the compiler.
The exact Internal Error is always of type F2084, but the subtype depends on the version of Delphi you have installed:

procedure ForIn_InternalCompilerError;
var
  Value: Integer;
  TraphicLightColorsTypeInfo: PTypeInfo;
begin
  TraphicLightColorsTypeInfo := TypeInfo(TTraphicLightColors);
  for Value in REnumerationEnumerator.Create(TraphicLightColorsTypeInfo) do
    ShowValueAsTraphicLightColor(Value);
end;
// Delphi 2007:
// [DCC Error] EnumerationEnumeratorDemoProcedures.dpr(49): F2084 Internal Error: C14125
// Delphi 2009:
// [DCC Error] EnumerationEnumeratorDemoProcedures.dpr(49): F2084 Internal Error: C15170
// Delphi 2010:
// [DCC Error] EnumerationEnumeratorDemoProcedures.dpr(49): F2084 Internal Error: C15700

Bummer. It actually caused me too loose interest in using for … in with enumerated types for a while.
Until today, when I needed a static class function returning an instance of another type.
Then I realized that there is not much difference between a constructor, and such function.

So in addition to the Create constructor, I added a From function like this:

    constructor Create(aEnumeratorTypeInfo: PTypeInfo);
    class function From(aEnumeratorTypeInfo: PTypeInfo): REnumerationEnumerator; static;

Lo and behold, this code now compiles fine:

procedure ForIn;
var
  Value: Integer;
  TraphicLightColorsTypeInfo: PTypeInfo;
begin
  TraphicLightColorsTypeInfo := TypeInfo(TTraphicLightColors);
  for Value in REnumerationEnumerator.From(TraphicLightColorsTypeInfo) do
    ShowValueAsTraphicLightColor(Value);
end;

This finally creates a work around the [WayBack/Archive] Internal Errors mentioned in QC65594.

I’m still a bit puzzled why this works with a static class function, but not with a constructor.
If anyone has a clue about that, please drop a note below.

Edit 20230314: reference to StackOverflow where I used this blog post in an answer at [Wayback/Archive] enums – Iterate through items in an enumeration in Delphi – Stack Overflow (thanks [Wayback/Archive] JosephStyons for asking).

–jeroen