# Iterating over a sequence using “for .. in”

The for .. in construct was added to Delphi 2005 and allows you to iterate over arrays, lists and other container objects. In this article I will show you how to implement a class that provides this capacity. I will also show you that you don’t have to pre-allocate values in an array, a list or in any other container object, but that you may generate them when the user actually requests them.

As an example, I will use the Fibonacci sequence which is a seqence of integers where each element is the sum of the previous two (1, 1, 2, 3, 5, 8, 13 etc.). This may not in itself be a very interesting case, but it makes it easy to illustrate the point. My goal with this article is to be able to write

```for i in FibonacciNumbers(100) do
WriteLn(i);
```

and see all numbers in the Fibonacci series that are smaller than 100.

Creating the enumerator

The first thing we need is an object that implements the actual iteration over the integers. We may create a class to do this, but I have chosen to use a record. As of Delphi 2006, records may have methods, which we will need in the enumerator. The reason I use a record here, is because I need only one enumerator per Fibonacci object, and by including a record variable, I don’t have to bother with allocating or freeing memory for the enumerator. Here is the code for the enumerator:

```type
TFibonacciEnumerator = record
private
MaxNumber: Integer;
ThisNumber: Integer;
LastNumber: Integer;
SecondToLastNumber: Integer;
function GetCurrent: Integer;
public
function MoveNext: Boolean;
end;

implementation

function TFibonacciEnumerator.GetCurrent: Integer;
begin
Result := ThisNumber;
end;

function TFibonacciEnumerator.MoveNext: Boolean;
begin
if (ThisNumber = 0) then
ThisNumber := 1
else
begin
SecondToLastNumber := LastNumber;
LastNumber := ThisNumber;
ThisNumber := SecondToLastNumber + LastNumber;
end;
Result := (ThisNumber < MaxNumber) or (MaxNumber < 0);
end;
```

An object that implements an enumerator must implement two methods: MoveNext() and Current(). MoveNext() moves to the next element in the list. It returns True if such an element exists, and False otherwise. When you call “for .. in”, this method is called first, which means that the first time, it should move to the first element. The Current() method returns the current element (the one previously selected using MoveNext).

In our case, we keep a variable, ThisNumber, which holds the current value. Each time the MoveNext method is called, it calculates the next number. It then returns True if the calculated number is smaller than the supplied max value, and False otherwise.

Creating the Fibonacci class

We also need the actual object, on which a user can ask for the enumerator, i.e. a class that will serve as a “container” for the enumerator. If you were to write an enumerator for a class that already holds values, that class would typically contain e.g. an array of values over which the enumerator will iterate, but in our case, the job of the “container class” is almost exclusively to supply the enumerator. The code for the TFibonacciNumbers class follows:

```type
IFibonacciNumbers = interface ['{642E6631-B8EA-4C6A-9003-6AE5257EDF5D}']
function GetEnumerator: TFibonacciEnumerator;
end;

TFibonacciNumbers = class(TInterfacedObject, IFibonacciNumbers)
protected
Enumerator: TFibonacciEnumerator;
public
function GetEnumerator: TFibonacciEnumerator;
constructor Create(MaxNumber: Integer);
end;

implementation

constructor TFibonacciNumbers.Create(MaxNumber: Integer);
begin
Enumerator.MaxNumber := MaxNumber;
Enumerator.SecondToLastNumber := 0;
Enumerator.LastNumber := 0;
Enumerator.ThisNumber := 0;
end;

function TFibonacciNumbers.GetEnumerator: TFibonacciEnumerator;
begin
Result := Enumerator;
end;
```

To support an enumerator, an object must implement a GetEnumerator() method, that returns an enumerator of the correct type – in our case a TFibonacciEnumerator object. When the object is created, all we have to do is initialize the enumerator. I have chosen to let TFibonacciNumbers implement an interface, and extend the TInterfacedObject class. This way, TFibonacciNumbers objects are automatically reference counted, and the memory they occupy will be released automatically when all references to them are removed. This means that I can write

```for i in TFibonacciNumbers.Create(100) do
WriteLn;
```

whereas I would otherwise have to write

```fn := TFibonacciNumbers.Create(100);
try
for i in fn do
WriteLn;
finally
fn.free;
end;
```

We are getting close to our original goal now. By adding one more method

```function FibonacciNumbers(MaxNumber: Integer = -1): IFibonacciNumbers;
begin
Result := TFibonacciNumbers.Create(MaxNumber);
end;
```

we can now write the simple code that was our goal all along:

```for i in FibonacciNumbers(100) do
WriteLn(i);
```

The complete source code is available here.