TL; DR: Les langages fonctionnels gèrent-ils mieux la récursion que les non-fonctionnels?
Je lis actuellement Code Complete 2. À un moment donné du livre, l'auteur nous met en garde contre la récursion. Il dit que cela devrait être évité autant que possible et que les fonctions utilisant la récursion sont généralement moins efficaces qu'une solution utilisant des boucles. À titre d’exemple, l’auteur a écrit une fonction Java qui utilise la récursivité pour calculer la factorielle d’un nombre comme celui-ci (ce n’est peut-être pas exactement la même chose puisque je n’ai pas le livre avec moi pour le moment):
public int factorial(int x) {
if (x <= 0)
return 1;
else
return x * factorial(x - 1);
}
Ceci est présenté comme une mauvaise solution. Cependant, dans les langages fonctionnels, la récursivité est souvent la méthode préférée. Par exemple, voici la fonction factorielle dans Haskell utilisant la récursivité:
factorial :: Integer -> Integer
factorial 0 = 1
factorial n = n * factorial (n - 1)
Et est largement accepté comme une bonne solution. Comme je l'ai vu, Haskell utilise très souvent la récursivité et je n'ai vu nulle part où elle était mal vue.
Donc, ma question est essentiellement la suivante:
- Les langages fonctionnels gèrent-ils mieux la récursion que les non fonctionnels?
EDIT: Je suis conscient que les exemples que j'ai utilisés ne sont pas les meilleurs pour illustrer ma question. Je voulais juste souligner que Haskell (et les langages fonctionnels en général) utilise la récursion beaucoup plus souvent que les langages non fonctionnels.
factorial n = product [1..n]
est plus succinct, plus efficace et ne déborde pas la pile pour les gros n
(et si vous avez besoin de mémoization, des options totalement différentes sont nécessaires). product
est défini en termes de certains fold
, ce qui est défini de manière récursive, mais avec un soin extrême. La récursivité est une solution acceptable la plupart du temps, mais il est toujours facile de le faire mal / sous-optimal.