Pipe Operator Simulation in PHP: Funktionsketten bauen

1. Warum PHP keinen nativen Pipe Operator hat

Ein Pipe Operator, wie ihn Elixir mit |> oder das lange diskutierte JavaScript-Proposal anbietet, leitet den Rückgabewert eines Ausdrucks direkt als Eingabe in den nächsten Ausdruck weiter. PHP kennt dieses Sprachfeature nicht, obwohl es mehrfach als RFC diskutiert wurde. Ohne nativen Operator bleibt nur die Möglichkeit, denselben Effekt über eine gewöhnliche Funktion nachzubilden, die eine Liste von Funktionen nacheinander auf einen Startwert anwendet.

Diese Pipe Operator Simulation ist kein Ersatz mit Kompromissen, sondern in der Praxis fast gleichwertig: eine pipe()-Funktion mit variabler Argumentanzahl übernimmt exakt dieselbe Aufgabe wie ein nativer Operator, nur mit etwas mehr Zeichen pro Aufruf. Der entscheidende Vorteil gegenüber tief verschachtelten Funktionsaufrufen bleibt erhalten: die Leserichtung folgt dem tatsächlichen Datenfluss, von der ersten bis zur letzten Transformation.

Dieser Artikel zeigt den vollständigen Aufbau einer Pipe Operator Simulation in PHP 8.4, von der einfachen pipe()-Funktion über compose() bis zur Fehlerbehandlung und Typisierung mit PHPStan.

2. Das Problem verschachtelter Funktionsaufrufe

Ohne Pipe Operator werden mehrstufige Transformationen in PHP häufig als verschachtelte Funktionsaufrufe geschrieben: f(g(h($wert))). Die Reihenfolge, in der die Funktionen tatsächlich ausgeführt werden, ist dabei von innen nach außen, während die Leserichtung des Codes von außen nach innen verläuft. Bei mehr als drei verschachtelten Aufrufen wird dieser Bruch zwischen Ausführungsreihenfolge und Leserichtung zu einer echten Fehlerquelle beim Nachvollziehen des Codes.

Die Alternative, eine Kette von Zwischenvariablen, löst das Leserichtungsproblem, führt aber neue, meist schlecht benannte Variablen wie $step1, $step2 ein, die den Namensraum der Funktion unnötig aufblähen. Eine Pipe Operator Simulation löst beide Probleme gleichzeitig: die Leserichtung folgt dem Datenfluss, und es entstehen keine überflüssigen Zwischenvariablen im umgebenden Scope.

<?php

declare(strict_types=1);

function slugify(string $s): string
{
    return strtolower(trim($s));
}

function replaceSpaces(string $s): string
{
    return str_replace(' ', '-', $s);
}

function removeSpecialChars(string $s): string
{
    return preg_replace('/[^a-z0-9\-]/', '', $s);
}

// Nested calls — execution order is inside-out, reading order is outside-in
$slugNested = removeSpecialChars(replaceSpaces(slugify('  Hello World! ')));

// Intermediate variables — readable order, but clutters the scope
$step1 = slugify('  Hello World! ');
$step2 = replaceSpaces($step1);
$slugSteps = removeSpecialChars($step2);

3. Eine eigene pipe()-Funktion implementieren

Die Kernidee einer Pipe Operator Simulation ist eine Funktion, die einen Startwert und eine variable Anzahl weiterer Funktionen entgegennimmt und diese Funktionen nacheinander anwendet, wobei jede Funktion das Ergebnis der vorherigen als Eingabe erhält. Mit array_reduce lässt sich das in einer einzigen, kompakten Implementierung umsetzen, ohne eine Schleife von Hand zu schreiben.

Wichtig für eine robuste Pipe Operator Simulation ist die First-Class-Callable-Syntax aus PHP 8.1 als Aufrufform: slugify(...) statt des Strings 'slugify', damit die IDE und PHPStan jede Stufe der Pipeline statisch prüfen können. Ebenso wichtig ist die Reihenfolge der Parameter: eine pipe()-Funktion liest sich am natürlichsten, wenn der Startwert zuerst steht, gefolgt von den Transformationsfunktionen in Ausführungsreihenfolge.

<?php

declare(strict_types=1);

/**
 * Applies a sequence of single-argument functions left to right.
 *
 * @param mixed $initial
 * @param callable ...$fns
 * @return mixed
 */
function pipe(mixed $initial, callable ...$fns): mixed
{
    return array_reduce(
        $fns,
        fn (mixed $carry, callable $fn): mixed => $fn($carry),
        $initial,
    );
}

// Reading order now matches execution order, left to right
$slug = pipe(
    '  Hello World! ',
    slugify(...),
    replaceSpaces(...),
    removeSpecialChars(...),
);

echo $slug; // hello-world

4. compose(): Funktionsketten ohne Zwischenwert bauen

