PHP 8.5’in Pipe Operatörü: Gerçek Dünyada Neden Basitlik Vaadi Boşa Çıkıyor?

PHP 8.5’in tanıtımıyla birlikte geliştiriciler arasında heyecan yaratan pipe operatörü (|>), fonksiyon zincirlemelerini daha temiz ve okunabilir hale getirme vaadiyle piyasaya sürüldü. Bu operatör sayesinde verilerin tek bir satırda, iç içe fonksiyonlar olmadan akışı sağlanabiliyor. Ancak gerçek dünya uygulamalarında, özellikle PHP’nin standart dizi fonksiyonlarıyla çalışırken, operatörün üç önemli sınırlaması ortaya çıkıyor.

Fonksiyon Zincirlerinin Vaadi: Temiz ve Okunabilir Kod

Pipe operatörü, verileri soldan sağa doğru akışta tutarak fonksiyon zincirlerini daha doğal bir şekilde yazmayı hedefliyor. Örneğin, bir başlık metnini URL dostu bir forma dönüştürmek artık oldukça basit:

$slug = $title |> trim(...) |> strtolower(...);

Bu yaklaşım, fonksiyonel programlama prensiplerine uygun olarak verinin her adımda dönüştürülmesini sağlıyor. Temiz bir dizaynla geliştiriciler, özellikle string manipülasyonu gibi yaygın görevlerde kodlarını daha okunabilir ve bakımı kolay hale getirebiliyor. Operatörün sunduğu avantajlar, ilk bakışta oldukça cazip görünüyor.

Gerçek Dünya Problemleri: Dizi Fonksiyonlarıyla Uyumsuzluk

Ancak gerçek dünya uygulamaları genellikle basit string işlemlerinden ibaret değil. Çoğu durumda, geliştiriciler kullanıcıdan alınan verileri temizlemek, filtrelemek ve sıralamak gibi karmaşık işlemlerle uğraşıyor. Örneğin, kullanıcıdan alınan etiketleri temizleyip alfabetik sıraya dizmek yaygın bir senaryodur. Geleneksel yaklaşımda, bu işlemler iç içe fonksiyonlarla gerçekleştiriliyor:

$cleanTags = array_values(
    array_filter(
        array_map(fn($t) => strtolower(trim($t)), $rawTags),
        fn($t) => strlen($t) >= 3
    )
);
sort($cleanTags);

Pipe operatörü bu karmaşık zinciri basitleştirmeyi hedefliyor. Naif bir yaklaşımda, zincirleme şu şekilde yapılabiliyor:

$cleanTags = $rawTags
    |> (fn($ts) => array_map(fn($t) => strtolower(trim($t)), $ts))
    |> (fn($ts) => array_filter($ts, fn($t) => strlen($t) >= 3))
    |> array_values(...)
    |> (function ($ts) { sort($ts); return $ts; });

Bu kod zincirinin okunabilir olduğu iddia edilse de, üç önemli soruna yol açıyor. Standart dizi fonksiyonlarının tasarımı, pipe operatörünün beklentileriyle tamamen örtüşmüyor.

Sorun 1: Argüman Sırası Uyumsuzluğu

PHP’nin standart dizi fonksiyonları, array_map ve array_filter gibi fonksiyonlar farklı argüman sıralarına sahiptir. array_map fonksiyonu callable’ı ilk parametre olarak alırken, array_filter diziyi ilk parametre olarak bekler. Pipe operatörü ise her zaman sol taraftaki değeri sağdaki fonksiyonun ilk argümanı olarak geçirir. Bu durumda:

$result = $rawTags |> array_filter(...); // Çalışır: dizi ilk argümandır
$result = $rawTags |> array_map(...);      // Başarısız olur: $rawTags callable olarak algılanır

Bu nedenle, array_map ya da array_filter fonksiyonlarını zincirde kullanmak için, argüman sırasının tersine çevrilmesi gerekiyor. Örneğin, array_map’i zincirde kullanabilmek için bir arrow fonksiyonu ile sarılması gerekir. Sadece array_values gibi tek bir argüman alan fonksiyonlar doğrudan zincirde kullanılabilir.

Sorun 2: Arrow Fonksiyonlarının Parantez Gereksinimi

Zincirdeki arrow fonksiyonlarının parantezlerle sarılması zorunludur. Örneğin:

