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

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!