title: Fermeture (informatique)
text: # Fermeture (informatique)
  
  Dans un langage de programmation, une fermeture ou clôture (en anglais : closure) est une fonction accompagnée de son environnement lexical. L'environnement lexical d'une fonction est l'ensemble des variables non locales qu'elle a capturées, soit par valeur (c'est-à-dire par copie des valeurs des variables), soit par référence (c'est-à-dire par copie des adresses mémoires des variables). Une fermeture est donc créée, entre autres, lorsqu'une fonction est définie dans le corps d'une autre fonction et utilise des paramètres ou des variables locales de cette dernière.
  
  Une fermeture peut être passée en argument d'une fonction dans l'environnement où elle a été créée (passée vers le bas) ou renvoyée comme valeur de retour (passée vers le haut). Dans ce cas, le problème posé alors par la fermeture est qu'elle fait référence à des données qui auraient typiquement été allouées sur la pile d'exécution et libérées à la sortie de l'environnement. Hors optimisations par le compilateur, le problème est généralement résolu par une allocation sur le tas de l'environnement.
  
  ## Exemples
  
  La fonction interne ajoute10 a toujours accès à l'argument nombre, bien que l'appel à la fonction ajouteur soit terminé.
  
  ### ActionScript
  
  En ActionScript :
  
  ### C++
  
  Depuis C++11 :
  
  Avant C++11, le concept de clôture pouvait être implémenté avec des structures :
  
  D'une manière générale, les templates permettent, en plus d'une écriture allégée dans certains cas bien spécifiques, de propager explicitement les constantes, et donc de certifier au compilateur que certains calculs peuvent et doivent être faits dès la compilation sans inquiétude de possibles effets de bord.
  
  Les clôtures peuvent aussi être implémentées à travers des objets de bibliothèques populaires telles que boost. Par exemple boost::function couplé de boost::bind permet d'implémenter une clôture. Des clôtures plus simples peuvent aussi être implémentées à travers boost::lambda.
  
  Le concept de clôture est aussi présent dans la meta-programmation (programmation template), on en trouve beaucoup dans boost::mpl. Ceci s'explique du fait que la programmation en langage template se rapproche du paradigme fonctionnel.
  
  Cependant par définition une clôture peut faire référence à son environnement direct, ici la gestion de ce modèle nécessiterait que l’instruction appelante transmette la portée de son propre environnement, par exemple par un passage de référence ou de pointeurs. Cela complique la syntaxe et rend dangereux leur utilisation en fonction de leur durée de vie. Il existe de telles clôtures dans boost::signals et libsigc++ qui sont capables de savoir quand la structure appelante est supprimée, évitant alors de potentielles violations d'accès.
  
  ### C#
  
  En C# :
  
  ### C, C++, Objective-C
  
  Le principe de fermeture a été introduit par Apple au travers des blocs qui sont une extension non standard du C disponible sur OS X à partir de la version 10.6 « Snow Leopard » et sur iOS à partir de la version 4.0 :
  
  Avec une extension du compilateur gcc, on peut utiliser les fonctions imbriquées pour émuler les closures. Cela fonctionne tant que l'on ne sort pas de la fonction contenante. Le code suivant est donc invalide (la variable nombre n'existe que dans la fonction ajouteur, et sa valeur est perdue après l'appel) :
  
  ### Common Lisp
  
  En Common Lisp :
  
  ### Delphi
  
  En Delphi :
  
  ### Go
  
  En Go :
  
  ### Groovy
  
  En Groovy, une fermeture se débute et se termine par une accolade. La fermeture ajouteur renvoie une fermeture anonyme :
  
  ### Haskell
  
  En Haskell, la curryfication permet de générer des fermetures directement par application partielle des arguments :
  
  Ou encore, étant donné que les opérateurs sont eux-mêmes des fonctions :
  
  ### Java
  
  En Java :
  
  ### JavaScript
  
  En JavaScript :
  
  ### Lua
  
  En Lua :
  
  ### OCaml
  
  En OCaml, la curryfication permet de générer des fermetures directement par application partielle des arguments :
  
  Ou encore, étant donné que les opérateurs sont eux-mêmes des fonctions :
  
  ### Perl
  
  En Perl :
  
  ### PHP
  
  En PHP :
  
  Il est important de noter qu'en PHP, une fonction n'a pas accès aux variables de l'environnement où la fonction est déclarée. Pour ce faire il faut utiliser use($nombre) comme ci-dessus.
  
  ### Powershell
  
  En PowerShell :
  
  ### Python
  
  En Python :
  
  ### Ruby
  
  En Ruby :
  
  ### Rust
  
  En Rust, les fermetures capturent leur environnement en utilisant pour chaque variable le niveau de privilège le plus bas possible : par référence immuable, par référence mutable, ou enfin par valeur. Chaque fermeture possède un unique type anonyme. On décrit leur type générique à l'aide des traits (interfaces) Fn, FnMut et FnOnce selon que la fermeture prenne la capture par référence immuable, mutable ou par valeur respectivement.
  
  Le mot-clé move permet de forcer la capture par valeur, par exemple lorsque la durée de vie de la fermeture risque d'excéder celle des variables. C'est le cas ici puisque nombre est alloué sur la pile.
  
  On peut utiliser un type de retour générique (typage et surcharge statique et fermeture allouée sur la pile par défaut) :
  
  ### Scala
  
  En Scala :
  
  ### Scheme
  
  Le concept de fermeture a été précisé dans l'article de Sussman et Steele de 1975 cité dans l'introduction, qui a présidé à la naissance du langage Scheme. Contrairement à celles de Lisp (qui implémente les fermetures en 1978 dans les machines Lisp du MIT en MacLisp), les fonctions sont en Scheme des valeurs de première classe.
  
  ### Smalltalk
  
  En Smalltalk :
  
  ### Swift
  
  En Swift :
  
  ### CoffeeScript
  
  En CoffeeScript :
  
  ### WLangage
  
  En WLangage :
  
  