Les fonctions lambdas
En Kotlin, les fonctions lambdas sont des fonctions anonymes pouvant être manipulées comme des valeurs, c'est-à-dire qu'elles peuvent être :
- passées en argument à d’autres fonctions;
- assignées à des variables;
- retournées par des fonctions.
Dans cette recette, nous nous concentrerons davantage sur une lambda passée en argument à une autre fonction. Vous trouverez les deux autres cas à la fin de la recette dans la section "Pour aller plus loin".
Passer une lambda en argument à une fonction
Prenons par exemple une fonction nommée appliquerOperation() ayant comme paramètres un nombre et une opération à effectuer sur ce nombre :
fun appliquerOperation(nombre: Int, operation: (Int) -> Int): Int {
return operation(nombre)
}
Remarquez qu'operation est en fait une lambda passée en argument à la fonction appliquerOperation. Maintenant, regardez comment cette fonction est appelée dans un main :
fun main() {
val resultat = appliquerOperation(5, { n -> n * 2 })
println(resultat) // 10
}
Décortiquons la syntaxe de notre lambda :
{ n -> n * 2 }: notre expression lambda, entre les accoladesn: le paramètre d'entrée de notre lambda->: la flèche permet de séparer les paramètres d'entrée du corps de la lambdan * 2: le corps de la lambda qui, dans ce cas-ci, retourne le double den.
Remarquez l'absence du mot-clé return. En effet, lorsque la valeur de retour n'est pas Unit (qui agit comme un void en C#),la dernière expression dans le corps de la lambda sera automatiquement considérée comme la valeur de retour. Nul besoin d'utiliser le mot-clé return.
Le mot-clé it
Lorsqu’une lambda n’a qu’un seul paramètre, Kotlin permet d’y accéder sans avoir à le déclarer explicitement, à l’aide du mot-clé it. Cela rend la lambda plus concise et plus lisible.
Voici la même expression lambda que présentée plus haut, mais utilisant le mot-clé it à la place de n -> ... :
fun main() {
val resultat = appliquerOperation(5, { it * 2 })
println(resultat) // 10
}
Différentes signatures possibles
Le type d'une lambda décrit ses paramètres et sa valeur de retour. Il existe plusieurs variétés de signatures possibles :
// Avec paramètres et valeur de retour
(Int, Int) -> Int // ex. : { a, b -> a + b }
// Avec paramètres, sans valeur de retour
(Int, Int) -> Unit // ex. : { a, b -> println(a + b) }
// Sans paramètre, avec valeur de retour
() -> String // ex. : { "Bonjour" }
// Sans paramètre ni valeur de retour
() -> Unit // ex. : { println("Salut !") }
Exemple avec () -> Unit
fun repeter(fois: Int, action: () -> Unit) {
for (i in 1..fois) {
action()
}
}
fun main() {
repeter(3, { println("Salut !") }) // Affichera 3x "Salut !" dans la console
}
Osbervez les fonctions suivantes :
fun filtrerPairs(l: List<Int>): List<Int> { /* boucle + if (n % 2 == 0) */ }
fun filtrerPositifs(l: List<Int>): List<Int> { /* boucle + if (n > 0) */ }
fun filtrerPlusGrandsQueCent(l: List<Int>): List<Int> { /* boucle + if (n > 100) */ }
Consigne :
- Identifiez ce qui est identique dans les trois fonctions, et ce qui change.
- Écrivez une seule fonction
filtrerqui remplace les trois. Requis :filtrerdevra prendre une lambda en paramètre ! - Écrivez les trois appels correspondants dans le
main. Utilisez cette liste :val liste = listOf(-3, 4, 150, 7).
Solution:
fun main() {
val liste = listOf(-3, 4, 150, 7)
filtrer(liste, { it % 2 == 0 })
filtrer(liste, { it > 0 })
filtrer(liste, { it > 100 })
}
fun filtrer(l: List<Int>, condition: (Int) -> Boolean): List<Int> {
val resultat = mutableListOf<Int>()
for (n in l) {
if (condition(n)) {
resultat.add(n)
}
}
return resultat
}
La trailing lambda
Lorsque le dernier paramètre d'une fonction est une lambda, on peut écrire cette lambda après les parenthèses. On appelle cela une trailing lambda. C'est seulement une alternative syntaxique : la lambda conserve le même comportement.
Lambda à l'intérieur des parenthèses
val resultat = appliquerOperation(5, { it * 2 })
println(resultat) // 10
Lambda après les parenthèses
val resultat = appliquerOperation(5) { it * 2 }
println(resultat) // 10
Une lambda peut être déportée seulement si elle est le dernier paramètre d'une fonction. Si une fonction possède deux lambdas, la première doit être définie dans les parenthèses, alors que la seconde peut être déportée. Nous verrons un exemple avec Button plus bas.
- Réécrivez les trois appels de
filtreravec une trailing lambda.
Solution
filtrer(liste) { it % 2 == 0 }
filtrer(liste) { it > 0 }
filtrer(liste) { it > 100 }
Où trouvons-nous des lambdas avec Compose ?
Regardons la signature de notre fonction composable préférée. Combien de paramètres de Button sont des lambdas ?
@Composable
fun Button(
onClick: () -> Unit,
modifier: Modifier = Modifier,
enabled: Boolean = true,
shape: Shape = ButtonDefaults.shape,
colors: ButtonColors = ButtonDefaults.buttonColors(),
elevation: ButtonElevation? = ButtonDefaults.buttonElevation(),
border: BorderStroke? = null,
contentPadding: PaddingValues = ButtonDefaults.ContentPadding,
interactionSource: MutableInteractionSource? = null,
content: @Composable RowScope.() -> Unit
)
Deux ! onClick et content.
Puisque content est une lambda, et qu'elle est le dernier paramètre de Button, elle peut être déportée :
// Appel sans trailing lambda
Button(
onClick = { println("Clic !") },
content = { Text("Cliquez-moi") }
)
// Appel avec trailing lambda
Button(
onClick = { println("Clic !") }
)
{
Text("Cliquez-moi")
}
Les deux appels sont équivalents.
Information additionnelle
RowScope fournit des modificateurs qui n'ont de sens que dans une Row, comme Modifier.weight() et Modifier.align() :
Row {
Text("A", modifier = Modifier.weight(1f)) // OK : on est dans un RowScope
Text("B", modifier = Modifier.weight(2f))
}
Text("C", modifier = Modifier.weight(1f)) // Erreur : pas de RowScope ici
Pour aller plus loin
Exemple : Assigner une lambda à une variable
Une lambda peut être assignée à une variable. Il suffit de placer directement la lambda dans une variable, puis on utilise cette variable pour l'appeler.
fun main() {
val somme: (Int, Int) -> Int = { n, m -> n + m }
val resultat = somme(5, 4)
println(resultat) // 9
}
Exemple : retourner une lambda à partir d’une fonction
Une lambda peut également être une valeur de retour. Prenons une fonction nommée creerOperation() qui retourne une opération que l’on pourra exécuter plus tard. Quelle serait la signature de cette fonction ?
fun creerOperation(): (Int) -> Int {
return { n -> n * 2 }
}
Comment faire appel à cette fonction dans un main() ?
fun main() {
val operation = creerOperation()
val resultat = operation(5)
println(resultat) // 10
}