Les expressions lambda (λ)

Le lambda-calcul, souvent écrit λ-calcul, fut développé par Alonzo Church , un pionnier de l'informatique théorique avec Alan Turing, John von Neumann et une poignée d'autres qui mériteraient aussi d'être nommés ici. Il s'agit d'une idée à la fois d'une grande simplicité et d'une grande puissance. Avec ce calcul, on peut définir les concepts de calculabilité et de récursivité.

(int x) => x + 1
(x, y) => x * y
Func <int,double>  f2 => x => x * 3.14159;

from c in clients
   where c.Ville == "Montréal"
   select c.Nom

clients.
   Where(c => c.Ville == "Montréal").
   Select(c => c.Nom)

Avec l'avènement d'abstractions aussi fortes que la programmation générique et le polymorphisme, toutefois, il devient possible d'exprimer des λ-expressions à même les outils du langage.

Imaginons par exemple qu'on veuille écrire un programme C++ s'appuyant sur les algorithmes standards et cherchant, par exemple, à trouver le premier élément d'une séquence d'entiers (un tableau, disons).

La solution classique avec une fonction prédicat serait :

bool plus_petit_que_4(int val) {
   return val < 4;
}
#include <iostream>
#include <iterator>
#include <algorithm>
#include <random>
int main() {
   using namespace std;
   // initialiser le générateur de nombres pseudo aléatoires
   random_device rd;
   mt19937 prng { rd() };
   int tab[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
   // mélanger les éléments du tableau
   shuffle(begin(tab), end(tab), prng);
   // afficher le tableau mélangé
   copy(begin(tab), end(tab), ostream_iterator<int>{ cout, " " });
   // trouver et afficher le premier élément respectant la contrainte du prédicat
   cout << '\n' << *find_if(begin(tab), end(tab), plus_petit_que_4) << endl;
}

Cette solution n'est pas très flexible, on le remarquera; une version avec foncteurs serait un sérieux pas en avant :

class PlusPetitQue {
   int seuil;
public:
   PlusPetitQue(int seuil) : seuil{ seuil } {
   }
   bool operator()(int n) const {
      return n < seuil;
   }
};
// ... inclusions et using ...
int main() {
   int tab[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
   random_device rd;
   mt19937 prng { rd() };
   shuffle(begin(tab), end(tab), prng);
   copy(begin(tab), end(tab), ostream_iterator<int>{ cout, " " });
   // trouver et afficher le premier élément respectant la contrainte du prédicat
   cout << endl << *find_if(begin(tab), end(tab), PlusPetitQue{ 4 }) << endl;
}

En effet, cette version a la qualité de permettre de comparer les éléments d'une séquence avec une valeur arbitraire plutôt qu'avec une valeur connue à la compilation. On profite de la capacité qu'a le foncteur (un objet) de conserver un état pour la durée de son existence en lui confiant la borne avec laquelle comparer chaque élément de la séquence. Un gain net de généricité.

Cela dit, cette version peut encore gagner en généricité au prix d'un petit effort supplémentaire, d'un peu d'imagination et en combinant programmation générique et polymorphisme.

Les λ de C++

Avec C++ 11, les λ font leur entrée dans le langage en tant qu'outil à part entière. Une λ est une expression compacte à partir de laquelle le compilateur générera un foncteur.

Par exemple, supposons que nous réduisions le problème de compter les éléments d'une séquence dont la valeur se situe sous un certain seuil à la fonction suivante :

template <class T, class It>
   int compter_sous_seuil(It debut, It fin, const T &seuil) {
      int n = 0;
      for (; debut != fin; ++debut)
         if (*debut < seuil)
            ++n;
      return n;
   }

Pour un vecteur d'entiers v, afficher à la sortie standard les éléments de valeur inférieure à 4 s'exprimerait alors :

cout << compter_sous_seuil(begin(v), end(v), 4);

Une amélioration possible de l'implémentation de la fonction serait de remplacer la répétitive par un appel à std::count_if(). Cela serait possible en passant par un foncteur intermédiaire. Supposons que ce foncteur soit local à la fonction; nous aurions alors :

template <class T, class It>
   int compter_sous_seuil(It debut, It fin, const T &seuil) {
      using std::count_if;
      class PlusPetitQue {
         T seuil;
      public:
         PlusPetitQue(const T &seuil) : seuil{ seuil } {
         }
         bool operator()(const T &val) const {
            return val < seuil;
         }
      };
      return count_if(debut, fin, PlusPetitQue{ seuil });
   }

Cela fonctionnerait, et serait sans doute un peu plus rapide que la version originale de la fonction, mais la quantité de code à rédiger s'est accrue de manière significative. Ceci peut décourager les gens d'utiliser les algorithme standards et les foncteurs, malgré leurs nombreux avantages.

C'est ici que les λ entrent en scène. Examinez le code suivant :

template <class T, class It>
   int compter_sous_seuil(It debut, It fin, const T &seuil) {
      return count_if(debut, fin, [&](const T &val) {
         return val < seuil;
      });
   }

Plus concis, vous en conviendrez. Le code qu'on retrouve va à l'essentiel, et omet presque tous les détails auxquels une implémentation manuelle d'une foncteur aurait dû porter attention. Pourtant, il s'agit de code précisément équivalent en termes de performance à la version reposant sur un foncteur.

Anatomie d'une λ

Une λ a la structure suivante :

• Une liste de captures
• Une liste de paramètres (optionnelle)
• Un type de retour (optionnel), et
• Un bloc de code, correspondant à l'opérateur () du foncteur qui sera généré

Examinons chacun de ces éléments constitutifs, en utilisant à titre d'exemple le λ nommé f. Remarquez le recours au type auto de C++ 11, qui déduit le type d'une variable du type de l'expression servant à l'initialiser. Les λ sont des types presque anonymes : nous ne voulons pas connaître le nom que le compilateur aura utilisé pour chacune d'elles.

auto f = [&](const T &val) {
   //    ^^^
   return val < seuil;
};

auto f = [&](const T &val) {
   //       ^^^^^^^^^^^^^^
   return val < seuil;
};

auto f = [&](const T &val) -> bool {
   //                      ^^^^^^^
   return val < seuil;
};

auto f = [&](const T &val) {                        // <--
   return val < seuil;   // <--
};                       // <--

auto carre(int n) -> long { return n*n; }

long carre(int n) { return n*n; }

Le schéma ci-dessous montre la relation entre les divers éléments d'une λ et du foncteur correspondant. La correspondance, comme vous pouvez le constater, est directe, et le code généré dans chaque cas offre exactement les mêmes performances.

Maiontenant que les λ sont répandues dans la plupart des compilateurs, ce mécanisme est parmi les plus populaires de C++ 11.

Enrichissement avec C++ 14 – λ génériques

L'un des principaux atouts de C++ 14 sur le très innovateur C++ 11 est l'avènement de λ génériques. En effet, s'il est possible depuis C++ 11 d'exprimer par des λ des foncteurs de manière concise, comme :

auto addint = [](int a, int b) {
   return a + b;
};
auto addX = [](X a, X b) {
   return a + b;
};

struct addint {
   auto operator()(int a, int b) const -> decltype(a+b) {
      return a + b;
   }
};	
struct addX {
   auto operator()(X a, X b) const -> decltype(a+b) {
      return a + b;
   }
};

...il devient possible avec C++ 14 d'exprimer une λ générique comme suit :

auto add = [](auto a, auto b) {
   return a + b;
};

struct add {
   template <class T>
      auto operator()(T a, T b) const -> decltype(a+b) {
         return a + b;
      }
};

Ce faisant, la généricité s'adjoint à la simplicité d'écriture. Cette nouvelle façon de programmer change vraiment la pratique de la programmation de manière considérable.

Enrichissement avec C++ 14 – captures plus complètes

Avec C++ 11, les λ pouvaient capturer par valeur (par copie) ou par référence. Depuis C++ 14, il est possible de capturer par mouvement, et il est possible de renommer des variables lors d'une copie. Ce qui suit donne un exemple (académique et d'utilité limitée) ce que qu'il est possible d'exprimer dans un bloc de capture avec les λ maintenant :

#include <memory>
#include <iostream>
using namespace std;
struct X {
   int valeur = 3;
};
int main() {
   int n = 10;
   auto p = make_unique<X>();
   auto f = [p = std::move(p), niter = n, inc = -1]() mutable -> int {
      cout << p->valeur << ' ';
      return niter += inc;
   }();
}

J'ai délibérément limité les actions dans le bloc de capture à une utilisation de nouveaux mécanismes, les autres ayant déjà été expliqués précédemment. Ainsi :

• L'écriture p = move(p) déplace la responsabilité sur le pointé de p dans la fonction appelante vers un autre p local à la λ. Ce passage par mouvement n'était pas possible, du moins sans heurts, avec C++ 11
• L'écriture niter = n copie le n de la fonction appelante vers une variable niter locale à la λ. Cette capacité de « renommer » une variable capturée est une autre innovation de C++ 14. Notez au passage qu'il est possible de donner à une variable dans une λ le même nom que celui d'une variable se situant dans le contexte de son utilisation, comme par exemple [x = y,y = 3]{ return x+y; } qui ferait de x dans la λ une copie de y dans son contexte, et ferait de y dans la λ un attribut d'instance initialisé à la valeur 3
• Enfin, inc = -1 crée et initialise une variable locale à la λ sans que nous n'ayons à en faire une contrepartie locale à la fonction appelante

Cet élargissement des capacités des expressions λ les rend encore plus polyvalentes.

Retourner une λ d'une fonction

Pour retourner une λ d'une fonction, il est d'usage en C++ 11 d'avoir recours à une std::function de signature appropriée, du fait que le type exact d'une λ est inconnu du programme; même si nous savions le type généré par un compilateur donné, ce type ne serait pas garanti pour les autres compilateurs, ou même pour les compilations ultérieures avec un même compilateur. Depuis C++ 14, les fonctions pouvant être de type auto, il est possible de retourner directement une lambda d'une fonction, dans la mesure où certaines règles d'hygiène sont respectées.

Exemples – λ immuables

Notre premier exemple sera celui d'une λ sans paramètres et retournant toujours true, un exemple banal :

std::function<bool()> tautologie() {
   return []{ return true; };
}

auto tautologie() {
   return []{ return true; };
}

Autre exemple simple, basé sur une fermeture : celui d'une λ capable d'ajouter une même quantité à plusieurs valeurs, une à la fois, telle qu'elle pourrait être utilisée dans un std::transform().

std::function<float(float)> ajouter(float montant) {
   return [montant](float x) { return x + montant; };
}

auto ajouter(float montant) {
   return [montant](float x) { return x + montant; };
}

Le recours à une copie dans la capture de la λ est normal ici, du fait que la λ sera retournée par la fonction; si une capture est faite par référence, il faut avoir la certitude que le référé existera encore après la fin de la fonction, ce qui exclut les variables locales. Ainsi, ce qui suit est dangereux et mène à un comportement indéfini :

// ... inclusions et using ...
std::function<int()> vilain(int n) { // un paramètre est une variable locale, à plus forte partie un paramètre passé par valeur
   return [&]() { return n; }; // oups! n a été capturé par référence
} // n décède ici... mais la λ retournée a une référence dessus!
int main() {
  auto f = danger(3);
  cout << f() << endl; // indefini : l'appel utilise une référence au paramètre n, qui est local à vilain
}

On pourrait se demander pourquoi du code aussi dangereux compilerait, mais il se trouve qu'il est parfois tout à fait raisonnable pour une λ de capturer une variable par référence. Par exemple :

// ... inclusions et using ...
template <class It, class T>
   T somme(It debut, It fin) {
      using value_type = typename iterator_traits<It>::value_type;
      T resultat {};
      auto cumul = [&](const value_type &val) {
         resultat += val;
      };
      for_each(debut, fin, cumul);
      return resultat;
}

Évidemment, dans cet exemple, utiliser std::accumulate() aurait été préférable, mais il demeure clair que la capture de resultat par référence est une opération tout à fait légale.

Exemple – λ mutable

Il arrive que retourner une λ mutable soit l'action souhaitée. Par défaut, les variables capturées par valeur dans une λ sont considérées const lors de l'action de l'opérateur (). Par exemple, ceci est illégal :

int i = 3;
auto f = [=]() {
   return i++; // illégal, i est considéré const ici
};

Dans un tel cas, il faut qualifier la λ de mutable. Par exemple :

int i = 3;
auto f = [=]() mutable {
   return i++; // légal
};

Ceci peut par exemple servir à la mise en place d'un générateur de nombres séquentiels :

// ... includes et using ...
template <class T>
   function<T()> generer_sequence(T init) {
      return [cur = init]() mutable { return cur++; }; }
   }
