Skip to content

Update fr translation to last en cheatsheet content and fix some errors #614

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Nov 8, 2016
Merged

Update fr translation to last en cheatsheet content and fix some errors #614

Changes from 1 commit
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
6cb492f
Update to last en cheatsheet content and fix some errors
Nov 3, 2016
3b2ea3b
Use english for comprehension term instead of poor french translation
Nov 8, 2016
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
22 changes: 11 additions & 11 deletions fr/cheatsheets/index.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -17,20 +17,20 @@ language: fr
| `var x: Double = 5` | type explicite |
| <span id="functions" class="h2">fonctions</span> | |
| <span class="label success">Good</span> `def f(x: Int) = { x*x }`<br> <span class="label important">Bad</span> `def f(x: Int) { x*x }` | définition d'une fonction <br> erreur cachée : sans le = c'est une procédure qui retourne un Unit ; occasionnant des problèmes incontrôlés. |
| <span class="label success">Good</span> `def f(x: Any) = println(x)`<br> <span class="label important">Bad</span> `def f(x) = println(x)` | définition d'une fonction <br> erreur de syntaxe : chaque argument à besoin d'être typés. |
| <span class="label success">Good</span> `def f(x: Any) = println(x)`<br> <span class="label important">Bad</span> `def f(x) = println(x)` | définition d'une fonction <br> erreur de syntaxe : chaque argument a besoin d'être typé. |
| `type R = Double` | alias de type |
| `def f(x: R)` vs.<br> `def f(x: => R)` | appel par valeur <br> appel par nom (paramètres paresseux (lazy)) |
| `(x:R) => x*x` | fonction anonyme |
| `(1 to 5).map(_*2)` vs.<br> `(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. |
| <span class="label success">Good</span> `(1 to 5).map(2*)`<br> <span class="label important">Bad</span> `(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. |
| <span class="label success">Good</span> `(1 to 5).map(2*)`<br> <span class="label important">Bad</span> `(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))` <br> `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` <br> `(1 to 5) map (_*2)` | sucre syntaxique pour opérateurs infixés. |
| `def sum(args: Int*) = args.reduceLeft(_+_)` | arguments variadiques. |
Expand All @@ -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._`<br>`breakable {`<br>` for (x <- xs) {`<br>` if (Math.random < 0.1) break`<br>` }`<br>`}`| break. ([transparents](http://www.slideshare.net/Odersky/fosdem-2009-1013261/21)) |
| `for (x <- xs if x%2 == 0) yield x*10` _est équivalent à_ <br>`xs.filter(_%2 == 0).map(_*10)` | pour la compréhension : filter/map |
| `for ((x,y) <- xs zip ys) yield x*y` _est équivalent à_ <br>`(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 à_ <br>`xs flatMap {x => ys map {y => x*y}}` | pour la compréhension : produit cartésien. |
| `for (x <- xs; y <- ys) {`<br> `println("%d/%d = %.1f".format(x,y, x*y))`<br>`}` | pour la compréhension : à la manière impérative <br>[sprintf-style](http://java.sun.com/javase/6/docs/api/java/util/Formatter.html#syntax) |
| `for (i <- 1 to 5) {`<br> `println(i)`<br>`}` | pour la compréhension : itère jusqu'à la borne supérieure comprise. |
| `for (i <- 1 until 5) {`<br> `println(i)`<br>`}` | 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 à_ <br>`xs.filter(_%2 == 0).map(_*10)` | compréhension avec for: filter/map |
| `for ((x,y) <- xs zip ys) yield x*y` _est équivalent à_ <br>`(xs zip ys) map { case (x,y) => x*y }` | compréhension avec for : liaison déstructurée |
| `for (x <- xs; y <- ys) yield x*y` _est équivalent à_ <br>`xs flatMap {x => ys map {y => x*y}}` | compréhension avec for : produit cartésien. |
| `for (x <- xs; y <- ys) {`<br> `println("%d/%d = %.1f".format(x,y, x*y))`<br>`}` | compréhension avec for : à la manière impérative <br>[sprintf-style](http://java.sun.com/javase/6/docs/api/java/util/Formatter.html#syntax) |
| `for (i <- 1 to 5) {`<br> `println(i)`<br>`}` | compréhension avec for : itère jusqu'à la borne supérieure comprise. |
| `for (i <- 1 until 5) {`<br> `println(i)`<br>`}` | compréhension avec for : itère jusqu'à la borne supérieure non comprise. |
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I wonder whether "for en compréhension" would be a more exact translation of "for comprehension". After all, this what we use in math: we can define "un ensemble en compréhension" (the syntax { x € Z | x > -10 }).

But that's French pedantry. TBH when I speak French I say "for comprehension" in English anyway. I would stick to the English term for this.

| <span id="pattern_matching" class="h2">pattern matching</span> | |
| <span class="label success">Good</span> `(xs zip ys) map { case (x,y) => x*y }`<br> <span class="label important">Bad</span> `(xs zip ys) map( (x,y) => x*y )` | cas d’utilisation d’une fonction utilisée avec un "pattern matching". |
| <span class="label important">Bad</span><br>`val v42 = 42`<br>`Some(3) match {`<br>` case Some(v42) => println("42")`<br>` case _ => println("Not 42")`<br>`}` | "v42" est interprété comme un nom ayant n’importe quelle valeur de type Int, donc "42" est affiché. |
Expand All @@ -69,7 +69,7 @@ language: fr
| <span id="object_orientation" class="h2">l'orienté objet</span> | |
| `class C(x: R)` _est équivalent à_ <br>`class C(private val x: R)`<br>`var c = new C(4)` | paramètres du constructeur - privé |
| `class C(val x: R)`<br>`var c = new C(4)`<br>`c.x` | paramètres du constructeur - public |
| `class C(var x: R) {`<br>`assert(x > 0, "positive please")`<br>`var y = x`<br>`val readonly = 5`<br>`private var secret = 1`<br>`def this = this(42)`<br>`}`|<br>le constructeur est dans le corps de la classe<br>déclare un membre public<br>are un accesseur<br>déclare un membre privé<br>constructeur alternatif |
| `class C(var x: R) {`<br>`assert(x > 0, "positive please")`<br>`var y = x`<br>`val readonly = 5`<br>`private var secret = 1`<br>`def this = this(42)`<br>`}`|<br>le constructeur est dans le corps de la classe<br>déclare un membre public<br>déclare un accesseur<br>déclare un membre privé<br>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. |
Expand Down