Prosedürel programlama ve fonksiyonel programlama için Wikipedia makalelerini okudum , ancak hala biraz kafam karıştı. Birisi çekirdeğe kaynatabilir mi?

İşlevsel bir dil (ideal olarak) matematiksel bir işlev yazmanıza olanak tanır, yani n argüman alan ve bir değer döndüren bir işlev . Program yürütülürse, bu işlev gerektiği gibi mantıksal olarak değerlendirilir. ¹

Yordamsal bir dil ise bir dizi ardışık adım gerçekleştirir. (Sıralı mantığı, devam geçiş tarzı adı verilen işlevsel mantığa dönüştürmenin bir yolu vardır .)

Sonuç olarak, tamamen işlevsel bir program bir girdi için her zaman aynı değeri verir ve değerlendirme sırası iyi tanımlanmamıştır; bu da kullanıcı girişi veya rastgele değerler gibi belirsiz değerlerin tamamen işlevsel dillerde modellenmesinin zor olduğu anlamına gelir.

¹ Bu yanıttaki diğer her şey gibi, bu bir genelleme. Bir hesaplamanın, çağrıldığı yerde değil, sonucuna ihtiyaç duyulduğunda değerlendirildiği bu özellik “tembellik” olarak bilinir. İşlevsel diller aslında evrensel olarak tembel değildir ve tembellik işlevsel programlama ile sınırlı değildir. Daha ziyade, burada verilen açıklama, farklı ve zıt kategoriler değil, daha ziyade akıcı fikirler olan farklı programlama stillerini düşünmek için bir “zihinsel çerçeve” sağlar.

Temelde iki stil Yin ve Yang gibidir. Biri örgütlü, diğeri kaotik. Fonksiyonel programlamanın bariz bir seçim olduğu durumlar vardır ve diğer durumlar ise Prosedürel programlama daha iyi bir seçimdir. Bu nedenle, her iki programlama stilini de kapsayan yeni bir sürümle ortaya çıkan en az iki dil vardır. ( Perl 6 ve D 2 )

Usul:

• Bir rutinin çıktısının her zaman girdi ile doğrudan bir ilişkisi yoktur.
• Her şey belirli bir sırayla yapılır.
• Bir rutinin yürütülmesinin yan etkileri olabilir.
• Çözümleri lineer bir şekilde uygulama eğilimindedir.

Perl 6

sub factorial ( UInt:D $n is copy ) returns UInt {

  # modify "outside" state
  state $call-count++;
  # in this case it is rather pointless as
  # it can't even be accessed from outside

  my $result = 1;

  loop ( ; $n > 0 ; $n-- ){

    $result *= $n;

  }

  return $result;
}

D 2

int factorial( int n ){

  int result = 1;

  for( ; n > 0 ; n-- ){
    result *= n;
  }

  return result;
}

Fonksiyonel:

• Genellikle özyinelemeli.
• Belirli bir giriş için her zaman aynı çıkışı döndürür.
• Değerlendirme sırası genellikle tanımsızdır.
• Vatansız olmalı. Yani hiçbir işlemin yan etkisi olamaz.
• Paralel yürütme için iyi uyum
• Bölme ve fethetme yaklaşımını vurgulama eğilimindedir.
• Tembel Değerlendirme özelliğine sahip olabilir.

Haskell