Während pipe() sofort einen Startwert entgegennimmt und das Endergebnis liefert, erzeugt compose() stattdessen eine neue, wiederverwendbare Funktion, ohne selbst einen Wert auszuwerten. Diese neue Funktion kann beliebig oft mit unterschiedlichen Eingaben aufgerufen werden, was compose() von der einmaligen Auswertung durch pipe() unterscheidet. Der Unterschied ist vergleichbar mit dem zwischen einem sofort ausgeführten Ausdruck und einer benannten Funktion.

Mathematisch entspricht compose(f, g, h) der Funktion x => h(g(f(x))), wobei die Reihenfolge in der Pipe Operator Simulation bewusst von links nach rechts gewählt wird, entgegen der mathematischen Konvention, die meist von rechts nach links liest. Diese Entscheidung folgt der intuitiveren Leserichtung des Pipe Operators und sollte im Team konsistent dokumentiert werden, um Verwechslungen mit der mathematischen Notation zu vermeiden.

<?php

declare(strict_types=1);

/**
 * Builds a reusable function from a sequence of single-argument functions.
 *
 * @param callable ...$fns
 * @return Closure(mixed): mixed
 */
function compose(callable ...$fns): Closure
{
    return function (mixed $initial) use ($fns): mixed {
        return pipe($initial, ...$fns);
    };
}

// Build once, call the resulting closure many times
$slugify = compose(
    slugify(...),
    replaceSpaces(...),
    removeSpecialChars(...),
);

echo $slugify('  Hello World! ');   // hello-world
echo $slugify('  Another Title ');  // another-title

5. Praxisbeispiel: Datenverarbeitung als Pipeline

Ein häufiger Anwendungsfall für eine Pipe Operator Simulation ist die Verarbeitung von CSV-Zeilen oder API-Antworten in mehreren klar getrennten Schritten: Parsen, Normalisieren, Validieren, Transformieren. Jeder Schritt bleibt eine kleine, isoliert testbare Funktion, während pipe() die Reihenfolge der Anwendung übernimmt. Das macht jeden einzelnen Verarbeitungsschritt einzeln durch Unit-Tests absicherbar, ohne die gesamte Pipeline mit aufzusetzen.

Der Vorteil gegenüber einer einzigen großen Funktion mit allen Schritten inline: jede Stufe der Pipe Operator Simulation kann unabhängig ausgetauscht, wiederverwendet oder in einer anderen Reihenfolge kombiniert werden. Eine Import-Pipeline für Produktdaten und eine Export-Pipeline für Berichte können so dieselben Normalisierungsschritte teilen, ohne Code zu duplizieren.

<?php

declare(strict_types=1);

/**
 * @param array<string, string> $row
 * @return array<string, string>
 */
function trimAllValues(array $row): array
{
    return array_map(trim(...), $row);
}

/**
 * @param array<string, string> $row
 * @return array{sku: string, price: float, name: string}
 */
function normalizeRow(array $row): array
{
    return [
        'sku' => strtoupper($row['sku']),
        'price' => (float) str_replace(',', '.', $row['price']),
        'name' => ucfirst($row['name']),
    ];
}

/**
 * @param array{sku: string, price: float, name: string} $row
 * @return array{sku: string, price: float, name: string}
 */
function applyMinimumPrice(array $row): array
{
    $row['price'] = max($row['price'], 0.01);
    return $row;
}

$rawRow = ['sku' => ' sku-123 ', 'price' => '19,90', 'name' => ' widget '];

$processedRow = pipe(
    $rawRow,
    trimAllValues(...),
    normalizeRow(...),
    applyMinimumPrice(...),
);

// ['sku' => 'SKU-123', 'price' => 19.9, 'name' => 'Widget']

6. Fehlerbehandlung in Pipelines: früh abbrechen

Ein einfacher pipe()-Aufruf bricht nicht automatisch ab, wenn eine Zwischenstufe einen ungültigen Zustand liefert, etwa null bei einem fehlgeschlagenen Parse-Schritt. Die nächste Funktion in der Kette erhält dann diesen ungültigen Wert und schlägt möglicherweise mit einer unklaren Fehlermeldung fehl, weit entfernt von der eigentlichen Fehlerursache. Für robuste Pipelines lohnt sich eine Variante, die nach jeder Stufe auf null prüft und die Kette bei Bedarf sofort abbricht.

Diese defensive Pipe Operator Simulation lässt sich elegant mit dem Nullsafe-Operator oder einer eigenen pipeOrNull()-Variante umsetzen, die jede Stufe überspringt, sobald der Wert null geworden ist. Der nächste Artikel in dieser Reihe zeigt, wie Maybe- und Either-Typen dieselbe Aufgabe noch expliziter lösen, indem der Fehlerzustand Teil des Rückgabetyps wird, statt implizit über null transportiert zu werden.

<?php

declare(strict_types=1);

/**
 * Pipe variant that short-circuits as soon as a stage returns null.
 *
 * @param mixed $initial
 * @param callable ...$fns
 * @return mixed
 */
