GetClojure

```
(let [-> 5] ->)
```
```
5
```
```
(let [-> 8] ->)
```
```
8
```
```
(let [-> :arrow] ->)
```
```
:arrow
```
```
(let [-> :foo]
  (-> {}))
```
```
nil
```
```
(let [-> inc]
  (-> 5))
```
```
6
```
```
(var ->)
```
```
#'clojure.core/->
```
```
(-> 5)
```
```
5
```
```
(-> `'foo)
```
```
(quote user/foo)
```

(clojure.repl/source ->)

nil

"Source not found\n"

```
(-> 3)
```
```
3
```
```
(-> 1)
```
```
1
```

(clojure.repl/doc ->)

nil

"-------------------------\nclojure.core/->\nMacro\n"

```
(-> 100)
```
```
100
```
```
(-> 42)
```
```
42
```
```
(-> (-> 5
        (+ 2))
    (* 4))
```
```
28
```

(macroexpand '(-> [] z/down z/right (-> z/down z/right)))

(z/right (z/down (z/right (z/down []))))

(macroexpand '(-> (*) (-> (*) +)))

(+ (* (*)))

(-> #'map
    meta)

{:ns #object[sci.impl.vars.SciNamespace 0x71bde97b "clojure.core"], :name map, :sci/built-in true, :arglists ([f] [f coll] [f c1 c2] [f c1 c2 c3] [f c1 c2 c3 & colls]), :doc "Returns a lazy sequence consisting of the result of applying f to\n  the set of first items of each coll, followed by applying f to the\n  set of second items in each coll, until any one of the colls is\n  exhausted.  Any rem...

```
(-> 'clojure-is
    fn?)
```
```
false
```
```
(-> "foo"
    .toUpperCase)
```
```
"FOO"
```
```
(-> 2
    print)
```
```
nil
```
```
"2"
```
```
(-> "hi"
    println)
```
```
nil
```
```
"hi\n"
```
```
(-> 5
    inc)
```
```
6
```
```
(-> "2"
    (string?))
```
```
true
```
```
(-> "abc"
    .toUpperCase)
```
```
"ABC"
```

(-> Integer/MAX_VALUE
    inc)

2147483648

```
(-> {:body ""})
```
```
{:body ""}
```
```
(-> "foo"
    count)
```
```
3
```
```
(-> 1
    inc)
```
```
2
```
```
(-> +
    #'foo)
```
```
#'clojure.core/+
```

(macroexpand '(-> x (< (-> (*) (+ (*))))))

(< x
   (-> (*)
       (+ (*))))

((-> [+ *]
     #(-> *))
  1
  true)

true

```
(-> 10
    inc)
```
```
11
```
```
(-> +
    type)
```
```
clojure.core$_PLUS_
```
```
(-> +
    meta)
```
```
nil
```

(-> #'apply
    meta)

{:arglists ([f args] [f x args] [f x y args] [f x y z args] [f a b c d & args]),
 :doc
   "Applies fn f to the argument list formed by prepending intervening arguments to args.",
 :name apply,
 :ns #object [sci.impl.vars.SciNamespace 0x71bde97b "clojure.core"],
 :sci/built-in true}

```
(-> 3
    dec)
```
```
2
```
```
(-> :area
    :top)
```
```
nil
```

(-> []
    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....

```
(-> (+)
    (+))
```
```
0
```
```
(-> "5"
    Integer.)
```
```
5
```
```
(-> 1
    (inc))
```
```
2
```
```
(-> =
    =)
```
```
true
```
```
(-> 1
    (prn))
```
```
nil
```
```
"1\n"
```
```
(-> "2"
    string?)
```
```
true
```
```
(-> nil
    lazy-seq)
```
```
()
```
```
(-> 5
    even?)
```
```
false
```
```
(-> "a"
    (println))
```
```
nil
```
```
"a\n"
```
```
(-> []
    (conj 4))
```
```
[4]
```
```
(#(-> 1))
```
```
1
```

<<- <-

1 2 3 4 5 6 7 8 9 10

-> ->>