`clojure.core/->`¶

Type: macro Added: Clojure 1.0 Examples: 9 Runnable: 4

([x & forms])

Threads the expr through the forms. Inserts x as the second item in the first form, making a list of it if it is not a list already. If there are more forms, inserts the first form as the second item in second form, etc.

Examples¶

by zk on 2010-07-12

;; Use of `->` (the "thread-first" macro) can help make code
;; more readable by removing nesting. It can be especially
;; useful when using host methods:

;; Arguably a bit cumbersome to read:
(first (.split (.replace (.toUpperCase "a b c d") "A" "X") " "))
"X"

;; Perhaps easier to read:
(-> "a b c d" 
           .toUpperCase 
           (.replace "A" "X") 
           (.split " ") 
           first)
"X"

;; It can also be useful for pulling values out of deeply-nested
;; data structures:
(def person 
            {:name "Mark Volkmann"
             :address {:street "644 Glen Summit"
                       :city "St. Charles"
                       :state "Missouri"
                       :zip 63304}
             :employer {:name "Object Computing, Inc."
                        :address {:street "12140 Woodcrest Dr."
                                  :city "Creve Coeur"
                                  :state "Missouri"
                                  :zip 63141}}})

(-> person :employer :address :city)
"Creve Coeur"

;; same as above, but with more nesting
(:city (:address (:employer person)))
"Creve Coeur"

;; Note that this operator (along with ->>) has at times been
;; referred to as a 'thrush' operator.

;; http://blog.fogus.me/2010/09/28/thrush-in-clojure-redux/

by na_ka_na on 2011-01-03 . May have evaluation errors.

;; Your own REPL! (Read Eval Print Loop)

;; We would need a little helper macro for that
;; It does what its name says - loops forever
(defmacro loop-forever [& body] `(loop [] ~@body (recur)))

;; Your own REPL
(loop-forever (println (eval (read))))                                                                     
(+ 1 2)
3

;; If you read the above code left to right (outside in) it reads LPER.
;; Inside out it reads REPL alright.

;; Sometimes it might be easier to read code outside in, just like a sequence of steps:
;; 1. Read, 2. Eval, 3. Print, 4. Loop
;; Here's how -> helps you:

(-> (read) (eval) (println) (loop-forever))                                                                
(+ 1 2)
3

;; Does that read easier for you? If it does, -> is your friend!

;; To see what Clojure did behind the scenes with your -> expression:
(require 'clojure.walk)
nil
(clojure.walk/macroexpand-all '(-> (read) (eval) (println) (loop-forever)))
(loop* [] (println (eval (read))) (recur))

;; You can even use ->'s cousin ->> to setup your own REPL:
(->> (read) (eval) (println) (while true))
(+ 1 2)
3

;; Can you see why we can't use -> to write the above?

by BertrandDechoux on 2012-06-09

by arathunku on 2015-04-21

by expert0226 on 2016-01-07 . May have evaluation errors.

by eggsyntax on 2016-05-07 . May have evaluation errors.

by rafmagana on 2016-06-01 . May have evaluation errors.

by MokkeMeguru on 2017-08-28

Note by steveminer¶

See also ->> which is similar but threads the first expr as the last argument of the forms.

Note by John Wang¶

I have a short blog on this, in case you are still confused on it and understand Chinese.

Note by phreed¶

Can be used as an alternative to get-in.

clojure.core/->¶

Examples¶

Note by steveminer¶

Note by John Wang¶

Note by phreed¶

See also¶

`clojure.core/->`¶