(-> "foobar"
    (subs 2 4)
    .toUpperCase)

"OB"

(-> "foo"
    (str "bar")
    (str "baz"))

"foobarbaz"

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

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

(-> [1 2 3]
    shuffle
    first)

1

(#(-> {1 2, 3 4}))

{1 2, 3 4}

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

(user/.length (user/.trim "foo"))

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

17/3

(defn foo
  [a]
  (-> inc
      inc))

#'user/foo

(-> :a
    ((fn [x] (str x))))

":a"

('remove
 (-> 'clojure.core
     ns-publics
     keys
     set))

remove

(macroexpand `(-> a
                  f1
                  ((f2))))

((user/f2) (user/f1 user/a))

(-> {1 2}
    first
    pop
    pop)

[]

(-> {:one {:two "X"}}
    (:one)
    (:two))

"X"

(-> {:a 1}
    first
    class
    supers)

#{clojure.lang.IMapEntry java.lang.Iterable clojure.lang.Reversible clojure.lang.Sequential clojure.lang.IPersistentStack clojure.lang.AFn java.util.List java.lang.Runnable clojure.lang.Counted java.io.Serializable java.util.Map$Entry clojure.lang.IHashEq java.lang.Comparable clojure.lang.ILookup clojure.lang.IPersistentCollection clojure.lang.IPersistentVector clojure.lang.AMapEntry clojure.lang....

(-> {:foo {:bar "bat"}}
    :foo
    :bar)

"bat"

(defn f1
  [a]
  (-> a
      meta))

#'user/f1

(-> clojure.string
    quote
    ns-publics
    keys
    sort)

(blank? capitalize
        ends-with?
        escape
        includes?
        index-of
        join
        last-index-of
        lower-case
        re-quote-replacement
        replace
        replace-first
        reverse
        split
        split-lines
        starts-with?
        trim
        trim-newline
        triml
        trimr
        upper-case)

(-> false
    false?
    (= (false? false)))

true

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

(partial inc 1)

(-> "println"
    symbol
    resolve
    meta
    :line)

nil

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

(fn* 5 [] (do))

(-> "hello"
    count
    inc
    (* 5))

30

(-> {}
    (cond-> true (assoc :bar 1)))

{:bar 1}

(-> "foo"
    (doto println)
    (str "bar"))

"foobar"

"foo\n"

(-> 5
    (+ 10)
    (< 20))

true

(-> "Hello"
    (.substring 2 5)
    .toUpperCase)

"LLO"

(-> 1
    inc
    (doto prn)
    inc)

3

"2\n"

(-> #'+
    meta
    :ns
    str
    keyword)

:clojure.core

(macroexpand-1 '(-> x y z))

(z (y x))

(-> 0.1
    (- 1.3877787807814457E-17)
    (+ 1.3877787807814457E-17))

0.1

(keyword (-> *ns*
             ns-name
             name)
         "foo")

:user/foo

(-> 1
    list
    (->> (map inc)))

(2)

(-> 1
    (* 10)
    (+ 3))

13

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

(quote 1 (a))

(macroexpand '(-> (wrap-params app-routes) (wrap-cookies)))

(wrap-cookies (wrap-params app-routes))

(-> (a b c)
    quote
    reverse)

(c b a)

(-> 2
    dec
    dec
    (/ 1))

0

(macroexpand '(-> thing (do-something arg-foo)))

(do-something thing arg-foo)

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

"A B C D"

(-> 5
    (* 2)
    (* 3))

30

(-> "clojure.walk"
    symbol
    find-ns
    meta
    :doc)

nil

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

true

(-> +
    (list 1 1)
    eval)

2

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

0

(#(-> %
      inc
      inc)
 2)

4

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

6

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

(+ 1 3)

(macroexpand '(-> x (nth 2)))

(nth x 2)

(-> {:x 1}
    (assoc :x 5))

{:x 5}

(-> 4
    (list 1 2 3))

(4 1 2 3)