int main() {
   auto gen = generer_sequence(1.5); // gen générera 1.5, 2.5, 3.5, ...
   cout << gen() << endl;
   cout << gen() << endl;
   cout << gen() << endl;
}

Exemple – λ récursive d'une fonction

Pour qu'une λ soit récursive, il faut qu'elle soit nommée et placée dans une std::function ou dans une entité de fonctionnalité équivalente. Par exemple, ceci ne compilera pas :

// ... inclusions et using ...
int main() {
   auto fac = [](int n) {
      return n == 0 || n == 1? 1.0 : n * fac(n-1); // illégal: il faudrait connaître le type de fac ici, et on ne le connaît pas encore (auto ne suffit pas)
   };
   cout << fac(5) << endl;
}

Avec une std::function, tout fonctionne normalement...

// ... inclusions et using ...
int main() {
   function<double(int)> fac = [&](int n) {
      return n == 0 || n == 1? 1.0 : n * fac(n-1); // Ok
   };
   cout << fac(5) << endl;
}

Notez la capture par référence de fac elle-même, qui est nécessaire pour y faire référence, justement, à l'intérieur. Pour ce qui est de retourner une telle λ d'une fonction, par contre, c'est une autre histoire.

// ... inclusions et using ...
function<double(int)> generer_factorielle() {
   function<double(int)> fac = [&](int n) {
      return n == 0 || n == 1 ? 1.0 : n * fac(n-1);
   };
   return fac;
}
int main() {
   auto fac = generer_factorielle();
   cout << fac(5) << endl; // boum! Mais pourquoi?
}

