PHP Programming in the 21st Century: Collections instead of loops, functional thinking, and separating data preparation from side effects

readonlyenummatchstrlen(...)

Why collections are better than "manual" loops

forforeach

• Declarative:

• The composition:

• Fewer states:

• Testability:

Example: filter, projection and aggregate

Before (imperative):

$total=0; foreach ($orders as $order) { if ($order['status']==='paid' && $order['amount'] > 1000) { $total +=$order['amount'] * 0.9; // скидка } }

After (pure PHP, no frameworks):

$paidOver1000=array_filter($orders, fn($o)=> $o['status']==='paid' && $o['amount'] > 1000); $discounted=array_map(fn($o)=> $o['amount'] * 0.9, $paidOver1000); $total=array_reduce($discounted, fn($sum, $a)=> $sum + $a, 0);

With a collection (for example, Laravel Collection):

use Illuminate\Support\Collection; /** @var Collection $orders */ $total=$orders ->where('status', 'paid') ->filter(fn($o)=> $o['amount'] > 1000) ->map(fn($o)=> $o['amount'] * 0.9) ->sum();

map()

Functional programming in PHP: basic techniques

Pure functions and immutable data

echo

final class Money { public function __construct( public readonly int $amountCents, public readonly string $currency, ) {} } function applyDiscount(Money $price, float $rate): Money { return new Money((int)round($price->amountCents * (1 - $rate)), $price->currency); }

Higher-order functions and "first-class" callbacks

In PHP 8.1+, you can get a callable "as a value":

$len=strlen(...); // callable echo $len('hello'); // 5

It's convenient for composition.:

$trim=fn (string $s): string=> trim ($s); $upper=fn (string $s): string=> mb_strtoupper($s); $format=fn (string $s): string=> $top($trim($s)); echo $format ("hi"); / / "HI"

Currying and partial application

$multiply=fn(int $a)=> fn(int $b)=> $a * $b; $double=$multiply(2); echo $double(21); // 42

Composition via pipes

pipe()

$result=collect($users) ->filter(fn($u)=> $u->active) ->pipe(fn($c)=> ['count'=> $c->count(), 'emails'=> $c->pluck('email')->all()]);

Separation of data preparation from side effects ("Functional Core, Imperative Shell")

Idea:

Example: importing CSV clients

Step 1. Clean data preparation

final class ClientDTO { public function __construct( public readonly string $email, public readonly string $name, public readonly ?string $phone, ) {} } function parseCsv(string $path): iterable { $h=fopen($path, 'rb'); try { while (($row=fgetcsv($h, 0, ';')) !==false) { yield $row; } } finally { fclose($h); } } function toClientDTO(iterable $rows): iterable { foreach ($rows as [$email, $name, $phone]) { $email=mb_strtolower(trim($email)); if (!filter_var($email, FILTER_VALIDATE_EMAIL)) { continue; // отбрасываем невалидные } yield new ClientDTO($email, trim($name), $phone ? trim($phone) : null); } } // Конвейер подготовки $clients=toClientDTO(parseCsv('/path/clients.csv')); // iterable чистых DTO

Step 2. Imperative shell — a single point of side effects

function persistClients(iterable $clients, PDO $pdo): int { $count=0; $pdo->beginTransaction(); try { $stmt=$pdo->prepare('INSERT INTO clients(email, name, phone) VALUES(?, ?, ?) ON CONFLICT(email) DO NOTHING'); foreach ($clients as $c) { $stmt->execute([$c->email, $c->name, $c->phone]); $count++; } $pdo->commit(); return $count; } catch (Throwable $e) { $pdo->rollBack(); throw $e; } } // Все эффекты — здесь: $pdo=new PDO(/* ... */); $count=persistClients($clients, $pdo);

Advantages: pure functions are easily covered by tests; any side effects are localized and transparently monitored (transactions, backups, logging).

Collections + Laziness: when memory and speed are important

generatorsyieldlazy collectionsLazyCollection

function numbers(): iterable { for ($i=0; $i < 10_000_000; $i++) { yield $i; } } $sum=0; foreach (numbers() as $n) { if ($n % 2===0) { $sum +=$n; } }

In Laravel:

use Illuminate\Support\LazyCollection; $sum=LazyCollection::make(fn()=> numbers()) ->filter(fn($n)=> $n % 2===0) ->reduce(fn($acc, $n)=> $acc + $n, 0);

The rule:

readonlyenum

Modern PHP encourages resilient data models.

enum OrderStatus: string { case NEW='new'; case PAID='paid'; case SHIPPED='shipped'; } final class OrderLine { public function __construct( public readonly string $sku, public readonly int $qty, public readonly int $priceCents, ) {} } final class Order { /** @param OrderLine[] $lines */ public function __construct( public readonly string $id, public OrderStatus $status, public readonly array $lines, ) {} public function total(): int { return array_reduce($this->lines, fn($s, $l)=> $s + $l->qty * $l->priceCents, 0); } }

• readonly

• enum

• total()

Realistic pipeline of domain logic

Suppose you need to calculate bonuses for paid orders for the current month and send notifications.

A clean conveyor:

/** @return iterable */ function paidOrdersForMonth(iterable $orders, DateTimeImmutable $month): iterable { foreach ($orders as $o) { if ($o->status===OrderStatus::PAID && $o->createdAt->format('Y-m')===$month->format('Y-m')) { yield $o; } } } function calculateBonusCents(Order $o): int { $total=$o->total(); return (int)round($total * 0.05); } function bonuses(iterable $orders, DateTimeImmutable $month): iterable { foreach (paidOrdersForMonth($orders, $month) as $o) { yield [$o->id, calculateBonusCents($o)]; } }

The border of side effects:

function persistBonuses(iterable $items, PDO $pdo): void { $stmt=$pdo->prepare('INSERT INTO bonuses(order_id, amount_cents) VALUES(?, ?)'); $pdo->beginTransaction(); try { foreach ($items as [$orderId, $amount]) { $stmt->execute([$orderId, $amount]); } $pdo->commit(); } catch (Throwable $e) { $pdo->rollBack(); throw $e; } } function notify(iterable $items, callable $send): void { foreach ($items as [$orderId, $amount]) { $send("Order #$orderId bonus: $amount cents"); } } // Использование: $items=bonuses($ordersFromRepo, new DateTimeImmutable('now')); // можно разветвить поток: persistBonuses($items, $pdo); // если нужно уведомлять — пересоздайте генератор или предварительно материализуйте список: $items2=iterator_to_array(bonuses($ordersFromRepo, new DateTimeImmutable('now'))); notify($items2, $mailerSend);

iterator_to_array

Mistakes and non-obvious points

• Micro-optimizations versus clarity.

• Hidden mutation of the input.

• Side effects in the middle of the pipeline.map()DB::insert()

• Uncontrollable laziness.

• Mixing validation and effects.all

Practical techniques for teams

1. The "collections only" internal guide:map/filter/reduce/pipe

2. Clean modules:DomainInfrastructure

3. Typing is everywhere:enumreadonly

4. Lazy pipelines for large streams:LazyCollection

5. Transformation tests:

6. Transactions and retrays — in the shell:

7. Wrappers-adapters for effects:

Mini cheat sheet

• Convert:

  • foreacharray_map->map()

  • array_filter->filter()

  • array_reduce->sum()->reduce()

• Effect boundaries:

  • Database/HTTP/files/log — only in shell services (Application/Infrastructure).

• Efficiency:

  • LazyCollection

  • Hot spots → profile, not guess.

• Typing:

  • enumreadonly

Conclusion

echomap/filter/reduce