(-> "Hi there!"
    .toUpperCase
    println)

nil

"HI THERE!\n"

((-> "inc"
     symbol
     resolve)
  0)

1

(-> 1
    inc
    inc
    inc)

4

(macroexpand '(-> 1 bamboozle))

(bamboozle 1)

(-> partition
    var
    meta
    :arglists)

([n coll] [n step coll] [n step pad coll])

(-> ""
    vector
    list
    hash-set)

#{([""])}

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

"x"

(macroexpand (-> 1
                 inc
                 inc))

3

(-> 'inc
    resolve
    meta
    :name)

inc

(-> {:x 1}
    first
    empty)

nil

(macroexpand '(-> x (recur)))

(recur x)

(#(-> {:x %})
 5)

{:x 5}

(-> *clojure-version*
    var
    meta
    keys)

(:ns :dynamic :name)

(let []
  (-> 3
      (+ 2)))

5

(-> 1
    inc
    (* 2))

4

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

(2 1)

(-> (range 10)
    rest
    first)

1

(-> :a
    ((partial conj #{})))

#{:a}

(-> 'filter
    resolve
    deref
    ifn?)

true

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

"p:foobar"

(-> remove
    meta
    :name
    class)

nil

(-> 3
    inc
    inc
    inc)

6

(-> 2
    ((fn [x] 3)))

3

(-> +
    var
    meta
    :since)

nil

(macroexpand '(-> 1 inc))

(inc 1)

(-> first
    var
    meta
    :doc)

"Returns the first item in the collection. Calls seq on its\n    argument. If coll is nil, returns nil."

(-> "foo"
    ^String (identity)
    (.trim))

"foo"

(-> [3 4]
    class
    ancestors)

#{java.lang.Iterable clojure.lang.Reversible clojure.lang.Sequential clojure.lang.IReduce clojure.lang.IPersistentStack clojure.lang.AFn java.util.List java.lang.Runnable clojure.lang.Counted java.io.Serializable clojure.lang.IHashEq clojure.lang.IReduceInit java.lang.Comparable clojure.lang.ILookup clojure.lang.IKVReduce clojure.lang.IPersistentCollection clojure.lang.IEditableCollection clojure....

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

(fn* foo [] ())

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

:foo

(-> 5
    (< 2 9))

false

(-> true
    (if true false))

true

(-> 0
    (inc)
    (inc)
    (inc))

3

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

"BAR"

(-> 'clojure.core
    the-ns
    meta
    :doc)

nil

(-> (keyword ":bla")
    str
    read-string)

:user/bla

(-> {:a 1}
    first
    flatten)

(:a 1)

(-> "foo"
    .toUpperCase
    (println "afterfoo"))

nil

"FOO afterfoo\n"

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

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

(-> 0
    inc
    inc
    inc)

3

(-> 9
    inc
    (repeat 0.0))

(0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0 0.0)

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

"BAR"

(-> first
    var
    meta
    :arglists)

([coll])

(-> "="
    symbol
    resolve
    meta)

{:ns #object[sci.impl.vars.SciNamespace 0x71bde97b "clojure.core"], :name =, :sci/built-in true, :arglists ([x] [x y] [x y & more]), :doc "Equality. Returns true if x equals y, false if not. Same as\n  Java x.equals(y) except it also works for nil, and compares\n  numbers and collections in a type-independent manner.  Clojure's immutable data\n  structures define equals() (and thus =) as a value, ...

(-> 'clojure.core/conj
    find-var
    meta
    :doc)

"conj[oin]. Returns a new collection with the xs\n    'added'. (conj nil item) returns (item).\n    (conj coll) returns coll. (conj) returns [].\n    The 'addition' may happen at different 'places' depending\n    on the concrete type."

(-> '+
    (list 1 1))

(+ 1 1)

(-> (interleave "devn" "justin_smith")
    sort)

(\d \e \j \n \s \t \u \v)

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

{() :a}

(-> \a
    (doto prn)
    int)

97

"\\a\n"

(macroexpand '(-> x f))

(f x)