Você pode me dar alguns exemplos da vida real do -> macro?

Question

Parece ser uma macro poderoso, mas eu estou deixando de aplicá-lo para qualquer coisa, mas exemplos bobos. Você pode me mostrar algum uso real dele?

Obrigado!

Answer 1

Compare:

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

para:

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

-> é usado quando você quer uma maneira concisa para chamadas ninho. Ele permite que você listar as chamadas na ordem em que vai ser chamado em vez de dentro para fora, que podem ser mais legível. No terceiro exemplo, perceber o quanto a distância é entre alguns dos argumentos e a função a que pertencem; -> permite que você argumentos de grupo e chamadas de função um pouco mais limpa. Porque é uma macro também funciona para chamadas de Java, que é bom.

-> não é tão poderoso, ele só poupa alguns parens agora e depois. Usá-lo ou não é uma questão de estilo e legibilidade.

Olhe para o fundo do clojure.zip para exemplos extremos de como isso é útil.

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

Answer 2

Retirado do wiki Eu sempre achei neste exemplo 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)

Como Brian disse - não é 'útil' tanto como 'estilo diferente'. Acho que para todos java interoperabilidade esta forma de 'começar com X', em seguida, fazer Y e Z ... mais legível do que Z fazer a Y de X.

Basicamente, você tem 4 opções:

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

I encontrar -.> Realmente brilha para interoperabilidade java, mas evitá-lo em outros lugares

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 usa isso para procurar Assembla bilhetes