PHP 8.5 Adiciona Operador Pipe: Uma Revolução na Programação PHP

O PHP 8.5, com lançamento previsto para novembro deste ano, trará consigo uma funcionalidade muito aguardada pela comunidade: o operador pipe (|>). Embora seja um recurso aparentemente simples, seu potencial é imenso e representa anos de desenvolvimento e discussão.

O que é o Operador Pipe?

O operador pipe, representado por |>, possui uma elegância enganadora. Ele pega o valor do lado esquerdo e o passa como único argumento para uma função (ou callable, no caso do PHP) do lado direito:

$result = "Hello World" |> strlen(...);

// É equivalente a
$result = strlen("Hello World");

Isoladamente, isso pode não parecer revolucionário. Mas a verdadeira magia acontece quando encadeamos múltiplas operações, formando um “pipeline”. Veja este exemplo prático:

$arr = [
  new Widget(tags: ['a', 'b', 'c']),
  new Widget(tags: ['c', 'd', 'e']),
  new Widget(tags: ['x', 'y', 'a']),
];

$result = $arr
    |> fn($x) => array_column($x, 'tags') // Obtém um array de arrays
    |> fn($x) => array_merge(...$x)       // Achata em um grande array
    |> array_unique(...)                  // Remove duplicatas
    |> array_values(...)                  // Reindexa o array
;

// $result é ['a', 'b', 'c', 'd', 'e', 'x', 'y']

A Diferença na Legibilidade

Sem o operador pipe, o mesmo código seria uma bagunça aninhada:

array_values(array_unique(array_merge(...array_column($arr, 'tags'))));

Ou exigiria variáveis temporárias para cada etapa, aumentando a complexidade mental e impedindo o uso em contextos de expressão única, como blocos match().

Origens e Inspiração

O operador |> aparece em muitas linguagens, principalmente no mundo funcional. F# e OCaml possuem operadores essencialmente idênticos, enquanto Elixir oferece uma versão mais sofisticada.

Para o PHP, a jornada começou com o Hack/HHVM, o fork do PHP criado pelo Facebook. Em 2016, Sara Golemon propôs portar os pipes do Hack diretamente para o PHP, mas usando uma sintaxe diferente com o token $$:

$result = $arr
    |> array_column($$, 'tags')
    |> array_merge(...$$)
    |> array_unique($$)
    |> array_values($$)
;

Embora poderoso, esse approach era não-padrão e limitante. Após várias tentativas e colaborações com a equipe da PHP Foundation, finalmente chegamos à implementação atual.

Mais que a Soma de suas Partes

O operador pipe brilha quando combinado com outros recursos. Imagine usá-lo em contextos onde apenas uma expressão é permitida, como em match():

$string = 'something GoesHERE';

$newString = match ($format) {
    'snake_case' => $string
        |> splitString(...)
        |> fn($x) => implode('_', $x)
        |> strtolower(...),
    'lowerCamel' => $string
        |> splitString(...)
        |> fn($x) => array_map(ucfirst(...), $x)
        |> fn($x) => implode('', $x)
        |> lcfirst(...),
    // Outras opções aqui
};

Funcionalidade Avançada: Maybe Monad

Com uma única função auxiliar, podemos implementar tratamento de valores nulos de forma elegante:

function maybe(\Closure $c): \Closure
{
    return fn(mixed $arg) => $arg === null ? null : $c($arg);
}

$profit = [1, 4, 5] 
    |> maybe(loadSeveral(...))
    |> maybe(filter(isOnSale(...)))
    |> maybe(map(sellWidget(...)))
    |> maybe(array_sum(...));

Isso implementa um Maybe Monad com pipes e uma função de uma linha!

Processamento de Streams

O potencial para processamento de streams é imenso:

fopen('dados.csv', 'rb')
    |> decode_rot13(...)
    |> lines_from_charstream(...)
    |> map(str_getcsv(...))
    |> map(Product::create(...))
    |> map($repo->save(...))
;

O Que Vem Depois?

Embora o operador pipe seja um marco importante, o desenvolvimento não para por aí. Há trabalho ativo em duas RFCs de acompanhamento:

1. Aplicação Parcial de Funções (PFA)

Uma segunda tentativa de implementar a Aplicação Parcial de Funções, que permitiria transformar funções multi-parâmetro em funções de parâmetro único mais facilmente.

2. Operador de Composição de Funções

Enquanto o pipe executa imediatamente, a composição de funções criaria uma nova função combinando duas funções. Isso permitiria otimizações como:

fopen('dados.csv', 'rb')
    |> decode_rot13(...)
    |> lines_from_charstream(...)
    |> map(str_getcsv(...) + Product::create(...) + $repo->save(...))
;

Conclusão

O operador pipe do PHP 8.5 representa uma das funcionalidades com maior “custo-benefício” dos últimos anos, comparável à promoção de propriedades no construtor. Essa pequena adição sintática abre portas para:

• Código mais legível: Pipelines claros substituem aninhamentos complexos
• Programação funcional: Facilita padrões funcionais no PHP
• Expressões compostas: Permite chains complexos em contextos de expressão única
• Flexibilidade: Qualquer função pode ser usada, não apenas métodos predefinidos

Para desenvolvedores PHP, o operador pipe não é apenas uma nova sintaxe - é uma nova forma de pensar sobre composição de código e fluxo de dados. Prepare-se para uma revolução silenciosa mas poderosa no desenvolvimento PHP.

O PHP 8.5 chega em novembro, e com ele, uma ferramenta que promete transformar a forma como escrevemos e organizamos nosso código. É hora de começar a pensar em pipelines!