Pouvez-vous me donner des exemples concrets de la - > macro?

Question

Cela semble être une macro puissante, mais je ne l’applique pas à d’autres exemples que des exemples stupides. Pouvez-vous m'en montrer un réel usage?

Merci!

Answer 1

Comparez:

user> (:baz (:bar (:foo {:foo {:bar {:baz 123}}})))
123
user> (java.io.BufferedReader. (java.io.FileReader. "foo.txt"))
#<BufferedReader java.io.BufferedReader@6e1f8f>
user> (vec (reverse (.split (.replaceAll (.toLowerCase "FOO,BAR,BAZ") "b" "x") ",")))
["xaz" "xar" "foo"]

à:

user> (-> {:foo {:bar {:baz 123}}} :foo :bar :baz)
123
user> (-> "foo.txt" java.io.FileReader. java.io.BufferedReader.)
#<BufferedReader java.io.BufferedReader@7a6c34>
user> (-> "FOO,BAR,BAZ" .toLowerCase (.replaceAll "b" "x") (.split ",") reverse vec)
["xaz" "xar" "foo"]

- > est utilisé lorsque vous souhaitez utiliser un moyen concis pour imbriquer des appels. Il vous permet de répertorier les appels dans l'ordre dans lequel ils seront appelés plutôt que dans l'ordre inverse, ce qui peut être plus lisible. Dans le troisième exemple, notez la distance qui sépare certains des arguments et la fonction à laquelle ils appartiennent. - > vous permet de grouper les arguments et les appels de fonction un peu plus proprement. Parce que c'est une macro, cela fonctionne aussi pour les appels Java, ce qui est agréable.

- > n’est pas si puissant que cela, il vous fait juste économiser quelques parenthèses de temps en temps. L’utiliser ou non est une question de style et de lisibilité.

Regardez au bas de clojure.zip pour des exemples extrêmes de la façon dont cela est utile.

(-> dz next next next next next next next next next remove up (append-child 'e) root)

Answer 2

Tiré du wiki j'ai toujours trouvé cet exemple impressionnant:

user=> (import '(java.net URL) '(java.util.zip ZipInputStream))
user=> (-> "http://clojure.googlecode.com/files/clojure_20081217.zip"
           URL. .openStream ZipInputStream. .getNextEntry bean :name)

Comme Brian l'a dit - ce n'est pas tant "utile" que "style différent". Je trouve pour tout java interop cette forme de 'commencer par X' puis de faire Y et Z ... plus lisibles que de Z à Y de X.

En gros, vous avez 4 options:

; imperative style named steps:
(let [X something
      b (Y X)
      c (Z b)] c)

; nested calls
(Z (Y X))

; threaded calls
(-> X Y Z)

; functional composition
((comp Z Y) X)

Je trouve - > brille vraiment pour java interop mais évitez-le ailleurs.

Answer 3

(defn search-tickets-for [term]
  (-> term search zip-soup first :content
    ((partial filter #(= :body (:tag %)))) first :content
    ((partial filter #(= :div (:tag %))))
    ((partial filter #(= "content" ((comp :id :attrs) %))))
    ((partial map :content)) first ((partial map :content))
    ((partial map first)) ((partial filter #(= :ul (:tag %)))) first :content
    ((partial map :content))
    ((partial map first))
    ((partial mapcat :content))
    ((partial filter #(= :h4 (:tag %))))
    ((partial mapcat :content))
    ((partial filter #(= :a (:tag %))))
    ((partial mapcat :content))))

clojurebot de #clojure l'utilise pour rechercher des tickets assemblés