Parla di programmazione funzionale e dei suoi…

La programmazione funzionale (FP) è un paradigma di programmazione che considera i calcoli come valutazione di funzioni matematiche, evitando modifiche di stato e dati mutabili.

Principi fondamentali:

Funzioni pure: Una funzione è considerata pura se:

Restituisce sempre lo stesso risultato per gli stessi argomenti.
Non ha effetti collaterali (non modifica lo stato globale, non esegue input/output, ecc.).

<?php
// Funzione pura
function add(int $a, int $b): int {
    return $a + $b;
}

// Funzione non pura (ha effetto collaterale - modifica una variabile globale)
$count = 0;
function increment_and_get(): int {
    global $count;
    $count++;
    return $count;
}

Immutabilità dei dati: Una volta creati, i dati non possono essere modificati. Invece di modificare un oggetto esistente, si crea uno nuovo con le modifiche necessarie.

<?php
// Esempio di immutabilità (in PHP non è un principio rigoroso del linguaggio, ma può essere implementato)
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;
    }

    // Invece di modificare, restituisce un nuovo oggetto
    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 rimane (1, 2), $p2 diventa (2, 3)

Funzioni come oggetti di prima classe: Le funzioni possono essere passate come argomenti ad altre funzioni, restituite da funzioni, assegnate a variabili.

<?php
// Funzioni come variabili
$greeter = function(string $name): string {
    return "Hello, " . $name;
};

echo $greeter("World"); // Output: Hello, World

// Funzioni come argomenti
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]

Assenza di effetti collaterali: I calcoli non influenzano lo stato del programma al di fuori del loro ambito.
Dichiaratività: Si concentra su cosa deve essere calcolato, non su come.

Vantaggi:

Migliore testabilità (le funzioni pure sono facili da testare).
Semplificazione del parallelismo (l’assenza di stato mutabile riduce i problemi di sincronizzazione).
Migliore debug.
Comportamento del codice più prevedibile.

Parla di programmazione funzionale e dei suoi principi.