Funktionelle Programmierung mit Phunkie: Parser -Kombinatoren in PHP

Phunkie: Bau von Parser -Kombinatoren in Php (Teil 1)

Dieses aus dem Inviqa -Blog angepasste Tutorial zeigt, wie Parser -Kombinators mithilfe der Phunkie -Funktionsbibliothek für PHP erstellt werden. Wir werden uns auf die Kernkonzepte konzentrieren und grundlegende Parser aufbauen, wobei wir die Bühne für fortgeschrittenere Kombinatoren in einem nachfolgenden Teil setzen.

Warum funktionelle Programmierung für Parser?

funktionale Programmierung mit Schwerpunkt auf reinen Funktionen und Kompositionsfähigkeit eignet sich ideal für den Aufbau robuster und wartbarer Parser. Die Fähigkeit, kleinere, gut definierte Parsingfunktionen zu größeren, komplexeren zu kombinieren, ist ein wichtigerer Vorteil.

Die Phunkie -Bibliothek bietet die erforderlichen funktionalen Strukturen, um diesen Prozess in Php zu vereinfachen.

Parser verstehen

Parsing ist der Prozess des Erkennens von Phrasen innerhalb einer Zeichenfolge. Wir werden rekursives Parsen verwenden, eine unkomplizierte, aber leistungsstarke Technik.

Kombinatoren: Kompositionskraft

Kombinatoren sind wiederverwendbare Muster für das Komponieren von Funktionen. In der funktionellen Programmierung sind sie grundlegend für den Aufbau komplexer Systeme aus einfacheren Komponenten. Wir werden Parser als Funktionen implementieren und Kombinatoren verwenden, um sie zu kombinieren.

Parser mit Typen

repräsentieren

Ein Parser nimmt eine Zeichenfolge als Eingabe und versucht, eine grammatikalische Definition zu entsprechen. Das Ergebnis ist entweder eine erfolgreiche Übereinstimmung mit der verbleibenden Zeichenfolge oder einem Fehler. Wir werden Phunkies Pair -Typ verwenden, um dieses Ergebnis darzustellen: ein Paar, das den übereinstimmenden Teil und die verbleibende Zeichenfolge enthält. Um mehrere mögliche Übereinstimmungen zu verarbeiten, verwenden wir ImmList (unveränderliche Liste).

Der Parser Typ in 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); }
}

primitive Parsers

1. result(string $a): Es ist immer erfolgreich, die angegebene Zeichenfolge $a und die Eingangszeichenfolge unverändert zurückzugeben.

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

2. zero(): immer fehlschlägt und eine leere Liste zurückgibt.

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

3. item(): Verbraucht das erste Zeichen der Eingangszeichenfolge. Fällt fehl, wenn die Zeichenfolge leer ist.

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

Parser -Kombinatoren: seq

Der seq -Kombinator ermöglicht die Sequenzierung von Parsers. Es wendet Parsers nacheinander an und gibt die kombinierten Ergebnisse zurück. Eine naive Implementierung wäre komplex und fehleranfällig. Stattdessen nutzen wir die Kraft von Monaden.

Die flatMap -Methode

Die flatMap -Methode (auch als bind bekannt) ist eine Schlüsselkomponente des Monad -Musters. Es ermöglicht die Erkettung von Berechnungen, den Umgang mit den Ergebnissen eines Parsers und das Weitergeben an den nächsten.

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 Verwenden Sie flatMap und map

Eine elegantere seq -implementierung mit flatMap und 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); }
}

oder unter Verwendung von Phunkie's for Contension (0,6.0 und später):

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

Dies schließt zu Teil 1. Teil 2 werden fortgeschrittenere Kombinatoren und Parsenstrategien untersucht.

Das obige ist der detaillierte Inhalt vonFunktionelle Programmierung mit Phunkie: Parser -Kombinatoren in PHP. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!