Come sono collegati immutabilità e purezza?

L'immutabilità (oggetti non modificabili) e la purezza (funzioni senza effetti collaterali) sono strettamente correlate, poiché l'immutabilità favorisce il raggiungimento della purezza.

Funzione pura:

• Restituisce sempre lo stesso risultato per gli stessi dati di input.
• Non modifica lo stato al di fuori del suo ambito (nessun effetto collaterale).

Se una funzione prende oggetti mutabili come argomenti e li modifica, non è pura, poiché la sua chiamata può cambiare lo stato del sistema al di fuori della funzione.

Utilizzando oggetti immutabili:

• La funzione non può modificare gli oggetti passati, poiché sono immutabili.
• Qualsiasi "modifica" porta alla creazione di un nuovo oggetto, non alla modifica di quello esistente.
• Questo garantisce l'assenza di effetti collaterali legati alla modifica degli argomenti passati.

Esempio:

<?php

// Oggetto mutabile
class MutablePoint {
    public $x;
    public $y;

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

// Funzione non pura (modifica l'oggetto passato)
function moveMutablePoint(MutablePoint $point, $dx, $dy) {
    $point->x += $dx;
    $point->y += $dy;
}

$mutablePoint = new MutablePoint(0, 0);
moveMutablePoint($mutablePoint, 1, 1);
// $mutablePoint ora è (1, 1) - lo stato è cambiato fuori dalla funzione

// Oggetto immutabile
final class ImmutablePoint {
    private $x;
    private $y;

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

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

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

    // Il metodo restituisce UN NUOVO oggetto, non modifica quello attuale
    public function move($dx, $dy): self {
        return new self($this->x + $dx, $this->y + $dy);
    }
}

// Funzione pura (lavora con oggetti immutabili)
function moveImmutablePoint(ImmutablePoint $point, $dx, $dy): ImmutablePoint {
    return $point->move($dx, $dy);
}

$immutablePoint = new ImmutablePoint(0, 0);
$newImmutablePoint = moveImmutablePoint($immutablePoint, 1, 1);
// $immutablePoint rimane (0, 0) - lo stato non è cambiato fuori dalla funzione
// $newImmutablePoint ora è (1, 1) - è stato creato un nuovo oggetto

In questo modo, l'uso di oggetti immutabili è uno dei modi per creare funzioni pure, contribuendo a un codice più prevedibile, testabile e facilmente manutenibile.