|> (fn($ts) => array_map(fn($t) => strtolower(trim($t)), $ts))

Buradaki parantezler opsiyonel değil, zorunludur. Parantezler olmadan, parser tüm ifadeyi tek bir arrow fonksiyona yanlış yorumlayabilir. Ağustos 2025’te yayınlanan bir düzeltmeyle bu gereklilik vurgulandı, ancak pratik kullanımda geliştiriciler sürekli olarak parantezleri eklemek zorunda kalıyor.

Bu durum, zincirleme kullanımın pratikte oldukça külfetli hale gelmesine neden oluyor. Pazarlama örneklerinde sıkça kullanılan trim(...) ya da strtolower(...) gibi first-class callable’lar pratikte nadiren karşımıza çıkıyor.

Sorun 3: Referansla Değiştirilen Fonksiyonların Kullanımı

Zincirin son adımında, sort fonksiyonu kullanılırken başka bir sınırlama ortaya çıkıyor. sort fonksiyonu diziyi referansla değiştirerek boolean bir değer döndürür. PHP RFC’si, referans parametreleri olan fonksiyonların first-class callable olarak kullanılmasını engelliyor. Bu listeye dahil olan fonksiyonlar arasında şunlar bulunuyor:

• sort, rsort, usort, ksort
• array_push, array_pop, array_shift, array_unshift
• array_walk

Bu fonksiyonların zincir içinde kullanılması için tam bir kapalı fonksiyonun kullanılması gerekiyor:

|> (function ($ts) { sort($ts); return $ts; });

Bu durum, pipe operatörünün vaad ettiği basitlikten uzaklaşıyor. Pratikte, çoğu geliştirici sort fonksiyonunu zincirin dışında kullanmayı tercih ediyor.

Pipe Operatörünün Güçlü Olduğu Alanlar

Tüm bu sınırlamalara rağmen, pipe operatörü belirli senaryolarda oldukça etkili olabiliyor. Fonksiyonların tek bir argüman alması ve verinin ilk argüman olması durumunda operatörün avantajları ortaya çıkıyor. Örneğin, string dönüşümleri, kodlama/çözme işlemleri ya da matematiksel hesaplamalar zincir içinde net bir şekilde ifade edilebiliyor:

$payload = $body
    |> json_encode(...)
    |> gzencode(...)
    |> base64_encode(...);

Burada fonksiyonlar trim, strtolower ya da preg_replace gibi tek argümanlı fonksiyonlar olduğu için zincirleme doğal bir şekilde çalışıyor. Ayrıca, metod çağrıları ve __invoke nesneleri de pipe operatörüyle uyumlu olarak kullanılabiliyor.

Çözüm: Koleksiyon Kütüphaneleri

Standart PHP fonksiyonlarının tutarsızlıkları, tasarımdan kaynaklanan bir sorun. Dizi fonksiyonları zincirleme için tasarlanmadığından, pipe operatörü kullanırken birçok workaround’a ihtiyaç duyuluyor. Daha zarif bir çözüm, koleksiyon kütüphaneleriyle mümkün hale geliyor. Örneğin, noctud/collection kütüphanesi, metod zincirlemelerini tutarlı bir şekilde sağlıyor:

$cleanTags = listOf($rawTags)
    ->map(fn(string $t) => strtolower(trim($t)))
    ->filter(fn(string $t) => strlen($t) >= 3)
    ->sorted();

Burada map, filter ve sorted metodları, veriyi ($this) ilk argüman olarak kabul ediyor. Bu sayede argüman sırasıyla ilgili sorunlar ortadan kalkıyor ve parantez gereksinimi ortadan kalkıyor. PHPStan gibi statik analiz araçları da zincir boyunca koleksiyonun değişmezliğini takip edebiliyor.

Benzer şekilde, illuminate/collections, doctrine/collections ve ramsey/collection gibi kütüphaneler de tutarlı metod zincirleri sunuyor. Temel çözüm, standart dizi fonksiyonlarının sınırlamalarını aşmak değil, bu sınırlamaları kökten çözmekten geçiyor.

Geliştiriciler, pipe operatörünün sunduğu avantajlardan faydalanırken, realiteye uygun çözümler üretmek için koleksiyon kütüphanelerine yönelmeye devam edecek. Bu sayede kodlarını daha okunabilir, bakımı kolay ve geleceğe hazır hale getirebiliyorlar.