Programmation fonctionnelle en Kotlin : principes et exemples

Introduction à la programmation fonctionnelle en Kotlin

Kotlin est un langage moderne multi-paradigme qui combine harmonieusement la programmation orientée objet et fonctionnelle. Le style fonctionnel permet d'écrire un code plus prévisible, concis et testable. Dans cet article, nous allons aborder les concepts clés de la programmation fonctionnelle (PF) en Kotlin : les fonctions pures, l'immutabilité des données, les fonctions d'ordre supérieur et le travail avec les collections via map, filter et fold. Ce contenu est destiné aux développeurs déjà familiers avec les bases de la syntaxe Kotlin.

Fonctions pures et immutabilité

Qu'est-ce qu'une fonction pure ?

Une fonction pure est une fonction qui :

• Retourne toujours le même résultat pour les mêmes arguments (déterminisme).
• N'a pas d'effets secondaires (ne modifie pas l'état externe, ne lit pas de variables globales, n'effectue pas d'entrées/sorties).

Exemple de fonction pure :

fun sum(a: Int, b: Int): Int = a + b

Exemple de fonction impure (dépend de l'état externe) :

var counter = 0fun impureSum(a: Int, b: Int): Int {    counter++ // effet secondaire    return a + b}

Immutabilité

En PF, on évite de modifier les données après leur création. En Kotlin, on utilise pour cela :

• val au lieu de var pour déclarer des références immuables.
• Les collections immuables : listOf, mapOf, setOf.
• La copie d'objets avec modifications via copy() pour les data classes.

data class User(val name: String, val age: Int)

fun main() {    val user = User("Alice", 25)    val updatedUser = user.copy(age = 26) // création d'une nouvelle copie    println(user)        // User(name=Alice, age=25)    println(updatedUser) // User(name=Alice, age=26)}

Avantages de l'immutabilité : simplification du débogage, sécurité des threads, prévisibilité du code.

Fonctions d'ordre supérieur et expressions lambda

Les fonctions comme valeurs

En Kotlin, les fonctions peuvent être passées en arguments, retournées par d'autres fonctions et stockées dans des variables. C'est la base du style fonctionnel.

// Fonction qui prend une autre fonction en paramètrefun operateOnNumbers(a: Int, b: Int, operation: (Int, Int) -> Int): Int {    return operation(a, b)}

fun main() {    val sum = operateOnNumbers(5, 3) { x, y -> x + y }    val product = operateOnNumbers(5, 3) { x, y -> x * y }    println("Somme : $sum, Produit : $product")}

Expressions lambda

Une lambda est une fonction anonyme écrite de manière compacte. Syntaxe : { arguments -> corps }.

val square: (Int) -> Int = { x -> x * x }val result = square(4) // 16

// S'il n'y a qu'un seul argument, on peut utiliser le nom implicite itval double: (Int) -> Int = { it * 2 }

Fonctions d'ordre supérieur intégrées

Kotlin fournit de nombreuses fonctions utiles pour travailler avec les collections :

• map — transforme chaque élément.
• filter — conserve les éléments qui satisfont une condition.
• fold — réduit la collection à une seule valeur avec un accumulateur initial.

fun main() {    val numbers = listOf(1, 2, 3, 4, 5)

    // map : élever au carré    val squares = numbers.map { it * it }    println(squares) // [1, 4, 9, 16, 25]

    // filter : ne garder que les pairs    val evens = numbers.filter { it % 2 == 0 }    println(evens) // [2, 4]

    // fold : somme de tous les éléments    val sum = numbers.fold(0) { acc, element -> acc + element }    println(sum) // 15

    // Chaînage d'appels : carrés pairs    val evenSquares = numbers        .filter { it % 2 == 0 }        .map { it * it }    println(evenSquares) // [4, 16]}