• Saf Fonksiyonlar (Pure Functions):
  * Aynı girdilerle çağrıldığında her zaman aynı çıktıyı üreten fonksiyonlardır.
  * Fonksiyonun dışındaki herhangi bir durumu değiştirmezler (yan etki yok).
  * Dış dünyayla etkileşime girmezler (dosya okuma/yazma, ağ istekleri vb.).
  * Örnek: Bir sayıyı ikiyle çarpan bir fonksiyon saf fonksiyondur. Her zaman aynı sayıyı verirseniz, her zaman aynı sonucu alırsınız.
  *
  Kod:

          def add(a, b):
              return a + b
          # add(2, 3) her zaman 5 döndürür ve dış dünyayı etkilemez.

• Değişmezlik (Immutability):
  * Bir kez oluşturulduktan sonra değeri değiştirilemeyen veriler anlamına gelir.
  * Fonksiyonel programlamada, bir değeri değiştirmek yerine, onun yeni bir kopyasını oluşturur ve bu kopya üzerinde işlem yaparsınız.
  * Bu, özellikle çoklu iş parçacıklı ortamlarda hataları azaltır çünkü farklı iş parçacıklarının aynı veriyi beklenmedik şekillerde değiştirmesi engellenir.
  * Örnek: Python'da tuple'lar değişmezken, listeler değişebilirdir.
  *
  Kod:

          # Değişmez veri (Immutable)
          my_tuple = (1, 2, 3)
          # my_tuple[0] = 5  # Hata verir
  
          # Değişebilir veri (Mutable)
          my_list = [1, 2, 3]
          my_list[0] = 5
          print(my_list) # Çıktı: [5, 2, 3]

• Birinci Sınıf Fonksiyonlar (First-Class Functions):
  * Fonksiyonların diğer değişkenler gibi ele alınabildiği anlamına gelir.
  * Bir fonksiyona argüman olarak geçirilebilir, bir fonksiyondan döndürülebilir ve bir değişkene atanabilirler.
  * Bu özellik, "yüksek dereceli fonksiyonlar" kavramının temelini oluşturur.
  * Örnek: JavaScript'te bir değişkene fonksiyon atamak veya bir fonksiyonu başka bir fonksiyona parametre olarak vermek yaygındır.
  
• Yüksek Dereceli Fonksiyonlar (Higher-Order Functions):
  * Bir veya daha fazla fonksiyonu argüman olarak alan veya bir fonksiyon döndüren fonksiyonlardır.
  * `map`, `filter`, `reduce` gibi fonksiyonlar tipik yüksek dereceli fonksiyon örnekleridir.
  * Örnek: Bir listeyi dönüştürmek için kullanılan `map` fonksiyonu.
  *
  Kod:

          # Python'da yüksek dereceli fonksiyon örneği
          numbers = [1, 2, 3, 4, 5]
          squared_numbers = list(map(lambda x: x * x, numbers))
          print(squared_numbers) # Çıktı: [1, 4, 9, 16, 25]

• Yan Etkisiz Olma (Side-Effect Free):
  * Bir fonksiyonun çağrıldığında, girdi parametreleri dışında herhangi bir gözlemlenebilir değişiklik yapmaması anlamına gelir.
  * Veritabanına yazma, bir dosyayı değiştirme, ağ isteği gönderme, global bir değişkenin değerini değiştirme gibi eylemler yan etkidir.
  * Saf fonksiyonlar doğası gereği yan etkisizdir. Yan etkilerin kontrol altına alınması, kodun anlaşılırlığını ve test edilebilirliğini artırır.
  
• Fonksiyon Kompozisyonu (Function Composition):
  * Birden fazla küçük fonksiyonu birleştirerek daha karmaşık fonksiyonlar oluşturma işlemidir.
  * Matematikteki f(g(x)) gibi düşünülmelidir. Bir fonksiyonun çıktısı, diğerinin girdisi olur.
  * Bu, kodun daha modüler ve okunabilir olmasını sağlar.
  * Örnek: Bir sayıyı ikiyle çarpıp sonra 5 ekleyen iki fonksiyonu birleştirmek.
  
• Referans Şeffaflığı (Referential Transparency):
  * Bir ifadenin, değeriyle değiştirilebilmesi ve programın davranışının değişmemesi anlamına gelir.
  * Bu özellik, saf fonksiyonların doğrudan bir sonucudur. Saf fonksiyonlar referans şeffaflığına sahiptir.
  * Bu, derleyicilerin veya yorumlayıcıların optimizasyon yapmasına olanak tanır ve kodun mantıksal olarak daha basit olmasını sağlar.