Quel est le problème ici? Simplement, la variable fac dans generer_factorielle() capture une référence sur fac... qui est en fait une variable locale à la fonction generer_factorielle(), donc qui est détruite à la fin de cette fonction. Conséquemment, la variable fac de main() est une copie de la variable fac de generer_factorielle(), et cette copie utilise une référence à une variable qui n'existe plus.

Une solution est d'utiliser une écriture comprenant une λ dans une λ le code suit, après quoi vous trouverez des explications.

// ... inclusions et using ...
function<double(int)> generer_factorielle() {
   function<double(int)> fac = [](int n) {
      function<double(int)> impl = [&](int n) {
         return n == 0 || n == 1 ? 1.0 : n * impl(n-1);
      };
      return impl(n);
   };
   return fac;
}
int main() {
   auto fac = generer_factorielle();
   cout << fac(5) << endl; // et voilà!
}

Ici, la λ externe est placée dans fac, et cette dernière encapsule une λ interne nommée impl. Puisque la λ interne vit dans la λ externe, la référence sur impl dans impl demeure valide pendant une exécution de fac.

Si des états doivent persister pour la λ interne, il est d'usage de les capturer par copie dans la λ externe, quitte à qualifier le λ externe de mutable pour permettre à la λ interne de les manipuler sans problème. Notez que cela inclut tout particulièrement des références sur this dans une méthode d'instance.

