Hoe zijn onveranderlijkheid en zuiverheid met elkaar…

Onveranderlijkheid (niet-veranderbare objecten) en puurheid (functies zonder bijwerkingen) zijn nauw met elkaar verbonden, omdat onveranderlijkheid helpt bij het bereiken van puurheid.

Puur functie:

Geeft altijd hetzelfde resultaat voor dezelfde invoergegevens.
Wijzigt de toestand buiten zijn scope niet (geen bijwerkingen).

Als een functie wijzigbare objecten als argumenten neemt en deze wijzigt, is deze niet puur, omdat de aanroep de systeemstatus buiten de functie kan veranderen.

Door gebruik te maken van onveranderlijke objecten:

Kan de functie de meegegeven objecten niet wijzigen, omdat ze onveranderlijk zijn.
Elke "wijziging" leidt tot het creëren van een nieuw object, niet tot het wijzigen van het bestaande.
Dit garandeert het ontbreken van bijwerkingen gerelateerd aan het wijzigen van de meegegeven argumenten.

Voorbeeld:

<?php

// Wijzigbaar object
class MutablePoint {
    public $x;
    public $y;

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

// Onpuur functie (wijzigt het meegegeven object)
function moveMutablePoint(MutablePoint $point, $dx, $dy) {
    $point->x += $dx;
    $point->y += $dy;
}

$mutablePoint = new MutablePoint(0, 0);
moveMutablePoint($mutablePoint, 1, 1);
// $mutablePoint is nu (1, 1) - de toestand is buiten de functie veranderd

// Onveranderlijk object
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;
    }

    // De methode geeft EEN NIEUW object terug, wijzigt niet het huidige
    public function move($dx, $dy): self {
        return new self($this->x + $dx, $this->y + $dy);
    }
}

// Puur functie (werkt met onveranderlijke objecten)
function moveImmutablePoint(ImmutablePoint $point, $dx, $dy): ImmutablePoint {
    return $point->move($dx, $dy);
}

$immutablePoint = new ImmutablePoint(0, 0);
$newImmutablePoint = moveImmutablePoint($immutablePoint, 1, 1);
// $immutablePoint blijft (0, 0) - de toestand is niet veranderd buiten de functie
// $newImmutablePoint is nu (1, 1) - er is een nieuw object gemaakt

Door gebruik te maken van onveranderlijke objecten, is het mogelijk om zuivere functies te maken, wat bijdraagt aan voorspelbaarder, testbaarder en onderhoudsvriendelijker code.

Hoe zijn onveranderlijkheid en zuiverheid met elkaar verbonden?