diff --git a/fr/cheatsheets/index.md b/fr/cheatsheets/index.md
index 5f114785ae..b15e1dbe30 100644
--- a/fr/cheatsheets/index.md
+++ b/fr/cheatsheets/index.md
@@ -17,20 +17,20 @@ language: fr
| `var x: Double = 5` | type explicite |
| fonctions | |
| Good `def f(x: Int) = { x*x }`
Bad `def f(x: Int) { x*x }` | définition d'une fonction
erreur cachée : sans le = c'est une procédure qui retourne un Unit ; occasionnant des problèmes incontrôlés. |
-| Good `def f(x: Any) = println(x)`
Bad `def f(x) = println(x)` | définition d'une fonction
erreur de syntaxe : chaque argument à besoin d'être typés. |
+| Good `def f(x: Any) = println(x)`
Bad `def f(x) = println(x)` | définition d'une fonction
erreur de syntaxe : chaque argument a besoin d'être typé. |
| `type R = Double` | alias de type |
| `def f(x: R)` vs.
`def f(x: => R)` | appel par valeur
appel par nom (paramètres paresseux (lazy)) |
| `(x:R) => x*x` | fonction anonyme |
| `(1 to 5).map(_*2)` vs.
`(1 to 5).reduceLeft( _+_ )` | fonction anonyme : l'underscore est associé à la position du paramètre en argument. |
| `(1 to 5).map( x => x*x )` | fonction anonyme : pour utiliser un argument deux fois, il faut le nommer. |
-| Good `(1 to 5).map(2*)`
Bad `(1 to 5).map(*2)` | fonction anonyme : méthode bornée et infixée. Il faut utiliser `2*_` pour le bien. |
-| `(1 to 5).map { val x=_*2; println(x); x }` | fonction anonyme : la dernière expression d'un bloc est celle qui est retournée. |
+| Good `(1 to 5).map(2*)`
Bad `(1 to 5).map(*2)` | fonction anonyme : méthode bornée et infixée. Pour votre santé, préférez la syntaxe `2*_`. |
+| `(1 to 5).map { x => val y=x*2; println(y); y }` | fonction anonyme : la dernière expression d'un bloc est celle qui est retournée. |
| `(1 to 5) filter {_%2 == 0} map {_*2}` | fonctions anonymes : style "pipeline". (ou avec des parenthèses). |
| `def compose(g:R=>R, h:R=>R) = (x:R) => g(h(x))`
`val f = compose({_*2}, {_-1})` | fonctions anonymes : pour passer plusieurs blocs, il faut les entourer par des parenthèses. |
| `val zscore = (mean:R, sd:R) => (x:R) => (x-mean)/sd` | curryfication, syntaxe évidente. |
| `def zscore(mean:R, sd:R) = (x:R) => (x-mean)/sd` | curryfication, syntaxe évidente. |
| `def zscore(mean:R, sd:R)(x:R) = (x-mean)/sd` | curryfication, sucre syntaxique. mais alors : |
-| `val normer = zscore(7, 0.4)_` | il faut traiter l'underscore dans la fonction partielle, mais ceci uniquement pour la version avec le sucre syntaxique. |
+| `val normer = zscore(7, 0.4) _` | il faut ajouter l'underscore dans la fonction partielle, mais ceci uniquement pour la version avec le sucre syntaxique. |
| `def mapmake[T](g:T=>T)(seq: List[T]) = seq.map(g)` | type générique. |
| `5.+(3); 5 + 3`
`(1 to 5) map (_*2)` | sucre syntaxique pour opérateurs infixés. |
| `def sum(args: Int*) = args.reduceLeft(_+_)` | arguments variadiques. |
@@ -55,12 +55,12 @@ language: fr
| `while (x < 5) { println(x); x += 1}` | boucle while. |
| `do { println(x); x += 1} while (x < 5)` | boucle do while. |
| `import scala.util.control.Breaks._`
`breakable {`
` for (x <- xs) {`
` if (Math.random < 0.1) break`
` }`
`}`| break. ([transparents](http://www.slideshare.net/Odersky/fosdem-2009-1013261/21)) |
-| `for (x <- xs if x%2 == 0) yield x*10` _est équivalent à_
`xs.filter(_%2 == 0).map(_*10)` | pour la compréhension : filter/map |
-| `for ((x,y) <- xs zip ys) yield x*y` _est équivalent à_
`(xs zip ys) map { case (x,y) => x*y }` | pour la compréhension : liaison déstructurée |
-| `for (x <- xs; y <- ys) yield x*y` _est équivalent à_
`xs flatMap {x => ys map {y => x*y}}` | pour la compréhension : produit cartésien. |
-| `for (x <- xs; y <- ys) {`
`println("%d/%d = %.1f".format(x,y, x*y))`
`}` | pour la compréhension : à la manière impérative
[sprintf-style](http://java.sun.com/javase/6/docs/api/java/util/Formatter.html#syntax) |
-| `for (i <- 1 to 5) {`
`println(i)`
`}` | pour la compréhension : itère jusqu'à la borne supérieure comprise. |
-| `for (i <- 1 until 5) {`
`println(i)`
`}` | pour la compréhension : itère jusqu'à la borne supérieure non comprise. |
+| `for (x <- xs if x%2 == 0) yield x*10` _est équivalent à_
`xs.filter(_%2 == 0).map(_*10)` | *for comprehension*: filter/map |
+| `for ((x,y) <- xs zip ys) yield x*y` _est équivalent à_
`(xs zip ys) map { case (x,y) => x*y }` | *for comprehension* : liaison déstructurée |
+| `for (x <- xs; y <- ys) yield x*y` _est équivalent à_
`xs flatMap {x => ys map {y => x*y}}` | *for comprehension* : produit cartésien. |
+| `for (x <- xs; y <- ys) {`
`println("%d/%d = %.1f".format(x,y, x*y))`
`}` | *for comprehension* : à la manière impérative
[sprintf-style](http://java.sun.com/javase/6/docs/api/java/util/Formatter.html#syntax) |
+| `for (i <- 1 to 5) {`
`println(i)`
`}` | *for comprehension* : itère jusqu'à la borne supérieure comprise. |
+| `for (i <- 1 until 5) {`
`println(i)`
`}` | *for comprehension* : itère jusqu'à la borne supérieure non comprise. |
| pattern matching | |
| Good `(xs zip ys) map { case (x,y) => x*y }`
Bad `(xs zip ys) map( (x,y) => x*y )` | cas d’utilisation d’une fonction utilisée avec un "pattern matching". |
| Bad
`val v42 = 42`
`Some(3) match {`
` case Some(v42) => println("42")`
` case _ => println("Not 42")`
`}` | "v42" est interprété comme un nom ayant n’importe quelle valeur de type Int, donc "42" est affiché. |
@@ -69,7 +69,7 @@ language: fr
| l'orienté objet | |
| `class C(x: R)` _est équivalent à_
`class C(private val x: R)`
`var c = new C(4)` | paramètres du constructeur - privé |
| `class C(val x: R)`
`var c = new C(4)`
`c.x` | paramètres du constructeur - public |
-| `class C(var x: R) {`
`assert(x > 0, "positive please")`
`var y = x`
`val readonly = 5`
`private var secret = 1`
`def this = this(42)`
`}`|
le constructeur est dans le corps de la classe
déclare un membre public
are un accesseur
déclare un membre privé
constructeur alternatif |
+| `class C(var x: R) {`
`assert(x > 0, "positive please")`
`var y = x`
`val readonly = 5`
`private var secret = 1`
`def this = this(42)`
`}`|
le constructeur est dans le corps de la classe
déclare un membre public
déclare un accesseur
déclare un membre privé
constructeur alternatif |
| `new{ ... }` | classe anonyme |
| `abstract class D { ... }` | définition d’une classe abstraite. (qui n’est pas instanciable). |
| `class C extends D { ... }` | définition d’une classe qui hérite d’une autre. |