Yield from delegation in PHP - Time & Space Complexity

Time Complexity: Yield from delegation

O(n)

Understanding Time Complexity

We want to understand how the time needed to run a generator with yield from changes as the input grows.

How does delegating to another generator affect the total steps the program takes?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

function gen1(array $items) {
    foreach ($items as $item) {
        yield $item;
    }
}

function gen2(array $items) {
    yield from gen1($items);
}

foreach (gen2([1, 2, 3, 4, 5]) as $value) {
    // process $value
}

This code uses yield from to delegate yielding values from one generator to another.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through each item in the array inside gen1.
• How many times: Once for each element in the input array.

How Execution Grows With Input

Each item in the input array causes one yield operation, so the total steps grow directly with the number of items.

Input Size (n)	Approx. Operations
10	About 10 yields
100	About 100 yields
1000	About 1000 yields

Pattern observation: The number of steps grows in a straight line as input size increases.

Final Time Complexity

Time Complexity: O(n)

This means the time to run grows directly in proportion to the number of items we yield.

Common Mistake

[X] Wrong: "Using yield from adds extra hidden loops making it slower than a simple loop."

[OK] Correct: yield from just passes through the values from the delegated generator without extra looping, so it doesn't add extra time beyond the original loop.

Interview Connect

Understanding how delegation with yield from affects time helps you explain generator behavior clearly and shows you grasp efficient iteration patterns.

Self-Check

What if we replaced yield from with a nested loop that yields each item? How would the time complexity change?

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