Hangi İşlevsel özellikler getirdikleri faydalar için biraz OOP karışıklığına değer?

Haskell ve F # 'da fonksiyonel programlamayı öğrendikten sonra, OOP paradigması sınıflar, arayüzler, nesnelerle geriye doğru görünüyor. İş arkadaşımın anlayabileceği işe FP'nin hangi yönlerini getirebilirim? Bunları kullanabilmemiz için patronumla takımımı yeniden eğitme konusunda konuşmaya değer FP stilleri var mı?

FP'nin olası yönleri:

• değişmezlik
• Kısmi Uygulama ve Kurutma
• Birinci Sınıf Fonksiyonlar (fonksiyon göstergeleri / Fonksiyonel Nesneler / Strateji Kalıbı)
• Tembel Değerlendirme (ve Monadlar)
• Saf Fonksiyonlar (yan etki yok)
• İfadeler (İfadelerle - her kod satırı, yan etkilere neden olmak yerine yan etkilere neden olur)
• özyineleme
• Örüntü Eşleme

Dilin desteklediği sınıra kadar programlama dilinin desteklediği her şeyi yapabileceğimiz herkes için ücretsiz mi? Yoksa daha iyi bir kılavuz var mı?

Fonksiyonel programlama, Nesneye Dayalı programlamadan farklı bir paradigmadır (farklı bir zihniyet ve programlar hakkında farklı bir düşünme şekli). Burada problemler ve çözümleri hakkında düşünmenin birden fazla yolunun (nesne yönelimli) olduğunu fark etmeye başladınız. Başkaları da var (prosedürel ve jenerik programlama akla geliyor). Bu yeni bilgiye nasıl tepki verdiğiniz, bu yeni araçları ve yaklaşımları kabul edip beceri setinize entegre edip etmediğiniz, büyüyüp daha eksiksiz ve yetenekli bir geliştirici olup olmadığınızı belirleyecektir.

