(-> keyword
    var
    meta
    :arglists)

([name] [ns name])

(-> 1
    (+ 2)
    inc)

4

(-> 4
    (println "foo" "bar"))

nil

"4 foo bar\n"

(macroexpand '(-> foo bar))

(bar foo)

(-> "foo"
    .getBytes
    first
    int)

102

(-> "c:\\some"
    (.split "\\\\")
    seq)

("c:" "some")

(((-> (->> (#(% %)
            (->> (! (->> (($ $) ?)
                         #()
                         (-> [?])))
                 #()
                 (-> [$]))))
      (->> #()
           (-> [!])))
   (->> (->> (({(= (+) $) #(*)} (= =) #(* $ (! (- $ (*))))))
             #()
             (-> [$]))
        #()
        (-> [!])))
  10)

3628800

(macroexpand-1 '(-> :abc name))

(name :abc)

(-> "foo"
    .toUpperCase
    (str "bar"))

"FOObar"

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

"BAR"

(-> '[^WhatNowLazybot? {}]
    first
    meta)

{:tag WhatNowLazybot?}

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

1

(macroexpand '(-> "hello" count))

(count "hello")

(-> 1235
    range
    sort
    first)

0

(-> (range 3)
    (conj 5))

(5 0 1 2)

(-> 5
    #_whatever
    inc)

6

(-> #{}
    transient
    class
    supers)

#{clojure.lang.AFn clojure.lang.ATransientSet clojure.lang.Counted
  clojure.lang.IFn clojure.lang.ITransientCollection clojure.lang.ITransientSet
  java.lang.Object java.lang.Runnable java.util.concurrent.Callable}

(-> +
    var
    meta
    :arglists)

([] [x] [x y] [x y & more])

(-> realized?
    var
    meta
    :added)

nil

(-> 1
    (+ 2 3))

6

(-> ()
    rest
    rest
    rest
    rest)

()

(-> 1
    ((partial + 2)))

3

(macroexpand '(-> + 1))

(1 +)

(macroexpand (-> 2
                 #""
                 quote))

(#"" 2)

(-> #'apply
    meta
    :arglists
    last)

[f a b c d & args]

(-> "foo"
    (#(.toUpperCase %)))

"FOO"

(macroexpand '(-> foo @bar))

(clojure.core/deref foo bar)

((-> +
     (partial 1))
  4)

5

(-> (range 10)
    butlast
    rest)

(1 2 3 4 5 6 7 8)

(-> 5
    /
    /
    /)

1/5

(-> 5
    inc
    inc
    dec)

6

(-> 'clojure.string
    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)

(-> +
    (apply [1 1]))

2

(-> {:a 1}
    (get :a))

1

(-> foo.bar/baz
    quote
    namespace
    symbol)

foo.bar

(-> [a 5]
    (let a))

5

(macroexpand '(-> x +))

(+ x)

(doto :x
  (-> class
      prn))

:x

"clojure.lang.Keyword\n"

(if (== (+ 1 1) 2)
  (-> 5
      inc)
  (-> 4
      dec))

6

(-> xyz
    quote
    str
    seq)

(\x \y \z)

(macroexpand-1 '(-> [$] #()))

(fn* [$] [] ())

(macroexpand '(-> 1 (print)))

(print 1)

(-> "x.y"
    (.split ".")
    first)

nil

(-> 3
    (* 2)
    (inc))

7

(-> (make-hierarchy)
    (derive 'foo 'bar))

{:ancestors {foo #{bar}}, :descendants {bar #{foo}}, :parents {foo #{bar}}}

(-> #'inc
    meta
    :ns
    str)

"clojure.core"

(-> 1
    (list 2 3))

(1 2 3)

(-> "foobar"
    (->> (str "p:")))

"p:foobar"

(-> for
    var
    meta
    :macro)

true

(-> 1
    inc
    (* 3))

6