Programmation fonctionnelle en Ruby

Présentation

La programmation fonctionnelle (FP) est une alternative au paradigme de la programmation de la traditionnelle (programmation structurelle ou impérative et la programmation orientée objet) a inventé, comme le «lambda-calcul» par Alonso Eglise en 30 ans, bien avant il était connu que exactement ce que c'était un ordinateur.

Les études de l'église a servi de base pour le développement du langage de programmation Lisp, et puis ils ont été presque totalement abandonnés, comme ils le prétendent la programmation impérative les ordinateurs qui a généré la base et comme Pascal, C, et aujourd'hui le moderne C + + et Java.

L'idée de base du calcul de lambda est un programme d'ordinateur peut être exprimé, au lieu d'un ensemble d'instructions obligatoires (ce faire, alors faites ceci, puis cela), avec une série de fonctions dont les paramètres sont le même nombre fonctions.

Un programme fonctionnel est habituellement composée d'une fonction qui prend en entrée une autre fonction qui prend une autre fonction comme entrée, et ainsi de suite.

Cela signifie que si un programme traditionnel, écrit dans un paradigme impératif ou des objets, se compose d'une série de commandes qui agissent sur la variable dont la valeur représente l '«Etat» du programme, la programmation fonctionnelle dans le concept même de la variable n'existe pas (Il n'ya pas de concept de «l'état») et l'exécution est confiée à un certain nombre de fonctions qui opèrent sur la fonction constante.

L'intérêt pour les langages fonctionnels ont été perdues au fil du temps, pour plusieurs raisons, notamment la difficulté de l'apprentissage (en général un homme pense d'objets plutôt que les fonctions, sauf s'il est un mathématicien!) Et la difficulté à trouver interprètes efficaces ou des compilateurs.

Ruby et FP

Aujourd'hui, cet intérêt a été éveillé, cependant, parce que la programmation fonctionnelle apporte avec elle une conséquence de très précieux: il ne peut pas définir par le plomb à des bogues à l'exécution. En d'autres termes, au moment de la compilation ou la première fois ou bien il fonctionne ou ne fonctionne pas. Impossible de se comporter de façon pas prévu a priori (dans un programme fonctionnel, en fait, il n'ya pas de notion d'exception).

Ainsi sont nés et certains sont en plein essor dans les langages fonctionnels (plus ou moins pur, et avec le soutien plus ou moins à la programmation traditionnelle), tels que: ML / OCaml , Haskell , F # .

Ruby n'est pas un langage fonctionnel, mais il utilise des techniques de programmation fonctionnels qui peuvent nous aider à formuler des algorithmes plus synthétique, plus puissant et plus efficace. Outre que, habituellement, plus facile à lire.

Chaque carte et

La première caractéristique des langues qui soutiennent en quelque sorte la FP, est d'avoir dans votre bibliothèque standard itérateurs fonctionnels. Par exemple:

 $ Éléments = [1,2,3,4,5]







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

Les fonctions «carte» et «chacun» de Ruby sont rien de plus que appliquée FP! En fait il ya des fonctions qui ont d'autres fonctions comme arguments. En Ruby, alors, que les parties des blocs de code inclus dans {} ou entre do / fin des fonctions anonymes sont construits spécialement pour être des sujets de nombreuses fonctions.

Ces fonctions sont appelées dans la FP d'ordre élevé, fonctions qui prennent en savoir autant de fonctions que l'entrée.

En particulier la «carte» agit comme une fonction classique et mathématique peut être lu comme suit: pour chaque élément de la série de un à cinq, exécuter la fonction: imprimer le numéro suivant naturelle.

Cette «carte» ou «associés», pour chaque élément d'une collection (un tableau en Ruby on dirait) une certaine fonction définie dans le bloc.

La même chose se produirait naturellement avec:

 



 $ Elementi.each {...}

 

Fermetures: Proc et lambda

Les fermetures sont un concept similaire à celui de la fonction afin de haute: la possibilité de définir nettement une fonction de variables qui agissent sur ​​la vie dans un contexte différent de celui de la fonction (par exemple les variables globales ou des variables d'autres fonctions).

En Ruby, je peux écrire une fermeture à l'aide des fonctions anonymes qui peuvent être définies avec les mots-clés ou Proc.new lambda.

Voici un exemple:

 multipliez def (multiplicateur)



    



 retour lambda {| n | n multiplicateurs *}







 fin









 PER3 de multiplication = (3)









 met per3.call (3) # => 9







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

Pas exactement de soi dans cet exemple, je définir une fonction «multiplier». Ce qui est étrange, cette fonction? Ici je n'ai tout simplement pas utiliser n'importe quelle variable!

L'argument n'est pas un multiplicateur variable est simplement un espace réservé pour une fonction constante ou une autre.

Mais, dans la programmation traditionnelle, j'écrirais:

 multipliez def (a, b)



    



 retourner une b *







 fin









 met à la multiplication (3,3)

Comme on peut le constater, cependant, je définis une fermeture en utilisant un "opérateur" J'appelle PER3, qui définit le comportement de toutes les multiplications "x3". Puis-je appeler cet opérateur le numéro 3. Je peux aussi l'appeler récursivement! Ou appeler, au lieu d'une constante, sur une autre fonction.

Dans la programmation traditionnelle, cependant, je suis obligé de définir à l'avance le nombre de variables impliquées dans la transaction - limitant ainsi la multiplication de deux nombres - et, plus important, je dois insérer un concept de l'Etat, l'allocation de mémoire pour deux variables qui contiennent les valeurs doivent être multipliés.

• <<
• 1
• 2
• >>