Les IIFE – Immediately-Invoked Function Expressions

Supposons qu'un objet doive être initialisé à l'aide de plusieurs opérations, et que cette initialisation soit locale, pas du type que l'on retrouve disséminées un peu partout dans le programme.

class X {
   // ... bla bla ...
};
X fonction_jetable_et_complexe() {
   // ... bla bla ...
}
int main() {
   const X obj = fonction_jetable_et_complexe();
   // ...
}

class X {
   // ... bla bla ...
};
int main() {
   const X obj = []() -> X {
      // ... code jetable et complexe
      // retournant un X correctement
      // initialisé
   }(); // on l'appelle immédiatement!
   // ...
}

La particularité d'une IIFE est d'être anonyme et appelée sur-le-champ. Utiliser cette technique pour initialiser un objet n'est que l'une de ses principales applications.

Exemple concret : ce programme de deux (oui, deux!) instructions initialise la constante contenu avec le contenu du fichier in.txt, puis affiche cette constante :

#include <string>
#include <iostream>
#include <fstream>
#include <iterator>
int main() {
   const auto contenu = [] {
      ifstream in{ "in.txt" };
      string s{ istreambuf_iterator<char>{ in }, istreambuf_iterator<char>{} };
      return s;
   }();
   cout << contenu << endl;
}

Surcharge de λ

auto f = [](int i) {
   return i + 1;
};

La technique en question va comme suit :

