Funktionell programmering i Ruby

Inledning

Funktionell programmering (FP) är en programmeringsparadigm alternativ till den traditionella (eller strukturella imperativ programmering och objektorienterad programmering) uppfanns, som "lambda-kalkyl" av Alonso kyrka på 30 år, långt innan det var känt att precis vad en dator.

Studier av kyrkan låg till grund för utvecklingen av Lisp programmeringsspråk, och sedan de var nästan helt övergivna, eftersom det bekräftade imperativ programmering dator där ett grundläggande och som Pascal, C, och idag den moderna C + + och Java.

Den grundläggande idén med lambdakalkyl är att ett datorprogram kan uttryckas, i stället för en obligatorisk uppsättning instruktioner (gör detta, gör detta, då gör det), med en rad funktioner vars parametrar är lika många funktioner.

En funktionell program är vanligtvis består av en funktion som tar som indata en annan funktion som tar en annan funktion som indata, och så vidare.

Detta innebär att medan ett traditionellt program, skrivet i ett imperativt paradigm eller föremål, består av en serie kommandon som har effekt på variabel vars värde representerar den "stat" i programmet, i funktionell programmering begreppet variabel inte existerar (Det finns ingen begreppet "stat") och utförandet anförtros ett antal funktioner som arbetar på konstant funktion.

Intresset för funktionella språk har gått förlorat under tiden av flera skäl, främst svårigheten att lära sig (oftast en man tänker på föremål snarare än funktioner, om det inte är en matematiker!) Och svårigheten att hitta effektiv kompilatorer eller tolkar.

Ruby och FP

Idag var detta intresse väcktes, men eftersom funktionell programmering för med sig en konsekvens av mycket värdefullt: det kan inte per definition resultera i run-time fel. Med andra ord, vid kompileringen eller första gången antingen det fungerar eller inte fungerar. Kan inte bete sig på sätt som inte förutsägbar i förväg (på ett funktionellt program i själva verket finns det inget begrepp om undantag).

Således föddes och vissa är blomstrande funktionella språk (mer eller mindre ren, och med mer eller mindre stöd till den traditionella programmering) som: ML / OCaml , Haskell , F # .

Ruby är inte ett funktionellt språk, men använder en del funktionell programmering tekniker som kan hjälpa oss att göra algoritmer mer syntetiska, mer potent och mer effektiv. Förutom att generellt lättare att läsa.

Varje och karta

Det första utmärkande för språk som stöder på något sätt Ramprogrammet skall ha i ditt vanliga bibliotek av funktionella iteratorer. Till exempel:

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







 $ Elementi.map {| ELEM | sätter ELEM + 1}

Funktionen "karta" och "vart" av Ruby är inget annat än tillämpad FP! I själva verket finns det funktioner som har andra funktioner som argument. I Ruby, då, att de delar av block av kod omsluten av {} eller mellan att göra / avsluta anonym funktioner finns inbyggda speciellt för att vara betvingar av många funktioner.

Dessa funktioner kallas i FP hög ordningens funktioner, dvs funktioner som tar så många funktioner som indata.

I synnerhet "karta" fungerar som en klassisk och matematisk funktion kan läsas som följer: för varje del av serien från ett till fem köra funktionen: Skriver nästa naturliga tal.

Den "karta" eller "medarbetare", för varje element i en samling (en rad i Ruby skulle säga) en viss funktion som definieras i blocket.

Samma sak skulle hända naturligt med:

 



 $ Elementi.each {...}

 

Nedläggningar: Proc och lambda

Nedläggningarna är ett koncept som liknar hög-order funktion: förmågan att kraftigt definiera en funktion att agera på variabler som lever i ett sammanhang skiljer sig från funktionen (som globala variabler eller funktioner av andra variabler).

I Ruby kan jag skriva en nedläggning använda avidentifierade funktioner som kan definieras med nyckelord Proc.new eller lambda.

Här är ett exempel:

 sista multiplikation (multiplikator)



    



 tillbaka lambda {| n | n * multiplier}







 slut









 per3 = multiplikation (3)









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







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

I detta exempel, inte bara en funktion jag kallar självklart "mångfaldigande". Vad är så konstigt denna funktion? Här har jag helt enkelt använder inte någon rörlig!

Det argumentet är inte en variabel multiplikator är helt enkelt en platshållare för en konstant eller en funktion.

Men i traditionell programmering, skulle jag skriva:

 def multiplicera (a, b)



    



 återgång a * b







 slut









 sätter multiplikation (3,3)

Som framgår dock att använda en nedläggning jag kallar en "operatör" Jag kallar per3, som fastställer hur alla multiplikationer "x3". Då ska jag kalla detta operatören siffran 3. Jag kan även kalla det rekursivt! Eller kalla det, i stället för en konstant, på en annan funktion.

I traditionell programmering, är jag dock tvungen att bestämma på förhand hur många variabler inblandade i transaktionen - på så sätt begränsa multiplikation av två tal - och, viktigast av allt, måste jag sätta in ett koncept av staten, fördela minne för två variabler som innehåller de värden som ska multipliceras.

• <<
• 1
• 2
• >>