If we compare the performance for smaller values (so that the old code doesn't crash), we can see that it's also 3 times as fast as the recursive version with no tail recursion.
Si on compare les performances avec des valeurs plus petites, on remarque que c'est également 3 fois plus rapide que la version classique sans récursion terminale.
So let's do an exercise on tail recursion.
As mentioned above, the key requirement for tail recursion is that the method calls itself as the last instruction.
Comme mentionné plus haut, il faut que la dernière instruction de la méthode soit l'appel récursif à elle-même.
The interest of tail recursion is mostly to avoid very deep recursive chains.
L'intיret d'une tail recursion est principalement d'יviter des chaines rיcursives très profondes.
In this session we've gotten to know tail recursion as a special case of recursion that corresponds to a loop in an imperative program.
Dans cette section, on a dיcouvert la tail recursion comme un cas spיcial de la rיcursion, qui correspond a une boucle dans un programme impיratif.
What's that? Some languages, more particularly functional languages, have native support for an optimization technique called tail recursion.
Enhanced XSLT 3.0 support - including support for xsl:assert and automatic tail recursion detection for xsl:call-template
Prise en XSLT 3.0, y compris la prise en charge de xsl:assert et de la détection de la récursion terminale automatique pour xsl:call-template
Unfortunately, the C# compiler doesn't support tail recursion, which is a pity, since the CLR supports it. However, all is not lost!
En C#, le compilateur n'implémente malheureusement pas la récursion terminale, ce qui est un peu dommage dans la mesure où le CLR le supporte... Pourtant, tout n'est pas perdu !
I suggest you follow the Wikipedia link above, which is a good starting point to understand tail recursion.
Je vous suggère de suivre le lien Wikipedia ci-dessus, qui est un bon point de départ pour comprendre cette notion.
This method can't be used directly: it returns a Bounce object, and we don't really know what to do with this... To execute it, we use the Trampoline.MakeTrampoline method, which returns a new function on which tail recursion is applied.
Cette méthode n'est pas directement utilisable, puisqu'elle renvoie un objet Bounce dont on ne sait pas trop quoi faire... Pour l'exécuter, on utilise la méthode Trampoline.MakeTrampoline, qui renvoie une nouvelle fonction qui applique la récursion terminale.
This notion being quite new to me, I won't try to give a full course about tail recursion... much smarter people already took care of it!
Le concept étant assez nouveau pour moi, je ne vais pas faire un cours complet sur la récursion terminale... des personnes beaucoup plus compétentes s'en sont déjà chargées !
We now have a method that meets the requirements for tail recursion: the recursive call to Factorial really is the last instruction.
On a donc maintenant une méthode qui remplit les critères pour la récursion terminale : l'appel récursif à Factorial est bien la dernière opération effectuée par la méthode.