Pourquoi les langages de programmation fonctionnels nécessitent-ils un garbage collection?

Qu'est-ce qui empêche ghc de traduire Haskell en un langage de programmation concaténatif tel que la logique combinatoire, puis d'utiliser simplement l'allocation de pile pour tout? Selon Wikipedia, la traduction du calcul lambda à la logique combinatoire est triviale, et les langages de programmation concaténatifs peuvent compter uniquement sur une pile pour l'allocation de mémoire. Est-il possible de faire cette traduction et donc d'éliminer le ramasse-miettes pour des langues comme Haskell et ocaml? Y a-t-il des inconvénients à faire cela?

EDIT: déplacé ici /programming/39440412/why-do-functional-programming-languages-require-garbage-collection

Tous les commentaires suivants reposent sur le choix d'une stratégie d'implémentation standard utilisant des fermetures pour représenter les valeurs de fonction et un ordre d'évaluation appel par valeur:

1. Pour le calcul lambda pur, la collecte des ordures n'est pas nécessaire. Cela est dû au fait qu'il n'est pas possible de former des cycles dans le tas: chaque valeur nouvellement allouée ne peut contenir que des références aux valeurs précédemment allouées, et donc le graphique de la mémoire forme un DAG - donc le comptage des références suffit pour gérer la mémoire.

2. La plupart des implémentations n'utilisent pas le comptage de références pour deux raisons.

   1. Ils prennent en charge une forme de type pointeur (par exemple, le refconstructeur de type en ML), et ainsi de vrais cycles dans le tas peuvent être formés.
   2. Le comptage des références est beaucoup moins efficace que la récupération de place, car
      • il nécessite beaucoup d'espace supplémentaire pour conserver les comptes de référence, et
      • la mise à jour des décomptes est généralement un travail inutile, et
      • les mises à jour des comptes créent un tas de conflits d'écriture qui détruit les performances parallèles.

3. Les langages de type linéaire peuvent éliminer le nombre de références (essentiellement parce que les nombres sont 0-1: soit la valeur a une seule référence, soit elle est morte et peut être libérée).

4. Cependant, l'allocation de pile ne suffit toujours pas. En effet, il est possible de former des valeurs de fonction qui se réfèrent à des variables libres (c'est-à-dire que nous devons implémenter des fermetures de fonction), si vous allouez des choses sur la pile, les valeurs en direct peuvent être entrelacées avec des valeurs mortes, ce qui entraînera une asymptotique incorrecte l'utilisation de l'espace.

5. Vous pouvez obtenir la bonne asymptotique en remplaçant une pile par une "pile de spaghetti" (c'est-à-dire implémenter la pile en tant que liste chaînée dans le tas, afin de pouvoir découper les cadres morts selon les besoins).

6. Si vous voulez une vraie discipline de pile, vous pouvez utiliser des systèmes de types basés sur une "logique ordonnée" (essentiellement des types linéaires sans échange).