Partial Function Application in PHP 8.6, so ersetzt ihr Arrow Functions durch Platzhalter

Von Roland Golla
0 Kommentar
Dalí Elefant trägt Maschine mit Schrift Partial Function Application und PHP 8.6

Mit PHP 8.6 ist ein Feature erschienen, auf das viele von uns seit Jahren warten. Partial Function Application erlaubt es, eine Funktion mit nur einem Teil ihrer Argumente aufzurufen. Wo noch etwas fehlt, steht ein Fragezeichen. PHP führt die Funktion dann nicht aus. Ihr bekommt eine fertige Closure zurück, die auf den Rest wartet. Klingt klein, räumt aber in fast jedem Projekt auf, das viel mit array_map(), array_filter() oder dem Pipe Operator arbeitet. Wir zeigen euch hier, wie das Feature funktioniert, wo die Fallen liegen und wie ihr es im Team sicher einführt. Den Überblick über alle anderen Neuerungen findet ihr in PHP 8.6 neue Features erklärt.

PHP 8.6 im Team einführen?

Wir bringen eure Anwendung mit eurem Team auf PHP 8.6. Neue Syntax und Deprecations sichern wir mit Rector, PHPStan, PHPUnit und Cypress E2E Tests in der Pipeline ab.

Was ist Partial Function Application in PHP

Partial Function Application, kurz PFA, ist ein Funktionsaufruf mit Lücken. Ihr gebt die Argumente an, die ihr schon kennt. An die Stellen, die noch offen sind, setzt ihr einen Platzhalter. Das Ergebnis ist ein Closure Objekt. Erst wenn ihr diese Closure aufruft, läuft die eigentliche Funktion.

function greet(string $greeting, string $name): string
{
    return $greeting . ', ' . $name . '!';
}

$hello = greet('Hallo', ?);

echo $hello('Sabine'); // Hallo, Sabine!
echo $hello('Deniz');  // Hallo, Deniz!

Das Feature kommt von Larry Garfield und Arnaud Le Blanc. Ein erster Anlauf ist vor einigen Jahren gescheitert. Die zweite Version des RFC Partial Function Application v2 ging dann ohne eine einzige Gegenstimme durch. Das sagt viel darüber, wie sehr die Community diese Syntax wollte.

Die drei Platzhalter in PHP 8.6

PHP 8.6 kennt drei Arten von Platzhaltern. Ihr könnt sie kombinieren, solange die Reihenfolge stimmt.

PlatzhalterBedeutungBeispiel
?Genau ein Argument an dieser Positionround(?, 2)
...Alle restlichen Argumente, nur einmal und nur am Endesprintf('%s: %s', ...)
name: ?Ein benannter Parameter, unabhängig von der Positionjson_encode(?, flags: JSON_PRETTY_PRINT)

Die Reihenfolge im Aufruf ist fest. Erst kommen positionale Werte und ?, dann benannte Argumente, ganz am Ende optional .... Mindestens ein Platzhalter muss drin sein, sonst wäre es ein normaler Funktionsaufruf.

// Ein Platzhalter
$twoDecimals = round(?, 2);
$twoDecimals(19.987); // 19.99

// Benannter Platzhalter
$prettyJson = json_encode(?, flags: JSON_PRETTY_PRINT);
echo $prettyJson(['php' => '8.6']);

// Alle restlichen Argumente
$logLine = sprintf('[%s] %s', ...);
echo $logLine('INFO', 'Deployment fertig');

Wichtig für den Alltag: Ohne ... werden überzählige Argumente beim Aufruf der Closure verworfen. Mit ... reicht PHP sie an die Funktion durch.

Partial Function Application statt Arrow Function

Seit PHP 7.4 schreiben wir für jeden kleinen Callback eine Arrow Function. Seit PHP 8.1 gibt es die First Class Callable Syntax mit strlen(...), die aber nur ohne weitere Argumente hilft. PHP 8.6 schließt genau diese Lücke.

SchreibweiseAb VersionStärken und Grenzen
fn ($p) => round($p, 2)PHP 7.4Flexibel, aber viel Rauschen. Argumente werden erst beim Aufruf ausgewertet
round(...)PHP 8.1Kurz, aber nur ohne feste Zusatzargumente nutzbar
round(?, 2)PHP 8.6Kurz und mit festen Argumenten. Typen und Defaults bleiben erhalten

