Funksjonell Programmering i Ruby

Innledning

Funksjonell programmering (FP) er et programmeringsspråk paradigme alternativ til den tradisjonelle (eller strukturelle avgjørende programmering og objektorientert programmering) oppfunnet, som "lambda calculus" av Alonso kirke i 30 år, lenge før det ble kjent at nøyaktig hva en datamaskin.

Studier av kirken tjente som grunnlag for utviklingen av Lisp programmeringsspråk, og da de var nesten helt forlatt, da det bekreftet maktpåliggende programmering datamaskin som genererte Basic og som Pascal, C, og i dag er moderne C + + og Java.

Den grunnleggende ideen om lambda calculus er at et dataprogram kan uttrykkes, i stedet for en obligatorisk sett med instruksjoner (gjør dette, så gjør dette, så gjør det), med en rekke funksjoner som parametere er så mange funksjoner.

En funksjonell program er vanligvis sammensatt av en funksjon som tar som input en annen funksjon som tar en annen funksjon som input, og så videre.

Dette betyr at mens et tradisjonelt program, skrevet i en viktig paradigme eller gjenstander, består av en serie med kommandoer som handler på variabelen hvis verdi representerer "state" av programmet, i funksjonell programmering konseptet variable ikke eksisterer (Det er ikke begrepet "stat") og utførelse er overlatt til en rekke funksjoner som opererer på konstant funksjon.

Interessen for funksjonelle språk har gått tapt over tid av flere grunner, først og fremst vansker med læring (vanligvis en mann som tenker på objekter heller enn funksjoner, med mindre det er en matematiker!) Og det er vanskelig å finne effektiv kompilatorer eller tolker.

Ruby og FP

I dag ble denne interessen vekket, men fordi funksjonell programmering bringer med seg en konsekvens av meget verdifulle: det kan ikke per definisjon resultere i kjøre-time bugs. Med andre ord, ved kompilering eller første gang, enten det fungerer eller ikke fungerer. Kan ikke oppføre seg på måter ikke er forutsigbare på forhånd (i en funksjonell program, faktisk er det ingen begrepet unntak).

Dermed ble født, og noen er blomstrende funksjonelle språk (mer eller mindre rene, og med mer eller mindre støtte til de tradisjonelle programmering) som: ML / OCaml , Haskell , F # .

Ruby er ikke et funksjonelt språk, men bruker noen funksjonell programmering teknikker som kan hjelpe oss å lage algoritmer mer syntetisk, mer potente og mer effektiv. Bortsett fra det generelt lettere å lese.

Hver og kart

Det første karakteristiske språk som støtter på noen måte FP er å ha i din standard bibliotek av funksjonelle iterators. For eksempel:

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







 $ Elementi.map {| Elkem | setter Elkem + 1}

Funksjonen "kart" og "hver" av Ruby er noe mer enn anvendt FP! Faktisk er det funksjoner som har andre funksjoner som argumenter. I Ruby, da, at de deler av blokker av kode vedlagt i {} eller mellom do / end anonyme funksjoner er bygget spesielt for å være fag av mange funksjoner.

Slike funksjoner kalles på FP high-orden, dvs. funksjoner som tar så mange innspill funksjoner.

Spesielt "kart" fungerer som en klassisk og matematisk funksjon kan leses som følger: for hvert element i serien fra en til fem, kjøre funksjonen: Skriver det neste naturlige tall.

At "kart" eller "kollegaer", for hvert element i en samling (en array i Ruby vil si) en viss funksjon definert i blokken.

Det samme ville skje naturlig med:

 



 $ Elementi.each {...}

 

Nedleggelser: Proc og lambdasonde

Nedleggelsene er et konsept som minner om høy-order funksjon: muligheten til vesentlig definere en funksjon for å handle på variabler som lever i en sammenheng forskjellig fra funksjonen (som globale variabler eller funksjoner av andre variabler).

I Ruby, kan jeg skrive en nedleggelse bruker anonyme funksjoner som kan defineres med søkeordene Proc.new eller lambda.

Her er et eksempel:

 endelig multiplikasjon (multiplier)



    



 returnere lambda {| n | n * multiplikator}







 end









 per3 = multiplikasjon (3)









 setter per3.call (3) # => 9







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

I dette eksempelet, ikke bare en funksjon jeg kaller selvinnlysende "multiplikasjon". Hva er så merkelig denne funksjonen? Her har jeg rett og slett ikke bruke noe variabel!

Argumentet er ikke en variabel multiplikator er bare en plassholder for en konstant eller en funksjon.

Men i tradisjonell programmering, vil jeg skrive:

 def formere (a, b)



    



 returnere en * b







 end









 setter multiplikasjon (3.3)

Som kan sees, men ved hjelp av en nedleggelse jeg kaller en "operator" Jeg kaller per3, som definerer atferden til alle multiplikasjon "x3". Så jeg kaller dette operatør tallet 3. Jeg kan til og med kalle det rekursivt! Eller kaller det, i stedet for en konstant, på en annen funksjon.

I tradisjonell programmering, men jeg er tvunget til å definere a priori antall variabler som er involvert i transaksjonen - og dermed begrense multiplikasjon av to tall - og, viktigst, må jeg sette inn et konsept av staten, tildele minne for to variabler som inneholder verdier som skal multipliseres.

• <<
• 1
• 2
• >>