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

(1 2 3)

(-> xyx
    quote
    str
    (.indexOf "y"))

1

(-> ["foo" "bar"]
    (nth 1)
    first)

\b

(macroexpand '(-> :a #{:a}))

(#{:a} :a)

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

12

(-> (range 10)
    ((partial map inc)))

(1 2 3 4 5 6 7 8 9 10)

(-> *ns*
    ns-interns
    (get 'foo)
    type)

nil

(-> 1
    (inc)
    (inc)
    (* 2))

6

(-> 4
    (+ 5)
    (* 2))

18

(macroexpand-1 '(-> f1 f2 f3))

(f3 (f2 f1))

(macroexpand '(-> {} (assoc :a 1)))

(assoc {} :a 1)

(-> 5
    /
    /
    /
    /)

5N

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

2

(-> "This is a sideways stick")

"This is a sideways stick"

(-> 5
    range
    (->> (map inc)))

(1 2 3 4 5)

(-> 5
    (#(* % %)))

25

(-> 1
    inc
    (doto println)
    inc)

3

"2\n"

(macroexpand '(-> a #(a)))

(fn* a [] (a))

(-> "foo"
    .getBytes
    (->> (new String)))

"foo"

(-> [1 2 3]
    sort
    reverse)

(3 2 1)

(-> 1
    (* 2)
    (- 5))

-3

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

foo

(-> "string"
    (#(str "prepend" %)))

"prependstring"

(-> {:a 1}
    (update-in [:a] inc))

{:a 2}

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

[1 10]

(map #(-> %
          int)
  "123")

(49 50 51)

(macroexpand '(-> x y z))

(z (y x))

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

(a x b)

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

(2 (b a))

(-> "reduce"
    symbol
    resolve
    meta
    :doc)

"f should be a function of 2 arguments. If val is not supplied,\n  returns the result of applying f to the first 2 items in coll, then\n  applying f to that result and the 3rd item, etc. If coll contains no\n  items, f must accept no arguments as well, and reduce returns the\n  result of calling f with no arguments.  If coll has only 1 item, it\n  is returned and f is not called.  If val is suppli...

(-> 1
    inc
    ((partial * 3)))

6

(macroexpand-1 '(-> "foo" .toUpperCase symbol))

(symbol (.toUpperCase "foo"))

(-> (:a :X :b)
    (:c :d))

:d

(-> 10
    (cons [1 2 3]))

(10 1 2 3)

(-> '(x)
    meta
    vals
    first)

1

(-> even?
    (filter [1 2 3]))

(2)

(macroexpand `(-> BirthEvent
                  (next-person-id)
                  0))

(0 (user/next-person-id user/BirthEvent))

(macroexpand '(-> a #((((((a))))))))

(fn* a [] ((((((a)))))))

(-> {:a :b}
    (find :a)
    class)

clojure.lang.MapEntry

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

(fn* 1 [] (inc))

(macroexpand-1 '(-> 5 (#(do))))

((fn* [] (do)) 5)

(macroexpand '(-> *ns* .getName in-ns))

(in-ns (.getName *ns*))

(-> '(deftype Node [id])
    macroexpand-1)

(deftype Node [id])

(-> 1
    (+ 2 3)
    println)

nil

"6\n"

(-> "foo"
    .getBytes
    ((partial map int)))

(102 111 111)

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

nil

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

(clojure.core/unquote (-> my-var-var
                          namespace
                          symbol))

(-> 1
    (+ 2)
    delay
    deref)

3

(-> clojure.core
    quote
    find-ns
    meta
    :doc)

nil

(macroexpand-1 '(-> x (map a)))

(map x a)