L10n fr for final exercises: currying, function call.

Author: tdd

exercises/currying/exercise.js

@@ -6,7 +6,7 @@
 
 var runner = require('../runner')
 
-module.exports = runner.custom(function(curryN) {
+var exercise = module.exports = runner.custom(function(curryN) {
   function add3(one, two, three) {
     return one + two + three
   }
@@ -27,8 +27,10 @@ module.exports = runner.custom(function(curryN) {
     return Array.prototype.concat.apply([], args).join(" ");
   }
 
+  var words = exercise.__('five_words').split(',')
+  var call = words.map(function(word) { return "('" + word + "')" }).join('')
   result.push(
-    "curryN(strConcat, 5)('This')('problem')('has')('been')('solved')) => " +
-    curryN(strConcat, 5)('This')('problem')('has')('been')('solved'))
+    "curryN(strConcat, 5)" + call + ") => " +
+    curryN(strConcat, 5)(words[0])(words[1])(words[2])(words[3])(words[4]))
   return result
 }).hideInput()

exercises/currying/problem.fr.md

@@ -0,0 +1,74 @@
+Voici un exemple d’implémentation de `curry3()`, qui « curryfie » jusqu’à 3 arguments :
+
+```js
+function curry3(fun){
+  return function(three){
+    return function(two){
+      return function (one){
+        return fun(one, two, three)
+      }
+    }
+  }
+}
+```
+
+Si nous devions utiliser cette implémentation avec la fonction d’exemple suivante :
+
+```js
+function abc(one, two, three) {
+  return one/two/three
+}
+```
+
+Ça donnerait quelque chose comme ça :
+
+```js
+var curryC = curry3(abc)
+var curryB = curryC(2)
+var curryA = curryB(3)
+
+console.log(curryA(6)) // => 1
+```
+
+# Défi
+
+Dans cet exercice, nous allons implémenter la fonction `curry()` pour un nombre quelconque d’arguments.
+
+`curryN()` acceptera deux paramètres :
+
+* `fn` : la fonction à « curryfier ».
+* `n` : un nombre optionnel d’arguments à « curryfier ».  Si cet argument est manquant, `curryN()` utilisera l’arité de `fn` à la place (c’est-à-dire son nombre de paramètres déclarés).
+
+## Exemple
+
+```js
+function add3(one, two, three) {
+  return one + two + three
+}
+
+var curryC = curryN(add3)
+var curryB = curryC(1)
+var curryA = curryB(2)
+console.log(curryA(3))  // => 6
+console.log(curryA(10)) // => 13
+
+console.log(curryN(add3)(1)(2)(3)) // => 6
+```
+
+## Conditions
+
+* N’utilisez ni boucle (`for`, `while`…) ni `Array.prototype.forEach`
+
+## Conseil
+
+On peut détecter l’arité d’une fonction avec la propriété `.length` de celle-ci.
+
+## Base de travail
+
+```js
+function curryN(fn, n) {
+  // VOTRE SOLUTION ICI
+}
+
+module.exports = curryN
+```

exercises/currying/solution_fr/solution.js

@@ -0,0 +1,26 @@
+function curryN(fn, n) {
+  // Si l’argument `n` est absent, on utilise la propriété `.length` de la fonction.
+  if (typeof n !== 'number') n = fn.length
+
+  function getCurriedFn(prev) {
+    return function(arg) {
+      // Concatène l’argument qui vient d’être passé avec le tableau des arguments
+      // déjà spécifiés.
+      var args = prev.concat(arg)
+      // Si tous les arguments ne sont pas encore pré-remplis, renvoie
+      // la version currifiée de la fonction originale.
+      if (args.length < n) return getCurriedFn(args)
+      // Sinon, invoque la fonction d’origine avec les arguments, et
+      // renvoie sa valeur de retour.
+      else return fn.apply(this, args)
+    };
+  }
+
+  // Renvoie une version currifiée de la fonction d’origine.
+  return getCurriedFn([])
+}
+
+module.exports = curryN
+
+// Source de cette solution :
+// http://benalman.com/news/2012/09/partial-application-in-javascript/#manually-specifying-function-arity

exercises/function_call/problem.fr.md

@@ -0,0 +1,69 @@
+## Défi
+
+Écrivez une fonction qui vous permet d’utiliser `Array.prototype.slice` sans avoir à utiliser
+ `.call` pour l’invoquer.
+
+En temps normal, vous devriez appeler `slice()` à l’aide de `call()` ou `apply()` :
+
+```js
+var slice = Array.prototype.slice
+
+function() {
+  var args = slice.call(arguments) // ça marche
+}
+```
+
+Nous, on veut que le code suivant marche :
+
+```js
+var slice = yourFunction
+
+function() {
+  var args = slice(arguments) // ça marche
+}
+```
+
+## Exemple
+
+Votre fonction `slice()` devrait avoir le comportement suivant :
+
+```js
+var nums = [1,2,3,4,5]
+
+// Votre fonction slice doit correspondre au comportement
+// de la fonction slice standard, à ceci près qu'elle reçoit
+// le tableau comme premier argument.
+
+slice(nums, 0, 2) // [1, 2]
+slice(nums, 1, 2) // [2]
+
+// Avec le slice standard, pour comparaison
+nums.slice(0, 2) // [1, 2]
+nums.slice(1, 2) // [2]
+```
+
+## Conditions
+
+* N’utilisez ni boucle (`for`, `while`…) ni `Array.prototype.forEach`
+* N’utilisez pas le mot-clé `function` :D
+
+## Conseils
+
+* La solution fait une seule ligne.  Même pas longue.
+* Tout fonction JavaScript hérite de méthodes telles que `call()`, `apply()` et `bind()`, provenant de l’objet `Function.prototype`.
+* `Function#call()` fonctionne quelle que soit la fonction sur laquelle on l’appelle (par exemple dans `someFunction.call()`, `this` à l’exécution sera `someFunction`).
+* `Function#call()` est elle-même une fonction, et hérite donc de `Function.prototype` :
+
+```js
+function myFunction() {
+  console.log("J’ai appelé ma fonction")
+}
+
+Function.prototype.call.call(myFunction) // => "J’ai appelé ma fonction"
+```
+
+## Base de travail
+
+```js
+module.exports = // VOTRE SOLUTION ICI !
+```

exercises/function_call/solution_fr/solution.js

@@ -0,0 +1,14 @@
+// Explication :
+//
+// La valeur de `this` dans `Function#call()` est la fonction
+// sur laquelle on appelle `call()`.
+//
+// `bind()` renvoie une nouvelle fonction dont la valeur de
+// `this` est définie à ce qu’on lui a passé comme premier argument.
+//
+// Toute fonction « hérite » `Function.prototype`, et donc toute fonction,
+// y compris `call()`, `apply()` et `bind()`, a les méthodes `apply()`
+// et `bind()`.
+//
+// Function.prototype.call === Function.call
+module.exports = Function.call.bind(Array.prototype.slice)

i18n/en.json

@@ -41,6 +41,9 @@
       "all_loaded": "All %d users loaded!",
       "bad_result": "expected: \n%s\n but got:\n%s",
       "took_too_long": "Took too long!"
+    },
+    "Currying": {
+      "five_words": "This,problem,has,been,solved"
     }
   }
 }

i18n/fr.json

@@ -61,6 +61,9 @@
       "all_loaded": "L’ensemble des %d utilisateurs a été chargé !",
       "bad_result": "j’attendais : \n%s\n mais j’ai reçu :\n%s",
       "took_too_long": "Ça a pris trop longtemps !"
+    },
+    "Currying": {
+      "five_words": "Ce,problème,est,désormais,résolu"
     }
   }
 }