L10n fr for partial-application exercises

Author: tdd

exercises/partial_application_with_bind/problem.fr.md

@@ -0,0 +1,43 @@
+RESUME/FIXME
+
+# Défi
+
+**Utilisez `Function#bind()`** pour implémenter une fonction de log qui vous permet de préfixer vos messages.
+
+Votre implémentation doit accepter une `String` de préfixe, et renvoyer une fonction qui affichera les contenus qu’on lui passe sur la console, préfixée par cette `String`.
+
+Assurez-vous que **tous** les arguments passés à la fonction de log (celle renvoyée par la fonction que vous allez écrire) sont bien affichés.
+
+**Affichez le résultat directement sur la console.**
+
+## Arguments
+
+* `namespace` : une `String` qui préfixe les messages passés à la fonction qui sera retournée.
+
+## Exemple
+
+```js
+var info = logger('INFO :')
+info('ceci est un message d’information')
+// INFO : ceci est un message d’information
+
+var warn = logger('WARN :')
+warn('ceci est un avertissement', 'avec du rab')
+// WARN : ceci est un avertissement avec du rab
+```
+
+## Conditions
+
+* Utilisez `Function#bind()`
+
+## Base de travail
+
+```js
+module.exports = function logger(namespace) {
+  // VOTRE SOLUTION ICI
+}
+```
+
+## Resources
+
+* https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/bind

exercises/partial_application_without_bind/problem.fr.md

@@ -0,0 +1,109 @@
+L’application partielle vous permet de créer de nouvelles fonctions à partir de fonctions existantes, en pré-remplissant tout ou partie de leurs arguments.  Une fois les arguments pré-remplis définis, vous obtenez une nouvelle fonction qui n’attend plus que les éventuels arguments restants pour exécuter la fonction d’origine.
+
+Plus formellement : l’application partielle désigne le pré-remplissage d’arguments d’une fonction pour produire une fonction de moindre arité.
+
+À titre d’exemple, imaginons que nous avons une fonction `add()` qui accepte deux arguments et renvoie leur somme :
+
+```js
+function add(x, y) {
+  return x + y
+}
+
+add(10, 20) // => 30
+```
+
+À présent, imaginons que nous disposons d’une fonction `partiallyApply()`.  Celle-ci reçoit une fonction et quelques arguments qu’elle « applique partiellement » (qu’elle pré-remplit, en somme).
+
+Dans le code qui suit, nous pré-remplissons le premier argument de notre fonction `add()`, à savoir `x` :
+
+```js
+var addTen = partiallyApply(add, 10) // pré-remplit `x` à 10
+```
+
+`addTen()` est une nouvelle fonction, qui n’a plus besoin que du paramètre `y` de `add()`.  `add()` n’a pas encore été appelée !
+
+Une fois que nous passons l’argument pour `y`, la fonction `add()` originale peut être appelée :
+
+```js
+addTen(20)  // => 30
+addTen(100) // => 110
+addTen(0)   // => 10
+// etc.
+```
+
+Tous les exemples ci-dessus reviennent à appeler `add(10, y)`, ou `y` serait fourni dans l’appel à la bien-nommée `addTen()`.
+
+# Défi
+
+Utilisez l’application partielle pour créer une fonction qui pré-remplit un premier argument pour `console.log()`.  En somme, implémentez une fonction de log qui préfixe son message.
+
+Votre implémentation doit accepter une `String` de préfixe, et renvoyer une fonction qui affichera les contenus qu’on lui passe sur la console, préfixée par cette `String`.
+
+Vous aurez besoin de `Function#apply()` pour implémenter l’application partielle.
+
+Assurez-vous que **tous** les arguments passés à la fonction de log (celle renvoyée par la fonction que vous allez écrire) sont bien affichés.
+
+**Affichez le résultat directement sur la console.**
+
+## Arguments
+
+* `namespace` : une `String` qui préfixe les messages passés à la fonction qui sera retournée.
+
+## Exemple
+
+```js
+var info = logger('INFO :')
+info('ceci est un message d’information')
+// INFO : ceci est un message d’information
+
+var warn = logger('WARN :')
+warn('ceci est un avertissement', 'avec du rab')
+// WARN : ceci est un avertissement avec du rab
+```
+
+## Conditions
+
+* N’utilisez pas `Function#bind()`
+* Utilisez `Function#apply()`
+
+## Base de travail
+
+```js
+var slice = Array.prototype.slice
+
+function logger(namespace) {
+  // VOTRE SOLUTION ICI
+}
+
+module.exports = logger
+```
+
+## Ressources
+
+* https://en.wikipedia.org/wiki/Partial_application
+* https://developer.mozilla.org/fr/docs/Web/JavaScript/Reference/Objets_globaux/Function/apply
+
+## Conseils
+
+Gardez à l’esprit que `console.log()` accepte un nombre quelconque d’arguments et les affiche, séparés par des espaces :
+
+```js
+console.log('bonjour', 'monde') // => 'bonjour monde'
+console.log(1, 2, 3)            // => 1 2 3
+```
+
+Nous voulons simplement pré-remplir le premier argument de `console.log()`.
+
+`Function#apply()` nous permet d’exécuter une fonction, en fournissant une valeur spécifique pour `this` (ce qu’on peut royalement ignorer sur ce coup), puis un **tableau d’arguments à passer à la fonction** :
+
+```js
+add(10, 20)               // => 30
+add.apply(null, [10, 20]) // => 30
+```
+
+Faites bien la différence entre `apply()` et `call()` :
+
+```js
+add.apply(null, [10, 20]) // => 30
+add.call(null, 10, 20)    // => 30
+```