function pipeOrNull(mixed $initial, callable ...$fns): mixed
{
    $value = $initial;

    foreach ($fns as $fn) {
        if ($value === null) {
            return null;
        }

        $value = $fn($value);
    }

    return $value;
}

function parseInteger(string $s): ?int
{
    return ctype_digit($s) ? (int) $s : null;
}

function doubleIt(int $n): int
{
    return $n * 2;
}

echo pipeOrNull('42', parseInteger(...), doubleIt(...));  // 84
var_dump(pipeOrNull('abc', parseInteger(...), doubleIt(...))); // NULL, doubleIt never runs

7. Typisierung mit PHPStan: Templates für generische Pipelines

Eine generische pipe()-Funktion mit mixed-Typen prüft für PHPStan nicht, ob die Ausgabe einer Stufe zum erwarteten Eingabetyp der nächsten Stufe passt. Für kleine, feste Pipelines lohnt sich deshalb eine spezialisierte, typisierte Variante mit konkreten Parametertypen statt mixed, etwa pipeStringToInt(string $s, callable $a, callable $b): int. Diese Variante verliert an Generizität, gewinnt aber vollständige statische Prüfbarkeit.

Für generische Pipelines mit variabler Stufenanzahl bietet PHPStan @template-Typen an, die zumindest den Eingabetyp der ersten Stufe und den Rückgabetyp der letzten Stufe korrekt propagieren, auch wenn die Typen der Zwischenstufen für PHPStan an dieser Stelle nicht mehr vollständig verfolgt werden können. In der Praxis reicht das meist aus, um die häufigsten Tippfehler bei Funktionsnamen und offensichtliche Typinkompatibilitäten am Anfang und Ende der Kette zu erkennen.

<?php

declare(strict_types=1);

/**
 * Two-stage typed pipe for maximum static analysis precision.
 *
 * @template TInput
 * @template TMiddle
 * @template TOutput
 * @param TInput $initial
 * @param Closure(TInput): TMiddle $first
 * @param Closure(TMiddle): TOutput $second
 * @return TOutput
 */
function pipe2(mixed $initial, Closure $first, Closure $second): mixed
{
    return $second($first($initial));
}

$result = pipe2(
    '  Hello World! ',
    slugify(...),
    strlen(...),
);
// PHPStan infers $result as int

8. Pipe Operator vs. Fluent Interfaces und Methodenketten

Fluent Interfaces, bei denen jede Methode $this zurückgibt und Methodenaufrufe verkettet werden, lösen ein ähnliches Lesbarkeitsproblem wie eine Pipe Operator Simulation, sind aber an eine bestimmte Klasse gebunden. Eine pipe()-Funktion funktioniert dagegen mit beliebigen, unabhängigen Funktionen aus unterschiedlichen Namespaces und benötigt keine gemeinsame Basisklasse oder ein durchgängiges Interface.

Der Nachteil von Fluent Interfaces: sie erzwingen, dass jede Methode zur selben Klasse gehört, was bei der Kombination von Funktionen aus verschiedenen Bibliotheken zu unnötigen Wrapper-Klassen führt. Eine Pipe Operator Simulation mit freien Funktionen ist hier flexibler, weil beliebige callable-Werte kombiniert werden können, unabhängig davon, ob sie aus einer Klasse, einer globalen Funktion oder einer anonymen Closure stammen.

9. Pipe Operator Simulation im direkten Vergleich

Die folgende Tabelle stellt die verschiedenen Ansätze für mehrstufige Transformationen in PHP gegenüber und zeigt, wann eine Pipe Operator Simulation die lesbarste Lösung ist.

Für einmalige Transformationen ist pipe() die direkteste Lösung, für wiederholt benötigte Ketten lohnt sich compose(), das die Kette einmal baut und danach beliebig oft aufruft, ohne die Funktionsliste erneut anzugeben.

10. Zusammenfassung

Eine Pipe Operator Simulation in PHP ersetzt tief verschachtelte Funktionsaufrufe und unnötige Zwischenvariablen durch eine lesbare, links nach rechts fließende Kette von Transformationen. Die eigene pipe()-Funktion wertet sofort einen Startwert aus, während compose() eine wiederverwendbare Funktion für mehrfache Anwendung erzeugt. Beide Bausteine basieren auf array_reduce und der First-Class-Callable-Syntax und benötigen keine externe Bibliothek.

Für Robustheit in echten Pipelines lohnt sich eine Variante wie pipeOrNull(), die bei ungültigen Zwischenwerten früh abbricht, statt Fehler unkontrolliert weiterzureichen. Mit PHPStan-Templates bleibt zumindest der Eingabe- und Ausgabetyp der gesamten Kette geprüft, auch wenn Zwischenstufen bei generischen Pipelines nicht vollständig typisiert werden können. Für die meisten Projekte reicht eine einzige gemeinsame pipe()-Funktion in einer zentralen Utility-Datei völlig aus.

11. FAQ: Pipe Operator Simulation in PHP