Puoi darmi alcuni esempi di vita reale di - > macro?

Question

Sembra essere una macro potente, ma non riesco ad applicarla a esempi tutt'altro che sciocchi. Puoi mostrarmene un vero uso?

Grazie!

Answer 1

Confronto:

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"]

a:

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"]

- > viene utilizzato quando si desidera un modo conciso di nidificare le chiamate. Ti consente di elencare le chiamate nell'ordine in cui verranno chiamate anziché all'interno, il che può essere più leggibile. Nel terzo esempio, nota quanta distanza c'è tra alcuni degli argomenti e la funzione a cui appartengono; - > ti consente di raggruppare argomenti e funzioni in modo un po 'più chiaro. Perché è una macro funziona anche per le chiamate Java, il che è carino.

- > non è così potente, ti salva solo qualche volta ogni tanto. Usarlo o no è una questione di stile e leggibilità.

Guarda in fondo a clojure.zip per esempi estremi di come ciò sia utile.

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

Answer 2

Tratto dal wiki che ho sempre trovato questo esempio impressionante:

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

Come ha detto Brian, non è "utile" quanto "stile diverso". Trovo per tutti i java interop questa forma di "inizia con X", quindi esegui Y e Z ... più leggibile rispetto a Z a Y di X.

Fondamentalmente hai 4 opzioni:

; 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)

Trovo - > brilla davvero per l'interoperabilità Java ma evitatelo altrove.

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 di #clojure lo usa per cercare i biglietti assembla