Recursion terminale

Récursion terminale

En informatique, la récursion terminale (aussi appelée récursion finale) est un cas particulier de récursivité où l'appel récursif est la dernière instruction de la fonction récursive.

Transformation en itération

Lors de la compilation, la récursion terminale peut être transformée en itération.

La récursion terminale est utilisée principalement dans les langages de programmation fonctionnels pour exprimer un processus itératif dans une forme fonctionnelle récursive. Les langages de programmation fonctionnels peuvent généralement détecter la récursion terminale et optimiser son exécution en transformant la récursion en itération, économisant ainsi l'espace de la pile d'exécution, comme décrit ci-dessous.

Exemple

Prenons ce programme Scheme comme exemple :

(define (factorielle n)
  (define (iterer n acc)
    (if (<= n 1)
        acc
        (iterer (- n 1) (* acc n))))
  (iterer n 1))

On observe que la fonction iterer s'appelle elle-même à la fin de sa définition. Cela permet à l'interpréteur ou au compilateur de réorganiser l'exécution, qui sans cela ressemblerait à ceci :

call factorielle (3)

call iterer (3 1)
 call iterer (2 3)
  call iterer (1 6)
   call iterer (0 6)
   retourne 6
  retourne 6
 retourne 6
retourne 6

retourne 6

après réorganisation :

call factorielle (3)

remplace les arguments avec (3 1), jump into « iterer »
remplace les arguments avec (2 3), re-iterer
remplace les arguments avec (1 6), re-iterer
remplace les arguments avec (0 6), re-iterer
retourne 6

(l'espace consommé sur la pile d'exécution est proportionnel à l'indentation)

Avantages

Cette réorganisation économise de l'espace car aucun état, sauf l'adresse de la fonction appelante, n'a besoin d'être sauvé sur la pile ou sur le tas. Cela signifie également que le programmeur n'a pas à craindre l'épuisement de l'espace de pile ou du tas pour des récursions très profondes.

Certains programmeurs utilisant des langages fonctionnels réécrivent du code récursif enveloppé de façon à tirer parti de cette caractéristique. Cela requiert souvent l'utilisation d'un accumulateur (acc dans l'implémentation ci-dessus de factorielle), comme argument de la fonction en récursion terminale. Dans certains cas (comme pour le filtrage de listes) et dans certains langages, la récursion terminale nécessite de réécrire une fonction dans un style non-fonctionnel : c'est-à-dire une fonction qui altère le contenu de variables passées en argument par référence.

Certains compilateurs utilisent une technique de réécriture de programme en « Continuation Passing Style » qui automatise la transformation d'une récursion enveloppée en récursion terminale. Associée à l'élimination d'appel terminal, cette technique permet d'optimiser le code produit pour des langages fonctionnels.

Pour finir, voici une version enveloppée de factorielle :

(define (factorielle n)
  (cond ((= n 0) 1)
        (else (* n (factorielle (- n 1))))))

Le résultat de l'appel récursif (factorielle (- n 1)) est utilisé par la fonction *, qui constitue ici l'enveloppe. À cause de cela, le résultat de (factorielle (- n 1)) doit être empilé pour être utilisé par *. On ne peut économiser d'espace de pile.

Source

L'article de Guy Steele : ftp://publications.ai.mit.edu/ai-publications/0-499/AIM-443.ps

Ce document provient de « R%C3%A9cursion terminale ».