• Daha Az Hata: Saf fonksiyonlar ve değişmezlik sayesinde, kodun öngörülebilirliği artar. Durum değişikliklerinin ve yan etkilerin olmaması, beklenmedik hataların (özellikle eş zamanlılık hatalarının) ortaya çıkma olasılığını büyük ölçüde azaltır.
• Kolay Test Edilebilirlik: Saf fonksiyonlar, belirli girdiler için her zaman aynı çıktıyı verdiğinden, test senaryoları yazmak ve testleri otomatikleştirmek çok daha kolaydır. Dış bağımlılıkları veya yan etkileri taklit etmek zorunda kalmazsınız.
• Eş Zamanlılık (Concurrency) ve Paralellik (Parallelism): Değişmez veriler ve yan etkisiz fonksiyonlar, çok çekirdekli işlemcilerde veya dağıtık sistemlerde paralel işlem yapmayı çok daha güvenli ve kolay hale getirir. Paylaşılan durumun olmaması, kilitlenme (deadlock) veya yarış durumu (race condition) gibi yaygın eş zamanlılık sorunlarını ortadan kaldırır.
• Modülerlik ve Yeniden Kullanılabilirlik: Fonksiyon kompozisyonu ve yüksek dereceli fonksiyonlar, küçük, bağımsız ve yeniden kullanılabilir fonksiyonlar oluşturmayı teşvik eder. Bu, kod tabanının daha modüler ve bakımı daha kolay olmasını sağlar.
• Daha Temiz ve Okunabilir Kod: Deklaratif doğası gereği, fonksiyonel kod genellikle "nasıl" değil, "ne" yapıldığına odaklanır. Bu, kodun niyetini anlamayı kolaylaştırır ve daha yüksek seviyeli bir soyutlama sunar.

• Öğrenme Eğrisi: Özellikle imperatif veya nesne yönelimli programlamaya alışkın geliştiriciler için fonksiyonel programlama paradigmalarına geçiş, yeni bir düşünce biçimi gerektirdiğinden zorlayıcı olabilir. Rekürsiyon, yüksek dereceli fonksiyonlar, monadlar gibi kavramlar ilk başta karmaşık gelebilir.
• Performans Endişeleri: Bazı durumlarda, değişmezlik ve yeni nesnelerin sıkça oluşturulması, bellekte ek yük ve performans düşüşlerine neden olabilir. Ancak, modern FP dilleri ve derleyicileri bu sorunları optimize etmek için gelişmiş teknikler kullanmaktadır.
• G/Ç İşlemleri ve Yan Etkiler: Gerçek dünya uygulamaları her zaman dosya okuma/yazma, ağ istekleri gibi yan etkiler içerir. Fonksiyonel programlama bu yan etkileri yönetmek için özel yapılar (örneğin monadlar) kullanır ki bu yapılar başlangıçta anlaşılması zor olabilir.
• Kaynak Bulunabilirlik: Nesne yönelimli programlamaya kıyasla fonksiyonel programlama kaynakları (dersler, kütüphaneler, topluluk desteği) bazı dillerde daha az olabilir, ancak bu durum hızla değişmektedir.

• Haskell: Saf fonksiyonel bir dil olarak tasarlanmıştır. Tembel değerlendirme (lazy evaluation) ve güçlü tip sistemine sahiptir. Akademik çevrelerde ve bazı ticari projelerde kullanılır.
• Lisp/Scheme/Clojure: Tarihsel olarak en eski fonksiyonel dillerden biridir. Makro yetenekleri ve dinamik doğaları ile bilinirler. Özellikle Clojure, JVM üzerinde çalışmasıyla popülerdir.
• Erlang/Elixir: Eş zamanlı ve dağıtık sistemler oluşturmak için tasarlanmıştır. Telekomünikasyon gibi yüksek kullanılabilirlik gerektiren alanlarda kullanılır. Hata toleransına vurgu yaparlar.
• Scala: Hem nesne yönelimli hem de fonksiyonel programlamayı destekleyen hibrit bir dildir. JVM üzerinde çalışır ve büyük veri işleme (Apache Spark) gibi alanlarda popülerdir.
• F#: Microsoft tarafından geliştirilen, .NET platformu için tasarlanmış bir fonksiyonel dil.
• JavaScript: Esnek yapısı sayesinde fonksiyonel programlama stillerini benimsemek için çok uygundur. Fonksiyonları birinci sınıf vatandaş olarak ele alması, yüksek dereceli fonksiyonların kullanımını teşvik eder.
• Python: Çok paradigmalı bir dil olup, lambdalar, map, filter, reduce gibi fonksiyonel yapılar sunar. Fonksiyonel bir tarzda kod yazmak mümkündür, ancak saf bir FP dili değildir.

// Python ile Fonksiyonel Yaklaşım
from functools import reduce

users = [
    {"name": "ali", "age": 30, "isActive": True},
    {"name": "ayşe", "age": 25, "isActive": False},
    {"name": "can", "age": 35, "isActive": True},
    {"name": "deniz", "age": 22, "isActive": True}
]

# 1. Aktif kullanıcıları filtrele (pure function)
def is_active_user(user):
    return user["isActive"]

active_users = filter(is_active_user, users)

# 2. İsimleri büyük harfe çevir (pure function)
def uppercase_name(user):
    return user["name"].upper()

uppercase_names = map(uppercase_name, active_users)

# 3. İsimleri alfabetik olarak sırala (pure function)
sorted_names = sorted(list(uppercase_names))

print(sorted_names)
# Çıktı: ['ALI', 'CAN', 'DENIZ']

# Zincirleme (Function Composition) ile daha kompakt yazım
# Bu yaklaşım, ara değişkenler olmadan, fonksiyonların akışını gösterir.
# Ancak, okunabilirlik açısından bazen ara adımlar daha faydalı olabilir.
processed_names = sorted(list(map(lambda user: user["name"].upper(),
                                  filter(lambda user: user["isActive"], users))))
print(processed_names)
# Çıktı: ['ALI', 'CAN', 'DENIZ']

"Fonksiyonel programlama, programlamayı daha basit ve öngörülebilir hale getiren bir yoldur." - Unknown (Ortak Görüş)

Genişletmek için tıkla ...