{"id":468,"date":"2021-11-02T14:56:25","date_gmt":"2021-11-02T14:56:25","guid":{"rendered":"https:\/\/www.louismarchand.me\/?page_id=468"},"modified":"2022-11-02T14:54:47","modified_gmt":"2022-11-02T14:54:47","slug":"objet-2-les-fonctions-lambda","status":"publish","type":"page","link":"https:\/\/www.louismarchand.me\/index.php\/objet-2-les-fonctions-lambda\/","title":{"rendered":"Les fonctions lambda"},"content":{"rendered":"

Introduction<\/h2>\n

En programmation, l’utilisation de variable est un \u00e9l\u00e9ment extr\u00eamement important, autant pour stocker des donn\u00e9es que pour les partager entre les diff\u00e9rentes instances de votre syst\u00e8me. En effet, s’il n’y avait pas de variables, nous ne pourrions pas transf\u00e9rer des valeurs d’un objet \u00e0 un autre en utilisant les assignateurs (\u00ab\u00a0setters\u00a0\u00bb), les constructeurs ou m\u00eame des variables globales. Ces variables peuvent contenir toute sorte de valeurs: des entiers, des conteneurs, des pointeurs, des cha\u00eenes de caract\u00e8res, des objets haut niveau (clients, produits, formes, etc.)<\/p>\n

Les fonctions lambda est un principe permettant de stocker une routine (ou une m\u00e9thode dans un contexte objet) dans une variable. De la m\u00eame mani\u00e8re qu’une variable contenant toute sorte de valeurs permet de partager ces valeurs d’une instance du syst\u00e8me \u00e0 une autre, une fonction lambda permet \u00e9galement de partager une routine d’une instance \u00e0 une autre. Cette m\u00e9canique est donc tr\u00e8s int\u00e9ressante pour cr\u00e9er des structures d’\u00e9v\u00e9nement, tout en gardant un faible couplage entre les diff\u00e9rents \u00e9l\u00e9ments du syst\u00e8me (par exemple, entre les classes en langage-objet par classes).<\/p>\n

Cette m\u00e9canique, bas\u00e9e sur la th\u00e9orie math\u00e9matique \u00ab\u00a0Lambda Calcul\u00a0\u00bb, a \u00e9t\u00e9 cr\u00e9\u00e9e initialement par les langages fonctionnels. Il s’agit en fait d’un \u00e9l\u00e9ment primordial des langages comme Lisp, Haskell, OCaml, Scheme ou m\u00eame JavaScript. Si vous avez d\u00e9j\u00e0 utilis\u00e9 JQuery avec Javascript, vous avez certainement d\u00e9j\u00e0 fait du code similaire \u00e0 ceci:<\/p>\n

\n
mon_bouton.<\/span>click<\/span>(<\/span>function<\/span> ()<\/span> {<\/span>\r\n  alert<\/span>(<\/span>\"Bonjour tout le monde!\"<\/span>);<\/span>\r\n});<\/span>\r\n<\/pre>\n<\/div>\n
On voit ici qu’on lance la m\u00e9thode .click(...)<\/code> de la variable mon_bouton<\/code> (m\u00e9thode qui indique \u00e0 Javascript quel code il devra lancer lorsque l’utilisateur clique sur le bouton). Le bout de code qui nous int\u00e9resse ici, c’est l’argument qui est envoy\u00e9 \u00e0 cette m\u00e9thode click<\/code>:<\/p>\n
\n
function<\/span> ()<\/span> {<\/span>\r\n  alert<\/span>(<\/span>\"Bonjour tout le monde!\"<\/span>);<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
On voit ici que ce qui est envoy\u00e9 comme valeur d’argument \u00e0 la m\u00e9thode .click(...)<\/code> est… une fonction en tant que telle. La m\u00e9thode .click(...)<\/code> pourra stocker la fonction dans une variable accessible \u00e0 l’int\u00e9rieur du bouton et ce dernier pourra lancer la fonction lorsque l’utilisateur appuiera sur ce bouton. On voit qu’on peut donc cr\u00e9er une structure d’\u00e9v\u00e9nement (lancer une certaine routine lorsque l’utilisateur clique sur un bouton), sans avoir \u00e0 utiliser de m\u00e9canique de \u00ab\u00a0Listener\u00a0\u00bb comme utilis\u00e9 en Java.<\/p>\n
Ce qui est int\u00e9ressant avec cette m\u00e9canique, c’est qu’elle permet \u00e0 la classe bouton de lancer une m\u00e9thode d’une autre classe sans avoir de d\u00e9pendance. En d’autres mots, si on a le diagramme suivant:<\/p>\n
\"\"<\/p>\n
On a que le contr\u00f4leur connait le bouton (il a une d\u00e9pendance), mais le bouton ne connait pas le contr\u00f4leur (il est ind\u00e9pendant). Par contre, malgr\u00e9 cette ind\u00e9pendance, le bouton peut tout de m\u00eame lancer une m\u00e9thode du contr\u00f4leur. C’est le contr\u00f4leur qui doit ajouter sa m\u00e9thode dans le bouton en utilisant la m\u00e9thode \u00ab\u00a0click\u00a0\u00bb. Le bouton contient, dans une variable, la m\u00e9thode \u00e0 lancer, mais sans savoir dans quelle classe cette m\u00e9thode se trouve.<\/p>\n
Cette m\u00e9canique nous permet d’avoir les m\u00eames avantages que le patron conceptuel Observeur ou que les Listener, sans avoir les inconv\u00e9nients. En effet, aucune interface (ou classe abstraite) n’est n\u00e9cessaire et on peut utiliser n’importe quelle m\u00e9thode, peu importe le nom qu’on lui donne (contrairement aux Listeners ou aux Observeurs qui imposent le nom des m\u00e9thodes lanc\u00e9s).<\/p>\n
Les Agents en Eiffel<\/h2>\n
Dans le langage Eiffel, le lambda calcul est impl\u00e9ment\u00e9 en utilisant le mot cl\u00e9 \u00ab\u00a0agent\u00a0\u00bb. Un \u00ab\u00a0agent\u00a0\u00bb permet de prendre une m\u00e9thode et de la transformer en objet, permettant ainsi de l’utiliser comme valeur dans une variable (ou attribut, argument, etc.) L’objet cr\u00e9\u00e9e est d’un type descendant de ROUTINE<\/code>. Une ROUTINE<\/code> peut \u00eatre autant de types FUNCTION<\/code> ou PROCEDURE<\/code> (ou PREDICATE<\/code>, mais nous ne toucherons pas \u00e0 cette classe dans ce cours). Je rappelle qu’une fonction est une routine qui retourne une valeur et une proc\u00e9dure est une routine qui ne retourne pas de valeur.<\/p>\n
\"\"<\/p>\n
Les fonctions<\/h3>\n
Initialement, nous cr\u00e9ons une m\u00e9thode de mani\u00e8re conventionnelle. Par exemple, voici une m\u00e9thode qui fait une addition de deux nombres et qui retourne la somme:<\/p>\n
\n
addition<\/span>(<\/span>a<\/span>,<\/span> b<\/span>:<\/span>INTEGER<\/span>):<\/span>INTEGER<\/span>\r\n\tdo<\/span>\r\n\t\tResult<\/span> :=<\/span> a<\/span> +<\/span> b<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
Il est important de comprendre que ce n’est qu’un exemple pour vous faire comprendre la m\u00e9canique des \u00ab\u00a0agents\u00a0\u00bb. Voici maintenant la cr\u00e9ation d’une variable de type FUNCTION<\/code> en utilisant un \u00ab\u00a0agent\u00a0\u00bb:<\/p>\n
\n
make<\/span>\r\n\tlocal<\/span>\r\n\t\tl_addition<\/span>:<\/span>FUNCTION<\/span>[<\/span>TUPLE<\/span>[<\/span>a<\/span>,<\/span> b<\/span>:<\/span>INTEGER<\/span>]<\/span>,<\/span> INTEGER<\/span>]<\/span>\r\n\tdo<\/span>\r\n\t\tl_addition<\/span> :=<\/span> agent<\/span> addition<\/span>\r\n\t\tprint<\/span>(<\/span>\"Le resultat: \"<\/span> +<\/span> l_addition<\/span>.<\/span>item<\/span>(<\/span>3<\/span>,<\/span> 5<\/span>).<\/span>out<\/span> +<\/span> \"%N\"<\/span>)<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
Ce code affichera le r\u00e9sultat suivant:<\/p>\n
Le resultat: 8<\/pre>\n
Sachez \u00e9galement que dans les derni\u00e8res versions d’EiffelStudio, il est possible d’utiliser la variable, comme s’il s’agissait d’une m\u00e9thode en soi. C’est-\u00e0-dire que nous pouvons \u00e9viter d’utiliser le \u00ab\u00a0item\u00a0\u00bb. Par exemple:<\/p>\n
\n
make<\/span>\r\n\tlocal<\/span>\r\n\t\tl_addition<\/span>:<\/span>FUNCTION<\/span>[<\/span>TUPLE<\/span>[<\/span>a<\/span>,<\/span> b<\/span>:<\/span>INTEGER<\/span>]<\/span>,<\/span> INTEGER<\/span>]<\/span>\r\n\tdo<\/span>\r\n\t\tl_addition<\/span> :=<\/span> agent<\/span> addition<\/span>\r\n\t\tprint<\/span>(<\/span>\"Le resultat: \"<\/span> +<\/span> l_addition<\/span>(<\/span>3<\/span>,<\/span> 5<\/span>).<\/span>out<\/span> +<\/span> \"%N\"<\/span>)<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
donnera \u00e9galement le r\u00e9sultat:<\/p>\n
Le resultat: 8<\/pre>\n
Il est \u00e9galement possible de \u00ab\u00a0pr\u00e9-assigner\u00a0\u00bb des arguments lors de la cr\u00e9ation de l’agent. Pour ce faire, nous ajoutons directement les arguments \u00ab\u00a0pr\u00e9-assign\u00e9s\u00a0\u00bb dans la cr\u00e9ation de l’agent et nous laissons les autres arguments en utilisant le caract\u00e8re \u00ab\u00a0?\u00a0\u00bb. Par exemple:<\/p>\n
\n
make<\/span>\r\n\tlocal<\/span>\r\n\t\tl_incrementation<\/span>:<\/span>FUNCTION<\/span>[<\/span>TUPLE<\/span>[<\/span>valeur<\/span>:<\/span>INTEGER<\/span>]<\/span>,<\/span> INTEGER<\/span>]<\/span>\r\n\tdo<\/span>\r\n\t\tl_incrementation<\/span> :=<\/span> agent<\/span> addition<\/span>(<\/span>?<\/span>,<\/span> 1<\/span>)<\/span>\r\n\t\tprint<\/span>(<\/span>\"Le resultat: \"<\/span> +<\/span> l_incrementation<\/span>(<\/span>8<\/span>).<\/span>out<\/span> +<\/span> \"%N\"<\/span>)<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
Le code donnera le r\u00e9sultat suivant:<\/p>\n
Le resultat: 9<\/pre>\n
Dans le cas o\u00f9 il n’y a pas d’argument \u00e0 la FUNCTION<\/code>, on doit utiliser .item([])<\/code> (ou sans le \u00ab\u00a0.item\u00a0\u00bb) pour lancer l’ex\u00e9cuter. Par exemple:<\/p>\n
\n
make<\/span>\r\n\tlocal<\/span>\r\n\t\tl_5<\/span>:<\/span>FUNCTION<\/span>[<\/span>TUPLE<\/span>,<\/span> INTEGER<\/span>]<\/span>\r\n\tdo<\/span>\r\n\t\tl_5<\/span> :=<\/span> agent<\/span> addition<\/span>(<\/span>3<\/span>,<\/span> 2<\/span>)<\/span>\r\n\t\tprint<\/span>(<\/span>\"Le resultat: \"<\/span> +<\/span> l_5<\/span>.<\/span>item<\/span>(<\/span>[]<\/span>).<\/span>out<\/span> +<\/span> \"%N\"<\/span>)<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
ou<\/p>\n
\n
make<\/span>\r\n\tlocal<\/span>\r\n\t\tl_5<\/span>:<\/span>FUNCTION<\/span>[<\/span>TUPLE<\/span>,<\/span> INTEGER<\/span>]<\/span>\r\n\tdo<\/span>\r\n\t\tl_5<\/span> :=<\/span> agent<\/span> addition<\/span>(<\/span>3<\/span>,<\/span> 2<\/span>)<\/span>\r\n\t\tprint<\/span>(<\/span>\"Le resultat: \"<\/span> +<\/span> l_5<\/span>(<\/span>[]<\/span>).<\/span>out<\/span> +<\/span> \"%N\"<\/span>)<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
Dans les deux cas, nous obtenons le r\u00e9sultat:<\/p>\n
Le resultat: 5<\/pre>\n
Les proc\u00e9dures<\/h3>\n
L’utilisation d’une proc\u00e9dure se fait de la m\u00eame mani\u00e8re, mais en utilisant \u00ab\u00a0.call\u00a0\u00bb au lieu de \u00ab\u00a0.item\u00a0\u00bb et sans valeur de retour.<\/p>\n
Par exemple, voici une m\u00e9thode standard que nous utiliserons dans notre exemple:<\/p>\n
\n
afficher_addition<\/span>(<\/span>a<\/span>,<\/span> b<\/span>:<\/span>INTEGER<\/span>)<\/span>\r\n\tdo<\/span>\r\n\t\tprint<\/span>(<\/span>\"La somme est: \"<\/span> +<\/span> (<\/span>a<\/span> +<\/span> b<\/span>).<\/span>out<\/span> +<\/span> \"%N\"<\/span>)<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
Voici comment on utilise la proc\u00e9dure sous la forme d’agent:<\/p>\n
\n
make<\/span>\r\n\tlocal<\/span>\r\n\t\tl_afficher<\/span>:<\/span>PROCEDURE<\/span>[<\/span>TUPLE<\/span>[<\/span>a<\/span>,<\/span> b<\/span>:<\/span>INTEGER<\/span>]]<\/span>\r\n\tdo<\/span>\r\n\t\tl_afficher<\/span> :=<\/span> agent<\/span> afficher_addition<\/span>\r\n\t\tl_afficher<\/span>.<\/span>call<\/span>(<\/span>3<\/span>,<\/span> 5<\/span>)<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
Le r\u00e9sultat du code est:<\/p>\n
La somme est: 8<\/pre>\n
On peut \u00e9galement lancer l’agent sans utiliser le \u00ab\u00a0.call\u00a0\u00bb. Par exemple:<\/p>\n
\n
make<\/span>\r\n\tlocal<\/span>\r\n\t\tl_afficher<\/span>:<\/span>PROCEDURE<\/span>[<\/span>TUPLE<\/span>[<\/span>a<\/span>,<\/span> b<\/span>:<\/span>INTEGER<\/span>]]<\/span>\r\n\tdo<\/span>\r\n\t\tl_afficher<\/span> :=<\/span> agent<\/span> afficher_addition<\/span>\r\n\t\tl_afficher<\/span>(<\/span>3<\/span>,<\/span> 5<\/span>)<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
De la m\u00eame mani\u00e8re que pour les fonctions, il y a la possibilit\u00e9 de \u00ab\u00a0pr\u00e9-assigner\u00a0\u00bb des arguments en utilisant le caract\u00e8re \u00ab\u00a0?\u00a0\u00bb lors de la cr\u00e9ation de l’agent:<\/p>\n
\n
make<\/span>\r\n\tlocal<\/span>\r\n\t\tl_afficher<\/span>:<\/span>PROCEDURE<\/span>[<\/span>TUPLE<\/span>[<\/span>valeur<\/span>:<\/span>INTEGER<\/span>]]<\/span>\r\n\tdo<\/span>\r\n\t\tl_afficher<\/span> :=<\/span> agent<\/span> afficher_addition<\/span>(<\/span>1<\/span>,<\/span> ?<\/span>)<\/span>\r\n\t\tl_afficher<\/span>(<\/span>8<\/span>)<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
Le r\u00e9sultat de ce code est:<\/p>\n
La somme est: 9<\/pre>\n
Finalement, toujours de mani\u00e8re similaire au fonction, lorsque nous lan\u00e7ons une proc\u00e9dure sous la forme d’agent sans argument, il faut utiliser \u00ab\u00a0.call([])\u00a0\u00bb (avec ou sans le \u00ab\u00a0.call\u00a0\u00bb). Par exemple:<\/p>\n
\n
make<\/span>\r\n\tlocal<\/span>\r\n\t\tl_afficher<\/span>:<\/span>PROCEDURE<\/span>[<\/span>TUPLE<\/span>]<\/span>\r\n\tdo<\/span>\r\n\t\tl_afficher<\/span> :=<\/span> agent<\/span> afficher_addition<\/span>(<\/span>2<\/span>,<\/span> 3<\/span>)<\/span>\r\n\t\tl_afficher<\/span>.<\/span>call<\/span>(<\/span>[]<\/span>)<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
ou:<\/p>\n
\n
make<\/span>\r\n\tlocal<\/span>\r\n\t\tl_afficher<\/span>:<\/span>PROCEDURE<\/span>[<\/span>TUPLE<\/span>]<\/span>\r\n\tdo<\/span>\r\n\t\tl_afficher<\/span> :=<\/span> agent<\/span> afficher_addition<\/span>(<\/span>2<\/span>,<\/span> 3<\/span>)<\/span>\r\n\t\tl_afficher<\/span>(<\/span>[]<\/span>)<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
Les agents en ligne<\/h3>\n
Il est possible de sp\u00e9cifier directement le code qu’ex\u00e9cutera un agent dans la d\u00e9finition de l’agent. Voici un exemple avec une fonction:<\/p>\n
\n
make<\/span>\r\n\tlocal<\/span>\r\n\t\tl_addition<\/span>:<\/span>FUNCTION<\/span>[<\/span>TUPLE<\/span>[<\/span>a<\/span>,<\/span> b<\/span>:<\/span>INTEGER<\/span>]<\/span>,<\/span> INTEGER<\/span>]<\/span>\r\n\tdo<\/span>\r\n\t\tl_addition<\/span> :=<\/span> agent<\/span> (<\/span>a<\/span>,<\/span> b<\/span>:<\/span>INTEGER<\/span>):<\/span>INTEGER<\/span>\r\n\t\t\t\t\t\tdo<\/span>\r\n\t\t\t\t\t\t\tResult<\/span> :=<\/span> a<\/span> +<\/span> b<\/span>\r\n\t\t\t\t\t\tend<\/span>\r\n\t\tprint<\/span>(<\/span>\"Le resultat: \"<\/span> +<\/span> l_addition<\/span>(<\/span>3<\/span>,<\/span> 5<\/span>).<\/span>out<\/span> +<\/span> \"%N\"<\/span>)<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
Le r\u00e9sultat donne:<\/p>\n
Le resultat: 8<\/pre>\n
Et un autre exemple avec une proc\u00e9dure:<\/p>\n
\n
make<\/span>\r\n\tlocal<\/span>\r\n\t\tl_addition<\/span>:<\/span>PROCEDURE<\/span>[<\/span>TUPLE<\/span>[<\/span>a<\/span>,<\/span> b<\/span>:<\/span>INTEGER<\/span>]]<\/span>\r\n\tdo<\/span>\r\n\t\tl_addition<\/span> :=<\/span> agent<\/span> (<\/span>a<\/span>,<\/span> b<\/span>:<\/span>INTEGER<\/span>)<\/span>\r\n\t\t\t\t\t\tdo<\/span>\r\n\t\t\t\t\t\t\tprint<\/span>(<\/span>\"La somme est: \"<\/span> +<\/span> (<\/span>a<\/span> +<\/span> b<\/span>).<\/span>out<\/span> +<\/span> \"%N\"<\/span>)<\/span>\r\n\t\t\t\t\t\tend<\/span>\r\n\t\tl_addition<\/span>(<\/span>3<\/span>,<\/span> 5<\/span>)<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
Qui donne le r\u00e9sultat:<\/p>\n
La somme est: 8<\/pre>\n
Les agents de classes<\/h3>\n
Il est possible de cr\u00e9er un \u00ab\u00a0agent\u00a0\u00bb \u00e0 partir d’une m\u00e9thode de classe. Le premier argument de cette m\u00e9thode est un argument du type de la classe qui contenait la m\u00e9thode \u00e0 l’origine.<\/p>\n
Par exemple, avec une proc\u00e9dure:<\/p>\n
\n
make<\/span>\r\n\t\t-- Ex\u00e9cute l'application<\/span>\r\n\tlocal<\/span>\r\n\t\tl_to_upper<\/span>:<\/span>PROCEDURE<\/span>[<\/span>TUPLE<\/span>[<\/span>STRING<\/span>]]<\/span>\r\n\t\tl_texte<\/span>:<\/span>STRING<\/span>\r\n\tdo<\/span>\r\n\t\tl_to_upper<\/span> :=<\/span> agent<\/span> {<\/span>STRING<\/span>}.<\/span>to_upper<\/span>\r\n\t\tl_texte<\/span> :=<\/span> \"Un Texte\"<\/span>\r\n\t\tl_to_upper<\/span>(<\/span>l_texte<\/span>)<\/span>\r\n\t\tprint<\/span>(<\/span>l_texte<\/span> +<\/span> \"%N\"<\/span>)<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
Ce code donne le r\u00e9sultat:<\/p>\n
UN TEXTE<\/pre>\n
Ensuite, avec une fonction:<\/p>\n
\n
make<\/span>\r\n\t\t-- Ex\u00e9cute l'application<\/span>\r\n\tlocal<\/span>\r\n\t\tl_head<\/span>:<\/span>FUNCTION<\/span>[<\/span>TUPLE<\/span>[<\/span>STRING<\/span>,<\/span> INTEGER<\/span>]<\/span>,<\/span> STRING<\/span>]<\/span>\r\n\tdo<\/span>\r\n\t\tl_head<\/span> :=<\/span> agent<\/span> {<\/span>STRING<\/span>}.<\/span>head<\/span>\r\n\t\tprint<\/span>(<\/span>\"Les 4 premiers caracteres: \"<\/span> +<\/span>\r\n\t\t\t\tl_head<\/span>(<\/span>\"Bonjour tout le monde\"<\/span>,<\/span> 4<\/span>)<\/span> +<\/span> \"%N\"<\/span>)<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
Ce code donne le r\u00e9sultat:<\/p>\n
Les 4 premiers caracteres: Bonj<\/pre>\n
Les m\u00e9thodes d’action de boucle<\/h3>\n
Il est tr\u00e8s int\u00e9ressant d’utiliser les agents dans un contexte de boucle, car \u00e7a permet d’encapsuler la boucle \u00e0 l’int\u00e9rieur de la classe de liste. En d’autres mots, au lieu de faire la boucle nous-m\u00eames, dans notre programme, on indique \u00e0 la liste l’action qu’on veut ex\u00e9cuter et la liste s’occupe d’ex\u00e9cuter la boucle.<\/p>\n
Il existe 3 m\u00e9thodes d’action dans la classe LIST:<\/p>\n
    \n
  • \n
      \n
    • do_all: Permets d’ex\u00e9cuter un agent pour chaque \u00e9l\u00e9ment de la liste;<\/li>\n
    • for_all: Test avec une fonction bool\u00e9enne (sous forme d’agent) que tous les \u00e9l\u00e9ments retournent Vrai;<\/li>\n
    • do_if: Pour tous les \u00e9l\u00e9ments de la liste, ex\u00e9cute un agent sur un \u00e9l\u00e9ment de la liste, seulement si un test avec une fonction bool\u00e9enne (sous forme d’agent) retourne Vrai.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
      Voici des exemples d’utilisation des m\u00e9thodes d’action de liste:<\/p>\n
      \n
      make<\/span>\r\n\tlocal<\/span>\r\n\t\tl_liste<\/span>:<\/span>ARRAYED_LIST<\/span>[<\/span>STRING<\/span>]<\/span>\r\n\tdo<\/span>\r\n\t\tcreate<\/span> l_liste<\/span>.<\/span>make<\/span> (<\/span>5<\/span>)<\/span>\r\n\t\tl_liste<\/span>.<\/span>extend<\/span> (<\/span>\"Ligne 1\"<\/span>)<\/span>\r\n\t\tl_liste<\/span>.<\/span>extend<\/span> (<\/span>\"Ligne 2\"<\/span>)<\/span>\r\n\t\tl_liste<\/span>.<\/span>extend<\/span> (<\/span>\"Ligne 3\"<\/span>)<\/span>\r\n\t\tl_liste<\/span>.<\/span>extend<\/span> (<\/span>\"Ligne 4\"<\/span>)<\/span>\r\n\t\tl_liste<\/span>.<\/span>extend<\/span> (<\/span>\"Ligne 5\"<\/span>)<\/span>\r\n\t\tl_liste<\/span>.<\/span>do_all<\/span> (<\/span>agent<\/span> (<\/span>l_string<\/span>:<\/span>STRING<\/span>)<\/span>\r\n\t\t\t\t\t\tdo<\/span>\r\n\t\t\t\t\t\t\tprint<\/span>(<\/span>l_string<\/span> +<\/span> \"%N\"<\/span>)<\/span>\r\n\t\t\t\t\t\tend<\/span>)<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
      Ce code donne le r\u00e9sultat suivant:<\/p>\n
      Ligne 1\r\nLigne 2\r\nLigne 3\r\nLigne 4\r\nLigne 5<\/pre>\n
      Un autre exemple qui permet rapidement de valider les entr\u00e9es des utilisateurs:<\/p>\n
      \n
      make<\/span>\r\n\t\t-- Ex\u00e9cute l'application<\/span>\r\n\tlocal<\/span>\r\n\t\tl_liste<\/span>:<\/span>ARRAYED_LIST<\/span>[<\/span>STRING<\/span>]<\/span>\r\n\tdo<\/span>\r\n\t\tcreate<\/span> l_liste<\/span>.<\/span>make<\/span> (<\/span>5<\/span>)<\/span>\r\n\t\tl_liste<\/span>.<\/span>extend<\/span> (<\/span>\"1\"<\/span>)<\/span>\t-- Simule l'entr\u00e9e de donn\u00e9es<\/span>\r\n\t\tl_liste<\/span>.<\/span>extend<\/span> (<\/span>\"Allo\"<\/span>)<\/span>\t-- par l'utilisateur<\/span>\r\n\t\tl_liste<\/span>.<\/span>extend<\/span> (<\/span>\"2\"<\/span>)<\/span>\r\n\t\tl_liste<\/span>.<\/span>extend<\/span> (<\/span>\"3\"<\/span>)<\/span>\r\n\t\tl_liste<\/span>.<\/span>extend<\/span> (<\/span>\"Bonjour\"<\/span>)<\/span>\r\n\t\texecuter_programme<\/span>(<\/span>l_liste<\/span>)<\/span>\r\n\tend<\/span>\r\n\r\nexecuter_programme<\/span>(<\/span>a_liste<\/span>:<\/span>LIST<\/span>[<\/span>STRING<\/span>]<\/span>)<\/span>\r\n\t\t-- Lance le programme seulement si tous les \u00e9l\u00e9ments sont entiers<\/span>\r\n\tdo<\/span>\r\n\t\tif<\/span> a_liste<\/span>.<\/span>for_all<\/span> (<\/span>agent<\/span> {<\/span>STRING<\/span>}.<\/span>is_integer<\/span>)<\/span> then<\/span>\r\n\t\t\t-- Tous les \u00e9l\u00e9ments sont des entiers valides. Proc\u00e9dons<\/span>\r\n\t\telse<\/span>\r\n\t\t\ta_liste<\/span>.<\/span>do_if<\/span> (<\/span>agent<\/span> (<\/span>a_string<\/span>:<\/span>STRING<\/span>)<\/span>\r\n\t\t\t\t\t\t\t\tdo<\/span>\r\n\t\t\t\t\t\t\t\t\tprint<\/span>(<\/span>\"La valeur: \"<\/span> +<\/span> a_string<\/span> +<\/span> \" n'est pas un entier valide%N\"<\/span>)<\/span>\r\n\t\t\t\t\t\t\t\tend<\/span>\r\n\t\t\t\t\t\t\t,<\/span> agent<\/span> (<\/span>a_string<\/span>:<\/span>STRING<\/span>):<\/span>BOOLEAN<\/span>\r\n\t\t\t\t\t\t\t\tdo<\/span>\r\n\t\t\t\t\t\t\t\t\tResult<\/span> :=<\/span> not<\/span> a_string<\/span>.<\/span>is_integer<\/span>\r\n\t\t\t\t\t\t\t\tend<\/span>\r\n\t\t\t\t\t\t)<\/span>\r\n\t\tend<\/span>\r\n\tend<\/span>\r\n<\/pre>\n<\/div>\n
      Les lambdas en Java<\/h2>\n
      Le langage Java a \u00e9galement sa version des fonctions lambda. Malheureusement, tr\u00e8s peu de m\u00e9canismes inclue dans les librairies de base de java utilisent ou permette l’utilisation des fonctions lambda. La raison pour cette absence est que les fonctions lambda ont fait leur apparition dans le langage Java \u00e0 partir de la version 8 et que les librairies de bases ont \u00e9t\u00e9 faites bien avant cette version.<\/p>\n
      De plus, les fonctions lambda en Java sont beaucoup moins structur\u00e9es que ce que nous avons vu en Eiffel avec les \u00ab\u00a0agents\u00a0\u00bb. En effet, l’impl\u00e9mentation des fonctions lambda en Java est bas\u00e9e sur le principe des langages fonctionnels qui ne sont g\u00e9n\u00e9ralement pas typ\u00e9s. Donc, le syst\u00e8me de fonctions lambda en Java ne respecte pas le paradigme de programmation orient\u00e9e objet par classe, mais bien celui de programmation orient\u00e9e objet par prototype. En d’autres mots, il n’y a pas de classe telle que Methode<\/code>, Procedure<\/code> ou Function<\/code> g\u00e9n\u00e9r\u00e9 \u00e0 partir de la syntaxe des lambdas en Java. Un lambda g\u00e9n\u00e8re d’une certaine fa\u00e7on un objet qui n’a pas de type. Inversement, afin de faire en sorte que ces fonctions lambda soient utilisables avec le reste du langage Java, les concepteurs ont fait en sorte que les fonctions lambda peuvent g\u00e9n\u00e9rer des objets qui se conforment \u00e0 certaines interfaces.<\/p>\n
      Pour cr\u00e9er une fonction lambda, il faut utiliser la syntaxe:<\/p>\n
      (TypeArgument1 argument1, TypeArgument2 argument2, ...) -> code<\/pre>\n
      Voici un exemple. Premi\u00e8rement, prenons la classe Personne suivante qui nous servira dans notre exemple:<\/p>\n
      \n
      public<\/span> class<\/span> Personne<\/span> {<\/span>\r\n    private<\/span> int<\/span> age<\/span>;<\/span>\r\n\r\n    private<\/span> String<\/span> nom<\/span>;<\/span>\r\n\r\n    public<\/span> void<\/span> setAge<\/span>(<\/span>int<\/span> aAge<\/span>)<\/span> {<\/span>\r\n        age<\/span> =<\/span> aAge<\/span>;<\/span>\r\n    }<\/span>\r\n\r\n    public<\/span> int<\/span> getAge<\/span>()<\/span> {<\/span>\r\n        return<\/span> age<\/span>;<\/span>\r\n    }<\/span>\r\n\r\n    public<\/span> void<\/span> setNom<\/span>(<\/span>String<\/span> aNom<\/span>)<\/span> {<\/span>\r\n        nom<\/span> =<\/span> aNom<\/span>;<\/span>\r\n    }<\/span>\r\n\r\n    public<\/span> String<\/span> getNom<\/span>()<\/span> {<\/span>\r\n        return<\/span> nom<\/span>;<\/span>\r\n    }<\/span>\r\n\r\n    public<\/span> Personne<\/span>(<\/span>int<\/span> aAge<\/span>,<\/span> String<\/span> aNom<\/span>)<\/span> {<\/span>\r\n        setAge<\/span>(<\/span>aAge<\/span>);<\/span>\r\n        setNom<\/span>(<\/span>aNom<\/span>);<\/span>\r\n    }<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
      Ensuite, prenons le programme suivant:<\/p>\n
      \n
      public<\/span> class<\/span> Programme<\/span> {<\/span>\r\n\r\n    private<\/span> interface<\/span> CheckPersonne<\/span> {<\/span>\r\n       public<\/span> boolean<\/span> test<\/span>(<\/span>Personne<\/span> aPersonne<\/span>);<\/span>\r\n    }<\/span> \r\n\r\n    public<\/span> Programme<\/span>()<\/span> {<\/span>\r\n        CheckPersonne<\/span> ma_lambda<\/span> =<\/span> (<\/span>Personne<\/span> p<\/span>)<\/span> -><\/span> p<\/span>.<\/span>getAge<\/span>()<\/span> ><\/span> 18<\/span>;<\/span>\r\n        Personne<\/span> personne1<\/span> =<\/span> new<\/span> Personne<\/span>(<\/span>7<\/span>,<\/span> \"Alice\"<\/span>);<\/span>\r\n        Personne<\/span> personne2<\/span> =<\/span> new<\/span> Personne<\/span>(<\/span>900<\/span>,<\/span> \"Yoda\"<\/span>);<\/span>\r\n        if<\/span>(<\/span>ma_lambda<\/span>.<\/span>test<\/span>(<\/span>personne1<\/span>)){<\/span>\r\n            System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>personne1<\/span>.<\/span>getNom<\/span>()<\/span> +<\/span> \" a plus de 18 ans\"<\/span>);<\/span>\r\n        }<\/span>\r\n        if<\/span>(<\/span>ma_lambda<\/span>.<\/span>test<\/span>(<\/span>personne2<\/span>)){<\/span>\r\n            System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>personne2<\/span>.<\/span>getNom<\/span>()<\/span> +<\/span> \" a plus de 18 ans\"<\/span>);<\/span>\r\n        }<\/span>\r\n    }<\/span>\r\n\r\n    public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> aArguments<\/span>)<\/span> {<\/span>\r\n        new<\/span> Programme<\/span>();<\/span>\r\n    }<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
      On voit ici que la fonction lambda est plac\u00e9e dans une variable de Type CheckPersonne<\/code> qui contient la fonction test()<\/code>. Pour utiliser la fonction lambda, nous devons utiliser cette fonction test()<\/code>. Le r\u00e9sultat de ce code donnera:<\/p>\n
      Yoda a plus de 18 ans.<\/pre>\n
      On peut varier le type de retour de la fonction lambda en modifiant l’interface et en faisant en sorte que la lambda retourne le bon type. On peut \u00e9galement cr\u00e9er une fonction lambda qui ne retourne aucune valeur. Par exemple:<\/p>\n
      \n
      public<\/span> class<\/span> Programme<\/span> {<\/span>\r\n\r\n    private<\/span> interface<\/span> PrintPersonne<\/span> {<\/span>\r\n       public<\/span> void<\/span> run<\/span>(<\/span>Personne<\/span> aPersonne<\/span>);<\/span>\r\n    }<\/span> \r\n\r\n    public<\/span> Programme<\/span>()<\/span> {<\/span>\r\n        PrintPersonne<\/span> ma_lambda<\/span> =<\/span> (<\/span>Personne<\/span> p<\/span>)<\/span> -><\/span> System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\r\n                \"L'age de \"<\/span> +<\/span> p<\/span>.<\/span>getNom<\/span>()<\/span> +<\/span> \" est de \"<\/span> +<\/span> p<\/span>.<\/span>getAge<\/span>()<\/span> +<\/span> \" ans.\"<\/span>);<\/span>\r\n        Personne<\/span> personne1<\/span> =<\/span> new<\/span> Personne<\/span>(<\/span>7<\/span>,<\/span> \"Alice\"<\/span>);<\/span>\r\n        ma_lambda<\/span>.<\/span>run<\/span>(<\/span>personne1<\/span>);<\/span>\r\n    }<\/span>\r\n\r\n    public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> aArguments<\/span>)<\/span> {<\/span>\r\n        new<\/span> Programme<\/span>();<\/span>\r\n    }<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
      Le r\u00e9sultat de ce programme code est:<\/p>\n
      L'age de Alice est de 7 ans.<\/pre>\n
      Lambda sur des listes<\/h3>\n
      Un peu comme dans le cas des actions de boucle dans Eiffel, il est possible d’utiliser les lambdas dans le contexte d’une liste afin d’indiquer \u00e0 la liste une action \u00e0 effectuer sur chaque \u00e9l\u00e9ment de la liste. Pour ce faire, on utilise la m\u00e9thode forEach<\/code> contenue dans toutes les List<\/code>. Voici un exemple:<\/p>\n
      \n
      public<\/span> class<\/span> Programme<\/span> {<\/span>\r\n\r\n    private<\/span> static<\/span> void<\/span> printPersonne<\/span>(<\/span>Personne<\/span> aPersonne<\/span>)<\/span> {<\/span>\r\n        System<\/span>.<\/span>out<\/span>.<\/span>println<\/span>(<\/span>\"L'age de \"<\/span> +<\/span> aPersonne<\/span>.<\/span>getNom<\/span>()<\/span> +<\/span> \" est de \"<\/span> +<\/span> \r\n                aPersonne<\/span>.<\/span>getAge<\/span>()<\/span> +<\/span> \" ans.\"<\/span>);<\/span>\r\n    }<\/span>\r\n\r\n    public<\/span> Programme<\/span>()<\/span> {<\/span>\r\n        List<\/span><<\/span>Personne<\/span>><\/span> lPersonnes<\/span> =<\/span> new<\/span> LinkedList<\/span><<\/span>Personne<\/span>><\/span>();<\/span>\r\n        lPersonnes<\/span>.<\/span>add<\/span>(<\/span>new<\/span> Personne<\/span>(<\/span>7<\/span>,<\/span> \"Alice\"<\/span>));<\/span>\r\n        lPersonnes<\/span>.<\/span>add<\/span>(<\/span>new<\/span> Personne<\/span>(<\/span>900<\/span>,<\/span> \"Yoda\"<\/span>));<\/span>\r\n        lPersonnes<\/span>.<\/span>forEach<\/span>(<\/span>(<\/span>Personne<\/span> p<\/span>)<\/span> -><\/span> printPersonne<\/span>(<\/span>p<\/span>));<\/span>\r\n    }<\/span>\r\n\r\n\r\n    public<\/span> static<\/span> void<\/span> main<\/span>(<\/span>String<\/span>[]<\/span> aArguments<\/span>)<\/span> {<\/span>\r\n        new<\/span> Programme<\/span>();<\/span>\r\n    }<\/span>\r\n}<\/span>\r\n<\/pre>\n<\/div>\n
      Le r\u00e9sultat de cet exemple est:<\/p>\n
      L'age de Alice est de 7 ans.\r\nL'age de Yoda est de 900 ans.<\/pre>\n
      Retour<\/a><\/p>\n
      \n
      Auteur: Louis Marchand
      \n      \"Creative<\/a>
      \nSauf pour les sections sp\u00e9cifi\u00e9es autrement, ce travail est sous licence       Creative Commons Attribution 4.0 International<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
      Introduction En programmation, l’utilisation de variable est un \u00e9l\u00e9ment extr\u00eamement important, autant pour stocker des donn\u00e9es que pour les partager entre les diff\u00e9rentes instances de votre syst\u00e8me. En effet, s’il n’y avait pas de variables, nous ne pourrions pas transf\u00e9rer des valeurs d’un objet \u00e0 un autre en utilisant les assignateurs (\u00ab\u00a0setters\u00a0\u00bb), les constructeurs ou… Continue reading Les fonctions lambda<\/span><\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-468","page","type-page","status-publish","hentry","entry"],"_links":{"self":[{"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/pages\/468","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/comments?post=468"}],"version-history":[{"count":11,"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/pages\/468\/revisions"}],"predecessor-version":[{"id":758,"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/pages\/468\/revisions\/758"}],"wp:attachment":[{"href":"https:\/\/www.louismarchand.me\/index.php\/wp-json\/wp\/v2\/media?parent=468"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}