Fonksiyonel Programlama - Değişmezlik

FP (özellikle F #, ancak diğer FP de Tamam) değişmez veriler ile ilgili anlamaya çalışıyorum ve devlet dolu düşünme (OOP tarzı) eski alışkanlığı kırmak. Buradaki soruya verilen yanıtın bir kısmı, OOP'ta durumsal temsillerle FP'deki değişmez olanlarla çözülen sorunların etrafındaki herhangi bir yazımı araştırmamı yineledi (Örneğin: Üreticiler ve Tüketici ile bir kuyruk). Herhangi bir düşünce veya bağlantı bekliyoruz? Şimdiden teşekkürler.

Düzenleme : Soruyu biraz daha açıklığa kavuşturmak için, nasıl değişmez yapılar (ex: kuyruk) FP birden çok iş parçacığı (ex: üretici ve tüketici) arasında aynı anda paylaşılır

Bazen bu şekilde ifade edilmesine rağmen, fonksiyonel programlama¹ durum bilgisi olan hesaplamaları engellemez. Yaptığı şey, programcıyı durumu açık hale getirmeye zorlamaktır.

Örneğin, zorunlu bir kuyruk (bazı sözde dillerde) kullanarak bazı programların temel yapısını ele alalım:

q := Queue.new();
while (true) {
    if (Queue.is_empty(q)) {
        Queue.add(q, producer());
    } else {
        consumer(Queue.take(q));
    }
}

İşlevsel kuyruk veri yapısına (tek seferde bir farkla başa çıkmak için zorunlu bir dilde) karşılık gelen yapı şöyle görünecektir:

q := Queue.empty;
while (true) {
    if (q = Queue.empty) {
        q := Queue.add(q, producer());
    } else {
        (tail, element) := Queue.take(q);
        consumer(element);
        q := tail;
    }
}

Kuyruk şimdi değiştirilemediğinden, nesnenin kendisi değişmez. Bu sözde kodda, qkendisi bir değişkendir; atamaları q := Queue.add(…)ve q := tailfarklı bir nesneye işaret olun. Kuyruk işlevlerinin arabirimi değişti: her biri işlemden kaynaklanan yeni kuyruk nesnesini döndürmelidir.

Tamamen işlevsel bir dilde, yani yan etkisi olmayan bir dilde, tüm durumu açık hale getirmeniz gerekir. Üretici ve tüketici muhtemelen bir şeyler yapıyor olduğundan, durumları burada da aracının arayüzünde olmalıdır.

main_loop(q, other_state) {
    if (q = Queue.empty) {
        let (new_state, element) = producer(other_state);
        main_loop(Queue.add(q, element), new_state);
    } else {
        let (tail, element) = Queue.take(q);
        let new_state = consumer(other_state, element);
        main_loop(tail, new_state);
    }
}
main_loop(Queue.empty, initial_state)

Şimdi her devlet parçasının nasıl açıkça yönetildiğine dikkat edin. Kuyruk düzenleme işlevleri kuyruğu girdi olarak alır ve çıktı olarak yeni bir kuyruk oluşturur. Üretici ve tüketici de devletlerini geçer.

Eşzamanlı programlama çok iyi uymuyor iç fonksiyonel programlama, ama çok iyi uyuyor etrafında fonksiyonel programlama. Fikir, bir grup ayrı hesaplama düğümü çalıştırmak ve mesaj alışverişi yapmalarına izin vermektir. Her düğüm işlevsel bir program çalıştırır ve ileti gönderip alırken durumu değişir.

Örneğin devamı, tek bir kuyruk olduğu için belirli bir düğüm tarafından yönetiliyor. Tüketiciler bu düğüme bir eleman elde etmek için bir mesaj gönderir. Yapımcılar bu düğüme eleman eklemek için bir mesaj gönderir.

main_loop(q) =
    consumer->consume(q->take()) || q->add(producer->produce());
    main_loop(q)

Eşzamanlılık right³ alır dil “sanayileşmiş” biridir Erlang . Erlang'ı öğrenmek kesinlikle eşzamanlı programlama hakkında aydınlanmanın yoludur⁴.

Şimdi herkes yan etkisiz dillere geçiyor!

¹ _{Bu terim birçok anlamlara sahiptir; burada yan etkiler olmadan programlama yapmak için kullandığınızı düşünüyorum ve bu da benim kullandığım anlam.}
² _{Örtük durum ile programlama zorunlu programlamadır ; nesne yönelimi tamamen dik bir kaygıdır.}
³ _{Enflamatuar, biliyorum, ama demek istediğim. Paylaşılan belleğe sahip konular eşzamanlı programlamanın montaj dilidir. Mesaj geçişini anlamak çok daha kolaydır ve yan etki eksikliği, eşzamanlılığı tanıttığınız anda gerçekten parlar.}
⁴ _{Ve bu, Erlang hayranı olmayan, başka nedenlerle gelen birinden geliyor.}

Bir FP dilindeki durumsal davranış, önceki durumdan yeni duruma geçiş olarak uygulanır. Örneğin, enqueue bir kuyruktan ve bir değerden, enqueued değeriyle yeni bir kuyruğa dönüşüm olacaktır. Dequeue, kuyruktan değere dönüşüm ve değeri kaldırılmış yeni bir kuyruk olur. Monadlar gibi yapılar, bu durum dönüşümünü (ve diğer hesaplama sonuçlarını) faydalı şekillerde soyutlamak için tasarlanmıştır.

... FP'deki değişmez olanlarla OOP'taki durumsal temsillerle çözülen sorunlar (Örn: Üreticiler ve Tüketici ile bir kuyruk)

Sorunuz "XY sorunu" olarak adlandırılan sorudur. Özellikle, belirttiğiniz kavram (üreticiler ve tüketici ile kuyruk) aslında bir çözümdür ve tarif ettiğiniz gibi bir "sorun" değildir. Bu bir zorluk yaratır, çünkü doğası gereği saf olmayan bir şeyin tamamen işlevsel bir şekilde uygulanmasını istersiniz. Cevabım bir soru ile başlıyor: çözmeye çalıştığınız sorun nedir?

Birden fazla üreticinin sonuçlarını tek bir paylaşılan tüketiciye göndermesinin birçok yolu vardır. Belki de F # 'deki en belirgin çözüm, tüketiciyi bir temsilci (aka MailboxProcessor) yapmak ve üreticilere Postsonuçlarını tüketici temsilcisine kazandırmaktır. Bu dahili olarak bir kuyruk kullanır ve saf değildir (F # 'da mesaj göndermek kontrolsüz bir yan etkidir, safsızlıktır).

Bununla birlikte, altta yatan sorunun daha çok paralel programlamanın dağılım-toplama modeli gibi olması muhtemeldir. Bu sorunu çözmek için bir dizi girdi değeri oluşturabilir ve ardından Array.Parallel.mapbunların üzerinde bir seri kullanarak sonuçları toplayabilirsiniz Array.reduce. Alternatif olarak, PSeqsekans elemanlarını paralel olarak işlemek için modülden fonksiyonları kullanabilirsiniz .

Ayrıca, durumsal düşüncede yanlış bir şey olmadığını vurgulamalıyım. Saflığın avantajları vardır, ancak kesinlikle her derde deva değildir ve eksikliklerinden de haberdar olmalısınız. Gerçekten de, bu yüzden F # saf bir işlevsel dil değildir: bu yüzden tercih edildiklerinde safsızlıkları kullanabilirsiniz.

Clojure, eşzamanlılıkla yakından ilişkili olan çok iyi düşünülmüş bir devlet ve kimlik kavramına sahiptir. Değişmezlik önemli bir rol oynar, Clojure'daki tüm değerler değişmezdir ve referanslarla erişilebilir. Referanslar basit göstergelerden daha fazlasıdır. Değere erişimi yönetiyorlar ve farklı semantiklere sahip birden fazla türü var. Bir referans, yeni (değişmez) bir değere işaret edecek şekilde modifiye edilebilir ve bu tür bir değişikliğin atomik olması garanti edilir. Ancak, değişiklikten sonra diğer tüm evreler hala en azından referansa erişinceye kadar orijinal değer üzerinde çalışır.

Clojure'da devlet ve kimlik hakkında mükemmel bir makale okumanızı şiddetle tavsiye ederim , detayları yapabileceğimden çok daha iyi açıklıyor.