Add as-> macro documentation (#2392)

* Add as-> macro documentation

* Add as-> in english clojure.html.markdown

2 files changed, 26 insertions, 5 deletions

diff --git a/clojure.html.markdown b/clojure.html.markdown
index 58e835c9..bf9258f7 100644
--- a/clojure.html.markdown
+++ b/clojure.html.markdown
@@ -289,6 +289,19 @@ keymap ; => {:a 1, :b 2, :c 3}
    (into []))    ;=> (into [] (filter odd? (map inc (range 10)))
                  ; Result: [1 3 5 7 9]
 
+; When you are in a situation where you want more freedom as where to
+; put the result of previous data transformations in an 
+; expression, you can use the as-> macro. With it, you can assign a
+; specific name to transformations' output ans use it as a
+; placeholder in your chained expressions:
+
+(as-> [1 2 3] input
+  (map inc input);=> You can use last transform's output at the last position
+  (nth input 4) ;=>  and at the second position, in the same expression
+  (conj [4 5 6] input [8 9 10])) ;=> or in the middle !
+
+
+
 ; Modules
 ;;;;;;;;;;;;;;;
 
diff --git a/fr-fr/clojure-fr.html.markdown b/fr-fr/clojure-fr.html.markdown
index 63bc25b5..65747c0d 100644
--- a/fr-fr/clojure-fr.html.markdown
+++ b/fr-fr/clojure-fr.html.markdown
@@ -275,7 +275,7 @@ ressemblent à toutes les autres formes:
 (let [name "Urkel"]
   (print "Saying hello to " name)
   (str "Hello " name)) ; => "Hello Urkel" (prints "Saying hello to Urkel")
-  
+
 ; Utilisez les Threading Macros (-> et ->>) pour exprimer plus
 ; clairement vos transformations, en y pensant de manière multi-niveaux.
 
@@ -284,10 +284,10 @@ ressemblent à toutes les autres formes:
 ; de la forme suivante, constituant à chaque fois un nouvel étage
 ; de transformation. Par exemple:
 (->  
-   {:a 1 :b 2} 
+   {:a 1 :b 2}
    (assoc :c 3) ;=> Génère ici (assoc {:a 1 :b 2} :c 3)
    (dissoc :b)) ;=> Génère ici (dissoc (assoc {:a 1 :b 2} :c 3) :b)
-   
+
 ; Cette expression est ré-écrite en:
 ; (dissoc (assoc {:a 1 :b 2} :c 3) :b)
 ; et est évaluée en : {:a 1 :c 3}
@@ -302,6 +302,14 @@ ressemblent à toutes les autres formes:
    (into []))    ;=> Génère ici (into [] (filter odd? (map inc (range 10))), ce qui est évalué au final à;
                  ; [1 3 5 7 9]
 
+; Quand vous êtes dans une situation où vous voulez plus de liberté pour choisir 
+; où mettre le résultat des étages précédents, vous pouvez utiliser la
+; macro as->. Avec cette macro, donnez un nom spécifique au résultat de la transformation
+; précédente pour le placer, à votre guise, où bon vous semble dans l'étage courant:
+(as-> [1 2 3] input
+  (map inc input);=> Utilisation du résultat en dernière position
+  (nth input 4) ;=> et en deuxième position, dans la même expression
+  (conj [4 5 6] input [8 9 10])) ;=> ou au milieu !
 
 ; Modules
 ;;;;;;;;;;;;;;;
@@ -370,7 +378,7 @@ ressemblent à toutes les autres formes:
 ; STM
 ;;;;;;;;;;;;;;;;;
 
-; La mémoire logiciel transactionnelle ("Software Transactional Memory") 
+; La mémoire logiciel transactionnelle ("Software Transactional Memory")
 ; est le mécanisme que Clojure utilise pour gérer les états persistents.
 ; Il y a plusieurs formes en Clojure qui utilisent cela.
 
@@ -384,7 +392,7 @@ ressemblent à toutes les autres formes:
 (swap! my-atom assoc :a 1) ; Définit my-atom comme le résultat de (assoc {} :a 1)
 (swap! my-atom assoc :b 2) ; Définit my-atom comme le résultat de (assoc {:a 1} :b 2)
 
-; Use '@' to dereference the atom and get the value 
+; Use '@' to dereference the atom and get the value
 my-atom  ;=> Atom<#...> (Renvoie l'objet Atom)
 @my-atom ; => {:a 1 :b 2}