Vai al contenuto

PHP 8.5 – l’operatore PIPE

Con PHP 8.5, rilasciato il 20 novembre 2025, il linguaggio ha finalmente ottenuto l’operatore pipe |>. Chi arriva da F#, Elixir, OCaml o Hack lo conosce bene: prende il valore che sta alla sua sinistra e lo passa come argomento alla funzione che sta alla sua destra. Il risultato è che una sequenza di trasformazioni si legge dall’alto verso il basso, nello stesso ordine in cui viene eseguita, invece che dall’interno verso l’esterno.

In questo articolo vediamo come funziona davvero, quali sono le regole (e le trappole) da conoscere, come usarlo in modo idiomatico e perché la sua storia, lunga quasi dieci anni, si intreccia con un’altra novità: la partial function application di PHP 8.6.

Il problema che risolve

Prendiamo un compito banale: trasformare il titolo di un articolo in uno slug da usare nell’URL. Senza pipe abbiamo due strade. La prima è annidare le chiamate:

$slug = strtolower(
    preg_replace('/[^a-z0-9]+/i', '-',
        trim($titolo)
    )
);

Il codice funziona, ma va letto al contrario: la prima operazione eseguita (trim) è la più interna, l’ultima (strtolower) è la più esterna. Con tre passaggi è ancora gestibile; con sei o sette diventa un esercizio di conteggio delle parentesi. La seconda strada è usare variabili temporanee:

$tmp  = trim($titolo);
$tmp  = preg_replace('/[^a-z0-9]+/i', '-', $tmp);
$slug = strtolower($tmp);

Più leggibile, ma rumoroso: $tmp non ha alcun significato di dominio, esiste solo per trasportare il dato da una riga all’altra. Con l’operatore pipe lo stesso flusso diventa:

$slug = $titolo
    |> trim(...)
    |> (fn(string $s): string => preg_replace('/[^a-z0-9]+/i', '-', $s))
    |> strtolower(...);

Ogni riga è un passaggio della trasformazione, nell’ordine in cui avviene. Non ci sono variabili intermedie né parentesi da contare.

Come funziona

La regola è una sola: l’espressione $valore |> $callable equivale a $callable($valore). Il valore a sinistra può essere qualsiasi espressione; a destra deve esserci qualcosa che, una volta valutato, sia un callable in grado di accettare quel valore come unico argomento. Il risultato dell’intera espressione è il valore restituito dall’ultimo callable della catena.

$lunghezza = 'Benvenuto in PHP!' |> strlen(...);
// equivale a: $lunghezza = strlen('Benvenuto in PHP!');

La sintassi strlen(...) non è nuova: è la first-class callable syntax introdotta in PHP 8.1, che crea una Closure a partire da una funzione o da un metodo senza chiamarlo. È la forma più comune e più naturale da usare con il pipe, ed è anche la più efficiente: l’implementazione compila le first-class callable di funzioni, metodi e metodi statici in chiamate dirette, senza overhead aggiuntivo. Le closure scritte a mano, invece, mantengono il loro normale costo.

Le forme di callable ammesse

A destra di |> si può mettere qualunque callable supportato da PHP:

$risultato = $input
    |> trim(...)                       // funzione nativa (first-class callable)
    |> 'strtoupper'                    // nome di funzione come stringa
    |> Str::normalizza(...)            // metodo statico
    |> $formatter->formatta(...)       // metodo di istanza
    |> new Sanificatore()              // oggetto invocabile (__invoke)
    |> (fn(string $s): string => "[$s]"); // arrow function, tra parentesi

Nel codice reale conviene preferire in modo coerente le first-class callable: sono verificate dall’IDE e dagli analizzatori statici, mentre i nomi di funzione come stringa non lo sono.

Le regole da conoscere

1. Il callable deve accettare un solo argomento obbligatorio

Il pipe passa un solo valore. Se la funzione a destra ha due o più parametri obbligatori, la chiamata fallisce con un ArgumentCountError, esattamente come se la chiamassimo a mano con un argomento in meno. I parametri opzionali, invece, non sono un problema: restano al loro valore di default.

function somma(int $a, int $b): int { return $a + $b; }

$x = 5 |> somma(...); // ArgumentCountError: manca il secondo argomento

2. Niente parametri per riferimento

Le funzioni che accettano il primo parametro per riferimento (come sort(), array_push() o shuffle()) non possono stare a destra del pipe: il valore che scorre nella catena non è una variabile modificabile. Se serve, si incapsula l’operazione in una closure che lavora su una copia e la restituisce:

$ordinati = $numeri
    |> (function (array $a): array { sort($a); return $a; });

3. Le arrow function vanno tra parentesi

Il corpo di una arrow function si estende il più possibile verso destra. Senza parentesi, una fn in mezzo alla catena “inghiottirebbe” tutti i passaggi successivi come parte del proprio corpo. Per questo le parentesi attorno alle arrow function usate nel pipe sono obbligatorie:

// Corretto
$valore
    |> (fn($x) => $x + 1)
    |> (fn($y) => $y * 2);

// Errore di sintassi
$valore
    |> fn($x) => $x + 1
    |> fn($y) => $y * 2;

4. A destra va un callable, non una chiamata

È l’errore più frequente, soprattutto per chi ha in mente esempi scritti prima del rilascio definitivo. trim(...) è un callable; trim() è una chiamata a trim senza argomenti, che viene eseguita subito (e fallisce) prima ancora che il pipe entri in gioco.

// Sbagliato: trim() viene chiamata senza argomenti
$pulito = $messaggio |> trim();

// Corretto
$pulito = $messaggio |> trim(...);