( Wikipedia'dan kopyalandı );

fac :: Integer -> Integer

fac 0 = 1
fac n | n > 0 = n * fac (n-1)

veya tek bir satırda:

fac n = if n > 0 then n * fac (n-1) else 1

Perl 6

proto sub factorial ( UInt:D $n ) returns UInt {*}

multi sub factorial (  0 ) { 1 }
multi sub factorial ( $n ) { $n * samewith $n-1 } # { $n * factorial $n-1 }

D 2

pure int factorial( invariant int n ){
  if( n <= 1 ){
    return 1;
  }else{
    return n * factorial( n-1 );
  }
}

Kenar notu:

Faktöriyör aslında Perl 6'da bir alt rutin oluşturduğunuz gibi yeni operatörler oluşturmanın ne kadar kolay olduğunu gösteren yaygın bir örnektir. Bu özellik Perl 6 ile o kadar iç içe geçmiştir ki Rakudo uygulamasındaki çoğu operatör bu şekilde tanımlanır. Ayrıca mevcut operatörlere kendi çoklu adaylarınızı eklemenizi sağlar.

sub postfix:< ! > ( UInt:D $n --> UInt )
  is tighter(&infix:<*>)
  { [*] 2 .. $n }

say 5!; # 120␤

Bu örnek ayrıca, sayısal infix çarpma işleciyle birleştirilmiş aralık oluşturma ( 2..$n) ve liste azaltma meta-işlecini ( [ OPERATOR ] LIST) gösterir. ( *)
Ayrıca --> UIntimzadan returns UIntsonra imzayı koyabileceğinizi de gösterir .

( Herhangi bir argüman olmadan çağrıldığında 2çarpma "operatörü" döneceği için aralığı başlatmakla kurtulabilirsiniz 1)

Daha önce başka bir yerde bu tanımı görmedim, ama buradaki farkları oldukça iyi özetliyor:

Fonksiyonel programlama ifadelere odaklanır

Prosedürel programlama ifadelere odaklanır

İfadelerin değerleri vardır. İşlevsel bir program, değeri bilgisayarın gerçekleştirmesi için bir dizi talimat olan bir ifadedir.

İfadelerin değerleri yoktur ve bunun yerine bazı kavramsal makinelerin durumunu değiştirirler.

Tamamen işlevsel bir dilde hiçbir ifade olmayacaktı, devleti manipüle etmenin bir yolu olmadığı anlamında (yine de "deyim" adında bir sözdizimsel yapıya sahip olabilirler, ancak durumu manipüle etmedikçe ona bu anlamda bir ifade demezdim ). Tamamen prosedürel bir dilde ifade olmazdı, her şey makinenin durumunu manipüle eden bir talimat olurdu.

Haskell tamamen işlevsel bir dile bir örnek olacaktır, çünkü durumu manipüle etmenin bir yolu yoktur. Makine kodu tamamen yordamsal bir dile örnektir, çünkü bir programdaki her şey makinenin kayıtlarının durumunu ve hafızasını manipüle eden bir ifadedir.

Kafa karıştırıcı kısım, programlama dillerinin büyük çoğunluğunun hem ifadeleri hem de ifadeleri içermesi ve paradigmaları karıştırmanıza izin vermesidir. Diller, ifadelerin ve ifadelerin kullanımını ne kadar teşvik ettiklerine bağlı olarak daha işlevsel veya daha prosedürel olarak sınıflandırılabilir.

Örneğin, bir işlev çağrısı bir ifade olduğu için C, COBOL'dan daha işlevsel olacaktır, oysa COBOL'de bir alt programı çağırmak bir ifadedir (paylaşılan değişkenlerin durumunu değiştirir ve bir değer döndürmez). Python, C'den daha işlevsel olacaktır, çünkü koşullu mantığı kısa devre değerlendirmesini (if ifadelerinin aksine test && path1 || path2) kullanarak bir ifade olarak ifade etmenizi sağlar. Şema Python'dan daha işlevsel olacaktır çünkü şemadaki her şey bir ifadedir.

Yine de prosedürel paradigmayı teşvik eden bir dilde işlevsel bir tarzda yazabilirsiniz ve bunun tersi de geçerlidir. Dil tarafından teşvik edilmeyen bir paradigmada yazmak daha zor ve / veya daha garip.

Bilgisayar biliminde fonksiyonel programlama, hesaplamayı matematiksel fonksiyonların değerlendirilmesi olarak ele alan ve durum ve değişken verileri önleyen bir programlama paradigmasıdır. Durum değişikliklerini vurgulayan prosedürel programlama stilinin aksine fonksiyonların uygulanmasını vurgular.

Fonksiyonel Programlama

num = 1 
def function_to_add_one(num):
    num += 1
    return num


function_to_add_one(num)
function_to_add_one(num)
function_to_add_one(num)
function_to_add_one(num)
function_to_add_one(num)

#Final Output: 2

Prosedürel Programlama

num = 1 
def procedure_to_add_one():
    global num
    num += 1
    return num


procedure_to_add_one()
procedure_to_add_one()
procedure_to_add_one()
procedure_to_add_one()
procedure_to_add_one()

#Final Output: 6

function_to_add_one bir işlevdir

procedure_to_add_one bir prosedür

İşlevi beş kez çalıştırsanız bile , her döndüğünde 2

Eğer çalıştırırsanız prosedürünü beş kez, beşinci çalışma sonunda size verecektir 6 .

Prosedürel / fonksiyonel / objektif programlamanın bir probleme nasıl yaklaşılacağı ile ilgili olduğuna inanıyorum.

Birinci stil her şeyi adım adım planlar ve her seferinde bir adım (bir prosedür) uygulayarak sorunu çözer. Öte yandan, işlevsel programlama, sorunun alt probleme ayrıldığı böl ve fethet yaklaşımını vurgulayacaktır, daha sonra her bir alt problem çözülür (bu alt problemi çözmek için bir işlev yaratılır) ve sonuçlar birleştirilir. tüm sorunun cevabını oluşturun. Son olarak, Objektif programlama, her biri (bir şekilde) benzersiz özelliklere sahip olan ve başkalarıyla etkileşime giren birçok nesne ile bilgisayarın içinde bir mini dünya yaratarak gerçek dünyayı taklit eder. Bu etkileşimlerden sonuç ortaya çıkacaktı.

Her programlama tarzının kendine özgü avantajları ve zayıflıkları vardır. Bu nedenle, "saf programlama" (yani tamamen prosedürel - hiç kimse bunu yapmaz, bu arada garip - veya tamamen işlevsel veya tamamen nesnel) gibi bir şey yapmak, imkansız değilse bile, özellikle bazı temel problemler dışında çok zordur. bir programlama stilinin avantajını göstermek için tasarlanmıştır (bu nedenle, saflıktan hoşlananlara "weenie" diyoruz: D).

Daha sonra, bu stillerden, her bir stil için optimize edilmiş programlama dilleri var. Örneğin, Meclis tamamen prosedürle ilgilidir. Tamam, çoğu erken dil prosedüreldir, sadece Asm değil, C, Pascal gibi (ve duyduğum Fortran). Daha sonra, objektif okulda tüm ünlü Java'larımız var (Aslında, Java ve C # "para odaklı" olarak adlandırılan bir sınıfta, ancak bu başka bir tartışmaya tabi). Ayrıca objektif Smalltalk. Fonksiyonel okulda, "neredeyse işlevsel" (bazıları saf olarak kabul edilmez) olurdu Lisp ailesi ve ML ailesi ve birçok "tamamen işlevsel" Haskell, Erlang, vb. Bu arada, Perl, Python gibi birçok genel dil var. , Ruby.

Konrad'ın yorumunu genişletmek için:

Sonuç olarak, tamamen işlevsel bir program girdi için her zaman aynı değeri verir ve değerlendirme sırası iyi tanımlanmamıştır;

Bu nedenle, fonksiyonel kodun paralel hale getirilmesi genellikle daha kolaydır. Fonksiyonların (genellikle) hiçbir yan etkisi olmadığından ve (genellikle) sadece argümanları üzerinde hareket ettiklerinden, birçok eşzamanlılık sorunu ortadan kalkar.

Fonksiyonel programlama, kodunuzun doğru olduğunu kanıtlayabilmeniz gerektiğinde de kullanılır . Bu, prosedürel programlama ile çok daha zordur (fonksiyonel ile kolay değil, yine de daha kolay).

Feragatname: Yıllar boyunca fonksiyonel programlama kullanmadım ve sadece son zamanlarda tekrar bakmaya başladım, bu yüzden burada tam olarak doğru olmayabilirim. :)

