PHP : les monades

Ce post est fortement inspiré de la conférence technique de Gina Banyard au "FORUM PHP 2024" :

Forum PHP 2024

spO0q ?? ・ 13 octobre

#php #programmation #techtalks

Démystifier les monades avec 3 synonymes simples

Commençons par quelques synonymes :

• conteneurs
• emballages
• modèles de conception

Si vous recherchez « monades PHP » sur Google, d'autres concepts apparaîtront rapidement, comme la programmation fonctionnelle, la liaison, les piles et même les mathématiques ésotériques (par exemple, foncteur, monoïdes).

N'ayez pas peur.

À la base, une Monade est un modèle qui peut être implémenté de différentes manières.

Modèles de conception

Lorsque vous avez des opérations à exécuter, vous pouvez simplement définir des objets et des assistants personnalisés, comme d'habitude.

Alors, pourquoi s'embêter avec des concepts alternatifs ?

À mon humble avis, c'est toujours une bonne question, car il faut rester efficace, mais il existe des limites communes avec les approches classiques :

• l'ordre des opérations compte
• Code WET
• exceptions

Les monades peuvent gérer les valeurs facultatives (ou non encore disponibles) de manière plus cohérente.

Monad vs gestion des erreurs/exceptions classiques

Les projets modernes incluent des outils d'analyse statique, mais les exceptions PHP ne sont pas saisies.

En d'autres termes, les outils ne peuvent pas détecter les exceptions dans la signature de la fonction, ils ne peuvent donc pas déterminer si le code gère correctement les exceptions.

Pour tester cela, les équipes de développement écrivent généralement des tests fonctionnels, mais une détection précoce avec une analyse statique serait plus fiable.

Source : "Les Exception : le trou dans la raquette du typage" (fr)

Avec Monads, vous obtenez un objet typé dans tous les cas, par exemple, un cas d'énumération personnalisé (par exemple, FileErrors::AccessDenied), donc l'erreur est saisie dans le système.

Implémentation de la monade Logger

Construire un système de journalisation robuste peut être un défi. Il est facile de dupliquer des chaînes et des appels.

Au lieu de tout coder en dur, vous définiriez probablement un assistant personnalisé appelé log() et l'utiliseriez partout dans votre projet.

Cela viserait à garder le code SEC mais pourrait ne pas permettre de composer des fonctions plus complexes dans des cas spécifiques.

L'approche fonctionnelle ne consisterait pas à utiliser un tel helper global. Au lieu de cela, il préférerait implémenter une Monade pour envelopper d'autres fonctions :

final class LoggerMonad {
    public function __construct(
        public mixed $data,
        public array $logs = [],
    ) {}

    public function bind(callable $fn) {
         $resultLoggerMonad = $fn($this->data);
         return new LoggerMonad(
             $resultLoggerMonad->data,
             [...$this->logs, ...$resultLoggerMonad->logs],
         );
   }
}

function loggify(callable $fn): Closure {
    return function ($value) use ($fn) {
        $name = (new ReflectionFunction($fn))->name;
        $log = [
            'Running '. $name .'('. var_export($value, true) .')'
        ];
        return new LoggerMonad($fn($value), $log);
    };
}

Ensuite, vous pouvez utiliser le wrapper loggify comme ça :

function add2(int $v): int {
    return $v + 2;
}

function square(int $v): int {
    return $v * $v;
}

function multi3(int $v): int {
    return $v * 3;
}

function logIt($value, callable ...$fns) {
    $logging_fns = array_map(loggify(...), $fns);
    $monad = new LoggerMonad($value);
    foreach ($logging_fns as $fn) {
        $monad = $monad->bind($fn);
    }
    return $monad;
}

print_r(logIt(
   3,
   add2(...),
   square(...),
   multi3(...)
));

Source : "Monades simplement" de Gina Banyard (fr)

Qu'est-ce que la liaison ?

?? Bébé ne me fais pas de mal

Les monades sont destinées à envelopper des valeurs, qui peuvent être de n'importe quel type, y compris des objets et des fonctions.

Comme dans tout autre système d'emballage, vous trouverez un constructeur (~ classe) qui prend cette valeur en entrée et quelques méthodes qui ont leurs propres objectifs en fonction du modèle que vous essayez d'implémenter.

Cependant, toutes les Monades incluent une fonction de liaison. Comme son nom l'indique, c'est ici que les valeurs (ou rappels) sont transmises.

Quoi qu'il arrive dans ces rappels, la monade l'enveloppera, ce qui semble un moyen puissant de décorer les valeurs et de refactoriser le code.

Le code est-il plus lisible ?

Cela dépend clairement de la mise en œuvre, et il est facile de se perdre au début.

Cependant, cette approche alternative peut réduire considérablement le nombre de blocs if et rendre les valeurs de retour plus cohérentes :

final class LoggerMonad {
    public function __construct(
        public mixed $data,
        public array $logs = [],
    ) {}

    public function bind(callable $fn) {
         $resultLoggerMonad = $fn($this->data);
         return new LoggerMonad(
             $resultLoggerMonad->data,
             [...$this->logs, ...$resultLoggerMonad->logs],
         );
   }
}

function loggify(callable $fn): Closure {
    return function ($value) use ($fn) {
        $name = (new ReflectionFunction($fn))->name;
        $log = [
            'Running '. $name .'('. var_export($value, true) .')'
        ];
        return new LoggerMonad($fn($value), $log);
    };
}

Source : fp4php - monades

Avantages et inconvénients

Avantages

• ✅ il existe différentes monades à des fins différentes : Peut-être, Soit, Logger, Liste, Lecteur, etc
• ✅ les monades permettent d'encapsuler le code avec de meilleurs types, ce qui peut améliorer l'analyse statique
• ✅ PHP ne fournit pas de constructions intégrées pour cela, donc l'implémentation dépend entièrement du développeur

Inconvénients

• ❌ PHP ne fournit pas de structures intégrées (par exemple, génériques) pour cela, donc l'implémentation dépend entièrement du développeur
• ❌ ça ne simplifie pas le code

Aller plus loin

• Gestion des erreurs fonctionnelles avec les monades, les transformateurs de monades et Cats MTL
• Monades et utilisation en PHP
• Programmation fonctionnelle en PHP

Conclure

J'espère que vous en savez maintenant un peu plus sur les monades PHP.

Bien sûr, vous ne devez pas ajouter des modèles de conception fantaisistes à votre projet juste pour le plaisir.

De plus, il est facile de passer à côté de l'essentiel et de se concentrer sur des aspects très spécifiques, comme la gestion des erreurs, alors qu'il s'agit d'un tout nouveau paradigme.

Cependant, cela reste rafraîchissant de découvrir de nouvelles approches. Nous devons sortir des sentiers battus.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!