Continuation
98793
30976768
2008-06-24T20:54:19Z
Noky
272042
/* Programmation par continuation */
En informatique, la '''continuation''' d'un système désigne son ''futur'', c'est-à-dire la suite des instructions qu'il lui reste à exécuter à un moment précis. C'est un point de vue pour décrire l'état de la machine.
==Dans les langages de programmation==
===Utilisation explicite===
Dans certains [[langage de programmation|langages de programmation]], les continuations peuvent être manipulées explicitement en tant qu'objets du langage à part entière : on peut stocker la continuation courante dans une [[variable]] que l'on peut donc manipuler en tant que telle ; puis plus loin, on peut restaurer la continuation, ce qui a pour effet de dérouter l'exécution du programme actuel vers le futur que l'on avait enregistré.
En [[C (langage)|C]], l'instruction ''setjmp'' permet de capturer une continuation (en fait, stocker la valeur du [[compteur ordinal]] dans une variable), et l'instruction ''longjmp'' permet de dérouter le programme vers une continuation enregistrée.
En [[programmation fonctionnelle]], une continuation prend la forme d'une fonction qui peut prendre divers arguments (qui influent sur la valeur de retour de l'instruction qui avait "saisi" la continuation courante) et qui n'a pas de valeur de retour (en fait ne finit pas du point de vue de l'appelant, car le programme est dérouté).
''Exemple en [[Scheme]] :''
<source lang="scheme">
(define fonction1
(lambda (k)
(begin (display "Toto")
(k "Titi")
(display "Tata")
)))
(display (call-with-current-continuation fonction1))
</source>
a pour sortie à l'écran :
Toto
Titi
L'instruction « (display "Tata") » a été ignorée.
Explication :
*nous commençons par définir une fonction «fonction1», puis nous demandons d'afficher le résultat («display») de «(call-with-current-continuation fonction1)».
*l'instruction «call-with-current-continuation» a pour effet de capturer la continuation courante (qui est d'afficher la valeur de retour grâce à la commande «display», puis de terminer le programme) et de l'envoyer en argument à la fonction «fonction1»
*or cette fonction est une séquence de trois instructions, dont la deuxième est d'appeler la continuation «k» passée en argument, donc de sortir de la fonction puisque la continuation aura été capturée à l'extérieur.
*après cela, la continuation s'exécute normalement : «display» s'exécute avec la valeur de retour de «(call-with-current-continuation fonction1)», qui avait été fournie en argument de «k», c'est-à-dire "Titi"; puis le programme termine.
===Utilisation implicite : les exceptions===
Cependant l'utilisation la plus courante de la notion de continuation se fait de manière implicite, lorsque l'on manipule les [[système de gestion d'exceptions|exceptions]].
En effet, le bloc d'exception n'est qu'une [[syntaxe|structure syntaxique]] pour dire qu'avant d'exécuter, on a enregistré la continuation courante (sans le bloc) précédée de l'exécution de la routine de traitement d'exception, et que lorsque une exception sera rencontrée pendant exécution du bloc, alors on appellera la continuation correspondante.
''Exemple en [[OCaml]] :''
<source lang="ocaml">
try
50 / 0
with
Division_by_zero -> 42 ;;
</source>
retourne
- : int = 42
Explication : avant d'exécuter cette stupide division, OCaml enregistre la continuation consistant à retourner 42 puis à finir l'exécution dans l'exception «Division_by_zero». Puis OCaml essaye de lancer la division qui résulte en l'appel de cette exception, à laquelle justement on venait d'associer une continuation.
===Programmation par continuation===
En [[programmation fonctionnelle]], la ''programmation par continuation'' désigne une technique de programmation consistant à n'utiliser que de simples appels de fonction qui prennent pour argument leur propre continuation, au lieu d'appeler séquentiellement des fonctions, ou d'exécuter une fonction sur le résultat de la précédente. Ces fonctions se retrouvent en quelque sorte maîtresses de leur destin, et ne se contentent plus de subir le contexte.
Un des enjeux de la programmation par continuation est d'obtenir un programme [[Récursion terminale|récursif terminal]], qui après [[Compilateur|compilation]] et optimisation ne requiert plus d'empiler les appels successifs imbriqués. Ceci se traduit par une moindre consommation de mémoire.
''Exemple : calcul de la factorielle, en [[OCaml]]''
Version «classique» :
<source lang="ocaml">
let rec fact = function
| 0 -> 1
| n -> n*(fact (n - 1));;
</source>
Version par continuation (qui est ''stricto sensu'' récursive terminale, mais pourrait être bien simplifiée pour consommer moins de mémoire, en stockant l'accumulation du résultat plutôt qu'une continuation, qui elle est de plus en plus grosse, ce qui fait qu'on n'a rien gagné sur le plan pratique) :
<source lang="ocaml">
let rec fact k = function
| 0 -> (k 1)
| n -> fact (fun x -> k (n * x)) (n - 1);;
</source>
(Si on veut juste calculer la factorielle de 5 et l'afficher, la syntaxe d'appel serait alors :)
<source lang="ocaml">
print_int (fact 5);;
</source>
dans le premier cas et
<source lang="ocaml">
fact print_int 5
</source>
dans le second.
== En sémantique dénotationnelle ==
Il existe une [[sémantique dénotationnelle]] dite ''par passage de continuation''. Dans cette [[sémantique des langages de programmation|sémantique]], le sens mathématique d'un programme est une fonction qui prend une continuation (celle qui suit son exécution) et rend une continuation (celle qui précède son exécution).
Ainsi, si ''P'' est un programme, alors sa sémantique ''<nowiki>[[P]]</nowiki>'' est de type ''Continuation -> Continuation'', où le type ''Continuation'' est le type ''État -> Observation''.
Et si ''E'' est une expression (programme qui a une valeur dans le langage), ''<nowiki>[[E]]</nowiki>'' est de type ''E_Continuation -> Continuation'', où le type ''E_Continuation'' (ou continuation d'expression) est le type ''Valeur -> Continuation''.
Les continuations permettent de donner un contenu computationnel à la [[logique classique]] dans le cadre de la [[isomorphisme de Curry-Howard|correspondance de Curry-Howard]].
[[Catégorie:Informatique théorique]]
[[Catégorie:Programmation informatique]]
[[Catégorie:Structure de contrôle]]
{{Portail informatique}}
[[cs:Continuation]]
[[de:Continuation]]
[[en:Continuation]]
[[it:Continuazione]]
[[ja:継続]]
[[ru:Продолжение]]
[[uk:Продовження (програмування)]]