Accueil Le blog ebiznext
Pattern matching dans les langages fonctionnels et dans Scala en particulier

Certains développeurs sur le net ont une fâcheuse tendance à interpréter le pattern matching Scala comme un super switch. J’aimerais ici dire que j’ai compris qu’il ne s’agit pas du tout de ça.

Ce post prend volontairement un ton assez léger (les passionnés me comprendront)

Un des concepts les plus puissants de Scala est le pattern matching car il nous permet d’abstraire les algorithmes exactement comme on le faisait en mathématiques pour décrire les opérations algébriques.

Grace au pattern matching des langages fonctionnels, l’affectation est relégué à une instruction assembleur. Si si vraiment. Je m’explique:

Quand on veut définir un algorithme , dans 99,99999999999999999999% des cas on le définit en termes de pattern matching. Prenons le cas d’une somme des éléments d’une liste.
Pour réaliser l’algorithme nous exprimerions l’algorithme au professeur de mathématiques comme suit :

Soit f la fonction somme et L la liste
- pour une liste vide, f(l) = 0
- Pour une liste L constituée d’un élément x et d’une sous liste ll, f(l) = x + f(ll)

En scala cela s’écrit presque pareil :

def f(l) = L match {
case Nil => 0
case x::ll => x+f(ll)
}

Pareil pour la fonction max(l)

def max(l) = l match {
case Nil => throw new Exception (“….”)
case x::Nil => x
case x::y::ll if x > y => max(x::ll)
case x::y::ll if y > x => max(y::ll)
}

Et pour le reverse d’une liste c’est pareil aussi :

def reserve(l) l match {
case Nil => Nil
case x::Nil => x
case x::ll => reverse(ll)::x
}

ect ect …

Un de mes outils préférés pour exprimer les algorithmes est sans conteste le pattern matching car enfin il me libère de l’assembleur (oops je voulais dire de opérations de sauvegarde dans un registre intermédiaire que l’on appelle en programmation impérative l’affectation).

Bref dans l’absolu, il n’est jamais nécessaire de faire des affectations intermédiaires pour exprimer un algorithme, sinon attention cela signifie que nous faisons de l’assembleur moderne certes mais de l’assembleur quand meme.

Plus formellement :
La partie entre le mot clef “case” et la flêche “=>” dans le pattern matching est ce que l’on appelle une structure algébrique.

Toutes les structures complexes (arbre / liste / graphe …) peuvent se définir sous la forme de structures algébriques récursives et le pattern match nous permet de décomposer ces structures algébriques.

On le voit bien, on est très très loin du pauvre switch du début de cette note.