Yield from delegation in PHP - Step-by-Step Execution

Concept Flow - Yield from delegation

Start generator

↓

Yield values from sub-generator

↓

Receive value from caller

↓

Pass value to sub-generator

↓

Sub-generator yields value

↓

Yield value to caller

↓

Repeat until sub-generator ends

↓

End generator

The main generator delegates yielding and receiving values to a sub-generator using 'yield from', passing values back and forth until the sub-generator finishes.

Execution Sample

PHP

<?php
function subGen() {
  yield 1;
  yield 2;
}
function mainGen() {
  yield from subGen();
}
foreach(mainGen() as $val) { echo $val; }

This code delegates yielding values 1 and 2 from subGen() through mainGen() to the caller.

Execution Table

Step	Action	Generator State	Value Yielded	Caller Receives
1	mainGen() starts	mainGen active, subGen not started	none	none
2	yield from subGen() starts subGen	subGen active at first yield	1	1
3	Caller receives 1	subGen paused after yield 1	1	1
4	Caller requests next	subGen resumes	2	2
5	Caller receives 2	subGen paused after yield 2	2	2
6	Caller requests next	subGen ends	none	none
7	mainGen ends	mainGen ends	none	none

💡 subGen finishes yielding all values, so mainGen ends as well

Variable Tracker

Variable	Start	After Step 2	After Step 4	After Step 6	Final
mainGen state	not started	active, delegating	active, delegating	ended	ended
subGen state	not started	active at yield 1	active at yield 2	ended	ended
value yielded	none	1	2	none	none

Key Moments - 3 Insights

Why does mainGen yield values even though it has no explicit yield statements?

Because 'yield from' delegates yielding to subGen, so mainGen yields whatever subGen yields (see execution_table steps 2 and 4).

What happens when the sub-generator finishes?

When subGen ends (step 6), mainGen also ends immediately (step 7), stopping the iteration.

How does the caller receive values from subGen through mainGen?

The caller calls mainGen, which delegates to subGen via 'yield from', passing yielded values directly to the caller (steps 3 and 5).

Visual Quiz - 3 Questions

Look at the execution_table, what value does the caller receive at step 3?

A 1

B 2

C none

D subGen object

💡 Hint

Check the 'Value Yielded' and 'Caller Receives' columns at step 3.

At which step does subGen finish yielding all values?

A Step 4

B Step 6

C Step 7

D Step 2

💡 Hint

Look for 'subGen ends' in the 'Generator State' column.

If we add a third yield in subGen, how would the execution_table change?

A mainGen would end earlier.

B Caller would receive no values.

C There would be an extra step with value 3 yielded before subGen ends.

D subGen would never end.

💡 Hint

Think about how 'yield from' passes all yields from subGen to caller.

Concept Snapshot

PHP 'yield from' lets one generator pass values from another generator directly.
Syntax: yield from subGenerator();
It forwards all yields and receives transparently.
Useful to simplify generator delegation.
Stops when sub-generator ends.

Full Transcript

This example shows how PHP's 'yield from' delegates yielding values from a sub-generator to the main generator. The main generator starts, then calls 'yield from' on the sub-generator. The sub-generator yields values 1 and 2, which are passed directly to the caller. When the sub-generator finishes, the main generator ends too. This delegation allows the main generator to yield all values from the sub-generator without writing explicit loops. The execution table traces each step, showing generator states and values passed. The variable tracker shows how generator states and yielded values change over time. Key moments clarify common confusions about delegation and generator ending. The quiz tests understanding of yielded values and generator lifecycle.

Practice

1.

What does the yield from statement do in PHP generators?

easy

A. It delegates yielding values from another generator or iterable.

B. It stops the generator immediately.

C. It converts a generator into an array.

D. It throws an exception inside the generator.

Solution

1. Step 1: Understand the purpose of yield from

   yield from is used to delegate yielding values from another generator or iterable, so you don't have to write a loop to yield each value manually.

2. Step 2: Compare with other options

   Stopping a generator, converting it to an array, or throwing exceptions are unrelated to yield from.

3. Final Answer:

   It delegates yielding values from another generator or iterable. -> Option A

4. Quick Check:

   yield from delegates values [OK]

