Parlez de la programmation fonctionnelle et de ses…

La programmation fonctionnelle (PF) est un paradigme de programmation qui considère les calculs comme l’évaluation de fonctions mathématiques, évitant ainsi les changements d’état et les données mutables.

Principes fondamentaux:

Fonctions pures: Une fonction est considérée comme pure si:

Elle retourne toujours le même résultat pour les mêmes arguments.
Elle n’a pas d’effets secondaires (ne modifie pas l’état global, ne réalise pas d’entrée/sortie, etc.).

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

// Fonction non pure (a un effet secondaire - modifie une variable globale)
$count = 0;
function increment_and_get(): int {
    global $count;
    $count++;
    return $count;
}

Immutabilité des données: Une fois créés, les données ne peuvent pas être modifiées. Au lieu de changer un objet existant, on en crée un nouveau avec les modifications nécessaires.

<?php
// Exemple d’immutabilité (en PHP ce n’est pas un principe strict du langage, mais il peut être implémenté)
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;
    }

    // Au lieu de modifier, retourne un nouvel objet
    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 reste (1, 2), $p2 devient (2, 3)

Fonctions comme objets de première classe: Les fonctions peuvent être passées comme arguments à d’autres fonctions, retournées par des fonctions, assignées à des variables.

<?php
// Fonctions comme variables
$greeter = function(string $name): string {
    return "Hello, " . $name;
};

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

// Fonctions comme arguments
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]

Absence d’effets secondaires: Les calculs n’affectent pas l’état du programme en dehors de leur portée.
Déclarativité: Se concentre sur ce qu’il faut calculer, et non sur comment.

Avantages:

Meilleure testabilité (les fonctions pures sont faciles à tester).
Simplification du parallélisme (l’absence d’état mutable réduit les problèmes de synchronisation).
Meilleure débogabilité.
Comportement du code plus prévisible.

Parlez de la programmation fonctionnelle et de ses principes.