Functioneel Programmeren in Ruby

Introductie

Functioneel programmeren (FP) is een programmeer paradigma alternatief voor de traditionele (structurele of imperatief programmeren en object-georiënteerd programmeren) uitgevonden, als de "lambda calculus" door Alonso kerk in 30 jaar, lang voor bekend was dat precies wat het was een computer.

Studies van de kerk diende als basis voor de ontwikkeling van de programmeertaal Lisp, en dan waren ze bijna volledig verlaten, omdat ze beweerde dat de imperatief programmeren van de computers die de Basic en als Pascal, C, en vandaag de gegenereerde moderne C + + en Java.

Het basisidee van de lambda-calculus is dat een computerprogramma kan worden uitgedrukt, in plaats van een verplichte set van instructies (doe dit, doe dit dan, doe dan dat), met een reeks van functies waarvan de parameters zijn hetzelfde nummer functies.

Een functioneel programma is meestal samengesteld uit een functie die als invoer neemt een andere functie die een andere functie neemt als input, en ga zo maar door.

Dit betekent dat tijdens een traditioneel programma, geschreven in een imperatieve paradigma of voorwerpen, bestaat uit een serie van commando's die werken op de variabele waarvan de waarde vertegenwoordigt de "staat" van het programma, functioneel programmeren in het concept van de variabele niet bestaat (Er is geen concept van "state") en de uitvoering is toevertrouwd aan een aantal functies die werken op een constante functie.

De belangstelling voor functionele talen verloren is gegaan gedurende de tijd om verschillende redenen, met name de moeilijkheid van het leren (meestal een man denkt aan objecten in plaats van functies, tenzij hij is een wiskundige!) En de moeilijkheid bij het vinden van efficiënte tolken of compilers.

Ruby en FP

Vandaag de dag is deze interesse is gewekt, echter, omdat functioneel programmeren met zich meebrengt een gevolg van de zeer waardevol: het kan niet per definitie leiden tot fouten bij run-time. Met andere woorden, tijdens het compileren of de eerste keer dat zowel het werkt of niet werkt. Kan niet gedragen op manieren die niet a priori te verwachten (in een functioneel programma, in feite is er geen concept van uitzondering).

Zo werden geboren en sommige zijn bloeiende functionele talen (meer of minder zuiver, en met meer of minder steun voor de traditionele programmering), zoals: ML / OCaml , Haskell , F # .

Ruby is niet een functionele taal, maar maakt gebruik van functioneel programmeren technieken die ons kan helpen om algoritmes meer synthetische, krachtiger en effectiever te formuleren. Daarnaast is meestal makkelijker te lezen.

Elke en kaart

Het eerste kenmerk van talen die steunen op een bepaalde manier de FP, is om in uw standaard bibliotheek iterators functioneel. Bijvoorbeeld:

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







 Elementi.map $ {| elem | zet elem} + 1

De functies "kaart" en "ieder" van Ruby zijn niets meer dan toegepaste FP! In feite zijn er functies die andere functies als argumenten hebben. In Ruby, dan, dat die delen van de blokken van de code ingesloten in {} of tussen niet / einde anonieme functies zijn speciaal gebouwd om te worden onderwerpen van vele functies.

Deze functies worden genoemd in de FP high-order-functies, dat wil zeggen functies die rekening zo veel functies als input.

In het bijzonder "kaart" werkt als een klassieke en wiskundige functie kan worden gelezen als volgt: voor elk element van de serie van een tot vijf, lopen de functie: print het volgende natuurlijke getal.

Dat "kaart" of "medewerkers", voor elk element van een verzameling (een Array in Ruby zouden we zeggen) een bepaalde functie in de zin van het blok.

Hetzelfde zou natuurlijk gebeuren met:

 



 $ Elementi.each {...}

 

Sluitingen: Proc en lambda

De sluitingen zijn een concept vergelijkbaar met die van een hoge-orde functie: de mogelijkheid om aanzienlijk te definiëren een functie van de variabelen die handelen over het leven in een context verschilt van dat van de functie (bijv. globale variabelen of variabelen van andere functies).

In Ruby, kan ik schrijven een sluiting met behulp van anonieme functies die kunnen worden gedefinieerd met de trefwoorden Proc.new of lambda.

Hier is een voorbeeld:

 def vermenigvuldigen (multiplier)



    



 terug lambda {| n | n * multiplier}







 einde









 per3 = vermenigvuldiging (3)









 per3.call zet (3) # => 9







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

Niet echt vanzelfsprekend in dit voorbeeld heb ik een functie definiëren "vermenigvuldigen". Wat is er zo vreemd deze functie? Hier heb ik simpelweg geen gebruik maken van een variabele!

Het argument is niet een variabele multiplier is gewoon een tijdelijke aanduiding voor een constante of een andere functie.

Maar in de traditionele programmering, zou ik schrijven:

 def vermenigvuldigen (a, b)



    



 return a * b







 einde









 zet de vermenigvuldiging (3.3)

Zoals te zien is, echter, definieer ik een sluiting met behulp van een "operator" Ik noem per3, die het gedrag van alle vermenigvuldigingen "x3" definieert. Dan noem ik dit de exploitant van de nummer 3. Ik kan ook noemen recursief! Of noem het, in plaats van een constante, op een andere functie.

In de traditionele programmering, echter, ben ik gedwongen om te bepalen op voorhand het aantal variabelen bij de transactie betrokken - hetgeen dus een beperking van de vermenigvuldiging van twee getallen - en, nog belangrijker, ik heb een concept van de staat invoegen, het toewijzen van geheugen voor twee variabelen die bevatten de waarden die moeten worden vermenigvuldigd.

• <<
• 1
• 2
• >>