fn： fn是一个宏，用于定义一个简单的函数，如下： 

简短的函数可以使用#()，%表示唯一的参数；%1、%2 ..依次表示第1、2、..个参数；%&表示所有参数，如下：

下面是几个定义函数的例子：

defn： defn 宏用来定义一个函数。它的参数包括一个函数名字，一个可选的注释字符串，参数列表，然后一个方法体。而函数的返回值则是方法体里面最后一个表达式的值。所有的函数都会返回一个值， 只是有的返回的值是nil。

1. user=> (defn f1 [] "hello ithomer")              ;定义无参函数
2. #'user/f1
3. user=> (f1)
4. "hello ithomer"
5. user=> (defn f2 [x] (format "hello %s" x))       ;定义一个参数函数
6. #'user/f2
7. user=> (f2 "ithomer")
8. "hello ithomer"
9. user=> (defn f3 [x y] (+ x y))                   ;定义两个参数相加的函数
10. #'user/f3
11. user=> (f3 2 4)
12. 6
13. user=> (defn f4 "f4 function comment" [] (println "f4 function here"))       ;带注释的函数
14. #'user/f4
15. user=> (f4)
16. f4 function here
17. nil
18. user=> (doc f4)          ;通过doc查看函数注释信息
19. -------------------------
20. user/f4
21. ([])
22. f4 function comment
23. nil
24. user=> (defn f5 ([] (str "no parameter"))
25. ([name] (str "my name is " name)))      ;定义重载的函数（无参数、一个参数）
26. #'user/f5
27. user=> (f5)                  ; 无参数
28. "no parameter"
29. user=> (f5 "clojure")        ; 一个参数
30. "my name is clojure"
31. user=> (defn f1 [& a] (str a))       ;定义变参函数
32. #'user/f1
33. user=> (f1 1 2 3)
34. "(1 2 3)"
35. user=> (defn m [& arg] (str arg ", size=" (count arg)))      ;定义变参函数
36. #'user/m
37. user=> (m 1 2 3 4 5)
38. "(1 2 3 4 5), size=5"
39. user=> (m "a" 1 2.3 -1)
40. "(\"a\" 1 2.3 -1), size=4"
41. user=> (defn exp [a f1 b f2 c] (f2 (f1 a b) c))              ;函数作为参数
42. #'user/exp
43. user=> (exp 5 - 2 + 3)
44. 6
45. user=> (defn f [a] (fn [b] (- a b)))                     ;函数作为返回值
46. #'user/f
47. user=> ((f 7) 4)
48. 3

defn-： defn-与defn功能一致，都是用于定义函数的，defn-定义的函数作用域是私有的，而defn定义的函数是公有的，如下： 

1. user=> (ns test1)                    ;ns的意思是切换到指定的命名空间，如果不存在，则新建该命名空间
2. nil
3. test1=> (defn- foo [] "hello ithomer")           ;定义私有函数foo，返回字符串world
4. #'test1/foo
5. test1=> (defn bar [] (str "hello " (foo)))       ;定义公有函数bar，并调用私有函数foo
6. #'test1/bar
7. test1=> (foo)            ;当前命名空间内调用foo函数
8. "hello ithomer"
9. test1=> (bar)            ;当前命名空间内调用bar函数
10. "hello hello ithomer"
11. test1=> (ns test2)       ;切换到test2命名空间中
12. nil
13. test2=> (test1/bar)      ;调用test1命名空间的bar函数，返回成功
14. "hello hello ithomer"
15. test2=> (test1/foo)      ;调用test1命名空间的foo函数，出现异常，提示test1的foo函数不是公开的
16. java.lang.IllegalStateException: var: #'test1/foo is not public (NO_SOURCE_FILE:79)

组合函数comp： 形如   ((comp f1 f2 .. fn) arg1 arg2 .. argn)  

就是对参数从右到左组合执行所有函数，可以转变为： (f1 (f2 (.. (fn arg1 arg2 .. argn))))

举例如下： 

