Comment l'immuabilité et la pureté sont-elles liées…

L'immuabilité (objets immuables) et la pureté (fonctions sans effets secondaires) sont étroitement liées, car l'immuabilité favorise la réalisation de la pureté.

Fonction pure :

Retourne toujours le même résultat pour les mêmes données d'entrée.
Ne modifie pas l'état en dehors de sa portée (pas d'effets secondaires).

Si une fonction prend des objets modifiables en argument et les modifie, elle n'est pas pure, car son appel peut changer l'état du système en dehors de la fonction.

En utilisant des objets immuables :

La fonction ne peut pas changer les objets passés, car ils sont immuables.
Toute "modification" conduit à la création d'un nouvel objet, et non à la modification de l'existant.
Cela garantit l'absence d'effets secondaires liés à la modification des arguments passés.

Exemple :

<?php

// Objet mutable
class MutablePoint {
    public $x;
    public $y;

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

// Fonction non pure (modifie l'objet passé)
function moveMutablePoint(MutablePoint $point, $dx, $dy) {
    $point->x += $dx;
    $point->y += $dy;
}

$mutablePoint = new MutablePoint(0, 0);
moveMutablePoint($mutablePoint, 1, 1);
// $mutablePoint est maintenant (1, 1) - l'état a changé en dehors de la fonction

// Objet immuable
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;
    }

    // La méthode retourne UN NOUVEL objet, ne modifie pas l'objet actuel
    public function move($dx, $dy): self {
        return new self($this->x + $dx, $this->y + $dy);
    }
}

// Fonction pure (travaille avec des objets immuables)
function moveImmutablePoint(ImmutablePoint $point, $dx, $dy): ImmutablePoint {
    return $point->move($dx, $dy);
}

$immutablePoint = new ImmutablePoint(0, 0);
$newImmutablePoint = moveImmutablePoint($immutablePoint, 1, 1);
// $immutablePoint reste à (0, 0) - l'état n'a pas changé en dehors de la fonction
// $newImmutablePoint est maintenant (1, 1) - un nouvel objet a été créé

Ainsi, l'utilisation d'objets immuables est l'une des façons de créer des fonctions pures, ce qui favorise un code plus prévisible, testable et facile à maintenir.

Comment l'immuabilité et la pureté sont-elles liées ?