Ein typisches Beispiel aus dem Projektalltag. Ihr habt eine Liste von Preisen und wollt sie runden:

$prices = [19.987, 5.512, 120.049];

// bisher
$rounded = array_map(fn (float $price) => round($price, 2), $prices);

// PHP 8.6
$rounded = array_map(round(?, 2), $prices);
// [19.99, 5.51, 120.05]

Partial Function Application mit array_map und array_filter

Am meisten spart ihr bei Callbacks für Array Funktionen. Ein Beispiel direkt aus der offiziellen Release Seite von PHP 8.6 filtert eine Liste von Versionen:

$versions = ['8.4', '8.5', '8.6', '8.7', '9.0'];

$supportsPfa = array_filter(
    $versions,
    version_compare(?, '8.6', '>='),
);
// ['8.6', '8.7', '9.0']

Auch strikte Prüfungen werden lesbar. Benannte Argumente und Platzhalter lassen sich mischen:

$allowedRoles = ['admin', 'editor', 'author'];

$validRoles = array_filter(
    $requestedRoles,
    in_array(?, $allowedRoles, strict: true),
);

$slugs = array_map(str_replace(' ', '-', ?), $titles);
$trimmed = array_map(trim(?, " \t\n/"), $paths);

Achtet bei array_filter() darauf, welches Argument die Funktion bekommt. Ohne Modus übergibt PHP nur den Wert. Mit ARRAY_FILTER_USE_BOTH kommen Wert und Key, dann braucht ihr zwei Platzhalter.

Partial Function Application mit dem Pipe Operator

PHP 8.5 hat den Pipe Operator |> gebracht. Jeder Schritt in der Pipe braucht eine Funktion mit genau einem Parameter. Sobald eine Funktion mehr Argumente hatte, stand wieder eine Arrow Function in der Kette. Mit PHP 8.6 passen beide Features endlich zusammen:

// PHP 8.5
$slug = $title
    |> trim(...)
    |> strtolower(...)
    |> (fn (string $s) => str_replace(' ', '-', $s))
    |> (fn (string $s) => preg_replace('/[^a-z0-9-]/', '', $s));

// PHP 8.6
$slug = $title
    |> trim(...)
    |> strtolower(...)
    |> str_replace(' ', '-', ?)
    |> preg_replace('/[^a-z0-9-]/', '', ?);

Das liest sich besser und spart Laufzeit. Steht eine Partial Application mit einem einzigen Platzhalter direkt rechts vom Pipe Operator, baut der Compiler daraus einen direkten Funktionsaufruf. Es entsteht gar keine Closure.

Form in der PipeOptimiertHinweis
foo(?), foo(1, ?)JaEin Platzhalter, direkter Aufruf ohne Closure
foo(1, a: ?), foo(1, ...)JaAuch benannt oder mit Rest Platzhalter
foo(?, ?), foo(?, ...)NeinMehr als ein offenes Argument, Closure bleibt
foo(a: 1, ...)NeinBenannter Wert vor dem Rest Platzhalter

Wie der Pipe Operator selbst funktioniert und was PHP 8.5 sonst gebracht hat, steht in unserem Glossar PHP 8 Versionen im Vergleich.

Methoden und statische Factory Methoden partiell anwenden

Partial Function Application funktioniert nicht nur mit Funktionen. Instanzmethoden, statische Methoden, Closures und invokable Objekte gehen genauso.

// Instanzmethode, ergibt eine nicht statische Closure
$formatGerman = $formatter->format(?, locale: 'de_DE');
$labels = array_map($formatGerman, $amounts);

// Statische Factory Methode, ergibt eine statische Closure
$euro = Money::of(?, 'EUR');
$totals = array_map($euro, [10, 25, 99]);

// Konstruktor geht nicht
$user = new User(?, 'admin');
// Error: Cannot create Closure for new expression

Für new gibt es bewusst keine Partial Application. Wer Objekte so bauen will, nutzt eine statische Factory Methode. Das passt ohnehin gut zu Value Objects. Die Closure ist genau dann statisch, wenn die Methode statisch ist. Bei static::create(?) löst PHP die späte statische Bindung beim Erzeugen der Closure auf, nicht erst beim Aufruf.