• Définir un foncteur – disons overload_set – générique sur la base de deux foncteurs, disons F0 et F1, quelles que soient leurs signatures;
• Dériver overload_set<F0,F1> de F0 et F1 par héritage multiple et public, pour qu'un overload_set<F0,F1> soit à la fois un F0 et un F1;
• Indiquer par des instructions using que overload_set<F0,F1> expose F0::operator() et F1::operator(). À titre de rappel, C++ expose les fonctions par nom, pas par signature. Ceci permet d'utiliser operator() tel que défini par F0 et par F1 directement à partir d'un overload_set<F0,F1>, faisant d'un overload_set<F0,F1> un foncteur combinant les opérateurs () de ses deux parents;
• Une fois cette étape franchie, ne reste plus qu'à utiliser une fonction génératrice (ici : overload(F0,F1)) pour générer un overload_set<F0,F1> à partir de deux expressions λ.

À titre d'exemple :

template <class F0, class F1>
   struct overload_set : F0, F1 {
      overload_set(F0 x0, F1 x1) : F0(x0), F1(x1) {
      }
      using F0::operator();
      using F1::operator();
   };
template <class F0, class F1>
   overload_set<F0,F1> overload(F1 f0, F2 f1) {
      return { f0,f1 };
   }
auto f = overload(
   [](){ return 1; },
   [](int x){ return x+1; }
);
int main() {
   int x = f();
   int y = f(2);
}