Lo stesso vale per i metodi: $utente |> $servizio->elabora() chiama elabora() senza argomenti e prova poi a usarne il risultato come callable. La forma giusta è $utente |> $servizio->elabora(...).

5. Funzioni void e valori null

Una funzione dichiarata void restituisce null, che diventa l’input del passaggio successivo. Il pipe non è pensato per gli effetti collaterali: se un passaggio serve solo a loggare o a salvare qualcosa, dovrebbe restituire comunque il valore ricevuto (vedi il paragrafo sul debug).

Esempi pratici

Normalizzare un indirizzo email

$email = $request->get('email')
    |> trim(...)
    |> strtolower(...)
    |> (fn(string $e): string|false => filter_var($e, FILTER_VALIDATE_EMAIL));

Lavorare con gli array

Qui emerge il limite principale dell’operatore in PHP 8.5. Molte funzioni sugli array non hanno l’array come primo parametro (array_map() lo vuole come secondo) oppure richiedono un secondo argomento obbligatorio (la callback di array_filter() è opzionale, ma spesso serve). La soluzione è una arrow function che fissa gli altri argomenti:

$nomi = $dipendenti
    |> (fn(array $d): array => array_filter($d, fn(array $e): bool => $e['stipendio'] > 48000))
    |> (fn(array $d): array => array_map(fn(array $e): string => $e['nome'], $d))
    |> (fn(array $n): string => implode(', ', $n));

Le funzioni che prendono l’array come unico parametro obbligatorio, invece, si usano direttamente:

$categorie = $prodotti
    |> (fn(array $p): array => array_column($p, 'categorie'))
    |> (fn(array $liste): array => array_merge(...$liste))
    |> array_unique(...)
    |> array_values(...);

Costruire un oggetto alla fine della catena

$dto = $payloadJson
    |> (fn(string $j): array => json_decode($j, true, flags: JSON_THROW_ON_ERROR))
    |> (fn(array $dati): OrdineDto => new OrdineDto(...$dati));

Debug di una catena

Una catena di pipe non ha variabili intermedie da ispezionare. Per vedere cosa succede a metà strada si può inserire un passaggio “trasparente”, che stampa o logga il valore e lo restituisce invariato:

function ispeziona(mixed $valore): mixed
{
    dump($valore); // oppure $logger->debug(...)
    return $valore;
}

$slug = $titolo
    |> trim(...)
    |> ispeziona(...)
    |> strtolower(...);

Errori tipici in sintesi

  • Chiamata al posto del callable: |> trim() invece di |> trim(...).
  • Ordine degli argomenti: |> preg_match(...) passa il valore come pattern, non come soggetto. Serve |> (fn($s) => preg_match('/test/', $s)).
  • Arrow function senza parentesi: errore di sintassi.
  • Funzioni per riferimento (sort, shuffle…): vanno incapsulate in una closure.
  • Abuso: $x |> strlen(...) non è più leggibile di strlen($x). Il pipe rende al meglio con tre o più trasformazioni in sequenza.

Un po’ di storia: tre RFC in nove anni

L’idea non è nuova. Nel 2016 Sara Golemon e Marcelo Camargo proposero di portare in PHP il pipe di Hack, il linguaggio di Facebook derivato da PHP, che usava un segnaposto speciale ($$) per indicare dove inserire il valore. Quella RFC non arrivò mai al voto.

Nel 2020 Larry Garfield presentò una seconda versione, più semplice e basata sui callable, pensata per lavorare insieme a una RFC sulla partial function application. Quest’ultima non passò per la complessità che introduceva nel motore, e il pipe ne pagò le conseguenze: al voto di luglio 2021 la “v2” fu respinta con 11 voti favorevoli e 17 contrari.

La terza versione, sempre di Garfield, con un’implementazione rifatta con l’aiuto di Ilija Tovilo e Arnaud Le Blanc del team della PHP Foundation, è stata approvata nel 2025 ed è entrata in PHP 8.5. Durante il ciclo di rilascio è stata aggiunta l’obbligatorietà delle parentesi attorno alle arrow function, per eliminare l’ambiguità descritta sopra.

Uno sguardo avanti: PHP 8.6 e la partial function application

Il limite principale del pipe in PHP 8.5 (dover scrivere una arrow function ogni volta che una funzione ha più di un parametro) è proprio quello che la partial function application risolve. La nuova RFC, sempre di Larry Garfield con Arnaud Le Blanc, è stata approvata all’unanimità ed è inclusa in PHP 8.6, il cui rilascio è previsto per il 19 novembre 2026. Permette di “pre-riempire” alcuni argomenti e lasciare un segnaposto ? per quello che arriverà dalla catena:

// PHP 8.6
$output = 'Hello World'
    |> str_replace(' ', '-', ?)
    |> strtolower(...);

// "hello-world"

Con PHP 8.6 molte delle arrow function viste negli esempi sugli array potranno essere sostituite da una chiamata parziale, rendendo le catene ancora più compatte.

Conclusione

L’operatore pipe non aggiunge nuove capacità a PHP: tutto quello che fa si poteva già scrivere con chiamate annidate o variabili temporanee. Quello che cambia è la leggibilità. Usato con le first-class callable e riservato a trasformazioni in più passaggi, rende il flusso dei dati esplicito e lineare. Le regole da tenere a mente sono poche: a destra va un callable e non una chiamata, il callable riceve un solo argomento, niente parametri per riferimento, e le arrow function vanno sempre tra parentesi.

Per approfondire: RFC Pipe operator v3 e annuncio ufficiale di PHP 8.5.