Wann PHP die Argumente auswertet

Das ist der wichtigste Unterschied zur Arrow Function und die häufigste Falle. Bei einer Partial Application wertet PHP alle festen Argumente sofort aus, beim Erzeugen der Closure. Bei einer Arrow Function passiert das erst beim Aufruf.

// Partial Application, die Uhrzeit wird EINMAL beim Erzeugen gelesen
$stamp = str_replace('{time}', date('H:i:s'), ?);

// Arrow Function, die Uhrzeit wird bei JEDEM Aufruf gelesen
$stamp = fn (string $line) => str_replace('{time}', date('H:i:s'), $line);

In den meisten Fällen ist das ein Vorteil. Ein teures Argument wird nur einmal berechnet. Ihr müsst es aber wissen. Alles, was sich zwischen Erzeugen und Aufruf ändern soll, gehört weiter in eine Arrow Function. Das gilt für Uhrzeiten, Zufallswerte, Zähler und Werte aus einem Request, der sich noch ändert.

Den gleichen Effekt könnt ihr bewusst nutzen. Setzt ihr alle Argumente und schließt mit ... ab, bekommt ihr eine Closure ohne Parameter. So bereitet ihr einen Aufruf vor und führt ihn später aus:

$warmUpCache = $cache->rebuild('products', 'de', ...);

// später, etwa nach dem Deployment
$warmUpCache();

Partial Function Application mit Time Duration

Richtig stark wird das Feature zusammen mit anderen Neuerungen aus PHP 8.6. Die neue Klasse Time\Duration beschreibt Zeitdauern mit fester Einheit. Mit einem benannten Platzhalter konfiguriert ihr eine Retry Logik einmal und ruft sie danach nur noch mit dem Versuch auf. Das Muster stammt aus den Beispielen auf php.net:

use Time\Duration;

function backoff(Duration $baseDelay, Duration $step, int $attempt): void
{
    $delay = $baseDelay->add($step->multiplyBy(2 ** $attempt));
    $delay = min($delay, Duration::fromSeconds(30));

    time_nanosleep($delay->seconds, $delay->nanoseconds);
}

$waitBeforeRetry = backoff(
    Duration::fromSeconds(1),
    Duration::fromMilliseconds(100),
    attempt: ?,
);

$waitBeforeRetry($attempt);

Typen, Reflection und SensitiveParameter

Die erzeugte Closure ist keine anonyme Blackbox. Sie übernimmt für jeden offenen Parameter Namen, Typ, Default Wert und Referenzübergabe der Originalfunktion. Auch der Rückgabetyp bleibt erhalten. Reflection, Dependency Injection Container und statische Analyse sehen also eine echte, typisierte Funktion.

function formatPrice(float $amount, string $currency = 'EUR'): string
{
    return number_format($amount, 2, ',', '.') . ' ' . $currency;
}

$inEuro = formatPrice(?, 'EUR');

$reflection = new ReflectionFunction($inEuro);
$parameter = $reflection->getParameters()[0];

echo $parameter->getName();         // amount
echo $parameter->getType();         // float
echo $reflection->getReturnType();  // string

Von den Attributen übernimmt PHP genau zwei: #[\NoDiscard] und #[\SensitiveParameter]. Das zweite ist für die Sicherheit wichtig. Ein Passwort, das ihr per Platzhalter durchreicht, taucht weiterhin nicht im Stack Trace auf.

