Programmation fonctionnelle avec phunkie: combinateurs d'analyseurs en php

Phunkie: Construire des combinateurs d'analyseurs en php (partie 1)

Ce tutoriel, adapté du blog Inviqa, montre comment créer des combinateurs d'analyseurs à l'aide de la bibliothèque fonctionnelle Phunkie pour PHP. Nous nous concentrerons sur les concepts de base et construions des analyseurs de base, en préparant la voie à des combinateurs plus avancés dans une partie ultérieure.

Pourquoi la programmation fonctionnelle pour les analyseurs?

La programmation fonctionnelle, en mettant l'accent sur les fonctions pures et la composabilité, est idéalement adaptée à la construction d'analyseurs robustes et maintenables. La capacité de combiner des fonctions d'analyse plus petites et bien définies en plus grandes et plus complexes est un avantage clé.

La bibliothèque Phunkie fournit les structures fonctionnelles nécessaires pour simplifier ce processus en php.

Comprendre les analyseurs

L'analyse est le processus de reconnaissance des phrases au sein d'une chaîne. Nous utiliserons l'analyse récursive-descente, une technique simple mais puissante.

combinateurs: puissance de composition

Les combinateurs

sont des modèles réutilisables pour la composition des fonctions. Dans la programmation fonctionnelle, ils sont fondamentaux pour construire des systèmes complexes à partir de composants plus simples. Nous implémenterons les analyseurs en fonction et utiliserons des combinateurs pour les combiner.

représentant des analyseurs avec des types

Un analyseur prend une chaîne en entrée et tente de faire correspondre une définition grammaticale. Le résultat est soit une correspondance réussie avec la chaîne restante, soit une défaillance. Nous utiliserons le type Pair de Phunkie pour représenter ce résultat: une paire contenant la partie correspondante et la chaîne restante. Pour gérer plusieurs correspondances possibles, nous utiliserons ImmList (liste immuable).

le Parser Tapez en php

use Phunkie\Types\Pair;
use Phunkie\Types\ImmList;

class Parser {
    private $run;
    public function __construct(callable $run) { $this->run = $run; }
    public function run(string $toParse): ImmList { return ($this->run)($toParse); }
}

Analyseurs primitifs

1. result(string $a): réussit toujours, renvoyant la chaîne donnée $a et la chaîne d'entrée inchangée.

   function result(string $a): Parser {
       return new Parser(fn(string $s) => ImmList(Pair($a, $s)));
   }

2. zero(): échoue toujours, renvoyant une liste vide.

   function zero(): Parser {
       return new Parser(fn($s) => Nil());
   }

3. item(): consomme le premier caractère de la chaîne d'entrée. Échoue si la chaîne est vide.

   function item(): Parser {
       return new Parser(fn(string $s) => strlen($s) == 0 ? Nil() : ImmList(Pair($s[0], substr($s, 1))));
   }

combinateurs d'analyseurs: seq

Le combinateur seq permet le séquençage des analyseurs. Il applique les analyseurs les uns après les autres, renvoyant les résultats combinés. Une implémentation naïve serait complexe et sujette aux erreurs. Au lieu de cela, nous tirons parti de la puissance des monades.

la méthode flatMap

La méthode flatMap (également connue sous le nom de bind) est un composant clé du modèle de monade. Il permet de chaîner des calculs, de gérer les résultats d'un analyseur et de les passer au suivant.

class Parser {
    // ... (previous code) ...

    public function flatMap(callable $f): Parser {
        return new Parser(function(string $s) use ($f) {
            return $this->run($s)->flatMap(function(Pair $result) use ($f) {
                return $f($result->_1)->run($result->_2);
            });
        });
    }
    public function map(callable $f) {
        return new Parser(function(string $s) use ($f) {
            return $this->run($s)->map(function(Pair $result) use ($f) {
                return Pair($f($result->_1), $result->_2);
            });
        });
    }
}

seq en utilisant flatMap et map

Une implémentation plus élégante seq utilisant flatMap et map:

use Phunkie\Types\Pair;
use Phunkie\Types\ImmList;

class Parser {
    private $run;
    public function __construct(callable $run) { $this->run = $run; }
    public function run(string $toParse): ImmList { return ($this->run)($toParse); }
}

ou, en utilisant des Phunkie pour la compréhension (0,6.0 et plus tard):

function result(string $a): Parser {
    return new Parser(fn(string $s) => ImmList(Pair($a, $s)));
}

Ceci conclut la partie 1. La partie 2 explorera des combinateurs plus avancés et des stratégies d'analyse.

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!