Programació funcional a Rubí

Introducció

La programació funcional (FP) és un paradigma de programació alternativa a la tradicional (o programació estructural imprescindible i la programació orientada a objectes) va inventar, com "càlcul lambda" per Alonso Església en 30 anys, molt abans que se sabia que exactament el que un ordinador.

Els estudis de l'Església va servir de base per al desenvolupament del llenguatge de programació Lisp, i després es va abandonar gairebé per complet, com ho va afirmar l'equip de programació imperatiu que va generar el bàsic i com Pascal, C, i avui el modern C + + i Java.

La idea bàsica del càlcul lambda és un programa d'ordinador que es pot expressar, en lloc d'un conjunt obligatori de les instruccions (fer això, llavors fer això, fes allò), amb una sèrie de funcions els paràmetres són molts funcions.

Un programa funcional es compon generalment d'una funció que pren com a entrada a una altra funció que té una altra funció com a entrada, i així successivament.

Això vol dir que mentre un programa tradicional, escrita en un paradigma imperatiu o objectes, es compon d'una sèrie de comandes que actuen sobre la variable el valor representa l '"estat" del programa, en la programació funcional del concepte de variable no existeix (No existeix el concepte de "Estat") i l'execució és a càrrec d'una sèrie de funcions que operen sobre la funció constant.

L'interès en els llenguatges funcionals s'ha perdut amb el temps per diverses raons, sobretot la dificultat d'aprenentatge (en general un home pensa dels objectes en lloc de funcions, a menys que sigui un matemàtic!) I la dificultat de trobar compiladors o intèrprets eficients.

Ruby i FP

Avui dia, aquest interès es va despertar, però, a causa de la programació funcional comporta una conseqüència de gran valor: no es pot per resultat la definició dels errors en temps d'execució. En altres paraules, en temps de compilació, o la primera vegada que tots dos funciona o no funciona. No pot comportar-se de forma impredictible per endavant (en un programa funcional, de fet, no existeix el concepte d'excepció).

Així van néixer i alguns estan prosperant els llenguatges funcionals (més o menys pur, i amb el suport més o menys a la programació tradicional), com ara: ML / Ocaml , Haskell , F # .

Ruby no és un llenguatge funcional, sinó que utilitza algunes tècniques de programació funcional que ens pot ajudar a que els algoritmes més sintètic, més potent i més eficaç. A més que, en general, més fàcils de llegir.

Cada un i mapa

La primera característica de les llengües que donen suport d'alguna manera, la FP ha de tenir a la seva biblioteca estàndard de iteradors funcional. Per exemple:

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







 $ Elementi.map {| Elem | puts elem + 1}

La funció de "mapa" i "cadascun" Ruby no són més que aplicar FP! De fet, hi ha funcions que tenen altres funcions com a arguments. En Ruby, doncs, que les parts dels blocs de codi entre {} o entre do / cap de funcions anònimes es construeixen específicament per a ser subjectes de moltes funcions.

Aquestes funcions es denominen a la FP d'ordre superior, funcions, és a dir que tenen tantes funcions com a entrada.

En particular "mapa" actua com una funció matemàtica clàssica i es pot llegir de la següent manera: per a cada element de la sèrie d'un a cinc, executar la funció: imprimeix el nombre natural següent.

Aquest "mapa" o "associats", per a cada element d'una col · lecció (una matriu en Ruby podria dir) una certa funció definida en el bloc.

El mateix passaria naturalment amb:

 



 $ Elementi.each {...}

 

Tancaments: Proc i lambda

Els tancaments són un concepte similar a la d'alta per a la funció: la possibilitat de definir una funció substancial per actuar sobre les variables que estan vivint en un context diferent al de la funció (per exemple, les variables globals i funcions d'altres variables).

En Ruby, puc escriure un tancament amb funcions anònimes que poden ser definits amb la Proc.new paraules clau o lambda.

Heus aquí un exemple:

 multiplicació final (multiplicador)



    



 tornar lambda {| n | n multiplicador *}







 final









 per3 = multiplicació (3)









 per3.call posa (3) # => 9







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

En aquest exemple, no només una funció que jo anomeno autoevidents "multiplicació". ¿Què té d'estrany aquesta funció? Aquí simplement no s'usa cap variable!

L'argument no és un multiplicador variable és simplement un marcador de posició per a una constant o una funció.

No obstant això, en la programació tradicional, que m'agradaria escriure:

 def multiplicar (a, b)



    



 tornar a * b







 final









 posa de multiplicació (3.3)

Com es pot veure, però, amb un tancament que jo anomeno un "operador" Faig una crida per3, que defineix el comportament de totes les multiplicacions "x3". Llavors jo dic a aquest operador el nombre 3. Fins i tot es pot trucar recursivament! O en diuen, en lloc d'una constant, en una altra funció.

En la programació tradicional, però, em veig obligat a definir a priori el nombre de variables que intervenen en l'operació - el que limita la multiplicació de dos nombres - i, el més important, he d'introduir un concepte d'Estat, l'assignació de memòria per a dues variables que contenen els valors que es multipliquen.

• <<
• 1
• 2
• >>