偏函数partial： 形如 ((partial  f  arg1 arg2 .. argn)  arga argb .. argz)

就是执行： (f  arg1 arg2 .. argn  arga argb .. argz) 
注意：偏函数的第一个参数是一个函数，后面至少有1个其他参数 
partial函数称为“偏函数”或者“部分完整函数”，因为它是不完整的，定义也用def而不是defn。 

constantly函数： constantly函数接受一个参数x，并返回一个变参函数，该变参函数无论参数是什么，都返回这个x值。

二、函数调用 
->：宏-> 我们也称为 “thread” 宏，它本质上是调用一系列的函数，前一个函数的返回值作为后一个函数的参数，返回最后一次函数调用的值，比如下面两行代码的作用是一样的：

1. user=> (.toUpperCase "a b c d")
2. "A B C D"
3. user=> (.replace (.toUpperCase "a b c d") "A" "X")
4. "X B C D"
5. user=> (.split (.replace (.toUpperCase "a b c d") "A" "X") " ")              ; 数组
6. #<String[] [Ljava.lang.String;@41ab11b0>
7. user=> (first (.split (.replace (.toUpperCase "a b c d") "A" "X") " "))
8. "X"
9. user=> (-> "a b c d" .toUpperCase)
10. "A B C D"
11. user=> (-> "a b c d" .toUpperCase (.replace "A" "X"))
12. "X B C D"
13. user=> (-> "a b c d" .toUpperCase (.replace "A" "X") (.split " "))            ; 数组
14. #<String[] [Ljava.lang.String;@58e41bc3>
15. user=> (-> "a b c d" .toUpperCase (.replace "A" "X") (.split " ") first)
16. "X"

这样调用的好处是更少的()，也更接近于scala的习惯。 

1. user=> (-> (/ 144 12) (/ 2 3) str keyword list)
2. (:2)
3. user=> (list (keyword (str (/ (/ 144 12) 2 3))))
4. (:2)
5. user=> (-> (/ 144 12))
6. 12
7. user=> (-> (/ 144 12) (/ 2 3))
8. 2
9. user=> (-> (/ 144 12) (/ 2 3) str)
10. "2"
11. user=> (-> (/ 144 12) (/ 2 3) str keyword)
12. :2
13. user=> (-> (/ 144 12) (/ 2 3) str keyword list)
14. (:2)
15. user=> (/ (/ 144 12) 2 3)
16. 2
17. user=> (str (/ (/ 144 12) 2 3))
18. "2"
19. user=> (keyword (str (/ (/ 144 12) 2 3)))
20. :2
21. user=> (list (keyword (str (/ (/ 144 12) 2 3))))
22. (:2)

上面两句结果一样。 
->>： 后面的函数迭代使用之前的函数结果作为最后一个参数，返回最后一次函数调用的值，试看下面两个语句： 

1. user=> (-> 10 (/ 3))      ; 10/3  10作为/函数第一个参数
2. 10/3
3. user=> (->> 10 (/ 3))  ; 3/10  10作为/函数最后一个参数
4. 3/10

eval： eval解析表达式数据结构（不是字符串），并返回结果。 

apply函数： apply 把给定的集合里面的所有元素一次性地给指定的函数作为参数调用，然后返回这个函数的返回值。可以把apply看作是SQL里面的聚合函数，如下：

三、函数检查 
fn?： fn?用于检查给定的参数是否为函数，是返回true，否则返回false，如：

1. user=> (fn? #("test"))
2. true
3. user=> (fn? 1)
4. false
5. user=> (fn? nil)
6. false
7. user=> (fn? +)
8. true
9. user=> (fn? mod)
10. true
11. user=> (fn? rem)
12. true
13. user=> (fn? =)
14. true
15. user=> (fn? with-precision)
16. java.lang.Exception: Can't take value of a macro: #'clojure.core/with-precision (NO_SOURCE_FILE:32)
17. user=> (fn? min)
18. true
19. user=> (fn? >=)
20. true