Vorbește despre programarea funcțională și…

Programarea funcțională (FP) este un paradigm de programare care consideră calculele ca evaluarea funcțiilor matematice, evitând modificarea stării și datele mutabile.

Principii de bază:

Funcții pure: O funcție este considerată pură dacă:

Întotdeauna returnează același rezultat pentru aceiași argumente.
Nu are efecte secundare (nu modifică starea globală, nu efectuează intrare/ieșire etc.).

<?php
// Funcție pură
function add(int $a, int $b): int {
    return $a + $b;
}

// Funcție nepură (are efect secundar - modifică o variabilă globală)
$count = 0;
function increment_and_get(): int {
    global $count;
    $count++;
    return $count;
}

Imutabilitatea datelor: Odată create, datele nu pot fi modificate. În loc să se modifice un obiect existent, se creează unul nou cu modificările necesare.

<?php
// Exemplu de imutabilitate (în PHP nu este un principiu strict al limbajului, dar poate fi implementat)
class ImmutablePoint {
    private int $x;
    private int $y;

    public function __construct(int $x, int $y) {
        $this->x = $x;
        $this->y = $y;
    }

    public function getX(): int {
        return $this->x;
    }

    public function getY(): int {
        return $this->y;
    }

    // În loc să se modifice, se returnează un obiect nou
    public function move(int $dx, int $dy): self {
        return new self($this->x + $dx, $this->y + $dy);
    }
}

$p1 = new ImmutablePoint(1, 2);
$p2 = $p1->move(1, 1); // $p1 rămâne (1, 2), $p2 devine (2, 3)

Funcții ca obiecte de primă clasă: Funcțiile pot fi transmise ca argumente altor funcții, returnate din funcții, atribuite variabilelor.

<?php
// Funcții ca variabile
$greeter = function(string $name): string {
    return "Hello, " . $name;
};

echo $greeter("World"); // Afișează: Hello, World

// Funcții ca argumente
function apply_transform(array $data, callable $transform): array {
    $result = [];
    foreach ($data as $item) {
        $result[] = $transform($item);
    }
    return $result;
}

$numbers = [1, 2, 3];
$doubled_numbers = apply_transform($numbers, function(int $n): int {
    return $n * 2;
}); // $doubled_numbers = [2, 4, 6]

Lipsa efectelor secundare: Calculul nu afectează starea programului în afara domeniului său.
Declarativ: Se concentrează pe ce trebuie calculat, nu pe cum.

Avantaje:

Testare mai bună (funcțiile pure sunt ușor de testat).
Simplificarea paralelismului (lipsa stării mutable reduce problemele de sincronizare).
Debugging mai bun.
Comportament mai previzibil al codului.

Vorbește despre programarea funcțională și principiile sale.