Burada gerçekten vurgulamadığım bir şey, Haskell gibi modern fonksiyonel dillerin, akış kontrolü için birinci sınıf işlevlerde açık özyinelemeden çok daha fazla olduğudur. Yukarıdaki gibi Haskell'de faktöryel özyinelemeli tanımlamanız gerekmez. Bence böyle bir şey

fac n = foldr (*) 1 [1..n]

mükemmel bir deyimsel yapıdır ve ruh olarak açık özyineleme kullanmaktan çok daha yakındır.

Fonksiyonel bir programlama global değişkenler edildiği prosedürel programlama ile aynıdır değildir kullanılır.

Yordamsal diller, durumu (değişkenleri kullanarak) izleme eğilimindedir ve bir dizi adım olarak yürütme eğilimindedir. Tamamen işlevsel diller durumu takip etmez, değişmez değerler kullanır ve bir dizi bağımlılık olarak çalışma eğilimindedir. Birçok durumda çağrı yığınının durumu, işlem değişkenindeki durum değişkenlerinde saklanana eşdeğer olacak bilgileri tutacaktır.

Özyineleme işlevsel stil programlamanın klasik bir örneğidir.

Konrad şunları söyledi:

Sonuç olarak, tamamen işlevsel bir program girdi için her zaman aynı değeri verir ve değerlendirme sırası iyi tanımlanmamıştır; bu da kullanıcı girişi veya rastgele değerler gibi belirsiz değerlerin tamamen işlevsel dillerde modellenmesinin zor olduğu anlamına gelir.