Ce faisant, il devient possible de combiner (par composition d'appels à overload()) autant de foncteurs et de λ que souhaité.

template <class ... F>
   struct overload : F ... {
      using F::operator()...;
   };
template <class ... F> overload(F...) -> overload<F...>;
#include <string>
#include <iostream>
using namespace std;
int main() {
   auto f = overload(
      [](int) { cout << "int" << endl; },
      [](char) { cout << "char" << endl; },
      [](double) { cout << "double" << endl; },
      [](auto) { cout << "inconnu" << endl; },
   );
   f(3); // int
   f(string{ "J'aime mon prof" }); // inconnu
}

Lectures complémentaires

Quelques liens pour enrichir le propos.

• Sous C++ 03, Jaakko Järvi a développé une bibliothèque très sophistiquée, Boost Lambda, dont vous pouvez vous inspirer pour faire travailler vos méninges à un niveau d'abstraction des plus divertissants.
• Quelques textes de Matt Might :
  • http://matt.might.net/articles/lambda-style-anonymous-functions-from-c++-templates/
  • http://matt.might.net/articles/self-inlining-anonymous-functions-in-c++/
  • http://matt.might.net/articles/static-closures-in-c-plus-plus/
• Pour un comparatif des λ en divers langages, voir cet article du Code Project, écrit en 2011 par Nishant Sivakumar : http://www.codeproject.com/KB/cpp/LambdasCompared.aspx
• Textes de Scott Meyers :
  • gestion de la qualification const, texte de 2011 : http://cpp-next.com/archive/2011/04/appearing-and-disappearing-consts-in-c/
  • explication des nuances fines entre λ et fermetures, un bref texte de 2013 : http://scottmeyers.blogspot.ca/2013/05/lambdas-vs-closures.html
• Un truc pour traiter une λ munie d'états (avec un bloc de capture non-vide) comme un pointeur de fonction, proposé en 2014 : http://deplinenoise.wordpress.com/2014/02/23/using-c11-capturing-lambdas-w-vanilla-c-api-functions/
• Plusieurs petits problèmes dont la solution est exprimée sous forme de λ, par Sumant Tambe en 2014 et en 2015 :
  • http://cpptruths.blogspot.ca/2014/03/fun-with-lambdas-c14-style-part-1.html
  • http://cpptruths.blogspot.ca/2014/05/fun-with-lambdas-c14-style-part-2.html
  • Des monades avec les λ de C++ 14... C'est fou à quel point ce langage a évolué rapidement au cours des dernières années! http://cpptruths.blogspot.ca/2014/08/fun-with-lambdas-c14-style-part-3.html
  • http://cpptruths.blogspot.ca/2015/06/fun-with-lambdas-c14-style-part-4.html
• Utiliser les λ pour écrire avec C++ 11 du code similaire à celui qu'on retrouve en C# avec Linq, un article de Gaston Hillar en 2014 : http://www.drdobbs.com/cpp/linq-like-list-manipulation-in-c/240166882 (je me suis permis des expérimentations similaires : quelque-chose-comme-linq.html si la curiosité vous prend)
• Quelques textes d'introduction :
  • démystifier les λ de C++, texte de Glennan Carnie en 2014 : http://blog.feabhas.com/2014/03/demystifying-c-lambdas/
  • tour d'horizon des λ de C++ 14, selon Paul Silisteanu en 2014 : https://solarianprogrammer.com/2014/08/28/cpp-14-lambda-tutorial/
  • introduction rapide aux éléments syntaxiques des λ, par Ovidiu Cucu en 2014 : http://codexpert.ro/blog/2014/10/25/c11-lets-write-a-hello-lambda/
  • profiter des λ de C++ 11, texte de Josh Lospinoso en 2015 : https://jlospinoso.github.io/c++/developing/software/visual%20studio/2015/03/11/lambdas-and-cpp11.html
• À propos des IIFE :
  • texte de 2014 par Jason Turner, qui montre comment utiliser des λ de C++ 11 pour réaliser des IIFE : http://blog2.emptycrate.com/content/complex-object-initialization-optimization-iife-c11
  • l'idée des IIFE présentée par Herb Sutter en 2013 : http://herbsutter.com/2013/04/05/complex-initialization-for-a-const-variable/
  • dans ce texte de 2016, Bartlomiej Filipek explique les IIFE dans un contexte d'initialisation complexe : http://www.bfilipek.com/2016/11/iife-for-complex-initialization.html
  • initialisation des IIFE globales et effets de bord, un court article de Paul Dan Silisteanu en 2019 : https://solarianprogrammer.com/2019/10/31/a-happy-halloween-from-cpp/
  • texte de Ben Deane en 2019, qui explore les ramifications de la nouvelle syntaxe permettant de contraindre les types génériques d'une λ à partir de C++ 20 en lien avec les IIFE : http://www.elbeno.com/blog/?p=1645
• En 2014, Paul Fultz II propose une manière d'initialiser une λ de manière statique : http://pfultz2.com/blog/2014/09/02/static-lambda/
• En 2015, Ovidiu Cucu montre comment on peut tirer profit des λ dans une application MFC : http://codexpert.ro/blog/2015/04/30/using-lambdas-in-mfc-applications-part-2-replacing-callback-functions/
• Distinguer λ et fermeture, par Scott Meyers en 2013 : http://scottmeyers.blogspot.ca/2013/05/lambdas-vs-closures.html
• Recommandations de Marco Arena en 2015, portant sur la gestion de this dans le bloc de capture d'une λ : https://marcoarena.wordpress.com/2015/07/30/either-capture-this-or-copy-this/
• Simuler un static_if du langage D à l'aide de λ génériques ou de SFINAE, techniques mises de l'avant par Baptiste Wicht en 2015 : http://baptiste-wicht.com/posts/2015/07/simulate-static_if-with-c11c14.html
• Explication de ce mécanisme, par Arne Mertz en 2015 :
  • http://arne-mertz.de/2015/10/new-c-features-lambdas/
  • http://arne-mertz.de/2015/11/lambdas-part-2-capture-lists-and-stateful-closures/
• « Surcharger une λ », un truc sympathique proposé par Nick Athanasiou en 2015 : https://ngathanasiou.wordpress.com/2015/10/20/lambda-hackery-overloading-sfinae-and-copyrights/
• En 2016, Oscar Forner Martinez décrit les différences entre les λ de C++ 11, C++ 14 et C++ 17 : http://maitesin.github.io//Lambda_comparison/
• Dans ce texte de 2016, Sune Vuorela met en garde contre les autoréférences dangereuses dans les λ : http://pusling.com/blog/?p=446
• En 2016, J propose une technique pour faire semblant de passer une λ munie d'états pour un pointeur de fonction. Notez que je ne suis pas convaincu que sa technique soit exempte de comportement indéfini, alors soyez prévenu(e)s : http://bannalia.blogspot.ca/2016/07/passing-capturing-c-lambda-functions-as.html
• Visiter un variant à l'aide d'une λ, par Vittorio Romeo en 2016 :
  • https://vittorioromeo.info/index/blog/variants_lambdas_part_1.html
  • https://vittorioromeo.info/index/blog/variants_lambdas_part_2.html
  • en 2016, Vittorio Romeo discute d'un article douteux comparant l'utilisabilité des λ... et des itérateurs. Oui, étrange, je sais : https://vittorioromeo.info/index/blog/on_lambda_vs_iterator_paper.html
• En 2016, ce texte d'Adi Shavit décrit la conversion implicite des λ sans états en pointeurs de fonctions comme de la magie : https://adishavit.github.io/2016/magical-captureless-lambdas/
• Dans ce texte de 2016, ce texte d'Adi Shavit explique ce que les blocs de capture collectent sans que l'on ne s'en aperçoive, même si on laisse le bloc de capture vide : https://adishavit.github.io/2016/leaky-closures-captureless-lambdas/
• Présentation sommaire des λ pour celles et ceux qui les rencontrent pour la première fois, proposée par Rajeev Masilamani en 2016 : https://simpletalkaboutcplusplus.wordpress.com/2016/11/27/lambdas-on-the-fly/
• En 2016, Adi Shavit montre comment utiliser une λ à titre de fonction de rappel (de Callback) : https://adishavit.github.io/2016/lambdas-callbacks/
• Quelques trucs amusants à propos des λ, par Adi Shavit en 2016 : https://adishavit.github.io/2016/Technical-Debt/
• Capture d'objets relayés par Perfect Forwarding, un texte de Vittorio Romeo en 2016 : http://vittorioromeo.info/index/blog/capturing_perfectly_forwarded_objects_in_lambdas.html
• En 2017, Björn Fahller recommande les λ pour à la fois clarifier les programmes et accélérer leur exécution : http://playfulprogramming.blogspot.ca/2017/01/generate-lambdas-for-clarity-and.html
• Dans ce texte de 2017, Arne Mertz met en garde contre les abus de λ, qui peuvent selon lui réduire la lisibilité du code : https://arne-mertz.de/2017/02/lambda-overdose/
• Texte de Jonathan Boccara en 2017 à propos des λ et de la lisibilité du code : http://www.fluentcpp.com/2017/01/19/making-code-expressive-lambdas/
• Il est possible d'utiliser une λ pour tricher sur l'amitié d'une classe, comme le montre cet extrait de code
• En 2017, sur la base d'une présentation par Jason Turner, Marek Krj présente une implémentation de fibonacci reposant une λ Stateful : http://ib-krajewski.blogspot.ca/2017/02/advanced-stateful-lambdas.html
• Texte de Majank Jain en 2017 sur les λ :
  • comparatif entre les λ et les foncteurs : https://mayankj08.github.io/2017/07/23/Lambdas-In-C++/
  • discussion des λ qualifiées mutable : https://mayankj08.github.io//2017/08/06/Mutable-Lambdas-In-C++/
• En 2017, Jay Bazuzi montre comment on peut utiliser une λ dans une démarche de refactorisation classique : http://jay.bazuzi.com/Safely-extract-a-method-in-any-C++-code/
• En 2018, Philippe M. Groarke mêle λ et templates variadiques pour faire quelques acrobaties : https://philippegroarke.com/blog/2018/05/19/declarative-functional-apis-a-k-a-abusing-lambda-parameters/
• En 2019, Bartlomiej Filipek explore en détail les λ :
  • https://www.bfilipek.com/2019/02/lambdas-story-part1.html
  • https://www.bfilipek.com/2019/03/lambdas-story-part2.html
• Textes de Raymond Chen :
  • comment le compilateur joint à Visual Studio traite la conversion implicite d'une λ sans états à un pointeur de fonction, dans le respect des conventions d'appel, un texte de Raymond Chen en 2015 : http://blogs.msdn.com/b/oldnewthing/archive/2015/02/20/10594680.aspx
  • gérer la durée de vie de certains objets dans une λ, texte de 2019 : https://devblogs.microsoft.com/oldnewthing/?p=100635
  • combiner les λ et if constexpr pour réaliser une sorte de λ ayant plusieurs types de retour, par Raymond Chen en 2019 : https://devblogs.microsoft.com/oldnewthing/20191107-00/?p=103071
  • alléger le recours aux coroutines avec des λ par Raymond Chen en 2019 : https://devblogs.microsoft.com/oldnewthing/?p=100735
  • en 2019, Raymond Chen recommande de ne pas passer d'expressions λ à des macros... : https://devblogs.microsoft.com/oldnewthing/?p=100705
• Interaction des λ génériques et de SYCL, texte de 2019 par Georgi Mirazchiyski : https://www.codeplay.com/portal/06-11-19-sycl-cpp-generic-interfaces-with-generic-lambdas
• Émuler des λ génériques avec contraintes de types, par insooth(?) : https://github.com/insooth/insooth.github.io/blob/master/templated-generic-lambdas.md