En gros le fait de faire ça permet de faire des simplification dans le code généré c'est ça?

Vu la page en anglais j'imagine que oui

En OCaml en tout cas c’est directement traduit en boucle for dans le bytecode généré

Après certains diront que le fait de coder en continuation rend le code illisible, mais en OCaml je trouve cela plus clair

Le code généré par ghc est illisible (ça change de gcc) je trouve enfin c'est vraiment le bordel donc ce sera difficile à voir je pense. Mais ça me parait logique qu'une telle simplification soit importante.

Mais je l'utilise pas trop je trouve,

par exemple pour la fonction factorielle

factorial 0 = 1
factorial x = x * factorial (x-1)

C'est pas une récursivité terminale j'imagine vu que je multiplie par x mais bon d'un côté en implémentation naive je vois pas d'autres solutions

fac n = aux 1 n where aux k 0 = k; aux k m = aux (k*m) (m-1)

Par exemple (je connais pas les conventions de mise en forme en haskell)

Mais ça a pas l’air de faire une grande différence en vrai

fac n = aux 1 n
where aux k 0 = k
aux k m = aux (k*m)(m-1)

En Haskell

Temps d'execution de factorial 7777 avec ta fonction 0.025s et avec la mienne 0.021s

Dans ton cul la récursivité terminale

Le code source est là

Naif: http://redcloud.fr/naif.s
Chouhartem: http://redcloud.fr/chouhartem.s

Je rage

Mais sérieux l'assembleur qui sort de ghc est illisible

En Ocaml ton implémentation est plus rapide?

Oui, et surtout ne stack overflow pas

De quoi?

Sinon, ailleurs en ruby: ruby ruby.rb 0.07s user 0.01s system 97% cpu 0.082 total

Pourquoi je peux pas faire les même récursions en Ruby ou Python?

RuntimeError: maximum recursion depth exceeded in comparison

Parce que ces langages ne sont pas fait pour

Ah ouais de la merde

Même en C j'y arrive pas wallah

1. include<iostream>

using namespace std;

int factorial(int n)
{
if (n == 0) {
return 1; }
else {
// cout << "* " << (n-1) << endl;
return n*factorial(n-1);
}}

int main()
{
cout << factorial(7777) << endl;
}

Sérieux c'est quoi le problème il me multiplie par 0 alors qu'il devrait pas Ca me fait penser que j'ai jamais essayé la récursion en dehors de ocaml/haskell

int overflow, tout simplement

Même pas je croyais mais non il me multiplie bien le résultat final par 0 le con

Ou alors le fait d'utiliser des long int ne suffit pas

Bordel c'est tellement mieux le monde fonctionnel

tous ces trucs la dependent du compilateur. Il y a des compilos C qui savent traiter la recursivite terminal et les modification simple pour rendre les codes recursif terminal et transforme le tout en boucle for. Et il y en a d'autre qui ne savent pas.

Bah là pour le coup c'est bien de l'overflow, j'avais oublié les limitations du C++. Y a pas moyen de travailler avec de gros nombres ça me parait étrange quand même. J'aurais bien aimé essayer

Okay Chouhartem j'ai l'explication

http://stackoverflow.com/questions/13042353/does-haskell-have-tail-recursive-optimization