(macroexpand '(-> a (fn [])))

(fn a [])

(-> range
    var
    meta
    :since)

nil

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

"BAR"

(macroexpand '(-> 1 (fn [])))

(fn 1 [])

(-> []
    (with-meta {:type nil})
    type)

clojure.lang.PersistentVector

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

"foo"

(-> 25
    (+ 1)
    inc)

27

(-> ":a"
    (subs 1)
    keyword)

:a

(-> map
    :key1
    :key2
    :key3)

nil

(-> my-var-var
    namespace
    symbol
    quote)

(symbol (namespace my-var-var))

(->> 10
     conj
     (-> [1]))

[1 10]

(-> #{1 2 3})

#{1 2 3}

(macroexpand '(-> "a" println))

(println "a")

(-> 1
    +
    +
    +)

1

(-> (meta #'+)
    :name
    type)

clojure.lang.Symbol

(macroexpand '(-> "foo" (.trim) (.length)))

(.length (.trim "foo"))

(identical? +
            (-> #'+
                meta
                :name))

false

(-> 1
    (+ 5)
    (- 10))

-4

(-> {:a 0, "b" 4}
    (:b))

nil

(-> 8
    (* 2)
    (+ 42))

58

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

{:a 1, :b 2}

(-> ["one"]
    first
    (str "_")
    keyword)

:one_

(-> [-128]
    byte-array
    String.
    .getBytes
    seq)

(-17 -65 -67)

(-> 1
    ((partial str 3 2)))

"321"

(macroexpand '#(-> + 1 %))

(fn* [%1]
  (-> +
      1
      %1))

(macroexpand-1 '(-> 10 (- 5)))

(- 10 5)

(-> 10
    vector
    (with-meta {:name "frank"}))

[10]

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

(c (b a))

(-> +
    {+ 3}
    (* 2))

6

(-> "foo"
    .getBytes
    first
    int
    inc)

103

(macroexpand '#(-> [%1 %2 %&]))

(fn* [%1 %2 & %&]
  (-> [%1 %2 %&]))

(-> [i 3]
    (dotimes (prn i)))

nil

"0\n1\n2\n"

(-> {:bar inc}
    :bar
    (apply 5 []))

6

(-> {:a {:b 4}}
    :a
    :b)

4

(repeatedly 2
            #(-> {:a (rand)}))

({:a 0.6681858476930959} {:a 0.928989939360174})

(-> :foo
    max
    min
    clojure.set/difference
    comp)

:foo

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

6

(-> "snowman ☃"
    .getBytes
    (String. "UTF-8"))

"snowman ☃"

(-> "bar"
    (#(str "foo" %)))

"foobar"

(-> 1
    (#(/ 3 %)))

3

(-> 1
    ((fn [x] (inc x))))

2

(macroexpand '(-> 1 @(a)))

(clojure.core/deref 1 (a))

(macroexpand-1 '(-> user (repo/upsert :users)))

(repo/upsert user :users)

(-> 5
    (+ 3)
    (/ 2))

4

(-> "a b c d"
    .toUpperCase)

"A B C D"

(-> {:a 1}
    (find :a)
    type)

clojure.lang.MapEntry

(macroexpand '(-> 1 (+ 1)))

(+ 1 1)

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

6

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

10

(macroexpand-1 '(-> 5 (+ 3)))

(+ 5 3)