((-> [n]
     #(if (zero? n) 1 (* n (fact (- n 1))))
     (->> (-> fact)))
  10)

3628800

(-> {}
    (assoc :a 10)
    (assoc :a 1))

{:a 1}

(-> 2
    (as-> myval (+ 3 myval)))

5

(-> {:name "foo"}
    :name
    ((comp symbol name)))

foo

(-> {}
    (assoc :a 3)
    (assoc :b 1))

{:a 3, :b 1}

(macroexpand '(-> [foo] ((fn (print foo)))))

((fn (print foo)) [foo])

(-> first
    var
    meta
    ((juxt :line :file)))

[nil nil]

(macroexpand '(-> 2 #(+ 3)))

(fn* 2 [] (+ 3))

(-> (identity 1)
    (+ 1)
    (* 2))

4

(-> [-128]
    byte-array
    (String. "ISO-8859-1")
    .getBytes
    seq)

(-62 -128)

(-> "two words"
    (clojure.string/split #" ")
    last)

"words"

(defmacro here [] `'~(-> &form meta :line))

#'user/here

(-> 3
    (= 4)
    (if "hi" "hello"))

"hello"

(-> "A"
    first
    int
    inc
    char
    str)

"B"

(-> 5
    (doto ((constantly (println "OK"))))
    inc)

6

"OK\n"

(clojure.walk/macroexpand-all '(-> 6 inc (/ 2)))

(/ (inc 6) 2)

(-> []
    (conj 2)
    atom
    (->> (def foo)))

#'user/foo

(-> 8
    inc
    dec
    (+ 10)
    str)

"18"

(-> 41
    identity
    identity
    identity
    identity
    inc)

42

(-> 1
    (#(+ % 2 3)))

6

(clojure.walk/macroexpand-all '(-> x f y z))

(z (y (f x)))

(-> (var reduce)
    meta
    :ns
    ns-name
    name)

"clojure.core"

(-> 2
    ((fn [x] (+ 1 x))))

3

(-> #'+
    :arglists
    first
    :args
    first
    :doc)

nil

(-> 1
    (+ 2 3 4 5))

15

(macroexpand '(-> "foo" (fn [x] x)))

(fn "foo" [x] x)

(macroexpand-1 '(-> x (a b c)))

(a x b c)

(clojure.walk/macroexpand-all '(-> a (->> b c)))

(c (b a))

(defn mkkey
  []
  (keyword (-> *ns*
               ns-name
               name)))

#'user/mkkey

(-> (.toUpperCase "foobar")
    (subs 3 6)
    .intern)

"BAR"

(-> *
    #(%)
    (->> (def a)))

#'user/a

(clojure.walk/macroexpand-all '(-> x y z w))

(w (z (y x)))

(-> 1
    inc
    inc
    inc
    inc
    inc)

6

(macroexpand '(-> x ((f a b))))

((f a b) x)

(-> {}
    (assoc :foo 5)
    (assoc :bar "bar"))

{:bar "bar", :foo 5}

(macroexpand '(-> 1 (2 3 4)))

(2 1 3 4)

(reduce #(-> %2)
  '(1 2))

2

(-> [1 2 3]
    (->> (map inc)))

(2 3 4)

(-> [:a :b :c]
    second
    name
    clojure.string/upper-case)

"B"

(/ 100 (-> 0
           inc)
   4 5)

5

(-> (iterate list ())
    (nth 2000)
    flatten
    count)

0

(macroexpand-1 '(-> 1 inc inc inc))

(inc (inc (inc 1)))

(macroexpand-1 '(-> 1 2 3 4))

(4 (3 (2 1)))

(-> '(1 2 3)
    reverse
    first)

3

(meta (-> [2 3]
          (with-meta {:foo :bar})))

{:foo :bar}

(macroexpand '(-> 123 (#(println %))))

((fn* [%1] (println %1)) 123)

(clojure.walk/macroexpand-all '(-> a b c d))

(d (c (b a)))

(-> (subs (.toUpperCase "foobar") 3 6)
    .intern)

"BAR"

(-> 3
    (= 3)
    (if "hi" "hello"))

"hi"

(-> 2
    ((fn [x] (+ x 1))))

3