A new PHP version is about to be released. At the time I’m writing this blog PHP 5.5 is in beta 4.

Eager to see the updates, I’ve compiled the new beta version. The feature list is available at: http://www.php.net/manual/en/migration55.new-features.php

The generators are the most important feature..

Generating generators in PHP 5.5

A generator is basically a function that contains a call to “yield”.

Let’s take the example form php.net:

 1<?php
 2function xrange($start, $limit, $step = 1) {
 3   for ($i = $start; $i <= $limit; $i += $step) {
 4       yield $i;
 5   }
 6}
 7
 8echo 'Single digit odd numbers: ';
 9
10/* Note that an array is never created or returned,
11* which saves memory. */
12foreach (xrange(1, 9, 2) as $number) {
13   echo "$number ";
14}
15?>

Basically, the generator (xrange in this case), instead of returning an array, will return a value at a time, in order to be processed.

But wait… wasn’t this already possible before this version?

Generators before PHP 5.5

Before PHP 5.5 there were already Iterators:

 1<?php
 2
 3class xrange implements Iterator
 4{
 5    private $position = 0;
 6    private $start;
 7    private $limit;
 8    private $step;
 9
10    public function __construct($start, $limit, $step = 1)
11    {
12        $this->start = $start;
13        $this->limit = $limit;
14        $this->step = $step;
15        $this->position = 0;
16    }
17
18    function rewind()
19    {
20        $this->position = 0;
21    }
22
23    function current()
24    {
25        return $this->start + ($this->position * $this->step);
26    }
27
28    function key()
29    {
30        return $this->position;
31    }
32
33    function next()
34    {
35        ++$this->position;
36    }
37
38    function valid()
39    {
40        return $this->current() <= $this->limit;
41    }
42}
43
44echo 'Single digit odd numbers: ';
45
46/* Note that an array is never created or returned,
47 * which saves memory. */
48foreach (new xrange(2, 9, 2) as $number) {
49    echo "$number ";
50}
51?>

Beside the fact that the Iterator is an object with multiple properties, basically we can achieve the same result.

But why do we need generators then? Simple! Instead of using ~40 lines of code, we can simply use 5 to achieve the same goal.

Another interesting thing is that:

1get_class(printer());

will return Generator.

Basically, a generator returns an object of type Generator, and this object extends Iterator.

The major difference, as it is described on the php.net website, is that the generator can not be reset, basically it goes one way only.

Sending information to the generators

Yes, generators work both ways, but each generator only works in one particular direction. If the syntax above is for “producing” data, then the syntax below is only for “consuming” data.

The syntax for a “consumer” is simple:

 1<?php
 2function printer() {
 3    $counter = 0;
 4    while(true) {
 5        $counter++;
 6        $value = yield;
 7        echo $value . $counter . PHP_EOL;
 8    }
 9    echo ‘Never executed...' . PHP_EOL;
10}
11
12$printer = printer();
13$printer->send('Hello!');
14echo 'Something is happening over here...' . PHP_EOL;
15$printer->send('Hello!');
16?>

The output will be:

1Hello!1
2Something is happening over here...
3Hello!2

Basically, the value of yield can be used as any other value. What’s interesting is the while. On php.net is the folowing comment:

// Sends the given value to the
// generator as the result of
// the yield expression and
// resumes execution of the
// generator.

The loop is needed because the generator will stop after it processes the value and will only continue when a new value is received. If we remove the while, only the first value will be processed, regardless of how many times we’ll call send().

An interesting thing is that what comes after the loop will not be executed, that is in my case:
echo ‘Never executed…’ . PHP_EOL;

So, if it looks like a good place to release a resource (e.g. DB or file), in fact it isn’t, because that code will never get executed.

It seems useful for logging. Again, nothing that couldn’t have been done before, but now it allows for an easier approach.

I’ve found though something that doesn’t work:

 1<?php
 2function printer() {
 3    while(true) {
 4        echo yield . PHP_EOL;
 5    }
 6}
 7
 8$printer = printer();
 9$printer->send('Hello world!');
10
11foreach($printer as $line) {
12    echo $line . PHP_EOF;
13}

A little chaotic, isn’t it? But I was wondering what would happen:
Fatal error: Uncaught exception ‘Exception’ with message ‘Cannot rewind a generator that was already run’ in…

So, once send() is used on an iterator, you can’t use it as an iterator again. Of course, another one can be generated with:
printer();

What is more confusing is that Generator is a final class, so it can’t be extended, and if you try to instantiate it directly (although even if it worked it would be useless):
Catchable fatal error: The “Generator” class is reserved for internal use and cannot be manually instantiated in…

Conclusion

It is an interesting feature because it simplifies things a lot when you try to create an iterator.

Also the use of send() seems very interesting, not because it is doing something new, but because it is doing it easier.

On the other hand, I don’t like that there is the same syntax for both generator versions and even more that what is after the while is not getting executed. I think the syntax is a little confusing because there isn’t a clear difference between the two. On the other hand, this already exists in Python, so for inspirator the examples from this language can be used.