Generators for lazy evaluation: practical patterns in PHP

nphp5 Jan 2026 01:42

Generators are one of the most underused features in PHP. Beyond file reading, they have several useful patterns.

Infinite sequence (no memory growth):

PHP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php
function fibonacci(): Generator
{
    [$a, $b] = [0, 1];
    while (true) {
        yield $a;
        [$a, $b] = [$b, $a + $b];
    }
}
$gen = fibonacci();
for ($i = 0; $i < 10; $i++) {
    echo $gen->current() . "\n";
    $gen->next();
}
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Pipeline: compose multiple transforms without intermediate arrays:

PHP

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
<?php
function map(Generator $source, callable $fn): Generator
{
    foreach ($source as $value) {
        yield $fn($value);
    }
}
function filter(Generator $source, callable $predicate): Generator
{
    foreach ($source as $value) {
        if ($predicate($value)) {
            yield $value;
        }
    }
}
function take(Generator $source, int $n): Generator
{
    $i = 0;
    foreach ($source as $value) {
        if (++$i > $n) return;
        yield $value;
    }
}
function integers(int $from = 0): Generator
{
    while (true) yield $from++;
}
// Lazy: only computes what is consumed
$result = take(
    filter(
        map(integers(1), fn($n) => $n * $n),
        fn($n) => $n % 2 === 0
    ),
    5
);
foreach ($result as $v) {
    echo $v . "\n"; // 4, 16, 36, 64, 100
}
 
 
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1348

Replies (5)

alex_petrov5 Jan 2026 02:02

The pipeline pattern is genuinely useful for ETL-style data processing. Each step is testable in isolation, memory usage stays flat, and adding a new transform is one function.

dmitry_kv5 Jan 2026 03:07

yield from delegates to another generator or iterable. Useful for recursive generators (tree traversal) where you would otherwise need to collect all results before yielding them.

vova5 Jan 2026 05:07

Generators do not rewind by default. Once exhausted they cannot be iterated again. If you need to iterate multiple times, collect into an array or create a new generator instance.

taras_boh5 Jan 2026 05:28

Send values into a generator with $gen->send($value). The send value becomes the return value of yield inside the generator. Useful for two-way communication in coroutine patterns.

nphp5 Jan 2026 07:04

return inside a generator terminates it and the return value is accessible via $gen->getReturn() after the generator is exhausted. Useful for aggregation: yield individual items, return the final count.

Write a reply