(-> [:p "foo" :p]
    butlast
    vec)

[:p "foo"]

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

"LLO"

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

10

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

3

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

(a b c)

(-> \tab
    int
    inc
    (repeat 0.0))

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

(macroexpand '(-> x (f y)))

(f x y)

(-> 10
    (range)
    (->> (map -)))

(0 -1 -2 -3 -4 -5 -6 -7 -8 -9)

(-> 1
    inc
    dec
    (* 10))

10

((-> [!]
     #([!] (+)))
  (*))

1

(-> "somestring"
    (clojure.string/split #"")
    (clojure.string/join ""))

""

(-> 1
    2
    3
    4
    quote)

(4 (3 (2 1)))

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

(b a c)

(macroexpand `(-> a
                  f1
                  f2))

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

(-> [:keyword {:key "VALUE"}]
    second
    :key)

"VALUE"

(defn stack-depth
  []
  (-> (Exception.)
      .getStackTrace
      count))

#'user/stack-depth

(-> 1
    (- 2)
    (- 7))

-8

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

nil

(def my-ns-name
  (-> *ns*
      ns-name
      name))

#'user/my-ns-name

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

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

(-> {:body {:status "test"}}
    :body
    :status)

"test"

(-> "huh"
    (#(println % "?")))

nil

"huh ?\n"

(-> ()
    next
    next
    next
    next
    next)

nil

(-> {'a 7}
    (assoc 'b 8))

{a 7, b 8}

(-> "foobar"
    (subs 3)
    (str "quux"))

"barquux"

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

2

(-> "a"
    (.concat "b")
    (.concat "c"))

"abc"

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

(c (b a))

(-> 10
    (1 2 3)
    quote)

(1 10 2 3)

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

(a 1 b)

(-> 2
    (- 5)
    (str "!"))

"-3!"

(-> {:a 1}
    (select-keys [:a])
    vec)

[[:a 1]]

(macroexpand '(-> f1 f2 f3))

(f3 (f2 f1))

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

(3 (2 1))

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

nil

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

:d

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

1

(-> 42
    identity
    inc
    (identity)
    (dec))

42

(let [n 4]
  (-> n
      dec))

3

(-> lol
    whut
    undefined
    symbols
    quote)

(symbols (undefined (whut lol)))

(-> '(.isEmpty "")
    first
    class)

clojure.lang.Symbol

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

(1 2 3 4 5)

(-> [a b]
    (fn
      (assoc a
        b (-> b
              (a 0)
              inc)))
    (reduce {} "foo bar baz"))

{\space 2, \a 2, \b 2, \f 1, \o 2, \r 1, \z 1}

(-> []
    (when (= 1 2) (conj 12)))

12

(-> (range 42)
    vec
    transient
    pop!
    count)

41

(macroexpand '(-> crazy (nesting) (fun functions)))

(fun (nesting crazy) functions)

(symbol (-> (resolve '+)
            str
            (subs 2)))

clojure.core/+

(-> 5
    (->> (- 6))
    (+ 3))

4

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

(1 10 2 3)

(-> 'x
    (str 'a 'b 'c 'd))

"xabcd"