Hint: Remember: yield from passes values from another generator [OK]

Common Mistakes:

• Thinking yield from stops the generator
• Confusing yield from with array conversion
• Assuming it throws exceptions

2.

Which of the following is the correct syntax to delegate yielding from another generator $gen inside a generator function?

function gen() {
    // your code here
}

easy

A. yield $gen;

B. yield to $gen;

C. yield($gen);

D. yield from $gen;

Solution

1. Step 1: Recall correct yield from syntax

   The correct syntax to delegate yielding from another generator is yield from $gen;.

2. Step 2: Check other options for syntax errors

   yield $gen; yields the generator object itself, not its values. yield($gen); is invalid syntax. yield to $gen; is not valid PHP syntax.

3. Final Answer:

   yield from $gen; -> Option D

4. Quick Check:

   Correct syntax uses yield from [OK]

Hint: Use exact phrase yield from to delegate generators [OK]

Common Mistakes:

• Using just yield $gen; instead of yield from
• Adding parentheses incorrectly
• Writing invalid keywords like 'yield to'

3.

What will be the output of the following PHP code?

function gen1() {
    yield 1;
    yield 2;
}

function gen2() {
    yield from gen1();
    yield 3;
}

foreach (gen2() as $value) {
    echo $value . ' ';
}

medium

A. 1 3 2

B. 3 1 2

C. 1 2 3

D. 1 2

Solution

1. Step 1: Understand yield from gen1() in gen2()

   This delegates yielding values 1 and 2 from gen1() inside gen2().

2. Step 2: Trace the output of the foreach loop

   The loop yields 1, then 2 from gen1(), then yields 3 from gen2(). So output is "1 2 3 "

3. Final Answer:

   1 2 3 -> Option C

4. Quick Check:

   Delegation yields 1,2 then 3 [OK]

Hint: Remember yield from outputs all delegated values first [OK]

Common Mistakes:

• Assuming order is changed
• Forgetting the last yield after delegation
• Thinking yield from yields the generator object

4.

Identify the error in this PHP generator code:

function genA() {
    yield 1;
    yield 2;
}

function genB() {
    yield genA();
    yield 3;
}

foreach (genB() as $val) {
    echo $val . ' ';
}

medium

A. It yields the generator object instead of its values.

B. Missing semicolon after yield statements.

C. Cannot yield inside a function.

D. The foreach loop is invalid syntax.

Solution

1. Step 1: Analyze yield genA(); in genB()

   This yields the generator object genA() itself, not the values it produces.

2. Step 2: Understand correct delegation with yield from

   To yield values from genA(), use yield from genA(); instead of yield genA();.

3. Final Answer:

   It yields the generator object instead of its values. -> Option A

4. Quick Check:

   Use yield from to delegate values [OK]

Hint: Use yield from to yield values, not the generator object [OK]

Common Mistakes:

• Using yield instead of yield from for delegation
• Assuming yielding a generator yields its values
• Ignoring the need to delegate properly

5.

Given two generators genX() yielding numbers 1 to 3 and genY() yielding numbers 4 to 6, how can you create a generator genZ() that yields all numbers from 1 to 6 using yield from?

function genX() {
    yield 1;
    yield 2;
    yield 3;
}

function genY() {
    yield 4;
    yield 5;
    yield 6;
}

function genZ() {
    // Fill in code here
}

hard

A. yield genX(); yield genY();

B. yield from genX(); yield from genY();

C. yield genX() + genY();

D. yield from genY(); yield from genX();

Solution

1. Step 1: Use yield from to delegate both generators in order

   To yield all numbers from 1 to 6 in sequence, delegate genX() first, then genY() using yield from.

2. Step 2: Check order and syntax

   yield from genX(); yield from genY(); yields 1,2,3 then 4,5,6. yield from genY(); yield from genX(); reverses order. Options B and C yield generator objects or invalid expressions.

3. Final Answer:

   yield from genX(); yield from genY(); -> Option B

4. Quick Check:

   Delegate generators in order with yield from [OK]

Hint: Chain generators with multiple yield from statements [OK]

Common Mistakes:

• Yielding generators instead of delegating
• Reversing the order of delegation
• Trying to add generators directly