Tamamen işlevsel bir programdaki değerlendirme sırasını (özellikle tembellikle) hatta önemsiz olmak zor olabilir (ama iyi tanımlanmadığını söylemek programınızın gidip gitmediğini söyleyemeyeceğinizi düşünüyor) hiç çalışmak için!

Belki de daha iyi bir açıklama, fonksiyonel programlardaki kontrol akışının, bir fonksiyonun argümanlarının değerine ne zaman ihtiyaç duyulduğuna dayanmasıdır. İyi yazılmış programlarda durumun açık hale geldiği bununla ilgili iyi bir şey: her bir işlev, girişlerini keyfi olarak küresel durumu karıştırmak yerine parametreler olarak listeler . Bu nedenle, bir düzeyde, bir seferde bir işlevle ilgili değerlendirme sırasını sorgulamak daha kolaydır . Her işlev evrenin geri kalanını görmezden gelebilir ve ne yapması gerektiğine odaklanabilir. Birleştirildiklerinde, fonksiyonların tek başına olduğu gibi çalışacağı garanti edilir [1].

... kullanıcı girişi veya rastgele değerler gibi belirsiz değerlerin tamamen işlevsel dillerde modellenmesi zordur.

Tamamen işlevsel programlarda giriş probleminin çözümü, yeterince güçlü bir soyutlama kullanarak DSL olarak zorunlu bir dili gömmektir . Zorunlu (ya da saf olmayan işlevsel) dillerde buna gerek yoktur, çünkü durumu dolaylı olarak "aldatabilir" ve geçebilirsiniz ve değerlendirme sırası açıktır (ister beğenip beğenmeseniz de). Bu "hile" ve tüm parametrelerin her işleve zorla değerlendirilmesi nedeniyle, zorunlu dillerde 1) kendi kontrol akış mekanizmalarınızı (makrolar olmadan) oluşturma yeteneğinizi kaybedersiniz, 2) kod doğal olarak iş parçacığı için güvenli ve / veya paralelleştirilemez varsayılan olarak, 3) ve geri alma (zaman yolculuğu) gibi bir şey uygulamak dikkatli bir çalışma gerektirir (zorunlu programcı eski değerleri geri almak için bir reçete saklamalıdır!), Ancak saf fonksiyonel programlama tüm bunları satın alır - ve birkaç tane daha unuttum - "ücretsiz".

