Programmation fonctionnelle

1. Définition

Une fonction est une expression qui prend en entrée des arguments et renvoie un résultat. Elle est semblable à une méthode mais c’est un objet et elle peut donc être manipulée de façon différente.

Pour définir une fonction, on utilise la syntaxe (t: T) => ???. La partie gauche correspond aux arguments du type désiré et la partie droite aux opérations effectuées sur ces paramètres.

La fonction est alors un objet de type T => U où U est le type de l’objet retourné dans la partie de droite. Une fonction peut prendre un, aucun ou plusieurs arguments.

Exemple de fonction à un argument

Prenons comme exemple une fonction qui multiplie un Int par 1.2.

val fonctionUnArg = (i: Int) => i * 1.2 
// fonctionUnArg: Int => Double = <function>785a95b 

Sans spécifier son type de retour, il est automatiquement inféré à Double par le compilateur.

Exemple de fonction à deux arguments

Prenons comme exemple une fonction qui multiplie un Int à un Double. Le résultat par défaut sera un Double.

val fonctionDeuxArg = (i: Int, j: Double) => i * j 
// fonctionDeuxArg: (Int, Double) => Double = <function>25521b7 

On peut forcer le type de retour à BigDecimal et compter sur la conversion entre le type Double et BigDecimal. Le type de retour spécifié prévaut sur le type inféré par le compilateur.

val fonctionDeuxArgDecimal: (Int, Double) => BigDecimal = (i: Int, 
j: Double) => i * j 
// fonctionDeuxArgDecimal: (Int, Double) => BigDecimal = 
<function>25521b7 

Exemple de fonction sans argument

Prenons comme exemple une fonction qui imprime dans la console le message “Bonjour”. Comme la méthode println est une méthode qui a pour type de retour Unit, la fonction elle aussi a pour type de retour Unit.

val fonctionSansArg...

1. Définition

Un trait est une construction qui se rapproche à la fois de la notion d’interface et de la notion de classe abstraite en Java. On peut y définir des méthodes ou des valeurs accessibles uniquement aux classes qui l’étendent.

Comme dans une interface, on peut définir des fonctions sans les implémenter. Dans ce cas, toutes les implémentations qui étendent ce trait devront implémenter cette fonction.

Comme dans une classe abstraite, on peut définir des fonctions concrètes. Dans ce cas, tous les éléments qui étendent ce trait auront accès à cette fonction.

2. Étendre un trait

Prenons comme exemple un trait Animal qui définit les fonctions abstraites suivantes :

La méthode concrète imprimeSon imprime le son que produit l’animal.

trait Animal { 
 val nombreDePattes: Int 
 def son(): String 
 def imprimeSon(): String = s"L'animal fait ${son()}" 
} 
// defined trait Animal 

On crée une classe Chien qui étend ce trait en utilisant le mot-clé extends et en implémentant la méthode son et la variable nombreDePattes.

