Programare funcţională în Ruby

Introducere

De programare funcţional (FP) este o paradigmă alternativă de programare pentru a tradiţionale (de programare structurale sau imperativ şi programarea orientată pe obiecte) a inventat, ca "lambda calcul" de către Biserica Alonso 30 de ani, cu mult înainte de era cunoscut faptul că exact ceea ce a fost un computer.

Studii de Biserica a servit ca bază pentru dezvoltarea limbajului de programare Lisp, şi apoi ei au fost aproape complet abandonate, astfel cum au solicitat imperativ de programare calculatoare care a generat de bază şi ca Pascal, C, şi astăzi moderne de C + + şi Java.

Ideea de bază a calculului lambda este faptul că un program de calculator pot fi exprimate, în loc de un set de instrucţiuni obligatorii (face acest lucru, apoi face acest lucru, atunci acest lucru), cu o serie de funcţii ale căror parametri sunt acelaşi număr de funcţii.

Un program funcţional este, de obicei compus dintr-o funcţie care ia ca date de intrare o altă funcţie care ia altă funcţie ca intrare, şi aşa mai departe.

Acest lucru înseamnă că, în timp ce un program traditional, scris într-o paradigmă imperativ sau obiecte, constă dintr-o serie de comenzi care acţionează asupra variabila a cărei valoare reprezintă "de stat" a programului, de programare funcţional în însuşi conceptul de variabilă nu există (Nu există nici conceptul de "stat") şi de execuţie este încredinţată unui număr de funcţii care operează asupra funcţiei constante.

Interesul în limbajele funcţionale a fost pierdut în timp, din mai multe motive, mai ales cu dificultăţile de învăţare (de obicei, un om crede de obiecte, mai degrabă decât funcţii, cu excepţia cazului în el este un matematician!) Şi dificultatea de a găsi interpreţi eficiente sau compilatoare.

Ruby şi FP

Astăzi, acest interes a fost trezit, însă, pentru că de programare funcţional aduce cu ea o consecinţă a foarte valoroase: ea nu poate prin definiţie duce la bug-uri la run-time. Cu alte cuvinte, la momentul compilării sau prima oară, fie că funcţionează sau nu funcţionează. Poate nu se comportă în moduri care nu sunt anticipate a priori (intr-un program funcţional, de fapt, nu există conceptul de excepţie).

Astfel, s-au nascut, iar unele sunt înfloritoare, limbi funcţionale (mai mult sau mai puţin pură, şi cu sprijinul mai mult sau mai puţin pentru traditionale de programare), cum ar fi: ML / OCaml , Haskell , F # .

Ruby nu este un limbaj funcţional, dar utilizează tehnici de programare funcţional, care ne pot ajuta să formuleze algoritmi mai sintetice, mai puternice şi mai eficiente. Pe lângă faptul că, de obicei, mai uşor de citit.

Fiecare şi harta

Prima caracteristică de limbi care sprijin într-un fel FP, este de a avea în iteratori dvs. biblioteca standard funcţional. De exemplu:

 Elemente $ = [1,2,3,4,5]







 Elementi.map $ {| ELEM | pune ELEM} + 1

Funcţiile "hartă" şi "fiecare" din Ruby nu sunt nimic mai mult decât aplicate FP! De fapt, există funcţii care au alte funcţii ca argumente. În Ruby, apoi, că acele părţi din blocuri de cod închise în {} sau între face / sfârşitul funcţii anonim sunt construite special pentru a fi subiecte de multe functii.

Aceste funcţii sunt denumite în FP de mare pentru funcţii, funcţii şi anume că ia-o de mai multe funcţii ca intrare.

În special, "harta" acţionează ca o funcţie clasică şi matematice poate fi citit după cum urmează: pentru fiecare element al seriei unu la cinci, executaţi funcţia: imprimare următorul număr natural.

Această "hartă" sau "asociaţi", pentru fiecare element dintr-o colecţie (un Array în Ruby am putea spune), o anumită funcţie definită în bloc.

Acelaşi lucru se va întâmpla natural cu:

 



 $ Elementi.each {...}

 

Închidere: Proc şi lambda

Închidere sunt un concept similar cu cel al funcţiei de mare pentru a-: capacitatea de a defini în mod substanţial în funcţie de variabile care acţionează pe viaţă într-un context diferit de cel al funcţiei (de exemplu, variabilele globale sau variabile de alte functii).

În Ruby, Pot să scriu o închidere utilizând funcţii anonime, care pot fi definite cu Proc.new cuvinte cheie sau lambda.

Iată un exemplu:

 def multiplica (multiplicare)



    



 întoarcere lambda {| n | n * multiplicator}







 capăt









 per3 = multiplicare (3)









 per3.call pune (3) # => 9







 pune per3.call (per8.call (2)) # => 48

Nu chiar de la sine înţeles, în acest exemplu am defini o funcţie de "multiplica". Ce este atât de ciudat această funcţie? Aici am pur şi simplu nu folosesc nici o variabila!

Argumentul nu este un factor de multiplicare variabilă este pur şi simplu un substituent pentru o funcţie sau o altă constantă.

Dar, în traditionale de programare, aş scrie:

 def multiplica (a, b)



    



 întoarcere a, b *







 capăt









 pune de multiplicare (3.3)

Cum se poate observa, totuşi, am defini o închidere folosind un "operator" Fac apel per3, care defineşte comportamentul tuturor înmulţiri "x3". Apoi am numesc acest operator numărul 3. Pot apela, de asemenea, o recursiv! Sau apel, în loc de o constantă, pe o altă funcţie.

In traditionale de programare, cu toate acestea, eu sunt obligat să se definească în prealabil a numărului de variabile implicate în tranzacţie - limitându-se astfel o multiplicare a două numere - şi, cel mai important, am să inseraţi un concept de stat, alocarea de memorie pentru două variabile care conţin valorile de care urmează să fie multiplicate.

• <<
• 1
• 2
• >>