Utiliser les types de fonction et les expressions lambda en Kotlin

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

1. Introduction

Dans cet atelier de programmation, vous allez étudier la syntaxe spécifique aux expressions lambda, et apprendre ce que sont les types de fonction et comment les utiliser.

En langage Kotlin, les fonctions sont considérées comme des constructions de première classe. Cela signifie qu'elles peuvent être traitées comme un type de données. Vous pouvez stocker des fonctions dans des variables, les transmettre à d'autres fonctions en tant qu'arguments et les renvoyer à partir d'autres fonctions.

Comme pour d'autres types de données pouvant être exprimés avec des valeurs littérales (comme un type Int d'une valeur 10 et un type String d'une valeur "Hello"), vous pouvez déclarer des littéraux de fonction, appelés "expression lambda" ou plus simplement "lambdas". Les expressions lambda sont largement utilisées pour le développement Android et, de manière plus générale, en programmation Kotlin.

Conditions préalables

  • Vous maîtrisez la programmation Kotlin, y compris les fonctions, les instructions if/else et la possibilité de valeur nulle.

Points abordés

  • Définir une fonction avec la syntaxe lambda
  • Stocker des fonctions dans des variables
  • Transmettre des fonctions en tant qu'arguments à d'autres fonctions
  • Renvoyer des fonctions à partir d'autres fonctions
  • Utiliser des types de fonction pouvant avoir une valeur nulle
  • Rendre les expressions lambda plus concises
  • Qu'est-ce qu'une fonction d'ordre supérieur ?
  • Utiliser la fonction repeat()

Ce dont vous avez besoin

  • Un navigateur Web ayant accès à Kotlin Playground

2. Regarder la vidéo du code pas à pas (facultatif)

Si vous souhaitez voir un formateur réaliser cet atelier de programmation, regardez la vidéo ci-dessous.

Nous vous recommandons d'afficher la vidéo en plein écran (à l'aide de l'icône Ce symbole qui indique le mode plein écran représente quatre coins d'un carré mis en évidence. dans l'angle inférieur droit de la vidéo) pour mieux voir Android Studio et le code.

Cette étape est facultative. Vous pouvez également ignorer la vidéo et passer immédiatement aux instructions de l'atelier de programmation.

3. Stocker une fonction dans une variable

Jusqu'à présent, vous avez appris à déclarer des fonctions avec le mot clé fun. Une fonction déclarée avec le mot clé fun peut être appelée, ce qui entraîne l'exécution du code dans le corps de la fonction.

En tant que constructions de première classe, les fonctions sont également des types de données. Vous pouvez donc les stocker dans des variables, les transmettre à des fonctions et les renvoyer à partir de fonctions. Peut-être souhaitez-vous être en mesure de modifier le comportement d'une partie de votre application au moment de l'exécution ou d'imbriquer des fonctions modulables pour créer des mises en page, comme vous l'avez fait lors d'ateliers de programmation précédents. Sachez que tout cela est possible avec les expressions lambda.

Pour illustrer notre propos, prenons l'exemple de la chasse aux bonbons ("trick-or-treat" an anglais), une tradition d'Halloween dans de nombreux pays, au cours de laquelle les enfants déguisés passent de porte en porte pour demander des friandises (le plus souvent) en récitant la phrase "Des bonbons ou un sort".

Stockez une fonction dans une variable :

  1. Accédez à Kotlin Playground.
  2. Après la fonction main(), définissez une fonction trick() sans paramètre ni valeur renvoyée qui affiche "No treats!". La syntaxe est identique à celle d'autres fonctions présentées dans des ateliers précédents.
fun main() {

}

fun trick() {
    println("No treats!")
}
  1. Dans le corps de la fonction main(), créez une variable appelée trickFunction et définissez-la sur trick. Aucune parenthèse n'est incluse après trick, car vous souhaitez stocker la fonction dans une variable, et non l'appeler.
fun main() {
    val trickFunction = trick
}

fun trick() {
    println("No treats!")
}
  1. Exécutez votre code. Une erreur est générée, car le compilateur Kotlin reconnaît trick comme nom de la fonction trick(), mais s'attend à ce que vous l'appeliez au lieu de l'affecter à une variable.
Function invocation 'trick()' expected

Vous avez essayé de stocker trick dans la variable trickFunction. Toutefois, pour faire référence à une fonction en tant que valeur, vous devez utiliser l'opérateur de référence de fonction (::). La syntaxe est illustrée ci-dessous :