class Chien extends Animal { 
 val nombreDePattes: Int = 4 
 def son(): String = "Ouaf !" ...

1. Définition

Une case class est une classe qui présente trois grands avantages supplémentaires.

Premièrement, une méthode apply est systématiquement présente dans son objet compagnon (cf. chapitre Un aperçu du langage - Objets singletons) ce qui permet de créer une instance d’une case class sans le préfixe new. Cela rend le code moins encombré et donc plus lisible.

Deuxièmement, tous ses paramètres sont des val, c’est-à-dire des variables immuables, comme décrit dans le chapitre Un aperçu du langage - Variables, ce qui permet d’y accéder plus facilement.

Troisièmement, les méthodes toString, hashCode et equals sont automatiquement implémentées et de façon plus naturelle : respectivement, elles affichent, hachent et comparent un arbre construit à partir des arguments de la case class. Cela permet de comparer et lire les case class plus efficacement.

Prenons comme exemple une classe abstraite ClasseCouleur et une case class CouleurPleine qui étend cette classe.

abstract class ClasseCouleur 
// defined class ClasseCouleur 
 
case class CouleurPleine(nom: String) extends ClasseCouleur 
// defined class CouleurPleine 

Avec une instance de la classe CouleurPleine, on peut accéder à son paramètre nom.

val couleur = CouleurPleine("rouge") ...

1. Définition

Le pattern matching (filtrage par motif) est utilisé pour effectuer différentes actions selon la valeur de l’objet observé. Il se construit avec la structure match et chaque ligne correspond au mot-clé case. On peut le rapprocher de la structure switch en Java. Il peut se faire sur beaucoup plus d’éléments et présente trois différences majeures.

Premièrement, un match est une expression en Scala et de ce fait renvoie toujours un résultat.

Deuxièmement, si une condition est rencontrée, le match est terminé et on ne passe pas à la condition suivante, il n’y a pas besoin du mot-clé break pour sortir de la structure.

Troisièmement, si aucune des conditions n’est remplie, cela résulte en une exception de type MatchError. Il faut donc bien faire attention à spécifier tous les cas possibles.

Chaque cas peut s’écrire sur une ou plusieurs lignes, auquel cas, comme dans une méthode ou une fonction, c’est la dernière ligne qui fait office de résultat. Dans le cas où le cas fait plusieurs lignes, on n’est pas obligé de l’entourer d’accolades ; cela reste à la discrétion du développeur.

2. Pattern constructeurs

Dans un pattern matching, une instance de case class peut être décomposée soit avec des variables, soit en spécifiant une valeur spécifique ou une constante pour un ou plusieurs des arguments.

On définit la case class Mixte qui prend en paramètres deux CouleurBasique.

case class Mixte(couleurA: CouleurBasique, couleurB: 
CouleurBasique) extends Couleur 
// defined class Mixte 

Dans notre exemple, on peut décomposer une instance de Mixte en Mixte (couleurA, couleurB) où couleurA et couleurB sont ses paramètres de type Couleur.

On définit la méthode extraireMixte qui prend en entrée une Couleur et imprime les deux couleurs mixées d’un objet Mixte. On ajoute un cas spécifique lorsqu’il s’agit d’un mixte de Blanc et Noir.

def extraireMixte(couleur: Couleur) = couleur match { 
 case Mixte(Blanc, Noir) => print("mixte spécial") 
 case Mixte(couleurA, couleurB) => print(s"mixte de $couleurA...

1. Définition

Comme son nom l’indique, la classe typée Option est utilisée pour des valeurs optionnelles. Un objet de ce type peut avoir deux valeurs possibles :

Ce type est souvent utilisé dans les opérations classiques des collections Scala, comme par exemple pour accéder à un élément d’une Map avec la méthode get.

Prenons comme exemple une Map[String, Int] associant un nom d’animal à un nombre.

val animauxMap = Map("chat" -> 4) 
// animauxMap: Map[String, Int] = Map("chat" -> 4) 

Si on appelle la méthode get sur cette variable avec l’argument "chat”, on obtient une Option[Int] non vide.

animauxMap.get("chat") 
// res59: Option[Int] = Some(4) 

Si on appelle la méthode get sur cette variable avec l’argument "chien”, on obtient une Option[Int] vide, autrement dit, None.

animauxMap.get("chien") 
// res60: Option[Int] = None 

Pour créer une Option à partir d’un objet non nul, il suffit d’utiliser la case class Some qui étend la classe Option suivie de la valeur non nulle.

val optionDefinie = Some(12) 
// optionDefinie: Some[Int] = Some(12) 

Pour savoir si une Option est définie ou vide, on utilise les méthodes...

1. Accès aux éléments d’une collection

nombres.head 
// res78: Int = 2 

Nil.head 
// java.util.NoSuchElementException: head of empty list 

nombres.headOption 
// res79: Option[Int] = Some(2) 
 
Nil.headOption 
// res80: Option[Any] = None 

nombres.tail 
// res81: List[Int] = List(3, 5, 8, 13, 21) 

singleton.tail 
// res82: List[Int] = List() 

Nil.tail 
java.lang.UnsupportedOperationException: tail of empty list 

1. try/catch/finally

Comme en Java, il est possible d’encadrer du code pour intercepter les Exception et les traiter. Dans la partie catch, on retrouve un pattern matching décrivant les différents types d’erreurs qu’on peut rencontrer. Dans la partie finally, on peut effectuer des opérations à la fin du bloc, qu’il finisse en erreur ou en succès.

Prenons comme exemple une méthode qui prend en entrée une URL de site Internet sous forme de String et qui imprime le contenu du site.

Dans le bloc try, on va créer une URL à partir de la String et assigner son contenu à une variable contenuDuSite.

Dans le bloc catch, on va intercepter les erreurs liées à une URL incorrecte et celles liées à un site inexistant.

Dans le bloc finally, on imprime le contenu récupéré s’il existe ou une chaîne vide sinon.

import java.io.{FileNotFoundException, IOException} 
import scala.io.Source 
 
def imprimeSite(url: String) = { 
 var contenuDuSite = "" 
 try { 
   contenuDuSite = 
Source.fromURL(URI.create(url).toURL).mkString 
 } catch { 
   case _: IllegalArgumentException => println("URL incorrecte") 
   case _: UnknownHostException => println("Site inconnu") 
 } finally { 
   println(s"Contenu du site $url : $contenuDuSite") 
 } 
} 
// imprimeSite: (nomDeFichier: String)Unit 

Si on appelle cette méthode avec un site existant, la méthode fonctionne correctement. 

imprimeSite("http://www.perdu.com/") 
// Contenu du site http://www.perdu.com/ : <html><head><title>Vous 
Etes Perdu...

1. Définition

Lorsqu’on veut écrire des opérations asynchrones, on fait appel à un Future. Cela correspond à un bloc d’opérations qui sera disponible à un moment, ou, à défaut, renverra une Exception. Le résultat d’un Future est un Try (vu dans la partie Gestion des erreurs) et peut donc avoir deux valeurs possibles :

Future fait partie du package scala.concurrent, il faut l’importer pour pouvoir l’utiliser. De plus, il faut spécifier un contexte d’exécution lors de la manipulation de Future ; pour cela, il suffit d’importer le contexte global présent dans le même paquet et le déclarer dans une variable implicite.

Prenons comme exemple la méthode tacheLongue qui attend 10 secondes puis donne un nombre aléatoire entre 1 et 10.

import scala.concurrent.Future 
import scala.concurrent.ExecutionContext 
import scala.util.Random 
 
implicit val executor: ExecutionContext = ExecutionContext.global 
// executor: scala.concurrent.ExecutionContext = 
scala.concurrent.impl.ExecutionContextImpl@d204ff8 
 
def tacheLongue(): Future[Int] = Future { 
 Thread.sleep(10000) 
 Random.nextInt(10) 
} 
// tacheLongue: ()scala.concurrent.Future[Int] 

Si on appelle cette méthode, l’élément obtenu sera un Future non complété.

val resultat = tacheLongue() 
// resultat: Future[Int] = Future(<not completed>) 

Si on attend 10 secondes, la valeur créée sera disponible. Pour cela, on peut interrompre le thread mais on peut également utiliser la méthode utilitaire result disponible dans l’objet Await. Elle prend en argument un Future...

1. Paramètres implicites

Une méthode ou une classe peuvent prendre en paramètre un argument implicite. 

Prenons comme exemple une liste sur laquelle on applique la méthode sorted. 

Une nouvelle liste ordonnée est créée avec l’Ordering implicite contenu dans la classe String qui trie les éléments par ordre alphabétique.

val liste = List("blanc", "azur", "pourpre", "violet") 
// liste: List[String] = List(blanc, azur, pourpre, violet) 
 
liste.sorted 
// res161: List[String] = List(azur, blanc, pourpre, violet) 

On définit un implicit de type Ordering qui classe des String par taille croissante. Pour cela, on utilise la méthode by propre à Ordering qui permet d’appliquer une fonction anonyme avec la méthode length de String (voir chapitre Un aperçu du langage - Méthodes).

implicit val ordre: Ordering[String] = Ordering.by(_.length) 
// ordre: Ordering[String] = scala.math.Ordering$$anon$7@22ffd61f 
 
liste.sorted 
// res162: List[String] = List(azur, blanc, violet, pourpre) 

On peut aussi appeler cette méthode en renseignant directement l’argument.

liste.sorted(Ordering.String) 
// res163: List[String] = List(azur, blanc, pourpre, violet) 

2. Conversions implicites

Une conversion implicite peut être effectuée dans l’un des deux cas :

val i: Long = 1 
// i: Long = 1 
 
val j: Int = 1L 
// Type mismatch 

1. Définition du service

Le service propose plusieurs méthodes pour gérer la machine :

2. Modèles

Un produit est défini par le trait Produit et chaque type de produit est défini par un case object. Il possède les attributs suivants :

On surcharge la méthode toString pour plus de praticité.

trait Produit { 
 override final def toString: String = code 
 def prix: Double 
 def code: String 
 def quantiteInitiale: Int 
} 

Le trait est étendu par trois traits scellés :

sealed trait Friandise extends Produit { 
 override val prix: Double = 1.0 
 override val quantiteInitiale: Int = 5 
} 

case object Chocolat extends Friandise { 
 override val code: String = "CHO" 
} 
 
case object BarreEnergetique extends Friandise { 
 override val code: String = "BAR" 
 override val prix: Double = 1.5 
} 
 
case object Reglisse extends Friandise { 
 override val code: String = "REG" 
 override...