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

:a

(-> 10
    Integer.
    (Integer/toString 16))

"a"

(let [rocket-to-the-sun (-> (*))]
  rocket-to-the-sun)

1

(-> [x 1]
    (let x))

1

(-> 1
    (inc)
    (inc)
    (inc))

4

(->  foo
    quote
    name
    count)

4

(macroexpand '(-> foo (#())))

((fn* [] ()) foo)

(-> 5
    (if true false))

true

(-> (clojure.string/split "b.cl" #".")
    first)

nil

(macroexpand '(-> 1 2))

(2 1)

(-> str
    (apply nil)
    count)

0

(-> "foo.bar"
    (.split "\\.")
    vec)

["foo" "bar"]

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

(fn 1 [])

(-> [1]
    first
    (+ 3))

4

(-> +
    var
    meta
    :added)

nil

(-> (clojure.string/split "b.cl" #"\.")
    first)

"b"

(-> 'wat'
    (#(identity %)))

wat'

(-> nil
    first
    :key
    :key2)

nil

(-> \A
    int
    inc
    char)

\B

(-> [3]
    empty
    rest
    class)

clojure.lang.PersistentList$EmptyList

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

((fn []) a)

(-> #(prn :hi)
    (apply ()))

nil

":hi\n"

(-> nil
    :players
    first
    :segments)

nil

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

"foo"

(-> :user/foo
    str
    (subs 1))

"user/foo"

(-> 1
    (doto println)
    inc)

2

"1\n"

(-> #'str
    meta
    :tag
    type)

nil

(-> [1 2 3]
    count)

3

(#(-> {:a %})
 1)

{:a 1}

(-> {:a 1}
    first
    class)

clojure.lang.MapEntry

(-> 5
    inc
    inc
    inc)

8

(-> sequence
    var
    meta
    :added)

nil

(-> #'+
    meta
    :name
    keyword)

:+

(-> 1
    [:a :b :c])

:b

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

(println "a")

(-> {}
    (assoc :a ())
    (assoc :a []))

{:a []}

(+ 1
   2
   (-> 3))

6

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

(inc 1)

(-> 'clojure.core
    the-ns
    ns-name
    type)

clojure.lang.Symbol

(-> 'famished
    pr-str
    read-string
    type)

clojure.lang.Symbol

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

(2 1)

(-> 1
    (#(prn %)))

nil

"1\n"

(-> 2
    inc
    inc
    inc)

5

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

(a b c)

(-> 'clojure.core
    ns-publics
    ('cond->)
    meta)

{:macro true,
 :name cond->,
 :ns #object [sci.impl.vars.SciNamespace 0x71bde97b "clojure.core"]}

(-> 5
    (+ 1)
    >)

true

(-> "abc"
    .toUpperCase
    reverse
    str)

"(\\C \\B \\A)"

(-> '(blah)
    meta
    :line)

1

(-> "x"
    (str 1 2))

"x12"

(macroexpand-1 '(-> 3 (foo)))

(foo 3)