function authenticate(string $user, #[\SensitiveParameter] string $password): bool
{
    // ...
}

$loginAsAdmin = authenticate('admin', ?);
// $password bleibt in der Closure als SensitiveParameter markiert

Bei variadischen Funktionen bekommen die Platzhalter durchnummerierte Namen. Aus einem Parameter ...$values werden in der Closure Pflichtparameter wie $values0 und $values1. Das solltet ihr wissen, wenn ihr solche Closures später mit benannten Argumenten aufruft.

Typische Fehler bei Partial Function Application

Die meisten Fehler zeigt PHP sofort an, oft schon beim Kompilieren. Diese Fälle solltet ihr kennen:

FehlerBeispielWas passiert
Zu wenige Argumentestr_replace(?)ArgumentCountError, weil Pflichtparameter fehlen
Platzhalter nach benanntem Argumentfoo(a: 1, ?)Fatal Error beim Kompilieren
Benanntes Argument überschreibt Platzhalterfoo(?, a: 5)Error, wenn a der Parameter des Platzhalters ist
Konstruktornew User(?)Error, Closure für new nicht möglich
Kontextabhängige Funktionencompact(?), extract(?)Nicht erlaubt, ebenso func_get_arg() und get_defined_vars()

Auch die magischen Methoden __get und __set lassen sich nicht partiell anwenden. __call und __callStatic funktionieren dagegen. PHP behandelt sie wie eine Methode mit beliebig vielen Argumenten. Alle Sonderfälle stehen im Migration Guide von PHP 8.5 auf 8.6.

Partial Function Application testen und absichern

Neue Syntax ist nur so gut wie die Werkzeuge, die sie verstehen. Bevor ihr Partial Function Application im Team freigebt, prüft ihr drei Dinge.

  • Statische Analyse: PHPStan versteht die neue Syntax seit Version 2.3.6. Was das Update sonst bringt, steht in PHPStan 2.3.6 und PHP 8.6. Prüft auch Psalm und euren Code Style Fixer auf die passende Version.
  • Mindestversion: Partial Function Application ist neue Syntax. Unter PHP 8.5 gibt es einen Parse Error. Setzt "php": ">=8.6" in der composer.json erst, wenn alle Server und CI Images umgestellt sind.
  • Tests: Eine Closure aus einer Partial Application testet ihr wie jede andere Funktion. Prüft vor allem Stellen, an denen ihr Arrow Functions ersetzt habt, auf den Unterschied bei der Auswertung der Argumente.
final class SlugTest extends TestCase
{
    public function testTitlesBecomeSlugs(): void
    {
        $toSlug = str_replace(' ', '-', ?);

        self::assertSame(
            ['php-8.6', 'partial-function-application'],
            array_map($toSlug, ['php 8.6', 'partial function application']),
        );
    }
}

Wer bestehenden Code umstellen will, sollte das nicht von Hand tun. Rector PHP ist dafür das richtige Werkzeug, sobald passende Regeln für PHP 8.6 bereitstehen. Was die aktuelle Version kann, zeigt Rector 2.8 neue Features. Für das Upgrade selbst haben wir eine eigene Seite zum PHP 8.6 Upgrade mit CI Matrix, Composer Check und Rollout in Stufen.

Coding Agents brauchen klare Regeln

Coding Agents kennen neue Syntax oft erst spät. Manche schreiben weiter Arrow Functions, andere setzen Platzhalter an Stellen, an denen die frühe Auswertung schadet. Legt im Projekt fest, ab welcher PHP Version Partial Function Application erlaubt ist und wo ihr lieber bei Arrow Functions bleibt. Diese Regeln gehören in die Projektdokumentation und als Quality Gate in die Pipeline. Wie das aussieht, zeigen die NCA PHP AI Coding Guidelines.

Wann ihr lieber bei der Arrow Function bleibt

Partial Function Application ist kein Ersatz für jede Closure. In diesen Fällen bleibt die Arrow Function die bessere Wahl:

  • Logik im Callback: Sobald ihr rechnet, verzweigt oder mehrere Funktionen kombiniert, ist eine Arrow Function klarer.
  • Werte, die sich ändern: Uhrzeit, Zufall, Zähler oder Zustand aus einem Objekt, das sich zwischen Erzeugen und Aufruf ändert.
  • Viele Platzhalter: Ein Aufruf wie foo(?, ?, 3, ?) ist schwer zu lesen. Benannte Parameter in einer Arrow Function sagen mehr.
  • Gemischte PHP Versionen: Bibliotheken, die noch PHP 8.5 unterstützen, können die Syntax nicht nutzen.

Fazit

Partial Function Application ist das Feature, das PHP 8.6 im Alltag am stärksten prägen wird. Ein Fragezeichen ersetzt die meisten kleinen Arrow Functions, der Pipe Operator wird endlich bequem, und die Closures bleiben voll typisiert. Die eine Falle ist die frühe Auswertung der Argumente. Wer die kennt, Tests hat und PHPStan auf dem aktuellen Stand hält, kann das Feature ohne Risiko einführen.

Häufige Fragen zu Partial Function Application in PHP

Was ist Partial Function Application in PHP 8.6?

Partial Function Application ist ein Funktionsaufruf, bei dem ein oder mehrere Argumente durch Platzhalter ersetzt werden. PHP liefert dann eine typisierte Closure, die die fehlenden Argumente erwartet. Die Funktion selbst läuft erst beim Aufruf dieser Closure. So ersetzt array_map(round(?, 2), $prices) eine komplette Arrow Function.

Welche Platzhalter gibt es in PHP 8.6?

Es gibt drei. Das Fragezeichen steht für genau ein Argument an seiner Position. Drei Punkte stehen für alle restlichen Argumente und dürfen nur einmal am Ende stehen. Benannte Platzhalter wie flags: ? ersetzen gezielt einen bestimmten Parameter, unabhängig von seiner Position.

Ist Partial Function Application schneller als eine Arrow Function?

Rechts vom Pipe Operator ja. Hat die Partial Application dort genau einen Platzhalter, macht der Compiler daraus einen direkten Funktionsaufruf ohne Closure. Außerhalb von Pipes ist der Unterschied klein. Der größere Gewinn ist die Lesbarkeit. Messt Performance trotzdem immer in eurer eigenen Anwendung.

Wann werden die Argumente einer Partial Application ausgewertet?

Sofort beim Erzeugen der Closure, nicht erst beim Aufruf. Das ist der wichtigste Unterschied zur Arrow Function. Ein Argument wie date() wird also nur einmal gelesen. Werte, die sich bis zum Aufruf ändern sollen, gehören deshalb weiter in eine Arrow Function.

Funktioniert Partial Function Application mit Konstruktoren?

Nein. Ein Ausdruck mit new und Platzhalter führt zu einem Fehler, weil PHP dafür keine Closure erzeugt. Statische Factory Methoden funktionieren dagegen, ebenso normale Methoden, Closures und invokable Objekte. Für Value Objects ist eine Factory Methode wie Money::of(?, ‚EUR‘) ohnehin oft die bessere Lösung.

Versteht PHPStan Partial Function Application?

Ja, PHPStan unterstützt die neue Syntax seit Version 2.3.6. Weil die erzeugte Closure Typen, Defaults und Rückgabetyp der Originalfunktion übernimmt, kann die statische Analyse Fehler genauso finden wie bei normalen Aufrufen. Prüft zusätzlich, ob Psalm, Rector und euer Code Style Tool schon passende Versionen haben.

Kann ich Partial Function Application in Bibliotheken nutzen?

Nur, wenn die Bibliothek mindestens PHP 8.6 voraussetzt. Die Syntax ist neu, ältere Versionen brechen mit einem Parse Error ab. Für Pakete, die noch PHP 8.4 oder 8.5 unterstützen, bleibt die Arrow Function. In eigenen Anwendungen lohnt sich die Umstellung, sobald alle Server und CI Images auf 8.6 laufen.

Bleibt SensitiveParameter bei Partial Function Application erhalten?

Ja. Die erzeugte Closure übernimmt die Attribute SensitiveParameter und NoDiscard der Originalfunktion. Ein Passwort, das ihr über einen Platzhalter weiterreicht, erscheint also weiterhin nicht im Stack Trace. Andere Attribute übernimmt PHP nicht, darauf solltet ihr bei eigener Attribut Logik achten.

PHP 8.6 mit Never Code Alone

Wir bringen eure PHP Anwendungen mit eurem Team auf PHP 8.6 und führen neue Sprachfeatures sauber ein, abgesichert mit Rector, PHPStan, PHPUnit, Cypress E2E Tests und klaren Regeln für Coding Agents. Kostenloses Kennenlernen, ehrliche Aufwandsschätzung, minutengenaue Abrechnung.

0 Kommentar

Tutorials und Top Posts

Gib uns Feedback

Diese Seite benutzt Cookies. Ein Akzeptieren hilft uns die Seite zu verbessern. Ok Mehr dazu