2afc9eec512244cc.png

  1. Pour faire référence à la fonction en tant que valeur, réaffectez trickFunction à ::trick.
fun main() {
    val trickFunction = ::trick
}

fun trick() {
    println("No treats!")
}
  1. Exécutez votre code pour vérifier qu'il n'y a plus d'erreurs. Vous recevez un avertissement vous indiquant que trickFunction n'est jamais utilisé. Ce problème sera toutefois résolu dans la section suivante.

Redéfinir la fonction avec une expression lambda

Les expressions lambda fournissent une syntaxe concise pour définir une fonction sans le mot clé fun. Vous pouvez stocker une expression lambda directement dans une variable sans référence de fonction sur une autre fonction.

Avant l'opérateur d'affectation (=), ajoutez le mot clé val ou var suivi du nom de la variable. C'est ce que vous utiliserez lors de l'appel de la fonction. L'expression lambda se trouve après l'opérateur d'affectation (=). Elle est constituée d'une paire d'accolades qui forment le corps de la fonction. La syntaxe est illustrée dans l'image suivante :

7bf9daf9feff0dec.png

Lorsque vous définissez une fonction avec une expression lambda, une variable y fait référence. Vous pouvez également affecter sa valeur à d'autres variables, comme n'importe quel autre type, et l'appeler avec le nom de la nouvelle variable.

Mettez à jour le code pour qu'il utilise une expression lambda :

  1. Réécrivez la fonction trick() avec une expression lambda. Le nom trick fait à présent référence au nom d'une variable. Le corps de la fonction entre accolades est à présent une expression lambda.
fun main() {
    val trickFunction = ::trick
}

val trick = {
    println("No treats!")
}
  1. Dans la fonction main(), supprimez l'opérateur de référence (::), car trick fait maintenant référence à une variable plutôt qu'à un nom de fonction.
fun main() {
    val trickFunction = trick
}

val trick = {
    println("No treats!")
}
  1. Exécutez votre code. Il n'y a aucune erreur. Vous pouvez faire référence à la fonction trick() sans l'opérateur de référence (::). Aucune sortie n'est disponible, car vous n'avez toujours pas appelé la fonction.
  2. Dans la fonction main(), appelez la fonction trick(), mais cette fois en incluant les parenthèses, comme vous le feriez pour n'importe quelle autre fonction.
fun main() {
    val trickFunction = trick
    trick()
}

val trick = {
    println("No treats!")
}
  1. Exécutez votre code. Le corps de l'expression lambda est exécuté.
No treats!
  1. Dans la fonction main(), appelez la variable trickFunction comme s'il s'agissait d'une fonction.
fun main() {
    val trickFunction = trick
    trick()
    trickFunction()
}

val trick = {
    println("No treats!")
}
  1. Exécutez votre code. La fonction est appelée deux fois : une première fois pour l'appel de fonction trick() et une seconde fois pour l'appel de fonction trickFunction().
No treats!
No treats!

Les expressions lambda vous permettent de créer des variables qui stockent des fonctions, de les appeler comme des fonctions et de les stocker dans d'autres variables pouvant être appelées comme des fonctions.

4. Utiliser des fonctions en tant que type de données

Dans un atelier de programmation précédent, nous avons vu que Kotlin utilisait l'inférence de type. Lorsque vous déclarez une variable, il n'est généralement pas nécessaire de spécifier explicitement le type. Dans l'exemple précédent, le compilateur Kotlin a pu déduire que la valeur de trick était une fonction. Toutefois, si vous souhaitez spécifier le type d'un paramètre de fonction ou d'un type renvoyé, vous devez connaître la syntaxe à utiliser pour exprimer des types de fonction. Les types de fonction sont constitués d'un ensemble de parenthèses contenant une liste de paramètres facultative, le symbole -> et un type renvoyé. La syntaxe est illustrée dans l'image suivante :

1554805ee8183ef.png

Le type de données de la variable trick que vous avez déclarée précédemment est () -> Unit. Rien n'est mis entre parenthèses, car la fonction ne comporte aucun paramètre. Le type renvoyé est Unit, car la fonction ne renvoie rien. Si votre fonction acceptait deux paramètres Int et renvoyait un Int, son type de données serait (Int, Int) -> Int.

Déclarez une autre fonction avec une expression lambda qui spécifie explicitement son type :

  1. Après la variable trick, déclarez une variable treat correspondant à une expression lambda avec un corps qui affiche le message "Have a treat!".
