¿Cómo están relacionadas la inmutabilidad y la…

La inmutabilidad (objetos inalterables) y la pureza (funciones sin efectos secundarios) están estrechamente relacionadas, ya que la inmutabilidad ayuda a lograr la pureza.

Función pura:

Siempre devuelve el mismo resultado para los mismos datos de entrada.
No modifica el estado fuera de su ámbito (no tiene efectos secundarios).

Si una función toma objetos mutables como argumentos y los modifica, no es pura, ya que su llamada puede cambiar el estado del sistema fuera de la función.

Usando objetos inmutables:

La función no puede cambiar los objetos pasados, ya que son inmutables.
Cualquier "cambio" resulta en la creación de un nuevo objeto, no en la modificación del existente.
Esto garantiza la ausencia de efectos secundarios relacionados con la modificación de los argumentos pasados.

Ejemplo:

<?php

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

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

// Función no pura (modifica el objeto pasado)
function moveMutablePoint(MutablePoint $point, $dx, $dy) {
    $point->x += $dx;
    $point->y += $dy;
}

$mutablePoint = new MutablePoint(0, 0);
moveMutablePoint($mutablePoint, 1, 1);
// $mutablePoint ahora es (1, 1) - el estado cambió fuera de la función

// Objeto inmutable
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;
    }

    // El método devuelve UN NUEVO objeto, no modifica el actual
    public function move($dx, $dy): self {
        return new self($this->x + $dx, $this->y + $dy);
    }
}

// Función pura (trabaja con objetos inmutables)
function moveImmutablePoint(ImmutablePoint $point, $dx, $dy): ImmutablePoint {
    return $point->move($dx, $dy);
}

$immutablePoint = new ImmutablePoint(0, 0);
$newImmutablePoint = moveImmutablePoint($immutablePoint, 1, 1);
// $immutablePoint permanece en (0, 0) - el estado no cambió fuera de la función
// $newImmutablePoint ahora es (1, 1) - se creó un nuevo objeto

De esta manera, el uso de objetos inmutables es una de las formas de crear funciones puras, lo que favorece un código más predecible, testeable y fácil de mantener.

¿Cómo están relacionadas la inmutabilidad y la pureza?