 
 "Pour contourner cette limitation apparente, nous avons le do opérateur:"
 
+(exercice
+  "Vous ferez face à de nombreuses décisions"
+  [ (= __ (if (false? (= 4 5))
+            :a
+            :b))] :a)
+
+
+(exercice
+  "Certains d'entre eux vous laisse pas d'alternative"
+  [(= __ (if (> 4 3)
+           []))] [])
+
+
+(exercice
+  "Et dans une telle situation, vous pouvez ne rien avoir"
+  [(= __ (if (nil? 0)
+           [:a :b :c]))]nil)
+
+
+(exercice
+  "Dans d'autres cas  votre alternative peut être intéressant"
+  [(= :glory (if (not (empty? ()))
+               :doom
+               __))] :glory)
+
+
+(exercice
+  "Ou votre destin peut être scellé"
+  [(= 'doom (if-not (zero? __)
+              'doom
+              'more-doom))]1)
+
+
+(exercice
+  "En cas d'urgence,sonorez les alarmes "
+  [ (= :sirens
+      (explain-defcon-level __))]:cocked-pistol)
+
+
+(exercice
+  "Mais l'admettre quand vous ne savez pas quoi faire"
+  [(= __
+     (explain-defcon-level :yo-mama))] :say-what?)
+
+
 [[:subsection {:tag "do" :title "do"}]]
 
 "*do* vous permet de «boucler» des formes multiples. Essayez ce qui suit dans votre REPL:"


2. Commencez boucle sur les parties du corps. La \"queue\" de la séquence sera lié à *remaining-asym-parts* . Initialement, il est lié à la séquence complète passée à la fonction, *asym-body-parts* . Créer une séquence de résultats, *final-body-parts* ; sa valeur initiale est un vecteur vide.


3. Si remaining-asym-parts est vide, cela signifie que nous avons traité la séquence entière et nous pouvons retourner le résultat, *final-body-parts*.

4. Sinon, diviser la liste en tête, partie , et la queue, *remaining* . En outre, ajouter une *part* à *final-body-parts* de corps et re-lier le résultat du nom *final-body-parts* . Cela peut sembler bizarre, et il est intéressant de comprendre pourquoi cela fonctionne.

"Les vrais Clojurists ne feront presque jamais cela. Cependant, Les vrais Clojurists  utilisent des mots clés pour rechercher les valeurs dans les maps:
"


(exercice
  "Une valeur doit être fournie pour chaque clé"
  [(= {:a 1} (hash-map :a __))] 1)


(exercice
  "La taille est le nombre d'entrées"
  [(= __ (count {:a 1 :b 2}))] 2)

(exercice
  "Vous pouvez rechercher la valeur pour une clé donnée"
  [(= __ (get {:a 1 :b 2} :b))] 2)


(exercice
  "Maps peut êtres utilisé comme une functions pour faire des lookups"
  [(= __ ({:a 1 :b 2} :a))] 1)


(exercice
  "Et peut être utilisé comme un mot clés"
  [(= __ (:a {:a 1 :b 2}))] 1)


(exercice
  "Mais les clés d'une map ne sont pas nécessairement des mots clés"
  [(= __ ({2010 "Vancouver" 2014 "Sochi" 2018 "PyeongChang"} 2014))] "Sochi")


(exercice
  "Vous ne pouvez pas être en mesure de trouver une entrée pour une clé"
  [(= __ (get {:a 1 :b 2} :c))] nil)


(exercice
  "Mais vous pouvez fournir votre propre valeur par défaut"
  [(= __ (get {:a 1 :b 2} :c :key-not-found))] :key-not-found)


(exercice
  "Vous pouvez savoir si une clé est présente"
  [(= __ (contains? {:a nil :b nil} :b))] true)


(exercice
  "Ou si elle est absente"
  [(= __ (contains? {:a nil :b nil} :c))] false)


(exercice
  "Les maps sont immuables, mais vous pouvez créer une nouvelle version améliorée"
  [(= {1 "January" 2 __} (assoc {1 "January"} 2 "February"))] "February")







[[:section {:tags "keywords" :title "Mots Clés"}]]

"Les mots-clés en Clojure sont mieux compris par la façon dont ils sont utilisés. Ils sont principalement utilisés comme clés dans les maps, comme vous pouvez le voir ci-dessus. Exemples de mots clés:"
