(-> #'for
    meta
    :macro)

true

(-> range
    var
    meta)

{:ns #object[sci.impl.vars.SciNamespace 0x71bde97b "clojure.core"], :name range, :sci/built-in true, :arglists ([] [end] [start end] [start end step]), :doc "Returns a lazy seq of nums from start (inclusive) to end\n  (exclusive), by step, where start defaults to 0, step to 1, and end to\n  infinity. When step is equal to 0, returns an infinite sequence of\n  start. When start is equal to end, ret...

(-> []
    fn
    class
    supers)

#{clojure.lang.AFn clojure.lang.AFunction clojure.lang.Fn clojure.lang.IFn
  clojure.lang.IMeta clojure.lang.IObj java.io.Serializable java.lang.Object
  java.lang.Runnable java.util.Comparator java.util.concurrent.Callable}

(-> "clojure.core/+"
    symbol
    find-var)

#'clojure.core/+

(-> 2
    (->> println))

nil

"2\n"

(-> +
    meta
    :macro)

nil

(-> data
    :type
    quote)

(:type data)

(-> (Exception.)
    (.getStackTrace)
    (count))

29

(-> 1
    (+ 2))

3

(-> "x"
    (str "a"))

"xa"

(-> #'reduce
    meta
    (#'clojure.repl/print-doc))

nil

"-------------------------\nclojure.core/reduce\n([f coll] [f val coll])\n  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 col...

(-> 5
    inc
    inc)

7

(-> 1
    (+ 3))

4

(-> #'map
    meta
    :name)

map

(macroexpand '(-> zip z/down z/right (-> z/down z/right z/right)))

(z/right (z/right (z/down (z/right (z/down zip)))))

(-> (meta #'*out*)
    :dynamic)

true

(-> 1/3
    double
    rationalize)

3333333333333333/10000000000000000

(-> [3]
    empty
    class)

clojure.lang.PersistentVector

(-> :foo
    (hash-map :bar))

{:foo :bar}

(-> 2
    -
    str)

"-2"

(-> 1
    (/ 3))

1/3

(macroexpand '(-> * ()))

(nil *)

(-> 1
    (inc)
    (inc))

3

(-> (meta #'+)
    keys)

(:ns :name :sci/built-in :arglists :doc :sci.impl/inlined)

(-> #'first
    meta
    :doc)

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

(-> #'==
    meta
    :doc)

"Returns non-nil if nums all have the equivalent\n  value (type-independent), otherwise false"

(-> 1
    inc
    inc)

3

(-> 5
    (+ 2))

7

(-> "abc"
    .toUpperCase
    reverse)

(\C \B \A)

(-> {:test 1}
    :test)

1

(-> "D"
    .toLowerCase
    keyword)

:d

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

:bar

(-> "hi"
    prn
    with-out-str)

"\"hi\"\n"

(-> "eval"
    symbol
    resolve)

#'clojure.core/eval

(-> \a
    int
    byte)

97

(-> 3
    (- 1))

2

(-> #'conj
    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."

(-> nil
    false?
    false?)

true

(-> :foo
    name
    symbol)

foo

(-> 1
    str
    clojure.string/trim)

"1"

(-> 5
    zero?
    not)

true

(-> :a
    {:a 4})

4

(-> `foo
    str
    symbol)

user/foo

(-> ::foo
    name
    keyword)

:foo

(-> :content
    quote
    clojure.string/capitalize)

":content"

(-> 2
    inc
    dec)

2

(-> \h
    int
    Integer/toHexString)

"68"

(-> "foo"
    first
    int)

102

(-> 1
    str
    keyword)

:1

(-> map
    class
    ancestors)

#{clojure.lang.AFn clojure.lang.AFunction clojure.lang.Fn clojure.lang.IFn
  clojure.lang.IMeta clojure.lang.IObj clojure.lang.RestFn java.io.Serializable
  java.lang.Object java.lang.Runnable java.util.Comparator
  java.util.concurrent.Callable}