PHP Generators and Namespaces

A generator is a special type of function that can pause its execution and yield values one at a time, resuming from where it left off on the next call. Generators implement the Iterator interface without requiring an array to be built upfront, making them memory-efficient for large or infinite sequences.

function fibonacci(): Generator {
    [$a, $b] = [0, 1];
    while (true) {
        yield $a;
        [$a, $b] = [$b, $a + $b];
    }
}

foreach (fibonacci() as $i => $value) {
    if ($i >= 10) break;
    echo $value . ' '; // 0 1 1 2 3 5 8 13 21 34
}

How generators work:

1. Calling a generator function returns a Generator object immediately — no code executes yet.
2. Each call to ->current() / each foreach iteration resumes execution until the next yield.
3. yield $value pauses the function and passes $value to the caller.
4. Execution resumes from after the yield on the next iteration.

Practical use — reading a large file without loading it all:

function readLines(string $path): Generator {
    $file = fopen($path, 'r');
    while (($line = fgets($file)) !== false) {
        yield trim($line);
    }
    fclose($file);
}

foreach (readLines('/var/log/app.log') as $line) {
    processLine($line); // one line in memory at a time
}

yield from (delegation) allows a generator to delegate to another generator or iterable:

function inner(): Generator { yield 1; yield 2; }
function outer(): Generator { yield 0; yield from inner(); yield 3; }

Interview note: Generators are often compared to Fibers (PHP 8.1). Both can pause execution, but generators are pull-based (the consumer requests values); Fibers are bidirectional cooperative coroutines used for async programming.

Namespaces in PHP are a way to encapsulate related classes, interfaces, functions, and constants under a named scope, avoiding naming collisions between your code and third-party libraries.

Declaring a namespace:

userService->findOrFail($id);
    }
}

Composer and PSR-4:

"autoload": {
    "psr-4": {
        "App\\": "src/"
    }
}

App\Models\User maps to src/Models/User.php. Running composer dump-autoload registers this mapping so PHP finds class files automatically.

Namespaces prevent collisions by placing your classes in a named scope. Two classes with the same name in different namespaces are completely distinct:

// Your code
namespace App\Http;
class Request { /* ... */ }

// A vendor library
namespace Symfony\Component\HttpFoundation;
class Request { /* ... */ }

// Both can coexist; PHP resolves them by their fully qualified name
$myRequest     = new \App\Http\Request();
$symfonyRequest = new \Symfony\Component\HttpFoundation\Request();

The use statement — importing for convenience:

namespace App\Controllers;

use App\Services\UserService;
use Symfony\Component\HttpFoundation\Request;

class UserController {
    public function index(Request $request): void { ... }
}

Without use, you'd write the full path every time: new \Symfony\Component\HttpFoundation\Request().

Aliasing to resolve conflicts:

use App\Http\Request as AppRequest;
use Symfony\Component\HttpFoundation\Request as SymfonyRequest;

function handle(AppRequest $app, SymfonyRequest $symfony): void { ... }

Namespace grouping (use declarations, PHP 7.0+):

use App\Models\{User, Post, Comment};
use function App\Helpers\{formatDate, truncate};
use const App\Config\{APP_ENV, DEBUG};

PSR-4 autoloading ties it all together: The composer.json autoload section maps namespace prefixes to directories, so Composer's autoloader resolves any fully-qualified class name to the correct file automatically.

Sub-namespaces are namespaces nested within a parent namespace, using backslash (\) as the separator. They allow fine-grained organization of code within a larger namespace hierarchy.

// Top-level namespace
namespace App;

// Sub-namespaces
namespace App\Http\Controllers;
namespace App\Http\Middleware;
namespace App\Database\Repositories;
namespace App\Services\Payment;

Example project structure:

src/
├── Http/
│   ├── Controllers/
│   │   └── UserController.php   → namespace App\Http\Controllers;
│   └── Middleware/
│       └── AuthMiddleware.php   → namespace App\Http\Middleware;
└── Services/
    └── Payment/
        └── StripeService.php    → namespace App\Services\Payment;

Using sub-namespaced classes:

namespace App\Http\Controllers;

use App\Services\Payment\StripeService;
use App\Database\Repositories\UserRepository;

class CheckoutController {
    public function __construct(
        private StripeService $stripe,
        private UserRepository $users,
    ) {}
}

PSR-4 mapping: With Composer, App\\ mapped to src/ means App\Http\Controllers\UserController automatically resolves to src/Http/Controllers/UserController.php. The namespace hierarchy mirrors the directory structure.

Sub-namespaces have no special language behavior beyond being part of the fully-qualified name — they are purely an organizational convention.

To access a global (non-namespaced) class, function, or constant from within a namespace, prefix its name with a backslash (\):

namespace App\Utils;

class StringHelper {
    public function process(string $input): string {
        // Global class — prefix with \
        $exception = new \InvalidArgumentException('Bad input');

        // Global function — prefix with \
        $length = \strlen($input);
        $encoded = \json_encode(['value' => $input]);

        // Global constant — prefix with \
        $separator = \DIRECTORY_SEPARATOR;
        $pi = \M_PI;

        return $encoded;
    }
}

Why the backslash is needed: Inside a namespace, PHP first looks for the name in the current namespace. Without \, strlen in App\Utils would look for App\Utils\strlen — which doesn't exist — and then fall back to the global scope for functions and constants (but not classes in PHP 7+). Using \ explicitly makes the intent clear and avoids ambiguity.

use as an alternative:

namespace App\Utils;

use InvalidArgumentException;  // import global class
use function strlen;           // import global function
use const DIRECTORY_SEPARATOR; // import global constant

class StringHelper {
    public function validate(string $input): void {
        if (strlen($input) === 0) {
            throw new InvalidArgumentException('Input cannot be empty');
        }
    }
}

Interview note: The global keyword in PHP is unrelated to namespaces — it is used to bring a global variable into function scope (global $db;). To access global namespace members, use the \ prefix or use statements.