(macroexpand '(->> x ((fn [x]))))
((fn [x]) x)
(->> [1 2 3] (map inc))
(2 3 4)
(->> 1 (+ 2) (+ 3))
6
(macroexpand '(->> a b c))
(c (b a))
(-> 1 list (->> (map inc)))
(2)
(macroexpand-1 '(->> x (a b)))
(a b x)
(->> 10 range (take-nth 3) rest)
(3 6 9)
(macroexpand-1 '(->> 10 (- 5)))
(- 5 10)
(->> 5 repeat (take 100) (reduce +))
500
(->> (* i 2) (let [i 10]))
20
(->> (range 10) (sort-by even?) (partition-by even?))
((1 3 5 7 9) (0 2 4 6 8))
(-> [1 2 3] (->> (map inc)))
(2 3 4)
(->> (range 10) (filter odd?) (map inc))
(2 4 6 8 10)
(->> 5 inc (range 1) (apply *))
120
(->> (inc x) (for [x (range 10)]))
(1 2 3 4 5 6 7 8 9 10)
(->> '(deffoo Bar) macroexpand-1 second meta)
nil
(->> (range 100) shuffle (take 10) doall)
(52 45 11 39 75 0 10 26 97 19)
(->> 123 str (map str) (map read-string))
(1 2 3)
(->> (filter even? (range 30)) (drop 10))
(20 22 24 26 28)
(macroexpand '(->> (range 100) (filter even?)))
(filter even? (range 100))
(->> (range 100000) (map inc) (reduce +))
5000050000
(->> (range 100) (filter odd?) (reduce +))
2500
(->> [1 2 3 4] (map odd?))
(true false true false)
(->> partition var meta :arglists (map count))
(2 3 4)
(->> 500 str (map (comp read-string str)))
(5 0 0)
(-> "somesting" (clojure.string/split #"") (->> (clojure.string/join "")))
"somesting"
(->> "hello world" (filter #{\l}) (count))
3
(->> (range 10) (filter even?) (map inc))
(1 3 5 7 9)
(-> 30 (range) (distinct) (->> (map inc)))
(1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
(->> (range 5) (map inc) (filter even?))
(2 4)
(-> 5 (->> (- 6)) (+ 3))
4
(->> (range 10) (map inc) (filter even?))
(2 4 6 8 10)
(->> 100 (+ 10 10) (/ 12))
1/10
(macroexpand-1 '(->> dna (map f) foo))
(foo (map f dna))
((->> dec (repeat 2) (apply comp)) 3)
1
(macroexpand `(->> foo (bar qux) baz))
(user/baz (user/bar user/qux user/foo))
(->> (repeatedly 10 #(rand-int 10)) (sort))
(1 2 2 2 3 4 6 7 9 9)
(-> 1 (/ 3) (->> (- 2)))
5/3
(defn f [l] (->> l :foo (max)))
#'user/f
(-> 1 (+ 1) (->> (* 3)))
6
(->> "a 123" (re-seq #"\d+") first read-string)
123
(->> "foo" .getBytes (map #(Integer/toBinaryString %)))
("1100110" "1101111" "1101111")
(->> (map identity (range 10)) doall type)
clojure.lang.LazySeq
(->> [1 2 3 4] rest rest)
(3 4)
(->> 1 inc (repeat 2) (apply *))
4
(->> (range 100) (reverse) (partition 2 1))
((99 98) (98 97) (97 96) (96 95) (95 94) (94 93) (93 92) (92 91) (91 90) (90 89) (89 88) (88 87) (87 86) (86 85) (85 84) (84 83) (83 82) (82 81) (81 80) (80 79) (79 78) (78 77) (77 76) (76 75) (75 74) (74 73) (73 72) (72 71) (71 70) (70 69) (69 68) (68 67) (67 66) (66 65) (65 64) (64 63) (63 62) (62 61) (61 60) (60 59) (59 58) (58 57) (57 56) (56 55) (55 54) (54 53) (53 52) (52 51) (51 50) (50 49)...
(-> 5 (- 1) (->> (str "->")))
"->4"
(->> 25 (#(+ % 1)) int)
26
(->> (+ x 1) (let [x 5]))
6
(->> (lazy-seq (range)) (map print) (take 3))
(nil nil nil)
"012"