val trick = {
    println("No treats!")
}

val treat = {
    println("Have a treat!")
}
  1. Spécifiez le type de données de la variable treat en tant que () -> Unit.
val treat: () -> Unit = {
    println("Have a treat!")
}
  1. Dans la fonction main(), appelez la fonction treat().
fun main() {
    val trickFunction = trick
    trick()
    trickFunction()
    treat()
}
  1. Exécutez le code. La fonction treat() se comporte comme trick(). Les deux variables ont le même type de données, même si seule la variable treat le déclare explicitement.
No treats!
No treats!
Have a treat!

Utiliser une fonction comme type renvoyé

Une fonction est un type de données et peut donc être utilisée comme n'importe quel autre type de données. Vous pouvez même renvoyer des fonctions à partir d'autres fonctions. La syntaxe est illustrée dans l'image suivante :

6bd674c383827fe5.png

Créez une fonction qui en renvoie une autre.

  1. Supprimez le code de la fonction main().
fun main() {

}
  1. Après la fonction main(), définissez une fonction trickOrTreat() qui accepte un paramètre isTrick de type Boolean.
fun main() {

}

fun trickOrTreat(isTrick: Boolean): () -> Unit {
}

val trick = {
    println("No treats!")
}

val treat = {
    println("Have a treat!")
}
  1. Dans le corps de la fonction trickOrTreat(), ajoutez une instruction if qui renvoie trick() si la valeur de isTrick est true et treat() si la valeur de isTrick est "false".
fun trickOrTreat(isTrick: Boolean): () -> Unit {
    if (isTrick) {
        return trick
    } else {
        return treat
    }
}
  1. Dans la fonction main(), créez une variable treatFunction, puis affectez-la au résultat de l'appel de trickOrTreat(), en transmettant false pour le paramètre isTrick. Créez ensuite une deuxième variable, appelée trickFunction, puis affectez-la au résultat de l'appel de trickOrTreat(), en transmettant cette fois true pour le paramètre isTrick.
fun main() {
    val treatFunction = trickOrTreat(false)
    val trickFunction = trickOrTreat(true)
}
  1. Appelez trickFunction(), puis treatFunction() sur la ligne suivante.
fun main() {
    val treatFunction = trickOrTreat(false)
    val trickFunction = trickOrTreat(true)
    treatFunction()
    trickFunction()
}
  1. Exécutez votre code. Vous devriez voir la sortie de chaque fonction. Même si vous n'avez pas appelé directement les fonctions trick() ou treat(), vous pouvez toujours le faire, car vous avez stocké les valeurs renvoyées chaque fois que vous avez appelé la fonction trickOrTreat() et que vous avez appelé les fonctions avec les variables trickFunction et treatFunction.
Have a treat!
No treats!

Vous savez maintenant comment les fonctions peuvent en renvoyer d'autres. Vous pouvez également transmettre une fonction en tant qu'argument à une autre fonction. Vous souhaiterez peut-être appliquer un comportement personnalisé à la fonction trickOrTreat() pour qu'elle fasse autre chose que renvoyer l'une des deux chaînes. Une fonction qui en accepte une autre comme argument vous permet de transmettre une fonction différente chaque fois qu'elle est appelée.

Transmettre une fonction à une autre en tant qu'argument

Dans certains pays qui célèbrent Halloween, les enfants reçoivent de la petite monnaie au lieu de friandises, voire les deux. Vous allez modifier votre fonction trickOrTreat() de manière à autoriser une récompense supplémentaire, représentée par une fonction fournie en tant qu'argument.

La fonction utilisée par trickOrTreat() en tant que paramètre doit également accepter un paramètre qui lui est propre. Lors de la déclaration de types de fonction, les paramètres ne sont pas étiquetés. Il vous suffit de spécifier les types de données de chaque paramètre, en les séparant par une virgule. La syntaxe est illustrée dans l'image suivante :

8e4c954306a7ab25.png

Lorsque vous écrivez une expression lambda pour une fonction qui accepte des paramètres, des noms leurs sont attribués dans l'ordre dans lequel ils apparaissent. Ces noms sont listés après les accolades ouvrantes et séparés par une virgule. Une flèche (->) sépare les noms des paramètres du corps de la fonction. La syntaxe est illustrée dans l'image suivante :

d6dd66beb0d97a99.png

Mettez à jour la fonction trickOrTreat() pour qu'elle accepte une fonction comme paramètre :

  1. Après le paramètre isTrick, ajoutez un paramètre extraTreat de type (Int) -> String.