Hepimiz belirli bir karmaşıklık seviyesiyle başa çıkmak için eğitildik ve rahatız. Bunu bir kişinin hrair limiti olarak adlandırmayı seviyorum (Watership Down'dan ne kadar sayabilirsin). Zihninizi genişletmek, daha fazla seçenek düşünmek ve sorunlara yaklaşmak ve çözmek için daha fazla araca sahip olmak harika bir şey. Ancak bu bir değişikliktir ve sizi rahatlık alanınızdan çeker.

Karşılaşabileceğiniz bir sorun, "her şey bir nesnedir" kalabalığını takip etmek için daha az içerikli olmanızdır. Yazılım geliştirmeye işlevsel bir yaklaşımın neden bazı problemler için iyi çalıştığını anlamayan (veya anlamak isteyen) insanlarla çalışırken sabır geliştirmeniz gerekebilir. Genel bir programlama yaklaşımı gibi bazı problemler için de işe yarar.

İyi şanslar!

İşlevsel programlama, günlük kod yazımında çok pratik, toprağa bağlı, üretkenlik sağlar: bazı özellikler tersliği destekler, çünkü bu, ne kadar az kod yazarsanız, o kadar az arıza yapar ve daha az bakım gerektirir.

Bir matematikçi olarak, fantezi fonksiyonel şeyleri çok çekici buluyorum, ancak genellikle bir uygulama tasarlarken yararlıdır: bu yapılar, bu değişmezleri değişkenlerle temsil etmeden, program yapısında birçok değişkeni program yapısında kodlayabilir.

En sevdiğim kombinasyon oldukça önemsiz görünebilir, ancak bunun çok yüksek bir verimlilik etkisine sahip olduğuna inanıyorum. Bu kombinasyon, tekrar etiketleyeceğim Kısmi Uygulama ve Kıvrılma ve Birinci Sınıf Fonksiyonlarıdır , bir daha asla for-loop yazmaz : bunun yerine, döngü gövdesini bir yineleme veya haritalama işlevine geçirir. Son zamanlarda bir C ++ işi için işe alındı ​​ve eğlenceli bir şekilde fark ettim, tamamen döngüler yazma alışkanlığını kaybettim !

Özyineleme ve Örüntü Eşleme kombinasyonu, o Ziyaretçi tasarım örüntüsünün ihtiyacını ortadan kaldırır . Boole ifadelerinin bir değerlendiricisini programlamak için ihtiyacınız olan kodu karşılaştırın: herhangi bir fonksiyonel programlama dilinde bu yaklaşık 15 satır olmalıdır, OOP'ta yapılacak doğru şey , o oyuncak örneğini döndüren Ziyaretçi tasarım modelini kullanmaktır . kapsamlı bir deneme. Avantajları açıktır ve herhangi bir rahatsızlığın farkında değilim.

İşinizde kullandığınız bilginin hangi kısımlarını, Superman'ın normal bir yaşamın tadını çıkarmak için Clark Kent gibi davranması gerektiğini kısıtlamanız gerekebilir. Ama daha fazlasını bilmek sana zarar vermez. Bununla birlikte, Fonksiyonel Programlamanın bazı yönleri Nesneye Dayalı bir dükkan için uygundur ve diğer yönler patronunuzla konuşmaya değer olabilir, böylece mağazanızın ortalama bilgi seviyesini yükseltebilir ve sonuç olarak daha iyi kod yazabilirsiniz.

FP ve OOP birbirini dışlamaz. Scala'ya bak. Bazıları bunun en kötü olduğunu düşünür çünkü saf olmayan FP'dir, ancak bazıları aynı nedenden dolayı en iyisi olduğunu düşünür.

Tek tek, İşte OOP ile harika çalışan bazı yönler:

• Saf Fonksiyonlar (yan etki yok) - Bildiğim her programlama dili bunu destekliyor. Kodunuzu çok, akıl yürütmek için çok daha kolay hale getirir ve pratik olduğunda kullanılmalıdır. Ona FP demek zorunda değilsiniz. Sadece iyi kodlama uygulamaları deyin.

• Değiştirilemezlik: String tartışmalı olarak en çok kullanılan Java nesnesidir ve değişmezdir. Ben kapağı Immutable Java Nesneleri ve Immutable Java Koleksiyonlar blogumda. Bunlardan bazıları sizin için geçerli olabilir.

• Birinci Sınıf İşlevler (işlev işaretçileri / İşlevsel Nesneler / Strateji Kalıbı) - Java, 1.1 sürümünden bu yana, Listener arabirimini uygulayan API sınıflarının çoğunun (ve yüzlerce) olduğu bunun hobbled, mutant bir sürümüne sahiptir. Runnable muhtemelen en sık kullanılan fonksiyonel nesnedir. Birinci Sınıf İşlevleri, onları yerel olarak desteklemeyen bir dilde kodlamak için daha fazla çalışmadır, ancak bazen kodunuzun diğer yönlerini basitleştirdiklerinde ekstra çaba sarf etmeye değer.

• Özyineleme ağaçları işlemek için kullanışlıdır. Bir OOP dükkanında, bu muhtemelen özyinelemenin birincil uygun kullanımıdır. OOP dillerinde eğlenmek için özyineleme kullanmak, çoğu OOP dilinin varsayılan olarak yığın boşluğuna sahip olmaması durumunda, bunu iyi bir fikir haline getirmek için muhtemelen çatık olmalıdır.

• İfadeler (İfadelere Karşı - her kod satırı, yan etkilere neden olmak yerine yan etkilere ek olarak bir değer üretir) - C, C ++ ve Java'daki tek değerlendirici operatör Üçlü İşleçtir . Blogumda uygun kullanımı tartışıyorum. Yeniden kullanılabilir ve değerlendirici olan bazı basit fonksiyonlar yazabilirsiniz.

• Tembel Değerlendirme (ve Monadlar) - çoğunlukla OOP'ta tembel Başlatma ile sınırlıdır. Bunu destekleyecek dil özellikleri olmadan, yararlı olan bazı API'leri bulabilirsiniz, ancak kendinizinkini yazmak zordur. Bunun yerine akış kullanımınızı en üst düzeye çıkarın - örnekler için Yazar ve Okuyucu arabirimlerine bakın.

• Kısmi Uygulama ve Kurutma - Birinci sınıf fonksiyonlar olmadan pratik değildir.

• Örüntü Eşleme - genellikle OOP'de önerilmez.

Özetle, çalışmanın, dilin desteklediği sınıra kadar programlama dilinin desteklediği her şeyi yapabileceğiniz herkes için ücretsiz olması gerektiğini düşünmüyorum. İş arkadaşlarınız tarafından okunabilirliğin, işe alınmak için yapılan kod için turnusol testi olması gerektiğini düşünüyorum. Sizi en çok dinlendiren işte, iş arkadaşlarınızın ufkunu genişletmek için iş başında eğitim almaya başlayacağım.

Fonksiyonel programlamaya ve nesne yönelimli programlamaya ek olarak, bildirimsel programlama da (SQL, XQuery) vardır. Her stili öğrenmek yeni bilgiler edinmenize yardımcı olur ve iş için doğru aracı seçmeyi öğrenirsiniz.

Ama evet, bir dilde kod yazmak çok sinir bozucu olabilir ve başka bir şey kullanıyorsanız, belirli bir sorun alanı için çok daha üretken olabileceğinizi bilin. Bununla birlikte, Java gibi bir dil kullanıyor olsanız bile, FP'den Java kodunuza kavramları dolambaçlı yollarla da olsa uygulamak mümkündür. Örneğin, Guava çerçevesi bunlardan bazılarını yapar.

Bir programcı olarak öğrenmeyi asla bırakmamalısınız. Bununla birlikte, FP öğrenmenin OOP becerilerinizi azaltması çok ilginç. OOP öğrenmeyi bisiklet kullanmayı öğrenmeyi düşünüyorum; nasıl yapılacağını asla unutma.

FP'nin giriş ve çıkışlarını öğrendiğimde, kendimi daha matematiksel düşünerek buldum ve yazılım yazdığım araçlara daha iyi bir bakış açısı kazandım. Bu benim kişisel deneyimim.

Daha fazla deneyim kazandıkça, çekirdek programlama kavramlarını kaybetmek çok daha zor olacaktır. Bu yüzden, OOP kavramları zihninizde tamamen katılaşana kadar FP'de bunu kolaylaştırmanızı öneririm. FP kesin bir paradigma değişimidir. İyi şanslar!

Şimdiden birçok iyi yanıt var, bu yüzden benimki sorunuzun bir alt kümesini ele alacak; yani, OOP ve fonksiyonel özellikler birbirini dışlamadığından, sorunuzun öncülüne zorlanıyorum.

C ++ 11 kullanıyorsanız, dil / standart kütüphanede yerleşik olan ve OOP ile iyi bir şekilde sinerji yaratan (oldukça) fonksiyonel programlama özelliklerinin birçoğu vardır. Tabii ki, TMP'nin patronunuz veya iş arkadaşlarınız tarafından ne kadar iyi alınacağından emin değilim, ancak mesele şu ki, bu özelliklerin çoğunu C ++ gibi işlevsel olmayan / OOP dillerinde bir şekilde veya başka bir şekilde alabilirsiniz.

Derleme zamanı yinelemeli şablonların kullanılması ilk 3 noktanıza bağlıdır,

• değişmezlik
• özyineleme
• Örüntü Eşleme

Bu şablon değerlerinin değişmez olduğu (derleme zamanı sabitleri), herhangi bir yineleme özyineleme kullanılarak yapılır ve dallanma, aşırı yük çözünürlüğü biçiminde (daha fazla veya daha az) desen eşleştirme kullanılarak yapılır.

Diğer noktaları gelince, kullanma std::bindve std::functionsize kısmi fonksiyon uygulaması verir ve fonksiyon işaretçileri yerleşik olan dile. Çağrılabilir nesneler işlevsel nesnelerdir (kısmi işlev uygulamasının yanı sıra). Çağrılabilir nesnelerle, onları tanımlayanları kastediyorum operator ().

Tembel değerlendirme ve saf işlevler biraz daha zor olurdu; saf işlevler için, yalnızca değere göre yakalanan lambda işlevlerini kullanabilirsiniz, ancak bu ideal değildir.

Son olarak, kısmi işlev uygulamasıyla derleme zamanı özyinelemesinin kullanımına bir örnek. Biraz çelişkili bir örnek, ama yukarıdaki noktaların çoğunu gösteriyor. Belirli bir demet içindeki değerleri belirli bir işleve özyineli olarak bağlar ve (çağrılabilir) bir işlev nesnesi oluşturur

#include <iostream>
#include <functional>

//holds a compile-time index sequence
template<std::size_t ... >
struct index_seq
{};

//builds the index_seq<...> struct with the indices (boils down to compile-time indexing)
template<std::size_t N, std::size_t ... Seq>
struct gen_indices
  : gen_indices<N-1, N-1, Seq ... >
{};

template<std::size_t ... Seq>
struct gen_indices<0, Seq ... >
{
    typedef index_seq<Seq ... > type;
};


template <typename RType>
struct bind_to_fcn
{
    template <class Fcn, class ... Args>
    std::function<RType()> fcn_bind(Fcn fcn, std::tuple<Args...> params)
    {
        return bindFunc(typename gen_indices<sizeof...(Args)>::type(), fcn, params);
    }

    template<std::size_t ... Seq, class Fcn, class ... Args>
    std::function<RType()> bindFunc(index_seq<Seq...>, Fcn fcn, std::tuple<Args...> params)
    {
        return std::bind(fcn, std::get<Seq>(params) ...);
    }
};

//some arbitrary testing function to use
double foo(int x, float y, double z)
{
    return x + y + z;
}

int main(void)
{
    //some tuple of parameters to use in the function call
    std::tuple<int, float, double> t = std::make_tuple(1, 2.04, 0.1);                                                                                                                                                                                                      
    typedef double(*SumFcn)(int,float,double);

    bind_to_fcn<double> binder;
    auto other_fcn_obj = binder.fcn_bind<SumFcn>(foo, t);
    std::cout << other_fcn_obj() << std::endl;
}