Lire le code

★ Méthode systématique

📖 Les méthodes décortiquées

Pour lire un code, il faut savoir exactement ce que chaque appel produit : sa signature, son type de retour, et son comportement aux bords. Voici les méthodes qui reviennent tout le temps.

① Transformer une collection

List(1,2,3).map(_ * 2)        // List(2,4,6)   — 3 éléments → 3 éléments
List("a","bb").map(_.length)    // List(1,2)      — List[String] → List[Int]

List(1,2,3).flatMap(x => List(x, -x))  // List(1,-1, 2,-2, 3,-3)
List("hi","yo").flatMap(_.toList)        // List(h,i,y,o)  — String ≡ Seq[Char]

List(1,2,3,4).collect { case x if x%2==0 => x*x }  // List(4,16)

② Chercher & tester (renvoient un Boolean / Option)

Piège : forall sur une collection vide renvoie toujours true (vacuité). exists sur vide → false.

③ Découper & extraire

List(5,1,3).head   // 5
List(5,1,3).tail   // List(1,3)
Nil.head             // ⚠ NoSuchElementException

Plusieurs renvoient un tuple (splitAt, partition, span) — pense à les déstructurer : val (a, b) = l.partition(_>2).

④ Construire & concaténer une liste

x :: liste     // "cons" : ajoute x EN TÊTE → nouvelle List (O(1))
1 :: 2 :: Nil   // construit List(1,2)  (Nil = liste vide)
l1 ::: l2      // concatène deux List
x +: seq       // prepend (Seq générique)   ;  seq :+ x = append
s1 ++ s2       // concatène deux collections quelconques

En pattern matching, case h :: t lie h = tête et t = reste ; case Nil = liste vide. C'est l'écriture canonique pour parcourir une liste récursivement.

⑤ Agréger : fold & reduce

List(1,2,3).foldLeft(0)(_ + _)
// op(op(op(0,1),2),3) = ((0+1)+2)+3 = 6

List(1,2,3).foldLeft(10)(_ - _)
// ((10-1)-2)-3 = 4   ← l'ordre compte si op non commutative

acc=0 → +1 → acc=1 → +2 → acc=3 → +3 → acc=6

Spécialisés (raccourcis de fold) : sum, product, min, max, maxBy(f) / minBy(f) (max selon une clé), mkString(sep) (concatène en String : List(1,2,3).mkString("-") → "1-2-3"). Bord : collection vide → fold renvoie z ; sum→0 ; mais max sur vide → exception.

⑥ Grouper, trier, zipper

List(1,2,3,4).groupBy(_ % 2)
// Map(1 -> List(1,3), 0 -> List(2,4))

// comptage par groupe : map sur les valeurs
mots.groupBy(identity).map { case (m, l) => m -> l.size }
// ou directement : mots.groupMapReduce(identity)(_ => 1)(_ + _)

zip s'arrête à la plus courte des deux collections (les éléments en trop sont ignorés).

⑦ Option — une « mini-collection » de 0 ou 1 élément

Une Option[T] se manipule comme une collection : map, flatMap, filter marchent dessus. C'est ce qui permet de chaîner sans if ni try.

// chaîner sans exception : tout None court-circuite
val r = users.get("bob")        // Option[User]
            .map(_.email)         // Option[String]
            .filter(_.contains("@"))
            .getOrElse("inconnu")  // String  ← sortie sûre

Lecture la plus courante : match { case Some(x) => … ; case None => … }. Le getOrElse est le « point de sortie » qui transforme un Option[T] en T.

⑧ Map & String

m(k)            // V — ⚠ throw si absent
m.get(k)        // Option[V] — safe
m.getOrElse(k,d)// V ou défaut
m.contains(k)   // Boolean
m + (k -> v)    // ajout/maj
m - k           // retrait
m.keys  m.values

s.split(" ")     // Array[String]
s.trim          // enlève espaces
s.toInt         // ⚠ throw si pas un nb
s.length
s.map(_.toUpper)// map sur les Char
l.mkString(",")  // liste → String

⑨ Akka — les méthodes des acteurs

Clé de lecture : actorOf renvoie un ActorRef (une référence, jamais l'objet acteur). Un acteur traite ses messages séquentiellement → un var interne est safe. La concurrence est entre acteurs, donc l'ordre des messages de deux expéditeurs est non déterministe.

1. Lambda et map

scala> val nums = List(1, 2, 3, 4)
scala> val result = nums.map(x => x * x).filter(_ > 5)

2. Pattern matching sur Option

def safeDiv(a : Int, b : Int) : Option[Int] =
   if (b == 0) None
   else Some(a / b)

val r = safeDiv(10, 2) match {
   case Some(x) if x > 3 => s"grand: $x"
   case Some(x)          => s"petit: $x"
   case None             => "division par zero"
}

3. Fold sur liste

val data = List(5, 2, 8, 1, 9, 3)

val sumOfEven = data.foldLeft(0) { (acc, x) =>
   if (x % 2 == 0) acc + x else acc
}

val maxVal = data.foldLeft(Int.MinValue)(math.max)

4. Récursivité avec accumulateur

def reverse[T](l : List[T]) : List[T] = {
   def aux(reste : List[T], acc : List[T]) : List[T] =
      reste match {
         case Nil     => acc
         case h :: t => aux(t, h :: acc)
      }
   aux(l, Nil)
}

reverse(List(1, 2, 3))

5. Case class et pattern matching

sealed trait Shape
case class Circle(r : Double) extends Shape
case class Rectangle(w : Double, h : Double) extends Shape
case object Point extends Shape

def area(s : Shape) : Double = s match {
   case Circle(r)       => math.Pi * r * r
   case Rectangle(w, h) => w * h
   case Point           => 0.0
}

6. For-comprehension

val users  = List("alice", "bob", "charlie")
val domains = List("@a.com", "@b.com")

val emails = for {
   u <- users if u.length > 3
   d <- domains
} yield u + d

7. Lazy val et by name

def compute() : Int = { println("calcul") ; 42 }

val      a = compute()
lazy val b = compute()
def      c = compute()

println("--- avant usage ---")
println(a)
println(b)
println(b)
println(c)
println(c)

calcul              ← val a
--- avant usage ---
42                  ← println(a)
calcul              ← b évalué (1er usage)
42                  ← println(b)
42                  ← println(b), b pas re-évalué
calcul              ← c re-évalué
42                  ← println(c)
calcul              ← c re-évalué
42                  ← println(c)

8. Actor Akka

class Counter extends Actor {
   var n : Int = 0
   def receive : Receive = {
      case "inc"  => n += 1
      case "get"  => sender() ! n
   }
}

// Quelque part :
counter ! "inc"
counter ! "inc"
counter ! "inc"
counter ! "get"   // pour celui qui demande

★ Récap des patterns à reconnaître