Umarım bu gayret gibi görünmez, sadece biraz bakış açısı eklemek istedim. C # 3.0 gibi güçlü dillerde zorunlu programlama ve özellikle karma paradigma programlama, işleri halletmek için hala tamamen etkili yollardır ve gümüş mermi yoktur .

[1] ... muhtemelen bellek kullanımı hariç (Haskell'de bkz. Katla ve katla).

Konrad'ın yorumunu genişletmek için:

ve değerlendirme sırası iyi tanımlanmamıştır

Bazı fonksiyonel diller Tembel Değerlendirme olarak adlandırılır. Bu, değer gerekinceye kadar bir işlevin yürütülmediği anlamına gelir. O zamana kadar işlevin kendisi aktarılan şeydir.

Yordamsal diller adım 1 adım 2 adım 3'tür ... adım 2'de 2 + 2 ekleyin derseniz, bunu doğru yapar. Tembel değerlendirmede 2 + 2 ekle diyebilirsiniz, ancak sonuç asla kullanılmazsa, eklemeyi asla yapmaz.

Eğer bir şansın varsa, Lisp / Scheme'in bir kopyasını almayı ve içinde bazı projeler yapmayı öneririm. Son zamanlarda bandwago haline gelen fikirlerin çoğu, on yıllar önce Lisp'de ifade edildi: fonksiyonel programlama, devamlar (kapanışlar olarak), çöp toplama, hatta XML.

Bu, tüm bu mevcut fikirlere ve sembolik hesaplama gibi birkaç şeye daha iyi bir başlangıç ​​yapmak için iyi bir yol olacaktır.

Fonksiyonel programlamanın ne için iyi olduğunu ve ne için iyi olmadığını bilmelisiniz. Her şey için iyi değil. Bazı problemler en iyi yan etkiler açısından ifade edilir, burada aynı soru sorulduğu zamana göre farklı cevaplar verir.

@Creighton:

Haskell'de product adlı bir kütüphane işlevi vardır :

prouduct list = foldr 1 (*) list

ya da sadece:

product = foldr 1 (*)

yani "deyimsel" faktöriyel

fac n = foldr 1 (*)  [1..n]

sadece olurdu

fac n = product [1..n]

Yordamsal programlama, ifade dizilerini ve koşullu yapıları (işlevsel olmayan) değerler olan bağımsız değişkenler üzerinden parametreleştirilmiş yordamlar adı verilen ayrı bloklara böler.

İşlevsel programlama, işlevlerin birinci sınıf değerler olması dışında aynıdır, bu nedenle diğer işlevlere bağımsız değişken olarak iletilebilir ve işlev çağrılarının sonuçları olarak döndürülebilir.

Fonksiyonel programlamanın bu yorumdaki prosedürel programlamanın genelleştirilmesi olduğunu unutmayın. Bununla birlikte, bir azınlık "işlevsel programlama" yı, yan etkisi olmayan, Haskell dışındaki tüm önemli fonksiyonel diller için önemsiz olan fakat önemsiz olarak tanımlamaktadır.

Farkı anlamak için, hem prosedürel hem de fonksiyonel programlamanın "vaftiz babası" paradigmasının zorunlu programlama olduğunu anlamak gerekir .

Temel olarak prosedürel programlama sadece temel soyutlama yönteminin "prosedür" olduğu zorunlu programları yapılandırmanın bir yoludur. (veya bazı programlama dillerinde "işlev"). Nesneye Yönelik Programlama bile, zorunlu bir programı yapılandırmanın başka bir yoludur, burada durum nesnelerde kapsüllenir, "geçerli durum" ile bir nesne haline gelir, ayrıca bu nesnenin size izin veren bir dizi işlevi, yöntemi ve diğer şeyleri vardır programcı durumu manipüle veya güncelleme.

Şimdi, fonksiyonel programlama ile ilgili olarak, , yaklaşımındaki öz , hangi değerlerin alınacağını ve bu değerlerin nasıl aktarılması gerektiğini tanımlamasıdır. (bu nedenle, birinci sınıf değerler olarak işlevler alıp bunları diğer işlevlere parametre olarak ilettiği için durum ve değiştirilebilir veriler yoktur).

Not: Her programlama paradigmasının kullanıldığını anlamak, hepsi arasındaki farkları netleştirmelidir.

PSS: Günün sonunda, programlama paradigmaları problemleri çözmek için sadece farklı yaklaşımlardır.

PSS: Bu quora cevabının harika bir açıklaması var.

Buradaki cevapların hiçbirinde deyimsel fonksiyonel programlama gösterilmiyor. Özyinelemeli faktöriyel cevap, FP'de özyinelemeyi temsil etmek için mükemmeldir, ancak kodun çoğunluğu özyinelemeli değildir, bu yüzden cevabın tamamen temsilci olduğunu düşünmüyorum.

Dize diziniz olduğunu ve her dize "5" veya "-200" gibi bir tamsayıyı temsil ettiğini varsayalım. Bu dizeler dizisini dahili test durumunuzla karşılaştırmak istiyorsunuz (Tamsayı karşılaştırmasını kullanarak). Her iki çözüm de aşağıda gösterilmiştir

Usul

arr_equal(a : [Int], b : [Str]) -> Bool {
    if(a.len != b.len) {
        return false;
    }

    bool ret = true;
    for( int i = 0; i < a.len /* Optimized with && ret*/; i++ ) {
        int a_int = a[i];
        int b_int = parseInt(b[i]);
        ret &= a_int == b_int;  
    }
    return ret;
}

fonksiyonel

eq = i, j => i == j # This is usually a built-in
toInt = i => parseInt(i) # Of course, parseInt === toInt here, but this is for visualization

arr_equal(a : [Int], b : [Str]) -> Bool =
    zip(a, b.map(toInt)) # Combines into [Int, Int]
   .map(eq)
   .reduce(true, (i, j) => i && j) # Start with true, and continuously && it with each value

Saf işlevsel diller genellikle araştırma dilidir (Gerçek dünya serbest yan etkileri sevdiğinden), gerçek dünyadaki prosedürel diller uygun olduğunda çok daha basit işlevsel sözdizimini kullanır.

Bu genellikle Lodash gibi harici bir kütüphane veya Rust gibi daha yeni dillerle yerleşik olarak kullanılabilir . Fonksiyonel programlama ağır kaldırma gibi işlevleri / kavramlarla yapılır map, filter, reduce, currying,partial , son üç daha fazla anlayış için bakabilirsiniz.

ek

Vahşi doğada kullanmak için, derleyici normalde işlev çağrısı yükü çok yüksek olduğu için işlevsel sürümün dahili olarak yordamsal sürüme nasıl dönüştürüleceğini hesaplamak zorundadır. Gösterilen faktöryel gibi özyinelemeli durumlarda, O (n) bellek kullanımını kaldırmak için kuyruk çağrısı gibi hileler kullanılır. Hiçbir yan etkisi olmaması, fonksiyonel derleyicilerin && reten .reduceson yapıldığında bile optimizasyonu uygulamasına izin verir . JS'de Lodash kullanmak, açıkça herhangi bir optimizasyona izin vermez, bu nedenle performansa bir vuruştur (Bu genellikle web geliştirme ile ilgili bir endişe değildir). Rust gibi diller dahili olarak optimize edilir (Ve optimizasyona try_foldyardımcı olacak işlevlere sahiptir && ret).