Fonction pure

Un article de Wikipédia, l'encyclopédie libre.
Sauter à la navigation Sauter à la recherche

En programmation informatique, une fonction pure est une fonction qui possède les propriétés suivantes[1],[2] :

  1. Sa valeur de retour est la même pour les mêmes arguments (pas de variation avec des variables statiques locales, des variables non locales, des arguments mutables de type référence ou des flux d'entrée).
  2. Son évaluation n'a pas d'effets de bord (pas de mutation de variables statiques locales, de variables non locales, d'arguments mutables de type référence ou de flux d'entrée-sortie).

Une fonction pure est ainsi un analogue informatique d'une fonction mathématique. Certains auteurs, particulièrement de la communauté des langages impératifs[Lesquels ?], utilisent le terme "pure" pour désigner les fonctions qui ont uniquement la propriété 2 du dessus[3].

Exemples[modifier | modifier le code]

Fonctions pures[modifier | modifier le code]

Les fonctions C++ suivantes sont pures :

Fonctions impures[modifier | modifier le code]

Les fonctions C++ suivantes sont impures car elles ne vérifient la propriété 1 ci-dessus :

  • à cause de la variation de la valeur de retour avec une variable non locale
int f() {
  return x;
}
  • à cause de la variation de la valeur de retour avec un argument mutable de type référence
int f(int* x) {
  return *x;
}
  • à cause de la variation de la valeur de retour avec un flux d'entrée
int f() {
  int x = 0;
  std::cin >> x;
  return x;
}

Les fonctions C++ suivantes sont impures car elles ne vérifient la propriété 2 ci-dessus :

  • à cause de la mutation d'une variable statique locale
void f() {
  static int x = 0;
  ++x;
}
  • à cause de la mutation d'une variable non locale
void f() {
  ++x;
}
  • à cause de la mutation d'un argument mutable de type référence
void f(int* x) {
  ++*x;
}
  • à cause de la mutation d'un flux de sortie
void f() {
  std::cout << "Hello, world!" << std::endl;
}

Notes et références[modifier | modifier le code]

  1. (en) Bartosz Milewski, « Basics of Haskell », sur Schoolofhaskell, (consulté le 18 août 2018) : « Here are the fundamental properties of a pure function: 1. A function returns exactly the same result every time it's called with the same set of arguments. In other words a function has no state, nor can it access any external state. Every time you call it, it behaves like a newborn baby with blank memory and no knowledge of the external world. 2. A function has no side effects. Calling a function once is the same as calling it twice and discarding the result of the first call. »
  2. (en) Brian Lonsdorf, « Professor Frisby's Mostly Adequate Guide to Functional Programming », sur GitBook, (consulté le 18 août 2018) : « A pure function is a function that, given the same input, will always return the same output and does not have any observable side effect. »
  3. (en) « GCC 8.1 Manual », sur GCC, the GNU Compiler Collection, (consulté le 18 août 2018)

Voir aussi[modifier | modifier le code]