fun trickOrTreat(isTrick: Boolean, extraTreat: (Int) -> String): () -> Unit {
  1. Dans le bloc else, avant l'instruction return, appelez println() en transmettant un appel à la fonction extraTreat(). Transmettez 5 à l'appel vers extraTreat().
fun trickOrTreat(isTrick: Boolean, extraTreat: (Int) -> String): () -> Unit {
    if (isTrick) {
        return trick
    } else {
        println(extraTreat(5))
        return treat
    }
}
  1. Lorsque vous appelez la fonction trickOrTreat(), vous devez maintenant définir une fonction avec une expression lambda et la transmettre au paramètre extraTreat. Dans la fonction main(), avant les appels à la fonction trickOrTreat(), ajoutez coins(). La fonction coins() attribue le nom quantity au paramètre Int et renvoie String. Vous remarquerez peut-être que le mot clé return est absent. En fait, il ne peut pas être utilisé dans des expressions lambda. Au lieu de cela, c'est le résultat de la dernière expression de la fonction qui devient la valeur renvoyée.
fun main() {
    val coins: (Int) -> String = { quantity ->
        "$quantity quarters"
    }

    val treatFunction = trickOrTreat(false)
    val trickFunction = trickOrTreat(true)
    treatFunction()
    trickFunction()
}
  1. Après la fonction coins(), ajoutez une fonction cupcake() comme indiqué. Nommez le paramètre Int "quantity" et séparez-le du corps de la fonction à l'aide de l'opérateur ->. Vous pouvez maintenant transmettre la fonction coins() ou cupcake() à trickOrTreat().
fun main() {
    val coins: (Int) -> String = { quantity ->
        "$quantity quarters"
    }

    val cupcake: (Int) -> String = {quantity ->
        "Have a cupcake!"
    }

    val treatFunction = trickOrTreat(false)
    val trickFunction = trickOrTreat(true)
    treatFunction()
    trickFunction()
}
  1. Dans la fonction cupcake(), supprimez le paramètre quantity et le symbole ->. Vous pouvez les omettre, car ils ne sont pas utilisés.
val cupcake: (Int) -> String = {
    "Have a cupcake!"
}
  1. Mettez à jour les appels à la fonction trickOrTreat(). Pour le premier appel, lorsque la valeur du paramètre isTrick est définie sur false, transmettez la fonction coins(). Pour le deuxième appel, lorsque la valeur du paramètre isTrick est true, transmettez la fonction cupcake().
fun main() {
    val coins: (Int) -> String = { quantity ->
        "$quantity quarters"
    }

    val cupcake: (Int) -> String = {
        "Have a cupcake!"
    }

    val treatFunction = trickOrTreat(false, coins)
    val trickFunction = trickOrTreat(true, cupcake)
    treatFunction()
    trickFunction()
}
  1. Exécutez votre code. La fonction extraTreat() n'est appelée que lorsque le paramètre isTrick est défini sur un argument false. La sortie inclut donc cinq pièces de 25 cents, mais pas de cupcakes.
5 quarters
Have a treat!
No treats!

Types de fonction pouvant avoir une valeur nulle

Comme les autres types de données, les types de fonction peuvent être déclarés comme nullables. Dans ce cas, une variable peut contenir une fonction ou être null.

Pour déclarer une fonction comme nullable, placez son type entre parenthèses, suivi du signe ? en dehors de la parenthèse de fin. Par exemple, si vous voulez rendre le type () -> String nullable, déclarez-le comme type (() -> String)?. La syntaxe est illustrée dans l'image suivante :

eb9f645061544a76.png

Rendez le paramètre extraTreat nullable pour ne pas avoir à fournir une fonction extraTreat() chaque fois que vous appelez la fonction trickOrTreat() :

  1. Définissez le type du paramètre extraTreat sur (() -> String)?.
fun trickOrTreat(isTrick: Boolean, extraTreat: ((Int) -> String)?): () -> Unit {
  1. Modifiez l'appel de la fonction extraTreat() de manière à utiliser une instruction if pour appeler la fonction uniquement si elle n'est pas nulle. La fonction trickOrTreat() devrait maintenant se présenter comme suit :
fun trickOrTreat(isTrick: Boolean, extraTreat: ((Int) -> String)?): () -> Unit {
    if (isTrick) {
        return trick
    } else {
        if (extraTreat != null) {
            println(extraTreat(5))
        }
        return treat
    }
}
  1. Supprimez la fonction cupcake(), puis remplacez l'argument cupcake par null dans le deuxième appel de la fonction trickOrTreat().
fun main() {
    val coins: (Int) -> String = { quantity ->
        "$quantity quarters"
    }

    val treatFunction = trickOrTreat(false, coins)
    val trickFunction = trickOrTreat(true, null)
    treatFunction()
    trickFunction()
}
  1. Exécutez votre code. Vous devriez obtenir le même résultat. Maintenant que vous pouvez déclarer des types de fonction comme nullables, il n'est plus nécessaire de transmettre une fonction pour le paramètre extraTreat.
5 quarters
Have a treat!
No treats!

5. Écrire des expressions lambda avec une syntaxe abrégée

Les expressions lambda offrent différentes méthodes pour rendre votre code plus concis. Cette section vous invite à en découvrir quelques-unes. En effet, la plupart des expressions lambda que vous rencontrez et écrivez utilisent une syntaxe abrégée.

Omettre les noms des paramètres

Lorsque vous avez écrit la fonction coins(), vous avez explicitement déclaré le nom quantity pour son paramètre Int. Toutefois, comme nous l'avons vu avec la fonction cupcake(), vous pouvez omettre complètement le nom du paramètre. Si une fonction comporte un seul paramètre et que vous ne fournissez pas de nom, Kotlin lui attribue implicitement le nom it. Vous pouvez donc omettre le nom du paramètre et le symbole ->, ce qui rend vos expressions lambda plus concises. La syntaxe est illustrée dans l'image suivante :

3fc275a5ad9518be.png

Modifiez la fonction coins() pour qu'elle utilise la syntaxe abrégée pour les paramètres :

  1. Dans la fonction coins(), supprimez le nom du paramètre quantity et le symbole ->.
val coins: (Int) -> String = {
    "$quantity quarters"
}
  1. Modifiez le modèle de chaîne "$quantity quarters" pour qu'il fasse référence au paramètre à l'aide de $it.
val coins: (Int) -> String = {
    "$it quarters"
}
  1. Exécutez votre code. Kotlin reconnaît le nom it du paramètre Int et affiche toujours le nombre de pièces de 25 cents.
5 quarters
Have a treat!
No treats!

Transmettre une expression lambda directement à une fonction

Pour le moment, la fonction coins() n'est utilisée qu'à un seul endroit. Que diriez-vous de pouvoir transmettre une expression lambda directement à la fonction trickOrTreat() sans devoir créer une variable au préalable ?

Les expressions lambda sont simplement des littéraux de fonction, tout comme 0 est un littéral d'entier ou "Hello" un littéral de chaîne. Vous pouvez transmettre directement une expression lambda à un appel de fonction. La syntaxe est illustrée dans l'image suivante :

2b7175152f7b66e5.png

Modifiez le code de manière à pouvoir supprimer la variable coins :

  1. Déplacez l'expression lambda pour qu'elle soit transmise directement à l'appel de la fonction trickOrTreat(). Vous pouvez également condenser l'expression lambda sur une seule ligne.
fun main() {
    val coins: (Int) -> String = {
        "$it quarters"
    }
    val treatFunction = trickOrTreat(false, { "$it quarters" })
    val trickFunction = trickOrTreat(true, null)
    treatFunction()
    trickFunction()
}
  1. Supprimez la variable coins, car elle n'est plus utilisée.
fun main() {
    val treatFunction = trickOrTreat(false, { "$it quarters" })
    val trickFunction = trickOrTreat(true, null)
    treatFunction()
    trickFunction()
}
  1. Exécutez le code. Il est toujours compilé et exécuté comme prévu.
5 quarters
Have a treat!
No treats!

Utiliser la syntaxe lambda de fin

Vous pouvez utiliser une autre option abrégée pour écrire des lambdas lorsqu'un type de fonction est le dernier paramètre d'une fonction. Si tel est le cas, vous pouvez placer l'expression lambda après la parenthèse fermante pour appeler la fonction. La syntaxe est illustrée dans l'image suivante :

b3de63c209052189.png

Cela améliore la lisibilité du code, dans la mesure où l'expression lambda est séparée des autres paramètres. Cependant, cela ne modifie pas sa fonction.

Mettez à jour le code pour qu'il utilise la syntaxe lambda de fin :

  1. Dans la variable treatFunction, déplacez l'expression lambda {"$it quarters"} après la parenthèse fermante dans l'appel de la fonction trickOrTreat().
val treatFunction = trickOrTreat(false) { "$it quarters" }
  1. Exécutez votre code. Tout fonctionne toujours correctement.
5 quarters
Have a treat!
No treats!

6. Utiliser la fonction repeat()

Lorsqu'une fonction en renvoie une autre ou utilise une fonction comme argument, elle est appelée "fonction d'ordre supérieur". trickOrTreat() est un exemple de fonction de ce type, car elle utilise une fonction de type ((Int) -> String)? comme paramètre et renvoie une fonction de type () -> Unit. Kotlin propose plusieurs fonctions d'ordre supérieur bien utiles que vous pouvez exploiter grâce aux connaissances que vous venez d'acquérir sur les lambdas.

repeat() appartient à cette catégorie des fonctions d'ordre supérieur. La fonction repeat() permet d'exprimer une boucle for avec des fonctions de manière concise. Vous utiliserez fréquemment cette fonction, ainsi que d'autres fonctions d'ordre supérieur, dans les modules suivants. La fonction repeat() a la signature suivante :

repeat(times: Int, action: (Int) -> Unit)

Le paramètre times correspond au nombre d'itérations prévues de l'action. Le paramètre action est une fonction qui accepte un seul paramètre Int et renvoie un type Unit. Le paramètre Int de la fonction action correspond au nombre de fois où l'action a été exécutée jusqu'à présent ; par exemple un argument 0 pour la première itération ou un argument 1 pour la deuxième itération. Vous pouvez utiliser la fonction repeat() pour répéter le code un nombre déterminé de fois, comme une boucle for. La syntaxe est illustrée dans l'image suivante :

e0459d5f7c814016.png

Au lieu d'appeler la fonction trickFunction() une seule fois, vous pouvez l'appeler à plusieurs reprises avec la fonction repeat().

Mettez à jour votre code "trick-or-treat" pour voir la fonction repeat() en action :

  1. Dans la fonction main(), appelez la fonction repeat() entre les appels de treatFunction() et trickFunction(). Transmettez 4 pour le paramètre times et utilisez la syntaxe lambda de fin pour la fonction action. Il n'est pas nécessaire d'indiquer un nom pour le paramètre Int de l'expression lambda.
fun main() {
    val treatFunction = trickOrTreat(false) { "$it quarters" }
    val trickFunction = trickOrTreat(true, null)
    treatFunction()
    trickFunction()
    repeat(4) {

    }
}
  1. Déplacez l'appel de la fonction treatFunction() vers l'expression lambda de la fonction repeat().
fun main() {
    val treatFunction = trickOrTreat(false) { "$it quarters" }
    val trickFunction = trickOrTreat(true, null)
    repeat(4) {
        treatFunction()
    }
    trickFunction()
}
  1. Exécutez votre code. La chaîne "Have a treat" doit être affichée quatre fois.
5 quarters
Have a treat!
Have a treat!
Have a treat!
Have a treat!
No treats!

7. Conclusion

Félicitations ! Vous avez appris les principes de base des types de fonction et des expressions lambda. Une bonne connaissance de ces concepts vous sera utile pour poursuivre l'apprentissage du langage Kotlin. L'utilisation des types de fonction, des fonctions d'ordre supérieur et de la syntaxe abrégée permet également de rendre votre code plus concis et d'en améliorer la lisibilité.

Résumé

  • En langage Kotlin, les fonctions sont des constructions de première classe qui peuvent être traitées comme des types de données.
  • Les expressions lambda fournissent une syntaxe abrégée pour l'écriture de fonctions.
  • Vous pouvez transmettre des types de fonction à d'autres fonctions.
  • Vous pouvez renvoyer un type de fonction à partir d'une autre fonction.
  • Une expression lambda renvoie la valeur de la dernière expression.
  • Si une étiquette de paramètre est omise dans une expression lambda comportant un seul paramètre, l'identifiant it est utilisé pour y faire référence.
  • Les lambdas peuvent être écrits de façon intégrée sans nom de variable.
  • Si le dernier paramètre d'une fonction est un type de fonction, vous pouvez utiliser la syntaxe lambda de fin pour déplacer l'expression lambda après la dernière parenthèse lors de l'appel d'une fonction.
  • Les fonctions d'ordre supérieur utilisent d'autres fonctions en tant que paramètres ou renvoient une fonction.
  • repeat() est une fonction d'ordre supérieur qui fonctionne comme une boucle for.

En savoir plus