Funktionel Programmering i Ruby

Indledning

Funktionsprogrammering (FP) er et programmeringssprog paradigme alternativ til de opfundet traditionelle (strukturelle eller tvingende programmering og objekt-orienteret programmering), som "lambda calculus" af Alonso Kirke i 30 år, længe før det blev kendt, at præcis, hvad det var en computer.

Undersøgelser af Kirkens tjent som grundlag for udviklingen af ​​programmeringssproget Lisp, og så de var næsten helt opgivet, da de hævdede imperativt programmeringssprog de computere, der genererede Basic og som Pascal, C, og i dag den moderne C + + og Java.

Den grundlæggende idé om lambda calculus er, at et edb-program kan udtrykkes, i stedet for et obligatorisk sæt af instrukser (gør dette, så gør dette, så gør det), med en række funktioner, hvis parametre er det samme antal funktioner.

En funktionel program er normalt består af en funktion, der tager som input en anden funktion, der tager en anden funktion som input, og så videre.

Dette betyder, at mens et traditionelt program, skrevet i en absolut nødvendighed paradigme eller objekter, består af en række kommandoer, der virker på den variabel, hvis værdi repræsenterer den "tilstand" af programmet, er funktionel programmering i selve begrebet variabel eksisterer ikke (Der er ingen begreb "tilstand") og udførelse er overdraget til en række funktioner, der opererer på konstant funktion.

Interessen for funktionelle sprog er gået tabt i tidens løb af flere grunde, først og fremmest vanskeligheden ved læring (som regel en mand tænker på objekter i stedet for funktioner, medmindre han er en matematiker!) Og vanskelighederne med at finde effektiv tolke og oversættere.

Ruby og FP

I dag Denne interesse er blevet vakt, men fordi funktionel programmering medfører det en konsekvens af meget værdifuld: Det kan ikke per definition fører til fejl på run-time. Med andre ord, enten det på kompilere tid, eller første gang, virker eller ikke virker. Kan ikke opføre sig på måder, der ikke forventet på forhånd (i et funktionelt program, i virkeligheden er der ingen begreb undtagelse).

Således blev født, og nogle er blomstrende funktionelle sprog (mere eller mindre ren, og med mere eller mindre støtte til traditionel programmering) såsom: ML / OCaml , Haskell , F # .

Ruby er ikke et funktionelt sprog, men bruger funktionel programmering teknikker, der kan hjælpe os til at formulere algoritmer mere syntetisk, mere potent og mere effektiv. Udover at det som regel, lettere at læse.

Hver og kort

Den første er karakteristisk for sprog, der understøtter en eller anden måde at FP, er at have i din standard bibliotek iteratorer funktionel. For eksempel:

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







 Elementi.map $ {| elem | sætter elem} + 1

Funktionerne "kort" og "hver" af Ruby er intet mere end anvendt FP! I virkeligheden er der funktioner, som har andre funktioner som argumenter. I Ruby, så er de dele af blokke af kode omsluttet af {} eller mellem Do / slutningen anonyme funktioner er bygget specielt til at blive emner af mange funktioner.

Disse funktioner kaldes i FP med høj-ordens funktioner, dvs funktioner, tage så mange funktioner som input.

Især "kort" fungerer som en klassisk og matematisk funktion kan læses som følger: for hvert element i serien 1-5, funktionen køre: udskrive det næste naturlige tal.

At "kort" eller "associerede" for hvert element i en samling (et array i Ruby ville vi sige) en bestemt funktion defineret i blokken.

Det samme ville ske naturligt med:

 



 $ Elementi.each {...}

 

Lukninger: Proc og lambda

De lukninger er et koncept, der svarer til høj-order funktion: evnen til at definere en væsentlig funktion af variable, der handler om at leve i en kontekst forskellig fra den funktion (f.eks globale variabler eller variabler af andre funktioner).

I Ruby, kan jeg skrive en lukning bruger anonyme funktioner, der kan defineres med de søgeord Proc.new eller lambda.

Her er et eksempel:

 def formere (multiplikator)



    



 tilbage lambda {| n | n * multiplikator}







 ende









 per3 = multiplikation (3)









 per3.call sætter (3) # => 9







 sætter per3.call (per8.call (2)) # => 48

Ikke ligefrem en selvfølge i dette eksempel definerer jeg en funktion "formere". Hvad er så mærkeligt denne funktion? Her vil jeg simpelthen ikke bruge nogen variabel!

Argumentet er ikke en variabel multiplikator er blot en pladsholder for en konstant eller en anden funktion.

Men i traditionel programmering, ville jeg skrive:

 def gange (a, b)



    



 returnere en * b







 ende









 sætter multiplikation (3.3)

Som det kan ses, men jeg definerer en lukning ved hjælp af en "operatør" Jeg kalder per3, som definerer adfærden hos alle multiplikationer "X3". Så jeg kalder denne operatør tallet 3. Jeg kan også kalde det rekursivt! Eller kalder det, i stedet for en konstant, på en anden funktion.

I traditionel programmering, dog er jeg tvunget til at definere på forhånd antallet af variabler, der er involveret i transaktionen - og dermed mindske multiplikation af to tal - og vigtigst, jeg er nødt til at indsætte et koncept af staten, tildele hukommelse til to variabler, der indeholder de værdier, der skal ganges.

• <<
• 1
• 2
• >>